@pmelab/gtd 27.6.0 → 27.7.1

package/src/testkit/steps.ts

@@ -70,7 +70,15 @@ export class TestkitWorld extends QuickPickleWorld {
         for (const action of actions) await action(beat, repo)
       }
     }
-    for (const [step, verdict] of this.verdicts) actors[step] = () => verdict
+    for (const [step, verdict] of this.verdicts) {
+      // A verdict would overwrite the queued actions, silently skipping their checks.
+      if (this.actions.has(step)) {
+        throw new Error(
+          `step "${step}" has a judge verdict and queued actions; the actions would never run`,
+        )
+      }
+      actors[step] = () => verdict
+    }
     await this.repo().drive(actors)
   }
 }
@@ -120,6 +128,19 @@ Given(
   },
 )
 
+// A standing assertion like any queued action: it applies on every later visit
+// to the step until `from now on` clears the list.
+Given(
+  "step {string} is prompted with {string}",
+  (world: TestkitWorld, step: string, text: string) => {
+    world.act(step, (beat) => {
+      if (!beat.content.includes(text)) {
+        throw new Error(`step "${step}" was not prompted with "${text}":\n${beat.content}`)
+      }
+    })
+  },
+)
+
 Given("step {string} runs its script", (world: TestkitWorld, step: string) => {
   world.act(step, runsItsScript)
 })
@@ -207,6 +228,28 @@ Then("the commit subjects end with:", (world: TestkitWorld, list: string) => {
   assert.deepStrictEqual(world.repo().subjects().slice(-expected.length), expected)
 })
 
+const outputOf = async (world: TestkitWorld, list: string): Promise<string> => {
+  const result = await world.repo().gtd(...args(list))
+  assert.strictEqual(result.exitCode, 0, result.stderr)
+  return result.stdout
+}
+
+Then(
+  "the output of gtd {string} contains {string}",
+  async (world: TestkitWorld, list: string, text: string) => {
+    const out = await outputOf(world, list)
+    assert.ok(out.includes(text), out)
+  },
+)
+
+Then(
+  "the output of gtd {string} does not contain {string}",
+  async (world: TestkitWorld, list: string, text: string) => {
+    const out = await outputOf(world, list)
+    assert.ok(!out.includes(text), out)
+  },
+)
+
 Then("{string} contains {string}", (world: TestkitWorld, path: string, text: string) => {
   assert.ok(world.repo().read(path)?.includes(text), `${path}: ${world.repo().read(path)}`)
 })

package/src/testkit/testkit.feature

@@ -1,3 +1,4 @@
+@inmem
 Feature: testkit drives any workflow against the real engine
 
   A workflow the scenario writes itself, never a shipped one: scripted actors
