@pmelab/gtd 42.0.0 → 43.0.0

package/dist/workflows.mjs

@@ -13931,8 +13931,8 @@ const eolOf = (content) => content.includes("\r\n") ? "\r\n" : "\n";
 const PREFIX_RE$1 = /^(H|A):\s*/;
 const lineOf = (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 = (content, item) => item.children.map((child) => sourceText(content, child)).join(" ").trim();
-const prefixOf = (content, item) => PREFIX_RE$1.exec(itemText(content, item));
+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));
 /** A thread is a definition whose body OPENS with a list whose first item carries a prefix — anything else stays a one-shot footnote. */
 const isThreadBody = (content, children) => {
 	const first = children[0];
@@ -13952,7 +13952,7 @@ const entryOf = (content, item, previous, report) => {
 		return;
 	}
 	const author = match[1] === "H" ? "me" : "agent";
-	const text = itemText(content, item).slice(match[0].length).trim();
+	const text = itemText$1(content, item).slice(match[0].length).trim();
 	if (text === "") report(`empty "${match[1]}:" entry — write your own words there`, start, end);
 	if (previous === void 0 && author === "agent") report(`the agent never starts a thread — the first entry must be "H:"`, start, end);
 	else if (previous === author) report(`two consecutive "${match[1]}:" entries — entries must alternate`, start, end);
@@ -15654,6 +15654,9 @@ const qaDescriptor = {
 };
 //#endregion
 //#region src/steering/review.ts
+const ANSWER_LEAD = "Tick exactly one:";
+const ANSWER_FIX = "fix as suggested";
+const ANSWER_WONT_FIX = "won't fix";
 /**
 * The canonical sample. Every detail here is load-bearing for the formatter
 * round-trip: both footnote bodies exceed 80 characters so a reflow actually
@@ -15920,16 +15923,42 @@ const parseHunk = (content, lines, title, item) => {
 		errors: [hunkSecondPointerFinding(content, lines, item, token, sourceLine, title, file), hunkLineWithoutRangeFinding(content, item, token, sourceLine, title, file)].filter((e) => e !== void 0)
 	};
 };
+const itemText = (content, item) => item.children.map((c) => sourceText(content, c)).join(" ").replace(/^\[[ xX]\]\s*/, "").trim();
+/**
+* The task list right after the `Tick exactly one:` paragraph, with that
+* paragraph's index. Read by position, never by label, so an edited label or
+* a free text opening with `./path` is still an answer, not a pointer. Any
+* count but three boxes is kept, and reads as unanswered.
+*/
+const answerListOf = (content, body) => {
+	const lead = body.findIndex((n, i) => n.type === "paragraph" && sourceText(content, n) === "Tick exactly one:" && body[i + 1]?.type === "list" && body[i + 1].children.every((item) => item.checked != null));
+	if (lead === -1) return void 0;
+	const list = body[lead + 1];
+	const last = list.children.length - 1;
+	return {
+		lead,
+		list,
+		options: list.children.map((item, i) => {
+			const text = itemText(content, item);
+			return {
+				checked: item.checked === true,
+				text: i === last && text.toLowerCase() === "_your answer_".toLowerCase() ? "" : text
+			};
+		})
+	};
+};
 /** Splits one chunk's body nodes into its file pointers (hunk pointers are task items, collected recursively at ANY nesting depth via `taskItems` — a nested hunk is the same kind of hunk as a top-level one) and description prose. The description is the chunk's own leading run and never a node that contains a hunk pointer: it stops at the first node whose `taskItems` include a real pointer (at any depth — a blockquote wrapping a pointer list stops it just as a top-level list would). Every node kind in what's left before that point contributes — a `footnoteDefinition` is the one exception, excluded by `blockNodesOfRun` itself (it's a note, never document content). */
 const parseChunkBody = (content, lines, title, body) => {
-	const firstPointerIndex = body.findIndex((n) => taskItems(n).some((item) => hasPointerToken(content, item)));
-	const leadingRun = firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex);
+	const answer = answerListOf(content, body);
+	const isAnswer = (n) => answer !== void 0 && (n === answer.list || n === body[answer.lead]);
+	const firstPointerIndex = body.findIndex((n) => !isAnswer(n) && taskItems(n).some((item) => hasPointerToken(content, item)));
+	const leadingRun = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter((n) => !isAnswer(n));
 	const descriptionNodes = blockNodesOfRun(content, leadingRun);
 	const descriptionInline = collapseImages(blockRunInline(content, leadingRun));
 	const description = leadingRun.filter((n) => n.type !== "footnoteDefinition").map((n) => sourceText(content, n)).join(" ").trim();
 	const files = [];
 	const errors = [];
