@pmelab/gtd 32.1.0 → 33.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "32.1.0",
+  "version": "33.0.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -588,21 +588,24 @@ home directory — fails every command until you delete it. See
 
 #### The naive pass
 
-After design the agent first implements the requirements directly. A judge
-checks whether it changed anything outside the expected set (tests, steering
-files; see `seamAllow`). Incidental changes land; a needed seam change is
-refactored first, in its own slice with its own quality lap
-(`refactorQualityReviews`) and review, before the feature is implemented and
-reviewed; a wrong approach is retried twice, then rests for you to steer or
-overrule it. `gtd slices` lists the `refactor` and `feature` slices. A refactor
-that already carried the whole feature leaves the implementation nothing to do:
-its empty turn passes, and the feature review covers the whole change. Feedback
-at the feature review re-runs design and the implementation, never the naive
-pass; feedback at the refactor review re-runs the refactor, never design; a
-refactor-review change the refactor cannot build is refused, and the only way
-out is `gtd abandon`. A process from 27.5.0 or later whose judge ruled
-`refactor-first` must `gtd abandon` too. Each slice's quality lap reviews only
-that slice. Details in
+After design the agent first implements the requirements directly,
+breadth-first, with a behaviour-level acceptance test per criterion that names
+its ID (`[AC-3] …`) and reaches only code that existed before the pass. The pass
+is sent back while a criterion's ID is missing from its tests, a test imports a
+file it added, or the suite is red on it. A judge checks whether it changed
+anything outside the expected set (tests, steering files; see `seamAllow`).
+Incidental changes land; a needed seam change is refactored first, in its own
+slice with its own quality lap (`refactorQualityReviews`) and review, before the
+feature is implemented and reviewed; a wrong approach is retried twice, then
+rests for you to steer or overrule it. `gtd slices` lists the `refactor` and
+`feature` slices. A refactor that already carried the whole feature leaves the
+implementation nothing to do: its empty turn passes, and the feature review
+covers the whole change. Feedback at the feature review re-runs design and the
+implementation, never the naive pass; feedback at the refactor review re-runs
+the refactor, never design; a refactor-review change the refactor cannot build
+is refused, and the only way out is `gtd abandon`. A process from 27.5.0 or
+later whose judge ruled `refactor-first` must `gtd abandon` too. Each slice's
+quality lap reviews only that slice. Details in
 [the naive-pass path](docs/configuration.md#the-naive-pass-path).
 
 **Flag mode (`flagMode`, on by default).** On, the implementation is asked for a

package/dist/chunks/{reserved-2fV0mj14.mjs → reserved-BU5Zi-nX.mjs}

@@ -1203,24 +1203,47 @@ Print the closing message and stop — this writes nothing itself.
 `;
 };
 const listed = (paths, unreadable = []) => paths.map((path) => `  - \`${displayPath(path)}\`${unreadable.includes(path) ? " (unreadable)" : ""}`).join("\n");
+const isRed = (retry) => "red" in retry;
+const isFault = (retry) => "fault" in retry;
+const pickUp = (hash) => `Pick it up — \`git diff --binary ${hash}^ ${hash} | git apply\``;
 const criteriaBinding = (refused) => `- Its \`## Acceptance Criteria\` (\`AC-<n>\`) bind this turn: re-read them from
   the file, never from memory, and stop only when each one holds. They are
   settled — ${refused ? "a turn that changes them is refused" : "leave them as they are"}`;
-const naivePassPrompt = (rejection) => `${stateFileRules}
+const naiveRetry = (retry) => isFault(retry) ? `
+Your previous attempt's (\`${retry.hash}\`) tests fall short:
+${retry.fault}
+${pickUp(retry.hash)} — and fix its tests; do not start over.
+` : isRed(retry) ? `
+Your previous attempt (\`${retry.red}\`) left the suite red; \`.gtd/FEEDBACK.md\`
+holds the output. ${pickUp(retry.red)}
+— and fix it until the suite is green; do not start over.
+` : `
+Your previous attempt was rejected: the judge answered \`reject\` (p=${retry.p}),
+meaning the naive pass solved the task the wrong way — discard it and
+re-implement. It changed these files outside the expected set:
+${listed(retry.strays)}
+Start over and choose a different approach; do not rebuild the same diff.
+`;
+const naivePassPrompt = (retry) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
 ${criteriaBinding(false)}
 - Implement them the quickest way that works — the naive version. Do not
   restructure, abstract or refactor around the change; a later step judges
   the shape of your diff and a reviewer makes it fit
-- Add tests as you go, and leave \`.gtd/\` untouched
+- Work breadth-first: rough out every part of the change before finishing any
+  one, so a run cut off midway still shows the whole shape
+- Write behaviour-level acceptance tests, at least one per criterion, each
+  naming its ID in the test or scenario name (\`[AC-3] …\`). Test through code
+  that existed before this pass — a public entry point, the CLI, an existing
+  module's exports — never a file this pass adds: that is naive structure a
+  later reset and refactor replaces. A pass that leaves a criterion's ID out
+  of its tests, or whose test imports a file it added, is sent back
+- Run \`${env.testCommand}\` and finish only once it is green with every
+  criterion's test passing: the next step runs it on your diff and sends a red
+  pass back
+- Leave \`.gtd/\` untouched
 - Leave everything uncommitted and finish your turn — do not commit
-${rejection === void 0 ? "" : `
-Your previous attempt was rejected: the judge answered \`reject\` (p=${rejection.p}),
-meaning the naive pass solved the task the wrong way — discard it and
-re-implement. It changed these files outside the expected set:
-${listed(rejection.strays)}
-Start over and choose a different approach; do not rebuild the same diff.
-`}`;
+${retry === void 0 ? "" : naiveRetry(retry)}`;
 const implementBuildingPrompt = (reference, tier, amend, afterRefactor, flagMode = true) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
 ${criteriaBinding(true)}
@@ -1245,8 +1268,41 @@ const implementFixPrompt = () => `${stateFileRules}
 ${fixFeedbackPrompt}
 - Leave everything uncommitted and finish your turn — do not commit
 `;
