@pmelab/gtd 58.2.0 → 59.0.1

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

@@ -1,147 +0,0 @@
-@inmem
-Feature: a naive pass ends only when its tests reach no file it added and the suite is green
-
-  `seam.naive` needs no test at all. A pass whose test imports a file the pass
-  added is sent back; `seam.check` then runs the suite with the kept pass
-  applied, and a red run sends it back too, before the judge sees it. Three
-  failed attempts rest at `seam.steer`.
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    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:
-      """
-      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
-
-      ## Release Flag
-
-      new
-
-      ## Acceptance Criteria
-
-      - AC-1: `subtract(5, 3)` returns 2.
-      - AC-2: `add` still adds.
-      """
-    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
-      """
-
-  Scenario: a pass without a test goes on to the check and the judge
-    Given step "seam.check" changes nothing
-    When the process is driven
-    Then the process rests at "seam.judge"
-    And the commit subjects end with:
-      """
-      gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive → seam.check
-      gtd(check): seam.check → seam.judge
-      """
-
-  Scenario: a test importing a file the pass added is sent back, and an overrule runs the check and sticks
-    Given step "seam.naive" writes "src/subtract.ts" with:
-      """
-      export const subtract = (a: number, b: number) => a - b
-      """
-    And step "seam.naive" writes "src/subtract.test.ts" with:
-      """
-      import { subtract } from "./subtract.js"
-      it("subtracts", () => expect(subtract(5, 3)).toBe(2))
-      """
-    When the process is driven
-    Then the process rests at "seam.steer"
-    And the resting step's content contains "src/subtract.test.ts → src/subtract.ts"
-
-    Given step "seam.check" changes nothing
-    When gtd lands
-    And the process is driven
-    Then the process rests at "seam.judge"
-    And the commit subjects end with:
-      """
-      gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive
-      gtd(agent): seam.naive
-      gtd(agent): seam.naive → seam.steer
-      gtd(human): seam.steer → seam.check
-      gtd(check): seam.check → seam.judge
-      """
-
-    Given judge step "seam.judge" answers:
-      """
-      [{"id":"shape","answer":"reject","p":0.9}]
-      """
-    When the process is driven
-    Then the process rests at "seam.steer"
-    And the resting step's content contains "rejected the last attempt"
-    And the commit subjects end with:
-      """
-      gtd(check): seam.check → seam.judge
-      gtd(judge): seam.judge → seam.naive
-      gtd(agent): seam.naive → seam.check
-      gtd(check): seam.check → seam.judge
-      gtd(judge): seam.judge → seam.naive
-      gtd(agent): seam.naive → seam.check
-      gtd(check): seam.check → seam.judge
-      gtd(judge): seam.judge → seam.steer
-      """
-
-  Scenario: a red suite sends the pass back, and it moves on only once green
-    Given step "seam.naive" writes "tests/calc.test.ts" with:
-      """
-      import { add, subtract } from "../src/calc.js"
-      it("subtracts", () => expect(subtract(5, 3)).toBe(2))
-      it("still adds", () => expect(add(1, 1)).toBe(2))
-      """
-    When the process is driven
-    Then the process rests at "seam.check"
-    And the resting step's content contains "git checkout -q HEAD --"
-    And the resting step's content does not contain "'^'"
-    And the resting step's content contains "npm test"
-
-    Given step "seam.naive" is no longer scripted
-    And step "seam.check" writes ".gtd/FEEDBACK.md" with:
-      """
-      FAIL tests/calc.test.ts > subtracts
-      """
-    When the process is driven
-    Then the process rests at "seam.naive"
-    And the resting step's content contains "left the suite red"
-    And ".gtd/FEEDBACK.md" contains "> subtracts"
-
-    Given step "seam.naive" writes "tests/calc.test.ts" with:
-      """
-      import { add, subtract } from "../src/calc.js"
-      it("subtracts", () => expect(subtract(5, 3)).toBe(2))
-      it("still adds", () => expect(add(2, 2)).toBe(4))
-      """
-    And step "seam.check" from now on changes nothing
-    When the process is driven
-    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.applying
-      """

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

