@pmelab/gtd 54.0.0 → 55.0.0

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

@@ -1,11 +1,10 @@
 @inmem
-Feature: a naive pass ends only when a test names every criterion and the suite is green
+Feature: a naive pass ends only when its tests reach no file it added and the suite is green
 
-  `seam.naive` writes behaviour-level acceptance tests, each naming its
-  criterion's ID. A pass whose tests leave an ID out or import a file the
-  pass added is sent back; `seam.check` then runs the suite with the kept
-  pass applied, and a red run sends it back too, before the judge sees it.
-  Three failed attempts rest at `seam.steer`.
+  `seam.naive` needs no test at all. A pass whose test imports a file the pass
+  added is sent back; `seam.check` then runs the suite with the kept pass
+  applied, and a red run sends it back too, before the judge sees it. Three
+  failed attempts rest at `seam.steer`.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
@@ -44,15 +43,30 @@ Feature: a naive pass ends only when a test names every criterion and the suite
       export const subtract = (a: number, b: number) => a - b
       """
 
-  Scenario: a pass whose tests leave a criterion's ID out is sent back, and an overrule runs the check and sticks
-    Given step "seam.naive" writes "tests/calc.test.ts" with:
+  Scenario: a pass without a test goes on to the check and the judge
+    Given step "seam.check" changes nothing
+    When the process is driven
+    Then the process rests at "seam.judge"
+    And the commit subjects end with:
       """
-      import { add, subtract } from "../src/calc.js"
-      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
+      """
+
+  Scenario: a test importing a file the pass added is sent back, and an overrule runs the check and sticks
+    Given step "seam.naive" writes "src/subtract.ts" with:
+      """
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And step "seam.naive" writes "src/subtract.test.ts" with:
+      """
+      import { subtract } from "./subtract.js"
+      it("subtracts", () => expect(subtract(5, 3)).toBe(2))
       """
     When the process is driven
     Then the process rests at "seam.steer"
-    And the resting step's content contains "acceptance-tests: no test of the naive pass names AC-2"
+    And the resting step's content contains "src/subtract.test.ts → src/subtract.ts"
 
     Given step "seam.check" changes nothing
     When gtd lands
@@ -87,27 +101,12 @@ Feature: a naive pass ends only when a test names every criterion and the suite
       gtd(judge): seam.judge → seam.steer
       """
 
-  Scenario: a test importing a file the pass added is sent back
-    Given step "seam.naive" writes "src/subtract.ts" with:
-      """
-      export const subtract = (a: number, b: number) => a - b
-      """
-    And step "seam.naive" writes "src/subtract.test.ts" with:
-      """
-      import { subtract } from "./subtract.js"
-      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
-      it("[AC-2] still adds", () => {})
-      """
-    When the process is driven
-    Then the process rests at "seam.steer"
-    And the resting step's content contains "src/subtract.test.ts → src/subtract.ts"
-
   Scenario: a red suite sends the pass back, and it moves on only once green
     Given step "seam.naive" writes "tests/calc.test.ts" with:
       """
       import { add, subtract } from "../src/calc.js"
