@pmelab/gtd 54.0.0 → 56.0.0

package/src/steering/review.test.ts

@@ -2118,7 +2118,7 @@ describe("answer boxes", async () => {
 })
 
 describe("review — sectioned layout", async () => {
-  const { reviewChunks, reviewDecisions, reviewSections, sectionedReview, unansweredNotes } =
+  const { reviewChunks, reviewDecisions, reviewSections, unansweredNotes } =
     await import("./review.js")
   const boxes = (ticked?: 0 | 1 | 2): string[] => [
     "Tick exactly one:",
@@ -2230,78 +2230,4 @@ describe("review — sectioned layout", async () => {
       .map((a) => a.title)
     expect(titles.some((t) => t.includes("A finding"))).toBe(false)
   })
-
-  describe("sectionedReview", () => {
-    const flat = [
-      ...head,
-      "## Weakened scenarios",
-      "",
-      "- a.feature — s — Then x",
-      "",
-      "## A finding",
-      "",
-      "_should: contract_",
-      "",
-      "Leaks a token.",
-      "",
-      ...boxes(),
-      "",
-      "Wiring",
-      "------",
-      "",
-      "### Detail",
-      "",
-      "- [ ] ./src/b.ts#3-4 — wires it",
-      "",
-      "## Fixed automatically",
-      "",
-      "- f (fedcba9)",
-      "",
-    ].join("\n")
-
-    it("moves boxed chunks under Findings and the named ones under Walkthrough, a level deeper", () => {
-      expect(sectionedReview(flat, new Set(["Wiring"]))).toBe(
-        [
-          ...head,
-          "## Weakened scenarios",
-          "",
-          "- a.feature — s — Then x",
-          "",
-          "## Findings",
-          "",
-          "### A finding",
-          "",
-          "_should: contract_",
-          "",
-          "Leaks a token.",
-          "",
-          ...boxes(),
-          "",
-          "## Walkthrough",
-          "",
-          "### Wiring",
-          "",
-          "#### Detail",
-          "",
-          "- [ ] ./src/b.ts#3-4 — wires it",
-          "",
-          "## Fixed automatically",
-          "",
-          "- f (fedcba9)",
-          "",
-        ].join("\n"),
-      )
-    })
-
-    it("is valid and stable once sectioned", () => {
-      const once = sectionedReview(flat, new Set(["Wiring"]))
-      expect(review.validate(once)).toEqual([])
-      expect(sectionedReview(once, new Set(["Wiring"]))).toBe(once)
-    })
-
-    it("leaves a review with nothing to group byte for byte", () => {
-      const plain = [...head, "## Nothing to note", "", "Review the diff yourself.", ""].join("\n")
-      expect(sectionedReview(plain, new Set())).toBe(plain)
-    })
-  })
 })

package/src/steering/review.ts

@@ -96,7 +96,7 @@ export const ANSWER_WONT_FIX = "won't fix"
 
 /** A chunk's leading `_critical: security_` paragraph: the tier gtd ranked it with, and why. */
 const SEVERITY_LINE_RE = /^_((?:critical|should|could)(?::[^_\n]*)?)_$/
-export const severityLine = (label: string): string => `_${label}_`
+const severityLine = (label: string): string => `_${label}_`
 
 interface ReviewDoc {
   readonly shortHash?: string
@@ -1591,76 +1591,3 @@ export const reviewSections = (
     section: s.section,
     line: s.headingLine,
   }))