@@ -1,263 +0,0 @@
-@inmem
-Feature: a person tries the naive pass by hand before anything builds on it
-
-  `naiveTest` is a factory option of the shipped workflows, off by default. On,
-  every green naive pass is applied to the working tree and the process rests
-  at `seam.try`. A clean landing signs it off and the process goes on — to the
-  seam judge when the requirements ask for a release flag, else straight to the
-  implementation. Notes in
-  `.gtd/NAIVE-TEST.md`, a code edit or a requirements edit send it back: the
-  pass and the person's code edits leave the tree again, and the next naive
-  pass gets the notes and the edits. Every lap ends at the gate again.
-
-  Rule: with no release flag asked for
-
-    Background:
-      Given a gtd config with:
-        """
-        import { feature } from "@pmelab/gtd/workflows/feature"
-        export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
-        export default feature({ naiveTest: true })
-        """
-      And an environment variable "GTD_QUALITYREVIEWS" set to ""
-      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 calculator module
-
-        ## 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 "seam.applying" runs its script
-      And step "seam.restoring" runs its script
-
-    Scenario: a green naive pass rests at seam.try, applied to the working tree
-      When the process is driven
-      Then the process rests at "seam.try"
-      And the resting step's content contains "try it by hand"
-      And the resting step's content contains "`.gtd/NAIVE-TEST.md`"
-      And "src/calc.ts" contains "export const subtract"
-      And the commit subjects end with:
-        """
-        gtd(agent): seam.naive → seam.check
-        gtd(check): seam.check → seam.applying
-        gtd(check): seam.applying → seam.try
-        """
-
-    Scenario: a clean landing signs the pass off, takes it out and lands it as the implementation
-      When the process is driven
-      Then the process rests at "seam.try"
-      When gtd lands
-      And step "implement.applying" runs its script
-      And step "implement.health.check" changes nothing
-      And step "implement.closing" runs its script
-      And the process is driven
-      Then the process rests at "build.review.reviewing"
-      And "src/calc.ts" contains "export const subtract"
-      And the commit subjects end with:
-        """
-        gtd(check): seam.applying → seam.try
-        gtd(human): seam.try → seam.restoring
-        gtd(check): seam.restoring → implement.applying
-        gtd(check): implement.applying → implement.health.check
-        gtd(check): implement.health.check → implement.closing
-        gtd(check): implement.closing → build.review.reviewing
-        """
-
-    Scenario: notes and a code edit send the pass back, out of the tree, to a naive pass that reads both
-      Given step "seam.naive", when prompted with "> subtract(5, 3) printed 8, not 2.", writes "notes-read.txt" with:
-        """
-        read
-        """
-      And step "seam.naive", when prompted with "-- . ':(exclude).gtd'", writes "edits-read.txt" with:
-        """
-        read
-        """
-      When the process is driven
-      Then the process rests at "seam.try"
-      Given a file ".gtd/NAIVE-TEST.md" with:
-        """
-        subtract(5, 3) printed 8, not 2.
-        """
-      And a file "src/calc.ts" with:
-        """
-        export const add = (a: number, b: number) => a + b
-        export const subtract = (a: number, b: number) => a - b
-        """
-      And a file "src/hint.ts" with:
-        """
-        export const hint = "subtract, not add"
-        """
-      When gtd lands
-      And the process is driven
-      Then the process rests at "seam.try"
-      And "src/hint.ts" does not exist
-      And "notes-read.txt" contains "read"
-      And "edits-read.txt" contains "read"
-      And ".gtd/NAIVE-TEST.md" does not exist
-      And the commit subjects end with:
-        """
-        gtd(check): seam.applying → seam.try
-        gtd(human): seam.try → seam.restoring
-        gtd(check): seam.restoring → seam.naive
-        gtd(agent): seam.naive → seam.check
-        gtd(check): seam.check → seam.applying
-        gtd(check): seam.applying → seam.try
-        """
-
-    Scenario: notes alone send the pass back with no edits to read
-      Given step "seam.naive", when prompted with "They edited the code", writes "edits-read.txt" with:
-        """
-        read
-        """
-      When the process is driven
-      Then the process rests at "seam.try"
-      Given a file ".gtd/NAIVE-TEST.md" with:
-        """
-        subtract adds.
-        """
-      When gtd lands
-      And the process is driven
-      Then the process rests at "seam.try"
-      And "edits-read.txt" does not exist
-
-    Scenario: a requirements edit at seam.try stays, and sends the pass back
-      When the process is driven
-      Then the process rests at "seam.try"
-      Given a file ".gtd/REQUIREMENTS.md" with:
-        """
-        # Requirements
-
-        ## Impact
-
-        - the calculator module
-
-        ## Acceptance Criteria
-
-        - AC-1: subtract(a, b) returns a - b.
-        - AC-2: subtract(a, b) rejects NaN.
-        """
-      When gtd lands
-      And the process is driven
-      Then the process rests at "seam.try"
-      And ".gtd/REQUIREMENTS.md" contains "AC-2: subtract(a, b) rejects NaN."
-      And the commit subjects end with:
-        """
-        gtd(human): seam.try → seam.restoring
-        gtd(check): seam.restoring → seam.naive
-        gtd(agent): seam.naive → seam.check
-        gtd(check): seam.check → seam.applying
-        gtd(check): seam.applying → seam.try
-        """
-
-  Rule: with a release flag asked for
-
-    Background:
-      Given a gtd config with:
-        """
-        import { feature } from "@pmelab/gtd/workflows/feature"
-        export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
-        export default feature({ naiveTest: true })
-        """
-      And an environment variable "GTD_QUALITYREVIEWS" set to ""
-      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 calculator module
-
-        ## Release Flag
-
-      new
-
-      ## 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 "seam.applying" runs its script
-      And step "seam.restoring" runs its script
-
-    Scenario: the person tries the pass before the seam judge rules
-      When the process is driven
-      Then the process rests at "seam.try"
-      And the resting step's content contains "the seam judge rules on its shape"
-      When gtd lands
-      And the process is driven
-      Then the process rests at "seam.judge"
-
-  Rule: with a naiveTest that is neither true nor false
-
-    Background:
-      Given an environment variable "GTD_NAIVETEST" set to "maybe"
-      And a gtd config with:
-        """
-        import { feature } from "@pmelab/gtd/workflows/feature"
-        export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
-        export default feature()
-        """
-      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
-        """
-
-    Scenario: the landing that would pin it is refused
-      Then driving the process is refused with "naiveTest must be"

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

@@ -1,93 +0,0 @@
-# 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 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, applies the kept pass as it is — no build turn — and
-  runs the health loop and quality lap to the feature review. The flag is pinned here so the per-flag test runs never
-  move it off this path.
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
-    And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
-    And a file "src/greeting.ts" with:
-      """
-      export const greeting = "Helo, world"
-      """
-    And the working tree is committed as "feat: add greeting"
-    And a file "TODO.md" with:
-      """
-      # Fix the typo
-
-      greeting says "Helo"; make it "Hello".
-      """
-    And step "unwind" changes nothing
-    And step "start-gate.check" changes nothing
-    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-
-      ## Concerns
-
-      ### Typo
-
-      - greeting reads "Hello, world".
-
-      ## Impact
-
-      - the greeting module
-
-      ## Release Flag
-
-      new
-
-      ## Acceptance Criteria
-
-      - AC-1: the change behaves as described.
-      """
-    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] holds", () => {})
-      """
-    And step "seam.naive" writes "src/greeting.ts" with:
-      """
-      export const greeting = "Hello, world"
-      """
-    And judge step "seam.judge" answers:
-      """
-      [{"id":"shape","answer":"land","p":0.9}]
-      """
-    And step "implement.applying" runs its script
-    And step "implement.health.check" changes nothing
-    And step "implement.closing" runs its script
-    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
-    When the process is driven
-    Then the process rests at "build.review.reviewing"
-    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
-      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 → seam.naive
-      gtd(agent): seam.naive → seam.check
-      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.closing
-      gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
-      """
-    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.applying" has a body containing "\"answer\":\"land\""
-    And no commit body contains "Gtd-Approved:"
-    And no commit body contains "Gtd-Workflow:"

