@pmelab/gtd 5.0.0 → 6.0.0

package/dist/gtd.bundle.mjs

@@ -1058,15 +1058,15 @@ const hash = (self) => {
 	if (structuralRegionState.enabled === true) return 0;
 	switch (typeof self) {
 		case "number": return number$1(self);
-		case "bigint": return string$2(self.toString(10));
-		case "boolean": return string$2(String(self));
-		case "symbol": return string$2(String(self));
-		case "string": return string$2(self);
-		case "undefined": return string$2("undefined");
+		case "bigint": return string(self.toString(10));
+		case "boolean": return string(String(self));
+		case "symbol": return string(String(self));
+		case "string": return string(self);
+		case "undefined": return string("undefined");
 		case "function":
-		case "object": if (self === null) return string$2("null");
+		case "object": if (self === null) return string("null");
 		else if (self instanceof Date) {
-			if (Number.isNaN(self.getTime())) return string$2("Invalid Date");
+			if (Number.isNaN(self.getTime())) return string("Invalid Date");
 			return hash(self.toISOString());
 		} else if (self instanceof URL) return hash(self.href);
 		else if (isHash(self)) return self[symbol$1]();
@@ -1112,7 +1112,7 @@ const number$1 = (n) => {
 * @since 2.0.0
 * @category hashing
 */
-const string$2 = (str) => {
+const string = (str) => {
 	let h = 5381, i = str.length;
 	while (i) h = h * 33 ^ str.charCodeAt(--i);
 	return optimize(h);
@@ -1123,7 +1123,7 @@ const string$2 = (str) => {
 */
 const structureKeys = (o, keys) => {
 	let h = 12289;
-	for (let i = 0; i < keys.length; i++) h ^= pipe(string$2(keys[i]), combine$7(hash(o[keys[i]])));
+	for (let i = 0; i < keys.length; i++) h ^= pipe(string(keys[i]), combine$7(hash(o[keys[i]])));
 	return optimize(h);
 };
 /**
@@ -6665,7 +6665,7 @@ const OP_NONE = "None";
 const OP_RUNTIME = "Runtime";
 /** @internal */
 const OP_COMPOSITE = "Composite";
-const emptyHash = /*#__PURE__*/ string$2(`${FiberIdSymbolKey}-${OP_NONE}`);
+const emptyHash = /*#__PURE__*/ string(`${FiberIdSymbolKey}-${OP_NONE}`);
 /** @internal */
 var None$2 = class {
 	[FiberIdTypeId] = FiberIdTypeId;
@@ -6702,7 +6702,7 @@ var Runtime = class {
 		this.startTimeMillis = startTimeMillis;
 	}
 	[symbol$1]() {
-		return cached(this, string$2(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`));
+		return cached(this, string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`));
 	}
 	[symbol](that) {
 		return isFiberId$1(that) && that._tag === OP_RUNTIME && this.id === that.id && this.startTimeMillis === that.startTimeMillis;
@@ -6734,7 +6734,7 @@ var Composite$1 = class {
 	}
 	_hash;
 	[symbol$1]() {
-		return pipe(string$2(`${FiberIdSymbolKey}-${this._tag}`), combine$7(hash(this.left)), combine$7(hash(this.right)), cached(this));
+		return pipe(string(`${FiberIdSymbolKey}-${this._tag}`), combine$7(hash(this.left)), combine$7(hash(this.right)), cached(this));
 	}
 	[symbol](that) {
 		return isFiberId$1(that) && that._tag === OP_COMPOSITE && equals$2(this.left, that.left) && equals$2(this.right, that.right);
@@ -7047,7 +7047,7 @@ const makeCons = (head, tail) => {
 	cons.tail = tail;
 	return cons;
 };
-const NilHash = /*#__PURE__*/ string$2("Nil");
+const NilHash = /*#__PURE__*/ string("Nil");
 const _Nil = /*#__PURE__*/ Object.create({
 	[TypeId$18]: TypeId$18,
 	_tag: "Nil",
@@ -7957,7 +7957,7 @@ var EffectPrimitiveFailure = class {
 		return exitIsExit(that) && that._op === "Failure" && equals$2(this.effect_instruction_i0, that.effect_instruction_i0);
 	}
 	[symbol$1]() {
-		return pipe(string$2(this._tag), combine$7(hash(this.effect_instruction_i0)), cached(this));
+		return pipe(string(this._tag), combine$7(hash(this.effect_instruction_i0)), cached(this));
 	}
 	get cause() {
 		return this.effect_instruction_i0;
@@ -7998,7 +7998,7 @@ var EffectPrimitiveSuccess = class {
 		return exitIsExit(that) && that._op === "Success" && equals$2(this.effect_instruction_i0, that.effect_instruction_i0);
 	}
 	[symbol$1]() {
-		return pipe(string$2(this._tag), combine$7(hash(this.effect_instruction_i0)), cached(this));
+		return pipe(string(this._tag), combine$7(hash(this.effect_instruction_i0)), cached(this));
 	}
 	get value() {
 		return this.effect_instruction_i0;
@@ -10127,7 +10127,7 @@ const OP_DONE$3 = "Done";
 const OP_RUNNING = "Running";
 /** @internal */
 const OP_SUSPENDED = "Suspended";
-const DoneHash = /*#__PURE__*/ string$2(`${FiberStatusSymbolKey}-${OP_DONE$3}`);
+const DoneHash = /*#__PURE__*/ string(`${FiberStatusSymbolKey}-${OP_DONE$3}`);
 /** @internal */
 var Done$1 = class {
 	[FiberStatusTypeId] = FiberStatusTypeId;
@@ -10551,7 +10551,7 @@ const makeExit = (options) => {
 			return isMicroExit(that) && that._tag === options.op && equals$2(this[args], that[args]);
 		},
 		[symbol$1]() {
-			return cached(this, combine$7(string$2(options.op))(hash(this[args])));
+			return cached(this, combine$7(string(options.op))(hash(this[args])));
 		}
 	};
 	return function(value) {
@@ -11203,7 +11203,7 @@ var MetricLabelImpl = class {
 	constructor(key, value) {
 		this.key = key;
 		this.value = value;
-		this._hash = string$2(MetricLabelSymbolKey + this.key + this.value);
+		this._hash = string(MetricLabelSymbolKey + this.key + this.value);
 	}
 	[symbol$1]() {
 		return this._hash;
@@ -11734,7 +11734,7 @@ var MetricBoundariesImpl = class {
 	[MetricBoundariesTypeId] = MetricBoundariesTypeId;
 	constructor(values) {
 		this.values = values;
-		this._hash = pipe(string$2(MetricBoundariesSymbolKey), combine$7(array(this.values)));
+		this._hash = pipe(string(MetricBoundariesSymbolKey), combine$7(array(this.values)));
 	}
 	_hash;
 	[symbol$1]() {
@@ -11786,7 +11786,7 @@ var CounterKeyType = class {
 	constructor(incremental, bigint) {
 		this.incremental = incremental;
 		this.bigint = bigint;
-		this._hash = string$2(CounterKeyTypeSymbolKey);
+		this._hash = string(CounterKeyTypeSymbolKey);
 	}
 	_hash;
 	[symbol$1]() {
@@ -11806,7 +11806,7 @@ var HistogramKeyType = class {
 	[HistogramKeyTypeTypeId] = HistogramKeyTypeTypeId;
 	constructor(boundaries) {
 		this.boundaries = boundaries;
-		this._hash = pipe(string$2(HistogramKeyTypeSymbolKey), combine$7(hash(this.boundaries)));
+		this._hash = pipe(string(HistogramKeyTypeSymbolKey), combine$7(hash(this.boundaries)));
 	}
 	_hash;
 	[symbol$1]() {
@@ -11853,7 +11853,7 @@ var MetricKeyImpl = class {
 		this.keyType = keyType;
 		this.description = description;
 		this.tags = tags;
-		this._hash = pipe(string$2(this.name + this.description), combine$7(hash(this.keyType)), combine$7(array(this.tags)));
+		this._hash = pipe(string(this.name + this.description), combine$7(hash(this.keyType)), combine$7(array(this.tags)));
 	}
 	_hash;
 	[symbol$1]() {
@@ -12058,7 +12058,7 @@ var FrequencyState = class {
 	}
 	_hash;
 	[symbol$1]() {
-		return pipe(string$2(FrequencyStateSymbolKey), combine$7(array(fromIterable$6(this.occurrences.entries()))), cached(this));
+		return pipe(string(FrequencyStateSymbolKey), combine$7(array(fromIterable$6(this.occurrences.entries()))), cached(this));
 	}
 	[symbol](that) {
 		return isFrequencyState(that) && arrayEquals(fromIterable$6(this.occurrences.entries()), fromIterable$6(that.occurrences.entries()));
@@ -15357,7 +15357,7 @@ const ProtoTimeZoneNamed = {
 	...ProtoTimeZone,
 	_tag: "Named",
 	[symbol$1]() {
-		return cached(this, string$2(`Named:${this.id}`));
+		return cached(this, string(`Named:${this.id}`));
 	},
 	[symbol](that) {
 		return isTimeZone(that) && that._tag === "Named" && this.id === that.id;
@@ -15377,7 +15377,7 @@ const ProtoTimeZoneOffset = {
 	...ProtoTimeZone,
 	_tag: "Offset",
 	[symbol$1]() {
-		return cached(this, string$2(`Offset:${this.offset}`));
+		return cached(this, string(`Offset:${this.offset}`));
 	},
 	[symbol](that) {
 		return isTimeZone(that) && that._tag === "Offset" && this.offset === that.offset;
@@ -29906,8 +29906,6 @@ const collectUint8Array = /*#__PURE__*/ foldLeftChunks(/*#__PURE__*/ new Uint8Ar
 /** @internal */
 const CommandTypeId = /*#__PURE__*/ Symbol.for("@effect/platform/Command");
 /** @internal */
-const isCommand = (u) => typeof u === "object" && u != null && CommandTypeId in u;
-/** @internal */
 const flatten$1 = (self) => Array.from(flattenLoop(self));
 /** @internal */
 const flattenLoop = (self) => {
@@ -30012,8 +30010,6 @@ const stdout$1 = /*#__PURE__*/ dual(2, (self, output) => {
 	}
 });
 /** @internal */
-const string$1 = /*#__PURE__*/ dual((args) => isCommand(args[0]), (command, encoding) => flatMap$4(CommandExecutor$1, (executor) => executor.string(command, encoding)));
-/** @internal */
 const workingDirectory$1 = /*#__PURE__*/ dual(2, (self, cwd) => {
 	switch (self._tag) {
 		case "StandardCommand": return makeStandard({
@@ -30045,16 +30041,6 @@ const flatten = flatten$1;
 */
 const make$1 = make$2;
 /**
-* Runs the command returning the entire output as a string with the
-* specified encoding.
-*
-* If an encoding is not specified, the encoding will default to `utf-8`.
-*
-* @since 1.0.0
-* @category execution
-*/
-const string = string$1;
-/**
 * Specify the standard error stream for a command.
 *
 * @since 1.0.0
@@ -189117,6 +189103,10 @@ const isCommitState = (state) => state.commit !== void 0;
 const isReviewWindowState = (def, state) => def.states[state]?.reviewWindow === true;
 /** True when `state` anchors the review window's diff base (see `StateDef.reviewBase`). Safe for an unknown state name (returns `false`). */
 const isReviewBaseState = (def, state) => def.states[state]?.reviewBase === true;
+/** The workflow's declared review-entry state name (see `StateDef.reviewEntry`) — `gtd review <commitish>` (`src/program.ts`) enters this state to start a new review process. `undefined` when no state declares one; `validateDefinition` guarantees at most one does, so the first (only) match wins. */
+const reviewEntryStateOf = (def) => {
+	for (const [name, state] of Object.entries(def.states)) if (state.reviewEntry === true) return name;
+};
 /**
 * `gtd(<actor>): <state>` — the subject a step commit carries. Per decision
 * 2, `<actor>` is WHO AUTHORED THE STEP (the invoker), and `<state>` is the
@@ -189445,6 +189435,29 @@ const validateReviewWindow = (name, state) => {
 	if (state.reviewBase !== void 0) errors.push(`state "${name}": a commit state cannot declare "reviewBase"`);
 	return errors;
 };
+/**
+* `reviewEntry`, when present, is forbidden on a commit state (never at
+* rest — same rule family as `reviewWindow`/`reviewBase`) and on the initial
+* state: a review entry is a deliberate, distinct starting point from the
+* workflow's ordinary "no active cycle" rest (`gtd review` itself REQUIRES
+* resting at the initial state before it will act — see `src/program.ts` —
+* so the two must stay distinguishable rather than collapsing into one).
+* The at-most-one-state rule is checked separately, over the whole
+* definition (see `validateReviewEntryUniqueness`), since it isn't a
+* per-state finding.
+*/
+const validateReviewEntry = (name, state) => {
+	if (state.reviewEntry === void 0) return [];
+	const errors = [];
+	if (isCommitState(state)) errors.push(`state "${name}": a commit state cannot declare "reviewEntry"`);
+	if (state.initial === true) errors.push(`state "${name}": the initial state cannot declare "reviewEntry"`);
+	return errors;
+};
+/** At most one state may declare `reviewEntry: true` — `gtd review <commitish>` (`src/program.ts`) needs a single, unambiguous state name to enter (see `reviewEntryStateOf`). */
+const validateReviewEntryUniqueness = (def, names) => {
+	const entryNames = names.filter((name) => def.states[name].reviewEntry === true);
+	return entryNames.length > 1 ? [`at most one state may declare "reviewEntry" (found ${entryNames.length}: ${entryNames.join(", ")})`] : [];
+};
 /** Every `on` row parses, and its target names a defined state. */
 const validateOnEdges = (name, state, names) => {
 	const errors = [];
@@ -189505,7 +189518,8 @@ const validateState = (def, name, names) => {
 		...validateMemory(name, state),
 		...validateFile(name, state),
 		...validateMode(def, name, state),
-		...validateReviewWindow(name, state)
+		...validateReviewWindow(name, state),
+		...validateReviewEntry(name, state)
 	];
 };
 /**
@@ -189527,9 +189541,11 @@ const validateState = (def, name, names) => {
 * `knownModes`), requires a sibling `file`, and is never declared on a commit
 * state; every `modes:` entry declares at least one non-blank
 * `format`/`validate` command; `reviewWindow`/`reviewBase`, when
-* present, are never declared on a commit state; every state is reachable from
-* the initial state by walking `on` targets and `retry.otherwise` redirects
-* (checked only when the initial-state rule itself passed — see
+* present, are never declared on a commit state; `reviewEntry`, when present,
+* is never declared on a commit state or the initial state, and at most one
+* state across the whole workflow may declare it; every state is reachable
+* from the initial state by walking `on` targets and `retry.otherwise`
+* redirects (checked only when the initial-state rule itself passed — see
 * `validateReachability`).
 */
 const validateDefinition = (def) => {
@@ -189540,6 +189556,7 @@ const validateDefinition = (def) => {
 		...initialErrors,
 		...validateModes(def),
 		...names.flatMap((name) => validateState(def, name, names)),
+		...validateReviewEntryUniqueness(def, names),
 		...initialErrors.length === 0 ? validateReachability(def, names) : []
 	];
 };
@@ -189749,7 +189766,8 @@ const KNOWN_STATE_KEYS = /* @__PURE__ */ new Set([
 	"file",
 	"mode",
 	"reviewWindow",
-	"reviewBase"
+	"reviewBase",
+	"reviewEntry"
 ]);
 const KNOWN_TOP_KEYS = /* @__PURE__ */ new Set([
 	"vars",
@@ -189909,7 +189927,7 @@ const compileMode = (raw, name, errors) => {
 /** The `initial` field: `true` only when the raw value is the literal boolean `true`. */
 const compileInitial = (raw, name, errors) => compileBooleanFlag(raw, "initial", name, errors);
 /**
-* A boolean state flag (`initial`/`reviewWindow`/`reviewBase`): `true` only
+* A boolean state flag (`initial`/`reviewWindow`/`reviewBase`/`reviewEntry`): `true` only
 * when the raw value is the literal `true`; a non-boolean is a config error;
 * `false` (or absent) compiles away to `undefined` so it never lands in the
 * `StateDef` — `false` and "unset" mean the same thing for every such flag.
@@ -189948,7 +189966,8 @@ const assembleStateDef = (parts) => ({
 		file: parts.file,
 		mode: parts.mode,
 		reviewWindow: parts.reviewWindow,
-		reviewBase: parts.reviewBase
+		reviewBase: parts.reviewBase,
+		reviewEntry: parts.reviewEntry
 	}),
 	...assembleContentFields(parts.content)
 });
@@ -189971,7 +189990,8 @@ const compileState = (name, raw, configDir, errors) => {
 		file: compileFile(raw, name, errors),
 		mode: compileMode(raw, name, errors),
 		reviewWindow: compileBooleanFlag(raw, "reviewWindow", name, errors),
-		reviewBase: compileBooleanFlag(raw, "reviewBase", name, errors)
+		reviewBase: compileBooleanFlag(raw, "reviewBase", name, errors),
+		reviewEntry: compileBooleanFlag(raw, "reviewEntry", name, errors)
 	});
 };
 /**
@@ -190012,27 +190032,6 @@ const compileWorkflowConfig = (raw, configDir, rcModes) => {
 	};
 };
 //#endregion
-//#region src/workflows/default.ts
-/**
-* The bundled default workflow, compiled through the exact same
-* `compileWorkflowConfig` a user's `.gtdrc` `workflow:` key goes through — no
-* privileged code path (see default.yaml's header comment for why every
-* content string there is inline rather than a `./`-relative file
-* reference). `default.yaml` is imported as raw text (tsdown's `.yaml` text
-* loader / the vitest `rawMd` transform — see tsdown.config.ts /
-* tests/vitest.rawMd.ts), so this module never touches the filesystem: it
-* works identically in the dev checkout, under `vitest`, and inside the
-* single-file `dist/gtd.bundle.mjs` build.
-*
-* `configDir` is passed as `"."` and never actually consulted: none of
-* default.yaml's content values start with `./`/`../`, so
-* `compileWorkflowConfig` never resolves a file reference against it.
-*/
-const compiled = compileWorkflowConfig((0, import_dist$1.parse)("# The bundled default gtd workflow (v3 \"pattern machine\" — see\n# docs/design/pattern-machine-plan.md, and\n# docs/design/steering-file-validation-command.md for the `gtd validate`\n# self-validation model that replaced the old in-machine validation loops).\n# Compiled through the exact same `compileWorkflowConfig` a user's `.gtdrc`\n# `workflow:` key goes through — no privileged code path\n# (src/workflows/default.ts does the compiling).\n#\n# Every content string below is INLINE (no `./`-relative file references):\n# the bundled default ships inside a single-file build\n# (`dist/gtd.bundle.mjs`), so its content must already be resolved at BUILD\n# time rather than read from disk at RUNTIME — the same reason\n# `src/prompts/*.md` are imported through tsdown's `.md`-as-text loader\n# instead of read via `fs` at runtime. `default.yaml` itself is imported the\n# same way (tsdown/vitest both treat `.yaml` as text — see\n# tsdown.config.ts / tests/vitest.rawMd.ts), so this file never needs a\n# sibling prompts/ directory to exist on disk once installed.\n#\n# States, in cycle order — 10 states, no squash:\n#   idle (initial, human, message)\n#     -> grilling (agent, prompt): reads .gtd/TODO.md's sketch (or a prior\n#     lap's feedback), explores the codebase, and develops it into a concrete\n#     implementation plan, stating any open question it can't settle itself\n#     under a `## Open Questions` heading rather than guessing silently. Its\n#     `file:`/`mode:` (TODO.md/`qa`) makes the plan's format checkable — it\n#     self-validates before finishing (see \"Steering-file validation\" below).\n#   grilling -> grilling-answer (human, message): tick off suggested\n#     defaults by replacing them with `Answer:` lines; a clean step accepts\n#     every remaining default -> building; any edit loops back to grilling.\n#   grilling-answer -> building (agent, prompt): implements the plan in\n#     .gtd/TODO.md directly (no task decomposition, no per-task queue) and\n#     deletes .gtd/TODO.md once the work is complete and verified.\n#   building -> checking (check, script): runs the test command inline;\n#     A/M .gtd/FEEDBACK.md -> fixing (capped, redirects to escalate); D\n#     .gtd/FEEDBACK.md (a green run that just cleaned up prior feedback) or C\n#     (green, nothing to clean) -> reviewing.\n#   fixing (agent, prompt) <-> checking\n#   escalate (human, message): manual intervention, then back to checking\n#   checking (green) -> reviewing (agent, prompt): writes .gtd/REVIEW.md in\n#     the checkbox review format, grouping the cycle's full diff into\n#     reviewable chunks; its `file:`/`mode:` (REVIEW.md/`review`) makes that\n#     format checkable, so it self-validates before finishing.\n#   reviewing -> await-review (human, message): tick a pointer's `- [\n#     ]` to `- [x]` to approve that item; deleting .gtd/REVIEW.md outright is\n#     the power-user approve-everything shortcut; anything else pending\n#     (code edits with REVIEW.md untouched) is feedback straight to grilling.\n#   await-review -> review-deciding (check, script), entered by any `M\n#     .gtd/REVIEW.md` step: if no unticked `- [ ]` pointer remains, the cycle\n#     is approved (rm .gtd/REVIEW.md -> idle); otherwise the still-unticked\n#     pointers (with their notes) are extracted into a fresh .gtd/TODO.md and\n#     .gtd/REVIEW.md is removed (-> grilling, feedback lap).\n#\n# The cycle ends at human approval, resting back at idle — there is no\n# squash state. The cycle's commits stay in history; whether/how to squash\n# them (amend, interactive rebase, a PR's squash-merge) is entirely the\n# human's business once they're done reviewing — gtd makes no assumption.\n# That squash-flavored finale (a `squashing` prompt state + a `done` commit\n# state) still exists as an ENGINE capability (see STATES.md §8) and is kept\n# as part of the fuller machine at docs/examples/advanced-workflow.md.\n#\n# A `gtd(<actor>): idle` commit — entering the workflow's own initial state —\n# is therefore a PROCESS BOUNDARY (see `computeProcessRun` in src/Edge.ts):\n# the next cycle's `retry` counts, `startCommit`, and diffs never reach back\n# across an approved cycle's own idle-entering commit.\n#\n# HYGIENE INVARIANT (asserted in e2e — see default-workflow.feature): an\n# approved cycle leaves `.gtd/` empty. FEEDBACK.md is cleaned up by a green\n# `checking` run; REVIEW.md by the review-deciding approval branch; TODO.md by\n# `building`.\n#\n# Steering-file validation. `grilling` and `reviewing` each declare a\n# `file:`/`mode:` pair (TODO.md as `qa`, REVIEW.md as `review`), so their\n# output has a checkable format. src/OpenQuestions.ts and src/ReviewDoc.ts are\n# those two formats' EXECUTABLE SPECS (their unit tests are the format spec\n# tests), and `gtd validate` FORMATS the resolved state's rendered `file:` in\n# place then runs the SAME parser over it, exiting non-zero with findings when\n# it violates the format. There is no in-machine validation state and no bash\n# port to keep in sync — the producing agent self-validates before finishing\n# (plain `gtd next` appends the \"run `gtd validate` and fix all violations\"\n# instruction; under `--json` the driving loop runs it after the turn and\n# re-prompts on findings — see skills/loop/SKILL.md), AND `gtd step` runs the\n# same format-and-validate gate on capture, refusing a turn whose steering file\n# is invalid. So the check runs after a human edits too — at the human gates\n# `grilling-answer` (TODO.md) and `await-review` (REVIEW.md) — and a human gate\n# is only ever handed a tidy, well-formed file. The same parsers back the LSP's\n# live diagnostics (src/Lsp.ts).\n#\n# `grilling` and `reviewing` both declare `model: smart` — an opaque harness\n# hint (see the comment at `grilling` below) for their heavier one-shot\n# planning/reviewing turns. Every other state is unset (harness default).\n#\n# The four agent states each declare a `memory:` scope label (`plan`,\n# `build`, `fix`, `review` — see the comment at `grilling` below) — another\n# opaque hint a memory-aware driver reads to decide when an agent turn keeps\n# the previous turn's memory and when it starts fresh: a loop that re-enters\n# one state (grilling around its answer loop, fixing around checking) keeps\n# the same label and retains memory across its laps; crossing to the next\n# phase's differently-labelled state clears it. gtd never interprets the\n# label (see STATES.md §1 and skills/loop/SKILL.md's driver contract).\n#\n# `vars.testCommand` is this workflow's own declared default for `checking`'s\n# script (see it.vars in PatternTemplates.ts) — override it per-repo with a\n# top-level `.gtdrc` `vars: { testCommand: ... }` key, or per-invocation with\n# a `GTD_VAR_testCommand` environment variable (highest precedence).\n#\n# `vars.todoFile`/`reviewFile`/`feedbackFile` are this workflow's ONE source\n# of truth for the three steering-file paths every prompt/script below reads\n# or writes — each appears in templates as `<%~ it.vars.todoFile %>` etc\n# (see docs/design/state-file-association.md §2). Every state that rests on\n# one of these files also declares a `file:`/`mode:` pair (see STATES.md's\n# property table) so `gtd status`/`gtd next --json` and the LSP (`gtd lsp`)\n# know which file a human/editor should look at, and in what format\n# (`qa` for TODO.md's open-questions format, `review` for REVIEW.md's\n# checkbox format) — `fixing`/`escalate` declare `file:` alone (FEEDBACK.md\n# is plain text, no LSP format). KNOWN LIMITATION: `on` pattern keys below are\n# NOT Eta templates — they keep the LITERAL `.gtd/...` paths matching these\n# vars' DEFAULT values. Repointing `todoFile`/`reviewFile`/`feedbackFile` via\n# `.gtdrc`'s top-level `vars:` or a `GTD_VAR_` override changes what `file:`\n# renders to (and what a template reads/writes) WITHOUT changing what the\n# `on` patterns match against — desyncing the machine. See\n# docs/configuration.md's `file:`/`mode:` section for the full caveat.\n#\n# A fuller machine — two-phase Q&A planning, an architecture phase, task\n# decomposition, a deterministic per-task builder loop, agent-prepared\n# review, and the squash finale (`squashing` + `done`) — is preserved as a\n# copy-paste `.gtdrc` example at docs/examples/advanced-workflow.md.\n\nvars:\n  testCommand: npm test\n  todoFile: .gtd/TODO.md\n  reviewFile: .gtd/REVIEW.md\n  feedbackFile: .gtd/FEEDBACK.md\n\nstates:\n  idle:\n    actor: human\n    initial: true\n    # Every human-gate `message:` below closes with the SAME rendered block —\n    # a \"What each change does next\" list built from `it.edges`, the resting\n    # state's own `on` edges (see PatternTemplates.TemplateContext.edges). Each\n    # edge's human-readable route lives in its `describe:` (the single source\n    # of truth), so the list can never drift from the routing it documents.\n    # The block skips edges without a `describe`, and each `<%~ ... \"\\n\" %>`\n    # keeps the bullet's own newline (Eta's autoTrim strips the template's own\n    # line breaks around `<% %>` tags, not text inside an interpolation).\n    message: |\n      No active gtd cycle.\n\n      To start one, write `.gtd/TODO.md` with a short sketch of what you want\n      built — a few sentences is enough.\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"* **\":\n        to: grilling\n        describe: >-\n          Save your sketch to `.gtd/TODO.md` (any working-tree change) to start\n          the cycle — the agent reads it, explores the codebase, and develops it\n          into a concrete implementation plan (**grilling**).\n\n  grilling:\n    actor: agent\n    file: <%= it.vars.todoFile %>\n    mode: qa\n    # `model` is an opaque harness hint — gtd never interprets this string, it\n    # only passes it through to `gtd next --json`/`gtd status --json` so the\n    # driving loop can map it onto whatever models its agent harness\n    # provides. \"smart\" here just names the harness-chosen tier for the\n    # heavier planning turn; states without a `model` use the harness's\n    # default.\n    model: smart\n    # `memory` is an opaque memory-scope label — gtd never interprets it, it\n    # only passes it through to `gtd next --json`/`gtd status --json` so a\n    # memory-aware driving loop can decide when an agent turn continues from\n    # the previous turn's memory and when it starts fresh: consecutive agent\n    # turns that emit the SAME label share memory, a change (or the first\n    # turn) is where the driver starts fresh. `grilling` re-enters itself\n    # around the grilling-answer loop, so labelling every lap\n    # `plan` keeps the planner's accumulated exploration across the loop; the\n    # next phase (`building`) carries a different label, clearing it.\n    memory: plan\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.todoFile %>`, which this prompt tells you to develop.\n\n      `<%= it.vars.todoFile %>` holds a short sketch of what to build (or\n      feedback from a prior review lap). Read it, explore the codebase, and\n      develop it into a concrete implementation plan.\n\n      For every question you cannot settle yourself, add it under a\n      `## Open Questions` heading, one `### <question>` sub-heading each,\n      whose body's FIRST non-blank line is exactly\n      `Suggested default: <your answer>` — the human can accept it as-is or\n      override it. Omit the section entirely once there are no open\n      questions. If `<%= it.vars.todoFile %>` already carries\n      `## Open Questions` entries from a previous lap, fold any\n      `Answer: <text>` line into the plan; every remaining entry's body must\n      still start with either `Suggested default: ...` or `Answer: ...` —\n      never anything else.\n\n      Leave `<%= it.vars.todoFile %>` uncommitted and finish your turn — do\n      not commit, and do not run `gtd step agent` yourself; the harness does\n      that.\n    on:\n      \"* **\": grilling-answer\n\n  grilling-answer:\n    actor: human\n    file: <%= it.vars.todoFile %>\n    mode: qa\n    message: |\n      `<%= it.vars.todoFile %>` holds the plan under development, with any\n      open questions under `## Open Questions` — each carrying a suggested\n      default. Answer a question by editing its entry in place: replace its\n      `Suggested default: ...` line with `Answer: ...`, or add further detail.\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"C\":\n        to: building\n        describe: >-\n          Change nothing to accept every suggested default as-is and move on to\n          implementation (**building**).\n      \"* **\":\n        to: grilling\n        describe: >-\n          Edit the plan — answer a question, add detail, or raise a new one — to\n          send it back for another round of grilling (**grilling**).\n\n  building:\n    actor: agent\n    file: <%= it.vars.todoFile %>\n    mode: qa\n    # A distinct memory scope from `plan`: implementation starts fresh, with\n    # the plan already settled in `.gtd/TODO.md` (which this prompt reads\n    # below) rather than carried in the planner's working memory.\n    memory: build\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create or edit anything under `.gtd/` except deleting\n      `<%= it.vars.todoFile %>`, which this prompt tells you to delete once\n      its work is complete.\n\n      The plan to implement is: <%~ it.read(it.vars.todoFile) %>\n\n      Read that plan and implement it in full. Use TDD discipline: one test,\n      then the implementation that passes it, then the next — never write\n      all the tests first.\n\n      Delete `<%= it.vars.todoFile %>` once the work it describes is complete\n      and verified. Leave everything else uncommitted and finish your turn.\n    on:\n      \"* **\": checking\n\n  checking:\n    actor: check\n    script: |\n      #!/usr/bin/env bash\n      # gtd check turn — the loop driver executes this verbatim, then\n      # steps the check actor. Mechanics only: run the test suite and record a\n      # red run's output as .gtd/FEEDBACK.md. What that output MEANS (another\n      # fix round vs escalation) is decided by the workflow's own `on`/`retry`\n      # rules at capture time — never here.\n      #\n      # `it.vars.testCommand` defaults to \"npm test\" (this workflow's own\n      # `vars:` above) — override it with a top-level `.gtdrc`\n      # `vars: { testCommand: ... }` key, or a `GTD_VAR_testCommand`\n      # environment variable (highest precedence).\n      #\n      # A green run also removes any `<%= it.vars.feedbackFile %>` left over\n      # from an earlier red run — there is no squash to discard it for us\n      # anymore, so the script cleans it up itself before moving on to\n      # review.\n      set +e\n      mkdir -p .gtd\n      <%~ it.vars.testCommand %> > .gtd/.check-output 2>&1\n      code=$?\n      if [ \"$code\" -ne 0 ]; then\n        if [ -s .gtd/.check-output ]; then\n          mv .gtd/.check-output <%~ it.vars.feedbackFile %>\n        else\n          rm -f .gtd/.check-output\n          printf 'npm test failed with exit code %s and produced no output.' \"$code\" > <%~ it.vars.feedbackFile %>\n        fi\n      else\n        rm -f .gtd/.check-output\n        rm -f <%~ it.vars.feedbackFile %>\n      fi\n    on:\n      \"A .gtd/FEEDBACK.md\": fixing\n      \"M .gtd/FEEDBACK.md\": fixing\n      \"D .gtd/FEEDBACK.md\": reviewing\n      \"C\": reviewing\n\n  fixing:\n    actor: agent\n    file: <%= it.vars.feedbackFile %>\n    # Its own memory scope: the fix loop re-enters `fixing` around `checking`\n    # (up to the retry cap), so labelling every attempt `fix` lets the agent\n    # remember what it already tried across the loop; a green check moves on\n    # to the differently-labelled `reviewing`, clearing it.\n    memory: fix\n    retry:\n      max: 3\n      otherwise: escalate\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.feedbackFile %>`, which this prompt tells you to address.\n\n      Read `<%= it.vars.feedbackFile %>` (the failing test output) and fix\n      the code so the suite passes. Keep the change focused — do not\n      refactor unrelated code. If the feedback is wrong, empty or delete\n      `<%= it.vars.feedbackFile %>` instead of \"fixing\" a non-issue; the\n      machine picks the dispute up either way.\n\n      Leave everything uncommitted and finish your turn — do not commit.\n    on:\n      \"* **\": checking\n\n  escalate:\n    actor: human\n    file: <%= it.vars.feedbackFile %>\n    message: |\n      The agent could not get the check to pass after repeated attempts.\n      `<%= it.vars.feedbackFile %>` holds the last failing output.\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"* **\":\n        to: checking\n        describe: >-\n          Fix the failure yourself — edit the code and/or `.gtd/FEEDBACK.md` —\n          to re-run the check (**checking**).\n\n  reviewing:\n    actor: agent\n    file: <%= it.vars.reviewFile %>\n    mode: review\n    model: smart\n    # A distinct memory scope again: the reviewer looks at the cycle's full\n    # diff (inlined into its prompt) with a fresh perspective, not the\n    # builder's or fixer's working memory.\n    memory: review\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.reviewFile %>`, which this prompt tells you to write.\n\n      Write `<%= it.vars.reviewFile %>` to help a human review the cycle's\n      full diff (inlined below) in this EXACT format:\n\n      - First non-blank line: `# Review: <%= it.currentCommit.slice(0, 7) %>`\n      - Somewhere in the document: `<!-- base: <%= it.startCommit %> -->`\n      - At least one `## <Chunk Title>` heading, grouping hunks semantically\n        (same feature/refactor/fix, even across files) — a short explanation\n        of what changed and why, then one\n        `- [ ] ./path/to/file.ts#42 — note` file pointer per hunk (checkboxes\n        are for the human to tick, not you; every path is `./`-relative, with\n        an optional `#line` and an optional ` — note`).\n\n      Leave `<%= it.vars.reviewFile %>` uncommitted and finish your turn.\n      <% if (it.processDiff.trim()) { %>\n\n      ## Full cycle diff\n\n      ```diff\n      <%~ it.processDiff %>\n      ```\n      <% } %>\n    on:\n      \"* **\": await-review\n\n  await-review:\n    actor: human\n    file: <%= it.vars.reviewFile %>\n    mode: review\n    # While the cycle rests here for human review, gtd opens a \"review checkout\n    # window\": HEAD and the index are temporarily rewound to this cycle's start\n    # (the process boundary — no `reviewBase` state is declared, so the base\n    # defaults to it) with the working tree untouched, so the whole cycle diff\n    # surfaces as ordinary uncommitted changes in the editor's git integration.\n    # The window closes automatically on the next invocation, once the cycle\n    # rests anywhere else (see src/ReviewWindow.ts, STATES.md §11).\n    reviewWindow: true\n    message: |\n      `<%= it.vars.reviewFile %>` holds the review record for the completed\n      cycle — one `- [ ]` checkbox per reviewable item, grouped into chunks.\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"D .gtd/REVIEW.md\":\n        to: idle\n        describe: >-\n          Delete `.gtd/REVIEW.md` outright to approve the whole cycle at once\n          and rest back at the start (**idle**).\n      \"M .gtd/REVIEW.md\":\n        to: review-deciding\n        describe: >-\n          Edit `.gtd/REVIEW.md` — tick a `- [ ]` box to `- [x]` to approve that\n          item, or add notes — to hand it to a deterministic check\n          (**review-deciding**) that closes the cycle out when every box is\n          ticked, or extracts the still-unticked items into a fresh\n          `.gtd/TODO.md` and loops back through **grilling** with that feedback.\n      \"* **\":\n        to: grilling\n        describe: >-\n          Change only code, leaving `.gtd/REVIEW.md` untouched, to send that as\n          feedback straight back to **grilling**.\n\n  review-deciding:\n    actor: check\n    file: <%= it.vars.reviewFile %>\n    mode: review\n    script: |\n      #!/usr/bin/env bash\n      # gtd check turn — the loop driver executes this verbatim, then\n      # steps the check actor. Mechanics only: if .gtd/REVIEW.md still has any\n      # unticked \"- [ ]\" pointer, extract those pointers (with their notes)\n      # into a fresh .gtd/TODO.md; either way, remove .gtd/REVIEW.md. What\n      # the resulting diff MEANS (feedback lap vs. full approval) is decided\n      # by this state's own `on` rules at capture time — never here. The\n      # A/M .gtd/TODO.md row is declared BEFORE the D .gtd/REVIEW.md row (see\n      # this workflow's `on` map below) so a feedback lap — which always also\n      # deletes .gtd/REVIEW.md — is captured as feedback, not mistaken for an\n      # approval.\n      set +e\n      mkdir -p .gtd\n      if grep -qE '^[[:space:]]*-[[:space:]]*\\[[[:space:]]*\\]' <%~ it.vars.reviewFile %> 2>/dev/null; then\n        {\n          echo \"Feedback from review — address these before continuing:\"\n          echo\n          grep -E '^[[:space:]]*-[[:space:]]*\\[[[:space:]]*\\]' <%~ it.vars.reviewFile %>\n        } > <%~ it.vars.todoFile %>\n      fi\n      rm -f <%~ it.vars.reviewFile %>\n    on:\n      \"A .gtd/TODO.md\": grilling\n      \"M .gtd/TODO.md\": grilling\n      \"D .gtd/REVIEW.md\": idle\n      \"C\": await-review\n"), ".");
-const defaultWorkflowDefinition = compiled.definition;
-/** The default workflow's own declared `vars:` defaults — `{ testCommand: "npm test" }`, overridable via a top-level `.gtdrc` `vars:` key or a `GTD_VAR_testCommand` environment variable (see `src/Edge.ts`'s `resolveVars`). */
-const defaultWorkflowVars = compiled.vars;
-//#endregion
 //#region src/Cwd.ts
 var Cwd = class Cwd extends Tag("Cwd")() {
 	static layer = (root) => succeed$2(Cwd, { root });
@@ -190070,10 +190069,11 @@ var Cwd = class Cwd extends Tag("Cwd")() {
 * Kept in its own module, separate from `./Config.js`, so `scripts/generate-
 * schema.ts` (run via `jiti`, a plain TS-via-Babel loader with no bundler-
 * style pluggable per-extension loaders) can import JUST the schema without
-* pulling in `./Config.js`'s chain to `./workflows/default.js` — which
-* imports `default.yaml` as raw text via tsdown's/vitest's `.yaml`-as-text
-* loader, something `jiti` has no equivalent for and doesn't need here: the
-* schema shape never depends on the bundled default workflow's content.
+* risking a transitive pull into the bundled workflow templates
+* (`./workflows/templates.js`, which imports `simple.yaml`/`advanced.yaml` as
+* raw text via tsdown's/vitest's `.yaml`-as-text loader — something `jiti` has
+* no equivalent for and doesn't need here): the schema shape never depends on
+* any workflow's content.
 */
 /** The `vars:` shape (top-level AND inside `workflow:`): a flat name -> scalar map (`compileVarsMap` coerces every scalar to a string). */
 const varsJsonSchema = {
@@ -190210,6 +190210,10 @@ const workflowJsonSchema = {
 					reviewBase: {
 						type: "boolean",
 						description: "Marks the state whose most-recent in-process commit anchors the review window's diff base; absent any, the base is the process start. Forbidden on a commit state."
+					},
+					reviewEntry: {
+						type: "boolean",
+						description: "Marks the (at most one) state `gtd review <commitish>` enters to start a brand new process reviewing <commitish>..HEAD. Forbidden on a commit state and on the initial state."
 					}
 				}
 			}
@@ -190317,11 +190321,11 @@ const loadMerged = (root) => tryPromise({
 	},
 	catch: (e) => e instanceof Error ? e : new Error(String(e))
 });
-const SCHEMA_STUB = `${JSON.stringify({ $schema: "https://raw.githubusercontent.com/pmelab/gtd/main/schema.json" }, null, 2)}\n`;
 /**
 * Reuses the same `walkUp` + `searchStrategy: "none"` cosmiconfig explorer as
 * `loadMerged` to detect whether ANY level of the cwd→root walk carries a gtd
-* config. Returns `true` on the first non-empty `search(dir)` result.
+* config. Returns `true` on the first non-empty `search(dir)` result. Exported
+* so `gtd init` (src/program.ts) can refuse to overwrite an existing config.
 */
 const anyConfigPresent = (root) => tryPromise({
 	try: async () => {
@@ -190374,29 +190378,25 @@ const compileRcVars = (raw) => {
 	return vars;
 };
 /**
-* Compile the decoded config's `workflow:` key (or the bundled default, when
-* absent) plus its top-level `vars:`/`modes:` keys into `ConfigOperations`. `root` is
-* used as the workflow compiler's `configDir` — the directory a custom
-* workflow's `./`-relative content references resolve against. Throws (via
-* `compileWorkflowConfig`/`compileRcVars`) on any invalid custom
-* workflow/vars; the bundled default's workflow half never throws here (it
-* is pre-compiled and validated once at module load, see
-* `./workflows/default.ts`).
+* The error every config-reading command fails with when no `workflow:` key is
+* configured anywhere in the cwd→home chain. gtd ships no default workflow, so
+* there is nothing to fall back to — the user must scaffold one with
+* `gtd init`. Exported so the CLI layer and tests can assert on it verbatim.
+*/
+const NO_WORKFLOW_MESSAGE = "gtd: no workflow configured — run `gtd init <simple|advanced>` to create .gtdrc.json";
+/**
+* Compile the decoded config's `workflow:` key plus its top-level
+* `vars:`/`modes:` keys into `ConfigOperations`. `root` is used as the
+* workflow compiler's `configDir` — the directory a custom workflow's
+* `./`-relative content references resolve against. Throws `NO_WORKFLOW_MESSAGE`
+* when no `workflow:` key is present (there is no bundled default to fall back
+* to — see `gtd init`), or (via `compileWorkflowConfig`/`compileRcVars`) on any
+* invalid workflow/vars.
 */
 const toOperations = (decoded, root) => {
 	const rcVars = compileRcVars(decoded.vars);
 	const rcModes = compileRcModes(decoded.modes);
-	if (decoded.workflow === void 0) {
-		const modes = mergeModes(defaultWorkflowDefinition.modes, rcModes);
-		return {
-			workflow: modes !== void 0 ? {
-				...defaultWorkflowDefinition,
-				modes
-			} : defaultWorkflowDefinition,
-			workflowVars: defaultWorkflowVars,
-			rcVars
-		};
-	}
+	if (decoded.workflow === void 0) throw new Error(NO_WORKFLOW_MESSAGE);
 	const { definition, vars: workflowVars } = compileWorkflowConfig(decoded.workflow, root, rcModes);
 	return {
 		workflow: definition,
@@ -190407,43 +190407,17 @@ const toOperations = (decoded, root) => {
 const formatSchemaError = (e) => {
 	return `Invalid gtd config: ${ArrayFormatter.formatErrorSync(e).map((i) => (i.path.length > 0 ? i.path.join(".") + ": " : "") + i.message).join("; ")}`;
 };
-/**
-* Auto-init as an explicit capability, separate from config LOADING: the stub
-* write mutates the repository (a file write plus a commit or amend), so it
-* must only ever run for a state command that has already passed the
-* repo-root guard — never at layer-construction time, where it would fire for
-* `--version`/`--help`, `format`, bare/unknown commands, and root-guard
-* refusals alike (and from a subdirectory would drop the stub into the wrong
-* directory). `makeProgram` calls `ensure` right after the repo-root guard;
-* the in-memory test world provides `ConfigInit.Noop`.
-*/
-var ConfigInit = class ConfigInit extends Tag("ConfigInit")() {
-	static Noop = succeed$2(ConfigInit, { ensure: _void });
-	static Live = effect$1(ConfigInit, gen(function* () {
-		const { root } = yield* Cwd;
-		const executor = yield* CommandExecutor;
-		const fs = yield* FileSystem;
-		return { ensure: gen(function* () {
-			if (yield* anyConfigPresent(root)) return;
-			const git = (...args) => executor.exitCode(make$1("git", ...args).pipe(workingDirectory(root)));
-			const writeStub = fs.writeFileString(join(root, ".gtdrc.json"), SCHEMA_STUB).pipe(mapError$1((e) => e instanceof Error ? e : new Error(String(e))));
-			const headSubject = yield* make$1("git", "log", "-1", "--pretty=%s").pipe(workingDirectory(root), string).pipe(map$4((s) => s.trim())).pipe(catchAll(() => succeed$3(void 0)));
-			yield* writeStub;
-			yield* git("add", ".gtdrc.json");
-			if (headSubject !== void 0 && parseStateSubject(headSubject) !== void 0) yield* git("commit", "--amend", "--no-edit");
-			else yield* git("commit", "-m", "chore: add .gtdrc.json");
-		}).pipe(provideService(CommandExecutor, executor), mapError$1((e) => e instanceof Error ? e : new Error(String(e)))) };
-	}));
-};
 var ConfigService = class ConfigService extends Tag("ConfigService")() {
 	static Live = effect$1(ConfigService, gen(function* () {
 		const { root } = yield* Cwd;
-		const { $schema: _schema, ...cleaned } = yield* loadMerged(root);
-		const decoded = yield* decodeUnknown(ConfigSchema)(cleaned, { onExcessProperty: "error" }).pipe(mapError$1(formatSchemaError)).pipe(mapError$1((msg) => new Error(msg)));
-		return yield* try_({
-			try: () => toOperations(decoded, root),
-			catch: (e) => e instanceof Error ? e : new Error(String(e))
-		});
+		return { load: gen(function* () {
+			const { $schema: _schema, ...cleaned } = yield* loadMerged(root);
+			const decoded = yield* decodeUnknown(ConfigSchema)(cleaned, { onExcessProperty: "error" }).pipe(mapError$1(formatSchemaError)).pipe(mapError$1((msg) => new Error(msg)));
+			return yield* try_({
+				try: () => toOperations(decoded, root),
+				catch: (e) => e instanceof Error ? e : new Error(String(e))
+			});
+		}) };
 	}));
 };
 //#endregion
@@ -191401,6 +191375,49 @@ var WorktreeReader = class WorktreeReader extends Tag("WorktreeReader")() {
 	}));
 };
 //#endregion
+//#region src/workflows/advanced.yaml
+var advanced_default = "# The \"advanced\" gtd workflow template — written verbatim into `.gtdrc.json`\n# (nested under a `workflow:` key) by `gtd init advanced`. See\n# docs/examples/advanced-workflow.md for the full state-by-state walkthrough\n# and STATES.md §10 for how it relates to the \"simple\" template.\n#\n# This is the fuller machine: two-phase human-in-the-loop planning\n# (grilling ⇄ grilling-answer for the product plan, architecting ⇄\n# architecting-answer for the technical plan), task decomposition\n# (decompose → .gtd/tasks/), a deterministic per-task builder queue (picking →\n# building → checking/fixing), agent-prepared review (reviewing → await-review),\n# and a squash finale (squashing → done, a `commit:` state that collapses the\n# whole cycle into one commit whose message the agent authored in\n# .gtd/COMMIT_MSG.md).\n#\n# Every content string below is INLINE (no `./`-relative file references): the\n# bundled templates ship inside a single-file build (`dist/gtd.bundle.mjs`), so\n# their content must already be resolved at BUILD time rather than read from\n# disk at RUNTIME. `advanced.yaml` is imported as raw text (tsdown's `.yaml`\n# text loader / the vitest rawMd transform), so this module never touches the\n# filesystem.\n\nvars:\n  testCommand: npm test\n  todoFile: .gtd/TODO.md\n  architectureFile: .gtd/ARCHITECTURE.md\n  reviewFile: .gtd/REVIEW.md\n  feedbackFile: .gtd/FEEDBACK.md\n\nstates:\n  idle:\n    actor: human\n    initial: true\n    message: |\n      No active gtd cycle.\n\n      To start one: write `.gtd/TODO.md` with a short sketch of what you want\n      built — a few sentences is enough — then run `gtd step human`.\n    on:\n      \"* **\": grilling\n\n  grilling:\n    actor: agent\n    file: <%= it.vars.todoFile %>\n    mode: qa\n    # `model` is an opaque harness hint — gtd never interprets this string, it\n    # only passes it through to `gtd next --json`/`gtd status --json` so the\n    # driving loop can map it onto whatever models its agent harness\n    # provides. \"smart\" here just names the harness-chosen tier for the\n    # heavier planning/reviewing turns; states without a `model` use the\n    # harness's default.\n    model: smart\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state (plans, task specs, review records) — never create, edit, or\n      delete anything under `.gtd/` except `<%= it.vars.todoFile %>`, which\n      this prompt tells you to write.\n\n      `<%= it.vars.todoFile %>` holds the plan under development. Read it,\n      then develop it into a concrete, product-level plan in this one turn —\n      explore the codebase before asking anything, so every open question is\n      one the codebase genuinely cannot answer.\n\n      Scope: product and user-facing decisions only. Leave implementation\n      details (file/module structure, data models, tech-stack choices) for\n      the next phase (`.gtd/ARCHITECTURE.md`).\n\n      For every remaining open question, add it under a `## Open Questions`\n      heading, one `### <question>` sub-heading each, with a\n      `Suggested default: <answer>` line the human can accept as-is. Omit the\n      section entirely once there are none.\n\n      Leave `.gtd/TODO.md` uncommitted and finish your turn — do not commit,\n      and do not run `gtd step agent` yourself; the harness does that.\n    on:\n      \"* **\": grilling-answer\n\n  grilling-answer:\n    actor: human\n    file: <%= it.vars.todoFile %>\n    mode: qa\n    message: |\n      `<%= it.vars.todoFile %>` holds the plan under development, with any\n      open questions under `## Open Questions` — each carrying a suggested\n      default.\n\n      To answer a question, edit its entry in place (replace\n      `Suggested default: ...` with `Answer: ...`, or annotate further), then\n      run `gtd step human`.\n\n      To accept all suggested defaults as-is and move on to technical\n      architecting, run `gtd step human` with no edits.\n    on:\n      \"C\": architecting\n      \"* **\": grilling\n\n  architecting:\n    actor: agent\n    file: <%= it.vars.architectureFile %>\n    mode: qa\n    model: smart\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.architectureFile %>` and `<%= it.vars.todoFile %>`, which\n      this prompt tells you to write and delete respectively.\n\n      Read `<%= it.vars.todoFile %>` (the converged product plan) and\n      develop `<%= it.vars.architectureFile %>` from it in this one turn:\n      file/module structure, data models, library/tech-stack choices,\n      error-handling strategy — the *how*, building on the *what* already\n      settled. Do not re-open product-level decisions from\n      `<%= it.vars.todoFile %>`; treat them as settled.\n\n      For every remaining open question, add it under a `## Open Questions`\n      heading the same way as the grilling phase (one `### <question>`\n      sub-heading, a `Suggested default: <answer>` line). Omit the section\n      once there are none.\n\n      Once `<%= it.vars.architectureFile %>` is written, delete\n      `<%= it.vars.todoFile %>` — its content has been folded in and it must\n      not linger.\n\n      Leave everything uncommitted and finish your turn.\n    on:\n      \"* **\": architecting-answer\n\n  architecting-answer:\n    actor: human\n    file: <%= it.vars.architectureFile %>\n    mode: qa\n    message: |\n      `<%= it.vars.architectureFile %>` holds the technical plan under\n      development, with any open questions under `## Open Questions`.\n\n      To answer a question, edit its entry in place, then run\n      `gtd step human`.\n\n      To accept all suggested defaults as-is and move on to decomposing the\n      work, run `gtd step human` with no edits.\n    on:\n      \"C\": decompose\n      \"* **\": architecting\n\n  decompose:\n    actor: agent\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except the\n      task-spec files this prompt tells you to write (under `.gtd/tasks/`),\n      and `.gtd/ARCHITECTURE.md`, which it tells you to delete.\n\n      Read `.gtd/ARCHITECTURE.md` (the converged technical plan) and\n      decompose it into an ordered set of self-contained task files under\n      `.gtd/tasks/` (e.g. `.gtd/tasks/01-short-name.md`,\n      `.gtd/tasks/02-short-name.md`, ...). Order them so the test suite can\n      pass again after each one lands; each file is self-contained\n      (description, acceptance criteria as `- [ ]` checkboxes, relevant\n      paths) since a building turn receives only that one file as context.\n\n      No task file may reference any other `.gtd/` file, or a requirement to\n      preserve/update workflow state — `.gtd/` is machine-managed and gets\n      cleaned up as the cycle proceeds.\n\n      Once the task files are written, delete `.gtd/ARCHITECTURE.md`. Leave\n      everything uncommitted and finish your turn.\n    on:\n      \"* .gtd/tasks/**\": picking\n\n  picking:\n    actor: check\n    script: |\n      #!/usr/bin/env bash\n      # gtd check turn (the queue arbiter) — the loop driver executes this\n      # verbatim, then steps the check actor. Mechanics only: take the\n      # first task file (by name) under .gtd/tasks/ into .gtd/NEXT.md, or\n      # remove .gtd/NEXT.md when the queue is empty. What NEXT.md's\n      # presence/absence MEANS (another task to build vs. the queue closing\n      # out to review) is decided by this state's own `on` rules at capture\n      # time — never here.\n      set +e\n      next=$(ls .gtd/tasks/*.md 2>/dev/null | head -n 1)\n      if [ -n \"$next\" ]; then\n        printf '%s' \"$next\" > .gtd/NEXT.md\n      else\n        rm -f .gtd/NEXT.md\n      fi\n    on:\n      \"D .gtd/NEXT.md\": reviewing\n      \"* .gtd/NEXT.md\": building\n      \"C\": reviewing\n\n  building:\n    actor: agent\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create or edit anything under `.gtd/` except deleting the\n      one task file this prompt tells you to delete; never touch\n      `.gtd/NEXT.md` yourself — the `picking` state owns it.\n\n      The task file to implement is: <%~ it.read(\".gtd/NEXT.md\") %>\n\n      Read that file and implement EXACTLY the one task it describes — no\n      more, no less; leave every other task file under `.gtd/tasks/`\n      untouched. Use TDD discipline: one test, then the implementation that\n      passes it, then the next — never write all the tests first.\n\n      Delete the task file once its work is complete and verified. Leave\n      everything else uncommitted and finish your turn.\n    on:\n      \"* **\": checking\n\n  checking:\n    actor: check\n    script: |\n      #!/usr/bin/env bash\n      # gtd check turn — the loop driver executes this verbatim, then steps\n      # the check actor. Mechanics only: run the test suite and record a\n      # red run's output as .gtd/FEEDBACK.md. What that output MEANS (another\n      # fix round vs escalation) is decided by the workflow's own `on`/`retry`\n      # rules at capture time — never here.\n      #\n      # `it.vars.testCommand` defaults to \"npm test\" (this workflow's own\n      # `vars:` above) — override it with a top-level `.gtdrc`\n      # `vars: { testCommand: ... }` key, or a `GTD_VAR_testCommand`\n      # environment variable (highest precedence).\n      set +e\n      mkdir -p .gtd\n      <%~ it.vars.testCommand %> > .gtd/.check-output 2>&1\n      code=$?\n      if [ \"$code\" -ne 0 ]; then\n        if [ -s .gtd/.check-output ]; then\n          mv .gtd/.check-output .gtd/FEEDBACK.md\n        else\n          rm -f .gtd/.check-output\n          printf 'npm test failed with exit code %s and produced no output.' \"$code\" > .gtd/FEEDBACK.md\n        fi\n      else\n        rm -f .gtd/.check-output\n      fi\n    on:\n      \"A .gtd/FEEDBACK.md\": fixing\n      \"M .gtd/FEEDBACK.md\": fixing\n      \"C\": picking\n\n  fixing:\n    actor: agent\n    file: <%= it.vars.feedbackFile %>\n    retry:\n      max: 3\n      otherwise: escalate\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.feedbackFile %>`, which this prompt tells you to address.\n\n      Read `<%= it.vars.feedbackFile %>` (the failing test output) and fix\n      the code so the suite passes. Keep the change focused — do not\n      refactor unrelated code. If the feedback is wrong, empty or delete\n      `<%= it.vars.feedbackFile %>` instead of \"fixing\" a non-issue; the\n      machine picks the dispute up either way.\n\n      Leave everything uncommitted and finish your turn — do not commit.\n    on:\n      \"* **\": checking\n\n  escalate:\n    actor: human\n    file: <%= it.vars.feedbackFile %>\n    message: |\n      The agent could not get the check to pass after repeated attempts.\n      `<%= it.vars.feedbackFile %>` holds the last failing output.\n\n      Investigate and fix it yourself (editing code and/or\n      `<%= it.vars.feedbackFile %>`), then run `gtd step human` to try the\n      check again.\n    on:\n      \"* **\": checking\n\n  reviewing:\n    actor: agent\n    file: <%= it.vars.reviewFile %>\n    mode: review\n    model: smart\n    # A direct entry point: `gtd review <commitish>` starts a fresh review\n    # process here over `<commitish>..HEAD` (e.g. a colleague's PR branch).\n    reviewEntry: true\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.reviewFile %>`, which this prompt tells you to write.\n\n      Write `<%= it.vars.reviewFile %>` to help a human review the cycle's\n      full diff (inlined below): group hunks semantically (same\n      feature/refactor/fix, even across files), and for each group write a\n      short heading, an explanation of what changed and why, and\n      `- [ ] ./path/to/file.ts#42` style file pointers (checkboxes are for\n      the human to tick, not you).\n\n      Leave `<%= it.vars.reviewFile %>` uncommitted and finish your turn.\n      <% if (it.processDiff.trim()) { %>\n\n      ## Full cycle diff\n\n      ```diff\n      <%~ it.processDiff %>\n      ```\n      <% } %>\n    on:\n      \"* .gtd/REVIEW.md\": await-review\n\n  await-review:\n    actor: human\n    file: <%= it.vars.reviewFile %>\n    mode: review\n    message: |\n      `<%= it.vars.reviewFile %>` holds the review record for the completed\n      cycle.\n\n      To approve: delete `<%= it.vars.reviewFile %>` and run\n      `gtd step human`.\n\n      To request changes: edit `<%= it.vars.reviewFile %>` (or the code)\n      with what's wrong — including just ticking its checkboxes — then run\n      `gtd step human`; this sends the cycle back through grilling with your\n      feedback as the new input.\n    on:\n      \"D .gtd/REVIEW.md\": squashing\n      \"* **\": grilling\n\n  squashing:\n    actor: agent\n    prompt: |\n      You are an autonomous coding agent. The cycle is approved and done.\n      `.gtd/` holds this workflow's own state — never create, edit, or delete\n      anything under `.gtd/` except `.gtd/COMMIT_MSG.md`, which this prompt\n      tells you to write.\n\n      Write `.gtd/COMMIT_MSG.md` with ONE conventional-commits message for\n      the entire cycle (subject line `type(scope): subject`, imperative mood,\n      <= 72 characters; a body explaining the why, trade-offs, and key\n      decisions). Plain text, no markdown wrapper.\n\n      Leave `.gtd/COMMIT_MSG.md` uncommitted and finish your turn — entering\n      this file squashes the whole cycle into one commit using its content as\n      the message.\n      <% if (it.processDiff.trim()) { %>\n\n      ## Full cycle diff\n\n      ```diff\n      <%~ it.processDiff %>\n      ```\n      <% } %>\n    on:\n      \"A .gtd/COMMIT_MSG.md\": done\n      \"M .gtd/COMMIT_MSG.md\": done\n\n  done:\n    commit: |\n      <%~ it.read(\".gtd/COMMIT_MSG.md\") %>\n\n      Token cost: <%= it.processCost %>\n      <% it.processCostByModel.forEach(function(m){ %>\n      - <%= m.model %>: <%= m.cost %>\n      <% }) %>\n";
+//#endregion
+//#region src/workflows/simple.yaml
+var simple_default = "# The \"simple\" gtd workflow template — written verbatim into `.gtdrc.json`\n# (nested under a `workflow:` key) by `gtd init simple`. gtd ships no default\n# workflow: a repo picks one of the bundled templates with `gtd init`, and a\n# state command run with no workflow configured fails (see src/Config.ts).\n# See STATES.md §10 for the walkthrough and docs/examples/advanced-workflow.md\n# for the fuller `advanced` template.\n#\n# Compiled through the exact same `compileWorkflowConfig` a user's `.gtdrc`\n# `workflow:` key goes through — no privileged code path\n# (src/workflows/templates.ts does the compiling).\n#\n# Every content string below is INLINE (no `./`-relative file references):\n# the bundled templates ship inside a single-file build\n# (`dist/gtd.bundle.mjs`), so their content must already be resolved at BUILD\n# time rather than read from disk at RUNTIME — the same reason\n# `src/prompts/*.md` are imported through tsdown's `.md`-as-text loader\n# instead of read via `fs` at runtime. `simple.yaml` itself is imported the\n# same way (tsdown/vitest both treat `.yaml` as text — see\n# tsdown.config.ts / tests/vitest.rawMd.ts), so this file never needs a\n# sibling prompts/ directory to exist on disk once installed.\n#\n# States, in cycle order — 10 states, no squash:\n#   idle (initial, human, message)\n#     -> grilling (agent, prompt): reads .gtd/TODO.md's sketch (or a prior\n#     lap's feedback), explores the codebase, and develops it into a concrete\n#     implementation plan, stating any open question it can't settle itself\n#     under a `## Open Questions` heading rather than guessing silently. Its\n#     `file:`/`mode:` (TODO.md/`qa`) makes the plan's format checkable — it\n#     self-validates before finishing (see \"Steering-file validation\" below).\n#   grilling -> grilling-answer (human, message): tick off suggested\n#     defaults by replacing them with `Answer:` lines; a clean step accepts\n#     every remaining default -> building; any edit loops back to grilling.\n#   grilling-answer -> building (agent, prompt): implements the plan in\n#     .gtd/TODO.md directly (no task decomposition, no per-task queue) and\n#     deletes .gtd/TODO.md once the work is complete and verified.\n#   building -> checking (check, script): runs the test command inline;\n#     A/M .gtd/FEEDBACK.md -> fixing (capped, redirects to escalate); D\n#     .gtd/FEEDBACK.md (a green run that just cleaned up prior feedback) or C\n#     (green, nothing to clean) -> reviewing.\n#   fixing (agent, prompt) <-> checking\n#   escalate (human, message): manual intervention, then back to checking\n#   checking (green) -> reviewing (agent, prompt): writes .gtd/REVIEW.md in\n#     the checkbox review format, grouping the cycle's full diff into\n#     reviewable chunks; its `file:`/`mode:` (REVIEW.md/`review`) makes that\n#     format checkable, so it self-validates before finishing. `reviewing`\n#     ALSO declares `reviewEntry: true` — a second way in: `gtd review\n#     <commitish>` (a clean tree resting at idle) writes an empty\n#     `gtd(human): reviewing` entry commit carrying <commitish>'s hash as a\n#     `Gtd-Review-Base:` trailer, starting a brand new process that reviews\n#     <commitish>..HEAD (e.g. a colleague's PR branch) through this exact same\n#     reviewing/await-review/feedback-lap machinery.\n#   reviewing -> await-review (human, message): tick a pointer's `- [\n#     ]` to `- [x]` to approve that item; deleting .gtd/REVIEW.md outright is\n#     the power-user approve-everything shortcut; anything else pending\n#     (code edits with REVIEW.md untouched) is feedback straight to grilling.\n#   await-review -> review-deciding (check, script), entered by any `M\n#     .gtd/REVIEW.md` step: if no unticked `- [ ]` pointer remains, the cycle\n#     is approved (rm .gtd/REVIEW.md -> idle); otherwise the still-unticked\n#     pointers (with their notes) are extracted into a fresh .gtd/TODO.md and\n#     .gtd/REVIEW.md is removed (-> grilling, feedback lap).\n#\n# The cycle ends at human approval, resting back at idle — there is no\n# squash state. The cycle's commits stay in history; whether/how to squash\n# them (amend, interactive rebase, a PR's squash-merge) is entirely the\n# human's business once they're done reviewing — gtd makes no assumption.\n# That squash-flavored finale (a `squashing` prompt state + a `done` commit\n# state) still exists as an ENGINE capability (see STATES.md §8) and is kept\n# as part of the fuller machine at docs/examples/advanced-workflow.md.\n#\n# A `gtd(<actor>): idle` commit — entering the workflow's own initial state —\n# is therefore a PROCESS BOUNDARY (see `computeProcessRun` in src/Edge.ts):\n# the next cycle's `retry` counts, `startCommit`, and diffs never reach back\n# across an approved cycle's own idle-entering commit.\n#\n# HYGIENE INVARIANT (asserted in e2e — see default-workflow.feature): an\n# approved cycle leaves `.gtd/` empty. FEEDBACK.md is cleaned up by a green\n# `checking` run; REVIEW.md by the review-deciding approval branch; TODO.md by\n# `building`.\n#\n# Steering-file validation. `grilling` and `reviewing` each declare a\n# `file:`/`mode:` pair (TODO.md as `qa`, REVIEW.md as `review`), so their\n# output has a checkable format. src/OpenQuestions.ts and src/ReviewDoc.ts are\n# those two formats' EXECUTABLE SPECS (their unit tests are the format spec\n# tests), and `gtd validate` FORMATS the resolved state's rendered `file:` in\n# place then runs the SAME parser over it, exiting non-zero with findings when\n# it violates the format. There is no in-machine validation state and no bash\n# port to keep in sync — the producing agent self-validates before finishing\n# (plain `gtd next` appends the \"run `gtd validate` and fix all violations\"\n# instruction; under `--json` the driving loop runs it after the turn and\n# re-prompts on findings — see skills/loop/SKILL.md), AND `gtd step` runs the\n# same format-and-validate gate on capture, refusing a turn whose steering file\n# is invalid. So the check runs after a human edits too — at the human gates\n# `grilling-answer` (TODO.md) and `await-review` (REVIEW.md) — and a human gate\n# is only ever handed a tidy, well-formed file. The same parsers back the LSP's\n# live diagnostics (src/Lsp.ts).\n#\n# `grilling` and `reviewing` both declare `model: smart` — an opaque harness\n# hint (see the comment at `grilling` below) for their heavier one-shot\n# planning/reviewing turns. Every other state is unset (harness default).\n#\n# The four agent states each declare a `memory:` scope label (`plan`,\n# `build`, `fix`, `review` — see the comment at `grilling` below) — another\n# opaque hint a memory-aware driver reads to decide when an agent turn keeps\n# the previous turn's memory and when it starts fresh: a loop that re-enters\n# one state (grilling around its answer loop, fixing around checking) keeps\n# the same label and retains memory across its laps; crossing to the next\n# phase's differently-labelled state clears it. gtd never interprets the\n# label (see STATES.md §1 and skills/loop/SKILL.md's driver contract).\n#\n# `vars.testCommand` is this workflow's own declared default for `checking`'s\n# script (see it.vars in PatternTemplates.ts) — override it per-repo with a\n# top-level `.gtdrc` `vars: { testCommand: ... }` key, or per-invocation with\n# a `GTD_VAR_testCommand` environment variable (highest precedence).\n#\n# `vars.todoFile`/`reviewFile`/`feedbackFile` are this workflow's ONE source\n# of truth for the three steering-file paths every prompt/script below reads\n# or writes — each appears in templates as `<%~ it.vars.todoFile %>` etc\n# (see docs/design/state-file-association.md §2). Every state that rests on\n# one of these files also declares a `file:`/`mode:` pair (see STATES.md's\n# property table) so `gtd status`/`gtd next --json` and the LSP (`gtd lsp`)\n# know which file a human/editor should look at, and in what format\n# (`qa` for TODO.md's open-questions format, `review` for REVIEW.md's\n# checkbox format) — `fixing`/`escalate` declare `file:` alone (FEEDBACK.md\n# is plain text, no LSP format). KNOWN LIMITATION: `on` pattern keys below are\n# NOT Eta templates — they keep the LITERAL `.gtd/...` paths matching these\n# vars' DEFAULT values. Repointing `todoFile`/`reviewFile`/`feedbackFile` via\n# `.gtdrc`'s top-level `vars:` or a `GTD_VAR_` override changes what `file:`\n# renders to (and what a template reads/writes) WITHOUT changing what the\n# `on` patterns match against — desyncing the machine. See\n# docs/configuration.md's `file:`/`mode:` section for the full caveat.\n#\n# A fuller machine — two-phase Q&A planning, an architecture phase, task\n# decomposition, a deterministic per-task builder loop, agent-prepared\n# review, and the squash finale (`squashing` + `done`) — is preserved as a\n# copy-paste `.gtdrc` example at docs/examples/advanced-workflow.md.\n\nvars:\n  testCommand: npm test\n  todoFile: .gtd/TODO.md\n  reviewFile: .gtd/REVIEW.md\n  feedbackFile: .gtd/FEEDBACK.md\n\nstates:\n  idle:\n    actor: human\n    initial: true\n    # Every human-gate `message:` below closes with the SAME rendered block —\n    # a \"What each change does next\" list built from `it.edges`, the resting\n    # state's own `on` edges (see PatternTemplates.TemplateContext.edges). Each\n    # edge's human-readable route lives in its `describe:` (the single source\n    # of truth), so the list can never drift from the routing it documents.\n    # The block skips edges without a `describe`, and each `<%~ ... \"\\n\" %>`\n    # keeps the bullet's own newline (Eta's autoTrim strips the template's own\n    # line breaks around `<% %>` tags, not text inside an interpolation).\n    message: |\n      No active gtd cycle.\n\n      To start one, write `.gtd/TODO.md` with a short sketch of what you want\n      built — a few sentences is enough.\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"* **\":\n        to: grilling\n        describe: >-\n          Save your sketch to `.gtd/TODO.md` (any working-tree change) to start\n          the cycle — the agent reads it, explores the codebase, and develops it\n          into a concrete implementation plan (**grilling**).\n\n  grilling:\n    actor: agent\n    file: <%= it.vars.todoFile %>\n    mode: qa\n    # `model` is an opaque harness hint — gtd never interprets this string, it\n    # only passes it through to `gtd next --json`/`gtd status --json` so the\n    # driving loop can map it onto whatever models its agent harness\n    # provides. \"smart\" here just names the harness-chosen tier for the\n    # heavier planning turn; states without a `model` use the harness's\n    # default.\n    model: smart\n    # `memory` is an opaque memory-scope label — gtd never interprets it, it\n    # only passes it through to `gtd next --json`/`gtd status --json` so a\n    # memory-aware driving loop can decide when an agent turn continues from\n    # the previous turn's memory and when it starts fresh: consecutive agent\n    # turns that emit the SAME label share memory, a change (or the first\n    # turn) is where the driver starts fresh. `grilling` re-enters itself\n    # around the grilling-answer loop, so labelling every lap\n    # `plan` keeps the planner's accumulated exploration across the loop; the\n    # next phase (`building`) carries a different label, clearing it.\n    memory: plan\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.todoFile %>`, which this prompt tells you to develop.\n\n      `<%= it.vars.todoFile %>` holds a short sketch of what to build (or\n      feedback from a prior review lap). Read it, explore the codebase, and\n      develop it into a concrete implementation plan.\n\n      For every question you cannot settle yourself, add it under a\n      `## Open Questions` heading, one `### <question>` sub-heading each,\n      whose body's FIRST non-blank line is exactly\n      `Suggested default: <your answer>` — the human can accept it as-is or\n      override it. Omit the section entirely once there are no open\n      questions. If `<%= it.vars.todoFile %>` already carries\n      `## Open Questions` entries from a previous lap, fold any\n      `Answer: <text>` line into the plan; every remaining entry's body must\n      still start with either `Suggested default: ...` or `Answer: ...` —\n      never anything else.\n\n      Leave `<%= it.vars.todoFile %>` uncommitted and finish your turn — do\n      not commit, and do not run `gtd step agent` yourself; the harness does\n      that.\n    on:\n      \"* **\": grilling-answer\n\n  grilling-answer:\n    actor: human\n    file: <%= it.vars.todoFile %>\n    mode: qa\n    message: |\n      `<%= it.vars.todoFile %>` holds the plan under development, with any\n      open questions under `## Open Questions` — each carrying a suggested\n      default. Answer a question by editing its entry in place: replace its\n      `Suggested default: ...` line with `Answer: ...`, or add further detail.\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"C\":\n        to: building\n        describe: >-\n          Change nothing to accept every suggested default as-is and move on to\n          implementation (**building**).\n      \"* **\":\n        to: grilling\n        describe: >-\n          Edit the plan — answer a question, add detail, or raise a new one — to\n          send it back for another round of grilling (**grilling**).\n\n  building:\n    actor: agent\n    file: <%= it.vars.todoFile %>\n    mode: qa\n    # A distinct memory scope from `plan`: implementation starts fresh, with\n    # the plan already settled in `.gtd/TODO.md` (which this prompt reads\n    # below) rather than carried in the planner's working memory.\n    memory: build\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create or edit anything under `.gtd/` except deleting\n      `<%= it.vars.todoFile %>`, which this prompt tells you to delete once\n      its work is complete.\n\n      The plan to implement is: <%~ it.read(it.vars.todoFile) %>\n\n      Read that plan and implement it in full. Use TDD discipline: one test,\n      then the implementation that passes it, then the next — never write\n      all the tests first.\n\n      Delete `<%= it.vars.todoFile %>` once the work it describes is complete\n      and verified. Leave everything else uncommitted and finish your turn.\n    on:\n      \"* **\": checking\n\n  checking:\n    actor: check\n    script: |\n      #!/usr/bin/env bash\n      # gtd check turn — the loop driver executes this verbatim, then\n      # steps the check actor. Mechanics only: run the test suite and record a\n      # red run's output as .gtd/FEEDBACK.md. What that output MEANS (another\n      # fix round vs escalation) is decided by the workflow's own `on`/`retry`\n      # rules at capture time — never here.\n      #\n      # `it.vars.testCommand` defaults to \"npm test\" (this workflow's own\n      # `vars:` above) — override it with a top-level `.gtdrc`\n      # `vars: { testCommand: ... }` key, or a `GTD_VAR_testCommand`\n      # environment variable (highest precedence).\n      #\n      # A green run also removes any `<%= it.vars.feedbackFile %>` left over\n      # from an earlier red run — there is no squash to discard it for us\n      # anymore, so the script cleans it up itself before moving on to\n      # review.\n      set +e\n      mkdir -p .gtd\n      <%~ it.vars.testCommand %> > .gtd/.check-output 2>&1\n      code=$?\n      if [ \"$code\" -ne 0 ]; then\n        if [ -s .gtd/.check-output ]; then\n          mv .gtd/.check-output <%~ it.vars.feedbackFile %>\n        else\n          rm -f .gtd/.check-output\n          printf 'npm test failed with exit code %s and produced no output.' \"$code\" > <%~ it.vars.feedbackFile %>\n        fi\n      else\n        rm -f .gtd/.check-output\n        rm -f <%~ it.vars.feedbackFile %>\n      fi\n    on:\n      \"A .gtd/FEEDBACK.md\": fixing\n      \"M .gtd/FEEDBACK.md\": fixing\n      \"D .gtd/FEEDBACK.md\": reviewing\n      \"C\": reviewing\n\n  fixing:\n    actor: agent\n    file: <%= it.vars.feedbackFile %>\n    # Its own memory scope: the fix loop re-enters `fixing` around `checking`\n    # (up to the retry cap), so labelling every attempt `fix` lets the agent\n    # remember what it already tried across the loop; a green check moves on\n    # to the differently-labelled `reviewing`, clearing it.\n    memory: fix\n    retry:\n      max: 3\n      otherwise: escalate\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.feedbackFile %>`, which this prompt tells you to address.\n\n      Read `<%= it.vars.feedbackFile %>` (the failing test output) and fix\n      the code so the suite passes. Keep the change focused — do not\n      refactor unrelated code. If the feedback is wrong, empty or delete\n      `<%= it.vars.feedbackFile %>` instead of \"fixing\" a non-issue; the\n      machine picks the dispute up either way.\n\n      Leave everything uncommitted and finish your turn — do not commit.\n    on:\n      \"* **\": checking\n\n  escalate:\n    actor: human\n    file: <%= it.vars.feedbackFile %>\n    message: |\n      The agent could not get the check to pass after repeated attempts.\n      `<%= it.vars.feedbackFile %>` holds the last failing output.\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"* **\":\n        to: checking\n        describe: >-\n          Fix the failure yourself — edit the code and/or `.gtd/FEEDBACK.md` —\n          to re-run the check (**checking**).\n\n  reviewing:\n    actor: agent\n    file: <%= it.vars.reviewFile %>\n    mode: review\n    model: smart\n    # A distinct memory scope again: the reviewer looks at the cycle's full\n    # diff (inlined into its prompt) with a fresh perspective, not the\n    # builder's or fixer's working memory.\n    memory: review\n    # `gtd review <commitish>` (a plain non-gtd branch, e.g. a colleague's PR)\n    # enters here directly, recording the resolved base as a `Gtd-Review-Base:`\n    # trailer on its empty entry commit — everything below then reuses the\n    # existing reviewing/await-review/feedback-lap machinery unmodified over\n    # <commitish>..HEAD (see STATES.md §11).\n    reviewEntry: true\n    prompt: |\n      You are an autonomous coding agent. `.gtd/` holds this workflow's own\n      state — never create, edit, or delete anything under `.gtd/` except\n      `<%= it.vars.reviewFile %>`, which this prompt tells you to write.\n\n      Write `<%= it.vars.reviewFile %>` to help a human review the cycle's\n      full diff (inlined below) in this EXACT format:\n\n      - First non-blank line: `# Review: <%= it.currentCommit.slice(0, 7) %>`\n      - Somewhere in the document: `<!-- base: <%= it.startCommit %> -->`\n      - At least one `## <Chunk Title>` heading, grouping hunks semantically\n        (same feature/refactor/fix, even across files) — a short explanation\n        of what changed and why, then one\n        `- [ ] ./path/to/file.ts#42 — note` file pointer per hunk (checkboxes\n        are for the human to tick, not you; every path is `./`-relative, with\n        an optional `#line` and an optional ` — note`).\n\n      Leave `<%= it.vars.reviewFile %>` uncommitted and finish your turn.\n      <% if (it.processDiff.trim()) { %>\n\n      ## Full cycle diff\n\n      ```diff\n      <%~ it.processDiff %>\n      ```\n      <% } %>\n    on:\n      \"* **\": await-review\n\n  await-review:\n    actor: human\n    file: <%= it.vars.reviewFile %>\n    mode: review\n    # While the cycle rests here for human review, gtd opens a \"review checkout\n    # window\": HEAD and the index are temporarily rewound to this cycle's start\n    # (the process boundary — no `reviewBase` state is declared, so the base\n    # defaults to it) with the working tree untouched, so the whole cycle diff\n    # surfaces as ordinary uncommitted changes in the editor's git integration.\n    # The window closes automatically on the next invocation, once the cycle\n    # rests anywhere else (see src/ReviewWindow.ts, STATES.md §11).\n    reviewWindow: true\n    message: |\n      `<%= it.vars.reviewFile %>` holds the review record for the completed\n      cycle — one `- [ ]` checkbox per reviewable item, grouped into chunks.\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"D .gtd/REVIEW.md\":\n        to: idle\n        describe: >-\n          Delete `.gtd/REVIEW.md` outright to approve the whole cycle at once\n          and rest back at the start (**idle**).\n      \"M .gtd/REVIEW.md\":\n        to: review-deciding\n        describe: >-\n          Edit `.gtd/REVIEW.md` — tick a `- [ ]` box to `- [x]` to approve that\n          item, or add notes — to hand it to a deterministic check\n          (**review-deciding**) that closes the cycle out when every box is\n          ticked, or extracts the still-unticked items into a fresh\n          `.gtd/TODO.md` and loops back through **grilling** with that feedback.\n      \"* **\":\n        to: grilling\n        describe: >-\n          Change only code, leaving `.gtd/REVIEW.md` untouched, to send that as\n          feedback straight back to **grilling**.\n\n  review-deciding:\n    actor: check\n    file: <%= it.vars.reviewFile %>\n    mode: review\n    script: |\n      #!/usr/bin/env bash\n      # gtd check turn — the loop driver executes this verbatim, then\n      # steps the check actor. Mechanics only: if .gtd/REVIEW.md still has any\n      # unticked \"- [ ]\" pointer, extract those pointers (with their notes)\n      # into a fresh .gtd/TODO.md; either way, remove .gtd/REVIEW.md. What\n      # the resulting diff MEANS (feedback lap vs. full approval) is decided\n      # by this state's own `on` rules at capture time — never here. The\n      # A/M .gtd/TODO.md row is declared BEFORE the D .gtd/REVIEW.md row (see\n      # this workflow's `on` map below) so a feedback lap — which always also\n      # deletes .gtd/REVIEW.md — is captured as feedback, not mistaken for an\n      # approval.\n      set +e\n      mkdir -p .gtd\n      if grep -qE '^[[:space:]]*-[[:space:]]*\\[[[:space:]]*\\]' <%~ it.vars.reviewFile %> 2>/dev/null; then\n        {\n          echo \"Feedback from review — address these before continuing:\"\n          echo\n          grep -E '^[[:space:]]*-[[:space:]]*\\[[[:space:]]*\\]' <%~ it.vars.reviewFile %>\n        } > <%~ it.vars.todoFile %>\n      fi\n      rm -f <%~ it.vars.reviewFile %>\n    on:\n      \"A .gtd/TODO.md\": grilling\n      \"M .gtd/TODO.md\": grilling\n      \"D .gtd/REVIEW.md\": idle\n      \"C\": await-review\n";
+//#endregion
+//#region src/workflows/templates.ts
+/**
+* The `$schema` URL editors resolve for `.gtdrc.json` completion/validation —
+* written as the first key of every `gtd init` config (see `renderInitConfig`).
+*/
+const SCHEMA_URL = "https://raw.githubusercontent.com/pmelab/gtd/main/schema.json";
+/**
+* The bundled workflow templates `gtd init <name>` can scaffold, keyed by the
+* name the user passes. Each value is the raw YAML text of the template file,
+* imported as a string (tsdown's `.yaml` text loader / the vitest `rawMd`
+* transform — see tsdown.config.ts / tests/vitest.rawMd.ts), so this module
+* never touches the filesystem: it works identically in the dev checkout,
+* under `vitest`, and inside the single-file `dist/gtd.bundle.mjs` build.
+*/
+const WORKFLOW_TEMPLATES = {
+	simple: simple_default,
+	advanced: advanced_default
+};
+/** The template names as a plain array, for usage messages and validation. */
+const WORKFLOW_TEMPLATE_NAMES = Object.keys(WORKFLOW_TEMPLATES);
+const isWorkflowTemplateName = (name) => Object.prototype.hasOwnProperty.call(WORKFLOW_TEMPLATES, name);
+/**
+* Render the `.gtdrc.json` `gtd init <name>` writes: a `$schema` link (so
+* editors pick up completion/validation) plus the template's whole workflow
+* object nested under a `workflow:` key — exactly the shape a hand-authored
+* `.gtdrc` `workflow:` value takes (`{ vars, states }`). The template's
+* multi-line prompts/scripts become `\n`-escaped JSON strings; the config
+* loader parses them back identically to the YAML source.
+*/
+const renderInitConfig = (name) => {
+	const workflow = (0, import_dist$1.parse)(WORKFLOW_TEMPLATES[name]);
+	return JSON.stringify({
+		$schema: SCHEMA_URL,
+		workflow
+	}, null, 2) + "\n";
+};
+//#endregion
 //#region node_modules/eta/dist/index.mjs
 var EtaError = class extends Error {
 	constructor(message) {
@@ -191952,6 +191969,23 @@ const parseCostTrailers = (messages) => {
 	}
 	return entries;
 };
+const REVIEW_BASE_TRAILER_PREFIX = "Gtd-Review-Base: ";
+const REVIEW_BASE_TRAILER_RE = /^Gtd-Review-Base:[ \t]*(\S+)[ \t]*$/m;
+/**
+* Append a `Gtd-Review-Base: <base>` trailer (after a blank line) to a commit
+* `subject` — the entry commit `gtd review <commitish>` writes to start a new
+* review process. Mirrors `withCostTrailer`'s placement: the subject (first
+* line) is untouched, so `parseStateSubject`/`resolveState` read it back
+* exactly like any other turn commit.
+*/
+const withReviewBaseTrailer = (subject, base) => `${subject}\n\n${REVIEW_BASE_TRAILER_PREFIX}${base}`;
+/**
+* The `Gtd-Review-Base: <hash>` trailer recorded on a `gtd review <commitish>`
+* entry commit (see `withReviewBaseTrailer`), or `undefined` when `message`
+* carries none. Read back by `computeProcessRun` — ONLY off the process's
+* first (oldest) commit — to override the run's diff base.
+*/
+const parseReviewBaseTrailer = (message) => REVIEW_BASE_TRAILER_RE.exec(message)?.[1];
 /** The total token cost across the given entries (`0` when none). */
 const totalCostOf = (entries) => entries.reduce((sum, entry) => sum + entry.cost, 0);
 /** Per-model token totals, highest-cost first (ties broken by model name for a stable order). */
@@ -191968,7 +192002,7 @@ const normalizeStatus = (raw) => raw === "A" ? "A" : raw === "D" ? "D" : "M";
 /** Resolve HEAD's subject against the active workflow definition (the bundled default, or a compiled `.gtdrc` `workflow:` key). */
 const resolveRest = () => gen(function* () {
 	const git = yield* GitService;
-	const def = (yield* ConfigService).workflow;
+	const def = (yield* (yield* ConfigService).load).workflow;
 	const state = resolveState(def, (yield* git.hasCommits()) ? yield* git.lastCommitSubject() : "");
 	const stateDef = def.states[state];
 	if (stateDef.actor === void 0) return yield* fail$2(/* @__PURE__ */ new Error(`gtd: resolved at commit state "${state}" — a process never rests there`));
@@ -192007,6 +192041,7 @@ const computeProcessRun = (git, def) => gen(function* () {
 	if (!(yield* git.hasCommits())) return {
 		startHash: "",
 		startParentHash: EMPTY_TREE$1,
+		diffBase: EMPTY_TREE$1,
 		trace: [],
 		costEntries: []
 	};
@@ -192026,6 +192061,7 @@ const computeProcessRun = (git, def) => gen(function* () {
 	return {
 		startHash: startIdx < history.length ? history[startIdx].hash : history[history.length - 1].hash,
 		startParentHash,
+		diffBase: (processCommits.length > 0 ? parseReviewBaseTrailer(processCommits[0].message) : void 0) ?? startParentHash,
 		trace,
 		costEntries
 	};
@@ -192078,7 +192114,7 @@ const buildTemplateContext = (git, read, state, actor, run, vars, edges, current
 	const hasCommits = yield* git.hasCommits();
 	const currentCommit = hasCommits ? yield* git.resolveRef("HEAD") : "";
 	const previousCommit = hasCommits ? yield* git.resolveRef("HEAD~1").pipe(catchAll(() => succeed$3(run.startParentHash))) : "";
-	const processDiff = [yield* git.diffRef(run.startParentHash).pipe(catchAll(() => succeed$3(""))), yield* git.diffHead().pipe(catchAll(() => succeed$3("")))].filter((d) => d.trim().length > 0).join("\n\n");
+	const processDiff = [yield* git.diffRef(run.diffBase).pipe(catchAll(() => succeed$3(""))), yield* git.diffHead().pipe(catchAll(() => succeed$3("")))].filter((d) => d.trim().length > 0).join("\n\n");
 	const lastDiff = run.trace.length > 0 ? yield* git.commitDiff(currentCommit).pipe(catchAll(() => succeed$3(""))) : "";
 	const stepEntry = currentCost > 0 || currentModel !== void 0 ? [{
 		cost: currentCost,
@@ -192086,7 +192122,7 @@ const buildTemplateContext = (git, read, state, actor, run, vars, edges, current
 	}] : [];
 	const allCostEntries = [...run.costEntries, ...stepEntry];
 	return {
-		startCommit: run.startHash,
+		startCommit: run.diffBase,
 		currentCommit,
 		previousCommit,
 		state,
@@ -192289,10 +192325,12 @@ const closeReviewWindow = gen(function* () {
 * subcommand.
 *
 * The base is the most-recent in-process `reviewBase` commit
-* (`reviewBaseHash`) or, absent any such state, the process start
-* (`startParentHash`). When that resolves to the empty tree (a process with no
-* prior commit) or to HEAD itself (an empty process), there is nothing to
-* surface and the window stays closed.
+* (`reviewBaseHash`) or, absent any such state, the process's diff base
+* (`run.diffBase` — the process start, `startParentHash`, unless a
+* `gtd review <commitish>` entry commit overrode it via a `Gtd-Review-Base:`
+* trailer, see `computeProcessRun`). When that resolves to the empty tree (a
+* process with no prior commit) or to HEAD itself (an empty process), there
+* is nothing to surface and the window stays closed.
 *
 * Ordering is crash-safe: base ref → head ref → mixed reset → `.gtd/` index
 * pin → intent-to-add. A crash before the head-ref write leaves only a stale
@@ -192301,11 +192339,11 @@ const closeReviewWindow = gen(function* () {
 */
 const openReviewWindow = gen(function* () {
 	const git = yield* GitService;
-	const def = (yield* ConfigService).workflow;
+	const def = (yield* (yield* ConfigService).load).workflow;
 	if (!(yield* git.hasCommits())) return { opened: false };
 	if (!isReviewWindowState(def, resolveState(def, yield* git.lastCommitSubject()))) return { opened: false };
 	const run = yield* computeProcessRun(git, def);
-	const base = (yield* reviewBaseHash(git, def, run)) ?? run.startParentHash;
+	const base = (yield* reviewBaseHash(git, def, run)) ?? run.diffBase;
 	const headHash = yield* git.resolveRef("HEAD");
 	if (base === EMPTY_TREE || base === headHash) return { opened: false };
 	yield* git.updateRef(REVIEW_BASE_REF, base);
@@ -203842,7 +203880,7 @@ const worktreeLayerForRoot = (root) => WorktreeReader.Live.pipe(provide(Cwd.laye
 */
 const loadModeMap = async (root, onWarn) => {
 	try {
-		const config = await runPromise(ConfigService.pipe(provide$1(configLayerForRoot(root))));
+		const config = await runPromise(ConfigService.pipe(flatMap$4((c) => c.load), provide$1(configLayerForRoot(root))));
 		const vars = resolveVars(config.workflowVars, config.rcVars, process.env);
 		const { map, warnings } = buildFileModeMap(config.workflow, vars, root);
 		for (const warning of warnings) onWarn(warning);
@@ -203861,7 +203899,7 @@ const loadModeMap = async (root, onWarn) => {
 */
 const resolveSteeringFile = (root) => gen(function* () {
 	const git = yield* GitService;
-	const config = yield* ConfigService;
+	const config = yield* (yield* ConfigService).load;
 	const worktree = yield* WorktreeReader;
 	const envVars = yield* EnvVars;
 	const rest = yield* resolveRest();
@@ -204135,12 +204173,21 @@ const GTD_VERSION = createRequire(import.meta.url)("../package.json").version;
 const HELP_TEXT = `Usage: gtd [command] [options]
 
 Commands:
+  init <workflow>  Scaffold a .gtdrc.json for this repo with the chosen
+                   bundled workflow inline (one of: simple, advanced). Run
+                   once per repo; refuses if a gtd config already exists.
+                   Leaves the file uncommitted for you to review and commit
   step <actor>     Authenticate as <actor>, match the resolved rest's
                    declared patterns against the pending changes, and commit
                    (or squash) the one resulting transition. Pass
                    --cost=<n> (optionally --model=<name>) to record the
                    just-finished invocation's token cost and model on the
                    turn commit (summed into it.processCost/processCostByModel)
+  review <commitish>
+                   Start a NEW review process at the workflow's declared
+                   review-entry state (reviewEntry: true), reviewing
+                   <commitish>..HEAD — e.g. a colleague's PR branch. Requires
+                   a clean tree resting at the workflow's initial state
   next             Print the resolved rest's rendered script/prompt/message
                    (no mutation)
   status           Print the resolved rest's state/actor and which declared
@@ -204232,16 +204279,47 @@ const rejectExtraArgs = (command, argv) => {
 /**
 * `gtd lsp`: start the LSP server for `.gtd/` steering files over stdio.
 * Rejects `--json` (not a state command) and extra positional arguments
-* (takes none). Dispatched BEFORE the known-subcommand guard, the repo-root
-* guard, and auto-init — since the server needs no
-* git/config/workflow dependency at all (it's keyed on file name, not
-* workflow state; see `src/Lsp.ts`'s module doc).
+* (takes none). Dispatched BEFORE the known-subcommand guard and the repo-root
+* guard — since the server needs no git/config/workflow dependency at all
+* (it's keyed on file name, not workflow state; see `src/Lsp.ts`'s module doc).
 */
 const runLspCommand = (argv, json) => gen(function* () {
 	if (json) return yield* fail$2(/* @__PURE__ */ new Error("gtd lsp does not accept --json"));
 	yield* rejectExtraArgs("lsp", argv);
 	yield* startLspServer();
 });
+/** The `choose one of: ...` suffix shared by every `gtd init` usage error. */
+const initWorkflowChoices = () => `choose one of: ${WORKFLOW_TEMPLATE_NAMES.join(", ")}`;
+/**
+* `gtd init <workflow>`: scaffold a `.gtdrc.json` carrying one of the bundled
+* workflow templates inline (`simple`/`advanced`). Dispatched like `lsp` —
+* BEFORE the closeReviewWindow/dispatch/openReviewWindow block — because it is
+* the ONE command that must run with no workflow configured yet: it needs no
+* `ConfigService` (which would throw the "no workflow" error pre-init) and no
+* review window. It still runs the repo-root guard (it writes `.gtdrc.json` at
+* the root) and refuses to clobber an existing config. The file is left
+* UNCOMMITTED, so the message warns to commit it before the first `gtd step`
+* (an uncommitted config is a pending change the initial state's `* **` edge
+* would otherwise capture).
+*/
+const runInitCommand = (argv, json, write) => gen(function* () {
+	const args = commandArgs(argv);
+	if (args.length === 0) return yield* fail$2(/* @__PURE__ */ new Error(`gtd init: missing workflow — ${initWorkflowChoices()}`));
+	if (args.length > 1) return yield* fail$2(/* @__PURE__ */ new Error(`gtd init: too many arguments — expected one workflow, got: ${args.join(", ")}`));
+	const name = args[0];
+	if (!isWorkflowTemplateName(name)) return yield* fail$2(/* @__PURE__ */ new Error(`gtd init: unknown workflow '${name}' — ${initWorkflowChoices()}`));
+	const git = yield* GitService;
+	const fs = yield* FileSystem;
+	yield* assertRunningFromRepoRoot(git, fs);
+	const { root } = yield* Cwd;
+	if (yield* anyConfigPresent(root)) return yield* fail$2(/* @__PURE__ */ new Error("gtd init: a gtd config already exists — remove it before re-initializing"));
+	yield* fs.writeFileString(join(root, ".gtdrc.json"), renderInitConfig(name)).pipe(mapError$1((e) => e instanceof Error ? e : new Error(String(e))));
+	if (json) write(JSON.stringify({
+		written: ".gtdrc.json",
+		workflow: name
+	}) + "\n");
+	else write(`Wrote .gtdrc.json with the "${name}" workflow.\n\nReview and commit it before starting: an uncommitted .gtdrc.json counts as a\npending change, so the initial state would capture it on the first step. Once\ncommitted, run \`gtd step human\` to begin.\n`);
+});
 /**
 * Resolve HEAD's rest, the current process run, and the template context for
 * rendering that rest's OWN state/actor — the common prefix shared by `gtd
@@ -204251,7 +204329,7 @@ const runLspCommand = (argv, json) => gen(function* () {
 * instead of sharing this helper).
 */
 const resolveRestContext = (git) => gen(function* () {
-	const config = yield* ConfigService;
+	const config = yield* (yield* ConfigService).load;
 	const worktree = yield* WorktreeReader;
 	const envVars = yield* EnvVars;
 	const rest = yield* resolveRest();
@@ -204274,7 +204352,7 @@ const formatStepRefusal = (invoker, refusal) => refusal.reason === "out-of-turn"
 */
 const stepAsActor = (invoker, cost, model) => gen(function* () {
 	const git = yield* GitService;
-	const config = yield* ConfigService;
+	const config = yield* (yield* ConfigService).load;
 	const worktree = yield* WorktreeReader;
 	const envVars = yield* EnvVars;
 	const rest = yield* resolveRest();
@@ -204323,6 +204401,52 @@ const runStepCommand = (argv, json, write, cost, model) => gen(function* () {
 	reportStepResult(result, json, write);
 });
 /**
+* `gtd review <commitish>`: start a brand NEW review process at the active
+* workflow's declared `reviewEntry: true` state (see
+* `PatternMachine.reviewEntryStateOf`), reviewing `<commitish>..HEAD` — e.g. a
+* colleague's PR branch pushed on top of a shared base, with no gtd process of
+* its own. Writes an ordinary EMPTY turn commit
+* (`gtd(human): <review-entry-state>`) carrying the resolved `<commitish>`'s
+* full hash as a `Gtd-Review-Base:` trailer (`withReviewBaseTrailer`) —
+* `computeProcessRun` reads that trailer back off this same commit (its
+* process's own oldest) to override the new process's diff base, so the
+* ENTIRE existing review flow (reviewing → await-review → feedback laps, the
+* `await-review` review checkout window) operates over `<commitish>..HEAD`
+* with zero duplicated logic — see `src/Edge.ts`/`src/ReviewWindow.ts`.
+*
+* Any failure below is a plain refusal: nothing is written.
+*
+* a. The machine must currently rest at the workflow's INITIAL state — a
+*    plain non-gtd branch (the normal case) resolves there via the
+*    inert-subject rule (STATES.md §5); a process already underway refuses.
+* b. The working tree must be clean.
+* c. The active workflow must declare a `reviewEntry: true` state.
+* d. `<commitish>` must resolve to a commit, be an ancestor of HEAD, and
+*    differ from HEAD (nothing to review otherwise).
+*/
+const runReviewCommand = (argv, json, write) => gen(function* () {
+	const args = commandArgs(argv);
+	if (args.length === 0) return yield* fail$2(/* @__PURE__ */ new Error("gtd review: missing <commitish> argument"));
+	if (args.length > 1) return yield* fail$2(/* @__PURE__ */ new Error(`gtd review: too many arguments — expected one <commitish>, got: ${args.join(", ")}`));
+	const commitish = args[0];
+	const git = yield* GitService;
+	const rest = yield* resolveRest();
+	if (rest.state !== initialStateOf(rest.def)) return yield* fail$2(/* @__PURE__ */ new Error(`gtd review: a process is already underway (resting at "${rest.state}") — finish or abandon it before starting a review`));
+	if ((yield* pendingChanges(git)).length > 0) return yield* fail$2(/* @__PURE__ */ new Error("gtd review: the working tree must be clean before starting a review"));
+	const entryState = reviewEntryStateOf(rest.def);
+	if (entryState === void 0) return yield* fail$2(/* @__PURE__ */ new Error("gtd review: the active workflow declares no review entry state"));
+	const resolvedBase = yield* git.resolveRef(commitish).pipe(mapError$1(() => /* @__PURE__ */ new Error(`gtd review: "${commitish}" does not resolve to a commit`)));
+	if (resolvedBase === (yield* git.resolveRef("HEAD"))) return yield* fail$2(/* @__PURE__ */ new Error(`gtd review: "${commitish}" is HEAD — nothing to review`));
+	if (!(yield* git.isAncestor(resolvedBase, "HEAD"))) return yield* fail$2(/* @__PURE__ */ new Error(`gtd review: "${commitish}" is not an ancestor of HEAD`));
+	const subject = stateSubject("human", entryState);
+	yield* git.commitAsIs(withReviewBaseTrailer(subject, resolvedBase));
+	if (json) write(JSON.stringify({
+		state: entryState,
+		subject
+	}) + "\n");
+	else write(`committed: ${subject}\n`);
+});
+/**
 * The self-validation instruction gtd APPENDS to a `prompt` rest that declares
 * both `file:` and `mode:` — i.e. a state whose actor hands over a steering
 * file `gtd validate` formats and checks. Appended ONLY to plain `gtd next`
@@ -204529,10 +204653,11 @@ const runStatusCommand = (argv, json, write) => gen(function* () {
 const runMermaidCommand = (argv, json, write) => gen(function* () {
 	if (json) return yield* fail$2(/* @__PURE__ */ new Error("gtd mermaid does not accept --json"));
 	yield* rejectExtraArgs("mermaid", argv);
-	write(renderMermaid((yield* ConfigService).workflow));
+	write(renderMermaid((yield* (yield* ConfigService).load).workflow));
 });
 const KNOWN_SUBCOMMANDS = [
 	"step",
+	"review",
 	"next",
 	"status",
 	"validate",
@@ -204583,6 +204708,7 @@ const assertRunningFromRepoRoot = (git, fs) => gen(function* () {
 const dispatchKnownSubcommand = (sub, argv, json, write, cost, model) => {
 	switch (sub) {
 		case "step": return runStepCommand(argv, json, write, cost, model);
+		case "review": return runReviewCommand(argv, json, write);
 		case "next": return runNextCommand(json, write);
 		case "status": return runStatusCommand(argv, json, write);
 		case "validate": return runValidateCommand(argv, json, write);
@@ -204593,15 +204719,17 @@ const dispatchKnownSubcommand = (sub, argv, json, write, cost, model) => {
 * Factory that returns the gtd driver Effect with the given I/O options.
 *
 * The returned Effect requires `GitService | FileSystem.FileSystem |
-* ConfigService | ConfigInit | Cwd | WorktreeReader`. Production code calls
+* ConfigService | Cwd | WorktreeReader | EnvVars`. Production code calls
 * this with no arguments; the test world supplies an in-memory layer set and
 * captures stdout via the `write` callback.
 *
-* v3 command surface: `step <actor>` / `next` / `run` / `status` /
-* `validate` / `mermaid` (see `src/Edge.ts` and
-* `docs/design/pattern-machine-plan.md` §3), plus `lsp`. Bare `gtd` or an
-* unknown subcommand is a usage error. Shared setup (argv parsing, the repo-root guard) lives here;
-* each subcommand's own logic is a named `run*Command` function above.
+* v3 command surface: `step <actor>` / `next` / `status` / `validate` /
+* `mermaid` (see `src/Edge.ts` and `docs/design/pattern-machine-plan.md` §3),
+* plus `lsp` and `init <workflow>` — both dispatched before the config-reading
+* path since they must work with no workflow configured yet. Bare `gtd` or an
+* unknown subcommand is a usage error. Shared setup (argv parsing, the
+* repo-root guard) lives here; each subcommand's own logic is a named
+* `run*Command` function above.
 */
 function makeProgram(opts = {}) {
 	const argv = opts.argv ?? process.argv;
@@ -204614,12 +204742,12 @@ function makeProgram(opts = {}) {
 		if (unknownOption !== void 0) return yield* fail$2(/* @__PURE__ */ new Error(`gtd: unknown option '${unknownOption}' — see \`gtd --help\``));
 		const { cost, model } = yield* parseStepFlags(argv, positional);
 		if (positional === "lsp") return yield* runLspCommand(argv, json);
+		if (positional === "init") return yield* runInitCommand(argv, json, write);
 		const sub = yield* requireKnownSubcommand(positional, json, write);
 		const git = yield* GitService;
 		const fs = yield* FileSystem;
 		yield* assertRunningFromRepoRoot(git, fs);
 		yield* closeReviewWindow;
-		yield* (yield* ConfigInit).ensure;
 		const outcome = yield* either(dispatchKnownSubcommand(sub, argv, json, write, cost, model));
 		const rearm = yield* either(openReviewWindow);
 		if (isLeft(outcome)) return yield* fail$2(outcome.left);
@@ -204632,7 +204760,7 @@ function makeProgram(opts = {}) {
 //#endregion
 //#region src/main.ts
 if (runVersionOrHelp(process.argv, (chunk) => process.stdout.write(chunk))) process.exit(0);
-makeProgram().pipe(provide$1(GitService.Live), provide$1(ConfigService.Live), provide$1(ConfigInit.Live), provide$1(WorktreeReader.Live), provide$1(EnvVars.Live), provide$1(Cwd.Live), provide$1(layer), catchAll((error) => sync$1(() => {
+makeProgram().pipe(provide$1(GitService.Live), provide$1(ConfigService.Live), provide$1(WorktreeReader.Live), provide$1(EnvVars.Live), provide$1(Cwd.Live), provide$1(layer), catchAll((error) => sync$1(() => {
 	if (process.argv.includes("--json") && !isEnveloped(error)) process.stdout.write(JSON.stringify({
 		state: "error",
 		prompt: error.message