@pmelab/gtd 27.6.0 → 27.7.1

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

@@ -118,69 +118,6 @@ Feature: the risk tier is proposed at triage and recorded behind GTD_FLAG_RISK_T
         | low  |
         | high |
 
-    Scenario Outline: low and high processes produce the same commit subjects to implement.building
-      Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-        """
-        # Requirements
-
-        ## Risk Tier
-
-        <tier> — reason
-        """
-      And step "design.gate.answer" changes nothing
-      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
-        """
-      And judge step "seam.judge" answers:
-        """
-        [{"id":"shape","answer":"land","p":0.9}]
-        """
-      When the process is driven
-      Then the process rests at "implement.building"
-      And the commit subjects end with:
-        """
-        gtd(agent): design.triage → design.gate.answer
-        gtd(human): design.gate.answer → seam.naive
-        gtd(agent): seam.naive → seam.judge
-        gtd(judge): seam.judge → implement.building
-        """
-
-      Examples:
-        | tier |
-        | low  |
-        | high |
-
-    Scenario Outline: the implementation prompt demands a flag for high and none for low
-      Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-        """
-        # Requirements
-
-        ## Risk Tier
-
-        <tier> — reason
-        """
-      And step "design.gate.answer" changes nothing
-      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
-        """
-      And judge step "seam.judge" answers:
-        """
-        [{"id":"shape","answer":"land","p":0.9}]
-        """
-      When the process is driven
-      Then the process rests at "implement.building"
-      And the resting step's content contains "<demand>"
-      And the resting step's content does not contain "<absent>"
-
-      Examples:
-        | tier | demand                                                | absent                |
-        | high | Put the new behaviour behind a new release flag       | Add no release flag   |
-        | low  | Add no release flag — this change is low risk tier    | new release flag      |
-
     Scenario: the tier comes from the requirements the final design gate lap accepted
       Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
         """

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

@@ -0,0 +1,146 @@
+# One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
+@inmem
+Feature: rejected naive passes walk one fixed path through the steer gate to idle
+
+  With GTD_FLAG_NAIVE_PASS on and GTD_FLAG_RISK_TIER off, three rejected naive
+  passes rest at the steer gate, where a human edit restarts the seam and the
+  steered rerun lands. The flags are pinned so the per-flag test runs never
+  move it off its path.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And an environment variable "GTD_FLAG_NAIVE_PASS" set to "1"
+    And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`.
+      """
+    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:
+      """
+      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"
+
+    Given step "seam.naive" is prompted with "Your previous attempt was rejected"
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"reject","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the resting step's content contains "Overrule"
+    And the resting step's content contains "src/calc.ts"
+
+    Given a file ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`, in the calculator module.
+      """
+    And step "seam.naive" from now on changes nothing
+    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
+      """
+    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 = (a: number, b: number) => a - b
+      export const SUBTRACT = true
+      """
+    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:
+      """
+      gtd(human): idle → unwind
+      gtd(check): unwind → start-gate.check
+      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(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → seam.steer
+      gtd(human): seam.steer → seam.naive
+      gtd(agent): seam.naive → 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
+      """
+    And the commit "gtd(human): idle → unwind" has a body containing "Gtd-Var: flag_naive_pass=1"
+    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(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\""
+    And no commit body contains "Gtd-Approved:"
+    And no commit body contains "Gtd-Workflow:"

package/src/workflows/feature/seam.feature

@@ -166,73 +166,6 @@ Feature: the naive pass and seam judge replace architecture behind GTD_FLAG_NAIV
     And the resting step's content contains "src/calc.ts"
     And the resting step's content does not contain "src/calc*.ts"
 
-  Scenario: a refactor-first judgment rests at the approval gate, then refactors, then implements
-    Given 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
-      """
-    And judge step "seam.judge" answers:
-      """
-      [{"id":"shape","answer":"refactor-first","p":0.9}]
-      """
-    And step "refactor.deriving" writes ".gtd/REFACTOR.md" with:
-      """
-      # Behaviour-neutral refactor
-
-      ## Scope (read-only)
-
-      - `src/calc.ts` # gtd-path-exempt: scenario fixture, not a repo file
-      """
-    And step "refactor.building" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      export const op = (a: number, b: number, sign: number) => a + sign * b
-      """
-    And step "refactor.health.check" changes nothing
-    And step "refactor.closing" runs its script
-    When the process is driven
-    Then the process rests at "seam.approve"
-    And the resting step's content contains "src/calc.ts"
-    When gtd lands
-    Then the last commit subject is "gtd(human): seam.approve → refactor.deriving"
-    And the last commit body contains "Gtd-Approved:"
-    When the process is driven
-    Then the process rests at "implement.building"
-    And the commit subjects end with:
-      """
-      gtd(judge): seam.judge → seam.approve
-      gtd(human): seam.approve → refactor.deriving
-      gtd(check): refactor.deriving → refactor.building
-      gtd(agent): refactor.building → refactor.health.check
-      gtd(check): refactor.health.check → refactor.closing
-      gtd(check): refactor.closing → implement.building
-      """
-
-  Scenario: three rejects retry the naive pass twice, then rest at the steer gate
-    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":"reject","p":0.9}]
-      """
-    When the process is driven
-    Then the process rests at "seam.steer"
-    And the resting step's content contains "Overrule"
-    And the resting step's content contains "src/calc.ts"
-    And the commit subjects end with:
-      """
-      gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive → seam.judge
-      gtd(judge): seam.judge → seam.naive
-      gtd(agent): seam.naive → seam.judge
-      gtd(judge): seam.judge → seam.naive
-      gtd(agent): seam.naive → seam.judge
-      gtd(judge): seam.judge → seam.steer
-      """
-
   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:
       """

package/src/workflows/shared/steps.ts

@@ -117,7 +117,6 @@ export const fixRisks = (notes: readonly t.NoteInput[]): Promise<void> =>
 export const awaitReview = (
   base: string,
   message = t.buildReviewAwaitReviewMessage(base),
-  acceptClean = false,
 ): Promise<void> =>
   human("review.await-review", {
     message,
@@ -125,7 +124,7 @@ export const awaitReview = (
     file: REVIEW,
     mode: "review",
     base,
-    ...(acceptClean ? { acceptClean } : {}),
+    acceptClean: true,
   })
 
 /** The round at commit `round` left no `.gtd/REVIEW.md`. */

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

@@ -38,8 +38,18 @@ const handOff = async (
   } = {},
 ) => {
   const log: string[] = []
+  const gates: boolean[] = []
   const scripts = new Map<string, string>()
   const files = new Map<string, string>()
+  const onReviewing = () => {
+    if (log.filter((n) => n === "review.reviewing").length > 1) throw new Error("re-review")
+    if (after !== "unwritten") files.set(REVIEW, reviewDoc("new add function"))
+  }
+  const onGate = (request: StepRequest) => {
+    if (request.kind === "human") gates.push(request.options.acceptClean === true)
+    if (after === "deleted") files.delete(REVIEW)
+    else if (after !== "unwritten") files.set(REVIEW, after)
+  }
   installContext(
     fixtureContext(
       { codeThreads: extra.codeThreads ?? [] },
@@ -48,14 +58,8 @@ const handOff = async (
           if (request.kind === "restart") return Promise.resolve()
           log.push(request.name)
           if (request.kind === "run") scripts.set(request.name, request.body)
-          if (request.name === "review.reviewing") {
-            if (log.filter((n) => n === "review.reviewing").length > 1) throw new Error("re-review")
-            if (after !== "unwritten") files.set(REVIEW, reviewDoc("new add function"))
-          }
-          if (request.name === "review.await-review") {
-            if (after === "deleted") files.delete(REVIEW)
-            else if (after !== "unwritten") files.set(REVIEW, after)
-          }
+          if (request.name === "review.reviewing") onReviewing()
+          if (request.name === "review.await-review") onGate(request)
           return Promise.resolve()
         },
         refuse: (message: string): never => {
@@ -96,7 +100,7 @@ const handOff = async (
     () => undefined,
     (e: unknown) => (e as Error).message,
   )
-  return { log, scripts, refusal }
+  return { log, scripts, refusal, gates }
 }
 
 describe("the hand-off review", () => {
@@ -105,6 +109,11 @@ describe("the hand-off review", () => {
     expect(run.log).toEqual(["review.reviewing", "review.await-review", "review.closing"])
   })
 
+  it("the review gate accepts a clean landing", async () => {
+    const run = await handOff(reviewDoc("new add function"))
+    expect(run.gates).toEqual([true])
+  })
+
   it("a note ends the round with the review kept and the reviewer's version copied beside it", async () => {
     const run = await handOff(reviewDoc("new add function — rename it to sum"))
     expect(run.log).toEqual(["review.reviewing", "review.await-review", "review.handing-off"])

package/src/workflows/shared/workflows.steps.ts

@@ -35,12 +35,13 @@ Then("the last commit body contains {string}", (world: TestkitWorld, text: strin
 Then(
   "the commit {string} has a body containing {string}",
   (world: TestkitWorld, subject: string, text: string) => {
-    const message = world
+    // Every commit with the subject, so a repeated step is not judged by its first match.
+    const matching = world
       .repo()
       .messages()
-      .find((m) => m.split("\n")[0] === subject)
-    assert.ok(message !== undefined, `no commit "${subject}"`)
-    assert.ok(message.includes(text), message)
+      .filter((m) => m.split("\n")[0] === subject)
+    assert.ok(matching.length > 0, `no commit "${subject}"`)
+    for (const message of matching) assert.ok(message.includes(text), message)
   },
 )