@pmelab/gtd 49.0.0 → 51.0.0

package/src/workflows/feature/reviewer-walkthrough.feature

@@ -11,6 +11,7 @@ Feature: a reviewer walks the human through the feature's code
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And an environment variable "GTD_FLAGMODE" set to "false"
     And a file "src/calc.ts" with:
@@ -67,6 +68,10 @@ Feature: a reviewer walks the human through the feature's code
     And step "build.quality.sorting" runs its script
     And step "build.quality.closing" runs its script
     And step "build.review.carrying" runs its script
+    And judge step "build.review.ranking" answers:
+      """
+      []
+      """
 
   Scenario: the finding gets its text and answer boxes under the reviewer's pointers
     Given step "build.review.reviewing" is prompted with "- `## AC-1 ignores floating point`:"
@@ -93,12 +98,16 @@ Feature: a reviewer walks the human through the feature's code
       """
       ## Subtract
 
+      _critical: judge unsure_
+
       The new export.
 
       - [ ] ./src/calc.ts#2-2 — subtract(a, b)
 
       ## AC-1 ignores floating point
 
+      _critical: judge unsure_
+
       Should subtract round? The criterion does not say.
 
       In the code:
@@ -114,7 +123,8 @@ Feature: a reviewer walks the human through the feature's code
     And no commit body contains "build.review.composing"
     And the commit subjects end with:
       """
-      gtd(agent): build.review.reviewing → build.review.carrying
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
       gtd(check): build.review.carrying → build.review.await-review
       """
 
@@ -169,11 +179,13 @@ Feature: a reviewer walks the human through the feature's code
     Then the process rests at "build.review.await-review"
     And the commit subjects end with:
       """