package/src/workflows/feature/planning.ts

@@ -1,41 +0,0 @@
-import {
-  changes,
-  hasThreadFor,
-  requireAnswers,
-  requireReplies,
-  requireThreadsClosed,
-  requireProgress,
-  scope,
-} from "../../flows/index.js"
-import { REQUIREMENTS } from "../shared/steps.js"
-import { requireCriteria, requireImpact } from "./criteria.js"
-import { requireReleaseFlag } from "./release-flag.js"
-import { answerProductQuestions, triage } from "./steps.js"
-
-/**
- * Always stop for the human. Resolves `true` when the round changed anything
- * (the author revises), `false` on a clean re-run. Open threads refuse every
- * landing; unticked questions only refuse a round with no thread for the
- * agent to answer.
- */
-const noteGate = async (file: string, answer: () => Promise<void>): Promise<boolean> => {
-  await answer()
-  requireThreadsClosed(file)
-  if (changes().length === 0) return false
-  if (!hasThreadFor("agent", file)) requireAnswers(file)
-  return true
-}
-
-/** Triage the sketch since `base` into requirements, until no product question is open; `guard` holds every round's criteria. */
-export const design = (base: string, guard?: () => void): Promise<void> =>
-  scope("design", async () => {
-    do {
-      await triage(base)
-      requireProgress(REQUIREMENTS)
-      requireReplies(REQUIREMENTS)
-      requireCriteria(REQUIREMENTS)
-      requireImpact(REQUIREMENTS)
-      requireReleaseFlag(REQUIREMENTS)
-      guard?.()
-    } while (await noteGate(REQUIREMENTS, answerProductQuestions))
-  })

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

