@pmelab/gtd 27.1.0 → 27.3.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "27.1.0",
+  "version": "27.3.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

@@ -552,6 +552,13 @@ unknown key. `gtd.config.ts` is the only repository config: gtd 23 removed the
 home directory — fails every command until you delete it. See
 [Migrating from `.gtdrc`](https://github.com/pmelab/gtd/blob/main/docs/configuration.md#migrating-from-gtdrc).
 
+### Rolling out and cleaning up release flags
+
+Two more bundled workflows retire a release flag:
+`gtd --workflow rollout --var flag=<name>` turns it default-on,
+`gtd --workflow cleanup --var flag=<name>` removes it afterwards. See
+[Feature flags](docs/configuration.md#rolling-out-and-cleaning-up-a-release-flag).
+
 ## Checking a range for stray files
 
 ```sh
@@ -599,15 +606,15 @@ are not process history: `gtd history` does not list them, and the
 gtd is one package, `@pmelab/gtd`, and every entrypoint shares its version and
 [SemVer promise](https://github.com/pmelab/gtd/blob/main/COMPATIBILITY.md).
 
-| Import                                                                                       | What it is                                                                                                                                                                                             |
-| -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `@pmelab/gtd/flows`                                                                          | The flow API a workflow is written in: the steps (`agent`, `human`, `run`, …), workflow factories, `defineConfig` and `FLOWS_PROTOCOL`.                                                                |
-| `@pmelab/gtd/wire`                                                                           | The driver protocol: `WIRE_SCHEMA`, the exit codes and the types of every `--json` document.                                                                                                           |
-| `@pmelab/gtd/steering`                                                                       | The steering-file formats (`qa`, `review`) and the review-note readers.                                                                                                                                |
-| `@pmelab/gtd/workflow-kit`                                                                   | Policy-free building blocks to compose a workflow from: health checks, quality laps, scenario freezing, review tails.                                                                                  |
-| `@pmelab/gtd/workflows`                                                                      | Every shipped workflow and all its parts in one module; also resolvable as `@pmelab/gtd/workflow`.                                                                                                     |
-| `@pmelab/gtd/workflows/feature`, `@pmelab/gtd/workflows/review`, `@pmelab/gtd/workflows/fix` | One shipped workflow each: its factory as the default export, its parts, and the reserved exports (`defaults`, `envDefaults`, `summary`, `steering`, `skills`, `access`). `gtd install` imports these. |
-| `@pmelab/gtd/testkit`                                                                        | Runs any workflow against the real engine, in an in-memory or a real repository. Needs `vitest` and `quickpickle`, optional peer dependencies.                                                         |
+| Import                                                                                                                                                         | What it is                                                                                                                                                                                             |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `@pmelab/gtd/flows`                                                                                                                                            | The flow API a workflow is written in: the steps (`agent`, `human`, `run`, …), workflow factories, `defineConfig` and `FLOWS_PROTOCOL`.                                                                |
+| `@pmelab/gtd/wire`                                                                                                                                             | The driver protocol: `WIRE_SCHEMA`, the exit codes and the types of every `--json` document.                                                                                                           |
+| `@pmelab/gtd/steering`                                                                                                                                         | The steering-file formats (`qa`, `review`) and the review-note readers.                                                                                                                                |
+| `@pmelab/gtd/workflow-kit`                                                                                                                                     | Policy-free building blocks to compose a workflow from: health checks, quality laps, scenario freezing, review tails.                                                                                  |
+| `@pmelab/gtd/workflows`                                                                                                                                        | Every shipped workflow and all its parts in one module; also resolvable as `@pmelab/gtd/workflow`.                                                                                                     |
+| `@pmelab/gtd/workflows/feature`, `@pmelab/gtd/workflows/review`, `@pmelab/gtd/workflows/fix`, `@pmelab/gtd/workflows/rollout`, `@pmelab/gtd/workflows/cleanup` | One shipped workflow each: its factory as the default export, its parts, and the reserved exports (`defaults`, `envDefaults`, `summary`, `steering`, `skills`, `access`). `gtd install` imports these. |
+| `@pmelab/gtd/testkit`                                                                                                                                          | Runs any workflow against the real engine, in an in-memory or a real repository. Needs `vitest` and `quickpickle`, optional peer dependencies.                                                         |
 
 Types come from the TypeScript sources the package ships. Configs never need an
 install for any of these but `./testkit`: gtd resolves a `gtd.config.ts`'s

package/dist/chunks/registry-CP3YuV9j.mjs

@@ -0,0 +1,101 @@
+import { read, refuse } from "../flows.mjs";
+//#region src/workflows/shared/registry.ts
+const FILL = "
";
+const commentLength = (rest) => {
+	const end = rest.startsWith("//") ? rest.indexOf("\n") : rest.indexOf("*/") + 2;
+	return end <= 0 ? rest.length : end;
+};
+const stringEnd = (text, i, quote) => {
+	let j = i + 1;
+	while (j < text.length && text[j] !== quote) j += text[j] === "\\" ? 2 : 1;
+	return Math.min(j, text.length);
+};
+const mask = (text) => {
+	let out = "";
+	let i = 0;
+	while (i < text.length) {
+		const c = text[i];
+		const rest = text.slice(i);
+		if (rest.startsWith("//") || rest.startsWith("/*")) {
+			const len = commentLength(rest);
+			out += FILL.repeat(len);
+			i += len;
+		} else if (c === "\"" || c === "'" || c === "`") {
+			const j = stringEnd(text, i, c);
+			out += c + FILL.repeat(j - i - 1) + (j < text.length ? c : "");
+			i = j + 1;
+		} else {
+			out += c;
+			i += 1;
+		}
+	}
+	return out;
+};
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const entrySpan = (text, name) => {
+	const quoted = escapeRegExp(name);
+	const re = new RegExp(`\\bname\\s*:\\s*(["'\`])${quoted}\\1`, "g");
+	const masked = mask(text);
+	for (const hit of text.matchAll(re)) {
+		if (masked[hit.index] === FILL) continue;
+		const start = masked.lastIndexOf("{", hit.index);
+		const close = masked.indexOf("}", hit.index);
+		return start < 0 || close < 0 ? void 0 : {
+			start,
+			end: close + 1
+		};
+	}
+};
+const DEFAULT_ON = /\bdefaultOn\s*:\s*(true|false)\s*,?/;
+const defaultOnHit = (body) => DEFAULT_ON.exec(mask(body));
+const defaultOnValue = (body) => defaultOnHit(body)?.[1];
+const KIND = /\bkind\s*:\s*["'`]/;
+const registryEntry = (text, name) => {
+	const span = entrySpan(text, name);
+	if (span === void 0) return void 0;
+	const body = text.slice(span.start, span.end);
+	const hit = KIND.exec(mask(body));
+	return {
+		kind: (hit === null ? null : /^(\w+)["'`]/.exec(body.slice(hit.index + hit[0].length)))?.[1] ?? "",
+		defaultOn: defaultOnValue(body) === "true"
+	};
+};
+const canonical = (body) => {
+	const hit = defaultOnHit(body);
+	const kept = hit === null ? body : body.slice(0, hit.index) + body.slice(hit.index + hit[0].length);
+	const masked = mask(kept);
+	return kept.split("").filter((c, i) => masked[i] === FILL || !(/\s/.test(c) || c === "," && /^\s*}/.test(masked.slice(i + 1)))).join("");
+};
+/**
+* [] when `after` differs from `before` only by the named entry's `defaultOn`
+* going absent/false → true (whitespace and trailing commas inside that entry
+* ignored, so oxfmt re-wrapping it passes); else one line per fault.
+*/
+const flipProblems = (before, after, name) => {
+	const was = entrySpan(before, name);
+	const now = entrySpan(after, name);
+	if (was === void 0) return [`no entry "${name}" before the turn`];
+	if (now === void 0) return [`entry "${name}" is gone`];
+	const faults = [];
+	if (before.slice(0, was.start) !== after.slice(0, now.start)) faults.push("text before the entry changed");
+	if (before.slice(was.end) !== after.slice(now.end)) faults.push("text after the entry changed");
+	const oldBody = before.slice(was.start, was.end);
+	const newBody = after.slice(now.start, now.end);
+	if (canonical(oldBody) !== canonical(newBody)) faults.push(`entry "${name}" changed beyond defaultOn`);
+	if (defaultOnValue(newBody) !== "true") faults.push(`"${name}" is not set to defaultOn: true`);
+	return faults;
+};
+/** `path:line` for every `GTD_FLAG_<NAME>` in shipped sources; re-states scripts/lint-flags.ts' rule by hand. */
+const flagReferences = (files, name) => {
+	const pattern = new RegExp(`\\bGTD_FLAG_${escapeRegExp(name.toUpperCase())}\\b`);
+	return files.filter(({ path }) => !/\.(test|fixture|stories)\.tsx?$/.test(path)).flatMap(({ path, text }) => text.split("\n").flatMap((line, i) => pattern.test(line) ? [`${path}:${i + 1}`] : []));
+};
+const requireFlag = (workflow, registryPath, name, defaultOn) => {
+	if (name === "") return refuse(`gtd: ${workflow} needs --var flag=<name>`);
+	const entry = registryEntry(read(registryPath) ?? "", name);
+	if (entry === void 0) return refuse(`gtd: ${workflow}: no flag "${name}" in ${registryPath}`);
+	if (entry.kind !== "release") return refuse(`gtd: ${workflow}: flag "${name}" is ${entry.kind}, not release`);
+	if (entry.defaultOn !== defaultOn) return refuse(defaultOn ? `gtd: ${workflow}: flag "${name}" is not default-on — roll it out first` : `gtd: ${workflow}: flag "${name}" is already default-on`);
+};
+//#endregion
+export { requireFlag as i, flipProblems as n, registryEntry as r, flagReferences as t };

package/dist/chunks/{reserved-BL9krPao.mjs → reserved-BPdVZkgv.mjs}

@@ -1,5 +1,5 @@
-import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, env, head, human, judge, numeric, quote, read, refuse, removeScript, run, scope, showScript, skillsFor, start, vars } from "../flows.mjs";
-import { escalation as escalation$1, fixFindings, gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, qualityLap as qualityLap$1, removedAssertions, reviewToHandOff } from "../workflow-kit.mjs";
+import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, env, head, human, judge, numeric, quote, skillsFor, start, vars } from "../flows.mjs";
+import { escalation as escalation$1, gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, removedAssertions } from "../workflow-kit.mjs";
 import { c as String$, g as standardSchemaV1, h as optionalWith, l as Struct } from "./Schema-CyImoHTj.mjs";
 //#region src/workflows/shared/prose.ts
 const skillsPreamble = `- Load whatever's listed here that your harness actually has installed,
@@ -591,6 +591,26 @@ ${fixFeedbackPrompt}
   then legitimately report itself already satisfied later
 - Leave everything uncommitted and finish your turn — do not commit
 `;
