feat: probe/teach agent split — explicit phase markers, position-only plan map

Diagnosis (2026-09-11 user testing, minimal-effort GLM): sessions stuck on
'plan' forever. Two causes: (1) the three-phase view read the stored tree's
currentNodeId, which nothing ever writes post author-once (2026-09-03) — a
structural dead seam; (2) the teacher stochastically left quiz.nodeId
untagged, and done-by-quiz-result semantics would have falsely completed
nodes anyway.

The redesign (docs/probe-teach-split.md) abolishes derived occupancy in
favor of explicit events:

- Two agents over one transcript: createProberAgent (quiz without a
  nodeId field, ask, probe_done) and createTeacherAgent (full toolset,
  plan_init onward). The chat-handler construction branch keys on a
  probe_done part in the transcript. MODELS.prober added.
- probe_done: server-side seam tool — carries the learner assessment
  (strands + free-form edge read), refuses while a question is open or
  the probe is already concluded, and queues a handoff steer through the
  generalized wake pipeline (steers now dedupe by id, not jobId; job
  finalization only for job steers). The teacher auto-wakes and authors
  the plan; the learner sees the assessment via the probe-done card.
- phases: probe ends at a concluded probe_done, plan ends at a
  successful plan_init — strictly sequential, no skipping, no legacy
  compatibility (data wiped at the pivot per doctrine).
- Plan map = position, not completion: derivePlanStatuses reads only
  tagged quiz CALLS (state/outcome feed nothing); current = latest
  tagged node with consecutive duplicates collapsed, visited = earlier
  distinct stays (a revisit stays in both — current wins at render).
  PlanTree is structure-only; currentNodeId/doneNodeIds and the dead
  mutation helpers are gone. No fallback current.
- Prompts split per agent (prompts/prober/, prompts/teacher/ over the
  trimmed shared base); graph-context injection removed entirely
  (shelved, docs/probe-teach-split.md §5); knowledge-graph context no
  longer reaches either agent.
- Plan blocks are full-only snapshots at plan_init (neighborhood
  machinery retired; the persistent DAG window is the future UI wave);
  usage capture unchanged.

Gates: tsc clean, 294/294 tests (phases/plan-tree/plan-blocks/question-
tools rewritten to the new semantics; probe-done + handoff-wake tests
added), lint, build. Live GLM smoke PASS: prober concluded with an honest
assessment, teacher auto-woke, authored a 10-node plan with the block
attached, then tagged checks on slope-instinct → secant derived current/
visited exactly as designed; grading honest both ways (driver off-by-one
proved a wrong answer grades false).

tests/probe-done.test.ts

@@ -0,0 +1,121 @@
+/**
+ * probe_done — the probe→planning seam tool (docs/probe-teach-split.md §2).
+ * Server-side; three outcomes: refusal while a question is open, refusal
+ * after the probe is already concluded, ok + handoff queued. The handoff
+ * rides the wake pipeline (deliver injected here — no server seam import).
+ */
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { after, describe, it } from "node:test";
+import { probeDoneTool } from "../src/agent/tools/probe.ts";
+import type { ProbeHandoffSteerMessage } from "../src/core/contracts.ts";
+import { chatStore } from "../src/store/chats.ts";
+import { PATHS } from "../config.ts";
+
+const dataDir = path.join(PATHS.root, "data");
+fs.mkdirSync(dataDir, { recursive: true });
+
+const createdChats: string[] = [];
+after(() => {
+	for (const id of createdChats) {
+		try {
+			fs.unlinkSync(path.join(PATHS.chats, `${id}.json`));
+		} catch {
+			/* scratch cleanup, best effort */
+		}
+	}
+});
+
+function newChat(title: string): string {
+	const chat = chatStore.createChat(title);
+	createdChats.push(chat.id);
+	return chat.id;
+}
+
+const ASSESSMENT = {
+	strands: [
+		{ strand: "the derivative as a limit", assessment: "Floor: slope intuition. Ceiling: formal ε–δ." },
+	],
+	summary: "Enter at the formal definition.",
+};
+
+async function execute(tools: ReturnType<typeof probeDoneTool>, input: unknown) {
+	const t = tools.probe_done!;
+	assert.ok(typeof t.execute === "function");
+	return t.execute(input as never, { toolCallId: "test", messages: [] } as never) as Promise<{
+		ok: boolean;
+		error?: string;
+	}>;
+}
+
+describe("probe_done: the probe→planning seam", () => {
+	it("ok path: records the assessment and queues the handoff steer (deterministic id)", async () => {
+		const chatId = newChat("Probe: ok");
+		const delivered: ProbeHandoffSteerMessage[] = [];
+		const tools = probeDoneTool({ chatId, chatStore, deliver: (s) => delivered.push(s) });
+
+		const res = await execute(tools, { assessment: ASSESSMENT });
+		assert.equal(res.ok, true);
+		assert.equal(res.error, undefined);
+		assert.equal(delivered.length, 1, "the handoff is queued exactly once");
+		assert.equal(delivered[0]!.id, `steer_probe_${chatId}`);
+		assert.equal((delivered[0]!.metadata as { probeHandoff: { chatId: string } }).probeHandoff.chatId, chatId);
+	});
+
+	it("REFUSES while a question is still open — resolve it first", async () => {
+		const chatId = newChat("Probe: open question");
+		chatStore.saveMessages(chatId, [
+			{
+				id: "m1",
+				role: "assistant",
+				parts: [{ type: "tool-quiz", state: "input-available", input: { question: "q?" } }],
+			} as never,
+		]);
+		const delivered: ProbeHandoffSteerMessage[] = [];
+		const tools = probeDoneTool({ chatId, chatStore, deliver: (s) => delivered.push(s) });
+
+		const res = await execute(tools, { assessment: ASSESSMENT });
+		assert.equal(res.ok, false);
+		assert.match(res.error!, /question is still open/i);
+		assert.equal(delivered.length, 0, "nothing queued on refusal");
+	});
+
+	it("REFUSES a second conclusion — probe_done fires exactly once", async () => {
+		const chatId = newChat("Probe: twice");
+		chatStore.saveMessages(chatId, [
+			{
+				id: "m1",
+				role: "assistant",
+				parts: [{ type: "tool-probe_done", state: "output-available", input: { assessment: ASSESSMENT }, output: { ok: true } }],
+			} as never,
+		]);
+		const delivered: ProbeHandoffSteerMessage[] = [];
+		const tools = probeDoneTool({ chatId, chatStore, deliver: (s) => delivered.push(s) });
+
+		const res = await execute(tools, { assessment: ASSESSMENT });
+		assert.equal(res.ok, false);
+		assert.match(res.error!, /already concluded/i);
+		assert.equal(delivered.length, 0);
+	});
+
+	it("REFUSES an unknown chat defensively", async () => {
+		const tools = probeDoneTool({ chatId: "chat_nonexistent", chatStore, deliver: () => {} });
+		const res = await execute(tools, { assessment: ASSESSMENT });
+		assert.equal(res.ok, false);
+		assert.match(res.error!, /not found/i);
+	});
+
+	it("a deliver failure never fails the call — the assessment records; the wake is recoverable-by-design", async () => {
+		const chatId = newChat("Probe: deliver crash");
+		const tools = probeDoneTool({
+			chatId,
+			chatStore,
+			deliver: () => {
+				throw new Error("queue exploded");
+			},
+		});
+		const res = await execute(tools, { assessment: ASSESSMENT });
+		assert.equal(res.ok, true, "ok:true even when the queue is lost — the next client message constructs the teacher off the transcript seam");
+	});
+});