@@ -47,6 +48,8 @@ Feature: testkit drives any workflow against the real engine
       gtd(judge): ready → ship
       """
     And "PLAN.md" contains "add two numbers"
+    And the output of gtd "next" contains "ship"
+    And the output of gtd "next" does not contain "rework"
 
   Scenario: a red check sends the process to repair, and an unscripted step is where it rests
     Given step "plan" writes "PLAN.md" with:
@@ -63,6 +66,38 @@ Feature: testkit drives any workflow against the real engine
     And the resting step's content contains "Make the suite pass."
     And the last commit subject is "gtd(check): check → repair"
 
+  Scenario: a step's beat content is asserted as a queued actor
+    Given step "plan" is prompted with "Write PLAN.md."
+    And step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "check" changes nothing
+    And judge step "ready" answers:
+      """
+      [{ "id": "ready", "answer": true, "p": 0.9 }]
+      """
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process rests at "ship"
+    And "PLAN.md" contains "add two numbers"
+
+  Scenario: a judge step with queued actions refuses the drive
+    Given step "plan" changes nothing
+    And step "check" changes nothing
+    And step "ready" is prompted with "never seen"
+    And judge step "ready" answers:
+      """
+      [{ "id": "ready", "answer": true, "p": 0.9 }]
+      """
+    When gtd starts workflow "tiny"
+    Then driving the process is refused with "queued actions"
+
+  Scenario: a beat that lacks the expected text refuses the drive
+    Given step "plan" is prompted with "Write a poem"
+    When gtd starts workflow "tiny"
+    Then driving the process is refused with 'was not prompted with "Write a poem"'
+
   Scenario: a start the workflow refuses is reported with its message
     Then starting workflow "picky" with "--var mode=bad" is refused with "picky refuses every start"
 

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

@@ -0,0 +1,94 @@
+# One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
+@inmem
+Feature: cleanup walks one fixed path from the opening commit to idle
+
+  A default-on release flag is cleaned up by an agent that removes the registry
+  entry and the off path; health, review and closing follow and the process
+  rests at idle. Cleanup reads no release flag, so no flag is pinned here and
+  every flag state takes the same path.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And a gtd config with:
+      """
+      export {
+        feature as default,
+        feature,
+        defaults,
+        envDefaults,
+        summary,
+        steering,
+        skills,
+        access,
+      } from "@pmelab/gtd/workflows/feature"
+      import { cleanup } from "@pmelab/gtd/workflows"
+      export { cleanup }
+      """
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And a file "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And a file "src/calc.ts" with:
+      """
+      export const on = process.env.GTD_FLAG_LIVE !== "0"
+      """
+    And the working tree is committed as "feat: registry"
+    And step "cleanup.removing" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
+      ] as const
+      """
+    And step "cleanup.removing" writes "src/calc.ts" with:
+      """
+      export const on = true
+      """
+    And step "build.health.check" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        flag removed
+      """
+    And step "build.review.closing" runs its script
+
+  Scenario: removing the entry and the off path runs health, review and closing to idle
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    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-1
+        flag removed
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And "src/flags/index.ts" does not contain "live"
+    And "src/calc.ts" does not contain "GTD_FLAG_LIVE"
+    And the commit subjects end with:
+      """
+      gtd(human): cleanup.removing
+      gtd(agent): cleanup.removing → build.health.check
+      gtd(check): build.health.check → 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): cleanup.removing" has a body containing "Gtd-Workflow: cleanup"
+    And the commit "gtd(human): cleanup.removing" has a body containing "Gtd-Var: flag=live"

package/src/workflows/cleanup/cleanup.feature

@@ -36,35 +36,6 @@ Feature: cleanup removes a default-on release flag and keeps its flag-on path
       """
     And the working tree is committed as "feat: registry"
 
-  Scenario: removing the entry and the off path lands, then reaches the review gate
-    Given step "cleanup.removing" writes "src/flags/index.ts" with:
-      """
-      export const FLAGS = [
-        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
-        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
-      ] as const
-      """
-    And step "cleanup.removing" writes "src/calc.ts" with:
-      """
-      export const on = true
-      """
-    And step "build.health.check" changes nothing
-    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#1-1
-        flag removed
-      """
-    When gtd starts workflow "cleanup" with "--var flag=live"
-    And the process is driven
-    Then the process rests at "build.review.await-review"
-    And "src/flags/index.ts" does not contain "live"
-
   Scenario: a turn leaving the registry entry is refused
     Given step "cleanup.removing" writes "src/calc.ts" with:
       """

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

@@ -0,0 +1,114 @@
+@inmem
+Feature: a trivial change takes the same few beats at either risk tier, flag-free at low
+
+  With GTD_FLAG_NAIVE_PASS and GTD_FLAG_RISK_TIER on, a one-line copy fix goes
+  from idle through the naive pass, the seam judge's land, implement and human
+  review back to idle. Low tier walks exactly the steps high does; only the
+  implementation prompt and the summary differ.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    And an environment variable "GTD_FLAG_NAIVE_PASS" set to "1"
+    And an environment variable "GTD_FLAG_RISK_TIER" set to "1"
+    And a file "src/greeting.ts" with:
+      """
+      export const greeting = "Helo, world"
+      """
+    And the working tree is committed as "feat: add greeting"
+    And a file "TODO.md" with:
+      """
+      # Fix the typo
+
+      greeting says "Helo"; make it "Hello".
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.gate.answer" changes nothing
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+    And step "build.quality.correctness.reviewing" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## greeting
+
+      - [ ] ./src/greeting.ts#1-1
+        typo fixed
+      """
+    And step "build.review.closing" runs its script
+
+  Scenario Outline: a one-line fix runs idle to idle with the same beats at either tier
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Risk Tier
+
+      <tier> — one-line copy fix
+      """
+    When the process is driven
+    Then the process rests at "seam.naive"
+    And the last commit subject is "gtd(human): design.gate.answer → seam.naive"
+
+    Given step "seam.naive" writes "src/greeting.ts" with:
+      """
+      export const greeting = "Hello, world"
+      """
+    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>"
+
+    Given step "implement.building" writes "src/greeting.ts" with:
+      """
+      export const greeting = "Hello, world!"
+      """
+    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 -->
+
+      ## greeting
+
+      - [x] ./src/greeting.ts#1-1
+        typo fixed
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And "src/greeting.ts" contains "Hello, world!"
+    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 → implement.building
+      gtd(agent): implement.building → implement.health.check
+      gtd(check): implement.health.check → implement.closing
+      gtd(check): implement.closing → build.quality.correctness.reviewing
+      gtd(agent): build.quality.correctness.reviewing → 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 output of gtd "summary" <summary> "needs a human reviewer"
+
+    Examples:
+      | tier | demand                                             | absent              | summary          |
+      | low  | Add no release flag                                | new release flag    | does not contain |
+      | high | Put the new behaviour behind a new release flag    | Add no release flag | contains         |

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

