@pmelab/gtd 43.0.0 → 44.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "43.0.0",
+  "version": "44.0.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -588,24 +588,28 @@ the agent may overturn the answer. See
 for its `ui:` settings.
 
 The bundled workflows are named `feature` (the ordinary start above), `review`
-and `fix`. They are independent: `review` and `fix` never plan, and they meet
-only in `.gtd/REVIEW.md`. Each brings its own door. This command:
+and `fix`. `review` and `fix` never plan. Each brings its own door. This
+command:
 
 ```bash
 gtd door review <commitish>
 ```
 
-starts a pure review of everything from `<commitish>` to HEAD. It goes straight
-to the quality lap and a review, with no planning and no building; unlike
-`feature`, its lap fixes every finding and a reviewer turn
-(`build.review.reviewing`) writes `.gtd/REVIEW.md`, risks and all. Sign off and
-it closes. Leave notes and the process ends with `.gtd/REVIEW.md` (and the
-reviewer's original, `.gtd/REVIEW.orig.md`) left for `gtd door fix`. Until `fix`
-consumes them, starting `feature` or `review` is refused; remove both files to
-abandon the hand-off. `gtd door fix` fixes those notes and every `Risk:` in one
-turn, then asks for your review of the fix. With no review waiting, it repairs a
-red baseline as its own reviewed commit instead. `gtd doors` lists the doors of
-the workflows your `gtd.config.ts` exports, plus any it adds.
+starts a review of everything from `<commitish>` to HEAD — the same review a
+`feature` process ends with, minus planning and building. A green gate, then the
+quality lenses: mechanical findings are fixed, noise is dropped, and the rest
+become notes in `.gtd/REVIEW.md`, one tick box each. Tick `fix as suggested` or
+write your own answer and the process fixes it in place — your own answers that
+ask for a change are collected into `.gtd/REQUIREMENTS.md` and built by one
+`feedback.fixing` turn, with no design phase and no criteria — under the health
+loop, then asks for your review again. Sign off (or tick `won't fix`) and it
+closes; nothing is left behind. A note asking for new behaviour belongs in a
+`feature` process: tick `won't fix` and start one. `gtd door fix` repairs a red
+baseline as its own reviewed commit; a note at its review is left in
+`.gtd/REVIEW.md` (beside the reviewer's original, `.gtd/REVIEW.orig.md`) for the
+next `gtd door fix`, and until that runs, starting `feature` or `review` is
+refused — remove both files to abandon the hand-off. `gtd doors` lists the doors
+of the workflows your `gtd.config.ts` exports, plus any it adds.
 `gtd --workflow <name>` starts any workflow by name.
 
 The workflow itself is a plain async TypeScript function, and the

package/dist/chunks/{reserved-COEMFEpy.mjs → reserved-DJk_6-ju.mjs}

@@ -978,6 +978,15 @@ ${notes.length === 0 ? "(none)\n" : notesCapture(notes)}
 The reviewer's risks are:
 
 ${risks.length === 0 ? "(none)\n" : notesCapture(risks)}`;
+const reviewFeedbackFixPrompt = () => `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\` — the concerns the human's review asked for,
+  one \`## \` heading each, in build order
+- Build every concern in this one turn; an answered question is context,
+  not a concern
+- Where a change is behavioural, add a test that fails without it
+- Leave \`.gtd/REQUIREMENTS.md\` untouched — the next step removes it
+- Leave everything uncommitted and finish your turn
+`;
 const buildReviewReviewMissingMessage = (commit) => `The review round committed no \`.gtd/REVIEW.md\` (at ${commit}), so there is
 nothing to sign off on.
 
@@ -1606,6 +1615,36 @@ const awaitReview = (base, message = buildReviewAwaitReviewMessage(base)) => hum
 	base,
 	acceptClean: true
 });
+/** 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, access, rules) => {
+	const fixing = (name) => agentWithSkills(name, buildReviewFixNitsPrompt(notes, rules), {
+		label: "Fixing your nits",
+		file: REVIEW,
+		model: planner(),
+		system: reviewerSystem()
+	});
+	return access === void 0 ? fixing("review.fix.nits.fixing") : scope({
+		name: "review.fix.nits",
+		access
+	}, () => fixing("fixing"));
+};
+/** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
+const collecting = (capture, round) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture, void 0, round), {
+	label: "Collecting your feedback",
+	file: REQUIREMENTS,
+	mode: "qa",
+	model: planner(),
+	system: reviewerSystem(),
+	allowEmpty: true
+});
 /** The round at commit `round` left no `.gtd/REVIEW.md`. */
 const reviewMissing = (round) => human("review.review-missing", {
 	message: buildReviewReviewMissingMessage(round),
@@ -1802,6 +1841,7 @@ const skills = (vars) => {
 	return {
 		design: ["spec-driven-development", "planning-and-task-breakdown"],
 		notes: ["incremental-implementation", "code-simplification"],
+		feedback: ["test-driven-development", "incremental-implementation"],
 		...build,
 		...Object.fromEntries(Object.entries(build).map(([name, list]) => [`refactor.${name}`, list])),
 		refactor: ["ponytail"],
@@ -1834,4 +1874,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { naivePassPrompt as $, agentWithSkills as A, coverageQuestion as B, fixCheck as C, envDefaults as Ct, reviewMissing as D, flipProblems as Dt, planner as E, flagReferences as Et, builderSystem as F, designTriagePrompt as G, criterionLine as H, clearCriteriaMessage as I, handOffAwaitReviewMessage as J, finisherSystem as K, clearCriteriaQuestion as L, buildReviewCollectingPrompt as M, buildReviewFixNitsPrompt as N, reviewQuality as O, registryEntry as Ot, buildReviewTriageMessage as P, naiveApplyFailure as Q, composedReview as R, coder as S, defaults as St, fixRisks as T, flagMentions as Tt, designGateAnswerMessage as U, coveringPrompt as V, designSystem as W, implementBuildingPrompt as X, idleMessage as Y, implementFixPrompt as Z, REFACTOR_NOTE as _, slicingPrompt as _t, flagModeOn as a, refactorBuildingPrompt as at, SLICES as b, unwindFailedMessage as bt, baseline as c, refactorNotePrompt as ct, guarded as d, reviewEditsCapture as dt, normaliseCriteriaScript as et, healthy as f, reviewGateBlockedMessage as ft, REFACTOR as g, seamSteerMessage as gt, QUALITY as h, seamByHandMessage as ht, skills as i, qualityUnresolvedMessage as it, buildReviewAnswerQuestionsPrompt as j, reviewing as k, requireFlag as kt, escalation as l, refactorRules as lt, HANDOFF as m, reviewerSystem as mt, summary as n, qualityFindingsFile as nt, flagShipped as o, refactorDroppedRefusal as ot, FEEDBACK as p, reviewNotesCapture as pt, fixReviewNotesPrompt as q, access as r, qualityTriageMessage as rt, shipped as s, refactorFixPrompt as st, steering as t, oversizedMessage as tt, gate as u, reviewEditNotesCapture as ut, REQUIREMENTS as v, startGateBlockedMessage as vt, fixQuality as w, testFileGlobs as wt, awaitReview as x, unwindFailure as xt, REVIEW as y, uncoveredMessage as yt, coverageMessage as z };
+export { naiveApplyFailure as $, reviewMissing as A, registryEntry as At, coverageMessage as B, coder as C, unwindFailure as Ct, fixQuality as D, flagMentions as Dt, fixNits as E, testFileGlobs as Et, buildReviewTriageMessage as F, designSystem as G, coveringPrompt as H, builderSystem as I, fixReviewNotesPrompt as J, designTriagePrompt as K, clearCriteriaMessage as L, reviewing as M, agentWithSkills as N, fixRisks as O, flagReferences as Ot, buildReviewCollectingPrompt as P, implementFixPrompt as Q, clearCriteriaQuestion as R, awaitReview as S, unwindFailedMessage as St, fixCheck as T, envDefaults as Tt, criterionLine as U, coverageQuestion as V, designGateAnswerMessage as W, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REFACTOR_NOTE as _, seamByHandMessage as _t, flagModeOn as a, qualityUnresolvedMessage as at, SLICES as b, startGateBlockedMessage as bt, baseline as c, refactorFixPrompt as ct, guarded as d, reviewEditNotesCapture as dt, naivePassPrompt as et, healthy as f, reviewEditsCapture as ft, REFACTOR as g, reviewerSystem as gt, QUALITY as h, reviewNotesCapture as ht, skills as i, qualityTriageMessage as it, reviewQuality as j, requireFlag as jt, planner as k, flipProblems as kt, escalation as l, refactorNotePrompt as lt, HANDOFF as m, reviewGateBlockedMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorBuildingPrompt as ot, FEEDBACK as p, reviewFeedbackFixPrompt as pt, finisherSystem as q, access as r, qualityFindingsFile as rt, shipped as s, refactorDroppedRefusal as st, steering as t, normaliseCriteriaScript as tt, gate as u, refactorRules as ut, REQUIREMENTS as v, seamSteerMessage as vt, collecting as w, defaults as wt, answerReviewQuestions as x, uncoveredMessage as xt, REVIEW as y, slicingPrompt as yt, composedReview as z };

package/dist/chunks/review-X7Jfz0dY.mjs

@@ -0,0 +1,249 @@
+import { answered, changesSince, head, judge, numeric, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
+import { removedAssertions, review } from "../workflow-kit.mjs";
+import { A as reviewMissing, E as fixNits, F as buildReviewTriageMessage, O as fixRisks, S as awaitReview, T as fixCheck, d as guarded, dt as reviewEditNotesCapture, f as healthy, ft as reviewEditsCapture, h as QUALITY, ht as reviewNotesCapture, w as collecting, x as answerReviewQuestions, y as REVIEW, z as composedReview } from "./reserved-DJk_6-ju.mjs";
+import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-5w5mxGTq.mjs";
+//#region src/workflows/shared/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."
+});
+const TIER_ORDER = {
+	critical: 0,
+	should: 1,
+	could: 2
+};
+/** Capture order: critical, should, could; within a tier one-way doors, then new concepts. */
+const captureKey = (s) => s === void 0 ? 2 : TIER_ORDER[s.tier] * 3 + s.rank;
+const SEVERITY_ANSWERS = {
+	security: ["yes", "no"],
+	reversibility: ["one-way", "two-way"],
+	blastRadius: [
+		"local",
+		"module",
+		"contract"
+	],
+	newConcept: ["yes", "no"]
+};
+/** Anything unanswered, unrecognised, cut or below `minP` is `critical`, never `could`. */
+const severityOf = (note, judgment, minP) => {
+	const ans = (q) => judgment.answers[`${note.id}.${q}`];
+	const a = (q) => ans(q)?.answer;
+	const rank = () => a("reversibility") === "one-way" ? 0 : a("newConcept") === "yes" ? 1 : 2;
+	if (note.forced) return {
+		tier: "critical",
+		reason: "critical: forced by `!`",
+		rank: 2
+	};
+	if (judgment.truncated.includes(note.id) || Object.entries(SEVERITY_ANSWERS).some(([q, allowed]) => !allowed.includes(a(q) ?? "") || !((ans(q)?.p ?? NaN) >= minP))) return {
+		tier: "critical",
+		reason: "critical: judge unsure",
+		rank: 2
+	};
+	const critical = [...a("security") === "yes" ? ["security"] : [], ...a("reversibility") === "one-way" ? ["one-way door"] : []];
+	if (critical.length > 0) return {
+		tier: "critical",
+		reason: `critical: ${critical.join(", ")}`,
+		rank: rank()
+	};
+	const should = [...a("blastRadius") === "contract" ? ["contract"] : [], ...a("newConcept") === "yes" ? ["new concept"] : []];
+	if (should.length > 0) return {
+		tier: "should",
+		reason: `should: ${should.join(", ")}`,
+		rank: rank()
+	};
+	return {
+		tier: "could",
+		reason: "could",
+		rank: 2
+	};
+};
+const severityQuestions = (note) => [
+	{
+		id: `${note.id}.security`,
+		primitive: "noul",
+		instructions: `Does the change the human asks for in note "${note.id}" (on "${note.anchor}") touch security — authentication, authorisation, secrets, untrusted input or data exposure?`,
+		criteria: "yes: it changes or could weaken a security property. no: it does not."
+	},
+	{
+		id: `${note.id}.reversibility`,
+		primitive: "choice",
+		instructions: `Once the change in note "${note.id}" ships, can it be undone without breaking anyone who already depends on it?`,
+		criteria: "one-way: a published API, file format, persisted data, protocol or other contract that cannot be taken back. two-way: can be reverted freely."
+	},
+	{
+		id: `${note.id}.blastRadius`,
+		primitive: "choice",
+		instructions: `How far does the change in note "${note.id}" reach?`,
+		criteria: "local: one function or file. module: a whole module or several files. contract: a public interface other code or users depend on."
+	},
+	{
+		id: `${note.id}.newConcept`,
+		primitive: "noul",
+		instructions: `Does the change in note "${note.id}" introduce a concept new to this codebase — a new abstraction, entity or term? Judge from the evidence, never a glossary; reusing or extending an existing concept is not new.`,
+		criteria: "yes: a genuinely new concept. no: reuses or extends an existing one."
+	}
+];
+/**
+* One judge rest: a verdict per unforced note (a forced note is asked
+* nothing) plus four severity answers. 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`. Severity answers on a
+* non-`edit` note are ignored; on an `edit` they order the collecting turn.
+*/
+const triage = (severities) => async (notes) => {
+	const asked = notes.filter((n) => !n.forced);
+	const judgment = asked.length === 0 ? {
+		answers: {},
+		truncated: []
+	} : await judge("review.triage", {
+		questions: asked.flatMap((n) => [verdictQuestion(n), ...severityQuestions(n)]),
+		evidence: Object.fromEntries(asked.map((n) => [n.id, `Anchor: ${n.anchor}\nReviewer's text: ${n.before}\nHuman's text: ${n.text}`])),
+		message: buildReviewTriageMessage(),
+		label: "Judging each note"
+	});
+	const { answers, truncated } = judgment;
+	const minP = numeric(vars.reviewNoteActionable, Infinity);
+	const severityMinP = numeric(vars.reviewSeverityMinP, Infinity);
+	severities.clear();
+	return new Map(notes.map((n) => {
+		const verdict = n.forced ? void 0 : VERDICTS.find((v) => v !== "edit" && answered(answers[n.id], v, minP));
+		if (verdict !== void 0 && !truncated.includes(n.id)) return [n.id, verdict];
+		severities.set(n.id, severityOf(n, judgment, severityMinP));
+		return [n.id, "edit"];
+	}));
+};
+const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
+/**
+* gtd writes `.gtd/REVIEW.md` from the quality lap's `report` — no reviewer
+* turn — and removes what the fixer left in `.gtd/QUALITY.md`. A re-review
+* after fixed nits restores the doc as committed at `carry`, answers kept;
+* a fresh one leaves out the notes the human already answered.
+*/
+const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new Set()) => run("review.composing", carry === void 0 ? writeScript(REVIEW, composedReview(base, {
+	...report,
+	weakened: removedAssertions(changesSince(base)),
+	nitFix,
+	answered
+}), [QUALITY]) : showScript(carry, REVIEW, REVIEW), {
+	label: "Composing the review",
+	file: REVIEW,
+	base
+});
+/**
+* The quality lap's notes reach a human over everything since `base`, who
+* answers each one — fix as suggested, won't fix, or their own answer — and
+* may comment. A fix joins the nit batch, a won't-fix is dropped, and an own
+* answer or comment is judged: edits end the review as `feedback` for the
+* caller to build, questions are answered in place, nits fixed in one batch,
+* praise dropped.
+*/
+const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
+	const { guard, guardRests, fixAccess, rules } = options;
+	const feedback = options.feedback ?? {
+		file: ".gtd/REQUIREMENTS.md",
+		collecting,
+		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"
+	};
+	const severities = /* @__PURE__ */ new Map();
+	let nitFix;
+	const answered = /* @__PURE__ */ new Set();
+	return review(base, {
+		file: REVIEW,
+		feedback: feedback.file,
+		isCode,
+		reviewing: (b, carry) => {
+			const fixedAt = nitFix;
+			nitFix = void 0;
+			return composing(b, options.report ?? NO_FINDINGS, carry, fixedAt, answered);
+		},
+		fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
+		keepGreen: () => healthy(() => fixCheck(rules), {
+			escalations,
+			guard,
+			guardRests,
+			rules
+		}),
+		awaitReview: (b) => awaitReview(b),
+		reviewMissing,
+		collecting: feedback.collecting,
+		triage: triage(severities),
+		decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
+		answerQuestions: answerReviewQuestions,
+		fixNits: async (notes) => {
+			await guarded((n) => fixNits(n, fixAccess, rules), guard)(notes);
+			nitFix = head();
+		},
+		close: closeReview,
+		captures: {
+			edits: reviewEditsCapture,
+			notes: reviewNotesCapture,
+			editNotes: (round, edits, answeredAt) => reviewEditNotesCapture(round, edits.map((n, i) => ({
+				n,
+				i,
+				s: severities.get(n.id),
+				key: captureKey(severities.get(n.id))
+			})).sort((x, y) => x.key - y.key || x.i - y.i).map(({ n, s }) => ({
+				id: n.id,
+				anchor: n.anchor,
+				text: n.forced ? n.text.replace(/^!\s*/, "") : n.text,
+				...s === void 0 ? {} : { label: s.reason }
+			})), answeredAt)
+		},
+		refusals: {
+			deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note (or edit code) to request changes.",
+			unmatched: feedback.unmatched,
+			...feedback.dropped === void 0 ? {} : { dropped: feedback.dropped }
+		}
+	});
+};
+function buildTail(first, second, ...rest) {
+	const options = callForm(first, second, rest);
+	if (options === void 0) return Promise.reject(/* @__PURE__ */ new Error("buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither"));
+	const [base, form] = options;
+	return tail((escalations, report) => humanReview(base, escalations, {
+		...form,
+		report
+	}), {
+		...form,
+		triage: true
+	});
+}
+const isOptionalBoolean = (value) => value == null || typeof value === "boolean";
+const legacyForm = (fixFirst, base, green, options) => isOptionalBoolean(fixFirst) && isOptionalBoolean(green) && isOptionalObject(options) ? [base, {
+	...options,
+	fixFirst: fixFirst ?? void 0,
+	green: green ?? void 0
+}] : void 0;
+const currentForm = (base, options, third, fourth) => isOptionalObject(options) && third == null && fourth == null ? [base, options ?? {}] : void 0;
+const callForm = (first, second, [third, fourth, ...extra]) => {
+	if (extra.some((value) => value != null)) return void 0;
+	if (typeof second === "string") return legacyForm(first, second, third, fourth);
+	if (typeof first === "string") return currentForm(first, second, third, fourth);
+};
+/**
+* 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);
+};
+//#endregion
+export { reUnwind as i, humanReview as n, isCode as r, buildTail as t };

package/dist/chunks/{tail-C_xn8U7U.mjs → tail-5w5mxGTq.mjs}

@@ -1,6 +1,6 @@
 import { answered, head, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
 import { fixFindings, lensEntriesOf, lensOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { C as fixCheck, D as reviewMissing, J as handOffAwaitReviewMessage, O as reviewQuality, T as fixRisks, d as guarded, f as healthy, h as QUALITY, k as reviewing, l as escalation, nt as qualityFindingsFile, rt as qualityTriageMessage, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-COEMFEpy.mjs";
+import { A as reviewMissing, D as fixQuality, M as reviewing, O as fixRisks, S as awaitReview, T as fixCheck, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, it as qualityTriageMessage, j as reviewQuality, l as escalation, rt as qualityFindingsFile, y as REVIEW } from "./reserved-DJk_6-ju.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
 	notes: [],
@@ -217,7 +217,7 @@ const runTail = (finish, options) => scope("build", async () => {
 	return finish(escalations, NO_FINDINGS);
 });
 /**
-* The review and fix workflows' human review since `base`: a sign-off closes
+* The fix workflow's human review since `base`: a sign-off closes
 * `.gtd/REVIEW.md`; a note leaves it, with the reviewer's own version as
 * `REVIEW_ORIG`, for the next `fix` to read — never a re-plan.
 */
