@pmelab/gtd 24.3.0 → 25.0.0

package/dist/workflows.mjs

@@ -1,4 +1,3 @@
-import { dirname } from "node:path";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -217,6 +216,13 @@ const removeScript = (paths) => [
 	...removal(paths),
 	""
 ].join("\n");
+/** Write `path` as committed at `ref` to `to`. */
+const showScript = (ref, path, to) => [
+	"#!/usr/bin/env sh",
+	"set -e",
+	`git show ${quote(`${ref}:${path}`)} > ${quote(to)}`,
+	""
+].join("\n");
 //#endregion
 //#region src/flows/helpers.ts
 /** Whether a judge answered `expected` at a probability of at least `minP`. */
@@ -323,13 +329,6 @@ const escalation$1 = async (count, steps) => {
 	await steps.describe();
 	await steps.stop();
 };
-/** Run `check` again while `pending()` holds — a run then does not count — and resolve the first run that does. */
-const untilSettled = async (check, pending) => {
-	for (;;) {
-		const green = await check();
-		if (!pending()) return green;
-	}
-};
 const STAMP = /\n<!-- gtd check [0-9a-f]+ -->\n?$/;
 const stripStamp = (text) => text.replace(STAMP, "\n");
 /**
@@ -382,102 +381,59 @@ const fixFindings = async (f) => {
 };
 //#endregion
 //#region src/workflow-kit/scenarios.ts
-const DOC_STRING = /^(\s*)("""|```)/;
-/**
-* Gherkin wording only: lines trimmed; blank, `#` comment and `@` tag lines
-* dropped — except inside a doc string, whose content is test input: kept
-* whole, indented relative to its opening delimiter (as Gherkin reads it).
-*/
-const scenarioText = (source) => {
+const DOC_STRING = /^("""|```)/;
+const THEN = /^Then\s/;
+const CONTINUATION = /^(And|But|\*)\s/;
+const HEADING = /^(Feature|Rule|Background|Scenario|Scenario Outline|Scenario Template|Example):/;
+/** Trimmed lines outside doc strings, whose content is test input, not steps. */
+const stepLines = (source) => {
 	const out = [];
-	let doc;
-	for (const line of source.split("\n")) {
-		const delimiter = DOC_STRING.exec(line);
-		if (doc === void 0 && delimiter !== null) {
-			doc = {
-				indent: delimiter[1].length,
-				fence: delimiter[2]
-			};
-			out.push(line.trim());
-		} else if (doc !== void 0 && line.trim().startsWith(doc.fence)) {
-			doc = void 0;
-			out.push(line.trim());
-		} else if (doc !== void 0) {
-			const lead = line.length - line.trimStart().length;
-			out.push(line.slice(Math.min(lead, doc.indent)).trimEnd());
-		} else {
-			const trimmed = line.trim();
-			if (trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("@")) out.push(trimmed);
-		}
+	let fence;
+	for (const trimmed of source.split("\n").map((l) => l.trim())) {
+		const opening = fence === void 0 ? DOC_STRING.exec(trimmed)?.[1] : void 0;
+		if (opening !== void 0) fence = opening;
+		else if (fence === void 0) out.push(trimmed);
+		else if (trimmed.startsWith(fence)) fence = void 0;
 	}
-	return out.join("\n");
-};
-const textOf = (path) => {
-	const source = read(path);
-	return source === void 0 ? void 0 : scenarioText(source);
-};
-/** Snapshot `.feature` paths at `head()`, merged over `previous`; `undefined` when nothing is frozen. */
-const freezeScenarios = (paths, previous) => {
-	if (paths.length === 0) return previous;
-	const texts = { ...previous?.texts };
-	for (const path of paths) {
-		const text = textOf(path);
-		if (text !== void 0) texts[path] = text;
-	}
-	return Object.keys(texts).length === 0 ? previous : {
-		at: head$1(),
-		texts
-	};
+	return out;
 };
-/** Paths whose wording differs from the snapshot (a deleted file counts). */
-const driftedScenarios = (frozen) => Object.entries(frozen.texts).filter(([path, text]) => textOf(path) !== text).map(([path]) => path);
-const lines = (text) => text === void 0 || text === "" ? [] : text.split("\n");
-/** `table[i][j]`: the longest common subsequence of `a[i..]` and `b[j..]`. */
-const lcsTable = (a, b) => {
-	const table = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
-	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
-	return table;
-};
-/** Changed lines in file order, `- ` / `+ `-prefixed, so a moved or repeated step still shows. */
-const lineDiff = (a, b) => {
-	const table = lcsTable(a, b);
+const neutral = (line) => line === "" || line.startsWith("#") || line.startsWith("|");
+/** Trimmed `Then` step lines, an `And`/`But`/`*` continuing one included; doc strings skipped. */
+const assertionLines = (source) => {
 	const out = [];
-	let i = 0;
-	let j = 0;
-	while (i < a.length && j < b.length) if (a[i] === b[j]) {
-		i++;
-		j++;
-	} else if (table[i + 1][j] >= table[i][j + 1]) out.push(`- ${a[i++]}`);
-	else out.push(`+ ${b[j++]}`);
-	return [
-		...out,
-		...a.slice(i).map((l) => `- ${l}`),
-		...b.slice(j).map((l) => `+ ${l}`)
-	];
+	let inThen = false;
+	let scenario = "";
+	for (const line of stepLines(source)) {
+		if (HEADING.test(line)) scenario = line;
+		if (THEN.test(line)) inThen = true;
+		else if (!CONTINUATION.test(line) && !neutral(line)) inThen = false;
+		if (inThen && !neutral(line)) out.push({
+			scenario,
+			line
+		});
+	}
+	return out;
 };
-const wordingDrift = (frozen, path) => ({
-	path,
-	lines: lineDiff(lines(frozen.texts[path]), lines(textOf(path)))
-});
+const key = (a) => `${a.scenario}\n${a.line}`;
 /**
-* After a turn: rest at `stop` while wording drifted from `frozen`. Whatever
-* still differs after it is accepted and moves the snapshot; what was
-* restored stays frozen as it was.
+* Assertions a `.feature` file that existed before `changes` lost — the one
+* way rewording a scenario can weaken it. Matched within each scenario and
+* counted, so a line moving to another scenario, or one of two identical
+* `Then`s dropped, still shows. A renamed scenario reports all of its own.
 */
-const holdWording$1 = async (frozen, stop) => {
-	if (frozen === void 0) return;
-	const drifted = driftedScenarios(frozen);
-	if (drifted.length === 0) return;
-	await stop(frozen.at, drifted.map((path) => wordingDrift(frozen, path)));
-	const accepted = driftedScenarios(frozen);
-	if (accepted.length === 0) return;
-	for (const path of accepted) {
-		const text = textOf(path);
-		if (text === void 0) delete frozen.texts[path];
-		else frozen.texts[path] = text;
-	}
-	frozen.at = head$1();
-};
+const removedAssertions = (changes) => changes.filter((c) => c.path.endsWith(".feature") && c.before !== void 0).map((c) => {
+	const left = /* @__PURE__ */ new Map();
+	for (const a of assertionLines(c.after ?? "")) left.set(key(a), (left.get(key(a)) ?? 0) + 1);
+	const lines = assertionLines(c.before ?? "").filter((a) => {
+		const n = left.get(key(a)) ?? 0;
+		left.set(key(a), n - 1);
+		return n <= 0;
+	});
+	return {
+		path: c.path,
+		lines
+	};
+}).filter((r) => r.lines.length > 0);
 //#endregion
 //#region node_modules/mdast-util-to-string/lib/index.js
 /**
@@ -16360,10 +16316,13 @@ const reviewNotes = (before, after) => {
 	return [...parseReviewDoc(after).changesets.flatMap((chunk) => {
 		const prior = oldChunks.get(chunk.title);
 		return [...chunkNote(chunk, prior), ...pointerNotes(chunk, prior)];
-	}), ...footnoteNotes(before, after)].sort((a, b) => a.line - b.line).map((f, i) => ({
-		id: `note-${i + 1}`,
-		...f.note
-	}));
+	}), ...footnoteNotes(before, after)].sort((a, b) => a.line - b.line).map((f, i) => {
+		return {
+			id: `note-${i + 1}`,
+			...f.note,
+			forced: /^!(\s|$)/.test(f.note.text)
+		};
+	});
 };
 /** Pointer notes the reviewer opened with `Risk:`, in document order — the ones the workflow fixes before the human gate. */
 const reviewRisks = (content) => parseReviewDoc(content).changesets.flatMap((chunk) => chunk.files.flatMap((file) => file.note?.startsWith("Risk:") ? [{
@@ -16526,16 +16485,17 @@ const converse = async (p, base, collectedBefore) => {
 		if (!hasThreadFor("human", p.file)) return collectedAt;
 	}
 };
-/** Judge every note, then run each verdict's route: answers, then nit fixes, then the edits' lap. */
+/** 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] = [
+	const [edits, questions, nits, deferred] = [
 		of("edit"),
 		of("question"),
-		of("nit")
+		of("nit"),
+		of("defer")
 	];
-	if (edits.length + questions.length + nits.length === 0) return r.unfolded();
+	if (edits.length + questions.length + nits.length + deferred.length === 0) return r.unfolded();
 	let answeredAt;
 	if (questions.length > 0) {
 		await p.answerQuestions(questions);
@@ -16545,6 +16505,7 @@ 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)));
@@ -16558,7 +16519,7 @@ const routeNotes = async (p, notes, r) => {
 	}
 	return {
 		next: "await",
-		reviewed: answeredAt
+		reviewed: answeredAt ?? r.round
 	};
 };
 /** A code edit, not a thread-only change: lines that only add, answer or remove code threads don't count. */
@@ -16987,6 +16948,10 @@ ${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
@@ -17130,7 +17095,8 @@ ${footnoteFoldIn}${codeThreadReplies()}
 - Every open point here is TECHNICAL — triage already resolved
   the product ones, one phase earlier. PERMISSIVE: answer it
   yourself unless you genuinely cannot defend a default; a wrong
-  technical call is still caught by the full run and the quality lap
+  technical call is still caught by each package's suite run and the
+  quality lap
 - The narrow exception: a simplification that drops something
   \`.gtd/REQUIREMENTS.md\` mentions is an open question, not a
   silent default
@@ -17142,11 +17108,13 @@ ${footnoteFoldIn}${codeThreadReplies()}
      only, as fenced TypeScript (or the repository's language)
   3. \`## Call Stacks\` — seam level, entry point → module
      boundary; one line per hop, never per line of code
-  4. \`## E2E Scenarios\` — Gherkin in fenced \`gherkin\` blocks
-     (whatever e2e framework the repository uses), each preceded
-     by a line \`- e2e: <path>\`. With no user-visible
-     behaviour change, the literal line \`No e2e change.\` plus a
-     one-line reason — never empty or missing
+  4. \`## E2E Scenarios\` — one line per user-visible behaviour,
+     \`- e2e: <path> — <behaviour> (covers <concern>)\`, in plain
+     words: the builder writes the scenario in the repository's
+     own e2e framework, so never spell out Gherkin here. With no
+     user-visible behaviour change, the literal line
+     \`No e2e change.\` plus a one-line reason — never empty or
+     missing
   5. \`## Unit Tests\` — one \`### <interface>\` per entry of
      \`## Interfaces\`, each test a line
      \`- unit: <path> — <behaviour> (covers <concern>)\`;
@@ -17172,35 +17140,31 @@ const architectureDecomposePrompt = () => `${styleBlock}
 ${stateFileRules}
 - The only state files this turn touches are the package files
   under \`.gtd/packages/\` — no other files for notes or output.
-  Never delete \`.gtd/ARCHITECTURE.md\`: the build tail's full run
-  still needs it, and package files may reference it
+  Never delete \`.gtd/ARCHITECTURE.md\`: package files may
+  reference it, and it is removed with the last package
 - Work from \`.gtd/ARCHITECTURE.md\` if you wrote it earlier this
   conversation, otherwise read it (the converged technical
   plan). It already lists the concerns, interfaces, e2e scenarios
   and unit tests — this turn groups them into packages. A
   \`## Merged Concerns\` heading there records merges, never a
   concern of its own: write no package file for it
-- A package is a consecutive run of \`## Unit Tests\` entries that go
-  green together on the fast suite, at most ~8 unit-test entries
-  each. Keep the merge rule: concerns whose footprints centre on the
-  same files stay in one package unless the later one only consumes
-  an interface the earlier one creates. Prefer fewer, larger
-  packages. Order them so each stays green on the fast suite —
-  interface-introducing packages first
+- A package is one concern's slice, and each must leave the full
+  suite green — every package boundary costs a full run, so write
+  as few as the concerns allow. Keep the merge rule: concerns whose
+  footprints centre on the same files stay in one package unless
+  the later one only consumes an interface the earlier one creates.
+  Order them interface-introducing packages first
 - Write the packages under \`.gtd/packages/\`, each carrying its
   requirement(s) — both, independently, if merged — its tasks, and
   each task's acceptance criteria as \`- [ ]\` checkboxes and
   relevant paths:
-  - \`.gtd/packages/00-e2e-scenarios.md\` — package 0: it writes
-    \`## E2E Scenarios\` as tests in the repository's own e2e
-    framework and leaves them red. Write no such file when
-    \`## E2E Scenarios\` says "No e2e change."
-  - \`01-…\` onward — the unit-test packages. A requirement no test
-    covers (docs, README, deletions, config) becomes a chore
-    package, or a task of one; chore packages declare no tests
-  - the last numbered package is the wiring package: CLI entry,
-    workflow composition, config. A red e2e after it is a bug, not
-    missing work
+  - \`01-…\` onward — one vertical slice each: the unit tests,
+    the code, the wiring (CLI entry, workflow composition, config)
+    and every \`## E2E Scenarios\` entry its concern covers, so the
+    slice ends with its scenarios passing. A requirement no test
+    covers (docs, README, deletions, config) is a task of the slice
+    it belongs to; only one no slice owns becomes a chore package,
+    which declares no tests
 - Every package with tests has a \`## Tests\` section, one line per
   declared test, copied from the architecture entries:
   \`- unit: \\\`<path>\\\`\` or \`- e2e: \\\`<path>\\\`\`. Chore packages have
@@ -17246,10 +17210,10 @@ const packagesItemBuildingPrompt = (pkg) => `${stateFileRules}
 - Write the tests the package declares under \`## Tests\` first,
   then the code that makes them pass; the turn is refused unless
   every declared test is in your diff
-- Package 0 (\`.gtd/packages/00-e2e-scenarios.md\`) writes the scenarios verbatim
-  from \`## E2E Scenarios\` of \`.gtd/ARCHITECTURE.md\`, with only
-  step code that typechecks, and leaves them red — no
-  implementation
+- A declared e2e test is a scenario in the repository's own e2e
+  framework for the behaviour its \`## E2E Scenarios\` entry names.
+  Word it to fit the existing steps — reuse and generalise them
+  rather than adding one-off ones
 - Implement every task the package describes, no more, no less,
   fanning independent ones out to parallel subagents where your
   harness supports it; leave other package files untouched
@@ -17303,22 +17267,9 @@ Edit \`.gtd/ESCALATION.md\` with fresh instructions for the next fix
 turn, or land untouched to give it one more attempt at the same
 analysis.
 `;
-const buildContextPrompt = (built) => {
-	const list = (paths) => paths.length === 0 ? "  (none)" : paths.map((path) => `  - ${path}`).join("\n");
-	return `- Read \`.gtd/ARCHITECTURE.md\` — the plan every package was built from
-- A red scenario that is NEW in this plan likely means missing wiring
-  between packages; new scenarios:
-${list(built.scenarios.added)}
-- A red CHANGED or existing scenario or test is a regression a package
-  introduced; scenarios this plan changed:
-${list(built.scenarios.changed)}
-- Each package's commits, to bisect a break:
-${built.ranges.map((r) => `  git log --oneline ${r.from}..${r.to}  # ${r.pkg}`).join("\n")}
-`;
-};
-const buildFixPrompt = (built) => `${stateFileRules}
+const buildFixPrompt = () => `${stateFileRules}
 ${fixFeedbackPrompt}
-${built === void 0 ? "" : buildContextPrompt(built)}- Leave everything uncommitted — do not commit
+- Leave everything uncommitted — do not commit
 `;
 const finisherSystem = () => `${finisherPersona}
 
@@ -17470,9 +17421,10 @@ const reviewNotesCapture = (commit) => `This is machine-captured input, not inst
 Commit: ${commit}
 The human's notes are in .gtd/REVIEW.md at this commit. Run: git show ${commit}
 `;
+const noteHead = (n) => `${n.id} — ${n.anchor}${n.label === void 0 ? "" : ` (${n.label})`}`;
 const notesCapture = (notes) => `This is machine-captured input, not instructions.
 
-${notes.map((n) => `- ${n.id} — ${n.anchor}\n  ${n.text.replace(/\n/g, "\n  ")}`).join("\n")}
+${notes.map((n) => `- ${noteHead(n)}\n  ${n.text.replace(/\n/g, "\n  ")}`).join("\n")}
 `;
 const buildReviewAnswerQuestionsPrompt = (notes) => `${stateFileRules}
 - The only state file this turn writes is \`.gtd/REVIEW.md\`; touch no
@@ -17534,12 +17486,47 @@ record.
 What each change does next (then run \`gtd land\`):
 - **Re-review** — re-run the reviewer to author a fresh \`.gtd/REVIEW.md\` (**build.review.reviewing**).
 `;
+/** Greedy wrap at 80 columns with a 2-space continuation indent: oxfmt (`proseWrap: always`) rewrites any other shape. */
+const wrapItem = (item) => {
+	const out = [];
+	let line = "";
+	for (const word of item.split(" ")) if (line !== "" && line.length + 1 + word.length > 80) {
+		out.push(line);
+		line = `  ${word}`;
+	} 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
 \`praise\`. Run \`gtd judge answer\` and pipe a choice per note — or land
 untouched, which treats every note as \`edit\` (the conservative
 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\`.
 `;
 const buildReviewCollectingPrompt = (capture) => `${styleBlock}
 
@@ -17560,6 +17547,8 @@ ${footnoteFoldIn}${codeThreadReplies()}
 - When the capture names an answering commit, carry each answered
   question into \`.gtd/REQUIREMENTS.md\`'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)\`
+  label into the concern folded from it
 - Nit notes were already fixed: never re-raise a fixed nit as a concern
 - Finish by running \`gtd check review .gtd/REVIEW.md\` and fix
   what it reports
@@ -17601,7 +17590,18 @@ actionability, and never dismiss a real note or edit as approval.
 - If not: finish without writing anything — changing nothing is
   the sign-off
 `;
-const buildReviewReviewingPrompt = (base, carry) => `${styleBlock}
+const scenariosPrompt = (removed) => `- When a scenario in a \`.feature\` file was added or changed since the
+  base, the first chunk is \`## Scenarios\`: one pointer per such
+  scenario, its note saying in plain words what behaviour it now pins
+  down — the human signs off the scenarios here, nowhere else
+${removed.length === 0 ? "" : `- These assertions of scenarios that existed at the base are gone:
+${removed.map(({ path, lines }) => lines.map((a) => `    ${path} — ${a.scenario} — ${a.line}\n`).join("")).join("")}  Open the note of each scenario that lost one with \`Weakened:\`,
+  naming the lost line and whether \`.gtd/REQUIREMENTS.md\` asked
+  for it. A scenario that no longer exists has no pointer of its own:
+  put its \`Weakened:\` note on a pointer of the chunk covering its
+  removal
+`}`;
+const buildReviewReviewingPrompt = (base, carry, removed = []) => `${styleBlock}
 
 ${styleFormatContract}
 
@@ -17643,7 +17643,7 @@ review the changes:
   A note sitting entirely on the line(s) beneath the pointer is
   also valid. Either way, the note must never start with a bare \`./path\` token
   — that parses as a second pointer, not a note
-No diff is given — read the changes yourself. The range runs
+${scenariosPrompt(removed)}No diff is given — read the changes yourself. The range runs
 from \`${base}\` to the working tree (committed turns
 plus anything pending); on a feedback round that's the previous
 review's boundary, so it covers only what's new.
@@ -17690,20 +17690,6 @@ ${it.processCostByModel.map((m) => `- ${m.model}: ${m.cost}\n`).join("")}
 Print the closing message and stop — this writes nothing itself.
 `;
 };
-const scenarioWordingMessage = (at, drifted) => `The e2e scenario wording was frozen when package 0 landed, and the last
-turn changed it. Removed lines are marked \`-\`, added ones \`+\`:
-
-${drifted.map(({ path, lines }) => `${path}\n${lines.join("\n")}`).join("\n\n")}
-
-To accept the change, land untouched.
-
-To reject it, run
-
-    git checkout ${at} -- ${drifted.map(({ path }) => quote(path)).join(" ")}
-
-and land. Restoring only some of the files is a partial accept: every file
-still differing from the frozen wording is accepted.
-`;
 //#endregion
 //#region src/workflows/shared/steps.ts
 const FEEDBACK = ".gtd/FEEDBACK.md";
@@ -17714,7 +17700,7 @@ const REVIEW = ".gtd/REVIEW.md";
 const QUALITY = ".gtd/QUALITY.md";
 const planner = () => env.plannerModel ?? "";
 const coder = () => env.coderModel ?? "";
-const fixCheck = (built) => agentWithSkills("fix", buildFixPrompt(built), {
+const fixCheck = () => agentWithSkills("fix", buildFixPrompt(), {
 	label: "Fixing the check",
 	file: FEEDBACK,
 	model: coder(),
@@ -17770,7 +17756,7 @@ const fixQuality = () => agentWithSkills("fix.quality.fixing", buildFixQualityPr
 	allowEmpty: true
 });
 /** Write `.gtd/REVIEW.md` over everything since `base`, carrying the answers of commit `carry` when given. */
-const reviewing = (base, carry) => agentWithSkills("review.reviewing", buildReviewReviewingPrompt(base, carry), {
+const reviewing = (base, carry) => agentWithSkills("review.reviewing", buildReviewReviewingPrompt(base, carry, removedAssertions(changesSince(base))), {
 	label: "Reviewing",
 	file: REVIEW,
 	mode: "review",
@@ -17786,12 +17772,13 @@ const fixRisks = (notes) => agentWithSkills("review.fix.risks.fixing", buildRevi
 	system: reviewerSystem(),
 	allowEmpty: true
 });
-const awaitReview = (base, message = buildReviewAwaitReviewMessage(base)) => human("review.await-review", {
+const awaitReview = (base, message = buildReviewAwaitReviewMessage(base), acceptClean = false) => human("review.await-review", {
 	message,
 	label: "Awaiting your review",
 	file: REVIEW,
 	mode: "review",
-	base
+	base,
+	...acceptClean ? { acceptClean } : {}
 });
 /** The round at commit `round` left no `.gtd/REVIEW.md`. */
 const reviewMissing = (round) => human("review.review-missing", {
@@ -17800,25 +17787,13 @@ const reviewMissing = (round) => human("review.review-missing", {
 });
 //#endregion
 //#region src/workflows/shared/health.ts
-/** Written while `fastTestCommand` is unset; its presence rests the process at the check. */
-const SETUP = ".gtd/SETUP.md";
-const SETUP_TEXT = "The bundled workflow needs the `fastTestCommand` setting: the fast suite (everything but e2e).\nSet it as a workflow option in `gtd.config.ts` or as GTD_FASTTESTCOMMAND.";
-/** Shell lines for a check's preamble: unset (blank after trim) setting writes `SETUP` and skips the suite. */
-const fastSuiteGuard = () => (env.fastTestCommand ?? "").trim() === "" ? [
-	`mkdir -p ${quote(dirname(SETUP))}`,
-	`printf '%s\\n' ${quote(SETUP_TEXT)} > ${quote(SETUP)}`,
-	`printf '%s\\n' ${quote(SETUP_TEXT)} >&2`,
-	"exit 0"
-] : [`rm -f ${quote(SETUP)}`];
 /** Fix turns a run of red checks gets before it escalates. */
 const FIX_CAP = 3;
-const unconfigured = () => read(SETUP) !== void 0;
 /** Run the suite as step `name`; resolves `true` when it passed. A failure is in `.gtd/FEEDBACK.md`. */
-const baseline = (name, label = "Checking the baseline") => untilSettled(() => check(name, env.testCommand ?? "", {
+const baseline = (name, label = "Checking the baseline") => check(name, env.testCommand ?? "", {
 	report: FEEDBACK,
-	label,
-	preamble: fastSuiteGuard()
-}), unconfigured);
+	label
+});
 const escalationSteps = {
 	limit: 2,
 	describe: describeEscalation,
@@ -17856,22 +17831,18 @@ const sameFailure = async (previous, current) => {
 	});
 	return comparable && truncated.length === 0 && answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity));
 };
-const runSuite = (options) => {
-	const fast = options.suite === "fast";
-	return check("health.check", (fast ? env.fastTestCommand : env.testCommand) ?? "", {
-		report: FEEDBACK,
-		label: "Running checks",
-		sweepOnGreen: [ESCALATION, ...options.sweepOnGreen ?? []],
-		...fast ? { preamble: fastSuiteGuard() } : {}
-	});
-};
+const runSuite = (options) => check("health.check", env.testCommand ?? "", {
+	report: FEEDBACK,
+	label: "Running checks",
+	sweepOnGreen: [ESCALATION, ...options.sweepOnGreen ?? []]
+});
 /**
 * Loop until the suite is green: check, and on red run `fix` — escalating
 * first once `FIX_CAP` fixes are spent, or a judge calls the failure
 * identical to the previous round's.
 */
 const healthy = (fix, options = {}) => healthy$1(fix, {
-	check: options.suite === "fast" ? () => untilSettled(() => runSuite(options), unconfigured) : () => runSuite(options),
+	check: () => runSuite(options),
 	report: FEEDBACK,
 	fixCap: 3,
 	fixesSoFar: options.fixesSoFar ?? 0,
@@ -37207,12 +37178,12 @@ const defaults = {
 	judgeBudgetBytes: "32768",
 	judgeIdenticalMinP: "0.7",
 	reviewNoteActionable: "0.7",
+	reviewSeverityMinP: "0.7",
 	qualityReviews: "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge"
 };
 /** Environment settings. */
 const envDefaults = {
 	testCommand: "npm test",
-	fastTestCommand: "",
 	plannerModel: "smart",
 	coderModel: "base"
 };
@@ -37224,9 +37195,9 @@ const ShippedOptions = Struct({
 	judgeBudgetBytes: setting,
 	judgeIdenticalMinP: setting,
 	reviewNoteActionable: setting,
+	reviewSeverityMinP: setting,
 	qualityReviews: setting,
 	testCommand: setting,
-	fastTestCommand: setting,
 	plannerModel: setting,
 	coderModel: setting
 });
@@ -37246,21 +37217,6 @@ const shipped = (flow, doors, base) => defineWorkflow(standardSchemaV1(ShippedOp
 	base
 }));
 //#endregion
-//#region src/workflows/shared/scenarios.ts
-/** After a turn: stop at `scenario-wording` while wording drifted; accept moves the snapshot. */
-const holdWording = (frozen) => holdWording$1(frozen, (at, drifted) => human("scenario-wording", {
-	message: scenarioWordingMessage(at, drifted),
-	label: "Scenario wording changed",
-	acceptClean: true,
-	base: at
-}));
-/** `turn`, then `holdWording`; `within` names the scope the gate rests in. */
-const guarded = (frozen, turn, within) => async () => {
-	await turn();
-	if (within === void 0) await holdWording(frozen);
-	else await scope(within, () => holdWording(frozen));
-};
-//#endregion
 //#region src/workflows/shared/tail.ts
 /** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
 const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
@@ -37271,8 +37227,8 @@ const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
 */
 const qualityLap = () => qualityLap$1(lensesOf(vars.qualityReviews ?? ""), reviewQuality, QUALITY);
 /** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-const fixQualityFindings = (escalations, frozen) => fixFindings({
-	fix: guarded(frozen, fixQuality),
+const fixQualityFindings = (escalations) => fixFindings({
+	fix: fixQuality,
 	findings: QUALITY,
 	cap: 3,
 	escalate: () => escalation(escalations)
@@ -37288,34 +37244,25 @@ const refusePendingHandOff = () => {
 };
 /**
 * The build tail: fix (when entered red), keep green, the quality lap, then
-* `finish` — the human review, as the calling workflow runs it.
+* `finish` — the human review, as the calling workflow runs it. `green`: the
+* caller just left the full suite green (the package loop), so no run opens it.
 */
-const tail = (fixFirst, finish, built) => scope("build", async () => {
-	const frozen = built?.frozen;
+const tail = (fixFirst, finish, green = false) => scope("build", async () => {
 	const escalations = { rounds: 0 };
-	const guardedFix = guarded(frozen, () => fixCheck());
+	const fix = fixCheck;
 	const repair = async () => {
-		await guardedFix();
-		await healthy(guardedFix, {
+		await fix();
+		await healthy(fix, {
 			fixesSoFar: 1,
 			escalations
 		});
 	};
 	if (fixFirst) await repair();
-	else await healthy(guarded(frozen, () => fixCheck(built)), {
-		escalations,
-		sweepOnGreen: [ARCHITECTURE]
-	});
-	if (await qualityLap() === "findings") if (await fixQualityFindings(escalations, frozen)) await healthy(guardedFix, { escalations });
+	else if (!green) await healthy(fix, { escalations });
+	if (await qualityLap() === "findings") if (await fixQualityFindings(escalations)) await healthy(fix, { escalations });
 	else await repair();
-	return finish(escalations, frozen);
+	return finish(escalations);
 });
-const handOffScript = (reviewed) => [
-	"#!/usr/bin/env sh",
-	"set -e",
-	`git show ${quote(`${reviewed}:${REVIEW}`)} > ${quote(REVIEW_ORIG)}`,
-	""
-].join("\n");
 /**
 * The review and fix workflows' human review since `base`: a sign-off closes
 * `.gtd/REVIEW.md`; a note leaves it, with the reviewer's own version as
@@ -37325,11 +37272,11 @@ const handOffReview = (base, escalations) => reviewToHandOff(base, {
 	file: REVIEW,
 	reviewing,
 	fixRisks,
-	keepGreen: () => healthy(() => fixCheck(), { escalations }),
+	keepGreen: () => healthy(fixCheck, { escalations }),
 	awaitReview: (b) => awaitReview(b, handOffAwaitReviewMessage(b)),
 	reviewMissing,
 	close: closeReview,
-	handOff: (reviewed) => run("review.handing-off", handOffScript(reviewed), { label: "Handing your notes to fix" }),
+	handOff: (reviewed) => run("review.handing-off", showScript(reviewed, REVIEW, REVIEW_ORIG), { label: "Handing your notes to fix" }),
 	threadsPending: "gtd land: open-threads: a thread in .gtd/REVIEW.md or an `H:` code comment waits on the agent — nothing answers it here; delete it, or turn it into a note for fix.",
 	unparsed: "gtd land: review-doc: your edit to .gtd/REVIEW.md contains no note fix can read — restore the deleted chunk, or write the note as a line under its entry.",
 	deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note to hand to fix."
@@ -37407,10 +37354,13 @@ const collecting = (capture) => agentWithSkills("review.collecting", buildReview
 	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/packages.ts
-/** Package 0: the e2e scenarios, written red. */
-const SCENARIO_PACKAGE = ".gtd/packages/00-e2e-scenarios.md";
 const TEST_LINE = /^\s*-\s+(unit|e2e):\s+`([^`]+)`/;
 /** The `## Tests` entries of a package file; malformed lines are ignored. */
 const declaredTests = (packageText) => {
@@ -37440,47 +37390,29 @@ const requireDeclaredTests = (pkg, since) => {
 	if (missing.length === 0) return;
 	refuse(`gtd land: declared-tests: ${pkg} declares tests that are ${satisfied ? "missing from the tree" : "not in the package's diff"} — write them first:\n${missing.map((path) => `  - ${path}`).join("\n")}`);
 };
-/** Build `pkg`, check its declared tests, keep the fast suite green, and close it out, which removes it. */
-const packageItem = async (pkg, frozen) => {
+/**
+* Build `pkg`, check its declared tests, keep the full suite green, and close
+* it out, which removes it — and `.gtd/ARCHITECTURE.md` with the last one.
+*/
+const packageItem = async (pkg) => {
 	const from = head$1();
 	const declared = (turn) => async () => {
 		await turn();
 		requireDeclaredTests(pkg, from);
 	};
-	await guarded(frozen, declared(() => build(pkg)))();
-	await healthy(guarded(frozen, declared(fixSuite)), { suite: "fast" });
-	await run("closing", removeScript([pkg, ".gtd/SATISFIED.md"]), { label: "Closing out the package" });
-	return {
+	await declared(() => build(pkg))();
+	await healthy(declared(fixSuite));
+	await run("closing", removeScript([
 		pkg,
-		from,
-		to: head$1()
-	};
+		".gtd/SATISFIED.md",
+		...glob(".gtd/packages/*.md").length === 1 ? [ARCHITECTURE] : []
+	]), { label: "Closing out the package" });
 };
 /** The first queued package — the one a package step works on. */
 const nextPackage = () => [...glob(".gtd/packages/*.md")].sort()[0];
-const outsideGtd = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
 /** Build every package file under `.gtd/packages/`, in name order. */
-const packages = (carried) => scope("packages", async () => {
-	let frozen = carried;
-	const ranges = [];
-	let touched = [];
-	for (let pkg = nextPackage(); pkg !== void 0; pkg = nextPackage()) {
-		const range = await scope("item", () => packageItem(pkg, pkg === ".gtd/packages/00-e2e-scenarios.md" ? void 0 : frozen));
-		ranges.push(range);
-		if (pkg === ".gtd/packages/00-e2e-scenarios.md") {
-			touched = changesSince(range.from).filter((c) => outsideGtd(c.path) && c.status !== "deleted");
-			frozen = freezeScenarios(touched.filter((c) => c.path.endsWith(".feature")).map((c) => c.path), frozen);
-		}
-	}
-	const paths = (status) => touched.filter((c) => c.status === status).map((c) => c.path);
-	return {
-		ranges,
-		scenarios: {
-			added: paths("added"),
-			changed: paths("modified")
-		},
-		frozen
-	};
+const packages = () => scope("packages", async () => {
+	for (let pkg = nextPackage(); pkg !== void 0; pkg = nextPackage()) await scope("item", () => packageItem(pkg));
 });
 //#endregion
 //#region src/workflows/feature/planning.ts
@@ -37513,7 +37445,7 @@ const architecture = () => scope("architecture", async () => {
 	} while (await noteGate(ARCHITECTURE, answerTechnicalQuestions));
 	await decompose();
 	if (changes(".gtd/packages/**").length === 0) refuse("gtd land: decompose: write at least one package under .gtd/packages/");
-	if (changes(".gtd/ARCHITECTURE.md").some((c) => c.status === "deleted")) refuse("gtd land: decompose: keep .gtd/ARCHITECTURE.md — the build tail's full run needs it; it is removed only once that run is green");
+	if (changes(".gtd/ARCHITECTURE.md").some((c) => c.status === "deleted")) refuse("gtd land: decompose: keep .gtd/ARCHITECTURE.md — the packages are built from it; it is removed with the last package");
 });
 //#endregion
 //#region src/workflows/feature/review.ts
@@ -37530,23 +37462,106 @@ 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 SEVERITY_ANSWERS = {
+	security: ["yes", "no"],
+	reversibility: ["one-way", "two-way"],
+	blastRadius: [
+		"local",
+		"module",
+		"contract"
+	],
+	newConcept: ["yes", "no"]
+};
 /**
-* One judge rest, one verdict per note. 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`, and a blank floor makes
-* every note one.
+* Deferring is the risky direction: anything unanswered, unrecognised, cut or
+* below `minP` is `critical`, never `could`.
 */
-const triage$1 = async (notes) => {
-	const { answers, truncated } = await judge("review.triage", {
-		questions: notes.map(verdictQuestion),
-		evidence: Object.fromEntries(notes.map((n) => [n.id, `Anchor: ${n.anchor}\nReviewer's text: ${n.before}\nHuman's text: ${n.text}`])),
+const severityOf = (note, judgment, minP) => {
+	const ans = (q) => judgment.answers[`${note.id}.${q}`];
+	const a = (q) => ans(q)?.answer;
+	const rank = () => a("reversibility") === "one-way" ? 0 : a("newConcept") === "yes" ? 1 : 2;
+	if (note.forced) return {
+		tier: "critical",
+		reason: "critical: forced by `!`",
+		rank: 2
+	};
+	if (judgment.truncated.includes(note.id) || Object.entries(SEVERITY_ANSWERS).some(([q, allowed]) => !allowed.includes(a(q) ?? "") || !((ans(q)?.p ?? NaN) >= minP))) return {
+		tier: "critical",
+		reason: "critical: judge unsure",
+		rank: 2
+	};
+	const critical = [...a("security") === "yes" ? ["security"] : [], ...a("reversibility") === "one-way" ? ["one-way door"] : []];
+	if (critical.length > 0) return {
+		tier: "critical",
+		reason: `critical: ${critical.join(", ")}`,
+		rank: rank()
+	};
+	const should = [...a("blastRadius") === "contract" ? ["contract"] : [], ...a("newConcept") === "yes" ? ["new concept"] : []];
+	if (should.length > 0) return {
+		tier: "should",
+		reason: `should: ${should.join(", ")}`,
+		rank: rank()
+	};
+	return {
+		tier: "could",
+		reason: "could",
+		rank: 2
+	};
+};
+const severityQuestions = (note) => [
+	{
+		id: `${note.id}.security`,
+		primitive: "noul",
+		instructions: `Does the change the human asks for in note "${note.id}" (on "${note.anchor}") touch security — authentication, authorisation, secrets, untrusted input or data exposure?`,
+		criteria: "yes: it changes or could weaken a security property. no: it does not."
+	},
+	{
+		id: `${note.id}.reversibility`,
+		primitive: "choice",
+		instructions: `Once the change in note "${note.id}" ships, can it be undone without breaking anyone who already depends on it?`,
+		criteria: "one-way: a published API, file format, persisted data, protocol or other contract that cannot be taken back. two-way: can be reverted freely."
+	},
+	{
+		id: `${note.id}.blastRadius`,
+		primitive: "choice",
+		instructions: `How far does the change in note "${note.id}" reach?`,
+		criteria: "local: one function or file. module: a whole module or several files. contract: a public interface other code or users depend on."
+	},
+	{
+		id: `${note.id}.newConcept`,
+		primitive: "noul",
+		instructions: `Does the change in note "${note.id}" introduce a concept new to this codebase — a new abstraction, entity or term? Judge from the evidence, never a glossary; reusing or extending an existing concept is not new.`,
+		criteria: "yes: a genuinely new concept. no: reuses or extends an existing one."
+	}
+];
+/**
+* One judge rest: a verdict per unforced note (a forced note is asked
+* 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`.
+*/
+const triage$1 = (severities) => async (notes) => {
+	const asked = notes.filter((n) => !n.forced);
+	const judgment = asked.length === 0 ? {
+		answers: {},
+		truncated: []
+	} : await judge("review.triage", {
+		questions: asked.flatMap((n) => [verdictQuestion(n), ...severityQuestions(n)]),
+		evidence: Object.fromEntries(asked.map((n) => [n.id, `Anchor: ${n.anchor}\nReviewer's text: ${n.before}\nHuman's text: ${n.text}`])),
 		message: buildReviewTriageMessage(),
 		label: "Judging each note"
 	});
+	const { answers, truncated } = judgment;
 	const minP = numeric(vars.reviewNoteActionable, Infinity);
+	const severityMinP = numeric(vars.reviewSeverityMinP, Infinity);
+	severities.clear();
 	return new Map(notes.map((n) => {
-		const verdict = VERDICTS.find((v) => v !== "edit" && answered(answers[n.id], v, minP));
-		return [n.id, truncated.includes(n.id) || verdict === void 0 ? "edit" : verdict];
+		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"];
 	}));
 };
 const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
@@ -37556,32 +37571,61 @@ const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
 * another planning lap, questions are answered in place, nits fixed in one
 * batch, praise dropped.
 */
-const review$1 = (base, escalations = { rounds: 0 }, frozen) => review$2(base, {
-	file: REVIEW,
-	feedback: REQUIREMENTS,
-	isCode,
-	reviewing,
-	fixRisks: (risks) => guarded(frozen, () => fixRisks(risks), "review")(),
-	keepGreen: () => healthy(guarded(frozen, fixCheck, "review"), { escalations }),
-	awaitReview,
-	reviewMissing,
-	collecting,
-	triage: triage$1,
-	answerQuestions: answerReviewQuestions,
-	fixNits: (notes) => guarded(frozen, () => fixNits(notes), "review")(),
-	close: closeReview,
-	captures: {
-		edits: reviewEditsCapture,
-		notes: reviewNotesCapture,
-		editNotes: reviewEditNotesCapture
-	},
-	refusals: {
-		deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note (or edit code) to request changes.",
-		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"
-	}
-});
-/** The build tail: fix (when entered red), keep green, the quality lap, then human review since `base`. */
-const buildTail = (fixFirst, base, built) => tail(fixFirst, (escalations, frozen) => review$1(base, escalations, frozen), built);
+const review$1 = (base, escalations = { rounds: 0 }) => {
+	const severities = /* @__PURE__ */ new Map();
+	let deferred = [];
+	return review$2(base, {
+		file: REVIEW,
+		feedback: REQUIREMENTS,
+		isCode,
+		reviewing: (b, carry) => {
+			deferred = [];
+			return reviewing(b, carry);
+		},
+		fixRisks,
+		keepGreen: () => healthy(fixCheck, { escalations }),
+		awaitReview: (b) => {
+			const notes = deferred;
+			deferred = [];
+			return notes.length > 0 ? awaitReview(b, buildReviewAwaitAfterDeferMessage(b, notes), true) : awaitReview(b);
+		},
+		reviewMissing,
+		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());
+		},
+		answerQuestions: answerReviewQuestions,
+		fixNits,
+		close: closeReview,
+		captures: {
+			edits: reviewEditsCapture,
+			notes: reviewNotesCapture,
+			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 }) => ({
+				id: n.id,
+				anchor: n.anchor,
+				text: n.forced ? n.text.replace(/^!\s*/, "") : n.text,
+				...s === void 0 ? {} : { label: s.reason }
+			})), answeredAt)
+		},
+		refusals: {
+			deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note (or edit code) to request changes.",
+			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"
+		}
+	});
+};
+/** The build tail: fix (when entered red), keep green unless `green`, the quality lap, then human review since `base`. */
+const buildTail = (fixFirst, base, green = false) => tail(fixFirst, (escalations) => review$1(base, escalations), green);
 //#endregion
 //#region src/workflows/feature/feature.ts
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
@@ -37608,13 +37652,11 @@ const reUnwind = async (feedback) => {
 /** Plan, build and review until a review round signs off; feedback re-plans from scratch. */
 const planAndBuild = async (firstBase) => {
 	let base = firstBase;
-	let carried;
 	for (;;) {
 		await design(base);
 		await architecture();
-		const built = await packages(carried);
-		carried = built.frozen;
-		const outcome = await buildTail(false, base, built);
+		await packages();
+		const outcome = await buildTail(false, base, true);
 		if (outcome.verdict === "signoff") return;
 		await reUnwind(outcome);
 		base = outcome.base;
@@ -37673,6 +37715,7 @@ const access = (vars) => ({
 	architecture: { write: [".gtd/REQUIREMENTS.md"] },
 	"architecture.decompose": { write: [".gtd/packages/**", ".gtd/ARCHITECTURE.md"] },
 	"build.review": { write: [".gtd/REVIEW.md"] },
+	"build.review.defer": { write: [".gtd/TODO.md"] },
 	"build.review.fix.nits": {},
 	"build.review.fix.risks": {},
 	...lensScopes("build.quality", lensesOf(vars.qualityReviews ?? ""), () => ({ write: [] }))
@@ -37749,4 +37792,4 @@ var workflows_default = feature;
 */
 const doors = {};
 //#endregion
-export { ARCHITECTURE, ESCALATION, FEEDBACK, FIX_CAP, QUALITY, REQUIREMENTS, REVIEW, REVIEW_ORIG, SCENARIO_PACKAGE, SETUP, ShippedOptions, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, answerTechnicalQuestions, architecture, author, awaitReview, base, baseline, build, buildTail, builtInLenses, closeReview, coder, collecting, declaredTests, decompose, workflows_default as default, defaults, describeEscalation, design, doors, driftedScenarios, envDefaults, escalate, escalation, escalationExhausted, fastSuiteGuard, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, fixSuite, freezeScenarios, gate, guarded, handOffReview, handOffTail, healthy, holdWording, lensesOf, nextPackage, ordinaryStart, packageItem, packages, planAndBuild, planner, qualityLap, reUnwind, requireDeclaredTests, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewing, scenarioText, skills, steering, summary, tail, threads, triage, unwind, wordingDrift };
+export { ARCHITECTURE, ESCALATION, FEEDBACK, FIX_CAP, QUALITY, REQUIREMENTS, REVIEW, REVIEW_ORIG, ShippedOptions, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, answerTechnicalQuestions, architecture, author, awaitReview, base, baseline, build, buildTail, builtInLenses, closeReview, coder, collecting, declaredTests, decompose, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, fixSuite, gate, handOffReview, handOffTail, healthy, lensesOf, nextPackage, ordinaryStart, packageItem, packages, planAndBuild, planner, qualityLap, reUnwind, requireDeclaredTests, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewing, skills, steering, summary, tail, threads, triage, unwind };