-      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
-      it("[AC-2] still adds", () => expect(add(1, 1)).toBe(2))
+      it("subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("still adds", () => expect(add(1, 1)).toBe(2))
       """
     When the process is driven
     Then the process rests at "seam.check"
@@ -118,18 +117,18 @@ Feature: a naive pass ends only when a test names every criterion and the suite
     Given step "seam.naive" is no longer scripted
     And step "seam.check" writes ".gtd/FEEDBACK.md" with:
       """
-      FAIL tests/calc.test.ts > [AC-1] subtracts
+      FAIL tests/calc.test.ts > subtracts
       """
     When the process is driven
     Then the process rests at "seam.naive"
     And the resting step's content contains "left the suite red"
-    And ".gtd/FEEDBACK.md" contains "[AC-1] subtracts"
+    And ".gtd/FEEDBACK.md" contains "> subtracts"
 
     Given step "seam.naive" writes "tests/calc.test.ts" with:
       """
       import { add, subtract } from "../src/calc.js"
-      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
-      it("[AC-2] still adds", () => expect(add(2, 2)).toBe(4))
+      it("subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("still adds", () => expect(add(2, 2)).toBe(4))
       """
     And step "seam.check" from now on changes nothing
     When the process is driven

package/src/workflows/feature/prototype.ts

@@ -3,7 +3,6 @@ import { HEADING, markFenced } from "../shared/fences.js"
 import { coder, PROTOTYPE, REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
-import type { Guard } from "../shared/health.js"
 import { green } from "./green.js"
 import { criteriaOf, criterionIds, handsOnIds, requireCriteriaFrozen } from "./criteria.js"
 
@@ -130,7 +129,7 @@ const testing = async (
   return requireReport(ids, retest)
 }
 
-const fixing = async (guard?: Guard): Promise<void> => {
+const fixing = async (): Promise<void> => {
   await scope("fix", () =>
     t.agentWithSkills("fixing", t.prototypeFixingPrompt(), {
       label: "Fixing what the hands-on test found",
@@ -145,7 +144,6 @@ const fixing = async (guard?: Guard): Promise<void> => {
   if (changes().some((c) => c.path === PROTOTYPE))
     refuse(`gtd land: prototype-fix: leave ${PROTOTYPE} as it is — the next round re-tests from it`)
   frozen()
-  guard?.()
 }
 
 /** A person's rest; resolves `true` when they changed something to test again, `false` on a clean overrule. */
@@ -161,10 +159,9 @@ const askPerson = async (name: string, message: string, label: string): Promise<
  * Use the change by hand: a testing turn reports on every criterion a person
  * can observe, a fix turn takes each failure, and the change is tested again —
  * until the report is clean, or `prototypeRounds` fixes are spent and a person
- * decides. A change with no such criterion is not tested by hand. `guard`
- * holds every fix turn, as it holds the implementation's.
+ * decides. A change with no such criterion is not tested by hand.
  */
-export const prototypeTest = async (guard?: Guard): Promise<void> => {
+export const prototypeTest = async (): Promise<void> => {
   const cap = prototypeRounds()
   if (cap === 0) return
   await scope("prototype", async () => {
@@ -185,7 +182,7 @@ export const prototypeTest = async (guard?: Guard): Promise<void> => {
       } else if (open.length === 0) return
       else if (fixes < cap && open.some((i) => i.verdict === "fail")) {
         fixes++
-        await fixing(guard)
+        await fixing()
       } else {
         const changed = await askPerson(
           "open",
@@ -195,7 +192,7 @@ export const prototypeTest = async (guard?: Guard): Promise<void> => {
         if (!changed) return
         fixes = 0
       }
-      await green(guard)
+      await green()
     }
   })
 }

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

@@ -5,8 +5,9 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
   On a refactor-first judgment the naive pass is never applied. `seam.note`
   reads the whole naive diff and writes `.gtd/REFACTOR-NOTE.md`; the refactor
   lands on its own with the existing suite green; the rebuild re-implements the
-  change on the refactored base and lands only once it carries the naive pass's
-  acceptance tests and the suite is green. The note reaches both turns.
+  change on the refactored base, is asked to carry over every test file the
+  naive pass added or changed, and lands once the suite is green. The note
+  reaches both turns.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
@@ -18,6 +19,10 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
       """
       export const add = (a: number, b: number) => a + b
       """
+    And a file "src/calc.test.ts" with:
+      """
+      it("adds", () => {})
+      """
     And the working tree is committed as "feat: add calculator"
     And a file "TODO.md" with:
       """
@@ -49,7 +54,12 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
     And step "seam.check" changes nothing
     And step "seam.naive" writes "src/acceptance.test.ts" with:
       """
-      it("[AC-1] subtracts", () => {})
+      it("subtracts", () => {})
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("adds", () => {})
+      it("subtracts a larger number", () => {})
       """
     And step "seam.naive" writes "src/calc.ts" with:
       """
@@ -125,7 +135,8 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
     And the process is driven
     Then the process rests at "implement.building"
     And the resting step's content contains "shared `op(a, b, sign)`"
-    And the resting step's content contains "acceptance tests for AC-1"
+    And the resting step's content contains "Carry over the naive pass's acceptance tests"
+    And the resting step's content contains "'src/acceptance.test.ts' 'src/calc.test.ts'"
 
   Scenario: a note turn that changes anything but the note is refused
     Given step "seam.note" writes "src/calc.ts" with:
@@ -198,7 +209,7 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
     And "src/calc.ts" contains "op(a, b, 1)"
     And "src/calc.ts" does not contain "subtract"
 
-  Scenario: the rebuild lands only once it carries the naive pass's acceptance tests, green
+  Scenario: the rebuild lands once green, whichever tests it carried
     Given step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
       """
       Seam: a shared `op` in src/calc.ts.
@@ -254,18 +265,11 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
       export const add = (a: number, b: number) => op(a, b, 1)
       export const subtract = (a: number, b: number) => op(a, b, -1)
       """
-    Then driving the process is refused with "rebuild-acceptance"
-
-    Given step "implement.building" writes "src/acceptance.test.ts" with:
-      """
-      it("[AC-1] subtracts", () => {})
-      """
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
     When the process is driven
     Then the process rests at "build.review.reviewing"
     And "src/calc.ts" contains "op(a, b, -1)"
-    And "src/acceptance.test.ts" contains "[AC-1]"
     And ".gtd/REFACTOR-NOTE.md" does not exist
     And the commit subjects end with:
       """

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

@@ -14,8 +14,6 @@ import {
   naivePass,
   acceptanceFault,
   naiveAcceptance,
-  requireAcceptance,
-  requireAcceptanceKept,
   seamBuild,
   type SeamOutcome,
 } from "./seam.js"
@@ -108,71 +106,24 @@ describe("naivePass", () => {
   })
 })
 
