@pmelab/gtd 32.0.0 → 33.0.0

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))
@@ -79,6 +86,17 @@ describe("naivePass", () => {
     expect(request.options).toMatchObject({ keep: true })
   })
 
+  it("runs on the coder model, base by default, the coderModel setting otherwise", async () => {
+    const plain = await capture()
+    const set = await captureStep(() => naivePass(), {
+      scope: "seam",
+      env: { coderModel: "sonnet" },
+    })
+    if (plain.kind !== "agent" || set.kind !== "agent") throw new Error("unreachable")
+    expect(plain.options.model).toBe("base")
+    expect(set.options.model).toBe("sonnet")
+  })
+
   it("carries the rejection into the retry prompt", async () => {
     const request = await capture({ strays: ["src/core.ts"], p: 0.8 })
     if (request.kind !== "agent") throw new Error("unreachable")
@@ -87,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 = [
@@ -113,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[]> = {}
@@ -147,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]?.()
@@ -174,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 () => {
@@ -251,6 +432,11 @@ describe("implement", () => {
     return request.prompt
   }
 
+  it("builds on the coder model", async () => {
+    await building("abc")
+    expect(lastOptions?.model).toBe("base")
+  })
+
   it("after a refactor, lets an empty turn complete the step and says so", async () => {
     const prompt = await building("abc", undefined, undefined, () =>
       implement({ reference: "abc", afterRefactor: true }),

package/src/workflows/feature/seam.ts

@@ -1,14 +1,20 @@
+import { posix } from "node:path"
 import {
   changes,
+  check,
+  env,
   head,
   human,
   judgeDiffShape,
   kept,
+  quote,
+  read,
   removeScript,
   run,
   scope,
   slice,
   vars,
+  type Change,
   type DiffShapeResult,
   type KeptTip,
 } from "../../flows/index.js"
@@ -16,12 +22,19 @@ import { healthy } from "../shared/health.js"
 import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
-import { requireCriteria, requireCriteriaFrozen } from "./criteria.js"
-import { refactorStrays, reviewedRefactor } from "./refactor.js"
+import { criteriaOf, requireCriteria, requireCriteriaFrozen } from "./criteria.js"
+import {
+  COMMENT,
+  holdsCallSites,
+  isTestFile,
+  refactorStrays,
+  reviewedRefactor,
+} from "./refactor.js"
+import { isCode } from "./review.js"
 import { flagModeOn } from "../shared/options.js"
 import type { RiskTier } from "./tier.js"
 
-/** 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. */
@@ -35,14 +48,121 @@ export const judgeSeam = (tip: KeptTip): Promise<DiffShapeResult> =>
     exempt: tip.changes.filter((c) => c.status === "added").map((c) => c.path),
   })
 
-export const naivePass = (rejection?: t.SeamRejection): Promise<void> =>
-  t.agentWithSkills("naive", t.naivePassPrompt(rejection), {
-    label: rejection === undefined ? "Writing the naive pass" : "Rewriting the naive pass",
+export const naivePass = (retry?: t.NaiveRetry): Promise<void> =>
+  t.agentWithSkills("naive", t.naivePassPrompt(retry), {
+    label: retry === undefined ? "Writing the naive pass" : "Rewriting the naive pass",
     keep: true,
     model: coder(),
     system: t.builderSystem(),
   })
 
+// Only a string an import, `require` or `mock` call takes: a URL route or path-like data is not one.
+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: string): string[] => {
+  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: Change): { readonly path: string; readonly tail: boolean }[] =>
+  [...(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: ReturnType<typeof importsOf>, added: string): boolean =>
+  namesOf(added).some((name) =>
+    imports.some(({ path, tail }) => name === path || (tail && name.endsWith(`/${path}`))),
+  )
+
+const named = (id: string, text: string): boolean =>
+  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: Change): string => {
+  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.
+ */
+export const acceptanceFault = (file: string, tip: KeptTip): string | undefined => {
+  const ids = (criteriaOf(read(file) ?? "") ?? []).map((c) => c.id).filter((id) => id !== "")
+  const tests = tip.changes.filter(
+    (c) => c.after !== undefined && isCode(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(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")}`
+  return undefined
+}
+
+const restore = (path: string): string =>
+  `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: KeptTip): Promise<boolean> => {
+  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" },
+  )
+}
+
 export interface ImplementOptions {
   readonly reference?: string | undefined
   readonly tier?: RiskTier | undefined
@@ -103,34 +223,79 @@ interface Decision {
   readonly shape?: DiffShapeResult
 }
 
+/** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
+const steer = async (retry: t.NaiveRetry): Promise<boolean> => {
+  await human("steer", {
+    message: t.seamSteerMessage(retry),
+    label: "Steer or overrule the naive pass",
+    file: REQUIREMENTS,
+    acceptClean: true,
+  })
+  if (changes().length === 0) return false
+  requireCriteria(REQUIREMENTS)
+  return true
+}
+
+type Verdict =
+  | { readonly kind: "retry"; readonly retry: t.NaiveRetry }
+  | { readonly kind: "steered" }
+  | { readonly kind: "overruled" }
+
+/** Rejects, test faults and red checks share one budget; a steer or an overrule refills it. */
+const budget = (): ((next: t.NaiveRetry) => Promise<Verdict>) => {
+  let retries = 0
+  return async (next) => {
+    if (retries < NAIVE_RETRIES) {
+      retries++
+      return { kind: "retry", retry: next }
+    }
+    const steered = await steer(next)
+    retries = 0
+    // A steered or overruled red pass leaves its report behind: nothing reads it any more.
+    if (read(FEEDBACK) !== undefined)
+      await run("clear", removeScript([FEEDBACK]), { label: "Clearing the red check" })
+    return { kind: steered ? "steered" : "overruled" }
+  }
+}
+
+interface Vetting {
+  readonly again: ReturnType<typeof budget>
+  /** Set once a human overrules a test fault: the rule does not fit this change, so later passes skip it. */
+  waived: boolean
+}
+
+/** 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: KeptTip, vetting: Vetting): Promise<Verdict | undefined> => {
+  const fault = vetting.waived ? undefined : acceptanceFault(REQUIREMENTS, tip)
+  if (fault !== undefined) {
+    const verdict = await vetting.again({ fault, hash: tip.hash })
+    if (verdict.kind !== "overruled") return verdict
+    vetting.waived = true
+  }
+  if (await naiveGreen(tip)) return undefined
+  const verdict = await vetting.again({ red: tip.hash })
+  return verdict.kind === "overruled" ? undefined : verdict
+}
+
+/** The judge's ruling on a vetted pass: the decision, or the next attempt's verdict. */
+const ruled = async (tip: KeptTip, again: Vetting["again"]): Promise<Decision | Verdict> => {
+  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 = (): Promise<Decision> =>
   scope("seam", async () => {
-    let rejection: t.SeamRejection | undefined
-    let retries = 0
+    const vetting: Vetting = { again: budget(), waived: false }
+    let retry: t.NaiveRetry | undefined
     for (;;) {
-      await naivePass(rejection)
+      await naivePass(retry)
       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 }
-      if (retries < NAIVE_RETRIES) {
-        retries++
-        continue
-      }
-      await human("steer", {
-        message: t.seamSteerMessage(rejection),
-        label: "Steer or overrule the rejected naive pass",
-        file: REQUIREMENTS,
-        acceptClean: true,
-      })
-      // Any edit steers, with a fresh budget and no stale rejection; clean overrules.
-      if (changes().length === 0) return { reference: tip.hash }
-      requireCriteria(REQUIREMENTS)
-      rejection = undefined
-      retries = 0
+      const outcome = (await vetted(tip, vetting)) ?? (await ruled(tip, vetting.again))
+      if (!("kind" in outcome)) return outcome
+      retry = outcome.kind === "retry" ? outcome.retry : undefined
     }
   })