@@ -237,7 +237,7 @@ const handOffReview = (base, escalations, guard) => reviewToHandOff(base, {
 	unparsed: "gtd land: review-doc: your edit to .gtd/REVIEW.md contains no note fix can read — restore the deleted chunk, or write the note as a line under its entry.",
 	deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note to hand to fix."
 });
-/** The tail the review and fix workflows run: ends at the hand-off review since `base`. */
+/** The tail the fix workflow runs: ends at the hand-off review since `base`. */
 const handOffTail = (fixFirst, base, guard) => tail((escalations) => handOffReview(base, escalations, guard), {
 	fixFirst,
 	guard

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { Ct as envDefaults, Et as flagReferences, Ot as registryEntry, S as coder, St as defaults, i as skills, kt as requireFlag, n as summary, o as flagShipped, r as access, t as steering } from "../chunks/reserved-COEMFEpy.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-C_xn8U7U.mjs";
+import { At as registryEntry, C as coder, Ot as flagReferences, Tt as envDefaults, i as skills, jt as requireFlag, n as summary, o as flagShipped, r as access, t as steering, wt as defaults } from "../chunks/reserved-DJk_6-ju.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-5w5mxGTq.mjs";
 //#region src/workflows/cleanup/cleanup.ts
 const removingPrompt = (name, registry) => `Clean up the release flag "${name}", which is default-on: delete its entry in ${registry}, and remove every \`GTD_FLAG_${name.toUpperCase()}\` check from the shipped sources. Keep the flag-on path; delete code only the off path reached, including tests that pin the off path.`;
 const cleanupFlow = async () => {