@pmelab/gtd 53.0.0 → 55.0.0

package/src/workflows/feature/feature.ts

@@ -57,6 +57,8 @@ export const buildFeature = async (firstBase: string): Promise<void> => {
   const handedOut = new Set(listedIds())
   const seam = await seamBuild(firstBase)
   const used = gather(handedOut)
+  // Read before the implementation closes the file: the quality lap's coverage lens checks them.
+  const requirements = read(REQUIREMENTS)
   const closed = await implementing({
     reference: seam.reference,
     tier,
@@ -72,7 +74,7 @@ export const buildFeature = async (firstBase: string): Promise<void> => {
     !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
       ? firstBase
       : seam.base
-  const outcome = await reviewedTail(base, base)
+  const outcome = await reviewedTail(base, base, requirements)
   await featureFeedback(outcome, base, { closed, used })
 }
 
@@ -87,11 +89,12 @@ const gather = (handedOut: Set<string>): readonly string[] => {
 const reviewedTail = (
   base: string,
   lensBase: string,
+  requirements: string | undefined,
   lap: "first" | "feedback" = "first",
 ): Promise<ReviewOutcome> =>
   tail(
     (escalations, report) => humanReview(base, escalations, { report, walkthrough: true, lap }),
-    { green: true, lensBase },
+    { green: true, lensBase, requirements },
   )
 
 // seam.naive / seam.judge never run on a feedback lap: its design → implement is built unjudged
@@ -113,8 +116,9 @@ const featureFeedback = async (
       gather(handedOut)
     })
     const tier = riskTierOn() ? recordRisk() : undefined
+    const requirements = read(REQUIREMENTS)
     closed = await implementing({ tier, amend: true })
-    outcome = await reviewedTail(outcome.base, lensBase, "feedback")
+    outcome = await reviewedTail(outcome.base, lensBase, requirements, "feedback")
   }
 }
 
@@ -133,8 +137,9 @@ export const afterTail = async (first: ReviewOutcome): Promise<void> => {
     await reUnwind(outcome)
     await design(outcome.base)
     const tier = riskTierOn() ? recordRisk() : undefined
+    const requirements = read(REQUIREMENTS)
     await implement({ tier, amend: true })
-    outcome = await buildTail(outcome.base, { green: true })
+    outcome = await buildTail(outcome.base, { green: true, requirements })
   }
 }
 

package/src/workflows/feature/green.ts

@@ -3,7 +3,7 @@ import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { requireCriteriaFrozen } from "./criteria.js"
 
-export const green = (guard?: () => void): Promise<void> =>
+export const green = (): Promise<void> =>
   healthy(
     () =>
       t.agentWithSkills("fix.suite.fixing", t.implementFixPrompt(), {
@@ -13,10 +13,7 @@ export const green = (guard?: () => void): Promise<void> =>
         system: t.builderSystem(),
       }),
     {
-      guard: () => {
-        requireCriteriaFrozen(REQUIREMENTS)
-        guard?.()
-      },
+      guard: () => requireCriteriaFrozen(REQUIREMENTS),
       guardRests: false,
     },
   )

package/src/workflows/feature/lens-review.feature

@@ -161,6 +161,56 @@ Feature: the quality lap's findings are triaged before the review
       gtd(check): build.review.carrying → build.review.await-review
       """
 
+  Scenario: a risk is fixed before the human sees the review, re-reviewed in the reviewer's own draft
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9},{"id":"Q2","answer":"noise","p":0.85},{"id":"Q3","answer":"design","p":0.8}]
+      """
+    And step "build.fix.quality.fixing" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("subtracts a larger number", () => {})
+      """
+    And step "build.fix.quality.fixing" deletes ".gtd/QUALITY.md"
+    And step "build.health.check" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Subtract
+
+      - [ ] ./src/calc.ts#2-2 — Risk: overflows on large numbers
+
+      ## AC-1 ignores floating point
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+      """
+    When the process is driven
+    Then the process rests at "build.review.fix.risks.fixing"
+    Given step "build.review.reviewing" is no longer scripted
+    And step "build.review.reviewing" replaces the text "Risk: overflows on large numbers" in ".gtd/REVIEW.md" with "subtract(a, b), now guarded"
+    And step "build.review.fix.risks.fixing" changes nothing
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains "subtract(a, b), now guarded"
+    And ".gtd/REVIEW.md" contains "## Fixed automatically" exactly once
+    And ".gtd/REVIEW.md" contains "## Dropped as noise" exactly once
+    And ".gtd/REVIEW.md" contains "## Walkthrough" exactly once
+    And ".gtd/REVIEW.md" contains "Should subtract round? The criterion does not say." exactly once
+    And ".gtd/REVIEW.md" contains "Tick exactly one:" exactly once
+    And the commit subjects end with:
+      """
+      gtd(check): build.health.check → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.fix.risks.fixing
+      gtd(agent): build.review.fix.risks.fixing → build.health.check
+      gtd(check): build.health.check → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
+      gtd(check): build.review.carrying → build.review.await-review
+      """
+
   Scenario: an unsure verdict makes a finding a note, never a fix or a drop
     Given judge step "build.quality.triage" answers:
       """

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/refactor-review.feature

@@ -1185,6 +1185,44 @@ Feature: the refactor is reviewed on its own before the feature is implemented
         """
       And no commit body contains "refactor.build.review.composing"
 
