@pmelab/gtd 55.0.0 → 57.0.0

package/dist/chunks/{review-BJGKwlYv.mjs → review-v7sh5GF4.mjs}

@@ -1,13 +1,12 @@
-import { answered, changesSince, head, judge, numeric, read, refuse, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
-import { b as sectionedReview, h as reviewChunks, m as REVIEW_SECTIONS, v as reviewRisks, y as reviewSections } from "./steering-CLhu8C7q.mjs";
-import { removedAssertions, review } from "../workflow-kit.mjs";
-import { A as reviewing, At as withWalkthrough, Bt as parseStandards, C as fixCheck, E as fixRisks, F as chunkTexts, Ft as conflictBody, Ht as standardKey, It as conflictFor, Lt as conflictTitle, N as buildReviewTriageMessage, O as reviewMissing, Ot as walkthroughBlock, Pt as STANDARDS, R as composedReview, Rt as isConflictTitle, S as collecting, Tt as unranked, Vt as renderStandards, _t as reviewNotesCapture, b as awaitReview, d as healthy, mt as reviewEditsCapture, pt as reviewEditNotesCapture, st as rankedReview, u as guarded, v as REVIEW, vt as reviewRankingMessage, w as fixNits, wt as titledNotes, y as answerReviewQuestions, zt as oneLine } from "./reserved-DHafcW7t.mjs";
-import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-B9Hw2AFB.mjs";
+import { answered, changesSince, head, judge, numeric, read, refuse, requireRevert, restoreScript, run, vars, writeScript } from "../flows.mjs";
+import { S as reviewSections, _ as REVIEW_SECTIONS, v as reviewChunks, x as reviewRisks } from "./steering-CCNvngSH.mjs";
+import { review } from "../workflow-kit.mjs";
+import { At as oneLine, C as collecting, D as fixRisks, Dt as conflictFor, Et as conflictBody, Mt as renderStandards, Nt as standardKey, Ot as conflictTitle, P as buildReviewTriageMessage, T as fixNits, Tt as STANDARDS, b as answerReviewQuestions, d as guarded, et as nitFixBlock, f as healthy, j as reviewing, jt as parseStandards, k as reviewMissing, kt as isConflictTitle, lt as reviewEditNotesCapture, pt as reviewNotesCapture, ut as reviewEditsCapture, w as fixCheck, x as awaitReview, xt as withSummary, y as REVIEW } from "./reserved-X2RkNHin.mjs";
+import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-S04KEewi.mjs";
 //#region src/workflows/shared/learn.ts
 const SUMMARY_MAX = 200;
-const BANNER = /^_(?:The fixer left this unresolved\.|A fix turn removed this while renaming another finding — check whether it was fixed\.|No detail given\.)_\s*/;
 const summary = (body) => {
-	const text = oneLine(body).replace(BANNER, "");
+	const text = oneLine(body);
 	return text.length > SUMMARY_MAX ? `${text.slice(0, SUMMARY_MAX - 1)}…` : text;
 };
 /** The standard a won't-fix or an own answer would make; a fix states none. */
@@ -276,139 +275,41 @@ const triage = (severities) => async (notes) => {
 		return [n.id, "edit"];
 	}));
 };
