@pmelab/gtd 49.0.0 → 51.0.0

package/dist/workflows.mjs

@@ -15648,6 +15648,9 @@ const qaDescriptor = {
 const ANSWER_LEAD = "Tick exactly one:";
 const ANSWER_FIX = "fix as suggested";
 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]*)?)_$/;
+const severityLine = (label) => `_${label}_`;
 /**
 * The canonical sample. Every detail here is load-bearing for the formatter
 * round-trip: both footnote bodies exceed 80 characters so a reflow actually
@@ -15938,12 +15941,26 @@ const answerListOf = (content, body) => {
 		})
 	};
 };
+/** A leading severity line is the chunk's tier, never its prose. */
+const splitSeverity = (content, run) => {
+	const first = run[0];
+	const label = first?.type === "paragraph" ? SEVERITY_LINE_RE.exec(sourceText(content, first).trim())?.[1] : void 0;
+	if (label === void 0) return { leadingRun: run };
+	return {
+		severity: {
+			label,
+			line: toLspPosition(first.position.start).line
+		},
+		leadingRun: run.slice(1)
+	};
+};
 /** Splits one chunk's body nodes into its file pointers (hunk pointers are task items, collected recursively at ANY nesting depth via `taskItems` — a nested hunk is the same kind of hunk as a top-level one) and description prose. The description is the chunk's own leading run and never a node that contains a hunk pointer: it stops at the first node whose `taskItems` include a real pointer (at any depth — a blockquote wrapping a pointer list stops it just as a top-level list would). Every node kind in what's left before that point contributes — a `footnoteDefinition` is the one exception, excluded by `blockNodesOfRun` itself (it's a note, never document content). */
 const parseChunkBody = (content, lines, title, body) => {
 	const answer = answerListOf(content, body);
 	const isAnswer = (n) => answer !== void 0 && (n === answer.list || n === body[answer.lead]);
 	const firstPointerIndex = body.findIndex((n) => !isAnswer(n) && taskItems(n).some((item) => hasPointerToken(content, item)));
-	const leadingRun = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter((n) => !isAnswer(n));
+	const run = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter((n) => !isAnswer(n));
+	const { severity, leadingRun } = splitSeverity(content, run);
 	const descriptionNodes = blockNodesOfRun(content, leadingRun);
 	const descriptionInline = collapseImages(blockRunInline(content, leadingRun));
 	const description = leadingRun.filter((n) => n.type !== "footnoteDefinition").map((n) => sourceText(content, n)).join(" ").trim();
@@ -15962,6 +15979,7 @@ const parseChunkBody = (content, lines, title, body) => {
 		files,
 		errors,
 		...answer === void 0 ? {} : { answers: answer.options },
+		...severity === void 0 ? {} : { severity },
 		boxed: body.some((n) => !isAnswer(n) && taskItems(n).length > 0)
 	};
 };
