@pmelab/gtd 51.0.1 → 52.1.0

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,384 @@
+@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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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
+
+      ## Impact
+
+      - the greeting module
+
+      ## 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

@@ -33,6 +33,10 @@ Feature: each quality lens runs on its own model hint
       """
       # Requirements
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: `subtract(a, b)` returns `a - b`.
@@ -51,10 +55,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

@@ -35,6 +35,10 @@ Feature: the quality lap's findings are triaged before the review
 
       - `subtract(a, b)` returns `a - b`.
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: subtract(a, b) returns a - b.
@@ -53,10 +57,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 +113,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 +131,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 +237,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/naive-acceptance.feature

@@ -28,6 +28,10 @@ Feature: a naive pass ends only when a test names every criterion and the suite
       """
       # Requirements
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: `subtract(5, 3)` returns 2.

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

@@ -36,6 +36,10 @@ Feature: a naive pass the judge rules land is itself the implementation
 
       - greeting reads "Hello, world".
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: the change behaves as described.
@@ -57,10 +61,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 +79,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/planning.ts

@@ -8,7 +8,7 @@ import {
   scope,
 } from "../../flows/index.js"
 import { REQUIREMENTS } from "../shared/steps.js"
-import { requireCriteria } from "./criteria.js"
+import { requireCriteria, requireImpact } from "./criteria.js"
 import { answerProductQuestions, triage } from "./steps.js"
 
 /**
@@ -33,6 +33,7 @@ export const design = (base: string, guard?: () => void): Promise<void> =>
       requireProgress(REQUIREMENTS)
       requireReplies(REQUIREMENTS)
       requireCriteria(REQUIREMENTS)
+      requireImpact(REQUIREMENTS)
       guard?.()
     } while (await noteGate(REQUIREMENTS, answerProductQuestions))
   })

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

@@ -28,6 +28,10 @@ Feature: past its round cap the hands-on test rests at a person's gate
       """
       # Requirements
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: subtract(a, b) returns a - b.
@@ -47,7 +51,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.
 
@@ -29,6 +30,10 @@ Feature: every criterion is tested by hand before the quality lap
       """
       # Requirements
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: subtract(a, b) returns a - b.
@@ -48,7 +53,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 +62,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 +84,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 +126,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
@@ -235,6 +240,10 @@ Feature: every criterion is tested by hand before the quality lap
       """
       # Requirements
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-2: add is unchanged.