@pmelab/gtd 36.0.0 → 38.0.0

package/dist/workflows/feature.mjs

@@ -1,7 +1,7 @@
-import { answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, numeric, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restoreScript, revertScript, run, scope, slice, start, vars, wrote } from "../flows.mjs";
+import { agent, answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, numeric, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restoreScript, revertScript, run, scope, slice, start, vars, wrote } from "../flows.mjs";
 import { lensEntriesOf, review as review$1 } from "../workflow-kit.mjs";
-import { $ as qualityUnresolvedMessage, A as buildReviewCollectingPrompt, B as deferNotesScript, C as planner, D as agentWithSkills, E as reviewing, F as clearCriteriaQuestion, H as designSystem, I as coverageMessage, J as implementBuildingPrompt, L as coverageQuestion, M as buildReviewTriageMessage, N as builderSystem, O as buildReviewAnswerQuestionsPrompt, P as clearCriteriaMessage, Q as normaliseCriteriaScript, R as coveringPrompt, S as fixRisks, U as designTriagePrompt, V as designGateAnswerMessage, X as naiveApplyFailure, Y as implementFixPrompt, Z as naivePassPrompt, _ as REVIEW, _t as testFileGlobs, a as flagModeOn, at as reviewEditsCapture, b as fixCheck, ct as reviewerSystem, d as guarded, dt as startGateBlockedMessage, et as refactorBuildingPrompt, f as healthy, ft as uncoveredMessage, g as REQUIREMENTS, gt as envDefaults, h as REFACTOR, ht as defaults, i as skills, it as reviewEditNotesCapture, j as buildReviewFixNitsPrompt, k as buildReviewAwaitAfterDeferMessage, lt as seamByHandMessage, m as QUALITY, mt as unwindFailure, n as summary, nt as refactorFixPrompt, p as FEEDBACK, pt as unwindFailedMessage, q as idleMessage, r as access, rt as refactorRules, s as shipped, st as reviewNotesCapture, t as steering, tt as refactorDroppedRefusal, u as gate, ut as seamSteerMessage, v as awaitReview, w as reviewMissing, y as coder, z as criterionLine } from "../chunks/reserved-BAv71I4i.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-kar1zhOb.mjs";
+import { $ as naivePassPrompt, A as buildReviewAnswerQuestionsPrompt, B as coveringPrompt, E as reviewMissing, F as builderSystem, G as designTriagePrompt, H as deferNotesScript, I as clearCriteriaMessage, L as clearCriteriaQuestion, M as buildReviewCollectingPrompt, N as buildReviewFixNitsPrompt, O as reviewing, P as buildReviewTriageMessage, Q as naiveApplyFailure, R as coverageMessage, S as fixCheck, T as planner, U as designGateAnswerMessage, V as criterionLine, W as designSystem, X as implementBuildingPrompt, Y as idleMessage, Z as implementFixPrompt, _ as REQUIREMENTS, _t as unwindFailedMessage, a as flagModeOn, at as refactorNotePrompt, b as awaitReview, bt as envDefaults, ct as reviewEditsCapture, d as guarded, dt as reviewerSystem, et as normaliseCriteriaScript, f as healthy, ft as seamByHandMessage, g as REFACTOR_NOTE, gt as uncoveredMessage, h as REFACTOR, ht as startGateBlockedMessage, i as skills, it as refactorFixPrompt, j as buildReviewAwaitAfterDeferMessage, k as agentWithSkills, m as QUALITY, mt as slicingPrompt, n as summary, nt as refactorBuildingPrompt, ot as refactorRules, p as FEEDBACK, pt as seamSteerMessage, r as access, rt as refactorDroppedRefusal, s as shipped, st as reviewEditNotesCapture, t as steering, tt as qualityUnresolvedMessage, u as gate, ut as reviewNotesCapture, v as REVIEW, vt as unwindFailure, w as fixRisks, x as coder, xt as testFileGlobs, y as SLICES, yt as defaults, z as coverageQuestion } from "../chunks/reserved-sfMdy7v7.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-Cgca5Gp-.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
@@ -17,13 +17,15 @@ const markFenced = (text) => {
 		};
 	});
 };
