@pmelab/gtd 23.2.0 → 24.1.0

package/dist/wire.mjs

@@ -0,0 +1,2 @@
+import { C as EXIT_SIGTERM, D as WIRE_SCHEMA, E as UNATTRIBUTED_MODEL, O as renderFormat, S as EXIT_SIGINT, T as ACCESS_REFUSAL, _ as demandOf, a as landFields, b as EXIT_OK, c as renderLandJson, d as renderBeatPlain, f as beatDocument, g as beatKindOf, h as BEAT_KINDS, i as judgeJson, l as renderLandPlain, m as statusOf, n as resolveSession, o as landProseText, p as renderBeatJson, r as selectPath, s as noopText, t as globMatches, u as DEMAND_BRIEFING, v as stallDiagnosis, w as EXIT_USAGE_ERROR, x as EXIT_RUNTIME_ERROR, y as EXIT_CODES } from "./chunks/wire-DA7q2ikx.mjs";
+export { ACCESS_REFUSAL, BEAT_KINDS, DEMAND_BRIEFING, EXIT_CODES, EXIT_OK, EXIT_RUNTIME_ERROR, EXIT_SIGINT, EXIT_SIGTERM, EXIT_USAGE_ERROR, UNATTRIBUTED_MODEL, WIRE_SCHEMA, beatDocument, beatKindOf, demandOf, globMatches, judgeJson, landFields, landProseText, noopText, renderBeatJson, renderBeatPlain, renderFormat, renderLandJson, renderLandPlain, resolveSession, selectPath, stallDiagnosis, statusOf };

package/dist/workflow-kit.mjs

