@pmelab/gtd 32.1.0 → 33.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) => {
@@ -17999,24 +18000,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 +18065,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 +38530,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 +38538,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 +38653,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) => {
@@ -38823,4 +39003,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": "33.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/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

@@ -57,7 +57,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"
       """
@@ -99,7 +104,8 @@ 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

package/src/workflows/feature/feature.test.ts

@@ -47,6 +47,8 @@ const review = (text?: string): string =>
 
 const CALC = "export const add = (a: number, b: number) => a + b\n"
 
+const ACCEPTANCE = 'it("[AC-1] done", () => {})\n'
+
 const naivePlanned = () => {
   const repo = testRepo({
     workflow: CONFIG_SCAFFOLD,
@@ -77,7 +79,11 @@ describe("planAndBuild", () => {
               "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
             ),
           "design.gate.answer": () => undefined,
-          "seam.naive": (_, r) => r.write("src/calc.ts", SUBTRACT),
+          "seam.naive": (_, r) => {
+            r.write("src/calc.ts", SUBTRACT)
+            r.write("src/calc.test.ts", ACCEPTANCE)
+          },
+          "seam.check": () => undefined,
           "seam.judge": () => '[{"id":"shape","answer":"refactor-first","p":0.9}]',
           "refactor.deriving": runsItsScript,
           "refactor.building": (_, r) => r.write("src/calc.ts", SUBTRACT),
@@ -112,7 +118,11 @@ describe("planAndBuild", () => {
       "start-gate.check": () => undefined,
       "design.triage": requirements,
       "design.gate.answer": () => undefined,
-      "seam.naive": (_: unknown, r: typeof repo) => r.write("src/calc.ts", `${CALC}// naive\n`),
+      "seam.naive": (_: unknown, r: typeof repo) => {
+        r.write("src/calc.ts", `${CALC}// naive\n`)
+        r.write("src/calc.test.ts", ACCEPTANCE)
+      },
+      "seam.check": () => undefined,
       "seam.judge": () => '[{"id":"shape","answer":"land","p":0.9}]',
       "implement.building": (_: unknown, r: typeof repo) =>
         r.write("src/calc.ts", `${CALC}// built\n`),
@@ -341,7 +351,10 @@ describe("an in-flight 28.0.0 naive-pass process", () => {
           "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
         ),
       "design.gate.answer": () => undefined,
-      "seam.naive": (_, r) => r.write("src/calc.ts", `${CALC}// naive\n`),
+      "seam.naive": (_, r) => {
+        r.write("src/calc.ts", `${CALC}// naive\n`)
+        r.write("src/calc.test.ts", ACCEPTANCE)
+      },
     })
     const kept = /Gtd-Kept: (\w+)/.exec(repo.messages().at(-1)!)![1]!
     const seen: Record<string, number> = {
@@ -366,16 +379,13 @@ describe("an in-flight 28.0.0 naive-pass process", () => {
     return repo
   }
 
+  // seam.check now follows every naive pass, so no rest past the first naive pass replays.
   for (const [name, trail] of Object.entries(trails)) {
-    const replays = name !== "refactor-first"
-    it(`${name}: ${replays ? "every rest replays to itself" : "every rest from the verdict on fails replay"}`, async () => {
+    it(`${name}: every rest past the naive pass fails replay`, async () => {
       for (let upTo = 1; upTo <= trail.length; upTo++) {
         const rest = trail[upTo - 1]![2]
         const repo = await forged(trail, upTo)
-        if (replays) expect((await repo.next()).state, rest).toBe(rest)
-        else {
-          await expect(repo.next(), rest).rejects.toThrow("the workflow changed under this process")
-        }
+        await expect(repo.next(), rest).rejects.toThrow("the workflow changed under this process")
       }
     })
   }

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

@@ -0,0 +1,140 @@
+@inmem
+Feature: a naive pass ends only when a test names every criterion and the suite is green
+
+  `seam.naive` writes behaviour-level acceptance tests, each naming its
+  criterion's ID. A pass whose tests leave an ID out or import a file the
+  pass added is sent back; `seam.check` then runs the suite with the kept
+  pass applied, and a red run sends it back too, before the judge sees it.
+  Three failed attempts rest at `seam.steer`.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: `subtract(5, 3)` returns 2.
+      - AC-2: `add` still adds.
+      """
+    And step "design.gate.answer" changes nothing
+    And step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+
+  Scenario: a pass whose tests leave a criterion's ID out is sent back, and an overrule runs the check and sticks
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      import { add, subtract } from "../src/calc.js"
+      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the resting step's content contains "acceptance-tests: no test of the naive pass names AC-2"
+
+    Given step "seam.check" changes nothing
+    When gtd lands
+    And the process is driven
+    Then the process rests at "seam.judge"
+    And the commit subjects end with:
+      """
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive
+      gtd(agent): seam.naive
+      gtd(agent): seam.naive → seam.steer
+      gtd(human): seam.steer → seam.check
+      gtd(check): seam.check → seam.judge
+      """
+
+    Given judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"reject","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the resting step's content contains "rejected the last attempt"
+    And the commit subjects end with:
+      """
+      gtd(check): seam.check → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
+      gtd(judge): seam.judge → seam.steer
+      """
+
+  Scenario: a test importing a file the pass added is sent back
+    Given step "seam.naive" writes "src/subtract.ts" with:
+      """
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And step "seam.naive" writes "src/subtract.test.ts" with:
+      """
+      import { subtract } from "./subtract.js"
+      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("[AC-2] still adds", () => {})
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the resting step's content contains "src/subtract.test.ts → src/subtract.ts"
+
+  Scenario: a red suite sends the pass back, and it moves on only once green
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      import { add, subtract } from "../src/calc.js"
+      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("[AC-2] still adds", () => expect(add(1, 1)).toBe(2))
+      """
+    When the process is driven
+    Then the process rests at "seam.check"
+    And the resting step's content contains "git checkout -q HEAD --"
+    And the resting step's content does not contain "'^'"
+    And the resting step's content contains "npm test"
+
+    Given step "seam.naive" is no longer scripted
+    And step "seam.check" writes ".gtd/FEEDBACK.md" with:
+      """
+      FAIL tests/calc.test.ts > [AC-1] subtracts
+      """
+    When the process is driven
+    Then the process rests at "seam.naive"
+    And the resting step's content contains "left the suite red"
+    And ".gtd/FEEDBACK.md" contains "[AC-1] subtracts"
+
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      import { add, subtract } from "../src/calc.js"
+      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("[AC-2] still adds", () => expect(add(2, 2)).toBe(4))
+      """
+    And step "seam.check" from now on changes nothing
+    When the process is driven
+    Then the process rests at "implement.building"
+    And the commit subjects end with:
+      """
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → implement.building
+      """

package/src/workflows/feature/one-step-land.feature

@@ -40,6 +40,11 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       - AC-1: the change behaves as described.
       """
     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", () => {})
+      """
     And step "seam.naive" writes "src/greeting.ts" with:
       """
       export const greeting = "Hello, world"
@@ -93,7 +98,8 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       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
@@ -104,7 +110,7 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       gtd(check): build.review.closing → idle
       """
     And the commit "gtd(human): idle → unwind" has a body containing "Gtd-Var: flag_risk_tier=0"
-    And the commit "gtd(agent): seam.naive → seam.judge" has a body containing "Gtd-Kept:"
+    And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"
     And the commit "gtd(judge): seam.judge → implement.building" has a body containing "\"answer\":\"land\""
     And no commit body contains "Gtd-Approved:"
     And the output lines of gtd "slices" start with:

package/src/workflows/feature/refactor-absorbs.feature

@@ -43,7 +43,12 @@ Feature: a refactor that carried the whole feature still gets a feature review
     And step "design.gate.answer" changes nothing
 
   Scenario: an empty implement turn after a refactor that did it all reaches review and idle
-    Given step "seam.naive" writes "src/calc.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/calc.ts" with:
       """
       export const add = (a: number, b: number) => a + b
       export const subtract = (a: number, b: number) => a - b

package/src/workflows/feature/refactor-first.feature

@@ -42,7 +42,12 @@ Feature: a refactor-first judgment walks one fixed path to idle
     And step "design.gate.answer" changes nothing
 
   Scenario: a refactor-first judgment runs refactor, its review, implement and review to idle
-    Given step "seam.naive" writes "src/calc.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/calc.ts" with:
       """
       export const add = (a: number, b: number) => a + b
       export const subtract = (a: number, b: number) => a - b
@@ -141,7 +146,8 @@ Feature: a refactor-first judgment walks one fixed path to idle
       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 → refactor.deriving
       gtd(check): refactor.deriving → refactor.building
       gtd(agent): refactor.building → refactor.health.check
@@ -158,7 +164,7 @@ Feature: a refactor-first judgment walks one fixed path to idle
       gtd(check): build.review.closing → idle
       """
     And the commit "gtd(human): idle → unwind" has a body containing "Gtd-Var: flag_risk_tier=0"
-    And the commit "gtd(agent): seam.naive → seam.judge" has a body containing "Gtd-Kept:"
+    And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"
     And the commit "gtd(judge): seam.judge → refactor.deriving" has a body containing "\"answer\":\"refactor-first\""
     And no commit body contains "Gtd-Approved:"
     And the output lines of gtd "slices" start with: