@pmelab/gtd 52.0.0 → 53.0.0

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 { 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, start, vars, wrote } from "../flows.mjs";
 import { lensEntriesOf } from "../workflow-kit.mjs";
-import { $ as normaliseCriteriaScript, At as unwindFailure, C as coder, Ct as seamSteerMessage, E as fixNits, Et as testerSystem, Ft as envDefaults, H as designGateAnswerMessage, I as builderSystem, It as testFileGlobs, J as idleMessage, N as agentWithSkills, P as buildReviewCollectingPrompt, Pt as defaults, Q as naivePassPrompt, R as clearCriteriaMessage, St as seamByHandMessage, Tt as startGateBlockedMessage, U as designSystem, V as criterionLine, W as designTriagePrompt, X as implementFixPrompt, Y as implementBuildingPrompt, Z as naiveApplyFailure, _ as REFACTOR_NOTE, a as flagModeOn, at as prototypeTestingPrompt, b as SLICES, d as healthy, dt as refactorDroppedRefusal, et as observableMessage, f as FEEDBACK, ft as refactorFixPrompt, g as REFACTOR, i as skills, it as prototypeOpenMessage, k as planner, kt as unwindFailedMessage, l as gate, m as PROTOTYPE, mt as refactorRules, n as summary, nt as oversizedMessage, ot as prototypeUnguidedMessage, p as HANDOFF, pt as refactorNotePrompt, r as access, rt as prototypeFixingPrompt, s as shipped, t as steering, tt as observableQuestion, ut as refactorBuildingPrompt, v as REQUIREMENTS, w as collecting, wt as slicingPrompt, x as answerReviewQuestions, xt as reviewerSystem, z as clearCriteriaQuestion } from "../chunks/reserved-D0MKVFFa.mjs";
-import { a as refusePendingHandOff, c as joinReports, o as tail } from "../chunks/tail-I1-vVq0P.mjs";
-import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-ZzUQH1KZ.mjs";
+import { $ as observableMessage, B as designGateAnswerMessage, Ct as testerSystem, D as planner, Dt as unwindFailure, Et as unwindFailedMessage, H as designSystem, I as clearCriteriaMessage, J as implementBuildingPrompt, L as clearCriteriaQuestion, M as buildReviewCollectingPrompt, Mt as envDefaults, Nt as testFileGlobs, P as builderSystem, Q as normaliseCriteriaScript, S as collecting, St as startGateBlockedMessage, U as designTriagePrompt, V as designImpactPrompt, X as naiveApplyFailure, Y as implementFixPrompt, Z as naivePassPrompt, _ as REQUIREMENTS, a as flagModeOn, bt as seamByHandMessage, ct as refactorBuildingPrompt, d as healthy, dt as refactorNotePrompt, et as observableQuestion, f as FEEDBACK, ft as refactorRules, g as REFACTOR_NOTE, h as REFACTOR, i as skills, it as prototypeUnguidedMessage, j as agentWithSkills, jt as defaults, l as gate, lt as refactorDroppedRefusal, n as summary, nt as prototypeOpenMessage, p as PROTOTYPE, q as idleMessage, r as access, rt as prototypeTestingPrompt, s as shipped, t as steering, tt as prototypeFixingPrompt, ut as refactorFixPrompt, w as fixNits, x as coder, xt as seamSteerMessage, y as answerReviewQuestions, yt as reviewerSystem, z as criterionLine } from "../chunks/reserved-CQ7amcKG.mjs";
+import { a as refusePendingHandOff, o as tail } from "../chunks/tail-JZ9PAOwp.mjs";
+import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-CNgN_V8T.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
@@ -26,7 +26,7 @@ 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*\(no hands-on\))?:\s*(.*)$/;
+const ID = /^(AC-\d+)(\s*\(no hands-on\))?:\s*(.*)$/;
 const criterion = (id, as = id[1]) => ({
 	id: as,
 	text: id[3],
@@ -59,24 +59,22 @@ 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$1.exec(item);
+	const id = ID.exec(item);
 	return id === null ? {
 		id: "",
 		text: item
 	} : 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) => {
+/** The ID'd criteria of `text`. */
+const criterionIds = (text) => (criteriaOf(text) ?? []).map((c) => c.id).filter((id) => id !== "");
+/** The ID'd criteria of `text` a person can try by hand: none tagged `(no hands-on)`. */
+const handsOnIds = (text) => {
 	const tagged = (criteriaOf(text) ?? []).filter((c) => c.noHandsOn).map((c) => c.id);
-	return criterionIds(text, slice).filter((id) => !tagged.includes(id));
+	return criterionIds(text).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 ids = items.map((item) => ID.exec(item));
 	const own = ids.every((id) => id !== null) && new Set(ids.map((id) => id[1])).size === ids.length;
 	return items.map((item, i) => {
 		const id = ids[i];
@@ -121,6 +119,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) => {
@@ -154,6 +184,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
@@ -165,15 +208,9 @@ 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. */
-const requireCriteriaIfEdited = () => {
-	const change = changes().get(REQUIREMENTS);
-	if (change === void 0) return;
-	if (change.status === "deleted") refuse(`gtd land: criteria-missing: ${REQUIREMENTS} must stay — narrow its criteria, never delete it`);
-	requireCriteria(REQUIREMENTS);
-};
 //#endregion
 //#region src/workflows/feature/tier.ts
 /** GTD_FLAG_RISK_TIER: pinned at process start, so a mid-process flip never moves a process. */
@@ -261,6 +298,7 @@ const design = (base, guard) => scope("design", async () => {
 		requireProgress(REQUIREMENTS);
 		requireReplies(REQUIREMENTS);
 		requireCriteria(REQUIREMENTS);
+		requireImpact(REQUIREMENTS);
 		guard?.();
 	} while (await noteGate(REQUIREMENTS, answerProductQuestions));
 });
@@ -338,12 +376,12 @@ const requireReport = (ids, retest) => {
 	};
 };
 /**
-* The slice's criteria a person can observe by using the change, by the
-* judge: those tagged `(no hands-on)` are never asked about.
+* The 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 observable = async () => {
 	const requirements = read(".gtd/REQUIREMENTS.md") ?? "";
-	const own = handsOnIds(requirements, slice);
+	const own = handsOnIds(requirements);
 	const criteria = (criteriaOf(requirements) ?? []).filter((c) => own.includes(c.id));
 	if (criteria.length === 0) return [];
 	const { answers } = await judge("observable", {
@@ -355,10 +393,9 @@ const observable = async (slice) => {
 	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",
+const testing = async (ids, retest) => {
+	await agentWithSkills("testing", prototypeTestingPrompt(criterionIds(read(".gtd/REQUIREMENTS.md") ?? "").filter((id) => !ids.includes(id)), retest), {
+		label: retest ? "Re-testing the change by hand" : "Testing the change by hand",
 		file: PROTOTYPE,
 		model: coder(),
 		system: testerSystem(),
@@ -366,8 +403,8 @@ const testing = async (slice, ids, retest) => {
 	});
 	return requireReport(ids, retest);
 };
-const fixing = async (slice, guard) => {
-	await scope("fix", () => agentWithSkills("fixing", prototypeFixingPrompt(sliceIds(slice)), {
+const fixing = async (guard) => {
+	await scope("fix", () => agentWithSkills("fixing", prototypeFixingPrompt(), {
 		label: "Fixing what the hands-on test found",
 		file: PROTOTYPE,
 		model: coder(),
@@ -391,29 +428,29 @@ const askPerson = async (name, message, label) => {
 	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 —
+* Use the change by hand: a testing turn reports on every criterion a person
+* can observe, a fix turn takes each failure, and the change 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.
+* decides. A change 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 prototypeTest = async (guard) => {
 	const cap = prototypeRounds();
 	if (cap === 0) return;
 	await scope("prototype", async () => {
-		const ids = await observable(slice);
+		const ids = await observable();
 		if (ids.length === 0) return;
 		let fixes = 0;
 		let retest = false;
 		for (;;) {
-			const { unguided, open } = await testing(slice, ids, retest);
+			const { unguided, open } = await testing(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);
+				await fixing(guard);
 			} else {
 				if (!await askPerson("open", prototypeOpenMessage(open, fixes), "Hands-on test still failing")) return;
 				fixes = 0;
@@ -423,53 +460,6 @@ const prototypeTest = async (slice, guard) => {
 	});
 };
 //#endregion
-//#region src/workflows/shared/continuation.ts
-const phase = (name, steered) => ({
-	name,
-	spent: false,
-	count: 0,
-	stalled: 0,
-	steered
-});
-const own = (fn) => fn();
-const continued = (fn) => scope("continue", fn);
-const afresh = (fn) => scope("fresh", fn);
-const setting = (name, least) => {
-	const raw = vars[name] ?? defaults[name];
-	const n = Number(raw);
-	if (raw.trim() === "" || !Number.isInteger(n) || n < least) refuse(`gtd: ${name} must be a whole number of at least ${least}, got ${JSON.stringify(raw)}`);
-	return n;
-};
-/**
-* Run `turn` until one ends without a handoff note: each stopped turn is picked
-* up by a continuation in a fresh conversation. Past `continuations` of them in
-* the phase, or after `continuationStall` in a row that close nothing still
-* open, the phase rests at `oversized` for a person; landing there grants a new round.
-*/
-const continuing = async (phase, turn) => {
-	const cap = setting("continuations", 0);
-	const stall = setting("continuationStall", 1);
-	let last = await turn(void 0, phase.spent ? afresh : own);
-	while (last.handoff !== void 0) {
-		phase.spent = true;
-		const from = last.handoff;
-		if (phase.count >= cap || phase.stalled >= stall) {
-			await human("oversized", {
-				message: oversizedMessage(phase.name, from, phase.count >= cap ? { cap } : { stall }, phase.steered !== void 0),
-				label: "Too big for its context",
-				acceptClean: true
-			});
-			phase.steered?.();
-			phase.count = 0;
-			phase.stalled = 0;
-		}
-		last = await turn(from, continued);
-		phase.count++;
-		phase.stalled = from.open.length === 0 || from.open.some((item) => !(last.handoff?.open ?? []).includes(item)) ? 0 : phase.stalled + 1;
-	}
-	return last.result;
-};
-//#endregion
 //#region src/workflows/feature/refactor.ts
 const REFACTOR_PACKAGE = REFACTOR;
 const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
@@ -615,7 +605,7 @@ const guardOf = ({ pattern, strays }, entry) => () => {
 	requireNoNewFlags(pattern, entry);
 };
 /** Derive, build, check and close one refactor lap; `feedback` is the collected review text of the lap before. */
-const refactorLap = async (p, guard, refactor, feedback) => {
+const refactorLap = async (p, guard, feedback) => {
 	const { pattern, strays, reference, note } = p;
 	await run("deriving", deriveScript([
 		...packageLines(strays, pattern, reference),
@@ -635,48 +625,32 @@ const refactorLap = async (p, guard, refactor, feedback) => {
 		label: "Deriving the refactor package",
 		file: REFACTOR_PACKAGE
 	});
-	const reached = /* @__PURE__ */ new Set();
-	await continuing(refactor, async (from, fresh) => {
-		await fresh(() => agentWithSkills("building", refactorBuildingPrompt({
-			pkg: REFACTOR_PACKAGE,
-			strays,
-			pattern,
-			reference,
-			feedback: feedback !== void 0,
-			note: note !== void 0,
-			from
-		}), {
-			label: from === void 0 ? "Refactoring" : "Continuing the refactor",
+	await agentWithSkills("building", refactorBuildingPrompt({
+		pkg: REFACTOR_PACKAGE,
+		strays,
+		pattern,
+		reference,
+		feedback: feedback !== void 0,
+		note: note !== void 0
+	}), {
+		label: "Refactoring",
+		model: coder(),
+		system: builderSystem()
+	});
+	guard();
+	await healthy(async () => {
+		await agentWithSkills("fix.suite.fixing", refactorFixPrompt(strays, pattern), {
+			label: "Fixing the check",
+			file: FEEDBACK,
 			model: coder(),
 			system: builderSystem()
-		}));
-		const left = read(HANDOFF);
-		guard();
-		const snapshot = head();
-		for (const c of changes()) reached.add(c.path);
-		await healthy(async () => {
-			await agentWithSkills("fix.suite.fixing", refactorFixPrompt(strays, pattern), {
-				label: "Fixing the check",
-				file: FEEDBACK,
-				model: coder(),
-				system: builderSystem()
-			});
-			guard();
-		}, {
-			describeGuard: guard,
-			rules: refactorRules(strays, pattern)
 		});
-		if (left === void 0) return { result: void 0 };
-		return {
-			result: void 0,
-			handoff: {
-				snapshot,
-				note: left.trim(),
-				open: strays.filter((path) => !reached.has(path))
-			}
-		};
+		guard();
+	}, {
+		describeGuard: guard,
+		rules: refactorRules(strays, pattern)
 	});
-	await run("closing", removeScript([REFACTOR_PACKAGE, HANDOFF]), { label: "Closing out the refactor" });
+	await run("closing", removeScript([REFACTOR_PACKAGE]), { label: "Closing out the refactor" });
 };
 const strayAccess = (strays) => ({ write: [
 	...strays,
@@ -690,7 +664,7 @@ const refactorFirst = async (shape, options = {}) => {
 		name: "refactor",
 		access: strayAccess(p.strays)
 	}, async () => {
-		await refactorLap(p, guardOf(p, head()), phase("refactor"));
+		await refactorLap(p, guardOf(p, head()));
 		return true;
 	});
 };
@@ -715,10 +689,9 @@ const reviewedRefactor = async (shape, options = {}) => {
 			unmatched: "gtd land: refactor-feedback: the review feedback changed files but wrote no .gtd/REFACTOR.md — a refactor cannot act on it; revert the change, or `gtd abandon` and restart",
 			dropped: refactorDroppedRefusal
 		};
-		const refactor = phase("refactor");
 		let collected;
 		for (;;) {
-			await refactorLap(p, guard, refactor, collected);
+			await refactorLap(p, guard, collected);
 			const outcome = await buildTail(entry, {
 				green: true,
 				guard,
@@ -748,32 +721,12 @@ 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, slice, from) => agentWithSkills("naive", naivePassPrompt(retry, sliceIds(slice), from), {
-	label: from !== void 0 ? "Continuing the naive pass" : retry === void 0 ? "Writing the naive pass" : "Rewriting the naive pass",
+const naivePass = (retry) => agentWithSkills("naive", naivePassPrompt(retry), {
+	label: retry === void 0 ? "Writing the naive pass" : "Rewriting the naive pass",
 	keep: true,
 	model: coder(),
 	system: builderSystem()
 });
-const handoffOf = (tip, slice) => {
-	const note = tip.changes.find((c) => c.path === ".gtd/HANDOFF.md" && c.after !== void 0);
-	if (note === void 0) return void 0;
-	return {
-		snapshot: tip.hash,
-		note: note.after.trim(),
-		open: unnamed(idsOf(REQUIREMENTS, slice), acceptanceTests(tip.changes))
-	};
-};
-/** A naive pass, continued until a pass ends without a handoff note: the snapshot is its kept tip. */
-const naiveContinued = (retry, slice, naive) => continuing(naive, async (from, fresh) => {
-	const tip = await fresh(async () => {
-		await naivePass(retry, slice, from);
-		return kept("naive");
-	});
-	return {
-		result: tip,
-		handoff: handoffOf(tip, slice)
-	};
-});
 const IMPORTED = /(?:\bfrom|\bimport|\brequire\s*\(|\bmock\s*\()\s*\(?\s*(["'`])([^"'`\n]+)\1/g;
 const EXTENSION = /\.[\w-]+$/;
 const ALIAS = /^(?:[@~]\/|#)/;
@@ -809,7 +762,7 @@ const addedLines = (change) => {
 	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 idsOf = (file) => criterionIds(read(file) ?? "");
 const unnamed = (ids, tests) => {
 	const lines = tests.map(addedLines);
 	return ids.filter((id) => !lines.some((text) => named(id, text)));
@@ -819,9 +772,9 @@ const unnamed = (ids, tests) => {
 * 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, slice) => {
+const acceptanceFault = (file, tip) => {
 	const tests = acceptanceTests(tip.changes);
-	const untested = unnamed(idsOf(file, slice), tests);
+	const untested = unnamed(idsOf(file), 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) => {
@@ -831,8 +784,8 @@ const acceptanceFault = (file, tip, slice) => {
 	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 naiveAcceptance = (tip) => {
+	const ids = idsOf(REQUIREMENTS);
 	const perTest = acceptanceTests(tip.changes).map((c) => {
 		const lines = addedLines(c);
 		return {
@@ -902,31 +855,19 @@ const applied = async (tip) => {
 	return !wrote(".gtd/FEEDBACK.md") && codeChanges().length > 0;
 };
 /** `carried` limited to the criteria `.gtd/REQUIREMENTS.md` lists now; a file listing none narrows nothing. */
-const settled = (carried, slice) => {
-	const listed = idsOf(REQUIREMENTS, slice);
-	if (carried === void 0) return listed;
+const settled = (carried) => {
+	const listed = idsOf(REQUIREMENTS);
 	return listed.length === 0 ? carried : carried.filter((id) => listed.includes(id));
 };
-const build = (options) => continuing(phase("build", requireCriteriaIfEdited), async (from, fresh) => {
-	await fresh(() => agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor, flagModeOn(), options.rebuild, sliceIds(options.slice), from), {
-		label: from === void 0 ? "Implementing" : "Continuing the implementation",
+const build = async (options) => {
+	await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor, flagModeOn(), options.rebuild), {
+		label: "Implementing",
 		model: coder(),
 		system: builderSystem(),
 		...options.afterRefactor === true ? { allowEmpty: true } : {}
-	}));
+	});
 	requireCriteriaFrozen(REQUIREMENTS);
-	const note = read(HANDOFF);
-	if (note === void 0) return { result: void 0 };
-	const ids = settled(options.rebuild?.acceptance?.ids, options.slice);
-	return {
-		result: void 0,
-		handoff: {
-			snapshot: head(),
-			note: note.trim(),
-			open: unnamed(ids, acceptanceTests(changesSince(start())))
-		}
-	};
-});
+};
 async function implement(first, tier, amend) {
 	await implementing(typeof first === "object" && first !== null ? first : {
 		reference: first,
@@ -943,30 +884,19 @@ const implementing = (options) => scope("implement", async () => {
 	else requireCriteriaFrozen(REQUIREMENTS);
 	if (built && acceptance !== void 0) requireAcceptance({
 		...acceptance,
-		ids: settled(acceptance.ids, options.slice)
+		ids: settled(acceptance.ids)
 	}, since);
 	const keepsTests = built && acceptance !== void 0 ? () => requireAcceptanceKept(acceptance) : void 0;
 	await green(keepsTests);
-	await prototypeTest(options.slice, keepsTests);
+	await prototypeTest(keepsTests);
 	const ids = criterionIds(read(".gtd/REQUIREMENTS.md") ?? "");
-	await closing(moreToBuild(options.more));
+	await run("closing", removeScript([
+		REQUIREMENTS,
+		REFACTOR_NOTE,
+		PROTOTYPE
+	]), { label: "Closing out the implementation" });
 	return ids;
 });
-const moreToBuild = (more) => typeof more === "function" ? more() : 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,
-	HANDOFF,
-	PROTOTYPE
-] : [
-	REQUIREMENTS,
-	REFACTOR_NOTE,
-	SLICES,
-	HANDOFF,
-	PROTOTYPE
-]), { label: "Closing out the implementation" });
 /** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
 const steer = async (retry) => {
 	await human("steer", {
@@ -997,8 +927,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, slice) => {
-	const fault = vetting.waived ? void 0 : acceptanceFault(REQUIREMENTS, tip, slice);
+const vetted = async (tip, vetting) => {
+	const fault = vetting.waived ? void 0 : acceptanceFault(REQUIREMENTS, tip);
 	if (fault !== void 0) {
 		const verdict = await vetting.again({
 			fault,
@@ -1032,16 +962,16 @@ const ruled = async (tip, again) => {
 		tip
 	} : next;
 };
-const decide = (slice) => scope("seam", async () => {
+const decide = () => scope("seam", async () => {
 	const vetting = {
 		again: budget(),
 		waived: false
 	};
-	const naive = phase("naive pass", requireCriteriaIfEdited);
 	let retry;
 	for (;;) {
-		const tip = await naiveContinued(retry, slice, naive);
-		const outcome = await vetted(tip, vetting, slice) ?? (flagModeOn() ? await ruled(tip, vetting.again) : {
+		await naivePass(retry);
+		const tip = kept("naive");
+		const outcome = await vetted(tip, vetting) ?? (flagModeOn() ? await ruled(tip, vetting.again) : {
 			reference: tip.hash,
 			tip
 		});
@@ -1062,8 +992,8 @@ const refactorNote = async (reference, strays) => {
 	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);
+const seamBuild = async (base) => {
+	const { reference, tip, shape } = await decide();
 	if (shape === void 0) return {
 		reference,
 		base,
@@ -1078,107 +1008,31 @@ const seamBuild = async (base, slice$1 = {}) => {
 		return {
 			reference,
 			base,
-			rebuild: { acceptance: naiveAcceptance(tip, slice$1.criteria) }
+			rebuild: { acceptance: naiveAcceptance(tip) }
 		};
 	}
 	const strays = refactorStrays(shape);
 	if (strays.length === 0) return {
 		reference,
 		base,
-		rebuild: { acceptance: naiveAcceptance(tip, slice$1.criteria) }
+		rebuild: { acceptance: naiveAcceptance(tip) }
 	};
 	const note = await scope("seam", () => refactorNote(reference, strays));
-	const refactored = await slice(slice$1.refactor ?? "refactor", () => reviewedRefactor(shape, {
+	const refactored = await reviewedRefactor(shape, {
 		reference,
 		note
-	}));
+	});
 	return {
 		reference,
 		base: head(),
 		refactored,
 		rebuild: {
 			note,
-			acceptance: naiveAcceptance(tip, slice$1.criteria)
+			acceptance: naiveAcceptance(tip)
 		}
 	};
 };
 //#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 = () => {
@@ -1186,94 +1040,37 @@ const unwind = () => {
 	return run("unwind", revertScript(commit, FEEDBACK, unwindFailure(commit)), { label: "Unwinding your input" });
 };
 /**
-* The slices `design.slicing` grouped the criteria into, each built in turn
-* from where the previous one landed; design must have run since `firstBase`.
+* A naive pass (judged only with `flagMode` on), then implement and the
+* quality lap, then the review; design must have run since `firstBase`.
 */
 const buildFeature = async (firstBase) => {
 	const tier = riskTierOn() ? recordRisk() : void 0;
-	const slices = await slicing();
 	const handedOut = new Set(listedIds());
-	const one = slices.length === 1;
-	const built = (i) => sliceIds(sliceCriteria(slices, i))?.length !== 0;
-	const reports = [];
-	for (const i of slices.keys()) {
-		if (!built(i)) continue;
-		const n = one ? "" : `-${i + 1}`;
-		await buildSlice(i === 0 ? firstBase : head(), {
-			number: `${i + 1}`,
-			tier,
-			criteria: sliceCriteria(slices, i),
-			refactor: `refactor${n}`,
-			feature: `feature${n}`,
-			more: () => slices.some((_, j) => j > i && built(j)),
-			reviewBase: one ? void 0 : firstBase,
-			handedOut,
-			laps: reports
-		});
-	}
+	const seam = await seamBuild(firstBase);
+	const used = gather(handedOut);
+	const closed = await implementing({
+		reference: seam.reference,
+		tier,
+		afterRefactor: seam.refactored,
+		naive: seam.land === true ? seam.reference : void 0,
+		rebuild: seam.rebuild
+	});
+	const carried = seam.rebuild?.acceptance?.tests ?? [];
+	const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path) && !carried.includes(c.path)) ? firstBase : seam.base;
+	const outcome = await reviewedTail(base, base);
+	await featureFeedback(outcome, base, {
+		closed,
+		used
+	});
 };
 const listedIds = () => criterionIds(read(".gtd/REQUIREMENTS.md") ?? "");
 const gather = (handedOut) => {
 	for (const id of listedIds()) handedOut.add(id);
 	return [...handedOut];
 };
-/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; after the last slice, the review. */
-const buildSlice = async (sliceBase, build) => {
-	const seam = await seamBuild(sliceBase, {
-		criteria: build.criteria,
-		refactor: build.refactor
-	});
-	const used = gather(build.handedOut);
-	await slice(build.feature, async () => {
-		const closed = await implementing({
-			reference: seam.reference,
-			tier: build.tier,
-			afterRefactor: seam.refactored,
-			naive: seam.land === true ? seam.reference : void 0,
-			rebuild: seam.rebuild,
-			slice: build.criteria,
-			more: build.more
-		});
-		const more = build.more();
-		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;
-		if (more) {
-			const guard = () => requireCriteriaFrozen(REQUIREMENTS);
-			const report = await tail(async (_, report) => report, {
-				green: true,
-				lensBase: base,
-				guard,
-				guardRests: false
-			});
-			build.laps.push({
-				slice: build.number,
-				report
-			});
-			return;
-		}
-		const reviewBase = build.reviewBase ?? base;
-		const outcome = await reviewedTail(reviewBase, base, {
-			slice: build.number,
-			laps: build.laps
-		});
-		await featureFeedback(outcome, base, {
-			closed,
-			used
-		});
-	});
-};
-/**
-* The quality lap of slice `last.slice`, then a reviewer's walkthrough since
-* `base` for the human, carrying what earlier slices' `laps` left too.
-*/
-const reviewedTail = (base, lensBase, last = {
-	slice: "",
-	laps: []
-}, lap = "first") => tail((escalations, report) => humanReview(base, escalations, {
-	report: last.laps.length === 0 ? report : joinReports([...last.laps, {
-		slice: last.slice,
-		report
-	}]),
+/** The quality lap, then a reviewer's walkthrough since `base` for the human. */
+const reviewedTail = (base, lensBase, lap = "first") => tail((escalations, report) => humanReview(base, escalations, {
+	report,
 	walkthrough: true,
 	lap
 }), {
@@ -1298,7 +1095,7 @@ const featureFeedback = async (first, lensBase, ids) => {
 			tier: riskTierOn() ? recordRisk() : void 0,
 			amend: true
 		});
-		outcome = await reviewedTail(outcome.base, lensBase, void 0, "feedback");
+		outcome = await reviewedTail(outcome.base, lensBase, "feedback");
 	}
 };
 /** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
@@ -1306,7 +1103,7 @@ const planAndBuild = async (firstBase, stated) => {
 	if (!await skipDesign(riskTierOn() ? void 0 : stated)) await design(firstBase);
 	await buildFeature(firstBase);
 };
-/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
+/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. */
 const afterTail = async (first) => {
 	let outcome = first;
 	while (outcome.verdict === "feedback") {
@@ -1328,7 +1125,6 @@ const ordinaryStart = async () => {
 	});
 	refusePendingHandOff();
 	flagModeOn();
-	sliceCap();
 	prototypeRounds();
 	const stated = statedCriteria(changes(), head());
 	await unwind();
@@ -1345,4 +1141,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, handsOnIds, 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, 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, requireImpact, requireImpactOnly, requireNoNewFlags, requireNoTestFiles, requireStableIds, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, statedCriteria, steering, summary, triage, unstableIds, unwind };