@pmelab/gtd 58.1.0 → 59.0.0

package/dist/workflows/feature.mjs

@@ -1,1018 +0,0 @@
-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, restoreScript, revertScript, run, scope, start, vars, wrote } from "../flows.mjs";
-import { lensEntriesOf } from "../workflow-kit.mjs";
-import { B as designSystem, Ct as testFileGlobs, D as planner, F as clearCriteriaMessage, I as clearCriteriaQuestion, J as implementBuildingPrompt, L as criterionLine, M as buildReviewCollectingPrompt, P as builderSystem, Q as naiveTryMessage, R as designGateAnswerMessage, S as collecting, St as envDefaults, V as designTriagePrompt, X as naiveApplyFailure, Y as implementFixPrompt, Z as naivePassPrompt, _ as REQUIREMENTS, _t as unwindFailedMessage, at as refactorFixPrompt, d as healthy, et as normaliseCriteriaScript, f as FEEDBACK, g as REFACTOR_NOTE, gt as startGateBlockedMessage, h as REFACTOR, ht as seamSteerMessage, i as skills, it as refactorDroppedRefusal, j as agentWithSkills, l as gate, mt as seamByHandMessage, n as summary, o as naiveTestOn, ot as refactorNotePrompt, p as NAIVE_TEST, pt as reviewerSystem, q as idleMessage, r as access, rt as refactorBuildingPrompt, s as shipped, st as refactorRules, t as steering, vt as unwindFailure, w as fixNits, x as coder, xt as defaults, y as answerReviewQuestions, z as designImpactPrompt } from "../chunks/reserved-lMYCaapY.mjs";
-import { a as refusePendingHandOff } from "../chunks/tail-Bd7L940p.mjs";
-import { n as isCode$1, r as reUnwind, t as buildTail } from "../chunks/review-Bfaror38.mjs";
-import { posix } from "node:path";
-//#region src/workflows/shared/fences.ts
-const markFenced = (text) => {
-	let fence;
-	return text.split(/\r?\n/).map((line) => {
-		const run = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1];
-		const fenced = fence !== void 0 || run !== void 0;
-		if (fence === void 0) fence = run;
-		else if (run !== void 0 && run[0] === fence[0] && run.length >= fence.length && /^ {0,3}(`+|~+)[ \t]*$/.test(line)) fence = void 0;
-		return {
-			line,
-			fenced
-		};
-	});
-};
-/** 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/release-flag.ts
-const NAME = /^existing:\s*`?([A-Za-z_][\w.-]*)`?$/i;
-const isFlagHeading = (h) => h !== null && h[1].length === 2 && /^release flag$/i.test(h[2].trim());
-/** The first line under `## Release Flag`, `undefined` without the section. */
-const requestLine = (text) => {
-	const lines = markFenced(text);
-	const at = lines.findIndex((l) => !l.fenced && isFlagHeading(HEADING.exec(l.line)));
-	if (at === -1) return void 0;
-	const body = lines.slice(at + 1);
-	const end = body.findIndex((l) => !l.fenced && HEADING.test(l.line));
-	return (end === -1 ? body : body.slice(0, end)).find((l) => l.line.trim() !== "")?.line.trim();
-};
-/** What `text` asks for, or why it cannot be read. No section asks for no flag. */
-const releaseFlagOf = (text) => {
-	const line = requestLine(text);
-	if (line === void 0 || /^none$/i.test(line)) return { kind: "none" };
-	if (/^new$/i.test(line)) return { kind: "new" };
-	const name = NAME.exec(line)?.[1];
-	return name === void 0 ? { unreadable: line } : {
-		kind: "existing",
-		name
-	};
-};
-/** Refuse `file` when its `## Release Flag` section is neither `none`, `new` nor `existing: <NAME>`. */
-const requireReleaseFlag = (file) => {
-	const request = releaseFlagOf(read(file) ?? "");
-	if (!("unreadable" in request)) return;
-	refuse(`gtd land: release-flag: ${file}'s "## Release Flag" reads ${JSON.stringify(request.unreadable)} — its first line must be \`new\`, \`existing: <NAME>\` or \`none\`, or leave the section out for no flag`);
-};
-/** What `.gtd/REQUIREMENTS.md` asks for now; a person's unreadable edit is refused. */
-const requestedFlag = () => {
-	requireReleaseFlag(REQUIREMENTS);
-	return releaseFlagOf(read(".gtd/REQUIREMENTS.md") ?? "");
-};
-/** Whether the change goes behind a release flag: only then does the seam judge rule. */
-const flagged = () => requestedFlag().kind !== "none";
-//#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 ID = /^(AC-\d+):\s*(.*)$/;
-const criterion = (id, as = id[1]) => ({
-	id: as,
-	text: id[2]
-});
-/** 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);
-	const at = lines.findIndex((l) => {
-		const heading = l.fenced ? null : HEADING.exec(l.line);
-		return heading !== null && (level === void 0 || heading[1].length === level) && title.test(heading[2]);
-	});
-	if (at === -1) return void 0;
-	const items = [];
-	let open = false;
-	for (const { line, fenced } of lines.slice(at + 1)) {
-		if (fenced) {
-			open = false;
-			continue;
-		}
-		if (HEADING.test(line)) break;
-		const item = ITEM.exec(line);
-		if (item !== null) {
-			items.push(item[1].trim());
-			open = true;
-		} else if (open && line.trim() !== "") items[items.length - 1] = `${items.at(-1)} ${line.trim()}`.trim();
-		else open = false;
-	}
-	return items;
-};
-/** 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);
-	return id === null ? {
-		id: "",
-		text: item
-	} : criterion(id);
-});
-/** The ID'd criteria of `text`. */
-const criterionIds = (text) => (criteriaOf(text) ?? []).map((c) => c.id).filter((id) => id !== "");
-/** 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 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];
-		if (own) return criterion(id);
-		return id === null ? {
-			id: `AC-${i + 1}`,
-			text: item
-		} : criterion(id, `AC-${i + 1}`);
-	});
-};
-const STATED = /^acceptance criteria:?$/i;
-const statedItems = (text) => text === void 0 ? [] : (listUnder(text, STATED) ?? []).filter((item) => item !== "");
-/**
-* The criteria a `TODO.md` in the sketch `sketch` (the idle turn's changes)
-* added or changed under an `Acceptance criteria` heading. More than one such
-* file is ambiguous, and any other change in the sketch is input only triage
-* folds in, so none.
-*/
-const statedCriteria = (sketch, commit) => {
-	const found = sketch.flatMap((change) => {
-		if (!/(^|\/)TODO\.md$/.test(change.path) || change.after === void 0) return [];
-		const items = statedItems(change.after);
-		if (items.length === 0 || items.join("\n") === statedItems(change.before).join("\n")) return [];
-		return [{
-			path: change.path,
-			commit,
-			text: change.after,
-			criteria: numbered(items)
-		}];
-	});
-	return found.length === 1 && sketch.length === 1 ? found[0] : void 0;
-};
-const listing = (criteria) => criteria.map(criterionLine).join("\n");
-/** Refuse a turn that leaves `file` without ID'd acceptance criteria. A deleted file is `requireProgress`'s call. */
-const requireCriteria = (file) => {
-	const text = read(file);
-	if (text === void 0) return;
-	const criteria = criteriaOf(text) ?? [];
-	const unnamed = criteria.filter((c) => c.id === "");
-	const ids = criteria.map((c) => c.id).filter((id) => id !== "");
-	const twice = ids.filter((id, i) => ids.indexOf(id) !== i);
-	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());
-const isImpactTurnHeading = (h) => h !== null && h[1].length === 2 && /^(impact|release flag)$/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` and `## Release Flag` sections, 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 = isImpactTurnHeading(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` and `## Release Flag` sections. */
-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" (and "## Release Flag") 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) => {
-	const top = Math.max(0, ...ids.used.map(idNumber));
-	const reused = listed.filter((id) => !ids.closed.includes(id) && idNumber(id) <= top);
-	if (reused.length === 0) return void 0;
-	return `numbers ${reused.join(", ")} at or below AC-${top}, an ID already handed out — keep a built criterion's ID (reword it in place when the review changes it), and number new ones from AC-${top + 1}`;
-};
-/** Refuse criteria in `file` that renumber or reuse an earlier ID. */
-const requireStableIds = (file, ids) => {
-	const why = unstableIds(criterionIds(read(file) ?? ""), ids);
-	if (why !== void 0) refuse(`gtd land: criteria-ids: ${file} ${why}`);
-};
-/** Refuse a turn that changed the acceptance criteria in `file`: after the design gate only another design lap may. */
-const requireCriteriaFrozen = (file) => {
-	const change = changes().get(file);
-	if (change === void 0) return;
-	if (listing(criteriaOf(change.before ?? "") ?? []) === listing(criteriaOf(change.after ?? "") ?? [])) return;
-	refuse(`gtd land: criteria-frozen: the acceptance criteria in ${file} are settled — restore them; only a design lap changes them`);
-};
-/** Whether the judge trusts `stated` as clear and checkable, every criterion of it. Truncated evidence never is. */
-const clear = async (stated) => {
-	const { answers, truncated } = await judge("clear", {
-		questions: [clearCriteriaQuestion],
-		evidence: {
-			criteria: listing(stated.criteria),
-			sketch: stated.text
-		},
-		message: clearCriteriaMessage(),
-		label: "Judging the stated acceptance criteria"
-	});
-	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);
-	requireReleaseFlag(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
-* design gate. `false` when design must run.
-*/
-const skipDesign = (stated) => stated === void 0 ? Promise.resolve(false) : scope("design", async () => {
-	if (!await clear(stated)) return false;
-	await run("normalise", normaliseCriteriaScript(stated), {
-		label: "Recording the stated acceptance criteria",
-		file: REQUIREMENTS
-	});
-	await impact();
-	return true;
-});
-//#endregion
-//#region src/workflows/feature/tier.ts
-/** GTD_FLAG_RISK_TIER: pinned at process start, so a mid-process flip never moves a process. */
-const riskTierOn = () => vars.flag_risk_tier === "1";
-const sectionLines = (text, title) => {
-	if (text === void 0) return [];
-	const heading = new RegExp(`^##[ \\t]+${title}[ \\t]*$`, "i");
-	const lines = markFenced(text);
-	const start = lines.findIndex((l) => !l.fenced && heading.test(l.line));
-	if (start < 0) return [];
-	const rest = lines.slice(start + 1);
-	const end = rest.findIndex((l) => !l.fenced && /^#{1,2}[ \t]/.test(l.line));
-	return end < 0 ? rest : rest.slice(0, end);
-};
-/** Anything but a legible `low` is `high`: under-tiering is the risky direction. */
-const readRiskTier = (requirements) => {
-	return (sectionLines(requirements, "Risk Tier").find((l) => !l.fenced && l.line.trim() !== "")?.line)?.trim().split(/\s+/)[0]?.replace(/[`*_]/g, "").toLowerCase() === "low" ? "low" : "high";
-};
-const CONTROL = /[\x00-\x1f\x7f-\x9f\u2028\u2029]/g;
-const tidy = (text) => text.replace(/\s+/g, " ").replace(CONTROL, "").trim();
-const productionSignals = (requirements) => {
-	const items = [];
-	for (const { line, fenced } of sectionLines(requirements, "Production Signals")) {
-		if (fenced) continue;
-		const top = /^[-*+][ \t]+(.*)$/.exec(line);
-		if (top !== null) items.push(top[1]);
-	}
-	return items.map(tidy).filter((item) => item !== "");
-};
-/** The tier is always marked, first, so the last `risk-tier` mark opens the current lap's marks. */
-const recordRisk = () => {
-	const requirements = read(REQUIREMENTS);
-	const tier = readRiskTier(requirements);
-	mark("risk-tier", tier);
-	for (const signal of productionSignals(requirements)) mark("production-signal", signal);
-	return tier;
-};
-//#endregion
-//#region src/workflows/feature/steps.ts
-/** Turn the sketch since `base` into `.gtd/REQUIREMENTS.md`. */
-const triage = (base) => agentWithSkills("triage", designTriagePrompt(base, riskTierOn()), {
-	label: "Triaging the change",
-	file: REQUIREMENTS,
-	mode: "qa",
-	model: planner(),
-	system: designSystem()
-});
-const answerProductQuestions = () => human("gate.answer", {
-	message: designGateAnswerMessage(riskTierOn()),
-	label: "Awaiting your product answers",
-	file: REQUIREMENTS,
-	mode: "qa",
-	acceptClean: true
-});
-/** Turn the refactor review round `capture` describes into `.gtd/REFACTOR.md`, or change nothing. */
-const refactorCollecting = (capture, round, strays) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture, {
-	strays,
-	round
-}), {
-	label: "Collecting your refactor feedback",
-	file: REFACTOR,
-	model: planner(),
-	system: reviewerSystem(),
-	allowEmpty: true
-});
-//#endregion
-//#region src/workflows/feature/planning.ts
-/**
-* Always stop for the human. Resolves `true` when the round changed anything
-* (the author revises), `false` on a clean re-run. Open threads refuse every
-* landing; unticked questions only refuse a round with no thread for the
-* agent to answer.
-*/
-const noteGate = async (file, answer) => {
-	await answer();
-	requireThreadsClosed(file);
-	if (changes().length === 0) return false;
-	if (!hasThreadFor("agent", file)) requireAnswers(file);
-	return true;
-};
-/** Triage the sketch since `base` into requirements, until no product question is open; `guard` holds every round's criteria. */
-const design = (base, guard) => scope("design", async () => {
-	do {
-		await triage(base);
-		requireProgress(REQUIREMENTS);
-		requireReplies(REQUIREMENTS);
-		requireCriteria(REQUIREMENTS);
-		requireImpact(REQUIREMENTS);
-		requireReleaseFlag(REQUIREMENTS);
-		guard?.();
-	} while (await noteGate(REQUIREMENTS, answerProductQuestions));
-});
-//#endregion
-//#region src/workflows/feature/green.ts
-const green = () => healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
-	label: "Fixing the check",
-	file: FEEDBACK,
-	model: coder(),
-	system: builderSystem()
-}), {
-	guard: () => requireCriteriaFrozen(REQUIREMENTS),
-	guardRests: false
-});
-//#endregion
-//#region src/workflows/feature/refactor.ts
-const REFACTOR_PACKAGE = REFACTOR;
-const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
-const requireWithin = (allowed) => {
-	const outside = changes().map((c) => c.path).filter((path) => isCode(path) && !allowed.includes(path));
-	if (outside.length === 0) return;
-	refuse(`gtd land: refactor-scope: the refactor may change only its stray paths — revert these:\n${outside.map((path) => `  - ${path}`).join("\n")}`);
-};
-const isTestFile = (path) => testFileGlobs.some((glob) => matches(path, glob));
-const requireNoTestFiles = () => {
-	const tests = changes().map((c) => c.path).filter((path) => isCode(path) && isTestFile(path));
-	if (tests.length === 0) return;
-	refuse(`gtd land: refactor-tests: the refactor may not change a test file — revert these:\n${tests.map((path) => `  - ${path}`).join("\n")}`);
-};
-const holdsCallSites = (path) => !path.endsWith(".feature") && !path.endsWith(".snap");
-const COMMENT = /(?<![*/])\/\*[\s\S]*?\*\/|(?<!:)\/\/.*$/gm;
-const ASSERTION = /\b(?:expect|assert\w*)\s*[.(]/g;
-const TEST_CASE = /(?<![.\w])x?(?:it|test|describe)\s*[.(]/g;
-const MODIFIER = /(?<![.\w])(?:it|test|describe)\.(skip|only|todo|fails|skipIf|runIf)\b|(?<![.\w])(x)(?:it|test|describe)\b/g;
-const counts = (text) => {
-	const live = text.replace(COMMENT, "");
-	const modifiers = [...live.matchAll(MODIFIER)].map((m) => m[1] ?? m[2]).sort();
-	return JSON.stringify([
-		[...live.matchAll(ASSERTION)].length,
-		[...live.matchAll(TEST_CASE)].length,
-		modifiers
-	]);
-};
-const tested = (text) => {
-	const live = text.replace(COMMENT, "");
-	return live.search(ASSERTION) >= 0 || live.search(TEST_CASE) >= 0;
-};
-const callSitesOnly = ({ path, status, before, after }) => status === "modified" && holdsCallSites(path) && before !== void 0 && after !== void 0 && tested(before) && counts(before) === counts(after);
-/**
-* The test-file half of the refactor guard: an existing test may follow a changed call shape,
-* nothing more. Returns the test files it admitted, which the scope check then allows.
-*/
-const requireTestCallSitesOnly = () => {
-	const tests = changes().filter((c) => isCode(c.path) && isTestFile(c.path));
-	const refused = tests.filter((c) => !callSitesOnly(c)).map((c) => c.path);
-	if (refused.length > 0) refuse(`gtd land: refactor-tests: the refactor may update an existing test file's call sites only — never add, delete, skip or comment out a test or an assertion, or touch a snapshot, a .feature file or test data; revert these:\n${refused.map((path) => `  - ${path}`).join("\n")}`);
-	return tests.map((c) => c.path);
-};
-const flagExpression = (pattern) => {
-	if (pattern.trim() === "") throw new Error("gtd: refactorFlagPattern must not be blank");
-	let expression;
-	try {
-		expression = new RegExp(pattern, "g");
-	} catch (error) {
-		throw new Error(`gtd: refactorFlagPattern is not a valid regular expression: ${String(error)}`);
-	}
-	if (expression.test("")) throw new Error("gtd: refactorFlagPattern must not match the empty string");
-	return expression;
-};
-const countFlags = (text, expression, into) => {
-	let zeroLength = false;
-	for (const [name] of text.matchAll(expression)) if (name === "") zeroLength = true;
-	else into.set(name, (into.get(name) ?? 0) + 1);
-	return zeroLength;
-};
-const listPaths = (paths) => paths.map((path) => `  - ${path}`).join("\n");
-const requireNoNewFlags = (pattern, since) => {
-	const expression = flagExpression(pattern);
-	const before = /* @__PURE__ */ new Map();
-	const after = /* @__PURE__ */ new Map();
-	const unreadable = [];
-	const zeroLength = [];
-	for (const { path, status, before: was, after: now } of changesSince(since)) {
-		if (!isCode(path)) continue;
-		const oldSide = status === "added" ? "" : was;
-		const newSide = status === "deleted" ? "" : now;
-		if (oldSide === void 0 || newSide === void 0) {
-			unreadable.push(path);
-			continue;
-		}
-		countFlags(oldSide, expression, before);
-		if (countFlags(newSide, expression, after)) zeroLength.push(path);
-	}
-	if (unreadable.length > 0) refuse(`gtd land: refactor-flags: cannot compare flag reads in:\n${listPaths(unreadable)}`);
-	if (zeroLength.length > 0) refuse(`gtd land: refactor-flags: refactorFlagPattern (${pattern}) produced a zero-length match in:\n${listPaths(zeroLength)}`);
-	const raised = [...after].filter(([name, count]) => count > (before.get(name) ?? 0));
-	if (raised.length === 0) return;
-	refuse(`gtd land: refactor-flags: the refactor may not introduce or add reads of a flag (${pattern}):\n${raised.map(([name, count]) => `  - ${name}: ${before.get(name) ?? 0} → ${count}`).join("\n")}`);
-};
-/** A test-file stray is never refactored: the implement turn still reads it in the naive tip. */
-const refactorStrays = (shape) => shape.strays.filter((path) => !isTestFile(path));
-const packageLines = (strays, pattern, reference) => [
-	"# Behaviour-neutral refactor",
-	"",
-	"## Scope (read-only)",
-	"",
-	...strays.map((path) => `- \`${path}\``),
-	"",
-	"This list is fixed when the package is derived: editing it here widens or narrows nothing.",
-	"",
-	"## Rules",
-	"",
-	"- The suite's outcome must not change",
-	"- Change only the paths above, plus an existing test file where a changed call shape reaches it: never add or delete a test file, and never add, remove or alter a test or an assertion",
-	`- Introduce no flag read and add no second read of an existing one (\`${pattern}\`)`,
-	"",
-	"## Reference",
-	"",
-	...reference === void 0 ? ["None."] : [
-		`Reading material only, never applied: \`git show ${reference} -- ${strays.map(quote).join(" ")}\``,
-		"",
-		"Its changes to the existing code above are the seam this refactor exists to land, minus the feature's own behaviour."
-	],
-	""
-];
-const demoteHeadings = (text) => {
-	const marked = markFenced(text.trimEnd());
-	const lines = marked.map((m) => m.line);
-	const headings = marked.map((m) => m.fenced ? void 0 : /^(#{1,6}) /.exec(m.line)?.[1]?.length);
-	const shift = 3 - Math.min(...headings.filter((n) => n !== void 0));
-	return lines.map((line, i) => {
-		const depth = headings[i];
-		if (depth === void 0) return line;
-		return "#".repeat(Math.min(6, depth + shift)) + line.slice(depth);
-	});
-};
-const deriveScript = (lines) => `mkdir -p .gtd
-printf '%s\\n' ${lines.map(quote).join(" ")} > ${quote(REFACTOR_PACKAGE)}
-`;
-/** Undefined for every shape that is not a readable `refactor-first`; throws on a bad flag pattern. */
-const plan = (shape, options) => {
-	if (shape.choice !== "refactor-first" || shape.unreadable.length > 0) return void 0;
-	const pattern = vars.refactorFlagPattern ?? defaults.refactorFlagPattern;
-	const expression = flagExpression(pattern);
-	const strays = refactorStrays(shape);
-	if (strays.length === 0) return void 0;
-	const zeroLength = strays.filter((path) => countFlags(read(path) ?? "", expression, /* @__PURE__ */ new Map()));
-	if (zeroLength.length > 0) throw new Error(`gtd: refactorFlagPattern (${pattern}) produces a zero-length match in:\n${listPaths(zeroLength)}`);
-	return {
-		pattern,
-		strays,
-		reference: options.reference?.trim() ? options.reference : void 0,
-		note: options.note?.trim() ? options.note : void 0
-	};
-};
-const guardOf = ({ pattern, strays }, entry) => () => {
-	requireWithin([...strays, ...requireTestCallSitesOnly()]);
-	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, 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
-	});
-	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()
-		});
-		guard();
-	}, {
-		describeGuard: guard,
-		rules: refactorRules(strays, pattern)
-	});
-	await run("closing", removeScript([REFACTOR_PACKAGE]), { label: "Closing out the refactor" });
-};
-const strayAccess = (strays) => ({ write: [
-	...strays,
-	...testFileGlobs,
-	".gtd/**"
-] });
-const refactorFirst = async (shape, options = {}) => {
-	const p = plan(shape, options);
-	if (p === void 0) return false;
-	return scope({
-		name: "refactor",
-		access: strayAccess(p.strays)
-	}, async () => {
-		await refactorLap(p, guardOf(p, head()));
-		return true;
-	});
-};
-/**
-* `refactorFirst` plus its review, in the one `refactor` scope so the tail's
-* steps are `refactor.build.*`. A review edit re-runs the refactor, never a
-* re-plan: the collected notes ride the re-derived package. Every round
-* reviews the whole refactor since `entry`, since each lap rebuilds over it.
-*/
-const reviewedRefactor = async (shape, options = {}) => {
-	const p = plan(shape, options);
-	if (p === void 0) return false;
-	return scope({
-		name: "refactor",
-		access: strayAccess(p.strays)
-	}, async () => {
-		const entry = head();
-		const guard = guardOf(p, entry);
-		const feedback = {
-			file: REFACTOR_PACKAGE,
-			collecting: (capture, round) => refactorCollecting(capture, round, p.strays),
-			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
-		};
-		let collected;
-		for (;;) {
-			await refactorLap(p, guard, collected);
-			const outcome = await buildTail(entry, {
-				green: true,
-				guard,
-				guardRests: false,
-				lenses: lensEntriesOf(vars.refactorQualityReviews ?? ""),
-				feedback,
-				fixAccess: strayAccess(p.strays),
-				lensBase: entry,
-				rules: refactorRules(p.strays, p.pattern),
-				lap: "refactor"
-			});
-			if (outcome.verdict === "signoff") return true;
-			await reUnwind(outcome);
-			collected = read(REFACTOR_PACKAGE);
-			if (collected === void 0) throw new Error(`gtd: review feedback left no ${REFACTOR_PACKAGE}`);
-		}
-	});
-};
-//#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;
-/** A change to an existing file outside the allowlist is a stray even when the task needs it: the judge decides. */
-const judgeSeam = (tip) => judgeDiffShape("judge", {
-	changes: tip.changes,
-	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), {
-	label: retry === void 0 ? "Writing the naive pass" : "Rewriting the naive pass",
-	keep: true,
-	model: coder(),
-	system: builderSystem()
-});
-const IMPORTED = /(?:\bfrom|\bimport|\brequire\s*\(|\bmock\s*\()\s*\(?\s*(["'`])([^"'`\n]+)\1/g;
-const EXTENSION = /\.[\w-]+$/;
-const ALIAS = /^(?:[@~]\/|#)/;
-/** The specifiers an added `path` answers to: itself, without its extension, and its directory for an `index`. */
-const namesOf = (path) => {
-	const bare = path.replace(EXTENSION, "");
-	return posix.basename(bare) === "index" ? [
-		path,
-		bare,
-		posix.dirname(bare)
-	] : [path, bare];
-};
-/**
-* The repository paths `test` imports, each with and without an extension: a
-* relative specifier resolved from its directory, an aliased one (`@/`, `~/`,
-* `#`) as a path tail, anything else as written. Comments are skipped; a
-* computed import goes unseen.
-*/
-const importsOf = (test) => [...(test.after ?? "").replace(COMMENT, "").matchAll(IMPORTED)].flatMap(([, , spec]) => {
-	const relative = /^\.\.?(\/|$)/.test(spec);
-	const tail = ALIAS.test(spec);
-	const path = relative ? posix.join(posix.dirname(test.path), spec) : spec.replace(ALIAS, "");
-	return [path, path.replace(EXTENSION, "")].map((p) => ({
-		path: p,
-		tail
-	}));
-});
-const reaches = (imports, added) => namesOf(added).some((name) => imports.some(({ path, tail }) => name === path || tail && name.endsWith(`/${path}`)));
-const acceptanceTests = (changes) => changes.filter((c) => c.after !== void 0 && isCode$1(c.path) && isTestFile(c.path));
-/**
-* Why `tip`'s tests fall short, or `undefined`: a test importing a file the
-* pass added — naive structure a reset and refactor replaces, which the tests
-* must survive.
-*/
-const acceptanceFault = (tip) => {
-	const added = tip.changes.filter((c) => c.status === "added" && isCode$1(c.path) && !isTestFile(c.path)).map((c) => c.path);
-	const reaching = acceptanceTests(tip.changes).filter((test) => holdsCallSites(test.path)).flatMap((test) => {
-		const imports = importsOf(test);
-		return added.filter((path) => reaches(imports, path)).map((path) => `  - ${test.path} → ${path}`);
-	});
-	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`: every test file it added or changed. */
-const naiveAcceptance = (tip) => ({
-	hash: tip.hash,
-	tests: acceptanceTests(tip.changes).map((c) => c.path)
-});
-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
-* `true` when green. The pass's paths go back to HEAD before (an interrupted
-* run left them applied) and after; afterwards so does anything else the run
-* changed, judged against what was already dirty, which is left alone.
-*/
-const naiveGreen = (tip) => {
-	const paths = tip.changes.map((c) => restore(c.path));
-	return check("check", [
-		...paths,
-		"dirty=$(git -c core.quotePath=false ls-files -m -d -o --exclude-standard)",
-		`if ! git diff --binary --no-color --no-ext-diff --no-textconv --src-prefix=a/ --dst-prefix=b/ ${quote(`${tip.hash}^`)} ${quote(tip.hash)} -- | git apply --whitespace=nowarn; then`,
-		"  echo 'gtd: the kept naive pass no longer applies to HEAD; no test ran'",
-		"  exit 1",
-		"fi",
-		"(",
-		env.testCommand ?? "",
-		")",
-		"code=$?",
-		...paths,
-		"git -c core.quotePath=false ls-files -m -d -o --exclude-standard | while IFS= read -r path; do",
-		"  printf '%s\\n' \"$dirty\" | grep -qxF -- \"$path\" && continue",
-		"  if git cat-file -e \"HEAD:$path\" 2>/dev/null; then git checkout -q HEAD -- \"$path\"; else rm -f -- \"$path\"; fi",
-		"done",
-		"exit \"$code\""
-	].join("\n"), {
-		report: FEEDBACK,
-		label: "Running the naive pass's tests"
-	});
-};
-/** Resolves `false` when the tip no longer applies (the failure is in `.gtd/FEEDBACK.md`) or has nothing outside `.gtd/` to apply. */
-const applied = async (tip) => {
-	await run("applying", applyScript(tip, FEEDBACK, naiveApplyFailure(tip), [".gtd"]), { label: "Applying the naive pass" });
-	return !wrote(".gtd/FEEDBACK.md") && codeChanges().length > 0;
-};
-const build = async (options) => {
-	await agentWithSkills("building", implementBuildingPrompt(options.reference, options.amend, options.afterRefactor, requestedFlag(), options.rebuild), {
-		label: "Implementing",
-		model: coder(),
-		system: builderSystem(),
-		...options.afterRefactor === true ? { allowEmpty: true } : {}
-	});
-	requireCriteriaFrozen(REQUIREMENTS);
-};
-async function implement(first, tier, amend) {
-	await implementing(typeof first === "object" && first !== null ? first : {
-		reference: first,
-		tier,
-		amend
-	});
-}
-/** `implement`, resolving with the criterion IDs the requirements listed when it closed. */
-const implementing = (options) => scope("implement", async () => {
-	if (options.naive === void 0 || !await applied(options.naive)) await build(options);
-	else requireCriteriaFrozen(REQUIREMENTS);
-	await green();
-	const ids = criterionIds(read(".gtd/REQUIREMENTS.md") ?? "");
-	await run("closing", removeScript([REQUIREMENTS, REFACTOR_NOTE]), { label: "Closing out the implementation" });
-	return ids;
-});
-/** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
-const steer = async (retry) => {
-	await human("steer", {
-		message: seamSteerMessage(retry, flagged()),
-		label: "Steer or overrule the naive pass",
-		file: REQUIREMENTS,
-		acceptClean: true
-	});
-	if (changes().length === 0) return false;
-	requireCriteria(REQUIREMENTS);
-	return true;
-};
-/** Rejects, test faults and red checks share one budget; a steer or an overrule refills it. */
-const budget = () => {
-	let retries = 0;
-	return async (next) => {
-		if (retries < NAIVE_RETRIES) {
-			retries++;
-			return {
-				kind: "retry",
-				retry: next
-			};
-		}
-		const steered = await steer(next);
-		retries = 0;
-		if (read(".gtd/FEEDBACK.md") !== void 0) await run("clear", removeScript([FEEDBACK]), { label: "Clearing the red check" });
-		return { kind: steered ? "steered" : "overruled" };
-	};
-};
-/** 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(tip);
-	if (fault !== void 0) {
-		const verdict = await vetting.again({
-			fault,
-			hash: tip.hash
-		});
-		if (verdict.kind !== "overruled") return verdict;
-		vetting.waived = true;
-	}
-	if (await naiveGreen(tip)) return void 0;
-	const verdict = await vetting.again({ red: tip.hash });
-	return verdict.kind === "overruled" ? void 0 : verdict;
-};
-/** 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,
-		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,
-		tip
-	} : next;
-};
-/** Back to `before`: every code path, and the notes file. `.gtd/` edits (the requirements) stay. */
-const untryScript = (before) => {
-	const code = changesSince(before).filter((c) => isCode$1(c.path));
-	return restoreScript(head(), {
-		restore: code.filter((c) => c.status !== "added").map((c) => c.path),
-		remove: [...code.filter((c) => c.status === "added").map((c) => c.path), NAIVE_TEST]
-	}, before);
-};
-/**
-* A person tries the green pass `tip` in the working tree. Resolves
-* `undefined` on a clean landing (signed off), else what they sent back;
-* either way the pass, their code edits and the notes file leave the tree.
-*/
-const tried = async (tip) => {
-	const before = head();
-	await run("applying", applyScript(tip.hash, FEEDBACK, naiveApplyFailure(tip.hash), [".gtd"]), { label: "Applying the naive pass to try it" });
-	await human("try", {
-		message: naiveTryMessage(flagged()),
-		label: "Try the naive pass",
-		file: NAIVE_TEST,
-		acceptClean: true
-	});
-	const landed = changes();
-	const edits = landed.some((c) => isCode$1(c.path)) ? head() : void 0;
-	const notes = read(".gtd/NAIVE-TEST.md")?.trim() || void 0;
-	if (landed.some((c) => c.path === ".gtd/REQUIREMENTS.md")) requireCriteria(REQUIREMENTS);
-	await run("restoring", untryScript(before), { label: "Taking the naive pass out again" });
-	return landed.length === 0 ? void 0 : {
-		tested: tip.hash,
-		notes,
-		edits
-	};
-};
-const decide = () => scope("seam", async () => {
-	const vetting = {
-		again: budget(),
-		waived: false
-	};
-	let retry;
-	for (;;) {
-		await naivePass(retry);
-		const tip = kept("naive");
-		const verdict = await vetted(tip, vetting);
-		if (verdict === void 0 && naiveTestOn()) {
-			const sentBack = await tried(tip);
-			if (sentBack !== void 0) {
-				vetting.again = budget();
-				retry = sentBack;
-				continue;
-			}
-		}
-		const outcome = verdict ?? (flagged() ? await ruled(tip, vetting.again) : {
-			reference: tip.hash,
-			tip
-		});
-		if (!("kind" in outcome)) return outcome;
-		retry = outcome.kind === "retry" ? outcome.retry : void 0;
-	}
-});
-/** 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) => {
-	const { reference, tip, shape } = await decide();
-	if (shape === void 0) return {
-		reference,
-		base,
-		land: true
-	};
-	if (shape.unreadable.length > 0) {
-		await scope("seam", () => human("by-hand", {
-			message: seamByHandMessage(shape.strays, shape.unreadable, reference),
-			label: "Reviewing unreadable files by hand",
-			acceptClean: true
-		}));
-		return {
-			reference,
-			base,
-			rebuild: { acceptance: naiveAcceptance(tip) }
-		};
-	}
-	const strays = refactorStrays(shape);
-	if (strays.length === 0) return {
-		reference,
-		base,
-		rebuild: { acceptance: naiveAcceptance(tip) }
-	};
-	const note = await scope("seam", () => refactorNote(reference, strays));
-	const refactored = await reviewedRefactor(shape, {
-		reference,
-		note
-	});
-	return {
-		reference,
-		base: head(),
-		refactored,
-		rebuild: {
-			note,
-			acceptance: naiveAcceptance(tip)
-		}
-	};
-};
-//#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 when a release flag is asked for), 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 handedOut = new Set(listedIds());
-	const seam = await seamBuild(firstBase);
-	const used = gather(handedOut);
-	const requirements = read(REQUIREMENTS);
-	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 buildTail(base, {
-		green: true,
-		lensBase: base,
-		requirements
-	});
-	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];
-};
-const featureFeedback = async (first, lensBase, ids) => {
-	let outcome = first;
-	let closed = ids.closed;
-	const handedOut = /* @__PURE__ */ new Set([...ids.used, ...ids.closed]);
-	while (outcome.verdict === "feedback") {
-		await reUnwind(outcome);
-		const lap = {
-			closed,
-			used: [...handedOut]
-		};
-		await design(outcome.base, () => {
-			requireStableIds(REQUIREMENTS, lap);
-			gather(handedOut);
-		});
-		const tier = riskTierOn() ? recordRisk() : void 0;
-		const requirements = read(REQUIREMENTS);
-		closed = await implementing({
-			tier,
-			amend: true
-		});
-		outcome = await buildTail(outcome.base, {
-			green: true,
-			lensBase,
-			requirements,
-			lap: "feedback"
-		});
-	}
-};
-/** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
-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. */
-const afterTail = async (first) => {
-	let outcome = first;
-	while (outcome.verdict === "feedback") {
-		await reUnwind(outcome);
-		await design(outcome.base);
-		const tier = riskTierOn() ? recordRisk() : void 0;
-		const requirements = read(REQUIREMENTS);
-		await implement({
-			tier,
-			amend: true
-		});
-		outcome = await buildTail(outcome.base, {
-			green: true,
-			requirements
-		});
-	}
-};
-/** An ordinary start: wait at `idle`, unwind the sketch, check the baseline, then plan and build. */
-const ordinaryStart = async () => {
-	await human("idle", {
-		message: idleMessage(),
-		label: "Idle",
-		file: ".gtd/TODO.md"
-	});
-	refusePendingHandOff();
-	naiveTestOn();
-	const stated = statedCriteria(changes(), head());
-	await unwind();
-	if (changes(".gtd/FEEDBACK.md").some((c) => c.status !== "deleted")) await human("unwind-failed", {
-		message: unwindFailedMessage(),
-		label: "Could not unwind your input",
-		file: FEEDBACK
-	});
-	await gate("start-gate", startGateBlockedMessage());
-	await planAndBuild(start(), stated);
-};
-const feature = shipped(ordinaryStart);
-//#endregion
-//#region src/workflows/feature/index.ts
-var feature_default = feature;
-//#endregion
-export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, collecting, criteriaOf, criterionIds, feature_default as default, defaults, design, envDefaults, feature, fixNits, hasImpact, holdsCallSites, implement, implementing, isTestFile, judgeSeam, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireCriteria, requireCriteriaFrozen, requireImpact, requireImpactOnly, requireNoNewFlags, requireNoTestFiles, requireStableIds, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, statedCriteria, steering, summary, triage, unstableIds, unwind };