@pmelab/gtd 55.0.0 → 57.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

@@ -7,7 +7,6 @@ Feature: the criteria-coverage lens checks the change's tests against its criter
 
   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:
@@ -88,10 +87,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 +98,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/criteria.test.ts

@@ -1,13 +1,6 @@
 import { describe, expect, it } from "vitest"
 import type { Change } from "../../flows/index.js"
-import {
-  criteriaOf,
-  criterionIds,
-  handsOnIds,
-  hasImpact,
-  statedCriteria,
-  unstableIds,
-} from "./criteria.js"
+import { criteriaOf, criterionIds, hasImpact, statedCriteria, unstableIds } from "./criteria.js"
 
 const added = (path: string, after: string): Change => ({
   path,
@@ -55,17 +48,6 @@ describe("criteriaOf", () => {
     ).toEqual([{ id: "AC-1", text: "exits 2 when config is bad - missing file" }])
   })
 
-  it("reads the (no hands-on) tag between an ID and its colon", () => {
-    expect(
-      criteriaOf(
-        "## Acceptance Criteria\n\n- AC-1: runs\n- AC-2 (no hands-on): the prompt says so\n",
-      ),
-    ).toEqual([
-      { id: "AC-1", text: "runs" },
-      { id: "AC-2", text: "the prompt says so", noHandsOn: true },
-    ])
-  })
-
   it("is undefined without the section", () => {
     expect(criteriaOf("# R\n\n- AC-1: x\n")).toBeUndefined()
   })
@@ -84,19 +66,6 @@ describe("statedCriteria", () => {
     })
   })
 
