@pmelab/gtd 39.0.0 → 41.0.0

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

@@ -0,0 +1,271 @@
+@inmem
+Feature: a feature process ends at the human review
+
+  After the last slice's quality lap the process rests at the review gate,
+  `.gtd/REVIEW.md`. A sign-off ends the process. A note asking for a change in
+  behaviour starts a feedback lap — design, then implement with no new naive
+  pass or seam judge, the coverage judge over every criterion, the quality lap
+  — and the review again. Its design keeps a built criterion's ID and numbers
+  new behaviour above every ID handed out.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    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.review.reviewing" writes ".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
+
+  Scenario: a feature process ends at the review gate
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REQUIREMENTS.md" does not exist
+    And the resting step's content contains the hash of the commit "feat: add calculator"
+    And the commit subjects end with:
+      """
+      gtd(judge): implement.coverage → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.await-review
+      """
+
+  Scenario: a sign-off ends the process at idle
+    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#2-2
+        new subtract function
+      """
+    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(agent): build.review.reviewing → build.review.await-review
+      gtd(human): build.review.await-review → build.review.closing
+      gtd(check): build.review.closing → idle
+      """
+
+  Rule: a note asking for new behaviour runs the feedback lap
+
+    Background:
+      Given step "build.review.collecting" writes ".gtd/REQUIREMENTS.md" with:
+        """
+        # Requirements
+
+        ## Concerns
+
+        ### Multiply
+
+        - Export `multiply()`.
+        """
+      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.
+        """
+      And step "re-unwind" 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
+
+        - [ ] ./src/calc.ts#2-2
+          new subtract function[^why]
+
+        [^why]:
+            - H: also export multiply
+        """
+      When gtd lands
+      And the process is driven
+      Then the process rests at "build.review.await-review"
+      And ".gtd/REQUIREMENTS.md" contains "multiply"
+      Given a file ".gtd/REVIEW.md" with:
+        """
+        # Review: abc1234
+
+        <!-- base: 0000000 -->
+
+        ## calc
+
+        - [ ] ./src/calc.ts#2-2
+          new subtract function
+        """
+
+    Scenario: the lap keeps AC-1, adds AC-2, and covers both before the next review
+      Given step "design.triage" from now on changes nothing
+      And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+        """
+        # Requirements
+
+        ## Concerns
+
+        ### Multiply
+
+        - `multiply(a, b)` returns `a * b`.
+
+        ## Acceptance Criteria
+
+        - AC-1: subtract(a, b) returns a - b.
+        - AC-2: multiply(a, b) returns a * b.
+        """
+      And step "implement.building" writes "src/calc.ts" with:
+        """
+        export const add = (a: number, b: number) => a + b
+        export const subtract = (a: number, b: number) => a - b
+        export const multiply = (a: number, b: number) => a * b
+        """
+      And step "implement.building" writes "src/multiply.test.ts" with:
+        """
+        it("[AC-2] multiplies", () => {})
+        """
+      And judge step "implement.coverage" answers:
+        """
+        [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
+        """
+      When gtd lands
+      And the process is driven
+      Then the process rests at "build.review.await-review"
+      And ".gtd/REQUIREMENTS.md" does not exist
+      And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
+      And the commit subjects end with:
+        """
+        gtd(human): build.review.await-review → build.review.closing
+        gtd(check): build.review.closing → re-unwind
+        gtd(check): re-unwind → design.triage
+        gtd(agent): design.triage → design.gate.answer
+        gtd(human): design.gate.answer → implement.building
+        gtd(agent): implement.building → implement.health.check
+        gtd(check): implement.health.check → implement.coverage
+        gtd(judge): implement.coverage → implement.closing
+        gtd(check): implement.closing → build.review.reviewing
+        gtd(agent): build.review.reviewing → build.review.await-review
+        """
+
+    Scenario: a design numbering new behaviour at or below an earlier ID is refused
+      Given step "design.triage" from now on changes nothing
+      And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+        """
+        # Requirements
+
+        ## Concerns
+
+        ### Multiply
+
+        - `multiply(a, b)` returns `a * b`.
+
+        ## Acceptance Criteria
+
+        - AC-0: multiply(a, b) returns a * b.
+        - AC-1: subtract(a, b) returns a - b.
+        """
+      When gtd lands
+      Then driving the process is refused with "criteria-ids"
+
+    Scenario: the lap holds a new criterion to coverage
+      Given step "design.triage" from now on changes nothing
+      And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+        """
+        # Requirements
+
+        ## Concerns
+
+        ### Multiply
+
+        - `multiply(a, b)` returns `a * b`.
+
+        ## Acceptance Criteria
+
+        - AC-1: subtract(a, b) returns a - b.
+        - AC-2: multiply(a, b) returns a * b.
+        """
+      And step "implement.building" writes "src/calc.ts" with:
+        """
+        export const add = (a: number, b: number) => a + b
+        export const subtract = (a: number, b: number) => a - b
+        export const multiply = (a: number, b: number) => a * b
+        """
+      And judge step "implement.coverage" answers:
+        """
+        [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
+        """
+      When gtd lands
+      And the process is driven
+      Then the process rests at "implement.covering"
+      And the resting step's content contains "AC-2"

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

