@pmelab/gtd 45.2.0 → 47.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "45.2.0",
+  "version": "47.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {
@@ -62,11 +62,6 @@
       "source": "./src/workflows/cleanup/index.ts",
       "default": "./dist/workflows/cleanup.mjs"
     },
-    "./workflows/tests": {
-      "types": "./src/workflows/tests/index.ts",
-      "source": "./src/workflows/tests/index.ts",
-      "default": "./dist/workflows/tests.mjs"
-    },
     "./testkit": {
       "types": "./src/testkit/index.ts",
       "source": "./src/testkit/index.ts",

package/src/install/ConfigScaffold.ts

@@ -6,8 +6,7 @@ export const CONFIG_SCAFFOLD = `// The workflows gtd runs here: gtd's shipped fe
 // its own doors: \`gtd door review [base]\` and \`gtd door fix\`. Export \`rollout\`
 // from \`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
 // \`@pmelab/gtd/workflows/cleanup\` to add \`gtd door rollout <flag>\` and
-// \`gtd door cleanup <flag>\`, and \`tests\` from \`@pmelab/gtd/workflows/tests\`
-// to add \`gtd door tests\`.
+// \`gtd door cleanup <flag>\`.
 export {
   feature as default,
   feature,

package/src/install/Install.ts

@@ -516,11 +516,10 @@ rather than starting the review; \`gtd-door fix\` on a GREEN suite is a no-op
 straight back to \`idle\` — the exec'd \`gtd-build\` exits immediately on it.
 \`gtd doors\` lists the doors a repository offers (those of the workflows its
 config exports — the bundled \`fix\` and \`review [base]\`, plus the opt-in
-\`rollout <flag>\` (turn a release flag default-on), \`cleanup <flag>\`
-(remove it) and \`tests\` (revive skipped tests), which a config adds by
-exporting \`rollout\` from \`@pmelab/gtd/workflows/rollout\`, \`cleanup\` from
-\`@pmelab/gtd/workflows/cleanup\` and \`tests\` from
-\`@pmelab/gtd/workflows/tests\` — plus any it declares). Refuses with
+\`rollout <flag>\` (turn a release flag default-on) and \`cleanup <flag>\`
+(remove it), which a config adds by exporting \`rollout\` from
+\`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
+\`@pmelab/gtd/workflows/cleanup\` — plus any it declares). Refuses with
 \`usage: gtd-door <name> [args...]\` on stderr and exit \`2\` when the name is
 missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-door\`.
 

package/src/workflows/cleanup/cleanup.test.ts

@@ -90,6 +90,13 @@ describe("the cleanup guard over every later agent turn", () => {
     "build.health.check": () => undefined,
   }
 
+  // One lens finding, judged mechanical, so it reaches the fix turn.
+  const MECHANICAL: Actors = {
+    "build.quality.correctness.reviewing": (_, r) =>
+      r.write(".gtd/QUALITY.md", "# Quality\n\n## a finding\n\nFix it.\n"),
+    "build.quality.triage": () => '[{"id":"Q1","answer":"mechanical","p":0.9}]',
+  }
+
   // Without the shipped access rules, which would refuse a source write from a read-only turn first: the guard is the second line.
   const NO_ACCESS = CONFIG.replace("  access,\n", "")
 
@@ -185,15 +192,11 @@ describe("the cleanup guard over every later agent turn", () => {
     ).rejects.toThrow("src/b.ts:1 still names GTD_FLAG_LIVE")
   })
 
-  it("refuses the first fix after escalating quality findings that re-adds the env var", async () => {
+  it("refuses a quality fix turn that re-adds the env var", async () => {
     await expect(
       driven(guarded("correctness", NO_ACCESS), {
-        "build.quality.correctness.reviewing": (_, r) =>
-          r.write(".gtd/QUALITY.md", "- a finding\n"),
-        "build.fix.quality.fixing": () => undefined,
-        "build.health.describe": () => undefined,
-        "build.health.stop": () => undefined,
-        "build.fix": (_, r) => r.write("src/b.ts", NAMED),
+        ...MECHANICAL,
+        "build.fix.quality.fixing": (_, r) => r.write("src/b.ts", NAMED),
       }),
     ).rejects.toThrow("src/b.ts:1 still names GTD_FLAG_LIVE")
   })
@@ -209,8 +212,7 @@ describe("the cleanup guard over every later agent turn", () => {
   it("refuses a quality fix turn that restores the registry entry", async () => {
     await expect(
       driven(guarded("correctness"), {
-        "build.quality.correctness.reviewing": (_, r) =>
-          r.write(".gtd/QUALITY.md", "- a finding\n"),
+        ...MECHANICAL,
         "build.fix.quality.fixing": (_, r) => r.write("src/flags/index.ts", REGISTRY),
       }),
     ).rejects.toThrow('still declares flag "live"')

package/src/workflows/feature/feature.ts

@@ -9,9 +9,10 @@ import {
   slice,
   start,
 } from "../../flows/index.js"
-import { gate, healthy } from "../shared/health.js"
+import { gate } from "../shared/health.js"
+import { joinReports, type LensReport } from "../shared/lenses.js"
 import { flagModeOn, shipped } from "../shared/options.js"
-import { FEEDBACK, fixCheck, QUALITY, REQUIREMENTS } from "../shared/steps.js"
+import { FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff, tail } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 import {
@@ -36,7 +37,8 @@ import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
 // green-baseline gate → design → per slice of the criteria, a naive pass,
 // judged with `flagMode` on: it lands as the implementation, or (refactoring
 // first when the judge asks) is built fresh from → the health loop → the
-// quality lap → after the last slice, human review of the whole change, which
+// triaged quality lap, whose leftovers are carried on → after the last slice,
+// human review of the whole change and every slice's findings, which
 // signs off (the episode ends back at `idle`) or sends a design → implement
 // lap.
 
@@ -63,10 +65,12 @@ export const buildFeature = async (firstBase: string): Promise<void> => {
   const one = slices.length === 1
   // A steer may delete every criterion of a later slice: there is nothing to build there.
   const built = (i: number): boolean => sliceIds(sliceCriteria(slices, i))?.length !== 0
+  const reports: { slice: string; report: LensReport }[] = []
   for (const i of slices.keys()) {
     if (!built(i)) continue
     const n = one ? "" : `-${i + 1}`
     await buildSlice(i === 0 ? firstBase : head(), {
+      number: `${i + 1}`,
       tier,
       criteria: sliceCriteria(slices, i),
       refactor: `refactor${n}`,
@@ -76,6 +80,7 @@ export const buildFeature = async (firstBase: string): Promise<void> => {
       // Every slice but the one is built unreviewed, so the review covers them all.
       reviewBase: one ? undefined : firstBase,
       handedOut,
+      laps: reports,
     })
   }
 }
@@ -88,6 +93,8 @@ const gather = (handedOut: Set<string>): readonly string[] => {
 }
 
 interface SliceBuild {
+  /** The slice's number, from 1. */
+  readonly number: string
   readonly tier: RiskTier | undefined
   readonly criteria: CriteriaSlice | undefined
   readonly refactor: string
@@ -97,6 +104,8 @@ interface SliceBuild {
   readonly reviewBase?: string | undefined
   /** Every criterion ID handed out so far; the slice adds those a steer adds. */
   readonly handedOut: Set<string>
+  /** Each earlier slice's lap report, by slice number, for the review after the last one. */
+  readonly laps: { slice: string; report: LensReport }[]
 }
 
 /** A naive pass (judged only with `flagMode` on), then implement and the quality lap; after the last slice, the review. */
@@ -127,37 +136,38 @@ const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> =
     if (more) {
       // The criteria stay in the tree for the next slice; no quality fix may move them.
       const guard = () => requireCriteriaFrozen(REQUIREMENTS)
-      await tail(settleQuality, { green: true, lensBase: base, guard, guardRests: false })
+      // No gate between slices: what the lap left waits for the review after the last one.
+      const report = await tail(async (_, report) => report, {
+        green: true,
+        lensBase: base,
+        guard,
+        guardRests: false,
+      })
+      build.laps.push({ slice: build.number, report })
       return
     }
     const reviewBase = build.reviewBase ?? base
-    await featureFeedback(await reviewedTail(reviewBase, base), base, { closed, used })
+    const outcome = await reviewedTail(reviewBase, base, { slice: build.number, laps: build.laps })
+    await featureFeedback(outcome, base, { closed, used })
   })
 }
 
-// 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) {
-    rested = true
-    await human("quality-unresolved", {
-      message: t.qualityUnresolvedMessage(),
-      label: "Quality findings left unresolved",
-      file: QUALITY,
-    })
-  }
-  // The person may have fixed code by hand there; nothing else checks it before the review.
-  if (rested) await healthy(() => fixCheck())
-}
-
-/** The triaged quality lap, then the human review since `base`. */
-const reviewedTail = (base: string, lensBase: string): Promise<ReviewOutcome> =>
-  tail((escalations, report) => humanReview(base, escalations, { report }), {
-    green: true,
-    lensBase,
-    triage: true,
-  })
+/** The quality lap of slice `last.slice`, then the human review since `base`, listing what earlier slices' `laps` left too. */
+const reviewedTail = (
+  base: string,
+  lensBase: string,
+  last: { readonly slice: string; readonly laps: SliceBuild["laps"] } = { slice: "", laps: [] },
+): Promise<ReviewOutcome> =>
+  tail(
+    (escalations, report) =>
+      humanReview(base, escalations, {
+        report:
+          last.laps.length === 0
+            ? report
+            : joinReports([...last.laps, { slice: last.slice, report }]),
+      }),
+    { green: true, lensBase },
+  )
 
 // 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.

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

@@ -74,6 +74,7 @@ Feature: the quality lenses are the only agentic review
       Should subtract round? The criterion does not say.
       """
     And step "build.quality.sorting" runs its script
+    And step "build.quality.closing" 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
@@ -184,7 +185,8 @@ Feature: the quality lenses are the only agentic review
       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.health.check → build.quality.closing
+      gtd(check): build.quality.closing → build.review.composing
       gtd(check): build.review.composing → build.review.await-review
       """
 

package/src/workflows/feature/slice-findings.feature

@@ -0,0 +1,198 @@
+@inmem
+Feature: every slice's quality lap is triaged, and its leftovers wait for the review
+
+  A judge sorts each slice's findings like the last slice's (see
+  `lens-review.feature`): mechanical ones are fixed, noise is dropped, design
+  ones are never sent to the fixer. Nothing between slices asks a person
+  anything — what a lap leaves is carried to the review after the last slice,
+  each finding naming its slice and lens.
+
+  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 an environment variable "GTD_SLICEMAXCRITERIA" set to "1"
+    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:
+      """
+      # More arithmetic
+
+      subtract and multiply.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: multiply(a, b) returns a * b.
+      """
+    And step "design.gate.answer" changes nothing
+    And step "design.slicing" writes ".gtd/SLICES.md" with:
+      """
+      # Slices
+
+      ## Subtract
+
+      - AC-1
+
+      ## Multiply
+
+      - AC-2
+      """
+    And step "seam.naive", when prompted with "This slice builds AC-1 only", writes "src/sub.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And step "seam.naive", when prompted with "This slice builds AC-2 only", writes "src/mul.test.ts" with:
+      """
+      it("[AC-2] multiplies", () => {})
+      """
+    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", when its questions contain "AC-1", answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
+    And judge step "implement.coverage", when its questions contain "AC-2", answers:
+      """
+      [{"id":"AC-2","answer":"yes","p":0.9}]
+      """
+    And step "build.quality.sorting" runs its script
+    And step "build.quality.closing" runs its script
+    And step "build.health.check" changes nothing
+    And step "build.review.composing" runs its script
+
+  Scenario: a finding questioning a criterion reaches the final review, never the fixer
+    Given step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## AC-1 ignores floating point
+
+      Should subtract round? The criterion does not say.
+      """
+    And judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"design","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And no commit body contains "build.fix.quality.fixing"
+    And ".gtd/QUALITY.md" does not exist
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## AC-1 ignores floating point
+
+      _From slice 1, lens correctness._
+
+      Should subtract round? The criterion does not say.
+      """
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## AC-1 ignores floating point (2)
+
+      _From slice 2, lens correctness._
+      """
+    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 → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → implement.applying
+      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.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.review.composing
+      gtd(check): build.review.composing → build.review.await-review
+      """
+
+  Scenario: a mechanical finding the fix cap leaves in an early slice is carried, never escalated
+    Given step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## subtract has no negative test
+
+      Add a test subtracting a larger number.
+      """
+    And judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9}]
+      """
+    And step "build.fix.quality.fixing" changes nothing
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And no commit body contains "build.health.describe"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## subtract has no negative test
+
+      _From slice 1, lens correctness._
+
+      _The fixer left this unresolved._
+      """
+    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.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.quality.closing
+      gtd(check): build.quality.closing → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → implement.applying
+      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.quality.correctness.reviewing
+      gtd(agent): build.quality.correctness.reviewing → build.quality.triage
+      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.quality.closing
+      gtd(check): build.quality.closing → build.review.composing
+      gtd(check): build.review.composing → build.review.await-review
+      """
+
+  Scenario: the final review lists every slice's fixes with their commits
+    Given step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## subtract has no negative test
+
+      Add a test subtracting a larger number.
+      """
+    And judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9}]
+      """
+    And step "build.fix.quality.fixing" writes "src/edge.test.ts" with:
+      """
+      it("subtracts a larger number", () => {})
+      """
+    And step "build.fix.quality.fixing" deletes ".gtd/QUALITY.md"
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains ", slice 1, lens correctness)"
+    And ".gtd/REVIEW.md" contains ", slice 2, lens correctness)"
+    And ".gtd/REVIEW.md" contains the short hash of the commit "gtd(agent): build.fix.quality.fixing → build.health.check"
+    And no commit body contains "build.quality.closing"

package/src/workflows/fix/fix-lens-origin.feature

@@ -0,0 +1,101 @@
+@inmem
+Feature: each finding the reviewer is handed names the lens that wrote it
+
+  Lenses append to `.gtd/QUALITY.md` in turn, so a finding belongs to the lens
+  whose turn added it — even when two lenses give findings the same title,
+  which the review then tells apart by a numbered suffix.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness,tests"
+    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 ".gtd/REVIEW.orig.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        new add function
+      """
+    And a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        new add function — rename it to sum
+      """
+    And the working tree is committed as "chore: hand off a review"
+    And step "notes.fixing" writes "src/calc.ts" with:
+      """
+      export const sum = (a: number, b: number) => a + b
+      """
+    And step "notes.closing" runs its script
+    And step "build.health.check" changes nothing
+    And step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## sum is untested
+
+      From correctness.
+      """
+    And step "build.quality.tests.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## sum is untested
+
+      From correctness.
+
+      ## sum is untested
+
+      From tests.
+      """
+    And step "build.quality.sorting" runs its script
+    And step "build.quality.closing" runs its script
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        renamed to sum
+      """
+    And step "build.review.carrying" runs its script
+
+  Scenario: two lenses' findings with one title each name their own lens
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"design","p":0.9},{"id":"Q2","answer":"design","p":0.9}]
+      """
+    When gtd opens door "fix"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## sum is untested
+
+      _From lens correctness._
+
+      From correctness.
+
+      ## sum is untested (2)
+
+      _From lens tests._
+
+      From tests.
+      """

package/src/workflows/fix/fix-quality.feature

@@ -0,0 +1,131 @@
+@inmem
+Feature: fix's quality lap is triaged, and its leftovers go to the hand-off review
+
+  A judge sorts the lap's findings: mechanical ones are fixed for up to three
+  turns, noise is dropped, and design ones — with whatever the fix turns left —
+  are added to the reviewer's `.gtd/REVIEW.md` by gtd, never to a person's
+  gate before the review.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    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 ".gtd/REVIEW.orig.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        new add function
+      """
+    And a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        new add function — rename it to sum
+      """
+    And the working tree is committed as "chore: hand off a review"
+    And step "notes.fixing" writes "src/calc.ts" with:
+      """
+      export const sum = (a: number, b: number) => a + b
+      """
+    And step "notes.closing" runs its script
+    And step "build.health.check" changes nothing
+    And step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## sum has no negative test
+
+      Add a test summing negative numbers.
+
+      ## sum should be named plus
+
+      The glossary says plus.
+      """
+    And step "build.quality.sorting" runs its script
+    And step "build.quality.closing" runs its script
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        renamed to sum
+      """
+    And step "build.review.carrying" runs its script
+
+  Scenario: a design finding and one the fix cap left reach the reviewer, never an escalation
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9},{"id":"Q2","answer":"design","p":0.9}]
+      """
+    And step "build.fix.quality.fixing" changes nothing
+    When gtd opens door "fix"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/QUALITY.md" does not exist
+    And no commit body contains "build.health.describe"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## sum has no negative test
+
+      _From lens correctness._
+
+      _The fixer left this unresolved._
+      """
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## sum should be named plus
+
+      _From lens correctness._
+
+      The glossary says plus.
+      """
+    And the commit subjects end with:
+      """
+      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
+      gtd(agent): build.fix.quality.fixing
+      gtd(agent): build.fix.quality.fixing → build.health.check
+      gtd(check): build.health.check → build.quality.closing
+      gtd(check): build.quality.closing → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.carrying
+      gtd(check): build.review.carrying → build.review.await-review
+      """
+
+  Scenario: a fixed finding and a noise one are listed in the review
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9},{"id":"Q2","answer":"noise","p":0.9}]
+      """
+    And step "build.fix.quality.fixing" writes "src/calc.test.ts" with:
+      """
+      it("sums negative numbers", () => {})
+      """
+    And step "build.fix.quality.fixing" deletes ".gtd/QUALITY.md"
+    When gtd opens door "fix"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And no commit body contains "build.quality.closing"
+    And ".gtd/REVIEW.md" contains "## Fixed automatically"
+    And ".gtd/REVIEW.md" contains "- sum 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 "- sum should be named plus (p=0.9, lens correctness)"