@pmelab/gtd 32.1.0 → 33.0.0

package/src/workflows/feature/refactor-lens-models.feature

@@ -36,7 +36,12 @@ Feature: the refactor review's lenses take their model hints from refactorQualit
     And step "design.gate.answer" changes nothing
 
   Scenario: a refactor lens runs on its refactorQualityReviews hint, else its default
-    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-review.feature

@@ -52,6 +52,11 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       - 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/calc.ts" with:
       """
       export const add = (a: number, b: number) => a + b
@@ -136,6 +141,11 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       - 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/calc.ts" with:
       """
       export const add = (a: number, b: number) => a + b
@@ -219,6 +229,11 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         - 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/calc.ts" with:
         """
         export const add = (a: number, b: number) => a + b
@@ -1426,6 +1441,11 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         - 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/calc.ts" with:
         """
         export const add = (a: number, b: number) => a + b
@@ -1614,7 +1634,12 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
 
     Scenario: a test-file stray is dropped from the derived refactor package
-      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
@@ -1631,7 +1656,12 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       And ".gtd/REFACTOR.md" does not contain "src/calc.test.ts"
 
     Scenario: the refactor updates an existing test's call sites to the seam's new shape
-      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, b }: { a: number; b: number }) => a + b
         export const subtract = ({ a, b }: { a: number; b: number }) => a - b
@@ -1651,7 +1681,12 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       Then the process rests at "refactor.health.check"
 
     Scenario: the refactor may not drop an assertion from an existing test
-      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
@@ -1665,7 +1700,12 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       Then driving the process is refused with "refactor-tests"
 
     Scenario: a refactor-first whose strays are all test files goes straight to implement
-      Given step "seam.naive" writes "src/calc.test.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.test.ts" with:
         """
         import { expect, it } from "vitest"
         it("subtracts", () => expect(3 - 1).toBe(2))
@@ -1675,7 +1715,12 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       And ".gtd/REFACTOR.md" does not exist
 
     Scenario: collected review headings re-derive at ### with the deepest capped at ######
-      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.ts

@@ -42,7 +42,8 @@ export const requireWithin = (allowed: readonly string[]): void => {
 }
 
 // A fixed list, not `seamAllow`: narrowing that setting must not let a test file through.
-const isTestFile = (path: string): boolean => testFileGlobs.some((glob) => matches(path, glob))
+export const isTestFile = (path: string): boolean =>
+  testFileGlobs.some((glob) => matches(path, glob))
 
 // The bundled refactor uses `requireTestCallSitesOnly`; this stays a public export.
 export const requireNoTestFiles = (): void => {
@@ -56,11 +57,11 @@ export const requireNoTestFiles = (): void => {
 }
 
 // Call sites live in code: a `.feature` file or a snapshot holds only expectations.
-const holdsCallSites = (path: string): boolean =>
+export const holdsCallSites = (path: string): boolean =>
   !path.endsWith(".feature") && !path.endsWith(".snap")
 
 // `//` after a `:` (a URL) and `/*` after `*` or `/` (a glob) sit in strings, not comments.
-const COMMENT = /(?<![*/])\/\*[\s\S]*?\*\/|(?<!:)\/\/.*$/gm
+export const COMMENT = /(?<![*/])\/\*[\s\S]*?\*\/|(?<!:)\/\/.*$/gm
 const ASSERTION = /\b(?:expect|assert\w*)\s*[.(]/g
 const TEST_CASE = /(?<![.\w])x?(?:it|test|describe)\s*[.(]/g
 const MODIFIER =

package/src/workflows/feature/risk-tier.feature

@@ -146,6 +146,11 @@ Feature: the risk tier is proposed at triage and recorded behind GTD_FLAG_RISK_T
 
         - AC-1: the change behaves as described.
         """
+      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/calc.ts" with:
         """
         export const add = (a: number, b: number) => a + b
@@ -254,6 +259,11 @@ Feature: the risk tier is proposed at triage and recorded behind GTD_FLAG_RISK_T
         - 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/calc.ts" with:
         """
         export const add = (a: number, b: number) => a + b

package/src/workflows/feature/seam-rejection.feature