@@ -0,0 +1,108 @@
+# One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
+@inmem
+Feature: a naive pass the judge rules land goes straight to implement with no seam gate
+
+  With GTD_FLAG_NAIVE_PASS on and GTD_FLAG_RISK_TIER off, a naive pass that
+  edits an existing source file is judged land: the process skips the approval
+  gate, any refactor and any architecture, and runs implement, quality and
+  review back to idle. The flags are pinned here so the per-flag test runs never
+  move it off this path.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    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/greeting.ts" with:
+      """
+      export const greeting = "Helo, world"
+      """
+    And the working tree is committed as "feat: add greeting"
+    And a file "TODO.md" with:
+      """
+      # Fix the typo
+
+      greeting says "Helo"; make it "Hello".
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Typo
+
+      - greeting reads "Hello, world".
+      """
+    And step "design.gate.answer" changes nothing
+    And step "seam.naive" writes "src/greeting.ts" with:
+      """
+      export const greeting = "Hello, world"
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"land","p":0.9}]
+      """
+    And step "implement.building" writes "src/greeting.ts" with:
+      """
+      export const greeting = "Hello, world!"
+      """
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+    And step "build.quality.correctness.reviewing" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## greeting
+
+      - [ ] ./src/greeting.ts#1-1
+        typo fixed
+      """
+    And step "build.review.closing" runs its script
+
+  Scenario: a land judgment runs idle to idle with no seam gate, refactor or architecture
+    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 -->
+
+      ## greeting
+
+      - [x] ./src/greeting.ts#1-1
+        typo fixed
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And "src/greeting.ts" contains "Hello, world!"
+    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 → implement.building
+      gtd(agent): implement.building → implement.health.check
+      gtd(check): implement.health.check → implement.closing
+      gtd(check): implement.closing → build.quality.correctness.reviewing
+      gtd(agent): build.quality.correctness.reviewing → 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 → 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/refactor-first.feature

@@ -0,0 +1,137 @@
+# One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
+@inmem
+Feature: a refactor-first judgment walks one fixed path to idle
+
+  With GTD_FLAG_NAIVE_PASS on and GTD_FLAG_RISK_TIER off, a naive pass touching
+  an existing non-allowlisted file is ruled refactor-first, rests at the
+  approval gate, and is refactored before it is implemented. 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: a refactor-first judgment runs approval, refactor, implement and review to idle
+    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" runs its script
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-3
+        subtract built on the shared op
+      """
+    And step "build.review.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
+    And the process is driven
+    Then the process rests at "refactor.building"
+    And ".gtd/REFACTOR.md" contains "calc.ts`"
+
+    Given step "refactor.building" writes "src/calc.ts" with:
+      """
+      export const op = (a: number, b: number, sign: number) => a + sign * b
+      export const add = (a: number, b: number) => op(a, b, 1)
+      """
+    And step "refactor.health.check" changes nothing
+    And step "refactor.closing" runs its script
+    When the process is driven
+    Then the process rests at "implement.building"
+    And ".gtd/REFACTOR.md" does not exist
+    And "src/calc.ts" contains "op(a, b, 1)"
+
+    Given step "implement.building" writes "src/calc.ts" with:
+      """
+      export const op = (a: number, b: number, sign: number) => a + sign * b
+      export const add = (a: number, b: number) => op(a, b, 1)
+      export const subtract = (a: number, b: number) => op(a, b, -1)
+      """
+    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.await-review"
+
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [x] ./src/calc.ts#1-3
+        subtract built on the shared op
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And "src/calc.ts" contains "op(a, b, 1)"
+    And "src/calc.ts" contains "subtract"
+    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.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
+      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.approve" has a body containing "\"answer\":\"refactor-first\""
+    And the commit "gtd(human): seam.approve → refactor.deriving" has a body containing "Gtd-Approved: {\"step\":\"seam.approve#1\",\"name\":\"Test\",\"email\":\"test@test.com\"}"
+    And no commit body contains "Gtd-Workflow:"

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