@@ -1,6 +1,6 @@
 # One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
 @inmem
-Feature: rejected naive passes walk one fixed path through the steer gate to idle
+Feature: rejected naive passes walk one fixed path through the steer gate to the review gate
 
   With GTD_FLAG_RISK_TIER off, three rejected naive
   passes rest at the steer gate, where a human edit restarts the seam and the
@@ -40,7 +40,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       """
     And step "design.gate.answer" changes nothing
 
-  Scenario: three rejects rest at the steer gate, a steered rerun lands and runs to idle
+  Scenario: three rejects rest at the steer gate, a steered rerun lands and runs to the review gate
     Given step "seam.check" changes nothing
     And step "seam.naive" writes "src/acceptance.test.ts" with:
       """
@@ -100,7 +100,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
     And step "implement.applying" runs its script
     When gtd lands
     And the process is driven
-    Then the process rests at "idle"
+    Then the process rests at "build.review.reviewing"
     And the commit subjects end with:
       """
       gtd(human): idle → unwind
@@ -124,7 +124,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
-      gtd(check): implement.closing → idle
+      gtd(check): implement.closing → build.review.reviewing
       """
     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:"

package/src/workflows/feature/seam.feature

@@ -152,7 +152,7 @@ Feature: the naive pass and seam judge decide how a feature is built
       [{"id":"AC-1","answer":"yes","p":0.9}]
       """
     When the process is driven
-    Then the process rests at "idle"
+    Then the process rests at "build.review.reviewing"
     And "src/calc.ts" contains "subtract"
     And the commit subjects end with:
       """
@@ -160,7 +160,7 @@ Feature: the naive pass and seam judge decide how a feature is built
       gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
-      gtd(check): implement.closing → idle
+      gtd(check): implement.closing → build.review.reviewing
       """
     And ".gtd/REQUIREMENTS.md" does not exist
 

package/src/workflows/feature/seam.ts

@@ -283,7 +283,7 @@ export interface ImplementOptions {
   /** Where the slice began: the coverage judge reads only the tests changed since. */
   readonly base?: string | undefined
   /** Not the last slice: `.gtd/REQUIREMENTS.md` and `.gtd/SLICES.md` stay for the next one. */
-  readonly more?: boolean | undefined
+  readonly more?: boolean | (() => boolean) | undefined
 }
 
 /** Resolves `false` when the tip no longer applies (the failure is in `.gtd/FEEDBACK.md`) or has nothing outside `.gtd/` to apply. */
@@ -351,14 +351,19 @@ export function implement(
   tier?: RiskTier,
   amend?: boolean,
 ): Promise<void>
-export function implement(
+export async function implement(
   first?: string | ImplementOptions,
   tier?: RiskTier,
   amend?: boolean,
 ): Promise<void> {
-  const options: ImplementOptions =
-    typeof first === "object" && first !== null ? first : { reference: first, tier, amend }
-  return scope("implement", async () => {
+  await implementing(
+    typeof first === "object" && first !== null ? first : { reference: first, tier, amend },
+  )
+}
+
+/** `implement`, resolving with the criterion IDs the requirements listed when it closed. */
+export const implementing = (options: ImplementOptions): Promise<readonly string[]> =>
+  scope("implement", async () => {
     const since = head()
     const acceptance = options.rebuild?.acceptance
     const built = options.naive === undefined || !(await applied(options.naive))
@@ -372,9 +377,14 @@ export function implement(
       built && acceptance !== undefined ? () => requireAcceptanceKept(acceptance) : undefined,
     )
     await requireCoverage(options.base, options.slice)
-    await closing(options.more === true)
+    const ids = criterionIds(read(REQUIREMENTS) ?? "")
+    await closing(moreToBuild(options.more))
+    return ids
   })
-}
+
+// Read at closing: a narrowing at `implement.oversized` may have emptied every later slice.
+const moreToBuild = (more: ImplementOptions["more"]): boolean =>
+  typeof more === "function" ? more() : more === true
 
 /** The last slice's closing, for a last slice a steer left with no criterion to build. */
 export const closeOut = (): Promise<void> => scope("implement", () => closing(false))

package/src/workflows/feature/slicing.feature

@@ -51,7 +51,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       [{"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 "idle"
+    Then the process rests at "build.review.reviewing"
     And the commit subjects end with:
       """
       gtd(human): design.gate.answer → seam.naive