@@ -41,7 +41,12 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
     And step "design.gate.answer" changes nothing
 
   Scenario: three rejects rest at the steer gate, a steered rerun lands and runs 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) => b + a
       """
@@ -87,6 +92,10 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       - AC-1: the change behaves as described.
       """
     And step "seam.naive" from now on 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
@@ -127,14 +136,18 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       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 → seam.naive
-      gtd(agent): seam.naive → seam.judge
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
       gtd(judge): seam.judge → seam.naive
-      gtd(agent): seam.naive → seam.judge
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
       gtd(judge): seam.judge → seam.steer
       gtd(human): seam.steer → 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
@@ -144,7 +157,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       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 → seam.naive" has a body containing "\"answer\":\"reject\""
     And the commit "gtd(judge): seam.judge → seam.steer" has a body containing "\"answer\":\"reject\""
     And the commit "gtd(judge): seam.judge → implement.building" has a body containing "\"answer\":\"land\""

package/src/workflows/feature/seam.feature

@@ -51,7 +51,12 @@ Feature: the naive pass and seam judge decide how a feature is built
     And step "design.gate.answer" changes nothing
 
   Scenario: a land judgment goes straight to the implementation with no seam gate or refactor
-    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
@@ -72,12 +77,18 @@ Feature: the naive pass and seam judge decide how a feature is built
       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
       """
 
   Scenario: config skills for the implement scope reach the implement step
-    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
@@ -91,19 +102,33 @@ Feature: the naive pass and seam judge decide how a feature is built
     And the resting step's content contains "my-tdd, my-runbook"
 
   Scenario: the naive pass lands as a marker commit and its turn stays off the branch
-    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
       """
     When the process is driven
     Then the process rests at "seam.judge"
-    And the last commit subject is "gtd(agent): seam.naive → seam.judge"
-    And the last commit body contains "Gtd-Kept:"
+    And the commit subjects end with:
+      """
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
+      """
+    And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"
     And "src/calc.ts" does not contain "subtract"
 
   Scenario: the implementation is one build turn, a green check, then the requirements are closed out
-    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
@@ -132,7 +157,12 @@ Feature: the naive pass and seam judge decide how a feature is built
     And ".gtd/REQUIREMENTS.md" does not exist
 
   Scenario: a naive pass modifying a test file and adding a new one skips the judge
-    Given step "seam.naive" writes "src/subtract.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/subtract.ts" with:
       """
       export const subtract = (a: number, b: number) => a - b
       """
@@ -146,11 +176,17 @@ Feature: the naive pass and seam judge decide how a feature is built
     And the commit subjects end with:
       """
       gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive → implement.building
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → implement.building
       """
 
   Scenario: a naive pass adding a glob-named file does not hide a modified sibling
-    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 subtract = (a: number, b: number) => a - b
       """
@@ -169,7 +205,12 @@ Feature: the naive pass and seam judge decide how a feature is built
     And the resting step's content does not contain "src/calc*.ts"
 
   Scenario: an edit at the steer gate runs the naive pass again with a fresh retry budget
-    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) => b + a
       """
@@ -201,16 +242,24 @@ Feature: the naive pass and seam judge decide how a feature is built
     And the commit subjects end with:
       """
       gtd(human): seam.steer → seam.naive
-      gtd(agent): seam.naive → seam.judge
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
       gtd(judge): seam.judge → seam.naive
-      gtd(agent): seam.naive → seam.judge
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
       gtd(judge): seam.judge → seam.naive
-      gtd(agent): seam.naive → seam.judge
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
       gtd(judge): seam.judge → seam.steer
       """
 
   Scenario: a clean landing at the steer gate overrules, with no seam gate and no refactor
-    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) => b + a
       """
@@ -229,7 +278,12 @@ Feature: the naive pass and seam judge decide how a feature is built
       """
 
   Scenario: review feedback after land re-runs design and implement, never the seam phase