+/** A markdown heading: its `#` run, then its text. */
+const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+/** A list item, its checkbox dropped: its text. */
+const ITEM = /^ ?(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(.*)$/;
 //#endregion
 //#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 HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
-const ITEM = /^ ?(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(.*)$/;
-const ID = /^(AC-\d+):\s*(.*)$/;
+const ID$1 = /^(AC-\d+):\s*(.*)$/;
 /** 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);
@@ -51,7 +53,7 @@ const listUnder = (text, title, level) => {
 };
 /** The `- AC-<n>: …` list of `## Acceptance Criteria`, or `undefined` when the section is missing. */
 const criteriaOf = (text) => listUnder(text, /^acceptance criteria$/i, 2)?.map((item) => {
-	const id = ID.exec(item);
+	const id = ID$1.exec(item);
 	return id === null ? {
 		id: "",
 		text: item
@@ -60,16 +62,20 @@ const criteriaOf = (text) => listUnder(text, /^acceptance criteria$/i, 2)?.map((
 		text: id[2]
 	};
 });
+/** 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));
+/** `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.exec(item));
+	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, "$2")
+		text: item.replace(ID$1, "$2")
 	});
 };
 const STATED = /^acceptance criteria:?$/i;
@@ -623,7 +629,8 @@ const plan = (shape, options) => {
 	return {
 		pattern,
 		strays,
-		reference: options.reference?.trim() ? options.reference : void 0
+		reference: options.reference?.trim() ? options.reference : void 0,
+		note: options.note?.trim() ? options.note : void 0
 	};
 };
 const guardOf = ({ pattern, strays }, entry) => () => {
@@ -632,13 +639,22 @@ const guardOf = ({ pattern, strays }, entry) => () => {
 };
 /** Derive, build, check and close one refactor lap; `feedback` is the collected review text of the lap before. */
 const refactorLap = async (p, guard, feedback) => {
-	const { pattern, strays, reference } = p;
-	await run("deriving", deriveScript([...packageLines(strays, pattern, reference), ...feedback === void 0 ? [] : [
-		"## Review feedback",
-		"",
-		...demoteHeadings(feedback),
-		""
-	]]), {
+	const { pattern, strays, reference, note } = p;
+	await run("deriving", deriveScript([
+		...packageLines(strays, pattern, reference),
+		...note === void 0 ? [] : [
+			"## Refactor note",
+			"",
+			...demoteHeadings(note),
+			""
+		],
+		...feedback === void 0 ? [] : [
+			"## Review feedback",
+			"",
+			...demoteHeadings(feedback),
+			""
+		]
+	]), {
 		label: "Deriving the refactor package",
 		file: REFACTOR_PACKAGE
 	});
@@ -647,7 +663,8 @@ const refactorLap = async (p, guard, feedback) => {
 		strays,
 		pattern,
 		reference,
-		feedback: feedback !== void 0
+		feedback: feedback !== void 0,
+		note: note !== void 0
 	}), {
 		label: "Refactoring",
 		model: coder(),
@@ -733,22 +750,27 @@ 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 green = () => healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
+const green = (guard) => healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
 	label: "Fixing the check",
 	file: FEEDBACK,
 	model: coder(),
 	system: builderSystem()
 }), {
-	guard: frozen,
+	guard: () => {
+		frozen();
+		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 — no passing test since `base` covers, by the judge.
+* over, only `slice`'s when given — no passing test since `base` covers, by the judge.
 */
-const uncoveredSince = async (base) => {
-	const criteria = (criteriaOf(read(".gtd/REQUIREMENTS.md") ?? "") ?? []).filter((c) => c.id !== "");
+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: []
@@ -775,14 +797,14 @@ const record = (covered, uncovered = []) => {
 * 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()) => {
+const requireCoverage = async (base = start(), slice) => {
 	let retries = 0;
 	for (;;) {
-		const { covered, uncovered } = await uncoveredSince(base);
+		const { covered, uncovered } = await uncoveredSince(base, slice);
 		if (uncovered.length === 0) return record(covered);
 		if (retries < COVERING_RETRIES) {
 			retries++;
-			await agentWithSkills("covering", coveringPrompt(uncovered), {
+			await agentWithSkills("covering", coveringPrompt(uncovered, sliceIds(slice)), {
 				label: "Covering the acceptance criteria",
 				model: coder(),
 				system: builderSystem(),
@@ -813,7 +835,7 @@ const judgeSeam = (tip) => judgeDiffShape("judge", {
 	allow: (vars.seamAllow ?? defaults.seamAllow).split(",").map((glob) => glob.trim()).filter((glob) => glob !== ""),
 	exempt: tip.changes.filter((c) => c.status === "added").map((c) => c.path)
 });
-const naivePass = (retry) => agentWithSkills("naive", naivePassPrompt(retry), {
+const naivePass = (retry, slice) => agentWithSkills("naive", naivePassPrompt(retry, sliceIds(slice)), {
 	label: retry === void 0 ? "Writing the naive pass" : "Rewriting the naive pass",
 	keep: true,
 	model: coder(),
@@ -853,16 +875,20 @@ const addedLines = (change) => {
 	const before = new Set((change.before ?? "").split("\n"));
 	return change.after.split("\n").filter((line) => !before.has(line)).join("\n");
 };
+const acceptanceTests = (changes) => changes.filter((c) => c.after !== void 0 && isCode$1(c.path) && isTestFile(c.path));
+const idsOf = (file, slice) => criterionIds(read(file) ?? "", slice);
+const unnamed = (ids, tests) => {
+	const lines = tests.map(addedLines);
+	return ids.filter((id) => !lines.some((text) => named(id, text)));
+};
 /**
 * Why `tip`'s tests fall short, or `undefined`: a criterion ID of `file` no
 * test line of the pass names, or a test importing a file the pass added —
 * naive structure a reset and refactor replaces, which the tests must survive.
 */
-const acceptanceFault = (file, tip) => {
-	const ids = (criteriaOf(read(file) ?? "") ?? []).map((c) => c.id).filter((id) => id !== "");
-	const tests = tip.changes.filter((c) => c.after !== void 0 && isCode$1(c.path) && isTestFile(c.path));
-	const lines = tests.map(addedLines);
-	const untested = ids.filter((id) => !lines.some((text) => named(id, text)));
+const acceptanceFault = (file, tip, slice) => {
+	const tests = acceptanceTests(tip.changes);
+	const untested = unnamed(idsOf(file, slice), tests);
 	if (untested.length > 0) return `acceptance-tests: no test of the naive pass names ${untested.join(", ")} — write a behaviour-level test for each criterion with its ID in the test or scenario name, e.g. "[${untested[0]}] …"`;
 	const added = tip.changes.filter((c) => c.status === "added" && isCode$1(c.path) && !isTestFile(c.path)).map((c) => c.path);
 	const reaching = tests.filter((test) => holdsCallSites(test.path)).flatMap((test) => {
@@ -871,6 +897,41 @@ const acceptanceFault = (file, tip) => {
 	});
 	if (reaching.length > 0) return `acceptance-internals: these tests import files the naive pass added — test through code that existed before it (a public entry point, an existing module's exports):\n${reaching.join("\n")}`;
 };
+/** What a rebuild carries over from the naive pass `tip`: the IDs its tests name, and those test files. */
+const naiveAcceptance = (tip, slice) => {
+	const ids = idsOf(REQUIREMENTS, slice);
+	const perTest = acceptanceTests(tip.changes).map((c) => {
+		const lines = addedLines(c);
+		return {
+			path: c.path,
+			ids: ids.filter((id) => named(id, lines))
+		};
+	});
+	return {
+		hash: tip.hash,
+		tests: perTest.filter((c) => c.ids.length > 0).map((c) => c.path),
+		ids: ids.filter((id) => perTest.some((c) => c.ids.includes(id)))
+	};
+};
+/**
+* Refuse a rebuild whose test changes since `since` leave out an ID the naive
+* pass's tests named. A skipped test still counts: the gate reads text, never runs it.
+*/
+const requireAcceptance = (acceptance, since) => {
+	const missing = unnamed(acceptance.ids, acceptanceTests(changesSince(since)));
+	if (missing.length === 0) return;
+	refuse(`gtd land: rebuild-acceptance: the rebuild's tests leave out ${missing.join(", ")} — carry over the naive pass's acceptance tests (\`git show ${acceptance.hash} -- ${acceptance.tests.map(quote).join(" ")}\`), each with its ID in the test or scenario name`);
+};
+/**
+* Refuse a fix turn that, on its own, drops an ID the naive pass's tests named
+* from a test file. Turn-local, so a person's edit at an escalation rest never
+* wedges later fix turns.
+*/
+const requireAcceptanceKept = (acceptance) => {
+	const dropped = acceptance.ids.filter((id) => changes().filter((c) => isCode$1(c.path) && isTestFile(c.path)).some((c) => named(id, c.before ?? "") && !named(id, c.after ?? "")));
+	if (dropped.length === 0) return;
+	refuse(`gtd land: rebuild-acceptance: this turn drops ${dropped.join(", ")} from the tests — the naive pass's acceptance tests stay; fix the code, not them`);
+};
 const restore = (path) => `if git cat-file -e ${quote(`HEAD:${path}`)} 2>/dev/null; then git checkout -q HEAD -- ${quote(path)}; else rm -f -- ${quote(path)}; fi`;
 /**
 * Run the suite with `tip`'s diff applied, then take it out again; resolves
@@ -914,18 +975,30 @@ function implement(first, tier, amend) {
 		amend
 	};
 	return scope("implement", async () => {
-		if (options.naive === void 0 || !await applied(options.naive)) await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor, flagModeOn()), {
+		const since = head();
+		const acceptance = options.rebuild?.acceptance;
+		const built = options.naive === void 0 || !await applied(options.naive);
+		if (built) await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor, flagModeOn(), options.rebuild, sliceIds(options.slice)), {
 			label: "Implementing",
 			model: coder(),
 			system: builderSystem(),
 			...options.afterRefactor === true ? { allowEmpty: true } : {}
 		});
 		requireCriteriaFrozen(REQUIREMENTS);
-		await green();
-		await requireCoverage();
-		await run("closing", removeScript([REQUIREMENTS]), { label: "Closing out the implementation" });
+		if (built && acceptance !== void 0) requireAcceptance(acceptance, since);
+		await green(built && acceptance !== void 0 ? () => requireAcceptanceKept(acceptance) : void 0);
+		await requireCoverage(options.base, options.slice);
+		await closing(options.more === true);
 	});
 }
+/** 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] : [
+	REQUIREMENTS,
+	REFACTOR_NOTE,
+	SLICES
+]), { label: "Closing out the implementation" });
 /** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
 const steer = async (retry) => {
 	await human("steer", {
@@ -956,8 +1029,8 @@ const budget = () => {
 	};
 };
 /** Sends a pass whose tests fall short or run red back (`undefined`: it goes on, an overruled one as it is). */
-const vetted = async (tip, vetting) => {
-	const fault = vetting.waived ? void 0 : acceptanceFault(REQUIREMENTS, tip);
+const vetted = async (tip, vetting, slice) => {
+	const fault = vetting.waived ? void 0 : acceptanceFault(REQUIREMENTS, tip, slice);
 	if (fault !== void 0) {
 		const verdict = await vetting.again({
 			fault,
@@ -973,33 +1046,56 @@ const vetted = async (tip, vetting) => {
 /** The judge's ruling on a vetted pass: the decision, or the next attempt's verdict. */
 const ruled = async (tip, again) => {
 	const shape = await judgeSeam(tip);
-	if (shape.choice === "land") return { reference: tip.hash };
+	if (shape.choice === "land") return {
+		reference: tip.hash,
+		tip
+	};
 	if (shape.choice === "refactor-first") return {
 		reference: tip.hash,
+		tip,
 		shape
 	};
 	const next = await again({
 		strays: shape.strays,
 		p: shape.judgment?.answers.shape?.p ?? 0
 	});
-	return next.kind === "overruled" ? { reference: tip.hash } : next;
+	return next.kind === "overruled" ? {
+		reference: tip.hash,
+		tip
+	} : next;
 };
-const decide = () => scope("seam", async () => {
+const decide = (slice) => scope("seam", async () => {
 	const vetting = {
 		again: budget(),
 		waived: false
 	};
 	let retry;
 	for (;;) {
-		await naivePass(retry);
+		await naivePass(retry, slice);
 		const tip = kept("naive");
-		const outcome = await vetted(tip, vetting) ?? (flagModeOn() ? await ruled(tip, vetting.again) : { reference: tip.hash });
+		const outcome = await vetted(tip, vetting, slice) ?? (flagModeOn() ? await ruled(tip, vetting.again) : {
+			reference: tip.hash,
+			tip
+		});
 		if (!("kind" in outcome)) return outcome;
 		retry = outcome.kind === "retry" ? outcome.retry : void 0;
 	}
 });
-const seamBuild = async (base) => {
-	const { reference, shape } = await decide();
+/** Write the refactor note from the whole naive pass; a turn that changes anything else is refused. */
+const refactorNote = async (reference, strays) => {
+	await agent("note", refactorNotePrompt(reference, strays), {
+		label: "Writing the refactor note",
+		file: REFACTOR_NOTE,
+		model: coder(),
+		system: builderSystem()
+	});
+	const others = changes().map((c) => c.path).filter((path) => path !== REFACTOR_NOTE);
+	const note = read(".gtd/REFACTOR-NOTE.md") ?? "";
+	if (others.length > 0 || note.trim() === "") refuse(`gtd land: refactor-note: write ${REFACTOR_NOTE} and change nothing else${others.length > 0 ? ` — revert these:\n${others.map((path) => `  - ${path}`).join("\n")}` : ""}`);
+	return note;
+};
+const seamBuild = async (base, slice$1 = {}) => {
+	const { reference, tip, shape } = await decide(slice$1.criteria);
 	if (shape === void 0) return {
 		reference,
 		base,
@@ -1013,42 +1109,164 @@ const seamBuild = async (base) => {
 		}));
 		return {
 			reference,
-			base
+			base,
+			rebuild: { acceptance: naiveAcceptance(tip, slice$1.criteria) }
 		};
 	}
-	if (refactorStrays(shape).length === 0) return {
+	const strays = refactorStrays(shape);
+	if (strays.length === 0) return {
 		reference,
-		base
+		base,
+		rebuild: { acceptance: naiveAcceptance(tip, slice$1.criteria) }
 	};
-	const refactored = await slice("refactor", () => reviewedRefactor(shape, { reference }));
+	const note = await scope("seam", () => refactorNote(reference, strays));
+	const refactored = await slice(slice$1.refactor ?? "refactor", () => reviewedRefactor(shape, {
+		reference,
+		note
+	}));
 	return {
 		reference,
 		base: head(),
-		refactored
+		refactored,
+		rebuild: {
+			note,
+			acceptance: naiveAcceptance(tip, slice$1.criteria)
+		}
 	};
 };
 //#endregion
+//#region src/workflows/feature/slicing.ts
+const ID = /^(AC-\d+)(?![\w-])/;
+/** The `sliceMaxCriteria` setting. Anything but a positive integer fails rather than guess a cap. */
+const sliceCap = () => {
+	const value = vars.sliceMaxCriteria ?? defaults.sliceMaxCriteria;
+	if (!/^[1-9]\d*$/.test(value)) refuse(`gtd: sliceMaxCriteria must be a positive integer, got ${JSON.stringify(value)}`);
+	return Number(value);
+};
+/** Each `## ` heading of `text` with the list items under it; an item not led by an ID keeps an empty one. */
+const slicesOf = (text) => {
+	const slices = [];
+	let open = false;
+	for (const { line, fenced } of markFenced(text)) {
+		if (fenced) continue;
+		const heading = HEADING.exec(line);
+		if (heading !== null) {
+			open = heading[1] === "##";
+			if (open) slices.push({
+				title: heading[2],
+				ids: []
+			});
+			continue;
+		}
+		const item = ITEM.exec(line);
+		if (item !== null && open) slices.at(-1).ids.push(ID.exec(item[1])?.[1] ?? "");
+	}
+	return slices;
+};
+const twice = (list) => [...new Set(list.filter((id, i) => list.indexOf(id) !== i))];
+/** Why `slices` fail to put each of `ids` in exactly one slice of at most `cap`, or `undefined`. */
+const sliceFault = (slices, ids, cap) => {
+	const listed = slices.flatMap((s) => s.ids);
+	if (slices.length === 0) return `no "## " slice`;
+	const empty = slices.filter((s) => s.ids.length === 0).map((s) => s.title);
+	if (empty.length > 0) return `a slice with no criterion: ${empty.join(", ")}`;
+	if (listed.includes("")) return "a list item not led by a criterion ID";
+	const over = slices.filter((s) => s.ids.length > cap).map((s) => s.title);
+	if (over.length > 0) return `more than ${cap} criteria in: ${over.join(", ")}`;
+	const repeated = twice(listed);
+	if (repeated.length > 0) return `an ID in more than one slice: ${repeated.join(", ")}`;
+	const unknown = listed.filter((id) => !ids.includes(id));
+	if (unknown.length > 0) return `an ID ${REQUIREMENTS} does not list: ${unknown.join(", ")}`;
+	const missing = ids.filter((id) => !listed.includes(id));
+	if (missing.length > 0) return `no slice for: ${missing.join(", ")}`;
+};
+/** Refuse a turn whose `.gtd/SLICES.md` does not put each of `ids` in exactly one slice of at most `cap`. */
+const requireSlices = (ids, cap) => {
+	const slices = slicesOf(read(".gtd/SLICES.md") ?? "");
+	const why = sliceFault(slices, ids, cap);
+	if (why !== void 0) refuse(`gtd land: slices: ${SLICES} has ${why} — list each slice as a "## <title>" heading over "- AC-<n>" items, every criterion of ${REQUIREMENTS} in exactly one slice, at most ${cap} per slice`);
+	return slices;
+};
+/**
+* The slices to build, in order. Criteria within `sliceMaxCriteria` are one
+* slice and no turn; above it `design.slicing` groups them.
+*/
+const slicing = async () => {
+	const all = criterionIds(read(".gtd/REQUIREMENTS.md") ?? "");
+	const cap = sliceCap();
+	if (all.length <= cap) return [{
+		title: "",
+		ids: all
+	}];
+	return scope("design", async () => {
+		await agentWithSkills("slicing", slicingPrompt(cap), {
+			label: "Slicing the change",
+			file: SLICES,
+			model: planner(),
+			system: designSystem()
+		});
+		return requireSlices(all, cap);
+	});
+};
+/** Slice `i`'s criteria; `undefined` when `slices` is the one slice of an unsliced change. */
+const sliceCriteria = (slices, i) => slices.length === 1 ? void 0 : i < slices.length - 1 ? { only: slices[i].ids } : { except: slices.slice(0, -1).flatMap((s) => s.ids) };
+//#endregion
 //#region src/workflows/feature/feature.ts
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 const unwind = () => {
 	const commit = head();
 	return run("unwind", revertScript(commit, FEEDBACK, unwindFailure(commit)), { label: "Unwinding your input" });
 };
-/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; design must have run since `firstBase`. */
+/**
+* The slices `design.slicing` grouped the criteria into, each built in turn
+* from where the previous one landed; design must have run since `firstBase`.
+*/
 const buildFeature = async (firstBase) => {
 	const tier = riskTierOn() ? recordRisk() : void 0;
-	const seam = await seamBuild(firstBase);
-	await slice("feature", async () => {
+	const slices = await slicing();
+	const one = slices.length === 1;
+	for (const i of slices.keys()) {
+		const more = i < slices.length - 1;
+		const criteria = sliceCriteria(slices, i);
+		if (sliceIds(criteria)?.length === 0) {
+			if (!more) await closeOut();
+			continue;
+		}
+		const n = one ? "" : `-${i + 1}`;
+		await buildSlice(i === 0 ? firstBase : head(), {
+			tier,
+			criteria,
+			refactor: `refactor${n}`,
+			feature: `feature${n}`,
+			more
+		});
+	}
+};
+/** A naive pass (judged only with `flagMode` on), then implement and the quality lap. */
+const buildSlice = async (sliceBase, build) => {
+	const seam = await seamBuild(sliceBase, {
+		criteria: build.criteria,
+		refactor: build.refactor
+	});
+	await slice(build.feature, async () => {
 		await implement({
 			reference: seam.reference,
-			tier,
+			tier: build.tier,
 			afterRefactor: seam.refactored,
-			naive: seam.land === true ? seam.reference : void 0
+			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 base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path)) ? firstBase : seam.base;
+		const carried = seam.rebuild?.acceptance?.tests ?? [];
+		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path) && !carried.includes(c.path)) ? sliceBase : seam.base;
+		const guard = build.more ? () => requireCriteriaFrozen(REQUIREMENTS) : void 0;
 		await tail(settleQuality, {
 			green: true,
-			lensBase: base
+			lensBase: base,
+			guard,
+			guardRests: false
 		});
 	});
 };
@@ -1094,6 +1312,7 @@ const ordinaryStart = async () => {
 	});
 	refusePendingHandOff();
 	flagModeOn();
+	sliceCap();
 	const stated = statedCriteria(changes(), head());
 	await unwind();
 	if (changes(".gtd/FEEDBACK.md").some((c) => c.status !== "deleted")) await human("unwind-failed", {
@@ -1109,4 +1328,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, collecting, criteriaOf, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, holdsCallSites, implement, isTestFile, judgeSeam, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, statedCriteria, steering, summary, triage, unwind };
+export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, closeOut, collecting, criteriaOf, criterionIds, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, holdsCallSites, implement, isTestFile, judgeSeam, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireSlices, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, triage, unwind };

package/dist/workflows/fix.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, scope, start } from "../flows.mjs";
 import { d as reviewNotes, f as reviewRisks } from "../chunks/steering-DVILanVf.mjs";
-import { D as agentWithSkills, G as fixReviewNotesPrompt, W as finisherSystem, _ as REVIEW, c as baseline, gt as envDefaults, ht as defaults, i as skills, n as summary, r as access, s as shipped, t as steering, y as coder } from "../chunks/reserved-BAv71I4i.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-kar1zhOb.mjs";
+import { K as finisherSystem, bt as envDefaults, c as baseline, i as skills, k as agentWithSkills, n as summary, q as fixReviewNotesPrompt, r as access, s as shipped, t as steering, v as REVIEW, x as coder, yt as defaults } from "../chunks/reserved-sfMdy7v7.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-Cgca5Gp-.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,6 +1,6 @@
 import { start } from "../flows.mjs";
-import { gt as envDefaults, ht as defaults, i as skills, n as summary, ot as reviewGateBlockedMessage, r as access, s as shipped, t as steering, u as gate } from "../chunks/reserved-BAv71I4i.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-kar1zhOb.mjs";
+import { bt as envDefaults, i as skills, lt as reviewGateBlockedMessage, n as summary, r as access, s as shipped, t as steering, u as gate, yt as defaults } from "../chunks/reserved-sfMdy7v7.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-Cgca5Gp-.mjs";
 //#region src/workflows/review/review.ts
 /**
 * Pure review of everything since `reviewBase`: a green gate, the quality

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 { St as requireFlag, bt as flipProblems, gt as envDefaults, ht as defaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, vt as flagMentions, y as coder } from "../chunks/reserved-BAv71I4i.mjs";
+import { Et as requireFlag, St as flagMentions, bt as envDefaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as flipProblems, x as coder, yt as defaults } from "../chunks/reserved-sfMdy7v7.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.";