practice round: dead session starts, prompt laws, preamble, label unify

THE START BUG (owner report, reproduced live both kinds): new sessions
(?prompt flow — practice and teach alike) sat dead until a second
message, which then persisted WITHOUT the first. Root cause, proven
both directions: the submit POST rode the view's consumeAbort
controller; React StrictMode's simulated remount fires Diet A's
unmount cleanup (model.stop()) ~8ms in and killed the POST mid-flight;
the page's sentInitial guard had already flipped, so it never retried.
Teach was equally broken — only unnoticed, because every teach chat in
use predates the diet and practice starts are always fresh. Fix: the
submit law — POSTs are not abortable by view teardown (they are ~100ms
acks since Diet B and cannot starve the pool); after the ack, a
consumeAbort identity check guards the stream attach. Pinned with the
stop-mid-submit regression test. Live: StrictMode on, practice draft
POST 200/67ms, stream attached, message persisted, problem posed.

PRACTICE PROMPT (00-base): the opening rule — material arrives two
ways, both first-class (picked propositions primary; free-form —
topics, course material, files/PDFs — fully supported, never refused);
as soon as material exists the reply poses, at most one short line
before the problem call, no warm-up interview. Plus the hard law: no
problem is ever conversation — every problem through the tool (no
thinking field/no reveal/no verdict attaches to prose).

GRAPH-CONTEXT PREAMBLE: custom markers flatten to user-role on the
wire, so the old "Contextualization — the learner picked…" read like a
system broadcast in the learner's voice channel. Now the bracket
convention: "[Session context] — picked from the learner's knowledge
map…".

SIDEBAR: busy rows unify to "Working…" for both kinds (the spinner's
default label included); "Practicing…"/"Teacher is working…" retired.

Gates: 1490/1490, typecheck, lint. doctrine's stale doc pointer fixed.

tests/session-core.test.ts

@@ -593,6 +593,48 @@ describe("resumeStream (the reattach path)", () => {
 		assert.equal(m.getState().status, "ready");
 	});
 
+	it("SESSION START SURVIVES A STOP() RACING THE SUBMIT (owner, 2026-10-10 — the dead-practice-start postmortem)", async () => {
+		// React StrictMode's simulated remount fires the unmount cleanup
+		// (~8ms in) while the ?prompt first send's POST is in flight — the
+		// exact live repro: pre-fix, the POST rode consumeAbort and died
+		// with AbortError, the page's sentInitial guard never retried, and
+		// the session sat dead until a second message (which then persisted
+		// WITHOUT the first). The law: submits are not abortable by view
+		// teardown — the POST completes, the turn is server-side, and the
+		// dead view attaches no stream.
+		let resolvePost!: () => void;
+		let postAborted = false;
+		const fetches: string[] = [];
+		globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+			const url = String(input);
+			fetches.push(url);
+			if (url === "/api/chat") {
+				init?.signal?.addEventListener("abort", () => {
+					 postAborted = true;
+				});
+				await new Promise<void>((r) => {
+					 resolvePost = () => r();
+				});
+				return Response.json({ ok: true });
+			}
+			if (url === "/api/chats/chat_x") {
+				return Response.json({ messages: [{ id: "u1", role: "user", content: "quiz me", timestamp: 1 }] });
+			}
+			if (url === "/api/chats/chat_x/stream") return new Response("data: [DONE]\n\n", { status: 200 });
+			throw new Error(`unexpected fetch: ${url}`);
+		}) as typeof globalThis.fetch;
+		const m = model();
+		const sending = m.send({ type: "text", text: "quiz me" });
+		await new Promise((r) => setTimeout(r, 5)); // the POST is in flight
+		m.stop(); // StrictMode's simulated unmount lands mid-submit
+		resolvePost(); // the ack completes anyway
+		await sending;
+		assert.equal(postAborted, false, "the submit POST carries no teardown signal at all");
+		assert.ok(fetches.includes("/api/chat"), "the submit reached the server");
+		assert.ok(!fetches.some((u) => u.endsWith("/stream")), "a dead view attaches no stream — the turn is server-side");
+		assert.equal(m.getState().status, "ready");
+	});
+
 	it("REATTACH REPLAYS ONTO A CLEAN SLATE (owner, optimistic round 3): an aborted attempt's partials never double", async () => {
 		// StrictMode's simulated remount aborts the first resume mid-replay;
 		// its partial tail survived into the retry and the replay DOUBLED