@pmelab/gtd 19.0.0 → 20.0.1

package/dist/gtd.bundle.mjs

@@ -30964,7 +30964,7 @@ const changesSince = (hash, pattern) => {
 };
 /** The commit the process stands on at this point of the flow. */
 const head = () => ctx().head();
-/** The process's diff base: the commit before it began, or the base `gtd --entry` fixed. */
+/** The process's diff base: the commit before it began, or the base `gtd --workflow` fixed. */
 const start = () => ctx().start();
 /** The skill list `localName` (scoped from here, same as `agent()`) resolves to — for a prompt preamble. */
 const skillsFor = (localName) => ctx().skillsFor(localName);
@@ -47622,6 +47622,9 @@ const TRAILER_READERS = {
 	"Gtd-Step": (value, into) => {
 		into.step ??= parseStepId(value);
 	},
+	"Gtd-Workflow": (value, into) => {
+		if (value !== "") into.workflow ??= value;
+	},
 	"Gtd-Judge": (value, into) => {
 		const parsed = parseJson(value);
 		if (isVerdict(parsed)) into.judge.push(parsed);
@@ -47646,6 +47649,7 @@ const parseCommitMessage = (message) => {
 	const subject = (newline === -1 ? message : message.slice(0, newline)).trim();
 	const trailers = {
 		step: void 0,
+		workflow: void 0,
 		reviewBase: void 0,
 		judge: [],
 		vars: {},
@@ -47662,6 +47666,7 @@ const parseCommitMessage = (message) => {
 const formatCommitMessage = (spec) => {
 	const lines = [];
 	if (spec.step !== void 0) lines.push(`Gtd-Step: ${formatStepId(spec.step)}`);
+	if (spec.workflow !== void 0) lines.push(`Gtd-Workflow: ${spec.workflow}`);
 	if (spec.reviewBase !== void 0) lines.push(`Gtd-Review-Base: ${spec.reviewBase}`);
 	for (const [name, value] of Object.entries(spec.vars ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) lines.push(`Gtd-Var: ${name}=${value}`);
 	if (spec.cost !== void 0) lines.push(`Gtd-Cost: ${spec.cost.cost}${spec.cost.model !== void 0 ? ` ${spec.cost.model}` : ""}`);
@@ -47769,11 +47774,6 @@ const unknownOptions = (step) => {
 	return `gtd: step "${step.name}": unknown key(s) ${unknown.join(", ")} in ${step.kind}() options`;
 };
 const replay = async (input) => {
-	let entryRead = false;
-	const args = { get entry() {
-		entryRead = true;
-		return input.episode.entry;
-	} };
 	const commits = input.episode.commits.map((c) => ({
 		...c,
 		parsed: parseCommitMessage(c.message)
@@ -47964,8 +47964,7 @@ const replay = async (input) => {
 			kind: "rest",
 			rest: step,
 			trace,
-			landed,
-			entryRead
+			landed
 		});
 		pendingUsed = true;
 		landed = step;
@@ -48072,7 +48071,7 @@ const replay = async (input) => {
 	};
 	installContext(context);
 	try {
-		const flowDone = input.flow(args).then(() => {
+		const flowDone = input.flow({}).then(() => {
 			if (outcome === void 0 && trace.length === 0) outcome = {
 				kind: "failed",
 				message: "gtd: the flow returned without reaching any step"
@@ -48381,7 +48380,7 @@ const startGateBlockedMessage = () => `The test baseline is red — gtd will not
 \`.gtd/FEEDBACK.md\` holds the failing output.
 
 What each change does next (then run \`gtd land\`):
-- **Retry check** — edit the code and/or \`.gtd/FEEDBACK.md\` to fix the failing tests (**start-gate.check**). To repair the baseline as its own separate reviewed commit instead, abandon this start and run \`gtd --entry fix-precheck\` from a clean \`idle\`.
+- **Retry check** — edit the code and/or \`.gtd/FEEDBACK.md\` to fix the failing tests (**start-gate.check**). To repair the baseline as its own separate reviewed commit instead, abandon this start and run \`gtd --workflow fix\` from a clean \`idle\`.
 `;
 const reviewGateBlockedMessage = () => `The test baseline is red — gtd will not start a review on a broken suite.
 \`.gtd/FEEDBACK.md\` holds the failing output.
@@ -49141,7 +49140,7 @@ const fixSuite = () => agentWithSkills("fix.suite.fixing", packagesItemFixSuiteP
 	model: coder(),
 	system: builderSystem()
 });
-const fix = (built) => agentWithSkills("fix", buildFixPrompt(built), {
+const fixCheck = (built) => agentWithSkills("fix", buildFixPrompt(built), {
 	label: "Fixing the check",
 	file: FEEDBACK,
 	model: coder(),
@@ -49687,7 +49686,7 @@ const routeNotes = async (notes, r) => {
 	}
 	if (nits.length > 0) {
 		await guarded(r.frozen, () => fixNits(nits), "review")();
-		await healthy(guarded(r.frozen, fix, "review"), { escalations: r.escalations });
+		await healthy(guarded(r.frozen, fixCheck, "review"), { escalations: r.escalations });
 	}
 	if (edits.length > 0) {
 		await r.close();
@@ -49750,7 +49749,7 @@ const reviewOnce = async (base, carry, escalations, frozen) => {
 	const risks = reviewRisks(read(".gtd/REVIEW.md") ?? "");
 	if (risks.length === 0) return;
 	await guarded(frozen, () => fixRisks(risks), "review")();
-	await healthy(guarded(frozen, fix, "review"), { escalations });
+	await healthy(guarded(frozen, fixCheck, "review"), { escalations });
 	await reviewing(base, carry);
 };
 /**
@@ -49759,7 +49758,7 @@ const reviewOnce = async (base, carry, escalations, frozen) => {
 * another planning lap, questions are answered in place, nits fixed in one
 * batch, praise dropped.
 */
-const review = async (base, escalations = { rounds: 0 }, frozen) => {
+const review$1 = async (base, escalations = { rounds: 0 }, frozen) => {
 	let carry;
 	for (;;) {
 		await reviewOnce(base, carry, escalations, frozen);
@@ -49783,9 +49782,9 @@ const review = async (base, escalations = { rounds: 0 }, frozen) => {
 const buildTail = (fixFirst, base, built) => scope("build", async () => {
 	const frozen = built?.frozen;
 	const escalations = { rounds: 0 };
-	const guardedFix = guarded(frozen, () => fix());
+	const guardedFix = guarded(frozen, () => fixCheck());
 	let redFirst = fixFirst;
-	if (!fixFirst) await healthy(guarded(frozen, () => fix(built)), {
+	if (!fixFirst) await healthy(guarded(frozen, () => fixCheck(built)), {
 		escalations,
 		sweepOnGreen: [ARCHITECTURE]
 	});
@@ -49801,7 +49800,7 @@ const buildTail = (fixFirst, base, built) => scope("build", async () => {
 		}
 		const lap = lapped ? "clean" : await qualityLap();
 		lapped = true;
-		if (lap === "clean") return review(base, escalations, frozen);
+		if (lap === "clean") return review$1(base, escalations, frozen);
 		if (await fixQualityFindings(escalations, frozen)) await healthy(guardedFix, { escalations });
 		else redFirst = true;
 	}
@@ -49856,8 +49855,8 @@ const access = (vars) => ({
 	...Object.fromEntries(lensesOf(vars.qualityReviews ?? "").map((lens) => [`build.quality.${lens}`, { write: [] }]))
 });
 //#endregion
-//#region src/workflows/unified.ts
-var unified_exports = /* @__PURE__ */ __exportAll({
+//#region src/workflows/bundled.ts
+var bundled_exports = /* @__PURE__ */ __exportAll({
 	ARCHITECTURE: () => ARCHITECTURE,
 	ESCALATION: () => ESCALATION,
 	FEEDBACK: () => FEEDBACK,
@@ -49884,17 +49883,20 @@ var unified_exports = /* @__PURE__ */ __exportAll({
 	collecting: () => collecting,
 	declaredTests: () => declaredTests,
 	decompose: () => decompose,
-	default: () => unified,
+	default: () => feature,
 	defaults: () => defaults,
 	describeEscalation: () => describeEscalation,
 	design: () => design,
+	doors: () => doors,
 	driftedScenarios: () => driftedScenarios,
 	envDefaults: () => envDefaults,
 	escalate: () => escalate,
 	escalation: () => escalation,
 	escalationExhausted: () => escalationExhausted,
 	fastSuiteGuard: () => fastSuiteGuard,
+	feature: () => feature,
 	fix: () => fix,
+	fixCheck: () => fixCheck,
 	fixNits: () => fixNits,
 	fixQuality: () => fixQuality,
 	fixQualityFindings: () => fixQualityFindings,
@@ -49986,34 +49988,35 @@ const ordinaryStart = async () => {
 	await gate("start-gate", startGateBlockedMessage());
 	await planAndBuild(start());
 };
-const ENTRIES = [
-	"fix-precheck",
-	"review-gate.check",
-	"start-gate.check"
-];
-async function unified({ entry }) {
-	if (entry === void 0) return ordinaryStart();
-	if (entry === "fix-precheck") {
-		if (await baseline("fix-precheck")) return;
-		return afterTail(await buildTail(true, start()));
-	}
-	if (entry === "review-gate.check") {
-		await gate("review-gate", reviewGateBlockedMessage());
-		return afterTail(await buildTail(false, start()));
-	}
-	if (entry === "start-gate.check") {
-		await gate("start-gate", startGateBlockedMessage());
-		return planAndBuild(start());
-	}
-	refuse(`"${entry}" is not an enterable state — enterable states:\n${ENTRIES.map((name) => `  ${name}`).join("\n")}`);
-}
+/** Repair a red baseline through the build tail, as its own reviewed commit. */
+const fix = async () => {
+	if (await baseline("fix-precheck")) return;
+	return afterTail(await buildTail(true, start()));
+};
+/** Pure review of everything since `reviewBase`. */
+const review = async () => {
+	await gate("review-gate", reviewGateBlockedMessage());
+	return afterTail(await buildTail(false, start()));
+};
+const feature = ordinaryStart;
 const summary = summaryPrompt;
 const steering = {
 	[REQUIREMENTS]: "qa",
 	[ARCHITECTURE]: "qa",
 	[REVIEW]: "review"
 };
-const base = (entry, vars) => entry === "review-gate.check" ? vars.reviewBase ?? "" : void 0;
+const base = (workflow, vars) => workflow === "review" ? vars.reviewBase ?? "" : void 0;
+const doors = {
+	fix: { workflow: "fix" },
+	review: {
+		workflow: "review",
+		args: [{
+			name: "base",
+			optional: true
+		}],
+		vars: ({ base }) => base === void 0 ? {} : { reviewBase: base }
+	}
+};
 //#endregion
 //#region src/platform/Host.ts
 const toError$1 = (e) => e instanceof Error ? e : new Error(String(e));
@@ -50206,6 +50209,8 @@ const makeGitImpl = (executor, root) => {
 		resolveRef: (ref) => exec("git", "rev-parse", "--verify", ref).pipe(map$4((s) => s.trim()), flatMap$4((hash) => resolvedRefOrCorrupted(ref, hash))),
 		readRefOption: (ref) => exec("git", "rev-parse", "--verify", "--quiet", ref).pipe(map$4((s) => some(s.trim())), catchAll(() => succeed$3(none$4()))),
 		isAncestor: (a, b) => run$2(root, "git", "merge-base", "--is-ancestor", a, b).pipe(provide$2(succeed$2(CommandExecutor, executor)), map$4(() => true), catchAll(() => succeed$3(false))),
+		mergeBase: (a, b) => exec("git", "merge-base", a, b).pipe(map$4((s) => some(s.trim())), catchAll(() => succeed$3(none$4()))),
+		defaultBranch: () => exec("git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD").pipe(map$4((s) => s.trim()), catchAll(() => succeed$3("")), map$4((name) => name === "" ? "main" : name)),
 		topLevel: () => exec("git", "rev-parse", "--show-toplevel").pipe(map$4((s) => s.trim())),
 		gitDir: () => exec("git", "rev-parse", "--absolute-git-dir").pipe(map$4((s) => s.trim())),
 		gitCommonDir: () => exec("git", "rev-parse", "--path-format=absolute", "--git-common-dir").pipe(map$4((s) => s.trim())),
@@ -58112,45 +58117,71 @@ const load = gen(function* () {
 	const { levels, compiled, decodeDiagnostics } = yield* readRc;
 	const module = yield* discovery.workflowModule(host.root, host.home);
 	const loaded = yield* try_({
-		try: () => loadWorkflow(module),
+		try: () => loadWorkflows(module),
 		catch: (e) => new GtdError(`gtd config:\n  - ${module?.filepath ?? "(built-in default)"}: ${e instanceof Error ? e.message : String(e)}`)
 	});
 	const layerOrder = [...levels.map((level) => level.filepath), ...module ? [module.filepath] : []];
 	const diagnostics = dedupeDiagnostics(sortDiagnostics([
 		...decodeDiagnostics,
 		...compiled.diagnostics,
-		...wrongKindDiagnostics(loaded, compiled)
+		...wrongKindDiagnostics(loaded.files, compiled)
 	], layerOrder));
 	yield* failOnErrors(diagnostics);
-	const initial = yield* firstStep(loaded, headTree(yield* Workspace));
+	const initial = yield* firstStep(loaded.default, headTree(yield* Workspace));
+	const steering = Object.assign({}, ...loaded.files.map((f) => f.steering));
+	const scopesOf = (file) => {
+		const vars = resolveVars(file.defaults, compiled.rcVars, {}, host.env);
+		try {
+			return [...Object.keys(file.skills(vars)), ...Object.keys(file.access(vars))];
+		} catch {
+			return [];
+		}
+	};
+	const define = (entry) => ({
+		flow: entry.flow,
+		summary: entry.file.summary,
+		base: entry.file.base,
+		steering,
+		modes: compiled.modes,
+		skills: entry.file.skills,
+		configuredSkills: compiled.rcSkills,
+		skillsKeys: compiled.skillsKeys,
+		access: entry.file.access,
+		configuredAccess: compiled.access,
+		accessKeys: compiled.accessKeys,
+		knownScopes: () => loaded.files.filter((f) => f !== entry.file).flatMap(scopesOf),
+		skillsOrigin: entry.file.origin,
+		initial
+	});
+	const names = [...loaded.catalogue.keys()].sort();
+	const resolve = (name, entry) => ({
+		name,
+		def: define(entry),
+		vars: { ...entry.file.defaults },
+		env: { ...entry.file.envDefaults }
+	});
+	const defaultWorkflow = resolve(loaded.default.name, loaded.default);
 	return {
-		workflow: {
-			flow: loaded.flow,
-			summary: loaded.summary,
-			base: loaded.base,
-			steering: loaded.steering,
-			modes: compiled.modes,
-			skills: loaded.skills,
-			configuredSkills: compiled.rcSkills,
-			skillsKeys: compiled.skillsKeys,
-			access: loaded.access,
-			configuredAccess: compiled.access,
-			accessKeys: compiled.accessKeys,
-			skillsOrigin: module?.filepath ?? "(built-in default)",
-			initial
+		workflow: defaultWorkflow.def,
+		defaultWorkflow,
+		workflowNames: names,
+		doors: loaded.doors,
+		workflowNamed: (name) => {
+			const entry = loaded.catalogue.get(name);
+			return entry === void 0 ? void 0 : resolve(name, entry);
 		},
-		workflowVars: { ...loaded.defaults },
 		rcVars: compiled.rcVars,
-		workflowEnv: { ...loaded.envDefaults },
 		rcEnv: compiled.rcEnv,
 		...compiled.ui !== void 0 ? { ui: compiled.ui } : {},
 		warnings: diagnostics.filter((d) => d.severity === "warning"),
 		configFiles: levels.map((level) => level.filepath),
-		workflowFiles: loaded.dependencyFiles
+		workflowFiles: loaded.files.flatMap((f) => f.dependencyFiles)
 	};
 });
 /** A name under the wrong key (or under both) in a `.gtdrc` layer: each is an error at its own origin. */
-const wrongKindDiagnostics = (loaded, compiled) => {
+const wrongKindDiagnostics = (files, compiled) => {
+	const isEnvOnly = (key) => files.some((f) => Object.hasOwn(f.envDefaults, key)) && !files.some((f) => Object.hasOwn(f.defaults, key));
+	const isVarOnly = (key) => files.some((f) => Object.hasOwn(f.defaults, key)) && !files.some((f) => Object.hasOwn(f.envDefaults, key));
 	const error = (path, message, origin) => ({
 		severity: "error",
 		path,
@@ -58158,9 +58189,9 @@ const wrongKindDiagnostics = (loaded, compiled) => {
 		origin
 	});
 	const diagnostics = [];
-	for (const { key, origin } of compiled.varsKeys) if (Object.hasOwn(loaded.envDefaults, key)) diagnostics.push(error(["vars", key], `"vars.${key}" is an environment setting — move it under "env:"`, origin));
+	for (const { key, origin } of compiled.varsKeys) if (isEnvOnly(key)) diagnostics.push(error(["vars", key], `"vars.${key}" is an environment setting — move it under "env:"`, origin));
 	for (const { key, origin } of compiled.envKeys) {
-		if (Object.hasOwn(loaded.defaults, key)) diagnostics.push(error(["env", key], `"env.${key}" is a process setting — move it under "vars:"`, origin));
+		if (isVarOnly(key)) diagnostics.push(error(["env", key], `"env.${key}" is a process setting — move it under "vars:"`, origin));
 		if (compiled.varsKeys.some((v) => v.key === key)) diagnostics.push(error(["env", key], `"${key}" is declared under both "vars:" and "env:" — a setting is one kind or the other`, origin));
 	}
 	return diagnostics;
@@ -58188,7 +58219,7 @@ const jiti = () => {
 	return jitiModule.createJiti(import.meta.url, {
 		virtualModules: {
 			"@pmelab/gtd/flows": flows_exports,
-			"@pmelab/gtd/workflow": unified_exports
+			"@pmelab/gtd/workflow": bundled_exports
 		},
 		fsCache: false,
 		moduleCache: false,
@@ -58225,14 +58256,19 @@ const optionalFunction = (exports, name) => {
 	if (typeof value !== "function") throw new Error(`the "${name}" export is not a function`);
 	return value;
 };
-/**
-* Read a workflow module: the default export is the flow; `defaults`,
-* `envDefaults`, `summary`, `base` and `steering` are optional; any other export is ignored.
-*/
-const fromModule = (exported, origin, dependencyFiles) => {
-	const exports = typeof exported === "object" && exported !== null ? exported : {};
-	const flow = exports.default;
-	if (typeof flow !== "function") throw new Error("the default export is not a flow — export default an async function");
+const RESERVED_EXPORTS = /* @__PURE__ */ new Set([
+	"default",
+	"summary",
+	"base",
+	"defaults",
+	"envDefaults",
+	"steering",
+	"skills",
+	"access",
+	"doors"
+]);
+/** A module's per-file exports: `defaults`, `envDefaults`, `steering`, `skills`, `access`, `summary`, `base`. */
+const fileFrom = (exports, origin, dependencyFiles) => {
 	const defaults = stringRecord(exports, "defaults");
 	const envDefaults = stringRecord(exports, "envDefaults");
 	for (const [exportName, record] of [["defaults", defaults], ["envDefaults", envDefaults]]) {
@@ -58242,7 +58278,6 @@ const fromModule = (exported, origin, dependencyFiles) => {
 	const both = Object.keys(defaults).filter((name) => Object.hasOwn(envDefaults, name));
 	if (both.length > 0) throw new Error(`${both.map((name) => `"${name}"`).join(", ")} declared in both "defaults" and "envDefaults" — a setting is a process setting or an environment setting, not both`);
 	return {
-		flow,
 		defaults,
 		envDefaults,
 		steering: stringRecord(exports, "steering"),
@@ -58254,23 +58289,120 @@ const fromModule = (exported, origin, dependencyFiles) => {
 		dependencyFiles
 	};
 };
+const DOOR_NAME_RULE = /^[a-z][a-z0-9-]*$/;
+/** Why one door's `args` are malformed, or `undefined` when they are well-formed. */
+const argsProblem = (args) => {
+	if (args === void 0) return void 0;
+	if (!Array.isArray(args)) return `has "args" that is not an array`;
+	const seen = /* @__PURE__ */ new Set();
+	let optional = false;
+	for (const arg of args) {
+		if (typeof arg?.name !== "string") return `has an arg without a "name"`;
+		if (seen.has(arg.name)) return `declares duplicate arg "${arg.name}"`;
+		seen.add(arg.name);
+		if (arg.optional === true) optional = true;
+		else if (optional) return `declares required arg "${arg.name}" after an optional one`;
+	}
+};
+/** Why one door is malformed, or `undefined` when it is well-formed. */
+const doorProblem = (name, door) => {
+	if (!DOOR_NAME_RULE.test(name)) return `is not a valid door name — it must match ${DOOR_NAME_RULE}`;
+	const { workflow, args, vars } = door ?? {};
+	if (typeof workflow !== "string") return `must be an object with a "workflow" name`;
+	const varsOk = vars === void 0 || typeof vars === "function";
+	return argsProblem(args) ?? (varsOk ? void 0 : `has "vars" that is not a function`);
+};
+/** A module's `doors` export, shape-checked; the workflow names are checked later, against the merged catalogue. */
+const doorsFrom = (exports) => {
+	const value = exports["doors"];
+	if (value === void 0) return /* @__PURE__ */ new Map();
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`the "doors" export is not a record of doors`);
+	for (const [name, door] of Object.entries(value)) {
+		const problem = doorProblem(name, door);
+		if (problem !== void 0) throw new Error(`door "${name}" ${problem}`);
+	}
+	return new Map(Object.entries(value));
+};
+/** Merge bundled and repo doors (repo wins), then check each names a workflow the merged catalogue holds. */
+const mergeDoors = (bundled, repo, catalogue) => {
+	const doors = new Map([...bundled, ...repo].sort(([a], [b]) => a.localeCompare(b)));
+	for (const [name, door] of doors) if (!catalogue.has(door.workflow)) throw new Error(`door "${name}" names workflow "${door.workflow}", which is not startable — known: ${[...catalogue.keys()].sort().join(", ")}`);
+	return doors;
+};
+const namespaceOf = (exported) => typeof exported === "object" && exported !== null ? exported : {};
+/**
+* The bundled module is never scanned: its helper exports stay helpers, and
+* exactly these three are startable.
+*/
+const loadBundled = () => {
+	const file = fileFrom(namespaceOf(bundled_exports), BUILT_IN_ORIGIN, []);
+	const { feature, review, fix } = bundled_exports;
+	return {
+		file,
+		doors: doorsFrom(namespaceOf(bundled_exports)),
+		catalogue: /* @__PURE__ */ new Map([
+			["feature", {
+				flow: feature,
+				file
+			}],
+			["review", {
+				flow: review,
+				file
+			}],
+			["fix", {
+				flow: fix,
+				file
+			}]
+		])
+	};
+};
 /**
-* Evaluate `gtd.config.ts`, or take the bundled default. `cache` is jiti's
-* OWN per-call module cache (unrelated to the instance's `moduleCache:
-* false` — that governs reuse ACROSS calls, this one is populated fresh
-* DURING this one) — passing an empty object in has the side effect of
-* collecting every real file jiti resolved evaluating this module, module
-* AND every relative import it pulled in, transitively. Virtual modules
-* (`@pmelab/gtd/flows`) never touch it — no real file backs them.
+* Evaluate `gtd.config.ts` and overlay it on the bundled workflows. Every
+* exported function of the repo file but the reserved names is a workflow
+* named by its export. `cache` is jiti's OWN per-call module cache (unrelated
+* to the instance's `moduleCache: false`) — passing an empty object in has
+* the side effect of collecting every real file jiti resolved evaluating this
+* module, module AND every relative import it pulled in, transitively.
 */
-const loadWorkflow = (module) => {
-	if (module === void 0) return fromModule(unified_exports, BUILT_IN_ORIGIN, []);
+const loadWorkflows = (module) => {
+	const bundled = loadBundled();
+	const bundledDefault = {
+		flow: feature,
+		file: bundled.file,
+		name: "feature"
+	};
+	if (module === void 0) return {
+		files: [bundled.file],
+		catalogue: bundled.catalogue,
+		doors: mergeDoors(bundled.doors, /* @__PURE__ */ new Map(), bundled.catalogue),
+		default: bundledDefault
+	};
 	const cache = {};
-	const exported = jiti().evalModule(module.source, {
+	const exports = namespaceOf(jiti().evalModule(module.source, {
 		filename: module.filepath,
 		cache
-	});
-	return fromModule(exported, module.filepath, Object.keys(cache));
+	}));
+	const file = fileFrom(exports, module.filepath, Object.keys(cache));
+	const catalogue = new Map(bundled.catalogue);
+	for (const [name, value] of Object.entries(exports)) {
+		if (RESERVED_EXPORTS.has(name) || typeof value !== "function") continue;
+		catalogue.set(name, {
+			flow: value,
+			file
+		});
+	}
+	const flow = exports.default;
+	if (flow !== void 0 && typeof flow !== "function") throw new Error("the default export is not a function");
+	return {
+		files: [bundled.file, file],
+		catalogue,
+		doors: mergeDoors(bundled.doors, doorsFrom(exports), catalogue),
+		default: flow === void 0 ? bundledDefault : {
+			flow,
+			file,
+			name: "default"
+		}
+	};
 };
 const headTree = (workspace) => {
 	let entries;
@@ -58326,7 +58458,6 @@ const settingReads = (kind, watch) => {
 const replayToFirstStep = (loaded, vars, env, tree) => flatMap$4(promise(() => replay({
 	flow: loaded.flow,
 	episode: {
-		entry: void 0,
 		base: {
 			hash: "",
 			tree
@@ -58340,7 +58471,7 @@ const replayToFirstStep = (loaded, vars, env, tree) => flatMap$4(promise(() => r
 })), (outcome) => {
 	if (outcome.kind === "rest") return succeed$3(outcome.rest.name);
 	const problem = outcome.kind === "failed" || outcome.kind === "refused" ? outcome.message.replace(/^gtd: /, "") : "the default entry must begin at a step — that step is where a finished process waits";
-	return fail$7(new GtdError(`gtd config:\n  - ${loaded.origin}: ${problem}`));
+	return fail$7(new GtdError(`gtd config:\n  - ${loaded.file.origin}: ${problem}`));
 });
 /**
 * The default entry's first step — where a finished process waits — found the
@@ -58356,13 +58487,13 @@ const firstStep = (loaded, head) => gen(function* () {
 	const env = watchedEmptySettings();
 	const outcome = yield* either(replayToFirstStep(loaded, vars.settings, env.settings, empty.tree));
 	const reads = [...settingReads("process", vars), ...settingReads("environment", env)];
-	if (reads.length > 0) return yield* fail$7(new GtdError(`gtd config:\n  - ${loaded.origin}: the flow's first step on an ordinary start reads ${reads.join(" and ")} — that step is where a finished process waits, so it must not depend on a setting`));
+	if (reads.length > 0) return yield* fail$7(new GtdError(`gtd config:\n  - ${loaded.file.origin}: the flow's first step on an ordinary start reads ${reads.join(" and ")} — that step is where a finished process waits, so it must not depend on a setting`));
 	if (outcome._tag === "Left") return yield* fail$7(outcome.left);
 	const name = outcome.right;
 	if (!empty.read()) return name;
 	const atHead = yield* replayToFirstStep(loaded, vars.settings, env.settings, head);
 	if (atHead === name) return name;
-	return yield* fail$7(new GtdError(`gtd config:\n  - ${loaded.origin}: the flow's first step on an ordinary start depends on the repository's files ("${name}" without them, "${atHead}" at HEAD) — that step is where a finished process waits, so it must not change as files do`));
+	return yield* fail$7(new GtdError(`gtd config:\n  - ${loaded.file.origin}: the flow's first step on an ordinary start depends on the repository's files ("${name}" without them, "${atHead}" at HEAD) — that step is where a finished process waits, so it must not change as files do`));
 });
 var ConfigService = class ConfigService extends Tag("ConfigService")() {
 	static Live = succeed$2(ConfigService, { load });
@@ -58401,6 +58532,7 @@ const checkKeys = (keys, known, message, section) => {
 		origin
 	})), [...new Set(keys.map((k) => k.origin))])));
 };
+const knownTo = (def, own) => [.../* @__PURE__ */ new Set([...own, ...def.knownScopes?.() ?? []])];
 /**
 * Skill lists for the settings actually in use. `.gtdrc` `skills:` keys are
 * judged here, not at config load: only now are the pinned/entry vars known.
@@ -58410,7 +58542,8 @@ const resolveScopeSkills = (def, vars) => gen(function* () {
 		try: () => checkShape(def.skills(vars)),
 		catch: (e) => fail$4(def.skillsOrigin, e instanceof Error ? e.message : String(e))
 	});
-	yield* checkKeys(def.skillsKeys, Object.keys(skills), unknownSkillsKeyMessage, "skills");
+	const known = knownTo(def, Object.keys(skills));
+	yield* checkKeys(def.skillsKeys, known, unknownSkillsKeyMessage, "skills");
 	return skills;
 });
 const checkAccessShape = (value) => {
@@ -58430,7 +58563,8 @@ const resolveScopeAccess = (def, skills, vars) => gen(function* () {
 		try: () => checkAccessShape(def.access(vars)),
 		catch: (e) => fail$4(def.skillsOrigin, e instanceof Error ? e.message : String(e))
 	});
-	yield* checkKeys(def.accessKeys, [.../* @__PURE__ */ new Set([...Object.keys(skills), ...Object.keys(access)])], unknownAccessKeyMessage, "access");
+	const known = knownTo(def, [...Object.keys(skills), ...Object.keys(access)]);
+	yield* checkKeys(def.accessKeys, known, unknownAccessKeyMessage, "access");
 	return access;
 });
 //#endregion
@@ -63819,14 +63953,16 @@ const demandOf = (input) => {
 * instead of failing loudly.
 */
 const statusOf = (input) => {
-	const { rendered, idle, log, changes, next, cost, costByModel } = input;
+	const { rendered, idle, initial, workflow, log, changes, next, cost, costByModel } = input;
 	return {
 		idle,
+		initial,
 		model: rendered.model,
 		system: rendered.system !== void 0 && rendered.system !== "" ? rendered.system : void 0,
 		log,
 		state: rendered.state,
 		actor: rendered.actor,
+		workflow,
 		label: rendered.label,
 		memory: rendered.memory,
 		file: rendered.file,
@@ -63875,7 +64011,7 @@ const dispatchFieldsOf = (demand) => {
 	}
 };
 /**
-* Flatten a `Demand` plus its `BeatStatus` into the single 21-key document
+* Flatten a `Demand` plus its `BeatStatus` into the single 23-key document
 * `gtd next --json` emits — the ONLY place the two are joined. `cost`/
 * `costByModel` are omitted together, exactly when no cost was recorded
 * (`cost <= 0`).
@@ -63887,6 +64023,7 @@ const beatDocument = (demand, status) => {
 		kind: demand.kind,
 		content: demand.content,
 		idle: status.idle,
+		initial: status.initial,
 		session,
 		model: status.model,
 		system: status.system,
@@ -63894,6 +64031,7 @@ const beatDocument = (demand, status) => {
 		log: status.log,
 		state: status.state,
 		actor: status.actor,
+		workflow: status.workflow,
 		label: status.label,
 		memory: status.memory,
 		file: status.file,
@@ -63932,7 +64070,7 @@ const definedFields = (entries) => {
 	return result;
 };
 /**
-* The header block's own lines — `State:`/`Awaits:`/optional `Label:`/
+* The header block's own lines — `State:`/`Awaits:`/`Workflow:`/optional `Label:`/
 * `Model:`/`Memory:`/`File:`/`Mode:`/`Cost:`(+breakdown)/`Pending:`/`Next:`,
 * in that order. Used by `renderBeatPlain`'s header-showing kinds below.
 */
@@ -63947,6 +64085,7 @@ const beatHeaderLines = (document) => {
 	return [
 		`State: ${document.state}`,
 		`Awaits: ${document.actor}`,
+		`Workflow: ${document.workflow}`,
 		...Object.entries(optional).map(([key, value]) => `${key}: ${value}`),
 		...costStatusLines(document.cost ?? 0, document.costByModel ?? []),
 		...pendingStatusLines(document.changes),
@@ -64148,7 +64287,7 @@ const accessRefusal = (changes, write) => {
 	].join("\n");
 };
 //#endregion
-//#region src/step/planEntry.ts
+//#region src/step/planStart.ts
 const refusal = (message) => ({
 	kind: "refusal",
 	message
@@ -64160,43 +64299,42 @@ const checkOverrides = (commandLabel, varOverrides, declaredNames, envNames) =>
 	if (undeclared.length > 0) return refusal(`${commandLabel}: --var name(s) not declared by this workflow: ${undeclared.join(", ")} — declared: ${declaredNames.length > 0 ? declaredNames.join(", ") : "(none)"}`);
 });
 /**
-* `gtd --entry <name>`: start a brand NEW process at a workflow entry, writing
-* an opening commit that carries every process setting as a `Gtd-Var:` trailer, plus a
-* `Gtd-Review-Base:` trailer when the entry fixes the process's diff base.
+* `gtd --workflow <name>`: start a brand NEW process on a workflow, writing an
+* opening commit that names the workflow's first step and carries a
+* `Gtd-Workflow:` trailer, every process setting as a `Gtd-Var:` trailer, plus
+* a `Gtd-Review-Base:` trailer when the workflow fixes the process's diff base.
 * All validation is a REFUSAL, not an Effect failure.
 */
-const planEntry = (current, actor, entry) => gen(function* () {
-	const { state: name, commandLabel, vars: varOverrides } = entry;
-	if (!current.idle) return refusal(`${commandLabel}: a process is already underway (resting at "${current.state}") — finish it, or run \`gtd abandon\`, before entering`);
-	if (current.entryRefusal !== void 0) return refusal(`${commandLabel}: ${current.entryRefusal}`);
+const planStart = (current, actor, start) => gen(function* () {
+	const { workflow, first, commandLabel, vars: varOverrides } = start;
+	const name = workflow.name;
+	if (!current.idle) return refusal(`${commandLabel}: a process is already underway (resting at "${current.state}") — finish it, or run \`gtd abandon\`, before starting another`);
+	if ("refusal" in first) return refusal(`${commandLabel}: ${first.refusal}`);
+	const { firstStep } = first;
 	const config = yield* (yield* ConfigService).load;
 	const declaredNames = Object.keys({
-		...config.workflowVars,
+		...workflow.vars,
 		...config.rcVars
 	});
 	const overrideRefusal = yield* checkOverrides(commandLabel, varOverrides, declaredNames, Object.keys({
-		...config.workflowEnv,
+		...workflow.env,
 		...config.rcEnv
 	}));
 	if (overrideRefusal !== void 0) return overrideRefusal;
-	let base;
-	const baseOf = current.def.base;
-	const vars = resolveVars(config.workflowVars, config.rcVars, varOverrides, (yield* Host).env);
+	const baseOf = workflow.def.base;
+	const vars = resolveVars(workflow.vars, config.rcVars, varOverrides, (yield* Host).env);
 	const multiline = multilineSetting(vars);
 	if (multiline !== void 0) return refusal(`${commandLabel}: process setting "${multiline}" spans several lines — a process setting is pinned in a commit trailer and must be a single line`);
 	const template = yield* try_({
 		try: () => baseOf?.(name, vars),
 		catch: (e) => /* @__PURE__ */ new Error(`${commandLabel}: ${e instanceof Error ? e.message : String(e)}`)
 	});
-	if (baseOf !== void 0 && template !== void 0) {
-		const resolved = yield* resolveBase(name, commandLabel, baseOf, template);
-		if (typeof resolved !== "string") return resolved;
-		base = resolved;
-	}
-	const subject = formatSubject(actor, name);
+	const base = template === void 0 ? void 0 : yield* resolveBase(commandLabel, template);
+	if (typeof base === "object") return base;
+	const subject = formatSubject(actor, firstStep);
 	return {
-		kind: "entry",
-		state: name,
+		kind: "start",
+		workflow: name,
 		subject,
 		steps: [{
 			kind: "gitWrite",
@@ -64204,7 +64342,8 @@ const planEntry = (current, actor, entry) => gen(function* () {
 				kind: "commitAll",
 				message: formatCommitMessage({
 					actor,
-					to: name,
+					to: firstStep,
+					workflow: name,
 					...base !== void 0 ? { reviewBase: base } : {},
 					vars
 				})
@@ -64218,16 +64357,21 @@ const planEntry = (current, actor, entry) => gen(function* () {
 		}]
 	};
 });
-/** The entry's diff base: a commitish that resolves, is an ancestor of HEAD, and is not HEAD. */
-const resolveBase = (name, commandLabel, base, value) => gen(function* () {
-	const rendered = value.trim();
-	if (rendered === "") return refusal(`${commandLabel}: "${name}"'s reviewBase template rendered blank — template: ${base.toString()}; pass the base with --var`);
+/**
+* The workflow's diff base: `git merge-base <base> HEAD`, where a blank base
+* means the default branch. The merge-base is what gets pinned, so a base on
+* another branch reviews exactly this branch's own commits.
+*/
+const resolveBase = (commandLabel, value) => gen(function* () {
 	const git = yield* GitService;
-	const resolvedBase = yield* either(git.resolveRef(rendered));
-	if (resolvedBase._tag === "Left") return refusal(`${commandLabel}: "${rendered}" does not resolve to a commit`);
-	if (!(yield* git.isAncestor(resolvedBase.right, "HEAD"))) return refusal(`${commandLabel}: "${rendered}" is not an ancestor of HEAD`);
-	if (resolvedBase.right === (yield* git.resolveRef("HEAD"))) return refusal(`${commandLabel}: "${rendered}" is HEAD — nothing to review`);
-	return resolvedBase.right;
+	const rendered = value.trim();
+	const target = rendered === "" ? yield* git.defaultBranch() : rendered;
+	const resolvedBase = yield* either(git.resolveRef(target));
+	if (resolvedBase._tag === "Left") return refusal(`${commandLabel}: "${target}" does not resolve to a commit`);
+	const mergeBase = yield* git.mergeBase(resolvedBase.right, "HEAD");
+	if (isNone(mergeBase)) return refusal(`${commandLabel}: "${target}" shares no common ancestor with HEAD`);
+	if (mergeBase.value === (yield* git.resolveRef("HEAD"))) return refusal(`${commandLabel}: nothing to review: HEAD has no commits beyond ${target}`);
+	return mergeBase.value;
 });
 //#endregion
 //#region src/Edge.ts
@@ -64240,9 +64384,10 @@ const ACTORS = /* @__PURE__ */ new Set([
 ]);
 /**
 * Where the episode HEAD belongs to begins, read off subjects alone. Walking
-* back from HEAD: a trailer-less bare `gtd(human): <entry>` commit is what
-* `gtd --entry` writes — no landing ever produces one — and opens an entered
-* episode as its first commit; a commit that is not a gtd step commit, or one
+* back from HEAD: a bare `gtd(human): <step>` commit with no `Gtd-Step` is what
+* `gtd --workflow` writes — no landing ever produces one — and opens an
+* episode as its first commit (its `Gtd-Workflow` trailer names the workflow;
+* a legacy `--entry` opening has none); a commit that is not a gtd step commit, or one
 * entering the flow's first step (a finished episode), bounds the episode
 * from below.
 */
@@ -64251,18 +64396,21 @@ const locateEpisode = (def, history) => {
 		const message = parseCommitMessage(history[i].message);
 		const subject = message.parsed;
 		if (subject !== void 0 && message.step === void 0 && subject.from === void 0 && subject.actor === "human") return {
-			entry: subject.to,
+			workflow: message.workflow,
+			legacyOpening: message.workflow === void 0,
 			baseIndex: i,
 			processStart: i
 		};
 		if (subject === void 0 || !ACTORS.has(subject.actor) || subject.to === def.initial) return {
-			entry: void 0,
+			workflow: void 0,
+			legacyOpening: false,
 			baseIndex: i,
 			processStart: i + 1
 		};
 	}
 	return {
-		entry: void 0,
+		workflow: void 0,
+		legacyOpening: false,
 		baseIndex: -1,
 		processStart: 0
 	};
@@ -64296,7 +64444,8 @@ const runOf = (history, location, closingHash = void 0) => {
 	const startParentHash = hashAt(history, location.processStart - 1) ?? EMPTY_TREE$1;
 	const head = history[history.length - 1];
 	return {
-		entry: location.entry,
+		workflow: location.workflow,
+		legacyOpening: location.legacyOpening,
 		startHash: hashAt(history, location.processStart) ?? head?.hash ?? EMPTY_TREE$1,
 		startParentHash,
 		diffBase: first?.reviewBase ?? startParentHash,
@@ -64323,10 +64472,10 @@ const PAGE_TIERS = [
 * gtd step commit, or one landing the flow's initial state, bounds an
 * episode from below — EXCEPT a bare `gtd(human): <x>` subject (no `→`),
 * which is NEVER a boundary here, whatever `<x>` is. That bare shape is
-* `locateEpisode`'s own `opening` branch (an entered episode's first commit),
+* `locateEpisode`'s own `opening` branch (a started episode's first commit),
 * which takes priority there over the initial-state check no matter what the
-* entry is named — including an entry named after `def.initial` itself,
-* where the two branches would otherwise disagree. A bare human commit can
+* workflow's first step is named — including one named after `def.initial`
+* itself, where the two branches would otherwise disagree. A bare human commit can
 * also be a self-loop step landing rather than a real opening (this
 * subject-only pass can't read the `Gtd-Step` trailer that would tell them
 * apart), so ruling it out here can only make `findBoundaryBase` walk a FEW
@@ -64462,16 +64611,24 @@ const pendingTree = (workspace, entries, rewrite) => {
 * The one resolver of both setting kinds. Process settings: the recorded
 * (pinned) value wins per name, anything unrecorded resolves live — the
 * fallback for a process started before pinning existed. Environment settings
-* are always live. `entryOverrides` are `--var` values, passed only while a
-* process is being entered.
+* are always live. `startOverrides` are `--var` values, passed only while a
+* process is being started.
 */
-const settingsFor = (config, pinnedVars, hostEnv, entryOverrides = {}) => ({
+const settingsFor = (config, workflow, pinnedVars, hostEnv, startOverrides = {}) => ({
 	vars: {
-		...resolveVars(config.workflowVars, config.rcVars, entryOverrides, hostEnv),
+		...resolveVars(workflow.vars, config.rcVars, startOverrides, hostEnv),
 		...pinnedVars
 	},
-	env: resolveVars(config.workflowEnv, config.rcEnv, {}, hostEnv)
+	env: resolveVars(workflow.env, config.rcEnv, {}, hostEnv)
 });
+/** The workflow a run replays on: its pinned one, else the default. */
+const workflowOf = (config, run) => {
+	if (run.legacyOpening) return fail$7(/* @__PURE__ */ new Error("gtd: this process was opened by `gtd --entry`, which no longer exists — run `gtd abandon` to start over"));
+	if (run.workflow === void 0) return succeed$3(config.defaultWorkflow);
+	const named = config.workflowNamed(run.workflow);
+	if (named !== void 0) return succeed$3(named);
+	return fail$7(/* @__PURE__ */ new Error(`gtd: this process runs workflow "${run.workflow}", which gtd.config.ts no longer defines — run \`gtd abandon\` to start over`));
+};
 /**
 * `judgeBudgetBytes` is the one var that refuses rather than disabling its
 * mechanism when blanked: without a bound the judge payload is rejected
@@ -64488,7 +64645,6 @@ const judgeBudgetBytes = (vars) => {
 const replayFor = (setup, pending) => replay({
 	flow: setup.def.flow,
 	episode: {
-		entry: setup.run.entry,
 		base: setup.base,
 		commits: setup.episode
 	},
@@ -64506,7 +64662,7 @@ const replayFor = (setup, pending) => replay({
 const replayError = (outcome) => {
 	if (outcome.kind === "divergence" || outcome.kind === "failed") return new Error(outcome.message);
 	if (outcome.kind === "refused") return /* @__PURE__ */ new Error(`gtd: ${outcome.message}`);
-	if (outcome.kind === "ended") return /* @__PURE__ */ new Error("gtd: history ends the episode, but HEAD does not enter the default entry's first step — the workflow changed under this process; run `gtd abandon` to start over");
+	if (outcome.kind === "ended") return /* @__PURE__ */ new Error("gtd: history ends the episode, but HEAD does not enter the default workflow's first step — the workflow changed under this process; run `gtd abandon` to start over");
 };
 const judgeDocument = (step) => step.request.kind === "judge" ? JSON.stringify({
 	state: step.request.evidence,
@@ -64633,14 +64789,15 @@ const costByModel = (entries) => {
 	})).sort((a, b) => b.cost - a.cost || a.model.localeCompare(b.model));
 };
 /** Resolve the rest at `ref`, or at HEAD when `ref` is `undefined`. */
-const restAt = (ref, entryOverrides = {}) => gen(function* () {
+const restAt = (ref, startOverrides = {}) => gen(function* () {
 	const git = yield* GitService;
 	const config = yield* (yield* ConfigService).load;
 	const workspace = yield* Workspace;
 	const host = yield* Host;
-	const def = config.workflow;
-	const run = yield* computeProcessRun(git, def, ref);
-	const { vars, env } = settingsFor(config, run.pinnedVars, host.env, entryOverrides);
+	const run = yield* computeProcessRun(git, config.workflow, ref);
+	const resolved = yield* workflowOf(config, run);
+	const def = resolved.def;
+	const { vars, env } = settingsFor(config, resolved, run.pinnedVars, host.env, startOverrides);
 	const skills = yield* resolveScopeSkills(def, vars);
 	const access = yield* resolveScopeAccess(def, skills, vars);
 	const budget = yield* try_({
@@ -64688,6 +64845,7 @@ const restAt = (ref, entryOverrides = {}) => gen(function* () {
 	const memory = memoryOf(outcome.trace, run);
 	return {
 		def,
+		workflowName: resolved.name,
 		state: step.name,
 		stepDef,
 		actor: step.actor,
@@ -64709,21 +64867,20 @@ const restAt = (ref, entryOverrides = {}) => gen(function* () {
 });
 const currentRest = restAt(void 0);
 /**
-* Why `gtd --entry <name>` cannot open a process here, or `undefined` when it
-* can: the flow, handed `name`, must read it and reach a step from the tree
-* the opening commit would capture.
+* 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.
 */
-const entryRefusal = (rest, name, entryVars) => gen(function* () {
+const startRefusal = (rest, resolved, startVars) => gen(function* () {
 	const config = yield* (yield* ConfigService).load;
 	const host = yield* Host;
-	const { vars, env } = settingsFor(config, {}, host.env, entryVars);
-	const skills = yield* resolveScopeSkills(rest.def, vars);
-	const access = yield* resolveScopeAccess(rest.def, skills, vars);
+	const { vars, env } = settingsFor(config, resolved, {}, host.env, startVars);
+	const skills = yield* resolveScopeSkills(resolved.def, vars);
+	const access = yield* resolveScopeAccess(resolved.def, skills, vars);
 	const workspace = rest.setup.workspace;
 	const outcome = yield* promise(() => replay({
-		flow: rest.def.flow,
+		flow: resolved.def.flow,
 		episode: {
-			entry: name,
 			base: {
 				hash: "",
 				tree: pendingTree(workspace, rest.setup.pendingWorktree(), void 0)
@@ -64735,13 +64892,14 @@ const entryRefusal = (rest, name, entryVars) => gen(function* () {
 		start: "",
 		budgetBytes: rest.setup.budget,
 		skills,
-		configuredSkills: rest.def.configuredSkills,
+		configuredSkills: resolved.def.configuredSkills,
 		access,
-		configuredAccess: rest.def.configuredAccess
+		configuredAccess: resolved.def.configuredAccess
 	}));
-	if (outcome.kind === "refused") return outcome.message;
-	if (outcome.kind === "rest") return outcome.entryRead ? void 0 : `"${name}" is not an enterable state — this workflow reads no entry`;
-	return `"${name}" is not an enterable state — ${outcome.kind === "ended" ? "the flow reaches no step for it" : outcome.message}`;
+	if (outcome.kind === "rest") return { firstStep: outcome.rest.name };
+	if (outcome.kind === "refused") return { refusal: outcome.message };
+	const why = outcome.kind === "ended" ? "the flow reaches no step" : outcome.message;
+	return { refusal: `workflow "${resolved.name}" cannot start — ${why}` };
 });
 /** The review window's diff base at the rest. */
 const reviewBaseFor = (rest) => rest.step.request.options.base ?? rest.run.diffBase;
@@ -64759,8 +64917,8 @@ const renderRest = (rest) => succeed$3({
 * attempt at this very agent rest, and another dispatch would repeat it.
 */
 const stalledAt = (rest) => rest.changes.length === 0 && rest.stepDef.kind === "prompt" && rest.stepDef.allowEmpty !== true && rest.run.headTurn?.state === rest.state && rest.run.headTurn.actor === rest.actor && !rest.run.headTurn.step && rest.run.headTurn.empty;
-/** No process is underway: the default entry's first step, first visit — a dirty tree there is a turn not yet landed, not a process. */
-const noProcessUnderway = (rest) => rest.run.entry === void 0 && rest.state === rest.def.initial && rest.step.id.occurrence === 1;
+/** No process is underway: the default workflow's first step, first visit — a dirty tree there is a turn not yet landed, not a process. */
+const noProcessUnderway = (rest) => rest.run.workflow === void 0 && rest.state === rest.def.initial && rest.step.id.occurrence === 1;
 /** `idle` means exactly one thing: no process underway, clean tree. */
 const restIsIdle = (rest) => noProcessUnderway(rest) && rest.changes.length === 0;
 const isHumanReviewGate = (def) => def.actor === "human" && def.mode === "review";
@@ -64799,8 +64957,19 @@ const landingTarget = (outcome, rest) => {
 		message: outcome.message
 	});
 	if (outcome.kind === "divergence" || outcome.kind === "failed") return fail$7(new Error(outcome.message));
-	return succeed$3(outcome.kind === "rest" ? outcome.rest.name : rest.def.initial);
+	if (outcome.kind !== "rest") return succeed$3(rest.def.initial);
+	const reserved = initialStepRefusal(rest.run.workflow, outcome.rest.name, rest.def.initial);
+	return succeed$3(reserved === void 0 ? outcome.rest.name : reserved);
 };
+/**
+* A step commit entering the default's first step is what ends an episode, so
+* a named workflow landing there would read back as finished. Its opening
+* commit may name that step: a bare opening is never read as a boundary.
+*/
+const initialStepRefusal = (workflow, step, initial) => workflow !== void 0 && step === initial ? {
+	kind: "refusal",
+	message: `gtd: workflow "${workflow}" reaches step "${step}", the default workflow's first step — that is where a finished process waits, so a started process must never land there; rename the step`
+} : void 0;
 const landingTo = (rest, to) => {
 	if (rest.changes.length === 0 && rest.stepDef.kind === "script" && to === rest.state) return {
 		kind: "noop",
@@ -64862,7 +65031,8 @@ const snapshotFromRest = (rest, verdicts) => gen(function* () {
 const summaryFor = (run) => gen(function* () {
 	const config = yield* (yield* ConfigService).load;
 	const host = yield* Host;
-	const summary = config.workflow.summary;
+	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({
@@ -64875,7 +65045,7 @@ const summaryFor = (run) => gen(function* () {
 		})),
 		processCost: run.costEntries.reduce((sum, entry) => sum + entry.cost, 0),
 		processCostByModel: costByModel(run.costEntries),
-		...settingsFor(config, run.pinnedVars, host.env)
+		...settingsFor(config, resolved, run.pinnedVars, host.env)
 	});
 });
 //#endregion
@@ -76754,22 +76924,15 @@ f="$(gtd next --json=file)"
 f="\${f:-.gtd/TODO.md}"
 mkdir -p "$(dirname "$f")"
 exec "\${EDITOR:-vi}" "$f"`;
-const REVIEW_COMMAND = `#!/usr/bin/env sh
+const DOOR_COMMAND = `#!/usr/bin/env sh
 set -eu
 GTD_BUILD=~/.local/bin/gtd-build
 if [ -z "\${1:-}" ]; then
-  echo "usage: gtd-review <commitish>" >&2
+  echo "usage: gtd-door <name> [args...]" >&2
   exit 2
 fi
 cd "$(git rev-parse --show-toplevel)"
-script="$(gtd --entry review-gate.check --var reviewBase="$1")"
-sh -c "$script"
-exec "$GTD_BUILD"`;
-const FIX_COMMAND = `#!/usr/bin/env sh
-set -eu
-GTD_BUILD=~/.local/bin/gtd-build
-cd "$(git rev-parse --show-toplevel)"
-script="$(gtd --entry fix-precheck)"
+script="$(gtd door "$@")"
 sh -c "$script"
 exec "$GTD_BUILD"`;
 const HEADER = () => `gtd ${GTD_VERSION$1} — driver protocol\n\ngtd decides and prints; the driver executes. gtd never runs git, never runs\nyour agent, never runs a check script, and never runs a steering mode's own\nformat:/validate: command either — that pair is text in the script gtd next\n--json's validate field (or gtd validate) prints, for the driver to run\nitself ahead of gtd land.\n`;
@@ -76850,7 +77013,8 @@ exits 0, so read it in a shell variable and guard on emptiness
 adds the self-validation instruction at a validatable \`prompt\` rest, and a
 status-summary header at every OTHER kind; \`content\` itself never carries
 either), \`idle\` (\`true\` iff the resolved rest is the workflow's initial
-state with a clean tree), \`log\`, \`state\`, \`actor\`, \`changes\` (which
+state with a clean tree), \`initial\` (\`true\` iff no process is underway —
+the default workflow's first step, first visit — whatever the tree holds), \`log\`, \`state\`, \`actor\`, \`changes\` (which
 declared \`on\` pattern, if any, each pending change matches), \`next\` (the
 first declared \`on\` edge that would fire right now — \`{action?, pattern,
 target}\` — or \`null\` on no match). Only at \`kind: "prompt"\` (the DISPATCH
@@ -76944,7 +77108,7 @@ const DRIVER_OBLIGATIONS = `
     \`--json=judge\`, pipes that rendered \`{ state, questions }\` document to a
     judge model, and pipes ITS verdict (one \`{ id, answer, p }\` per pending
     question, as JSON on stdin) to \`gtd judge answer\` — the FIFTH command
-    that changes anything, alongside \`gtd land\`/\`gtd --entry\`/\`gtd
+    that changes anything, alongside \`gtd land\`/\`gtd --workflow\`/\`gtd
     abandon\`/\`gtd restore\`. It follows the exact same required-half /
     optional-half script contract as \`gtd land\` in obligation 8 above:
     read \`--json=script\` (and, if you want them, \`--json=settled\`/
@@ -76986,10 +77150,10 @@ logic beyond "ask gtd again".
 const commandSuite = () => `
 ## Building the user's command suite: interview first, then adapt
 
-The obligations above are the contract; the four command bodies below are one
+The obligations above are the contract; the three command bodies below are one
 WORKED EXAMPLE of it. Do not copy them blindly, and do not guess the user's
 setup — INVESTIGATE first, then INTERVIEW, then build a suite shaped by both.
-Hold ONE conversation, not four: the setup steps below come first, because a
+Hold ONE conversation, not three: the setup steps below come first, because a
 repo that is not set up yet cannot be driven, and the suite-shape questions
 follow in the same numbered list.
 
@@ -77045,8 +77209,8 @@ follow in the same numbered list.
    wrapped in \`# gtd-install: model exports\` / \`# gtd-install: end\`
    markers — NOT into \`.gtdrc\`. They stay per machine and are never
    committed, so one person's model choice binds nobody else on the repo.
-   Two consequences follow, both worth stating to the user: \`gtd-review\`
-   and \`gtd-fix\` inherit these exports only because they \`exec\`
+   Two consequences follow, both worth stating to the user: \`gtd-door\`
+   inherits these exports only because it \`exec\`s
    \`gtd-build\` — anything that drives beats without going through
    \`gtd-build\` sees the raw \`smart\`/\`base\` hints and fails; and \`GTD_*\` is
    the highest-precedence config layer, so these exports silently win over
@@ -77061,11 +77225,11 @@ follow in the same numbered list.
    obligations directly. Pick the runtime to match: bash, their language of
    choice, anything that reads \`--json=<path>\` and spawns subprocesses.
 9. **Where should the suite live, which editor should \`gtd-edit\` spawn, and
-   does anything need renaming?** Suggest \`~/.local/bin\` for all four —
-   \`gtd-build\`, \`gtd-edit\`, \`gtd-review\`, \`gtd-fix\` — and \`$EDITOR\` (never
+   does anything need renaming?** Suggest \`~/.local/bin\` for all three —
+   \`gtd-build\`, \`gtd-edit\`, \`gtd-door\` — and \`$EDITOR\` (never
    a hardcoded editor) for the one that opens files. The interview can
-   rename any of the four; whatever name is chosen for \`gtd-build\` is the
-   RESOLVED path baked into \`GTD_BUILD\` in the other two bodies below —
+   rename any of the three; whatever name is chosen for \`gtd-build\` is the
+   RESOLVED path baked into \`GTD_BUILD\` in the \`gtd-door\` body below —
    never the literal string \`gtd-build\`.
 
 Then build it, and verify safely before the first real drive:
@@ -77074,9 +77238,9 @@ check your kind dispatch against the table above, call them as often as you
 like. Nothing happens until you run an emitted script.
 
 The reference rendering in sh (no \`jq\`, no JSON parser at all — each
-\`--json=<path>\` call prints its one value directly). Two of the four bodies
-below share one convention: \`GTD_BUILD\` is set once, at the top, to the
-suite's resolved \`gtd-build\` path.
+\`--json=<path>\` call prints its one value directly). \`gtd-door\` takes the
+\`gtd-build\` path from one convention: \`GTD_BUILD\` is set once, at the top, to
+the suite's resolved \`gtd-build\` path.
 
 ### \`gtd-build\` — the driver loop
 
@@ -77114,41 +77278,33 @@ are ready. Default path: \`~/.local/bin/gtd-edit\`.
 ${EDIT_COMMAND}
 \`\`\`
 
-### \`gtd-review <commitish>\` — start a review round and drive it
-
-Runs \`gtd --entry review-gate.check --var reviewBase=<commitish>\`, captured
-by command substitution — never a pipe: a pipeline reports only its LAST
-command's exit status, so \`gtd --entry ... | sh\` under \`set -e\` would sail
-past a refusal and \`exec\` a loop over a process that was never started. It
-runs the captured script, then \`exec\`s the suite's RESOLVED \`gtd-build\`
-path — never the literal string \`gtd-build\`. This is one invocation that
-carries the review all the way to its next human gate, not just a starter:
-\`gtd-review\` on a RED baseline hands off to \`gtd-build\`, which halts at the
-blocked gate and prints it, rather than starting the review. Refuses with
-\`usage: gtd-review <commitish>\` on stderr and exit \`2\` when the commitish is
-missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-review\`.
-
-\`\`\`bash
-${REVIEW_COMMAND}
-\`\`\`
+### \`gtd-door <name> [args...]\` — start a process through a door and drive it
 
-### \`gtd-fix\` — enter the fix process and drive it
-
-Runs \`gtd --entry fix-precheck\`, captured the same way, then \`exec\`s the
-suite's RESOLVED \`gtd-build\` path. \`gtd-fix\` on a GREEN suite is a no-op
+Runs \`gtd door <name> [args...]\`, captured by command substitution — never a
+pipe: a pipeline reports only its LAST command's exit status, so
+\`gtd door ... | sh\` under \`set -e\` would sail past a refusal and \`exec\` a
+loop over a process that was never started. It runs the captured script, then
+\`exec\`s the suite's RESOLVED \`gtd-build\` path — never the literal string
+\`gtd-build\`. This is one invocation that carries the process all the way to
+its next human gate, not just a starter: \`gtd-door review\` on a RED baseline
+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.
-Default path: \`~/.local/bin/gtd-fix\`.
+\`gtd doors\` lists the doors a repository offers (the bundled \`fix\` and
+\`review [base]\`, plus any its config 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\`.
 
 \`\`\`bash
-${FIX_COMMAND}
+${DOOR_COMMAND}
 \`\`\`
 ${REINSTALL}`;
 const REINSTALL = `
 ## Re-installing: detect and adapt, don't blindly overwrite
 
 A second install on a machine that already has a suite is not a fresh
-install — read each of the four suite paths before writing anything
-(\`gtd-build\`, \`gtd-edit\`, \`gtd-review\`, \`gtd-fix\`), and branch per path:
+install — read each of the three suite paths before writing anything
+(\`gtd-build\`, \`gtd-edit\`, \`gtd-door\`), and branch per path:
 
 - Absent — install it, as in a fresh install.
 - Present and content-equal to what this gtd version would emit — say so,
@@ -77170,10 +77326,16 @@ markers is unchanged, and re-asks nothing — the resolved model names are
 per machine, so without this exemption every single re-install would
 report drift on the one command everybody has.
 
-This check scopes to exactly the four suite paths above. \`gtd-loop\` is
+This check scopes to exactly the three suite paths above, plus the superseded
+pair below. \`gtd-loop\` is
 outside it entirely — never read, never diffed, never touched by it in any
 way — an existing \`gtd-loop\` survives untouched beside the new
 \`gtd-build\`, and cleaning it up is the human's own call.
+
+\`gtd-fix\` and \`gtd-review\` are superseded by \`gtd-door\` (\`gtd-door fix\`,
+\`gtd-door review [base]\`). When either is still present beside the suite,
+name it to the user as superseded and ask before removing it — never remove
+one unasked.
 `;
 const EDITOR_INTEGRATION = `
 ## Editor integration: offer it, don't bury it
@@ -77221,7 +77383,7 @@ const PREREQUISITES = `
 ## Prerequisites and portability
 
 - A POSIX \`sh\` (dash, ash, bash's own POSIX mode, etc.) — gtd's own emitted
-  scripts (\`gtd land --json=script\`, \`gtd --entry <state>\`, \`gtd abandon\`,
+  scripts (\`gtd land --json=script\`, \`gtd --workflow <name>\`, \`gtd abandon\`,
   \`gtd restore\`, \`gtd judge answer --json=script\`) are POSIX sh; captured,
   then piped into it (see obligation 8 above). Reading
   \`gtd next --json=<path>\`/\`gtd land --json=<path>\`'s own output needs
@@ -77359,7 +77521,7 @@ const normalizeScriptNewline = (script) => script.length === 0 ? script : `${scr
 /**
 * `combinedScript`, narrowed to accept only an already-guarded
 * `RunnableScript` for `required` — the one boundary `ScriptSurface`'s brand
-* exists to protect: `gtd land`/`gtd --entry`'s emitted script. Every OTHER
+* exists to protect: `gtd land`/`gtd --workflow`'s emitted script. Every OTHER
 * `combinedScript` call (`abandon`/`restore`/steering validate, below) builds
 * from `emitScripts` directly and keeps the unbranded signature — those
 * paths land no guard-gated git write for a brand to protect.
@@ -77522,29 +77684,77 @@ const runLandCommand = (opts, json, out) => gen(function* () {
 	else out.write(renderLandPlain(built));
 });
 /**
-* Starts a brand new process at `<state>`, always as `"human"`. Captures
-* whatever the working tree carries at entry, like an ordinary land, rather
-* than demanding a clean tree.
+* Starts a brand new process on `<workflow>`, always as `"human"`. Captures
+* whatever the working tree carries at the start, like an ordinary land,
+* rather than demanding a clean tree.
 *
-* Refused when a process is already underway, the flow opens none for
-* `<state>`, a `--var` name is undeclared, or `reviewBase:` renders to
-* something that is not an ancestor of (and differs from) HEAD.
+* An unknown name is a usage error. Refused when a process is already
+* underway, the workflow reaches no step, a `--var` name is undeclared, or
+* `base` renders to something that is not an ancestor of (and differs from)
+* HEAD.
 */
-const runEntryCommand = (actor, entryState, varOverrides, out, commandLabel) => gen(function* () {
+const runStartCommand = (actor, workflow, varOverrides, out, commandLabel) => gen(function* () {
+	const config = yield* (yield* ConfigService).load;
+	const resolved = config.workflowNamed(workflow);
+	if (resolved === void 0) return yield* fail$7(new GtdUsageError(`gtd --workflow: unknown workflow "${workflow}" — startable: ${config.workflowNames.join(", ")}`));
 	const rest = yield* restAt(void 0, varOverrides);
-	const plan = yield* planEntry({
-		def: rest.def,
+	const started = yield* startRefusal(rest, resolved, varOverrides);
+	const plan = yield* planStart({
 		state: rest.state,
-		idle: noProcessUnderway(rest),
-		entryRefusal: yield* entryRefusal(rest, entryState, varOverrides)
+		idle: noProcessUnderway(rest)
 	}, actor, {
-		state: entryState,
+		workflow: resolved,
+		first: started,
 		commandLabel,
 		vars: varOverrides
 	});
 	if (plan.kind === "refusal") return yield* fail$7(new Error(plan.message));
 	out.write(landingScript(ScriptSurface.render(plan.steps)));
 });
+const doorSynopsis = (name, door) => [name, ...(door.args ?? []).map((arg) => arg.optional === true ? `[${arg.name}]` : `<${arg.name}>`)].join(" ");
+/**
+* `gtd door <name> [args…]`: `gtd --workflow` with the door's workflow and the
+* process settings its `vars` derive from the positional args. A wrong name or
+* arity is a usage error naming what would have worked.
+*/
+const runDoorCommand = (name, args, out) => gen(function* () {
+	const config = yield* (yield* ConfigService).load;
+	const door = config.doors.get(name);
+	if (door === void 0) {
+		const known = [...config.doors];
+		return yield* fail$7(new GtdUsageError(`gtd door: unknown door "${name}" — doors: ${known.map(([n, d]) => doorSynopsis(n, d)).join(", ")}`));
+	}
+	const declared = door.args ?? [];
+	const required = declared.filter((arg) => arg.optional !== true).length;
+	if (args.length < required || args.length > declared.length) return yield* fail$7(new GtdUsageError(`gtd door ${name}: ${args.length < required ? "missing" : "too many"} arguments — usage: gtd door ${doorSynopsis(name, door)}`));
+	const named = {};
+	declared.forEach((arg, i) => {
+		named[arg.name] = args[i];
+	});
+	const vars = yield* try_({
+		try: () => door.vars?.(named) ?? {},
+		catch: (e) => /* @__PURE__ */ new Error(`gtd door ${name}: ${e instanceof Error ? e.message : String(e)}`)
+	});
+	yield* runStartCommand("human", door.workflow, { ...vars }, out, `gtd door ${name}`);
+});
+/** `gtd doors`: every door and its args, sorted by name — plain lines, or one JSON array. */
+const runDoorsCommand = (json, out) => gen(function* () {
+	const doors = [...(yield* (yield* ConfigService).load).doors];
+	if (json.kind === "off") {
+		out.write(doors.map(([n, d]) => `${doorSynopsis(n, d)} → ${d.workflow}\n`).join(""));
+		return;
+	}
+	const document = doors.map(([n, d]) => ({
+		name: n,
+		workflow: d.workflow,
+		args: (d.args ?? []).map((arg) => ({
+			name: arg.name,
+			optional: arg.optional === true
+		}))
+	}));
+	if (json.kind === "document") out.write(`${JSON.stringify(document)}\n`);
+	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
@@ -77801,6 +78011,8 @@ const gatherBeatDocument = (rest, rendered) => gen(function* () {
 	}), statusOf({
 		rendered,
 		idle: restIsIdle(rest),
+		initial: noProcessUnderway(rest),
+		workflow: rest.workflowName,
 		log,
 		changes: computeStatusChanges(rest.changes),
 		next: yield* computeNextMatch(rest),
@@ -77887,7 +78099,9 @@ const dispatchVoidCommand = (command, json, out) => {
 			...command.cost !== void 0 ? { cost: command.cost } : {},
 			...command.model !== void 0 ? { model: command.model } : {}
 		}, json, out);
-		case "entry": return runEntryCommand(command.actor, command.state, command.vars, out, command.label);
+		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 "abandon": return runAbandonCommand(out);
 		case "restore": return runRestoreCommand(out);
 		case "next": return runNextCommand(json, out);
@@ -77951,12 +78165,12 @@ const FLAGS = [
 		name: "--json",
 		arity: "optional",
 		repeatable: false,
-		scope: (kind) => kind === "next" || kind === "land" || kind === "judge" || kind === "judgeAnswer",
+		scope: (kind) => kind === "next" || kind === "land" || kind === "judge" || kind === "judgeAnswer" || kind === "doors",
 		decode: ([raw]) => right(raw ?? ""),
-		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer` — 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` — 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 only) output",
+			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors 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",
@@ -78055,7 +78269,7 @@ const FLAGS = [
 		repeatable: false,
 		scope: (kind) => kind === "land",
 		decode: ([raw]) => nonNegativeNumber(raw ?? "", "--cost"),
-		scopeError: "gtd: --cost is only valid for `gtd land` — an entry is not a metered agent turn",
+		scopeError: "gtd: --cost is only valid for `gtd land` — a start is not a metered agent turn",
 		valueHint: "<n>",
 		help: ["(gtd land only) record the invocation's token cost"]
 	},
@@ -78074,24 +78288,20 @@ const FLAGS = [
 		]
 	},
 	{
-		name: "--entry",
+		name: "--workflow",
 		arity: 1,
 		repeatable: false,
-		scope: (kind) => kind === "entry",
+		scope: (kind) => kind === "start",
 		decode: ([raw]) => right(raw ?? ""),
-		scopeError: "gtd: --entry is only valid with no other command — use the bare `gtd --entry <state>` form; landing and entering are different verbs",
-		valueHint: "<state>",
-		help: [
-			"(with no command at all) start a brand new process,",
-			"handing <state> to the workflow as its entry —",
-			"authenticated as human"
-		]
+		scopeError: "gtd: --workflow is only valid with no other command — use the bare `gtd --workflow <name>` form; landing and starting are different verbs",
+		valueHint: "<name>",
+		help: ["(with no command at all) start a brand new process on", "the named workflow — authenticated as human"]
 	},
 	{
 		name: "--var",
 		arity: 1,
 		repeatable: true,
-		scope: (kind) => kind === "entry",
+		scope: (kind) => kind === "start",
 		decode: (raws) => {
 			const vars = {};
 			const seen = /* @__PURE__ */ new Set();
@@ -78108,10 +78318,10 @@ const FLAGS = [
 			}
 			return right(vars);
 		},
-		scopeError: "gtd: --var requires --entry",
+		scopeError: "gtd: --var requires --workflow",
 		valueHint: "<name>=<value>",
 		help: [
-			"(with --entry; repeatable) pin a process setting for the",
+			"(with --workflow; repeatable) pin a process setting for the",
 			"new process; the name must already be declared by the",
 			"workflow's defaults or the .gtdrc vars: (environment",
 			"settings are not pinnable)"
@@ -78394,6 +78604,34 @@ const COMMAND_ROWS = [
 			"Refuses (exit 1) when no process is underway."
 		]
 	},
+	{
+		token: "door",
+		kind: "door",
+		arity: {
+			name: "name",
+			variadic: "args"
+		},
+		details: [
+			"Start a process through a named shortcut, mapping the",
+			"positional args to that workflow's process settings — the",
+			"same start `gtd --workflow` makes, printed the same way.",
+			"Doors come from the config's `doors` export; the bundled",
+			"ones are `fix` and `review [base]`. An unknown door, or too",
+			"few or too many args, is a usage error (exit 2) naming the",
+			"doors or the door's synopsis"
+		]
+	},
+	{
+		token: "doors",
+		kind: "doors",
+		arity: "none",
+		details: [
+			"List every door, sorted: one `name [args] → workflow` line",
+			"each. --json prints one JSON array of { name, workflow,",
+			"args: [{ name, optional }] } instead; --json=<path> reads one",
+			"value off it. Writes nothing"
+		]
+	},
 	{
 		token: "judge",
 		kind: "judge",
@@ -78449,23 +78687,23 @@ const renderBlock = (header, lines) => {
 	const headerCell = `  ${header}`;
 	return (headerCell.length < COLUMN ? `${headerCell.padEnd(COLUMN)}${first ?? ""}\n` : `${headerCell}\n${" ".repeat(COLUMN)}${first ?? ""}\n`) + rest.map((l) => `${" ".repeat(COLUMN)}${l}\n`).join("");
 };
-const ENTRY_SHORT_FORM = renderBlock("(no command) --entry <state>", ["Starts a new process authenticated as human, e.g.", "'gtd --entry <state>'"]);
+const START_SHORT_FORM = renderBlock("(no command) --workflow <name>", ["Starts a new process authenticated as human, e.g.", "'gtd --workflow <name>'"]);
 const VERSION_BLOCK = renderBlock("version", ["Print version and exit"]);
 const HELP_BLOCK = renderBlock("help", ["Print this help and exit"]);
-const SPACE_FORM_FLAGS = /* @__PURE__ */ new Set(["--entry", "--var"]);
+const SPACE_FORM_FLAGS = /* @__PURE__ */ new Set(["--workflow", "--var"]);
 const flagHeader = (row) => {
 	if (row.valueHint === "") return row.name;
 	return SPACE_FORM_FLAGS.has(row.name) ? `${row.name} ${row.valueHint}` : `${row.name}=${row.valueHint}`;
 };
 const renderHelp = () => {
 	const commandBlocks = COMMAND_ROWS.map((row) => {
-		const header = row.arity === "none" ? row.token : "names" in row.arity ? `${row.token} <${row.arity.names[0]}> <${row.arity.names[1]}>` : `${row.token} <${row.arity.name}>`;
+		const header = row.arity === "none" ? row.token : "names" in row.arity ? `${row.token} <${row.arity.names[0]}> <${row.arity.names[1]}>` : "variadic" in row.arity ? `${row.token} <${row.arity.name}> [${row.arity.variadic}...]` : `${row.token} <${row.arity.name}>`;
 		return renderBlock(header, row.details);
 	});
 	return `Usage: gtd [command] [options]\n\nCommands:\n${[
 		commandBlocks[0],
 		commandBlocks[1],
-		ENTRY_SHORT_FORM,
+		START_SHORT_FORM,
 		...commandBlocks.slice(2),
 		VERSION_BLOCK,
 		HELP_BLOCK
@@ -78570,14 +78808,14 @@ const conflictViolation = (present) => {
 };
 const arityError = (cmd, rest, arity) => {
 	if (arity === "none") return rest.length > 0 ? `gtd ${cmd}: too many arguments — expected none, got: ${rest.join(", ")}` : void 0;
-	if ("names" in arity) {
-		const [first, second] = arity.names;
-		if (rest.length < 2) return rest.length === 0 ? `gtd ${cmd}: missing ${first} and ${second} arguments` : `gtd ${cmd}: missing ${second} argument`;
-		if (rest.length > 2) return `gtd ${cmd}: too many arguments — expected ${first} and ${second}, got: ${rest.join(", ")}`;
-		return;
-	}
+	if ("names" in arity) return pairArityError(cmd, rest, arity.names);
 	if (rest.length === 0) return `gtd ${cmd}: missing ${arity.name} argument`;
-	if (rest.length > 1) return `gtd ${cmd}: too many arguments — expected one ${arity.name}, got: ${rest.join(", ")}`;
+	if (!("variadic" in arity) && rest.length > 1) return `gtd ${cmd}: too many arguments — expected one ${arity.name}, got: ${rest.join(", ")}`;
+};
+const pairArityError = (cmd, rest, [first, second]) => {
+	if (rest.length === 0) return `gtd ${cmd}: missing ${first} and ${second} arguments`;
+	if (rest.length === 1) return `gtd ${cmd}: missing ${second} argument`;
+	if (rest.length > 2) return `gtd ${cmd}: too many arguments — expected ${first} and ${second}, got: ${rest.join(", ")}`;
 };
 /** Decode every present flag into a bag of values, or the first decode error encountered. */
 const decodeFlags = (byFlag) => {
@@ -78611,8 +78849,8 @@ const parseArgv = (argv) => {
 	if (tokenized.kind === "error") return usagePlan(tokenized.message, tokenized.jsonSeen);
 	const { positionals, byFlag, present, jsonSeen } = tokenized;
 	const first = positionals[0];
-	const entryRaw = byFlag.get("--entry")?.[0];
-	const entryPresent = entryRaw !== void 0;
+	const workflowRaw = byFlag.get("--workflow")?.[0];
+	const workflowPresent = workflowRaw !== void 0;
 	if (first === "version") return {
 		kind: "output",
 		stdout: `${GTD_VERSION}\n`
@@ -78623,17 +78861,17 @@ const parseArgv = (argv) => {
 	};
 	const row = first === void 0 ? void 0 : commandByToken(first);
 	const judgeAnswer = row?.kind === "judge" && positionals[1] === "answer";
-	const selectsEntry = entryPresent && first === void 0;
+	const selectsStart = workflowPresent && first === void 0;
 	const judgeRun = row?.kind === "judge" && positionals[1] === "run";
-	const kind = selectsEntry ? "entry" : judgeAnswer ? "judgeAnswer" : judgeRun ? "judgeRun" : row?.kind;
-	if (row === void 0 && !selectsEntry) {
+	const kind = selectsStart ? "start" : judgeAnswer ? "judgeAnswer" : judgeRun ? "judgeRun" : row?.kind;
+	if (row === void 0 && !selectsStart) {
 		const violation = scopeViolation(void 0, present);
 		if (violation !== void 0) return usagePlan(violation, jsonSeen);
 		if (first === void 0) return usagePlan("gtd: missing command — gtd decides and prints, a driver executes; run `gtd install`, or copy one from https://github.com/pmelab/gtd/blob/main/docs/driver.md's \"A complete minimal driver\" section and run that, or see usage above (`gtd --help`)", jsonSeen, renderHelp());
 		return usagePlan(`unknown command '${first}'`, jsonSeen);
 	}
 	const restPositionals = first === void 0 ? positionals : positionals.slice(judgeAnswer || judgeRun ? 2 : 1);
-	if (kind === "entry" && first === void 0) {
+	if (kind === "start" && first === void 0) {
 		if (restPositionals.length > 0) return usagePlan(`gtd: too many arguments — expected none, got: ${restPositionals.join(", ")}`, jsonSeen);
 	} else {
 		const arityMsg = kind === "check" && restPositionals.length === 0 && present.has("--open-threads") ? void 0 : arityError(first, restPositionals, row.arity);
@@ -78660,14 +78898,14 @@ const parseArgv = (argv) => {
 			verbose
 		};
 	}
-	if (kind === "entry") {
-		const label = `gtd --entry ${entryRaw}`;
+	if (kind === "start") {
+		const label = `gtd --workflow ${workflowRaw}`;
 		return {
 			kind: "command",
 			command: {
-				kind: "entry",
+				kind: "start",
 				actor: "human",
-				state: entryRaw,
+				workflow: workflowRaw,
 				vars: bag["--var"] ?? {},
 				label
 			},
@@ -78675,6 +78913,16 @@ const parseArgv = (argv) => {
 			verbose
 		};
 	}
+	if (kind === "door") return {
+		kind: "command",
+		command: {
+			kind: "door",
+			name: restPositionals[0],
+			args: restPositionals.slice(1)
+		},
+		json,
+		verbose
+	};
 	if (kind === "ui") return {
 		kind: "command",
 		command: {