@@ -509,13 +509,19 @@ describe("severity routing", () => {
       notes: ["add — quote", "sub", "mul"],
       answers: { "note-1": verdict("edit"), ...sev("note-1", could) },
     })
-    expect(run.gates).toEqual([false, true])
+    expect(run.gates).toEqual([true, true])
     expect(run.gateMessages[1]).toContain("NOT acted on")
     expect(run.gateMessages[1]).toContain("note-1")
     expect(run.gateMessages[0]).not.toContain("NOT acted on")
   })
 
-  it("a later gate does not accept a clean land after a deferral round with a nit", async () => {
+  it("the first round's gate accepts a clean land", async () => {
+    const run = await drive({ notes: ["add", "sub", "mul"] })
+    expect(run.gates.length).toBeGreaterThan(0)
+    expect(run.gates.every((g) => g)).toBe(true)
+  })
+
+  it("a later gate still accepts a clean land after a deferral round with a nit", async () => {
     const run = await drive({
       notes: ["add — quote", "sub — typo", "mul"],
       answers: {
@@ -527,7 +533,7 @@ describe("severity routing", () => {
     })
     expect(run.log).toContain("review.defer")
     expect(run.log.at(-1)).toBe("review.await-review")
-    expect(run.gates).toEqual([false, false])
+    expect(run.gates).toEqual([true, true])
   })
 
   it("a question and a could note in one round: the gate's base is the answering commit", async () => {

package/src/workflows/feature/review.ts

@@ -167,8 +167,8 @@ export const review = (
   escalations: EscalationCount = { rounds: 0 },
 ): Promise<kit.ReviewOutcome> => {
   const severities = new Map<string, Severity>()
-  // Armed by a defer-only round and spent at the very next gate; a fresh
-  // review (`reviewing`) disarms it, so a later gate never accepts a clean land.
+  // Armed by a defer-only round to pick the next gate's message; a fresh
+  // review (`reviewing`) disarms it.
   let deferred: readonly t.NoteInput[] = []
   return kit.review(base, {
     file: REVIEW,
@@ -184,7 +184,7 @@ export const review = (
       const notes = deferred
       deferred = []
       return notes.length > 0
-        ? awaitReview(b, t.buildReviewAwaitAfterDeferMessage(b, notes), true)
+        ? awaitReview(b, t.buildReviewAwaitAfterDeferMessage(b, notes))
         : awaitReview(b)
     },
     reviewMissing,