amosblomqvist
740293c361
The custom-message scheme (user-decided 2026-09-12): system-authored
user-role messages are NOT human messages — they carry marker data parts
only, the adapter owns their model-facing wording, and the UI renders
them under control. Nothing fake is ever persisted as human speech.
The inventory (all migrated):
- probe→teacher handoff wake: was a text-bearing user message rendering
as a fake user bubble; now data-probe-handoff marker-only — the
adapter flattens it to HANDOFF_TEXT (core/contracts/chat.ts), the UI
renders a quiet 'Preparing your plan…' system line.
- plan accept/decline: was boilerplate text ('The plan is accepted…',
'I'd like the plan revised…') masquerading as learner speech — the
decline wasn't even marked; now data-verdict {accepted, at} on its own
message, adapter flattens to verdictText(), UI renders the quiet
verdict marker ('✓ Plan accepted' / '↻ Plan revision requested').
sendVerdict sends TWO REAL MESSAGES when the learner typed a note
(the note as a genuine user message, then the verdict) in ONE turn
via setMessages + sendMessage() — no 409 dance, no double teacher turn.
- sub-agent steers: the abort steer gains its data-subagent-aborted
marker part; the UI keys steer rendering off PARTS (artifact/aborted),
not metadata — metadata stays as pump mechanics only.
- record-adapter: systemTextOf() flattens marker-only messages; steers
keep their text (payload — briefs are content, not boilerplate).
phases.ts: plan→teach advances on data-verdict{accepted:true} only;
learner text alone can never sanction teaching (pinned). data-plan-
accepted retired, no back-compat (user-decided: wiped-data doctrine).
Pinned: record-adapter.test.ts (verdict/handoff flattening, note+verdict
order, steer payload kept, UI-only parts skipped), phases.test.ts
(verdict marker semantics, out-of-order, text-never-fakes), jobs.test.ts
(abort marker part), demos.test.tsx (badge renders off the part, not
metadata).
Live GLM smoke (disposable driver, deleted): probe→conclude→wake→plan→
decline-with-note (revised, still plan)→accept-with-note (teach) — ALL
CHECKS PASS, including marker-only handoff/verdict on the wire and zero
fake human speech in the transcript.
Gates: tsc, lint, build, 335/335.
86 lines
3.3 KiB
TypeScript
86 lines
3.3 KiB
TypeScript
/**
|
|
* Phase derivation (docs/probe-teach-split.md §4) — EXPLICIT EVENTS, never
|
|
* occupancy. The probe→teach agent split (2026-09-11) gave every phase
|
|
* boundary a transcript marker:
|
|
*
|
|
* probe — until the first message containing a `tool-probe_done` part
|
|
* (the prober concludes; the assessment rides the tool part)
|
|
* plan — probe concluded, until the learner ACCEPTS the presented
|
|
* plan (a `data-verdict` part with accepted:true on the verdict
|
|
* button's own user message — the explicit verdict gate;
|
|
* plan_init itself is only the PRESENTATION and moves no
|
|
* phase; a declined verdict stays in plan)
|
|
* teach — teaching is sanctioned
|
|
*
|
|
* The former derived-occupancy seam (phase-of-tree via `currentNodeId`)
|
|
* is GONE: nothing ever writes currentNodeId (the stuck-on-plan bug — a
|
|
* session could never leave "plan"), and the stored tree no longer carries
|
|
* progress fields at all. No backwards compatibility: legacy sessions
|
|
* without probe_done simply read as probe (they are wiped data).
|
|
*
|
|
* Pure: no imports, no runtime deps — safe on server, client, and tests.
|
|
*/
|
|
|
|
/** The three phases of a session, as the picker / header / dividers see them. */
|
|
export type Phase3 = "probe" | "plan" | "teach";
|
|
|
|
/**
|
|
* Minimal structural slice of a UI message for the phase scan: parts with
|
|
* a state and (for concluded calls) an output.
|
|
*/
|
|
export interface PhaseMessage {
|
|
parts: ReadonlyArray<{ type: string; state?: string; output?: unknown }>;
|
|
}
|
|
|
|
/** The phase at `upToIndex` (inclusive; default: the last message). */
|
|
export function phaseAt3(messages: readonly PhaseMessage[], upToIndex?: number): Phase3 {
|
|
let phase: Phase3 = "probe";
|
|
const last = Math.min(upToIndex ?? messages.length - 1, messages.length - 1);
|
|
for (let i = 0; i <= last; i++) {
|
|
phase = advance(phase, messages[i]?.parts);
|
|
}
|
|
return phase;
|
|
}
|
|
|
|
/** One message's advance of the phase (pure fold step). */
|
|
function advance(
|
|
phase: Phase3,
|
|
parts: ReadonlyArray<{ type: string; state?: string; output?: unknown }> | undefined,
|
|
): Phase3 {
|
|
if (!parts) return phase;
|
|
for (const part of parts) {
|
|
// STRICTLY SEQUENTIAL: probe → plan only via a concluded probe_done,
|
|
// plan → teach only via the learner's plan acceptance (data-verdict
|
|
// with accepted:true). A marker out of order advances nothing — the
|
|
// chain never skips. plan_init PRESENTS the map; only the verdict
|
|
// sanctions teaching (a decline stays in plan).
|
|
if (phase === "probe" && part.type === "tool-probe_done" && part.state === "output-available") {
|
|
phase = "plan";
|
|
}
|
|
if (
|
|
phase === "plan" &&
|
|
part.type === "data-verdict" &&
|
|
(part as { data?: { accepted?: unknown } }).data?.accepted === true
|
|
) {
|
|
phase = "teach";
|
|
}
|
|
}
|
|
return phase;
|
|
}
|
|
|
|
/**
|
|
* The phase at EVERY message index, in one forward fold — the transcript
|
|
* dividers render one per boundary, so phaseAt3(m, i) per index would rescan
|
|
* 0..i each time (quadratic); this is the same derivation, linear.
|
|
* out[i] === phaseAt3(messages, i) for every i.
|
|
*/
|
|
export function phaseTimeline(messages: readonly PhaseMessage[]): Phase3[] {
|
|
const out: Phase3[] = [];
|
|
let phase: Phase3 = "probe";
|
|
for (let i = 0; i < messages.length; i++) {
|
|
phase = advance(phase, messages[i]?.parts);
|
|
out.push(phase);
|
|
}
|
|
return out;
|
|
}
|