@pmelab/gtd 27.9.0 → 28.1.0

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,
@@ -38993,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,
@@ -39004,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)));
@@ -39040,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) => {
@@ -39594,9 +39622,10 @@ const traceEntryOf = (hash, message) => ({
 	hash,
 	actor: message.parsed?.actor ?? ""
 });
-const costEntriesOf = (message) => message.cost.map((c) => ({
+const costEntriesOf = (hash, message) => message.cost.map((c) => ({
 	cost: c.cost,
-	model: c.model ?? "unspecified"
+	model: c.model ?? "unspecified",
+	hash
 }));
 const hashAt = (history, index) => history[index]?.hash;
 const historyFormatFault = (history, location) => formatFault(history.slice(location.baseIndex + 1).concat(history[location.baseIndex]?.message.startsWith("gtd") ? [history[location.baseIndex]] : []).map((c) => ({
@@ -39636,7 +39665,7 @@ const buildRun = (history, location, closingHash) => {
 		startParentHash,
 		diffBase: first?.reviewBase ?? startParentHash,
 		trace: processCommits.map((c, i) => traceEntryOf(c.hash, parsed[i])),
-		costEntries: parsed.flatMap(costEntriesOf),
+		costEntries: parsed.flatMap((m, i) => costEntriesOf(processCommits[i].hash, m)),
 		judgeVerdicts: parsed.flatMap((m) => m.judge),
 		marks: parsed.flatMap((m) => m.marks),
 		approvals: processCommits.flatMap((c, i) => approvalEntryOf(c.hash, parsed[i])),
@@ -39993,6 +40022,10 @@ const costByModel = (entries) => {
 		cost
 	})).sort((a, b) => b.cost - a.cost || a.model.localeCompare(b.model));
 };
+const costTotals = (entries) => ({
+	total: entries.reduce((sum, entry) => sum + entry.cost, 0),
+	byModel: costByModel(entries)
+});
 const setupFor = (config, run, workspace, host, startOverrides = {}) => gen(function* () {
 	const resolved = yield* workflowOf(config, run);
 	const def = resolved.def;
@@ -40096,57 +40129,69 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 		memory: memory.key,
 		memoryResumed: memory.resumed,
 		hints: hintsOf(stepDef),
-		cost: {
-			total: run.costEntries.reduce((sum, entry) => sum + entry.cost, 0),
-			byModel: costByModel(run.costEntries)
-		},
+		cost: costTotals(run.costEntries),
 		setup
 	};
 });
 const currentRest = restAt(void 0);
+/** Every slice refusal reads `<command>: refused — <reason>`; replay's own `gtd: ` lead is dropped. */
+const slicesDivergence = (command, 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(`${command}: refused — ${reason}`);
+};
 /**
-* 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.
+* The replay `gtd slices` and `gtd summary --slice` share: the slice ranges of
+* `run`, plus whether HEAD closes it. Reads like `historyTrail`, never
+* `restAt`: it narrates and writes nothing.
 */
-const processSlices = gen(function* () {
-	const git = yield* GitService;
-	const config = yield* (yield* ConfigService).load;
+const replayedSlices = (config, run, how) => gen(function* () {
 	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"));
+	if (run.trace.length === 0) return yield* fail$7(/* @__PURE__ */ new Error(`${how.command}: 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)
+			command: how.command,
+			configReason: how.configReason,
+			notEnded: (o) => slicesDivergence(how.command, 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));
+		if (outcome.kind !== "rest") return yield* fail$7(slicesDivergence(how.command, run, outcome));
 	}
 	return {
-		slices: sliceRangesOf(outcome.slices, run).map(({ name, base, tip, open }) => ({
+		ranges: sliceRangesOf(outcome.slices, run),
+		closed: closing !== void 0,
+		...versionWarning !== void 0 ? { versionWarning } : {}
+	};
+});
+/**
+* The slices of the process HEAD closes or sits inside, current episode only,
+* stack order. Returns a version warning for a closed run.
+*/
+const processSlices = gen(function* () {
+	const git = yield* GitService;
+	const config = yield* (yield* ConfigService).load;
+	const run = yield* runAtHead(git, config.workflow);
+	const { ranges, closed, versionWarning } = yield* replayedSlices(config, run, {
+		command: "gtd slices",
+		configReason: "HEAD's process replays under today's config; revert or stash the edit to list its slices"
+	});
+	return {
+		slices: ranges.map(({ name, base, tip, open }) => ({
 			name,
 			base,
 			tip,
-			closed: closing !== void 0 || !open
+			closed: closed || !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
@@ -40353,27 +40398,85 @@ const snapshotFromRest = (rest, verdicts) => gen(function* () {
 		landing
 	};
 });
-/** `gtd summary`'s prompt for `run`, or `undefined` when the workflow has none or there is nothing to summarize. */
-const summaryFor = (run) => gen(function* () {
+const narrowToSlice = (run, slice) => {
+	if (slice === void 0) return {
+		trace: run.trace,
+		costEntries: run.costEntries
+	};
+	const from = slice.base === run.startParentHash ? -1 : run.trace.findIndex((e) => e.hash === slice.base);
+	const to = run.trace.findIndex((e) => e.hash === slice.tip);
+	const trace = run.trace.slice(from + 1, to + 1);
+	const hashes = new Set(trace.map((e) => e.hash));
+	return {
+		trace,
+		costEntries: run.costEntries.filter((c) => hashes.has(c.hash))
+	};
+};
+const humanCommitsOf = (trace, entryCommit) => trace.filter((entry) => entry.actor === "human" && entry.hash !== entryCommit).map((entry) => ({
+	hash: entry.hash,
+	state: entry.state
+}));
+const summaryInput = (run, slice, settings) => {
+	const entryCommit = run.trace[0].hash;
+	const { trace, costEntries } = narrowToSlice(run, slice);
+	const { total, byModel } = costTotals(costEntries);
+	return {
+		entryCommit,
+		processBase: slice?.base ?? run.startParentHash,
+		processTip: slice?.tip ?? run.trace[run.trace.length - 1].hash,
+		humanCommits: humanCommitsOf(trace, entryCommit),
+		processCost: total,
+		processCostByModel: byModel,
+		marks: run.marks,
+		...settings,
+		...slice !== void 0 ? { slice } : {}
+	};
+};
+const locateSlice = (config, run, sliceName) => gen(function* () {
+	if (sliceName === void 0) return {};
+	const { ranges, versionWarning } = yield* replayedSlices(config, run, {
+		command: "gtd summary",
+		configReason: "HEAD's process replays under today's config; revert or stash the edit to summarize its slices"
+	});
+	const warn = versionWarning !== void 0 ? { versionWarning } : {};
+	const at = ranges.findIndex((r) => r.name === sliceName);
+	if (at < 0) return {
+		unknownSlice: `gtd summary: refused — no slice named "${sliceName}"; the slices, in stack order: ${ranges.map((r) => r.name).join(", ")}`,
+		...warn
+	};
+	const { base, tip } = ranges[at];
+	return {
+		slice: {
+			name: sliceName,
+			base,
+			tip,
+			index: at + 1,
+			count: ranges.length
+		},
+		...warn
+	};
+});
+/**
+* A plain call never replays; under a slice, `entryCommit` and `marks` stay
+* whole-process.
+*/
+const summaryFor = (run, sliceName) => gen(function* () {
 	const config = yield* (yield* ConfigService).load;
 	const host = yield* Host;
 	const resolved = yield* workflowOf(config, run);
 	const summary = resolved.def.summary;
-	if (summary === void 0 || run.trace.length === 0) return void 0;
-	const entryCommit = run.trace[0].hash;
-	return summary({
-		entryCommit,
-		processBase: run.startParentHash,
-		processTip: run.trace[run.trace.length - 1].hash,
-		humanCommits: run.trace.filter((entry) => entry.actor === "human" && entry.hash !== entryCommit).map((entry) => ({
-			hash: entry.hash,
-			state: entry.state
-		})),
-		processCost: run.costEntries.reduce((sum, entry) => sum + entry.cost, 0),
-		processCostByModel: costByModel(run.costEntries),
-		marks: run.marks,
-		...settingsFor(resolved, run.pinnedVars, host.env, {}, {})
-	});
+	if (summary === void 0) return { prompt: void 0 };
+	if (sliceName === void 0 && run.trace.length === 0) return { prompt: void 0 };
+	const located = yield* locateSlice(config, run, sliceName);
+	if ("unknownSlice" in located) return {
+		prompt: void 0,
+		...located
+	};
+	const { slice, versionWarning } = located;
+	return {
+		prompt: summary(summaryInput(run, slice, settingsFor(resolved, run.pinnedVars, host.env, {}, {}))),
+		...versionWarning !== void 0 ? { versionWarning } : {}
+	};
 });
 /** Repository-relative paths of the config files today's config and the process's own record name; one outside the repository cannot be read at a ref, so it is left out. */
 const inRepoConfigPaths = (root, files, recorded) => {
@@ -40438,13 +40541,14 @@ const replayFinishedProcess = (config, run, hash, how) => gen(function* () {
 	const git = yield* GitService;
 	const workspace = yield* Workspace;
 	const host = yield* Host;
+	const recorded = parseCommitMessage(run.episode.commits.find((c) => c.hash === hash)?.message ?? "").version;
+	const versionWarning = versionWarningFor(recorded);
+	const withWarning = (err) => versionWarning === void 0 ? err : /* @__PURE__ */ new Error(`${err.message}\n${versionWarning}`);
 	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));
+	if (differing.length > 0) return yield* fail$7(withWarning(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);
+	if (outcome.kind !== "ended") return yield* fail$7(withWarning(how.notEnded(outcome)));
 	return {
 		outcome,
 		recorded,
@@ -41134,12 +41238,16 @@ const planLanding = (opts = {}, current) => gen(function* () {
 * closes or sits inside its own closing message. Writes nothing — no git, no
 * state transition, no file. Refuses (throws, mapped to the runtime-error
 * exit code) when the workflow declares no `summary` prompt, or the resolved
-* run has no commits to name.
+* run has no commits to name. The edge never narrates: the CLI prints the
+* version warning, before the unknown-slice refusal; a replay refusal carries
+* it in its message.
 */
-const runSummaryCommand = (out) => gen(function* () {
-	const rendered = yield* summaryFor(yield* summaryRun);
-	if (rendered === void 0) return yield* fail$7(/* @__PURE__ */ new Error("gtd summary: refused — either this workflow declares no \"summary:\" template, or there is no finished/in-flight process to summarize at HEAD"));
-	out.write(rendered.endsWith("\n") ? rendered : rendered + "\n");
+const runSummaryCommand = (out, sliceName) => gen(function* () {
+	const { prompt, versionWarning, unknownSlice } = yield* summaryFor(yield* summaryRun, sliceName);
+	if (versionWarning !== void 0) yield* (yield* Narrator).warn(versionWarning);
+	if (unknownSlice !== void 0) return yield* fail$7(new Error(unknownSlice));
+	if (prompt === void 0) return yield* fail$7(/* @__PURE__ */ new Error("gtd summary: refused — either this workflow declares no \"summary:\" template, or there is no finished/in-flight process to summarize at HEAD"));
+	out.write(prompt.endsWith("\n") ? prompt : prompt + "\n");
 });
 /** Prints the review anchor hash bare, so an external tool can be pointed at the range under review. Nothing is written. Refuses when the run has no commits, where the hash would name a range with no review. */
 const runBaseCommand = (out) => gen(function* () {
@@ -41680,7 +41788,7 @@ const dispatchVoidCommand = (command, json, out) => {
 		case "uncheck": return runUncheckCommand(command.file);
 		case "install": return runInstallCommand(out);
 		case "loop": return runLoopCommand();
-		case "summary": return runSummaryCommand(out);
+		case "summary": return runSummaryCommand(out, command.slice);
 		case "base": return runBaseCommand(out);
 		case "judge": return runJudgeCommand(json, out);
 		case "judgeAnswer": return runJudgeAnswerCommand(json, out);
@@ -41850,6 +41958,21 @@ const FLAGS = [
 			"GTD_JUDGE_MODEL, then judge.json, then sonnet"
 		]
 	},
+	{
+		name: "--slice",
+		arity: 1,
+		repeatable: false,
+		scope: (kind) => kind === "summary",
+		decode: ([raw]) => right(raw),
+		scopeError: "gtd: --slice is only valid for `gtd summary`",
+		valueHint: "<name>",
+		help: [
+			"(gtd summary only) the closing-message prompt for one",
+			"slice, named as `gtd slices` lists it: its own range, human",
+			"commits and cost. An unknown name is refused (exit 1) with",
+			"every valid slice listed"
+		]
+	},
 	{
 		name: "--workflow",
 		arity: 1,
@@ -42154,10 +42277,15 @@ const COMMAND_ROWS = [
 			"no state transition, no file, no session identity — the",
 			"driver pipes the output to a cold agent and does what it",
 			"wants with the result (a squash, an amend, a PR body).",
-			"Refuses (exit 1) when the workflow declares no summary:",
-			"template, or when the resolved run has no commits to name",
-			"— runnable any time before the next thing lands on the",
-			"branch"
+			"--slice <name> prints it for one slice instead: its own",
+			"range, human commits and cost (see `gtd slices`); it also",
+			"refuses an unknown slice name, and a HEAD-closing process",
+			"whose config files differ from the working tree or whose",
+			"replay diverged; an open last slice is provisional. Refuses",
+			"(exit 1) when the workflow declares no summary: template,",
+			"or when the resolved run has no commits to name — plain",
+			"gtd summary is runnable any time before the next thing",
+			"lands on the branch"
 		]
 	},
 	{
@@ -42186,10 +42314,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"
 		]
 	},
 	{
@@ -42614,6 +42742,15 @@ const parseArgv = (argv) => {
 			verbose
 		};
 	}
+	if (kind === "summary") return {
+		kind: "command",
+		command: {
+			kind: "summary",
+			...bag["--slice"] !== void 0 ? { slice: bag["--slice"] } : {}
+		},
+		json,
+		verbose
+	};
 	if (kind === "historyShow") return {
 		kind: "command",
 		command: {