@pmelab/gtd 32.1.0 → 34.0.0

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

@@ -47,6 +47,8 @@ const review = (text?: string): string =>
 
 const CALC = "export const add = (a: number, b: number) => a + b\n"
 
+const ACCEPTANCE = 'it("[AC-1] done", () => {})\n'
+
 const naivePlanned = () => {
   const repo = testRepo({
     workflow: CONFIG_SCAFFOLD,
@@ -62,99 +64,6 @@ const naivePlanned = () => {
   return repo
 }
 
-describe("planAndBuild", () => {
-  it("a refactor that carried the whole feature: the empty implement turn passes and the review covers the whole change", async () => {
-    const repo = naivePlanned()
-    const SUBTRACT = `${CALC}export const subtract = (a: number, b: number) => a - b\n`
-    expect(
-      (
-        await repo.drive({
-          unwind: () => undefined,
-          "start-gate.check": () => undefined,
-          "design.triage": (_, r) =>
-            r.write(
-              ".gtd/REQUIREMENTS.md",
-              "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-            ),
-          "design.gate.answer": () => undefined,
-          "seam.naive": (_, r) => r.write("src/calc.ts", SUBTRACT),
-          "seam.judge": () => '[{"id":"shape","answer":"refactor-first","p":0.9}]',
-          "refactor.deriving": runsItsScript,
-          "refactor.building": (_, r) => r.write("src/calc.ts", SUBTRACT),
-          "refactor.health.check": () => undefined,
-          "refactor.closing": runsItsScript,
-          "refactor.build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", review()),
-        })
-      ).state,
-    ).toBe("refactor.build.review.await-review")
-    await repo.land()
-    const rest = await repo.drive({
-      "refactor.build.review.closing": runsItsScript,
-      "implement.building": () => undefined,
-      "implement.health.check": () => undefined,
-      "implement.closing": runsItsScript,
-      "build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", review()),
-    })
-    expect(rest.state).toBe("build.review.await-review")
-    const base = (await repo.gtd("base")).stdout.trim()
-    expect(repo.show(base, "src/calc.ts")).toBe(CALC)
-  })
-
-  it("after land, feedback rests next at design.triage, then implement.building, never seam.naive", async () => {
-    const repo = naivePlanned()
-    const requirements = (_: unknown, r: typeof repo) =>
-      r.write(
-        ".gtd/REQUIREMENTS.md",
-        "# Requirements\n\n## Concerns\n\n### Subtract\n\n- `subtract`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-      )
-    const lap = {
-      unwind: () => undefined,
-      "start-gate.check": () => undefined,
-      "design.triage": requirements,
-      "design.gate.answer": () => undefined,
-      "seam.naive": (_: unknown, r: typeof repo) => r.write("src/calc.ts", `${CALC}// naive\n`),
-      "seam.judge": () => '[{"id":"shape","answer":"land","p":0.9}]',
-      "implement.building": (_: unknown, r: typeof repo) =>
-        r.write("src/calc.ts", `${CALC}// built\n`),
-      "implement.health.check": () => undefined,
-      "implement.closing": runsItsScript,
-      "build.review.reviewing": (_: unknown, r: typeof repo) => r.write(".gtd/REVIEW.md", review()),
-    }
-    expect((await repo.drive(lap)).state).toBe("build.review.await-review")
-
-    repo.write(".gtd/REVIEW.md", review("also export multiply"))
-    await repo.land()
-    const collected = await repo.drive({
-      "build.review.collecting": (_, r) => {
-        requirements(_, r)
-        r.write(".gtd/REVIEW.md", `${review("also export multiply")}    - A: noted.\n`)
-      },
-    })
-    expect(collected.state).toBe("build.review.await-review")
-
-    repo.write(".gtd/REVIEW.md", review())
-    await repo.land()
-    const rest = await repo.drive({
-      "build.review.closing": runsItsScript,
-      "re-unwind": runsItsScript,
-      "design.triage": (_, r) =>
-        r.write(
-          ".gtd/REQUIREMENTS.md",
-          "# Requirements\n\n- multiply\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-        ),
-      "design.gate.answer": () => undefined,
-    })
-    expect(rest.state).toBe("implement.building")
-    expect(rest.content).toContain("already exists")
-    expect(rest.content).not.toContain("write the change fresh")
-    const subjects = repo.subjects()
-    const reUnwind = subjects.findIndex((subject) => subject.endsWith("→ re-unwind"))
-    expect(reUnwind).toBeGreaterThan(-1)
-    expect(subjects.slice(reUnwind + 1).some((subject) => subject.includes("seam."))).toBe(false)
-    expect(subjects.filter((subject) => subject.includes("→ seam.naive"))).toHaveLength(1)
-  })
-})
-
 describe("afterTail feedback lap", () => {
   const TAIL = [
     `import { start } from "@pmelab/gtd/flows"`,
@@ -341,7 +250,10 @@ describe("an in-flight 28.0.0 naive-pass process", () => {
           "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
         ),
       "design.gate.answer": () => undefined,
-      "seam.naive": (_, r) => r.write("src/calc.ts", `${CALC}// naive\n`),
+      "seam.naive": (_, r) => {
+        r.write("src/calc.ts", `${CALC}// naive\n`)
+        r.write("src/calc.test.ts", ACCEPTANCE)
+      },
     })
     const kept = /Gtd-Kept: (\w+)/.exec(repo.messages().at(-1)!)![1]!
     const seen: Record<string, number> = {
@@ -366,16 +278,13 @@ describe("an in-flight 28.0.0 naive-pass process", () => {
     return repo
   }
 
+  // seam.check now follows every naive pass, so no rest past the first naive pass replays.
   for (const [name, trail] of Object.entries(trails)) {
-    const replays = name !== "refactor-first"
-    it(`${name}: ${replays ? "every rest replays to itself" : "every rest from the verdict on fails replay"}`, async () => {
+    it(`${name}: every rest past the naive pass fails replay`, async () => {
       for (let upTo = 1; upTo <= trail.length; upTo++) {
         const rest = trail[upTo - 1]![2]
         const repo = await forged(trail, upTo)
-        if (replays) expect((await repo.next()).state, rest).toBe(rest)
-        else {
-          await expect(repo.next(), rest).rejects.toThrow("the workflow changed under this process")
-        }
+        await expect(repo.next(), rest).rejects.toThrow("the workflow changed under this process")
       }
     })
   }

package/src/workflows/feature/feature.ts

@@ -3,15 +3,16 @@ import {
   changesSince,
   head,
   human,
+  read,
   revertScript,
   run,
   slice,
   start,
 } from "../../flows/index.js"
-import { gate } from "../shared/health.js"
+import { gate, healthy } from "../shared/health.js"
 import { flagModeOn, shipped } from "../shared/options.js"
-import { FEEDBACK } from "../shared/steps.js"
-import { refusePendingHandOff } from "../shared/tail.js"
+import { FEEDBACK, fixCheck, QUALITY } from "../shared/steps.js"
+import { refusePendingHandOff, tail } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 import { skipDesign, statedCriteria, type StatedCriteria } from "./criteria.js"
 import { design } from "./planning.js"
@@ -22,9 +23,8 @@ import { recordRisk, riskTierOn } from "./tier.js"
 // The ordinary start. Any change to the tree starts a process: `idle` →
 // `unwind` reverts the sketch (its intent survives in history) → a
 // green-baseline gate → design → a judged naive pass (refactoring first when
-// the judge asks; with `flagMode` off, neither) → implement → the quality lap
-// → human review, which signs off (the episode ends back at `idle`) or sends a
-// design → implement lap.
+// the judge asks; with `flagMode` off, neither) → implement → the quality lap,
+// and the episode ends back at `idle`. Human review is the `review` door's.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -36,9 +36,7 @@ export const unwind = (): Promise<void> => {
 
 export { reUnwind }
 
-// seam.naive / seam.judge run once: a feedback lap is design → implement on every verdict, so a
-// seam a re-plan turns up is built unjudged and unrefactored.
-/** A judged naive pass (none with `flagMode` off), then implement and review until a review round signs off; design must have run since `firstBase`. */
+/** A judged naive pass (none with `flagMode` off), then implement and the quality lap; design must have run since `firstBase`. */
 export const buildFeature = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
   const seam: Omit<SeamOutcome, "reference"> & { reference?: string } = flagModeOn()
@@ -46,15 +44,31 @@ export const buildFeature = async (firstBase: string): Promise<void> => {
     : { base: firstBase }
   await slice("feature", async () => {
     await implement({ reference: seam.reference, tier, afterRefactor: seam.refactored })
-    // An empty feature slice: the refactor carried the feature, so review the whole change.
+    // An empty feature slice: the refactor carried the feature, so the lap covers the whole change.
     const base =
       seam.refactored === true && !changesSince(seam.base).some((c) => isCode(c.path))
         ? firstBase
         : seam.base
-    await featureFeedback(await buildTail(base, { green: true, lensBase: base }), base)
+    await tail(settleQuality, { green: true, lensBase: base })
   })
 }
 
+// The lap is feature's last look: findings the fix cap left must not end the process, nor reach
+// the next one's lap, which 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 idle.
+  if (rested) await healthy(() => fixCheck())
+}
+
 /** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
 export const planAndBuild = async (firstBase: string, stated?: StatedCriteria): Promise<void> => {
   // GTD_FLAG_RISK_TIER: the tier is proposed at triage and set at the design gate, so no skip.
@@ -62,20 +76,19 @@ export const planAndBuild = async (firstBase: string, stated?: StatedCriteria):
   await buildFeature(firstBase)
 }
 
-const featureFeedback = async (first: ReviewOutcome, lensBase?: string): Promise<void> => {
+// seam.naive / seam.judge never run here: a re-plan's seam is built unjudged and unrefactored.
+/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
+export const afterTail = async (first: ReviewOutcome): Promise<void> => {
   let outcome = first
   while (outcome.verdict === "feedback") {
     await reUnwind(outcome)
     await design(outcome.base)
     const tier = riskTierOn() ? recordRisk() : undefined
     await implement({ tier, amend: true })
-    outcome = await buildTail(outcome.base, { green: true, lap: "feedback", lensBase })
+    outcome = await buildTail(outcome.base, { green: true, lap: "feedback" })
   }
 }
 
-/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
-export const afterTail = (outcome: ReviewOutcome): Promise<void> => featureFeedback(outcome)
-
 /** An ordinary start: wait at `idle`, unwind the sketch, check the baseline, then plan and build. */
 export const ordinaryStart = async (): Promise<void> => {
   await human("idle", { message: t.idleMessage(), label: "Idle", file: ".gtd/TODO.md" })

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

@@ -58,7 +58,7 @@ Feature: flag mode off builds a feature with no release flag, seam judge or refa
     And step "implement.closing" runs its script
     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 "idle"
     And "src/calc.ts" contains "subtract"
     And the commit subjects end with:
       """
@@ -72,94 +72,5 @@ Feature: flag mode off builds a feature with no release flag, seam judge or refa
       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.quality.correctness.reviewing → idle
       """
-
-  Scenario: flag mode off asks for no flag on a feedback lap either
-    Given 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
-      """
-    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 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#2-2
-        new subtract function
-      """
-    When the process is driven
-    Then the process rests at "build.review.await-review"
-    Given a file ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#2-2
-        new subtract function[^why]
-
-      [^why]:
-          - H: also export multiply
-      """
-    And step "build.review.collecting" writes ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-
-      ## Concerns
-
-      ### Multiply
-
-      - Export `multiply()`.
-
-      ## Acceptance Criteria
-
-      - AC-1: the change behaves as described.
-      """
-    And step "build.review.collecting" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#2-2
-        new subtract function[^why]
-
-      [^why]:
-          - H: also export multiply
-          - A: noted in the requirements.
-      """
-    When gtd lands
-    And the process is driven
-    Then the process rests at "build.review.await-review"
-    Given a file ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#2-2
-        new subtract function
-      """
-    And step "build.review.closing" runs its script
-    And step "re-unwind" runs its script
-    And step "implement.building" is no longer scripted
-    When gtd lands
-    And the process is driven
-    Then the process rests at "implement.building"
-    And the resting step's content contains "Add no release flag — this project ships without release flags"
-    And the resting step's content does not contain "release flag the earlier lap added"
-    And no commit body contains "Gtd-Kept:"

package/src/workflows/feature/naive-acceptance.feature

@@ -0,0 +1,140 @@
+@inmem
+Feature: a naive pass ends only when a test names every criterion and the suite is green
+
+  `seam.naive` writes behaviour-level acceptance tests, each naming its
+  criterion's ID. A pass whose tests leave an ID out or import a file the
+  pass added is sent back; `seam.check` then runs the suite with the kept
+  pass applied, and a red run sends it back too, before the judge sees it.
+  Three failed attempts rest at `seam.steer`.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    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
+
+      ## Acceptance Criteria
+
+      - AC-1: `subtract(5, 3)` returns 2.
+      - AC-2: `add` still adds.
+      """
+    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
+      """
+
+  Scenario: a pass whose tests leave a criterion's ID out is sent back, and an overrule runs the check and sticks
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      import { add, subtract } from "../src/calc.js"
+      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the resting step's content contains "acceptance-tests: no test of the naive pass names AC-2"
+
+    Given step "seam.check" changes nothing
+    When gtd lands
+    And the process is driven
+    Then the process rests at "seam.judge"
+    And the commit subjects end with:
+      """
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive
+      gtd(agent): seam.naive
+      gtd(agent): seam.naive → seam.steer
+      gtd(human): seam.steer → seam.check
+      gtd(check): seam.check → seam.judge
+      """
+
+    Given 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 "rejected the last attempt"
+    And the commit subjects end with:
+      """
+      gtd(check): seam.check → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
+      gtd(judge): seam.judge → seam.steer
+      """
+
+  Scenario: a test importing a file the pass added is sent back
+    Given step "seam.naive" writes "src/subtract.ts" with:
+      """
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And step "seam.naive" writes "src/subtract.test.ts" with:
+      """
+      import { subtract } from "./subtract.js"
+      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("[AC-2] still adds", () => {})
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the resting step's content contains "src/subtract.test.ts → src/subtract.ts"
+
+  Scenario: a red suite sends the pass back, and it moves on only once green
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      import { add, subtract } from "../src/calc.js"
+      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("[AC-2] still adds", () => expect(add(1, 1)).toBe(2))
+      """
+    When the process is driven
+    Then the process rests at "seam.check"
+    And the resting step's content contains "git checkout -q HEAD --"
+    And the resting step's content does not contain "'^'"
+    And the resting step's content contains "npm test"
+
+    Given step "seam.naive" is no longer scripted
+    And step "seam.check" writes ".gtd/FEEDBACK.md" with:
+      """
+      FAIL tests/calc.test.ts > [AC-1] subtracts
+      """
+    When the process is driven
+    Then the process rests at "seam.naive"
+    And the resting step's content contains "left the suite red"
+    And ".gtd/FEEDBACK.md" contains "[AC-1] subtracts"
+
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      import { add, subtract } from "../src/calc.js"
+      it("[AC-1] subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("[AC-2] still adds", () => expect(add(2, 2)).toBe(4))
+      """
+    And step "seam.check" from now on changes nothing
+    When the process is driven
+    Then the process rests at "implement.building"
+    And the commit subjects end with:
+      """
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → implement.building
+      """

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

@@ -4,8 +4,8 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
 
   With GTD_FLAG_RISK_TIER off, a naive pass that
   edits an existing source file is judged land: the process skips the approval
-  gate and any refactor, and runs implement, quality and
-  review back to idle. The flag is pinned here so the per-flag test runs never
+  gate and any refactor, and runs implement and quality
+  back to idle, with no review. The flag is pinned here so the per-flag test runs never
   move it off this path.
 
   Background:
@@ -40,6 +40,11 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       - AC-1: the change behaves as described.
       """
     And step "design.gate.answer" changes nothing
+    And step "seam.check" changes nothing
+    And step "seam.naive" writes "src/acceptance.test.ts" with:
+      """
+      it("[AC-1] holds", () => {})
+      """
     And step "seam.naive" writes "src/greeting.ts" with:
       """
       export const greeting = "Hello, world"
@@ -55,35 +60,9 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
     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 or refactor
     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:
@@ -93,18 +72,16 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       gtd(check): start-gate.check → design.triage
       gtd(agent): design.triage → design.gate.answer
       gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive → seam.judge
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
       gtd(judge): seam.judge → implement.building
       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
+      gtd(agent): build.quality.correctness.reviewing → idle
       """
     And the commit "gtd(human): idle → unwind" has a body containing "Gtd-Var: flag_risk_tier=0"
-    And the commit "gtd(agent): seam.naive → seam.judge" has a body containing "Gtd-Kept:"
+    And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"
     And the commit "gtd(judge): seam.judge → implement.building" has a body containing "\"answer\":\"land\""
     And no commit body contains "Gtd-Approved:"
     And the output lines of gtd "slices" start with:

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

@@ -0,0 +1,96 @@
+@inmem
+Feature: quality findings left unresolved hold a feature process short of idle
+
+  The quality lap is the last look `feature` takes. When the fix cap leaves
+  `.gtd/QUALITY.md` behind, the process rests for a person instead of ending
+  with findings nobody acted on.
+
+  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 "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
+      """
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+
+  Scenario: findings the fix cap left unresolved rest at build.quality-unresolved
+    Given step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      - subtract has no test
+      """
+    And step "build.fix.quality.fixing" from now on changes nothing
+    And step "build.health.describe" writes ".gtd/ESCALATION.md" with:
+      """
+      # Escalation
+
+      The fix turn changed nothing.
+      """
+    When the process is driven
+    Then the process rests at "build.health.stop"
+    Given step "build.fix" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      // checked
+      """
+    And step "build.health.check" changes nothing
+    When gtd lands
+    And the process is driven
+    Then the process rests at "build.quality-unresolved"
+    And ".gtd/QUALITY.md" contains "subtract has no test"
+
+    When gtd lands
+    And the process is driven
+    Then the process rests at "build.quality-unresolved"
+
+    Given a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      // checked by hand
+      """
+    And the file ".gtd/QUALITY.md" is deleted
+    And step "build.health.check" changes nothing
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And the commit subjects end with:
+      """
+      gtd(check): build.health.check → build.quality-unresolved
+      gtd(human): build.quality-unresolved → build.health.check
+      gtd(check): build.health.check → idle
+      """