@pmelab/gtd 55.0.0 → 57.0.0

package/dist/web/main.js

@@ -25928,7 +25928,7 @@ function serializeChunks(chunks, expandTabs) {
 * @returns {ParseContext}
 *   Parser.
 */
-function parse(options) {
+function parse$1(options) {
 	/** @type {ParseContext} */
 	const parser = {
 		constructs: combineExtensions([constructs_exports, ...(options || {}).extensions || []]),
@@ -26243,7 +26243,7 @@ function fromMarkdown(value, encoding, options) {
 		options = encoding;
 		encoding = void 0;
 	}
-	return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));
+	return compiler(options)(postprocess(parse$1(options).document().write(preprocess()(value, encoding, true))));
 }
 /**
 * Note this compiler only understand complete buffering, not streaming.
@@ -29842,7 +29842,7 @@ const eolOf = (content) => content.includes("\r\n") ? "\r\n" : "\n";
 //#endregion
 //#region src/steering/Threads.ts
 const PREFIX_RE = /^(H|A):\s*/;
-const lineOf = (node, which) => toLspPosition(node.position[which]).line;
+const lineOf$1 = (node, which) => toLspPosition(node.position[which]).line;
 /** The item's own blocks joined — never the item node's span, which can run past its last line into the next bullet's marker. */
 const itemText$1 = (content, item) => item.children.map((child) => sourceText(content, child)).join(" ").trim();
 const prefixOf = (content, item) => PREFIX_RE.exec(itemText$1(content, item));
@@ -29856,9 +29856,9 @@ const isThreadBody = (content, children) => {
 };
 const foldName$1 = (name) => name.toLowerCase();
 /** One list item's entry, reporting any syntax problem; `previous` is the author before it. */
-const entryOf = (content, item, previous, report) => {
-	const start = lineOf(item, "start");
-	const end = lineOf(item, "end");
+const entryOf$1 = (content, item, previous, report) => {
+	const start = lineOf$1(item, "start");
+	const end = lineOf$1(item, "end");
 	const match = prefixOf(content, item);
 	if (!match) {
 		report(`an entry must start with "H:" or "A:"`, start, end);
@@ -29874,7 +29874,7 @@ const entryOf = (content, item, previous, report) => {
 		author,
 		text,
 		line: start,
-		endLine: last ? lineOf(last, "end") : end,
+		endLine: last ? lineOf$1(last, "end") : end,
 		column: toLspPosition(item.position.start).character
 	};
 };
@@ -29883,16 +29883,16 @@ const threadOf = (content, def, list, markers, report) => {
 	const entries = [];
 	let previous;
 	for (const item of list.children) {
-		const entry = entryOf(content, item, previous, report);
+		const entry = entryOf$1(content, item, previous, report);
 		if (!entry) continue;
 		previous = entry.author;
 		entries.push(entry);
 	}
-	for (const extra of def.children.slice(1)) report(`only one list of "H:"/"A:" entries may make up the body`, lineOf(extra, "start"), lineOf(extra, "end"));
+	for (const extra of def.children.slice(1)) report(`only one list of "H:"/"A:" entries may make up the body`, lineOf$1(extra, "start"), lineOf$1(extra, "end"));
 	return {
 		name,
-		line: lineOf(def, "start"),
-		endLine: lineOf(def, "end"),
+		line: lineOf$1(def, "start"),
+		endLine: lineOf$1(def, "end"),
 		markers: markers.filter((m) => foldName$1(m.name) === foldName$1(name)),
 		entries,
 		waitingOn: entries[entries.length - 1]?.author === "agent" ? "human" : "agent"
@@ -30126,6 +30126,8 @@ const noteLookup = (content, footnotes = parseFootnotes(content)) => {
 		return note === "" ? {} : { note };
 	};
 };
+/** Thread syntax findings alone — what free-form `validate` reports without inheriting the other footnote findings. */
+const threadFindings = (content) => collectThreads(content, parseMarkdown(content), []).findings;
 /** The first integer unused by any `fnN` marker or definition already in the document — deterministic (no clock, no randomness), so "add a footnote" is testable and idempotent under re-run: applying it twice yields `fn1` then `fn2`, never a collision. Counts orphan markers too (via `parseFootnotes`), so it never reuses a name that's already written but undefined. */
 const nextFootnoteName = (content) => {
 	const { markers, definitions } = parseFootnotes(content);
@@ -32116,14 +32118,14 @@ const CHOICE_NAMES = {
 /** A finding's decision as an outline node of its own; none for a chunk with no answer boxes. */
 const decisionNodes = (lines, chunk, end) => {
 	if (chunk.answerLine === void 0) return [];
-	const d = decisionOf(chunk);
+	const d = decisionOf$1(chunk);
 	return [{
 		name: `Decision: ${d === void 0 ? "open" : CHOICE_NAMES[d.choice] || d.text}`,
 		range: spanRange(lines, chunk.answerLine, Math.max(chunk.answerLine, end)),
 		selectionRange: lineRange(lines, chunk.answerLine)
 	}];
 };
-const isOpenChunk = (chunk, markers) => chunk.files.some((file) => !file.checked) || markers > 0 || chunk.answers !== void 0 && decisionOf(chunk) === void 0;
+const isOpenChunk = (chunk, markers) => chunk.files.some((file) => !file.checked) || markers > 0 || chunk.answers !== void 0 && decisionOf$1(chunk) === void 0;
 /**
 * Document outline for `.gtd/REVIEW.md`: the chunks still left to review — an
 * unchecked hunk, a footnote (so a human's comment never vanishes with the
@@ -32333,7 +32335,7 @@ const reviewView = (content) => {
 			},
 			...chunk.section === void 0 ? {} : { group: REVIEW_SECTIONS[chunk.section] },
 			...chunk.answers === void 0 ? {} : {
-				answered: decisionOf(chunk) !== void 0,
+				answered: decisionOf$1(chunk) !== void 0,
 				decision: chunk.answers.map((option, index) => ({
 					title: option.text,
 					checked: option.checked,
@@ -32549,7 +32551,7 @@ const CHOICES = [
 	"wontfix",
 	"answer"
 ];
-const decisionOf = (chunk) => {
+const decisionOf$1 = (chunk) => {
 	if (chunk.answers?.length !== 3) return void 0;
 	const ticked = chunk.answers.flatMap((o, i) => o.checked ? [i] : []);
 	if (ticked.length !== 1) return void 0;
@@ -32564,9 +32566,243 @@ const decisionOf = (chunk) => {
 	};
 };
 //#endregion
+//#region src/steering/findings.ts
+/** The `# ` heading the findings a judge called noise sit under. */
+const NOISE_HEADING = "Dropped as noise";
+const OPEN_GROUP = "Open";
+const MARKER = /\[\^[^\]\s]+\]/g;
+const isBox = (item, content) => {
+	if (typeof item.checked !== "boolean") return false;
+	const first = item.children[0];
+	if (first?.type !== "paragraph" || first.position === void 0) return false;
+	const text = content.slice(first.position.start.offset, first.position.end.offset);
+	return new RegExp(`^fix(?![\\w-])`).test(text);
+};
+const slice = (content, node) => content.slice(node.position.start.offset, node.position.end.offset);
+const lineOf = (node, end = false) => toLspPosition(end ? node.position.end : node.position.start).line;
+/** The box item's own text past its label: a formatter may fold a guidance line into it. */
+const inlineGuidance = (content, item) => {
+	const first = item.children[0];
+	return content.slice(first.position.start.offset, item.position.end.offset).slice(3).replace(/^[\s:—–-]+/, "").trim();
+};
+const guidanceOf = (parts) => parts.map((p) => p.replace(MARKER, "").trim()).filter((p) => p !== "").join("\n\n");
+/** `nodes` split at `box`: the body before it, the guidance after it. */
+const splitAtBox = (content, nodes, box) => {
+	const at = nodes.findIndex((n) => n.type === "list" && n.children.includes(box));
+	const list = nodes[at];
+	const boxAt = list.children.indexOf(box);
+	const bodyNodes = nodes.slice(0, boxAt > 0 ? at + 1 : at);
+	const trailing = list.children.slice(boxAt + 1);
+	const after = nodes.slice(at + 1);
+	return {
+		bodyNodes,
+		body: bodyNodes.map((n) => n === list ? content.slice(n.position.start.offset, box.position.start.offset).trimEnd() : slice(content, n)).join("\n\n"),
+		notBody: list.children.slice(boxAt),
+		guidance: guidanceOf([inlineGuidance(content, box), ...[...trailing, ...after].map((n) => slice(content, n))]),
+		last: after.at(-1) ?? trailing.at(-1) ?? box
+	};
+};
+const entryOf = (content, title, noise, headingLine, nodes, endLine) => {
+	const notes = nodes.filter((n) => n.type !== "footnoteDefinition");
+	const boxes = notes.flatMap((n) => n.type === "list" ? n.children.filter((i) => isBox(i, content)) : []);
+	const box = boxes[0];
+	const split = box === void 0 ? {
+		bodyNodes: notes,
+		body: notes.map((n) => slice(content, n)).join("\n\n"),
+		notBody: [],
+		guidance: ""
+	} : splitAtBox(content, notes, box);
+	return {
+		title,
+		body: split.body,
+		noise,
+		fix: box?.checked === true,
+		guidance: split.guidance,
+		boxes: boxes.length,
+		headingLine,
+		bodyNodes: split.bodyNodes,
+		...box === void 0 ? {} : { box },
+		notBody: new Set(split.notBody),
+		lastLine: split.last === void 0 ? headingLine : lineOf(split.last, true),
+		endLine
+	};
+};
+const parse = (content) => {
+	const tree = parseMarkdown(content);
+	const entries = [];
+	let noise = false;
+	let open;
+	const close = (endLine) => {
+		if (open !== void 0) entries.push(entryOf(content, open.title, noise, open.line, open.nodes, endLine));
+		open = void 0;
+	};
+	for (const node of tree.children) {
+		if (node.type === "heading" && node.depth <= 2) {
+			close(lineOf(node) - 1);
+			const text = headingText$1(content, node, (t) => t.replace(MARKER, ""));
+			if (node.depth === 1) noise = text === NOISE_HEADING;
+			else open = {
+				title: text,
+				line: lineOf(node),
+				nodes: []
+			};
+			continue;
+		}
+		open?.nodes.push(node);
+	}
+	close(content.split(/\r?\n/).length - 1);
+	return entries;
+};
+const entryFindings = (content) => parse(content).flatMap((e) => {
+	if (e.boxes === 0) return [{
+		message: `"${e.title}" has no \`- [ ] fix\` box — restore it, ticked to fix the finding or unticked to drop it`,
+		line: e.headingLine
+	}];
+	if (e.boxes > 1) return [{
+		message: `"${e.title}" has ${e.boxes} \`fix\` boxes — keep exactly one`,
+		line: e.headingLine
+	}];
+	if (!e.fix && e.guidance !== "") return [{
+		message: `"${e.title}" has guidance under an unticked box — tick it to fix the finding, or delete the text to drop it`,
+		line: lineOf(e.box)
+	}];
+	return [];
+});
+const findingsView = (content) => {
+	const noteAt = noteLookup(content);
+	return { nodes: parse(content).map((e, index) => {
+		const note = noteAt(e.headingLine);
+		return {
+			title: e.title,
+			anchor: {
+				kind: "chunk",
+				index
+			},
+			group: e.noise ? NOISE_HEADING : OPEN_GROUP,
+			...e.boxes === 1 ? { checked: e.fix } : {},
+			...e.guidance === "" ? {} : { note: e.guidance },
+			...note?.thread !== void 0 ? { thread: note.thread } : {},
+			body: blockNodesOfRun(content, e.bodyNodes, { skipListItem: (i) => e.notBody.has(i) })
+		};
+	}) };
+};
+const findingsOutline = (content) => {
+	const lines = content.split(/\r?\n/);
+	return [...parse(content).map((e) => ({
+		name: e.title,
+		detail: e.noise ? "noise" : e.fix ? "fix" : "drop",
+		range: spanRange(lines, e.headingLine, Math.max(e.headingLine, e.endLine)),
+		selectionRange: lineRange(lines, e.headingLine)
+	})), ...threadOutlineNodes(content).map((t) => t.node)];
+};
+const findingsAnnotate = (content, anchor, text) => {
+	const entries = parse(content);
+	const lines = content.split(/\r?\n/);
+	const resolved = (() => {
+		if (anchor.kind === "chunk") {
+			const e = entries[anchor.index];
+			return e && {
+				line: e.headingLine,
+				blockEndLine: e.headingLine,
+				key: `chunk:${anchor.index}`
+			};
+		}
+		if (anchor.kind !== "paragraph") return void 0;
+		const block = entries.flatMap((e) => e.bodyNodes).find((n) => anchor.line >= lineOf(n) && anchor.line <= lineOf(n, true));
+		return block && {
+			line: anchor.line,
+			blockEndLine: lineOf(block, true),
+			key: `paragraph:${anchor.line}`
+		};
+	})();
+	if (resolved === void 0) return {
+		ok: false,
+		reason: "anchor-not-found"
+	};
+	const result = footnoteAttachEdits(content, {
+		...resolved,
+		endCharacter: (lines[resolved.line] ?? "").length
+	}, text);
+	return result.ok ? {
+		ok: true,
+		edits: result.edits
+	} : result;
+};
+/** Ticks or unticks a finding's box; `text` replaces its guidance, and unticking drops it. */
+const findingsApply = (content, anchor, opts) => {
+	if (anchor.kind !== "chunk") return {
+		ok: false,
+		reason: "anchor-not-found"
+	};
+	const e = parse(content)[anchor.index];
+	if (e?.box === void 0 || e.boxes !== 1) return {
+		ok: false,
+		reason: "anchor-not-found"
+	};
+	const fix = opts.checked ?? e.fix;
+	const guidance = fix ? (opts.text ?? e.guidance).trim() : "";
+	if (fix === e.fix && guidance === e.guidance) return {
+		ok: true,
+		edits: []
+	};
+	const lines = content.split(/\r?\n/);
+	const eol = eolOf(content);
+	const start = lineOf(e.box);
+	const box = `${lines[start].match(/^\s*[-*+]\s+/)[0]}[${fix ? "x" : " "}] fix`;
+	const text = guidance === "" ? box : `${box}${eol}${eol}${guidance.split(/\r?\n/).join(eol)}`;
+	return {
+		ok: true,
+		edits: [{
+			range: {
+				start: {
+					line: start,
+					character: 0
+				},
+				end: lineRange(lines, e.lastLine).end
+			},
+			newText: text
+		}]
+	};
+};
+//#endregion
 //#region src/steering/index.ts
-/** The built-in registry: mode name → its format, in registry order. The single place `qa` and `review` are wired into names — everything else in this module dispatches over a resolved `SteeringFormat`, never a mode-name string. */
-const REGISTRY = /* @__PURE__ */ new Map([["qa", qaDescriptor], ["review", reviewDescriptor]]);
+/** The built-in registry: mode name → its format, in registry order. The single place the built-in formats are wired into names — everything else in this module dispatches over a resolved `SteeringFormat`, never a mode-name string. */
+const REGISTRY = /* @__PURE__ */ new Map([
+	["qa", qaDescriptor],
+	["review", reviewDescriptor],
+	["findings", {
+		sample: `# Quality
+
+## A finding a lens wrote[^nafind1]
+
+[^nafind1]:
+    Attached via the phone UI, this note shows a comment on a finding with a
+    \`multi word code span\` that runs past eighty characters in total length.
+
+What the lens found, and where.
+
+- [x] fix
+
+Fix it the simple way.
+
+# Dropped as noise
+
+## A finding the judge called noise
+
+Why the judge dropped it.
+
+- [ ] fix
+`,
+		validate: (content) => [...entryFindings(content), ...threadFindings(content)],
+		outline: findingsOutline,
+		actions: (content, range) => threadReplyActions(content, range.start),
+		view: findingsView,
+		annotate: findingsAnnotate,
+		apply: findingsApply,
+		clearTicks: (content) => content,
+		openThreads: openThreadsOf
+	}]
+]);
 [...REGISTRY.keys()];
 /** The built-in `SteeringFormat` registered under `mode`'s name, or `undefined` when it isn't a built-in mode at all. The one place a bare mode-name string is ever looked up — every consumer takes the RESOLVED value this returns, never a name, so "mode is required, never inferred from a file's basename" is a type, not a rule to remember. */
 const steeringFormatFor = (mode) => REGISTRY.get(mode);
@@ -32830,53 +33066,6 @@ const NoteSheet = ({ anchor, note, thread, onSave, onDismiss, onDone, busy, titl
 	});
 };
 //#endregion
-//#region src/web/notes.ts
-/** The thread with the human's saved reply applied the way the server applies it: appended to an open thread, replacing the last `H` entry of one waiting on the agent. Idempotent against a refetch that already carries the reply. */
-const withReply = (thread, text) => {
-	const entries = thread.waitingOn === "human" ? [...thread.entries, {
-		author: "me",
-		text
-	}] : [...thread.entries.slice(0, -1), {
-		author: "me",
-		text
-	}];
-	return {
-		...thread,
-		entries,
-		waitingOn: "agent"
-	};
-};
-const sameAnchor = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-/** Every node, its `body` blocks and its `children`, depth-first. */
-const flatten = (nodes) => nodes.flatMap((node) => [
-	node,
-	...flatten(node.body ?? []),
-	...flatten(node.children ?? [])
-]);
-const nodeAt = (nodes, anchor) => flatten(nodes).find((n) => sameAnchor(n.anchor, anchor));
-/**
-* The note text a sheet should open with. A `paragraph` anchor can name
-* either a top-level prose block OR a block riding in one of `body` (a
-* question's own body), so the lookup walks both — searching `nodes` alone
-* reopens a body block's note with an empty field, silently offering to
-* replace text the reader can still see behind the sheet.
-*
-* A thread opens EMPTY for a reply when the agent spoke last, and prefilled
-* with the last `H` entry when it waits on the agent (saving replaces it).
-*/
-const existingNoteFor = (nodes, anchor, overrides) => {
-	const node = nodeAt(nodes, anchor);
-	if (anchor.kind === "paragraph") {
-		const saved = overrides[anchor.line];
-		if (saved !== void 0) return saved;
-	}
-	if (node?.thread) {
-		if (node.thread.waitingOn === "human") return "";
-		return node.thread.entries.findLast((e) => e.author === "me")?.text ?? "";
-	}
-	return anchor.kind === "paragraph" ? node?.note : void 0;
-};
-//#endregion
 //#region node_modules/zustand/esm/vanilla.mjs
 const createStoreImpl = (createState) => {
 	let state;
@@ -33354,6 +33543,53 @@ const SaveIndicator = ({ refusal, saveStatus, expanded, failedCount, otherFailed
 	});
 };
 //#endregion
+//#region src/web/notes.ts
+/** The thread with the human's saved reply applied the way the server applies it: appended to an open thread, replacing the last `H` entry of one waiting on the agent. Idempotent against a refetch that already carries the reply. */
+const withReply = (thread, text) => {
+	const entries = thread.waitingOn === "human" ? [...thread.entries, {
+		author: "me",
+		text
+	}] : [...thread.entries.slice(0, -1), {
+		author: "me",
+		text
+	}];
+	return {
+		...thread,
+		entries,
+		waitingOn: "agent"
+	};
+};
+const sameAnchor = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/** Every node, its `body` blocks and its `children`, depth-first. */
+const flatten = (nodes) => nodes.flatMap((node) => [
+	node,
+	...flatten(node.body ?? []),
+	...flatten(node.children ?? [])
+]);
+const nodeAt = (nodes, anchor) => flatten(nodes).find((n) => sameAnchor(n.anchor, anchor));
+/**
+* The note text a sheet should open with. A `paragraph` anchor can name
+* either a top-level prose block OR a block riding in one of `body` (a
+* question's own body), so the lookup walks both — searching `nodes` alone
+* reopens a body block's note with an empty field, silently offering to
+* replace text the reader can still see behind the sheet.
+*
+* A thread opens EMPTY for a reply when the agent spoke last, and prefilled
+* with the last `H` entry when it waits on the agent (saving replaces it).
+*/
+const existingNoteFor = (nodes, anchor, overrides) => {
+	const node = nodeAt(nodes, anchor);
+	if (anchor.kind === "paragraph") {
+		const saved = overrides[anchor.line];
+		if (saved !== void 0) return saved;
+	}
+	if (node?.thread) {
+		if (node.thread.waitingOn === "human") return "";
+		return node.thread.entries.findLast((e) => e.author === "me")?.text ?? "";
+	}
+	return anchor.kind === "paragraph" ? node?.note : void 0;
+};
+//#endregion
 //#region src/web/screens/InlineRun.tsx
 /**
 * One projected `image`'s own rendering — its own component (not a case
@@ -33594,6 +33830,255 @@ const ProseBlocks = ({ nodes, noteOverrides, onOpenNote, readOnly }) => /* @__PU
 	}, node.anchor.kind === "paragraph" ? node.anchor.line : index))]
 });
 //#endregion
+//#region src/web/screens/Findings.tsx
+const MODE = "findings";
+const NOISE_GROUP = "Dropped as noise";
+const decisionOf = (node) => ({
+	fix: node.checked === true,
+	guidance: node.note ?? ""
+});
+const FindingRow = ({ node, index, decision, onToggle, onEditGuidance }) => {
+	const id = `finding-fix-${index}`;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", {
+		"data-testid": `finding-${index}`,
+		className: `border-b border-divider px-3 py-3 ${decision.fix ? "border-l-4 border-l-accent bg-surface" : ""}`,
+		children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", {
+				htmlFor: id,
+				className: "flex min-h-11 items-start gap-3",
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", {
+					id,
+					type: "checkbox",
+					"data-testid": `finding-checkbox-${index}`,
+					className: "mt-1 size-5 shrink-0",
+					checked: decision.fix,
+					onChange: (e) => onToggle(e.target.checked)
+				}), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", {
+					className: "min-w-0 flex-1",
+					children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+						className: "block font-medium",
+						children: node.title
+					}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+						className: "block text-small text-muted",
+						children: decision.fix ? "Fix" : "Drop"
+					})]
+				})]
+			}),
+			node.body !== void 0 && node.body.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+				className: "pl-8",
+				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ProseBlocks, {
+					nodes: node.body,
+					noteOverrides: {},
+					onOpenNote: () => {},
+					readOnly: true
+				})
+			}),
+			decision.fix && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+				className: "pl-8",
+				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button, {
+					variant: "ghost",
+					"data-testid": `finding-guidance-${index}`,
+					onClick: onEditGuidance,
+					"aria-label": decision.guidance === "" ? void 0 : `Edit guidance: ${decision.guidance}`,
+					className: "w-full px-0 text-left text-small font-normal text-muted",
+					children: decision.guidance !== "" ? decision.guidance : "Add guidance for the fixer (optional)"
+				})
+			})
+		]
+	});
+};
+const Group = ({ title, entries, render }) => entries.length === 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", {
+	"aria-label": title,
+	children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("h2", {
+		className: "m-0 px-3 pt-4 pb-1 text-small font-semibold text-muted uppercase",
+		children: title
+	}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", {
+		className: "m-0 list-none p-0",
+		children: entries.map(({ node, index }) => render(node, index))
+	})]
+});
+/** The finding gate: tick a finding to fix it, with optional guidance; unticked ones are dropped. */
+const FindingsView = ({ view, filePath, content, isLoading, readError, onDecide, onDone, busy }) => {
+	const overlay = useWriteStore((s) => s.overlay);
+	const save = useWriteStore((s) => s.save);
+	const [editing, setEditing] = (0, import_react.useState)(void 0);
+	if (view === void 0) {
+		const refusal = readError === void 0 ? void 0 : readRefusalFrom(readError);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Notice, {
+			tone: isLoading ? "info" : "error",
+			children: isLoading ? "Loading the findings…" : refusal !== void 0 ? messageForReadRefusal(refusal) : "Could not load the findings."
+		});
+	}
+	const decisionAt = (node) => overlay[cellKey(filePath, node.anchor, "decision")]?.value ?? decisionOf(node);
+	const decide = (node, next) => {
+		save({
+			cell: cellKey(filePath, node.anchor, "decision"),
+			optimistic: next,
+			write: onDecide?.(node.anchor, next.fix ? {
+				checked: true,
+				text: next.guidance
+			} : { checked: false })
+		}).catch(() => {});
+	};
+	const entries = view.nodes.map((node, index) => ({
+		node,
+		index
+	}));
+	const problems = content === void 0 ? [] : steeringFormatFor(MODE).validate(content);
+	const editingNode = editing === void 0 ? void 0 : view.nodes[editing];
+	const fixing = view.nodes.filter((n) => decisionAt(n).fix).length;
+	const row = (node, index) => {
+		const decision = decisionAt(node);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FindingRow, {
+			node,
+			index,
+			decision,
+			onToggle: (fix) => decide(node, {
+				fix,
+				guidance: fix ? decision.guidance : ""
+			}),
+			onEditGuidance: () => setEditing(index)
+		}, index);
+	};
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+		"data-testid": "findings-screen",
+		className: "flex h-full min-h-0 flex-1 flex-col",
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+			className: "min-h-0 flex-1 overflow-auto",
+			children: [
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+					className: "m-0 px-3 pt-3 text-small text-muted",
+					children: "Tick a finding to have it fixed; an unticked one is dropped. Anything bigger belongs in the final review."
+				}),
+				view.nodes.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Notice, {
+					"data-testid": "findings-empty",
+					children: "No findings to decide on."
+				}),
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Group, {
+					title: "Open",
+					entries: entries.filter(({ node }) => node.group !== NOISE_GROUP),
+					render: row
+				}),
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Group, {
+					title: NOISE_GROUP,
+					entries: entries.filter(({ node }) => node.group === NOISE_GROUP),
+					render: row
+				}),
+				problems.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Notice, {
+					tone: "error",
+					"data-testid": "findings-problems",
+					role: "status",
+					children: problems.map((p) => p.message).join(" ")
+				})
+			]
+		}), onDone !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+			className: "flex shrink-0 items-center justify-between gap-3 border-t border-border p-3",
+			children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+				"data-testid": "findings-summary",
+				className: "text-small text-muted",
+				children: `${fixing} to fix, ${view.nodes.length - fixing} to drop`
+			}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button, {
+				variant: "primary",
+				"data-testid": "findings-done",
+				onClick: () => {
+					save({
+						cell: cellKey(filePath, void 0, "done"),
+						optimistic: true,
+						mutate: onDone
+					}).catch(() => {});
+				},
+				disabled: busy === true || problems.length > 0,
+				children: "Done"
+			})]
+		})]
+	}), editingNode !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NoteSheet, {
+		anchor: editingNode.anchor,
+		title: "Guidance for the fixer",
+		label: "Guidance",
+		note: decisionAt(editingNode).guidance,
+		onSave: (_anchor, text) => {
+			setEditing(void 0);
+			decide(editingNode, {
+				fix: true,
+				guidance: text.trim()
+			});
+		},
+		onDismiss: () => setEditing(void 0)
+	})] });
+};
+const HandedBackPanel$3 = () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Notice, {
+	"data-testid": "handed-back-panel",
+	role: "status",
+	"aria-live": "polite",
+	children: "Handed back — this turn is done."
+});
+const FindingsInner = ({ filePath, data, isLoading, error }) => {
+	const indicatorProps = useSaveIndicatorProps();
+	const pending = useWriteStore((s) => s.pendingCount);
+	const [formatNotice, setFormatNotice] = (0, import_react.useState)(void 0);
+	const utils = trpc.useUtils();
+	const setValue = trpc.setValue.useMutation({ onSettled: () => utils.readSteeringFile.invalidate({
+		filePath,
+		mode: MODE
+	}) });
+	const done = trpc.done.useMutation();
+	const onDecide = (anchor, opts) => (cas) => setValue.mutateAsync({
+		filePath,
+		...cas,
+		mode: MODE,
+		anchor,
+		...opts
+	}).then((result) => {
+		setFormatNotice(result.formatNotice);
+		return result;
+	});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+		/* @__PURE__ */ (0, import_jsx_runtime.jsx)(SaveIndicator, { ...indicatorProps }),
+		/* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormatNoticeBanner, {
+			notice: formatNotice,
+			onDismiss: () => setFormatNotice(void 0)
+		}),
+		done.isSuccess ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HandedBackPanel$3, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FindingsView, {
+			view: data?.view,
+			content: data?.content,
+			filePath,
+			isLoading,
+			readError: error,
+			onDecide,
+			onDone: () => done.mutateAsync({}),
+			busy: pending > 0
+		})
+	] });
+};
+/** The finding gate's screen: reads `.gtd/QUALITY.md` as the `findings` format and writes each decision back. */
+const Findings = ({ filePath }) => {
+	const utils = trpc.useUtils();
+	const query = trpc.readSteeringFile.useQuery({
+		filePath,
+		mode: MODE
+	});
+	const refetchTokens = async () => {
+		const fresh = await utils.readSteeringFile.fetch({
+			filePath,
+			mode: MODE
+		});
+		return {
+			expectedHeadSha: fresh.headSha,
+			expectedContentHash: fresh.contentHash
+		};
+	};
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WriteStoreProvider, {
+		tokens: query.data,
+		refetchTokens,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FindingsInner, {
+			filePath,
+			data: query.data,
+			isLoading: query.isLoading,
+			error: query.error
+		})
+	});
+};
+//#endregion
 //#region src/web/screens/FreeForm.tsx
 /**
 * The empty-document save's own anchor line: `freeform.ts#freeFormApply`'s
@@ -35432,7 +35917,7 @@ const openable = (step) => step?.status === "ok" && step.file !== void 0;
 * and no route back to one. `trpc.step`'s own `mode` picks the screen —
 * `"review"` always means `Review` (that screen's own `readSteeringFile` call
 * is hardcoded to `mode: "review"`, matching `.gtd/REVIEW.md`'s one format);
-* `"qa"` means `Plan`; anything else (absent, or an unregistered mode name)
+* `"qa"` means `Plan`; `"findings"` means `Findings`; anything else (absent, or an unregistered mode name)
 * falls through to `FreeForm`, which reads the file as plain markdown and
 * offers only a note per block, plus a textfield when it's empty. Neither
 * screen offers a way back to a list — `done` is the only
@@ -35479,7 +35964,7 @@ const App = () => {
 		children: step.mode === "review" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Review, { filePath: step.file }) : step.mode === "qa" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Plan, {
 			filePath: step.file,
 			mode: "qa"
-		}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FreeForm, {
+		}) : step.mode === "findings" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Findings, { filePath: step.file }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FreeForm, {
 			filePath: step.file,
 			mode: step.mode
 		})