@pmelab/gtd 55.0.0 → 57.0.0

package/src/workflows/shared/vars.ts

@@ -29,6 +29,8 @@ export const defaults: Readonly<Record<string, string>> = {
   refactorFlagPattern: "\\bGTD_FLAG_\\w+",
   seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
   flagMode: "true",
+  // A person tries every green naive pass at `seam.try` before anything builds on it.
+  naiveTest: "false",
   // GTD_FLAG_RISK_TIER, recorded at process start; only "1" is on.
   flag_risk_tier: "0",
   // Decides the turn count: one `build.quality.<lens>` scope per entry, each
@@ -36,9 +38,6 @@ export const defaults: Readonly<Record<string, string>> = {
   qualityReviews:
     "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge, criteria-coverage",
   refactorQualityReviews: "correctness, ponytail-review, conventions",
-  // Fix-and-retest rounds of the hands-on test before a person is asked;
-  // "0" skips the test.
-  prototypeRounds: "3",
 }
 
 /** Environment settings. */

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

@@ -1,316 +0,0 @@
-@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 change 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 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: 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/prototype-rounds.feature

@@ -1,156 +0,0 @@
-@inmem
-Feature: past its round cap the hands-on test rests at a person's gate
-
-  `prototypeRounds` caps the fix turns the hands-on test gets. Once they
-  are spent and the report still has open items, the process rests at
-  implement.prototype.open naming them; a person's fix there is tested again
-  with a fresh budget.
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
-    And an environment variable "GTD_FLAGMODE" set to "false"
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "1"
-    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
-
-      ## Impact
-
-      - the greeting module
-
-      ## Acceptance Criteria
-
-      - AC-1: subtract(a, b) returns a - b.
-      - AC-2: add is unchanged.
-      """
-    And step "design.gate.answer" changes nothing
-    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.naive" writes "src/calc.test.ts" with:
-      """
-      it("[AC-1] subtracts", () => expect(subtract(3, 1)).toBe(2))
-      it("[AC-2] adds", () => expect(add(1, 1)).toBe(2))
-      """
-    And step "seam.check" changes nothing
-    And step "implement.applying" runs its script
-    And step "implement.health.check" changes nothing
-    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.closing" runs its script
-
-  Scenario: past the round cap a person is asked, naming the open items
-    Given step "implement.prototype.testing", when prompted with "Find how this project", writes ".gtd/PROTOTYPE.md" with:
-      """
-      ## AC-1: fail
-
-      `subtract(3, 1)` printed 4. Expected 2.
-
-      ## AC-2: pass
-
-      Printed 2.
-      """
-    And step "implement.prototype.testing", when prompted with "This is a re-test", writes ".gtd/PROTOTYPE.md" with:
-      """
-      ## AC-1: fail
-
-      Re-tested: `subtract(3, 1)` printed -2. Expected 2.
-
-      ## AC-2: pass
-
-      Printed 2.
-      """
-    And step "implement.prototype.fix.fixing" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      export const subtract = (a: number, b: number) => b - a
-      """
-    And step "implement.prototype.health.check" changes nothing
-    When the process is driven
-    Then the process rests at "implement.prototype.open"
-    And the resting step's content contains "- AC-1: fail"
-    And the resting step's content contains "after 1 fix round"
-    And the resting step's content does not contain "AC-2"
-
-  Scenario: a person's change at the gate is tested again
-    Given step "implement.prototype.testing", when prompted with "Find how this project", writes ".gtd/PROTOTYPE.md" with:
-      """
-      ## AC-1: blocked
-
-      `subtract` is not exported from any entry point I could run.
-
-      ## AC-2: pass
-
-      Printed 2.
-      """
-    And step "implement.prototype.open" 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 "implement.prototype.health.check" changes nothing
-    And step "implement.prototype.testing", when prompted with "This is a re-test", writes ".gtd/PROTOTYPE.md" with:
-      """
-      ## AC-1: pass
-
-      `subtract(3, 1)` printed 2.
-
-      ## AC-2: pass
-
-      Printed 2.
-      """
-    When the process is driven
-    Then the process rests at "build.quality.correctness.reviewing"
-    And the commit subjects end with:
-      """
-      gtd(agent): implement.prototype.testing → implement.prototype.open
-      gtd(human): implement.prototype.open → implement.prototype.health.check
-      gtd(check): implement.prototype.health.check → implement.prototype.testing
-      gtd(agent): implement.prototype.testing → implement.closing
-      gtd(check): implement.closing → build.quality.correctness.reviewing
-      """
-
-  Scenario: a re-test that sees exactly what the last round saw still ends the round
-    Given step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
-      """
-      ## AC-1: fail
-
-      `subtract(3, 1)` printed 4. Expected 2.
-
-      ## AC-2: pass
-
-      Printed 2.
-      """
-    And step "implement.prototype.fix.fixing" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      export const subtract = (a: number, b: number) => b - a
-      """
-    And step "implement.prototype.health.check" changes nothing
-    When the process is driven
-    Then the process rests at "implement.prototype.open"
-    And the commit subjects end with:
-      """
-      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
-      gtd(agent): implement.prototype.testing → implement.prototype.open
-      """