+const refactorRules = (strays, pattern) => `- Behaviour-neutral: the suite's outcome must not change
+- Change only these paths, nothing else — a test file only when it is
+  one of them:
+${strays.map((path) => `  - \`${path}\``).join("\n")}
+- Introduce no new flag read and add no second read of an existing one:
+  every match of \`${pattern}\` may move, never increase in number`;
+const refactorBuildingPrompt = (pkg, strays, pattern, reference) => `${stateFileRules}
+- The package to implement is \`${pkg}\`; never delete it
+${refactorRules(strays, pattern)}
+${reference === void 0 ? "" : `- Reference only: \`git show ${reference} -- ${strays.map(quote).join(" ")}\` shows an
+  earlier attempt at this change. Read it for ideas; never apply,
+  cherry-pick or check it out — write a fresh refactor
+`}- Leave everything uncommitted and finish your turn — do not commit
+`;
+const refactorFixPrompt = (strays, pattern) => `${stateFileRules}
+${fixFeedbackPrompt}
+${refactorRules(strays, pattern)}
+- Never do another package's work, even when it would green the suite
+- Leave everything uncommitted and finish your turn — do not commit
+`;
 const healthJudgeMessage = () => `The check is still red, and this isn't the first round —
 \`.gtd/FEEDBACK.md\` holds this round's output, and the previous round's
 is in history. Run \`gtd judge answer\` and pipe a
@@ -1157,12 +1177,22 @@ const escalationSteps = {
 	stop: escalate,
 	exhausted: escalationExhausted
 };
+const guarded = (turn, guard) => async (...a) => {
+	await turn(...a);
+	guard?.();
+};
+const guardedSteps = (guard, describeGuard) => ({
+	limit: escalationSteps.limit,
+	describe: guarded(guarded(escalationSteps.describe, guard), describeGuard),
+	stop: guarded(escalationSteps.stop, guard),
+	exhausted: guarded(escalationSteps.exhausted, guard)
+});
 /**
 * Hand a red suite that repeated attempts could not fix to a person: an
 * agent writes `.gtd/ESCALATION.md`, a human narrows it. From the third round
 * on, the human is told the budget is spent instead.
 */
-const escalation = (count) => escalation$1(count, escalationSteps);
+const escalation = (count, guard) => escalation$1(count, guardedSteps(guard));
 /** "Is this red round the same failure as the last one?" — asked of two reports, or of nothing when one is empty. */
 const retryQuestion = (comparable) => comparable ? {
 	id: "verdict",
@@ -1198,21 +1228,25 @@ const runSuite = (options) => check("health.check", env.testCommand ?? "", {
 * first once `FIX_CAP` fixes are spent, or a judge calls the failure
 * identical to the previous round's.
 */
-const healthy = (fix, options = {}) => healthy$1(fix, {
+const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	check: () => runSuite(options),
 	report: FEEDBACK,
 	fixCap: 3,
 	fixesSoFar: options.fixesSoFar ?? 0,
 	sameFailure,
 	escalations: options.escalations ?? { rounds: 0 },
-	escalation: escalationSteps
+	escalation: guardedSteps(options.guard, options.describeGuard)
 });
-/** Hold the process at `<name>.blocked` until the suite is green. */
-const gate = (name, message) => gate$1(name, () => baseline("check"), () => human("blocked", {
+/**
+* Hold the process at `<name>.blocked` until the suite is green. `guard` runs
+* after each `blocked` landing only — never after a check, whose refusal would
+* re-run the same script forever.
+*/
+const gate = (name, message, guard) => gate$1(name, () => baseline("check"), guarded(() => human("blocked", {
 	message,
 	label: "Baseline is red",
 	file: FEEDBACK
-}));
+}), guard));
 //#endregion
 //#region src/workflows/shared/vars.ts
 /** Process settings. */
@@ -1222,6 +1256,7 @@ const defaults = {
 	judgeIdenticalMinP: "0.7",
 	reviewNoteActionable: "0.7",
 	reviewSeverityMinP: "0.7",
+	refactorFlagPattern: "\\bGTD_FLAG_\\w+",
 	qualityReviews: "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge"
 };
 /** Environment settings. */
@@ -1239,6 +1274,7 @@ const ShippedOptions = Struct({
 	judgeIdenticalMinP: setting,
 	reviewNoteActionable: setting,
 	reviewSeverityMinP: setting,
+	refactorFlagPattern: setting,
 	qualityReviews: setting,
 	testCommand: setting,
 	plannerModel: setting,
@@ -1259,73 +1295,27 @@ const shipped = (flow, doors, base) => defineWorkflow(standardSchemaV1(ShippedOp
 	doors,
 	base
 }));
-//#endregion
-//#region src/workflows/shared/tail.ts
-/** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
-const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
-/**
-* One review turn per lens over the whole change, each appending every
-* finding to `.gtd/QUALITY.md`. Resolves `"findings"` when that file
-* has any.
-*/
-const qualityLap = () => qualityLap$1(lensesOf(vars.qualityReviews ?? ""), reviewQuality, QUALITY);
-/** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-const fixQualityFindings = (escalations) => fixFindings({
-	fix: fixQuality,
-	findings: QUALITY,
-	cap: 3,
-	escalate: () => escalation(escalations)
+const FlagOptions = Struct({
+	...ShippedOptions.fields,
+	flagRegistry: setting
 });
-/** `.gtd/REVIEW.md` removed at the end of a round at commit `round`. */
-const closeReview = (round) => run("review.closing", removeScript([REVIEW, REVIEW_ORIG]), {
-	label: "Closing the review",
-	base: round
-});
-/** Refuses while a reviewer's notes still await `gtd door fix`. */
-const refusePendingHandOff = () => {
-	if (read(".gtd/REVIEW.orig.md") !== void 0) refuse(`gtd: ${REVIEW_ORIG} is a pending hand-off — run \`gtd door fix\`, or remove ${REVIEW} and ${REVIEW_ORIG}.`);
-};
-/**
-* The build tail: fix (when entered red), keep green, the quality lap, then
-* `finish` — the human review, as the calling workflow runs it. `green`: the
-* caller just left the full suite green (the package loop), so no run opens it.
-*/
-const tail = (fixFirst, finish, green = false) => scope("build", async () => {
-	const escalations = { rounds: 0 };
-	const fix = fixCheck;
-	const repair = async () => {
-		await fix();
-		await healthy(fix, {
-			fixesSoFar: 1,
-			escalations
-		});
+const flagShipped = (flow) => defineWorkflow(standardSchemaV1(FlagOptions, {
+	onExcessProperty: "error",
+	errors: "all"
+}), (options) => {
+	const flagDefaults = {
+		...defaults,
+		flag: "",
+		flagRegistry: "src/flags/index.ts"
+	};
+	return {
+		flow,
+		defaults: over(flagDefaults, options),
+		envDefaults: over(envDefaults, options),
+		doors: {},
+		base: void 0
 	};
-	if (fixFirst) await repair();
-	else if (!green) await healthy(fix, { escalations });
-	if (await qualityLap() === "findings") if (await fixQualityFindings(escalations)) await healthy(fix, { escalations });
-	else await repair();
-	return finish(escalations);
-});
-/**
-* The review and fix workflows' 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.
-*/
-const handOffReview = (base, escalations) => reviewToHandOff(base, {
-	file: REVIEW,
-	reviewing,
-	fixRisks,
-	keepGreen: () => healthy(fixCheck, { escalations }),
-	awaitReview: (b) => awaitReview(b, handOffAwaitReviewMessage(b)),
-	reviewMissing,
-	close: closeReview,
-	handOff: (reviewed) => run("review.handing-off", showScript(reviewed, REVIEW, REVIEW_ORIG), { label: "Handing your notes to fix" }),
-	threadsPending: "gtd land: open-threads: a thread in .gtd/REVIEW.md or an `H:` code comment waits on the agent — nothing answers it here; delete it, or turn it into a note for fix.",
-	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`. */
-const handOffTail = (fixFirst, base) => tail(fixFirst, (escalations) => handOffReview(base, escalations));
 //#endregion
 //#region src/workflows/shared/skills.ts
 const skills = (vars) => ({
@@ -1346,6 +1336,9 @@ const skills = (vars) => ({
 	"build.review.fix.nits": ["incremental-implementation", "code-simplification"],
 	"build.review.fix.risks": ["debugging-and-error-recovery", "incremental-implementation"],
 	notes: ["incremental-implementation", "code-simplification"],
+	refactor: ["ponytail"],
+	"refactor.fix.suite": ["ponytail", "debugging-and-error-recovery"],
+	"refactor.health": ["ponytail", "debugging-and-error-recovery"],
 	...lensScopes("build.quality", lensesOf(vars.qualityReviews ?? ""), (lens) => builtInLenses[lens]?.skills ?? [lens])
 });
 //#endregion
@@ -1369,4 +1362,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { unwindFailedMessage as $, architectureDecomposePrompt as A, designSystem as B, fixRisks as C, agentWithSkills as D, reviewing as E, buildReviewFixNitsPrompt as F, packagesItemBuildingPrompt as G, finisherSystem as H, buildReviewTriageMessage as I, reviewEditsCapture as J, packagesItemFixSuitePrompt as K, builderSystem as L, buildReviewAnswerQuestionsPrompt as M, buildReviewAwaitAfterDeferMessage as N, architectSystem as O, buildReviewCollectingPrompt as P, startGateBlockedMessage as Q, deferNotesScript as R, fixCheck as S, reviewMissing as T, fixReviewNotesPrompt as U, designTriagePrompt as V, idleMessage as W, reviewNotesCapture as X, reviewGateBlockedMessage as Y, reviewerSystem as Z, FEEDBACK as _, REVIEW_ORIG as a, awaitReview as b, refusePendingHandOff as c, defaults as d, unwindFailure as et, envDefaults as f, ARCHITECTURE as g, healthy as h, skills as i, architectureGateAnswerMessage as j, architectureAuthorPrompt as k, tail as l, gate as m, summary as n, closeReview as o, baseline as p, reviewEditNotesCapture as q, access as r, handOffTail as s, steering as t, shipped as u, REQUIREMENTS as v, planner as w, coder as x, REVIEW as y, designGateAnswerMessage as z };
+export { reviewGateBlockedMessage as $, architectureAuthorPrompt as A, designGateAnswerMessage as B, fixRisks as C, reviewing as D, reviewQuality as E, buildReviewCollectingPrompt as F, handOffAwaitReviewMessage as G, designTriagePrompt as H, buildReviewFixNitsPrompt as I, packagesItemFixSuitePrompt as J, idleMessage as K, buildReviewTriageMessage as L, architectureGateAnswerMessage as M, buildReviewAnswerQuestionsPrompt as N, agentWithSkills as O, buildReviewAwaitAfterDeferMessage as P, reviewEditsCapture as Q, builderSystem as R, fixQuality as S, reviewMissing as T, finisherSystem as U, designSystem as V, fixReviewNotesPrompt as W, refactorFixPrompt as X, refactorBuildingPrompt as Y, reviewEditNotesCapture as Z, REQUIREMENTS as _, flagShipped as a, coder as b, envDefaults as c, gate as d, reviewNotesCapture as et, guarded as f, QUALITY as g, FEEDBACK as h, skills as i, unwindFailure as it, architectureDecomposePrompt as j, architectSystem as k, baseline as l, ARCHITECTURE as m, summary as n, startGateBlockedMessage as nt, shipped as o, healthy as p, packagesItemBuildingPrompt as q, access as r, unwindFailedMessage as rt, defaults as s, steering as t, reviewerSystem as tt, escalation as u, REVIEW as v, planner as w, fixCheck as x, awaitReview as y, deferNotesScript as z };

package/dist/chunks/tail-iLAMoigl.mjs

@@ -0,0 +1,81 @@
+import { read, refuse, removeScript, run, scope, showScript, vars } from "../flows.mjs";
+import { fixFindings, lensesOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
+import { C as fixRisks, D as reviewing, E as reviewQuality, G as handOffAwaitReviewMessage, S as fixQuality, T as reviewMissing, f as guarded, g as QUALITY, p as healthy, u as escalation, v as REVIEW, x as fixCheck, y as awaitReview } from "./reserved-BPdVZkgv.mjs";
+//#region src/workflows/shared/tail.ts
+/** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
+const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
+/**
+* One review turn per lens over the whole change, each appending every
+* finding to `.gtd/QUALITY.md`. Resolves `"findings"` when that file
+* has any.
+*/
+const qualityLap = (guard) => qualityLap$1(lensesOf(vars.qualityReviews ?? ""), guarded(reviewQuality, guard), QUALITY);
+/** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
+const fixQualityFindings = (escalations, guard) => fixFindings({
+	fix: guarded(fixQuality, guard),
+	findings: QUALITY,
+	cap: 3,
+	escalate: () => escalation(escalations, guard)
+});
+/** `.gtd/REVIEW.md` removed at the end of a round at commit `round`. */
+const closeReview = (round) => run("review.closing", removeScript([REVIEW, REVIEW_ORIG]), {
+	label: "Closing the review",
+	base: round
+});
+/** Refuses while a reviewer's notes still await `gtd door fix`. */
+const refusePendingHandOff = () => {
+	if (read(".gtd/REVIEW.orig.md") !== void 0) refuse(`gtd: ${REVIEW_ORIG} is a pending hand-off — run \`gtd door fix\`, or remove ${REVIEW} and ${REVIEW_ORIG}.`);
+};
+/**
+* The build tail: fix (when entered red), keep green, the quality lap, then
+* `finish` — the human review, as the calling workflow runs it. `green`: the
+* caller just left the full suite green (the package loop), so no run opens it.
+*/
+const tail = (fixFirst, finish, green = false, guard) => scope("build", async () => {
+	const escalations = { rounds: 0 };
+	const fix = fixCheck;
+	const repair = async () => {
+		await guarded(fix, guard)();
+		await healthy(fix, {
+			fixesSoFar: 1,
+			escalations,
+			guard
+		});
+	};
+	if (fixFirst) await repair();
+	else if (!green) await healthy(fix, {
+		escalations,
+		guard
+	});
+	if (await qualityLap(guard) === "findings") if (await fixQualityFindings(escalations, guard)) await healthy(fix, {
+		escalations,
+		guard
+	});
+	else await repair();
+	return finish(escalations);
+});
+/**
+* The review and fix workflows' 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.
+*/
+const handOffReview = (base, escalations, guard) => reviewToHandOff(base, {
+	file: REVIEW,
+	reviewing: guarded(reviewing, guard),
+	fixRisks: guarded(fixRisks, guard),
+	keepGreen: () => healthy(fixCheck, {
+		escalations,
+		guard
+	}),
+	awaitReview: (b) => awaitReview(b, handOffAwaitReviewMessage(b)),
+	reviewMissing,
+	close: closeReview,
+	handOff: (reviewed) => run("review.handing-off", showScript(reviewed, REVIEW, REVIEW_ORIG), { label: "Handing your notes to fix" }),
+	threadsPending: "gtd land: open-threads: a thread in .gtd/REVIEW.md or an `H:` code comment waits on the agent — nothing answers it here; delete it, or turn it into a note for fix.",
+	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`. */
+const handOffTail = (fixFirst, base, guard) => tail(fixFirst, (escalations) => handOffReview(base, escalations, guard), false, guard);
+//#endregion
+export { tail as a, refusePendingHandOff as i, closeReview as n, handOffTail as r, REVIEW_ORIG as t };

package/dist/gtd.bundle.mjs

@@ -20964,7 +20964,6 @@ const restorability = (git, headHash, tipHash) => gen(function* () {
 //#region src/flags/index.ts
 const FLAGS$1 = [];
 const BOOL = {
-	"": false,
 	"0": false,
 	false: false,
 	"1": true,
@@ -20972,9 +20971,13 @@ const BOOL = {
 };
 const resolveFlags = (env, registry = FLAGS$1) => {
 	const out = {};
-	for (const { name } of registry) {
+	for (const { name, defaultOn } of registry) {
 		const variable = `GTD_FLAG_${name.toUpperCase()}`;
 		const key = (env[variable] ?? "").toLowerCase();
+		if (key === "") {
+			out[name] = defaultOn ?? false;
+			continue;
+		}
 		if (!Object.hasOwn(BOOL, key)) throw new Error(`${variable} must be 1, 0, true or false`);
 		out[name] = BOOL[key];
 	}

package/dist/testkit.mjs

@@ -6091,7 +6091,6 @@ const restorability = (git, headHash, tipHash) => gen(function* () {
 //#region src/flags/index.ts
 const FLAGS$1 = [];
 const BOOL = {
-	"": false,
 	"0": false,
 	false: false,
 	"1": true,
@@ -6099,9 +6098,13 @@ const BOOL = {
 };
 const resolveFlags = (env, registry = FLAGS$1) => {
 	const out = {};
-	for (const { name } of registry) {
+	for (const { name, defaultOn } of registry) {
 		const variable = `GTD_FLAG_${name.toUpperCase()}`;
 		const key = (env[variable] ?? "").toLowerCase();
+		if (key === "") {
+			out[name] = defaultOn ?? false;
+			continue;
+		}
 		if (!Object.hasOwn(BOOL, key)) throw new Error(`${variable} must be 1, 0, true or false`);
 		out[name] = BOOL[key];
 	}
@@ -12958,6 +12961,17 @@ const recognizeDeferNotes = (repo, block) => {
 	repo.writeFile(".gtd/TODO.md", `${old}${sep}${lines.join("\n")}\n`);
 	return { kind: "applied" };
 };
+/** `mkdir -p <dir>` then `printf '%s\n' <quoted lines> > <path>`: a flow's one-file write. Re-rendered from what was extracted, so any other shape stays unrecognized. */
+const recognizeWriteLines = (repo, block) => {
+	const [mkdir, printf, ...rest] = block.split("\n");
+	if (rest.length > 0 || !mkdir?.startsWith("mkdir -p ") || !printf?.startsWith("printf '%s\\n' ")) return;
+	const tokens = extractQuotedTokens(printf.slice(14));
+	const path = tokens.pop();
+	if (path === void 0 || !path.includes("/")) return void 0;
+	if (`mkdir -p ${path.slice(0, path.lastIndexOf("/"))}\nprintf '%s\\n' ${tokens.map(shellQuote).join(" ")} > ${shellQuote(path)}` !== block) return void 0;
+	repo.writeFile(path, `${tokens.join("\n")}\n`);
+	return { kind: "applied" };
+};
 /** Every recognizer `applyEmittedScript` tries, first match wins — `recognizeScriptedCommand` stays last since it's the exact-hit fallback for anything the rest don't claim. */
 const recognizersFor = (repo, commands) => [
 	(block) => recognizeSetFlags(block),
@@ -12967,6 +12981,7 @@ const recognizersFor = (repo, commands) => [
 	(block) => recognizeBinaryGuard(commands, block),
 	(block) => recognizeGitBuilders(repo, block),
 	(block) => recognizeDeferNotes(repo, block),
+	(block) => recognizeWriteLines(repo, block),
 	(block) => recognizeFailurePromptWrapper(repo, commands, block),
 	(block) => recognizePresentationSubshell(repo, commands, block),
 	(block) => recognizeModeContradictionSkipNotice(block),

package/dist/workflows/cleanup.mjs

@@ -0,0 +1,37 @@
+import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
+import { a as flagShipped, b as coder, c as envDefaults, i as skills, n as summary, r as access, s as defaults, t as steering } from "../chunks/reserved-BPdVZkgv.mjs";
+import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-iLAMoigl.mjs";
+import { i as requireFlag, r as registryEntry, t as flagReferences } from "../chunks/registry-CP3YuV9j.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 () => {
+	const registry = vars.flagRegistry ?? "";
+	const name = vars.flag ?? "";
+	refusePendingHandOff();
+	requireFlag("cleanup", registry, name, true);
+	let scanned = false;
+	const guard = () => {
+		const turn = scanned ? changes() : void 0;
+		if ((turn === void 0 || turn.some((c) => c.path === registry)) && registryEntry(read(registry) ?? "", name) !== void 0) refuse(`gtd land: cleanup: ${registry} still declares flag "${name}"`);
+		const hits = flagReferences((turn === void 0 ? [...glob("src/**/*.ts"), ...glob("src/**/*.tsx")] : turn.filter((c) => c.status !== "deleted").map((c) => c.path).filter((path) => path.startsWith("src/") && /\.tsx?$/.test(path))).map((path) => ({
+			path,
+			text: read(path) ?? ""
+		})), name);
+		if (hits.length > 0) refuse(`gtd land: cleanup: ${hits.join(", ")} still names GTD_FLAG_${name.toUpperCase()}`);
+	};
+	await scope("cleanup", async () => {
+		await agent("removing", removingPrompt(name, registry), {
+			label: `Removing ${name}`,
+			model: coder()
+		});
+		guard();
+		scanned = true;
+	});
+	await handOffTail(false, start(), guard);
+};
+const cleanup = flagShipped(cleanupFlow);
+//#endregion
+//#region src/workflows/cleanup/index.ts
+var cleanup_default = cleanup;
+//#endregion
+export { access, cleanup, cleanupFlow, cleanup_default as default, defaults, envDefaults, skills, steering, summary };