@pmelab/gtd 41.0.0 → 43.0.0

package/dist/web/main.js

@@ -29844,8 +29844,8 @@ const eolOf = (content) => content.includes("\r\n") ? "\r\n" : "\n";
 const PREFIX_RE = /^(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.exec(itemText(content, item));
+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));
 /** 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];
@@ -29865,7 +29865,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);
@@ -31565,8 +31565,6 @@ const qaDescriptor = {
 	unansweredQuestions,
 	openThreads: openThreadsOf
 };
-//#endregion
-//#region src/steering/review.ts
 /**
 * The canonical sample. Every detail here is load-bearing for the formatter
 * round-trip: both footnote bodies exceed 80 characters so a reflow actually
@@ -31833,16 +31831,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);
@@ -31853,7 +31877,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. */
@@ -31889,9 +31915,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) errors.push({
+		if (files.length === 0 && boxed) errors.push({
 			message: `Chunk "${title}" has no file pointers`,
 			line: headingLine,
 			range: nodeRange(heading)
@@ -31902,7 +31928,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" });
@@ -31983,7 +32010,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;

package/dist/workflow-kit.mjs

@@ -1,5 +1,5 @@
-import { changes, changesSince, hasThreadFor, head, read, refuse, requireReplies, requireThreadsClosed, scope } from "./flows.mjs";
-import { c as stripCodeThreads, d as reviewNotes, f as reviewRisks, y as parseThreads } from "./chunks/steering-DVILanVf.mjs";
+import { changes, changesSince, hasThreadFor, head, mark, read, refuse, requireReplies, requireThreadsClosed, scope } from "./flows.mjs";
+import { _ as unansweredNotes, c as stripCodeThreads, g as reviewRisks, h as reviewNotes, m as reviewDecisions, w as parseThreads } from "./chunks/steering-D4LUQ-av.mjs";
 //#region src/workflow-kit/health.ts
 /** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */
 const escalation = async (count, steps) => {
@@ -172,6 +172,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:
@@ -191,7 +198,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);
@@ -201,24 +208,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()), "reply");
 		collectedAt = head();
 		requireReplies(p.file);
-		if (!hasThreadFor("human", p.file)) return collectedAt;
+		if (!hasThreadFor("human", p.file) && unansweredNotes(read(p.file) ?? "", changesSince(reviewed).get(p.file)?.before).length === 0) 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();
+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 = (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(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);
@@ -228,7 +258,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", {
@@ -250,8 +279,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
@@ -265,9 +294,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"));
@@ -277,6 +306,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();
 	const since = changesSince(reviewed);
@@ -297,15 +331,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(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,
@@ -335,7 +371,7 @@ const review = async (base, p) => {
 		let reviewed = head();
 		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;

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { Dt as registryEntry, Ot as requireFlag, S as coder, St as envDefaults, Tt as flagReferences, i as skills, n as summary, o as flagShipped, r as access, t as steering, xt as defaults } from "../chunks/reserved-Ch4LLrEj.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-lY1UmJrU.mjs";
+import { Ct as envDefaults, Et as flagReferences, Ot as registryEntry, S as coder, St as defaults, i as skills, kt as requireFlag, n as summary, o as flagShipped, r as access, t as steering } from "../chunks/reserved-COEMFEpy.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-C_xn8U7U.mjs";
 //#region src/workflows/cleanup/cleanup.ts
 const removingPrompt = (name, registry) => `Clean up the release flag "${name}", which is default-on: delete its entry in ${registry}, and remove every \`GTD_FLAG_${name.toUpperCase()}\` check from the shipped sources. Keep the flag-on path; delete code only the off path reached, including tests that pin the off path.`;
 const cleanupFlow = async () => {

package/dist/workflows/feature.mjs

@@ -1,7 +1,7 @@
-import { agent, answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, numeric, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restoreScript, revertScript, run, scope, slice, start, vars, wrote } from "../flows.mjs";
-import { lensEntriesOf, review as review$1 } from "../workflow-kit.mjs";
-import { $ as naiveApplyFailure, A as agentWithSkills, B as coverageQuestion, C as fixCheck, Ct as testFileGlobs, D as reviewMissing, E as planner, F as buildReviewTriageMessage, G as designSystem, H as criterionLine, I as builderSystem, K as designTriagePrompt, L as clearCriteriaMessage, M as buildReviewAwaitAfterDeferMessage, N as buildReviewCollectingPrompt, P as buildReviewFixNitsPrompt, Q as implementFixPrompt, R as clearCriteriaQuestion, S as coder, St as envDefaults, T as fixRisks, U as deferNotesScript, V as coveringPrompt, W as designGateAnswerMessage, X as idleMessage, Z as implementBuildingPrompt, _ as REFACTOR_NOTE, _t as startGateBlockedMessage, a as flagModeOn, at as refactorDroppedRefusal, b as SLICES, bt as unwindFailure, ct as refactorRules, d as guarded, et as naivePassPrompt, f as healthy, ft as reviewNotesCapture, g as REFACTOR, gt as slicingPrompt, h as QUALITY, ht as seamSteerMessage, i as skills, it as refactorBuildingPrompt, j as buildReviewAnswerQuestionsPrompt, k as reviewing, lt as reviewEditNotesCapture, m as HANDOFF, mt as seamByHandMessage, n as summary, nt as oversizedMessage, ot as refactorFixPrompt, p as FEEDBACK, pt as reviewerSystem, r as access, rt as qualityUnresolvedMessage, s as shipped, st as refactorNotePrompt, t as steering, tt as normaliseCriteriaScript, u as gate, ut as reviewEditsCapture, v as REQUIREMENTS, vt as uncoveredMessage, x as awaitReview, xt as defaults, y as REVIEW, yt as unwindFailedMessage, z as coverageMessage } from "../chunks/reserved-Ch4LLrEj.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-lY1UmJrU.mjs";
+import { agent, answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, numeric, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restoreScript, revertScript, run, scope, showScript, slice, start, vars, writeScript, wrote } from "../flows.mjs";
+import { lensEntriesOf, removedAssertions, review as review$1 } from "../workflow-kit.mjs";
+import { $ as naivePassPrompt, A as agentWithSkills, B as coverageQuestion, C as fixCheck, Ct as envDefaults, D as reviewMissing, E as planner, F as builderSystem, G as designTriagePrompt, H as criterionLine, I as clearCriteriaMessage, L as clearCriteriaQuestion, M as buildReviewCollectingPrompt, N as buildReviewFixNitsPrompt, P as buildReviewTriageMessage, Q as naiveApplyFailure, R as composedReview, S as coder, St as defaults, T as fixRisks, U as designGateAnswerMessage, V as coveringPrompt, W as designSystem, X as implementBuildingPrompt, Y as idleMessage, Z as implementFixPrompt, _ as REFACTOR_NOTE, _t as slicingPrompt, a as flagModeOn, at as refactorBuildingPrompt, b as SLICES, bt as unwindFailedMessage, ct as refactorNotePrompt, d as guarded, dt as reviewEditsCapture, et as normaliseCriteriaScript, f as healthy, g as REFACTOR, gt as seamSteerMessage, h as QUALITY, ht as seamByHandMessage, i as skills, it as qualityUnresolvedMessage, j as buildReviewAnswerQuestionsPrompt, lt as refactorRules, m as HANDOFF, mt as reviewerSystem, n as summary, ot as refactorDroppedRefusal, p as FEEDBACK, pt as reviewNotesCapture, r as access, s as shipped, st as refactorFixPrompt, t as steering, tt as oversizedMessage, u as gate, ut as reviewEditNotesCapture, v as REQUIREMENTS, vt as startGateBlockedMessage, wt as testFileGlobs, x as awaitReview, xt as unwindFailure, y as REVIEW, yt as uncoveredMessage, z as coverageMessage } from "../chunks/reserved-COEMFEpy.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "../chunks/tail-C_xn8U7U.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
@@ -241,7 +241,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",
@@ -260,11 +260,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
 /**
@@ -305,6 +300,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"],
@@ -315,10 +317,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;
@@ -382,7 +381,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);
@@ -402,17 +401,33 @@ 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/");
 /**
-* A reviewer writes `.gtd/REVIEW.md` over everything since `base`, a human
-* reviews and 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.
+* 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;
+* 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, {
+	...report,
+	weakened: removedAssertions(changesSince(base)),
+	nitFix,
+	answered
+}), [QUALITY]) : showScript(carry, REVIEW, REVIEW), {
+	label: "Composing the review",
+	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 go to another planning lap, questions
+* are answered in place, nits fixed in one batch, praise dropped.
 */
 const review = (base, escalations = { rounds: 0 }, options = {}) => {
 	const { guard, guardRests, fixAccess, rules } = options;
@@ -422,14 +437,16 @@ const review = (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$1(base, {
 		file: REVIEW,
 		feedback: feedback.file,
 		isCode: isCode$1,
 		reviewing: (b, carry) => {
-			deferred = [];
-			return reviewing(b, carry, options.lap);
+			const fixedAt = nitFix;
+			nitFix = void 0;
+			return composing(b, options.report ?? NO_FINDINGS, carry, fixedAt, answered);
 		},
 		fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
 		keepGreen: () => healthy(() => fixCheck(rules), {
@@ -438,25 +455,16 @@ const review = (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());
-		},
+		decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
 		answerQuestions: answerReviewQuestions,
-		fixNits: guarded((notes) => fixNits(notes, fixAccess, rules), guard),
+		fixNits: async (notes) => {
+			await guarded((n) => fixNits(n, fixAccess, rules), guard)(notes);
+			nitFix = head();
+		},
 		close: closeReview,
 		captures: {
 			edits: reviewEditsCapture,
@@ -464,8 +472,9 @@ const review = (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,
@@ -483,7 +492,13 @@ function buildTail(first, second, ...rest) {
 	const options = callForm(first, second, rest);
 	if (options === void 0) return Promise.reject(/* @__PURE__ */ new Error("buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither"));
 	const [base, form] = options;
-	return tail((escalations) => review(base, escalations, form), form);
+	return tail((escalations, report) => review(base, escalations, {
+		...form,
+		report
+	}), {
+		...form,
+		triage: true
+	});
 }
 const isOptionalBoolean = (value) => value == null || typeof value === "boolean";
 const legacyForm = (fixFirst, base, green, options) => isOptionalBoolean(fixFirst) && isOptionalBoolean(green) && isOptionalObject(options) ? [base, {
@@ -818,8 +833,7 @@ const reviewedRefactor = async (shape, options = {}) => {
 				feedback,
 				fixAccess: strayAccess(p.strays),
 				lensBase: entry,
-				rules: refactorRules(p.strays, p.pattern),
-				lap: "refactor"
+				rules: refactorRules(p.strays, p.pattern)
 			});
 			if (outcome.verdict === "signoff") return true;
 			await reUnwind(outcome);
@@ -1430,13 +1444,11 @@ const settleQuality = async () => {
 	}
 	if (rested) await healthy(() => fixCheck());
 };
-/** The quality lap, then the human review since `base`. */
-const reviewedTail = (base, lensBase, lap) => tail(async (escalations) => {
-	await settleQuality();
-	return review(base, escalations, { lap });
-}, {
+/** The triaged quality lap, then the human review since `base`. */
+const reviewedTail = (base, lensBase) => tail((escalations, report) => review(base, escalations, { report }), {
 	green: true,
-	lensBase
+	lensBase,
+	triage: true
 });
 const featureFeedback = async (first, lensBase, ids) => {
 	let outcome = first;
@@ -1456,7 +1468,7 @@ const featureFeedback = async (first, lensBase, ids) => {
 			tier: riskTierOn() ? recordRisk() : void 0,
 			amend: true
 		});
-		outcome = await reviewedTail(outcome.base, lensBase, "feedback");
+		outcome = await reviewedTail(outcome.base, lensBase);
 	}
 };
 /** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
@@ -1474,10 +1486,7 @@ const afterTail = async (first) => {
 			tier: riskTierOn() ? recordRisk() : void 0,
 			amend: true
 		});
-		outcome = await buildTail(outcome.base, {
-			green: true,
-			lap: "feedback"
-		});
+		outcome = await buildTail(outcome.base, { green: true });
 	}
 };
 /** An ordinary start: wait at `idle`, unwind the sketch, check the baseline, then plan and build. */
@@ -1505,4 +1514,4 @@ const feature = shipped(ordinaryStart);
 //#region src/workflows/feature/index.ts
 var feature_default = feature;
 //#endregion
-export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, closeOut, collecting, criteriaOf, criterionIds, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, holdsCallSites, implement, implementing, isTestFile, judgeSeam, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, triage, unstableIds, unwind };
+export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, closeOut, collecting, criteriaOf, criterionIds, feature_default as default, defaults, design, envDefaults, feature, fixNits, holdsCallSites, implement, implementing, isTestFile, judgeSeam, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, triage, unstableIds, unwind };

package/dist/workflows/fix.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, scope, start } from "../flows.mjs";
-import { d as reviewNotes, f as reviewRisks } from "../chunks/steering-DVILanVf.mjs";
-import { A as agentWithSkills, J as fixReviewNotesPrompt, S as coder, St as envDefaults, c as baseline, i as skills, n as summary, q as finisherSystem, r as access, s as shipped, t as steering, xt as defaults, y as REVIEW } from "../chunks/reserved-Ch4LLrEj.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-lY1UmJrU.mjs";
+import { g as reviewRisks, h as reviewNotes } from "../chunks/steering-D4LUQ-av.mjs";
+import { A as agentWithSkills, Ct as envDefaults, K as finisherSystem, S as coder, St as defaults, c as baseline, i as skills, n as summary, q as fixReviewNotesPrompt, r as access, s as shipped, t as steering, y as REVIEW } from "../chunks/reserved-COEMFEpy.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-C_xn8U7U.mjs";
 //#region src/workflows/fix/fix.ts
 /**
 * Fix every note a human left in a handed-off `.gtd/REVIEW.md` and every

package/dist/workflows/review.mjs

@@ -1,6 +1,6 @@
 import { start } from "../flows.mjs";
-import { St as envDefaults, dt as reviewGateBlockedMessage, i as skills, n as summary, r as access, s as shipped, t as steering, u as gate, xt as defaults } from "../chunks/reserved-Ch4LLrEj.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-lY1UmJrU.mjs";
+import { Ct as envDefaults, St as defaults, ft as reviewGateBlockedMessage, i as skills, n as summary, r as access, s as shipped, t as steering, u as gate } from "../chunks/reserved-COEMFEpy.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-C_xn8U7U.mjs";
 //#region src/workflows/review/review.ts
 /**
 * Pure review of everything since `reviewBase`: a green gate, the quality

package/dist/workflows/rollout.mjs

@@ -1,5 +1,5 @@
 import { agent, changesSince, glob, head, mark, read, refuse, removeScript, run, scope, vars } from "../flows.mjs";
-import { Et as flipProblems, Ot as requireFlag, S as coder, St as envDefaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as flagMentions, xt as defaults } from "../chunks/reserved-Ch4LLrEj.mjs";
+import { Ct as envDefaults, Dt as flipProblems, S as coder, St as defaults, Tt as flagMentions, i as skills, kt as requireFlag, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate } from "../chunks/reserved-COEMFEpy.mjs";
 //#region src/workflows/rollout/rollout.ts
 const flippingPrompt = (name, registry) => `Roll out the release flag "${name}": in ${registry}, set \`defaultOn: true\` on its entry. Change nothing else — no other entry, no other field, no other file, no comments.`;
 const suiteBlockedMessage = () => "The suite is red after the rollout. Fix it by hand — a rollout may only touch the flag's registry entry — then land.";