-    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) => b + a
       """

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

@@ -8,7 +8,14 @@ import {
 } from "../../flows/index.js"
 import { globMatches } from "../../wire/index.js"
 import { fixtureContext } from "../shared/text.fixture.js"
-import { implement, judgeSeam, naivePass, seamBuild, type SeamOutcome } from "./seam.js"
+import {
+  implement,
+  judgeSeam,
+  naivePass,
+  acceptanceFault,
+  seamBuild,
+  type SeamOutcome,
+} from "./seam.js"
 import { captureStep } from "../shared/text.fixture.js"
 
 afterEach(() => installContext(undefined))
@@ -98,6 +105,130 @@ describe("naivePass", () => {
   })
 })
 
+describe("acceptanceFault", () => {
+  const requirements = "# R\n\n## Acceptance Criteria\n\n- AC-1: adds.\n- AC-2: subtracts.\n"
+  const file = (path: string, status: Change["status"], after: string): Change => ({
+    path,
+    status,
+    before: status === "added" ? undefined : "",
+    after,
+  })
+  const refusal = (...changes: Change[]): string | undefined => {
+    installContext({
+      ...fixtureContext({}),
+      matches: globMatches,
+      read: (path: string) => (path === ".gtd/REQUIREMENTS.md" ? requirements : undefined),
+    } as unknown as FlowContext)
+    return acceptanceFault(".gtd/REQUIREMENTS.md", tip(...changes))
+  }
+  const tagged = 'import { add } from "../src/calc.js"\nit("[AC-1] adds")\nit("[AC-2] subtracts")'
+
+  it("passes when every ID is named in a test the pass wrote", () => {
+    expect(
+      refusal(file("src/calc.ts", "modified", "x"), file("tests/calc.test.ts", "added", tagged)),
+    ).toBe(undefined)
+  })
+
+  it("names every ID no test of the pass mentions", () => {
+    const message = refusal(file("tests/calc.test.ts", "added", 'it("[AC-12] x")'))
+    expect(message).toMatch(/^acceptance-tests: /)
+    expect(message).toContain("AC-1, AC-2")
+  })
+
+  it("does not count an ID in a non-test file", () => {
+    expect(refusal(file("src/calc.ts", "modified", "AC-1 AC-2"))).toContain("AC-1, AC-2")
+  })
+
+  it("refuses a test importing a file the pass added, resolved from the test's directory", () => {
+    const message = refusal(
+      file("src/naive/helper.ts", "added", "export const h = 1"),
+      file("src/naive/helper.test.ts", "added", `import { h } from "./helper.js"\n${tagged}`),
+    )
+    expect(message).toMatch(/^acceptance-internals: /)
+    expect(message).toContain("src/naive/helper.test.ts → src/naive/helper.ts")
+  })
+
+  it("refuses an aliased or directory import of an added module", () => {
+    const added = file("src/naive/index.ts", "added", "")
+    expect(
+      refusal(added, file("tests/a.test.ts", "added", `import "@/naive"\n${tagged}`)),
+    ).toContain("acceptance-internals")
+    expect(
+      refusal(added, file("tests/a.test.ts", "added", `import "../src/naive/index.js"\n${tagged}`)),
+    ).toContain("acceptance-internals")
+  })
+
+  it("counts only the lines the pass added: an ID an earlier feature left does not", () => {
+    const old = 'it("[AC-1] old")\nit("[AC-2] old")'
+    const message = refusal({
+      path: "tests/calc.test.ts",
+      status: "modified",
+      before: old,
+      after: `${old}\nit("[AC-2] new")`,
+    })
+    expect(message).toContain("names AC-1 —")
+  })
+
+  it("refuses a bare . or .. import of an added index", () => {
+    expect(
+      refusal(
+        file("src/naive/index.ts", "added", ""),
+        file("src/naive/__tests__/a.test.ts", "added", `import { x } from ".."\n${tagged}`),
+      ),
+    ).toContain("acceptance-internals")
+  })
+
+  it("reads a URL route or path-like data as no import", () => {
+    expect(
+      refusal(
+        file("src/routes/users.ts", "added", ""),
+        file(
+          "tests/a.test.ts",
+          "added",
+          `request(app).get("/users")\nrun("src/routes/users.ts")\n${tagged}`,
+        ),
+      ),
+    ).toBe(undefined)
+  })
+
+  it("reads no import out of a .feature file", () => {
+    expect(
+      refusal(
+        file("src/subtract.ts", "added", ""),
+        file("features/calc.feature", "added", `Given a file "src/subtract.ts"\n${tagged}`),
+      ),
+    ).toBe(undefined)
+  })
+
+  it("skips commented-out imports and takes a package subpath as no repository path", () => {
+    expect(
+      refusal(
+        file("src/naive/helper.ts", "added", ""),
+        file("src/date-fns/format.ts", "added", ""),
+        file(
+          "src/naive/a.test.ts",
+          "added",
+          `// import { h } from "./helper.js"\nimport { format } from "date-fns/format"\n${tagged}`,
+        ),
+      ),
+    ).toBe(undefined)
+  })
+
+  it("lets a test reach an existing module, a same-named file elsewhere, or a URL", () => {
+    expect(
+      refusal(
+        file("src/naive/api.ts", "added", ""),
+        file("src/calc.ts", "modified", ""),
+        file(
+          "tests/a.test.ts",
+          "added",
+          `import "../src/calc.js"\nimport "./api.js"\nfetch("https://x/api")\n${tagged}`,
+        ),
+      ),
+    ).toBe(undefined)
+  })
+})
+
 const REVIEW = ".gtd/REVIEW.md"
 const REFACTOR = ".gtd/REFACTOR.md"
 const reviewDoc = [
@@ -124,7 +255,10 @@ const driveSeam = async (
   answer: string,
   stray: Change = change("src/a.ts", "modified"),
   vars: Record<string, string> = {},
+  reds = 0,
 ): Promise<Seamed> => {
+  let red = false
+  let redsLeft = reds
   const names: string[] = []
   const slices: string[] = []
   const inside: Record<string, string[]> = {}
@@ -158,11 +292,17 @@ const driveSeam = async (
     read: (path: string) => files.get(path),
     head: () => current,
     kept: () => tip(stray),
-    changes: () => [],
+    changes: () => (red ? [change(".gtd/FEEDBACK.md", "added")] : []),
     changesSince: () => [],
     step: (request: StepRequest) => {
       if (request.kind === "restart") return Promise.resolve()
       const full = [...stack, request.name].join(".")
+      red = full === "seam.check" && redsLeft-- > 0
+      if (full === "seam.check") {
+        if (red) files.set(".gtd/FEEDBACK.md", "FAIL")
+        else files.delete(".gtd/FEEDBACK.md")
+      }
+      if (full === "seam.clear") files.delete(".gtd/FEEDBACK.md")
       names.push(full)
       for (const name of open) inside[name]!.push(full)
       effects[request.name]?.()
@@ -185,7 +325,37 @@ describe("seamBuild", () => {
     const h = await driveSeam("land")
     expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
     expect(h.slices).toEqual([])
-    expect(h.names).toEqual(["seam.naive", "seam.judge"])
+    expect(h.names).toEqual(["seam.naive", "seam.check", "seam.judge"])
+  })
+
+  it("a red check retries the pass, and the judge sees it only once green", async () => {
+    const h = await driveSeam("land", undefined, {}, 1)
+    expect(h.names).toEqual(["seam.naive", "seam.check", "seam.naive", "seam.check", "seam.judge"])
+  })
+
+  it("an overruled red pass gets a fresh budget for the judge's rejects", async () => {
+    const h = await driveSeam("reject", undefined, {}, 3)
+    const steers = h.names.flatMap((name, i) => (name === "seam.steer" ? [i] : []))
+    expect(steers).toHaveLength(2)
+    expect(h.names.slice(steers[0]! + 1, steers[1]).filter((n) => n === "seam.judge")).toHaveLength(
+      3,
+    )
+  })
+
+  it("a third red rests at seam.steer, and a clean landing there takes the red pass to the judge", async () => {
+    const h = await driveSeam("land", undefined, {}, 3)
+    expect(h.names).toEqual([
+      "seam.naive",
+      "seam.check",
+      "seam.naive",
+      "seam.check",
+      "seam.naive",
+      "seam.check",
+      "seam.steer",
+      "seam.clear",
+      "seam.judge",
+    ])
+    expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
   })
 
   it("refactor-first runs the reviewed refactor in slice refactor and resolves HEAD after it", async () => {