@pmelab/gtd 55.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

@@ -88,10 +88,6 @@ Feature: the criteria-coverage lens checks the change's tests against its criter
 
       - [ ] ./src/calc.ts#2-2 — subtract(a, b)
       """
-    And judge step "build.review.ranking" answers:
-      """
-      []
-      """
     And step "build.review.carrying" runs its script
     When the process is driven
     Then the process rests at "build.review.await-review"
@@ -103,7 +99,6 @@ Feature: the criteria-coverage lens checks the change's tests against its criter
       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.ranking
-      gtd(judge): build.review.ranking → build.review.carrying
+      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> => {
@@ -74,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, requirements)
+  const outcome = await buildTail(base, { green: true, lensBase: base, requirements })
   await featureFeedback(outcome, base, { closed, used })
 }
 
@@ -85,18 +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,
-  requirements: string | undefined,
-  lap: "first" | "feedback" = "first",
-): Promise<ReviewOutcome> =>
-  tail(
-    (escalations, report) => humanReview(base, escalations, { report, walkthrough: true, lap }),
-    { green: true, lensBase, requirements },
-  )
-
 // seam.naive / seam.judge never run on a feedback lap: its design → implement is built unjudged
 // and unrefactored.
 const featureFeedback = async (
@@ -118,7 +105,12 @@ const featureFeedback = async (
     const tier = riskTierOn() ? recordRisk() : undefined
     const requirements = read(REQUIREMENTS)
     closed = await implementing({ tier, amend: true })
-    outcome = await reviewedTail(outcome.base, lensBase, requirements, "feedback")
+    outcome = await buildTail(outcome.base, {
+      green: true,
+      lensBase,
+      requirements,
+      lap: "feedback",
+    })
   }
 }