@pmelab/gtd 34.0.0 → 36.0.0

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

@@ -0,0 +1,164 @@
+@inmem
+Feature: a feature is done only when every acceptance criterion has a passing test
+
+  Once the implementation's suite is green, implement.coverage asks a judge,
+  per criterion ID of .gtd/REQUIREMENTS.md, whether a test the change added or
+  changed covers it. Every ID covered lets the process close out, the judge's
+  landing marking each as `Gtd-Mark: covers=<id>`. An uncovered ID sends the
+  process back to a covering turn instead; after two, it rests for a person.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And an environment variable "GTD_FLAGMODE" set to "false"
+    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(a, b) returns a - b.
+      - AC-2: add is unchanged.
+      """
+    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
+      """
+    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
+
+  Scenario: the judge asks per criterion over the change's test files
+    When the process is driven
+    Then the process rests at "implement.coverage"
+    And the output of gtd "judge" contains "add is unchanged."
+    And the output of gtd "judge" contains "[AC-1] subtracts"
+
+  Scenario: every ID covered ends the feature and marks the IDs it covers
+    Given judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "idle"
+    And the commit subjects end with:
+      """
+      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
+      """
+    And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
+    And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-2"
+    And no commit body contains "Gtd-Mark: uncovered="
+
+  Scenario: one uncovered ID sends the process back instead of ending it
+    Given judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "implement.covering"
+    And the last commit subject is "gtd(judge): implement.coverage → implement.covering"
+    And the resting step's content contains "no passing test in this change that covers AC-2."
+    And no commit body contains "Gtd-Mark: covers="
+
+  Scenario: a yes below the confidence floor does not cover
+    Given judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.5}]
+      """
+    When the process is driven
+    Then the process rests at "implement.covering"
+    And the resting step's content contains "covers AC-2."
+
+  Scenario: a covering turn runs the suite before the judge rules again
+    Given judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
+      """
+    And step "implement.covering" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => expect(subtract(3, 1)).toBe(2))
+      it("[AC-2] adds", () => expect(add(1, 1)).toBe(2))
+      """
+    When the process is driven
+    Then the process rests at "implement.uncovered"
+    And the commit subjects end with:
+      """
+      gtd(judge): implement.coverage → implement.covering
+      gtd(agent): implement.covering → implement.health.check
+      gtd(check): implement.health.check → implement.coverage
+      gtd(judge): implement.coverage → implement.covering
+      gtd(agent): implement.covering → implement.health.check
+      gtd(check): implement.health.check → implement.coverage
+      gtd(judge): implement.coverage → implement.uncovered
+      """
+    And the resting step's content contains "still finds no passing test for AC-2"
+
+  Scenario: a covering turn may not change the acceptance criteria
+    Given judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
+      """
+    And step "implement.covering" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      """
+    Then driving the process is refused with "criteria-frozen"
+
+  Scenario: overruling at the gate ends the feature, recording the uncovered IDs
+    Given judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
+      """
+    And step "implement.covering" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => expect(subtract(3, 1)).toBe(2))
+      it("[AC-2] adds", () => expect(add(1, 1)).toBe(2))
+      """
+    And step "implement.uncovered" changes nothing
+    When the process is driven
+    Then the process rests at "idle"
+    And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
+    And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: uncovered=AC-2"
+
+  Scenario: an empty covering turn asks the judge again rather than stalling
+    Given judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
+      """
+    And step "implement.covering" changes nothing
+    When the process is driven
+    Then the process rests at "implement.uncovered"
+    And the commit subjects end with:
+      """
+      gtd(agent): implement.covering → implement.health.check
+      gtd(check): implement.health.check → implement.coverage
+      gtd(judge): implement.coverage → implement.uncovered
+      """

package/src/workflows/feature/coverage.ts

