@pmelab/gtd 35.0.0 → 36.0.0

package/dist/workflows.mjs

@@ -214,25 +214,21 @@ const checkScript = (command, options) => {
 		""
 	].join("\n");
 };
-/**
-* Reverse-apply `commit`'s changes to the working tree. A failure — the
-* patch no longer applies — writes `failure` and git's error to `report`,
-* since a failed revert and one with nothing to undo both leave the tree clean.
-*/
-const revertScript = (commit, report, failure) => {
+const patchScript = (commit, report, failure, reverse, exclude = []) => {
+	const paths = exclude.length === 0 ? "" : ` . ${exclude.map((p) => quote(`:(exclude,literal)${p}`)).join(" ")}`;
 	const range = `${quote(`${commit}^`)} ${quote(commit)}`;
 	const error = quote(`${report}.output`);
 	return [
 		"#!/usr/bin/env sh",
 		"set +e",
-		`if ! git diff --quiet ${range} --; then`,
+		`if ! git diff --quiet ${range} --${paths}; then`,
 		`  mkdir -p "$(dirname ${quote(report)})"`,
-		`  git diff --binary ${range} -- | git apply -R 2> ${error}`,
+		`  git diff --binary --no-color --no-ext-diff --no-textconv --src-prefix=a/ --dst-prefix=b/ ${range} --${paths} | git apply --whitespace=nowarn${reverse ? " -R" : ""} 2> ${error}`,
 		"  code=$?",
 		"  if [ \"$code\" -ne 0 ]; then",
 		"    {",
 		`      printf '%s\\n\\n' ${quote(failure)}`,
-		`      if [ -s ${error} ]; then cat ${error}; else printf 'Reverting it exited %s and produced no output.\\n' "$code"; fi`,
+		`      if [ -s ${error} ]; then cat ${error}; else printf '${reverse ? "Reverting" : "Applying"} it exited %s and produced no output.\\n' "$code"; fi`,
 		`    } > ${quote(report)}`,
 		"  fi",
 		`  rm -f ${error}`,
@@ -241,6 +237,14 @@ const revertScript = (commit, report, failure) => {
 	].join("\n");
 };
 /**
+* Reverse-apply `commit`'s changes to the working tree. A failure — the
+* patch no longer applies — writes `failure` and git's error to `report`,
+* since a failed revert and one with nothing to undo both leave the tree clean.
+*/
+const revertScript = (commit, report, failure) => patchScript(commit, report, failure, true);
+/** Apply `commit`'s changes outside `exclude` to the working tree; a failure is reported as `revertScript`'s is. */
+const applyScript = (commit, report, failure, exclude = []) => patchScript(commit, report, failure, false, exclude);
+/**
 * Undo the edits one commit made to `paths`: each goes back to its content
 * before `commit` — or away, when `commit` added it — but only while it is
 * still exactly as `commit` left it. A path changed since is left alone.
@@ -17188,6 +17192,7 @@ const agentWithSkills = (name, prompt, options = {}) => {
 	return agent(name, withSkills(skillsFor(name).join(", "), body), options);
 };
 const unwindFailure = (commit) => `gtd could not unwind ${commit} out of your working tree.`;
+const naiveApplyFailure = (commit) => `gtd could not apply the naive pass ${commit} to the working tree; it is built fresh instead.`;
 const idleMessage = () => `No active gtd process.
 
 To start one, make ANY change — a hand-edit to real code, a scratch
@@ -18036,8 +18041,8 @@ 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
+  restructure, abstract or refactor around the change; it may land exactly as
+  you leave it, and a reviewer makes it fit
 - 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
@@ -18087,12 +18092,13 @@ 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
+/** `judged`: whether an overruled pass still meets the seam judge (`flagMode` on). */
+const seamSteerMessage = (retry, judged = true) => 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
+  \`seam.check\` runs its suite and ${judged ? "the seam judge rules on its shape" : "it lands as the implementation"}. 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
@@ -18103,7 +18109,7 @@ 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
+  ${judged ? "the seam judge rules on its shape" : "it lands as the implementation"}, 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.
 
@@ -18119,9 +18125,8 @@ 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 (the risk tier stays as the
   design gate settled it; a tier edit here is not applied)
-- **Overrule** — land a clean tree to accept the last attempt's approach:
-  the implementation is built against it as reference, with no seam gate
-  and no refactor. Risk: this ships the seam the judge objected to,
+- **Overrule** — land a clean tree to accept the last attempt as it is: it
+  lands as the implementation, with no seam gate and no refactor. Risk: this ships the seam the judge objected to,
   unaddressed — the choice is recorded in history.
 
 An edit together with an approval counts as steer. Only
@@ -38728,7 +38733,7 @@ const naiveGreen = (tip) => {
 	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`,
+		`if ! git diff --binary --no-color --no-ext-diff --no-textconv --src-prefix=a/ --dst-prefix=b/ ${quote(`${tip.hash}^`)} ${quote(tip.hash)} -- | git apply --whitespace=nowarn; then`,
 		"  echo 'gtd: the kept naive pass no longer applies to HEAD; no test ran'",
 		"  exit 1",
 		"fi",
@@ -38747,6 +38752,11 @@ const naiveGreen = (tip) => {
 		label: "Running the naive pass's tests"
 	});
 };
