@pmelab/gtd 51.0.1 → 52.1.0

package/dist/workflow-kit.mjs

@@ -1,5 +1,5 @@
 import { changes, changesSince, hasThreadFor, head, mark, read, refuse, requireReplies, requireThreadsClosed, scope } from "./flows.mjs";
-import { E as parseThreads, _ as reviewRisks, c as stripCodeThreads, g as reviewNotes, h as reviewDecisions, y as unansweredNotes } from "./chunks/steering-DtUVUz9l.mjs";
+import { S as unansweredNotes, _ as reviewNotes, c as stripCodeThreads, g as reviewDecisions, k as parseThreads, v as reviewRisks } from "./chunks/steering-CLhu8C7q.mjs";
 //#region src/workflow-kit/health.ts
 /** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */
 const escalation = async (count, steps) => {

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { C as coder, It as defaults, Lt as envDefaults, Qt as requireFlag, Yt as flagReferences, Zt as registryEntry, i as skills, n as summary, o as flagShipped, r as access, t as steering } from "../chunks/reserved-CUkk9XgL.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-CX6Pdsql.mjs";
+import { C as coder, Ft as defaults, It as envDefaults, Jt as flagReferences, Xt as registryEntry, Zt as requireFlag, i as skills, n as summary, o as flagShipped, r as access, t as steering } from "../chunks/reserved-DxB5CROj.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-QZc7Uz2U.mjs";
 //#region src/workflows/cleanup/cleanup.ts
 const removingPrompt = (name, registry) => `Clean up the release flag "${name}", which is default-on: delete its entry in ${registry}, and remove every \`GTD_FLAG_${name.toUpperCase()}\` check from the shipped sources. Keep the flag-on path; delete code only the off path reached, including tests that pin the off path.`;
 const cleanupFlow = async () => {

package/dist/workflows/feature.mjs

@@ -1,8 +1,8 @@
 import { agent, answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireThreadsClosed, revertScript, run, scope, slice, start, vars, wrote } from "../flows.mjs";
 import { lensEntriesOf } from "../workflow-kit.mjs";
-import { $ as implementFixPrompt, C as coder, Ct as seamByHandMessage, Dt as testerSystem, E as fixNits, Et as startGateBlockedMessage, G as designGateAnswerMessage, H as coverageQuestion, I as builderSystem, It as defaults, K as designSystem, Lt as envDefaults, Mt as unwindFailure, N as agentWithSkills, P as buildReviewCollectingPrompt, Q as implementBuildingPrompt, R as clearCriteriaMessage, Rt as testFileGlobs, St as reviewerSystem, Tt as slicingPrompt, U as coveringPrompt, V as coverageMessage, W as criterionLine, Z as idleMessage, _ as REFACTOR_NOTE, a as flagModeOn, at as prototypeOpenMessage, b as SLICES, d as healthy, dt as refactorBuildingPrompt, et as naiveApplyFailure, f as FEEDBACK, ft as refactorDroppedRefusal, g as REFACTOR, ht as refactorRules, i as skills, it as prototypeFixingPrompt, jt as unwindFailedMessage, k as planner, kt as uncoveredMessage, l as gate, m as PROTOTYPE, mt as refactorNotePrompt, n as summary, nt as normaliseCriteriaScript, ot as prototypeTestingPrompt, p as HANDOFF, pt as refactorFixPrompt, q as designTriagePrompt, r as access, rt as oversizedMessage, s as shipped, st as prototypeUnguidedMessage, t as steering, tt as naivePassPrompt, v as REQUIREMENTS, w as collecting, wt as seamSteerMessage, x as answerReviewQuestions, z as clearCriteriaQuestion } from "../chunks/reserved-CUkk9XgL.mjs";
-import { a as refusePendingHandOff, c as joinReports, o as tail } from "../chunks/tail-CX6Pdsql.mjs";
-import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-BaCXlIT2.mjs";
+import { $ as naivePassPrompt, At as unwindFailedMessage, C as coder, Ct as seamByHandMessage, Dt as testerSystem, E as fixNits, Et as startGateBlockedMessage, Ft as defaults, G as designTriagePrompt, H as designGateAnswerMessage, I as builderSystem, It as envDefaults, Lt as testFileGlobs, N as agentWithSkills, P as buildReviewCollectingPrompt, Q as naiveApplyFailure, R as clearCriteriaMessage, St as reviewerSystem, Tt as slicingPrompt, U as designImpactPrompt, V as criterionLine, W as designSystem, X as implementBuildingPrompt, Y as idleMessage, Z as implementFixPrompt, _ as REFACTOR_NOTE, a as flagModeOn, at as prototypeOpenMessage, b as SLICES, d as healthy, dt as refactorBuildingPrompt, et as normaliseCriteriaScript, f as FEEDBACK, ft as refactorDroppedRefusal, g as REFACTOR, ht as refactorRules, i as skills, it as prototypeFixingPrompt, jt as unwindFailure, k as planner, l as gate, m as PROTOTYPE, mt as refactorNotePrompt, n as summary, nt as observableQuestion, ot as prototypeTestingPrompt, p as HANDOFF, pt as refactorFixPrompt, r as access, rt as oversizedMessage, s as shipped, st as prototypeUnguidedMessage, t as steering, tt as observableMessage, v as REQUIREMENTS, w as collecting, wt as seamSteerMessage, x as answerReviewQuestions, z as clearCriteriaQuestion } from "../chunks/reserved-DxB5CROj.mjs";
+import { a as refusePendingHandOff, c as joinReports, o as tail } from "../chunks/tail-QZc7Uz2U.mjs";
+import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-CKMSdvgW.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
@@ -26,7 +26,12 @@ const ITEM = /^ ?(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(.*)$/;
 //#region src/workflows/feature/criteria.ts
 /** Below this the judge's `yes` is not trusted: a wrong skip builds against criteria nobody can check. */
 const CLEAR_MIN_P = .8;
-const ID$1 = /^(AC-\d+):\s*(.*)$/;
+const ID$1 = /^(AC-\d+)(\s*\(no hands-on\))?:\s*(.*)$/;
+const criterion = (id, as = id[1]) => ({
+	id: as,
+	text: id[3],
+	...id[2] === void 0 ? {} : { noHandsOn: true }
+});
 /** 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, title, level) => {
 	const lines = markFenced(text);
@@ -58,25 +63,28 @@ const criteriaOf = (text) => listUnder(text, /^acceptance criteria$/i, 2)?.map((
 	return id === null ? {
 		id: "",
 		text: item
-	} : {
-		id: id[1],
-		text: id[2]
-	};
+	} : criterion(id);
 });
 /** The ID'd criteria of `text`, only `slice`'s when given. */
 const criterionIds = (text, slice) => (criteriaOf(text) ?? []).map((c) => c.id).filter((id) => id !== "" && (slice?.only === void 0 || slice.only.includes(id)) && !(slice?.except ?? []).includes(id));
+/** The ID'd criteria of `text` (`slice`'s when given) a person can try by hand: none tagged `(no hands-on)`. */
+const handsOnIds = (text, slice) => {
+	const tagged = (criteriaOf(text) ?? []).filter((c) => c.noHandsOn).map((c) => c.id);
+	return criterionIds(text, slice).filter((id) => !tagged.includes(id));
+};
 /** `slice`'s IDs in `.gtd/REQUIREMENTS.md` as it is now; `undefined` for an unsliced change. */
 const sliceIds = (slice) => slice === void 0 ? void 0 : criterionIds(read(".gtd/REQUIREMENTS.md") ?? "", slice);
 /** Items numbered `AC-1`…, unless every one already carries its own distinct ID. */
 const numbered = (items) => {
 	const ids = items.map((item) => ID$1.exec(item));
 	const own = ids.every((id) => id !== null) && new Set(ids.map((id) => id[1])).size === ids.length;
-	return items.map((item, i) => own ? {
-		id: ids[i][1],
-		text: ids[i][2]
-	} : {
-		id: `AC-${i + 1}`,
-		text: item.replace(ID$1, "$2")
+	return items.map((item, i) => {
+		const id = ids[i];
+		if (own) return criterion(id);
+		return id === null ? {
+			id: `AC-${i + 1}`,
+			text: item
+		} : criterion(id, `AC-${i + 1}`);
 	});
 };
 const STATED = /^acceptance criteria:?$/i;
@@ -113,6 +121,38 @@ const requireCriteria = (file) => {
 	if (criteria.length > 0 && unnamed.length === 0 && twice.length === 0) return;
 	refuse(`gtd land: acceptance-criteria: ${file} has ${criteria.length === 0 ? `no "## Acceptance Criteria" list` : unnamed.length > 0 ? `${unnamed.length} criterion without an ID:\n${unnamed.map((c) => `  - ${c.text}`).join("\n")}` : `duplicate IDs: ${[...new Set(twice)].join(", ")}`} — list every criterion under "## Acceptance Criteria" as "- AC-<n>: <checkable criterion>", each ID unique and never reused`);
 };
+const isImpactHeading = (h) => h !== null && h[1].length === 2 && /^impact$/i.test(h[2].trim());
+/** Whether `text` has an unfenced, level-2 `## Impact` heading. */
+const hasImpact = (text) => markFenced(text).some((l) => !l.fenced && isImpactHeading(HEADING.exec(l.line)));
+/** `text` without its `## Impact` section, whitespace collapsed. */
+const withoutImpact = (text) => {
+	let inImpact = false;
+	return markFenced(text).filter((l) => {
+		const h = l.fenced ? null : HEADING.exec(l.line);
+		if (h !== null && h[1].length <= 2) inImpact = isImpactHeading(h);
+		return !inImpact;
+	}).map((l) => l.line).join(" ").replace(/\s+/g, " ").trim();
+};
+/**
+* Refuse a turn that leaves `file` without a `## Impact` section. Only the
+* pending turn (`head()` is `""`): a triage lap recorded before Impact existed
+* replays without one, and refusing there would fail every in-flight process.
+* A human's edit at a later gate is not checked — the human owns that file then.
+*/
+const requireImpact = (file) => {
+	if (head() !== "") return;
+	const text = read(file);
+	if (text === void 0) return;
+	if (hasImpact(text)) return;
+	refuse(`gtd land: impact: ${file} has no "## Impact" section — explore the codebase and add "## Impact" naming the units, public surfaces and surprises this change touches`);
+};
+/** Refuse a turn that changed `file` beyond its `## Impact` section. */
+const requireImpactOnly = (file) => {
+	const change = changes().get(file);
+	if (change === void 0) return;
+	if (withoutImpact(change.before ?? "") === withoutImpact(change.after ?? "")) return;
+	refuse(`gtd land: impact-only: this turn may only add "## Impact" to ${file} — restore everything else`);
+};
 const idNumber = (id) => Number(id.slice(3));
 /** Why `listed` renumbers or reuses an earlier ID; `undefined` when it does neither. */
 const unstableIds = (listed, ids) => {
@@ -146,6 +186,19 @@ const clear = async (stated) => {
 	});
 	return truncated.length === 0 && answered(answers.clear, "yes", CLEAR_MIN_P);
 };
+/** The fast path's impact-only turn: add `## Impact`, leave the criteria alone. */
+const impact = async () => {
+	await agentWithSkills("impact", designImpactPrompt(), {
+		label: "Mapping the change's impact",
+		file: REQUIREMENTS,
+		model: planner(),
+		system: designSystem()
+	});
+	requireProgress(REQUIREMENTS);
+	requireCriteriaFrozen(REQUIREMENTS);
+	requireImpact(REQUIREMENTS);
+	requireImpactOnly(REQUIREMENTS);
+};
 /**
 * The skip path: when the sketch stated clear, checkable criteria, write them
 * to `.gtd/REQUIREMENTS.md` as they are and resolve `true` — no triage, no
@@ -157,6 +210,7 @@ const skipDesign = (stated) => stated === void 0 ? Promise.resolve(false) : scop
 		label: "Recording the stated acceptance criteria",
 		file: REQUIREMENTS
 	});
+	await impact();
 	return true;
 });
 /** After a gate that invites narrowing the requirements: an edit must leave valid criteria. */
@@ -253,10 +307,169 @@ const design = (base, guard) => scope("design", async () => {
 		requireProgress(REQUIREMENTS);
 		requireReplies(REQUIREMENTS);
 		requireCriteria(REQUIREMENTS);
+		requireImpact(REQUIREMENTS);
 		guard?.();
 	} while (await noteGate(REQUIREMENTS, answerProductQuestions));
 });
 //#endregion
+//#region src/workflows/feature/green.ts
+const green = (guard) => healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
+	label: "Fixing the check",
+	file: FEEDBACK,
+	model: coder(),
+	system: builderSystem()
+}), {
+	guard: () => {
+		requireCriteriaFrozen(REQUIREMENTS);
+		guard?.();
+	},
+	guardRests: false
+});
+//#endregion
+//#region src/workflows/feature/prototype.ts
+/** Only a `no` at this or above skips a criterion: no verdict, or an unsure one, sends it to the hands-on test. */
+const UNOBSERVABLE_MIN_P = .5;
+/** 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 each of `ids` once, with its open items: any other criterion is not
+* this test's to fix.
+*/
+const requireReport = (ids, 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 elsewhere = criterionIds(read(".gtd/REQUIREMENTS.md") ?? "").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))
+	};
+};
+/**
+* The slice's criteria a person can observe by using the change, by the
+* judge: those tagged `(no hands-on)` are never asked about.
+*/
+const observable = async (slice) => {
+	const requirements = read(".gtd/REQUIREMENTS.md") ?? "";
+	const own = handsOnIds(requirements, slice);
+	const criteria = (criteriaOf(requirements) ?? []).filter((c) => own.includes(c.id));
+	if (criteria.length === 0) return [];
+	const { answers } = await judge("observable", {
+		questions: criteria.map(observableQuestion),
+		evidence: { requirements },
+		message: observableMessage(),
+		label: "Judging which criteria to test by hand"
+	});
+	return own.filter((id) => !answered(answers[id], "no", UNOBSERVABLE_MIN_P));
+};
+const frozen = () => requireCriteriaFrozen(REQUIREMENTS);
+const testing = async (slice, ids, retest) => {
+	const skipped = criterionIds(read(".gtd/REQUIREMENTS.md") ?? "", slice).filter((id) => !ids.includes(id));
+	await agentWithSkills("testing", prototypeTestingPrompt(sliceIds(slice), skipped, retest), {
+		label: retest ? "Re-testing the slice by hand" : "Testing the slice by hand",
+		file: PROTOTYPE,
+		model: coder(),
+		system: testerSystem(),
+		allowEmpty: true
+	});
+	return requireReport(ids, 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 person
+* can observe, 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. A slice with no such criterion is not tested by hand. `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 () => {
+		const ids = await observable(slice);
+		if (ids.length === 0) return;
+		let fixes = 0;
+		let retest = false;
+		for (;;) {
+			const { unguided, open } = await testing(slice, ids, 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/shared/continuation.ts
 const phase = (name, steered) => ({
 	name,
@@ -573,211 +786,6 @@ const reviewedRefactor = async (shape, options = {}) => {
 	});
 };
 //#endregion
-//#region src/workflows/feature/coverage.ts
-/** Below this the judge's `yes` is not trusted: a wrongly covered ID ends the feature without its test. */
-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$1 = () => requireCriteriaFrozen(REQUIREMENTS);
-const green = (guard) => healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
-	label: "Fixing the check",
-	file: FEEDBACK,
-	model: coder(),
-	system: builderSystem()
-}), {
-	guard: () => {
-		frozen$1();
-		guard?.();
-	},
-	guardRests: false
-});
-const testsSince = (base) => changesSince(base).filter((c) => c.after !== void 0 && isCode$1(c.path) && isTestFile(c.path)).sort((a, b) => Number(/\bAC-\d/.test(a.after)) - Number(/\bAC-\d/.test(b.after))).map((c) => `=== ${c.path} (${c.status})\n${c.after}`).join("\n");
-/**
-* The criterion IDs of `.gtd/REQUIREMENTS.md` — read afresh, never carried
-* over, only `slice`'s when given — no passing test since `base` covers, by the judge.
-*/
-const uncoveredSince = async (base, slice) => {
-	const requirements = read(".gtd/REQUIREMENTS.md") ?? "";
-	const own = criterionIds(requirements, slice);
-	const criteria = (criteriaOf(requirements) ?? []).filter((c) => own.includes(c.id));
-	if (criteria.length === 0) return {
-		covered: [],
-		uncovered: []
-	};
-	const { answers } = await judge("coverage", {
-		questions: criteria.map(coverageQuestion),
-		evidence: { tests: testsSince(base) },
-		message: coverageMessage(),
-		label: "Judging acceptance-criteria coverage"
-	});
-	const covers = (id) => answered(answers[id], "yes", COVERED_MIN_P);
-	const ids = criteria.map((c) => c.id);
-	return {
-		covered: ids.filter(covers),
-		uncovered: ids.filter((id) => !covers(id))
-	};
-};
-const record = (covered, uncovered = []) => {
-	for (const id of covered) mark("covers", id);
-	for (const id of uncovered) mark("uncovered", id);
-};
-/**
-* Hold a green change until every acceptance criterion has a passing test,
-* sending uncovered IDs back to a covering turn; marks the IDs covered on the
-* landing that ends it. A human may overrule once the retries are spent.
-*/
-const requireCoverage = async (base = start(), slice) => {
-	let retries = 0;
-	for (;;) {
-		const { covered, uncovered } = await uncoveredSince(base, slice);
-		if (uncovered.length === 0) return record(covered);
-		if (retries < COVERING_RETRIES) {
-			retries++;
-			await agentWithSkills("covering", coveringPrompt(uncovered, sliceIds(slice)), {
-				label: "Covering the acceptance criteria",
-				model: coder(),
-				system: builderSystem(),
-				allowEmpty: true
-			});
-			frozen$1();
-		} else {
-			await human("uncovered", {
-				message: uncoveredMessage(uncovered),
-				label: "Acceptance criteria without a test",
-				file: REQUIREMENTS,
-				acceptClean: true
-			});
-			if (!changes().some((c) => isCode$1(c.path))) return record(covered, uncovered);
-			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;
@@ -986,7 +994,6 @@ const implementing = (options) => scope("implement", async () => {
 	}, since);
 	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));
@@ -1272,7 +1279,6 @@ const buildSlice = async (sliceBase, build) => {
 			naive: seam.land === true ? seam.reference : void 0,
 			rebuild: seam.rebuild,
 			slice: build.criteria,
-			base: build.criteria === void 0 ? void 0 : sliceBase,
 			more: build.more
 		});
 		const more = build.more();
@@ -1386,4 +1392,4 @@ const feature = shipped(ordinaryStart);
 //#region src/workflows/feature/index.ts
 var feature_default = feature;
 //#endregion
-export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, closeOut, collecting, criteriaOf, criterionIds, feature_default as default, defaults, design, envDefaults, feature, fixNits, holdsCallSites, implement, implementing, isTestFile, judgeSeam, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, triage, unstableIds, unwind };
+export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, closeOut, collecting, criteriaOf, criterionIds, feature_default as default, defaults, design, envDefaults, feature, fixNits, handsOnIds, hasImpact, holdsCallSites, implement, implementing, isTestFile, judgeSeam, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireImpact, requireImpactOnly, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, triage, unstableIds, unwind };

package/dist/workflows/fix.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, scope, start } from "../flows.mjs";
-import { _ as reviewRisks, g as reviewNotes } from "../chunks/steering-DtUVUz9l.mjs";
-import { C as coder, It as defaults, J as finisherSystem, Lt as envDefaults, N as agentWithSkills, Y as fixReviewNotesPrompt, c as baseline, i as skills, n as summary, r as access, s as shipped, t as steering, y as REVIEW } from "../chunks/reserved-CUkk9XgL.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-CX6Pdsql.mjs";
+import { _ as reviewNotes, v as reviewRisks } from "../chunks/steering-CLhu8C7q.mjs";
+import { C as coder, Ft as defaults, It as envDefaults, K as finisherSystem, N as agentWithSkills, c as baseline, i as skills, n as summary, q as fixReviewNotesPrompt, r as access, s as shipped, t as steering, y as REVIEW } from "../chunks/reserved-DxB5CROj.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-QZc7Uz2U.mjs";
 //#region src/workflows/fix/fix.ts
 /**
 * Fix every note a human left in a handed-off `.gtd/REVIEW.md` and every

package/dist/workflows/review.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, start } from "../flows.mjs";
-import { C as coder, It as defaults, J as finisherSystem, Lt as envDefaults, N as agentWithSkills, i as skills, l as gate, n as summary, r as access, s as shipped, t as steering, v as REQUIREMENTS, vt as reviewFeedbackFixPrompt, yt as reviewGateBlockedMessage } from "../chunks/reserved-CUkk9XgL.mjs";
-import { a as refusePendingHandOff } from "../chunks/tail-CX6Pdsql.mjs";
-import { i as reUnwind, t as buildTail } from "../chunks/review-BaCXlIT2.mjs";
+import { C as coder, Ft as defaults, It as envDefaults, K as finisherSystem, N as agentWithSkills, i as skills, l as gate, n as summary, r as access, s as shipped, t as steering, v as REQUIREMENTS, vt as reviewFeedbackFixPrompt, yt as reviewGateBlockedMessage } from "../chunks/reserved-DxB5CROj.mjs";
+import { a as refusePendingHandOff } from "../chunks/tail-QZc7Uz2U.mjs";
+import { i as reUnwind, t as buildTail } from "../chunks/review-CKMSdvgW.mjs";
 //#region src/workflows/review/review.ts
 const fixFeedback = async () => {
 	await agentWithSkills("feedback.fixing", reviewFeedbackFixPrompt(), {

package/dist/workflows/rollout.mjs

@@ -1,5 +1,5 @@
 import { agent, changesSince, glob, head, mark, read, refuse, removeScript, run, scope, vars } from "../flows.mjs";
-import { C as coder, It as defaults, Jt as flagMentions, Lt as envDefaults, Qt as requireFlag, Xt as flipProblems, f as FEEDBACK, i as skills, l as gate, n as summary, o as flagShipped, r as access, t as steering } from "../chunks/reserved-CUkk9XgL.mjs";
+import { C as coder, Ft as defaults, It as envDefaults, Yt as flipProblems, Zt as requireFlag, f as FEEDBACK, i as skills, l as gate, n as summary, o as flagShipped, qt as flagMentions, r as access, t as steering } from "../chunks/reserved-DxB5CROj.mjs";
 //#region src/workflows/rollout/rollout.ts
 const flippingPrompt = (name, registry) => `Roll out the release flag "${name}": in ${registry}, set \`defaultOn: true\` on its entry. Change nothing else — no other entry, no other field, no other file, no comments.`;
 const suiteBlockedMessage = () => "The suite is red after the rollout. Fix it by hand — a rollout may only touch the flag's registry entry — then land.";