-/** Review order: security, one-way doors, the judge unsure, then should, then could. */
-const chunkKey = (s) => s.tier === "could" ? 4 : s.tier === "should" ? 3 : s.security === true ? 0 : s.rank === 0 ? 1 : 2;
-/** A chunk's text, then the code each of its pointers covers: a bare path the whole file. */
-const chunkEvidence = (text, files) => [text, ...files.map(({ path, line, rangeEnd }) => {
-	const where = `${path}${line === void 0 ? "" : `#${line}${rangeEnd === void 0 ? "" : `-${rangeEnd}`}`}`;
-	const lines = read(path.replace(/^\.\//, ""))?.split("\n");
-	if (lines === void 0) return `${where}: no longer exists`;
-	return `${where}:\n${(line === void 0 ? lines : lines.slice(line - 1, rangeEnd ?? line)).join("\n")}`;
-})].join("\n\n");
-const bytes = (text) => new TextEncoder().encode(text).length;
-/** Fills each batch while the budget's even share still holds its widest evidence, so nothing is cut that fits alone. */
-const batched = (items, budget) => {
-	const batches = [];
-	let batch = [];
-	let widest = 0;
-	for (const item of items) {
-		const size = bytes(item.evidence);
-		if (batch.length > 0 && Math.floor(budget / (batch.length + 1)) < Math.max(widest, size)) {
-			batches.push(batch);
-			batch = [];
-			widest = 0;
-		}
-		batch.push(item);
-		widest = Math.max(widest, size);
-	}
-	return batch.length === 0 ? batches : [...batches, batch];
-};
-/**
-* Rates every chunk the reviewer wrote and sorts the \`findings\` among them
-* first in \`full\`, each led by its tier and reason; a walkthrough chunk
-* keeps its place and carries no tier. It is still rated, so a review with no
-* findings still reaches \`review.ranking\` and older histories replay.
-*/
-const ranked = async (review, full, findings) => {
-	const texts = chunkTexts(full);
-	const chunks = reviewChunks(review).map((c, i) => ({
-		id: `C${i + 1}`,
-		title: c.title,
-		evidence: chunkEvidence(texts.get(c.title) ?? "", c.files)
-	}));
-	if (chunks.length === 0) return full;
-	const minP = numeric(vars.reviewSeverityMinP, Infinity);
-	const batches = batched(chunks, numeric(vars.judgeBudgetBytes, 32768));
-	const severities = /* @__PURE__ */ new Map();
-	for (const [i, batch] of batches.entries()) {
-		const judgment = await judge("review.ranking", {
-			questions: batch.flatMap((c) => severityQuestions(c.id, `the change review chunk "${c.id}" ("${c.title}") walks through`, `the change in review chunk "${c.id}"`)),
-			evidence: Object.fromEntries(batch.map((c) => [c.id, c.evidence])),
-			message: reviewRankingMessage(),
-			label: batches.length === 1 ? "Ranking the review" : `Ranking the review (${i + 1}/${batches.length})`
-		});
-		for (const c of batch) severities.set(c.id, severityOf(c, judgment, minP));
-	}
-	return rankedReview(full, chunks.map((c, i) => ({
-		c,
-		i,
-		s: severities.get(c.id)
-	})).filter(({ c }) => findings.has(c.title)).sort((x, y) => chunkKey(x.s) - chunkKey(y.s) || x.i - y.i).map(({ c, s }) => ({
-		title: c.title,
-		label: s.reason
-	})));
-};
 const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
-const composedOf = (base, report, nitFix, answered) => ({
-	...report,
-	nitFix,
-	answered,
-	standards: {
-		added: standardsAddedSince(base),
-		undecided: parseStandards(read(".gtd/STANDARDS.md") ?? "").undecided
-	}
-});
-/**
-* gtd writes `.gtd/REVIEW.md` from the quality lap's `report` — no reviewer
-* turn. A re-review
-* after fixed nits restores the doc as committed at `carry`, answers kept;
-* a fresh one leaves out the notes the human already answered.
-*/
-const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new Set()) => run("review.composing", carry === void 0 ? writeScript(REVIEW, composedReview(base, {
-	...composedOf(base, report, nitFix, answered),
-	weakened: removedAssertions(changesSince(base))
-})) : showScript(carry, REVIEW, REVIEW), {
-	label: "Composing the review",
-	file: REVIEW,
-	base
-});
-/**
-* Refuses a review with a chunk pointing at no code, or a lap note without a
-* chunk of its own. A range with no code change has nothing to point at, so
-* there only a note's chunk needs a pointer.
-*/
-const requirePointers = (review, notes, codeChanged) => {
+/** Refuses a review with a chunk pointing at no code; a range with no code change has nothing to point at. */
+const requirePointers = (review, codeChanged) => {
 	const chunks = reviewChunks(review);
-	const titles = new Set(chunks.map((c) => c.title));
-	const noted = new Set(notes.map((n) => n.title));
 	const problems = [
-		...chunks.filter((c) => c.pointers === 0 && (codeChanged || noted.has(c.title))).map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — points at no code`),
+		...chunks.filter((c) => c.pointers === 0 && codeChanged).map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — points at no code`),
 		...chunks.filter((c) => isConflictTitle(c.title)).map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — gtd writes conflicts; leave it out`),
-		...notes.filter((n) => !titles.has(n.title)).map((n) => `  - ${n.title} — no chunk of its own`),
 		...chunks.filter((c, i) => chunks.findIndex((d) => d.title === c.title) !== i).map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — a second chunk with this title`),
-		...reviewSections(review).map((s) => `  - ${REVIEW}:${s.line + 1}: ${REVIEW_SECTIONS[s.section]} — gtd sorts the chunks into sections; write \`## \` chunks only`),
-		...reviewRisks(review).filter((r) => [...noted].some((title) => r.anchor.startsWith(`${title} ./`))).map((r) => `  - ${r.anchor} — no \`Risk:\` in a quality finding's chunk`)
+		...reviewSections(review).map((s) => `  - ${REVIEW}:${s.line + 1}: ${REVIEW_SECTIONS[s.section]} — write \`## \` chunks only`)
 	];
 	if (problems.length === 0) return;
-	refuse(`gtd land: review-pointers: ${problems.length} problem(s) in ${REVIEW} — every chunk needs a pointer to its code, and every quality finding its own chunk, headed exactly as the prompt gave it:\n${problems.join("\n")}`);
+	refuse(`gtd land: review-pointers: ${problems.length} problem(s) in ${REVIEW} — every chunk needs a pointer to its code:\n${problems.join("\n")}`);
 };
 /**
 * A reviewer walks the human through everything since `base`, every chunk
-* pointing at its code and each of the lap's notes a chunk of its own; gtd
-* then adds each note's text and answer boxes, and the summary chunks.
+* pointing at its code; gtd then appends the summary chunks.
 */
