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).

src/core/graph-context.ts

@@ -1,172 +0,0 @@
-/**
- * Graph-as-context (W8; vision §1 "The graph as session context", DECIDED
- * 2026-08-22).
- *
- * renderGraphContext() turns the derived graph into a compact markdown block
- * the teacher sees as part of its instructions — this is what makes probing
- * precise instead of generic: probe questions can target the boundary of
- * what the learner actually holds, and personalization compounds across
- * sessions.
- *
- * buildGraphContext() is the per-request entry point the chat-handler calls
- * (stateless: it re-reads the ledgers, so it self-updates as the graph grows
- * mid-session). An empty graph returns null — nothing is injected, and the
- * prompt fragment (50-graph-context.md) tells the teacher how to behave when
- * the block is absent (new learner).
- *
- * Selection strategy (§1 "the selection problem", simplest first): the WHOLE
- * graph while it is small; past MAX_NODES, hotspots (missed / dont-know
- * nodes) plus their 1-hop `follows` neighborhood — the frontier is where
- * the next session should probe.
- */
-
-import type { GraphEdge, GraphNode, LedgerEventKind } from "./contracts.ts";
-import { latestQuizOutcomes, type DerivedGraph } from "./graph.ts";
-
-/** The section header the teacher is taught to recognize (50-graph-context.md). */
-export const GRAPH_CONTEXT_HEADER = "LEARNER KNOWLEDGE GRAPH (auto-generated)";
-
-/** Above this node count only hotspots + their 1-hop neighborhood are shown. */
-export const MAX_CONTEXT_NODES = 150;
-
-/**
- * Group order for node lines: diagnostic value first (vision §1 hotspots).
- * No node-state classes (removed 2026-09-08) — the grouping is the raw
- * event fact: the node's LATEST quiz outcome (miss/dont-know = hotspot).
- */
-type Outcome = LedgerEventKind | "never-probed";
-
-function groupOf(outcome: Outcome): number {
-	if (outcome === "miss" || outcome === "dont-know") return 0;
-	if (outcome === "correct") return 1;
-	return 2; // never probed
-}
-
-const GROUP_LABELS = [
-	"Hotspots (last answer wrong or don't-know) — likely misconception sites and unexplored ground:",
-	"Answered correctly:",
-	"Never probed (assume nothing):",
-] as const;
-
-/** A hotspot is a node worth showing even under truncation (§1: diagnostic hotspots). */
-function isHotspot(outcome: Outcome): boolean {
-	return groupOf(outcome) === 0;
-}
-
-/**
- * Render the context block, or null when there is nothing worth injecting
- * (no nodes; or a truncated graph whose selection came out empty).
- *
- * Pure: callers hand in exactly what getGraph(graphStore) produces; the
- * outcomes are the raw latest-quiz-event facts (core/graph.ts).
- */
-export function renderGraphContext(
-	nodes: GraphNode[],
-	edges: GraphEdge[],
-	outcomes: Map<string, LedgerEventKind>,
-): string | null {
-	if (nodes.length === 0) return null;
-
-	// ── selection ───────────────────────────────────────────────────────────
-	const outcomeOf = (node: GraphNode): Outcome => outcomes.get(node.id) ?? "never-probed";
-	let selected = nodes;
-	let truncated = false;
-	if (nodes.length > MAX_CONTEXT_NODES) {
-		truncated = true;
-		const hotspots = nodes.filter((n) => isHotspot(outcomeOf(n)));
-		const keep = new Set(hotspots.map((n) => n.id));
-		// 1-hop follows neighborhood: premises AND derivations.
-		for (const edge of edges) {
-			if (edge.type !== "follows") continue;
-			if (keep.has(edge.from) || keep.has(edge.to)) {
-				keep.add(edge.from);
-				keep.add(edge.to);
-			}
-		}
-		selected = nodes.filter((n) => keep.has(n.id));
-		if (selected.length === 0) return null; // nothing diagnostic to show
-	}
-
-	// ── node lines, grouped/sorted by diagnostic priority ──────────────────────────
-	const lines: string[] = [
-		`===== ${GRAPH_CONTEXT_HEADER} =====`,
-		`${truncated ? `showing ${selected.length} of ${nodes.length} nodes (hotspots + their 1-hop neighborhood)` : `${nodes.length} nodes`}, ${edges.filter((e) => e.type === "follows").length} follows edges`,
-	];
-
-	for (const [group, label] of GROUP_LABELS.entries()) {
-		const groupNodes = selected
-			.filter((n) => groupOf(outcomeOf(n)) === group)
-			.sort((a, b) => (a.statement < b.statement ? -1 : a.statement > b.statement ? 1 : 0));
-		if (groupNodes.length === 0) continue;
-		lines.push("", label);
-		for (const node of groupNodes) {
-			const outcome = outcomeOf(node);
-			const tag = outcome === "never-probed" ? "never probed" : outcome;
-			lines.push(`• [${tag}] ${node.statement} (${node.id})`);
-		}
-	}
-
-	// ── requires edges, merged into chains ──────────────────────────────────
-	const byId = new Map(selected.map((n) => [n.id, n.statement]));
-	const follows = edges.filter(
-		(e) => e.type === "follows" && byId.has(e.from) && byId.has(e.to),
-	);
-	if (follows.length > 0) {
-		lines.push("", "Follows (premise → derivation):");
-		for (const chain of edgeChains(follows)) {
-			lines.push(chain.map((id) => byId.get(id) ?? id).join(" → "));
-		}
-	}
-
-	lines.push("===== end of knowledge graph =====");
-	return lines.join("\n");
-}
-
-/**
- * Merge a set of requires edges into maximal simple chains: a→b, b→c, a→d
- * renders as "a → b → c" and "a → d". Each edge appears in exactly one chain.
- */
-function edgeChains(edges: GraphEdge[]): string[][] {
-	const chains: string[][] = [];
-	const used = new Set<GraphEdge>();
-
-	const sorted = [...edges].sort((a, b) =>
-		`${a.from}\u0000${a.to}` < `${b.from}\u0000${b.to}` ? -1 : 1,
-	);
-	for (const edge of sorted) {
-		if (used.has(edge)) continue;
-		used.add(edge);
-		let chain = [edge.from, edge.to];
-		// Extend forward along unused outgoing edges (branching yields sibling
-		// chains; a cycle stops the walk).
-		for (;;) {
-			const tail = chain[chain.length - 1]!;
-			const next = sorted.find((e) => !used.has(e) && e.from === tail);
-			if (!next || chain.includes(next.to)) break; // branching or a cycle — stop
-			used.add(next);
-			chain.push(next.to);
-		}
-		// Extend backward along unused incoming edges, symmetrically.
-		for (;;) {
-			const head = chain[0]!;
-			const prev = sorted.find((e) => !used.has(e) && e.to === head);
-			if (!prev || chain.includes(prev.from)) break;
-			used.add(prev);
-			chain.unshift(prev.from);
-		}
-		chains.push(chain);
-	}
-	return chains;
-}
-
-// ─── the per-request entry point ─────────────────────────────────────────────
-
-/**
- * Build the graph context block for one request. Pure: the caller hands in
- * the derived graph (production: getGraph(graphStore) per request in the
- * chat-handler, so it self-updates as the graph grows mid-session).
- */
-export function buildGraphContext(graph: DerivedGraph): string | null {
-	const outcomes = latestQuizOutcomes(graph.nodes, graph.events);
-	return renderGraphContext(graph.nodes, graph.edges, outcomes);
-}