@pmelab/gtd 18.1.0 → 20.0.0

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);
@@ -31013,6 +31013,7 @@ const checkScript = (command, options) => {
 	return [
 		"#!/usr/bin/env sh",
 		"set +e",
+		...options.preamble ?? [],
 		...removal(options.sweep ?? []),
 		`mkdir -p "$(dirname ${report})"`,
 		"(",
@@ -31106,12 +31107,13 @@ const wrote = (path) => changes(path).some((c) => c.status !== "deleted");
 * command passed.
 */
 const check = async (name, command, options) => {
-	const { report, label, sweep, sweepOnGreen } = options;
+	const { report, label, sweep, sweepOnGreen, preamble } = options;
 	await run$3(name, checkScript(command, {
 		report,
 		stamp: head().slice(0, 7),
 		sweep,
-		sweepOnGreen
+		sweepOnGreen,
+		preamble
 	}), { label });
 	return !wrote(report);
 };
@@ -47620,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);
@@ -47644,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: {},
@@ -47660,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}` : ""}`);
@@ -47767,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)
@@ -47962,8 +47964,7 @@ const replay = async (input) => {
 			kind: "rest",
 			rest: step,
 			trace,
-			landed,
-			entryRead
+			landed
 		});
 		pendingUsed = true;
 		landed = step;
@@ -48070,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"
@@ -48157,8 +48158,7 @@ const architectPersona = `You are the technical planning voice in gtd's build pi
 once product concerns are settled, reading them cold, no carried
 conversation. Work out the *how* per concern — structure, data models,
 tech-stack choices, error handling — raise the technical open
-questions, then write one package spec per concern with no further
-judgement call: the grouping is already decided.`;
+questions, then pin interfaces and tests in the architecture document.`;
 const reviewerPersona = `You are the independent reviewing mind in gtd's build pipeline —
 deliberately separate from whoever wrote the code, with no attachment
 to it. Write a structured review document grouping a diff into
@@ -48167,12 +48167,6 @@ just approving; answer the human's questions inline in the review;
 and, when asked, fix the small nits the human flagged and the risks
 you marked yourself, each in one batch.
 Beyond that you never fix or build anything yourself.`;
-const specReviewerPersona = `You are the adversarial spec-conformance checker in gtd's build
-pipeline, checking one freshly-built package against its spec. Verify
-only: tasks done, criteria met, code sound and consistent with the
-codebase. Write feedback only when something is genuinely wrong —
-otherwise write nothing; a clean turn IS the approval. Never fix what
-you find — naming it precisely enough for a fix turn is the whole job.`;
 const builderPersona = `You are the TDD implementer in gtd's build pipeline: build one
 package's declared scope end to end, tests first, and come back to fix
 things when redirected — a failing check, or reviewer feedback. Stay
@@ -48382,19 +48376,11 @@ carries it.
 What each change does next (then run \`gtd land\`):
 - **Continue** — having undone the sketch by hand, check the test baseline is green and start triage (**start-gate.check**).
 `;
-const architecturePreMessage = () => `Judging whether \`.gtd/REQUIREMENTS.md\`'s settled concerns need a
-dedicated architecture pass — real structural decisions, multiple
-integration points, or a non-obvious tradeoff — before packages
-are written. Run \`gtd judge answer\` and pipe a verdict for
-\`architectureWarranted\` — or land untouched to run the full pass
-(the conservative default; a skipped judgment never suppresses
-it).
-`;
 const startGateBlockedMessage = () => `The test baseline is red — gtd will not start new work on a broken suite.
 \`.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.
@@ -48554,22 +48540,46 @@ ${footnoteFoldIn}${codeThreadReplies()}
   authority is to merge only, never to split — the whole problem
   is over-granularity
 - Record every merge under \`## Merged Concerns\`,
-  carrying both merged requirements verbatim so spec review
-  still covers each independently
+  carrying both merged requirements verbatim so each requirement
+  stays traceable to its tests
 - A merge raises no open question and stops for no
   human — do not route it to \`architecture.gate\` for a veto; the
-  human sees it when reviewing the plan, and spec review is the
-  real safety net
+  human sees it when reviewing the plan
 - Prefer fewer, larger packages — the smallest independently
   valuable change, not the smallest change that compiles
 - Every open point here is TECHNICAL — triage already resolved
   the product ones, one phase earlier. PERMISSIVE: answer it
   yourself unless you genuinely cannot defend a default; a wrong
-  technical call is still caught at spec review
+  technical call is still caught by the full run and the quality lap
 - The narrow exception: a simplification that drops something
   \`.gtd/REQUIREMENTS.md\` mentions is an open question, not a
   silent default
 
+- \`.gtd/ARCHITECTURE.md\` is the acceptance spec the human signs
+  off. It carries these sections, in this order:
+  1. \`## Open Questions\` (qa format, first, only when present)
+  2. \`## Interfaces\` — new and changed signatures/contracts
+     only, as fenced TypeScript (or the repository's language)
+  3. \`## Call Stacks\` — seam level, entry point → module
+     boundary; one line per hop, never per line of code
+  4. \`## E2E Scenarios\` — Gherkin in fenced \`gherkin\` blocks
+     (whatever e2e framework the repository uses), each preceded
+     by a line \`- e2e: <path>\`. With no user-visible
+     behaviour change, the literal line \`No e2e change.\` plus a
+     one-line reason — never empty or missing
+  5. \`## Unit Tests\` — one \`### <interface>\` per entry of
+     \`## Interfaces\`, each test a line
+     \`- unit: <path> — <behaviour> (covers <concern>)\`;
+     never against an internal helper. A requirement no test can
+     cover (docs, README, deletions, config) goes under a
+     \`### Chores\` heading in this section as
+     \`- chore: <path> — <what> (covers <concern>)\`
+  6. \`## Merged Concerns\` — kept, when any merge happened
+  7. \`## Answered Questions\` — last
+- Coverage rule: every concern in \`.gtd/REQUIREMENTS.md\` appears
+  in at least one \`(covers …)\` tail, as a test or a chore. Each
+  test entry carries its file path and level (unit / e2e)
+
 ${questionBar}
 ## Return lap
 
@@ -48581,26 +48591,41 @@ const architectureDecomposePrompt = () => `${styleBlock}
 
 ${stateFileRules}
 - The only state files this turn touches are the package files
-  under \`.gtd/packages/\` and \`.gtd/ARCHITECTURE.md\` (deleted) —
-  no other files for notes or output
+  under \`.gtd/packages/\` — no other files for notes or output.
+  Never delete \`.gtd/ARCHITECTURE.md\`: the build tail's full run
+  still needs it, and package files may reference it
 - Work from \`.gtd/ARCHITECTURE.md\` if you wrote it earlier this
   conversation, otherwise read it (the converged technical
-  plan). It already lists an ordered set of concerns with every
-  merge/split judgement made — this turn is a mechanical
-  write-out, not a planning one. A \`## Merged Concerns\` heading
-  there records those merges, never a concern of its own: write
-  no package file for it
-- Write one package file per concern, in the settled order,
-  under \`.gtd/packages/\` (e.g. \`.gtd/packages/01-name.md\`,
-  \`02-name.md\`, ...), each carrying that concern's
-  requirement(s) — both, independently, if merged — its
-  independent tasks, and each task's acceptance criteria as
-  \`- [ ]\` checkboxes and relevant paths
-- Do not merge or split concerns here — that judgement already
-  happened; carry the settled grouping over verbatim. No
-  package file may reference any other \`.gtd/\` file
-- Once written, delete \`.gtd/ARCHITECTURE.md\`. Leave everything
-  uncommitted and finish
+  plan). It already lists the concerns, interfaces, e2e scenarios
+  and unit tests — this turn groups them into packages. A
+  \`## Merged Concerns\` heading there records merges, never a
+  concern of its own: write no package file for it
+- A package is a consecutive run of \`## Unit Tests\` entries that go
+  green together on the fast suite, at most ~8 unit-test entries
+  each. Keep the merge rule: concerns whose footprints centre on the
+  same files stay in one package unless the later one only consumes
+  an interface the earlier one creates. Prefer fewer, larger
+  packages. Order them so each stays green on the fast suite —
+  interface-introducing packages first
+- Write the packages under \`.gtd/packages/\`, each carrying its
+  requirement(s) — both, independently, if merged — its tasks, and
+  each task's acceptance criteria as \`- [ ]\` checkboxes and
+  relevant paths:
+  - \`.gtd/packages/00-e2e-scenarios.md\` — package 0: it writes
+    \`## E2E Scenarios\` as tests in the repository's own e2e
+    framework and leaves them red. Write no such file when
+    \`## E2E Scenarios\` says "No e2e change."
+  - \`01-…\` onward — the unit-test packages. A requirement no test
+    covers (docs, README, deletions, config) becomes a chore
+    package, or a task of one; chore packages declare no tests
+  - the last numbered package is the wiring package: CLI entry,
+    workflow composition, config. A red e2e after it is a bug, not
+    missing work
+- Every package with tests has a \`## Tests\` section, one line per
+  declared test, copied from the architecture entries:
+  \`- unit: \\\`<path>\\\`\` or \`- e2e: \\\`<path>\\\`\`. Chore packages have
+  none
+- Leave everything uncommitted and finish
 `;
 const architectureGateAnswerMessage = () => `This gate stops on every process, even with no open question, so
 you can discuss \`.gtd/ARCHITECTURE.md\`; changing nothing and re-running
@@ -48629,7 +48654,7 @@ What each change does next (then run \`gtd land\`):
 `;
 const packagesItemBuildingPrompt = (pkg) => `${stateFileRules}
 - The only state file this turn may write is \`.gtd/SATISFIED.md\`;
-  never delete the package file (the spec-review gate reads it
+  never delete the package file (the declared-tests guard reads it
   after you)
 - The package to implement is \`${pkg}\`
 - First check its acceptance criteria against the current tree —
@@ -48638,6 +48663,13 @@ const packagesItemBuildingPrompt = (pkg) => `${stateFileRules}
   with each criterion's concrete evidence (commit, file, or
   symbol), change nothing else, and finish. Otherwise implement
   normally and skip that file