-const walkthrough = async (base, report, lap, carry, afterRiskFix) => {
-	const notes = titledNotes(report);
-	await reviewing(base, carry, lap, walkthroughBlock(notes, report.nitFix));
+const walkthrough = async (base, summary, lap, carry, nitFix, afterRiskFix) => {
+	await reviewing(base, carry, lap, nitFixBlock(nitFix));
 	const written = read(REVIEW);
 	if (written === void 0) return;
-	const review = unranked(written);
-	requirePointers(written, notes, changesSince(base).some((c) => isCode(c.path)));
+	requirePointers(written, changesSince(base).some((c) => isCode(c.path)));
 	if (!afterRiskFix && reviewRisks(written).length > 0) return;
-	const full = sectionedReview(await ranked(review, withWalkthrough(review, report), new Set(notes.map((n) => n.title))), new Set(reviewChunks(review).map((c) => c.title)));
+	const full = withSummary(written, summary);
 	if (full !== written) await run("review.carrying", writeScript(REVIEW, full), {
-		label: "Ordering the review and adding the quality lap's findings",
+		label: "Adding the quality lap's summary",
 		file: REVIEW,
 		base
 	});
 };
 /**
-* The quality lap's notes reach a human over everything since `base`, who
-* answers each one — fix as suggested, won't fix, or their own answer — and
-* may comment. A fix joins the nit batch, a won't-fix is dropped, and an own
-* answer or comment is judged: edits end the review as `feedback` for the
-* caller to build, questions are answered in place, nits fixed in one batch,
-* praise dropped.
+* A reviewer's walkthrough of everything since `base` reaches a human, who
+* may comment: each note is judged — edits end the review as `feedback` for
+* the caller to build, questions are answered in place, nits fixed in one
+* batch, praise dropped.
 */
 const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 	const { guard, guardRests, fixAccess, rules } = options;
@@ -419,7 +320,6 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 	};
 	const severities = /* @__PURE__ */ new Map();
 	let nitFix;