-
-const isBlankLine = (line: string | undefined): boolean => line !== undefined && line.trim() === ""
-
-/** How many lines a chunk's heading takes: two for a setext heading and its underline. */
-const headingSize = ({ heading, headingLine }: ChunkBlock): number =>
-  toLspPosition(heading.position!.end).line - headingLine + 1
-
-/** \`block\` with its heading an ATX \`### \` on one line, and every heading in its body one level deeper. */
-const demoted = (chunk: ChunkBlock, block: readonly string[]): string[] => {
-  const out = [...block]
-  for (const node of chunk.body) {
-    if (node.type !== "heading" || node.depth < 3 || node.depth > 5) continue
-    const at = toLspPosition(node.position!.start).line - chunk.headingLine
-    out[at] = out[at]!.replace(/^( {0,3})#/, "$1##")
-  }
-  const size = headingSize(chunk)
-  const title = size > 1 ? `### ${out[0]!.trim()}` : out[0]!.replace(/^ {0,3}##/, "###")
-  return [title, ...out.slice(size)]
-}
-
-/** A chunk's \`size\` heading lines, then its body with the blank lines around it trimmed. */
-const chunkText = (block: readonly string[], size: number): string => {
-  const rest = block.slice(size)
-  while (rest.length > 0 && isBlankLine(rest[0])) rest.shift()
-  while (rest.length > 0 && isBlankLine(rest.at(-1))) rest.pop()
-  const heading = block.slice(0, size).join("\n")
-  return rest.length === 0 ? heading : `${heading}\n\n${rest.join("\n")}`
-}
-
-/**
- * A flat review regrouped: every chunk with answer boxes under `## Findings`
- * and every chunk titled in `walkthrough` under `## Walkthrough`, each in its
- * current order and one heading level deeper. Any other chunk stays a `## ` of
- * its own, before the sections when it came before them, after otherwise. An
- * already sectioned review comes back unchanged.
- */
-export const sectionedReview = (content: string, walkthrough: ReadonlySet<string>): string => {
-  const tree = parseMarkdown(content)
-  const { chunks, sections } = splitChunks(tree, content)
-  if (sections.length > 0 || chunks.length === 0) return content
-  const { changesets } = parseReviewDoc(content)
-  const lines = content.split("\n")
-  const sectionOfChunk = (i: number): ReviewSection | undefined =>
-    changesets[i]!.answers !== undefined
-      ? "findings"
-      : walkthrough.has(changesets[i]!.title)
-        ? "walkthrough"
-        : undefined
-  const text = (i: number, demote: boolean): string => {
-    const chunk = chunks[i]!
-    const block = lines.slice(chunk.headingLine, chunks[i + 1]?.headingLine ?? lines.length)
-    return chunkText(demote ? demoted(chunk, block) : block, demote ? 1 : headingSize(chunk))
-  }
-  const grouped = chunks.map((_, i) => sectionOfChunk(i))
-  const first = grouped.findIndex((g) => g !== undefined)
-  if (first === -1) return content
-  const others = (keep: (i: number) => boolean): string[] =>
-    chunks.flatMap((_, i) => (grouped[i] === undefined && keep(i) ? [text(i, false)] : []))
-  const section = (s: ReviewSection): string[] => {
-    const members = chunks.flatMap((_, i) => (grouped[i] === s ? [text(i, true)] : []))
-    return members.length === 0 ? [] : [`## ${REVIEW_SECTIONS[s]}`, ...members]
-  }
-  const head = lines.slice(0, chunks[0]!.headingLine).join("\n").trim()
-  return `${[
-    head,
-    ...others((i) => i < first),
-    ...section("findings"),
-    ...section("walkthrough"),
-    ...others((i) => i > first),
-  ]
-    .filter((p) => p !== "")
-    .join("\n\n")}\n`
-}

package/src/workflow/compile.test.ts

@@ -10,6 +10,7 @@ describe("compileConfig", () => {
       modes: {
         qa: { validate: seededValidateCommand("qa") },
         review: { validate: seededValidateCommand("review") },
+        findings: { validate: seededValidateCommand("findings") },
       },
       skills: {},
       access: {},

package/src/workflows/feature/criteria-coverage.feature

@@ -0,0 +1,104 @@
+@inmem
+Feature: the criteria-coverage lens checks the change's tests against its criteria
+
+  The `criteria-coverage` quality lens gets the requirements the change was
+  built to, quoted in its prompt, and writes one finding per acceptance
+  criterion no test exercises. Its findings are triaged like any other lens's.
+
+  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 "criteria-coverage"
+    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
+
+      ## Impact
+
+      - the calculator module
+
+      ## Acceptance Criteria
+
+      - AC-1: `subtract(5, 3)` returns 2.
+      - AC-2: `subtract(1, 3)` returns -2.
+      """
+    And step "design.gate.answer" changes nothing
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("subtracts", () => expect(subtract(5, 3)).toBe(2))
+      """
+    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
+
+  Scenario: the lens gets the closed requirements and its finding per uncovered criterion is fixed
+    When the process is driven
+    Then the process rests at "build.quality.criteria-coverage.reviewing"
+    And ".gtd/REQUIREMENTS.md" does not exist
+    And the resting step's content contains "  > - AC-1: `subtract(5, 3)` returns 2."
+    And the resting step's content contains "  > - AC-2: `subtract(1, 3)` returns -2."
+    And the resting step's content contains "one finding per criterion no test exercises"
+
+    Given step "build.quality.criteria-coverage.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## AC-2 is not tested
+
+      No test subtracts a larger number.
+      """
+    And judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9}]
+      """
+    And step "build.fix.quality.fixing" writes "src/calc.test.ts" with:
+      """
+      it("subtracts", () => expect(subtract(5, 3)).toBe(2))
+      it("subtracts a larger number", () => expect(subtract(1, 3)).toBe(-2))
+      """
+    And step "build.fix.quality.fixing" deletes ".gtd/QUALITY.md"
+    And step "build.health.check" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Subtract
+
+      - [ ] ./src/calc.ts#2-2 — subtract(a, b)
+      """
+    And step "build.review.carrying" runs its script
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains "- AC-2 is not tested ("
+    And the commit subjects end with:
+      """
+      gtd(check): implement.closing → build.quality.criteria-coverage.reviewing
+      gtd(agent): build.quality.criteria-coverage.reviewing → build.quality.triage
+      gtd(judge): build.quality.triage → build.fix.quality.fixing
+      gtd(agent): build.fix.quality.fixing → build.health.check
+      gtd(check): build.health.check → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.carrying
+      gtd(check): build.review.carrying → build.review.await-review
+      """

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

@@ -91,7 +91,7 @@ describe("afterTail feedback lap", () => {
     await repo.drive({
       "review-gate.check": () => undefined,
       "build.health.check": () => undefined,
-      "build.review.composing": (_, r) => r.write(".gtd/REVIEW.md", review()),
+      "build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", review()),
     })
     repo.write(".gtd/REVIEW.md", review("also export multiply"))
     await repo.land()

package/src/workflows/feature/feature.ts

@@ -11,7 +11,7 @@ import {
 import { gate } from "../shared/health.js"
 import { flagModeOn, shipped } from "../shared/options.js"
 import { FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
-import { refusePendingHandOff, tail } from "../shared/tail.js"
+import { refusePendingHandOff } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 import {
   criterionIds,
@@ -22,7 +22,7 @@ import {
   type StatedCriteria,
 } from "./criteria.js"
 import { design } from "./planning.js"
-import { buildTail, humanReview, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
+import { buildTail, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
 import { prototypeRounds } from "./prototype.js"
 import { implement, implementing, seamBuild } from "./seam.js"
 import { recordRisk, riskTierOn } from "./tier.js"
@@ -32,10 +32,9 @@ import { recordRisk, riskTierOn } from "./tier.js"
 // green-baseline gate → design → a naive pass, judged with `flagMode` on: it
 // lands as the implementation, or (refactoring first when the judge asks) is
 // built fresh from → the health loop → a hands-on test of every criterion,
-// fixed and re-tested → the triaged quality lap, whose leftovers are carried
-// on → a reviewer's walkthrough of the whole change, its findings among its
-// chunks, for the human, which signs off (the episode ends back at `idle`) or
-// sends a design → implement lap.
+// fixed and re-tested → the triaged quality lap and its finding gate → a
+// reviewer's walkthrough of the whole change for the human, which signs off
+// (the episode ends back at `idle`) or sends a design → implement lap.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -57,6 +56,8 @@ export const buildFeature = async (firstBase: string): Promise<void> => {
   const handedOut = new Set(listedIds())
   const seam = await seamBuild(firstBase)
   const used = gather(handedOut)
+  // Read before the implementation closes the file: the quality lap's coverage lens checks them.
+  const requirements = read(REQUIREMENTS)
   const closed = await implementing({
     reference: seam.reference,
     tier,
@@ -72,7 +73,7 @@ export const buildFeature = async (firstBase: string): Promise<void> => {
     !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
       ? firstBase
       : seam.base
-  const outcome = await reviewedTail(base, base)
+  const outcome = await buildTail(base, { green: true, lensBase: base, requirements })
   await featureFeedback(outcome, base, { closed, used })
 }
 
@@ -83,17 +84,6 @@ const gather = (handedOut: Set<string>): readonly string[] => {
   return [...handedOut]
 }
 
-/** The quality lap, then a reviewer's walkthrough since `base` for the human. */
-const reviewedTail = (
-  base: string,
-  lensBase: string,
-  lap: "first" | "feedback" = "first",
-): Promise<ReviewOutcome> =>
-  tail(
-    (escalations, report) => humanReview(base, escalations, { report, walkthrough: true, lap }),
-    { green: true, lensBase },
-  )
-
 // seam.naive / seam.judge never run on a feedback lap: its design → implement is built unjudged
 // and unrefactored.
 const featureFeedback = async (
@@ -113,8 +103,14 @@ const featureFeedback = async (
       gather(handedOut)
     })
     const tier = riskTierOn() ? recordRisk() : undefined
+    const requirements = read(REQUIREMENTS)
     closed = await implementing({ tier, amend: true })
-    outcome = await reviewedTail(outcome.base, lensBase, "feedback")
+    outcome = await buildTail(outcome.base, {
+      green: true,
+      lensBase,
+      requirements,
+      lap: "feedback",
+    })
   }
 }
 
@@ -133,8 +129,9 @@ export const afterTail = async (first: ReviewOutcome): Promise<void> => {
     await reUnwind(outcome)
     await design(outcome.base)
     const tier = riskTierOn() ? recordRisk() : undefined
+    const requirements = read(REQUIREMENTS)
     await implement({ tier, amend: true })
-    outcome = await buildTail(outcome.base, { green: true })
+    outcome = await buildTail(outcome.base, { green: true, requirements })
   }
 }
 

package/src/workflows/feature/green.ts

@@ -3,7 +3,7 @@ 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> =>
+export const green = (): Promise<void> =>
   healthy(
     () =>
       t.agentWithSkills("fix.suite.fixing", t.implementFixPrompt(), {
@@ -13,10 +13,7 @@ export const green = (guard?: () => void): Promise<void> =>
         system: t.builderSystem(),
       }),
     {
-      guard: () => {
-        requireCriteriaFrozen(REQUIREMENTS)
-        guard?.()
-      },
+      guard: () => requireCriteriaFrozen(REQUIREMENTS),
       guardRests: false,
     },
   )