+/** Resolves `false` when the tip no longer applies (the failure is in `.gtd/FEEDBACK.md`) or has nothing outside `.gtd/` to apply. */
+const applied = async (tip) => {
+	await run("applying", applyScript(tip, FEEDBACK, naiveApplyFailure(tip), [".gtd"]), { label: "Applying the naive pass" });
+	return !wrote(".gtd/FEEDBACK.md") && codeChanges().length > 0;
+};
 function implement(first, tier, amend) {
 	const options = typeof first === "object" && first !== null ? first : {
 		reference: first,
@@ -38754,7 +38764,7 @@ function implement(first, tier, amend) {
 		amend
 	};
 	return scope("implement", async () => {
-		await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor, flagModeOn()), {
+		if (options.naive === void 0 || !await applied(options.naive)) await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor, flagModeOn()), {
 			label: "Implementing",
 			model: coder(),
 			system: builderSystem(),
@@ -38769,7 +38779,7 @@ function implement(first, tier, amend) {
 /** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
 const steer = async (retry) => {
 	await human("steer", {
-		message: seamSteerMessage(retry),
+		message: seamSteerMessage(retry, flagModeOn()),
 		label: "Steer or overrule the naive pass",
 		file: REQUIREMENTS,
 		acceptClean: true
@@ -38833,7 +38843,7 @@ const decide = () => scope("seam", async () => {
 	for (;;) {
 		await naivePass(retry);
 		const tip = kept("naive");
-		const outcome = await vetted(tip, vetting) ?? await ruled(tip, vetting.again);
+		const outcome = await vetted(tip, vetting) ?? (flagModeOn() ? await ruled(tip, vetting.again) : { reference: tip.hash });
 		if (!("kind" in outcome)) return outcome;
 		retry = outcome.kind === "retry" ? outcome.retry : void 0;
 	}
@@ -38842,7 +38852,8 @@ const seamBuild = async (base) => {
 	const { reference, shape } = await decide();
 	if (shape === void 0) return {
 		reference,
-		base
+		base,
+		land: true
 	};
 	if (shape.unreadable.length > 0) {
 		await scope("seam", () => human("by-hand", {
@@ -38873,15 +38884,16 @@ 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 the quality lap; design must have run since `firstBase`. */
+/** A naive pass (judged only with `flagMode` on), 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 };
+	const seam = await seamBuild(firstBase);
 	await slice("feature", async () => {
 		await implement({
 			reference: seam.reference,
 			tier,
-			afterRefactor: seam.refactored
+			afterRefactor: seam.refactored,
+			naive: seam.land === true ? seam.reference : void 0
 		});
 		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path)) ? firstBase : seam.base;
 		await tail(settleQuality, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "35.0.0",
+  "version": "36.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

@@ -223,9 +223,9 @@ workflow.
 ## Worked example: add an approval gate before building
 
 In the bundled default, `planAndBuild` runs the design phase, then
-`buildFeature`: the naive pass and its seam judge, then the implementation and
-the quality lap, ending with no human review. Add a human sign-off before the
-build:
+`buildFeature`: the naive pass and its seam judge, then the implementation (the
+pass itself on `land`) and 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/flows/scripts.ts

@@ -55,25 +55,31 @@ export const checkScript = (command: string, options: CheckScriptOptions): strin
   ].join("\n")
 }
 
-/**
- * Reverse-apply `commit`'s changes to the working tree. A failure — the
- * patch no longer applies — writes `failure` and git's error to `report`,
- * since a failed revert and one with nothing to undo both leave the tree clean.
- */
-export const revertScript = (commit: string, report: string, failure: string): string => {
+const patchScript = (
+  commit: string,
+  report: string,
+  failure: string,
+  reverse: boolean,
+  exclude: readonly string[] = [],
+): string => {
+  const paths =
+    exclude.length === 0
+      ? ""
+      : ` . ${exclude.map((p) => quote(`:(exclude,literal)${p}`)).join(" ")}`
   const range = `${quote(`${commit}^`)} ${quote(commit)}`
   const error = quote(`${report}.output`)
   return [
     "#!/usr/bin/env sh",
     "set +e",
-    `if ! git diff --quiet ${range} --; then`,
+    `if ! git diff --quiet ${range} --${paths}; then`,
     `  mkdir -p "$(dirname ${quote(report)})"`,
-    `  git diff --binary ${range} -- | git apply -R 2> ${error}`,
+    // Pinned flags: a user's diff.noprefix, color.ui, diff.external, textconv or apply.whitespace would change the patch.
+    `  git diff --binary --no-color --no-ext-diff --no-textconv --src-prefix=a/ --dst-prefix=b/ ${range} --${paths} | git apply --whitespace=nowarn${reverse ? " -R" : ""} 2> ${error}`,
     "  code=$?",
     '  if [ "$code" -ne 0 ]; then',
     "    {",
     `      printf '%s\\n\\n' ${quote(failure)}`,
-    `      if [ -s ${error} ]; then cat ${error}; else printf 'Reverting it exited %s and produced no output.\\n' "$code"; fi`,
+    `      if [ -s ${error} ]; then cat ${error}; else printf '${reverse ? "Reverting" : "Applying"} it exited %s and produced no output.\\n' "$code"; fi`,
     `    } > ${quote(report)}`,
     "  fi",
     `  rm -f ${error}`,
@@ -82,6 +88,22 @@ export const revertScript = (commit: string, report: string, failure: string): s
   ].join("\n")
 }
 
+/**
+ * Reverse-apply `commit`'s changes to the working tree. A failure — the
+ * patch no longer applies — writes `failure` and git's error to `report`,
+ * since a failed revert and one with nothing to undo both leave the tree clean.
+ */
+export const revertScript = (commit: string, report: string, failure: string): string =>
+  patchScript(commit, report, failure, true)
+
+/** Apply `commit`'s changes outside `exclude` to the working tree; a failure is reported as `revertScript`'s is. */
+export const applyScript = (
+  commit: string,
+  report: string,
+  failure: string,
+  exclude: readonly string[] = [],
+): string => patchScript(commit, report, failure, false, exclude)
+
 /**
  * Undo the edits one commit made to `paths`: each goes back to its content
  * before `commit` — or away, when `commit` added it — but only while it is

package/src/testkit/FlowScripts.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest"
 import {
+  applyScript,
   checkScript,
   moveScript,
   removeScript,
@@ -178,6 +179,63 @@ for (const makeTier of gitTiers) {
       })
     })
 
+    describe("applyScript", () => {
+      it("replays a commit's modifications, additions and deletions onto the working tree", () => {
+        t.seed.commit("feat: base", { "mod.txt": "before", "gone.txt": "g" })
+        t.seed.writeFile("mod.txt", "after")
+        t.seed.writeFile("added.txt", "new")
+        t.seed.deleteFile("gone.txt")
+        t.seed.stageAll()
+        t.seed.commit("feat: change", {})
+        const commit = t.observe.resolveRef("HEAD")
+        t.seed.writeFile("gone.txt", "g")
+        t.seed.deleteFile("added.txt")
+        t.seed.stageAll()
+        t.seed.commit("revert: change", { "mod.txt": "before" })
+        const head = t.observe.resolveRef("HEAD")
+        expect(run(applyScript(commit, REPORT, "could not apply")).ok).toBe(true)
+        expect(read("mod.txt")).toBe("after")
+        expect(read("added.txt")).toBe("new")
+        expect(read("gone.txt")).toBeUndefined()
+        expect(read(REPORT)).toBeUndefined()
+        expect(t.observe.resolveRef("HEAD")).toBe(head)
+      })
+
+      it("leaves excluded paths as they are", () => {
+        t.seed.commit("feat: base", { "a.txt": "a0", ".gtd/R.md": "r0" })
+        t.seed.commit("feat: change", { "a.txt": "a1", ".gtd/R.md": "r1", ".gtd/new.md": "n" })
+        const commit = t.observe.resolveRef("HEAD")
+        t.seed.commit("revert: change", { "a.txt": "a0", ".gtd/R.md": "r2" })
+        t.seed.commitDeletion(".gtd/new.md", "revert: change")
+        expect(run(applyScript(commit, REPORT, "could not apply", [".gtd"])).ok).toBe(true)
+        expect(read(REPORT)).toBeUndefined()
+        expect(read("a.txt")).toBe("a1")
+        expect(read(".gtd/R.md")).toBe("r2")
+        expect(read(".gtd/new.md")).toBeUndefined()
+      })
+
+      it("does nothing for a commit with nothing to apply", () => {
+        t.seed.commit("feat: empty", {})
+        const commit = t.observe.resolveRef("HEAD")
+        expect(run(applyScript(commit, REPORT, "could not apply")).ok).toBe(true)
+        expect(read(REPORT)).toBeUndefined()
+        expect(t.observe.statusPorcelain()).toBe("")
+      })
+
+      it("reports a commit that cannot apply, leaving the tree untouched", () => {
+        t.seed.commit("feat: base", { "a.txt": "a0" })
+        t.seed.commit("feat: change", { "a.txt": "a1", "b.txt": "b1" })
+        const commit = t.observe.resolveRef("HEAD")
+        t.seed.commitDeletion("b.txt", "revert: change")
+        t.seed.commit("revert: change", { "a.txt": "a0" })
+        t.seed.writeFile("b.txt", "other")
+        expect(run(applyScript(commit, REPORT, "could not apply")).ok).toBe(true)
+        expect(read(REPORT)).toMatch(/^could not apply\n\n\S/)
+        expect(read("a.txt")).toBe("a0")
+        expect(read("b.txt")).toBe("other")
+      })
+    })
+
     describe("checkScript", () => {
       const options = { report: REPORT, stamp: "abc1234" }
 

package/src/testkit/FlowScripts.ts

@@ -5,6 +5,7 @@
 // `sh` and this twin, so the two cannot drift apart silently.
 
 import {
+  applyScript,
   checkScript,
   moveScript,
   removeScript,
@@ -129,44 +130,80 @@ const recognizeRestore = (repo: InMemRepo, script: string): FlowScriptResult | u
 
 const PATCH_FAILED = "error: patch does not apply"
 
+const outside = (path: string, exclude: readonly string[]): boolean =>
+  !exclude.some((e) => path === e || path.startsWith(`${e}/`))
+
+/** Why `path` blocks the patch, `undefined` when it is exactly as `from` has it. */
+const blocking = (repo: InMemRepo, path: string, from: string, to: string): string | undefined => {
+  const expected = repo.fileAtRef(from, path)
+  const current = repo.readFile(path) ?? null
+  if (current === expected) return undefined
+  if (current === null || expected === null || repo.fileAtRef(to, path) === null) {
+    return `${PATCH_FAILED}: ${path}`
+  }
+  throw new Error(
+    `testkit: cannot tell in memory whether the patch of ${from}..${to} applies to the hand-edited ${path} — run this @live`,
+  )
+}
+
 /**
- * `git diff C^ C | git apply -R`, which is all or nothing. A file still
- * exactly as `C` left it reverts; a file gone, or one `C` added and that
- * changed since, fails the whole patch. A file `C` modified and that changed
- * since may still apply through its context — that needs real git, so it
- * throws rather than guess.
+ * `git diff C^ C | git apply [-R]`, which is all or nothing. A file exactly
+ * as the side being undone (`from`) has it moves to the other side (`to`); a
+ * file missing where `from` has one, or present where `from` has none, fails
+ * the whole patch. A file both sides have that differs from `from` may still
+ * apply through its context — that needs real git, so `blocking` throws
+ * rather than guess.
  */
-const reverseApply = (repo: InMemRepo, commit: string): string | undefined => {
+const patch = (
+  repo: InMemRepo,
+  commit: string,
+  reverse: boolean,
+  exclude: readonly string[],
+): string | undefined => {
   const parent = `${commit}^`
+  const [from, to] = reverse ? [commit, parent] : [parent, commit]
   const paths = new Set([...repo.pathsAtRef(parent), ...repo.pathsAtRef(commit)])
-  const changed = [...paths].filter((p) => repo.fileAtRef(parent, p) !== repo.fileAtRef(commit, p))
+  const changed = [...paths].filter(
+    (p) => repo.fileAtRef(parent, p) !== repo.fileAtRef(commit, p) && outside(p, exclude),
+  )
   for (const path of changed) {
-    const after = repo.fileAtRef(commit, path)
-    const current = repo.readFile(path) ?? null
-    if (current === after) continue
-    if (current === null || after === null || repo.fileAtRef(parent, path) === null) {
-      return `${PATCH_FAILED}: ${path}`
-    }
-    throw new Error(
-      `testkit: cannot tell in memory whether reverting ${commit} applies to the hand-edited ${path} — run this @live`,
-    )
+    const error = blocking(repo, path, from, to)
+    if (error !== undefined) return error
   }
   for (const path of changed) {
-    const before = repo.fileAtRef(parent, path)
-    if (before === null) repo.deleteFile(path)
-    else repo.writeFile(path, before)
+    const content = repo.fileAtRef(to, path)
+    if (content === null) repo.deleteFile(path)
+    else repo.writeFile(path, content)
   }
   return undefined
 }
 
-const recognizeRevert = (repo: InMemRepo, script: string): FlowScriptResult | undefined => {
+interface ParsedPatch {
+  readonly commit: string
+  readonly failure: string
+  readonly report: string
+  readonly exclude: readonly string[]
+}
+
+const parsePatch = (script: string): ParsedPatch | undefined => {
   const lines = script.split("\n")
-  const [, commit] = words(lines.find((l) => l.startsWith("if ! git diff --quiet ")) ?? "")
+  const [, commit, ...pathspecs] = words(
+    lines.find((l) => l.startsWith("if ! git diff --quiet ")) ?? "",
+  )
   const [, failure] = words(lines.find((l) => l.includes("printf '%s\\n\\n' ")) ?? "")
   const [report] = words(lines.find((l) => l.startsWith("    } > ")) ?? "")
   if (commit === undefined || failure === undefined || report === undefined) return undefined
-  if (revertScript(commit, report, failure) !== script) return undefined
-  const error = reverseApply(repo, commit)
+  const exclude = pathspecs.map((p) => p.replace(/^:\(exclude,literal\)/, ""))
+  return { commit, failure, report, exclude }
+}
+
+const recognizePatch = (repo: InMemRepo, script: string): FlowScriptResult | undefined => {
+  const parsed = parsePatch(script)
+  if (parsed === undefined) return undefined
+  const { commit, failure, report, exclude } = parsed
+  const reverse = revertScript(commit, report, failure) === script
+  if (!reverse && applyScript(commit, report, failure, exclude) !== script) return undefined
+  const error = patch(repo, commit, reverse, reverse ? [] : exclude)
   if (error !== undefined) repo.writeFile(report, `${failure}\n\n${error}\n`)
   return ok()
 }
@@ -319,7 +356,7 @@ export const applyFlowScript = (
     recognizeRemove(repo, script) ??
     recognizeMove(repo, script) ??
     recognizeShow(repo, script) ??
-    recognizeRevert(repo, script) ??
+    recognizePatch(repo, script) ??
     recognizeRestore(repo, script) ??
     recognizeCheck(repo, commands, script)
   )

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

@@ -86,7 +86,6 @@ 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", () => {})
@@ -98,10 +97,15 @@ Feature: acceptance criteria carry stable IDs, and a sketch that states clear on
         """
         export const greeting = "Hello, world"
         """
+      And step "seam.check" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds elsewhere", () => {})
+        """
       And judge step "seam.judge" answers:
         """
         [{"id":"shape","answer":"land","p":0.9}]
         """
+      And step "implement.applying" runs its script
       And step "implement.building" writes ".gtd/REQUIREMENTS.md" with:
         """
         # Requirements

package/src/workflows/feature/coverage.feature

@@ -34,15 +34,18 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       - AC-2: add is unchanged.
       """
     And step "design.gate.answer" changes nothing
-    And step "implement.building" writes "src/calc.ts" with:
+    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
       """
-    And step "implement.building" writes "src/calc.test.ts" with:
+    And step "seam.naive" writes "src/calc.test.ts" with:
       """
       it("[AC-1] subtracts", () => expect(subtract(3, 1)).toBe(2))
+      // AC-2: add is untouched
       """
+    And step "seam.check" changes nothing
+    And step "implement.applying" runs its script
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
 
@@ -61,7 +64,7 @@ Feature: a feature is done only when every acceptance criterion has a passing te
     Then the process rests at "idle"
     And the commit subjects end with:
       """
-      gtd(agent): implement.building → implement.health.check
+      gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → idle

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

@@ -1,10 +1,10 @@
 @inmem
-Feature: a trivial change takes the same few beats at either risk tier, flag-free at low
+Feature: a trivial change takes the same few beats at either risk tier
 
   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 the
-  quality lap back to idle. Low tier walks exactly the steps high does; only the
-  implementation prompt and the summary differ.
+  from idle through the naive pass, the seam judge's land, the applied pass and
+  the quality lap back to idle. Low tier walks exactly the steps high does; only
+  the summary differs.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
@@ -62,18 +62,10 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
       """
       [{"id":"shape","answer":"land","p":0.9}]
       """
-    When the process is driven
-    Then the process rests at "implement.building"
-    And the resting step's content contains "<demand>"
-    And the resting step's content does not contain "<absent>"
-
-    Given step "implement.building" writes "src/greeting.ts" with:
-      """
-      export const greeting = "Hello, world!"
-      """
+    And step "implement.applying" runs its script
     When the process is driven
     Then the process rests at "idle"
-    And "src/greeting.ts" contains "Hello, world!"
+    And "src/greeting.ts" contains "Hello, world"
     And the commit subjects end with:
       """
       gtd(human): idle → unwind
@@ -83,8 +75,8 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
       gtd(human): design.gate.answer → seam.naive
       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(judge): seam.judge → implement.applying
+      gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
@@ -93,6 +85,6 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
     And the output of gtd "summary" <summary> "needs a human reviewer"
 
     Examples:
-      | tier | demand                                             | absent              | summary          |
-      | low  | Add no release flag                                | new release flag    | does not contain |
-      | high | Put the new behaviour behind a new release flag    | Add no release flag | contains         |
+      | tier | summary          |
+      | low  | does not contain |
+      | high | contains         |

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

@@ -365,10 +365,30 @@ describe("flagMode", () => {
     expect((await designed(config("feature({ flagMode: true })"))).state).toBe("seam.naive")
   })
 
-  it("off through GTD_FLAGMODE=false, skips the naive pass and the seam judge", async () => {
-    const rest = await designed(CONFIG_SCAFFOLD, { GTD_FLAGMODE: "false" })
-    expect(rest.state).toBe("implement.building")
-    expect(rest.content).toContain("this project ships without release flags")
+  it("off through GTD_FLAGMODE=false, lands the naive pass with no seam judge", async () => {
+    const repo = testRepo({ workflow: CONFIG_SCAFFOLD, env: { GTD_FLAGMODE: "false" } })
+    repo.write("src/calc.ts", CALC)
+    repo.commit("feat: add calculator")
+    repo.write("TODO.md", "# Add subtract\n")
+    const rest = await repo.drive({
+      unwind: () => undefined,
+      "start-gate.check": () => undefined,
+      "design.triage": (_, r) =>
+        r.write(
+          ".gtd/REQUIREMENTS.md",
+          "# 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`)
+        r.write("src/calc.test.ts", ACCEPTANCE)
+      },
+      "seam.check": () => undefined,
+      "implement.applying": runsItsScript,
+    })
+    expect(rest.state).toBe("implement.health.check")
+    expect(repo.read("src/calc.ts")).toBe(`${CALC}// naive\n`)
+    expect(repo.subjects().some((subject) => subject.includes("seam.judge"))).toBe(false)
   })
 
   it("refuses a value other than true or false before the process starts", async () => {

package/src/workflows/feature/feature.ts

@@ -17,14 +17,15 @@ import * as t from "../shared/text.js"
 import { skipDesign, statedCriteria, type StatedCriteria } from "./criteria.js"
 import { design } from "./planning.js"
 import { buildTail, isCode, reUnwind, type ReviewOutcome } from "./review.js"
-import { implement, seamBuild, type SeamOutcome } from "./seam.js"
+import { implement, seamBuild } from "./seam.js"
 import { recordRisk, riskTierOn } from "./tier.js"
 
 // The ordinary start. Any change to the tree starts a process: `idle` →
 // `unwind` reverts the sketch (its intent survives in history) → a
-// green-baseline gate → design → a judged naive pass (refactoring first when
-// the judge asks; with `flagMode` off, neither) → implement → the quality lap,
-// and the episode ends back at `idle`. Human review is the `review` door's.
+// green-baseline gate → design → a naive pass, judged with `flagMode` on: it
+// lands as the implementation, or (refactoring first when the judge asks) is
+// built fresh from → the health loop → the quality lap, and the episode ends
+// back at `idle`. Human review is the `review` door's.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -36,17 +37,16 @@ export const unwind = (): Promise<void> => {
 
 export { reUnwind }
 
-/** A judged naive pass (none with `flagMode` off), then implement and the quality lap; design must have run since `firstBase`. */
+/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; design must have run since `firstBase`. */
 export const buildFeature = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
-  const seam: Omit<SeamOutcome, "reference"> & { reference?: string } = flagModeOn()
-    ? await seamBuild(firstBase)
-    : { base: firstBase }
+  const seam = await seamBuild(firstBase)
   await slice("feature", async () => {
     await implement({
       reference: seam.reference,
       tier,
       afterRefactor: seam.refactored,
+      naive: seam.land === true ? seam.reference : undefined,
     })
     // An empty feature slice: the refactor carried the feature, so the lap covers the whole change.
     const base =