-	const answered = /* @__PURE__ */ new Set();
 	let riskFixed = false;
 	return review(base, {
 		file: REVIEW,
@@ -429,8 +329,14 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 			const fixedAt = nitFix;
 			const afterRiskFix = riskFixed;
 			riskFixed = false;
-			const report = options.report ?? NO_FINDINGS;
-			return options.walkthrough === true ? guarded(() => walkthrough(b, composedOf(b, report, fixedAt, answered), options.lap ?? "first", carry, afterRiskFix), guard)() : composing(b, report, carry, fixedAt, answered);
+			const summary = {
+				report: options.report ?? NO_FINDINGS,
+				standards: {
+					added: standardsAddedSince(b),
+					undecided: parseStandards(read(".gtd/STANDARDS.md") ?? "").undecided
+				}
+			};
+			return guarded(() => walkthrough(b, summary, options.lap ?? "first", carry, fixedAt, afterRiskFix), guard)();
 		},
 		fixRisks: guarded((notes) => {
 			riskFixed = true;
@@ -449,7 +355,6 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 		reviewMissing,
 		collecting: feedback.collecting,
 		triage: triage(severities),
-		decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
 		settles: settlesStandard,
 		learn: learnStandards,
 		pending: standardsPending,
@@ -519,4 +424,4 @@ const reUnwind = async (feedback) => {
 	requireRevert(edited, base);
 };
 //#endregion
-export { reUnwind as i, humanReview as n, isCode as r, buildTail as t };
+export { isCode as n, reUnwind as r, buildTail as t };

package/dist/chunks/{steering-CLhu8C7q.mjs → steering-CCNvngSH.mjs}

@@ -9415,7 +9415,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 || []]),
@@ -9730,7 +9730,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.
@@ -13347,7 +13347,7 @@ const eolOf = (content) => content.includes("\r\n") ? "\r\n" : "\n";
 //#endregion
 //#region src/steering/Threads.ts
 const PREFIX_RE$1 = /^(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$1.exec(itemText$1(content, item));
@@ -13361,9 +13361,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);
@@ -13379,7 +13379,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
 	};
 };
@@ -13388,16 +13388,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"
@@ -16208,62 +16208,249 @@ const reviewSections = (content) => splitChunks(parseMarkdown(content), content)
 	section: s.section,
 	line: s.headingLine
 }));
-const isBlankLine = (line) => line !== void 0 && line.trim() === "";
-/** How many lines a chunk's heading takes: two for a setext heading and its underline. */
-const headingSize = ({ heading, headingLine }) => toLspPosition(heading.position.end).line - headingLine + 1;
-/** \`block\` with its heading an ATX \`### \` on one line, and every heading in its body one level deeper. */
-const demoted = (chunk, block) => {
-	const out = [...block];
-	for (const node of chunk.body) {
-		if (node.type !== "heading" || node.depth < 3 || node.depth > 5) continue;
-		const at = toLspPosition(node.position.start).line - chunk.headingLine;
-		out[at] = out[at].replace(/^( {0,3})#/, "$1##");
-	}
-	const size = headingSize(chunk);
-	return [size > 1 ? `### ${out[0].trim()}` : out[0].replace(/^ {0,3}##/, "###"), ...out.slice(size)];
+//#endregion
+//#region src/steering/findings.ts
+/** The `# ` heading the findings a judge called noise sit under. */
+const NOISE_HEADING = "Dropped as noise";
+/** The label of the one box under each finding. */
+const FIX_BOX = "fix";
+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);
 };
-/** A chunk's \`size\` heading lines, then its body with the blank lines around it trimmed. */
-const chunkText = (block, size) => {
-	const rest = block.slice(size);
-	while (rest.length > 0 && isBlankLine(rest[0])) rest.shift();
-	while (rest.length > 0 && isBlankLine(rest.at(-1))) rest.pop();
-	const heading = block.slice(0, size).join("\n");
-	return rest.length === 0 ? heading : `${heading}\n\n${rest.join("\n")}`;
+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();
 };
-/**
-* A flat review regrouped: every chunk with answer boxes under `## Findings`
-* and every chunk titled in `walkthrough` under `## Walkthrough`, each in its
-* current order and one heading level deeper. Any other chunk stays a `## ` of
-* its own, before the sections when it came before them, after otherwise. An
-* already sectioned review comes back unchanged.
-*/
-const sectionedReview = (content, walkthrough) => {
+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 { chunks, sections } = splitChunks(tree, content);
-	if (sections.length > 0 || chunks.length === 0) return content;
-	const { changesets } = parseReviewDoc(content);
-	const lines = content.split("\n");
-	const sectionOfChunk = (i) => changesets[i].answers !== void 0 ? "findings" : walkthrough.has(changesets[i].title) ? "walkthrough" : void 0;
-	const text = (i, demote) => {
-		const chunk = chunks[i];
-		const block = lines.slice(chunk.headingLine, chunks[i + 1]?.headingLine ?? lines.length);
-		return chunkText(demote ? demoted(chunk, block) : block, demote ? 1 : headingSize(chunk));
+	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;
 	};
-	const grouped = chunks.map((_, i) => sectionOfChunk(i));
-	const first = grouped.findIndex((g) => g !== void 0);
-	if (first === -1) return content;
-	const others = (keep) => chunks.flatMap((_, i) => grouped[i] === void 0 && keep(i) ? [text(i, false)] : []);
-	const section = (s) => {
-		const members = chunks.flatMap((_, i) => grouped[i] === s ? [text(i, true)] : []);
-		return members.length === 0 ? [] : [`## ${REVIEW_SECTIONS[s]}`, ...members];
+	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;
+};
+/** Every `## ` finding in a finding-gate file, in file order. */
+const findingEntries = (content) => parse(content).map(({ title, body, noise, fix, guidance, boxes, headingLine }) => ({
+	title,
+	body,
+	noise,
+	fix,
+	guidance,
+	boxes,
+	headingLine
+}));
+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
+		}]
 	};