-const seamSteerMessage = (rejection) => `The naive pass was rejected three times and the retries are spent.
-The last attempt changed these files outside the expected set:
+const steerChoices = (overrule) => `Two ways forward (then run \`gtd land\`):
+- **Steer** — edit \`.gtd/REQUIREMENTS.md\` to redirect the change; the naive
+  pass runs again with a fresh retry budget
+- **Overrule** — ${overrule}
+
+An edit together with an approval counts as steer. Only
+\`.gtd/REQUIREMENTS.md\` is meant to change here: any other edit lands on the
+branch unjudged.
+`;
+const seamSteerMessage = (retry) => isFault(retry) ? `The naive pass failed three times and the retries are spent. The last
+attempt's tests (\`git show ${retry.hash}\`) fall short:
+${retry.fault}
+
+${steerChoices(`land a clean tree to go on with the last attempt as it is:
+  \`seam.check\` runs its suite and the seam judge rules on its shape. Use it
+  when the rule cannot fit this change (tests the globs do not see, or no
+  entry point that existed before). Risk: a criterion may have no test that
+  survives a later refactor — the choice is recorded in history.`)}` : isRed(retry) ? `The naive pass failed three times and the retries are spent. The last
+attempt left the suite red: \`.gtd/FEEDBACK.md\` holds the last run's output; \`git show ${retry.red}\` shows
+the last attempt.
+
+Two ways forward (then run \`gtd land\`):
+- **Steer** — edit \`.gtd/REQUIREMENTS.md\` to redirect the change; the naive
+  pass runs again with a fresh retry budget
+- **Overrule** — land a clean tree to go on with the last attempt as it is:
+  the seam judge rules on its shape, and the implementation's health loop
+  must turn the suite green. Risk: the criteria's tests never passed on the
+  naive pass — the choice is recorded in history.
+
+An edit together with an approval counts as steer. Only
+\`.gtd/REQUIREMENTS.md\` is meant to change here: any other edit lands on the
+branch unjudged.
+` : seamRejectedMessage(retry);
+const seamRejectedMessage = (rejection) => `The naive pass failed three times and the retries are spent. The judge
+rejected the last attempt: it changed these files outside the expected set:
 ${listed(rejection.strays)}
 
 Two ways forward (then run \`gtd land\`):

package/dist/chunks/{tail-BynhCfuv.mjs → tail-DuXanjIY.mjs}

@@ -1,6 +1,6 @@
 import { read, refuse, removeScript, run, scope, showScript, vars } from "../flows.mjs";
 import { fixFindings, lensEntriesOf, lensOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { E as reviewing, S as fixRisks, T as reviewQuality, U as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, d as guarded, f as healthy, l as escalation, m as QUALITY, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-2fV0mj14.mjs";
+import { E as reviewing, S as fixRisks, T as reviewQuality, U as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, d as guarded, f as healthy, l as escalation, m as QUALITY, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-BU5Zi-nX.mjs";
 //#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";

package/dist/testkit.mjs

@@ -5,13 +5,13 @@ import { $ as logWarning, $i as NodeInspectSymbol, $n as map$5, $r as make$19, $
 import { createRequire } from "node:module";
 import * as Crypto from "node:crypto";
 import { createHash } from "node:crypto";
+import * as Path from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { PassThrough } from "node:stream";
 import * as NFS from "node:fs";
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import * as OS from "node:os";
 import { homedir, tmpdir } from "node:os";
-import * as Path from "node:path";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import * as ChildProcess from "node:child_process";
 import { execFileSync, execSync, spawnSync } from "node:child_process";
 import * as NodeUrl from "node:url";

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { gt as requireFlag, ht as registryEntry, i as skills, lt as defaults, n as summary, o as flagShipped, pt as flagReferences, r as access, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-2fV0mj14.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-BynhCfuv.mjs";
+import { gt as requireFlag, ht as registryEntry, i as skills, lt as defaults, n as summary, o as flagShipped, pt as flagReferences, r as access, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-BU5Zi-nX.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-DuXanjIY.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,8 @@
-import { answered, changes, changesSince, 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 } from "../flows.mjs";
+import { answered, changes, changesSince, check, 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 } from "../flows.mjs";
 import { lensEntriesOf, review as review$1 } from "../workflow-kit.mjs";
-import { $ as reviewEditNotesCapture, A as buildReviewCollectingPrompt, B as designTriagePrompt, C as planner, D as agentWithSkills, E as reviewing, F as clearCriteriaQuestion, G as implementBuildingPrompt, I as criterionLine, J as normaliseCriteriaScript, K as implementFixPrompt, L as deferNotesScript, M as buildReviewTriageMessage, N as builderSystem, O as buildReviewAnswerQuestionsPrompt, P as clearCriteriaMessage, Q as refactorRules, R as designGateAnswerMessage, S as fixRisks, W as idleMessage, X as refactorDroppedRefusal, Y as refactorBuildingPrompt, Z as refactorFixPrompt, _ as REVIEW, a as flagModeOn, at as seamSteerMessage, b as fixCheck, ct as unwindFailure, d as guarded, dt as testFileGlobs, et as reviewEditsCapture, f as healthy, g as REQUIREMENTS, h as REFACTOR, i as skills, it as seamByHandMessage, j as buildReviewFixNitsPrompt, k as buildReviewAwaitAfterDeferMessage, lt as defaults, n as summary, nt as reviewNotesCapture, ot as startGateBlockedMessage, p as FEEDBACK, q as naivePassPrompt, r as access, rt as reviewerSystem, s as shipped, st as unwindFailedMessage, t as steering, u as gate, ut as envDefaults, v as awaitReview, w as reviewMissing, y as coder, z as designSystem } from "../chunks/reserved-2fV0mj14.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-BynhCfuv.mjs";
+import { $ as reviewEditNotesCapture, A as buildReviewCollectingPrompt, B as designTriagePrompt, C as planner, D as agentWithSkills, E as reviewing, F as clearCriteriaQuestion, G as implementBuildingPrompt, I as criterionLine, J as normaliseCriteriaScript, K as implementFixPrompt, L as deferNotesScript, M as buildReviewTriageMessage, N as builderSystem, O as buildReviewAnswerQuestionsPrompt, P as clearCriteriaMessage, Q as refactorRules, R as designGateAnswerMessage, S as fixRisks, W as idleMessage, X as refactorDroppedRefusal, Y as refactorBuildingPrompt, Z as refactorFixPrompt, _ as REVIEW, a as flagModeOn, at as seamSteerMessage, b as fixCheck, ct as unwindFailure, d as guarded, dt as testFileGlobs, et as reviewEditsCapture, f as healthy, g as REQUIREMENTS, h as REFACTOR, i as skills, it as seamByHandMessage, j as buildReviewFixNitsPrompt, k as buildReviewAwaitAfterDeferMessage, lt as defaults, n as summary, nt as reviewNotesCapture, ot as startGateBlockedMessage, p as FEEDBACK, q as naivePassPrompt, r as access, rt as reviewerSystem, s as shipped, st as unwindFailedMessage, t as steering, u as gate, ut as envDefaults, v as awaitReview, w as reviewMissing, y as coder, z as designSystem } from "../chunks/reserved-BU5Zi-nX.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-DuXanjIY.mjs";
+import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
 	let fence;
@@ -727,7 +728,7 @@ const reviewedRefactor = async (shape, options = {}) => {
 };
 //#endregion
 //#region src/workflows/feature/seam.ts
-/** Naive-pass retries after a `reject`; the next `reject` rests at `seam.steer`. */
+/** Naive-pass retries after a `reject` or a red suite; the next one rests at `seam.steer`. */
 const NAIVE_RETRIES = 2;
 /** A change to an existing file outside the allowlist is a stray even when the task needs it: the judge decides. */
 const judgeSeam = (tip) => judgeDiffShape("judge", {
@@ -735,12 +736,95 @@ const judgeSeam = (tip) => judgeDiffShape("judge", {
 	allow: (vars.seamAllow ?? defaults.seamAllow).split(",").map((glob) => glob.trim()).filter((glob) => glob !== ""),
 	exempt: tip.changes.filter((c) => c.status === "added").map((c) => c.path)
 });
-const naivePass = (rejection) => agentWithSkills("naive", naivePassPrompt(rejection), {
-	label: rejection === void 0 ? "Writing the naive pass" : "Rewriting the naive pass",
+const naivePass = (retry) => agentWithSkills("naive", naivePassPrompt(retry), {
+	label: retry === void 0 ? "Writing the naive pass" : "Rewriting the naive pass",
 	keep: true,
 	model: coder(),
 	system: builderSystem()
 });
+const IMPORTED = /(?:\bfrom|\bimport|\brequire\s*\(|\bmock\s*\()\s*\(?\s*(["'`])([^"'`\n]+)\1/g;
+const EXTENSION = /\.[\w-]+$/;
+const ALIAS = /^(?:[@~]\/|#)/;
+/** The specifiers an added `path` answers to: itself, without its extension, and its directory for an `index`. */
+const namesOf = (path) => {
+	const bare = path.replace(EXTENSION, "");
+	return posix.basename(bare) === "index" ? [
+		path,
+		bare,
+		posix.dirname(bare)
+	] : [path, bare];
+};
+/**
+* The repository paths `test` imports, each with and without an extension: a
+* relative specifier resolved from its directory, an aliased one (`@/`, `~/`,
+* `#`) as a path tail, anything else as written. Comments are skipped; a
+* computed import goes unseen.
+*/
+const importsOf = (test) => [...(test.after ?? "").replace(COMMENT, "").matchAll(IMPORTED)].flatMap(([, , spec]) => {
+	const relative = /^\.\.?(\/|$)/.test(spec);
+	const tail = ALIAS.test(spec);
+	const path = relative ? posix.join(posix.dirname(test.path), spec) : spec.replace(ALIAS, "");
+	return [path, path.replace(EXTENSION, "")].map((p) => ({
+		path: p,
+		tail
+	}));
+});
+const reaches = (imports, added) => namesOf(added).some((name) => imports.some(({ path, tail }) => name === path || tail && name.endsWith(`/${path}`)));
+const named = (id, text) => new RegExp(`(?<![\\w-])${id}(?!\\d)`).test(text);
+/** The lines `change` added: an ID an earlier change left in the file does not count. */
+const addedLines = (change) => {
+	const before = new Set((change.before ?? "").split("\n"));
+	return change.after.split("\n").filter((line) => !before.has(line)).join("\n");
+};
+/**
+* Why `tip`'s tests fall short, or `undefined`: a criterion ID of `file` no
+* test line of the pass names, or a test importing a file the pass added —
+* naive structure a reset and refactor replaces, which the tests must survive.
+*/
+const acceptanceFault = (file, tip) => {
+	const ids = (criteriaOf(read(file) ?? "") ?? []).map((c) => c.id).filter((id) => id !== "");
+	const tests = tip.changes.filter((c) => c.after !== void 0 && isCode$1(c.path) && isTestFile(c.path));
+	const lines = tests.map(addedLines);
+	const untested = ids.filter((id) => !lines.some((text) => named(id, text)));
+	if (untested.length > 0) return `acceptance-tests: no test of the naive pass names ${untested.join(", ")} — write a behaviour-level test for each criterion with its ID in the test or scenario name, e.g. "[${untested[0]}] …"`;
+	const added = tip.changes.filter((c) => c.status === "added" && isCode$1(c.path) && !isTestFile(c.path)).map((c) => c.path);
+	const reaching = tests.filter((test) => holdsCallSites(test.path)).flatMap((test) => {
+		const imports = importsOf(test);
+		return added.filter((path) => reaches(imports, path)).map((path) => `  - ${test.path} → ${path}`);
+	});
+	if (reaching.length > 0) return `acceptance-internals: these tests import files the naive pass added — test through code that existed before it (a public entry point, an existing module's exports):\n${reaching.join("\n")}`;
+};
+const restore = (path) => `if git cat-file -e ${quote(`HEAD:${path}`)} 2>/dev/null; then git checkout -q HEAD -- ${quote(path)}; else rm -f -- ${quote(path)}; fi`;
+/**
+* Run the suite with `tip`'s diff applied, then take it out again; resolves
+* `true` when green. The pass's paths go back to HEAD before (an interrupted
+* run left them applied) and after; afterwards so does anything else the run
+* changed, judged against what was already dirty, which is left alone.
+*/
+const naiveGreen = (tip) => {
+	const paths = tip.changes.map((c) => restore(c.path));
+	return check("check", [
+		...paths,
+		"dirty=$(git -c core.quotePath=false ls-files -m -d -o --exclude-standard)",
+		`if ! git diff --binary ${quote(`${tip.hash}^`)} ${quote(tip.hash)} -- | git apply; then`,
+		"  echo 'gtd: the kept naive pass no longer applies to HEAD; no test ran'",
+		"  exit 1",
+		"fi",
+		"(",
+		env.testCommand ?? "",
+		")",
+		"code=$?",
+		...paths,
+		"git -c core.quotePath=false ls-files -m -d -o --exclude-standard | while IFS= read -r path; do",
+		"  printf '%s\\n' \"$dirty\" | grep -qxF -- \"$path\" && continue",
+		"  if git cat-file -e \"HEAD:$path\" 2>/dev/null; then git checkout -q HEAD -- \"$path\"; else rm -f -- \"$path\"; fi",
+		"done",
+		"exit \"$code\""
+	].join("\n"), {
+		report: FEEDBACK,
+		label: "Running the naive pass's tests"
+	});
+};
 function implement(first, tier, amend) {
 	const options = typeof first === "object" && first !== null ? first : {
 		reference: first,
@@ -767,36 +851,76 @@ function implement(first, tier, amend) {
 		await run("closing", removeScript([REQUIREMENTS]), { label: "Closing out the implementation" });
 	});
 }
-const decide = () => scope("seam", async () => {
-	let rejection;
+/** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
+const steer = async (retry) => {
+	await human("steer", {
+		message: seamSteerMessage(retry),
+		label: "Steer or overrule the naive pass",
+		file: REQUIREMENTS,
+		acceptClean: true
+	});
+	if (changes().length === 0) return false;
+	requireCriteria(REQUIREMENTS);
+	return true;
+};
+/** Rejects, test faults and red checks share one budget; a steer or an overrule refills it. */
+const budget = () => {
 	let retries = 0;
-	for (;;) {
-		await naivePass(rejection);
-		const tip = kept("naive");
-		const shape = await judgeSeam(tip);
-		if (shape.choice === "land") return { reference: tip.hash };
-		if (shape.choice === "refactor-first") return {
-			reference: tip.hash,
-			shape
-		};
-		rejection = {
-			strays: shape.strays,
-			p: shape.judgment?.answers.shape?.p ?? 0
-		};
+	return async (next) => {
 		if (retries < NAIVE_RETRIES) {
 			retries++;
-			continue;
+			return {
+				kind: "retry",
+				retry: next
+			};
 		}
-		await human("steer", {
-			message: seamSteerMessage(rejection),
-			label: "Steer or overrule the rejected naive pass",
-			file: REQUIREMENTS,
-			acceptClean: true
-		});
-		if (changes().length === 0) return { reference: tip.hash };
-		requireCriteria(REQUIREMENTS);
-		rejection = void 0;
+		const steered = await steer(next);
 		retries = 0;
+		if (read(".gtd/FEEDBACK.md") !== void 0) await run("clear", removeScript([FEEDBACK]), { label: "Clearing the red check" });
+		return { kind: steered ? "steered" : "overruled" };
+	};
+};
+/** Sends a pass whose tests fall short or run red back (`undefined`: it goes on, an overruled one as it is). */
+const vetted = async (tip, vetting) => {
+	const fault = vetting.waived ? void 0 : acceptanceFault(REQUIREMENTS, tip);
+	if (fault !== void 0) {
+		const verdict = await vetting.again({
+			fault,
+			hash: tip.hash
+		});
+		if (verdict.kind !== "overruled") return verdict;
+		vetting.waived = true;
+	}
+	if (await naiveGreen(tip)) return void 0;
+	const verdict = await vetting.again({ red: tip.hash });
+	return verdict.kind === "overruled" ? void 0 : verdict;
+};
+/** The judge's ruling on a vetted pass: the decision, or the next attempt's verdict. */
+const ruled = async (tip, again) => {
+	const shape = await judgeSeam(tip);
+	if (shape.choice === "land") return { reference: tip.hash };
+	if (shape.choice === "refactor-first") return {
+		reference: tip.hash,
+		shape
+	};
+	const next = await again({
+		strays: shape.strays,
+		p: shape.judgment?.answers.shape?.p ?? 0
+	});
+	return next.kind === "overruled" ? { reference: tip.hash } : next;
+};
+const decide = () => scope("seam", async () => {
+	const vetting = {
+		again: budget(),
+		waived: false
+	};
+	let retry;
+	for (;;) {
+		await naivePass(retry);
+		const tip = kept("naive");
+		const outcome = await vetted(tip, vetting) ?? await ruled(tip, vetting.again);
+		if (!("kind" in outcome)) return outcome;
+		retry = outcome.kind === "retry" ? outcome.retry : void 0;
 	}
 });
 const seamBuild = async (base) => {
@@ -898,4 +1022,4 @@ const feature = shipped(ordinaryStart);
 //#region src/workflows/feature/index.ts
 var feature_default = feature;
 //#endregion
-export { REFACTOR_PACKAGE, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, collecting, criteriaOf, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, implement, judgeSeam, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, statedCriteria, steering, summary, triage, unwind };
+export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, collecting, criteriaOf, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, holdsCallSites, implement, isTestFile, judgeSeam, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, statedCriteria, steering, summary, triage, 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 { D as agentWithSkills, H as fixReviewNotesPrompt, V as finisherSystem, _ as REVIEW, c as baseline, i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-2fV0mj14.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-BynhCfuv.mjs";
+import { D as agentWithSkills, H as fixReviewNotesPrompt, V as finisherSystem, _ as REVIEW, c as baseline, i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-BU5Zi-nX.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-DuXanjIY.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 { i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, tt as reviewGateBlockedMessage, u as gate, ut as envDefaults } from "../chunks/reserved-2fV0mj14.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-BynhCfuv.mjs";
+import { i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, tt as reviewGateBlockedMessage, u as gate, ut as envDefaults } from "../chunks/reserved-BU5Zi-nX.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-DuXanjIY.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 { ft as flagMentions, gt as requireFlag, i as skills, lt as defaults, mt as flipProblems, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, ut as envDefaults, y as coder } from "../chunks/reserved-2fV0mj14.mjs";
+import { ft as flagMentions, gt as requireFlag, i as skills, lt as defaults, mt as flipProblems, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, ut as envDefaults, y as coder } from "../chunks/reserved-BU5Zi-nX.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.";