-      gtd(agent): build.review.reviewing → build.review.carrying
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
       gtd(check): build.review.carrying → build.review.fix.risks.fixing
       gtd(agent): build.review.fix.risks.fixing → build.health.check
       gtd(check): build.health.check → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.carrying
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
       gtd(check): build.review.carrying → build.review.await-review
       """
 

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

@@ -9,6 +9,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to the
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
     And a file "src/calc.ts" with:

package/src/workflows/feature/seam.feature

@@ -7,6 +7,7 @@ Feature: the naive pass and seam judge decide how a feature is built
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And the gtd config ends with:
       """
       export const config = {

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

@@ -335,7 +335,7 @@ const driveSeam = async (
     note: () => void files.set(NOTE, "Seam: a shared op"),
     deriving: () => void files.set(REFACTOR, "package"),
     closing: () => void files.delete(REFACTOR),
-    "review.composing": () => void files.set(REVIEW, reviewDoc),
+    "review.reviewing": () => void files.set(REVIEW, reviewDoc),
     "review.closing": () => {
       files.delete(REVIEW)
       current = "after-refactor"
@@ -500,7 +500,8 @@ describe("implement", () => {
     lastOptions = undefined
     installContext(
       fixtureContext(
-        {},
+        // The hands-on test after coverage has its own scenarios.
+        { vars: { prototypeRounds: "0" } },
         {
           step: (request: StepRequest) => {
             requests.push(request)

package/src/workflows/feature/seam.ts

@@ -26,10 +26,19 @@ import {
   type KeptTip,
 } from "../../flows/index.js"
 import { continuing, phase, type Handoff, type Phase } from "../shared/continuation.js"
-import { coder, FEEDBACK, HANDOFF, REFACTOR_NOTE, REQUIREMENTS, SLICES } from "../shared/steps.js"
+import {
+  coder,
+  FEEDBACK,
+  HANDOFF,
+  PROTOTYPE,
+  REFACTOR_NOTE,
+  REQUIREMENTS,
+  SLICES,
+} from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
 import { green, requireCoverage } from "./coverage.js"
+import { prototypeTest } from "./prototype.js"
 import {
   criterionIds,
   requireCriteria,
@@ -373,10 +382,11 @@ export const implementing = (options: ImplementOptions): Promise<readonly string
     if (built && acceptance !== undefined)
       requireAcceptance({ ...acceptance, ids: settled(acceptance.ids, options.slice) }, since)
     // Fix turns are held to the carried tests too: deleting a red one must not buy a green suite.
-    await green(
-      built && acceptance !== undefined ? () => requireAcceptanceKept(acceptance) : undefined,
-    )
+    const keepsTests =
+      built && acceptance !== undefined ? () => requireAcceptanceKept(acceptance) : undefined
+    await green(keepsTests)
     await requireCoverage(options.base, options.slice)
+    await prototypeTest(options.slice, keepsTests)
     const ids = criterionIds(read(REQUIREMENTS) ?? "")
     await closing(moreToBuild(options.more))
     return ids
@@ -393,7 +403,11 @@ export const closeOut = (): Promise<void> => scope("implement", () => closing(fa
 const closing = (more: boolean): Promise<void> =>
   run(
     "closing",
-    removeScript(more ? [REFACTOR_NOTE, HANDOFF] : [REQUIREMENTS, REFACTOR_NOTE, SLICES, HANDOFF]),
+    removeScript(
+      more
+        ? [REFACTOR_NOTE, HANDOFF, PROTOTYPE]
+        : [REQUIREMENTS, REFACTOR_NOTE, SLICES, HANDOFF, PROTOTYPE],
+    ),
     { label: "Closing out the implementation" },
   )
 

package/src/workflows/feature/severity-budget.feature

@@ -0,0 +1,112 @@
+@inmem
+Feature: the review's ranking is batched to the judge's budget
+
+  `build.review.ranking` puts as many chunks in one judgment as the budget's
+  even share still holds whole; the rest go to the next. A chunk too big to
+  fit even alone is cut, and a cut chunk is critical.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    And an environment variable "GTD_FLAGMODE" set to "false"
+    And an environment variable "GTD_JUDGEBUDGETBYTES" set to "150"
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(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.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## AC-1 ignores floating point
+
+      Should subtract round? The criterion does not say.
+      """
+    And judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"design","p":0.9}]
+      """
+    And step "build.quality.sorting" runs its script
+    And step "build.quality.closing" runs its script
+    And step "build.review.carrying" runs its script
+
+  Scenario: a chunk the budget cuts is listed as critical, the others judged in batches of their own
+    Given step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Subtract
+
+      - [ ] ./src/calc.ts#2-2 — subtract(a, b)
+
+      ## AC-1 ignores floating point
+
+      - [ ] ./src/calc.ts#2-2 — returns the raw difference
+      """
+    And judge step "build.review.ranking", when its questions contain "C1.security", answers:
+      """
+      [{"id":"C1.security","answer":"no","p":0.9},{"id":"C1.reversibility","answer":"two-way","p":0.9},{"id":"C1.blastRadius","answer":"local","p":0.9},{"id":"C1.newConcept","answer":"no","p":0.9}]
+      """
+    And judge step "build.review.ranking", when its questions contain "C2.security", answers:
+      """
+      [{"id":"C2.security","answer":"no","p":0.9},{"id":"C2.reversibility","answer":"two-way","p":0.9},{"id":"C2.blastRadius","answer":"local","p":0.9},{"id":"C2.newConcept","answer":"no","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## AC-1 ignores floating point
+
+      _critical: judge unsure_
+      """
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## Subtract
+
+      _could_
+      """
+    And the commit subjects end with:
+      """
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
+      gtd(check): build.review.carrying → build.review.await-review
+      """

package/src/workflows/feature/severity-sorted-review.feature

@@ -0,0 +1,198 @@
+@inmem
+Feature: the final review lists what matters most first
+
+  Before the review rests, the judge rates every chunk the reviewer wrote — a
+  walkthrough chunk or a carried quality finding — on the same four questions
+  as a human's note (`build.review.ranking`): critical (security, or a one-way
+  door), should (a contract, or a new concept), could. The review lists them
+  in that order, security before one-way doors, each led by its tier and
+  reason. A chunk the judge cannot rate is critical, so it is shown first.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    And an environment variable "GTD_FLAGMODE" set to "false"
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## 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.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## AC-1 ignores floating point
+
+      Should subtract round? The criterion does not say.
+      """
+    And judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"design","p":0.9}]
+      """
+    And step "build.quality.sorting" runs its script
+    And step "build.quality.closing" runs its script
+    And step "build.review.carrying" runs its script
+
+  Scenario: security and one-way doors come first, a carried finding sorted among the rest
+    Given step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Subtract
+
+      The new export.
+
+      - [ ] ./src/calc.ts#2-2 — subtract(a, b)
+
+      ## Session token
+
+      - [ ] ./src/calc.ts#1-1 — reads the caller's token
+
+      ## AC-1 ignores floating point
+
+      - [ ] ./src/calc.ts#2-2 — returns the raw difference
+
+      ## Saved format
+
+      - [ ] ./src/calc.ts#1-2 — what callers persist
+      """
+    And judge step "build.review.ranking" answers:
+      """
+      [{"id":"C1.security","answer":"no","p":0.9},{"id":"C1.reversibility","answer":"two-way","p":0.9},{"id":"C1.blastRadius","answer":"local","p":0.9},{"id":"C1.newConcept","answer":"no","p":0.9},{"id":"C2.security","answer":"yes","p":0.9},{"id":"C2.reversibility","answer":"two-way","p":0.9},{"id":"C2.blastRadius","answer":"module","p":0.9},{"id":"C2.newConcept","answer":"no","p":0.9},{"id":"C3.security","answer":"no","p":0.9},{"id":"C3.reversibility","answer":"two-way","p":0.9},{"id":"C3.blastRadius","answer":"contract","p":0.9},{"id":"C3.newConcept","answer":"no","p":0.9},{"id":"C4.security","answer":"no","p":0.9},{"id":"C4.reversibility","answer":"one-way","p":0.9},{"id":"C4.blastRadius","answer":"contract","p":0.9},{"id":"C4.newConcept","answer":"no","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## Session token
+
+      _critical: security_
+
+      - [ ] ./src/calc.ts#1-1 — reads the caller's token
+
+      ## Saved format
+
+      _critical: one-way door_
+
+      - [ ] ./src/calc.ts#1-2 — what callers persist
+
+      ## AC-1 ignores floating point
+
+      _should: contract_
+
+      Should subtract round? The criterion does not say.
+      """
+    And ".gtd/REVIEW.md" contains:
+      """
+      - [ ] _your answer_
+
+      ## Subtract
+
+      _could_
+
+      The new export.
+      """
+    And the commit "gtd(judge): build.review.ranking → build.review.carrying" has a body containing "Gtd-Judge:"
+    And the commit subjects end with:
+      """
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
+      gtd(check): build.review.carrying → build.review.await-review
+      """
+
+  Scenario: a chunk the judge is unsure about is listed as critical
+    Given step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Subtract
+
+      The new export.
+
+      - [ ] ./src/calc.ts#2-2 — subtract(a, b)
+
+      ## Session token
+
+      - [ ] ./src/calc.ts#1-1 — reads the caller's token
+
+      ## AC-1 ignores floating point
+
+      - [ ] ./src/calc.ts#2-2 — returns the raw difference
+
+      ## Saved format
+
+      - [ ] ./src/calc.ts#1-2 — what callers persist
+      """
+    And judge step "build.review.ranking" answers:
+      """
+      [{"id":"C1.security","answer":"no","p":0.9},{"id":"C1.reversibility","answer":"two-way","p":0.9},{"id":"C1.blastRadius","answer":"local","p":0.9},{"id":"C1.newConcept","answer":"no","p":0.9},{"id":"C2.security","answer":"no","p":0.4},{"id":"C2.reversibility","answer":"two-way","p":0.9},{"id":"C2.blastRadius","answer":"local","p":0.9},{"id":"C2.newConcept","answer":"no","p":0.9},{"id":"C3.security","answer":"no","p":0.9},{"id":"C3.reversibility","answer":"two-way","p":0.9},{"id":"C3.blastRadius","answer":"contract","p":0.9},{"id":"C3.newConcept","answer":"no","p":0.9},{"id":"C4.security","answer":"no","p":0.9},{"id":"C4.reversibility","answer":"two-way","p":0.9},{"id":"C4.blastRadius","answer":"local","p":0.9},{"id":"C4.newConcept","answer":"yes","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Session token
+
+      _critical: judge unsure_
+      """
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## AC-1 ignores floating point
+
+      _should: contract_
+      """
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## Saved format
+
+      _should: new concept_
+      """
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## Subtract
+
+      _could_
+      """

package/src/workflows/feature/slice-findings.feature

@@ -9,6 +9,7 @@ Feature: every slice's quality lap is triaged, and its leftovers wait for the re
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And an environment variable "GTD_FLAGMODE" set to "false"
     And an environment variable "GTD_SLICEMAXCRITERIA" set to "1"
@@ -71,6 +72,10 @@ Feature: every slice's quality lap is triaged, and its leftovers wait for the re
     And step "build.quality.closing" runs its script
     And step "build.health.check" changes nothing
     And step "build.review.carrying" runs its script
+    And judge step "build.review.ranking" answers:
+      """
+      []
+      """
 
   Scenario: a finding questioning a criterion reaches the final review, never the fixer
     Given step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
@@ -112,6 +117,8 @@ Feature: every slice's quality lap is triaged, and its leftovers wait for the re
       """
       ## AC-1 ignores floating point
 
+      _critical: judge unsure_
+
       _From slice 1, lens correctness._
 
       Should subtract round? The criterion does not say.
@@ -120,6 +127,8 @@ Feature: every slice's quality lap is triaged, and its leftovers wait for the re
       """
       ## AC-1 ignores floating point (2)
 
+      _critical: judge unsure_
+
       _From slice 2, lens correctness._
       """
     And the commit subjects end with:
@@ -137,7 +146,8 @@ Feature: every slice's quality lap is triaged, and its leftovers wait for the re
       gtd(agent): build.quality.correctness.reviewing → build.quality.triage
       gtd(judge): build.quality.triage → build.quality.sorting
       gtd(check): build.quality.sorting → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.carrying
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
       gtd(check): build.review.carrying → build.review.await-review
       """
 
@@ -181,6 +191,8 @@ Feature: every slice's quality lap is triaged, and its leftovers wait for the re
       """
       ## subtract has no negative test
 
+      _critical: judge unsure_
+
       _From slice 1, lens correctness._
 
       _The fixer left this unresolved._
@@ -208,7 +220,8 @@ Feature: every slice's quality lap is triaged, and its leftovers wait for the re
       gtd(agent): build.fix.quality.fixing → build.health.check
       gtd(check): build.health.check → build.quality.closing
       gtd(check): build.quality.closing → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.carrying
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
       gtd(check): build.review.carrying → build.review.await-review
       """
 

package/src/workflows/feature/slicing-cap.feature

@@ -12,3 +12,12 @@ Feature: a bad sliceMaxCriteria refuses the landing that would pin it
       # Something
       """
     Then driving the process is refused with "sliceMaxCriteria must be a positive integer, got \"0\""
+
+  Scenario: a prototypeRounds that is not a whole number refuses the idle landing
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "-1"
+    And a file "TODO.md" with:
+      """
+      # Something
+      """
+    Then driving the process is refused with "prototypeRounds must be a non-negative integer, got \"-1\""

package/src/workflows/feature/slicing.feature

@@ -8,6 +8,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     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"

package/src/workflows/feature/standards.feature

@@ -11,6 +11,7 @@ Feature: the review learns standards from the human's answers
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And an environment variable "GTD_FLAGMODE" set to "false"
     And a file "src/calc.ts" with:
@@ -92,6 +93,10 @@ Feature: the review learns standards from the human's answers
       - [ ] ./src/calc.ts#2-2 — a plain function
       """
     And step "build.review.carrying" runs its script
+    And judge step "build.review.ranking" answers:
+      """
+      []
+      """
     And judge step "build.quality.triage" answers:
       """
       [{"id":"Q1","answer":"design","p":0.9}]

package/src/workflows/shared/options.ts

@@ -27,6 +27,7 @@ export const ShippedOptions = Schema.Struct({
   qualityReviews: setting,
   refactorQualityReviews: setting,
   continuations: setting,
+  prototypeRounds: setting,
   continuationStall: setting,
   testCommand: setting,
   plannerModel: setting,

package/src/workflows/shared/prose.ts

@@ -88,6 +88,12 @@ things when redirected — a failing check, or reviewer feedback. Stay
 strictly inside that task; never touch code outside it. Treat feedback as the
 diagnosis to act on; discard it, with reason, only when simply wrong.`
 
+export const testerPersona = `You are the hands-on tester in gtd's build pipeline: use what was just
+built the way a person would — run the real program, open the real
+page, call the real endpoint — and report exactly what you did and
+what you saw. Never fix anything yourself, and never pass a criterion
+you did not watch hold.`
+
 export const finisherPersona = `You are the closing identity in gtd's build pipeline — the last coder
 before it closes. Fix a late-breaking failing check after sign-off,
 focused and minimal. Every turn lands its own commit — nothing here