@@ -15998,7 +16016,7 @@ const parseChangesets = (tree, content, lines) => {
 	const errors = [];
 	for (const { heading, headingLine, body } of splitChunks(tree)) {
 		const title = headingText$1(content, heading);
-		const { description, descriptionNodes, descriptionInline, files, answers, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
+		const { description, descriptionNodes, descriptionInline, files, answers, severity, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
 		errors.push(...bodyErrors);
 		if (files.length === 0 && boxed) errors.push({
 			message: `Chunk "${title}" has no file pointers`,
@@ -16012,7 +16030,8 @@ const parseChangesets = (tree, content, lines) => {
 			descriptionInline,
 			files,
 			headingLine,
-			...answers === void 0 ? {} : { answers }
+			...answers === void 0 ? {} : { answers },
+			...severity === void 0 ? {} : { severity }
 		});
 	}
 	if (changesets.length === 0) errors.push({ message: "REVIEW.md has no '##' chunks" });
@@ -16313,6 +16332,7 @@ const reviewView = (content) => {
 			detail: chunk.description,
 			detailInline: chunk.descriptionInline,
 			body: chunk.descriptionNodes,
+			...chunk.severity === void 0 ? {} : { status: chunk.severity.label },
 			anchor: {
 				kind: "chunk",
 				index: chunkIndex
@@ -16460,15 +16480,19 @@ const reviewDescriptor = {
 	openThreads: openThreadsOf
 };
 const pointerLabel = (f) => `${f.path}${f.line === void 0 ? "" : `#${f.line}${f.rangeEnd === void 0 ? "" : `-${f.rangeEnd}`}`}`;
-const chunkNote = (chunk, prior) => chunk.description === (prior?.description ?? "") || prior === void 0 && chunk.answers !== void 0 ? [] : [{
-	line: chunk.headingLine,
-	note: {
-		kind: "chunk",
-		anchor: chunk.title,
-		before: prior?.description ?? "",
-		text: chunk.description
-	}
-}];
+const chunkProse = (chunk, retiered) => [chunk?.description ?? "", retiered && chunk?.severity !== void 0 ? severityLine(chunk.severity.label) : ""].filter((p) => p !== "").join("\n\n");
+const chunkNote = (chunk, prior) => {
+	const retiered = chunk.severity !== void 0 && chunk.severity.label !== prior?.severity?.label;
+	return chunkProse(chunk, retiered) === chunkProse(prior, retiered) || prior === void 0 && chunk.answers !== void 0 ? [] : [{
+		line: chunk.headingLine,
+		note: {
+			kind: "chunk",
+			anchor: chunk.title,
+			before: chunkProse(prior, retiered),
+			text: chunkProse(chunk, retiered)
+		}
+	}];
+};
 const pointerNotes = (chunk, prior) => chunk.files.flatMap((file) => {
 	const label = pointerLabel(file);
 	const was = prior?.files.find((f) => pointerLabel(f) === label);
@@ -16582,7 +16606,13 @@ const reviewDecisions = (before, after) => {
 const reviewChunks = (content) => parseReviewDoc(content).changesets.map((c) => ({
 	title: c.title,
 	line: c.headingLine,
-	pointers: c.files.length
+	pointers: c.files.length,
+	...c.severity === void 0 ? {} : { severityLine: c.severity.line },
+	files: c.files.map((f) => ({
+		path: f.path,
+		...f.line === void 0 ? {} : { line: f.line },
+		...f.rangeEnd === void 0 ? {} : { rangeEnd: f.rangeEnd }
+	}))
 }));
 //#endregion
 //#region src/steering/CodeThreads.ts
@@ -17211,6 +17241,7 @@ const defaults = {
 	qualityReviews: "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge",
 	refactorQualityReviews: "correctness, ponytail-review, conventions",
 	continuations: "3",
+	prototypeRounds: "3",
 	continuationStall: "2"
 };
 /** Environment settings. */
@@ -17288,6 +17319,11 @@ task in front of you end to end, tests first, and come back to fix
 things when redirected — a failing check, or reviewer feedback. Stay
 strictly inside that task; never touch code outside it. Treat feedback as the
 diagnosis to act on; discard it, with reason, only when simply wrong.`;
+const testerPersona = `You are the hands-on tester in gtd's build pipeline: use what was just
+built the way a person would — run the real program, open the real
+page, call the real endpoint — and report exactly what you did and
+what you saw. Never fix anything yourself, and never pass a criterion
+you did not watch hold.`;
 const finisherPersona = `You are the closing identity in gtd's build pipeline — the last coder
 before it closes. Fix a late-breaking failing check after sign-off,
 focused and minimal. Every turn lands its own commit — nothing here
@@ -17609,6 +17645,56 @@ const withWalkthrough = (review, report) => {
 	const body = lines.join("\n").trimEnd();
 	return summary.length === 0 ? `${body}\n` : `${body}\n\n${summary.join("\n\n")}\n`;
 };
+const chunkBlocks = (review) => {
+	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) => line !== void 0 && line.trim() === "";
+/** \`review\` with every chunk's severity line removed, so a re-review is ranked afresh. */
+const unranked = (review) => {
+	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");
+};
+const chunkTexts = (review) => new Map(chunkBlocks(review).blocks.map((b) => [b.title, b.lines.join("\n").trim()]));
+const trimBlankLines = (lines) => {
+	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.
+*/
+const rankedReview = (review, ranked) => {
+	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) => place.get(blocks[i].title) ?? ranked.length;
+	const chunk = (i) => {
+		const { title, lines } = blocks[i];
+		const label = labels.get(title);
+		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 === void 0 ? [] : [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 —
@@ -17663,8 +17749,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
@@ -17772,7 +17861,7 @@ const clearCriteriaQuestion = {
 	id: "clear",
 	primitive: "noul",
 	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."
+	criteria: "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."
 };
 const clearCriteriaMessage = () => `The sketch stated its own acceptance criteria. Run \`gtd judge answer\` and
 pipe \`yes\` when every one is clear and checkable, so design is skipped and
@@ -18163,6 +18252,13 @@ const wrapItem = (item) => {
 	} else line = line === "" ? word : `${line} ${word}`;
 	return [...out, line];
 };
+const reviewRankingMessage = () => `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.
+`;
 const buildReviewTriageMessage = () => `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
 request), \`question\`, \`nit\` (a small fix needing no re-plan) or
@@ -18684,6 +18780,80 @@ 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
 `;
+const testerSystem = () => `${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`;
+const prototypeTestingPrompt = (slice, retest) => `${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
+`;
+const prototypeFixingPrompt = (slice) => `${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 === void 0 ? "" : " (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) => items.map((item) => `- ${item.subject}: ${item.verdict}`).join("\n");
+const prototypeOpenMessage = (items, rounds) => `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
+`;
+const prototypeUnguidedMessage = () => `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
+`;
 //#endregion
 //#region src/workflows/shared/steps.ts
 const FEEDBACK = ".gtd/FEEDBACK.md";
@@ -18695,6 +18865,7 @@ const REFACTOR_NOTE = ".gtd/REFACTOR-NOTE.md";
 const QUALITY = ".gtd/QUALITY.md";
 const SLICES = ".gtd/SLICES.md";
 const HANDOFF = ".gtd/HANDOFF.md";
+const PROTOTYPE = ".gtd/PROTOTYPE.md";
 const planner = () => env.plannerModel ?? "";
 const coder = () => env.coderModel ?? "";
 const fixCheck = (rules) => agentWithSkills("fix", buildFixPrompt(rules), {
@@ -38412,6 +38583,7 @@ const ShippedOptions = Struct({
 	qualityReviews: setting$1,
 	refactorQualityReviews: setting$1,
 	continuations: setting$1,
+	prototypeRounds: setting$1,
 	continuationStall: setting$1,
 	testCommand: setting$1,
 	plannerModel: setting$1,
@@ -39052,7 +39224,8 @@ const severityOf = (note, judgment, minP) => {
 	if (critical.length > 0) return {
 		tier: "critical",
 		reason: `critical: ${critical.join(", ")}`,
-		rank: rank()
+		rank: rank(),
+		...a("security") === "yes" ? { security: true } : {}
 	};
 	const should = [...a("blastRadius") === "contract" ? ["contract"] : [], ...a("newConcept") === "yes" ? ["new concept"] : []];
 	if (should.length > 0) return {
@@ -39066,29 +39239,30 @@ const severityOf = (note, judgment, minP) => {
 		rank: 2
 	};
 };
-const severityQuestions = (note) => [
+/** `asks` names the change in full, `change` refers back to it. */
+const severityQuestions = (id, asks, change) => [
 	{
-		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."
 	}
 ];
@@ -39105,7 +39279,7 @@ const triage$1 = (severities) => async (notes) => {
 		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, `Anchor: ${n.anchor}\nReviewer's text: ${n.before}\nHuman's text: ${n.text}`])),
 		message: buildReviewTriageMessage(),
 		label: "Judging each note"
@@ -39121,6 +39295,67 @@ const triage$1 = (severities) => async (notes) => {
 		return [n.id, "edit"];
 	}));
 };
+/** Review order: security, one-way doors, the judge unsure, then should, then could. */
+const chunkKey = (s) => s.tier === "could" ? 4 : s.tier === "should" ? 3 : s.security === true ? 0 : s.rank === 0 ? 1 : 2;
+/** A chunk's text, then the code each of its pointers covers: a bare path the whole file. */
+const chunkEvidence = (text, files) => [text, ...files.map(({ path, line, rangeEnd }) => {
+	const where = `${path}${line === void 0 ? "" : `#${line}${rangeEnd === void 0 ? "" : `-${rangeEnd}`}`}`;
+	const lines = read(path.replace(/^\.\//, ""))?.split("\n");
+	if (lines === void 0) return `${where}: no longer exists`;
+	return `${where}:\n${(line === void 0 ? lines : lines.slice(line - 1, rangeEnd ?? line)).join("\n")}`;
+})].join("\n\n");
+const bytes = (text) => 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 = (items, budget) => {
+	const batches = [];
+	let batch = [];
+	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, full) => {
+	const texts = 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 = /* @__PURE__ */ new Map();
+	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: 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 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
+	})));
+};
 const isCode$1 = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
 const composedOf = (base, report, nitFix, answered) => ({
 	...report,
@@ -39172,12 +39407,13 @@ const requirePointers = (review, notes, codeChanged) => {
 const walkthrough = async (base, report, lap, carry) => {
 	const notes = titledNotes(report);
 	await reviewing(base, carry, lap, walkthroughBlock(notes, report.nitFix));
-	const review = read(REVIEW);
-	if (review === void 0) return;
-	requirePointers(review, notes, changesSince(base).some((c) => isCode$1(c.path)));
-	const full = withWalkthrough(review, report);
-	if (full !== review) await run("review.carrying", writeScript(REVIEW, full), {
-		label: "Adding the quality lap's findings",
+	const written = read(REVIEW);
+	if (written === void 0) return;
+	const review = unranked(written);
+	requirePointers(written, notes, changesSince(base).some((c) => isCode$1(c.path)));
+	const full = await ranked(review, withWalkthrough(review, report));
+	if (full !== written) await run("review.carrying", writeScript(REVIEW, full), {
+		label: "Ordering the review and adding the quality lap's findings",
 		file: REVIEW,
 		base
 	});
@@ -39597,7 +39833,9 @@ const reviewedRefactor = async (shape, options = {}) => {
 				feedback,
 				fixAccess: strayAccess(p.strays),
 				lensBase: entry,
-				rules: refactorRules(p.strays, p.pattern)
+				rules: refactorRules(p.strays, p.pattern),
+				walkthrough: true,
+				lap: "refactor"
 			});
 			if (outcome.verdict === "signoff") return true;
 			await reUnwind(outcome);
@@ -39612,7 +39850,7 @@ const reviewedRefactor = async (shape, options = {}) => {
 const COVERED_MIN_P = .7;
 /** Covering turns before the process rests at `uncovered`; a human edit there refills them. */
 const COVERING_RETRIES = 2;
-const frozen = () => requireCriteriaFrozen(REQUIREMENTS);
+const frozen$1 = () => requireCriteriaFrozen(REQUIREMENTS);
 const green = (guard) => healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
 	label: "Fixing the check",
 	file: FEEDBACK,
@@ -39620,7 +39858,7 @@ const green = (guard) => healthy(() => agentWithSkills("fix.suite.fixing", imple
 	system: builderSystem()
 }), {
 	guard: () => {
-		frozen();
+		frozen$1();
 		guard?.();
 	},
 	guardRests: false
@@ -39673,7 +39911,7 @@ const requireCoverage = async (base = start(), slice) => {
 				system: builderSystem(),
 				allowEmpty: true
 			});
-			frozen();
+			frozen$1();
 		} else {
 			await human("uncovered", {
 				message: uncoveredMessage(uncovered),
@@ -39682,13 +39920,136 @@ const requireCoverage = async (base = start(), slice) => {
 				acceptClean: true
 			});
 			if (!changes().some((c) => isCode$1(c.path))) return record(covered, uncovered);
-			frozen();
+			frozen$1();
 			retries = 0;
 		}
 		await green();
 	}
 };
 //#endregion
+//#region src/workflows/feature/prototype.ts
+/** The `prototypeRounds` setting. Anything but a non-negative integer fails rather than guess a cap. */
+const prototypeRounds = () => {
+	const value = vars.prototypeRounds ?? defaults.prototypeRounds;
+	if (!/^(0|[1-9]\d*)$/.test(value)) refuse(`gtd: prototypeRounds must be a non-negative integer, got ${JSON.stringify(value)}`);
+	return Number(value);
+};
+const CHUNK = /^(AC-\d+|Problem\b.*?)\s*:\s*(pass|fail|blocked)$/i;
+const UNGUIDED = /^no testing instructions$/i;
+/** The `## ` chunks of a prototype report; a heading in neither shape is prose, not an item. */
+const reportOf = (text) => {
+	let unguided = false;
+	const items = [];
+	const malformed = [];
+	for (const { line, fenced } of markFenced(text)) {
+		const heading = fenced ? null : HEADING.exec(line);
+		if (heading?.[1] !== "##") continue;
+		if (UNGUIDED.test(heading[2])) unguided = true;
+		const chunk = CHUNK.exec(heading[2]);
+		if (chunk === null && /^(ac-\d|problem)/i.test(heading[2])) malformed.push(heading[2]);
+		if (chunk !== null) items.push({
+			subject: /^ac-/i.test(chunk[1]) ? chunk[1].toUpperCase() : chunk[1],
+			verdict: chunk[2].toLowerCase()
+		});
+	}
+	return {
+		unguided,
+		items,
+		malformed
+	};
+};
+/**
+* The report the testing turn left, refused unless it is the only change and
+* names every criterion once, with its open items: another slice's criteria
+* are not this slice's to fix.
+*/
+const requireReport = (slice, retest) => {
+	const others = changes().map((c) => c.path).filter((path) => path !== PROTOTYPE);
+	if (others.length > 0) refuse(`gtd land: prototype-report: test in a disposable place and change nothing but ${PROTOTYPE} — revert these:\n${others.map((path) => `  - ${path}`).join("\n")}`);
+	const text = read(PROTOTYPE);
+	if (text === void 0) return refuse(`gtd land: prototype-report: write ${PROTOTYPE}`);
+	const report = reportOf(text);
+	if (report.malformed.length > 0) refuse(`gtd land: prototype-report: head each chunk \`## <ID>: pass|fail|blocked\` or \`## Problem <title>: pass|fail|blocked\` — these miss it:\n${report.malformed.map((h) => `  - ${h}`).join("\n")}`);
+	if (report.unguided && report.items.length === 0 && !retest) return {
+		unguided: true,
+		open: []
+	};
+	const requirements = read(".gtd/REQUIREMENTS.md") ?? "";
+	const ids = criterionIds(requirements, slice);
+	const elsewhere = criterionIds(requirements).filter((id) => !ids.includes(id));
+	const count = (id) => report.items.filter((i) => i.subject === id).length;
+	const wrong = ids.filter((id) => count(id) !== 1);
+	if (wrong.length > 0) refuse(`gtd land: prototype-report: ${PROTOTYPE} needs exactly one chunk headed \`## <ID>: pass|fail|blocked\` for ${wrong.join(", ")}`);
+	return {
+		unguided: false,
+		open: report.items.filter((i) => i.verdict !== "pass" && !elsewhere.includes(i.subject))
+	};
+};
+const frozen = () => requireCriteriaFrozen(REQUIREMENTS);
+const testing = async (slice, retest) => {
+	await agentWithSkills("testing", prototypeTestingPrompt(sliceIds(slice), retest), {
+		label: retest ? "Re-testing the slice by hand" : "Testing the slice by hand",
+		file: PROTOTYPE,
+		model: coder(),
+		system: testerSystem(),
+		allowEmpty: true
+	});
+	return requireReport(slice, retest);
+};
+const fixing = async (slice, guard) => {
+	await scope("fix", () => agentWithSkills("fixing", prototypeFixingPrompt(sliceIds(slice)), {
+		label: "Fixing what the hands-on test found",
+		file: PROTOTYPE,
+		model: coder(),
+		system: builderSystem(),
+		allowEmpty: true
+	}));
+	if (changes().some((c) => c.path === ".gtd/PROTOTYPE.md")) refuse(`gtd land: prototype-fix: leave ${PROTOTYPE} as it is — the next round re-tests from it`);
+	frozen();
+	guard?.();
+};
+/** A person's rest; resolves `true` when they changed something to test again, `false` on a clean overrule. */
+const askPerson = async (name, message, label) => {
+	await human(name, {
+		message,
+		label,
+		file: PROTOTYPE,
+		acceptClean: true
+	});
+	if (!changes().some((c) => c.path !== ".gtd/PROTOTYPE.md")) return false;
+	frozen();
+	return true;
+};
+/**
+* Use the slice by hand: a testing turn reports on every criterion, a fix turn
+* takes each failure, and the slice is tested again — until the report is
+* clean, or `prototypeRounds` fixes are spent and a person decides. `guard`
+* holds every fix turn, as it holds the implementation's.
+*/
+const prototypeTest = async (slice, guard) => {
+	const cap = prototypeRounds();
+	if (cap === 0) return;
+	await scope("prototype", async () => {
+		let fixes = 0;
+		let retest = false;
+		for (;;) {
+			const { unguided, open } = await testing(slice, retest);
+			retest = !unguided;
+			if (unguided) {
+				if (!await askPerson("unguided", prototypeUnguidedMessage(), "No way to test by hand")) return;
+			} else if (open.length === 0) return;
+			else if (fixes < cap && open.some((i) => i.verdict === "fail")) {
+				fixes++;
+				await fixing(slice, guard);
+			} else {
+				if (!await askPerson("open", prototypeOpenMessage(open, fixes), "Hands-on test still failing")) return;
+				fixes = 0;
+			}
+			await green(guard);
+		}
+	});
+};
+//#endregion
 //#region src/workflows/feature/seam.ts
 /** Naive-pass retries after a `reject` or a red suite; the next one rests at `seam.steer`. */
 const NAIVE_RETRIES = 2;
@@ -39895,8 +40256,10 @@ const implementing = (options) => scope("implement", async () => {
 		...acceptance,
 		ids: settled(acceptance.ids, options.slice)
 	}, since);
-	await green(built && acceptance !== void 0 ? () => requireAcceptanceKept(acceptance) : void 0);
+	const keepsTests = built && acceptance !== void 0 ? () => requireAcceptanceKept(acceptance) : void 0;
+	await green(keepsTests);
 	await requireCoverage(options.base, options.slice);
+	await prototypeTest(options.slice, keepsTests);
 	const ids = criterionIds(read(".gtd/REQUIREMENTS.md") ?? "");
 	await closing(moreToBuild(options.more));
 	return ids;
@@ -39905,11 +40268,16 @@ const moreToBuild = (more) => typeof more === "function" ? more() : more === tru
 /** The last slice's closing, for a last slice a steer left with no criterion to build. */
 const closeOut = () => scope("implement", () => closing(false));
 /** A slice with `more` after it keeps the criteria and the slicing for the next one. */
-const closing = (more) => run("closing", removeScript(more ? [REFACTOR_NOTE, HANDOFF] : [
+const closing = (more) => run("closing", removeScript(more ? [
+	REFACTOR_NOTE,
+	HANDOFF,
+	PROTOTYPE
+] : [
 	REQUIREMENTS,
 	REFACTOR_NOTE,
 	SLICES,
-	HANDOFF
+	HANDOFF,
+	PROTOTYPE
 ]), { label: "Closing out the implementation" });
 /** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
 const steer = async (retry) => {
@@ -40274,6 +40642,7 @@ const ordinaryStart = async () => {
 	refusePendingHandOff();
 	flagModeOn();
 	sliceCap();
+	prototypeRounds();
 	const stated = statedCriteria(changes(), head$1());
 	await unwind();
 	if (changes(".gtd/FEEDBACK.md").some((c) => c.status !== "deleted")) await human("unwind-failed", {
@@ -40308,6 +40677,10 @@ const skills = (vars) => {
 		seam: ["incremental-implementation"],
 		implement: ["test-driven-development", "incremental-implementation"],
 		"implement.fix.suite": ["debugging-and-error-recovery"],
+		"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"],
 		"implement.health": ["debugging-and-error-recovery"],
 		...lensScopes("build.quality", lensesOf(vars.qualityReviews ?? ""), (lens) => builtInLenses[lens]?.skills ?? [lens]),
 		...lensScopes("refactor.build.quality", lensesOf(vars.refactorQualityReviews ?? ""), (lens) => builtInLenses[lens]?.skills ?? [lens])
@@ -40485,4 +40858,4 @@ var workflows_default = feature;
 */
 const doors = {};
 //#endregion
-export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, HANDOFF, QUALITY, REFACTOR, REFACTOR_NOTE, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, SLICES, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeOut, closeReview, coder, collecting, criteriaOf, criterionIds, workflows_default as default, defaults, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, implementing, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, recheck, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, tail, threads, triage, unstableIds, unwind };
+export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, HANDOFF, PROTOTYPE, QUALITY, REFACTOR, REFACTOR_NOTE, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, SLICES, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeOut, closeReview, coder, collecting, criteriaOf, criterionIds, workflows_default as default, defaults, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, implementing, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, recheck, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, tail, threads, triage, unstableIds, unwind };