+- Write the tests the package declares under \`## Tests\` first,
+  then the code that makes them pass; the turn is refused unless
+  every declared test is in your diff
+- Package 0 (\`.gtd/packages/00-e2e-scenarios.md\`) writes the scenarios verbatim
+  from \`## E2E Scenarios\` of \`.gtd/ARCHITECTURE.md\`, with only
+  step code that typechecks, and leaves them red — no
+  implementation
 - Implement every task the package describes, no more, no less,
   fanning independent ones out to parallel subagents where your
   harness supports it; leave other package files untouched
@@ -48654,15 +48686,6 @@ ${fixFeedbackPrompt}
   then legitimately report itself already satisfied later
 - Leave everything uncommitted and finish your turn — do not commit
 `;
-const packagesItemFixSpecPrompt = (pkg) => `${stateFileRules}
-- The only state file this turn touches is
-  \`.gtd/SPEC_FEEDBACK.md\` — address it, then delete it
-- Read it (the reviewer's concerns) and the package spec
-  (\`${pkg}\`), then fix the code to
-  resolve every concern
-- Delete \`.gtd/SPEC_FEEDBACK.md\` once resolved; leave everything
-  else uncommitted and finish your turn
-`;
 const healthJudgeMessage = () => `The check is still red, and this isn't the first round —
 \`.gtd/FEEDBACK.md\` holds this round's output, and the previous round's
 is in history. Run \`gtd judge answer\` and pipe a
@@ -48700,45 +48723,22 @@ Edit \`.gtd/ESCALATION.md\` with fresh instructions for the next fix
 turn, or land untouched to give it one more attempt at the same
 analysis.
 `;
-const packagesItemSpecPreMessage = () => `Judging whether the code already satisfies each requirement in the
-package spec, before spending a full review turn. Run \`gtd judge
-answer\` and pipe a verdict per section — or land untouched to run
-the full review (the conservative default; a skipped judgment
-never suppresses anything).
-`;
-/** The sections a pre-judge could not clear, when it cleared the rest. */
-const specScope = (failing) => failing.length > 0 ? `- A pre-judge already found the other sections satisfied. Confine
-  your review to only these sections:
-${failing.map((title) => `  - ${title}\n`).join("")}` : "";
-const packagesItemSpecReviewPrompt = (pkg, failing = []) => `${styleBlock}
-
-You are reviewing a freshly-built work package against its own
-spec.
-
-${stateFileRules}
-- The only state file this turn touches is
-  \`.gtd/SPEC_FEEDBACK.md\` — write it only when you find problems
-- The package spec is \`${pkg}\`
-${specScope(failing)}- Verify the implementation against it: tasks done, criteria
-  met, code sound and consistent with the codebase. No diff is
-  given — read the range yourself, from \`${start()}\`
-  to the working tree, process-wide (it can span earlier
-  packages)
-- You own that bar; nothing downstream re-weighs your findings
-- Write nothing when the package fully satisfies its spec —
-  silence is your approval. Otherwise write
-  \`.gtd/SPEC_FEEDBACK.md\` listing what would violate the spec if
-  it shipped unaddressed, specific enough to act on, each as its
-  own \`## \` heading
-- Never fix anything yourself and never delete the package
-  file — a later step owns that
+const buildContextPrompt = (built) => {
+	const list = (paths) => paths.length === 0 ? "  (none)" : paths.map((path) => `  - ${path}`).join("\n");
+	return `- Read \`.gtd/ARCHITECTURE.md\` — the plan every package was built from
+- A red scenario that is NEW in this plan likely means missing wiring
+  between packages; new scenarios:
+${list(built.scenarios.added)}
+- A red CHANGED or existing scenario or test is a regression a package
+  introduced; scenarios this plan changed:
+${list(built.scenarios.changed)}
+- Each package's commits, to bisect a break:
+${built.ranges.map((r) => `  git log --oneline ${r.from}..${r.to}  # ${r.pkg}`).join("\n")}
 `;
-const specReviewerSystem = () => `${specReviewerPersona}
-
-${agentConduct}`;
-const buildFixPrompt = () => `${stateFileRules}
+};
+const buildFixPrompt = (built) => `${stateFileRules}
 ${fixFeedbackPrompt}
-- Leave everything uncommitted — do not commit
+${built === void 0 ? "" : buildContextPrompt(built)}- Leave everything uncommitted — do not commit
 `;
 const finisherSystem = () => `${finisherPersona}
 
@@ -49071,6 +49071,20 @@ ${it.processCostByModel.map((m) => `- ${m.model}: ${m.cost}\n`).join("")}
 Print the closing message and stop — this writes nothing itself.
 `;
 };
