@pmelab/gtd 40.0.0 → 42.0.0

package/src/testkit/FlowScripts.ts

@@ -12,6 +12,7 @@ import {
   restoreScript,
   revertScript,
   showScript,
+  writeScript,
 } from "../flows/index.js"
 import type { InMemRepo } from "./InMemRepo.js"
 import type { ScriptedCommand } from "./Layers.js"
@@ -60,6 +61,19 @@ const recognizeMove = (repo: InMemRepo, script: string): FlowScriptResult | unde
   return ok()
 }
 
+const recognizeWrite = (repo: InMemRepo, script: string): FlowScriptResult | undefined => {
+  const lines = shellLines(script.split("\n"))
+  if (!lines[3]?.startsWith("printf '%s' ")) return undefined
+  const [path] = words(lines[2] ?? "")
+  const [, content, to] = words(lines[3])
+  const remove = words(lines.find((l) => l.startsWith("rm -rf -- ")) ?? "")
+  if (path === undefined || content === undefined || to !== path) return undefined
+  if (writeScript(path, content, remove) !== script) return undefined
+  repo.writeFile(path, content)
+  removeAll(repo, remove)
+  return ok()
+}
+
 const recognizeShow = (repo: InMemRepo, script: string): FlowScriptResult | undefined => {
   const line = script.split("\n").find((l) => l.startsWith("git show ")) ?? ""
   const [source, to] = words(line)
@@ -356,6 +370,7 @@ export const applyFlowScript = (
     recognizeRemove(repo, script) ??
     recognizeMove(repo, script) ??
     recognizeShow(repo, script) ??
+    recognizeWrite(repo, script) ??
     recognizePatch(repo, script) ??
     recognizeRestore(repo, script) ??
     recognizeCheck(repo, commands, script)

package/src/testkit/steps.ts

@@ -127,6 +127,19 @@ Given("the file {string} is deleted", (world: TestkitWorld, path: string) => {
   world.repo().remove(path)
 })
 
+// A human's edit in place, so a scenario need not restate a file gtd wrote.
+Given(
+  "the text {string} in {string} is replaced with {string}",
+  (world: TestkitWorld, text: string, path: string, replacement: string) => {
+    const content = world.repo().read(path) ?? ""
+    assert.ok(content.includes(text), `${path}: ${content}`)
+    world.repo().write(
+      path,
+      content.replace(text, () => replacement),
+    )
+  },
+)
+
 Given("the working tree is committed as {string}", (world: TestkitWorld, message: string) => {
   world.repo().commit(message)
 })
@@ -341,6 +354,20 @@ Then("{string} contains {string}", (world: TestkitWorld, path: string, text: str
   assert.ok(world.repo().read(path)?.includes(text), `${path}: ${world.repo().read(path)}`)
 })
 
+Then("{string} contains:", (world: TestkitWorld, path: string, text: string) => {
+  assert.ok(world.repo().read(path)?.includes(text), `${path}: ${world.repo().read(path)}`)
+})
+
+Then(
+  "{string} contains the short hash of the commit {string}",
+  (world: TestkitWorld, path: string, subject: string) => {
+    const repo = world.repo()
+    const hash = repo.hashes()[repo.subjects().lastIndexOf(subject)]
+    assert.ok(hash !== undefined, `no commit "${subject}"`)
+    assert.ok(repo.read(path)?.includes(hash.slice(0, 7)), `${path}: ${repo.read(path)}`)
+  },
+)
+
 Then("{string} does not contain {string}", (world: TestkitWorld, path: string, text: string) => {
   const content = world.repo().read(path)
   assert.ok(content !== undefined && !content.includes(text), `${path}: ${content}`)

package/src/workflow-kit/health.ts

@@ -32,6 +32,8 @@ export const untilSettled = async (
   }
 }
 
+export type RetryVerdict = "identical" | "progress"
+
 export interface Health {
   /** One counted run of the suite; resolves `true` when green. */
   readonly check: () => Promise<boolean>
@@ -39,8 +41,8 @@ export interface Health {
   readonly report: string
   readonly fixCap: number
   readonly fixesSoFar?: number
-  /** Whether two consecutive red reports are the same failure; `true` escalates at once. */
-  readonly sameFailure: (previous: string, current: string) => Promise<boolean>
+  /** How a red report compares to the previous round's: `identical` escalates at once, `progress` at the cap earns one extra fix. */
+  readonly compare: (previous: string, current: string) => Promise<RetryVerdict | undefined>
   /** Shared with other callers in the same run of red checks. */
   readonly escalations: EscalationCount
   readonly escalation: EscalationSteps
@@ -58,13 +60,42 @@ const recheckReport = async (health: Health): Promise<true | string | undefined>
   return (await health.recheck()) || stripStamp(read(health.report) ?? "")
 }
 
+/** Escalate unless the re-check passes: `true` then, else the report the next round compares against. */
+const escalated = async (health: Health, current: string): Promise<true | string> => {
+  const rechecked = await recheckReport(health)
+  if (rechecked === true) {
+    health.escalations.rounds = 0
+    return true
+  }
+  await escalation(health.escalations, health.escalation)
+  return rechecked ?? current
+}
+
+const nextMove = async (
+  health: Health,
+  fixes: number,
+  cap: number,
+  previous: string | undefined,
+  current: string,
+): Promise<"extend" | "escalate" | undefined> => {
+  const capped = fixes >= cap
+  // Past a raised cap the loop escalates whatever the judge would answer.
+  if (capped && cap > health.fixCap) return "escalate"
+  const verdict = previous === undefined ? undefined : await health.compare(previous, current)
+  if (capped && verdict === "progress") return "extend"
+  return verdict === "identical" || capped ? "escalate" : undefined
+}
+
 /**
  * Loop until the suite is green: check, and on red run `fix` — escalating
- * first once `fixCap` fixes are spent, or `sameFailure` calls the failure
- * identical to the previous round's, unless `recheck` passes.
+ * first once `fixCap` fixes are spent, or `compare` calls the failure
+ * identical to the previous round's, unless `recheck` passes. A round that
+ * reaches the cap while `compare` calls it progress raises the cap by one fix,
+ * once per run of fixes between escalations.
  */
 export const healthy = async (fix: () => Promise<void>, health: Health): Promise<void> => {
   let fixes = health.fixesSoFar ?? 0
+  let cap = health.fixCap
   let previous: string | undefined
   for (;;) {
     if (await health.check()) {
@@ -72,17 +103,15 @@ export const healthy = async (fix: () => Promise<void>, health: Health): Promise
       return
     }
     const current = stripStamp(read(health.report) ?? "")
-    const stuck = previous !== undefined && (await health.sameFailure(previous, current))
+    const move = await nextMove(health, fixes, cap, previous, current)
     previous = current
-    if (stuck || fixes >= health.fixCap) {
-      const rechecked = await recheckReport(health)
-      if (rechecked === true) {
-        health.escalations.rounds = 0
-        return
-      }
-      previous = rechecked ?? previous
-      await escalation(health.escalations, health.escalation)
+    if (move === "extend") cap++
+    else if (move === "escalate") {
+      const after = await escalated(health, current)
+      if (after === true) return
+      previous = after
       fixes = 0
+      cap = health.fixCap
     }
     fixes++
     await fix()

package/src/workflows/feature/coverage.feature

@@ -61,13 +61,13 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
       """
     When the process is driven
-    Then the process rests at "build.review.reviewing"
+    Then the process rests at "build.review.composing"
     And the commit subjects end with:
       """
       gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
-      gtd(check): implement.closing → build.review.reviewing
+      gtd(check): implement.closing → build.review.composing
       """
     And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
     And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-2"
@@ -144,7 +144,7 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       """
     And step "implement.uncovered" changes nothing
     When the process is driven
-    Then the process rests at "build.review.reviewing"
+    Then the process rests at "build.review.composing"
     And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
     And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: uncovered=AC-2"
 

package/src/workflows/feature/fast-path.feature

@@ -64,7 +64,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       """
     And step "implement.applying" runs its script
     When the process is driven
-    Then the process rests at "build.review.reviewing"
+    Then the process rests at "build.review.composing"
     And "src/greeting.ts" contains "Hello, world"
     And the commit subjects end with:
       """
@@ -80,7 +80,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
+      gtd(agent): build.quality.correctness.reviewing → build.review.composing
       """
     And the output of gtd "summary" <summary> "needs a human reviewer"
 

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest"
-import { runsItsScript, testRepo, type Actor } from "../../testkit/index.js"
+import { runsItsScript, testRepo } from "../../testkit/index.js"
 import { CONFIG_SCAFFOLD } from "../../install/index.js"
 import { reviewDoc } from "../shared/config.fixture.js"
 
@@ -75,10 +75,7 @@ describe("afterTail feedback lap", () => {
     `}`,
   ].join("\n")
 
-  const prompts: string[] = []
-
   const feedbackLap = async () => {
-    prompts.length = 0
     const repo = testRepo({
       workflow: TAIL,
       env: {
@@ -93,10 +90,7 @@ describe("afterTail feedback lap", () => {
     await repo.drive({
       "review-gate.check": () => undefined,
       "build.health.check": () => undefined,
-      "build.review.reviewing": (beat, r) => {
-        prompts.push(beat.content)
-        r.write(".gtd/REVIEW.md", review())
-      },
+      "build.review.composing": (_, r) => r.write(".gtd/REVIEW.md", review()),
     })
     repo.write(".gtd/REVIEW.md", review("also export multiply"))
     await repo.land()
@@ -137,35 +131,6 @@ describe("afterTail feedback lap", () => {
     expect(rest.content).not.toContain("write the change fresh")
     expect(repo.subjects().some((subject) => subject.includes("seam."))).toBe(false)
   })
-
-  it("the first review says everything since base, the one after feedback only what is new", async () => {
-    const repo = await feedbackLap()
-    expect(prompts[0]).toContain("it covers everything since the base")
-    expect(prompts[0]).not.toContain("only what is new since the previous review")
-    const writes: Record<string, () => [string, string]> = {
-      "design.triage": () => [
-        ".gtd/REQUIREMENTS.md",
-        "# Requirements\n\n- multiply, designed\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-      ],
-      "implement.building": () => ["src/calc.ts", `${CALC}// again\n`],
-    }
-    const actors = new Proxy({} as Record<string, Actor>, {
-      get: (_, state: string): Actor | undefined =>
-        state === "build.review.await-review" || state === "idle"
-          ? undefined
-          : (beat, r) => {
-              if (state === "implement.coverage") return '[{"id":"AC-1","answer":"yes","p":0.9}]'
-              if (state === "build.review.reviewing") {
-                prompts.push(beat.content)
-                r.write(".gtd/REVIEW.md", review())
-              } else if (writes[state]) r.write(...writes[state]())
-              else if (state.endsWith("closing") || state === "re-unwind") r.runScript(beat.content)
-            },
-    })
-    await repo.drive(actors, { maxBeats: 80 })
-    expect(prompts[1]).toContain("it covers only what is new since the previous review")
-    expect(prompts[1]).not.toContain("everything since the base")
-  })
 })
 
 describe("an in-flight 28.0.0 naive-pass process", () => {

package/src/workflows/feature/feature.ts

@@ -9,7 +9,7 @@ import {
   slice,
   start,
 } from "../../flows/index.js"
-import { gate, healthy, type EscalationCount } from "../shared/health.js"
+import { gate, healthy } from "../shared/health.js"
 import { flagModeOn, shipped } from "../shared/options.js"
 import { FEEDBACK, fixCheck, QUALITY, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff, tail } from "../shared/tail.js"
@@ -135,8 +135,8 @@ const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> =
   })
 }
 
-// The lap's findings the fix cap left must not reach the review, nor the next process's lap,
-// which appends to the file. Empty counts as resolved, as the lap reads it.
+// Between slices nothing reviews the lap's leftovers, and the next lap appends to the file.
+// Empty counts as resolved, as the lap reads it.
 const settleQuality = async (): Promise<void> => {
   let rested = false
   while ((read(QUALITY) ?? "").length > 0) {
@@ -151,15 +151,13 @@ const settleQuality = async (): Promise<void> => {
   if (rested) await healthy(() => fixCheck())
 }
 
-/** The quality lap, then the human review since `base`. */
-const reviewedTail = (base: string, lensBase: string, lap?: "feedback"): Promise<ReviewOutcome> =>
-  tail(
-    async (escalations: EscalationCount) => {
-      await settleQuality()
-      return review(base, escalations, { lap })
-    },
-    { green: true, lensBase },
-  )
+/** The triaged quality lap, then the human review since `base`. */
+const reviewedTail = (base: string, lensBase: string): Promise<ReviewOutcome> =>
+  tail((escalations, report) => review(base, escalations, { report }), {
+    green: true,
+    lensBase,
+    triage: true,
+  })
 
 // seam.naive / seam.judge never run on a feedback lap: its design → implement is built unjudged
 // and unrefactored, held to every criterion's coverage since the process start.
@@ -181,7 +179,7 @@ const featureFeedback = async (
     })
     const tier = riskTierOn() ? recordRisk() : undefined
     closed = await implementing({ tier, amend: true })
-    outcome = await reviewedTail(outcome.base, lensBase, "feedback")
+    outcome = await reviewedTail(outcome.base, lensBase)
   }
 }
 
@@ -201,7 +199,7 @@ export const afterTail = async (first: ReviewOutcome): Promise<void> => {
     await design(outcome.base)
     const tier = riskTierOn() ? recordRisk() : undefined
     await implement({ tier, amend: true })
-    outcome = await buildTail(outcome.base, { green: true, lap: "feedback" })
+    outcome = await buildTail(outcome.base, { green: true })
   }
 }
 

package/src/workflows/feature/flag-mode.feature

@@ -67,7 +67,7 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       """
     And step "build.quality.correctness.reviewing" changes nothing
     When the process is driven
-    Then the process rests at "build.review.reviewing"
+    Then the process rests at "build.review.composing"
     And "src/calc.ts" contains "subtract"
     And "src/calc.test.ts" contains "[AC-1] subtracts"
     And the commit subjects end with:
@@ -85,5 +85,5 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
+      gtd(agent): build.quality.correctness.reviewing → build.review.composing
       """

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

@@ -0,0 +1,234 @@
+@inmem
+Feature: the quality lenses are the only agentic review
+
+  A judge classifies each `## ` finding the lenses wrote to `.gtd/QUALITY.md`:
+  a mechanical one is fixed by the fixer, noise is dropped with its `p` kept in
+  a trailer, and a design one becomes a note in `.gtd/REVIEW.md`. gtd writes
+  that file itself — no reviewer turn runs — and lists, without tick boxes,
+  what was fixed automatically and what was dropped as noise.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    And an environment variable "GTD_FLAGMODE" set to "false"
+    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`.
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      """
+    And step "design.gate.answer" changes nothing
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    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 step "seam.check" changes nothing
+    And step "implement.applying" runs its script
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
+    And step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## subtract has no negative test
+
+      Add a test subtracting a larger number.
+
+      ## add could be a method
+
+      A class would read better.
+
+      ## AC-1 ignores floating point
+
+      Should subtract round? The criterion does not say.
+      """
+    And step "build.quality.sorting" runs its script
+    And step "build.review.composing" runs its script
+
+  Scenario: a mechanical finding is fixed and listed, noise dropped and listed, a design one noted
+    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
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/QUALITY.md" does not exist
+    And the commit "gtd(judge): build.quality.triage → build.quality.sorting" has a body containing "Gtd-Mark: noise=Q2 p=0.85 add could be a method"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## AC-1 ignores floating point
+
+      Should subtract round? The criterion does not say.
+
+      ## Fixed automatically
+
+      - subtract has no negative test (
+      """
+    And ".gtd/REVIEW.md" contains the short hash of the commit "gtd(agent): build.fix.quality.fixing → build.health.check"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## Dropped as noise
+
+      - add could be a method (p=0.85)
+      """
+    And ".gtd/REVIEW.md" does not contain "[ ]"
+    And the commit subjects end with:
+      """
+      gtd(check): implement.closing → build.quality.correctness.reviewing
+      gtd(agent): build.quality.correctness.reviewing → build.quality.triage
+      gtd(judge): build.quality.triage → build.quality.sorting
+      gtd(check): build.quality.sorting → build.fix.quality.fixing
+      gtd(agent): build.fix.quality.fixing → build.health.check
+      gtd(check): build.health.check → build.review.composing
+      gtd(check): build.review.composing → 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:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.5},{"id":"Q2","answer":"noise","p":0.6}]
+      """
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains "## subtract has no negative test"
+    And ".gtd/REVIEW.md" contains "## add could be a method"
+    And ".gtd/REVIEW.md" contains "## AC-1 ignores floating point"
+    And ".gtd/REVIEW.md" does not contain "Fixed automatically"
+    And no commit body contains "Gtd-Mark: noise="
+    And the commit subjects end with:
+      """
+      gtd(judge): build.quality.triage → build.quality.sorting
+      gtd(check): build.quality.sorting → build.review.composing
+      gtd(check): build.review.composing → build.review.await-review
+      """
+
+  Scenario: a mechanical finding the fix cap leaves becomes a note
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9},{"id":"Q2","answer":"mechanical","p":0.9},{"id":"Q3","answer":"mechanical","p":0.9}]
+      """
+    And step "build.fix.quality.fixing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## add could be a method
+
+      A class would read better.
+      """
+    And step "build.health.check" changes nothing
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/QUALITY.md" does not exist
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## add could be a method
+
+      _The fixer left this unresolved._
+
+      A class would read better.
+      """
+    And ".gtd/REVIEW.md" contains "- subtract has no negative test ("
+    And ".gtd/REVIEW.md" contains "- AC-1 ignores floating point ("
+    And the commit subjects end with:
+      """
+      gtd(judge): build.quality.triage → build.fix.quality.fixing
+      gtd(agent): build.fix.quality.fixing
+      gtd(agent): build.fix.quality.fixing
+      gtd(agent): build.fix.quality.fixing → build.health.check
+      gtd(check): build.health.check → build.review.composing
+      gtd(check): build.review.composing → build.review.await-review
+      """
+
+  Scenario: a fixer that renames a chunk it leaves counts nothing fixed
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9},{"id":"Q2","answer":"mechanical","p":0.9},{"id":"Q3","answer":"mechanical","p":0.9}]
+      """
+    And step "build.fix.quality.fixing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## null check in parse()
+
+      Still open.
+      """
+    And step "build.health.check" changes nothing
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains "## null check in parse()"
+    And ".gtd/REVIEW.md" contains "## subtract has no negative test"
+    And ".gtd/REVIEW.md" contains "check whether it was fixed"
+    And ".gtd/REVIEW.md" does not contain "Fixed automatically"
+
+  Scenario: prose the fixer leaves outside every chunk does not hide its fixes
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9},{"id":"Q2","answer":"mechanical","p":0.9},{"id":"Q3","answer":"mechanical","p":0.9}]
+      """
+    And step "build.fix.quality.fixing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      All fixed.
+      """
+    And step "build.health.check" changes nothing
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains "- subtract has no negative test ("
+    And ".gtd/REVIEW.md" does not contain "check whether it was fixed"
+
+  Scenario: signing off a composed review ends the process
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"noise","p":0.9},{"id":"Q2","answer":"noise","p":0.9},{"id":"Q3","answer":"noise","p":0.9}]
+      """
+    And step "build.review.closing" runs its script
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/REVIEW.md" does not exist
+    And the commit subjects end with:
+      """
+      gtd(check): build.review.composing → build.review.await-review
+      gtd(human): build.review.await-review → build.review.closing
+      gtd(check): build.review.closing → idle
+      """

package/src/workflows/feature/one-step-land.feature

@@ -64,7 +64,7 @@ Feature: a naive pass the judge rules land is itself the implementation
 
   Scenario: a land judgment applies the naive pass and runs from idle to the review gate with no rebuild
     When the process is driven
-    Then the process rests at "build.review.reviewing"
+    Then the process rests at "build.review.composing"
     And "src/greeting.ts" contains "Hello, world"
     And "src/acceptance.test.ts" contains "[AC-1] holds"
     And the commit subjects end with:
@@ -81,7 +81,7 @@ Feature: a naive pass the judge rules land is itself the implementation
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
+      gtd(agent): build.quality.correctness.reviewing → build.review.composing
       """
     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.check" has a body containing "Gtd-Kept:"