@pmelab/gtd 27.8.0 → 28.0.0

package/dist/chunks/{tail-fj60rQ3y.mjs → tail-DHEaOHyp.mjs}

@@ -1,6 +1,6 @@
 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-UdSuHDUJ.mjs";
+import { C as reviewMissing, T as reviewing, U as handOffAwaitReviewMessage, _ as awaitReview, b as fixQuality, c as escalation, d as healthy, g as REVIEW, m as QUALITY, u as guarded, w as reviewQuality, x as fixRisks, y as fixCheck } from "./reserved-BIsngMGL.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";

package/dist/chunks/{wire-C12dahrH.mjs → wire-D3Rc5r22.mjs}

@@ -475,4 +475,17 @@ const compile = (glob) => {
 };
 const globMatches = (path, glob) => compile(glob).test(path);
 //#endregion
-export { EXIT_SIGTERM as C, UNATTRIBUTED_MODEL as D, ACCESS_REFUSAL as E, WIRE_SCHEMA as O, EXIT_SIGINT as S, EXIT_USAGE_ERROR as T, demandOf as _, landFields as a, EXIT_OK as b, renderLandJson as c, renderBeatPlain as d, beatDocument as f, beatKindOf as g, BEAT_KINDS as h, judgeJson as i, renderFormat as k, renderLandPlain as l, statusOf as m, resolveSession as n, landProseText as o, renderBeatJson as p, selectPath as r, noopText as s, globMatches as t, DEMAND_BRIEFING as u, stallDiagnosis as v, EXIT_STRAYS_FOUND as w, EXIT_RUNTIME_ERROR as x, EXIT_CODES as y };
+//#region src/wire/Slices.ts
+/** The ONLY place `gtd slices --json`'s shape is built; copies exactly the four fields, in order. */
+const slicesDocument = (slices) => ({
+	schema: 1,
+	slices: slices.map(({ name, base, tip, closed }) => ({
+		name,
+		base,
+		tip,
+		closed
+	}))
+});
+const renderSlicesJson = (document) => JSON.stringify(document) + "\n";
+//#endregion
+export { WIRE_SCHEMA as A, EXIT_RUNTIME_ERROR as C, EXIT_USAGE_ERROR as D, EXIT_STRAYS_FOUND as E, ACCESS_REFUSAL as O, EXIT_OK as S, EXIT_SIGTERM as T, BEAT_KINDS as _, selectPath as a, stallDiagnosis as b, landProseText as c, renderLandPlain as d, DEMAND_BRIEFING as f, statusOf as g, renderBeatJson as h, resolveSession as i, renderFormat as j, UNATTRIBUTED_MODEL as k, noopText as l, beatDocument as m, slicesDocument as n, judgeJson as o, renderBeatPlain as p, globMatches as r, landFields as s, renderSlicesJson as t, renderLandJson as u, beatKindOf as v, EXIT_SIGINT as w, EXIT_CODES as x, demandOf as y };

package/dist/gtd.bundle.mjs

@@ -21520,8 +21520,11 @@ hands off to \`gtd-build\`, which halts at the blocked gate and prints it,
 rather than starting the review; \`gtd-door fix\` on a GREEN suite is a no-op
 straight back to \`idle\` — the exec'd \`gtd-build\` exits immediately on it.
 \`gtd doors\` lists the doors a repository offers (those of the workflows its
-config exports — the bundled \`fix\` and \`review [base]\` — plus any it
-declares). Refuses with
+config exports — the bundled \`fix\` and \`review [base]\`, plus the opt-in
+\`rollout <flag>\` (turn a release flag default-on) and \`cleanup <flag>\`
+(remove it), which a config adds by exporting \`rollout\` from
+\`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
+\`@pmelab/gtd/workflows/cleanup\` — plus any it declares). Refuses with
 \`usage: gtd-door <name> [args...]\` on stderr and exit \`2\` when the name is
 missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-door\`.
 
@@ -21631,7 +21634,10 @@ const renderBriefing = () => HEADER() + BEAT_PROTOCOL + JSON_FIELD_REFERENCE + D
 const CONFIG_SCAFFOLD = `// The workflows gtd runs here: gtd's shipped feature, review and fix.
 // Every exported function is startable with \`gtd --workflow <name>\`; the
 // default export is what a change in the tree starts. Each workflow brings