@@ -0,0 +1,106 @@
+import {
+  answered,
+  changes,
+  changesSince,
+  human,
+  judge,
+  mark,
+  read,
+  start,
+} from "../../flows/index.js"
+import { healthy } from "../shared/health.js"
+import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
+import * as t from "../shared/text.js"
+import { criteriaOf, requireCriteriaFrozen } from "./criteria.js"
+import { isTestFile } from "./refactor.js"
+import { isCode } from "./review.js"
+
+/** Below this the judge's `yes` is not trusted: a wrongly covered ID ends the feature without its test. */
+const COVERED_MIN_P = 0.7
+
+/** Covering turns before the process rests at `uncovered`; a human edit there refills them. */
+const COVERING_RETRIES = 2
+
+const frozen = (): void => requireCriteriaFrozen(REQUIREMENTS)
+
+export const green = (): Promise<void> =>
+  healthy(
+    () =>
+      t.agentWithSkills("fix.suite.fixing", t.implementFixPrompt(), {
+        label: "Fixing the check",
+        file: FEEDBACK,
+        model: coder(),
+        system: t.builderSystem(),
+      }),
+    { guard: frozen, guardRests: false },
+  )
+
+// A budget cut keeps the end, so the files naming a criterion ID go last.
+const testsSince = (base: string): string =>
+  changesSince(base)
+    .filter((c) => c.after !== undefined && isCode(c.path) && isTestFile(c.path))
+    .sort((a, b) => Number(/\bAC-\d/.test(a.after!)) - Number(/\bAC-\d/.test(b.after!)))
+    .map((c) => `=== ${c.path} (${c.status})\n${c.after}`)
+    .join("\n")
+
+/**
+ * The criterion IDs of `.gtd/REQUIREMENTS.md` — read afresh, never carried
+ * over — no passing test since `base` covers, by the judge.
+ */
+const uncoveredSince = async (
+  base: string,
+): Promise<{ readonly covered: string[]; readonly uncovered: string[] }> => {
+  const requirements = read(REQUIREMENTS) ?? ""
+  const criteria = (criteriaOf(requirements) ?? []).filter((c) => c.id !== "")
+  if (criteria.length === 0) return { covered: [], uncovered: [] }
+  const { answers } = await judge("coverage", {
+    questions: criteria.map(t.coverageQuestion),
+    evidence: { tests: testsSince(base) },
+    message: t.coverageMessage(),
+    label: "Judging acceptance-criteria coverage",
+  })
+  // A budget cut keeps the evidence's end: a `no` may miss tests the judge never saw, a `yes` names one it did.
+  const covers = (id: string): boolean => answered(answers[id], "yes", COVERED_MIN_P)
+  const ids = criteria.map((c) => c.id)
+  return { covered: ids.filter(covers), uncovered: ids.filter((id) => !covers(id)) }
+}
+
+const record = (covered: readonly string[], uncovered: readonly string[] = []): void => {
+  for (const id of covered) mark("covers", id)
+  for (const id of uncovered) mark("uncovered", id)
+}
+
+/**
+ * Hold a green change until every acceptance criterion has a passing test,
+ * sending uncovered IDs back to a covering turn; marks the IDs covered on the
+ * landing that ends it. A human may overrule once the retries are spent.
+ */
+export const requireCoverage = async (base = start()): Promise<void> => {
+  let retries = 0
+  for (;;) {
+    const { covered, uncovered } = await uncoveredSince(base)
+    if (uncovered.length === 0) return record(covered)
+    if (retries < COVERING_RETRIES) {
+      retries++
+      await t.agentWithSkills("covering", t.coveringPrompt(uncovered), {
+        label: "Covering the acceptance criteria",
+        model: coder(),
+        system: t.builderSystem(),
+        // The judge may have missed a test that exists: an empty turn asks it again.
+        allowEmpty: true,
+      })
+      frozen()
+    } else {
+      await human("uncovered", {
+        message: t.uncoveredMessage(uncovered),
+        label: "Acceptance criteria without a test",
+        file: REQUIREMENTS,
+        acceptClean: true,
+      })
+      if (!changes().some((c) => isCode(c.path))) return record(covered, uncovered)
+      frozen()
+      retries = 0
+    }
+    await green()
+  }
+}

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
@@ -26,6 +26,10 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
     And step "design.gate.answer" changes nothing
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
     And step "build.quality.correctness.reviewing" changes nothing
 
   Scenario Outline: a one-line fix runs idle to idle with the same beats at either tier
@@ -58,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
@@ -79,15 +75,16 @@ 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(check): implement.health.check → implement.closing
+      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
       gtd(agent): build.quality.correctness.reviewing → idle
       """
     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

@@ -154,6 +154,7 @@ describe("afterTail feedback lap", () => {
         state === "build.review.await-review" || state === "idle"
           ? undefined
           : (beat, r) => {
+              if (state === "implement.coverage") return '[{"id":"AC-1","answer":"yes","p":0.9}]'
               if (state === "build.review.reviewing") {
                 prompts.push(beat.content)
                 r.write(".gtd/REVIEW.md", review())
@@ -364,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 () => {