@pmelab/gtd 49.0.0 → 51.0.0

package/src/workflows/shared/review.ts

@@ -70,10 +70,15 @@ interface Severity {
   readonly reason: string
   /** Capture order: 0 one-way door, 1 new concept, 2 everything else. */
   readonly rank: 0 | 1 | 2
+  readonly security?: true
 }
 
 /** Anything unanswered, unrecognised, cut or below `minP` is `critical`, never `could`. */
-export const severityOf = (note: ReviewNote, judgment: Judgment, minP: number): Severity => {
+export const severityOf = (
+  note: { readonly id: string; readonly forced?: boolean | undefined },
+  judgment: Judgment,
+  minP: number,
+): Severity => {
   const ans = (q: string) => judgment.answers[`${note.id}.${q}`]
   const a = (q: string): string | undefined => ans(q)?.answer
   const rank = (): 0 | 1 | 2 =>
@@ -90,7 +95,12 @@ export const severityOf = (note: ReviewNote, judgment: Judgment, minP: number):
     ...(a("reversibility") === "one-way" ? ["one-way door"] : []),
   ]
   if (critical.length > 0)
-    return { tier: "critical", reason: `critical: ${critical.join(", ")}`, rank: rank() }
+    return {
+      tier: "critical",
+      reason: `critical: ${critical.join(", ")}`,
+      rank: rank(),
+      ...(a("security") === "yes" ? { security: true as const } : {}),
+    }
   const should = [
     ...(a("blastRadius") === "contract" ? ["contract"] : []),
     ...(a("newConcept") === "yes" ? ["new concept"] : []),
@@ -100,31 +110,32 @@ export const severityOf = (note: ReviewNote, judgment: Judgment, minP: number):
   return { tier: "could", reason: "could", rank: 2 }
 }
 
-const severityQuestions = (note: ReviewNote): JudgeQuestion[] => [
+/** `asks` names the change in full, `change` refers back to it. */
+const severityQuestions = (id: string, asks: string, change: string): JudgeQuestion[] => [
   {
-    id: `${note.id}.security`,
+    id: `${id}.security`,
     primitive: "noul",
-    instructions: `Does the change the human asks for in note "${note.id}" (on "${note.anchor}") touch security — authentication, authorisation, secrets, untrusted input or data exposure?`,
+    instructions: `Does ${asks} touch security — authentication, authorisation, secrets, untrusted input or data exposure?`,
     criteria: "yes: it changes or could weaken a security property. no: it does not.",
   },
   {
-    id: `${note.id}.reversibility`,
+    id: `${id}.reversibility`,
     primitive: "choice",
-    instructions: `Once the change in note "${note.id}" ships, can it be undone without breaking anyone who already depends on it?`,
+    instructions: `Once ${change} ships, can it be undone without breaking anyone who already depends on it?`,
     criteria:
       "one-way: a published API, file format, persisted data, protocol or other contract that cannot be taken back. two-way: can be reverted freely.",
   },
   {
-    id: `${note.id}.blastRadius`,
+    id: `${id}.blastRadius`,
     primitive: "choice",
-    instructions: `How far does the change in note "${note.id}" reach?`,
+    instructions: `How far does ${change} reach?`,
     criteria:
       "local: one function or file. module: a whole module or several files. contract: a public interface other code or users depend on.",
   },
   {
-    id: `${note.id}.newConcept`,
+    id: `${id}.newConcept`,
     primitive: "noul",
-    instructions: `Does the change in note "${note.id}" introduce a concept new to this codebase — a new abstraction, entity or term? Judge from the evidence, never a glossary; reusing or extending an existing concept is not new.`,
+    instructions: `Does ${change} introduce a concept new to this codebase — a new abstraction, entity or term? Judge from the evidence, never a glossary; reusing or extending an existing concept is not new.`,
     criteria: "yes: a genuinely new concept. no: reuses or extends an existing one.",
   },
 ]
@@ -144,7 +155,14 @@ const triage =
       asked.length === 0
         ? { answers: {}, truncated: [] }
         : await judge("review.triage", {
-            questions: asked.flatMap((n) => [verdictQuestion(n), ...severityQuestions(n)]),
+            questions: asked.flatMap((n) => [
+              verdictQuestion(n),
+              ...severityQuestions(
+                n.id,
+                `the change the human asks for in note "${n.id}" (on "${n.anchor}")`,
+                `the change in note "${n.id}"`,
+              ),
+            ]),
             evidence: Object.fromEntries(
               asked.map((n) => [
                 n.id,
@@ -170,6 +188,91 @@ const triage =
     )
   }
 
+/** Review order: security, one-way doors, the judge unsure, then should, then could. */
+const chunkKey = (s: Severity): number =>
+  s.tier === "could" ? 4 : s.tier === "should" ? 3 : s.security === true ? 0 : s.rank === 0 ? 1 : 2
+
+type Pointer = ReturnType<typeof reviewChunks>[number]["files"][number]
+
+/** A chunk's text, then the code each of its pointers covers: a bare path the whole file. */
+const chunkEvidence = (text: string, files: readonly Pointer[]): string =>
+  [
+    text,
+    ...files.map(({ path, line, rangeEnd }) => {
+      const where = `${path}${line === undefined ? "" : `#${line}${rangeEnd === undefined ? "" : `-${rangeEnd}`}`}`
+      const lines = read(path.replace(/^\.\//, ""))?.split("\n")
+      if (lines === undefined) return `${where}: no longer exists`
+      const code = line === undefined ? lines : lines.slice(line - 1, rangeEnd ?? line)
+      return `${where}:\n${code.join("\n")}`
+    }),
+  ].join("\n\n")
+
+const bytes = (text: string): number => new TextEncoder().encode(text).length
+
+/** Fills each batch while the budget's even share still holds its widest evidence, so nothing is cut that fits alone. */
+const batched = <T extends { readonly evidence: string }>(
+  items: readonly T[],
+  budget: number,
+): T[][] => {
+  const batches: T[][] = []
+  let batch: T[] = []
+  let widest = 0
+  for (const item of items) {
+    const size = bytes(item.evidence)
+    if (batch.length > 0 && Math.floor(budget / (batch.length + 1)) < Math.max(widest, size)) {
+      batches.push(batch)
+      batch = []
+      widest = 0
+    }
+    batch.push(item)
+    widest = Math.max(widest, size)
+  }
+  return batch.length === 0 ? batches : [...batches, batch]
+}
+
+/**
+ * Rates every chunk the reviewer wrote — a walkthrough chunk or a carried
+ * finding — and sorts \`full\` by it, each chunk led by its tier and reason.
+ * gtd's summary chunks are not rated and stay last.
+ */
+const ranked = async (review: string, full: string): Promise<string> => {
+  const texts = t.chunkTexts(full)
+  const chunks = reviewChunks(review).map((c, i) => ({
+    id: `C${i + 1}`,
+    title: c.title,
+    evidence: chunkEvidence(texts.get(c.title) ?? "", c.files),
+  }))
+  if (chunks.length === 0) return full
+  const minP = numeric(vars.reviewSeverityMinP, Infinity)
+  const batches = batched(chunks, numeric(vars.judgeBudgetBytes, 32768))
+  const severities = new Map<string, Severity>()
+  for (const [i, batch] of batches.entries()) {
+    const judgment = await judge("review.ranking", {
+      questions: batch.flatMap((c) =>
+        severityQuestions(
+          c.id,
+          `the change review chunk "${c.id}" ("${c.title}") walks through`,
+          `the change in review chunk "${c.id}"`,
+        ),
+      ),
+      evidence: Object.fromEntries(batch.map((c) => [c.id, c.evidence])),
+      message: t.reviewRankingMessage(),
+      label:
+        batches.length === 1
+          ? "Ranking the review"
+          : `Ranking the review (${i + 1}/${batches.length})`,
+    })
+    for (const c of batch) severities.set(c.id, severityOf(c, judgment, minP))
+  }
+  return t.rankedReview(
+    full,
+    chunks
+      .map((c, i) => ({ c, i, s: severities.get(c.id)! }))
+      .sort((x, y) => chunkKey(x.s) - chunkKey(y.s) || x.i - y.i)
+      .map(({ c, s }) => ({ title: c.title, label: s.reason })),
+  )
+}
+
 export const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".gtd/")
 
 const composedOf = (
@@ -263,18 +366,21 @@ const walkthrough = async (
 ): Promise<void> => {
   const notes = t.titledNotes(report)
   await reviewing(base, carry, lap, t.walkthroughBlock(notes, report.nitFix))
-  const review = read(REVIEW)
+  const written = read(REVIEW)
   // A review the reviewer did not write is the round's own refusal or rest.
-  if (review === undefined) return
+  if (written === undefined) return
+  const review = t.unranked(written)
+  // Against the file as written, so a refusal's line numbers match it.
   requirePointers(
-    review,
+    written,
     notes,
     changesSince(base).some((c) => isCode(c.path)),
   )
-  const full = t.withWalkthrough(review, report)
-  if (full !== review) {
+  // Ranked even when it marks risks: the review written after their fix reaches the human with its own.
+  const full = await ranked(review, t.withWalkthrough(review, report))
+  if (full !== written) {
     await run("review.carrying", writeScript(REVIEW, full), {
-      label: "Adding the quality lap's findings",
+      label: "Ordering the review and adding the quality lap's findings",
       file: REVIEW,
       base,
     })

package/src/workflows/shared/skills.test.ts

@@ -29,6 +29,10 @@ describe("the bundled workflow's skills export", () => {
         "implement",
         "implement.fix.suite",
         "implement.health",
+        "implement.prototype",
+        "implement.prototype.fix",
+        "implement.prototype.fix.suite",
+        "implement.prototype.health",
         "build.quality.correctness",
         "build.quality.owasp-security",
         "build.quality.ponytail-review",

package/src/workflows/shared/skills.ts

@@ -33,6 +33,11 @@ export const skills = (
     seam: ["incremental-implementation"],
     implement: ["test-driven-development", "incremental-implementation"],
     "implement.fix.suite": ["debugging-and-error-recovery"],
+    // The hands-on tester runs the program, never the suite: no TDD.
+    "implement.prototype": [],
+    "implement.prototype.fix": ["test-driven-development", "incremental-implementation"],
+    "implement.prototype.fix.suite": ["debugging-and-error-recovery"],
+    "implement.prototype.health": ["debugging-and-error-recovery"],
     // `health` is shared code reached from both `implement` and `build`.
     "implement.health": ["debugging-and-error-recovery"],
     ...lensScopes(

package/src/workflows/shared/steps.ts

@@ -16,6 +16,7 @@ export const REFACTOR_NOTE = ".gtd/REFACTOR-NOTE.md"
 export const QUALITY = ".gtd/QUALITY.md"
 export const SLICES = ".gtd/SLICES.md"
 export const HANDOFF = ".gtd/HANDOFF.md"
+export const PROTOTYPE = ".gtd/PROTOTYPE.md"
 
 export const planner = (): string => env.plannerModel ?? ""
 export const coder = (): string => env.coderModel ?? ""

package/src/workflows/shared/text.test.ts

@@ -33,6 +33,8 @@ import {
   titledNotes,
   walkthroughBlock,
   withWalkthrough,
+  rankedReview,
+  unranked,
 } from "./text.js"
 import { reviewDecisions, steeringFormatFor, unansweredNotes } from "../../steering/index.js"
 import { captureStep, renderText } from "./text.fixture.js"
@@ -1517,3 +1519,91 @@ describe("walkthrough", () => {
     )
   })
 })
+
+describe("rankedReview", () => {
+  const review = [
+    "# Review: abc1234",
+    "",
+    "<!-- base: abc1234 -->",
+    "",
+    "## Rename",
+    "",
+    "- [ ] ./a.ts#1-1",
+    "",
+    "## Token",
+    "",
+    "_could_",
+    "",
+    "Reads the token.",
+    "",
+    "- [ ] ./a.ts#2-2",
+    "",
+    "## Fixed automatically",
+    "",
+    "- x (abc1234)",
+    "",
+  ].join("\n")
+
+  it("puts the ranked chunks first, each led by its tier, and leaves the rest in place", () => {
+    expect(
+      rankedReview(unranked(review), [
+        { title: "Token", label: "critical: security" },
+        { title: "Rename", label: "could" },
+      ]),
+    ).toBe(
+      [
+        "# Review: abc1234",
+        "",
+        "<!-- base: abc1234 -->",
+        "",
+        "## Token",
+        "",
+        "_critical: security_",
+        "",
+        "Reads the token.",
+        "",
+        "- [ ] ./a.ts#2-2",
+        "",
+        "## Rename",
+        "",
+        "_could_",
+        "",
+        "- [ ] ./a.ts#1-1",
+        "",
+        "## Fixed automatically",
+        "",
+        "- x (abc1234)",
+        "",
+      ].join("\n"),
+    )
+  })
+
+  it("keeps a setext heading whole", () => {
+    expect(
+      rankedReview("# Review: a\n\nToken\n-----\n\n- [ ] ./a.ts#1\n", [
+        { title: "Token", label: "could" },
+      ]),
+    ).toBe("# Review: a\n\nToken\n-----\n\n_could_\n\n- [ ] ./a.ts#1\n")
+  })
+
+  it("keeps a chunk's leading indented code block indented", () => {
+    const code = "# Review: abc1234\n\n## Code\n\n    const x = 1\n\n- [ ] ./a.ts#1-1\n"
+    expect(rankedReview(code, [{ title: "Code", label: "could" }])).toContain(
+      "_could_\n\n    const x = 1",
+    )
+  })
+
+  it("drops a stale tier with no blank line under the heading, never a longer paragraph", () => {
+    expect(unranked("## A\n_could_\n\nbody\n")).toBe("## A\nbody\n")
+    expect(unranked("## A\n\n_could_\n- [ ] ./a.ts#1\n")).toBe("## A\n\n- [ ] ./a.ts#1\n")
+    const code = "## A\n\n    _could_\n"
+    expect(unranked(code)).toBe(code)
+    const prose = "## A\n\n_should: x_\nruns on\n"
+    expect(unranked(prose)).toBe(prose)
+  })
+
+  it("drops a stale tier, so a re-review is ranked afresh", () => {
+    expect(unranked(review)).not.toContain("_could_")
+    expect(unranked(unranked(review))).toBe(unranked(review))
+  })
+})

package/src/workflows/shared/text.ts

@@ -19,6 +19,7 @@ import {
   ANSWER_WONT_FIX,
   FREE_TEXT_PLACEHOLDER,
   reviewChunks,
+  severityLine,
 } from "../../steering/index.js"
 import { escapeRegExp } from "./registry.js"
 import {
@@ -40,6 +41,7 @@ import {
   reviewerPersona,
   builderPersona,
   finisherPersona,
+  testerPersona,
   escalationPersona,
   stateFileRules,
   questionBar,
@@ -301,12 +303,78 @@ export const withWalkthrough = (review: string, report: ComposedReview): string
           `## ${unique("Dropped as noise")}\n\n${report.noise.map((f) => noiseLine(f, carriedOnly(f))).join("\n")}`,
         ]),
   ]
-  // Nothing to add leaves the review byte for byte, so no carrying step runs.
+  // Nothing to add leaves the review byte for byte.
   if (notes.size === listed && summary.length === 0) return review
   const body = lines.join("\n").trimEnd()
   return summary.length === 0 ? `${body}\n` : `${body}\n\n${summary.join("\n\n")}\n`
 }
 
+export interface RankedChunk {
+  readonly title: string
+  readonly label: string
+}
+
+const chunkBlocks = (
+  review: string,
+): { head: string[]; blocks: { title: string; lines: string[] }[] } => {
+  const lines = review.split("\n")
+  const chunks = reviewChunks(review)
+  return {
+    head: lines.slice(0, chunks[0]?.line ?? lines.length),
+    blocks: chunks.map((c, i) => ({
+      title: c.title,
+      lines: lines.slice(c.line, chunks[i + 1]?.line ?? lines.length),
+    })),
+  }
+}
+
+const isBlank = (line: string | undefined): boolean => line !== undefined && line.trim() === ""
+
+/** \`review\` with every chunk's severity line removed, so a re-review is ranked afresh. */
+export const unranked = (review: string): string => {
+  const drop = new Set(reviewChunks(review).flatMap((c) => c.severityLine ?? []))
+  if (drop.size === 0) return review
+  const lines = review.split("\n")
+  return lines.filter((_, i) => !drop.has(i) && !(drop.has(i - 1) && isBlank(lines[i]))).join("\n")
+}
+
+export const chunkTexts = (review: string): ReadonlyMap<string, string> =>
+  new Map(chunkBlocks(review).blocks.map((b) => [b.title, b.lines.join("\n").trim()]))
+
+// Blank lines only: a chunk opening with an indented code block keeps its indent.
+const trimBlankLines = (lines: readonly string[]): string[] => {
+  let start = 0
+  let end = lines.length
+  while (start < end && isBlank(lines[start])) start++
+  while (end > start && isBlank(lines[end - 1])) end--
+  return lines.slice(start, end)
+}
+
+/**
+ * \`review\` with the \`ranked\` chunks first, in their order, each led by its
+ * severity line; every other chunk follows in place.
+ */
+export const rankedReview = (review: string, ranked: readonly RankedChunk[]): string => {
+  const { head, blocks } = chunkBlocks(review)
+  const place = new Map(ranked.map((r, k) => [r.title, k]))
+  const labels = new Map(ranked.map((r) => [r.title, r.label]))
+  const order = (i: number): number => place.get(blocks[i]!.title) ?? ranked.length
+  const chunk = (i: number): string => {
+    const { title, lines } = blocks[i]!
+    const label = labels.get(title)
+    // A setext heading is its title line and its underline.
+    const heading = /^ {0,3}-+\s*$/.test(lines[1] ?? "") ? 2 : 1
+    const body = trimBlankLines(lines.slice(heading)).join("\n")
+    return [
+      lines.slice(0, heading).join("\n"),
+      ...(label === undefined ? [] : [severityLine(label)]),
+      ...(body === "" ? [] : [body]),
+    ].join("\n\n")
+  }
+  const sorted = blocks.map((_, i) => i).sort((x, y) => order(x) - order(y) || x - y)
+  return `${[head.join("\n").trim(), ...sorted.map(chunk)].filter((p) => p !== "").join("\n\n")}\n`
+}
+
 /**
  * \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, each ending in its
  * answer boxes, then the fixed and noise lists. Chunk titles are made unique —
@@ -418,8 +486,11 @@ const acceptanceCriteriaBlock = `
 Whichever lap this is, \`.gtd/REQUIREMENTS.md\` carries a
 \`## Acceptance Criteria\` section: one \`- AC-<n>: <criterion>\` line
 per criterion, numbered from \`AC-1\`. They bind every later step —
-the build is done when each one holds — so each must be checkable: a
-test or a command shows it holds or not. A later lap keeps every ID:
+the build is done when each one holds — so each must be behaviour a
+test can pin: one that fails when it does not hold. A green suite, a
+passing typecheck or lint, a generator or build that runs — the health
+check enforces those on every lap, so none is a criterion; fold what it
+must produce into a behaviour a test can observe. A later lap keeps every ID:
 reword a criterion in place, append a new one with the next unused
 number, delete a dropped one — never renumber, never reuse an ID. When
 the file holds no list (a review loop-back rewrites it), recover the
@@ -533,7 +604,7 @@ export const clearCriteriaQuestion: JudgeQuestion = {
   instructions:
     "state.criteria lists the acceptance criteria the human's sketch (state.sketch) stated, as gtd numbered them. Decide whether they can stand as the binding definition of done, with no design conversation.",
   criteria:
-    "yes: every criterion is clear and checkable — a test or a command can show it holds or not — and together they say what to build. no: any one criterion is vague, subjective or untestable, or the sketch leaves an open product question. Unsure means no.",
+    "yes: every criterion is clear behaviour a test can pin — a test would fail if it did not hold — and together they say what to build. no: any one criterion is vague, subjective or untestable, only a command can check it (a suite, typecheck, lint, build or generator run that passes), or the sketch leaves an open product question. Unsure means no.",
 }
 
 export const clearCriteriaMessage = (): string =>
@@ -1074,6 +1145,15 @@ const wrapItem = (item: string): string[] => {
   return [...out, line]
 }
 
+export const reviewRankingMessage = (): string =>
+  `Ranking each chunk of the review before the human reads it. Run
+\`gtd judge answer\` and pipe, per chunk \`C<n>\`: \`C<n>.security\`
+(yes/no), \`C<n>.reversibility\` (one-way/two-way),
+\`C<n>.blastRadius\` (local/module/contract) and \`C<n>.newConcept\`
+(yes/no) — or land without a verdict, which lists every chunk as
+critical.
+`
+
 export const buildReviewTriageMessage = (): string =>
   `Judging each note the human added to \`.gtd/REVIEW.md\` (a line note, a
 footnote, or prose under a chunk) with one verdict: \`edit\` (a change
@@ -1904,3 +1984,100 @@ Two ways forward (then run \`gtd land\`):
 - **Overrule** — land a clean tree to finish without them. The slice records
   the IDs it covers and, as \`uncovered\`, the ones it does not
 `
+
+export const testerSystem = (): string =>
+  `${testerPersona}
+
+${agentConduct}`
+
+const PROTOTYPE_FORMAT = `- Write \`.gtd/PROTOTYPE.md\`, replacing any earlier report: one \`## \` chunk
+  per criterion, headed \`## AC-<n>: pass\`, \`## AC-<n>: fail\` or
+  \`## AC-<n>: blocked\`, then one chunk per problem you found outside any
+  criterion, headed \`## Problem <short title>: fail\` (\`: pass\` once a
+  re-test shows it fixed). Under each: the exact steps you ran, what you
+  observed (output, a screenshot path, the error), and for a failure what
+  you expected instead
+- \`blocked\` is for a criterion you could not exercise, or one whose
+  expected behaviour itself looks wrong — say which and why: a person
+  decides it, never a fixer`
+
+export const prototypeTestingPrompt = (
+  slice: readonly string[] | undefined,
+  retest: boolean,
+): string =>
+  `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
+${sliceLine(slice)}- The change is built and its suite is green. Now test it by hand: use
+  every acceptance criterion the way a person would and watch what
+  happens. Running the test suite is not this — it already ran
+- Find how this project is exercised for real, in this order: a project
+  skill that launches or drives it (e.g. \`.claude/skills/*\`); a manual
+  testing or running section in \`AGENTS.md\`, \`CLAUDE.md\` or \`README.md\`;
+  failing those, the project's shape — a browser or Playwright for a web
+  project, the built CLI in a scratch directory for a CLI, a request client
+  for an API
+- Found none and recognised no shape: write only a chunk headed
+  \`## No testing instructions\` saying what you looked for, and finish —
+  a person is asked; never guess
+- Test in a disposable place only — a scratch directory outside this
+  repository, a throwaway repository, a dev server on a free port — never
+  against the user's real data or this working tree. Point every tool's
+  output (screenshots, traces, test results) outside the repository too
+${
+  retest
+    ? `- This is a re-test: \`.gtd/PROTOTYPE.md\` holds the last round's report and
+  a fix turn or a person has changed the code since. Re-test every failed or blocked criterion and
+  every problem it lists in full, then re-run the passed ones quickly
+`
+    : ""
+}${PROTOTYPE_FORMAT}
+- Change nothing but \`.gtd/PROTOTYPE.md\` — a turn that does is refused
+- Leave everything uncommitted and finish your turn — do not commit
+`
+
+export const prototypeFixingPrompt = (slice: readonly string[] | undefined): string =>
+  `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
+${sliceLine(slice)}${criteriaBinding(true)}
+- Read \`.gtd/PROTOTYPE.md\`: a hands-on test of the change. Fix every
+  \`fail\` chunk of this change's criteria${slice === undefined ? "" : " (this slice's only)"} or a problem found
+  beside them, at its cause, with a test that shows it; leave \`blocked\`
+  ones to the person
+- A \`fail\` the code does not explain (the tester misread what it saw) has
+  nothing to fix: leave it and change nothing for it — the next round re-tests
+- Leave \`.gtd/PROTOTYPE.md\` as it is: the next round re-tests from it
+- Run \`${env.testCommand}\` and finish only once it is green
+- Leave everything uncommitted and finish your turn — do not commit
+`
+
+const openItems = (items: readonly { subject: string; verdict: string }[]): string =>
+  items.map((item) => `- ${item.subject}: ${item.verdict}`).join("\n")
+
+export const prototypeOpenMessage = (
+  items: readonly { subject: string; verdict: string }[],
+  rounds: number,
+): string =>
+  `The hands-on test of this slice still has open items${rounds > 0 ? ` after ${rounds} fix round${rounds === 1 ? "" : "s"}` : ", and none a fixer can take"}:
+${openItems(items)}
+
+\`.gtd/PROTOTYPE.md\` holds the last report: the steps run and what was seen.
+
+Two ways forward (then run \`gtd land\`):
+- **Fix** — change the code, or the testing instructions, yourself (the
+  criteria are settled: an edit to them is refused); the suite runs and the
+  slice is tested again, with a fresh round budget
+- **Overrule** — land a clean tree to go on to the quality lap with these
+  items open
+`
+
+export const prototypeUnguidedMessage = (): string =>
+  `The hands-on test found no way to exercise this project for real — no
+project skill, no manual testing section in \`AGENTS.md\`, \`CLAUDE.md\` or
+\`README.md\`, and no project shape it recognised. \`.gtd/PROTOTYPE.md\` says
+what it looked for.
+
+Two ways forward (then run \`gtd land\`):
+- **Instruct** — add testing instructions (a project skill, or a manual
+  testing section); the slice is tested again
+- **Skip** — land a clean tree to go on to the quality lap untested
+`

package/src/workflows/shared/vars.ts

@@ -41,6 +41,9 @@ export const defaults: Readonly<Record<string, string>> = {
   // stopped at its context limit before a person is asked, and how many in a
   // row may close nothing still open.
   continuations: "3",
+  // Fix-and-retest rounds of a slice's prototype test before a person is
+  // asked; "0" skips the test.
+  prototypeRounds: "3",
   continuationStall: "2",
 }