@@ -1,131 +0,0 @@
-# One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
-@inmem
-Feature: a refactor that carried the whole feature still gets a quality lap over all of it
-
-  With GTD_FLAG_RISK_TIER off, a refactor-first
-  refactor can land everything the requirements ask for. The feature's
-  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's
-  quality lap covers the whole change, refactor included.
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
-    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`.
-
-      ## Impact
-
-      - the greeting module
-
-      ## Release Flag
-
-      new
-
-      ## Acceptance Criteria
-
-      - AC-1: the change behaves as described.
-      """
-    And step "design.gate.answer" changes nothing
-
-  Scenario: a tests-only implement turn after a refactor that did it all reaches the quality lap and the review
-    Given step "seam.check" changes nothing
-    And step "seam.naive" writes "src/acceptance.test.ts" with:
-      """
-      it("[AC-1] holds", () => {})
-      """
-    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}]
-      """
-    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:
-      """
-      export const add = (a: number, b: number) => a + b
-      export const subtract = (a: number, b: number) => a - b
-      """
-    And step "refactor.health.check" changes nothing
-    And step "refactor.closing" runs its script
-    And step "refactor.build.review.carrying" runs its script
-    And step "refactor.build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## calc
-
-      - [ ] ./src/calc.ts#1-2
-        subtract next to add
-      """
-    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
-        subtract next to add
-      """
-    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
-    When gtd lands
-    And the process is driven
-    Then the process rests at "build.quality.correctness.reviewing"
-    And the resting step's content contains the hash of the commit "feat: add calculator"
-    And ".gtd/REQUIREMENTS.md" does not exist
-
-    Given step "build.quality.correctness.reviewing" changes nothing
-    When the process is driven
-    Then the process rests at "build.review.reviewing"
-    And "src/calc.ts" contains "subtract"
-    And the commit subjects end with:
-      """
-      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.closing
-      gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
-      """