-describe("naiveAcceptance and requireAcceptance", () => {
-  const requirements =
-    "# R\n\n## Impact\n\n- the module\n\n## Acceptance Criteria\n\n- AC-1: adds.\n- AC-2: subtracts.\n"
-  const file = (path: string, before: string | undefined, after: string): Change => ({
-    path,
-    status: before === undefined ? "added" : "modified",
-    before,
-    after,
-  })
-  const install = (since: Change[] = []) =>
-    installContext({
-      ...fixtureContext({}),
-      matches: globMatches,
-      read: (path: string) => (path === ".gtd/REQUIREMENTS.md" ? requirements : undefined),
-      changesSince: () => since,
-      changes: () => since,
-      refuse: (message: string) => {
-        throw new Error(message)
-      },
-    } as unknown as FlowContext)
-
-  it("takes the IDs the pass's tests name on an added line, and only those test files", () => {
-    install()
+describe("naiveAcceptance", () => {
+  it("carries every test file the pass added or changed, named or not", () => {
+    installContext({ ...fixtureContext({}), matches: globMatches } as unknown as FlowContext)
     expect(
       naiveAcceptance(
         tip(
-          file("src/a.test.ts", 'it("[AC-2] old")', 'it("[AC-2] old")\nit("[AC-1] adds")'),
-          file("src/b.test.ts", undefined, 'it("helper")'),
-          file("src/calc.ts", "x", "AC-2"),
+          change("src/a.test.ts", "modified"),
+          change("tests/b.feature", "added"),
+          change("src/gone.test.ts", "deleted"),
+          change("src/calc.ts", "modified"),
+          change(".gtd/x.test.ts", "added"),
         ),
       ),
-    ).toEqual({ hash: "abc", tests: ["src/a.test.ts"], ids: ["AC-1"] })
-  })
-
-  it("refuses a rebuild whose tests leave out an ID, naming the naive tests to carry over", () => {
-    install([file("src/calc.test.ts", undefined, 'it("[AC-1] adds")')])
-    expect(() =>
-      requireAcceptance({ hash: "abc", tests: ["src/a.test.ts"], ids: ["AC-1", "AC-2"] }, "c0"),
-    ).toThrow(
-      /^gtd land: rebuild-acceptance: .*leave out AC-2 — .*git show abc -- 'src\/a\.test\.ts'/,
-    )
-  })
-
-  it("refuses a fix turn that itself drops a carried ID, never one that leaves it alone", () => {
-    const acceptance = { hash: "abc", tests: [], ids: ["AC-1"] }
-    install([file("src/calc.test.ts", 'it("[AC-1] adds")', 'it("adds")')])
-    expect(() => requireAcceptanceKept(acceptance)).toThrow(/drops AC-1/)
-    install([file("src/calc.ts", "a", "b")])
-    expect(() => requireAcceptanceKept(acceptance)).not.toThrow()
-  })
-
-  it("passes a rebuild whose tests name every ID, wherever they live", () => {
-    install([
-      file("tests/x.test.ts", undefined, 'it("[AC-1] adds")'),
-      file("tests/y.feature", "", "Scenario: [AC-2] subtracts"),
-    ])
-    expect(() =>
-      requireAcceptance({ hash: "abc", tests: ["src/a.test.ts"], ids: ["AC-1", "AC-2"] }, "c0"),
-    ).not.toThrow()
+    ).toEqual({ hash: "abc", tests: ["src/a.test.ts", "tests/b.feature"] })
   })
 })
 
 describe("acceptanceFault", () => {
-  const requirements =
-    "# R\n\n## Impact\n\n- the module\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,
@@ -180,30 +131,10 @@ describe("acceptanceFault", () => {
     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))
+    installContext({ ...fixtureContext({}), matches: globMatches } as unknown as FlowContext)
+    return acceptanceFault(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")
-  })
+  const tagged = 'import { add } from "../src/calc.js"\nit("adds")'
 
   it("refuses a test importing a file the pass added, resolved from the test's directory", () => {
     const message = refusal(
@@ -224,17 +155,6 @@ describe("acceptanceFault", () => {
     ).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(
@@ -424,7 +344,7 @@ describe("seamBuild", () => {
       reference: "abc",
       base: "after-refactor",
       refactored: true,
-      rebuild: { note: "Seam: a shared op", acceptance: { hash: "abc", tests: [], ids: [] } },
+      rebuild: { note: "Seam: a shared op", acceptance: { hash: "abc", tests: [] } },
     })
     expect(h.names.indexOf("seam.note")).toBe(h.names.indexOf("seam.judge") + 1)
     expect(h.names.indexOf("refactor.deriving")).toBe(h.names.indexOf("seam.note") + 1)
@@ -440,7 +360,7 @@ describe("seamBuild", () => {
     expect(h.outcome).toEqual({
       reference: "abc",
       base: "c-base",
-      rebuild: { acceptance: { hash: "abc", tests: [], ids: [] } },
+      rebuild: { acceptance: { hash: "abc", tests: ["src/a.test.ts"] } },
     })
     expect(h.names).not.toContain("seam.by-hand")
     expect(h.names.some((n) => n.startsWith("refactor"))).toBe(false)
@@ -466,7 +386,7 @@ describe("seamBuild", () => {
     expect(h.outcome).toEqual({
       reference: "abc",
       base: "c-base",
-      rebuild: { acceptance: { hash: "abc", tests: [], ids: [] } },
+      rebuild: { acceptance: { hash: "abc", tests: [] } },
     })
   })
 })
@@ -543,19 +463,17 @@ describe("implement", () => {
         reference: "abc",
         rebuild: {
           note: "# Note\n\nSeam: a shared op",
-          acceptance: { hash: "abc", tests: ["src/a.test.ts"], ids: ["AC-1"] },
+          acceptance: { hash: "abc", tests: ["src/a.test.ts"] },
         },
-        // The fixture's turn carries no test, so the acceptance guard refuses it after the prompt.
-      }).catch(() => undefined),
+      }),
     )
     expect(prompt).toContain("  > Seam: a shared op")
-    expect(prompt).toContain("acceptance tests for AC-1")
     expect(prompt).toContain("git show abc -- 'src/a.test.ts'")
   })
 
-  it("a rebuild whose naive tests named no ID asks to carry nothing over", async () => {
+  it("a rebuild whose naive pass wrote no test asks to carry nothing over", async () => {
     const prompt = await building("abc", undefined, undefined, () =>
-      implement({ reference: "abc", rebuild: { acceptance: { hash: "abc", tests: [], ids: [] } } }),
+      implement({ reference: "abc", rebuild: { acceptance: { hash: "abc", tests: [] } } }),
     )
     expect(prompt).not.toContain("Carry over")
     expect(prompt).not.toContain("refactor note")

package/src/workflows/feature/seam.ts

@@ -3,7 +3,6 @@ import {
   agent,
   applyScript,
   changes,
-  changesSince,
   check,
   codeChanges,
   env,
@@ -92,43 +91,19 @@ const reaches = (imports: ReturnType<typeof importsOf>, added: string): boolean
     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")
-}
-
 const acceptanceTests = (changes: readonly Change[]): readonly Change[] =>
   changes.filter((c) => c.after !== undefined && isCode(c.path) && isTestFile(c.path))
 
-const idsOf = (file: string): string[] => criterionIds(read(file) ?? "")
-
-// One rule for both gates, so a naive test carried over verbatim always satisfies the rebuild's.
-const unnamed = (ids: readonly string[], tests: readonly Change[]): string[] => {
-  const lines = tests.map(addedLines)
-  return ids.filter((id) => !lines.some((text) => named(id, text)))
-}
-
 /**
- * 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.
+ * Why `tip`'s tests fall short, or `undefined`: 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 tests = acceptanceTests(tip.changes)
-  const untested = unnamed(idsOf(file), tests)
-  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]}] …"`
+export const acceptanceFault = (tip: KeptTip): string | undefined => {
   const added = tip.changes
     .filter((c) => c.status === "added" && isCode(c.path) && !isTestFile(c.path))
     .map((c) => c.path)
-  const reaching = tests
+  const reaching = acceptanceTests(tip.changes)
     .filter((test) => holdsCallSites(test.path))
     .flatMap((test) => {
       const imports = importsOf(test)
@@ -141,48 +116,11 @@ export const acceptanceFault = (file: string, tip: KeptTip): string | undefined
   return undefined
 }
 
-/** What a rebuild carries over from the naive pass `tip`: the IDs its tests name, and those test files. */
-export const naiveAcceptance = (tip: KeptTip): t.Acceptance => {
-  const ids = idsOf(REQUIREMENTS)
-  const perTest = acceptanceTests(tip.changes).map((c) => {
-    const lines = addedLines(c)
-    return { path: c.path, ids: ids.filter((id) => named(id, lines)) }
-  })
-  return {
-    hash: tip.hash,
-    tests: perTest.filter((c) => c.ids.length > 0).map((c) => c.path),
-    ids: ids.filter((id) => perTest.some((c) => c.ids.includes(id))),
-  }
-}
-
-/**
- * Refuse a rebuild whose test changes since `since` leave out an ID the naive
- * pass's tests named. A skipped test still counts: the gate reads text, never runs it.
- */
-export const requireAcceptance = (acceptance: t.Acceptance, since: string): void => {
-  const missing = unnamed(acceptance.ids, acceptanceTests(changesSince(since)))
-  if (missing.length === 0) return
-  refuse(
-    `gtd land: rebuild-acceptance: the rebuild's tests leave out ${missing.join(", ")} — carry over the naive pass's acceptance tests (\`git show ${acceptance.hash} -- ${acceptance.tests.map(quote).join(" ")}\`), each with its ID in the test or scenario name`,
-  )
-}
-
-/**
- * Refuse a fix turn that, on its own, drops an ID the naive pass's tests named
- * from a test file. Turn-local, so a person's edit at an escalation rest never
- * wedges later fix turns.
- */
-export const requireAcceptanceKept = (acceptance: t.Acceptance): void => {
-  const dropped = acceptance.ids.filter((id) =>
-    changes()
-      .filter((c) => isCode(c.path) && isTestFile(c.path))
-      .some((c) => named(id, c.before ?? "") && !named(id, c.after ?? "")),
-  )
-  if (dropped.length === 0) return
-  refuse(
-    `gtd land: rebuild-acceptance: this turn drops ${dropped.join(", ")} from the tests — the naive pass's acceptance tests stay; fix the code, not them`,
-  )
-}
+/** What a rebuild carries over from the naive pass `tip`: every test file it added or changed. */
+export const naiveAcceptance = (tip: KeptTip): t.Acceptance => ({
+  hash: tip.hash,
+  tests: acceptanceTests(tip.changes).map((c) => c.path),
+})
 
 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`
@@ -243,12 +181,6 @@ const applied = async (tip: string): Promise<boolean> => {
   return !wrote(FEEDBACK) && codeChanges().length > 0
 }
 
-/** `carried` limited to the criteria `.gtd/REQUIREMENTS.md` lists now; a file listing none narrows nothing. */
-const settled = (carried: readonly string[]): readonly string[] => {
-  const listed = idsOf(REQUIREMENTS)
-  return listed.length === 0 ? carried : carried.filter((id) => listed.includes(id))
-}
-
 const build = async (options: ImplementOptions): Promise<void> => {
   await t.agentWithSkills(
     "building",
@@ -290,19 +222,11 @@ export async function implement(
 /** `implement`, resolving with the criterion IDs the requirements listed when it closed. */
 export const implementing = (options: ImplementOptions): Promise<readonly string[]> =>
   scope("implement", async () => {
-    const since = head()
-    const acceptance = options.rebuild?.acceptance
     const built = options.naive === undefined || !(await applied(options.naive))
     if (built) await build(options)
     else requireCriteriaFrozen(REQUIREMENTS)
-    // Only the criteria the requirements still list.
-    if (built && acceptance !== undefined)
-      requireAcceptance({ ...acceptance, ids: settled(acceptance.ids) }, since)
-    // Fix turns are held to the carried tests too: deleting a red one must not buy a green suite.
-    const keepsTests =
-      built && acceptance !== undefined ? () => requireAcceptanceKept(acceptance) : undefined
-    await green(keepsTests)
-    await prototypeTest(keepsTests)
+    await green()
+    await prototypeTest()
     const ids = criterionIds(read(REQUIREMENTS) ?? "")
     await run("closing", removeScript([REQUIREMENTS, REFACTOR_NOTE, PROTOTYPE]), {
       label: "Closing out the implementation",
@@ -360,7 +284,7 @@ interface Vetting {
 
 /** 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)
+  const fault = vetting.waived ? undefined : acceptanceFault(tip)
   if (fault !== undefined) {
     const verdict = await vetting.again({ fault, hash: tip.hash })
     if (verdict.kind !== "overruled") return verdict

package/src/workflows/fix/fix-quality.feature

@@ -4,11 +4,12 @@ Feature: fix's quality lap is triaged, and its leftovers go to the hand-off revi
   A judge sorts the lap's findings: mechanical ones are fixed for up to three
   turns, noise is dropped, and design ones — with whatever the fix turns left —
   are added to the reviewer's `.gtd/REVIEW.md` by gtd, never to a person's
-  gate before the review.
+  gate before the review. With no requirements to check against, the
+  `criteria-coverage` lens runs no turn.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    And an environment variable "GTD_QUALITYREVIEWS" set to "criteria-coverage, correctness"
     And a file "src/calc.ts" with:
       """
       export const add = (a: number, b: number) => a + b
@@ -81,6 +82,7 @@ Feature: fix's quality lap is triaged, and its leftovers go to the hand-off revi
     Then the process rests at "build.review.await-review"
     And ".gtd/QUALITY.md" does not exist
     And no commit body contains "build.health.describe"
+    And no commit body contains "build.quality.criteria-coverage"
     And ".gtd/REVIEW.md" contains:
       """
       ## sum has no negative test

package/src/workflows/shared/access.test.ts

@@ -19,6 +19,7 @@ describe("the bundled workflow's access export", () => {
       "build.quality.test-audit": { write: [] },
       "build.quality.conventions": { write: [] },
       "build.quality.spec-challenge": { write: [] },
+      "build.quality.criteria-coverage": { write: [] },
       "refactor.build.review": { write: [".gtd/REVIEW.md"] },
       "refactor.build.quality.correctness": { write: [] },
       "refactor.build.quality.ponytail-review": { write: [] },

package/src/workflows/shared/review.test.ts

@@ -575,7 +575,7 @@ describe("review verdict routing", () => {
 })
 
 describe("the default quality lenses", () => {
-  it("are the six lenses in the settled order", () => {
+  it("are the seven lenses in the settled order", () => {
     expect(bundled.defaults.qualityReviews!.split(",").map((l) => l.trim())).toEqual([
       "correctness",
       "owasp-security",
@@ -583,6 +583,7 @@ describe("the default quality lenses", () => {
       "test-audit",
       "conventions",
       "spec-challenge",
+      "criteria-coverage",
     ])
   })
 
@@ -590,6 +591,7 @@ describe("the default quality lenses", () => {
     expect(Object.keys(bundled.builtInLenses).sort()).toEqual([
       "conventions",
       "correctness",
+      "criteria-coverage",
       "spec-challenge",
     ])
   })