@@ -0,0 +1,352 @@
+import { changes, changesSince, hasThreadFor, head, read, refuse, requireReplies, requireThreadsClosed, scope } from "./flows.mjs";
+import { c as stripCodeThreads, d as reviewNotes, f as reviewRisks } from "./chunks/steering-D-PvRC5W.mjs";
+//#region src/workflow-kit/health.ts
+/** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */
+const escalation = async (count, steps) => {
+	if (count.rounds >= steps.limit) return steps.exhausted();
+	count.rounds++;
+	await steps.describe();
+	await steps.stop();
+};
+/** Run `check` again while `pending()` holds — a run then does not count — and resolve the first run that does. */
+const untilSettled = async (check, pending) => {
+	for (;;) {
+		const green = await check();
+		if (!pending()) return green;
+	}
+};
+const STAMP = /\n<!-- gtd check [0-9a-f]+ -->\n?$/;
+const stripStamp = (text) => text.replace(STAMP, "\n");
+/**
+* Loop until the suite is green: check, and on red run `fix` — escalating
+* first once `fixCap` fixes are spent, or `sameFailure` calls the failure
+* identical to the previous round's.
+*/
+const healthy = async (fix, health) => {
+	let fixes = health.fixesSoFar ?? 0;
+	let previous;
+	for (;;) {
+		if (await health.check()) {
+			health.escalations.rounds = 0;
+			return;
+		}
+		const current = stripStamp(read(health.report) ?? "");
+		const stuck = previous !== void 0 && await health.sameFailure(previous, current);
+		previous = current;
+		if (stuck || fixes >= health.fixCap) {
+			await escalation(health.escalations, health.escalation);
+			fixes = 0;
+		}
+		fixes++;
+		await fix();
+	}
+};
+/** Hold the process in scope `name` until `passes` resolves `true`, resting at `blocked` between tries. */
+const gate = (name, passes, blocked) => scope(name, async () => {
+	while (!await passes()) await blocked();
+});
+//#endregion
+//#region src/workflow-kit/quality.ts
+/** Split a comma-separated lens list: trimmed, blanks dropped. */
+const lensesOf = (value) => value.split(",").map((lens) => lens.trim()).filter((lens) => lens.length > 0);
+/** One `<scope>.<lens>` entry per lens — the per-lens part of a skills or access export. */
+const lensScopes = (scope, lenses, entry) => Object.fromEntries(lenses.map((lens) => [`${scope}.${lens}`, entry(lens)]));
+/** One `review` turn per lens, each appending its findings to `findings`; resolves `"findings"` when that file has any. */
+const qualityLap = async (lenses, review, findings) => {
+	for (const lens of lenses) await review(lens);
+	return (read(findings) ?? "").length > 0 ? "findings" : "clean";
+};
+/** Resolves `true` once `findings` is gone, `false` when `cap` turns escalated instead. */
+const fixFindings = async (f) => {
+	for (let turns = 0; turns < f.cap; turns++) {
+		await f.fix();
+		if (read(f.findings) === void 0) return true;
+	}
+	await f.escalate();
+	return false;
+};
+//#endregion
+//#region src/workflow-kit/scenarios.ts
+const DOC_STRING = /^(\s*)("""|```)/;
+/**
+* Gherkin wording only: lines trimmed; blank, `#` comment and `@` tag lines
+* dropped — except inside a doc string, whose content is test input: kept
+* whole, indented relative to its opening delimiter (as Gherkin reads it).
+*/
+const scenarioText = (source) => {
+	const out = [];
+	let doc;
+	for (const line of source.split("\n")) {
+		const delimiter = DOC_STRING.exec(line);
+		if (doc === void 0 && delimiter !== null) {
+			doc = {
+				indent: delimiter[1].length,
+				fence: delimiter[2]
+			};
+			out.push(line.trim());
+		} else if (doc !== void 0 && line.trim().startsWith(doc.fence)) {
+			doc = void 0;
+			out.push(line.trim());
+		} else if (doc !== void 0) {
+			const lead = line.length - line.trimStart().length;
+			out.push(line.slice(Math.min(lead, doc.indent)).trimEnd());
+		} else {
+			const trimmed = line.trim();
+			if (trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("@")) out.push(trimmed);
+		}
+	}
+	return out.join("\n");
+};
+const textOf = (path) => {
+	const source = read(path);
+	return source === void 0 ? void 0 : scenarioText(source);
+};
+/** Snapshot `.feature` paths at `head()`, merged over `previous`; `undefined` when nothing is frozen. */
+const freezeScenarios = (paths, previous) => {
+	if (paths.length === 0) return previous;
+	const texts = { ...previous?.texts };
+	for (const path of paths) {
+		const text = textOf(path);
+		if (text !== void 0) texts[path] = text;
+	}
+	return Object.keys(texts).length === 0 ? previous : {
+		at: head(),
+		texts
+	};
+};
+/** Paths whose wording differs from the snapshot (a deleted file counts). */
+const driftedScenarios = (frozen) => Object.entries(frozen.texts).filter(([path, text]) => textOf(path) !== text).map(([path]) => path);
+const lines = (text) => text === void 0 || text === "" ? [] : text.split("\n");
+/** `table[i][j]`: the longest common subsequence of `a[i..]` and `b[j..]`. */
+const lcsTable = (a, b) => {
+	const table = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+	return table;
+};
+/** Changed lines in file order, `- ` / `+ `-prefixed, so a moved or repeated step still shows. */
+const lineDiff = (a, b) => {
+	const table = lcsTable(a, b);
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) if (a[i] === b[j]) {
+		i++;
+		j++;
+	} else if (table[i + 1][j] >= table[i][j + 1]) out.push(`- ${a[i++]}`);
+	else out.push(`+ ${b[j++]}`);
+	return [
+		...out,
+		...a.slice(i).map((l) => `- ${l}`),
+		...b.slice(j).map((l) => `+ ${l}`)
+	];
+};
+const wordingDrift = (frozen, path) => ({
+	path,
+	lines: lineDiff(lines(frozen.texts[path]), lines(textOf(path)))
+});
+/**
+* After a turn: rest at `stop` while wording drifted from `frozen`. Whatever
+* still differs after it is accepted and moves the snapshot; what was
+* restored stays frozen as it was.
+*/
+const holdWording = async (frozen, stop) => {
+	if (frozen === void 0) return;
+	const drifted = driftedScenarios(frozen);
+	if (drifted.length === 0) return;
+	await stop(frozen.at, drifted.map((path) => wordingDrift(frozen, path)));
+	const accepted = driftedScenarios(frozen);
+	if (accepted.length === 0) return;
+	for (const path of accepted) {
+		const text = textOf(path);
+		if (text === void 0) delete frozen.texts[path];
+		else frozen.texts[path] = text;
+	}
+	frozen.at = head();
+};
+//#endregion
+//#region src/workflow-kit/review.ts
+const collect = async (p, capture) => {
+	await p.collecting(capture);
+	if (read(p.feedback) !== void 0) return "feedback";
+	if (changes().length === 0) return "signoff";
+	return refuse(p.refusals.unmatched);
+};
+/** A review with ticks, footnote markers and thread definitions removed: what is left is line notes. */
+const notesOf = (text) => text.replace(/^\[\^[^\]]+\]:[^\n]*(\n(?: {2,}|\t)[^\n]*|\n(?=\s*\n(?: {2,}|\t)))*/gm, "").replace(/\[\^[^\]]+\]/g, "").replace(/\[x\]/gi, "[ ]").replace(/\s+/g, " ").trim();
+/**
+* The human gate and its reply rounds: a question gets an answer inside
+* the review file and rests at the gate again, without a lap. Resolves the
+* commit of the last collecting turn, `"missing"` when the round left no
+* review, or `undefined` when no such turn ran.
+*/
+const converse = async (p, base, collectedBefore) => {
+	let collectedAt = collectedBefore;
+	for (;;) {
+		await p.awaitReview(base);
+		if (changes(p.file).some((c) => c.status === "deleted")) refuse(p.refusals.deleted);
+		if (read(p.file) === void 0) {
+			await p.reviewMissing(head());
+			return "missing";
+		}
+		requireThreadsClosed(p.file);
+		if (!hasThreadFor("agent", p.file)) return collectedAt;
+		await p.collecting(p.captures.edits(head()));
+		collectedAt = head();
+		requireReplies(p.file);
+		if (!hasThreadFor("human", p.file)) return collectedAt;
+	}
+};
+/** Judge every note, then run each verdict's route: answers, then nit fixes, then the edits' lap. */
+const routeNotes = async (p, notes, r) => {
+	const verdicts = await p.triage(notes);
+	const of = (v) => notes.filter((n) => (verdicts.get(n.id) ?? "edit") === v);
+	const [edits, questions, nits] = [
+		of("edit"),
+		of("question"),
+		of("nit")
+	];
+	if (edits.length + questions.length + nits.length === 0) return r.unfolded();
+	let answeredAt;
+	if (questions.length > 0) {
+		await p.answerQuestions(questions);
+		answeredAt = head();
+	}
+	if (nits.length > 0) {
+		await p.fixNits(nits);
+		await p.keepGreen();
+	}
+	if (edits.length > 0) {
+		await r.close();
+		return r.outcome(await collect(p, p.captures.editNotes(r.round, edits, answeredAt)));
+	}
+	if (nits.length > 0) {
+		await r.close();
+		return {
+			next: "rereview",
+			carry: answeredAt
+		};
+	}
+	return {
+		next: "await",
+		reviewed: answeredAt
+	};
+};
+/** A code edit, not a thread-only change: lines that only add, answer or remove code threads don't count. */
+const isCodeEdit = (p, c) => p.isCode(c.path) && stripCodeThreads(c.path, c.before ?? "") !== stripCodeThreads(c.path, c.after ?? "");
+/** Whether anything but thread edits and ticks landed in the review file since `commit`. */
+const notedSince = (p, commit) => changesSince(commit).some((c) => c.path === p.file && notesOf(c.before ?? "") !== notesOf(read(p.file) ?? ""));
+/**
+* What the in-loop collecting turn left: `folded` when it wrote `feedback`
+* (those folds need their lap whatever is judged later), `settled` when only
+* thread edits and ticks landed after it.
+*/
+const afterCollect = (p, collectedAt) => collectedAt === "" ? {
+	folded: false,
+	settled: false
+} : settledAfter(p, collectedAt);
+const settledAfter = (p, collectedAt) => ({
+	folded: collectedAt !== void 0 && read(p.feedback) !== void 0,
+	settled: collectedAt !== void 0 && changesSince(collectedAt).every((c) => !isCodeEdit(p, c)) && !notedSince(p, collectedAt)
+});
+const finish = async (p, reviewed, collectedAt) => {
+	const round = head();
+	const since = changesSince(reviewed);
+	const edited = since.filter((c) => isCodeEdit(p, c));
+	const baselineText = since.get(p.file)?.before ?? "";
+	const record = read(p.file) ?? "";
+	const { folded, settled } = afterCollect(p, collectedAt);
+	const noted = since.some((c) => c.path === p.file);
+	const close = () => p.close(round);
+	const outcome = (verdict) => verdict === "signoff" ? { verdict } : {
+		verdict,
+		base: round,
+		restoreFrom: reviewed,
+		edited
+	};
+	const unfolded = async () => {
+		await close();
+		return outcome(folded ? "feedback" : "signoff");
+	};
+	const collectWith = async (capture) => {
+		await close();
+		return outcome(await collect(p, capture));
+	};
+	if (settled || edited.length === 0 && !noted) return unfolded();
+	if (edited.length > 0) return collectWith(p.captures.edits(round));
+	const notes = reviewNotes(baselineText, record);
+	if (notes.length === 0) return collectWith(p.captures.notes(round));
+	return routeNotes(p, notes, {
+		round,
+		close,
+		outcome,
+		unfolded
+	});
+};
+/** Write the review; if it marks risks, fix them, keep green, and write it again — once, so the re-review's own risks reach the human unfixed. */
+const reviewOnce = async (p, base, carry) => {
+	await p.reviewing(base, carry);
+	const risks = reviewRisks(read(p.file) ?? "");
+	if (risks.length === 0) return;
+	await p.fixRisks(risks);
+	await p.keepGreen();
+	await p.reviewing(base, carry);
+};
+/**
+* A reviewer writes the review over everything since `base`, a human
+* reviews and signs off or comments, and each note is judged: edits go to
+* another lap, questions are answered in place, nits fixed in one batch,
+* praise dropped.
+*/
+const review = async (base, p) => {
+	let carry;
+	for (;;) {
+		await reviewOnce(p, base, carry);
+		carry = void 0;
+		let reviewed = head();
+		let collectedAt;
+		for (;;) {
+			collectedAt = await converse(p, base, collectedAt);
+			if (collectedAt === "missing") break;
+			const result = await finish(p, reviewed, collectedAt);
+			if (!("next" in result)) return result;
+			if (result.next === "rereview") {
+				carry = result.carry;
+				break;
+			}
+			reviewed = result.reviewed;
+		}
+	}
+};
+/**
+* A reviewer writes the review over everything since `base` and a human
+* reviews it. No note signs off and closes; any note ends the round with the
+* review left in place, for another workflow to read its notes — nothing is
+* judged or re-planned here.
+*/
+const reviewToHandOff = async (base, p) => {
+	for (;;) {
+		await reviewOnce(p, base, void 0);
+		const reviewed = head();
+		await p.awaitReview(base);
+		if (changes(p.file).some((c) => c.status === "deleted")) refuse(p.deleted);
+		const record = read(p.file);
+		if (record === void 0) {
+			await p.reviewMissing(head());
+			continue;
+		}
+		requireThreadsClosed(p.file);
+		if (hasThreadFor("agent", p.file)) refuse(p.threadsPending);
+		const since = changesSince(reviewed);
+		const before = since.get(p.file)?.before ?? record;
+		if (notesOf(before) === notesOf(record)) {
+			if (since.paths.some((f) => !f.startsWith(".gtd/"))) await p.keepGreen();
+			await p.close(head());
+			return;
+		}
+		if (reviewNotes(before, record).length === 0) refuse(p.unparsed);
+		await p.handOff(reviewed);
+		return;
+	}
+};
+//#endregion
+export { driftedScenarios, escalation, fixFindings, freezeScenarios, gate, healthy, holdWording, lensScopes, lensesOf, qualityLap, review, reviewToHandOff, scenarioText, untilSettled, wordingDrift };

package/dist/workflows/feature.mjs

@@ -0,0 +1,315 @@
+import { answered, changes, changesSince, glob, hasThreadFor, head, human, judge, numeric, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restoreScript, revertScript, run, scope, start, vars } from "../flows.mjs";
+import { freezeScenarios, review as review$1 } from "../workflow-kit.mjs";
+import { $ as unwindFailure, A as architectureAuthorPrompt, B as designTriagePrompt, C as fixCheck, D as reviewing, E as reviewMissing, F as buildReviewFixNitsPrompt, G as packagesItemFixSuitePrompt, I as buildReviewTriageMessage, K as reviewEditNotesCapture, L as builderSystem, M as architectureGateAnswerMessage, N as buildReviewAnswerQuestionsPrompt, O as agentWithSkills, P as buildReviewCollectingPrompt, Q as unwindFailedMessage, R as designGateAnswerMessage, S as coder, T as planner, U as idleMessage, W as packagesItemBuildingPrompt, X as reviewerSystem, Y as reviewNotesCapture, Z as startGateBlockedMessage, _ as ARCHITECTURE, b as REVIEW, c as refusePendingHandOff, d as shipped, f as defaults, g as healthy, h as gate, i as skills, j as architectureDecomposePrompt, k as architectSystem, l as tail, n as summary, o as closeReview, p as envDefaults, q as reviewEditsCapture, r as access, t as steering, u as guarded, v as FEEDBACK, w as fixRisks, x as awaitReview, y as REQUIREMENTS, z as designSystem } from "../chunks/reserved-ejn-LVYO.mjs";
+//#region src/workflows/feature/steps.ts
+/** Turn the sketch since `base` into `.gtd/REQUIREMENTS.md`. */
+const triage = (base) => agentWithSkills("triage", designTriagePrompt(base), {
+	label: "Triaging the change",
+	file: REQUIREMENTS,
+	mode: "qa",
+	model: planner(),
+	system: designSystem()
+});
+const author = () => agentWithSkills("author", architectureAuthorPrompt(), {
+	label: "Refining the technical plan",
+	file: ARCHITECTURE,
+	mode: "qa",
+	model: planner(),
+	system: architectSystem()
+});
+const decompose = () => agentWithSkills("decompose.decomposing", architectureDecomposePrompt(), {
+	label: "Decomposing into packages",
+	model: planner(),
+	system: architectSystem()
+});
+const answerProductQuestions = () => human("gate.answer", {
+	message: designGateAnswerMessage(),
+	label: "Awaiting your product answers",
+	file: REQUIREMENTS,
+	mode: "qa",
+	acceptClean: true
+});
+const answerTechnicalQuestions = () => human("gate.answer", {
+	message: architectureGateAnswerMessage(),
+	label: "Awaiting your technical answers",
+	file: ARCHITECTURE,
+	mode: "qa",
+	acceptClean: true
+});
+const build = (pkg) => agentWithSkills("building", packagesItemBuildingPrompt(pkg), {
+	label: "Building",
+	model: coder(),
+	system: builderSystem()
+});
+const fixSuite = () => agentWithSkills("fix.suite.fixing", packagesItemFixSuitePrompt(), {
+	label: "Fixing the check",
+	file: FEEDBACK,
+	model: coder(),
+	system: builderSystem()
+});
+/** Answer every `question` note inline in `.gtd/REVIEW.md`. */
+const answerReviewQuestions = (notes) => agentWithSkills("review.answer-review-questions", buildReviewAnswerQuestionsPrompt(notes), {
+	label: "Answering your questions",
+	file: REVIEW,
+	mode: "review",
+	model: planner(),
+	system: reviewerSystem()
+});
+/** Fix every `nit` note in one turn. */
+const fixNits = (notes) => agentWithSkills("review.fix.nits.fixing", buildReviewFixNitsPrompt(notes), {
+	label: "Fixing your nits",
+	file: REVIEW,
+	model: planner(),
+	system: reviewerSystem()
+});
+/** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
+const collecting = (capture) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture), {
+	label: "Collecting your feedback",
+	file: REQUIREMENTS,
+	mode: "qa",
+	model: planner(),
+	system: reviewerSystem(),
+	allowEmpty: true
+});
+//#endregion
+//#region src/workflows/feature/packages.ts
+/** Package 0: the e2e scenarios, written red. */
+const SCENARIO_PACKAGE = ".gtd/packages/00-e2e-scenarios.md";
+const TEST_LINE = /^\s*-\s+(unit|e2e):\s+`([^`]+)`/;
+/** The `## Tests` entries of a package file; malformed lines are ignored. */
+const declaredTests = (packageText) => {
+	const found = [];
+	let inTests = false;
+	for (const line of packageText.split("\n")) if (/^##\s/.test(line)) inTests = /^##\s+Tests\s*$/.test(line);
+	else if (inTests) {
+		const match = TEST_LINE.exec(line);
+		if (match) found.push({
+			level: match[1],
+			path: match[2]
+		});
+	}
+	return found;
+};
+/**
+* Refuse a build or fix turn unless every test `pkg` declares exists and is in the
+* diff since `since`. The package text is read as of `since`, so a builder
+* editing its own `## Tests` cannot dodge the guard; with `.gtd/SATISFIED.md`
+* written, existing in the tree suffices.
+*/
+const requireDeclaredTests = (pkg, since) => {
+	const range = changesSince(since);
+	const text = range.get(pkg)?.before ?? read(pkg) ?? "";
+	const satisfied = read(".gtd/SATISFIED.md") !== void 0;
+	const missing = declaredTests(text).map((test) => test.path).filter((path) => satisfied ? read(path) === void 0 : range.get(path) === void 0 || range.get(path)?.status === "deleted" || read(path) === void 0);
+	if (missing.length === 0) return;
+	refuse(`gtd land: declared-tests: ${pkg} declares tests that are ${satisfied ? "missing from the tree" : "not in the package's diff"} — write them first:\n${missing.map((path) => `  - ${path}`).join("\n")}`);
+};
+/** Build `pkg`, check its declared tests, keep the fast suite green, and close it out, which removes it. */
+const packageItem = async (pkg, frozen) => {
+	const from = head();
+	const declared = (turn) => async () => {
+		await turn();
+		requireDeclaredTests(pkg, from);
+	};
+	await guarded(frozen, declared(() => build(pkg)))();
+	await healthy(guarded(frozen, declared(fixSuite)), { suite: "fast" });
+	await run("closing", removeScript([pkg, ".gtd/SATISFIED.md"]), { label: "Closing out the package" });
+	return {
+		pkg,
+		from,
+		to: head()
+	};
+};
+/** The first queued package — the one a package step works on. */
+const nextPackage = () => [...glob(".gtd/packages/*.md")].sort()[0];
+const outsideGtd = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
+/** Build every package file under `.gtd/packages/`, in name order. */
+const packages = (carried) => scope("packages", async () => {
+	let frozen = carried;
+	const ranges = [];
+	let touched = [];
+	for (let pkg = nextPackage(); pkg !== void 0; pkg = nextPackage()) {
+		const range = await scope("item", () => packageItem(pkg, pkg === ".gtd/packages/00-e2e-scenarios.md" ? void 0 : frozen));
+		ranges.push(range);
+		if (pkg === ".gtd/packages/00-e2e-scenarios.md") {
+			touched = changesSince(range.from).filter((c) => outsideGtd(c.path) && c.status !== "deleted");
+			frozen = freezeScenarios(touched.filter((c) => c.path.endsWith(".feature")).map((c) => c.path), frozen);
+		}
+	}
+	const paths = (status) => touched.filter((c) => c.status === status).map((c) => c.path);
+	return {
+		ranges,
+		scenarios: {
+			added: paths("added"),
+			changed: paths("modified")
+		},
+		frozen
+	};
+});
+//#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. */
+const design = (base) => scope("design", async () => {
+	do {
+		await triage(base);
+		requireProgress(REQUIREMENTS);
+		requireReplies(REQUIREMENTS);
+	} while (await noteGate(REQUIREMENTS, answerProductQuestions));
+});
+/** Work out the technical plan, then decompose it into package files. */
+const architecture = () => scope("architecture", async () => {
+	do {
+		await author();
+		requireReplies(ARCHITECTURE);
+	} while (await noteGate(ARCHITECTURE, answerTechnicalQuestions));
+	await decompose();
+	if (changes(".gtd/packages/**").length === 0) refuse("gtd land: decompose: write at least one package under .gtd/packages/");
+	if (changes(".gtd/ARCHITECTURE.md").some((c) => c.status === "deleted")) refuse("gtd land: decompose: keep .gtd/ARCHITECTURE.md — the build tail's full run needs it; it is removed only once that run is green");
+});
+//#endregion
+//#region src/workflows/feature/review.ts
+const VERDICTS = [
+	"edit",
+	"question",
+	"nit",
+	"praise"
+];
+/** One four-way choice per note the human added to `.gtd/REVIEW.md`. */
+const verdictQuestion = (note) => ({
+	id: note.id,
+	primitive: "choice",
+	instructions: `Classify the human's note on review item "${note.anchor}" (in .gtd/REVIEW.md). Its evidence holds the anchor, the reviewer's text and the human's text.`,
+	criteria: "edit: a request to change behaviour, design or scope — anything needing a plan, or any note you are unsure about. question: asks something and wants an answer, with no change requested. nit: a small, local, unambiguous fix (naming, typo, formatting, comment wording) needing no re-plan. praise: an approving remark with nothing to do."
+});
+/**
+* One judge rest, one verdict per note. Dismissing a note is the risky
+* direction, so only a confident non-`edit` verdict on uncut evidence counts;
+* a cut, unanswered or below-floor note is an `edit`, and a blank floor makes
+* every note one.
+*/
+const triage$1 = async (notes) => {
+	const { answers, truncated } = await judge("review.triage", {
+		questions: notes.map(verdictQuestion),
+		evidence: Object.fromEntries(notes.map((n) => [n.id, `Anchor: ${n.anchor}\nReviewer's text: ${n.before}\nHuman's text: ${n.text}`])),
+		message: buildReviewTriageMessage(),
+		label: "Judging each note"
+	});
+	const minP = numeric(vars.reviewNoteActionable, Infinity);
+	return new Map(notes.map((n) => {
+		const verdict = VERDICTS.find((v) => v !== "edit" && answered(answers[n.id], v, minP));
+		return [n.id, truncated.includes(n.id) || verdict === void 0 ? "edit" : verdict];
+	}));
+};
+const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
+/**
+* A reviewer writes `.gtd/REVIEW.md` over everything since `base`, a human
+* reviews and signs off or comments, and each note is judged: edits go to
+* another planning lap, questions are answered in place, nits fixed in one
+* batch, praise dropped.
+*/
+const review = (base, escalations = { rounds: 0 }, frozen) => review$1(base, {
+	file: REVIEW,
+	feedback: REQUIREMENTS,
+	isCode,
+	reviewing,
+	fixRisks: (risks) => guarded(frozen, () => fixRisks(risks), "review")(),
+	keepGreen: () => healthy(guarded(frozen, fixCheck, "review"), { escalations }),
+	awaitReview,
+	reviewMissing,
+	collecting,
+	triage: triage$1,
+	answerQuestions: answerReviewQuestions,
+	fixNits: (notes) => guarded(frozen, () => fixNits(notes), "review")(),
+	close: closeReview,
+	captures: {
+		edits: reviewEditsCapture,
+		notes: reviewNotesCapture,
+		editNotes: reviewEditNotesCapture
+	},
+	refusals: {
+		deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note (or edit code) to request changes.",
+		unmatched: "gtd land: no declared pattern matches the pending changes — write .gtd/REQUIREMENTS.md from the feedback, or change nothing when it asks for nothing"
+	}
+});
+/** The build tail: fix (when entered red), keep green, the quality lap, then human review since `base`. */
+const buildTail = (fixFirst, base, built) => tail(fixFirst, (escalations, frozen) => review(base, escalations, frozen), built);
+//#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" });
+};
+/**
+* Undo the human's review-round code edits. A path changed since the human
+* left it is not overwritten; requireRevert names it instead.
+*/
+const reUnwind = async (feedback) => {
+	const { base, restoreFrom, edited } = feedback;
+	await run("re-unwind", restoreScript(base, {
+		restore: edited.filter((c) => c.status !== "added").map((c) => c.path),
+		remove: edited.filter((c) => c.status === "added").map((c) => c.path)
+	}, restoreFrom), {
+		label: "Re-unwinding your review edit",
+		file: REVIEW,
+		base
+	});
+	requireRevert(edited, base);
+};
+/** Plan, build and review until a review round signs off; feedback re-plans from scratch. */
+const planAndBuild = async (firstBase) => {
+	let base = firstBase;
+	let carried;
+	for (;;) {
+		await design(base);
+		await architecture();
+		const built = await packages(carried);
+		carried = built.frozen;
+		const outcome = await buildTail(false, base, built);
+		if (outcome.verdict === "signoff") return;
+		await reUnwind(outcome);
+		base = outcome.base;
+	}
+};
+/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. */
+const afterTail = async (outcome) => {
+	if (outcome.verdict === "signoff") return;
+	await reUnwind(outcome);
+	await planAndBuild(outcome.base);
+};
+/** 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();
+	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());
+};
+const feature = shipped(ordinaryStart);
+//#endregion
+//#region src/workflows/feature/index.ts
+var feature_default = feature;
+//#endregion
+export { SCENARIO_PACKAGE, access, afterTail, answerProductQuestions, answerReviewQuestions, answerTechnicalQuestions, architecture, author, build, buildTail, collecting, declaredTests, decompose, feature_default as default, defaults, design, envDefaults, feature, fixNits, fixSuite, nextPackage, ordinaryStart, packageItem, packages, planAndBuild, reUnwind, requireDeclaredTests, skills, steering, summary, triage, unwind };