@pmelab/gtd 32.1.0 → 34.0.0

package/dist/workflows.mjs

@@ -1,3 +1,4 @@
+import { posix } from "node:path";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -17212,6 +17213,17 @@ carries it.
 What each change does next (then run \`gtd land\`):
 - **Continue** — having undone the sketch by hand, check the test baseline is green and start triage (**start-gate.check**).
 `;
+const qualityUnresolvedMessage = () => `The quality lap's fix turns hit their cap and \`.gtd/QUALITY.md\` still
+holds findings. Nothing reviews the change after this, so the process
+will not end with them open.
+
+Fix what matters by hand, then delete or empty \`.gtd/QUALITY.md\` —
+dropping a finding is your call to make.
+
+What each change does next (then run \`gtd land\`):
+- **Delete or empty \`.gtd/QUALITY.md\`** — the suite runs on your edits, then the process ends (**idle**).
+- **Anything else** — rests here again.
+`;
 const startGateBlockedMessage = () => `The test baseline is red — gtd will not start new work on a broken suite.
 \`.gtd/FEEDBACK.md\` holds the failing output.
 
@@ -17999,24 +18011,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)}
@@ -18041,8 +18076,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\`):
@@ -38473,7 +38541,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", {
@@ -38481,12 +38549,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,
@@ -38513,36 +38664,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) => {
@@ -38580,7 +38771,7 @@ const unwind = () => {
 	const commit = head$1();
 	return run("unwind", revertScript(commit, FEEDBACK, unwindFailure(commit)), { label: "Unwinding your input" });
 };
-/** A judged naive pass (none with `flagMode` off), then implement and review until a review round signs off; design must have run since `firstBase`. */
+/** A judged naive pass (none with `flagMode` off), then implement and the quality lap; design must have run since `firstBase`. */
 const buildFeature = async (firstBase) => {
 	const tier = riskTierOn() ? recordRisk() : void 0;
 	const seam = flagModeOn() ? await seamBuild(firstBase) : { base: firstBase };
@@ -38591,18 +38782,31 @@ const buildFeature = async (firstBase) => {
 			afterRefactor: seam.refactored
 		});
 		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path)) ? firstBase : seam.base;
-		await featureFeedback(await buildTail(base, {
+		await tail(settleQuality, {
 			green: true,
 			lensBase: base
-		}), base);
+		});
 	});
 };
+const settleQuality = async () => {
+	let rested = false;
+	while ((read(".gtd/QUALITY.md") ?? "").length > 0) {
+		rested = true;
+		await human("quality-unresolved", {
+			message: qualityUnresolvedMessage(),
+			label: "Quality findings left unresolved",
+			file: QUALITY
+		});
+	}
+	if (rested) await healthy(() => fixCheck());
+};
 /** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
 const planAndBuild = async (firstBase, stated) => {
 	if (!await skipDesign(riskTierOn() ? void 0 : stated)) await design(firstBase);
 	await buildFeature(firstBase);
 };
-const featureFeedback = async (first, lensBase) => {
+/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
+const afterTail = async (first) => {
 	let outcome = first;
 	while (outcome.verdict === "feedback") {
 		await reUnwind(outcome);
@@ -38613,13 +38817,10 @@ const featureFeedback = async (first, lensBase) => {
 		});
 		outcome = await buildTail(outcome.base, {
 			green: true,
-			lap: "feedback",
-			lensBase
+			lap: "feedback"
 		});
 	}
 };
-/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
-const afterTail = (outcome) => featureFeedback(outcome);
 /** An ordinary start: wait at `idle`, unwind the sketch, check the baseline, then plan and build. */
 const ordinaryStart = async () => {
 	await human("idle", {
@@ -38823,4 +39024,4 @@ var workflows_default = feature;
 */
 const doors = {};
 //#endregion
-export { ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, QUALITY, REFACTOR, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, ShippedOptions, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeReview, coder, collecting, criteriaOf, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, implement, judgeSeam, lensEntriesOf, lensOf, lensesOf, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, statedCriteria, steering, summary, tail, threads, triage, unwind };
+export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, QUALITY, REFACTOR, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeReview, coder, collecting, criteriaOf, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, statedCriteria, steering, summary, tail, threads, triage, unwind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "32.1.0",
+  "version": "34.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/skills/authoring/SKILL.md

@@ -224,8 +224,8 @@ workflow.
 
 In the bundled default, `planAndBuild` runs the design phase, then
 `buildFeature`: the naive pass and its seam judge, then the implementation and
-review. Add a human sign-off before the first build (a review feedback lap
-re-runs design inside `buildFeature` and does not pass it again):
+the quality lap, ending with no human review. Add a human sign-off before the
+build:
 
 ```ts
 const planAndBuild = async (firstBase: string): Promise<void> => {

package/src/testkit/steps.ts

@@ -108,6 +108,10 @@ Given("a file {string} with:", (world: TestkitWorld, path: string, content: stri
   world.repo().write(path, withNewline(content))
 })
 
+Given("the file {string} is deleted", (world: TestkitWorld, path: string) => {
+  world.repo().remove(path)
+})
+
 Given("the working tree is committed as {string}", (world: TestkitWorld, message: string) => {
   world.repo().commit(message)
 })

package/src/workflows/feature/acceptance-criteria.feature

@@ -86,6 +86,14 @@ Feature: acceptance criteria carry stable IDs, and a sketch that states clear on
         - AC-1: `greeting` reads "Hello, world".
         """
       And step "design.gate.answer" changes nothing
+      And step "seam.check" changes nothing
+      And step "seam.naive" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds", () => {})
+        it("[AC-2] holds", () => {})
+        it("[AC-3] holds", () => {})
+        it("[AC-7] holds", () => {})
+        """
       And step "seam.naive" writes "src/greeting.ts" with:
         """
         export const greeting = "Hello, world"

package/src/workflows/feature/fast-path.feature

@@ -2,8 +2,8 @@
 Feature: a trivial change takes the same few beats at either risk tier, flag-free at low
 
   With GTD_FLAG_RISK_TIER on, a one-line copy fix goes
-  from idle through the naive pass, the seam judge's land, implement and human
-  review back to idle. Low tier walks exactly the steps high does; only the
+  from idle through the naive pass, the seam judge's land, implement and the
+  quality lap back to idle. Low tier walks exactly the steps high does; only the
   implementation prompt and the summary differ.
 
   Background:
@@ -27,18 +27,6 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
     And step "build.quality.correctness.reviewing" changes nothing
-    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## greeting
-
-      - [ ] ./src/greeting.ts#1-1
-        typo fixed
-      """
-    And step "build.review.closing" runs its script
 
   Scenario Outline: a one-line fix runs idle to idle with the same beats at either tier
     Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
@@ -57,7 +45,12 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
     Then the process rests at "seam.naive"
     And the last commit subject is "gtd(human): design.gate.answer → seam.naive"
 
-    Given step "seam.naive" writes "src/greeting.ts" with:
+    Given step "seam.check" changes nothing
+    And step "seam.naive" writes "src/acceptance.test.ts" with:
+      """
+      it("[AC-1] holds", () => {})
+      """
+    And step "seam.naive" writes "src/greeting.ts" with:
       """
       export const greeting = "Hello, world"
       """
@@ -75,21 +68,6 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
       export const greeting = "Hello, world!"
       """
     When the process is driven
-    Then the process rests at "build.review.await-review"
-
-    Given a file ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## greeting
-
-      - [x] ./src/greeting.ts#1-1
-        typo fixed
-      """
-    When gtd lands
-    And the process is driven
     Then the process rests at "idle"
     And "src/greeting.ts" contains "Hello, world!"
     And the commit subjects end with:
@@ -99,15 +77,13 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
       gtd(check): start-gate.check → design.triage
       gtd(agent): design.triage → design.gate.answer
       gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive → seam.judge
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
       gtd(judge): seam.judge → implement.building
       gtd(agent): implement.building → implement.health.check
       gtd(check): implement.health.check → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.await-review
-      gtd(human): build.review.await-review → build.review.closing
-      gtd(check): build.review.closing → idle
+      gtd(agent): build.quality.correctness.reviewing → idle
       """
     And the output of gtd "summary" <summary> "needs a human reviewer"