@pmelab/gtd 32.1.0 → 34.0.0

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

@@ -41,24 +41,17 @@ 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
       """
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
-    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#1-2
-        subtract added
-      """
-    And step "build.review.closing" runs its script
     When the process is driven
     Then the process rests at "seam.judge"
 
@@ -87,6 +80,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
@@ -104,21 +101,6 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       """
     When gtd lands
     And the process is driven
-    Then the process rests at "build.review.await-review"
-
-    Given a file ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [x] ./src/calc.ts#1-2
-        subtract added
-      """
-    When gtd lands
-    And the process is driven
     Then the process rests at "idle"
     And the commit subjects end with:
       """
@@ -127,24 +109,25 @@ 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
-      gtd(check): implement.closing → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.await-review
-      gtd(human): build.review.await-review → build.review.closing
-      gtd(check): build.review.closing → idle
+      gtd(check): implement.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
@@ -121,18 +146,23 @@ Feature: the naive pass and seam judge decide how a feature is built
     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"
+    Then the process rests at "idle"
     And the commit subjects end with:
       """
       gtd(judge): seam.judge → implement.building
       gtd(agent): implement.building → implement.health.check
       gtd(check): implement.health.check → implement.closing
-      gtd(check): implement.closing → build.review.reviewing
+      gtd(check): implement.closing → idle
       """
     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
       """
@@ -227,99 +276,3 @@ Feature: the naive pass and seam judge decide how a feature is built
       gtd(judge): seam.judge → seam.steer
       gtd(human): seam.steer → implement.building
       """
-
-  Scenario: review feedback after land re-runs design and implement, never the seam phase
-    Given step "seam.naive" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => b + a
-      """
-    And judge step "seam.judge" answers:
-      """
-      [{"id":"shape","answer":"land","p":0.9}]
-      """
-    And step "implement.building" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      export const SUBTRACT = process.env.GTD_FLAG_SUBTRACT === "1"
-      """
-    And step "implement.health.check" changes nothing
-    And step "implement.closing" runs its script
-    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#1-1
-        new add function
-      """
-    When the process is driven
-    Then the process rests at "build.review.await-review"
-    Given a file ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#1-1
-        new add function[^why]
-
-      [^why]:
-          - H: also export multiply
-      """
-    And step "build.review.collecting" writes ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-
-      ## Concerns
-
-      ### Multiply
-
-      - Export `multiply()`.
-      """
-    And step "build.review.collecting" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#1-1
-        new add function[^why]
-
-      [^why]:
-          - H: also export multiply
-          - A: noted in the requirements.
-      """
-    When gtd lands
-    And the process is driven
-    Then the process rests at "build.review.await-review"
-    Given a file ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#1-1
-        new add function
-      """
-    And step "build.review.closing" runs its script
-    And step "re-unwind" runs its script
-    When gtd lands
-    And the process is driven
-    Then the process rests at "implement.building"
-    And the commit subjects end with:
-      """
-      gtd(check): build.review.closing → re-unwind
-      gtd(check): re-unwind → design.triage
-      gtd(agent): design.triage → design.gate.answer
-      gtd(human): design.gate.answer → implement.building
-      gtd(agent): implement.building
-      """

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 () => {