+const scenarioWordingMessage = (at, drifted) => `The e2e scenario wording was frozen when package 0 landed, and the last
+turn changed it. Removed lines are marked \`-\`, added ones \`+\`:
+
+${drifted.map(({ path, lines }) => `${path}\n${lines.join("\n")}`).join("\n\n")}
+
+To accept the change, land untouched.
+
+To reject it, run
+
+    git checkout ${at} -- ${drifted.map(({ path }) => quote(path)).join(" ")}
+
+and land. Restoring only some of the files is a partial accept: every file
+still differing from the frozen wording is accepted.
+`;
 //#endregion
 //#region src/workflows/steps.ts
 const FEEDBACK = ".gtd/FEEDBACK.md";
@@ -49079,7 +49093,6 @@ const REQUIREMENTS = ".gtd/REQUIREMENTS.md";
 const ARCHITECTURE = ".gtd/ARCHITECTURE.md";
 const REVIEW = ".gtd/REVIEW.md";
 const QUALITY = ".gtd/QUALITY.md";
-const SPEC_FEEDBACK = ".gtd/SPEC_FEEDBACK.md";
 const planner = () => env.plannerModel ?? "";
 const coder = () => env.coderModel ?? "";
 /** Turn the sketch since `base` into `.gtd/REQUIREMENTS.md`. */
@@ -49127,20 +49140,7 @@ const fixSuite = () => agentWithSkills("fix.suite.fixing", packagesItemFixSuiteP
 	model: coder(),
 	system: builderSystem()
 });