-	for (const item of body.flatMap((n) => taskItems(n))) {
+	for (const item of body.filter((n) => !isAnswer(n)).flatMap((n) => taskItems(n))) {
 		const parsed = parseHunk(content, lines, title, item);
 		if (!parsed) continue;
 		files.push(parsed.file);
@@ -15940,7 +15969,9 @@ const parseChunkBody = (content, lines, title, body) => {
 		descriptionNodes,
 		descriptionInline,
 		files,
-		errors
+		errors,
+		...answer === void 0 ? {} : { answers: answer.options },
+		boxed: body.some((n) => !isAnswer(n) && taskItems(n).length > 0)
 	};
 };
 /** Splits the tree's top-level nodes into consecutive `##` chunk blocks — a `## ` line found only inside a fence never becomes a heading node at all, so it's never mistaken for a chunk. */
@@ -15976,9 +16007,9 @@ const parseChangesets = (tree, content, lines) => {
 	const errors = [];
 	for (const { heading, headingLine, body } of splitChunks(tree)) {
 		const title = headingText$1(content, heading);
-		const { description, descriptionNodes, descriptionInline, files, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
+		const { description, descriptionNodes, descriptionInline, files, answers, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
 		errors.push(...bodyErrors);
-		if (files.length === 0 && body.some((n) => taskItems(n).length > 0)) errors.push({
+		if (files.length === 0 && boxed) errors.push({
 			message: `Chunk "${title}" has no file pointers`,
 			line: headingLine,
 			range: nodeRange(heading)
@@ -15989,7 +16020,8 @@ const parseChangesets = (tree, content, lines) => {
 			descriptionNodes,
 			descriptionInline,
 			files,
-			headingLine
+			headingLine,
+			...answers === void 0 ? {} : { answers }
 		});
 	}
 	if (changesets.length === 0) errors.push({ message: "REVIEW.md has no '##' chunks" });
@@ -16070,7 +16102,9 @@ const isHunkPointerItem = (content, item) => {
 * clear, so a caller can skip the write and leave the mtime untouched.
 */
 const reviewClearTicks = (content) => {
-	const offsets = taskItems(parseMarkdown(content)).filter((item) => item.checked === true && isHunkPointerItem(content, item)).map((item) => checkboxOffset(content, item)).filter((o) => o !== void 0).sort((a, b) => a - b);
+	const tree = parseMarkdown(content);
+	const answers = new Set(splitChunks(tree).flatMap(({ body }) => answerListOf(content, body)?.list.children ?? []));
+	const offsets = taskItems(tree).filter((item) => item.checked === true && !answers.has(item) && isHunkPointerItem(content, item)).map((item) => checkboxOffset(content, item)).filter((o) => o !== void 0).sort((a, b) => a - b);
 	if (offsets.length === 0) return content;
 	let result = "";
 	let cursor = 0;
@@ -16504,6 +16538,55 @@ const reviewRisks = (content) => parseReviewDoc(content).changesets.flatMap((chu
 	id: `risk-${i + 1}`,
 	...r
 }));
+const CHOICES = [
+	"fix",
+	"wontfix",
+	"answer"
+];
+const decisionOf = (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;
+	const i = ticked[0];
+	const text = i === 2 ? chunk.answers[2].text : "";
+	if (i === 2 && text === "") return void 0;
+	return {
+		anchor: chunk.title,
+		body: chunk.description,
+		choice: CHOICES[i],
+		text
+	};
+};
+/**
+* Notes whose answer boxes do not hold exactly one tick (a ticked free-text
+* slot filled in), with their 1-based heading line and why; and, given the
+* file `before` the edit, every note whose boxes were deleted.
+*/
+const unansweredNotes = (content, before) => {
+	const now = parseReviewDoc(content).changesets;
+	const boxed = new Set(now.filter((c) => c.answers !== void 0).map((c) => c.title));
+	const removed = (before === void 0 ? [] : parseReviewDoc(before).changesets).filter((c) => c.answers !== void 0 && !boxed.has(c.title)).map((c) => ({
+		title: c.title,
+		line: 0,
+		reason: "its answer boxes were deleted — restore them"
+	}));
+	return [...now.filter((c) => c.answers !== void 0 && decisionOf(c) === void 0).map((c) => ({
+		title: c.title,
+		line: c.headingLine + 1,
+		reason: c.answers.length === 3 ? "tick exactly one box" : `it has ${c.answers.length} boxes — restore the three gtd wrote`
+	})), ...removed];
+};
+/** Every answer in `after` that `before` did not already hold for the same note, in document order. */
+const reviewDecisions = (before, after) => {
+	const prior = new Map(parseReviewDoc(before).changesets.map((c) => [c.title, c]));
+	return parseReviewDoc(after).changesets.flatMap((chunk) => {
+		const decision = decisionOf(chunk);
+		if (decision === void 0) return [];
+		const was = prior.get(chunk.title);
+		const old = was === void 0 ? void 0 : decisionOf(was);
+		return old?.choice === decision.choice && old.text === decision.text ? [] : [decision];
+	});
+};
 //#endregion
 //#region src/steering/CodeThreads.ts
 const TOKENS = [
@@ -16635,6 +16718,13 @@ const collect = async (p, capture, round, requested) => {
 	}
 	return refuse(p.refusals.unmatched);
 };
+/** Refuse while a note's answer boxes hold anything but exactly one tick, or a note's boxes were deleted. */
+const requireDecisions = (file, reviewed) => {
+	const open = unansweredNotes(read(file) ?? "", changesSince(reviewed).get(file)?.before);
+	if (open.length === 0) return;
+	const list = open.map((n) => `  - ${file}${n.line > 0 ? `:${n.line}` : ""}: ${n.title} — ${n.reason}`).join("\n");
+	refuse(`gtd land: answer-completeness: ${open.length} note(s) in ${file} not answered — tick exactly one box per note: fix as suggested, won't fix, or your own answer written over _your answer_:\n${list}`);
+};
 const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 /**
 * A review with ticks and THREAD footnotes (definition plus markers) removed:
@@ -16654,7 +16744,7 @@ const notesOf = (text) => {
 * commit of the last collecting turn, `"missing"` when the round left no
 * review, or `undefined` when no such turn ran.
 */
-const converse = async (p, base, collectedBefore) => {
+const converse = async (p, base, reviewed, collectedBefore) => {
 	let collectedAt = collectedBefore;
 	for (;;) {
 		await p.awaitReview(base);
@@ -16664,24 +16754,47 @@ const converse = async (p, base, collectedBefore) => {
 			return "missing";
 		}
 		requireThreadsClosed(p.file);
-		if (!hasThreadFor("agent", p.file)) return collectedAt;
+		if (!hasThreadFor("agent", p.file)) {
+			requireDecisions(p.file, reviewed);
+			return collectedAt;
+		}
 		await p.collecting(p.captures.edits(head$1()), "reply");
 		collectedAt = head$1();
 		requireReplies(p.file);
-		if (!hasThreadFor("human", p.file)) return collectedAt;
-	}
-};
-/** Judge every note, then run each verdict's route: answers, then nit fixes, then deferrals, then the edits' lap. */
-const routeNotes = async (p, notes, r) => {
-	const verdicts = await p.triage(notes);
-	const of = (v) => notes.filter((n) => (verdicts.get(n.id) ?? "edit") === v);
-	const [edits, questions, nits, deferred] = [
-		of("edit"),
-		of("question"),
-		of("nit"),
-		of("defer")
-	];
-	if (edits.length + questions.length + nits.length + deferred.length === 0) return r.unfolded();
+		if (!hasThreadFor("human", p.file) && unansweredNotes(read(p.file) ?? "", changesSince(reviewed).get(p.file)?.before).length === 0) return collectedAt;
+	}
+};
+const decisionNote = (d, id, text) => ({
+	id,
+	kind: "chunk",
+	anchor: d.anchor,
+	before: d.body,
+	text,
+	forced: /^!(\s|$)/.test(text)
+});
+/** One `Gtd-Mark` value per line: a control character would make mark() throw on every replay. */
+const oneLine = (text) => text.replace(/[\s\x00-\x1f\x7f-\x9f\u2028\u2029]+/g, " ").trim() || "untitled";
+/** Tell the policy, and mark each won't-fix on the gate's commit. */
+const record$2 = (p, decisions) => {
+	p.decided?.(decisions);
+	for (const d of decisions) if (d.choice === "wontfix") mark("wontfix", oneLine(d.anchor));
+};
+/**
+* Judge every note, then run each verdict's route: answers, then nit fixes,
+* then the edits' lap. Of the human's `decisions`, a fix joins the nit batch
+* unjudged, an own answer is judged like a note, and a won't-fix is dropped
+* with a `Gtd-Mark` on the gate's commit.
+*/
+const routeNotes = async (p, notes, r, decisions = []) => {
+	record$2(p, decisions);
+	const of = (c) => decisions.filter((d) => d.choice === c);
+	const fixes = of("fix").map((d, i) => decisionNote(d, `fix-${i + 1}`, d.body));
+	const judged = [...notes, ...of("answer").map((d, i) => decisionNote(d, `answer-${i + 1}`, d.text))];
+	const verdicts = judged.length === 0 ? /* @__PURE__ */ new Map() : await p.triage(judged);
+	const ofVerdict = (v) => judged.filter((n) => (verdicts.get(n.id) ?? "edit") === v);
+	const [edits, questions] = [ofVerdict("edit"), ofVerdict("question")];
+	const nits = [...ofVerdict("nit"), ...fixes];
+	if (edits.length + questions.length + nits.length === 0) return r.unfolded();
 	let answeredAt;
 	if (questions.length > 0) {
 		await p.answerQuestions(questions);
@@ -16691,7 +16804,6 @@ const routeNotes = async (p, notes, r) => {
 		await p.fixNits(nits);
 		await p.keepGreen();
 	}
-	if (deferred.length > 0) await p.defer(deferred);
 	if (edits.length > 0) {
 		await r.close();
 		return r.outcome(await collect(p, p.captures.editNotes(r.round, edits, answeredAt), "triaged", {
@@ -16713,8 +16825,8 @@ const routeNotes = async (p, notes, r) => {
 };
 /** A code edit, not a thread-only change: lines that only add, answer or remove code threads don't count. */
 const isCodeEdit = (p, c) => p.isCode(c.path) && stripCodeThreads(c.path, c.before ?? "") !== stripCodeThreads(c.path, c.after ?? "");
-/** Whether anything but thread edits and ticks landed in the review file since `commit`. */
-const notedSince = (p, commit) => changesSince(commit).some((c) => c.path === p.file && notesOf(c.before ?? "") !== notesOf(read(p.file) ?? ""));
+/** Whether a note or an answer, not just thread edits and pointer ticks, landed in the review file since `commit`. */
+const notedSince = (p, commit) => changesSince(commit).some((c) => c.path === p.file && (notesOf(c.before ?? "") !== notesOf(read(p.file) ?? "") || reviewDecisions(c.before ?? "", read(p.file) ?? "").length > 0));
 /**
 * What the in-loop collecting turn left: `folded` when it wrote `feedback`
 * (those folds need their lap whatever is judged later), `settled` when only
@@ -16728,9 +16840,9 @@ const settledAfter = (p, collectedAt) => ({
 	folded: collectedAt !== void 0 && read(p.feedback) !== void 0,
 	settled: collectedAt !== void 0 && changesSince(collectedAt).every((c) => !isCodeEdit(p, c)) && !notedSince(p, collectedAt)
 });
-const finishNotes = async (p, before, reopened, ctx) => {
-	const notes = reviewNotes(before, read(p.file) ?? "");
-	if (notes.length > 0) return routeNotes(p, notes, ctx);
+const finishNotes = async (p, before, decisions, reopened, ctx) => {
+	const notes = reviewNotes(before ?? "", read(p.file) ?? "");
+	if (notes.length + decisions.length > 0) return routeNotes(p, notes, ctx, decisions);
 	if (reopened) return ctx.unfolded();
 	await ctx.close();
 	return ctx.outcome(await collect(p, p.captures.notes(ctx.round), "notes"));
@@ -16740,6 +16852,11 @@ const toOutcome = (verdict, rest) => verdict === "signoff" ? { verdict } : {
 	...rest
 };
 const isReopened = (p, r) => r.settled && !r.folded && p.refusals.dropped !== void 0;
+/** A carried answer is unchanged, never routed twice; one ticked beside a thread still routes once the thread has settled. */
+const decisionsSince = (p, since) => {
+	const after = read(p.file) ?? "";
+	return reviewDecisions(since.get(p.file)?.before ?? after, after);
+};
 const finish = async (p, reviewed, collectedAt) => {
 	const round = head$1();
 	const since = changesSince(reviewed);
@@ -16760,15 +16877,17 @@ const finish = async (p, reviewed, collectedAt) => {
 		settled,
 		folded
 	});
-	if (settled && !reopened || edited.length === 0 && !noted) return unfolded();
+	const decisions = decisionsSince(p, since);
+	if (settled && !reopened && decisions.length === 0 || edited.length === 0 && !noted) return unfolded();
 	if (edited.length > 0) {
+		record$2(p, decisions);
 		await close();
 		return outcome(await collect(p, p.captures.edits(round, reopened ? reviewed : void 0), "edits", {
 			notes: [],
 			paths: edited.map((c) => c.path)
 		}));
 	}
-	return finishNotes(p, since.get(p.file)?.before ?? "", reopened, {
+	return finishNotes(p, since.get(p.file)?.before, decisions, reopened, {
 		round,
 		close,
 		outcome,
@@ -16798,7 +16917,7 @@ const review$2 = async (base, p) => {
 		let reviewed = head$1();
 		let collectedAt;
 		for (;;) {
-			collectedAt = await converse(p, base, collectedAt);
+			collectedAt = await converse(p, base, reviewed, collectedAt);
 			if (collectedAt === "missing") break;
 			const result = await finish(p, reviewed, collectedAt);
 			if (!("next" in result)) return result;
@@ -17278,9 +17397,9 @@ const SUMMARY_TITLES = [
 const unboxed = (body) => body.replace(/^(\s*(?:>\s*)*(?:[-*+]|\d+[.)])\s+)\[[ xX]\]\s?/gm, "$1");
 const short = (hash) => hash.slice(0, 7);
 /**
-* \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, then the fixed and
-* noise lists, with no tick boxes. Chunk titles are made unique — notes are
-* matched to their chunk by title.
+* \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, each ending in its
+* answer boxes, then the fixed and noise lists. Chunk titles are made unique —
+* notes and answers are matched to their chunk by title.
 */
 const composedReview = (base, report) => {
 	const used = new Set(SUMMARY_TITLES);
@@ -17291,11 +17410,16 @@ const composedReview = (base, report) => {
 		return name;
 	};
 	const chunk = (title, body) => `## ${title}\n\n${body.trim()}`;
+	const answerBoxes = `${ANSWER_LEAD}\n\n- [ ] ${ANSWER_FIX}\n- [ ] ${ANSWER_WONT_FIX}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`;
+	const notes = report.notes.map((n) => ({
+		...n,
+		title: unique(n.title)
+	})).filter((n) => report.answered?.has(n.title) !== true);
 	const weakened = (report.weakened ?? []).flatMap(({ path, lines }) => lines.map((a) => `- ${path} — ${a.scenario} — ${a.line}`));
 	const chunks = [
-		...report.nitFix === void 0 ? [] : [chunk("Fixed from your notes", `Your nits were fixed in ${short(report.nitFix)}; the list below is from before.`)],
+		...report.nitFix === void 0 ? [] : [chunk("Fixed from your notes", `Your nits and fix-as-suggested notes were worked on in ${short(report.nitFix)}; the notes you answered are left out — check the diff.`)],
 		...weakened.length === 0 ? [] : [chunk("Weakened scenarios", `These scenarios lost an assertion the review base had:\n\n${weakened.join("\n")}`)],
-		...report.notes.map((n) => chunk(unique(n.title), n.unresolved === true ? `_The fixer left this unresolved._\n\n${unboxed(n.body)}` : n.unclear === true ? `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${unboxed(n.body)}` : unboxed(n.body) || "_No detail given._")),
+		...notes.map((n) => chunk(n.title, `${n.unresolved === true ? `_The fixer left this unresolved._\n\n${unboxed(n.body)}` : n.unclear === true ? `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${unboxed(n.body)}` : unboxed(n.body) || "_No detail given._"}\n\n${answerBoxes}`)),
 		...report.fixed.length === 0 ? [] : [chunk("Fixed automatically", report.fixed.map((f) => `- ${f.title} (${short(f.commit)})`).join("\n"))],
 		...report.noise.length === 0 ? [] : [chunk("Dropped as noise", report.noise.map((f) => `- ${f.title} (p=${f.p})`).join("\n"))]
 	];
@@ -17378,10 +17502,6 @@ ${stateFileRules}
 ${footnoteFoldIn}${codeThreadReplies()}
 - The only state file this turn touches is \`.gtd/REQUIREMENTS.md\`
   — no other files for notes or output
-- Lines of a \`## Deferred review notes\` section of \`.gtd/TODO.md\`
-  that the start diff does not touch are parked by review, never folded;
-  the human's edits to such a line (or its removal) are input like any
-  other part of the start diff
 - \`.gtd/TODO.md\` is the likely home of the sketch that started
   this process — the human's input, folded into the concerns
   below like any other part of the start diff; never a state
@@ -17674,8 +17794,12 @@ const buildReviewAwaitReviewMessage = (base) => `\`.gtd/REVIEW.md\` holds what t
 per finding that needs your judgement — it questions a criterion or the
 approach, or the fixer could not resolve it — then, for reference only, what
 was **fixed automatically** (with the fixing commit) and what was **dropped
-as noise**. Nothing there needs an answer; disagreeing with a fix or a drop
-means writing a note of your own.
+as noise**. Each finding chunk ends in three boxes — tick exactly one:
+\`fix as suggested\` (fixed in the nit batch below), \`won't fix\` (dropped,
+recorded in the commit), or write your own answer over \`_your answer_\` and
+tick it (judged like a note). Every landing here is refused until each
+finding holds exactly one tick. The fixed and noise lists need no answer;
+disagreeing with a fix or a drop means writing a note of your own.
 
 Review the diff yourself, with whatever tool you like — gtd checks
 nothing out and touches no ref; \`gtd base\` prints this same hash any
@@ -17685,8 +17809,8 @@ working tree:
     git diff ${base}
 When you've been through the whole diff, run \`gtd land\`:
 
-- **Sign off** — leave no comment — no note in
-  \`.gtd/REVIEW.md\`, no code edit — to close the process.
+- **Sign off** — answer every finding, leave no other comment — no note
+  in \`.gtd/REVIEW.md\`, no code edit — to close the process.
   Every turn commit stays on the
   branch; run \`gtd summary\` afterward for a closing-message
   prompt.
@@ -17833,27 +17957,6 @@ const wrapItem = (item) => {
 	} else line = line === "" ? word : `${line} ${word}`;
 	return [...out, line];
 };
-/** Appends one section of `notes` to `.gtd/TODO.md`, wrapped the way oxfmt writes it; an existing file is only ever appended to. */
-const deferNotesScript = (notes, round) => {
-	return `mkdir -p .gtd
-if [ -s .gtd/TODO.md ]; then
-  [ -z "$(tail -c1 .gtd/TODO.md)" ] || printf '\\n' >> .gtd/TODO.md
-  printf '\\n' >> .gtd/TODO.md
-fi
-printf '%s\\n' ${[
-		`## Deferred review notes (${round.slice(0, 7)})`,
-		"",
-		...notes.flatMap((n) => wrapItem(`- ${noteHead(n)}: ${n.text.replace(/\s+/g, " ")}`))
-	].map(quote).join(" ")} >> .gtd/TODO.md
-`;
-};
-/** The gate right after a deferral: landing clean signs off without these notes. */
-const buildReviewAwaitAfterDeferMessage = (base, deferred) => `${buildReviewAwaitReviewMessage(base)}
-Deferred to \`.gtd/TODO.md\` just now, NOT acted on in this process — landing
-clean signs off without them:
-
-${deferred.map((n) => `- ${noteHead(n)}: ${n.text.replace(/\s*\n\s*/g, " ")}`).join("\n")}
-`;
 const buildReviewTriageMessage = () => `Judging each note the human added to \`.gtd/REVIEW.md\` (a line note, a
 footnote, or prose under a chunk) with one verdict: \`edit\` (a change
 request), \`question\`, \`nit\` (a small fix needing no re-plan) or
@@ -17863,16 +17966,18 @@ default; a skipped judgment never dismisses a note).
 
 Also judge each note's severity, one id per note: \`note-<n>.security\`,
 \`note-<n>.reversibility\`, \`note-<n>.blastRadius\` and
-\`note-<n>.newConcept\`.
+\`note-<n>.newConcept\`. An own answer under a finding's boxes is judged
+the same way, keyed \`answer-<n>\`.
 `;
 const closedFold = (round, target) => round === "edits" ? `- Fold every hand-edit and every note the human left that round into
-  \`${target}\`
+  \`${target}\` — a note ticked \`fix as suggested\` or answered in its
+  own words included; one ticked \`won't fix\` is dropped
 ` : round === "notes" ? `- Fold each note that asks for a change into \`${target}\`
 ` : `- Fold each \`edit\` note the capture lists, no other note, and every
   hand-edit, into \`${target}\`
 `;
 /** `refactor` retargets the prompt at `.gtd/REFACTOR.md` and fences it to the strays. A concern outside the fence is not folded; if nothing at all is written the landing is refused, but a partly buildable round drops the rest silently. */
-const buildReviewCollectingPrompt = (capture, refactor) => {
+const buildReviewCollectingPrompt = (capture, refactor, round) => {
 	const target = refactor ? ".gtd/REFACTOR.md" : ".gtd/REQUIREMENTS.md";
 	const fence = refactor ? `- The next refactor may change only these paths, plus an existing test
   file's call sites, and never a flag read:
@@ -17947,12 +18052,16 @@ ${refactor ? refactor.round === "reply" ? `- This turn replies inside \`.gtd/REV
 ${closedFold(refactor.round, target)}` : `- This turn writes \`${target}\` (the folded concerns) and
   replies inside \`.gtd/REVIEW.md\` (thread replies only; the file stays
   in the tree) — you classify, you do not build
-- Fold every concluded thread, ticked answer and hand-edit — and each
-  \`edit\` note the capture lists, no other note — into
-  \`${target}\` and delete the folded threads from
-  \`.gtd/REVIEW.md\`; append one \`- A:\` reply to each thread
-  whose last entry is a \`- H:\` question
-`}- When the capture names an answering commit, carry each answered
+- Fold every concluded thread and hand-edit — and each \`edit\` note
+  the capture lists, no other note — into \`${target}\` and
+  delete the folded threads from \`.gtd/REVIEW.md\`; append one \`- A:\`
+  reply to each thread whose last entry is a \`- H:\` question
+${round === "edits" ? `- A hand-edit round routes no answer box itself: fold each note
+  ticked \`fix as suggested\` or answered in its own words, too; drop one
+  ticked \`won't fix\`
+` : `- Never fold a note's ticked answer box the capture does not list: gtd
+  routes those itself
+`}`}- When the capture names an answering commit, carry each answered
   question into \`${target}\`'s \`## Answered Questions\` as
   \`### <the note>\` plus its answer — the lap replaces \`.gtd/REVIEW.md\`
 - Keep capture order, and carry each note's \`(tier: reason)\`
@@ -38437,7 +38546,7 @@ const fixNits = (notes, access, rules) => {
 	}, () => fixing("fixing"));
 };
 /** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
-const collecting = (capture) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture), {
+const collecting = (capture, round) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture, void 0, round), {
 	label: "Collecting your feedback",
 	file: REQUIREMENTS,
 	mode: "qa",
@@ -38456,11 +38565,6 @@ const refactorCollecting = (capture, round, strays) => agentWithSkills("review.c
 	system: reviewerSystem(),
 	allowEmpty: true
 });
-/** `build.review.defer`: append `notes` to `.gtd/TODO.md` as one section; the step's landing is the commit. */
-const deferNotes = (notes, round) => run("review.defer", deferNotesScript(notes, round), {
-	label: "Deferring could-notes to TODO.md",
-	file: ".gtd/TODO.md"
-});
 //#endregion
 //#region src/workflows/feature/planning.ts
 /**
@@ -38501,6 +38605,13 @@ const verdictQuestion = (note) => ({
 	instructions: `Classify the human's note on review item "${note.anchor}" (in .gtd/REVIEW.md). Its evidence holds the anchor, the reviewer's text and the human's text.`,
 	criteria: "edit: a request to change behaviour, design or scope — anything needing a plan, or any note you are unsure about. question: asks something and wants an answer, with no change requested. nit: a small, local, unambiguous fix (naming, typo, formatting, comment wording) needing no re-plan. praise: an approving remark with nothing to do."
 });
+const TIER_ORDER = {
+	critical: 0,
+	should: 1,
+	could: 2
+};
+/** Capture order: critical, should, could; within a tier one-way doors, then new concepts. */
+const captureKey = (s) => s === void 0 ? 2 : TIER_ORDER[s.tier] * 3 + s.rank;
 const SEVERITY_ANSWERS = {
 	security: ["yes", "no"],
 	reversibility: ["one-way", "two-way"],
@@ -38511,10 +38622,7 @@ const SEVERITY_ANSWERS = {
 	],
 	newConcept: ["yes", "no"]
 };
-/**
-* Deferring is the risky direction: anything unanswered, unrecognised, cut or
-* below `minP` is `critical`, never `could`.
-*/
+/** Anything unanswered, unrecognised, cut or below `minP` is `critical`, never `could`. */
 const severityOf = (note, judgment, minP) => {
 	const ans = (q) => judgment.answers[`${note.id}.${q}`];
 	const a = (q) => ans(q)?.answer;
@@ -38578,7 +38686,7 @@ const severityQuestions = (note) => [
 * nothing) plus four severity answers. Dismissing a note is the risky
 * direction, so only a confident non-`edit` verdict on uncut evidence counts;
 * a cut, unanswered or below-floor note is an `edit`. Severity answers on a
-* non-`edit` note are ignored. A confident `could` edit becomes `defer`.
+* non-`edit` note are ignored; on an `edit` they order the collecting turn.
 */
 const triage$1 = (severities) => async (notes) => {
 	const asked = notes.filter((n) => !n.forced);
@@ -38598,21 +38706,22 @@ const triage$1 = (severities) => async (notes) => {
 	return new Map(notes.map((n) => {
 		const verdict = n.forced ? void 0 : VERDICTS.find((v) => v !== "edit" && answered(answers[n.id], v, minP));
 		if (verdict !== void 0 && !truncated.includes(n.id)) return [n.id, verdict];
-		const severity = severityOf(n, judgment, severityMinP);
-		severities.set(n.id, severity);
-		return [n.id, severity.tier === "could" ? "defer" : "edit"];
+		severities.set(n.id, severityOf(n, judgment, severityMinP));
+		return [n.id, "edit"];
 	}));
 };
 const isCode$1 = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
 /**
 * gtd writes `.gtd/REVIEW.md` from the quality lap's `report` — no reviewer
 * turn — and removes what the fixer left in `.gtd/QUALITY.md`. A re-review
-* after fixed nits restores the doc as committed at `carry`, answers kept.
+* 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) => run("review.composing", carry === void 0 ? writeScript(REVIEW, composedReview(base, {
+const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new Set()) => run("review.composing", carry === void 0 ? writeScript(REVIEW, composedReview(base, {
 	...report,
 	weakened: removedAssertions(changesSince(base)),
-	nitFix
+	nitFix,
+	answered
 }), [QUALITY]) : showScript(carry, REVIEW, REVIEW), {
 	label: "Composing the review",
 	file: REVIEW,
@@ -38620,9 +38729,10 @@ const composing = (base, report, carry, nitFix) => run("review.composing", carry
 });
 /**
 * The quality lap's notes reach a human over everything since `base`, who
-* signs off or comments, and each note is judged: edits go to another
-* planning lap, questions are answered in place, nits fixed in one batch,
-* praise dropped.
+* 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 go to another planning lap, questions
+* are answered in place, nits fixed in one batch, praise dropped.
 */
 const review$1 = (base, escalations = { rounds: 0 }, options = {}) => {
 	const { guard, guardRests, fixAccess, rules } = options;
@@ -38632,17 +38742,16 @@ const review$1 = (base, escalations = { rounds: 0 }, options = {}) => {
 		unmatched: "gtd land: no declared pattern matches the pending changes — write .gtd/REQUIREMENTS.md from the feedback, or change nothing when it asks for nothing"
 	};
 	const severities = /* @__PURE__ */ new Map();
-	let deferred = [];
 	let nitFix;
+	const answered = /* @__PURE__ */ new Set();
 	return review$2(base, {
 		file: REVIEW,
 		feedback: feedback.file,
 		isCode: isCode$1,
 		reviewing: (b, carry) => {
-			deferred = [];
 			const fixedAt = nitFix;
 			nitFix = void 0;
-			return composing(b, options.report ?? NO_FINDINGS, carry, fixedAt);
+			return composing(b, options.report ?? NO_FINDINGS, carry, fixedAt, answered);
 		},
 		fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
 		keepGreen: () => healthy(() => fixCheck(rules), {
@@ -38651,23 +38760,11 @@ const review$1 = (base, escalations = { rounds: 0 }, options = {}) => {
 			guardRests,
 			rules
 		}),
-		awaitReview: (b) => {
-			const notes = deferred;
-			deferred = [];
-			return notes.length > 0 ? awaitReview(b, buildReviewAwaitAfterDeferMessage(b, notes)) : awaitReview(b);
-		},
+		awaitReview: (b) => awaitReview(b),
 		reviewMissing,
 		collecting: feedback.collecting,
 		triage: triage$1(severities),
-		defer: (notes) => {
-			deferred = notes.map((n) => ({
-				id: n.id,
-				anchor: n.anchor,
-				text: n.text,
-				label: severities.get(n.id).reason
-			}));
-			return deferNotes(deferred, head$1());
-		},
+		decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
 		answerQuestions: answerReviewQuestions,
 		fixNits: async (notes) => {
 			await guarded((n) => fixNits(n, fixAccess, rules), guard)(notes);
@@ -38680,8 +38777,9 @@ const review$1 = (base, escalations = { rounds: 0 }, options = {}) => {
 			editNotes: (round, edits, answeredAt) => reviewEditNotesCapture(round, edits.map((n, i) => ({
 				n,
 				i,
-				s: severities.get(n.id)
-			})).sort((x, y) => Number(x.s?.tier === "should") - Number(y.s?.tier === "should") || (x.s?.rank ?? 2) - (y.s?.rank ?? 2) || x.i - y.i).map(({ n, s }) => ({
+				s: severities.get(n.id),
+				key: captureKey(severities.get(n.id))
+			})).sort((x, y) => x.key - y.key || x.i - y.i).map(({ n, s }) => ({
 				id: n.id,
 				anchor: n.anchor,
 				text: n.forced ? n.text.replace(/^!\s*/, "") : n.text,
@@ -39749,11 +39847,9 @@ const skills = (vars) => {
 const access = (vars) => ({
 	design: { write: [] },
 	"build.review": { write: [".gtd/REVIEW.md"] },
-	"build.review.defer": { write: [".gtd/TODO.md"] },
 	"build.review.fix.nits": {},
 	"build.review.fix.risks": {},
 	"refactor.build.review": { write: [".gtd/REVIEW.md"] },
-	"refactor.build.review.defer": { write: [".gtd/TODO.md"] },
 	...lensScopes("build.quality", lensesOf(vars.qualityReviews ?? ""), () => ({ write: [] })),
 	...lensScopes("refactor.build.quality", lensesOf(vars.refactorQualityReviews ?? ""), () => ({ write: [] }))
 });
@@ -39900,4 +39996,4 @@ var workflows_default = feature;
 */
 const doors = {};
 //#endregion
-export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, HANDOFF, QUALITY, REFACTOR, REFACTOR_NOTE, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, SLICES, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeOut, closeReview, coder, collecting, criteriaOf, criterionIds, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, implementing, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, recheck, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, tail, threads, triage, unstableIds, unwind };
+export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, HANDOFF, QUALITY, REFACTOR, REFACTOR_NOTE, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, SLICES, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeOut, closeReview, coder, collecting, criteriaOf, criterionIds, workflows_default as default, defaults, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, implementing, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, recheck, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, tail, threads, triage, unstableIds, unwind };