@pmelab/gtd 35.0.0 → 37.0.0

package/src/workflows/feature/feature.ts

@@ -17,14 +17,15 @@ import * as t from "../shared/text.js"
 import { skipDesign, statedCriteria, type StatedCriteria } from "./criteria.js"
 import { design } from "./planning.js"
 import { buildTail, isCode, reUnwind, type ReviewOutcome } from "./review.js"
-import { implement, seamBuild, type SeamOutcome } from "./seam.js"
+import { implement, seamBuild } from "./seam.js"
 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,
-// and the episode ends back at `idle`. Human review is the `review` door's.
+// green-baseline gate → design → 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, 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,21 +37,24 @@ export const unwind = (): Promise<void> => {
 
 export { reUnwind }
 
-/** A judged naive pass (none with `flagMode` off), then implement and the quality lap; design must have run since `firstBase`. */
+/** A naive pass (judged only with `flagMode` on), 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()
-    ? await seamBuild(firstBase)
-    : { base: firstBase }
+  const seam = await seamBuild(firstBase)
   await slice("feature", async () => {
     await implement({
       reference: seam.reference,
       tier,
       afterRefactor: seam.refactored,
+      naive: seam.land === true ? seam.reference : undefined,
+      rebuild: seam.rebuild,
     })
-    // An empty feature slice: the refactor carried the feature, so the lap covers the whole change.
+    // A feature slice with no code beyond the carried-over tests: the refactor carried the
+    // feature, so the lap covers the whole change.
+    const carried = seam.rebuild?.acceptance?.tests ?? []
     const base =
-      seam.refactored === true && !changesSince(seam.base).some((c) => isCode(c.path))
+      seam.refactored === true &&
+      !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
         ? firstBase
         : seam.base
     await tail(settleQuality, { green: true, lensBase: base })

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

@@ -1,9 +1,9 @@
 @inmem
-Feature: flag mode off builds a feature with no release flag, seam judge or refactor
+Feature: flag mode off lands the naive pass with no release flag, seam judge or refactor
 
   `flagMode` is a factory option of the shipped workflows, on by default. Off,
   the project ships without feature flags: no seam judge and no refactor run,
-  and the naive implementation goes straight through the health loop and the
+  and the naive pass itself lands, straight through the health loop and the
   quality lap.
 
   Background:
@@ -43,17 +43,22 @@ Feature: flag mode off builds a feature with no release flag, seam judge or refa
       """
     And step "design.gate.answer" changes nothing
 
-  Scenario: flag mode off skips the seam judge and the refactor, and asks for no flag
+  Scenario: flag mode off lands the naive pass unjudged, and asks for no flag
     When the process is driven
-    Then the process rests at "implement.building"
+    Then the process rests at "seam.naive"
     And the resting step's content contains "the quickest way that works"
-    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 "new release flag"
-    Given step "implement.building" writes "src/calc.ts" with:
+    And the resting step's content does not contain "release flag"
+    Given 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:
@@ -64,6 +69,7 @@ Feature: flag mode off builds a feature with no release flag, seam judge or refa
     When the process is driven
     Then the process rests at "idle"
     And "src/calc.ts" contains "subtract"
+    And "src/calc.test.ts" contains "[AC-1] subtracts"
     And the commit subjects end with:
       """
       chore: initial commit
@@ -72,8 +78,10 @@ Feature: flag mode off builds a feature with no release flag, seam judge or refa
       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 → implement.building
-      gtd(agent): implement.building → implement.health.check
+      gtd(human): design.gate.answer → 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

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

@@ -37,11 +37,17 @@ Feature: each quality lens runs on its own model hint
       - AC-1: `subtract(a, b)` returns `a - b`.
       """
     And step "design.gate.answer" changes nothing
-    And step "implement.building" writes "src/calc.ts" with:
+    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:

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

@@ -129,12 +129,12 @@ Feature: a naive pass ends only when a test names every criterion and the suite
       """
     And step "seam.check" from now on changes nothing
     When the process is driven
-    Then the process rests at "implement.building"
+    Then the process rests at "implement.applying"
     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
+      gtd(check): seam.check → implement.applying
       """

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

@@ -1,11 +1,11 @@
 # 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
+Feature: a naive pass the judge rules land is itself the implementation
 
   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 and quality
-  back to idle, with no review. The flag is pinned here so the per-flag test runs never
+  gate and any refactor, applies the kept pass as it is — no build turn — and
+  runs the health loop 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:
@@ -53,10 +53,7 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       """
       [{"id":"shape","answer":"land","p":0.9}]
       """
-    And step "implement.building" writes "src/greeting.ts" with:
-      """
-      export const greeting = "Hello, world!"
-      """
+    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:
@@ -65,10 +62,11 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       """
     And step "build.quality.correctness.reviewing" changes nothing
 
-  Scenario: a land judgment runs idle to idle with no seam gate or refactor
+  Scenario: a land judgment applies the naive pass and runs idle to idle with no rebuild
     When the process is driven
     Then the process rests at "idle"
-    And "src/greeting.ts" contains "Hello, world!"
+    And "src/greeting.ts" contains "Hello, world"
+    And "src/acceptance.test.ts" contains "[AC-1] holds"
     And the commit subjects end with:
       """
       gtd(human): idle → unwind
@@ -78,8 +76,8 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       gtd(human): design.gate.answer → seam.naive
       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(judge): seam.judge → 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
@@ -87,7 +85,7 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       """
     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:"
-    And the commit "gtd(judge): seam.judge → implement.building" has a body containing "\"answer\":\"land\""
+    And the commit "gtd(judge): seam.judge → implement.applying" 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

@@ -37,11 +37,17 @@ Feature: quality findings left unresolved hold a feature process short of idle
       - AC-1: subtract(a, b) returns a - b.
       """
     And step "design.gate.answer" changes nothing
-    And step "implement.building" writes "src/calc.ts" with:
+    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:

package/src/workflows/feature/refactor-absorbs.feature

@@ -4,9 +4,9 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
 
   With GTD_FLAG_RISK_TIER off, a refactor-first
   refactor can land everything the requirements ask for. The feature slice's
-  implement turn then has nothing to author: its empty turn completes the
-  step, and with no code changed since the refactor the feature slice's
-  quality lap covers the whole change, refactor included.
+  implement turn then has only the naive pass's acceptance tests to carry
+  over, and with no code but tests changed since the refactor the feature
+  slice's quality lap covers the whole change, refactor included.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
@@ -42,7 +42,7 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
       """
     And step "design.gate.answer" changes nothing
 
-  Scenario: an empty implement turn after a refactor that did it all reaches the quality lap and idle
+  Scenario: a tests-only implement turn after a refactor that did it all reaches the quality lap and idle
     Given step "seam.check" changes nothing
     And step "seam.naive" writes "src/acceptance.test.ts" with:
       """
@@ -57,6 +57,10 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
       """
       [{"id":"shape","answer":"refactor-first","p":0.9}]
       """
+    And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: the existing code the strays touch.
+      """
     And step "refactor.deriving" runs its script
     And step "refactor.building" writes "src/calc.ts" with:
       """
@@ -91,7 +95,10 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
       - [x] ./src/calc.ts#1-2
         subtract next to add
       """
-    And step "implement.building" changes nothing
+    And step "implement.building" writes "src/acceptance.test.ts" with:
+      """
+      it("[AC-1] holds", () => {})
+      """
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
     And judge step "implement.coverage" answers:

package/src/workflows/feature/refactor-first.feature

@@ -56,6 +56,10 @@ Feature: a refactor-first judgment walks one fixed path to idle
       """
       [{"id":"shape","answer":"refactor-first","p":0.9}]
       """
+    And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: the existing code the strays touch.
+      """
     And step "refactor.deriving" runs its script
     When the process is driven
     Then the process rests at "refactor.building"
@@ -106,6 +110,10 @@ Feature: a refactor-first judgment walks one fixed path to idle
       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.building" writes "src/acceptance.test.ts" with:
+      """
+      it("[AC-1] holds", () => {})
+      """
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
     And judge step "implement.coverage" answers:
@@ -125,7 +133,8 @@ Feature: a refactor-first judgment walks one fixed path to idle
       gtd(human): design.gate.answer → seam.naive
       gtd(agent): seam.naive → seam.check
       gtd(check): seam.check → seam.judge
-      gtd(judge): seam.judge → refactor.deriving
+      gtd(judge): seam.judge → seam.note
+      gtd(agent): seam.note → refactor.deriving
       gtd(check): refactor.deriving → refactor.building
       gtd(agent): refactor.building → refactor.health.check
       gtd(check): refactor.health.check → refactor.closing
@@ -140,7 +149,7 @@ Feature: a refactor-first judgment walks one fixed path to 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.check" has a body containing "Gtd-Kept:"
-    And the commit "gtd(judge): seam.judge → refactor.deriving" has a body containing "\"answer\":\"refactor-first\""
+    And the commit "gtd(judge): seam.judge → seam.note" has a body containing "\"answer\":\"refactor-first\""
     And no commit body contains "Gtd-Approved:"
     And the output lines of gtd "slices" start with:
       """

package/src/workflows/feature/refactor-lens-models.feature

@@ -50,6 +50,10 @@ Feature: the refactor review's lenses take their model hints from refactorQualit
       """
       [{"id":"shape","answer":"refactor-first","p":0.9}]
       """
+    And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: the existing code the strays touch.
+      """
     And step "refactor.deriving" runs its script
     And step "refactor.building" writes "src/calc.ts" with:
       """

package/src/workflows/feature/refactor-rebuild.feature

@@ -0,0 +1,269 @@
+# One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
+@inmem
+Feature: refactor-first writes a refactor note, refactors on its own, then rebuilds
+
+  On a refactor-first judgment the naive pass is never applied. `seam.note`
+  reads the whole naive diff and writes `.gtd/REFACTOR-NOTE.md`; the refactor
+  lands on its own with the existing suite green; the rebuild re-implements the
+  change on the refactored base and lands only once it carries the naive pass's
+  acceptance tests and the suite is green. The note reaches both turns.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And an environment variable "GTD_REFACTORQUALITYREVIEWS" 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
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`.
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract returns the difference.
+      """
+    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] 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 judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"refactor-first","p":0.9}]
+      """
+
+  Scenario: the refactor note reaches the refactor turn and the rebuild turn
+    When the process is driven
+    Then the process rests at "seam.note"
+    And the resting step's content contains "git show"
+    And the resting step's content contains ".gtd/REFACTOR-NOTE.md"
+    And "src/calc.ts" does not contain "subtract"
+
+    Given step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      # Refactor note
+
+      Seam: route add through a shared `op(a, b, sign)` in src/calc.ts.
+      """
+    And step "refactor.deriving" runs its script
+    When the process is driven
+    Then the process rests at "refactor.building"
+    And ".gtd/REFACTOR.md" contains "## Refactor note"
+    And ".gtd/REFACTOR.md" contains "shared `op(a, b, sign)`"
+    And the resting step's content contains "Refactor note"
+
+    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
+    And step "refactor.build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-2
+        add built on the shared op
+      """
+    And step "refactor.build.review.closing" runs its script
+    When the process is driven
+    Then the process rests at "refactor.build.review.await-review"
+
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [x] ./src/calc.ts#1-2
+        add built on the shared op
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "implement.building"
+    And the resting step's content contains "shared `op(a, b, sign)`"
+    And the resting step's content contains "acceptance tests for AC-1"
+
+  Scenario: a note turn that changes anything but the note is refused
+    Given step "seam.note" writes "src/calc.ts" with:
+      """
+      export const sub = 1
+      """
+    Then driving the process is refused with "refactor-note"
+
+  Scenario: the refactor lands on its own only with the existing suite green
+    Given step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: a shared `op` in src/calc.ts.
+      """
+    And step "refactor.deriving" runs its script
+    And 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" writes ".gtd/FEEDBACK.md" with:
+      """
+      FAIL add(1, 2) returned -1
+      """
+    When the process is driven
+    Then the process rests at "refactor.fix.suite.fixing"
+
+    Given step "refactor.fix.suite.fixing" 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
+    And step "refactor.build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-2
+        add built on the shared op
+      """
+    And step "refactor.build.review.closing" runs its script
+    When the process is driven
+    Then the process rests at "refactor.build.review.await-review"
+
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [x] ./src/calc.ts#1-2
+        add built on the shared op
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "implement.building"
+    And "src/calc.ts" contains "op(a, b, 1)"
+    And "src/calc.ts" does not contain "subtract"
+    And the output of gtd "slices" contains "refactor "
+
+  Scenario: the rebuild lands only once it carries the naive pass's acceptance tests, green
+    Given step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: a shared `op` in src/calc.ts.
+      """
+    And step "refactor.deriving" runs its script
+    And 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
+    And step "refactor.build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-2
+        add built on the shared op
+      """
+    And step "refactor.build.review.closing" runs its script
+    When the process is driven
+    Then the process rests at "refactor.build.review.await-review"
+
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [x] ./src/calc.ts#1-2
+        add built on the shared op
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "implement.building"
+
+    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)
+      """
+    Then driving the process is refused with "rebuild-acceptance"
+
+    Given step "implement.building" writes "src/acceptance.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    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}]
+      """
+    When the process is driven
+    Then the process rests at "idle"
+    And "src/calc.ts" contains "op(a, b, -1)"
+    And "src/acceptance.test.ts" contains "[AC-1]"
+    And ".gtd/REFACTOR-NOTE.md" does not exist
+    And the commit subjects end with:
+      """
+      gtd(judge): seam.judge → seam.note
+      gtd(agent): seam.note → 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 → refactor.build.review.reviewing
+      gtd(agent): refactor.build.review.reviewing → refactor.build.review.await-review
+      gtd(human): refactor.build.review.await-review → refactor.build.review.closing
+      gtd(check): refactor.build.review.closing → 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 → idle
+      """
+    And the output lines of gtd "slices" start with:
+      """
+      refactor
+      feature
+      """