@try-works/dsh-recursive-mode 0.4.6 → 0.4.8

package/lib/client.js

@@ -522,9 +522,29 @@ window.__ModuleLoader__.load({
 		* carried over — this viewer reads run artifacts.
 		*/
 		/**
+		* A list item: the text AFTER its marker. The marker is consumed here exactly as the base parser consumed
+		* it — `text` is the item's CONTENT, and the renderer draws the `- ` / box back from `kind` + `checked`.
+		*/
+		const BULLET_RE = /^\s*[-*]\s+(.+)$/;
+		/**
+		* A task box (`[ ]`, `[x]`, `[X]`) at the front of a list item, split into its tick and the rest of the item.
+		*
+		* The tick is the one fact a reader of the document cannot recover from the text alone once the box has been
+		* recognised, so it travels as `checked`; everything after it is the item's content, as for any other bullet.
+		*/
+		const TASK_BOX_RE = /^\[([ xX])\]\s*(.*)$/;
+		/** A gate reading: `Coverage: FAIL` / `Approval: PASS`, as `run-spec.ts` reads the same lines. */
+		const GATE_RE = /^\s*(?:Coverage|Approval)\s*:\s*(PASS|FAIL)\s*$/i;
+		/**
 		* Markdown -> line tokens. Base is parsePlan (blank/h1-h4/li/plain, MIT),
 		* extended for fenced code blocks (one code line per block) and pipe tables
 		* (one table line per block, header separator row dropped).
+		*
+		* AND EXTENDED FOR WHAT THE RUN ARTIFACTS ACTUALLY CONTAIN — the task boxes and gate readings the
+		* scaffolded `00-requirements.md` ships (`- [ ] …`, `Coverage: FAIL`, `Approval: FAIL`), because a preview
+		* that renders an unticked box and a FAIL gate as generic body text hides the two marks a person who is
+		* being asked to approve the document most needs to see. Both are additive FIELDS on the existing `li` and
+		* `plain` kinds, so no line is retyped, no character is dropped, and every existing caller keeps working.
 		*/
 		function parseDoc(plan) {
 			const raw = String(plan == null ? "" : plan).split("\n");
@@ -591,11 +611,26 @@ window.__ModuleLoader__.load({
 					i += 1;
 					continue;
 				}
-				const li = /^\s*[-*]\s+(.+)$/.exec(line);
-				if (li) {
-					out.push({
+				const item = BULLET_RE.exec(line);
+				if (item) {
+					const box = TASK_BOX_RE.exec(item[1]);
+					out.push(box === null ? {
+						kind: "li",
+						text: item[1]
+					} : {
 						kind: "li",
-						text: li[1]
+						text: box[2],
+						checked: box[1] !== " "
+					});
+					i += 1;
+					continue;
+				}
+				const gate = GATE_RE.exec(line);
+				if (gate) {
+					out.push({
+						kind: "plain",
+						text: line,
+						gate: gate[1].toUpperCase() === "FAIL" ? "fail" : "pass"
 					});
 					i += 1;
 					continue;
@@ -671,11 +706,39 @@ window.__ModuleLoader__.load({
 			});
 		}
 		/**
+		* The mark of a task box.
+		*
+		* ⚠ THE MARK REPLACES `[ ]` / `[x]` IN PLACE, GLYPH FOR GLYPH. The parser hands over the item's content
+		* without the box, so what the reader sees is `- [ ] item` where the document says `- [x] item`: same line,
+		* same position, same length of reading — and the box is still legible as a box rather than as an assertion
+		* about the item.
+		*
+		* ⚠ AND THE TICK IS CARRIED TWICE — once as that glyph for the eye and once as text, visually hidden, for the
+		* ear — because the two bracket forms are read inconsistently by screen readers, and the whole point of the
+		* mark is that "this box is not ticked" survives every way of reading it. This span carries NO separator of
+		* its own: the item's text follows it directly, separated by the leading space on that text (see
+		* `lineElement`), so that neither side of the boundary has a trailing space to lose.
+		*/
+		function todoMark(line, key) {
+			const done = line.checked === true;
+			return (0, react.createElement)("span", {
+				key,
+				className: "rec-doc-todo-check" + (done ? " rec-doc-todo-check-on" : " rec-doc-todo-check-off"),
+				title: done ? "done" : "not done"
+			}, (0, react.createElement)("span", { "aria-hidden": "true" }, done ? "[x]" : "[ ]"), (0, react.createElement)("span", { className: "rec-doc-sr" }, done ? "done:" : "not done:"));
+		}
+		/**
 		* Render one parsed line as a React element. Headings/bullets get parsePlan
 		* sizing; code/table get block layout; inline markup applies to plain-ish text.
+		*
+		* ⚠ ONE RENDERER, TWO READERS. `DocViewer` and the run-start spec sheet's preview both come through here,
+		* so a mark that means "unticked box" or "gate reads FAIL" cannot mean one thing in the phase-doc viewer and
+		* another in the document a person is approving. Exported for that reason alone.
 		*/
-		function lineElement(line, i, isCurrent) {
+		function lineElement(line, i, isCurrent = false) {
 			const cls = "rec-doc-line rec-doc-" + line.kind + (isCurrent ? " rec-doc-line-current" : "");
+			const gateCls = line.gate === void 0 ? "" : " rec-doc-gate rec-doc-gate-" + line.gate;
+			const todoCls = line.checked === void 0 ? "" : " rec-doc-todo" + (line.checked ? " rec-doc-todo-done" : " rec-doc-todo-open");
 			if (line.kind === "blank") return (0, react.createElement)("div", {
 				key: i,
 				"data-line": String(i),
@@ -697,18 +760,42 @@ window.__ModuleLoader__.load({
 				}, (0, react.createElement)("table", { className: "rec-doc-table" }, (0, react.createElement)("thead", null, (0, react.createElement)("tr", null, header.map((c, n) => (0, react.createElement)("th", { key: "th-" + String(n) }, c)))), (0, react.createElement)("tbody", null, body.map((r, n) => (0, react.createElement)("tr", { key: "tr-" + String(n) }, r.map((c, m) => (0, react.createElement)("td", { key: "td-" + String(m) }, c)))))));
 			}
 			const nodes = inlineNodes(parseInline(line.text), String(i));
+			const SPACER = "\xA0";
+			if (line.kind === "li" && line.checked !== void 0) return (0, react.createElement)("div", {
+				key: i,
+				"data-line": String(i),
+				className: cls + todoCls
+			}, (0, react.createElement)("span", { className: "rec-doc-bullet" }, "-"), todoMark(line, "todo-" + String(i)), (0, react.createElement)("span", { className: "rec-doc-li-text" }, SPACER, nodes));
 			if (line.kind === "li") return (0, react.createElement)("div", {
 				key: i,
 				"data-line": String(i),
 				className: cls
-			}, (0, react.createElement)("span", { className: "rec-doc-bullet" }, "•"), (0, react.createElement)("span", { className: "rec-doc-li-text" }, nodes));
+			}, (0, react.createElement)("span", { className: "rec-doc-bullet" }, "-"), (0, react.createElement)("span", { className: "rec-doc-li-text" }, SPACER, nodes));
 			return (0, react.createElement)("div", {
 				key: i,
 				"data-line": String(i),
-				className: cls
+				className: cls + gateCls
 			}, nodes);
 		}
 		/**
+		* The parsed lines as elements — the preview built from `parseDoc` + `lineElement`, with no shell of its own.
+		*
+		* ⚠ THIS IS WHAT MAKES A SECOND RENDERER UNNECESSARY. Any surface that wants to show a run artifact as a
+		* PREVIEW (the phase-doc viewer's body, the run-start spec sheet's document body) renders these nodes inside
+		* whatever frame it owns, so the markdown is parsed and drawn exactly once in the plugin. `keyBase` namespaces
+		* the React keys when several of these are on screen at once; `current` is the vim cursor line, which the
+		* spec sheet never sets.
+		*/
+		function PreviewLines({ lines, keyBase = "doc", current = -1 }) {
+			return (0, react.createElement)("div", {
+				className: "rec-doc-lines",
+				"data-preview-lines": String(lines.length)
+			}, ...lines.map((line, i) => (0, react.createElement)("div", {
+				key: keyBase + "-line-" + String(i),
+				className: "rec-doc-line-wrap"
+			}, lineElement(line, i, i === current))));
+		}
+		/**
 		* The per-phase doc viewer. Fetches the route on mount / fileName change.
 		* Vim nav + / search + n/N + Esc; y copies the doc. Esc closes search first,
 		* else the viewer. data-theme is passed down by the hoisting Inspector
@@ -878,9 +965,6 @@ window.__ModuleLoader__.load({
 					else onClose();
 				}
 			};
-			new Set(matches);
-			matches.length > 0 && matches[activeMatch];
-			const lineEls = docLines.map((line, i) => lineElement(line, i, i === cursor));
 			const searchBar = searchOpen ? (0, react.createElement)("div", { className: "rec-doc-search" }, (0, react.createElement)("input", {
 				className: "rec-doc-search-input",
 				value: query,
@@ -908,7 +992,11 @@ window.__ModuleLoader__.load({
 				onClick: onClose,
 				title: "Close",
 				"aria-label": "Close"
-			}, "Close")), searchBar, (0, react.createElement)("div", { className: "rec-doc-body" }, text === null && error === null ? (0, react.createElement)("p", { className: "rec-doc-text" }, "Loading doc…") : null, error !== null ? (0, react.createElement)("p", { className: "rec-doc-text rec-doc-error" }, error) : null, text !== null ? lineEls : null), (0, react.createElement)("footer", { className: "rec-doc-footer" }, (0, react.createElement)("div", {
+			}, "Close")), searchBar, (0, react.createElement)("div", { className: "rec-doc-body" }, text === null && error === null ? (0, react.createElement)("p", { className: "rec-doc-text" }, "Loading doc…") : null, error !== null ? (0, react.createElement)("p", { className: "rec-doc-text rec-doc-error" }, error) : null, text !== null ? (0, react.createElement)(PreviewLines, {
+				lines: docLines,
+				keyBase: "doc",
+				current: cursor
+			}) : null), (0, react.createElement)("footer", { className: "rec-doc-footer" }, (0, react.createElement)("div", {
 				className: statusCls,
 				role: "status"
 			}, statusText), (0, react.createElement)("div", { className: "rec-doc-hints" }, SEARCH_HINTS.map((h, n) => (0, react.createElement)("span", { key: "hint-" + String(n) }, (0, react.createElement)("kbd", null, h[0]), " " + h[1] + (n < SEARCH_HINTS.length - 1 ? " |" : ""))))));
@@ -998,10 +1086,18 @@ window.__ModuleLoader__.load({
 		* Subscribe to the live route for one scope. Returns the current state. The SSE
 		* feed pushes full frames on every fs change; a dropped stream (sleep/error)
 		* triggers one refetch so the board never serves a stale fold.
+		*
+		* @param scope - sessionId PRIMARY + cwd fallback hint (host resolves the root).
+		* @param options - `enabled: false` clears the snapshot and never fetches.
 		*/
-		function useLiveProjection(scope) {
+		function useLiveProjection(scope, options = {}) {
+			const { enabled = true } = options;
 			const [state, setState] = (0, react.useState)(null);
 			(0, react.useEffect)(() => {
+				if (!enabled) {
+					setState(null);
+					return;
+				}
 				if (isEmpty(scope)) {
 					setState(null);
 					return;
@@ -1018,7 +1114,11 @@ window.__ModuleLoader__.load({
 					disposed = true;
 					disposeEvents();
 				};
-			}, [scope.sessionId, scope.cwd]);
+			}, [
+				scope.sessionId,
+				scope.cwd,
+				enabled
+			]);
 			return state;
 		}
 		//#endregion
@@ -1305,6 +1405,579 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/run-spec.ts
+		/** The named evidence classes, so a reader can tell a placeholder from an unmet gate. */
+		const ARTIFACT_MARKER_IDS = {
+			placeholder: "placeholder",
+			uncheckedTodo: "unchecked-todo",
+			failedGate: "failed-gate"
+		};
+		/** Every marker, in the order they are reported for a single line. */
+		const MARKER_PATTERNS = [
+			{
+				id: ARTIFACT_MARKER_IDS.placeholder,
+				re: /(^\s*\.\.\.\s*$)|(\[[^[\]\n<>]{2,120}\])|(<[^<>\n]{2,120}>)/
+			},
+			{
+				id: ARTIFACT_MARKER_IDS.uncheckedTodo,
+				re: /^\s*[-*]\s*\[ \]/
+			},
+			{
+				id: ARTIFACT_MARKER_IDS.failedGate,
+				re: /^\s*(Coverage|Approval):\s*FAIL\b/i
+			}
+		];
+		/**
+		* Which marker a single line carries, or null.
+		*
+		* Exported because the client prints the marker NAMES beside the quoted lines, and a second classifier that
+		* re-derived them would be a second answer to the same question.
+		*/
+		function markerIdsOnLine(line) {
+			const ids = [];
+			for (const pattern of MARKER_PATTERNS) if (pattern.re.test(line)) ids.push(pattern.id);
+			return ids;
+		}
+		/**
+		* Classify one artifact's text.
+		*
+		* A verdict of `unfilled` means the document still carries the template's own placeholder text — the
+		* evidence travels with it, line by line, so the refusal (and the client notice) can name what is missing
+		* instead of asserting a state the reader cannot check.
+		*/
+		function classifyArtifact(text) {
+			const lines = text.split(/\r?\n/);
+			const hits = [];
+			for (let i = 0; i < lines.length; i += 1) {
+				const line = lines[i];
+				for (const id of markerIdsOnLine(line)) hits.push({
+					id,
+					line: i + 1,
+					text: line.trim()
+				});
+			}
+			return {
+				verdict: hits.some((hit) => hit.id === ARTIFACT_MARKER_IDS.placeholder) ? "unfilled" : "filled",
+				hits
+			};
+		}
+		/** The unfilled evidence only (what a refusal names). */
+		function unfilledEvidence(result) {
+			return result.hits.filter((hit) => hit.id === ARTIFACT_MARKER_IDS.placeholder);
+		}
+		//#endregion
+		//#region src/client/spec-sheet-view.ts
+		/**
+		* Pure display model for the RUN-START SPEC SHEET.
+		*
+		* WHY THIS MODULE EXISTS. `src/client/spec-sheet.tsx` renders the Phase 0 document beside the run-start
+		* question so a person can read what they are approving. Everything that DECIDES what the sheet says is
+		* here instead: reading the tool call's own arguments, classifying the document, and choosing the fetch
+		* state. It is pure (no React, no fs, no session window), which is what lets the spec drive every branch —
+		* a stub, a filled document, a missing file, a failed route, a call with no runId — without a browser.
+		*
+		* ⚠ THE VERDICT COMES FROM THE TEXT, NEVER FROM THE FETCH. `loading`, `absent`, `error` and `loaded` are
+		* four different facts, and a single "not loaded" would collapse them — which is how a client comes to
+		* render an empty box for a failure and a failure for a document nobody has written yet.
+		*
+		* ⚠ AND IT IS NODE-FREE. This file is reached by the BROWSER bundle. Reading the artifact belongs to the
+		* server half (`run-start.ts`, `recursive_ask.tool.ts`); this half only ever DISPLAYS what the read-only
+		* `/doc` route returned.
+		*/
+		/**
+		* The wire name of the tool whose call row the sheet replaces.
+		*
+		* `tool.call.toolview` is a KEYED seat dispatched by this exact string, so a typo renders nothing at all
+		* rather than rendering wrongly — the failure mode the harness documents for a keyed seat.
+		*/
+		const RUN_START_TOOL_NAME = "recursive_ask";
+		/**
+		* The Phase 0 artifact the run-start decision is recorded in.
+		*
+		* ⚠ DUPLICATED DELIBERATELY, AND PINNED BY A TEST. `run-start.ts` holds the same string, but importing it
+		* here would pull `node:fs` / `node:crypto` into the browser bundle through `status.ts` and take the page
+		* down for a constant. `tests/spec-sheet.spec.ts` asserts this value EQUALS `RUN_START_ARTIFACT`, so the copy
+		* cannot drift; the client only ever reads through it and never writes.
+		*/
+		const RUN_START_SPEC_FILE = "00-requirements.md";
+		/** The gate id whose question this sheet accompanies. */
+		const RUN_START_GATE_ID = "run-start";
+		/** The all-null argument set: what a malformed, truncated, or absent payload yields. */
+		const NO_ARGS = {
+			gate: null,
+			runId: null,
+			artifact: null,
+			answer: null
+		};
+		/**
+		* Read the arguments out of the raw JSON the model dispatched.
+		*
+		* A malformed or empty payload yields all-nulls rather than throwing: a truncated mid-stream argument string
+		* is a normal sight on this seat (the harness exposes preparing calls with no arguments at all), and a view
+		* that threw on one would take the transcript down with it.
+		*/
+		function parseRecursiveAskArgs(argsRaw) {
+			if (argsRaw === null || argsRaw.trim() === "") return { ...NO_ARGS };
+			let parsed;
+			try {
+				parsed = JSON.parse(argsRaw);
+			} catch {
+				return { ...NO_ARGS };
+			}
+			if (typeof parsed !== "object" || parsed === null) return { ...NO_ARGS };
+			const record = parsed;
+			const str = (value) => typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+			return {
+				gate: str(record.gate),
+				runId: str(record.runId),
+				artifact: str(record.artifact),
+				answer: str(record.answer)
+			};
+		}
+		/**
+		* Read the call's arguments out of whichever phase the owner supplied.
+		*
+		* ⚠ THE THREE FAILURES ARE KEPT APART. "No block", "the arguments have not been dispatched yet" and "the
+		* window truncated the call" are three different facts, and a client that collapsed them into one empty
+		* argument set would tell a person the call named no run — a claim about the CALLER, made on evidence about
+		* the CLIENT.
+		*/
+		function readCall(block) {
+			if (block === null || block === void 0) return {
+				ok: false,
+				reason: "missing"
+			};
+			if (block.phase === "preparing") return {
+				ok: false,
+				reason: "preparing"
+			};
+			if (block.phase === "start") return {
+				ok: true,
+				args: parseRecursiveAskArgs(block.argsRaw)
+			};
+			const carried = block.call ?? null;
+			return carried === null ? {
+				ok: false,
+				reason: "truncated"
+			} : {
+				ok: true,
+				args: parseRecursiveAskArgs(carried.argsRaw)
+			};
+		}
+		/** Is this the run-start gate? Everything else keeps the generic tool row. */
+		function isRunStartCall(args) {
+			return args.gate === RUN_START_GATE_ID;
+		}
+		/** Whether this call is one the sheet claims at all: the run-start gate, with a run named. */
+		function isSpecSheetCall(read) {
+			return read.ok && isRunStartCall(read.args) && read.args.runId !== null;
+		}
+		/**
+		* Build the sheet's model from what the client actually has.
+		*
+		* ⚠ THE TEXT IS ONLY EVER TAKEN FROM A `loaded` FETCH. A stale body from a previous run is not shown against
+		* a new run id, because "this is the document" is the one claim this seat exists to make truthfully.
+		*/
+		function specSheetModel(input) {
+			const file = input.file ?? "00-requirements.md";
+			const text = input.fetch.state === "loaded" ? input.fetch.text ?? null : null;
+			const verdict = text === null ? null : classifyArtifact(text);
+			return {
+				runId: input.args.runId,
+				root: input.root,
+				file,
+				state: input.fetch.state,
+				error: input.fetch.error ?? null,
+				text,
+				verdict: verdict === null ? null : verdict.verdict,
+				evidence: verdict === null ? [] : verdict.hits,
+				args: input.args
+			};
+		}
+		/** The document's path, as it should be PRINTED (never as it is fetched). */
+		function specPath(runId, root, file) {
+			const at = ".recursive/run/" + (runId ?? "<runId>") + "/" + file;
+			return root === null || root.trim() === "" ? at : at + "  (in " + root + ")";
+		}
+		/** The mode a freshly mounted sheet opens in: the rendered document. */
+		const SPEC_DEFAULT_MODE = "preview";
+		/** The toggle's own label, ALWAYS naming the mode that is on screen — never the one a click would reach. */
+		const SPEC_MODE_LABEL = {
+			preview: "Showing: rendered preview",
+			raw: "Showing: raw source"
+		};
+		/** What the toggle does next, in the imperative, so the control reads as an action and its state reads apart. */
+		const SPEC_TOGGLE_LABEL = {
+			preview: "View source",
+			raw: "Back to preview"
+		};
+		/** One line describing what is on screen, in both modes, for the announced status. */
+		const SPEC_MODE_NOTE = {
+			preview: "The document is rendered here as a preview: headings, lists, code and tables are drawn as such.",
+			raw: "The document is shown here VERBATIM — the exact bytes, with nothing rendered and nothing removed."
+		};
+		/** The other mode — what one press of the toggle reaches. */
+		function otherMode(mode) {
+			return mode === "preview" ? "raw" : "preview";
+		}
+		/**
+		* Describe the toggle for a mode.
+		*
+		* ⚠ `pressed` IS DERIVED FROM THE MODE, NEVER STORED BESIDE IT. A second boolean that could disagree with the
+		* mode is how a control comes to say "pressed" while the rendered document is on screen — and this is the one
+		* control whose whole job is to tell the reader which of the two things they are looking at.
+		*/
+		function specViewToggle(mode) {
+			return {
+				mode,
+				action: SPEC_TOGGLE_LABEL[mode],
+				pressed: mode === "raw",
+				announce: SPEC_MODE_LABEL[mode] + ". " + SPEC_MODE_NOTE[mode]
+			};
+		}
+		/**
+		* Decide the body content for a document text and a mode.
+		*
+		* ⚠ NULL TEXT IS NOT `''`. A `null` document is one that was never loaded, and it must not be printed as an
+		* empty document — "there is nothing here" and "the document is empty" are different claims, and this seat
+		* exists to make claims a reader can trust.
+		*/
+		function specBodyContent(text, mode) {
+			if (text === null) return null;
+			return mode === "raw" ? {
+				mode: "raw",
+				text
+			} : {
+				mode: "preview",
+				text
+			};
+		}
+		/** What the sheet says while the call is still preparing (its arguments are not dispatched yet). */
+		const PREPARING_NOTICE = "This tool call has not been dispatched yet, so its arguments — and the run it names — are not available.";
+		/** What the sheet says when the loaded window truncated the call head away. */
+		const TRUNCATED_NOTICE = "The loaded window left this call's own arguments outside it, so the run spec it names cannot be resolved here.";
+		/** What each offered label means, quoted from the gate's own option descriptions. */
+		const RUN_START_OPTION_MEANING = "“Start run” records the approval and arms the run goal; “Hold” leaves the spec inert: no run goal, no autonomous rounds.";
+		/**
+		* The recorded decision, when this call carries one.
+		*
+		* ⚠ A `Hold` IS NOT AN APPROVAL and is not printed as one. The test is the same VALUE test the server makes
+		* (`run-start.ts::isRunStartApproval` — the approving label, not the mere presence of a decision line), so
+		* the sheet can never describe a hold as an approval.
+		*/
+		function decisionLine(answer) {
+			if (answer === null) return null;
+			return answer.trim() === "Start run" ? "This call records: " + answer + " — the approving label, which arms the run goal." : "This call records: " + answer + " — not the approving label, so no run goal is armed.";
+		}
+		//#endregion
+		//#region src/client/spec-sheet.tsx
+		/**
+		* THE RUN-START SPEC SHEET — the document beside the question it decides.
+		*
+		* THE DEFECT THIS ANSWERS. The owner asked for a run spec, the plugin scaffolded one and raised the
+		* `run-start` gate — "start this run or hold?" — and NOBODY WAS SHOWN THE DOCUMENT:
+		* *"the card ui for accepting the spec appeared, but i was never shown the spec before that so how could i
+		* approve if i havent seen it"*. The gate was decidable before it was readable.
+		*
+		* ⚠ WHERE THIS RENDERS, AND WHY NOT IN `conversation.approval.detail`. That seat was the first candidate —
+		* its catalog summary reads "Optional detail for the Tool call correlated with an approval request" — and it
+		* is the WRONG one, for a reason that is structural rather than stylistic:
+		*
+		*   1. `conversation.composer` is a CHAIN slot: its entries' selectors run in order and the FIRST non-null
+		*      match renders. `ui-approval` claims it with `select: pendingInteraction instanceof PendingApproval`
+		*      and declares `conversation.approval.detail` as its child; `ui-user-questions` claims it with
+		*      `select: pendingInteraction instanceof PendingQuestion` and declares
+		*      `conversation.plan-review.actions` instead. They are two mutually exclusive cells of ONE chain.
+		*   2. The run-start gate is asked through the USER-QUESTIONS channel (`askRunStartDirectly` →
+		*      `channel.ask(...)`, correlated by `wait: { callId: exec.callId }`), so while it is pending the
+		*      pending interaction IS a `PendingQuestion` — the question composer owns the composer, and
+		*      `conversation.approval.detail` is not mounted at all. A sheet registered there would render on the
+		*      one occasion it is not needed and never on the one it is.
+		*   3. `tool.call.toolview` keyed by tool name is the seat that exists exactly while THIS tool call is on
+		*      screen, is unclaimed for `recursive_ask` (the harness's own `ask_user_question` IS claimed, which is
+		*      the parallel that matters), and hands the view its own `callId`, the session `cwd` and the frozen
+		*      call block — which is how the `runId` is read out of the call's own arguments.
+		*
+		* WHAT IT SHOWS — AND THE DEFECT THAT CHANGED IT. This seat first showed the ACTUAL bytes of
+		* `.recursive/run/<runId>/00-requirements.md` as RAW TEXT, on the reasoning that verbatim is the honest
+		* thing to print. The honest answer to "is that a preview?" was NO, and the owner was being asked to APPROVE
+		* what they read: *reading `##` headings and pipe-table syntax is not reviewing a spec*. So the default is now
+		* a RENDERED PREVIEW — headings, lists, fenced code and pipe tables drawn as such — and the verbatim text is
+		* one press away behind "View source".
+		*
+		* ⚠ AND THE RAW MODE IS NOT DECORATION. A preview is an INTERPRETATION, and this seat asks a person to
+		* approve a document on the strength of it. The raw view exists so that "the preview is not paraphrasing or
+		* hiding anything" is a claim the reader can CHECK against the bytes rather than one they must take from the
+		* renderer. Its state is carried by `aria-pressed` and repeated in a `role="status"` line that names the mode
+		* on screen, so the mode is announced and not merely coloured.
+		*
+		* ⚠ ONE RENDERER, NOT TWO. The markdown is parsed and drawn by `doc-viewer.tsx` — `parseDoc` and its
+		* `PreviewLines` — the same code path the phase-doc viewer uses. A second markdown renderer in one plugin
+		* would be a second answer to "what does this document say", which is the defect this plugin exists to
+		* refuse. What `parseDoc` could not carry for a real `00-requirements.md` (the task boxes and the gate
+		* readings the template ships) was added THERE, for both readers, rather than forked here.
+		*
+		* WHAT IT STILL REFUSES TO DO. It is READ-ONLY (R9): the sheet has no approve/hold control, because a second
+		* control that looks like the question card's would be a second way to answer one question — the sheet may
+		* change HOW the document is shown, never WHETHER it is approved. And the honesty rule of
+		* `settings-view.ts` is unchanged: when the artifact is still the unfilled template the rendered view says so
+		* loudly and the unfilled marks stay visible AS unfilled (`☐ …` items and `Coverage: FAIL` gates are drawn as
+		* exactly that), so a pretty preview of an empty form can never read as an approvable spec.
+		*
+		* ACCESSIBILITY. The outer element is a `region` named by its own heading (`aria-labelledby`); the document
+		* body is a focusable (`tabIndex=0`) scrolling box with its own `aria-label` and `aria-readonly`, so the
+		* keyboard reaches the text and can scroll it without the decision controls leaving the viewport (the cap is
+		* CSS `max-height` with `overflow-y: auto`). The box is the SAME element in both modes, so toggling never
+		* drops focus. Escape is swallowed deliberately, because on a dialog-ish surface Escape is the key that
+		* dismisses and dismissing this sheet must never be read as a decision; and the one transition it has is none
+		* under `prefers-reduced-motion` (see the `.rec-spec` rules in `styles.ts`). No modal is used: nothing here
+		* needs a focus trap, and a trap would take the keyboard away from the decision controls.
+		*/
+		const EMPTY_WORKSPACES = {
+			items: [],
+			recentWorkspaceId: void 0
+		};
+		/**
+		* A scope that resolves nothing.
+		*
+		* The hook stays UNCONDITIONAL (the run 13 lesson: a conditional hook changed the hook count across renders
+		* and threw "Rendered more hooks than during the previous render"), so a row that is not a run-start call
+		* passes this and the route is never asked for it.
+		*/
+		const NO_SCOPE = {
+			sessionId: void 0,
+			cwd: void 0
+		};
+		/**
+		* Resolve the workspace root the `/doc` route will accept.
+		*
+		* ⚠ THE ROOT CANNOT BE THE SESSION CWD BY GUESSWORK. The route re-validates whatever root it is handed
+		* against the host's own workspace registry (`live-route.ts`: `resolveRoot(undefined, root)` must return the
+		* same canonical path), so the root used here is the one the live route ITSELF answered with; the workspace
+		* path is the hydration hint every other seat passes, and the owner-supplied `cwd` is the last resort.
+		*/
+		function resolveSpecRoot(snapshotRoot, workspacePath, cwd) {
+			if (typeof snapshotRoot === "string" && snapshotRoot.trim() !== "") return snapshotRoot;
+			if (workspacePath.trim() !== "") return workspacePath;
+			return cwd.trim() === "" ? null : cwd;
+		}
+		/** The route states the /doc fetch can produce, and what each one MEANS. */
+		function readDoc(runId, root, file) {
+			const [fetchState, setFetchState] = (0, react.useState)({ state: "loading" });
+			(0, react.useEffect)(() => {
+				if (runId === null || root === null) {
+					setFetchState({ state: "loading" });
+					return;
+				}
+				let disposed = false;
+				setFetchState({ state: "loading" });
+				fetchPhaseDoc({
+					root,
+					runId,
+					file
+				}).then((text) => {
+					if (!disposed) setFetchState({
+						state: "loaded",
+						text
+					});
+				}).catch((err) => {
+					if (disposed) return;
+					const message = err instanceof Error ? err.message : String(err);
+					const missing = /HTTP 404\b/.test(message);
+					setFetchState({
+						state: missing ? "absent" : "error",
+						error: message
+					});
+				});
+				return () => {
+					disposed = true;
+				};
+			}, [
+				runId,
+				root,
+				file
+			]);
+			return fetchState;
+		}
+		/**
+		* The seat component: renders the spec sheet for ONE `recursive_ask` tool call, and NOTHING for any other.
+		*
+		* Returning `null` is how an unclaimed key behaves, so a `tdd-mode` / `qa-signoff` / `gate-block` ask, or a
+		* preparing call whose arguments have not been dispatched yet, keeps the generic tool row it has today.
+		*/
+		function RunStartSpecSheet({ block, cwd, useSessions, useWorkspaces }) {
+			const sessions = useSessions === void 0 ? null : useSessions((s) => s);
+			const workspaces = useWorkspaces === void 0 ? EMPTY_WORKSPACES : useWorkspaces((s) => s) ?? EMPTY_WORKSPACES;
+			const workspacePath = sessions === null ? "" : currentWorkspacePath(workspaces, sessions);
+			const sessionCwd = sessions === null ? "" : currentSessionCwd(sessions);
+			const read = readCall(block);
+			const claims = isSpecSheetCall(read);
+			const runId = read.ok ? read.args.runId : null;
+			const root = resolveSpecRoot(useLiveProjection(sessions === null ? NO_SCOPE : {
+				sessionId: sessions.current,
+				cwd: workspacePath !== "" ? workspacePath : sessionCwd
+			}, { enabled: claims })?.root ?? null, workspacePath, cwd ?? "");
+			const fetchState = readDoc(claims ? runId : null, root, RUN_START_SPEC_FILE);
+			if (!read.ok) {
+				if (read.reason === "missing") return null;
+				const text = read.reason === "preparing" ? PREPARING_NOTICE : TRUNCATED_NOTICE;
+				return specFrame((0, react.createElement)("p", {
+					className: "rec-spec-notice",
+					role: "status"
+				}, text));
+			}
+			if (!claims) return null;
+			if (read.args.runId === null) return specFrame((0, react.createElement)("p", {
+				className: "rec-spec-notice",
+				role: "status"
+			}, "This `recursive_ask` call names no runId, so no run spec can be shown for it."));
+			return (0, react.createElement)(RunStartSpecSheetBody, { model: specSheetModel({
+				args: read.args,
+				root,
+				fetch: fetchState
+			}) });
+		}
+		/**
+		* The body, from a MODEL — split out so the spec can drive every state (stub, filled, absent, error, a
+		* recorded Hold, a recorded approval) without a route, a session, or a fetch.
+		*
+		* The MODE is local state and starts at the rendered preview (`SPEC_DEFAULT_MODE`); everything that decides
+		* what the sheet SAYS still comes from the pure model, so a spec can assert the words and the marks without
+		* mounting a component.
+		*/
+		function RunStartSpecSheetBody({ model }) {
+			const headingId = "rec-spec-title-" + (model.runId ?? "unresolved");
+			const [mode, setMode] = (0, react.useState)(SPEC_DEFAULT_MODE);
+			const toggle = specViewToggle(mode);
+			return (0, react.createElement)("section", {
+				className: "rec-spec",
+				role: "region",
+				"aria-labelledby": headingId,
+				"aria-readonly": "true",
+				"data-verdict": model.verdict ?? model.state,
+				"data-mode": mode,
+				onKeyDown: (event) => {
+					if (event.key !== "Escape") return;
+					event.preventDefault?.();
+					event.stopPropagation?.();
+				}
+			}, (0, react.createElement)("header", { className: "rec-spec-header" }, (0, react.createElement)("h3", {
+				className: "rec-spec-title",
+				id: headingId
+			}, "Run spec — " + (model.runId ?? "runId not carried") + " / " + model.file), (0, react.createElement)("span", { className: "rec-spec-tag" }, "read-only")), (0, react.createElement)("p", { className: "rec-spec-path" }, specPath(model.runId, model.root, model.file)), notice(model), questionBlock(model), viewControls(toggle, model, () => {
+				setMode(otherMode(toggle.mode));
+			}), documentBody(model, mode));
+		}
+		/**
+		* The mode control: one button, and the line that announces the state it just put the sheet in.
+		*
+		* ⚠ KEYBOARD-REACHABLE BY BEING A BUTTON. It is a real `<button type="button">`, so Tab reaches it and
+		* Enter/Space press it with no key handler of our own to get wrong. `aria-pressed` carries the state to a
+		* screen reader on the control, and the `role="status"` paragraph repeats it in words, naming the mode ON
+		* SCREEN ("Showing: raw source") rather than the action — so neither a pointer user nor a reader has to infer
+		* the current mode from the button's face.
+		*/
+		function viewControls(toggle, model, onToggle) {
+			const shown = model.text !== null;
+			return (0, react.createElement)("div", { className: "rec-spec-view" }, (0, react.createElement)("button", {
+				type: "button",
+				className: "rec-spec-view-toggle",
+				"aria-pressed": toggle.pressed,
+				title: toggle.announce,
+				"aria-disabled": !shown,
+				onClick: () => {
+					if (shown) onToggle();
+				}
+			}, toggle.action), (0, react.createElement)("span", {
+				className: "rec-spec-view-state",
+				role: "status"
+			}, toggle.announce));
+		}
+		/**
+		* The document body: the rendered preview, or the raw bytes — and only ever the document's OWN text.
+		*
+		* Both modes are built from the same string, so neither is a second reading of the file: `raw` prints the
+		* characters, `preview` hands those same characters to the one parser this plugin has.
+		*/
+		function documentBody(model, mode) {
+			const content = specBodyContent(model.text, mode);
+			const box = {
+				className: "rec-spec-body-scroll" + (content !== null && content.mode === "raw" ? " rec-spec-body-raw" : ""),
+				tabIndex: 0,
+				role: "group",
+				"aria-label": "Document text of " + (model.runId ?? "the run") + " / " + model.file + ", read-only, " + (mode === "raw" ? "raw source" : "rendered preview")
+			};
+			if (content === null) return (0, react.createElement)("div", box, (0, react.createElement)("p", { className: "rec-spec-empty" }, "No document text to show."));
+			if (content.mode === "raw") return (0, react.createElement)("div", box, (0, react.createElement)("pre", { className: "rec-spec-text" }, content.text));
+			return (0, react.createElement)("div", box, (0, react.createElement)(SpecPreview, {
+				text: content.text,
+				runId: model.runId,
+				file: model.file
+			}));
+		}
+		/**
+		* The rendered document.
+		*
+		* The parsing is memoised on the TEXT, so a toggle back and forth does not re-parse the document, and the
+		* elements come from `doc-viewer.tsx`'s `PreviewLines` — the one place in this plugin where a `DocLine`
+		* becomes markup.
+		*/
+		function SpecPreview({ text, runId, file }) {
+			const lines = (0, react.useMemo)(() => parseDoc(text), [text]);
+			return (0, react.createElement)(PreviewLines, {
+				lines,
+				keyBase: "rec-spec-" + (runId ?? "run") + "-" + file
+			});
+		}
+		/** The verdict notice: what the document IS, decided from its own text. */
+		function notice(model) {
+			if (model.state === "loading") return (0, react.createElement)("p", {
+				className: "rec-spec-notice",
+				role: "status"
+			}, "Reading the document…");
+			if (model.state === "absent") return (0, react.createElement)("p", {
+				className: "rec-spec-notice rec-spec-notice-error",
+				role: "status"
+			}, "That document does not exist yet, so there is nothing here to read and nothing to approve.");
+			if (model.state === "error") return (0, react.createElement)("p", {
+				className: "rec-spec-notice rec-spec-notice-error",
+				role: "status"
+			}, "The document could not be read: " + (model.error ?? "the route gave no reason"));
+			if (model.verdict === "unfilled") {
+				const strong = unfilledEvidence({
+					verdict: "unfilled",
+					hits: model.evidence
+				});
+				const context = model.evidence.filter((hit) => hit.id !== "placeholder");
+				return (0, react.createElement)("div", {
+					className: "rec-spec-notice rec-spec-notice-unfilled",
+					role: "status"
+				}, (0, react.createElement)("p", { className: "rec-spec-unfilled-lead" }, "This document is still the UNFILLED TEMPLATE. There is no spec to approve yet."), (0, react.createElement)("p", { className: "rec-spec-unfilled-why" }, "The template's own placeholder text is still in it:"), (0, react.createElement)("ul", { className: "rec-spec-evidence" }, strong.slice(0, 8).map((hit, n) => (0, react.createElement)("li", {
+					key: "placeholder-" + String(n),
+					className: "rec-spec-evidence-item"
+				}, "line " + String(hit.line) + ": " + hit.text))), strong.length > 8 ? (0, react.createElement)("p", { className: "rec-spec-unfilled-why" }, "…and " + String(strong.length - 8) + " more placeholder lines.") : null, context.length > 0 ? (0, react.createElement)("p", { className: "rec-spec-unfilled-why" }, "It also carries " + String(context.length) + " unfinished marker(s) of its own: " + context.slice(0, 3).map((hit) => "line " + String(hit.line) + ": " + hit.text).join(" | ")) : null, (0, react.createElement)("p", { className: "rec-spec-unfilled-next" }, "Fill the document in first. Approving here would record a decision about a spec that does not exist yet."));
+			}
+			if (model.verdict === "filled") return (0, react.createElement)("p", {
+				className: "rec-spec-notice rec-spec-notice-filled",
+				role: "status"
+			}, "The document carries real content: no template placeholder remains in it.");
+			return null;
+		}
+		/** The decision under way, in the gate's own words, plus the fact that the controls live elsewhere. */
+		function questionBlock(model) {
+			const recorded = decisionLine(model.args.answer);
+			return (0, react.createElement)("div", { className: "rec-spec-question" }, (0, react.createElement)("p", { className: "rec-spec-question-lead" }, "The question about this document is: “Approve phase 0 and start this run? Approving creates an armed goal the harness will keep driving.”"), (0, react.createElement)("p", { className: "rec-spec-question-options" }, RUN_START_OPTION_MEANING), (0, react.createElement)("p", { className: "rec-spec-question-where" }, "The decision controls are the question card's. This panel is read-only: it casts no vote and writes nothing."), recorded === null ? null : (0, react.createElement)("p", { className: "rec-spec-decision" }, recorded));
+		}
+		/** A minimal named frame for the states that precede a document (no call, no run id). */
+		function specFrame(...children) {
+			return (0, react.createElement)("section", {
+				className: "rec-spec",
+				role: "region",
+				"aria-label": "Run spec",
+				"aria-readonly": "true"
+			}, ...children);
+		}
+		//#endregion
 		//#region src/client/open-state.ts
 		/**
 		* Shared board open-state (run 08 R1): module-level store behind the launcher,
@@ -1382,7 +2055,7 @@ window.__ModuleLoader__.load({
 /* ===== dsh-recursive Paper theme (run 16) ===== */
 
 /* Raw tokens: light (default) + dark + shared, scoped to the board/inspector. */
-.rec-board, .rec-inspector {
+.rec-board, .rec-inspector, .rec-spec {
   /* light */
   --rm3-light-background: #FFFFFF;
   --rm3-light-foreground: #111111;
@@ -2041,6 +2714,9 @@ window.__ModuleLoader__.load({
   line-height: 1.7;
   padding: 0 6px;
   border-left: 2px solid transparent;
+  /* Containing block for the visually-hidden text that carries a task box's tick to a screen reader, so it
+     cannot be positioned against the page instead of against its own line. */
+  position: relative;
 }
 
 .rec-doc-line-current {
@@ -2465,8 +3141,302 @@ dl.rec-settings-rows {
   overflow-wrap: anywhere;
 }
 
+/* ===== Run-start spec sheet (tool.call.toolview key 'recursive_ask') =====
+   The document beside the run-start question. LIGHT is the only theme here: the sheet renders inline in a
+   transcript row, not on the board, so it does not own a data-theme attribute and must not inherit the
+   board's. The body is the ONLY scrolling box (a max-height cap with overflow-y: auto) so the decision
+   controls below it can never be pushed out of reach by a long document. */
+.rec-spec {
+  box-sizing: border-box;
+  margin: 6px 0;
+  padding: var(--board-space-12);
+  border: 1px solid var(--board-border);
+  border-radius: var(--board-radius-lg);
+  background: var(--board-card);
+  color: var(--board-fg);
+  font-family: var(--board-font-sans);
+  font-size: var(--board-text-sm);
+  /* The one transition this sheet has. It is disabled outright under prefers-reduced-motion below. */
+  transition: border-color 160ms ease;
+}
+
+.rec-spec-header {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: var(--board-space-8);
+}
+
+.rec-spec-title {
+  margin: 0;
+  font-size: var(--board-text-sm);
+  font-weight: var(--board-fw-semibold);
+  letter-spacing: var(--board-tracking-tight);
+  overflow-wrap: anywhere;
+}
+
+.rec-spec-tag {
+  flex: none;
+  font-size: var(--board-text-xs);
+  color: var(--board-muted-fg);
+}
+
+.rec-spec-path {
+  margin: 2px 0 var(--board-space-8);
+  font-family: var(--board-font-mono);
+  font-size: var(--board-text-xs);
+  color: var(--board-muted-fg);
+  overflow-wrap: anywhere;
+}
+
+.rec-spec-notice {
+  margin: 0 0 var(--board-space-8);
+  padding: var(--board-space-8);
+  border: 1px solid var(--board-border);
+  border-radius: var(--board-radius-md);
+  background: var(--board-muted);
+  font-size: var(--board-text-xs);
+  line-height: 1.5;
+}
+
+/* An UNFILLED template is stated as a warning, never as a neutral fact: the whole point of this seat is that
+   nobody is nudged toward approving a hollow document. */
+.rec-spec-notice-unfilled {
+  border-color: var(--board-warning);
+  background: color-mix(in srgb, var(--board-warning) 10%, var(--board-card));
+}
+
+.rec-spec-unfilled-lead {
+  margin: 0 0 6px;
+  font-weight: var(--board-fw-semibold);
+  color: var(--board-warning);
+}
+
+.rec-spec-unfilled-why {
+  margin: 0 0 4px;
+  color: var(--board-muted-fg);
+}
+
+.rec-spec-unfilled-next {
+  margin: 6px 0 0;
+  font-weight: var(--board-fw-medium);
+}
+
+.rec-spec-evidence {
+  margin: 0 0 4px;
+  padding-left: 18px;
+  font-family: var(--board-font-mono);
+  font-size: var(--board-text-xs);
+}
+
+.rec-spec-evidence-item {
+  overflow-wrap: anywhere;
+}
+
+.rec-spec-notice-filled {
+  border-color: var(--board-success);
+  background: color-mix(in srgb, var(--board-success) 8%, var(--board-card));
+}
+
+.rec-spec-notice-error {
+  border-color: var(--board-error);
+}
+
+.rec-spec-question {
+  margin: 0 0 var(--board-space-8);
+}
+
+.rec-spec-question-lead,
+.rec-spec-question-options,
+.rec-spec-question-where {
+  margin: 0 0 4px;
+  font-size: var(--board-text-xs);
+  line-height: 1.5;
+}
+
+.rec-spec-question-where {
+  color: var(--board-muted-fg);
+}
+
+.rec-spec-decision {
+  margin: 0;
+  font-size: var(--board-text-xs);
+  font-weight: var(--board-fw-medium);
+}
+
+/* The document body: the one bounded scroller. Focusable (tabIndex=0) for the keyboard, and the border
+   marks the focus ring's home rather than relying on a colour change alone. */
+.rec-spec-body-scroll {
+  max-height: 420px;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+  border: 1px solid var(--board-border);
+  border-radius: var(--board-radius-md);
+  background: var(--board-muted);
+}
+
+.rec-spec-body-scroll:focus-visible {
+  outline: 2px solid var(--board-info);
+  outline-offset: 2px;
+}
+
+/* The rendered preview inside that scroller (PreviewLines from doc-viewer.tsx). The line blocks carry their
+   own padding so the marks — task boxes, gate readings — line up in a column down the left edge. */
+.rec-spec-body-scroll .rec-doc-lines {
+  padding: var(--board-space-12);
+}
+
+.rec-spec-body-scroll .rec-doc-line {
+  padding: 0;
+}
+
+/* Raw source is monospace, wrapping, and NOT reflowed: the same characters the preview was built from. */
+.rec-spec-text {
+  margin: 0;
+  padding: var(--board-space-12);
+  font-family: var(--board-font-mono);
+  font-size: var(--board-text-xs);
+  line-height: 1.55;
+  /* The document is shown VERBATIM: only wrapping is normalised, never the characters. */
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  tab-size: 2;
+}
+
+/* ===== The mode control (preview <-> raw source) =====
+   One real button, so Tab reaches it and Enter/Space press it; aria-pressed carries its state to a screen
+   reader and the role=status line beside it names the mode on screen in words. */
+.rec-spec-view {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: var(--board-space-8);
+  margin: 0 0 var(--board-space-8);
+}
+
+.rec-spec-view-toggle {
+  flex: none;
+  padding: 4px 12px;
+  font-family: inherit;
+  font-size: var(--board-text-xs);
+  color: var(--board-fg);
+  background: var(--board-card);
+  border: 1px solid var(--board-border);
+  border-radius: 999px;
+  cursor: pointer;
+  white-space: nowrap;
+}
+
+.rec-spec-view-toggle:hover {
+  background: var(--board-accent);
+}
+
+.rec-spec-view-toggle:focus-visible {
+  outline: 2px solid var(--board-info);
+  outline-offset: 2px;
+}
+
+/* A pressed toggle says "the verbatim source is what you are reading" — marked, and not by colour alone. */
+.rec-spec-view-toggle[aria-pressed='true'] {
+  border-color: var(--board-info);
+  color: var(--board-info);
+  font-weight: var(--board-fw-semibold);
+}
+
+.rec-spec-view-toggle[aria-disabled='true'] {
+  opacity: 0.55;
+  cursor: default;
+}
+
+.rec-spec-view-state {
+  flex: 1 1 auto;
+  min-width: 0;
+  font-size: var(--board-text-xs);
+  color: var(--board-muted-fg);
+  overflow-wrap: anywhere;
+}
+
+/* ===== Marks the PREVIEW must not hide (shared with the phase-doc viewer) =====
+   The scaffolded Phase 0 template ships unticked boxes and two FAIL gates; a preview that drew them as
+   generic body text would make an unfilled form look like a finished spec. */
+.rec-doc-sr {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  border: 0;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  white-space: nowrap;
+}
+
+.rec-doc-todo {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+}
+
+.rec-doc-todo-check {
+  flex: none;
+  font-family: var(--board-font-mono);
+  font-size: 12.5px;
+  line-height: 1.7;
+  letter-spacing: var(--board-tracking-mono);
+}
+
+.rec-doc-todo-check-off {
+  color: var(--board-warning);
+  font-weight: var(--board-fw-semibold);
+}
+
+.rec-doc-todo-check-on {
+  color: var(--board-success);
+}
+
+/* An unticked box is stated, not merely greyed: the warning colour AND the mark together. */
+.rec-doc-todo-open .rec-doc-li-text {
+  color: var(--board-fg);
+}
+
+.rec-doc-todo-done .rec-doc-li-text {
+  color: var(--board-muted-fg);
+}
+
+.rec-doc-gate {
+  font-family: var(--board-font-mono);
+  font-size: var(--board-text-xs);
+  font-weight: var(--board-fw-semibold);
+  letter-spacing: var(--board-tracking-mono);
+  margin: 4px 0;
+  padding: 3px 8px;
+  border: 1px solid var(--board-border);
+  border-radius: var(--board-radius-md);
+  display: inline-block;
+}
+
+.rec-doc-gate-fail {
+  color: var(--board-error);
+  border-color: var(--board-error);
+  background: color-mix(in srgb, var(--board-error) 8%, var(--board-card));
+}
+
+.rec-doc-gate-pass {
+  color: var(--board-success);
+  border-color: var(--board-success);
+  background: color-mix(in srgb, var(--board-success) 8%, var(--board-card));
+}
+
+.rec-spec-empty {
+  margin: 0;
+  padding: var(--board-space-12);
+  color: var(--board-muted-fg);
+  font-size: var(--board-text-xs);
+}
+
 @media (prefers-reduced-motion: reduce) {
   .rec-card, .rec-back, .rec-close, .rec-theme-toggle { transition: none; }
+  .rec-spec { transition: none; }
 }
 `;
 		/**
@@ -2605,6 +3575,10 @@ dl.rec-settings-rows {
 					useWorkspaces: props?.useWorkspaces
 				});
 			})));
+			disposers.push(ctx.slots.inject("tool.call.toolview", () => ctx.slots.register({
+				name: "tool.call.toolview",
+				key: RUN_START_TOOL_NAME
+			}, RunStartSpecSheet)));
 			disposers.push(ctx.slots.inject("settings.section", () => ctx.slots.register({
 				name: "settings.section",
 				id: "recursive",