-  it("keeps a stated (no hands-on) tag, renumbered or not", () => {
-    const tagged = "## Acceptance criteria\n\n- AC-1: a\n- AC-2 (no hands-on): b\n"
-    expect(statedCriteria([added("TODO.md", tagged)], "abc")?.criteria).toEqual([
-      { id: "AC-1", text: "a" },
-      { id: "AC-2", text: "b", noHandsOn: true },
-    ])
-    const partial = "## Acceptance criteria\n\n- a\n- AC-7 (no hands-on): b\n"
-    expect(statedCriteria([added("TODO.md", partial)], "abc")?.criteria).toEqual([
-      { id: "AC-1", text: "a" },
-      { id: "AC-2", text: "b", noHandsOn: true },
-    ])
-  })
-
   it("renumbers when the stated IDs are partial or clash", () => {
     const sketch = [added("TODO.md", "## Acceptance criteria\n\n- AC-4: a\n- b\n")]
     expect(statedCriteria(sketch, "abc")?.criteria).toEqual([
@@ -144,15 +113,6 @@ describe("criterionIds", () => {
   })
 })
 
-describe("handsOnIds", () => {
-  const requirements =
-    "## Acceptance Criteria\n\n- AC-1: a\n- AC-2 (no hands-on): b\n- AC-3: c\n- AC-4 (no hands-on): d\n"
-
-  it("leaves out every criterion tagged (no hands-on)", () => {
-    expect(handsOnIds(requirements)).toEqual(["AC-1", "AC-3"])
-  })
-})
-
 describe("unstableIds", () => {
   const ids = { closed: ["AC-1", "AC-3"], used: ["AC-1", "AC-2", "AC-3"] }
 

package/src/workflows/feature/criteria.ts

@@ -17,8 +17,6 @@ import * as t from "../shared/text.js"
 export interface Criterion {
   readonly id: string
   readonly text: string
-  /** Tagged `(no hands-on)`: its tests prove it, so the hands-on test skips it. */
-  readonly noHandsOn?: true
 }
 
 /** Acceptance criteria the human's sketch stated outright, ready to normalise. */
@@ -33,13 +31,9 @@ export interface StatedCriteria {
 /** Below this the judge's `yes` is not trusted: a wrong skip builds against criteria nobody can check. */
 const CLEAR_MIN_P = 0.8
 
-const ID = /^(AC-\d+)(\s*\(no hands-on\))?:\s*(.*)$/
+const ID = /^(AC-\d+):\s*(.*)$/
 
-const criterion = (id: RegExpExecArray, as = id[1]!): Criterion => ({
-  id: as,
-  text: id[3]!,
-  ...(id[2] === undefined ? {} : { noHandsOn: true }),
-})
+const criterion = (id: RegExpExecArray, as = id[1]!): Criterion => ({ id: as, text: id[2]! })
 
 /** The list items under the first heading `title` matches (at `level` when given), up to the next heading; wrapped lines joined, fenced lines ignored. */
 const listUnder = (text: string, title: RegExp, level?: number): string[] | undefined => {
@@ -83,12 +77,6 @@ export const criteriaOf = (text: string): readonly Criterion[] | undefined =>
 export const criterionIds = (text: string): string[] =>
   (criteriaOf(text) ?? []).map((c) => c.id).filter((id) => id !== "")
 
-/** The ID'd criteria of `text` a person can try by hand: none tagged `(no hands-on)`. */
-export const handsOnIds = (text: string): string[] => {
-  const tagged = (criteriaOf(text) ?? []).filter((c) => c.noHandsOn).map((c) => c.id)
-  return criterionIds(text).filter((id) => !tagged.includes(id))
-}
-
 /** Items numbered `AC-1`…, unless every one already carries its own distinct ID. */
 const numbered = (items: readonly string[]): Criterion[] => {
   const ids = items.map((item) => ID.exec(item))

package/src/workflows/feature/fast-path.feature

@@ -8,7 +8,6 @@ Feature: a trivial change takes the same few beats at either risk tier
 
   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 "correctness"
     And an environment variable "GTD_FLAG_RISK_TIER" set to "1"
     And a file "src/greeting.ts" with:

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

@@ -9,9 +9,9 @@ import {
   start,
 } from "../../flows/index.js"
 import { gate } from "../shared/health.js"
-import { flagModeOn, shipped } from "../shared/options.js"
+import { flagModeOn, naiveTestOn, 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,20 +22,18 @@ import {
   type StatedCriteria,
 } from "./criteria.js"
 import { design } from "./planning.js"
-import { buildTail, humanReview, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
-import { prototypeRounds } from "./prototype.js"
+import { buildTail, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
 import { implement, implementing, seamBuild } from "./seam.js"
 import { recordRisk, riskTierOn } from "./tier.js"
 
 // The ordinary start. Any change to the tree starts a process: `idle` →
 // `unwind` reverts the sketch (its intent survives in history) → a
-// green-baseline gate → design → a naive pass, judged with `flagMode` on: it
+// green-baseline gate → design → a naive pass, tried by a person with
+// `naiveTest` on and 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.
+// built fresh from → the health loop → 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 +72,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 +83,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 +104,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",
+    })
   }
 }
 
@@ -149,7 +140,7 @@ export const ordinaryStart = async (): Promise<void> => {
   refusePendingHandOff()
   // Read right after idle, so a bad value refuses the landing that would pin it.
   flagModeOn()
-  prototypeRounds()
+  naiveTestOn()
   const stated = statedCriteria(changes(), head())
   await unwind()
   if (changes(FEEDBACK).some((c) => c.status !== "deleted")) {

package/src/workflows/feature/flag-mode.feature

@@ -11,7 +11,7 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       """
       import { feature } from "@pmelab/gtd/workflows/feature"
       export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
-      export default feature({ flagMode: false, prototypeRounds: "0" })
+      export default feature({ flagMode: false })
       """
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And a file "src/calc.ts" with:

package/src/workflows/feature/lens-models.feature

@@ -12,7 +12,6 @@ Feature: each quality lens runs on its own model hint
       export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
       export default feature({
         flagMode: false,
-        prototypeRounds: "0",
         qualityReviews: "correctness, conventions, test-audit=opus",
       })
       """