+    Scenario: a risk the refactor's re-review marks again reaches the human unfixed
+      Given step "refactor.build.review.reviewing" writes ".gtd/REVIEW.md" with:
+        """
+        # Review: abc1234
+
+        <!-- base: 0000000 -->
+
+        ## calc
+
+        - [ ] ./src/calc.ts#1-2 — Risk: drops the sign
+        """
+      When the process is driven
+      Then the process rests at "refactor.build.review.fix.risks.fixing"
+      Given step "refactor.build.review.reviewing" is no longer scripted
+      And step "refactor.build.review.reviewing" replaces the text "Risk: drops the sign" in ".gtd/REVIEW.md" with "Risk: still drops the sign"
+      And step "refactor.build.review.fix.risks.fixing" changes nothing
+      And step "refactor.build.health.check" changes nothing
+      When the process is driven
+      Then the process rests at "refactor.build.review.await-review"
+      And ".gtd/REVIEW.md" contains:
+        """
+        ## Walkthrough
+
+        ### calc
+
+        - [ ] ./src/calc.ts#1-2 — Risk: still drops the sign
+        """
+      And ".gtd/REVIEW.md" contains "## Walkthrough" exactly once
+      And the commit subjects end with:
+        """
+        gtd(agent): refactor.build.review.reviewing → refactor.build.review.fix.risks.fixing
+        gtd(agent): refactor.build.review.fix.risks.fixing → refactor.build.health.check
+        gtd(check): refactor.build.health.check → refactor.build.review.reviewing
+        gtd(agent): refactor.build.review.reviewing → refactor.build.review.ranking
+        gtd(judge): refactor.build.review.ranking → refactor.build.review.carrying
+        gtd(check): refactor.build.review.carrying → refactor.build.review.await-review
+        """
+
   Rule: with a quality lens on both the refactor and the feature
 
     Background:

package/src/workflows/feature/reviewer-walkthrough.feature

@@ -179,37 +179,6 @@ Feature: a reviewer walks the human through the feature's code
       """
     Then driving the process is refused with "AC-1 ignores floating point — no chunk of its own"
 
-  Scenario: a risk the reviewer marks is fixed before the human sees the review
-    Given step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## Subtract
-
-      - [ ] ./src/calc.ts#2-2 — Risk: overflows on large numbers
-
-      ## AC-1 ignores floating point
-
-      - [ ] ./src/calc.ts#2-2 — returns the raw difference
-      """
-    And step "build.review.fix.risks.fixing" changes nothing
-    And step "build.health.check" changes nothing
-    When the process is driven
-    Then the process rests at "build.review.await-review"
-    And the commit subjects end with:
-      """
-      gtd(agent): build.review.reviewing → build.review.ranking
-      gtd(judge): build.review.ranking → build.review.carrying
-      gtd(check): build.review.carrying → build.review.fix.risks.fixing
-      gtd(agent): build.review.fix.risks.fixing → build.health.check
-      gtd(check): build.health.check → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.ranking
-      gtd(judge): build.review.ranking → build.review.carrying
-      gtd(check): build.review.carrying → build.review.await-review
-      """
-
   Scenario: a standard conflict the reviewer writes itself is refused
     Given step "build.review.reviewing" writes ".gtd/REVIEW.md" 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")