-	return `${[
-		lines.slice(0, chunks[0].headingLine).join("\n").trim(),
-		...others((i) => i < first),
-		...section("findings"),
-		...section("walkthrough"),
-		...others((i) => i > first)
-	].filter((p) => p !== "").join("\n\n")}\n`;
+};
+/** The finding gate's file: one `## ` finding each, with one `fix` box and optional guidance below it. */
+const findingsDescriptor = {
+	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
 };
 //#endregion
 //#region src/steering/Edits.ts
@@ -16595,8 +16782,12 @@ const stripCodeThreads = (path, 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", findingsDescriptor]
+]);
 /** Every built-in format name, in registry order. */
 const BUILT_IN_MODE_NAMES = [...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. */
@@ -16633,4 +16824,4 @@ const viewOf = (format, content) => ({
 /** Every OPEN thread — last entry is the agent's — as `{ name, line, firstMe }` (0-based line). `[]` for a format with no thread concept. */
 const openThreads = (format, content) => format.openThreads?.(content) ?? [];
 //#endregion
-export { parseThreadsWithFindings as A, FREE_TEXT_PLACEHOLDER as C, openThreadFindings as D, THREAD_REPLY_ACTION_TITLE as E, headingSectionBodies as M, headingSections as N, parseFootnotes as O, formatFinding as P, unansweredNotes as S, FOOTNOTE_ACTION_TITLE as T, reviewNotes as _, unansweredQuestions as a, sectionedReview as b, stripCodeThreads as c, ANSWER_FIX as d, ANSWER_LEAD as f, reviewDecisions as g, reviewChunks as h, steeringFormatOrFreeForm as i, getParseCount as j, parseThreads as k, freeFormFormat as l, REVIEW_SECTIONS as m, openThreads as n, viewOf as o, ANSWER_WONT_FIX as p, steeringFormatFor as r, parseCodeThreads as s, BUILT_IN_MODE_NAMES as t, applySteeringEdits as u, reviewRisks as v, isAnswered as w, severityLine as x, reviewSections as y };
+export { parseThreads as A, unansweredNotes as C, THREAD_REPLY_ACTION_TITLE as D, FOOTNOTE_ACTION_TITLE as E, formatFinding as F, getParseCount as M, headingSectionBodies as N, openThreadFindings as O, headingSections as P, reviewSections as S, isAnswered as T, REVIEW_SECTIONS as _, unansweredQuestions as a, reviewNotes as b, stripCodeThreads as c, FIX_BOX as d, NOISE_HEADING as f, ANSWER_WONT_FIX as g, ANSWER_LEAD as h, steeringFormatOrFreeForm as i, parseThreadsWithFindings as j, parseFootnotes as k, freeFormFormat as l, ANSWER_FIX as m, openThreads as n, viewOf as o, findingEntries as p, steeringFormatFor as r, parseCodeThreads as s, BUILT_IN_MODE_NAMES as t, applySteeringEdits as u, reviewChunks as v, FREE_TEXT_PLACEHOLDER as w, reviewRisks as x, reviewDecisions as y };