@@ -60,7 +60,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
-      gtd(check): implement.closing → idle
+      gtd(check): implement.closing → build.review.reviewing
       """
     And the output lines of gtd "slices" start with:
       """
@@ -112,7 +112,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       [{"id":"AC-2","answer":"yes","p":0.9}]
       """
     When the process is driven
-    Then the process rests at "idle"
+    Then the process rests at "build.review.reviewing"
     And the commit subjects end with:
       """
       gtd(agent): design.triage → design.gate.answer
@@ -129,7 +129,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
-      gtd(check): implement.closing → idle
+      gtd(check): implement.closing → build.review.reviewing
       """
     And the output lines of gtd "slices" start with:
       """
@@ -223,3 +223,62 @@ Feature: a change with more criteria than the cap is built in coarse slices
       - AC-2
       """
     Then driving the process is refused with "wrote outside its write access"
+
+  Scenario: a steer that empties the last slice still ends at the review of the whole change
+    Given 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.
+      - AC-3: divide(a, b) returns a / b.
+      """
+    And step "design.slicing" writes ".gtd/SLICES.md" with:
+      """
+      # Slices
+
+      ## Subtract and divide
+
+      - AC-1
+      - AC-3
+
+      ## Multiply
+
+      - AC-2
+      """
+    And step "seam.naive" writes "src/sub.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    Given a file ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "build.review.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(human): seam.steer → 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.review.reviewing
+      """
+    And ".gtd/REQUIREMENTS.md" does not exist
+    And ".gtd/SLICES.md" does not exist
+    And the output of gtd "slices" does not contain "feature-2"

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

@@ -116,3 +116,33 @@ describe("healthy describeGuard", () => {
     ).rejects.toThrow("guarded: nope")
   })
 })
+
+describe("healthy at the fix cap", () => {
+  // Blank reports are not comparable; at an 8-byte budget the cut trims both.
+  it.each([
+    ["could not compare", "", (n: number) => "\n".repeat(n)],
+    ["saw only cut", `, judgeBudgetBytes: "8"`, (n: number) => `a long failing report ${n}\n`],
+  ])("grants no extra turn on progress the judge %s", async (_, extra, report) => {
+    let runs = 0
+    const repo = testRepo({
+      workflow: [
+        `import { healthy } from "@pmelab/gtd/workflows"`,
+        `import { agent } from "@pmelab/gtd/flows"`,
+        `export const defaults = { judgeIdenticalMinP: "0.7"${extra} }`,
+        `export const held = async () => { await agent("first", "go"); await healthy(() => agent("fix", "go")) }`,
+        `export default held`,
+      ].join("\n"),
+      env: { GTD_TEST_COMMAND: "true" },
+    })
+    await repo.start("held")
+    const rest = await repo.drive({
+      first: (_, r) => r.write("start", "1\n"),
+      "health.check": (_, r) => r.write(".gtd/FEEDBACK.md", report(++runs)),
+      "health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
+      fix: (_, r) => r.write("f", `${runs}\n`),
+      "health.recheck": (_, r) => r.write(".gtd/FEEDBACK.md", "red again\n"),
+    })
+    expect(rest.state).toBe("health.describe")
+    expect(repo.subjects().filter((s) => s.startsWith("gtd(agent): fix")).length).toBe(3)
+  })
+})

package/src/workflows/shared/health.ts

@@ -105,7 +105,10 @@ export const retryQuestion = (comparable: boolean): JudgeQuestion =>
           "new-failure: a materially different failure than before. progress: still red, but closer to green — the default if genuinely unsure.",
       }
 
-const sameFailure = async (previous: string, current: string): Promise<boolean> => {
+const compare = async (
+  previous: string,
+  current: string,
+): Promise<kit.RetryVerdict | undefined> => {
   const comparable = current.trim() !== "" && previous.trim() !== ""
   const { answers, truncated } = await judge("health.judge", {
     questions: [retryQuestion(comparable)],
@@ -113,12 +116,11 @@ const sameFailure = async (previous: string, current: string): Promise<boolean>
     message: t.healthJudgeMessage(),
     label: "Judging the retry",
   })
-  // Evidence the budget cut can make two different reports look alike: never sameness.
-  return (
-    comparable &&
-    truncated.length === 0 &&
-    answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity))
-  )
+  // Evidence the budget cut can make two different reports look alike: neither sameness nor progress.
+  if (!comparable || truncated.length > 0) return undefined
+  const minP = numeric(vars.judgeIdenticalMinP, Infinity)
+  if (answered(answers.verdict, "identical", minP)) return "identical"
+  return answered(answers.verdict, "progress", minP) ? "progress" : undefined
 }
 
 export interface HealthOptions {
@@ -153,7 +155,8 @@ const runSuite = (options: HealthOptions): Promise<boolean> =>
 /**
  * Loop until the suite is green: check, and on red run `fix` — escalating
  * first once `FIX_CAP` fixes are spent, or a judge calls the failure
- * identical to the previous round's. An escalation re-runs the suite once
+ * identical to the previous round's. A judge calling it progress at the cap
+ * buys one extra fix per run of fixes. An escalation re-runs the suite once
  * first; a green re-run ends the loop.
  */
 export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}): Promise<void> =>
@@ -162,7 +165,7 @@ export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}):
     report: FEEDBACK,
     fixCap: FIX_CAP,
     fixesSoFar: options.fixesSoFar ?? 0,
-    sameFailure,
+    compare,
     escalations: options.escalations ?? { rounds: 0 },
     recheck: () =>
       recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),

package/src/workflows/shared/progress.feature

@@ -0,0 +1,124 @@
+@inmem
+Feature: a fix loop still making progress at the cap gets one extra turn
+
+  `healthy` escalates once three fix turns are spent. When `health.judge`
+  calls that round progress — still red, but closer to green — with at least
+  `judgeIdenticalMinP` confidence, one more fix runs first, once per run of
+  fixes. The round after it escalates without asking the judge. Any other
+  verdict escalates at the cap as before.
+
+  Background:
+    Given a gtd config with:
+      """
+      import { healthy } from "@pmelab/gtd/workflows"
+      import { agent } from "@pmelab/gtd/flows"
+
+      export const defaults = { judgeIdenticalMinP: "0.7" }
+      export const held = async () => {
+        await agent("first", "go")
+        await healthy(() => agent("fix", "go"))
+      }
+      export default held
+      """
+    And step "first" writes "src/a.ts" with:
+      """
+      export const a = 1
+      """
+    And step "health.check" writes ".gtd/FEEDBACK.md" with:
+      """
+      tests failing
+      """
+    And step "fix" deletes ".gtd/FEEDBACK.md"
+    And step "health.recheck" writes ".gtd/FEEDBACK.md" with:
+      """
+      tests still failing
+      """
+
+  Scenario: progress at the cap buys exactly one extra fix turn
+    Given judge step "health.judge" answers:
+      """
+      [{"id":"verdict","answer":"progress","p":0.9}]
+      """
+    When gtd starts workflow "held"
+    And the process is driven
+    Then the process rests at "health.describe"
+    And the commit subjects end with:
+      """
+      gtd(agent): first → health.check
+      gtd(check): health.check → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.recheck
+      gtd(check): health.recheck → health.describe
+      """
+
+  Scenario Outline: <verdict> at <p> escalates at the cap without an extra turn
+    Given judge step "health.judge" answers:
+      """
+      [{"id":"verdict","answer":"<verdict>","p":<p>}]
+      """
+    When gtd starts workflow "held"
+    And the process is driven
+    Then the process rests at "health.describe"
+    And the commit subjects end with:
+      """
+      gtd(agent): first → health.check
+      gtd(check): health.check → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → health.recheck
+      gtd(check): health.recheck → health.describe
+      """
+
+    Examples:
+      | verdict     | p   |
+      | new-failure | 0.9 |
+      | progress    | 0.5 |
+
+  Scenario: a person's escalation stop starts a new run of fixes with its own extra turn
+    Given judge step "health.judge" answers:
+      """
+      [{"id":"verdict","answer":"progress","p":0.9}]
+      """
+    And step "health.describe" writes ".gtd/ESCALATION.md" with:
+      """
+      try something else
+      """
+    And step "health.stop" writes "NOTES.md" with:
+      """
+      narrowed
+      """
+    When gtd starts workflow "held"
+    And the process is driven
+    Then the process rests at "health.exhausted"
+    And the commit subjects end with:
+      """
+      gtd(agent): health.describe → health.stop
+      gtd(human): health.stop → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.recheck
+      gtd(check): health.recheck → health.exhausted
+      """