@pmelab/gtd 51.0.1 → 52.0.0

package/src/workflows/feature/criteria.ts

@@ -15,6 +15,8 @@ import * as t from "../shared/text.js"
 export interface Criterion {
   readonly id: string
   readonly text: string
+  /** Tagged `(no hands-on)`: its tests prove it, so the hands-on test skips it. */
+  readonly noHandsOn?: true
 }
 
 /** Acceptance criteria the human's sketch stated outright, ready to normalise. */
@@ -29,7 +31,13 @@ export interface StatedCriteria {
 /** Below this the judge's `yes` is not trusted: a wrong skip builds against criteria nobody can check. */
 const CLEAR_MIN_P = 0.8
 
-const ID = /^(AC-\d+):\s*(.*)$/
+const ID = /^(AC-\d+)(\s*\(no hands-on\))?:\s*(.*)$/
+
+const criterion = (id: RegExpExecArray, as = id[1]!): Criterion => ({
+  id: as,
+  text: id[3]!,
+  ...(id[2] === undefined ? {} : { noHandsOn: true }),
+})
 
 /** The list items under the first heading `title` matches (at `level` when given), up to the next heading; wrapped lines joined, fenced lines ignored. */
 const listUnder = (text: string, title: RegExp, level?: number): string[] | undefined => {
@@ -66,7 +74,7 @@ const listUnder = (text: string, title: RegExp, level?: number): string[] | unde
 export const criteriaOf = (text: string): readonly Criterion[] | undefined =>
   listUnder(text, /^acceptance criteria$/i, 2)?.map((item) => {
     const id = ID.exec(item)
-    return id === null ? { id: "", text: item } : { id: id[1]!, text: id[2]! }
+    return id === null ? { id: "", text: item } : criterion(id)
   })
 
 /**
@@ -90,6 +98,12 @@ export const criterionIds = (text: string, slice?: CriteriaSlice): string[] =>
         !(slice?.except ?? []).includes(id),
     )
 
+/** The ID'd criteria of `text` (`slice`'s when given) a person can try by hand: none tagged `(no hands-on)`. */
+export const handsOnIds = (text: string, slice?: CriteriaSlice): string[] => {
+  const tagged = (criteriaOf(text) ?? []).filter((c) => c.noHandsOn).map((c) => c.id)
+  return criterionIds(text, slice).filter((id) => !tagged.includes(id))
+}
+
 /** `slice`'s IDs in `.gtd/REQUIREMENTS.md` as it is now; `undefined` for an unsliced change. */
 export const sliceIds = (slice: CriteriaSlice | undefined): string[] | undefined =>
   slice === undefined ? undefined : criterionIds(read(REQUIREMENTS) ?? "", slice)
@@ -98,11 +112,11 @@ export const sliceIds = (slice: CriteriaSlice | undefined): string[] | undefined
 const numbered = (items: readonly string[]): Criterion[] => {
   const ids = items.map((item) => ID.exec(item))
   const own = ids.every((id) => id !== null) && new Set(ids.map((id) => id![1])).size === ids.length
-  return items.map((item, i) =>
-    own
-      ? { id: ids[i]![1]!, text: ids[i]![2]! }
-      : { id: `AC-${i + 1}`, text: item.replace(ID, "$2") },
-  )
+  return items.map((item, i) => {
+    const id = ids[i]
+    if (own) return criterion(id!)
+    return id === null ? { id: `AC-${i + 1}`, text: item } : criterion(id!, `AC-${i + 1}`)
+  })
 }
 
 const STATED = /^acceptance criteria:?$/i

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

@@ -27,10 +27,6 @@ Feature: a trivial change takes the same few beats at either risk tier
     And step "design.gate.answer" changes nothing
     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.quality.correctness.reviewing" changes nothing
 
   Scenario Outline: a one-line fix runs from idle to the review gate with the same beats at either tier
@@ -78,8 +74,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       gtd(check): seam.check → seam.judge
       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.health.check → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
       gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """

package/src/workflows/feature/feature.ts

@@ -123,7 +123,6 @@ const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> =
       naive: seam.land === true ? seam.reference : undefined,
       rebuild: seam.rebuild,
       slice: build.criteria,
-      base: build.criteria === undefined ? undefined : sliceBase,
       more: build.more,
     })
     // Closing kept the criteria exactly when there is more to build, so this reads as it did.
@@ -179,7 +178,7 @@ const reviewedTail = (
   )
 
 // 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.
+// and unrefactored.
 const featureFeedback = async (
   first: ReviewOutcome,
   lensBase: string,

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

@@ -61,10 +61,6 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
     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.quality.correctness.reviewing" changes nothing
     When the process is driven
     Then the process rests at "build.review.reviewing"
@@ -82,8 +78,7 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       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.health.check → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
       gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """

package/src/workflows/feature/green.ts

@@ -0,0 +1,22 @@
+import { healthy } from "../shared/health.js"
+import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
+import * as t from "../shared/text.js"
+import { requireCriteriaFrozen } from "./criteria.js"
+
+export const green = (guard?: () => void): Promise<void> =>
+  healthy(
+    () =>
+      t.agentWithSkills("fix.suite.fixing", t.implementFixPrompt(), {
+        label: "Fixing the check",
+        file: FEEDBACK,
+        model: coder(),
+        system: t.builderSystem(),
+      }),
+    {
+      guard: () => {
+        requireCriteriaFrozen(REQUIREMENTS)
+        guard?.()
+      },
+      guardRests: false,
+    },
+  )

package/src/workflows/feature/hands-on-skip.feature

@@ -0,0 +1,344 @@
+@inmem
+Feature: the hands-on test tries only the criteria a person can observe
+
+  Design may tag a criterion no person can try by using the change — prompt
+  wording, internal wiring — by writing `(no hands-on)` between its ID and the
+  colon. At every hands-on test, implement.prototype.observable asks a judge,
+  per untagged criterion, whether a person can observe it by using the
+  software; a tagged one is never asked about. Every ID it does not answer
+  `no` reaches implement.prototype.testing, which must report each once and
+  needs no chunk for the rest. A slice with no such criterion is not tested by hand, and
+  nothing rests to say so.
+
+  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 an environment variable "GTD_SLICEMAXCRITERIA" set to "2"
+    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.gate.answer" changes nothing
+    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
+
+  Scenario: the testing turn skips a tagged criterion, which the judge is never asked about
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2 (no hands-on): the build prompt names subtract.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] names subtract", () => {})
+      """
+    And judge step "implement.prototype.observable", when its questions contain "criterion AC-2 describes", answers:
+      """
+      [{"id":"AC-1","answer":"no","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
+      """
+    And judge step "implement.prototype.observable", when its questions contain "criterion AC-1 describes", answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
+    And step "implement.prototype.testing" is prompted with "Skip AC-2: no person can observe them"
+    And step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: pass
+
+      Printed 2.
+      """
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(check): implement.health.check → implement.prototype.observable
+      gtd(judge): implement.prototype.observable → implement.prototype.testing
+      gtd(agent): implement.prototype.testing → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      """
+
+  Scenario: a criterion the judge finds no person can observe is skipped like a tagged one
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: add is unchanged.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] adds", () => {})
+      """
+    And judge step "implement.prototype.observable" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
+      """
+    And step "implement.prototype.testing" is prompted with "Skip AC-2: no person can observe them"
+    And step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: pass
+
+      Printed 2.
+      """
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(judge): implement.prototype.observable → implement.prototype.testing
+      gtd(agent): implement.prototype.testing → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      """
+
+  Scenario: a criterion the judge gives no verdict on is tested by hand
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: add is unchanged.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] adds", () => {})
+      """
+    And judge step "implement.prototype.observable" answers:
+      """
+      [{"id":"AC-2","answer":"no","p":0.9}]
+      """
+    And step "implement.prototype.testing" is prompted with "Skip AC-2: no person can observe them"
+    And step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: pass
+
+      Printed 2.
+      """
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(judge): implement.prototype.observable → implement.prototype.testing
+      gtd(agent): implement.prototype.testing → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      """
+
+  Scenario: a judge landing without a verdict tests every untagged criterion by hand
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: add is unchanged.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] adds", () => {})
+      """
+    And judge step "implement.prototype.observable" answers:
+      """
+      []
+      """
+    And step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: pass
+
+      Printed 2.
+      """
+    Then driving the process is refused with "exactly one chunk headed `## <ID>: pass|fail|blocked` for AC-2"
+
+  Scenario: a report missing a criterion the judge found observable is refused
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: subtract prints a warning for negative results.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] warns", () => {})
+      """
+    And judge step "implement.prototype.observable" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
+      """
+    And step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: pass
+
+      Printed 2.
+      """
+    Then driving the process is refused with "exactly one chunk headed `## <ID>: pass|fail|blocked` for AC-2"
+
+  Scenario: a change with no observable criterion skips the hands-on test without resting
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: add is unchanged.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] adds", () => {})
+      """
+    And judge step "implement.prototype.observable" answers:
+      """
+      [{"id":"AC-1","answer":"no","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(check): implement.health.check → implement.prototype.observable
+      gtd(judge): implement.prototype.observable → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      """
+
+  Scenario: a change whose every criterion is tagged is not tested by hand or judged
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1 (no hands-on): the build prompt names subtract.
+      - AC-2 (no hands-on): the review prompt names subtract.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] names subtract in the build", () => {})
+      it("[AC-2] names subtract in the review", () => {})
+      """
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(check): implement.health.check → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      """
+
+  Scenario: each slice's hands-on test judges its own criteria afresh
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2 (no hands-on): the build prompt names subtract.
+      - AC-3: the review prompt names subtract.
+      """
+    And step "design.slicing" writes ".gtd/SLICES.md" with:
+      """
+      # Slices
+
+      ## Prompts
+
+      - AC-2
+      - AC-3
+
+      ## Subtract
+
+      - AC-1
+      """
+    And step "seam.naive", when prompted with "This slice builds AC-2, AC-3 only", writes "src/prompts.test.ts" with:
+      """
+      it("[AC-2] names subtract in the build", () => {})
+      it("[AC-3] names subtract in the review", () => {})
+      """
+    And step "seam.naive", when prompted with "This slice builds AC-1 only", writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And judge step "implement.prototype.observable", when its questions contain "criterion AC-3 describes", answers:
+      """
+      [{"id":"AC-3","answer":"no","p":0.9}]
+      """
+    And judge step "implement.prototype.observable", when its questions contain "criterion AC-1 describes", answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
+    And step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: pass
+
+      Printed 2.
+      """
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(check): implement.health.check → implement.prototype.observable
+      gtd(judge): implement.prototype.observable → implement.closing
+      gtd(check): implement.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.prototype.observable
+      gtd(judge): implement.prototype.observable → implement.prototype.testing
+      gtd(agent): implement.prototype.testing → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      """
+
+  Scenario: the tag is frozen once design is settled
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And judge step "implement.prototype.observable" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
+    And step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: fail
+
+      Printed 4.
+      """
+    And step "implement.prototype.fix.fixing" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1 (no hands-on): subtract(a, b) returns a - b.
+      """
+    Then driving the process is refused with "criteria-frozen"

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

@@ -51,10 +51,6 @@ Feature: each quality lens runs on its own model hint
     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}]
-      """
 
   Scenario: a hinted lens runs on its hint, every other lens on its default
     When the process is driven

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