-const fixSpec = (pkg) => agentWithSkills("fix.spec.fixing", packagesItemFixSpecPrompt(pkg), {
-	label: "Fixing review feedback",
-	file: SPEC_FEEDBACK,
-	model: coder(),
-	system: builderSystem()
-});
-/** Review `pkg` against its spec, focused on the `failing` sections the pre-judge could not clear. */
-const reviewPackage = (pkg, failing = []) => agentWithSkills("spec.review", packagesItemSpecReviewPrompt(pkg, failing), {
-	label: "Reviewing the package",
-	model: planner(),
-	system: specReviewerSystem(),
-	allowEmpty: true
-});
-const fix = () => agentWithSkills("fix", buildFixPrompt(), {
+const fixCheck = (built) => agentWithSkills("fix", buildFixPrompt(built), {
 	label: "Fixing the check",
 	file: FEEDBACK,
 	model: coder(),
@@ -49248,11 +49248,29 @@ const collecting = (capture) => agentWithSkills("review.collecting", buildReview
 	system: reviewerSystem(),
 	allowEmpty: true
 });
+//#endregion
+//#region src/workflows/health.ts
+/** Written while `fastTestCommand` is unset; its presence rests the process at the check. */
+const SETUP = ".gtd/SETUP.md";
+const SETUP_TEXT = "The bundled workflow needs the `fastTestCommand` setting: the fast suite (everything but e2e).\nSet it under `env:` in `.gtdrc` or as GTD_FASTTESTCOMMAND.";
+/** Shell lines for a check's preamble: unset (blank after trim) setting writes `SETUP` and skips the suite. */
+const fastSuiteGuard = () => (env.fastTestCommand ?? "").trim() === "" ? [
+	`mkdir -p ${quote(dirname(SETUP))}`,
+	`printf '%s\\n' ${quote(SETUP_TEXT)} > ${quote(SETUP)}`,
+	`printf '%s\\n' ${quote(SETUP_TEXT)} >&2`,
+	"exit 0"
+] : [`rm -f ${quote(SETUP)}`];
 /** Run the suite as step `name`; resolves `true` when it passed. A failure is in `.gtd/FEEDBACK.md`. */
-const baseline = (name, label = "Checking the baseline") => check(name, env.testCommand ?? "", {
-	report: FEEDBACK,
-	label
-});
+const baseline = async (name, label = "Checking the baseline") => {
+	for (;;) {
+		const green = await check(name, env.testCommand ?? "", {
+			report: FEEDBACK,
+			label,
+			preamble: fastSuiteGuard()
+		});
+		if (read(".gtd/SETUP.md") === void 0) return green;
+	}
+};
 /**
 * Hand a red suite that repeated attempts could not fix to a person: an
 * agent writes `.gtd/ESCALATION.md`, a human narrows it. From the third round
@@ -49291,6 +49309,15 @@ const sameFailure = async (previous, current) => {
 	});
 	return comparable && truncated.length === 0 && answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity));
 };
+const runSuite = (options) => {
+	const fast = options.suite === "fast";
+	return check("health.check", (fast ? env.fastTestCommand : env.testCommand) ?? "", {
+		report: FEEDBACK,
+		label: "Running checks",
+		sweepOnGreen: [ESCALATION, ...options.sweepOnGreen ?? []],
+		...fast ? { preamble: fastSuiteGuard() } : {}
+	});
+};
 /**
 * Loop until the suite is green: check, and on red run `fix` — escalating
 * first once `FIX_CAP` fixes are spent, or a judge calls the failure
@@ -49301,11 +49328,9 @@ const healthy = async (fix, options = {}) => {
 	let fixes = options.fixesSoFar ?? 0;
 	let previous;
 	for (;;) {
-		if (await check("health.check", env.testCommand ?? "", {
-			report: ".gtd/FEEDBACK.md",
-			label: "Running checks",
-			sweepOnGreen: [".gtd/ESCALATION.md"]
-		})) {
+		const green = await runSuite(options);
+		if (options.suite === "fast" && read(".gtd/SETUP.md") !== void 0) continue;
+		if (green) {
 			escalations.rounds = 0;
 			return;
 		}
@@ -49329,324 +49354,184 @@ const gate = (name, message) => scope(name, async () => {
 	});
 });
 //#endregion
-//#region src/workflows/diff.ts
-const CONTEXT = 3;
-const TOO_LARGE_LINES = 1500;
-const LOCKFILES = /* @__PURE__ */ new Set([
-	"package-lock.json",
-	"npm-shrinkwrap.json",
-	"yarn.lock",
-	"pnpm-lock.yaml",
-	"bun.lock",
-	"bun.lockb",
-	"Cargo.lock",
-	"composer.lock",
-	"Gemfile.lock",
-	"poetry.lock",
-	"uv.lock",
-	"Pipfile.lock",
-	"go.sum",
-	"flake.lock",
-	"mix.lock",
-	"pubspec.lock",
-	"Podfile.lock",
-	"gradle.lockfile"
-]);
-const GENERATED_GLOBS = [
-	"dist/**",
-	"build/**",
-	"out/**",
-	"coverage/**",
-	"node_modules/**",
-	"vendor/**",
-	".turbo/**",
-	"**/__snapshots__/**",
-	"**/*.snap",
-	"**/*.min.js",
-	"**/*.min.css",
-	"**/*.map"
-];
-const BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
-	"png",
-	"jpg",
-	"jpeg",
-	"gif",
-	"webp",
-	"ico",
-	"pdf",
-	"zip",
-	"gz",
-	"tar",
-	"woff",
-	"woff2",
-	"ttf",
-	"otf",
-	"mp4",
-	"wasm",
-	"bin",
-	"exe",
-	"so",
-	"dylib"
-]);
-const globCache = /* @__PURE__ */ new Map();
-const compileGlob = (glob) => {
-	let pattern = "^";
-	let i = 0;
-	while (i < glob.length) {
-		const char = glob[i];
-		if (char !== "*") {
-			pattern += char.replace(/[.+^${}()|[\]\\?]/g, "\\$&");
-			i += 1;
-		} else if (glob[i + 1] !== "*") {
-			pattern += "[^/]*";
-			i += 1;
-		} else if (glob[i + 2] === "/") {
-			pattern += "(?:.*/)?";
-			i += 3;
+//#region src/workflows/scenarios.ts
+const DOC_STRING = /^(\s*)("""|```)/;
+/**
+* Gherkin wording only: lines trimmed; blank, `#` comment and `@` tag lines
+* dropped — except inside a doc string, whose content is test input: kept
+* whole, indented relative to its opening delimiter (as Gherkin reads it).
+*/
+const scenarioText = (source) => {
+	const out = [];
+	let doc;
+	for (const line of source.split("\n")) {
+		const delimiter = DOC_STRING.exec(line);
+		if (doc === void 0 && delimiter !== null) {
+			doc = {
+				indent: delimiter[1].length,
+				fence: delimiter[2]
+			};
+			out.push(line.trim());
+		} else if (doc !== void 0 && line.trim().startsWith(doc.fence)) {
+			doc = void 0;
+			out.push(line.trim());
+		} else if (doc !== void 0) {
+			const lead = line.length - line.trimStart().length;
+			out.push(line.slice(Math.min(lead, doc.indent)).trimEnd());
 		} else {
-			pattern += ".*";
-			i += 2;
+			const trimmed = line.trim();
+			if (trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("@")) out.push(trimmed);
 		}
 	}
-	return new RegExp(`${pattern}$`);
+	return out.join("\n");
 };
-const matchesGlob = (path, glob) => {
-	let regex = globCache.get(glob);
-	if (regex === void 0) {
-		regex = compileGlob(glob);
-		globCache.set(glob, regex);
-	}
-	return regex.test(path);
+const textOf = (path) => {
+	const source = read(path);
+	return source === void 0 ? void 0 : scenarioText(source);
 };
-const extensionOf = (path) => {
-	const base = path.split("/").pop() ?? path;
-	const dot = base.lastIndexOf(".");
-	return dot === -1 ? "" : base.slice(dot + 1).toLowerCase();
-};
-const isBinary = (change) => BINARY_EXTENSIONS.has(extensionOf(change.path)) || (change.before?.includes("\0") ?? false) || (change.after?.includes("\0") ?? false);
-const isExcluded = (change) => change.path === ".gtd" || change.path.startsWith(".gtd/") || LOCKFILES.has(change.path.split("/").pop() ?? change.path) || GENERATED_GLOBS.some((glob) => matchesGlob(change.path, glob)) || isBinary(change);
-/** `changes` with lockfiles, generated trees and binaries dropped. */
-const filterChanges = (changes) => changes.filter((change) => !isExcluded(change));
-const linesOf = (content) => {
-	if (content === void 0 || content === "") return [];
-	const lines = content.split("\n");
-	if (lines[lines.length - 1] === "") lines.pop();
-	return lines;
+/** Snapshot `.feature` paths at `head()`, merged over `previous`; `undefined` when nothing is frozen. */
+const freezeScenarios = (paths, previous) => {
+	if (paths.length === 0) return previous;
+	const texts = { ...previous?.texts };
+	for (const path of paths) {
+		const text = textOf(path);
+		if (text !== void 0) texts[path] = text;
+	}
+	return Object.keys(texts).length === 0 ? previous : {
+		at: head(),
+		texts
+	};
 };
-/** `dp[i][j]` = the LCS length of `a[i:]` and `b[j:]`. */
+/** Paths whose wording differs from the snapshot (a deleted file counts). */
+const driftedScenarios = (frozen) => Object.entries(frozen.texts).filter(([path, text]) => textOf(path) !== text).map(([path]) => path);
+const lines = (text) => text === void 0 || text === "" ? [] : text.split("\n");
+/** `table[i][j]`: the longest common subsequence of `a[i..]` and `b[j..]`. */
 const lcsTable = (a, b) => {
-	const n = a.length;
-	const m = b.length;
-	const dp = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }).fill(0));
-	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
-	return dp;
-};
-/** Walk an LCS table into an edit script, favoring a deletion on a tie. */
-const backtrack = (a, b, dp) => {
-	const ops = [];
+	const table = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+	return table;
+};
+/** Changed lines in file order, `- ` / `+ `-prefixed, so a moved or repeated step still shows. */
+const lineDiff = (a, b) => {
+	const table = lcsTable(a, b);
+	const out = [];
 	let i = 0;
 	let j = 0;
 	while (i < a.length && j < b.length) if (a[i] === b[j]) {
-		ops.push({
-			type: "eq",
-			line: a[i]
-		});
-		i++;
-		j++;
-	} else if (dp[i + 1][j] >= dp[i][j + 1]) {
-		ops.push({
-			type: "del",
-			line: a[i]
-		});
 		i++;
-	} else {
-		ops.push({
-			type: "add",
-			line: b[j]
-		});
 		j++;
-	}
-	while (i < a.length) ops.push({
-		type: "del",
-		line: a[i++]
-	});
-	while (j < b.length) ops.push({
-		type: "add",
-		line: b[j++]
-	});
-	return ops;
-};
-/** Longest-common-subsequence edit script between two (already trimmed) line arrays. */
-const lcsOps = (a, b) => backtrack(a, b, lcsTable(a, b));
-const commonAffixes = (before, after) => {
-	const maxPrefix = Math.min(before.length, after.length);
-	let prefix = 0;
-	while (prefix < maxPrefix && before[prefix] === after[prefix]) prefix++;
-	const maxSuffix = maxPrefix - prefix;
-	let suffix = 0;
-	while (suffix < maxSuffix && before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) suffix++;
-	return {
-		prefix,
-		suffix
-	};
+	} else if (table[i + 1][j] >= table[i][j + 1]) out.push(`- ${a[i++]}`);
+	else out.push(`+ ${b[j++]}`);
+	return [
+		...out,
+		...a.slice(i).map((l) => `- ${l}`),
+		...b.slice(j).map((l) => `+ ${l}`)
+	];
 };
-const buildHunks = (ops) => {
-	const beforeLineAt = [];
-	const afterLineAt = [];
-	let bl = 1;
-	let al = 1;
-	for (const op of ops) {
-		beforeLineAt.push(bl);
-		afterLineAt.push(al);
-		if (op.type !== "add") bl++;
-		if (op.type !== "del") al++;
-	}
-	const ranges = [];
-	ops.forEach((op, idx) => {
-		if (op.type === "eq") return;
-		const start = Math.max(0, idx - CONTEXT);
-		const end = Math.min(ops.length - 1, idx + CONTEXT);
-		const last = ranges[ranges.length - 1];
-		if (last !== void 0 && start <= last[1] + 1) last[1] = Math.max(last[1], end);
-		else ranges.push([start, end]);
-	});
-	return ranges.map(([start, end]) => {
-		const slice = ops.slice(start, end + 1);
-		return {
-			beforeStart: beforeLineAt[start],
-			beforeCount: slice.filter((op) => op.type !== "add").length,
-			afterStart: afterLineAt[start],
-			afterCount: slice.filter((op) => op.type !== "del").length,
-			lines: slice.map((op) => `${op.type === "add" ? "+" : op.type === "del" ? "-" : " "}${op.line}`)
-		};
+const wordingDrift = (frozen, path) => ({
+	path,
+	lines: lineDiff(lines(frozen.texts[path]), lines(textOf(path)))
+});
+/** After a turn: stop at `scenario-wording` while wording drifted; accept moves the snapshot. */
+const holdWording = async (frozen) => {
+	if (frozen === void 0) return;
+	const drifted = driftedScenarios(frozen);
+	if (drifted.length === 0) return;
+	await human("scenario-wording", {
+		message: scenarioWordingMessage(frozen.at, drifted.map((path) => wordingDrift(frozen, path))),
+		label: "Scenario wording changed",
+		acceptClean: true,
+		base: frozen.at
 	});
+	const accepted = driftedScenarios(frozen);
+	if (accepted.length === 0) return;
+	for (const path of accepted) {
+		const text = textOf(path);
+		if (text === void 0) delete frozen.texts[path];
+		else frozen.texts[path] = text;
+	}
+	frozen.at = head();
 };
-const renderHunk = (hunk) => [`@@ -${hunk.beforeStart},${hunk.beforeCount} +${hunk.afterStart},${hunk.afterCount} @@`, ...hunk.lines];
-/** One file's unified diff, or a summary line when its changed region is too large to inline. */
-const renderFileDiff = (change) => {
-	const before = linesOf(change.before);
-	const after = linesOf(change.after);
-	const { prefix, suffix } = commonAffixes(before, after);
-	const beforeMiddle = before.slice(prefix, before.length - suffix);
-	const afterMiddle = after.slice(prefix, after.length - suffix);
-	if (beforeMiddle.length > TOO_LARGE_LINES || afterMiddle.length > TOO_LARGE_LINES) return `${change.path}: +${afterMiddle.length}/-${beforeMiddle.length} lines, too large to inline`;
-	const prefixOps = before.slice(0, prefix).map((line) => ({
-		type: "eq",
-		line
-	}));
-	const suffixOps = before.slice(before.length - suffix).map((line) => ({
-		type: "eq",
-		line
-	}));
-	const ops = [
-		...prefixOps,
-		...lcsOps(beforeMiddle, afterMiddle),
-		...suffixOps
-	];
-	const beforePath = change.status === "added" ? "/dev/null" : `a/${change.path}`;
-	const afterPath = change.status === "deleted" ? "/dev/null" : `b/${change.path}`;
-	return [
-		`--- ${beforePath}`,
-		`+++ ${afterPath}`,
-		...buildHunks(ops).flatMap(renderHunk)
-	].join("\n");
-};
-const omissionTrailer = (paths) => `${paths.length} file(s) omitted for the judge's byte budget: ${paths.join(", ")}`;
-/** The byte size of keeping `files`' first `keepCount` entries plus the trailer the rest would need — the trailer counts against the cap too, not just the kept text. */
-const sizeWithTrailer = (files, keepCount) => {
-	let used = 0;
-	for (let i = 0; i < keepCount; i++) used += Buffer.byteLength(files[i].text, "utf8") + (i > 0 ? 1 : 0);
-	if (files.length - keepCount === 0) return used;
-	const trailer = omissionTrailer(files.slice(keepCount).map((f) => f.path));
-	return used + (keepCount > 0 ? 1 : 0) + Buffer.byteLength(trailer, "utf8");
-};
-/**
-* The filtered `changes`, rendered as one unified diff (files in path order)
-* and bounded to `capBytes`: over the cap, whole files are dropped from the
-* end — never bytes off a hunk — and named in a trailer line, so the
-* judge is told what it did not see rather than handed a silently short diff.
-* The trailer itself is sized against the cap along with the files it keeps,
-* so a package with many touched files can never push the total past it.
-*/
-const packageDiff = (changes, capBytes) => {
-	const files = filterChanges(changes).slice().sort((a, b) => a.path.localeCompare(b.path)).map((change) => ({
-		path: change.path,
-		text: renderFileDiff(change)
-	}));
-	let keepCount = files.length;
-	while (keepCount > 0 && sizeWithTrailer(files, keepCount) > capBytes) keepCount--;
-	const dropped = files.slice(keepCount).map((f) => f.path);
-	return [...files.slice(0, keepCount).map((f) => f.text), ...dropped.length > 0 ? [omissionTrailer(dropped)] : []].join("\n");
+/** `turn`, then `holdWording`; `within` names the scope the gate rests in. */
+const guarded = (frozen, turn, within) => async () => {
+	await turn();
+	if (within === void 0) await holdWording(frozen);
+	else await scope(within, () => holdWording(frozen));
 };
 //#endregion
 //#region src/workflows/packages.ts
-const MAX_SECTIONS = 8;
-const DIFF_KEY = "diff";
-const sectionQuestion = (id, title) => ({
-	id,
-	primitive: "noul",
-	instructions: `Is the requirement "${title}" — the "${id}" evidence — already fully satisfied by the code in the "${DIFF_KEY}" evidence?`,
-	criteria: "Judge from the requirement text and the diff evidence alone. Only answer yes at a probability clearing the threshold below if genuinely confident nothing in this section is missing."
-});
-/**
-* Review one freshly built package against its spec: a pre-judge per
-* section, then an agent review of the sections it did not confidently
-* clear. `since` is the commit the package's own build started from — the
-* pre-judge's evidence is a diff over exactly that range, never an earlier
-* package's commits. Resolves `true` when approved.
-*/
-const specReview = async (pkg, since) => {
-	const found = sectionBodies(read(pkg) ?? "");
-	const titles = found.map((section) => section.title);
-	const judged = titles.length > 0 && titles.length <= MAX_SECTIONS;
-	const evidence = {};
-	const questions = [];
-	if (judged) {
-		found.forEach(({ title, body }, i) => {
-			evidence[`section-${i + 1}`] = body;
-			questions.push(sectionQuestion(`section-${i + 1}`, title));
+/** Package 0: the e2e scenarios, written red. */
+const SCENARIO_PACKAGE = ".gtd/packages/00-e2e-scenarios.md";
+const TEST_LINE = /^\s*-\s+(unit|e2e):\s+`([^`]+)`/;
+/** The `## Tests` entries of a package file; malformed lines are ignored. */
+const declaredTests = (packageText) => {
+	const found = [];
+	let inTests = false;
+	for (const line of packageText.split("\n")) if (/^##\s/.test(line)) inTests = /^##\s+Tests\s*$/.test(line);
+	else if (inTests) {
+		const match = TEST_LINE.exec(line);
+		if (match) found.push({
+			level: match[1],
+			path: match[2]
 		});
-		const capBytes = Math.floor(numeric(vars.judgeBudgetBytes, 32768) / (found.length + 1));
-		evidence[DIFF_KEY] = packageDiff(changesSince(since), capBytes);
 	}
-	const { answers, truncated } = await judge("spec.pre", {
-		questions,
-		evidence,
-		message: packagesItemSpecPreMessage(),
-		label: "Judging spec coverage"
-	});
-	const clearMinP = numeric(vars.specPreJudge, Infinity);
-	const failing = titles.filter((_, i) => {
-		const id = `section-${i + 1}`;
-		return !judged || truncated.includes(id) || truncated.includes(DIFF_KEY) || !answered(answers[id], "yes", clearMinP);
-	});
-	if (titles.length > 0 && failing.length === 0) return true;
-	await reviewPackage(pkg, failing);
-	if (wrote(".gtd/SPEC_FEEDBACK.md")) return false;
-	if (changes(".gtd/SPEC_FEEDBACK.md").length > 0 || changes().length === 0) return true;
-	return refuse("gtd land: no declared pattern matches the pending changes — write .gtd/SPEC_FEEDBACK.md to request changes, or change nothing to approve");
-};
-/** Build `pkg`, keep the suite green, review it against its spec, and close it out, which removes it. */
-const packageItem = async (pkg) => {
-	const since = head();
-	await build(pkg);
-	for (;;) {
-		await healthy(fixSuite);
-		if (await specReview(pkg, since)) break;
-		await fixSpec(pkg);
-	}
-	await run$3("closing", removeScript([
+	return found;
+};
+/**
+* Refuse a build or fix turn unless every test `pkg` declares exists and is in the
+* diff since `since`. The package text is read as of `since`, so a builder
+* editing its own `## Tests` cannot dodge the guard; with `.gtd/SATISFIED.md`
+* written, existing in the tree suffices.
+*/
+const requireDeclaredTests = (pkg, since) => {
+	const range = changesSince(since);
+	const text = range.get(pkg)?.before ?? read(pkg) ?? "";
+	const satisfied = read(".gtd/SATISFIED.md") !== void 0;
+	const missing = declaredTests(text).map((test) => test.path).filter((path) => satisfied ? read(path) === void 0 : range.get(path) === void 0 || range.get(path)?.status === "deleted" || read(path) === void 0);
+	if (missing.length === 0) return;
+	refuse(`gtd land: declared-tests: ${pkg} declares tests that are ${satisfied ? "missing from the tree" : "not in the package's diff"} — write them first:\n${missing.map((path) => `  - ${path}`).join("\n")}`);
+};
+/** Build `pkg`, check its declared tests, keep the fast suite green, and close it out, which removes it. */
+const packageItem = async (pkg, frozen) => {
+	const from = head();
+	const declared = (turn) => async () => {
+		await turn();
+		requireDeclaredTests(pkg, from);
+	};
+	await guarded(frozen, declared(() => build(pkg)))();
+	await healthy(guarded(frozen, declared(fixSuite)), { suite: "fast" });
+	await run$3("closing", removeScript([pkg, ".gtd/SATISFIED.md"]), { label: "Closing out the package" });
+	return {
 		pkg,
-		SPEC_FEEDBACK,
-		".gtd/SATISFIED.md",
-		ARCHITECTURE
-	]), { label: "Closing out the package" });
+		from,
+		to: head()
+	};
 };
 /** The first queued package — the one a package step works on. */
 const nextPackage = () => [...glob(".gtd/packages/*.md")].sort()[0];
+const outsideGtd = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
 /** Build every package file under `.gtd/packages/`, in name order. */
-const packages = () => scope("packages", async () => {
-	for (let pkg = nextPackage(); pkg !== void 0; pkg = nextPackage()) await scope("item", () => packageItem(pkg));
+const packages = (carried) => scope("packages", async () => {
+	let frozen = carried;
+	const ranges = [];
+	let touched = [];
+	for (let pkg = nextPackage(); pkg !== void 0; pkg = nextPackage()) {
+		const range = await scope("item", () => packageItem(pkg, pkg === ".gtd/packages/00-e2e-scenarios.md" ? void 0 : frozen));
+		ranges.push(range);
+		if (pkg === ".gtd/packages/00-e2e-scenarios.md") {
+			touched = changesSince(range.from).filter((c) => outsideGtd(c.path) && c.status !== "deleted");
+			frozen = freezeScenarios(touched.filter((c) => c.path.endsWith(".feature")).map((c) => c.path), frozen);
+		}
+	}
+	const paths = (status) => touched.filter((c) => c.status === status).map((c) => c.path);
+	return {
+		ranges,
+		scenarios: {
+			added: paths("added"),
+			changed: paths("modified")
+		},
+		frozen
+	};
 });
 //#endregion
 //#region src/workflows/planning.ts
@@ -49679,30 +49564,8 @@ const architecture = () => scope("architecture", async () => {
 	} while (await noteGate(ARCHITECTURE, answerTechnicalQuestions));
 	await decompose();
 	if (changes(".gtd/packages/**").length === 0) refuse("gtd land: decompose: write at least one package under .gtd/packages/");
+	if (changes(".gtd/ARCHITECTURE.md").some((c) => c.status === "deleted")) refuse("gtd land: decompose: keep .gtd/ARCHITECTURE.md — the build tail's full run needs it; it is removed only once that run is green");
 });
-/** A package file name from a plan's first heading. */
-const slug = (title) => title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "package";
-/** Whether the settled plan needs its own architecture pass, or goes straight to one package. */
-const architecturePass = async () => {
-	const { answers, truncated } = await judge("architecture-pre", {
-		questions: [{
-			id: "architectureWarranted",
-			primitive: "noul",
-			instructions: "Given the settled concerns in `.gtd/REQUIREMENTS.md` (in state), does this plan warrant a dedicated architecture pass — real structural decisions, multiple integration points, or a non-obvious tradeoff — before packages are written?",
-			criteria: "Answer yes if uncertain; a trivial, single-concern, mechanical plan with no real design decision answers no."
-		}],
-		evidence: { requirements: read(".gtd/REQUIREMENTS.md") ?? "" },
-		message: architecturePreMessage(),
-		label: "Judging whether this plan warrants an architecture pass"
-	});
-	const skip = truncated.length === 0 && answered(answers.architectureWarranted, "no", numeric(vars.architectureSkipMinP, Infinity));
-	const plan = read(REQUIREMENTS);
-	if (skip && plan !== void 0) {
-		await run$3("architecture-promote", moveScript(REQUIREMENTS, `.gtd/packages/01-${slug(sections(plan)[0] ?? "")}.md`), { label: "Promoting the plan straight to a package" });
-		return;
-	}
-	await architecture();
-};
 //#endregion
 //#region src/workflows/review.ts
 /** Split a `qualityReviews` value into its lenses: on `,`, trimmed, blanks dropped. */
@@ -49717,10 +49580,10 @@ const qualityLap = async () => {
 	return (read(".gtd/QUALITY.md") ?? "").length > 0 ? "findings" : "clean";
 };
 /** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-const fixQualityFindings = async (escalations) => {
+const fixQualityFindings = async (escalations, frozen) => {
 	for (let turns = 0; turns < 3; turns++) {
-		await fixQuality();
-		if (changes(".gtd/QUALITY.md").some((c) => c.status === "deleted")) return true;
+		await guarded(frozen, fixQuality)();
+		if (read(".gtd/QUALITY.md") === void 0) return true;
 	}
 	await escalation(escalations);
 	return false;
@@ -49822,8 +49685,8 @@ const routeNotes = async (notes, r) => {
 		answeredAt = head();
 	}
 	if (nits.length > 0) {
-		await fixNits(nits);
-		await healthy(fix, { escalations: r.escalations });
+		await guarded(r.frozen, () => fixNits(nits), "review")();
+		await healthy(guarded(r.frozen, fixCheck, "review"), { escalations: r.escalations });
 	}
 	if (edits.length > 0) {
 		await r.close();
@@ -49841,7 +49704,7 @@ const routeNotes = async (notes, r) => {
 		reviewed: answeredAt
 	};
 };
-const finish = async (reviewed, collectedAt, escalations) => {
+const finish = async (reviewed, collectedAt, escalations, frozen) => {
 	const round = head();
 	const since = changesSince(reviewed);
 	const edited = since.filter(isCodeEdit);
@@ -49874,18 +49737,19 @@ const finish = async (reviewed, collectedAt, escalations) => {
 	return routeNotes(notes, {
 		round,
 		escalations,
+		frozen,
 		close,
 		outcome,
 		unfolded
 	});
 };
 /** Write the review; if it marks risks, fix them, keep green, and write it again — once, so the re-review's own risks reach the human unfixed. */
-const reviewOnce = async (base, carry, escalations) => {
+const reviewOnce = async (base, carry, escalations, frozen) => {
 	await reviewing(base, carry);
 	const risks = reviewRisks(read(".gtd/REVIEW.md") ?? "");
 	if (risks.length === 0) return;
-	await fixRisks(risks);
-	await healthy(fix, { escalations });
+	await guarded(frozen, () => fixRisks(risks), "review")();
+	await healthy(guarded(frozen, fixCheck, "review"), { escalations });
 	await reviewing(base, carry);
 };
 /**
@@ -49894,17 +49758,17 @@ const reviewOnce = async (base, carry, escalations) => {
 * another planning lap, questions are answered in place, nits fixed in one
 * batch, praise dropped.
 */
-const review = async (base, escalations = { rounds: 0 }) => {
+const review$1 = async (base, escalations = { rounds: 0 }, frozen) => {
 	let carry;
 	for (;;) {
-		await reviewOnce(base, carry, escalations);
+		await reviewOnce(base, carry, escalations, frozen);
 		carry = void 0;
 		let reviewed = head();
 		let collectedAt;
 		for (;;) {
 			collectedAt = await converse(base, collectedAt);
 			if (collectedAt === "missing") break;
-			const result = await finish(reviewed, collectedAt, escalations);
+			const result = await finish(reviewed, collectedAt, escalations, frozen);
 			if (!("next" in result)) return result;
 			if (result.next === "rereview") {
 				carry = result.carry;
@@ -49915,14 +49779,20 @@ const review = async (base, escalations = { rounds: 0 }) => {
 	}
 };
 /** The build tail: fix (when entered red), keep green, the quality lap, then human review since `base`. */
-const buildTail = (fixFirst, base) => scope("build", async () => {
+const buildTail = (fixFirst, base, built) => scope("build", async () => {
+	const frozen = built?.frozen;
 	const escalations = { rounds: 0 };
+	const guardedFix = guarded(frozen, () => fixCheck());
 	let redFirst = fixFirst;
+	if (!fixFirst) await healthy(guarded(frozen, () => fixCheck(built)), {
+		escalations,
+		sweepOnGreen: [ARCHITECTURE]
+	});
 	let lapped = false;
 	for (;;) {
 		if (redFirst) {
-			await fix();
-			await healthy(fix, {
+			await guardedFix();
+			await healthy(guardedFix, {
 				fixesSoFar: 1,
 				escalations
 			});
@@ -49930,8 +49800,8 @@ const buildTail = (fixFirst, base) => scope("build", async () => {
 		}
 		const lap = lapped ? "clean" : await qualityLap();
 		lapped = true;
-		if (lap === "clean") return review(base, escalations);
-		if (await fixQualityFindings(escalations)) await healthy(fix, { escalations });
+		if (lap === "clean") return review$1(base, escalations, frozen);
+		if (await fixQualityFindings(escalations, frozen)) await healthy(guardedFix, { escalations });
 		else redFirst = true;
 	}
 });
@@ -49942,14 +49812,13 @@ const defaults = {
 	reviewBase: "",
 	judgeBudgetBytes: "32768",
 	judgeIdenticalMinP: "0.7",
-	specPreJudge: "0.9",
 	reviewNoteActionable: "0.7",
-	architectureSkipMinP: "0.85",
 	qualityReviews: "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge"
 };
 /** Environment settings. */
 const envDefaults = {
 	testCommand: "npm test",
+	fastTestCommand: "",
 	plannerModel: "smart",
 	coderModel: "base"
 };
@@ -49965,8 +49834,6 @@ const skills = (vars) => ({
 	"architecture.decompose": ["incremental-implementation", "planning-and-task-breakdown"],
 	"packages.item": ["test-driven-development", "incremental-implementation"],
 	"packages.item.fix.suite": ["debugging-and-error-recovery"],
-	"packages.item.fix.spec": ["incremental-implementation", "code-simplification"],
-	"packages.item.spec": ["code-review-and-quality", "spec-driven-development"],
 	"packages.item.health": ["debugging-and-error-recovery"],
 	build: ["debugging-and-error-recovery"],
 	"build.health": ["debugging-and-error-recovery"],
@@ -49982,15 +49849,14 @@ const access = (vars) => ({
 	design: { write: [] },
 	architecture: { write: [".gtd/REQUIREMENTS.md"] },
 	"architecture.decompose": { write: [".gtd/packages/**", ".gtd/ARCHITECTURE.md"] },
-	"packages.item.spec": { write: [".gtd/SPEC_FEEDBACK.md"] },
 	"build.review": { write: [".gtd/REVIEW.md"] },
 	"build.review.fix.nits": {},
 	"build.review.fix.risks": {},
 	...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,
@@ -49998,7 +49864,8 @@ var unified_exports = /* @__PURE__ */ __exportAll({
 	QUALITY: () => QUALITY,
 	REQUIREMENTS: () => REQUIREMENTS,
 	REVIEW: () => REVIEW,
-	SPEC_FEEDBACK: () => SPEC_FEEDBACK,
+	SCENARIO_PACKAGE: () => SCENARIO_PACKAGE,
+	SETUP: () => SETUP,
 	access: () => access,
 	afterTail: () => afterTail,
 	agentWithSkills: () => agentWithSkills,
@@ -50006,7 +49873,6 @@ var unified_exports = /* @__PURE__ */ __exportAll({
 	answerReviewQuestions: () => answerReviewQuestions,
 	answerTechnicalQuestions: () => answerTechnicalQuestions,
 	architecture: () => architecture,
-	architecturePass: () => architecturePass,
 	author: () => author,
 	awaitReview: () => awaitReview,
 	base: () => base,
@@ -50015,24 +49881,32 @@ var unified_exports = /* @__PURE__ */ __exportAll({
 	buildTail: () => buildTail,
 	builtInLenses: () => builtInLenses,
 	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,
 	fixRisks: () => fixRisks,
-	fixSpec: () => fixSpec,
 	fixSuite: () => fixSuite,
+	freezeScenarios: () => freezeScenarios,
 	gate: () => gate,
+	guarded: () => guarded,
 	healthy: () => healthy,
+	holdWording: () => holdWording,
 	lensesOf: () => lensesOf,
 	nextPackage: () => nextPackage,
 	ordinaryStart: () => ordinaryStart,
@@ -50041,19 +49915,20 @@ var unified_exports = /* @__PURE__ */ __exportAll({
 	planAndBuild: () => planAndBuild,
 	qualityLap: () => qualityLap,
 	reUnwind: () => reUnwind,
+	requireDeclaredTests: () => requireDeclaredTests,
 	retryQuestion: () => retryQuestion,
 	review: () => review,
 	reviewMissing: () => reviewMissing,
-	reviewPackage: () => reviewPackage,
 	reviewQuality: () => reviewQuality,
 	reviewing: () => reviewing,
+	scenarioText: () => scenarioText,
 	skills: () => skills,
-	specReview: () => specReview,
 	steering: () => steering,
 	summary: () => summary,
 	threads: () => threads,
 	triage: () => triage$1,
-	unwind: () => unwind
+	unwind: () => unwind,
+	wordingDrift: () => wordingDrift
 });
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 const unwind = () => {
@@ -50079,11 +49954,13 @@ const reUnwind = async (feedback) => {
 /** Plan, build and review until a review round signs off; feedback re-plans from scratch. */
 const planAndBuild = async (firstBase) => {
 	let base = firstBase;
+	let carried;
 	for (;;) {
 		await design(base);
-		await architecturePass();
-		await packages();
-		const outcome = await buildTail(false, base);
+		await architecture();
+		const built = await packages(carried);
+		carried = built.frozen;
+		const outcome = await buildTail(false, base, built);
 		if (outcome.verdict === "signoff") return;
 		await reUnwind(outcome);
 		base = outcome.base;
@@ -50111,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));
@@ -50331,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())),
@@ -58237,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,
@@ -58283,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;
@@ -58313,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,
@@ -58350,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]]) {
@@ -58367,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"),
@@ -58379,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;
@@ -58451,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
@@ -58465,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
@@ -58481,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 });
@@ -58495,7 +58501,10 @@ var ConfigService = class ConfigService extends Tag("ConfigService")() {
 //#endregion
 //#region src/workflow/init.ts
 const SCHEMA_URL = "https://cdn.jsdelivr.net/npm/@pmelab/gtd/schema.json";
-const INIT_ENV = { testCommand: "npm test" };
+const INIT_ENV = {
+	testCommand: "npm test",
+	fastTestCommand: ""
+};
 const MODES_SUGGESTION = {
 	qa: { format: "npx prettier --write \"$GTD_FILE\"" },
 	review: { format: "npx prettier --write \"$GTD_FILE\"" }
@@ -58523,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.
@@ -58532,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) => {
@@ -58552,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
@@ -63941,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,
@@ -63997,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`).
@@ -64009,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,
@@ -64016,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,
@@ -64054,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.
 */
@@ -64069,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),
@@ -64270,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
@@ -64282,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",
@@ -64326,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
 				})
@@ -64340,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
@@ -64362,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.
 */
@@ -64373,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
 	};
@@ -64418,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,
@@ -64445,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
@@ -64584,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
@@ -64610,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
 	},
@@ -64628,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,
@@ -64755,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_({
@@ -64810,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,
@@ -64831,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)
@@ -64857,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;
@@ -64881,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";
@@ -64921,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",
@@ -64984,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({
@@ -64997,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
@@ -76876,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`;
@@ -76972,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
@@ -77066,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\`/
@@ -77108,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.
 
@@ -77167,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
@@ -77183,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:
@@ -77196,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
 
@@ -77236,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\`.
+### \`gtd-door <name> [args...]\` — start a process through a door and drive it
 
-\`\`\`bash
-${REVIEW_COMMAND}
-\`\`\`
-
-### \`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,
@@ -77292,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
@@ -77343,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
@@ -77481,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.
@@ -77644,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
@@ -77923,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),
@@ -78009,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);
@@ -78073,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",
@@ -78177,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"]
 	},
@@ -78196,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();
@@ -78230,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)"
@@ -78516,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",
@@ -78571,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
@@ -78692,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) => {
@@ -78733,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`
@@ -78745,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);
@@ -78782,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
 			},
@@ -78797,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: {