-// its own doors: \`gtd door review [base]\` and \`gtd door fix\`.
+// its own doors: \`gtd door review [base]\` and \`gtd door fix\`. Export \`rollout\`
+// from \`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
+// \`@pmelab/gtd/workflows/cleanup\` to add \`gtd door rollout <flag>\` and
+// \`gtd door cleanup <flag>\`.
 export {
   feature as default,
   feature,
@@ -37652,6 +37658,22 @@ var init_Glob = __esmMin((() => {
 	globMatches = (path, glob) => compile(glob).test(path);
 }));
 //#endregion
+//#region src/wire/Slices.ts
+var slicesDocument, renderSlicesJson;
+var init_Slices = __esmMin((() => {
+	init_constants();
+	slicesDocument = (slices) => ({
+		schema: 1,
+		slices: slices.map(({ name, base, tip, closed }) => ({
+			name,
+			base,
+			tip,
+			closed
+		}))
+	});
+	renderSlicesJson = (document) => JSON.stringify(document) + "\n";
+}));
+//#endregion
 //#region src/wire/index.ts
 var init_wire = __esmMin((() => {
 	init_constants();
@@ -37666,6 +37688,7 @@ var init_wire = __esmMin((() => {
 	init_Select();
 	init_Sessions();
 	init_Glob();
+	init_Slices();
 }));
 //#endregion
 //#region src/replay/RefName.ts
@@ -37867,7 +37890,7 @@ const TRAILER_READERS = {
 		if (value !== "") into.branch ??= value;
 	},
 	"Gtd-Version": (value, into) => {
-		if (value !== "") into.version ??= value;
+		if (value !== "" && !/[\u0000-\u001f\u007f-\u009f]/.test(value)) into.version ??= value;
 	},
 	"Gtd-Kept": (value, into) => {
 		if (HASH_RE.test(value)) into.kept ??= value;
@@ -38305,7 +38328,8 @@ const replay = async (input) => {
 		via,
 		trace,
 		landed,
-		marks
+		marks,
+		slices: slices.map((s) => ({ ...s }))
 	};
 	const changesSince = (hash) => {
 		const tree = treeAt(hash);
@@ -38975,10 +38999,10 @@ const doorsFrom = (exports) => {
 };
 /**
 * Each exported workflow's own doors, onto the name it is exported under. The
-* `doors` export adds to them and settles a name two workflows both declare.
+* `doors` export adds to them and declares a name several workflows clash on.
 */
 const derivedDoors = (catalogue, declared) => {
-	const doors = /* @__PURE__ */ new Map();
+	const builders = /* @__PURE__ */ new Map();
 	for (const [workflow, loaded] of catalogue) for (const [name, spec] of Object.entries(loaded.doors ?? {})) {
 		const door = {
 			...spec,
@@ -38986,12 +39010,22 @@ const derivedDoors = (catalogue, declared) => {
 		};
 		const problem = doorProblem(name, door);
 		if (problem !== void 0) throw new Error(`workflow "${workflow}" builds door "${name}", which ${problem}`);
-		const other = doors.get(name);
-		if (other !== void 0 && !declared.has(name)) throw new Error(`door "${name}" is built by workflows "${other.workflow}" and "${workflow}" — declare it in the "doors" export to choose one (a declared door replaces the derived one, so restate its args and vars)`);
-		doors.set(name, door);
+		builders.set(name, [...builders.get(name) ?? [], door]);
+	}
+	const doors = /* @__PURE__ */ new Map();
+	const clashes = /* @__PURE__ */ new Map();
+	for (const [name, built] of builders) {
+		const owner = ownerOf(name, built);
+		if (owner !== void 0) doors.set(name, owner);
+		else if (!declared.has(name)) clashes.set(name, built.map((door) => door.workflow));
 	}
-	return new Map([...doors, ...declared]);
+	return {
+		doors: new Map([...doors, ...declared]),
+		clashes
+	};
 };
+/** The export named after the door owns it, else the sole builder; a clash of several builds no door. */
+const ownerOf = (name, built) => built.find((door) => door.workflow === name) ?? (built.length === 1 ? built[0] : void 0);
 /** Sort the doors and check each names a startable workflow. */
 const checkDoors = (declared, catalogue) => {
 	const doors = new Map([...declared].sort(([a], [b]) => a.localeCompare(b)));
@@ -39022,16 +39056,28 @@ const loadWorkflows = (module, shipped) => {
 		return workflow === void 0 ? [] : [[name, workflow]];
 	}));
 	const defaultWorkflow = built.get(value);
+	const derived = rejections.length > 0 ? {
+		doors: /* @__PURE__ */ new Map(),
+		clashes: /* @__PURE__ */ new Map()
+	} : derivedDoors(catalogue, doorsFrom(exports));
 	return {
 		file,
 		catalogue,
-		doors: rejections.length > 0 ? /* @__PURE__ */ new Map() : checkDoors(derivedDoors(catalogue, doorsFrom(exports)), catalogue),
+		doors: checkDoors(derived.doors, catalogue),
 		default: defaultWorkflow && {
 			...defaultWorkflow,
 			name: defaultName
 		},
 		config: compileConfig(exports["config"], module.filepath),
-		diagnostics: nameRejections(rejections)
+		diagnostics: [...nameRejections(rejections), ...[...derived.clashes].map(([name, builders]) => {
+			const names = [...builders].sort().map((b) => JSON.stringify(b));
+			return {
+				severity: "warning",
+				message: `door "${name}" is built by workflows ${names.slice(0, -1).join(", ")} and ${names.at(-1)} and none is exported under that name — declare it in the "doors" export`,
+				path: ["doors", name],
+				origin: file.origin
+			};
+		})]
 	};
 };
 const evaluateFromDisk = (module, shipped) => {
@@ -39746,22 +39792,14 @@ const runAtTip = (git, def, tip) => gen(function* () {
 	if (closing.length === 0) closing = yield* git.commitHistory(void 0, tip.hash);
 	return yield* runOf([...before, ...closing], { ...location }, tip.hash);
 });
-/** The process HEAD closes or sits inside — `gtd summary`'s run. */
-const summaryRun = gen(function* () {
-	const git = yield* GitService;
-	const def = (yield* (yield* ConfigService).load).workflow;
+const runAtHead = (git, def) => gen(function* () {
 	return yield* runAtTip(git, def, (yield* git.subjectHistory(1, 0))[0]);
 });
-/** The process whose finishing commit is `tip` — reads from `tip`'s own ancestry, so it works when no branch reaches it. */
-const closedRunAt = (tip) => gen(function* () {
+/** The process HEAD closes or sits inside — `gtd summary`'s run. */
+const summaryRun = gen(function* () {
 	const git = yield* GitService;
 	const def = (yield* (yield* ConfigService).load).workflow;
-	const hash = yield* git.resolveRef(tip);
-	const subject = yield* git.lastCommitSubject(hash);
-	return yield* runAtTip(git, def, {
-		hash,
-		subject
-	});
+	return yield* runAtHead(git, def);
 });
 const commitTree = (workspace, hash) => {
 	let entries;
@@ -40090,12 +40128,54 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 			total: run.costEntries.reduce((sum, entry) => sum + entry.cost, 0),
 			byModel: costByModel(run.costEntries)
 		},
-		setup,
-		slices: sliceRangesOf(outcome.slices, run)
+		setup
 	};
 });
 const currentRest = restAt(void 0);
 /**
+* The slices of the process HEAD closes or sits inside, current episode only,
+* stack order. Reads like `historyTrail`, never `restAt`: it narrates and
+* writes nothing, and returns a version warning for a closed run.
+*/
+const processSlices = gen(function* () {
+	const git = yield* GitService;
+	const config = yield* (yield* ConfigService).load;
+	const workspace = yield* Workspace;
+	const host = yield* Host;
+	const run = yield* runAtHead(git, config.workflow);
+	if (run.trace.length === 0) return yield* fail$7(/* @__PURE__ */ new Error("gtd slices: refused — HEAD neither closes nor sits inside a process"));
+	const closing = run.closingHash;
+	let outcome;
+	let versionWarning;
+	if (closing !== void 0) {
+		const replayed = yield* replayFinishedProcess(config, run, closing, {
+			command: "gtd slices",
+			configReason: "HEAD's process replays under today's config; revert or stash the edit to list its slices",
+			notEnded: (o) => slicesDivergence(run, o)
+		});
+		outcome = replayed.outcome;
+		versionWarning = replayed.versionWarning;
+	} else {
+		const { setup } = yield* setupFor(config, run, workspace, host);
+		outcome = yield* promise(() => replayFor(setup));
+		if (outcome.kind !== "rest") return yield* fail$7(slicesDivergence(run, outcome));
+	}
+	return {
+		slices: sliceRangesOf(outcome.slices, run).map(({ name, base, tip, open }) => ({
+			name,
+			base,
+			tip,
+			closed: closing !== void 0 || !open
+		})),
+		...versionWarning !== void 0 ? { versionWarning } : {}
+	};
+});
+/** Every `gtd slices` refusal reads `gtd slices: refused — <reason>`; replay's own `gtd: ` lead is dropped. */
+const slicesDivergence = (run, outcome) => {
+	const reason = outcome.kind === "rest" && run.closingHash !== void 0 ? `${run.closingHash.slice(0, 7)} closes a process that does not end under today's config` : replayError(outcome)?.message.replace(/^gtd: /, "") ?? "replay failed";
+	return /* @__PURE__ */ new Error(`gtd slices: refused — ${reason}`);
+};
+/**
 * Whether `gtd --workflow <name>` can start a process here: the workflow must
 * reach a step from the tree the opening commit would capture. That step is
 * what the opening commit's subject names.
@@ -40329,7 +40409,7 @@ const inRepoConfigPaths = (root, files, recorded) => {
 	for (const file of files) paths.add(relative(root, resolve(root, file)).split(sep).join("/"));
 	return [...paths].filter((p) => p !== "" && !p.startsWith("..") && !isAbsolute(p)).sort();
 };
-const configRefusal = (tip, paths) => /* @__PURE__ */ new Error(`gtd history: refused — config differs at ${tip.slice(0, 7)}: ${paths.join(", ")}. A history ref replays under today's config, so it is unreadable after the config changes`);
+const configRefusal = (command, tip, paths, reason = "A history ref replays under today's config, so it is unreadable after the config changes") => /* @__PURE__ */ new Error(`${command}: refused — config differs at ${tip.slice(0, 7)}: ${paths.join(", ")}. ${reason}`);
 const differingConfigPaths = (git, workspace, root, config, run, hash) => gen(function* () {
 	const differing = [];
 	for (const path of inRepoConfigPaths(root, Object.keys(config.fingerprint), run.pinnedConfig?.files ?? {})) if ((yield* orElseSucceed(git.readFileAtRef(hash, path), () => void 0)) !== workspace.readSync(path)) differing.push(path);
@@ -40360,22 +40440,19 @@ const versionWarningFor = (recorded) => recorded === GTD_VERSION ? void 0 : `gtd
 const historyTrail = (tip) => gen(function* () {
 	const git = yield* GitService;
 	const config = yield* (yield* ConfigService).load;
-	const workspace = yield* Workspace;
-	const host = yield* Host;
 	const hash = yield* git.resolveRef(tip);
-	const run = yield* closedRunAt(hash);
-	const differing = yield* differingConfigPaths(git, workspace, host.root, config, run, hash);
-	if (differing.length > 0) return yield* fail$7(configRefusal(hash, differing));
-	const { setup } = yield* setupFor(config, run, workspace, host);
-	yield* workspace.episodeTrees(run.episode.base, run.episode.commits.map((c) => c.hash));
-	const outcome = yield* promise(() => replayFor(setup));
-	if (outcome.kind !== "ended") return yield* fail$7(notClosedError(hash, outcome));
-	const steps = historySteps(run);
-	const recorded = parseCommitMessage(yield* git.lastCommitMessage(hash)).version;
-	const versionWarning = versionWarningFor(recorded);
+	const subject = yield* git.lastCommitSubject(hash);
+	const run = yield* runAtTip(git, config.workflow, {
+		hash,
+		subject
+	});
+	const { outcome, recorded, versionWarning } = yield* replayFinishedProcess(config, run, hash, {
+		command: "gtd history",
+		notEnded: (o) => notClosedError(hash, o)
+	});
 	return {
 		tip: hash,
-		steps,
+		steps: historySteps(run),
 		ended: outcome.via,
 		version: {
 			recorded,
@@ -40384,6 +40461,24 @@ const historyTrail = (tip) => gen(function* () {
 		...versionWarning !== void 0 ? { versionWarning } : {}
 	};
 });
+/** Refuses on config drift before replaying, so a stale config never runs the flow. */
+const replayFinishedProcess = (config, run, hash, how) => gen(function* () {
+	const git = yield* GitService;
+	const workspace = yield* Workspace;
+	const host = yield* Host;
+	const differing = yield* differingConfigPaths(git, workspace, host.root, config, run, hash);
+	if (differing.length > 0) return yield* fail$7(configRefusal(how.command, hash, differing, how.configReason));
+	const { setup } = yield* setupFor(config, run, workspace, host);
+	const outcome = yield* promise(() => replayFor(setup));
+	if (outcome.kind !== "ended") return yield* fail$7(how.notEnded(outcome));
+	const recorded = parseCommitMessage(run.episode.commits.find((c) => c.hash === hash)?.message ?? "").version;
+	const versionWarning = versionWarningFor(recorded);
+	return {
+		outcome,
+		recorded,
+		...versionWarning !== void 0 ? { versionWarning } : {}
+	};
+});
 //#endregion
 //#region src/emit/GitScript.ts
 const shellQuote$1 = (value) => `'${value.replace(/'/g, "'\\''")}'`;
@@ -41256,6 +41351,17 @@ const runDoorsCommand = (json, out) => gen(function* () {
 	if (json.kind === "document") out.write(`${JSON.stringify(document)}\n`);
 	else yield* writeSelection(out, document, json.path);
 });
+const runSlicesCommand = (json, out) => gen(function* () {
+	const { slices, versionWarning } = yield* processSlices;
+	if (versionWarning !== void 0) yield* (yield* Narrator).warn(versionWarning);
+	if (json.kind === "off") {
+		out.write(slices.map((s) => `${s.name} ${s.base}..${s.tip}\n`).join(""));
+		return;
+	}
+	const document = slicesDocument(slices);
+	if (json.kind === "document") out.write(renderSlicesJson(document));
+	else yield* writeSelection(out, document, json.path);
+});
 /**
 * Ends the process underway without completing it. Nothing is discarded: a
 * `git reset --mixed` to the process's start commit leaves every turn
@@ -41591,6 +41697,7 @@ const dispatchVoidCommand = (command, json, out) => {
 		case "start": return runStartCommand(command.actor, command.workflow, command.vars, out, command.label);
 		case "door": return runDoorCommand(command.name, command.args, out);
 		case "doors": return runDoorsCommand(json, out);
+		case "slices": return runSlicesCommand(json, out);
 		case "abandon": return runAbandonCommand(out);
 		case "restore": return runRestoreCommand(out);
 		case "next": return runNextCommand(json, out);
@@ -41649,12 +41756,12 @@ const FLAGS = [
 		name: "--json",
 		arity: "optional",
 		repeatable: false,
-		scope: (kind) => kind === "next" || kind === "land" || kind === "judge" || kind === "judgeAnswer" || kind === "doors" || kind === "historyList" || kind === "historyShow" || kind === "strays",
+		scope: (kind) => kind === "next" || kind === "land" || kind === "judge" || kind === "judgeAnswer" || kind === "doors" || kind === "slices" || kind === "historyList" || kind === "historyShow" || kind === "strays",
 		decode: ([raw]) => right(raw ?? ""),
-		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd history list`/`gtd history show`/`gtd strays` — every other command prints plain text; see `gtd install` for the driver protocol briefing",
+		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd slices`/`gtd history list`/`gtd history show`/`gtd strays` — every other command prints plain text; see `gtd install` for the driver protocol briefing",
 		valueHint: "<path>",
 		help: [
-			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd history",
+			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd slices/gtd history",
 			"list/gtd history show/gtd strays only) output structured JSON. Bare --json prints the whole document;",
 			"--json=<path> (a dotted key path into that document, e.g.",
 			"kind, content, session.id) prints just that value: a",
@@ -42107,10 +42214,10 @@ const COMMAND_ROWS = [
 			"positional args to that workflow's process settings — the",
 			"same start `gtd --workflow` makes, printed the same way.",
 			"Each workflow the config exports brings its own doors (gtd's",
-			"`fix` brings `fix`, `review` brings `review [base]`), plus",
-			"the config's `doors` export. An unknown door, or too few or",
-			"too many args, is a usage error (exit 2) naming the doors or",
-			"the door's synopsis"
+			"`fix`, `review [base]`, `rollout <flag>` and",
+			"`cleanup <flag>`), plus the config's `doors` export. An",
+			"unknown door, or too few or too many args, is a usage error",
+			"(exit 2) naming the doors or the door's synopsis"
 		]
 	},
 	{
@@ -42124,6 +42231,25 @@ const COMMAND_ROWS = [
 			"value off it. Writes nothing"
 		]
 	},
+	{
+		token: "slices",
+		kind: "slices",
+		arity: "none",
+		details: [
+			"List the slices of the process HEAD closes or sits inside,",
+			"first slice first: one `name base..tip` line each (full",
+			"hashes; plain output carries no promise). --json prints",
+			"{ schema: 1, slices: [{ name, base, tip, closed }] };",
+			"--json=<path> reads one value off it. Writes nothing: no",
+			"git, no state transition, no session identity. When HEAD",
+			"closes a process, every slice is listed as closed; a gtd",
+			"version mismatch only warns on stderr. Refuses (exit 1)",
+			"when HEAD neither closes nor sits inside a process, or when",
+			"today's config disagrees with history about the process:",
+			"HEAD closes it and its config files differ from the working",
+			"tree, or the replay diverged"
+		]
+	},
 	{
 		token: "judge",
 		kind: "judge",