@@ -53,10 +53,6 @@ Feature: the quality lap's findings are triaged before the review
     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.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
       """
       # Quality
@@ -113,7 +109,9 @@ Feature: the quality lap's findings are triaged before the review
     And the commit "gtd(judge): build.quality.triage → build.quality.sorting" has a body containing "Gtd-Mark: noise=Q2 p=0.85 add could be a method"
     And ".gtd/REVIEW.md" contains:
       """
-      ## AC-1 ignores floating point
+      ## Findings
+
+      ### AC-1 ignores floating point
 
       _critical: judge unsure_
 
@@ -129,9 +127,9 @@ Feature: the quality lap's findings are triaged before the review
       - [ ] won't fix
       - [ ] _your answer_
 
-      ## Fixed automatically
+      ## Walkthrough
 
-      - subtract has no negative test (
+      ### Subtract
       """
     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:
@@ -235,7 +233,7 @@ Feature: the quality lap's findings are triaged before the review
     And ".gtd/QUALITY.md" does not exist
     And ".gtd/REVIEW.md" contains:
       """
-      ## add could be a method
+      ### add could be a method
 
       _critical: judge unsure_
 

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

@@ -57,10 +57,6 @@ Feature: a naive pass the judge rules land is itself the implementation
     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.quality.correctness.reviewing" changes nothing
 
   Scenario: a land judgment applies the naive pass and runs from idle to the review gate with no rebuild
@@ -79,8 +75,7 @@ Feature: a naive pass the judge rules land is itself the implementation
       gtd(check): seam.check → seam.judge
       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.health.check → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
       gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """

package/src/workflows/feature/prototype-rounds.feature

@@ -47,7 +47,7 @@ Feature: past its round cap the hands-on test rests at a person's gate
     And step "seam.check" changes nothing
     And step "implement.applying" runs its script
     And step "implement.health.check" changes nothing
-    And judge step "implement.coverage" answers:
+    And judge step "implement.prototype.observable" answers:
       """
       [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
       """

package/src/workflows/feature/prototype.feature

@@ -1,10 +1,11 @@
 @inmem
-Feature: every criterion is tested by hand before the quality lap
+Feature: every observable criterion is tested by hand before the quality lap
 
-  Once coverage is judged, implement.prototype.testing uses the slice the way
-  a person would and writes .gtd/PROTOTYPE.md, one chunk per criterion headed
-  `## AC-<n>: pass|fail|blocked`, plus one per problem found beside them. A
-  failure goes to implement.prototype.fix.fixing and is tested again; only a clean
+  Once the suite is green, implement.prototype.observable judges which
+  criteria a person can observe, and implement.prototype.testing uses the
+  slice the way a person would and writes .gtd/PROTOTYPE.md, one chunk per
+  such criterion headed `## AC-<n>: pass|fail|blocked`, plus one per problem
+  found beside them. A failure goes to implement.prototype.fix.fixing and is tested again; only a clean
   report closes the slice. Past `prototypeRounds` fix rounds, or with nothing a
   fixer can take, a person decides at implement.prototype.open.
 
@@ -48,7 +49,7 @@ Feature: every criterion is tested by hand before the quality lap
     And step "seam.check" changes nothing
     And step "implement.applying" runs its script
     And step "implement.health.check" changes nothing
-    And judge step "implement.coverage" answers:
+    And judge step "implement.prototype.observable" answers:
       """
       [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
       """
@@ -57,7 +58,7 @@ Feature: every criterion is tested by hand before the quality lap
   Scenario: the testing turn is told to use every criterion for real, in a disposable place
     When the process is driven
     Then the process rests at "implement.prototype.testing"
-    And the last commit subject is "gtd(judge): implement.coverage → implement.prototype.testing"
+    And the last commit subject is "gtd(judge): implement.prototype.observable → implement.prototype.testing"
     And the resting step's content contains "Running the test suite is not this"
     And the resting step's content contains "against the user's real data or this working tree"
     And the resting step's content contains "`## AC-<n>: pass`"
@@ -79,7 +80,7 @@ Feature: every criterion is tested by hand before the quality lap
     Then the process rests at "build.quality.correctness.reviewing"
     And the commit subjects end with:
       """
-      gtd(judge): implement.coverage → implement.prototype.testing
+      gtd(judge): implement.prototype.observable → implement.prototype.testing
       gtd(agent): implement.prototype.testing → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
       """
@@ -121,7 +122,7 @@ Feature: every criterion is tested by hand before the quality lap
     Then the process rests at "build.quality.correctness.reviewing"
     And the commit subjects end with:
       """
-      gtd(judge): implement.coverage → implement.prototype.testing
+      gtd(judge): implement.prototype.observable → implement.prototype.testing
       gtd(agent): implement.prototype.testing → implement.prototype.fix.fixing
       gtd(agent): implement.prototype.fix.fixing → implement.prototype.health.check
       gtd(check): implement.prototype.health.check → implement.prototype.testing