@pmelab/gtd 33.0.0 → 34.0.0

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

@@ -0,0 +1,108 @@
+@inmem
+Feature: human review is the review door's, never the feature workflow's
+
+  A feature process ends once its last slice lands: the quality lap is its
+  last look at the change, and no human review rest follows it. Human review
+  runs only when someone opens the `review` door.
+
+  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.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`.
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      """
+    And step "design.gate.answer" changes nothing
+    And step "implement.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 "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+
+  Scenario: a feature process ends at idle with no review rest
+    When the process is driven
+    Then the process rests at "idle"
+    And "src/calc.ts" contains "subtract"
+    And ".gtd/REVIEW.md" does not exist
+    And the commit subjects end with:
+      """
+      gtd(human): design.gate.answer → implement.building
+      gtd(agent): implement.building → implement.health.check
+      gtd(check): implement.health.check → implement.closing
+      gtd(check): implement.closing → idle
+      """
+
+  Scenario: the review door still runs human review over the finished feature
+    When the process is driven
+    Then the process rests at "idle"
+
+    Given step "review-gate.check" changes nothing
+    And step "build.health.check" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#2-2
+        new subtract function
+      """
+    When gtd opens door "review" with "HEAD~8"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And the resting step's content contains the hash of the commit "feat: add calculator"
+
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [x] ./src/calc.ts#2-2
+        new subtract function
+      """
+    And step "build.review.closing" runs its script
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/REVIEW.md" does not exist
+    And the commit subjects end with:
+      """
+      gtd(check): implement.closing → idle
+      gtd(human): review-gate.check
+      gtd(check): review-gate.check → build.health.check
+      gtd(check): build.health.check → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.await-review
+      gtd(human): build.review.await-review → build.review.closing
+      gtd(check): build.review.closing → idle
+      """

package/src/workflows/shared/tail.ts

@@ -92,7 +92,7 @@ export interface TailOptions {
 
 /**
  * The build tail: fix (when entered red), keep green, the quality lap, then
- * `finish` — the human review, as the calling workflow runs it.
+ * `finish` — whatever the calling workflow runs last, a human review or nothing.
  */
 export function tail<T>(
   finish: (escalations: EscalationCount) => Promise<T>,
@@ -165,7 +165,7 @@ const runTail = <T>(finish: Finish<T>, options: TailOptions): Promise<T> =>
     // Truthy, not `true`: an untyped config's flags read as they always did.
     if (options.fixFirst) await repair()
     else if (!options.green) await healthy(fix, { escalations, guard, guardRests, rules })
-    // The lap runs once a tail: after its findings are fixed, review follows.
+    // The lap runs once a tail: after its findings are fixed, `finish` follows.
     if ((await qualityLap(guard, lenses, lensBase)) === "findings") {
       if (await fixQualityFindings(escalations, guard, guardRests, rules)) {
         await healthy(fix, { escalations, guard, guardRests, rules })

package/src/workflows/shared/text.ts

@@ -87,6 +87,19 @@ What each change does next (then run \`gtd land\`):
 - **Continue** — having undone the sketch by hand, check the test baseline is green and start triage (**start-gate.check**).
 `
 
+export const qualityUnresolvedMessage = (): string =>
+  `The quality lap's fix turns hit their cap and \`.gtd/QUALITY.md\` still
+holds findings. Nothing reviews the change after this, so the process
+will not end with them open.
+
+Fix what matters by hand, then delete or empty \`.gtd/QUALITY.md\` —
+dropping a finding is your call to make.
+
+What each change does next (then run \`gtd land\`):
+- **Delete or empty \`.gtd/QUALITY.md\`** — the suite runs on your edits, then the process ends (**idle**).
+- **Anything else** — rests here again.
+`
+
 export const startGateBlockedMessage = (): string =>
   `The test baseline is red — gtd will not start new work on a broken suite.
 \`.gtd/FEEDBACK.md\` holds the failing output.