@pmelab/gtd 9.11.0 → 9.13.0

package/dist/gtd.bundle.mjs

@@ -189660,7 +189660,7 @@ const STATE_FIELDS = {
 		surface: "def",
 		authored: "state",
 		viz: "field",
-		doc: "Who acts at this state. Required on every non-commit state; forbidden on a commit state."
+		doc: "Who acts at this state. Required on every state."
 	},
 	script: {
 		kind: "content",
@@ -189680,12 +189680,6 @@ const STATE_FIELDS = {
 		authored: "state",
 		doc: "Content kind: a human-facing message (Eta template), emitted by `gtd next`."
 	},
-	commit: {
-		kind: "content",
-		surface: "def",
-		authored: "state",
-		doc: "Content kind: entering this state ends the process by squashing it into one commit with this message (Eta template). Final — no actor, no on."
-	},
 	on: {
 		kind: "edges",
 		surface: "def",
@@ -189707,7 +189701,6 @@ const STATE_FIELDS = {
 		surface: "def",
 		authored: "machine",
 		nonEmpty: true,
-		commit: "forbidden",
 		viz: "field",
 		rest: "rendered",
 		doc: "Opaque harness hint stamped onto every one of this machine's own `prompt` states (e.g. \"smart\"), passed through `gtd next --json`/`gtd status --json`. The ONLY place a model may be declared — a state carrying its own `model:` is a config error. Never interpreted by gtd. A machine declaring this with no `prompt` state is a config error."
@@ -189717,7 +189710,6 @@ const STATE_FIELDS = {
 		surface: "def",
 		authored: "machine",
 		nonEmpty: true,
-		commit: "forbidden",
 		fileRef: true,
 		rest: "rendered",
 		viz: "field",
@@ -189729,9 +189721,8 @@ const STATE_FIELDS = {
 		surface: "def",
 		authored: "state",
 		nonEmpty: true,
-		commit: "forbidden",
 		rest: "rendered",
-		doc: "Opaque display name passed through `gtd next --json`/`gtd status --json` so a driver/viewer can show something nicer than the raw state name (e.g. \"Running checks\"). Never interpreted by gtd. Forbidden on a commit state."
+		doc: "Opaque display name passed through `gtd next --json`/`gtd status --json` so a driver/viewer can show something nicer than the raw state name (e.g. \"Running checks\"). Never interpreted by gtd."
 	},
 	/** Multiple states may (and, in the bundled default, do) share one `file:`. The engine never reads a path out of this string itself — only the LSP interprets it, to map rendered paths to `mode`. */
 	file: {
@@ -189739,59 +189730,45 @@ const STATE_FIELDS = {
 		surface: "def",
 		authored: "state",
 		nonEmpty: true,
-		commit: "forbidden",
 		viz: "field",
 		rest: "rendered",
-		doc: "The state's steering file: an Eta template naming the file a human/editor should look at while the machine rests here, RELATIVE to \".gtd/\" — the compiler prepends that directory automatically. A \"..\" segment, an absolute path, or an already-prefixed \".gtd/\" are rejected, not rewritten. Forbidden on a commit state."
+		doc: "The state's steering file: an Eta template naming the file a human/editor should look at while the machine rests here, RELATIVE to \".gtd/\" — the compiler prepends that directory automatically. A \"..\" segment, an absolute path, or an already-prefixed \".gtd/\" are rejected, not rewritten."
 	},
 	/** Opaque, like `model`: the engine never branches on it — the edge (`src/SteeringMode.ts`) resolves it to a format/validate pair. `validateDefinition` only enforces that the name resolves, so a typo can't silently disable the gate. */
 	mode: {
 		kind: "mode",
 		surface: "def",
 		authored: "state",
-		commit: "forbidden",
 		requires: "file",
 		viz: "field",
 		rest: "verbatim",
-		doc: "The steering file's format: the name of a built-in mode (qa/review, validated in-process by gtd) or of a `modes:` entry. gtd formats and validates the file with that mode before capturing a turn out of this state, and the LSP dispatches live diagnostics on the built-in names. Requires a sibling `file:`. Forbidden on a commit state."
+		doc: "The steering file's format: the name of a built-in mode (qa/review, validated in-process by gtd) or of a `modes:` entry. gtd formats and validates the file with that mode before capturing a turn out of this state, and the LSP dispatches live diagnostics on the built-in names. Requires a sibling `file:`."
 	},
-	/** This module's pure functions never read this flag — the window is opened/closed entirely at the edge (`src/ReviewWindow.ts`). */
-	reviewWindow: {
-		kind: "flag",
-		surface: "def",
-		authored: "state",
-		commit: "forbidden",
-		viz: "flag",
-		doc: "When true, gtd opens a review checkout window while the machine rests here — HEAD/index are rewound to the review base so the whole base..HEAD diff surfaces as uncommitted changes in the editor. Forbidden on a commit state."
-	},
-	/** Like `reviewWindow`, the engine never reads this — it's history-derived edge data. `isReviewBaseState` never treats a string value as the `true`/window-anchor form. */
+	/** The engine never reads this — it's history-derived edge data. `isReviewBaseState` never treats a string value as the `true`/window-anchor form. */
 	reviewBase: {
 		kind: "flagOrTemplate",
 		surface: "def",
 		authored: "state",
-		commit: "forbidden",
 		viz: "flag",
-		doc: "true marks the state whose most-recent in-process commit anchors the review window's diff base; absent any, the base is the process start. A string is a different shape: an Eta template rendering a commitish that becomes the WHOLE PROCESS's fixed diff base when this state is entered manually via `gtd --entry <state> --base <commitish>` (see the `entry` property below). Forbidden on a commit state."
+		doc: "true marks the state whose most-recent in-process commit anchors the review window's diff base; absent any, the base is the process start. A string is a different shape: an Eta template rendering a commitish that becomes the WHOLE PROCESS's fixed diff base when this state is entered manually via `gtd --entry <state> --base <commitish>` (see the `entry` property below)."
 	},
 	/** The pure engine never reads this — checked at the edge by the feedback-progress guard in `src/StepGuards.ts`. */
 	requireProgress: {
 		kind: "flag",
 		surface: "def",
 		authored: "state",
-		commit: "forbidden",
 		requires: "file",
 		viz: "flag",
-		doc: "When true, a step at this state is refused if its only pending change is deleting the state's own `file:` — a work-free turn that discards its input without addressing it. A `NOTHING ACTIONABLE` sentinel file is exempt (a legitimately non-actionable round makes no code change). Requires a `file:`. Forbidden on a commit state."
+		doc: "When true, a step at this state is refused if its only pending change is deleting the state's own `file:` — a work-free turn that discards its input without addressing it. A `NOTHING ACTIONABLE` sentinel file is exempt (a legitimately non-actionable round makes no code change). Requires a `file:`."
 	},
 	/** The pure engine never reads this — checked at the edge by the answer-completeness guard in `src/StepGuards.ts`, and only when the state also declares `mode: qa`. */
 	answerGate: {
 		kind: "flag",
 		surface: "def",
 		authored: "state",
-		commit: "forbidden",
 		requires: "file",
 		viz: "flag",
-		doc: "When true, a step at this state is refused unless every open question in its qa-mode `file:` is answered — exactly one checkbox ticked per question. Requires a `file:` and `mode: qa`. Forbidden on a commit state."
+		doc: "When true, a step at this state is refused unless every open question in its qa-mode `file:` is answered — exactly one checkbox ticked per question. Requires a `file:` and `mode: qa`."
 	},
 	/**
 	* The pure engine never reads this — checked at the edge by the
@@ -189804,10 +189781,9 @@ const STATE_FIELDS = {
 		kind: "flag",
 		surface: "def",
 		authored: "state",
-		commit: "forbidden",
 		requires: "file",
 		viz: "flag",
-		doc: "When true, a step at this state is refused unless the paths the human's own review-round commit touched have actually been reverted out of the working tree — re-established from the tree itself, never from the script's own exit code. Requires a `file:`. Forbidden on a commit state."
+		doc: "When true, a step at this state is refused unless the paths the human's own review-round commit touched have actually been reverted out of the working tree — re-established from the tree itself, never from the script's own exit code. Requires a `file:`."
 	},
 	/** Authoring-only: never lands on the compiled `StateDef` — `compileWorkflowConfig` reads the raw flag directly to build `entries.manual` instead. */
 	entry: {
@@ -189819,17 +189795,15 @@ const STATE_FIELDS = {
 	}
 };
 const STATE_FIELD_ENTRIES = Object.entries(STATE_FIELDS);
-/** The four content-kind field names, in declaration order — the "exactly one of" set `validateContentKind`/`compileContent` iterate. */
+/** The three content-kind field names, in declaration order — the "exactly one of" set `validateContentKind`/`compileContent` iterate. */
 const CONTENT_FIELDS = STATE_FIELD_ENTRIES.filter(([, spec]) => spec.kind === "content").map(([key]) => key);
 /** Every machine-authored field, in table order — the machine tier's `CONTENT_FIELDS`. */
 const MACHINE_FIELD_ENTRIES = STATE_FIELD_ENTRIES.filter(([, spec]) => spec.authored === "machine");
-const isCommitState = (state) => state.commit !== void 0;
 /**
 * The generic per-field rules every derivation site walks the same way:
-* non-empty, forbidden on a commit state, requires a sibling field — only
-* evaluated when `key` is actually declared on `state`. A field's own bespoke
-* checks (an `on` pattern parsing, a `mode` name resolving, …) are the
-* caller's concern.
+* non-empty, requires a sibling field — only evaluated when `key` is
+* actually declared on `state`. A field's own bespoke checks (an `on`
+* pattern parsing, a `mode` name resolving, …) are the caller's concern.
 */
 const validateFieldRules = (name, state, key, spec) => {
 	const raw = state;
@@ -189837,7 +189811,6 @@ const validateFieldRules = (name, state, key, spec) => {
 	if (value === void 0) return [];
 	const errors = [];
 	if (spec.nonEmpty === true && value === "") errors.push(`state "${name}": "${key}" must be a non-empty string`);
-	if (spec.commit === "forbidden" && isCommitState(state)) errors.push(`state "${name}": a commit state cannot declare "${key}"`);
 	if (spec.requires !== void 0 && raw[spec.requires] === void 0) errors.push(`state "${name}": "${key}" requires "${spec.requires}"`);
 	return errors;
 };
@@ -189856,13 +189829,10 @@ const contentKindOf = (state) => {
 	if (state.script !== void 0) return "script";
 	if (state.prompt !== void 0) return "prompt";
 	if (state.message !== void 0) return "message";
-	if (state.commit !== void 0) return "commit";
 };
-/** The raw template source a state's own content kind carries — `script`/`prompt`/`message`, or `undefined` for a commit state (never at rest, no template a viewer could show). */
+/** The raw template source a state's own content kind carries — `script`/`prompt`/`message`. */
 const contentOf = (state) => state.script ?? state.prompt ?? state.message;
-/** True when a rest at `state` should open the review checkout window. Safe for an unknown state name (returns `false`). */
-const isReviewWindowState = (def, state) => def.states[state]?.reviewWindow === true;
-/** True when `state` anchors the review window's diff base. Safe for an unknown state name (returns `false`). The string/template form of `reviewBase` is NOT a window anchor — this stays narrowed to `=== true` on purpose, never truthy. */
+/** True when `state` anchors the review's diff base. Safe for an unknown state name (returns `false`). The string/template form of `reviewBase` is NOT this anchor form — this stays narrowed to `=== true` on purpose, never truthy. */
 const isReviewBaseState = (def, state) => def.states[state]?.reviewBase === true;
 /** The named state's `reviewBase` when it is a STRING (an Eta template rendering a commitish that fixes the whole process's diff base) — `undefined` when `reviewBase` is `true`, absent, or `state` doesn't exist. Pure accessor only: rendering the template is an edge concern. */
 const entryBaseTemplateOf = (def, state) => {
@@ -189873,12 +189843,10 @@ const isRequireProgressState = (def, state) => def.states[state]?.requireProgres
 const isAnswerGateState = (def, state) => def.states[state]?.answerGate === true;
 const isRequireRevertState = (def, state) => def.states[state]?.requireRevert === true;
 /**
-* Every declared state that is NOT a commit state, sorted. Intentionally ALL
-* non-commit states, not just ones that declared `entry: true` — this drives
-* the CLI's `--entry <state>` guard and its error message, a broader set on
-* purpose.
+* Every declared state, sorted. This drives the CLI's `--entry <state>` guard
+* and its error message, a broader set than `entries.manual` on purpose.
 */
-const enterableStates = (def) => Object.keys(def.states).filter((name) => !isCommitState(def.states[name])).sort();
+const enterableStates = (def) => Object.keys(def.states).sort();
 const TRANSITION_SEP = " → ";
 /**
 * `gtd(<actor>): <from> → <to>` — the subject a step commit carries.
@@ -189922,7 +189890,6 @@ const initialStateOf = (def) => def.entries.default;
 /**
 * Every actor declared by ANY state in the workflow — the closed-world
 * vocabulary a parsed subject's actor is checked against by `resolveState`.
-* Commit states carry no `actor` and so contribute nothing.
 */
 const declaredActors = (def) => {
 	const actors = /* @__PURE__ */ new Set();
@@ -189939,18 +189906,13 @@ const declaredActors = (def) => {
 * now awaited.
 *
 * An unrecognized subject — non-`gtd(...)`, malformed, naming an undefined
-* state, an actor outside the vocabulary, or a commit state — resolves to the
-* INITIAL state (old histories and every completed process's squash commit
-* land here). Commit states are excluded explicitly rather than via an
-* actor-mismatch trick, since a hand-authored subject could still name one
-* even though `step` never writes one.
+* state, or an actor outside the vocabulary — resolves to the INITIAL state
+* (old histories land here).
 */
 const resolveState = (def, headSubject) => {
 	const parsed = parseStateSubject(headSubject);
 	if (parsed === void 0) return initialStateOf(def);
-	const state = def.states[parsed.state];
-	if (state === void 0) return initialStateOf(def);
-	if (isCommitState(state)) return initialStateOf(def);
+	if (def.states[parsed.state] === void 0) return initialStateOf(def);
 	if (!declaredActors(def).has(parsed.actor)) return initialStateOf(def);
 	return parsed.state;
 };
@@ -190089,19 +190051,18 @@ const memoryScopeAt = (scopes, state, trace) => {
 * or the tree is dirty and no `on` pattern matches. A clean tree with no
 * matching pattern is a plain no-op at a `script`/`message` rest, but at a
 * `prompt` rest it's an ATTEMPT instead: the state itself becomes the raw
-* target, falling through the same retry/commit-state tail as a real match,
-* tagged `attempt: true` on the resulting `"commit"` — a fruitless `prompt`
+* target, falling through the same retry tail as a real match, tagged
+* `attempt: true` on the resulting `"commit"` — a fruitless `prompt`
 * dispatch still costs money and must be remembered across restarts, so it's
 * committed rather than treated as an inert no-op. The target (or attempt's
-* self-target) is retry-redirected (`applyRetry`) before being classified: a
-* commit-state target yields `"squash"`; anything else yields `"commit"`.
-* Throws only on a structurally invalid call — an undefined `state`, or a
-* commit-state `state` (stepping AT a commit state is a caller error).
+* self-target) is retry-redirected (`applyRetry`) before being classified —
+* always yielding `"commit"`. Throws only on a structurally invalid call: an
+* undefined `state`.
 */
 const step = (def, state, invoker, payload) => {
 	const stateDef = def.states[state];
 	if (stateDef === void 0) throw new Error(`step: unknown state "${state}"`);
-	if (stateDef.actor === void 0) throw new Error(`step: "${state}" is a commit state — a process never rests there`);
+	if (stateDef.actor === void 0) throw new Error(`step: "${state}" declares no actor — a process never rests there`);
 	if (invoker !== stateDef.actor) return {
 		kind: "refusal",
 		reason: "out-of-turn",
@@ -190128,12 +190089,7 @@ const step = (def, state, invoker, payload) => {
 	const finalTarget = applyRetry(def, target, payload.processTrace);
 	const targetDef = def.states[finalTarget];
 	if (targetDef === void 0) throw new Error(`step: "${state}" transitions to undefined state "${finalTarget}"`);
-	if (targetDef.commit !== void 0) return {
-		kind: "squash",
-		state: finalTarget,
-		template: targetDef.commit
-	};
-	if (targetDef.actor === void 0) throw new Error(`step: "${finalTarget}" is not a commit state but declares no actor`);
+	if (targetDef.actor === void 0) throw new Error(`step: "${finalTarget}" declares no actor`);
 	return {
 		kind: "commit",
 		subject: stateSubject(invoker, finalTarget, state),
@@ -190166,7 +190122,6 @@ const validateEntries = (def, names) => {
 			errors.push(`entries.${key} "${state}" is not a defined state`);
 			return;
 		}
-		if (isCommitState(def.states[state])) errors.push(`entries.${key} "${state}" must not be a commit state`);
 		if (key !== "default" && state === def.entries.default) errors.push(`entries.${key} "${state}" must not be the same state as entries.default`);
 	};
 	checkEntry("default", def.entries.default);
@@ -190180,15 +190135,9 @@ const validateEntries = (def, names) => {
 };
 const validateContentKind = (name, state) => {
 	const kindCount = CONTENT_FIELDS.filter((key) => state[key] !== void 0).length;
-	return kindCount === 1 ? [] : [`state "${name}": must declare exactly one of script/prompt/message/commit (found ${kindCount})`];
-};
-const validateActorShape = (name, state) => {
-	if (!isCommitState(state)) return state.actor === void 0 ? [`state "${name}" must declare an actor (only a commit state may omit one)`] : [];
-	const errors = [];
-	if (state.actor !== void 0) errors.push(`commit state "${name}" must not declare an actor`);
-	if (state.on !== void 0) errors.push(`commit state "${name}" must not declare "on"`);
-	return errors;
+	return kindCount === 1 ? [] : [`state "${name}": must declare exactly one of script/prompt/message (found ${kindCount})`];
 };
+const validateActorShape = (name, state) => state.actor === void 0 ? [`state "${name}" must declare an actor`] : [];
 /**
 * A declared mode's `format`/`validate`, when present, may not be blank (a
 * whitespace-only shell command would run and "succeed", silently disabling
@@ -191409,7 +191358,8 @@ const KNOWN_TOP_KEYS = /* @__PURE__ */ new Set([
 	"entry",
 	"machines",
 	"vars",
-	"modes"
+	"modes",
+	"summary"
 ]);
 const KNOWN_MACHINE_KEYS = /* @__PURE__ */ new Set([
 	"params",
@@ -191423,7 +191373,8 @@ const LEGACY_STATE_KEY_HINTS = {
 	initial: `"initial" no longer exists — declare this state's qualified path in the top-level "entry.default" instead`,
 	reviewEntry: `"reviewEntry" no longer exists — declare "entry: true" on this state instead`,
 	fixEntry: `"fixEntry" no longer exists — declare "entry: true" on this state instead`,
-	memory: `"memory" no longer exists — a machine's memory scope is derived from its position in the tree and starts fresh on every entry`
+	memory: `"memory" no longer exists — a machine's memory scope is derived from its position in the tree and starts fresh on every entry`,
+	commit: `"commit" no longer exists — the automatic squash finale was removed; a review sign-off lands an ordinary commit entering the workflow's initial state, and \`gtd summary\` prints a prompt for the process's own closing message instead`
 };
 const LEGACY_REF_KEY_HINTS = {
 	as: `"as" no longer exists — a reference's local name (the key itself) IS the concrete name; there is nothing left to rename`,
@@ -191611,12 +191562,18 @@ const inlineMachineFileRefs = (machineRaw, machineName, configDir, errors, fileR
 */
 const inlineWorkflowFileRefs = (rawWorkflow, configDir, errors, fileRefs = nodeFileRefReader) => {
 	if (!isPlainObject$1(rawWorkflow)) return rawWorkflow;
+	const next = { ...rawWorkflow };
+	const rawSummary = rawWorkflow["summary"];
+	if (typeof rawSummary === "string" && isFileReference(rawSummary)) {
+		const resolved = resolveContent(rawSummary, configDir, `"summary"`, errors, fileRefs);
+		if (resolved !== void 0) next["summary"] = resolved;
+	}
 	const rawMachines = rawWorkflow["machines"];
-	if (!isPlainObject$1(rawMachines)) return rawWorkflow;
+	if (!isPlainObject$1(rawMachines)) return next;
 	const machines = {};
 	for (const [machineName, machineRaw] of Object.entries(rawMachines)) machines[machineName] = inlineMachineFileRefs(machineRaw, machineName, configDir, errors, fileRefs);
 	return {
-		...rawWorkflow,
+		...next,
 		machines
 	};
 };
@@ -191845,6 +191802,27 @@ const assertScopesCoverStates = (stateNames, scopes, errors) => {
 	for (const name of stateNames) if (!(name in scopes)) errors.push(`internal error: scopes map produced by the flattener is missing state "${name}"`);
 };
 /**
+* Compile the top-level `summary:` template — the `gtd summary` prompt. An
+* absent value is legal (`gtd summary` refuses at runtime instead); a
+* present-but-blank value (or a blank inlined file) is a load error, the same
+* rule a mode's `format:`/`validate:` follows. File-ref inlining mirrors
+* `compileContentRef`'s `ctx.inlineFileRefs` discipline.
+*/
+const compileSummary = (raw, configDir, errors, inlineFileRefs, fileRefs) => {
+	const value = raw["summary"];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") {
+		errors.push(`"summary" must be a string`);
+		return;
+	}
+	const resolved = inlineFileRefs ? resolveContent(value, configDir, `"summary"`, errors, fileRefs) : value;
+	if (resolved !== void 0 && resolved.trim() === "") {
+		errors.push(`"summary" must not be blank`);
+		return;
+	}
+	return resolved;
+};
+/**
 * Compile the raw, decoded `workflow:` YAML value into a `WorkflowDefinition`
 * plus the workflow's own compiled `vars:` map and its machine tree.
 * `rcModes` (the already-compiled top-level `.gtdrc` `modes:` key) is layered
@@ -191874,13 +191852,15 @@ const compileWorkflowConfig = (raw, configDir, rcModes, inlineFileRefs = true, f
 		if (isPlainObject$1(s) && s["entry"] === true) manualSet.add(name);
 	}
 	const manual = Array.from(manualSet).sort();
+	const summary = compileSummary(raw, configDir, errors, inlineFileRefs, fileRefs);
 	const definition = {
 		states,
 		entries: {
 			default: flattened.entries.default,
 			manual
 		},
-		modes
+		modes,
+		...summary !== void 0 ? { summary } : {}
 	};
 	assertScopesCoverStates(Object.keys(states), flattened.scopes, errors);
 	const definitionErrors = validateDefinition(definition);
@@ -191895,7 +191875,7 @@ const compileWorkflowConfig = (raw, configDir, rcModes, inlineFileRefs = true, f
 };
 //#endregion
 //#region src/workflows/unified.yaml
-var unified_default = "# gtd's BUILT-IN DEFAULT workflow — used when no `workflow:` key is\n# configured anywhere in the cwd→home config chain; `gtd init` seeds only\n# vars.testCommand + a modes: suggestion, never this file. Compiled through\n# the same `compileWorkflowConfig` a user's own `workflow:` goes through — no\n# privileged path. See skills/authoring/SKILL.md for how to read or edit it\n# (machines, patterns, templates) and docs/driver.md for how a driver runs it.\n#\n# One flow: any change to the tree starts the process. `idle` -> `unwind`\n# reverts that diff (intent survives only in history) -> a green-baseline\n# gate -> `design.triage` groups the reverted diff into ordered, classified\n# concerns and resolves the PRODUCT ones' open questions (`design.gate`) ->\n# `architecture.author` works out the *how* and resolves the TECHNICAL ones\n# (`architecture.gate`) -> `architecture.decompose` writes one package file\n# per concern -> the per-package queue (`packages.*`) builds and reviews each\n# -> the shared tail (`build.review.*`) decides sign-off (-> `build.squashing`\n# -> `done`, one commit) vs. actionable feedback (-> `re-unwind` -> back to\n# `design.triage`, a full re-plan lap that never builds on the human's\n# hand-edit). `--entry review-gate.check --var reviewBase=<commitish>` and\n# `--entry fix-precheck` are the two other entries into this same flow.\nvars:\n  testCommand: npm test\n  # plannerModel: the heavier tier for one-shot triage/design/review turns.\n  # coderModel: the tier for build/fix turns. Both repointable via a\n  # top-level `vars:` key or a `GTD_<NAME>` env var, like any other var.\n  plannerModel: smart\n  coderModel: base\n  # Declared (not left undeclared) so `--var reviewBase=...` passes the CLI's\n  # declared-name check; blank renders empty, which the review entry refuses.\n  reviewBase: \"\"\n  # gtd's own voice for generated files — adapted from the \"Spartan\" output\n  # style (https://github.com/alexgreensh/attention-span, AGPL-3.0, version 0.6),\n  # rewritten in gtd's own words for deliverables rather than chat replies;\n  # no upstream text ships. A point-in-time derivation with no refresh\n  # mechanism.\n  styleBlock: |-\n    This file is a deliverable, not a chat reply — size follows the work, and\n    padding is the target of any cut. Lead with the answer immediately; never\n    circle back to restate it once it has landed.\n\n    Write flat, commanding sentences — commit to the claim, do not hedge it.\n    Favor everyday vocabulary; where a term is unavoidable, define it in five\n    words or fewer on first use.\n\n    In markdown, bold carries the load: bold the claim, not the sentence around\n    it — reading only the bold text must yield the full point and every risk.\n\n    Never trim a risk, a number, a threshold, or a scoped condition to save\n    space. This outranks every other rule here.\n\n    Ship the artifact bare — no lead-in, no sign-off wrapped around it.\n    Compressing is not dropping: a task with three load-bearing parts ships all\n    three, each shorter, never two of three.\n\n    One idea per block; break when the idea shifts. Flag risk in one blunt\n    line rather than hedged prose. Never narrate the work — do it.\n  styleFormatContract: |-\n    This file is machine-read; its format contract outranks every style rule\n    above it: keep every `##`/`###` heading, every `- [ ]` checkbox row, and\n    every marker line exactly as specified — do not renumber or rename a\n    heading or replace a checkbox list with prose. A parser reads these\n    literally; a violation refuses the turn outright.\n\n    Voice rules above govern the prose between these elements, never the\n    elements themselves.\n\n  # One persona per prompt-bearing machine below, stamped as its `system:`\n  # (see src/StateFields.ts's `system`). `--system-prompt` REPLACES a\n  # harness's default system prompt — including its injected cwd/env/\n  # git-status block — so each persona is written self-contained, restating\n  # that context explicitly rather than relying on it.\n\n  # Shared conduct tail, appended after every persona's own role paragraph:\n  # use tools without asking, orient yourself with git, and go inspect what\n  # the turn's message names. Deliberately NOT named `*Persona`:\n  # `templates.test.ts` derives its six-name persona set from\n  # `it\\.vars\\.(\\w+Persona)`, so that suffix would silently grow the set.\n  agentConduct: |-\n    You have shell and file tools — bash, read, write, edit — and you are\n    expected to use them without asking first. This runs unattended: there is\n    no one to grant permission, confirm a command, or approve a plan before\n    you act. Investigate with real commands rather than assuming what a file,\n    a commit, or a decision's status actually is, then act on what you find.\n\n    You are already inside a git repository, at the working directory you\n    should treat as your whole world for this turn. There is no injected\n    status block — no cwd, no branch, no recent history, no tree state. Run\n    `git status`, `git log`, `ls` and the like yourself before you do\n    anything else; that is the normal first move of this turn, not an extra\n    step.\n\n    The message you receive each turn names a commit, a range, or a file for\n    you to go inspect yourself — `git show`, `git diff`, reading the file\n    directly — never a diff or a summary rendered into the conversation. Go\n    look before you act. Across the several turns one conversation may span,\n    work from what you already read and settled earlier rather than\n    re-deriving it from a cold read every time, unless the turn's own\n    instructions tell you this is a fresh, cold pass.\n  designPersona: |-\n    You are the product-facing planning voice in an autonomous build pipeline\n    called gtd. Your job is to turn a raw, half-formed sketch — a hand-edit to\n    real code, a scratch note, or both — into an ordered, classified list of\n    concerns a build can execute, and to carry a running conversation with a\n    human about the product decisions that list depends on. You are read by\n    that human, so write plainly and decisively; you are not read by a parser\n    except where a state's own instructions say otherwise.\n  architectPersona: |-\n    You are the technical planning voice in an autonomous build pipeline\n    called gtd. You take over once the product-facing concerns are settled,\n    reading them cold — you do not carry over the product conversation, only\n    its written, settled output. Your job is to work out the technical *how*\n    for each settled concern — file and module structure, data models,\n    library and tech-stack choices, error-handling strategy — raise the\n    technical open questions a human still needs to decide, and once every\n    question is answered, write one package spec file per concern with no\n    further judgement call: the grouping and ordering were already decided\n    upstream, and this final step is a mechanical write-out of a plan you\n    already converged on.\n  reviewerPersona: |-\n    You are the independent reviewing mind in an autonomous build pipeline\n    called gtd — deliberately a separate identity from whichever agent wrote\n    the code under review, so you bring no attachment to how it got built.\n    Your job splits into two distinct turns: first, writing a structured\n    review document that groups a diff into reviewable chunks for a human to\n    read through and comment on; later, reading back a round of that human's\n    feedback — a note, a hand-edit — and classifying whether it is genuinely\n    actionable or just an approving remark, without fixing anything yourself\n    either way. You judge and you classify; you never build.\n  specReviewerPersona: |-\n    You are the adversarial spec-conformance checker in an autonomous build\n    pipeline called gtd, reviewing one freshly-built work package against the\n    written spec it was built from. Your only job is to verify: are the\n    package's tasks actually done, its acceptance criteria actually met, and\n    the code sound and consistent with the rest of the codebase? You write\n    concrete, actionable feedback only when something is genuinely wrong —\n    and when nothing is, you write nothing at all, because a clean turn from\n    you IS the approval. You never fix a problem you find; naming it\n    precisely enough for someone else's fix turn to act on is the whole job.\n  builderPersona: |-\n    You are the TDD implementer in an autonomous build pipeline called gtd.\n    Your job is to build exactly one package's declared scope end to end,\n    tests first, and to come back and fix things when redirected: a failing\n    check's output, or a reviewer's concrete feedback. Stay strictly inside\n    the package in front of you, touching neither another package's files nor\n    code outside the current task. Treat feedback you're given as the\n    diagnosis to act on; discard it, with reason, only when it is simply\n    wrong.\n  finisherPersona: |-\n    You are the closing identity in an autonomous build pipeline called gtd —\n    the last coder this process hands work to before everything it touched is\n    squashed into a single commit. Most turns you are handed, your job is to\n    write the one conventional-commit message that summarizes the whole\n    approved change: subject line, imperative mood, a body that explains why\n    and what trade-offs were made, not just what changed. Occasionally you\n    are handed a late-breaking failing check instead — fix it, focused and\n    minimal, before the process can close. Either way, you are aware that\n    everything you touch this turn is about to lose its own commit boundary\n    and become part of one final message, so make that message earn its\n    place as the historical record.\n\n  # The scratchpad-opener sentence shared by every prompt-content state (see\n  # STATE_FIELDS's `prompt`) — this workflow's own state files are its private\n  # working notes, never project code or documentation a human reads. Injected\n  # as the leading line of all eleven prompt bodies that touch a `.gtd/` file\n  # directly; each state's own \"the only state file this turn touches is X\"\n  # sentence stays local, immediately after the tag. Three states splice a\n  # role clause into this same opening sentence (`build.review.collecting`,\n  # `packages.item.spec.review`, `build.squashing`) — those hoist the clause to\n  # its own leading sentence ahead of the tag instead, keeping every word.\n  stateFileRules: |-\n    You are an autonomous coding agent. This workflow steers itself\n    through its own state files — treat them as its private scratchpad,\n    never as project code or documentation.\n  # The open-questions warrant test, decide-it-yourself sink, and `## Open\n  # Questions` checkbox shape shared by `design.triage` and\n  # `architecture.author` — written phase-agnostic (no PRODUCT/TECHNICAL\n  # bake-in) so both sites can inject it verbatim. Each site's own\n  # phase-scope sentence (triage: product-only, technical waits; architecture:\n  # every point here is TECHNICAL) stays local around the tag — the two\n  # genuinely disagree on scope, so that sentence is never shared.\n  # `questionBarReturn` is the return-lap half — split out so each site can\n  # inject it under its own `## Return lap` heading instead of burying\n  # return-lap behaviour inside the first lap's own section.\n  questionBar: |-\n    For every open point, a question is warranted only when all three hold:\n    the answer is a genuine fork with divergent outcomes — user-visible for a\n    product question, materially different implementations for a technical\n    one; the sketch, the entry diff, and history do not already settle it\n    (treat anything the entry diff states explicitly — a directive in\n    `.gtd/TODO.md`, a committed choice in a hand-edit — as already settled,\n    and on a review loop-back lap treat whatever the human's own review-round\n    edit or note states explicitly the same way); and getting it wrong would\n    survive all the way to the human review tail.\n\n    Anything below that bar, decide yourself: record the decision under\n    `## Answered Questions` — the same section a human-answered question\n    lands in — as `### <the point phrased as a question>` followed by the\n    decision and a one-line rationale in prose, no checkboxes.\n\n    A question that clears the bar is written under a `## Open Questions`\n    heading near the top and takes this shape: one `### <question>`\n    sub-heading each, followed by a checkbox list of candidate answers — two\n    concrete options plus a final free-text slot, all left unticked:\n\n        ### <the question>\n\n        - [ ] <first option — a concrete answer, a few words of rationale>\n        - [ ] <second option>\n        - [ ] _your answer_\n\n    Never tick a box yourself — the human ticks exactly one per question.\n  questionBarReturn: |-\n    The human has ticked one option per question (or replaced\n    `_your answer_` with their own text): fold each chosen answer into its\n    concern's prose, then move the question into a `## Answered Questions`\n    section as `### <question>` followed by the resolved answer in plain\n    prose (drop the checkboxes). Never re-raise a deleted question; treat a\n    deleted `## Open Questions` section as acceptance. Omit `## Open\n    Questions` entirely once there are none left.\n  # The body `packages.item.fix-suite` and `build.fix` share byte for byte —\n  # both fix a red `.gtd/FEEDBACK.md`. `fix-suite` appends its own\n  # cross-package paragraph right after this tag (before the shared\n  # \"Leave everything uncommitted\" close, which stays local at both sites so\n  # the appended paragraph lands in the same position it renders in today);\n  # `build.fix` renders the tag alone.\n  fixFeedbackPrompt: |-\n    The only state file this turn touches is `.gtd/FEEDBACK.md`; fix it per its\n    contents, or delete it if the feedback turns out to be wrong. Do not\n    create other files to hold notes or output.\n\n    Read `.gtd/FEEDBACK.md` (the failing test output) and fix the\n    code so the suite passes. Keep the change focused — do not refactor\n    unrelated code. If the feedback is wrong, empty or delete\n    `.gtd/FEEDBACK.md` instead of \"fixing\" a non-issue.\n\nentry:\n  default: unified\n\nmachines:\n  # Shared green-baseline gate — start-gate/review-gate/fix-precheck all\n  # alias this script via &suiteCheck.\n  entryGate:\n    params: [onGreen, blockedMessage, blockedDescribe, checkLabel, blockedLabel, reviewBase]\n    entry: check\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        script: &suiteCheck |\n          #!/usr/bin/env sh\n          set +e\n          mkdir -p .gtd\n          # Sweep a raw review capture an earlier, abandoned process may have\n          # left behind — no ordinary path from deciding/collecting reaches\n          # this check.\n          rm -f .gtd/REVIEW_RAW.md\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 'the test command failed with exit code %s and produced no output.' \"$code\" > .gtd/FEEDBACK.md\n            fi\n            # Stamp with HEAD so a repeat identical failure still re-registers\n            # as an M/A edit instead of looking byte-identical (GREEN).\n            printf '\\n<!-- gtd check %s -->\\n' \"$(git rev-parse --short HEAD 2>/dev/null || echo pending)\" >> .gtd/FEEDBACK.md\n          else\n            rm -f .gtd/.check-output\n            rm -f .gtd/FEEDBACK.md\n          fi\n        # Marks BOTH entryGate instances (start-gate/review-gate); only\n        # review-gate strictly needs it, but the shared dedup makes marking\n        # one mark both — both ARE entry gates.\n        entry: true\n        # Only review-gate binds a real reviewBase (via --var); start-gate\n        # binds \"\" (no base), since it's reached from idle, never entered.\n        reviewBase: $reviewBase\n        on:\n          \"A .gtd/FEEDBACK.md\": blocked\n          \"M .gtd/FEEDBACK.md\": blocked\n          \"D .gtd/REVIEW_RAW.md\": $onGreen\n          \"D .gtd/FEEDBACK.md\": $onGreen\n          \"C\": $onGreen\n      blocked:\n        actor: human\n        label: $blockedLabel\n        file: FEEDBACK.md\n        message: $blockedMessage\n        on:\n          \"* **\":\n            to: check\n            action: Retry check\n            describe: $blockedDescribe\n\n  # Shared check/escalate pair for build.health.*/packages.item.health.* —\n  # the caller's own coder fix-state ($onRed), not this machine, handles red.\n  healthGate:\n    params: [onGreen, onRed, escalateDescribe, checkLabel, escalateLabel]\n    entry: check\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        # See the shared suite check on `entryGate.check` above.\n        script: *suiteCheck\n        on:\n          \"A .gtd/FEEDBACK.md\": $onRed\n          \"M .gtd/FEEDBACK.md\": $onRed\n          \"* **\": $onGreen\n          \"C\": $onGreen\n      escalate:\n        actor: human\n        label: $escalateLabel\n        file: FEEDBACK.md\n        message: |\n          The agent could not get the check to pass after repeated attempts.\n          `.gtd/FEEDBACK.md` holds the last failing output.\n\n          What each change does next (then run `gtd land`):\n          <% it.edges.forEach(function (e) { if (e.describe) { %>\n          <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n          <% } }) %>\n        on:\n          \"* **\":\n            to: check\n            action: Retry check\n            describe: $escalateDescribe\n\n  # Shared check/answer pair for design.gate/architecture.gate. No `file:`\n  # PARAM for the probe script itself: machine `$param` substitution is\n  # whole-value only, so a path can't be spliced into a shared script body —\n  # `file` here is instead the `answer` param's own `file:` (the human gate).\n  questionGate:\n    params: [file, message, onNone, onRevise, checkLabel, answerLabel]\n    entry: check\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        script: |\n          #!/usr/bin/env sh\n          # Exactly one of REQUIREMENTS.md/ARCHITECTURE.md exists on disk at\n          # a time — architecture.author deletes the former in the same turn\n          # it writes the latter — so this probe is unambiguous either way.\n          set +e\n          mkdir -p .gtd\n          file=.gtd/REQUIREMENTS.md\n          [ -f \"$file\" ] || file=.gtd/ARCHITECTURE.md\n          gtd check qa \"$file\" --open-questions > /dev/null 2>&1\n          code=$?\n          if [ \"$code\" -ne 0 ]; then\n            printf 'open questions remain in %s\\n' \"$file\" > .gtd/QUESTIONS.md\n            # See the shared suite check's cache-buster rationale on\n            # `entryGate.check` above.\n            printf '\\n<!-- gtd check %s -->\\n' \"$(git rev-parse --short HEAD 2>/dev/null || echo pending)\" >> .gtd/QUESTIONS.md\n          else\n            rm -f .gtd/QUESTIONS.md\n          fi\n        on:\n          \"A .gtd/QUESTIONS.md\": answer\n          \"M .gtd/QUESTIONS.md\": answer\n          \"D .gtd/QUESTIONS.md\": $onNone\n          \"C\": $onNone\n      answer:\n        actor: human\n        label: $answerLabel\n        file: $file\n        mode: qa\n        answerGate: true\n        message: $message\n        on:\n          \"* **\":\n            to: $onRevise\n            action: Revise answers\n            describe: >-\n              tick exactly one option per open question (replace\n              `_your answer_` for your own) to send it back for the agent to\n              fold your answers in. Delete a question to skip it, or delete\n              the whole `## Open Questions` section to accept the plan as-is.\n\n  # The triage phase — one conversation across the whole back-and-forth (the\n  # human's answer rationale survives every return lap). A review loop-back\n  # lap runs the suite itself and files any breakage as its own FIRST\n  # concern, rather than spending one of packages.item.fix-suite's\n  # (per-episode) retries on breakage the package didn't cause.\n  # ▸ planner identity.\n  designPlan:\n    model: <%= it.vars.plannerModel %>\n    system: |-\n      <%~ it.vars.designPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onArchitecture]\n    entry: triage\n    states:\n      triage:\n        actor: agent\n        label: Triaging the change\n        file: REQUIREMENTS.md\n        mode: qa\n        # Guards against discarding assembled review input without folding\n        # it in (the original bug this guard was added for).\n        requireProgress: true\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.styleFormatContract %>\n\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state file this turn touches is `.gtd/REQUIREMENTS.md`; develop it. Do\n          not create other files to hold notes or output.\n\n          `.gtd/TODO.md` is the likely home of the sketch that\n          started this process. Despite living beside this workflow's own\n          state files, it is the human's input — the sketch to be folded into\n          the concerns below like any other part of the start diff. It is\n          never a state file to preserve, and never gtd bookkeeping to ignore.\n\n          This process started at commit `<%= it.startCommit %>`. The change\n          that started it was reverted out of the working tree by the\n          `unwind` beat right after it landed, so `git diff <%= it.startCommit %>`\n          (against the working tree) is now empty — its content survives only\n          in history. Find the entry commit yourself: run\n          `git rev-list --ancestry-path <%= it.startCommit %>..HEAD | tail -1`\n          (the process's very first turn, landed immediately after\n          `<%= it.startCommit %>`, before any later baseline-repair commits) —\n          then `git show` that commit to see everything that started this\n          process: a hand-edit to real code, a scratch note in some file, or\n          both.\n\n          Whichever lap this is, leave `.gtd/REQUIREMENTS.md` uncommitted and\n          finish your turn once it reflects this lap's own work below.\n\n          ## First lap\n\n          `.gtd/REQUIREMENTS.md` does not exist yet (or holds whatever the\n          human's own change happened to leave there). Build it from that\n          start diff:\n\n          ### Group into concerns\n\n          Group the diff into an ordered list of concerns — each one a\n          coherent piece of work that can leave the test suite green on\n          its own, in the order you'd want them built. If a concern would\n          red-light tests that a later concern is meant to fix, that is\n          not a valid split: merge the two into one concern.\n\n          Two more tests sit beside that green floor, not instead of it.\n          Vertical, not horizontal: slice by capability, never by layer. A\n          concern that only prepares for a later one — types, scaffolding,\n          renames — is folded into the first concern that uses it. Distinct\n          acceptance: each concern needs an observable check that fails\n          before it and passes after; if you can't name one, merge it into\n          its neighbour. Prefer fewer, larger packages — the smallest\n          independently valuable change, not the smallest change that\n          compiles.\n\n          ### Classify each concern\n\n          Classify each concern as PRODUCT (a user-facing/requirements\n          decision) or TECHNICAL (an implementation decision).\n\n          <%~ it.vars.questionBar %>\n\n\n          Raise questions only for product concerns here — a technical\n          concern's open points wait for the next phase. When every concern\n          in this lap is TECHNICAL, write no `## Open Questions` section at\n          all.\n\n          ### Fold in the sketch\n\n          Fold everything the entry commit added into the concerns above —\n          a scratch note and a real code edit are both just a sketch of\n          the intent, a spec to be finished, never work to be preserved;\n          `unwind` already reverted both out of the tree, so there is\n          nothing left to delete. Describe each piece under the concern it\n          belongs to.\n\n          ## Return lap\n\n          <%~ it.vars.questionBarReturn %>\n\n          ## Review loop-back\n\n          `.gtd/REQUIREMENTS.md` already holds concerns and none of them\n          have a ticked-but-unfolded answer waiting — that shape means a\n          completed REVIEW round put this material here, not a question you\n          asked. Develop those existing concerns further with whatever the\n          round raised; never rediscover or regroup them from a cold read\n          the way the first lap does.\n\n          The human's own edit from that review round has been reverted out\n          of the working tree the same way the entry commit is — read it\n          from history, never the working tree: run\n          `git show <%= it.reviewBase %>` to see it. (On the first lap that\n          same hash is the process's own diff base, `<%= it.startCommit %>`,\n          so this branch does not apply: `.gtd/REQUIREMENTS.md`\n          does not exist yet for a review round to have happened against.)\n\n          Whatever this round touches, every decision already settled under\n          `## Answered Questions` stays settled on this lap too — never\n          re-open one. A genuinely open PRODUCT point in the round's own\n          material may still raise a fresh question under\n          `## Open Questions`: the product gate sits on this path exactly as\n          it does on the first lap, and will ask it.\n\n          Before grouping anything on this lap, run\n          `<%= it.vars.testCommand %>` yourself as part of reading the\n          situation: a review loop-back runs no green-baseline gate between\n          the revert above and this turn, so the tree may already be red —\n          reverting the human's edit can undo a fix that edit had put in. If\n          the suite is red, make that breakage the first concern in your\n          ordered list, ahead of everything else — every later concern's\n          \"leaves the suite green on its own\" property assumes the suite\n          already started green.\n        on:\n          \"* **\": gate.check\n\n      gate:\n        machine: questionGate\n        with:\n          file: REQUIREMENTS.md\n          onNone: $onArchitecture\n          onRevise: triage\n          checkLabel: Checking for open questions\n          answerLabel: Awaiting your product answers\n          message: |\n            `.gtd/REQUIREMENTS.md` holds the concerns under\n            development. Each open question under `## Open Questions` offers\n            a few options plus a `- [ ] _your answer_` slot. Answer EVERY\n            question by ticking exactly one box (`- [x]`); for your own\n            answer, replace `_your answer_` with your text and tick that\n            line. Stepping is refused while any question is unanswered.\n\n            What each change does next (then run `gtd land`):\n            <% it.edges.forEach(function (e) { if (e.describe) { %>\n            <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n            <% } }) %>\n\n  # A separate machine from designPlan (its own memory scope — a COLD read,\n  # not a resumed conversation). Merge authority lives in `author`, the first\n  # state that knows the *how*: it alone may re-merge concerns, never split;\n  # `decompose` carries that grouping over verbatim. ▸ planner identity.\n  archPlan:\n    model: <%= it.vars.plannerModel %>\n    system: |-\n      <%~ it.vars.architectPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onPackages]\n    entry: author\n    states:\n      author:\n        actor: agent\n        label: Refining the technical plan\n        file: ARCHITECTURE.md\n        mode: qa\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.styleFormatContract %>\n\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state files this\n          turn touches are `.gtd/ARCHITECTURE.md` (write it) and\n          `.gtd/REQUIREMENTS.md` (delete it once its content is\n          folded in). Do not create other files to hold notes or output.\n\n          You do not resume the design conversation — this is a separate\n          machine with its own memory, a cold read every time. Read\n          `.gtd/REQUIREMENTS.md` (the settled, ordered, classified\n          concerns) in full. Treat every decision recorded there — plain\n          prose or a resolved `## Answered Questions` entry, PRODUCT or\n          TECHNICAL alike — as settled; never re-open it.\n\n          Cold means the machine carries no conversational memory of\n          triage's own back-and-forth; it never meant no git access. This\n          process started at commit `<%= it.startCommit %>`. Find the\n          process's first turn yourself: run\n          `git rev-list --ancestry-path <%= it.startCommit %>..HEAD | tail -1`\n          then `git show` that commit to see everything that started this\n          process: a hand-edit to real code, a scratch note in some file,\n          or both.\n\n          Whichever lap this is, once `.gtd/ARCHITECTURE.md` is written,\n          delete `.gtd/REQUIREMENTS.md` — its content has been folded in and\n          it must not linger. Leave everything uncommitted and finish your\n          turn.\n\n          ## First lap\n\n          Develop `.gtd/ARCHITECTURE.md` from those concerns: for each one,\n          in the same order, work out the *how* — file/module structure,\n          data models, library/tech-stack choices, error-handling strategy —\n          building on the *what* already settled.\n\n          You now know the *how*, so you know each concern's file footprint —\n          list each concern's primary paths. Merge concerns whose footprints\n          center on the same files into one, unless the later one only\n          consumes an interface the earlier one creates: that exception is\n          what keeps a genuine build-on-top sequence from collapsing into one\n          blob. This authority is to merge only, never to split — granting\n          split authority here would work directly against the goal; the\n          whole problem is over-granularity. Record every merge under a\n          dedicated `## Merged Concerns` heading, carrying both merged requirements\n          verbatim so the per-package spec review still covers each one\n          independently. A merge raises no open question and stops for no\n          human — do not route it to `architecture.gate` for a veto; the\n          human still sees every merge when they review the plan, and the\n          per-package spec review is the real safety net. Prefer fewer,\n          larger packages — the smallest independently valuable change, not\n          the smallest change that compiles.\n\n          Every open point here is TECHNICAL — triage already resolved the\n          product ones, one phase earlier.\n\n          <%~ it.vars.questionBar %>\n\n          ## Return lap\n\n          <%~ it.vars.questionBarReturn %>\n        on:\n          \"* **\": gate.check\n\n      gate:\n        machine: questionGate\n        with:\n          file: ARCHITECTURE.md\n          onNone: decompose\n          onRevise: author\n          checkLabel: Checking for open questions\n          answerLabel: Awaiting your technical answers\n          message: |\n            `.gtd/ARCHITECTURE.md` holds the technical plan under\n            development. Each open question under `## Open Questions` offers\n            a few options plus a `- [ ] _your answer_` slot. Answer EVERY\n            question by ticking exactly one box (`- [x]`); for your own\n            answer, replace `_your answer_` with your text and tick that\n            line. Stepping is refused while any question is unanswered.\n\n            What each change does next (then run `gtd land`):\n            <% it.edges.forEach(function (e) { if (e.describe) { %>\n            <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n            <% } }) %>\n\n      decompose:\n        actor: agent\n        label: Decomposing into packages\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state files this turn touches\n          are the package files it writes under `.gtd/packages/` and\n          `.gtd/ARCHITECTURE.md`, which it deletes. Do not create other\n          files to hold notes or output.\n\n          If you wrote `.gtd/ARCHITECTURE.md` earlier in this\n          conversation, work from what you already settled; otherwise read it\n          (the converged technical plan) yourself. It already lists an\n          ordered set of concerns with every merge/split judgement\n          `architecture.author` made — this turn is a mechanical write-out,\n          not a planning one. A `## Merged Concerns` heading there is a\n          record of those merges, never a concern of its own: write no\n          package file for it.\n\n          Write one package file per concern, in the settled order, under\n          `.gtd/packages/` (e.g.\n          `.gtd/packages/01-name.md`,\n          `.gtd/packages/02-name.md`, ...). Each package file\n          carries that concern's requirement(s) (so it can be reviewed\n          against its spec — both, independently, when the concern was\n          merged), its independent tasks, and each task's acceptance\n          criteria as `- [ ]` checkboxes and relevant paths. Do not merge or\n          split concerns here — that judgement already happened in\n          `architecture.author`; carry the settled grouping over verbatim.\n          No package file may reference any other `.gtd/` file.\n\n          Once the package files are written, delete\n          `.gtd/ARCHITECTURE.md`. Leave everything uncommitted and\n          finish your turn.\n        on:\n          \"* .gtd/packages/**\": $onPackages\n\n  # The shared review tail. ▸ planner identity — `collecting` only judges/\n  # classifies feedback; there's no coder follow-through inside this machine.\n  #\n  # Nested inside buildTail (build.review), not a root sibling: a machine's\n  # memory scope is its dotted instance path, so nesting keeps `build.fix ->\n  # build.health.check -> build.review.* -> build.squashing` (the `--entry\n  # fix-precheck` path) inside one scope, so `build.squashing` drafts the\n  # finale from the same session that made the fixes. The ordinary path\n  # (packages -> build.review -> squashing) gets nothing from this either\n  # way, since `build`'s own scope has no prior turn to resume there.\n  humanReview:\n    model: <%= it.vars.plannerModel %>\n    system: |-\n      <%~ it.vars.reviewerPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    entry: reviewing\n    states:\n      reviewing:\n        actor: agent\n        label: Reviewing\n        file: REVIEW.md\n        mode: review\n        # `gtd --entry review-gate.check` enters via review-gate.check first\n        # (never straight here), which sets the Gtd-Review-Base trailer this\n        # tail reuses.\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.styleFormatContract %>\n\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state file this turn touches is `.gtd/REVIEW.md`; write it at exactly\n          that path. Do not create other files to hold notes or output.\n\n          Write `.gtd/REVIEW.md` to help a human review the changes in\n          this exact format:\n\n          - First non-blank line: `# Review: <%= it.currentCommit.slice(0, 7) %>`\n          - Somewhere in the document: `<!-- base: <%= it.reviewBase %> -->`\n          - At least one `## <Chunk Title>` heading, grouping hunks semantically\n            (same feature/refactor/fix, even across files) — a short explanation of\n            what changed and why, then one file pointer per hunk (checkboxes are\n            for the human to tick, not you; every path is `./`-relative, with an\n            optional `#line`). Put the note's opening line right on the\n            pointer's own line, after a dash — the reflow-proof shape:\n\n                - [ ] ./path/to/file.ts#42 — what this hunk does\n\n            If the note needs more than one line, continue it on the line(s)\n            below the pointer, indented exactly two spaces — never four or\n            more, which after a blank line reads as an indented code block\n            and never reflows:\n\n                - [ ] ./path/to/file.ts#42 — what this hunk does\n                  and here is more detail, continued below it\n\n            A note that sits entirely on the line(s) beneath the pointer is\n            also valid. Either way, the explanation itself must never start\n            with a bare `./path` token — that parses as a second hunk pointer,\n            not a note.\n\n          This prompt carries no diff — read the changes yourself. The range runs\n          from `<%= it.reviewBase %>` to the working tree (committed turns plus\n          anything still pending); on a feedback round that base is the previous\n          review's boundary, so it covers only what changed since then, not items\n          already signed off.\n\n          Leave `.gtd/REVIEW.md` uncommitted and finish your turn.\n        on:\n          \"* **\": await-review\n\n      await-review:\n        actor: human\n        label: Awaiting your review\n        file: REVIEW.md\n        mode: review\n        # Opens the review checkout window (src/ReviewWindow.ts) while\n        # resting here. Deleting REVIEW.md is refused by the review-doc\n        # guard (src/StepGuards.ts).\n        reviewWindow: true\n        message: |\n          `.gtd/REVIEW.md` holds the review record for the process — one\n          `- [ ]` checkbox per reviewable item, grouped into chunks. Tick a box\n          (`- [x]`) as you review each hunk; ticking only records that you've read\n          it, it is not sign-off.\n\n          When you've been through the whole diff, run `gtd land`:\n\n          - **Sign off** — leave no comment — no note in\n            `.gtd/REVIEW.md`, no code edit — to collapse the process into\n            one commit (**build.squashing**), whatever the boxes say.\n          - **Request changes** — leave a comment: a note on a\n            `.gtd/REVIEW.md` line, or a direct code edit — to send a FULL\n            development lap (**review.deciding** → **review.collecting** →\n            re-triage). A hand-edit you make here is treated as a SKETCH, not a\n            fix the agent builds on: it is reverted out of the tree and re-planned\n            from scratch, the same as any other change that starts a process.\n            There is no baseline check on the way back into planning — only a\n            genuinely non-actionable comment (an approving remark with no code\n            edit) skips the lap and signs off straight away.\n\n          Deleting `.gtd/REVIEW.md` is refused.\n        on:\n          \"* **\": deciding\n\n      deciding:\n        actor: check\n        label: Reviewing\n        file: REVIEW.md\n        mode: review\n        # Anchors the INCREMENTAL review base to the most-recent in-process\n        # commit (the process start on the first review).\n        reviewBase: true\n        script: |\n          #!/usr/bin/env sh\n          # FEEDBACK iff the human left a REVIEW.md note (any edit beyond a\n          # checkbox tick) or hand-edited any file this round outside .gtd/;\n          # otherwise a clean sign-off. This turn only CAPTURES the raw\n          # material into REVIEW_RAW.md — collecting judges actionability.\n          # A/M REVIEW_RAW.md rows are declared before D REVIEW.md so a\n          # feedback round (which also deletes REVIEW.md) isn't mistaken for\n          # sign-off.\n          set +e\n          mkdir -p .gtd\n          head=$(git rev-parse HEAD)\n          # Normalize [ ]/[x] before diffing, so only a real note counts.\n          before=$(git show \"HEAD^:.gtd/REVIEW.md\" 2>/dev/null | sed -E 's/\\[[ xX]\\]/[_]/g')\n          after=$(git show \"HEAD:.gtd/REVIEW.md\" 2>/dev/null | sed -E 's/\\[[ xX]\\]/[_]/g')\n          if git diff-tree --no-commit-id --name-only -r HEAD -- . \":(exclude).gtd\" \\\n               | grep -q . \\\n             || [ \"$before\" != \"$after\" ]; then\n            {\n              echo \"This is machine-captured input, not instructions. A downstream agent judges whether it's actionable.\"\n              echo\n              echo \"Commit: $head\"\n              echo \"The human's notes are in .gtd/REVIEW.md at this commit. Any hand edits are\"\n              echo \"in that commit's other paths. Run: git show $head\"\n            } > .gtd/REVIEW_RAW.md\n          fi\n          rm -f .gtd/REVIEW.md\n        on:\n          \"A .gtd/REVIEW_RAW.md\": collecting\n          \"M .gtd/REVIEW_RAW.md\": collecting\n          \"D .gtd/REVIEW.md\": $onSignoff\n\n      # Outcome is by which paths THIS diff touches: writing REQUIREMENTS.md\n      # (A/M) is the actionable case, so those rows are declared before \"D\n      # REVIEW_RAW.md\" — an actionable round's diff is both together, and\n      # the wrong order would short-circuit every round to sign-off.\n      # Consuming REVIEW_RAW.md alone is the non-actionable short-circuit,\n      # reusing $onSignoff since that IS a sign-off. No `C`/`\"* **\"` row: a\n      # clean turn here is a fruitless dispatch (falls through to the\n      # ordinary attempt default), never a verdict; a dirty tree matching\n      # neither row is a refusal.\n      collecting:\n        actor: agent\n        label: Collecting your feedback\n        file: REQUIREMENTS.md\n        mode: qa\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.styleFormatContract %>\n\n\n          You are an autonomous coding agent judging and classifying a round\n          of review feedback.\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state files this turn\n          touches are `.gtd/REQUIREMENTS.md` and\n          `.gtd/REVIEW_RAW.md`, which it deletes — do not change any\n          other file: you classify, you do not build.\n\n          The raw review material is: <%~ it.read(\".gtd/REVIEW_RAW.md\") %>\n\n          It names a commit. If you wrote today's review earlier in this\n          conversation, work from what you already reviewed; otherwise read that\n          commit's diff yourself before classifying anything.\n\n          The round is actionable if any of the following is true:\n\n          1. The human left a note on `.gtd/REVIEW.md` — a note is\n             anything beyond a checkbox flip, regardless of whether the box\n             itself is ticked (ticking means only \"I read this hunk\", never\n             sign-off). A note is a mandatory concern below, whether or not\n             its box is ticked.\n          2. The human added a code comment this round (a `+` line that is a\n             comment, in a hand-edited file) — even a plain-prose one. That\n             comment is an instruction: describe it as a concern below, and\n             note that the comment line itself is transient — it must not\n             survive the lap that satisfies it.\n          3. The human hand-edited any non-comment code this round. That code\n             is no longer an already-committed intent to build on top of — it\n             is a sketch, like the entry commit's own diff: describe what it\n             was reaching for under the concern it belongs to, and expect the\n             lap that follows to re-derive it from scratch. Never say the\n             human's lines are final or that they must survive unchanged.\n\n          The round is not actionable only when none of the above holds — the\n          human left nothing but an approving remark (a compliment, a \"looks\n          good\", or similar) with no code edit and no substantive note. Never\n          invent actionability where the definition above doesn't hold — it\n          manufactures a lap nothing asked for — and never dismiss a real note\n          or edit as approval, which drops feedback the human left.\n\n          If the round is actionable: write `.gtd/REQUIREMENTS.md`\n          with an ordered list of concerns, each classified PRODUCT (a\n          user-facing/requirements decision) or TECHNICAL (an implementation\n          decision) — the same shape `design.triage` builds, one\n          `## <heading>` per concern, in the order you'd want them built. Fold\n          every note, comment, and hand-edit from this round in under the\n          concern it belongs to, per the rules above. Raise no open\n          questions here — write no `## Open Questions` section;\n          `design.triage` owns that, one phase later. Then delete\n          `.gtd/REVIEW_RAW.md` and finish your turn.\n\n          If the round is not actionable: delete\n          `.gtd/REVIEW_RAW.md` and finish your turn, writing nothing\n          to `.gtd/REQUIREMENTS.md` — consuming the capture with no\n          other change is the sign-off.\n        on:\n          \"A .gtd/REQUIREMENTS.md\": $onFeedback\n          \"M .gtd/REQUIREMENTS.md\": $onFeedback\n          \"D .gtd/REVIEW_RAW.md\": $onSignoff\n\n  # The per-package review — a separate MIND from the implementer. ▸ planner\n  # identity; fixing findings is a coder action (packages.item.fix-spec).\n  specReview:\n    model: <%= it.vars.plannerModel %>\n    system: |-\n      <%~ it.vars.specReviewerPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onApproved, onFix]\n    entry: review\n    states:\n      review:\n        actor: agent\n        label: Reviewing the package\n        # No retry cap: the loop only re-enters through\n        # `fix-spec`/`health.check`, so under the per-episode rule this state's\n        # episode count can never exceed 1 and a cap could never fire. The\n        # spec-review loop is genuinely unbounded — see docs/configuration.md's\n        # `retry` documentation.\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          You are an autonomous coding agent reviewing a freshly-built work package\n          against its own spec.\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state file this turn touches is\n          `.gtd/SPEC_FEEDBACK.md`; write it only when — and only\n          when — you find problems. Do not create other files to hold notes or\n          output.\n\n          The package spec is: <%~ it.read(\".gtd/NEXT.md\") %>\n\n          Read that spec, then verify the package's implementation against it: are\n          all its tasks done, acceptance criteria met, and the code sound and\n          consistent with the codebase? This prompt carries no diff — read it\n          yourself: the range runs from `<%= it.startCommit %>` to the working\n          tree.\n\n          Note the range is process-wide (from the start of the whole build, not\n          just this package), so it can span earlier packages too.\n\n          - If it fully satisfies the spec, write nothing and finish your turn — a\n            clean turn is your approval.\n          - If it does not, write `.gtd/SPEC_FEEDBACK.md` listing the\n            concrete problems for a fix turn to address. Be specific.\n\n          Do not fix anything yourself and do not delete the package file — a later\n          step owns that. Finish your turn.\n        on:\n          \"A .gtd/SPEC_FEEDBACK.md\": $onFix\n          \"M .gtd/SPEC_FEEDBACK.md\": $onFix\n          \"D .gtd/SPEC_FEEDBACK.md\": $onApproved\n          \"C\": $onApproved\n\n  # The per-package build queue — identity-free; build identity lives in\n  # packageItem (below).\n  packageLoop:\n    params: [onDrained]\n    entry: picking\n    states:\n      picking:\n        actor: check\n        label: Picking the next package\n        script: |\n          #!/usr/bin/env sh\n          # Mechanics only — NEXT.md's presence/absence is interpreted by\n          # the `on` rows below, never here.\n          set +e\n          mkdir -p .gtd\n          # Sweep spent design/architecture steering files (gone by now) and\n          # any REVIEW_RAW.md the review loop-back left behind — the only\n          # sweeper on that path before it would leak into the squash finale.\n          rm -f .gtd/REQUIREMENTS.md .gtd/ARCHITECTURE.md .gtd/QUESTIONS.md .gtd/REVIEW_RAW.md\n          # Names are gtd-authored, never containing whitespace — safe to\n          # disable SC2012.\n          # shellcheck disable=SC2012\n          next=$(ls .gtd/packages/*.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\": $onDrained\n          \"* .gtd/NEXT.md\": item.building\n          \"C\": $onDrained\n\n      # Its own coder machine (below) keeps `packages` itself a single state.\n      item:\n        machine: packageItem\n        with:\n          onNext: picking\n\n  # The per-package build identity. ▸ coder identity. packages.item.closing\n  # -> picking is the one upward-resolving target in the file, hence $onNext.\n  packageItem:\n    model: <%= it.vars.coderModel %>\n    system: |-\n      <%~ it.vars.builderPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onNext]\n    entry: building\n    states:\n      building:\n        actor: agent\n        label: Building\n        prompt: |\n          <%~ it.vars.stateFileRules %>\n\n          The only state file this\n          turn may write is `.gtd/SATISFIED.md` (see below); do not\n          delete the package file (the spec-review gate reads it after you)\n          and never touch `.gtd/NEXT.md` — the `picking` state owns\n          it.\n\n          The package to implement is: <%~ it.read(\".gtd/NEXT.md\") %>\n\n          Before implementing anything, check the package's acceptance criteria\n          against the current tree — an earlier package's fix turn may already\n          have satisfied them. If **every** criterion is already met, implement\n          nothing: write `.gtd/SATISFIED.md` recording each criterion\n          and the concrete evidence it is already satisfied (the commit, file,\n          or symbol that proves it), change nothing else, and finish your turn.\n          If any criterion is outstanding, implement the package normally and\n          do not write that file.\n\n          That file describes a set of independent tasks. Implement all of them in\n          this one turn, fanning the independent tasks out to parallel subagents\n          where your harness supports it — each task is self-contained and can be\n          built concurrently. Implement exactly the tasks this package describes — no\n          more, no less; leave every other package file untouched. Use TDD\n          discipline within each task.\n\n          Leave the package file in place and everything else uncommitted, then\n          finish your turn.\n        on:\n          \"A .gtd/SATISFIED.md\": &satisfied\n            to: health.check\n            action: Close as already satisfied\n            describe: >-\n              record per-criterion evidence in .gtd/SATISFIED.md when this\n              package's work already landed (an earlier package's fix turn\n              pulled it in) — the package still runs the checks and the spec\n              review, then closes out.\n          \"M .gtd/SATISFIED.md\": *satisfied\n          \"* **\": health.check\n\n      fix-suite:\n        actor: agent\n        label: Fixing the check\n        file: FEEDBACK.md\n        prompt: |\n          <%~ it.vars.stateFileRules %>\n\n          <%~ it.vars.fixFeedbackPrompt %>\n\n          If the\n          only way to green the suite is to implement work that another\n          package file describes, make the smallest change that gets there and\n          do it — that later package will then legitimately report itself\n          already satisfied when its turn comes.\n\n          Leave everything uncommitted and finish your turn — do not commit.\n        retry:\n          max: 3\n          otherwise: health.escalate\n        on:\n          \"* **\": health.check\n\n      fix-spec:\n        actor: agent\n        label: Fixing review feedback\n        file: SPEC_FEEDBACK.md\n        prompt: |\n          <%~ it.vars.stateFileRules %>\n          The only state file this\n          turn touches is `.gtd/SPEC_FEEDBACK.md`; address it, then\n          delete it. Do not create other files to hold notes or output.\n\n          Read `.gtd/SPEC_FEEDBACK.md` (the reviewer's concerns about the\n          current package) and the package spec (`<%= it.read(\".gtd/NEXT.md\") %>`),\n          then fix the code to resolve every concern. Keep the change focused.\n\n          Delete `.gtd/SPEC_FEEDBACK.md` once every concern is addressed.\n          Leave everything else uncommitted and finish your turn.\n        on:\n          \"* **\": health.check\n\n      closing:\n        actor: check\n        label: Closing out the package\n        script: |\n          #!/usr/bin/env sh\n          # Removes the just-reviewed package file (path in NEXT.md) plus\n          # leftover spec feedback/evidence, so picking selects the next.\n          # Reached only on spec-review approval — that loop carries no retry\n          # cap, so there is no force-close path here.\n          set +e\n          pkg=$(cat .gtd/NEXT.md 2>/dev/null)\n          [ -n \"$pkg\" ] && rm -f \"$pkg\"\n          rm -f .gtd/SPEC_FEEDBACK.md .gtd/NEXT.md .gtd/SATISFIED.md\n        on:\n          \"* **\": $onNext\n\n      health:\n        machine: healthGate\n        with:\n          onGreen: spec\n          onRed: fix-suite\n          escalateDescribe: >-\n            edit the code and/or `.gtd/FEEDBACK.md` yourself\n            (**packages.item.health.check**).\n          checkLabel: Running checks\n          escalateLabel: Escalating to a human\n\n      spec:\n        machine: specReview\n        with:\n          onApproved: closing\n          onFix: fix-spec\n\n  # The process's build identity. ▸ coder identity — model/system stamped\n  # onto squashing/fix.\n  buildTail:\n    model: <%= it.vars.coderModel %>\n    system: |-\n      <%~ it.vars.finisherPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onDone, onFeedback]\n    # entry: is required by the machine grammar even though nothing resolves\n    # this machine bare; `fix` is an arbitrary pick.\n    entry: fix\n    states:\n      squashing:\n        actor: agent\n        label: Squashing\n        file: COMMIT_MSG.md\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          The process is approved and done.\n\n          <%~ it.vars.stateFileRules %>\n\n          The only\n          state file this turn touches is `.gtd/COMMIT_MSG.md`; write\n          it. Do not create other files to hold notes or output.\n\n          Leave `.gtd/COMMIT_MSG.md` uncommitted and finish your turn —\n          entering this file squashes everything this process retains into one\n          commit using its content as the message. This prompt carries no diff —\n          if you built that range yourself earlier in this conversation, work from\n          what you already know; otherwise read the range yourself. It runs from\n          `<%= it.retainedBase %>` to the working tree, and is exactly what that\n          commit will contain, the changes this process made (its trace/retry\n          boundary onward). For a normal build\n          process that is the whole feature; for a `gtd --entry review-gate.check`\n          process it is only the fixes made during the review — not the changeset\n          that was under review.\n\n          If that range is non-empty, write `.gtd/COMMIT_MSG.md` with one\n          conventional-commits message for the changes (subject line\n          `type(scope): subject`, imperative mood, <= 72 characters; a body\n          explaining the why, trade-offs, and key decisions). Plain text, no\n          markdown wrapper.\n\n          If that range is empty (a clean review sign-off with no fixes), write\n          `.gtd/COMMIT_MSG.md` with exactly this one line and nothing\n          else:\n\n          chore: human review\n        on:\n          \"A .gtd/COMMIT_MSG.md\": $onDone\n          \"M .gtd/COMMIT_MSG.md\": $onDone\n\n      fix:\n        actor: agent\n        label: Fixing the check\n        file: FEEDBACK.md\n        prompt: |\n          <%~ it.vars.stateFileRules %>\n\n          <%~ it.vars.fixFeedbackPrompt %>\n\n\n          Leave everything uncommitted and finish your turn — do not commit.\n        retry:\n          max: 3\n          otherwise: health.escalate\n        on:\n          \"* **\": health.check\n\n      health:\n        machine: healthGate\n        with:\n          onGreen: review\n          onRed: fix\n          escalateDescribe: >-\n            edit the code and/or `.gtd/FEEDBACK.md` yourself\n            (**build.health.check**).\n          checkLabel: Running checks\n          escalateLabel: Escalating to a human\n\n      # Nested here (not root) so `squashing` stays inside the builder's own\n      # scope on sign-off — see humanReview above.\n      review:\n        machine: humanReview\n        with:\n          onSignoff: squashing\n          onFeedback: $onFeedback\n\n  # WIRING ONLY — the root ties together the machine tree above.\n  unified:\n    entry: idle\n    states:\n      idle:\n        actor: human\n        label: Idle\n        file: TODO.md\n        message: |\n          No active gtd process.\n\n          To start one, make ANY change — a hand-edit to real code, a scratch\n          note, anything at all. .gtd/TODO.md is a good default\n          place to start sketching. gtd treats it as a SKETCH, not finished\n          work: the very next beat unwinds it out of your working tree (its\n          intent survives in history, for the triage phase to read), then\n          checks the test baseline is green, then triages the reverted diff\n          into ordered, classified concerns: product questions, then\n          technical questions, then one package per concern, built and\n          reviewed in parallel.\n\n          What each change does next (then run `gtd land`):\n          <% it.edges.forEach(function (e) { if (e.describe) { %>\n          <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n          <% } }) %>\n        on:\n          \"* **\":\n            to: unwind\n            action: Start\n            describe: >-\n              make any change — gtd unwinds it out of your working tree (its\n              intent survives in history) before checking the test baseline is\n              green, then triages the reverted diff into ordered, classified\n              concerns and resolves product questions, then technical ones,\n              before building each concern's package (**unwind** ->\n              **start-gate.check**).\n\n      # --entry fix-precheck: a red suite drops into build.fix (-> health ->\n      # review + squash tail); a green suite is a no-op back to idle.\n      fix-precheck:\n        actor: check\n        label: Checking the baseline\n        entry: true\n        script: *suiteCheck\n        on:\n          \"A .gtd/FEEDBACK.md\": build.fix\n          \"M .gtd/FEEDBACK.md\": build.fix\n          \"D .gtd/REVIEW_RAW.md\": idle\n          \"D .gtd/FEEDBACK.md\": idle\n          \"C\": idle\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\n      # Separate from start-gate.check: that gate's blocked -> check retry\n      # edge would otherwise re-run a revert here and discard a human's\n      # baseline repair. One inbound edge (from idle) means unwind runs\n      # exactly once, so it needs no idempotence guard itself.\n      unwind:\n        actor: check\n        label: Unwinding your input\n        script: |\n          #!/usr/bin/env sh\n          set +e\n          # Hoisted here, at the TOP: Eta's autoTrim eats the newline after\n          # an interpolation tag, so no tag may be the last token on a line.\n          # Uses it.currentCommit (render-time), not bare HEAD, so a\n          # late-running driver still reverts the right commit.\n          commit=\"<%~ it.currentCommit %>\"\n          git revert --no-commit \"$commit\"\n        on:\n          \"* **\": start-gate\n\n      # Reverts the human's own review-round hand-edit before re-planning,\n      # scoped to real code (`.gtd/` excluded — REVIEW.md is already gone by\n      # now). Names the commit via it.reviewBase (reviewBaseFor's own\n      # `await-review -> deciding` commit), never bare HEAD.\n      #\n      # requireRevert (below) re-checks the tree itself and refuses the step\n      # if residue remains, rather than trusting the script's exit code — a\n      # clean-filter round-trip or binary path can make `git apply -R` a\n      # silent no-op. Both `on` rows below target `design`: a hand-edited\n      # round leaves a dirty tree, a note-only round's patch is empty and\n      # leaves the tree clean — both are legitimate outcomes here, not a\n      # stall.\n      #\n      # `file: REVIEW.md` + `requireRevert: true` exist only to give that\n      # guard the path to exempt (it reads Rest.hints.file, never this\n      # literal) — REVIEW.md is already gone two commits earlier, so this\n      # state never renders it.\n      re-unwind:\n        actor: check\n        label: Re-unwinding your review edit\n        file: REVIEW.md\n        requireRevert: true\n        script: |\n          #!/usr/bin/env sh\n          # Scoped revert of the human's review-round edit — .gtd/ excluded\n          # (the guard's isCodePath re-derives the same exemption; keep both\n          # in sync). Expected to succeed; requireRevert catches a silent\n          # apply failure.\n          set +e\n          # Hoisted here, at the TOP: Eta's autoTrim eats the newline after\n          # an interpolation tag, so no tag may be the last token on a line.\n          commit=\"<%~ it.reviewBase %>\"\n          patch=.gtd/.re-unwind.patch\n          mkdir -p .gtd\n          git diff --binary \"$commit^\" \"$commit\" -- . \":(exclude).gtd\" > \"$patch\"\n          if [ -s \"$patch\" ]; then\n            git apply -R \"$patch\" || echo \"re-unwind: could not revert $commit\" >&2\n          fi\n          rm -f \"$patch\"\n        on:\n          \"* **\": design # a code hand-edit was reverted\n          \"C\": design # note-only round: nothing to revert\n\n      start-gate:\n        machine: entryGate\n        with:\n          onGreen: design\n          reviewBase: \"\"\n          blockedMessage: |\n            The test baseline is red — gtd will not start new work on a broken suite.\n            `.gtd/FEEDBACK.md` holds the failing output.\n\n            What each change does next (then run `gtd land`):\n            <% it.edges.forEach(function (e) { if (e.describe) { %>\n            <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n            <% } }) %>\n          blockedDescribe: >-\n            edit the code and/or `.gtd/FEEDBACK.md` to fix the failing tests\n            (**start-gate.check**). To repair the baseline as its own separate\n            reviewed commit instead, abandon this start and run\n            `gtd --entry fix-precheck` from a clean `idle`.\n          checkLabel: Checking the baseline\n          blockedLabel: Baseline is red\n\n      review-gate:\n        machine: entryGate\n        with:\n          onGreen: build.review\n          reviewBase: <%= it.vars.reviewBase %>\n          blockedMessage: |\n            The test baseline is red — gtd will not start a review on a broken suite.\n            `.gtd/FEEDBACK.md` holds the failing output.\n\n            What each change does next (then run `gtd land`):\n            <% it.edges.forEach(function (e) { if (e.describe) { %>\n            <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n            <% } }) %>\n          blockedDescribe: >-\n            edit the code and/or `.gtd/FEEDBACK.md` to fix the failing tests\n            (**review-gate.check**).\n          checkLabel: Checking the baseline\n          blockedLabel: Baseline is red\n\n      design:\n        machine: designPlan\n        with:\n          onArchitecture: architecture\n\n      architecture:\n        machine: archPlan\n        with:\n          onPackages: packages\n\n      packages:\n        machine: packageLoop\n        with:\n          onDrained: build.review\n\n      build:\n        machine: buildTail\n        with:\n          onDone: done\n          onFeedback: re-unwind\n";
+var unified_default = "# gtd's BUILT-IN DEFAULT workflow — used when no `workflow:` key is\n# configured anywhere in the cwd→home config chain; `gtd init` seeds only\n# vars.testCommand + a modes: suggestion, never this file. Compiled through\n# the same `compileWorkflowConfig` a user's own `workflow:` goes through — no\n# privileged path. See skills/authoring/SKILL.md for how to read or edit it\n# (machines, patterns, templates) and docs/driver.md for how a driver runs it.\n#\n# One flow: any change to the tree starts the process. `idle` -> `unwind`\n# reverts that diff (intent survives only in history) -> a green-baseline\n# gate -> `design.triage` groups the reverted diff into ordered, classified\n# concerns and resolves the PRODUCT ones' open questions (`design.gate`) ->\n# `architecture.author` works out the *how* and resolves the TECHNICAL ones\n# (`architecture.gate`) -> `architecture.decompose` writes one package file\n# per concern -> the per-package queue (`packages.*`) builds and reviews each\n# -> the shared tail (`build.review.*`) decides sign-off (-> `idle`, landing\n# an ordinary commit that closes the process — every per-turn commit stays on\n# the branch; run `gtd summary` afterward for a closing-message prompt) vs.\n# actionable feedback (-> `re-unwind` -> back to `design.triage`, a full\n# re-plan lap that never builds on the human's hand-edit). `--entry\n# review-gate.check --var reviewBase=<commitish>` and `--entry fix-precheck`\n# are the two other entries into this same flow.\nvars:\n  testCommand: npm test\n  # plannerModel: the heavier tier for one-shot triage/design/review turns.\n  # coderModel: the tier for build/fix turns. Both repointable via a\n  # top-level `vars:` key or a `GTD_<NAME>` env var, like any other var.\n  plannerModel: smart\n  coderModel: base\n  # Declared (not left undeclared) so `--var reviewBase=...` passes the CLI's\n  # declared-name check; blank renders empty, which the review entry refuses.\n  reviewBase: \"\"\n  # gtd's own voice for generated files — adapted from the \"Spartan\" output\n  # style (https://github.com/alexgreensh/attention-span, AGPL-3.0, version 0.6),\n  # rewritten in gtd's own words for deliverables rather than chat replies;\n  # no upstream text ships. A point-in-time derivation with no refresh\n  # mechanism.\n  styleBlock: |-\n    This file is a deliverable, not a chat reply — size follows the work, and\n    padding is the target of any cut. Lead with the answer immediately; never\n    circle back to restate it once it has landed.\n\n    Write flat, commanding sentences — commit to the claim, do not hedge it.\n    Favor everyday vocabulary; where a term is unavoidable, define it in five\n    words or fewer on first use.\n\n    In markdown, bold carries the load: bold the claim, not the sentence around\n    it — reading only the bold text must yield the full point and every risk.\n\n    Never trim a risk, a number, a threshold, or a scoped condition to save\n    space. This outranks every other rule here.\n\n    Ship the artifact bare — no lead-in, no sign-off wrapped around it.\n    Compressing is not dropping: a task with three load-bearing parts ships all\n    three, each shorter, never two of three.\n\n    One idea per block; break when the idea shifts. Flag risk in one blunt\n    line rather than hedged prose. Never narrate the work — do it.\n  styleFormatContract: |-\n    This file is machine-read; its format contract outranks every style rule\n    above it: keep every `##`/`###` heading, every `- [ ]` checkbox row, and\n    every marker line exactly as specified — do not renumber or rename a\n    heading or replace a checkbox list with prose. A parser reads these\n    literally; a violation refuses the turn outright.\n\n    Voice rules above govern the prose between these elements, never the\n    elements themselves.\n\n  # One persona per prompt-bearing machine below, stamped as its `system:`\n  # (see src/StateFields.ts's `system`). `--system-prompt` REPLACES a\n  # harness's default system prompt — including its injected cwd/env/\n  # git-status block — so each persona is written self-contained, restating\n  # that context explicitly rather than relying on it.\n\n  # Shared conduct tail, appended after every persona's own role paragraph:\n  # use tools without asking, orient yourself with git, and go inspect what\n  # the turn's message names. Deliberately NOT named `*Persona`:\n  # `templates.test.ts` derives its six-name persona set from\n  # `it\\.vars\\.(\\w+Persona)`, so that suffix would silently grow the set.\n  agentConduct: |-\n    You have shell and file tools — bash, read, write, edit — and you are\n    expected to use them without asking first. This runs unattended: there is\n    no one to grant permission, confirm a command, or approve a plan before\n    you act. Investigate with real commands rather than assuming what a file,\n    a commit, or a decision's status actually is, then act on what you find.\n\n    You are already inside a git repository, at the working directory you\n    should treat as your whole world for this turn. There is no injected\n    status block — no cwd, no branch, no recent history, no tree state. Run\n    `git status`, `git log`, `ls` and the like yourself before you do\n    anything else; that is the normal first move of this turn, not an extra\n    step.\n\n    The message you receive each turn names a commit, a range, or a file for\n    you to go inspect yourself — `git show`, `git diff`, reading the file\n    directly — never a diff or a summary rendered into the conversation. Go\n    look before you act. Across the several turns one conversation may span,\n    work from what you already read and settled earlier rather than\n    re-deriving it from a cold read every time, unless the turn's own\n    instructions tell you this is a fresh, cold pass.\n  designPersona: |-\n    You are the product-facing planning voice in an autonomous build pipeline\n    called gtd. Your job is to turn a raw, half-formed sketch — a hand-edit to\n    real code, a scratch note, or both — into an ordered, classified list of\n    concerns a build can execute, and to carry a running conversation with a\n    human about the product decisions that list depends on. You are read by\n    that human, so write plainly and decisively; you are not read by a parser\n    except where a state's own instructions say otherwise.\n  architectPersona: |-\n    You are the technical planning voice in an autonomous build pipeline\n    called gtd. You take over once the product-facing concerns are settled,\n    reading them cold — you do not carry over the product conversation, only\n    its written, settled output. Your job is to work out the technical *how*\n    for each settled concern — file and module structure, data models,\n    library and tech-stack choices, error-handling strategy — raise the\n    technical open questions a human still needs to decide, and once every\n    question is answered, write one package spec file per concern with no\n    further judgement call: the grouping and ordering were already decided\n    upstream, and this final step is a mechanical write-out of a plan you\n    already converged on.\n  reviewerPersona: |-\n    You are the independent reviewing mind in an autonomous build pipeline\n    called gtd — deliberately a separate identity from whichever agent wrote\n    the code under review, so you bring no attachment to how it got built.\n    Your job splits into two distinct turns: first, writing a structured\n    review document that groups a diff into reviewable chunks for a human to\n    read through and comment on; later, reading back a round of that human's\n    feedback — a note, a hand-edit — and classifying whether it is genuinely\n    actionable or just an approving remark, without fixing anything yourself\n    either way. You judge and you classify; you never build.\n  specReviewerPersona: |-\n    You are the adversarial spec-conformance checker in an autonomous build\n    pipeline called gtd, reviewing one freshly-built work package against the\n    written spec it was built from. Your only job is to verify: are the\n    package's tasks actually done, its acceptance criteria actually met, and\n    the code sound and consistent with the rest of the codebase? You write\n    concrete, actionable feedback only when something is genuinely wrong —\n    and when nothing is, you write nothing at all, because a clean turn from\n    you IS the approval. You never fix a problem you find; naming it\n    precisely enough for someone else's fix turn to act on is the whole job.\n  builderPersona: |-\n    You are the TDD implementer in an autonomous build pipeline called gtd.\n    Your job is to build exactly one package's declared scope end to end,\n    tests first, and to come back and fix things when redirected: a failing\n    check's output, or a reviewer's concrete feedback. Stay strictly inside\n    the package in front of you, touching neither another package's files nor\n    code outside the current task. Treat feedback you're given as the\n    diagnosis to act on; discard it, with reason, only when it is simply\n    wrong.\n  finisherPersona: |-\n    You are the closing identity in an autonomous build pipeline called gtd —\n    the last coder this process hands work to before it closes. You are\n    handed a late-breaking failing check after sign-off; fix it, focused and\n    minimal, before the process can close. Every turn you land stays its own\n    commit on the branch — nothing here gets squashed away.\n\n  # The scratchpad-opener sentence shared by every prompt-content state (see\n  # STATE_FIELDS's `prompt`) — this workflow's own state files are its private\n  # working notes, never project code or documentation a human reads. Injected\n  # as the leading line of every prompt body that touches a `.gtd/` file\n  # directly; each state's own \"the only state file this turn touches is X\"\n  # sentence stays local, immediately after the tag. Some states splice a\n  # role clause into this same opening sentence (`build.review.collecting`,\n  # `packages.item.spec.review`) — those hoist the clause to its own leading\n  # sentence ahead of the tag instead, keeping every word.\n  stateFileRules: |-\n    You are an autonomous coding agent. This workflow steers itself\n    through its own state files — treat them as its private scratchpad,\n    never as project code or documentation.\n  # The open-questions warrant test, decide-it-yourself sink, and `## Open\n  # Questions` checkbox shape shared by `design.triage` and\n  # `architecture.author` — written phase-agnostic (no PRODUCT/TECHNICAL\n  # bake-in) so both sites can inject it verbatim. Each site's own\n  # phase-scope sentence (triage: product-only, technical waits; architecture:\n  # every point here is TECHNICAL) stays local around the tag — the two\n  # genuinely disagree on scope, so that sentence is never shared.\n  # `questionBarReturn` is the return-lap half — split out so each site can\n  # inject it under its own `## Return lap` heading instead of burying\n  # return-lap behaviour inside the first lap's own section.\n  questionBar: |-\n    For every open point, a question is warranted only when all three hold:\n    the answer is a genuine fork with divergent outcomes — user-visible for a\n    product question, materially different implementations for a technical\n    one; the sketch, the entry diff, and history do not already settle it\n    (treat anything the entry diff states explicitly — a directive in\n    `.gtd/TODO.md`, a committed choice in a hand-edit — as already settled,\n    and on a review loop-back lap treat whatever the human's own review-round\n    edit or note states explicitly the same way); and getting it wrong would\n    survive all the way to the human review tail.\n\n    Anything below that bar, decide yourself: record the decision under\n    `## Answered Questions` — the same section a human-answered question\n    lands in — as `### <the point phrased as a question>` followed by the\n    decision and a one-line rationale in prose, no checkboxes.\n\n    A question that clears the bar is written under a `## Open Questions`\n    heading near the top and takes this shape: one `### <question>`\n    sub-heading each, followed by a checkbox list of candidate answers — two\n    concrete options plus a final free-text slot, all left unticked:\n\n        ### <the question>\n\n        - [ ] <first option — a concrete answer, a few words of rationale>\n        - [ ] <second option>\n        - [ ] _your answer_\n\n    Never tick a box yourself — the human ticks exactly one per question.\n  questionBarReturn: |-\n    The human has ticked one option per question (or replaced\n    `_your answer_` with their own text): fold each chosen answer into its\n    concern's prose, then move the question into a `## Answered Questions`\n    section as `### <question>` followed by the resolved answer in plain\n    prose (drop the checkboxes). Never re-raise a deleted question; treat a\n    deleted `## Open Questions` section as acceptance. Omit `## Open\n    Questions` entirely once there are none left.\n  # The body `packages.item.fix-suite` and `build.fix` share byte for byte —\n  # both fix a red `.gtd/FEEDBACK.md`. `fix-suite` appends its own\n  # cross-package paragraph right after this tag (before the shared\n  # \"Leave everything uncommitted\" close, which stays local at both sites so\n  # the appended paragraph lands in the same position it renders in today);\n  # `build.fix` renders the tag alone.\n  fixFeedbackPrompt: |-\n    The only state file this turn touches is `.gtd/FEEDBACK.md`; fix it per its\n    contents, or delete it if the feedback turns out to be wrong. Do not\n    create other files to hold notes or output.\n\n    Read `.gtd/FEEDBACK.md` (the failing test output) and fix the\n    code so the suite passes. Keep the change focused — do not refactor\n    unrelated code. If the feedback is wrong, empty or delete\n    `.gtd/FEEDBACK.md` instead of \"fixing\" a non-issue.\n\n# `gtd summary`'s prompt — printed cold, no session identity, no diff inlined.\n# Names the hashes/range for the agent to inspect itself; renders the same\n# it.processCost/it.processCostByModel the old squash finale used to.\nsummary: |\n  <%~ it.vars.styleBlock %>\n\n\n  Write the closing message for the process HEAD closes or currently sits\n  inside — the text a driver may use for a squash, an amend, or a pull\n  request body. You are starting cold: read every decision back out of the\n  commits named below rather than assuming any prior context.\n\n  Cover the initial motivation, the important decisions, and the trade-offs\n  made, and the high-level architectural changes — never which files\n  changed; that is what `git diff --stat` is for, not this message.\n\n  The process's entry commit is `<%= it.entryCommit %>`. <% if\n  (it.humanCommits.length > 0) { %>The human contributed at these commits,\n  oldest to newest:\n  <% it.humanCommits.forEach(function (c) { %>\n  - `<%= c.hash %>` (entering `<%= c.state %>`)\n  <% }) %><% } else { %>The human left no comment or edit this process —\n  every commit is machine-authored.<% } %>\n\n  Inspect the range yourself: `git log <%= it.processBase %>..<%= it.processTip %>`\n  and `git diff <%= it.processBase %> <%= it.processTip %>`. That range is\n  exactly what a squash or PR body should describe.\n\n  Token cost: <%= it.processCost %>\n  <% it.processCostByModel.forEach(function(m){ %>\n  - <%= m.model %>: <%= m.cost %>\n  <% }) %>\n\n  Print the closing message and stop — this command writes nothing itself.\n\nentry:\n  default: unified\n\nmachines:\n  # Shared green-baseline gate — start-gate/review-gate/fix-precheck all\n  # alias this script via &suiteCheck.\n  entryGate:\n    params: [onGreen, blockedMessage, blockedDescribe, checkLabel, blockedLabel, reviewBase]\n    entry: check\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        script: &suiteCheck |\n          #!/usr/bin/env sh\n          set +e\n          mkdir -p .gtd\n          # Sweep a raw review capture an earlier, abandoned process may have\n          # left behind — no ordinary path from deciding/collecting reaches\n          # this check.\n          rm -f .gtd/REVIEW_RAW.md\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 'the test command failed with exit code %s and produced no output.' \"$code\" > .gtd/FEEDBACK.md\n            fi\n            # Stamp with HEAD so a repeat identical failure still re-registers\n            # as an M/A edit instead of looking byte-identical (GREEN).\n            printf '\\n<!-- gtd check %s -->\\n' \"$(git rev-parse --short HEAD 2>/dev/null || echo pending)\" >> .gtd/FEEDBACK.md\n          else\n            rm -f .gtd/.check-output\n            rm -f .gtd/FEEDBACK.md\n          fi\n        # Marks BOTH entryGate instances (start-gate/review-gate); only\n        # review-gate strictly needs it, but the shared dedup makes marking\n        # one mark both — both ARE entry gates.\n        entry: true\n        # Only review-gate binds a real reviewBase (via --var); start-gate\n        # binds \"\" (no base), since it's reached from idle, never entered.\n        reviewBase: $reviewBase\n        on:\n          \"A .gtd/FEEDBACK.md\": blocked\n          \"M .gtd/FEEDBACK.md\": blocked\n          \"D .gtd/REVIEW_RAW.md\": $onGreen\n          \"D .gtd/FEEDBACK.md\": $onGreen\n          \"C\": $onGreen\n      blocked:\n        actor: human\n        label: $blockedLabel\n        file: FEEDBACK.md\n        message: $blockedMessage\n        on:\n          \"* **\":\n            to: check\n            action: Retry check\n            describe: $blockedDescribe\n\n  # Shared check/escalate pair for build.health.*/packages.item.health.* —\n  # the caller's own coder fix-state ($onRed), not this machine, handles red.\n  healthGate:\n    params: [onGreen, onRed, escalateDescribe, checkLabel, escalateLabel]\n    entry: check\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        # See the shared suite check on `entryGate.check` above.\n        script: *suiteCheck\n        on:\n          \"A .gtd/FEEDBACK.md\": $onRed\n          \"M .gtd/FEEDBACK.md\": $onRed\n          \"* **\": $onGreen\n          \"C\": $onGreen\n      escalate:\n        actor: human\n        label: $escalateLabel\n        file: FEEDBACK.md\n        message: |\n          The agent could not get the check to pass after repeated attempts.\n          `.gtd/FEEDBACK.md` holds the last failing output.\n\n          What each change does next (then run `gtd land`):\n          <% it.edges.forEach(function (e) { if (e.describe) { %>\n          <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n          <% } }) %>\n        on:\n          \"* **\":\n            to: check\n            action: Retry check\n            describe: $escalateDescribe\n\n  # Shared check/answer pair for design.gate/architecture.gate. No `file:`\n  # PARAM for the probe script itself: machine `$param` substitution is\n  # whole-value only, so a path can't be spliced into a shared script body —\n  # `file` here is instead the `answer` param's own `file:` (the human gate).\n  questionGate:\n    params: [file, message, onNone, onRevise, checkLabel, answerLabel]\n    entry: check\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        script: |\n          #!/usr/bin/env sh\n          # Exactly one of REQUIREMENTS.md/ARCHITECTURE.md exists on disk at\n          # a time — architecture.author deletes the former in the same turn\n          # it writes the latter — so this probe is unambiguous either way.\n          set +e\n          mkdir -p .gtd\n          file=.gtd/REQUIREMENTS.md\n          [ -f \"$file\" ] || file=.gtd/ARCHITECTURE.md\n          gtd check qa \"$file\" --open-questions > /dev/null 2>&1\n          code=$?\n          if [ \"$code\" -ne 0 ]; then\n            printf 'open questions remain in %s\\n' \"$file\" > .gtd/QUESTIONS.md\n            # See the shared suite check's cache-buster rationale on\n            # `entryGate.check` above.\n            printf '\\n<!-- gtd check %s -->\\n' \"$(git rev-parse --short HEAD 2>/dev/null || echo pending)\" >> .gtd/QUESTIONS.md\n          else\n            rm -f .gtd/QUESTIONS.md\n          fi\n        on:\n          \"A .gtd/QUESTIONS.md\": answer\n          \"M .gtd/QUESTIONS.md\": answer\n          \"D .gtd/QUESTIONS.md\": $onNone\n          \"C\": $onNone\n      answer:\n        actor: human\n        label: $answerLabel\n        file: $file\n        mode: qa\n        answerGate: true\n        message: $message\n        on:\n          \"* **\":\n            to: $onRevise\n            action: Revise answers\n            describe: >-\n              tick exactly one option per open question (replace\n              `_your answer_` for your own) to send it back for the agent to\n              fold your answers in. Delete a question to skip it, or delete\n              the whole `## Open Questions` section to accept the plan as-is.\n\n  # The triage phase — one conversation across the whole back-and-forth (the\n  # human's answer rationale survives every return lap). A review loop-back\n  # lap runs the suite itself and files any breakage as its own FIRST\n  # concern, rather than spending one of packages.item.fix-suite's\n  # (per-episode) retries on breakage the package didn't cause.\n  # ▸ planner identity.\n  designPlan:\n    model: <%= it.vars.plannerModel %>\n    system: |-\n      <%~ it.vars.designPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onArchitecture]\n    entry: triage\n    states:\n      triage:\n        actor: agent\n        label: Triaging the change\n        file: REQUIREMENTS.md\n        mode: qa\n        # Guards against discarding assembled review input without folding\n        # it in (the original bug this guard was added for).\n        requireProgress: true\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.styleFormatContract %>\n\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state file this turn touches is `.gtd/REQUIREMENTS.md`; develop it. Do\n          not create other files to hold notes or output.\n\n          `.gtd/TODO.md` is the likely home of the sketch that\n          started this process. Despite living beside this workflow's own\n          state files, it is the human's input — the sketch to be folded into\n          the concerns below like any other part of the start diff. It is\n          never a state file to preserve, and never gtd bookkeeping to ignore.\n\n          This process started at commit `<%= it.startCommit %>`. The change\n          that started it was reverted out of the working tree by the\n          `unwind` beat right after it landed, so `git diff <%= it.startCommit %>`\n          (against the working tree) is now empty — its content survives only\n          in history. Find the entry commit yourself: run\n          `git rev-list --ancestry-path <%= it.startCommit %>..HEAD | tail -1`\n          (the process's very first turn, landed immediately after\n          `<%= it.startCommit %>`, before any later baseline-repair commits) —\n          then `git show` that commit to see everything that started this\n          process: a hand-edit to real code, a scratch note in some file, or\n          both.\n\n          Whichever lap this is, leave `.gtd/REQUIREMENTS.md` uncommitted and\n          finish your turn once it reflects this lap's own work below.\n\n          ## First lap\n\n          `.gtd/REQUIREMENTS.md` does not exist yet (or holds whatever the\n          human's own change happened to leave there). Build it from that\n          start diff:\n\n          ### Group into concerns\n\n          Group the diff into an ordered list of concerns — each one a\n          coherent piece of work that can leave the test suite green on\n          its own, in the order you'd want them built. If a concern would\n          red-light tests that a later concern is meant to fix, that is\n          not a valid split: merge the two into one concern.\n\n          Two more tests sit beside that green floor, not instead of it.\n          Vertical, not horizontal: slice by capability, never by layer. A\n          concern that only prepares for a later one — types, scaffolding,\n          renames — is folded into the first concern that uses it. Distinct\n          acceptance: each concern needs an observable check that fails\n          before it and passes after; if you can't name one, merge it into\n          its neighbour. Prefer fewer, larger packages — the smallest\n          independently valuable change, not the smallest change that\n          compiles.\n\n          ### Classify each concern\n\n          Classify each concern as PRODUCT (a user-facing/requirements\n          decision) or TECHNICAL (an implementation decision).\n\n          <%~ it.vars.questionBar %>\n\n\n          Raise questions only for product concerns here — a technical\n          concern's open points wait for the next phase. When every concern\n          in this lap is TECHNICAL, write no `## Open Questions` section at\n          all.\n\n          ### Fold in the sketch\n\n          Fold everything the entry commit added into the concerns above —\n          a scratch note and a real code edit are both just a sketch of\n          the intent, a spec to be finished, never work to be preserved;\n          `unwind` already reverted both out of the tree, so there is\n          nothing left to delete. Describe each piece under the concern it\n          belongs to.\n\n          ## Return lap\n\n          <%~ it.vars.questionBarReturn %>\n\n          ## Review loop-back\n\n          `.gtd/REQUIREMENTS.md` already holds concerns and none of them\n          have a ticked-but-unfolded answer waiting — that shape means a\n          completed REVIEW round put this material here, not a question you\n          asked. Develop those existing concerns further with whatever the\n          round raised; never rediscover or regroup them from a cold read\n          the way the first lap does.\n\n          The human's own edit from that review round has been reverted out\n          of the working tree the same way the entry commit is — read it\n          from history, never the working tree: run\n          `git show <%= it.reviewBase %>` to see it. (On the first lap that\n          same hash is the process's own diff base, `<%= it.startCommit %>`,\n          so this branch does not apply: `.gtd/REQUIREMENTS.md`\n          does not exist yet for a review round to have happened against.)\n\n          Whatever this round touches, every decision already settled under\n          `## Answered Questions` stays settled on this lap too — never\n          re-open one. A genuinely open PRODUCT point in the round's own\n          material may still raise a fresh question under\n          `## Open Questions`: the product gate sits on this path exactly as\n          it does on the first lap, and will ask it.\n\n          Before grouping anything on this lap, run\n          `<%= it.vars.testCommand %>` yourself as part of reading the\n          situation: a review loop-back runs no green-baseline gate between\n          the revert above and this turn, so the tree may already be red —\n          reverting the human's edit can undo a fix that edit had put in. If\n          the suite is red, make that breakage the first concern in your\n          ordered list, ahead of everything else — every later concern's\n          \"leaves the suite green on its own\" property assumes the suite\n          already started green.\n        on:\n          \"* **\": gate.check\n\n      gate:\n        machine: questionGate\n        with:\n          file: REQUIREMENTS.md\n          onNone: $onArchitecture\n          onRevise: triage\n          checkLabel: Checking for open questions\n          answerLabel: Awaiting your product answers\n          message: |\n            `.gtd/REQUIREMENTS.md` holds the concerns under\n            development. Each open question under `## Open Questions` offers\n            a few options plus a `- [ ] _your answer_` slot. Answer EVERY\n            question by ticking exactly one box (`- [x]`); for your own\n            answer, replace `_your answer_` with your text and tick that\n            line. Stepping is refused while any question is unanswered.\n\n            What each change does next (then run `gtd land`):\n            <% it.edges.forEach(function (e) { if (e.describe) { %>\n            <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n            <% } }) %>\n\n  # A separate machine from designPlan (its own memory scope — a COLD read,\n  # not a resumed conversation). Merge authority lives in `author`, the first\n  # state that knows the *how*: it alone may re-merge concerns, never split;\n  # `decompose` carries that grouping over verbatim. ▸ planner identity.\n  archPlan:\n    model: <%= it.vars.plannerModel %>\n    system: |-\n      <%~ it.vars.architectPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onPackages]\n    entry: author\n    states:\n      author:\n        actor: agent\n        label: Refining the technical plan\n        file: ARCHITECTURE.md\n        mode: qa\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.styleFormatContract %>\n\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state files this\n          turn touches are `.gtd/ARCHITECTURE.md` (write it) and\n          `.gtd/REQUIREMENTS.md` (delete it once its content is\n          folded in). Do not create other files to hold notes or output.\n\n          You do not resume the design conversation — this is a separate\n          machine with its own memory, a cold read every time. Read\n          `.gtd/REQUIREMENTS.md` (the settled, ordered, classified\n          concerns) in full. Treat every decision recorded there — plain\n          prose or a resolved `## Answered Questions` entry, PRODUCT or\n          TECHNICAL alike — as settled; never re-open it.\n\n          Cold means the machine carries no conversational memory of\n          triage's own back-and-forth; it never meant no git access. This\n          process started at commit `<%= it.startCommit %>`. Find the\n          process's first turn yourself: run\n          `git rev-list --ancestry-path <%= it.startCommit %>..HEAD | tail -1`\n          then `git show` that commit to see everything that started this\n          process: a hand-edit to real code, a scratch note in some file,\n          or both.\n\n          Whichever lap this is, once `.gtd/ARCHITECTURE.md` is written,\n          delete `.gtd/REQUIREMENTS.md` — its content has been folded in and\n          it must not linger. Leave everything uncommitted and finish your\n          turn.\n\n          ## First lap\n\n          Develop `.gtd/ARCHITECTURE.md` from those concerns: for each one,\n          in the same order, work out the *how* — file/module structure,\n          data models, library/tech-stack choices, error-handling strategy —\n          building on the *what* already settled.\n\n          You now know the *how*, so you know each concern's file footprint —\n          list each concern's primary paths. Merge concerns whose footprints\n          center on the same files into one, unless the later one only\n          consumes an interface the earlier one creates: that exception is\n          what keeps a genuine build-on-top sequence from collapsing into one\n          blob. This authority is to merge only, never to split — granting\n          split authority here would work directly against the goal; the\n          whole problem is over-granularity. Record every merge under a\n          dedicated `## Merged Concerns` heading, carrying both merged requirements\n          verbatim so the per-package spec review still covers each one\n          independently. A merge raises no open question and stops for no\n          human — do not route it to `architecture.gate` for a veto; the\n          human still sees every merge when they review the plan, and the\n          per-package spec review is the real safety net. Prefer fewer,\n          larger packages — the smallest independently valuable change, not\n          the smallest change that compiles.\n\n          Every open point here is TECHNICAL — triage already resolved the\n          product ones, one phase earlier.\n\n          <%~ it.vars.questionBar %>\n\n          ## Return lap\n\n          <%~ it.vars.questionBarReturn %>\n        on:\n          \"* **\": gate.check\n\n      gate:\n        machine: questionGate\n        with:\n          file: ARCHITECTURE.md\n          onNone: decompose\n          onRevise: author\n          checkLabel: Checking for open questions\n          answerLabel: Awaiting your technical answers\n          message: |\n            `.gtd/ARCHITECTURE.md` holds the technical plan under\n            development. Each open question under `## Open Questions` offers\n            a few options plus a `- [ ] _your answer_` slot. Answer EVERY\n            question by ticking exactly one box (`- [x]`); for your own\n            answer, replace `_your answer_` with your text and tick that\n            line. Stepping is refused while any question is unanswered.\n\n            What each change does next (then run `gtd land`):\n            <% it.edges.forEach(function (e) { if (e.describe) { %>\n            <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n            <% } }) %>\n\n      decompose:\n        actor: agent\n        label: Decomposing into packages\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state files this turn touches\n          are the package files it writes under `.gtd/packages/` and\n          `.gtd/ARCHITECTURE.md`, which it deletes. Do not create other\n          files to hold notes or output.\n\n          If you wrote `.gtd/ARCHITECTURE.md` earlier in this\n          conversation, work from what you already settled; otherwise read it\n          (the converged technical plan) yourself. It already lists an\n          ordered set of concerns with every merge/split judgement\n          `architecture.author` made — this turn is a mechanical write-out,\n          not a planning one. A `## Merged Concerns` heading there is a\n          record of those merges, never a concern of its own: write no\n          package file for it.\n\n          Write one package file per concern, in the settled order, under\n          `.gtd/packages/` (e.g.\n          `.gtd/packages/01-name.md`,\n          `.gtd/packages/02-name.md`, ...). Each package file\n          carries that concern's requirement(s) (so it can be reviewed\n          against its spec — both, independently, when the concern was\n          merged), its independent tasks, and each task's acceptance\n          criteria as `- [ ]` checkboxes and relevant paths. Do not merge or\n          split concerns here — that judgement already happened in\n          `architecture.author`; carry the settled grouping over verbatim.\n          No package file may reference any other `.gtd/` file.\n\n          Once the package files are written, delete\n          `.gtd/ARCHITECTURE.md`. Leave everything uncommitted and\n          finish your turn.\n        on:\n          \"* .gtd/packages/**\": $onPackages\n\n  # The shared review tail. ▸ planner identity — `collecting` only judges/\n  # classifies feedback; there's no coder follow-through inside this machine.\n  #\n  # Nested inside buildTail (build.review), not a root sibling: a machine's\n  # memory scope is its dotted instance path, so nesting keeps `build.fix ->\n  # build.health.check -> build.review.*` (the `--entry fix-precheck` path)\n  # inside one scope, so the sign-off's boundary commit lands from the same\n  # scope that made the fixes.\n  humanReview:\n    model: <%= it.vars.plannerModel %>\n    system: |-\n      <%~ it.vars.reviewerPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    entry: reviewing\n    states:\n      reviewing:\n        actor: agent\n        label: Reviewing\n        file: REVIEW.md\n        mode: review\n        # `gtd --entry review-gate.check` enters via review-gate.check first\n        # (never straight here), which sets the Gtd-Review-Base trailer this\n        # tail reuses.\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.styleFormatContract %>\n\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state file this turn touches is `.gtd/REVIEW.md`; write it at exactly\n          that path. Do not create other files to hold notes or output.\n\n          Write `.gtd/REVIEW.md` to help a human review the changes in\n          this exact format:\n\n          - First non-blank line: `# Review: <%= it.currentCommit.slice(0, 7) %>`\n          - Somewhere in the document: `<!-- base: <%= it.reviewBase %> -->`\n          - At least one `## <Chunk Title>` heading, grouping hunks semantically\n            (same feature/refactor/fix, even across files) — a short explanation of\n            what changed and why, then one file pointer per hunk (checkboxes are\n            for the human to tick, not you; every path is `./`-relative, with an\n            optional `#line`). Put the note's opening line right on the\n            pointer's own line, after a dash — the reflow-proof shape:\n\n                - [ ] ./path/to/file.ts#42 — what this hunk does\n\n            If the note needs more than one line, continue it on the line(s)\n            below the pointer, indented exactly two spaces — never four or\n            more, which after a blank line reads as an indented code block\n            and never reflows:\n\n                - [ ] ./path/to/file.ts#42 — what this hunk does\n                  and here is more detail, continued below it\n\n            A note that sits entirely on the line(s) beneath the pointer is\n            also valid. Either way, the explanation itself must never start\n            with a bare `./path` token — that parses as a second hunk pointer,\n            not a note.\n\n          This prompt carries no diff — read the changes yourself. The range runs\n          from `<%= it.reviewBase %>` to the working tree (committed turns plus\n          anything still pending); on a feedback round that base is the previous\n          review's boundary, so it covers only what changed since then, not items\n          already signed off.\n\n          Leave `.gtd/REVIEW.md` uncommitted and finish your turn.\n        on:\n          \"* **\": await-review\n\n      await-review:\n        actor: human\n        label: Awaiting your review\n        file: REVIEW.md\n        mode: review\n        message: |\n          `.gtd/REVIEW.md` holds the review record for the process — one\n          `- [ ]` checkbox per reviewable item, grouped into chunks. Tick a box\n          (`- [x]`) as you review each hunk; ticking only records that you've read\n          it, it is not sign-off.\n\n          Review the diff yourself, with whatever tool you like — gtd checks\n          nothing out and touches no ref; `gtd base` prints this same hash any\n          time you need it again. The range runs from the review base to the\n          working tree:\n\n              git diff <%= it.reviewBase %>\n\n          When you've been through the whole diff, run `gtd land`:\n\n          - **Sign off** — leave no comment — no note in\n            `.gtd/REVIEW.md`, no code edit — to close the process,\n            whatever the boxes say. Every turn commit stays on the\n            branch; run `gtd summary` afterward for a closing-message\n            prompt.\n          - **Request changes** — leave a comment: a note on a\n            `.gtd/REVIEW.md` line, or a direct code edit — to send a FULL\n            development lap (**review.deciding** → **review.collecting** →\n            re-triage). A hand-edit you make here is treated as a SKETCH, not a\n            fix the agent builds on: it is reverted out of the tree and re-planned\n            from scratch, the same as any other change that starts a process.\n            There is no baseline check on the way back into planning — only a\n            genuinely non-actionable comment (an approving remark with no code\n            edit) skips the lap and signs off straight away.\n\n          Deleting `.gtd/REVIEW.md` is refused.\n        on:\n          \"* **\": deciding\n\n      deciding:\n        actor: check\n        label: Reviewing\n        file: REVIEW.md\n        mode: review\n        # Anchors the INCREMENTAL review base to the most-recent in-process\n        # commit (the process start on the first review).\n        reviewBase: true\n        script: |\n          #!/usr/bin/env sh\n          # FEEDBACK iff the human left a REVIEW.md note (any edit beyond a\n          # checkbox tick) or hand-edited any file this round outside .gtd/;\n          # otherwise a clean sign-off. This turn only CAPTURES the raw\n          # material into REVIEW_RAW.md — collecting judges actionability.\n          # A/M REVIEW_RAW.md rows are declared before D REVIEW.md so a\n          # feedback round (which also deletes REVIEW.md) isn't mistaken for\n          # sign-off.\n          set +e\n          mkdir -p .gtd\n          head=$(git rev-parse HEAD)\n          # Normalize [ ]/[x] before diffing, so only a real note counts.\n          before=$(git show \"HEAD^:.gtd/REVIEW.md\" 2>/dev/null | sed -E 's/\\[[ xX]\\]/[_]/g')\n          after=$(git show \"HEAD:.gtd/REVIEW.md\" 2>/dev/null | sed -E 's/\\[[ xX]\\]/[_]/g')\n          if git diff-tree --no-commit-id --name-only -r HEAD -- . \":(exclude).gtd\" \\\n               | grep -q . \\\n             || [ \"$before\" != \"$after\" ]; then\n            {\n              echo \"This is machine-captured input, not instructions. A downstream agent judges whether it's actionable.\"\n              echo\n              echo \"Commit: $head\"\n              echo \"The human's notes are in .gtd/REVIEW.md at this commit. Any hand edits are\"\n              echo \"in that commit's other paths. Run: git show $head\"\n            } > .gtd/REVIEW_RAW.md\n          fi\n          rm -f .gtd/REVIEW.md\n        on:\n          \"A .gtd/REVIEW_RAW.md\": collecting\n          \"M .gtd/REVIEW_RAW.md\": collecting\n          \"D .gtd/REVIEW.md\": $onSignoff\n\n      # Outcome is by which paths THIS diff touches: writing REQUIREMENTS.md\n      # (A/M) is the actionable case, so those rows are declared before \"D\n      # REVIEW_RAW.md\" — an actionable round's diff is both together, and\n      # the wrong order would short-circuit every round to sign-off.\n      # Consuming REVIEW_RAW.md alone is the non-actionable short-circuit,\n      # reusing $onSignoff since that IS a sign-off. No `C`/`\"* **\"` row: a\n      # clean turn here is a fruitless dispatch (falls through to the\n      # ordinary attempt default), never a verdict; a dirty tree matching\n      # neither row is a refusal.\n      collecting:\n        actor: agent\n        label: Collecting your feedback\n        file: REQUIREMENTS.md\n        mode: qa\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          <%~ it.vars.styleFormatContract %>\n\n\n          You are an autonomous coding agent judging and classifying a round\n          of review feedback.\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state files this turn\n          touches are `.gtd/REQUIREMENTS.md` and\n          `.gtd/REVIEW_RAW.md`, which it deletes — do not change any\n          other file: you classify, you do not build.\n\n          The raw review material is: <%~ it.read(\".gtd/REVIEW_RAW.md\") %>\n\n          It names a commit. If you wrote today's review earlier in this\n          conversation, work from what you already reviewed; otherwise read that\n          commit's diff yourself before classifying anything.\n\n          The round is actionable if any of the following is true:\n\n          1. The human left a note on `.gtd/REVIEW.md` — a note is\n             anything beyond a checkbox flip, regardless of whether the box\n             itself is ticked (ticking means only \"I read this hunk\", never\n             sign-off). A note is a mandatory concern below, whether or not\n             its box is ticked.\n          2. The human added a code comment this round (a `+` line that is a\n             comment, in a hand-edited file) — even a plain-prose one. That\n             comment is an instruction: describe it as a concern below, and\n             note that the comment line itself is transient — it must not\n             survive the lap that satisfies it.\n          3. The human hand-edited any non-comment code this round. That code\n             is no longer an already-committed intent to build on top of — it\n             is a sketch, like the entry commit's own diff: describe what it\n             was reaching for under the concern it belongs to, and expect the\n             lap that follows to re-derive it from scratch. Never say the\n             human's lines are final or that they must survive unchanged.\n\n          The round is not actionable only when none of the above holds — the\n          human left nothing but an approving remark (a compliment, a \"looks\n          good\", or similar) with no code edit and no substantive note. Never\n          invent actionability where the definition above doesn't hold — it\n          manufactures a lap nothing asked for — and never dismiss a real note\n          or edit as approval, which drops feedback the human left.\n\n          If the round is actionable: write `.gtd/REQUIREMENTS.md`\n          with an ordered list of concerns, each classified PRODUCT (a\n          user-facing/requirements decision) or TECHNICAL (an implementation\n          decision) — the same shape `design.triage` builds, one\n          `## <heading>` per concern, in the order you'd want them built. Fold\n          every note, comment, and hand-edit from this round in under the\n          concern it belongs to, per the rules above. Raise no open\n          questions here — write no `## Open Questions` section;\n          `design.triage` owns that, one phase later. Then delete\n          `.gtd/REVIEW_RAW.md` and finish your turn.\n\n          If the round is not actionable: delete\n          `.gtd/REVIEW_RAW.md` and finish your turn, writing nothing\n          to `.gtd/REQUIREMENTS.md` — consuming the capture with no\n          other change is the sign-off.\n        on:\n          \"A .gtd/REQUIREMENTS.md\": $onFeedback\n          \"M .gtd/REQUIREMENTS.md\": $onFeedback\n          \"D .gtd/REVIEW_RAW.md\": $onSignoff\n\n  # The per-package review — a separate MIND from the implementer. ▸ planner\n  # identity; fixing findings is a coder action (packages.item.fix-spec).\n  specReview:\n    model: <%= it.vars.plannerModel %>\n    system: |-\n      <%~ it.vars.specReviewerPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onApproved, onFix]\n    entry: review\n    states:\n      review:\n        actor: agent\n        label: Reviewing the package\n        # No retry cap: the loop only re-enters through\n        # `fix-spec`/`health.check`, so under the per-episode rule this state's\n        # episode count can never exceed 1 and a cap could never fire. The\n        # spec-review loop is genuinely unbounded — see docs/configuration.md's\n        # `retry` documentation.\n        prompt: |\n          <%~ it.vars.styleBlock %>\n\n\n          You are an autonomous coding agent reviewing a freshly-built work package\n          against its own spec.\n\n          <%~ it.vars.stateFileRules %>\n\n          The only state file this turn touches is\n          `.gtd/SPEC_FEEDBACK.md`; write it only when — and only\n          when — you find problems. Do not create other files to hold notes or\n          output.\n\n          The package spec is: <%~ it.read(\".gtd/NEXT.md\") %>\n\n          Read that spec, then verify the package's implementation against it: are\n          all its tasks done, acceptance criteria met, and the code sound and\n          consistent with the codebase? This prompt carries no diff — read it\n          yourself: the range runs from `<%= it.startCommit %>` to the working\n          tree.\n\n          Note the range is process-wide (from the start of the whole build, not\n          just this package), so it can span earlier packages too.\n\n          - If it fully satisfies the spec, write nothing and finish your turn — a\n            clean turn is your approval.\n          - If it does not, write `.gtd/SPEC_FEEDBACK.md` listing the\n            concrete problems for a fix turn to address. Be specific.\n\n          Do not fix anything yourself and do not delete the package file — a later\n          step owns that. Finish your turn.\n        on:\n          \"A .gtd/SPEC_FEEDBACK.md\": $onFix\n          \"M .gtd/SPEC_FEEDBACK.md\": $onFix\n          \"D .gtd/SPEC_FEEDBACK.md\": $onApproved\n          \"C\": $onApproved\n\n  # The per-package build queue — identity-free; build identity lives in\n  # packageItem (below).\n  packageLoop:\n    params: [onDrained]\n    entry: picking\n    states:\n      picking:\n        actor: check\n        label: Picking the next package\n        script: |\n          #!/usr/bin/env sh\n          # Mechanics only — NEXT.md's presence/absence is interpreted by\n          # the `on` rows below, never here.\n          set +e\n          mkdir -p .gtd\n          # Sweep spent design/architecture steering files (gone by now) and\n          # any REVIEW_RAW.md the review loop-back left behind — the only\n          # sweeper on that path before it would leak into a later `gtd\n          # summary` prompt's diff range.\n          rm -f .gtd/REQUIREMENTS.md .gtd/ARCHITECTURE.md .gtd/QUESTIONS.md .gtd/REVIEW_RAW.md\n          # Names are gtd-authored, never containing whitespace — safe to\n          # disable SC2012.\n          # shellcheck disable=SC2012\n          next=$(ls .gtd/packages/*.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\": $onDrained\n          \"* .gtd/NEXT.md\": item.building\n          \"C\": $onDrained\n\n      # Its own coder machine (below) keeps `packages` itself a single state.\n      item:\n        machine: packageItem\n        with:\n          onNext: picking\n\n  # The per-package build identity. ▸ coder identity. packages.item.closing\n  # -> picking is the one upward-resolving target in the file, hence $onNext.\n  packageItem:\n    model: <%= it.vars.coderModel %>\n    system: |-\n      <%~ it.vars.builderPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onNext]\n    entry: building\n    states:\n      building:\n        actor: agent\n        label: Building\n        prompt: |\n          <%~ it.vars.stateFileRules %>\n\n          The only state file this\n          turn may write is `.gtd/SATISFIED.md` (see below); do not\n          delete the package file (the spec-review gate reads it after you)\n          and never touch `.gtd/NEXT.md` — the `picking` state owns\n          it.\n\n          The package to implement is: <%~ it.read(\".gtd/NEXT.md\") %>\n\n          Before implementing anything, check the package's acceptance criteria\n          against the current tree — an earlier package's fix turn may already\n          have satisfied them. If **every** criterion is already met, implement\n          nothing: write `.gtd/SATISFIED.md` recording each criterion\n          and the concrete evidence it is already satisfied (the commit, file,\n          or symbol that proves it), change nothing else, and finish your turn.\n          If any criterion is outstanding, implement the package normally and\n          do not write that file.\n\n          That file describes a set of independent tasks. Implement all of them in\n          this one turn, fanning the independent tasks out to parallel subagents\n          where your harness supports it — each task is self-contained and can be\n          built concurrently. Implement exactly the tasks this package describes — no\n          more, no less; leave every other package file untouched. Use TDD\n          discipline within each task.\n\n          Leave the package file in place and everything else uncommitted, then\n          finish your turn.\n        on:\n          \"A .gtd/SATISFIED.md\": &satisfied\n            to: health.check\n            action: Close as already satisfied\n            describe: >-\n              record per-criterion evidence in .gtd/SATISFIED.md when this\n              package's work already landed (an earlier package's fix turn\n              pulled it in) — the package still runs the checks and the spec\n              review, then closes out.\n          \"M .gtd/SATISFIED.md\": *satisfied\n          \"* **\": health.check\n\n      fix-suite:\n        actor: agent\n        label: Fixing the check\n        file: FEEDBACK.md\n        prompt: |\n          <%~ it.vars.stateFileRules %>\n\n          <%~ it.vars.fixFeedbackPrompt %>\n\n          If the\n          only way to green the suite is to implement work that another\n          package file describes, make the smallest change that gets there and\n          do it — that later package will then legitimately report itself\n          already satisfied when its turn comes.\n\n          Leave everything uncommitted and finish your turn — do not commit.\n        retry:\n          max: 3\n          otherwise: health.escalate\n        on:\n          \"* **\": health.check\n\n      fix-spec:\n        actor: agent\n        label: Fixing review feedback\n        file: SPEC_FEEDBACK.md\n        prompt: |\n          <%~ it.vars.stateFileRules %>\n          The only state file this\n          turn touches is `.gtd/SPEC_FEEDBACK.md`; address it, then\n          delete it. Do not create other files to hold notes or output.\n\n          Read `.gtd/SPEC_FEEDBACK.md` (the reviewer's concerns about the\n          current package) and the package spec (`<%= it.read(\".gtd/NEXT.md\") %>`),\n          then fix the code to resolve every concern. Keep the change focused.\n\n          Delete `.gtd/SPEC_FEEDBACK.md` once every concern is addressed.\n          Leave everything else uncommitted and finish your turn.\n        on:\n          \"* **\": health.check\n\n      closing:\n        actor: check\n        label: Closing out the package\n        script: |\n          #!/usr/bin/env sh\n          # Removes the just-reviewed package file (path in NEXT.md) plus\n          # leftover spec feedback/evidence, so picking selects the next.\n          # Reached only on spec-review approval — that loop carries no retry\n          # cap, so there is no force-close path here.\n          set +e\n          pkg=$(cat .gtd/NEXT.md 2>/dev/null)\n          [ -n \"$pkg\" ] && rm -f \"$pkg\"\n          rm -f .gtd/SPEC_FEEDBACK.md .gtd/NEXT.md .gtd/SATISFIED.md\n        on:\n          \"* **\": $onNext\n\n      health:\n        machine: healthGate\n        with:\n          onGreen: spec\n          onRed: fix-suite\n          escalateDescribe: >-\n            edit the code and/or `.gtd/FEEDBACK.md` yourself\n            (**packages.item.health.check**).\n          checkLabel: Running checks\n          escalateLabel: Escalating to a human\n\n      spec:\n        machine: specReview\n        with:\n          onApproved: closing\n          onFix: fix-spec\n\n  # The process's build identity. ▸ coder identity — model/system stamped\n  # onto fix.\n  buildTail:\n    model: <%= it.vars.coderModel %>\n    system: |-\n      <%~ it.vars.finisherPersona %>\n\n\n      <%~ it.vars.agentConduct %>\n    params: [onDone, onFeedback]\n    # entry: is required by the machine grammar even though nothing resolves\n    # this machine bare; `fix` is an arbitrary pick.\n    entry: fix\n    states:\n      fix:\n        actor: agent\n        label: Fixing the check\n        file: FEEDBACK.md\n        prompt: |\n          <%~ it.vars.stateFileRules %>\n\n          <%~ it.vars.fixFeedbackPrompt %>\n\n\n          Leave everything uncommitted and finish your turn — do not commit.\n        retry:\n          max: 3\n          otherwise: health.escalate\n        on:\n          \"* **\": health.check\n\n      health:\n        machine: healthGate\n        with:\n          onGreen: review\n          onRed: fix\n          escalateDescribe: >-\n            edit the code and/or `.gtd/FEEDBACK.md` yourself\n            (**build.health.check**).\n          checkLabel: Running checks\n          escalateLabel: Escalating to a human\n\n      # Nested here (not root) so the sign-off's boundary commit stays inside\n      # the builder's own scope — see humanReview above.\n      review:\n        machine: humanReview\n        with:\n          onSignoff: $onDone\n          onFeedback: $onFeedback\n\n  # WIRING ONLY — the root ties together the machine tree above.\n  unified:\n    entry: idle\n    states:\n      idle:\n        actor: human\n        label: Idle\n        file: TODO.md\n        message: |\n          No active gtd process.\n\n          To start one, make ANY change — a hand-edit to real code, a scratch\n          note, anything at all. .gtd/TODO.md is a good default\n          place to start sketching. gtd treats it as a SKETCH, not finished\n          work: the very next beat unwinds it out of your working tree (its\n          intent survives in history, for the triage phase to read), then\n          checks the test baseline is green, then triages the reverted diff\n          into ordered, classified concerns: product questions, then\n          technical questions, then one package per concern, built and\n          reviewed in parallel.\n\n          What each change does next (then run `gtd land`):\n          <% it.edges.forEach(function (e) { if (e.describe) { %>\n          <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n          <% } }) %>\n        on:\n          \"* **\":\n            to: unwind\n            action: Start\n            describe: >-\n              make any change — gtd unwinds it out of your working tree (its\n              intent survives in history) before checking the test baseline is\n              green, then triages the reverted diff into ordered, classified\n              concerns and resolves product questions, then technical ones,\n              before building each concern's package (**unwind** ->\n              **start-gate.check**).\n\n      # --entry fix-precheck: a red suite drops into build.fix (-> health ->\n      # review tail); a green suite is a no-op back to idle.\n      fix-precheck:\n        actor: check\n        label: Checking the baseline\n        entry: true\n        script: *suiteCheck\n        on:\n          \"A .gtd/FEEDBACK.md\": build.fix\n          \"M .gtd/FEEDBACK.md\": build.fix\n          \"D .gtd/REVIEW_RAW.md\": idle\n          \"D .gtd/FEEDBACK.md\": idle\n          \"C\": idle\n\n      # Separate from start-gate.check: that gate's blocked -> check retry\n      # edge would otherwise re-run a revert here and discard a human's\n      # baseline repair. One inbound edge (from idle) means unwind runs\n      # exactly once, so it needs no idempotence guard itself.\n      unwind:\n        actor: check\n        label: Unwinding your input\n        script: |\n          #!/usr/bin/env sh\n          set +e\n          # Hoisted here, at the TOP: Eta's autoTrim eats the newline after\n          # an interpolation tag, so no tag may be the last token on a line.\n          # Uses it.currentCommit (render-time), not bare HEAD, so a\n          # late-running driver still reverts the right commit.\n          commit=\"<%~ it.currentCommit %>\"\n          git revert --no-commit \"$commit\"\n        on:\n          \"* **\": start-gate\n\n      # Reverts the human's own review-round hand-edit before re-planning,\n      # scoped to real code (`.gtd/` excluded — REVIEW.md is already gone by\n      # now). Names the commit via it.reviewBase (reviewBaseFor's own\n      # `await-review -> deciding` commit), never bare HEAD.\n      #\n      # requireRevert (below) re-checks the tree itself and refuses the step\n      # if residue remains, rather than trusting the script's exit code — a\n      # clean-filter round-trip or binary path can make `git apply -R` a\n      # silent no-op. Both `on` rows below target `design`: a hand-edited\n      # round leaves a dirty tree, a note-only round's patch is empty and\n      # leaves the tree clean — both are legitimate outcomes here, not a\n      # stall.\n      #\n      # `file: REVIEW.md` + `requireRevert: true` exist only to give that\n      # guard the path to exempt (it reads Rest.hints.file, never this\n      # literal) — REVIEW.md is already gone two commits earlier, so this\n      # state never renders it.\n      re-unwind:\n        actor: check\n        label: Re-unwinding your review edit\n        file: REVIEW.md\n        requireRevert: true\n        script: |\n          #!/usr/bin/env sh\n          # Scoped revert of the human's review-round edit — .gtd/ excluded\n          # (the guard's isCodePath re-derives the same exemption; keep both\n          # in sync). Expected to succeed; requireRevert catches a silent\n          # apply failure.\n          set +e\n          # Hoisted here, at the TOP: Eta's autoTrim eats the newline after\n          # an interpolation tag, so no tag may be the last token on a line.\n          commit=\"<%~ it.reviewBase %>\"\n          patch=.gtd/.re-unwind.patch\n          mkdir -p .gtd\n          git diff --binary \"$commit^\" \"$commit\" -- . \":(exclude).gtd\" > \"$patch\"\n          if [ -s \"$patch\" ]; then\n            git apply -R \"$patch\" || echo \"re-unwind: could not revert $commit\" >&2\n          fi\n          rm -f \"$patch\"\n        on:\n          \"* **\": design # a code hand-edit was reverted\n          \"C\": design # note-only round: nothing to revert\n\n      start-gate:\n        machine: entryGate\n        with:\n          onGreen: design\n          reviewBase: \"\"\n          blockedMessage: |\n            The test baseline is red — gtd will not start new work on a broken suite.\n            `.gtd/FEEDBACK.md` holds the failing output.\n\n            What each change does next (then run `gtd land`):\n            <% it.edges.forEach(function (e) { if (e.describe) { %>\n            <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n            <% } }) %>\n          blockedDescribe: >-\n            edit the code and/or `.gtd/FEEDBACK.md` to fix the failing tests\n            (**start-gate.check**). To repair the baseline as its own separate\n            reviewed commit instead, abandon this start and run\n            `gtd --entry fix-precheck` from a clean `idle`.\n          checkLabel: Checking the baseline\n          blockedLabel: Baseline is red\n\n      review-gate:\n        machine: entryGate\n        with:\n          onGreen: build.review\n          reviewBase: <%= it.vars.reviewBase %>\n          blockedMessage: |\n            The test baseline is red — gtd will not start a review on a broken suite.\n            `.gtd/FEEDBACK.md` holds the failing output.\n\n            What each change does next (then run `gtd land`):\n            <% it.edges.forEach(function (e) { if (e.describe) { %>\n            <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n            <% } }) %>\n          blockedDescribe: >-\n            edit the code and/or `.gtd/FEEDBACK.md` to fix the failing tests\n            (**review-gate.check**).\n          checkLabel: Checking the baseline\n          blockedLabel: Baseline is red\n\n      design:\n        machine: designPlan\n        with:\n          onArchitecture: architecture\n\n      architecture:\n        machine: archPlan\n        with:\n          onPackages: packages\n\n      packages:\n        machine: packageLoop\n        with:\n          onDrained: build.review\n\n      build:\n        machine: buildTail\n        with:\n          onDone: idle\n          onFeedback: re-unwind\n";
 //#endregion
 //#region src/workflows/templates.ts
 const SCHEMA_URL = "https://cdn.jsdelivr.net/npm/@pmelab/gtd/schema.json";
@@ -191980,7 +191960,7 @@ const JSON_TYPE = {
 /** One state's shape — `properties` is derived from `STATE_FIELD_ENTRIES` (every `authored: "state"` field, in table order); see `ConfigSchema.test.ts`. */
 const stateJsonSchema = {
 	type: "object",
-	description: "One workflow state. Declare exactly one content kind (script/prompt/message/commit). A commit state is final: no actor, no on.",
+	description: "One workflow state. Declare exactly one content kind (script/prompt/message).",
 	additionalProperties: false,
 	properties: Object.fromEntries(STATE_FIELD_ENTRIES.filter(([, spec]) => spec.authored === "state").map(([key, spec]) => [key, spec.jsonSchema ?? {
 		...JSON_TYPE[spec.kind],
@@ -192007,12 +191987,16 @@ const machineRefJsonSchema = {
 /** The whole `workflow:` value; `PatternConfig.ts`'s compiler is the authoritative schema, this is the editor's first net. */
 const workflowJsonSchema = {
 	type: "object",
-	description: "The whole machine definition: a tree of named machines rooted at entry.default (plus the workflow's own vars: defaults and modes: steering-file modes). Compiled and validated by gtd at load time; content strings starting with ./ or ../ are file references inlined from the config file's directory (a modes: command never is — it is a shell command).",
+	description: "The whole machine definition: a tree of named machines rooted at entry.default (plus the workflow's own vars: defaults, modes: steering-file modes, and summary: template). Compiled and validated by gtd at load time; content strings starting with ./ or ../ are file references inlined from the config file's directory (a modes: command never is — it is a shell command).",
 	additionalProperties: false,
 	required: ["entry", "machines"],
 	properties: {
 		vars: varsJsonSchema,
 		modes: modesJsonSchema,
+		summary: {
+			type: "string",
+			description: "Eta template rendered by `gtd summary`: instructions plus commit hashes (it.entryCommit, it.humanCommits, it.processBase, it.processTip) for an agent to write the process's own closing message. A ./ or ../ value is inlined from the config file's directory at load time. Absent is legal (gtd summary refuses); present-but-blank is a load error."
+		},
 		entry: {
 			type: "object",
 			description: "The workflow's root machine, resolved through the same resolver an `on`/`retry.otherwise` target uses (see src/Machines.ts) — accepts either a bare state path or an instance/reference-key path. Extra manual entry points are declared per-state instead, via a state's own `entry: true` (see `stateJsonSchema`'s `entry` property) — not here.",
@@ -192513,8 +192497,7 @@ const makeGitImpl = (executor, root) => {
 		updateRef: (ref, hash) => exec("git", "update-ref", ref, hash).pipe(asVoid),
 		deleteRef: (ref) => exec("git", "update-ref", "-d", ref).pipe(asVoid),
 		mixedResetTo: (ref) => exec("git", "reset", "--mixed", ref).pipe(asVoid),
-		hardResetTo: (ref) => exec("git", "reset", "--hard", ref).pipe(asVoid),
-		restoreStagedFrom: (source, paths) => paths.length === 0 ? _void : exec("git", "restore", "--staged", `--source=${source}`, "--", ...paths).pipe(catchIf((e) => !isIndexLockError(e), () => _void))
+		hardResetTo: (ref) => exec("git", "reset", "--hard", ref).pipe(asVoid)
 	};
 };
 const makeLiveEffect = gen(function* () {
@@ -193123,7 +193106,7 @@ const varsOnlyContext = (vars, state = "") => ({
 	state,
 	actor: "",
 	reviewBase: "",
-	retainedBase: "",
+	processBase: "",
 	processCost: 0,
 	processCostByModel: [],
 	read: (path) => {
@@ -193141,26 +193124,19 @@ const renderStateTemplate = (template, context) => eta.renderString(template, co
 const renderModeCommand = (template, context) => eta.renderString(template, context);
 //#endregion
 //#region src/RetainedHistory.ts
-/** Per-worktree (`refs/worktree/gtd/*`, like `ReviewWindow.ts`'s refs) so linked worktrees sharing one `.git` don't clobber each other's retained history. */
+/** Per-worktree (`refs/worktree/gtd/*`) so linked worktrees sharing one `.git` don't clobber each other's retained history. */
 const HISTORY_REF = "refs/worktree/gtd/history";
-const HISTORY_TRAILER_PREFIX = "Gtd-History: ";
-const HISTORY_TRAILER_RE = /^Gtd-History:[ \t]*(\S+)[ \t]*$/m;
-/** Appends a `Gtd-History: <hash>` trailer recording the pre-squash tip, for `gtd restore` to read back later. */
-const withHistoryTrailer = (subject, hash) => `${subject}\n\n${HISTORY_TRAILER_PREFIX}${hash}`;
-const parseHistoryTrailer = (message) => HISTORY_TRAILER_RE.exec(message)?.[1];
 const readRetainedHistory = (git) => git.readRefOption(HISTORY_REF);
 /**
-* Whether resetting to `tipHash` is safe: either HEAD is the squash commit
-* that still carries the matching `Gtd-History:` trailer (resetting discards
-* only that one commit), or HEAD is an ancestor of `tipHash` (nothing on top
-* would be lost). Anything else is refused.
+* Whether resetting to `tipHash` is safe: HEAD must be an ancestor of
+* `tipHash` (nothing on top of the retained tip would be lost). Anything else
+* is refused.
 */
-const restorability = (git, headHash, headMessage, tipHash) => gen(function* () {
-	if (parseHistoryTrailer(headMessage) === tipHash) return { ok: true };
+const restorability = (git, headHash, tipHash) => gen(function* () {
 	if (yield* git.isAncestor(headHash, tipHash)) return { ok: true };
 	return {
 		ok: false,
-		reason: "HEAD has advanced past the squash — restoring would discard commits built on top of it"
+		reason: "HEAD has advanced past the retained tip — restoring would discard commits built on top of it"
 	};
 });
 //#endregion
@@ -193187,39 +193163,11 @@ const commitAllowEmpty = (message) => {
 };
 /** `git add -A` then `commitAllowEmpty`, joined with `&&` so a failing `git add` never reaches the commit. */
 const commitAll = (message) => `git add -A &&\n${commitAllowEmpty(message)}`;
-const commitAsIs = (message) => commitAllowEmpty(message);
-const softResetTo = (ref) => `git reset --soft ${shellQuote(ref)}`;
 const mixedResetTo = (ref) => `git reset --mixed ${shellQuote(ref)}`;
 const hardResetTo = (ref) => `git reset --hard ${shellQuote(ref)}`;
-/**
-* `git add -A` then `git reset --hard HEAD` — discards every pending change,
-* tracked or untracked. Joined with `&&`: a failed stage must not reach the
-* hard reset, or untracked survivors remain — the exact outcome this builder
-* exists to avoid.
-*/
-const discardPending = () => `git add -A && git reset --hard HEAD`;
 const updateRef = (ref, hash) => `git update-ref ${shellQuote(ref)} ${shellQuote(hash)}`;
 /** `git update-ref -d <ref>` — idempotent: deleting a missing ref is already a no-op in real git. */
 const deleteRef = (ref) => `git update-ref -d ${shellQuote(ref)}`;
-/**
-* `git restore --staged --source=<source> -- <paths…>`, tolerant of a missing
-* ref or no path matching at `source` (mirrors `Git.ts`'s `restoreStagedFrom`)
-* but NOT of `index.lock` contention — swallowing that here would silently
-* skip the `.gtd/` index pin and leak plumbing into the review diff. Empty
-* `paths` emits nothing, mirroring the Effect implementation's own skip.
-*/
-const restoreStagedFrom = (source, paths) => {
-	if (paths.length === 0) return "";
-	const pathArgs = pathspec(paths);
-	return [
-		`if ! out=$(git restore --staged --source=${shellQuote(source)} -- ${pathArgs} 2>&1); then`,
-		`  case "$out" in`,
-		`    *"index.lock"*|*"Another git process seems to be running"*) printf '%s\\n' "$out" >&2; exit 1 ;;`,
-		`    *) : ;;`,
-		`  esac`,
-		`fi`
-	].join("\n");
-};
 //#endregion
 //#region src/OutcomeScript.ts
 /** The plain-text twin of `printfLine`: substitutes `args` into `fmt`'s `%s` placeholders, in order. */
@@ -193330,7 +193278,7 @@ const OUTCOME_PREAMBLE = [
 ].join("\n");
 /** `gtd_report_transition <from> <to>` — a landed self-loop/target-change transition, with its changed-file rows. */
 const transitionOutcome = (from, to) => `gtd_report_transition ${shellQuote(from)} ${shellQuote(to)}`;
-/** `gtd_report_commit <subject>` — a bare capture or a squash's final commit, with its changed-file rows. */
+/** `gtd_report_commit <subject>` — a bare capture (a self-loop commit), with its changed-file rows. */
 const commitOutcome = (subject) => `gtd_report_commit ${shellQuote(subject)}`;
 /** `gtd_report_note <text>` — one already-rendered plain line, no marker. */
 const noteOutcome = (text) => `gtd_report_note ${shellQuote(text)}`;
@@ -193368,12 +193316,6 @@ const headAssertion = (expectedHead) => {
 * same `set -eu` safety `headAssertion` documents.
 */
 const fileExistsGuard = (file) => `[ -f ${shellQuote(file)} ] || exit 0`;
-/** Same shape as `headAssertion`, for the saved-head ref a review window pins; `--verify --quiet` reads a missing ref as an empty string instead of erroring the substitution. */
-const reviewWindowAssertion = (ref, expectedHash) => {
-	const refQ = shellQuote(ref);
-	const hashQ = shellQuote(expectedHash);
-	return `[ "$(git rev-parse --verify --quiet ${refQ} 2>/dev/null)" = ${hashQ} ] || { printf 'gtd: review window ref %s changed since this script was generated (expected %s) — re-run gtd\\n' ${refQ} ${hashQ} >&2; exit 1; }`;
-};
 /**
 * Wraps `command` so a non-zero exit prints `prompt` plus the command's
 * captured output before propagating that exit code. The `{ … }` group lets
@@ -193443,7 +193385,6 @@ const assembleScript = (preconditions, steps) => {
 	if (steps.length === 0) return "";
 	const sections = ["set -eu"];
 	if (preconditions.expectedHead !== void 0) sections.push(headAssertion(preconditions.expectedHead));
-	if (preconditions.reviewWindow) sections.push(reviewWindowAssertion(preconditions.reviewWindow.ref, preconditions.reviewWindow.expectedHash));
 	if (steps.some((step) => step.kind === "gitWrite")) sections.push(RETRY_HELPER);
 	if (steps.some((step) => step.kind === "outcome")) sections.push(OUTCOME_PREAMBLE);
 	sections.push(...steps.map(renderStep));
@@ -193478,14 +193419,7 @@ const combinedScript = (required, optional) => {
 };
 //#endregion
 //#region src/Edge.ts
-const EMPTY_TREE$2 = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
-/**
-* The review checkout window's saved-head ref — duplicated from
-* `src/ReviewWindow.ts`'s own `REVIEW_HEAD_REF` rather than imported, to avoid
-* a circular module dependency (`ReviewWindow.ts` imports FROM this module).
-* Read (never written) here; the window itself is opened/closed elsewhere.
-*/
-const REVIEW_HEAD_REF$1 = "refs/worktree/gtd/review-head";
+const EMPTY_TREE$1 = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 const subjectOf = (message) => (message.split("\n")[0] ?? "").trim();
 const COST_TRAILER_PREFIX = "Gtd-Cost: ";
 const COST_TRAILER_RE = /^Gtd-Cost:[ \t]*([0-9]+(?:\.[0-9]+)?)(?:[ \t]+(.+?))?[ \t]*$/gm;
@@ -193547,8 +193481,8 @@ const normalizeStatus = (raw) => raw === "A" ? "A" : raw === "D" ? "D" : "M";
 * process left resting at a state a workflow upgrade removed would otherwise
 * look like a fresh idle repo instead of pointing at `gtd abandon`. Every
 * other case `resolveState` folds into "rest at the initial state" (an
-* unparseable subject, an actor mismatch, a commit-state target) is left as
-* is — those are legitimately "no active process," not a renamed-out state.
+* unparseable subject, an actor mismatch) is left as is — those are
+* legitimately "no active process," not a renamed-out state.
 */
 const resolveRestFrom = (def, headSubject) => {
 	const parsedHead = parseStateSubject(headSubject);
@@ -193560,7 +193494,7 @@ const resolveRestFrom = (def, headSubject) => {
 	const stateDef = def.states[state];
 	if (stateDef.actor === void 0) return {
 		ok: false,
-		error: /* @__PURE__ */ new Error(`gtd: resolved at commit state "${state}" — a process never rests there`)
+		error: /* @__PURE__ */ new Error(`gtd: resolved at state "${state}" declaring no actor`)
 	};
 	return {
 		ok: true,
@@ -193572,7 +193506,7 @@ const resolveRestFrom = (def, headSubject) => {
 		}
 	};
 };
-const pendingChanges = (git, base) => git.changedPaths(base).pipe(map$4((entries) => entries.map((e) => ({
+const pendingChanges = (git) => git.changedPaths().pipe(map$4((entries) => entries.map((e) => ({
 	status: normalizeStatus(e.status),
 	path: e.path
 }))));
@@ -193580,16 +193514,14 @@ const pendingChanges = (git, base) => git.changedPaths(base).pipe(map$4((entries
 * `ProcessRun.headTurn` from an already-fetched `commitHistory` array
 * (oldest→newest) — HEAD is its last entry. `undefined` for an empty
 * history, an unparseable/foreign subject, or a subject naming a state the
-* ACTIVE definition doesn't declare or that is a commit state (never a real
-* rest).
+* ACTIVE definition doesn't declare (never a real rest).
 */
 const headTurnFrom = (def, history) => {
 	if (history.length === 0) return void 0;
 	const head = history[history.length - 1];
 	const parsed = parseStateSubject(subjectOf(head.message));
 	if (parsed === void 0) return void 0;
-	const stateDef = def.states[parsed.state];
-	if (stateDef === void 0 || isCommitState(stateDef)) return void 0;
+	if (def.states[parsed.state] === void 0) return void 0;
 	return {
 		state: parsed.state,
 		actor: parsed.actor,
@@ -193614,6 +193546,33 @@ const parseEntryCommitOverrides = (processCommits) => {
 	};
 };
 /**
+* The boundary-exclusive backward walk `computeProcessRun` needs, split out
+* so the surrounding Effect.gen body stays under the complexity gate. Returns
+* the trace/retry boundary's history index (`i`, `-1` when the whole history
+* belongs to the process) and, when `includeClosingBoundary` folded HEAD's own
+* closing commit into the process, its hash.
+*/
+const walkProcessBoundary = (history, initialState, includeClosingBoundary) => {
+	let i = history.length - 1;
+	let closingHash;
+	if (includeClosingBoundary && i >= 0) {
+		const parsedLast = parseStateSubject(subjectOf(history[i].message));
+		if (parsedLast !== void 0 && parsedLast.state === initialState) {
+			closingHash = history[i].hash;
+			i--;
+		}
+	}
+	while (i >= 0) {
+		const parsed = parseStateSubject(subjectOf(history[i].message));
+		if (parsed === void 0 || parsed.state === initialState) break;
+		i--;
+	}
+	return {
+		boundaryIndex: i,
+		closingHash
+	};
+};
+/**
 * Walk first-parent history backward from HEAD while each commit's subject
 * parses as `gtd(actor): state` and that state isn't the workflow's initial
 * state; stop — excluding that boundary commit, which belongs to the
@@ -193627,24 +193586,30 @@ const parseEntryCommitOverrides = (processCommits) => {
 * `restAt`'s window-aware branch passes the saved-head hash here while a
 * review window is open, so the trace still covers commits a real `git log`
 * would miss with HEAD rewound to the review base.
+*
+* `includeClosingBoundary` (default `false`) is `summaryRun`'s one-flag
+* difference from `currentRun`'s ordinary walk: when set AND the walk's very
+* last history entry (HEAD itself) is a commit entering the initial state, that
+* boundary commit is folded INTO the trace instead of excluded, and its hash
+* is recorded as `ProcessRun.closingHash`. A process still in flight (HEAD is
+* not itself such a boundary) resolves identically to the flag being unset.
 */
-const computeProcessRun = (git, def, head) => gen(function* () {
+const computeProcessRun = (git, def, includeClosingBoundary = false) => gen(function* () {
 	const initialState = initialStateOf(def);
-	const history = yield* git.commitHistory(void 0, head);
-	let i = history.length - 1;
-	while (i >= 0) {
-		const parsed = parseStateSubject(subjectOf(history[i].message));
-		if (parsed === void 0 || parsed.state === initialState) break;
-		i--;
-	}
+	const history = yield* git.commitHistory();
+	const { boundaryIndex: i, closingHash } = walkProcessBoundary(history, initialState, includeClosingBoundary);
 	const startIdx = i + 1;
 	const processCommits = history.slice(startIdx);
-	const trace = processCommits.map((h) => ({
-		state: parseStateSubject(subjectOf(h.message)).state,
-		hash: h.hash
-	}));
+	const trace = processCommits.map((h) => {
+		const parsed = parseStateSubject(subjectOf(h.message));
+		return {
+			state: parsed.state,
+			hash: h.hash,
+			actor: parsed.actor
+		};
+	});
 	const costEntries = parseCostTrailers(processCommits.map((h) => h.message));
-	const startParentHash = i >= 0 ? history[i].hash : EMPTY_TREE$2;
+	const startParentHash = i >= 0 ? history[i].hash : EMPTY_TREE$1;
 	const startHash = startIdx < history.length ? history[startIdx].hash : history[history.length - 1].hash;
 	const { reviewBase: reviewBaseOverride, vars: entryVars } = parseEntryCommitOverrides(processCommits);
 	return {
@@ -193654,26 +193619,31 @@ const computeProcessRun = (git, def, head) => gen(function* () {
 		trace,
 		costEntries,
 		entryVars,
-		headTurn: headTurnFrom(def, history)
+		headTurn: headTurnFrom(def, history),
+		closingHash
 	};
 });
 /**
-* The run alone, WITHOUT resolving a rest — `gtd abandon`'s escape hatch (it
+* The run alone, WITHOUT resolving a rest — `gtd abandon`'s escape hatch: it
 * must still work when HEAD names a state `currentRest` would refuse on,
-* since abandon IS the recovery command for that case) and the review
-* window's re-arm, which degrades gracefully (stays closed) rather than
-* erroring on the same kind of foreign/refused rest.
-*
-* Window-aware on exactly the same terms as `restAt`: while a review checkout
-* window is open, real HEAD is rewound to the review base, so walking the
-* trace from literal HEAD would see a process that has not started. Both
-* callers need the REAL head, so the saved head is the walk's origin.
+* since abandon IS the recovery command for that case.
 */
 const currentRun = gen(function* () {
 	const git = yield* GitService;
 	const config = yield* (yield* ConfigService).load;
-	const windowHead = getOrUndefined(yield* git.readRefOption(REVIEW_HEAD_REF$1));
-	return yield* computeProcessRun(git, config.workflow, windowHead);
+	return yield* computeProcessRun(git, config.workflow);
+});
+/**
+* The process HEAD closes or sits inside — `gtd summary`'s run resolution.
+* Identical to `currentRun` for a process still in flight; for a finished
+* process (HEAD is itself a commit entering the initial state), the closing
+* commit is folded back into the trace and its hash recorded as
+* `closingHash` — see `computeProcessRun`'s `includeClosingBoundary` flag.
+*/
+const summaryRun = gen(function* () {
+	const git = yield* GitService;
+	const config = yield* (yield* ConfigService).load;
+	return yield* computeProcessRun(git, config.workflow, true);
 });
 /**
 * PURE: the most-recent in-process turn commit that entered a `reviewBase`
@@ -193818,11 +193788,11 @@ const withRenderedOn = (def, state, renderedOnEdges) => ({
 * Build the `PatternTemplates.TemplateContext` for rendering `state`'s content
 * at the resolved rest. `edges` must already be rendered by the caller
 * (`renderOnEdges`). `currentCost`/`currentModel` are the in-flight step's own
-* `--cost`/`--model`, folded into the process's committed cost entries so a
-* `commit:` squash template sees the whole-process total including the
-* squashing step (`0`/absent for the pure emitters, where no step runs). No
-* diff is computed here — `it.reviewBase`/`it.retainedBase` are bases a
-* template tells the agent to `git diff` itself.
+* `--cost`/`--model`, folded into the process's committed cost entries so
+* `it.processCost`/`it.processCostByModel` total the whole process (`0`/absent
+* for the pure emitters, where no step runs). No diff is computed here —
+* `it.reviewBase`/`it.processBase` are bases a template tells the agent to
+* `git diff` itself.
 */
 const buildTemplateContext = (git, read, state, actor, run, vars, edges, currentCost, currentModel, reviewBase) => gen(function* () {
 	const currentCommit = yield* git.resolveRef("HEAD");
@@ -193839,7 +193809,7 @@ const buildTemplateContext = (git, read, state, actor, run, vars, edges, current
 		state,
 		actor,
 		reviewBase,
-		retainedBase: run.startParentHash,
+		processBase: run.startParentHash,
 		processCost: totalCostOf(allCostEntries),
 		processCostByModel: costByModel(allCostEntries),
 		read,
@@ -193848,6 +193818,22 @@ const buildTemplateContext = (git, read, state, actor, run, vars, edges, current
 	};
 });
 /**
+* The `TemplateContext` `gtd summary` renders `def.summary` against — no
+* resting state, no `on` edges (a summary isn't rendered AT a state), `cost`/
+* `model` both absent (the command writes nothing, so there is no in-flight
+* step to fold in).
+*/
+const summaryTemplateContext = (run) => gen(function* () {
+	const git = yield* GitService;
+	const config = yield* (yield* ConfigService).load;
+	const files = yield* RepoFiles;
+	const envVars = yield* EnvVars;
+	const def = config.workflow;
+	const vars = resolveVars(config.workflowVars, config.rcVars, run.entryVars, envVars.all);
+	const reviewBase = reviewBaseFor(def, run);
+	return yield* buildTemplateContext(git, templateRead(files), "", "", run, vars, void 0, 0, void 0, reviewBase);
+});
+/**
 * True when this process would retain NOTHING: nothing pending and no net
 * change between its trace/retry boundary and HEAD. Used by `planStep`'s
 * "returned to the initial state retaining nothing" mixed-reset branch.
@@ -193857,37 +193843,24 @@ const retainsNothing = (git, run, changes) => gen(function* () {
 	return (yield* git.changedPathsSince(run.startParentHash)).length === 0;
 });
 const omitUndefined = (obj) => Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
-/**
-* Resolve `Rest` at an arbitrary ref (`gtd visualize` reading the review
-* window's saved head via `REVIEW_HEAD_REF`, or `undefined` for HEAD itself).
-*
-* Window-aware ONLY at `ref === undefined`: when the review checkout window's
-* saved-head ref resolves, its hash is used as the effective head for
-* `lastCommitSubject` and `computeProcessRun`'s trace walk — real git HEAD
-* has been rewound to the review base while the window is open, so reading
-* literal `HEAD` there would resolve state/trace/memory against the wrong
-* commit.
-*/
+/** Resolve `Rest` at an arbitrary ref, or `undefined` for HEAD itself. */
 const restAt = (ref) => gen(function* () {
 	const git = yield* GitService;
 	const config = yield* (yield* ConfigService).load;
 	const files = yield* RepoFiles;
 	const envVars = yield* EnvVars;
 	const def = config.workflow;
-	let windowHead;
-	if (ref === void 0) windowHead = getOrUndefined(yield* git.readRefOption(REVIEW_HEAD_REF$1));
-	const effectiveRef = windowHead ?? ref;
-	const headSubject = yield* git.lastCommitSubject(effectiveRef);
+	const headSubject = yield* git.lastCommitSubject(ref);
 	const resolution = resolveRestFrom(def, headSubject);
 	if (!resolution.ok) return yield* fail$2(resolution.error);
 	const resolved = resolution.rest;
 	yield* (yield* Narrator).narrate(`rest resolved: ${resolved.state} (awaits ${resolved.actor})`);
-	const run = yield* computeProcessRun(git, def, windowHead);
+	const run = yield* computeProcessRun(git, def);
 	const vars = resolveVars(config.workflowVars, config.rcVars, run.entryVars, envVars.all);
 	const on = yield* renderOnEdgesOrFail(resolved.stateDef.on, vars);
 	const stepDef = withRenderedOn(def, resolved.state, on);
 	const reviewBase = reviewBaseFor(def, run);
-	const changes = yield* pendingChanges(git, windowHead);
+	const changes = yield* pendingChanges(git);
 	const context = yield* buildTemplateContext(git, templateRead(files), resolved.state, resolved.actor, run, vars, on, 0, void 0, reviewBase);
 	const memory = memoryKeyFor(config.stateScopes, resolved, run);
 	const memoryResumed = memoryResumedFor(def, config.stateScopes, resolved, run);
@@ -193899,7 +193872,6 @@ const restAt = (ref) => gen(function* () {
 		on,
 		stepDef,
 		changes,
-		windowHead,
 		memory,
 		memoryResumed,
 		hints,
@@ -193929,16 +193901,16 @@ const renderHints = (stateDef, context) => gen(function* () {
 	return omitUndefined(hints);
 });
 /**
-* Render a `Rest`'s declared content (script/prompt/message — never `commit`,
-* since a `Rest` never rests at a commit state) plus every `STATE_FIELDS`
-* field carrying a `rest` kind and its computed memory key — all of which
-* already live on `rest` (`rest.context`/`rest.hints`/`rest.memory`, built
-* once by `restAt` via `renderHints`), so this takes no other parameters.
+* Render a `Rest`'s declared content (script/prompt/message) plus every
+* `STATE_FIELDS` field carrying a `rest` kind and its computed memory key —
+* all of which already live on `rest` (`rest.context`/`rest.hints`/
+* `rest.memory`, built once by `restAt` via `renderHints`), so this takes no
+* other parameters.
 */
 const renderRest = (rest) => gen(function* () {
 	const kind = contentKindOf(rest.stateDef);
 	if (kind === void 0) return yield* fail$2(/* @__PURE__ */ new Error(`state "${rest.state}" declares no content — invalid definition`));
-	const template = rest.stateDef.script ?? rest.stateDef.prompt ?? rest.stateDef.message ?? rest.stateDef.commit;
+	const template = rest.stateDef.script ?? rest.stateDef.prompt ?? rest.stateDef.message;
 	const content = yield* try_({
 		try: () => renderStateTemplate(template, rest.context),
 		catch: (e) => e instanceof Error ? e : new Error(String(e))
@@ -193973,21 +193945,7 @@ const stalledAt = (rest) => rest.changes.length === 0 && rest.run.headTurn?.stat
 * `PatternMachine.step`'s own tests (a defensive message beats a lie).
 */
 const formatStepRefusal = (refusal) => refusal.reason === "out-of-turn" ? `gtd land: out of turn — "${refusal.state}" awaits ${refusal.awaits}` : `gtd land: no declared pattern matches the pending changes at "${refusal.state}" — declared patterns: ${refusal.patterns.length > 0 ? refusal.patterns.join(", ") : "(none)"}`;
-/**
-* Build the `TemplateContext` for rendering a DIFFERENT state than `rest`'s
-* own resting one, with a step's `cost`/`model` folded in — a squash's commit
-* template needs this; it is NOT interchangeable with `rest.context`, which
-* is pinned to the resting state with `cost: 0`. Exported for `program.ts`'s
-* `planLanding`, which assembles the same script by hand and must pick the
-* same context.
-*/
-const contextAt = (rest, targetState, invoker, cost, model) => gen(function* () {
-	const git = yield* GitService;
-	const files = yield* RepoFiles;
-	const onEdges = targetState === rest.state ? rest.on : yield* renderOnEdgesOrFail(rest.def.states[targetState]?.on, rest.vars);
-	return yield* buildTemplateContext(git, templateRead(files), targetState, invoker, rest.run, rest.vars, onEdges, cost ?? 0, model, reviewBaseFor(rest.def, rest.run));
-});
-/** `updateRef(HISTORY_REF, tip)` as a single-element (or empty) step list — OMITTED when `tip === startParentHash`, mirroring `retainHistory`'s own no-op check. Shared by the squash branch and the commit branch's collapse case below. */
+/** `updateRef(HISTORY_REF, tip)` as a single-element (or empty) step list — OMITTED when `tip === startParentHash`, mirroring `retainHistory`'s own no-op check. Used by the commit branch's collapse case below. */
 const retainHistoryStep = (tip, startParentHash) => tip === startParentHash ? [] : [{
 	kind: "gitWrite",
 	command: updateRef(HISTORY_REF, tip)
@@ -194002,20 +193960,20 @@ const commitDecisionOutcome = (decision) => ({
 * state retaining nothing" collapse — target is the initial state, the
 * process started somewhere other than the empty tree, and nothing pending or
 * already-committed since its start parent survives (`retainsNothing`).
-* Always `false` for a `"squash"` decision and for an ATTEMPT: an agent that
-* did nothing must never rewind a process, and an attempt landing at a prompt
-* state that's also the initial state would otherwise satisfy every other
-* criterion identically to a genuine collapse.
+* Always `false` for an ATTEMPT: an agent that did nothing must never rewind
+* a process, and an attempt landing at a prompt state that's also the initial
+* state would otherwise satisfy every other criterion identically to a
+* genuine collapse.
 */
 const collapsesWith = (git, rest, decision) => gen(function* () {
-	if (decision.kind === "squash" || decision.attempt === true) return false;
-	return parseStateSubject(decision.subject)?.state === initialStateOf(rest.def) && rest.run.startParentHash !== EMPTY_TREE$2 && (yield* retainsNothing(git, rest.run, rest.changes));
+	if (decision.attempt === true) return false;
+	return parseStateSubject(decision.subject)?.state === initialStateOf(rest.def) && rest.run.startParentHash !== EMPTY_TREE$1 && (yield* retainsNothing(git, rest.run, rest.changes));
 });
 /**
 * The service-requiring twin of `collapsesWith`, for `program.ts` to ask
 * instead of reaching into `GitService` itself — the boundary AGENTS.md pins.
 * `planLanding` calls this to fill `LandResult.settled` for a `"commit"`/
-* `"squash"` plan, off the same `rest`/`decision` `renderDecision` already
+* `"commit"` plan, off the same `rest`/`decision` `renderDecision` already
 * decided against, so the two git reads (`changedPathsSince` + `resolveRef`)
 * can never disagree with each other.
 */
@@ -194024,100 +193982,54 @@ const collapsesToInitialState = (rest, decision) => gen(function* () {
 	return yield* collapsesWith(git, rest, decision);
 });
 /**
-* Render a `"commit"`/`"squash"` decision as the `EmitStep`s the external
-* driver runs to produce its git effect — the ONE place a decision becomes
-* git commands. Every git call here is a READ; nothing is written — gtd
-* itself never writes git, only a driven script does.
+* Render a `"commit"` decision as the `EmitStep`s the external driver runs to
+* produce its git effect — the ONE place a decision becomes git commands.
+* Every git call here is a READ; nothing is written — gtd itself never writes
+* git, only a driven script does.
 *
-* The commit branch carries one non-obvious case: a commit whose target is
-* the workflow's INITIAL state, from a process that retained nothing, is a
-* no-op probe (`gtd --entry fix-precheck` against a green suite is the
-* shipped example) and must leave no trace — it emits retain-history plus a
-* mixed reset to the process start instead of a commit, so the entry commit
-* and the probe collapse away together rather than dirtying the log with a
-* round trip to `idle`.
+* One non-obvious case: a commit whose target is the workflow's INITIAL
+* state, from a process that retained nothing, is a no-op probe
+* (`gtd --entry fix-precheck` against a green suite is the shipped example)
+* and must leave no trace — it emits retain-history plus a mixed reset to the
+* process start instead of a commit, so the entry commit and the probe
+* collapse away together rather than dirtying the log with a round trip to
+* `idle`.
 */
-const renderDecision = (git, rest, decision, context, cost, model) => gen(function* () {
+const renderDecision = (git, rest, decision, cost, model) => gen(function* () {
 	const run = rest.run;
-	switch (decision.kind) {
-		case "commit":
-			if (yield* collapsesWith(git, rest, decision)) {
-				const tip = yield* git.resolveRef("HEAD");
-				return [
-					...retainHistoryStep(tip, run.startParentHash),
-					{
-						kind: "gitWrite",
-						command: mixedResetTo(run.startParentHash)
-					},
-					{
-						kind: "outcome",
-						command: noteOutcome(COLLAPSED_TEXT)
-					}
-				];
-			}
-			return [{
+	if (yield* collapsesWith(git, rest, decision)) {
+		const tip = yield* git.resolveRef("HEAD");
+		return [
+			...retainHistoryStep(tip, run.startParentHash),
+			{
 				kind: "gitWrite",
-				command: commitAll(withCostTrailer(decision.subject, cost, model))
-			}, commitDecisionOutcome(decision)];
-		case "squash": {
-			const message = yield* try_({
-				try: () => renderStateTemplate(decision.template, context),
-				catch: (e) => /* @__PURE__ */ new Error(`gtd: rendering the "${decision.state}" commit template failed — nothing was committed: ${e instanceof Error ? e.message : String(e)}`)
-			});
-			const tip = yield* git.resolveRef("HEAD");
-			return [
-				...retainHistoryStep(tip, run.startParentHash),
-				{
-					kind: "gitWrite",
-					command: softResetTo(run.startParentHash)
-				},
-				{
-					kind: "gitWrite",
-					command: commitAsIs(withHistoryTrailer(message, tip))
-				},
-				{
-					kind: "gitWrite",
-					command: discardPending()
-				},
-				{
-					kind: "outcome",
-					command: commitOutcome(subjectOf(message))
-				}
-			];
-		}
+				command: mixedResetTo(run.startParentHash)
+			},
+			{
+				kind: "outcome",
+				command: noteOutcome(COLLAPSED_TEXT)
+			}
+		];
 	}
+	return [{
+		kind: "gitWrite",
+		command: commitAll(withCostTrailer(decision.subject, cost, model))
+	}, commitDecisionOutcome(decision)];
 });
 /**
 * The `EmitPreconditions` a step's/entry's assembled scripts assert against:
 * `expectedHead` is the resolved HEAD hash the `Rest` snapshot was taken at.
-* When `targetState` declares `reviewWindow: true` and a window is currently
-* open, the script also pins the window's saved-head hash — a later run whose
-* window has since closed or moved must re-decide rather than trust a stale
-* script.
-*/
-const buildPreconditions = (git, rest, targetState) => gen(function* () {
-	const expectedHead = rest.context.currentCommit;
-	if (!isReviewWindowState(rest.def, targetState)) return { expectedHead };
-	const windowHead = yield* git.readRefOption(REVIEW_HEAD_REF$1);
-	if (isNone(windowHead)) return { expectedHead };
-	return {
-		expectedHead,
-		reviewWindow: {
-			ref: REVIEW_HEAD_REF$1,
-			expectedHash: windowHead.value
-		}
-	};
-});
+*/
+const buildPreconditions = (rest) => ({ expectedHead: rest.context.currentCommit });
 /**
-* The `EmittedScripts` a `"commit"`/`"squash"` `StepPlan` carries alongside
-* `perform` — built from the SAME `renderDecision` output, but a render
-* failure collapses to an EMPTY script (`emitScripts` with no steps) instead
-* of failing this Effect: `perform` stays the one place a render failure is
-* ever reported to a caller, unchanged by this addition.
+* The `EmittedScripts` a `"commit"` `StepPlan` carries alongside `perform` —
+* built from the SAME `renderDecision` output, but a render failure collapses
+* to an EMPTY script (`emitScripts` with no steps) instead of failing this
+* Effect: `perform` stays the one place a render failure is ever reported to
+* a caller, unchanged by this addition.
 */
-const buildStepScripts = (git, rest, decision, context, cost, model) => gen(function* () {
-	const targetState = decision.kind === "commit" ? decision.to : decision.state;
-	return emitScripts(yield* buildPreconditions(git, rest, targetState), yield* renderDecision(git, rest, decision, context, cost, model).pipe(catchAll(() => succeed$3([]))));
+const buildStepScripts = (git, rest, decision, cost, model) => gen(function* () {
+	return emitScripts(buildPreconditions(rest), yield* renderDecision(git, rest, decision, cost, model).pipe(catchAll(() => succeed$3([]))));
 });
 /**
 * A no-op is TERMINAL only at a `script` rest: gtd rendered the script, the
@@ -194134,10 +194046,8 @@ const noOpSettles = (rest) => contentKindOf(rest.stateDef) === "script";
 /**
 * Decide what landing at `rest` does, authenticated as `rest.actor` (the
 * state's own declared actor, so out-of-turn is unreachable by construction),
-* and — for a `"commit"`/`"squash"` decision — assemble the emitted `scripts`
-* a driver runs to land it (against `rest.context` for a commit, or a
-* freshly built `contextAt` for a squash, which renders a DIFFERENT state's
-* template with the step's cost folded in).
+* and — for a `"commit"` decision — assemble the emitted `scripts` a driver
+* runs to land it, against `rest.context`.
 */
 const planStep = (rest, opts = {}) => gen(function* () {
 	const decision = step(rest.stepDef, rest.state, rest.actor, {
@@ -194155,8 +194065,7 @@ const planStep = (rest, opts = {}) => gen(function* () {
 	};
 	const { cost, model } = opts;
 	const git = yield* GitService;
-	const scriptContext = decision.kind === "commit" ? rest.context : yield* contextAt(rest, decision.state, rest.actor, cost, model);
-	const scripts = yield* buildStepScripts(git, rest, decision, scriptContext, cost, model);
+	const scripts = yield* buildStepScripts(git, rest, decision, cost, model);
 	return {
 		kind: decision.kind,
 		state: rest.state,
@@ -194166,7 +194075,7 @@ const planStep = (rest, opts = {}) => gen(function* () {
 });
 /**
 * `gtd --entry <state>`: start a brand NEW process at `entry.state` — any
-* declared, non-commit state — writing an ordinary turn commit carrying zero
+* declared state — writing an ordinary turn commit carrying zero
 * or more `Gtd-Var:` trailers for each `entry.vars` override, plus — when
 * `entry.state` declares a string `reviewBase:` — a `Gtd-Review-Base:`
 * trailer pinning the new process's diff base. Captures whatever the working
@@ -194234,12 +194143,11 @@ const planEntry = (rest, actor, entry) => gen(function* () {
 		...base !== void 0 ? { base } : {},
 		vars: varOverrides
 	});
-	const scriptsGit = yield* GitService;
 	return {
 		kind: "entry",
 		state: entryState,
 		subject,
-		scripts: emitScripts(yield* buildPreconditions(scriptsGit, rest, entryState), [{
+		scripts: emitScripts(buildPreconditions(rest), [{
 			kind: "gitWrite",
 			command: commitAll(message)
 		}, {
@@ -194249,106 +194157,36 @@ const planEntry = (rest, actor, entry) => gen(function* () {
 	};
 });
 //#endregion
-//#region src/ReviewWindow.ts
+//#region src/Summary.ts
 /**
-* Per-worktree (`refs/worktree/*`) so linked worktrees sharing one `.git`
-* don't clobber each other's window.
+* Every `human`-authored commit in `run.trace`, oldest to newest, minus
+* `entryHash` — derived generically off the invoking actor `computeProcessRun`
+* already parsed onto each `TraceEntry`, never by naming a state.
 */
-const REVIEW_HEAD_REF = "refs/worktree/gtd/review-head";
-const REVIEW_BASE_REF = "refs/worktree/gtd/review-base";
-/** The pre-7.2 shared refs — gtd never writes them, only reads them to finish a window an older gtd left open across the upgrade. */
-const LEGACY_REVIEW_HEAD_REF = "refs/gtd/review-head";
-const LEGACY_REVIEW_BASE_REF = "refs/gtd/review-base";
-const EMPTY_TREE$1 = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
-/** The manual-recovery incantation every close refusal ends with. */
-const manualRecovery = (refs) => `\`git reset --mixed ${refs.headRef} && git update-ref -d ${refs.headRef} && git update-ref -d ${refs.baseRef}\``;
-/**
-* Which ref pair (if any) records an open window: this worktree's own
-* `refs/worktree/gtd/*` pair first, falling back to the pre-7.2 shared
-* `refs/gtd/*` pair so an upgrade mid-window still closes cleanly.
-*/
-const openWindowRefs = (git) => gen(function* () {
-	const scoped = yield* git.readRefOption(REVIEW_HEAD_REF);
-	if (isSome(scoped)) return some({
-		headRef: REVIEW_HEAD_REF,
-		baseRef: REVIEW_BASE_REF,
-		headHash: scoped.value,
-		legacy: false
-	});
-	const legacy = yield* git.readRefOption(LEGACY_REVIEW_HEAD_REF);
-	if (isNone(legacy)) return none$4();
-	return some({
-		headRef: LEGACY_REVIEW_HEAD_REF,
-		baseRef: LEGACY_REVIEW_BASE_REF,
-		headHash: legacy.value,
-		legacy: true
-	});
-});
-const decideCloseWindow = gen(function* () {
-	const git = yield* GitService;
-	const open = yield* openWindowRefs(git);
-	if (isNone(open)) return { shouldClose: false };
-	const refs = open.value;
-	const base = yield* git.readRefOption(refs.baseRef);
-	if (isSome(base) && base.value !== EMPTY_TREE$1) {
-		if (!(yield* git.isAncestor(base.value, "HEAD"))) return yield* fail$2(/* @__PURE__ */ new Error(`a gtd review checkout window is open but HEAD has moved off the reviewed branch — return to it, or restore manually with ${manualRecovery(refs)}`));
-	}
-	if (refs.legacy) {
-		if (!(yield* git.isAncestor("HEAD", refs.headHash))) return yield* fail$2(/* @__PURE__ */ new Error(`a review checkout window is recorded under the shared ${LEGACY_REVIEW_HEAD_REF} (written by gtd 7.1 or older) but it does not belong to this worktree — HEAD is not contained in it. gtd now scopes the window per worktree (${REVIEW_HEAD_REF}); in the worktree that owns it, run ${manualRecovery(refs)}`));
-	}
-	return {
-		shouldClose: true,
-		refs
-	};
-});
+const humanCommitsOf = (run, entryHash) => run.trace.filter((entry) => entry.actor === "human" && entry.hash !== entryHash).map((entry) => ({
+	hash: entry.hash,
+	state: entry.state
+}));
 /**
-* PURE: the close sequence's bash text — reset to the saved head, then delete
-* both refs — built from `src/GitScript.ts`'s `mixedResetTo`/`deleteRef`.
-* Assumes its caller's guards (the reviewed-branch check, the legacy
-* containment check — see `decideCloseWindow`) have already passed; this
-* builder performs none of them, only the write sequence for the case where
-* they did.
-*
-* Resets to `refs.headHash` (the resolved hash), not `refs.headRef` by name —
-* the very next statement deletes that ref, so naming it for the reset would
-* fail on re-entry. A hash stays resolvable regardless, keeping the sequence
-* idempotent.
-*/
-const buildCloseWindowScript = (refs) => [
-	mixedResetTo(refs.headHash),
-	deleteRef(refs.headRef),
-	deleteRef(refs.baseRef)
-].join(" &&\n");
-const decideOpenWindow = (def, target, run, head) => {
-	if (!isReviewWindowState(def, target)) return { shouldOpen: false };
-	const base = reviewBaseFor(def, run);
-	if (base === EMPTY_TREE$1 || base === head) return { shouldOpen: false };
-	return {
-		shouldOpen: true,
-		base,
-		head
+* Build `SummaryContext` for `run` and render `def.summary` against it — pure,
+* touching no git and no filesystem (`base` already carries a resolved
+* `read`/`vars`/`processCost`, built by the caller against real git). Returns
+* `undefined` when the workflow declares no `summary:` or `run.trace` is
+* empty — both refusal conditions belong to the caller (`program.ts`), not an
+* Effect failure here.
+*/
+const buildSummary = (def, run, base) => {
+	if (def.summary === void 0 || run.trace.length === 0) return void 0;
+	const entryCommit = run.trace[0].hash;
+	const processTip = run.trace[run.trace.length - 1].hash;
+	const context = {
+		...base,
+		entryCommit,
+		humanCommits: humanCommitsOf(run, entryCommit),
+		processTip
 	};
+	return renderStateTemplate(def.summary, context);
 };
-/**
-* The open sequence's bash text: base-ref write, head-ref write,
-* mixed-reset-to-base, then a `.gtd/`-scoped `restoreStagedFrom` pin. No `git
-* add --intent-to-add` — that both loses the index-lock race and truncates
-* discarded files to zero bytes — so new files stay untracked; new files
-* outside `.gtd/` stay unpinned too, since `restoreStagedFrom` is scoped
-* there alone. Idempotent under re-entry.
-*
-* `".gtd"` is a deliberate literal, not derived from states' `file:`
-* declarations — it must also cover paths no state declares (a check
-* script's temp output), and `src/testing/EmittedScriptRecognizer.ts`'s
-* `recognizeReviewWindowOpen` re-derives this exact string to recognize the
-* script, which only works while it's fixed.
-*/
-const buildOpenWindowScript = (decision) => [
-	updateRef(REVIEW_BASE_REF, decision.base),
-	updateRef(REVIEW_HEAD_REF, decision.head),
-	mixedResetTo(decision.base),
-	restoreStagedFrom(REVIEW_HEAD_REF, [".gtd"])
-].join(" &&\n");
 //#endregion
 //#region node_modules/vscode-languageserver/lib/common/utils/is.js
 var require_is$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -205983,9 +205821,10 @@ const isPlumbingPath = (path) => path === ".gtd" || path.startsWith(`.gtd/`);
 const isCodePath = (path) => !isPlumbingPath(path);
 /** The `mode:` name of gtd's built-in REVIEW.md checkbox format — the only mode the review-doc guard understands. */
 const REVIEW_MODE = "review";
+/** Selects exactly the human review gate (`await-review` in the bundled template) — a human-actor state declaring `mode: review`. */
 const reviewDocGuard = {
 	name: "review-doc",
-	appliesTo: (rest) => isReviewWindowState(rest.def, rest.state) && rest.stateDef.mode === REVIEW_MODE,
+	appliesTo: (rest) => rest.stateDef.actor === "human" && rest.stateDef.mode === REVIEW_MODE,
 	check: (ctx) => succeed$3(ctx.fileDeleted ? `${ctx.file} was deleted at "${ctx.rest.state}" — restore it, or leave a note (or edit code) to request changes.` : void 0)
 };
 /** The one-line marker `feedback-collecting` writes when a review round left nothing actionable — the ONLY content that lets a `requireProgress` state's instructions file be deleted without a code change. */
@@ -206037,7 +205876,7 @@ const stepGuards = [
 * of the current committed/working bytes, and fail with the first refusal's
 * reason, prefixed `gtd land: ` (the one place that prefix, and
 * `Commentary.ts`'s `renderFailure` `/^gtd[: ]/` contract, is satisfied). A
-* no-op for a squash/no-op decision, an ATTEMPT commit (empty diff by
+* no-op for a `"noop"` decision, an ATTEMPT commit (empty diff by
 * construction — nothing for any guard to check), a state with no `file:`, or
 * a state no guard applies to.
 */
@@ -206058,7 +205897,7 @@ const enforceStepGuards = (input) => gen(function* () {
 		template: input.context
 	};
 	const files = yield* RepoFiles;
-	const head = yield* cached(files.committed(file, input.windowHead));
+	const head = yield* cached(files.committed(file));
 	const worktree = yield* cached(try_(() => files.working(file)));
 	const ctx = {
 		...base,
@@ -206858,76 +206697,27 @@ const steeringModeSteps = (rest) => gen(function* () {
 	if (resolved === void 0) return yield* fail$2(new Error(unknownModeMessage(rest.def, rest.state, mode)));
 	return yield* renderSteeringModeCommandSteps(resolved, file, rest.context);
 });
-/**
-* The `optional` half: re-open the review checkout window when the step
-* lands at a `reviewWindow: true` state, `""` otherwise. Takes the
-* already-decided `OpenWindowDecision` rather than deciding itself, since
-* narration belongs at the caller.
-*
-* `"HEAD"` is deliberately the literal string, not a resolved hash — git
-* resolves it when this script runs, after the required script has already
-* landed the new commit. For the same reason it carries no `expectedHead`
-* precondition: that hash doesn't exist yet at decide time.
-*/
-const openWindowScript = (decision) => {
-	if (!decision.shouldOpen) return "";
-	return emitScripts({}, [], [{
-		kind: "gitWrite",
-		command: buildOpenWindowScript({
-			base: decision.base,
-			head: decision.head
-		})
-	}]).optional;
-};
-/** `decideOpenWindow`'s result, narrated here (the one caller with `Narrator` in scope) — `decideOpenWindow` itself stays pure. */
-const decideAndNarrateOpenWindow = (rest, targetState) => gen(function* () {
-	const decision = decideOpenWindow(rest.def, targetState, rest.run, "HEAD");
-	yield* (yield* Narrator).narrate(decision.shouldOpen ? `review-window: open (base ${decision.base.slice(0, 7)})` : "review-window: no-op");
-	return decision;
-});
 /** True for a `"commit"` decision that is an ATTEMPT (`PatternMachine.StepCommit.attempt`) — the one flag both `enforceStepGuards` and `buildRequiredScript` bypass their own steps for (see each call site). */
 const isAttemptDecision = (decision) => decision.kind === "commit" && decision.attempt === true;
+/** The subject the required script will produce. */
+const previewSubject = (decision) => succeed$3(decision.subject);
 /**
-* The subject the required script will produce. Unreachable-on-failure:
-* `renderDecision` already rendered the same template and refused the
-* command if it threw, so this second render can never be the first to fail.
-*/
-const previewSubject = (decision, rest) => decision.kind === "commit" ? succeed$3(decision.subject) : try_(() => renderStateTemplate(decision.template, rest.context).split("\n")[0].trim()).pipe(catchAll(() => succeed$3(null)));
-/**
-* The `required` half: the review-window close (when one is open), the
-* resting state's own steering-mode commands, then the commit/squash steps.
-* The steering-mode step is skipped for an attempt commit — nothing to
-* format/validate in an empty diff, and running `format:` ahead of the
-* commit could dirty the tree and turn an "empty" attempt non-empty, breaking
-* `stalledAt`'s derivation. The window close still runs regardless —
-* committing with a window open would land the attempt on the review base.
+* The `required` half: the resting state's own steering-mode commands, then
+* the commit steps. The steering-mode step is skipped for an attempt commit —
+* nothing to format/validate in an empty diff, and running `format:` ahead of
+* the commit could dirty the tree and turn an "empty" attempt non-empty,
+* breaking `stalledAt`'s derivation.
 */
 const buildRequiredScript = (rest, decision, cost, model) => gen(function* () {
 	const git = yield* GitService;
-	const closeDecision = yield* decideCloseWindow;
-	yield* (yield* Narrator).narrate(closeDecision.shouldClose ? "review-window: close" : "review-window: no-op");
-	const commitContext = decision.kind === "commit" ? rest.context : yield* contextAt(rest, decision.state, rest.actor, cost, model);
-	const isAttempt = isAttemptDecision(decision);
-	const steps = [
-		...closeDecision.shouldClose ? [{
-			kind: "gitWrite",
-			command: buildCloseWindowScript(closeDecision.refs)
-		}] : [],
-		...isAttempt ? [] : yield* steeringModeSteps(rest),
-		...yield* renderDecision(git, rest, decision, commitContext, cost, model)
-	];
+	const steps = [...isAttemptDecision(decision) ? [] : yield* steeringModeSteps(rest), ...yield* renderDecision(git, rest, decision, cost, model)];
 	return emitScripts(headPreconditions(rest.context.currentCommit), steps).required;
 });
 /**
-* Decide the one resulting transition (commit or squash) for `gtd land`
+* Decide the one resulting transition (a commit) for `gtd land`
 * without performing it, authenticating as `rest.actor`. Refusals fail the
 * Effect with a formatted message; a no-op returns `subject: null` and empty
 * scripts.
-*
-* `plan.scripts` (built by `Edge.ts`) is not reused here: its precondition
-* uses `rest.context.currentCommit`, which while a review window is open is
-* the window's base, not the real head, and it contains no window close/open
-* steps. This function builds its own required/optional pair instead.
 */
 const planLanding = (opts = {}) => gen(function* () {
 	const rest = yield* currentRest;
@@ -206949,32 +206739,61 @@ const planLanding = (opts = {}) => gen(function* () {
 		};
 	}
 	const decision = plan.decision;
-	if (decision.kind !== "commit" && decision.kind !== "squash") return yield* fail$2(/* @__PURE__ */ new Error(`gtd: internal error — plan kind "${plan.kind}" but decision kind "${decision.kind}"`));
+	if (decision.kind !== "commit") return yield* fail$2(/* @__PURE__ */ new Error(`gtd: internal error — plan kind "${plan.kind}" but decision kind "${decision.kind}"`));
 	yield* enforceStepGuards({
 		rest,
 		context: rest.context,
 		file: rest.hints.file,
 		changes: rest.changes,
-		windowHead: rest.windowHead,
 		kind: decision.kind,
 		attempt: isAttemptDecision(decision)
 	});
-	const targetState = decision.kind === "commit" ? decision.to : decision.state;
-	const restingState = decision.kind === "commit" ? decision.to : initialStateOf(rest.def);
+	const restingState = decision.to;
 	const settled = yield* collapsesToInitialState(rest, decision);
-	const openDecision = yield* decideAndNarrateOpenWindow(rest, targetState);
 	const required = yield* buildRequiredScript(rest, decision, opts.cost, opts.model);
 	return {
 		state: restingState,
-		subject: yield* previewSubject(decision, rest),
+		subject: yield* previewSubject(decision),
 		cost: opts.cost ?? null,
 		model: opts.model ?? null,
-		script: normalizeScriptNewline(combinedScript(required, openWindowScript(openDecision))),
+		script: normalizeScriptNewline(combinedScript(required, "")),
 		settled,
 		idle: restingState === initialStateOf(rest.def)
 	};
 });
 /**
+* `gtd summary`: print the prompt for an agent to write the process HEAD
+* closes or sits inside its own closing message. Writes nothing — no git, no
+* state transition, no file. Refuses (throws, mapped to the runtime-error
+* exit code) on either of the two conditions `src/Summary.ts`'s
+* `buildSummary` folds into one `undefined`: the workflow declares no
+* `summary:` template, or the resolved run has no commits to name.
+*/
+const runSummaryCommand = (out) => gen(function* () {
+	const config = yield* (yield* ConfigService).load;
+	const run = yield* summaryRun;
+	const context = yield* summaryTemplateContext(run);
+	const rendered = buildSummary(config.workflow, run, context);
+	if (rendered === void 0) return yield* fail$2(/* @__PURE__ */ new Error("gtd summary: refused — either this workflow declares no \"summary:\" template, or there is no finished/in-flight process to summarize at HEAD"));
+	out.write(rendered.endsWith("\n") ? rendered : rendered + "\n");
+});
+/**
+* `gtd base`: print the review anchor hash — `reviewBaseFor(rest.def,
+* rest.run)` — bare and newline-terminated, so an external tool (a diff, a
+* PR tool, another agent) can be pointed at the range under review. Shaped
+* exactly like `runSummaryCommand`: one `Rest` resolved, nothing written — no
+* git, no state transition, no session identity. Refuses (mapped to the
+* runtime-error exit code) when the resolved run has no commits to name —
+* the only case where the hash would name a range that corresponds to no
+* review, exactly the way `runSummaryCommand` refuses on an empty trace.
+*/
+const runBaseCommand = (out) => gen(function* () {
+	const rest = yield* currentRest;
+	if (rest.run.trace.length === 0) return yield* fail$2(/* @__PURE__ */ new Error("gtd base: refused — no process is underway at HEAD"));
+	const base = reviewBaseFor(rest.def, rest.run);
+	out.write(`${base}\n`);
+});
+/**
 * `gtd land [--cost=<n>] [--model=<name>]`: land whatever the tree shows at
 * the currently resolved rest, authenticated as the rest's own actor.
 * Plain output writes `result.script` verbatim so `gtd land | sh` keeps
@@ -206990,7 +206809,7 @@ const runLandCommand = (opts, json, sh, out) => gen(function* () {
 });
 /**
 * `gtd --entry <state> [--var <name>=<value> ...]` (`actor` always `"human"`):
-* start a brand new process at `<state>` — any declared, non-commit state.
+* start a brand new process at `<state>` — any declared state.
 * Writes an ordinary turn commit carrying zero or more `Gtd-Var:` trailers,
 * plus a `Gtd-Review-Base:` trailer when `<state>` declares a `reviewBase:`.
 * Commits via `commitAllWithPrefix` — capturing whatever the working tree
@@ -207049,13 +206868,8 @@ const runAbandonCommand = (out) => gen(function* () {
 	}
 	const restState = run.trace[run.trace.length - 1].state;
 	if (run.startParentHash === EMPTY_TREE) return yield* fail$2(/* @__PURE__ */ new Error(`gtd abandon: the process underway (resting at "${restState}") starts at the repository's first commit — there is no earlier commit to rewind to`));
-	const closeDecision = yield* decideCloseWindow;
-	const tip = closeDecision.shouldClose ? closeDecision.refs.headHash : yield* git.resolveRef("HEAD");
+	const tip = yield* git.resolveRef("HEAD");
 	const steps = [
-		...closeDecision.shouldClose ? [{
-			kind: "gitWrite",
-			command: buildCloseWindowScript(closeDecision.refs)
-		}] : [],
 		{
 			kind: "gitWrite",
 			command: updateRef(HISTORY_REF, tip)
@@ -207069,12 +206883,12 @@ const runAbandonCommand = (out) => gen(function* () {
 			command: abandonedOutcome(restState, run.startParentHash, initial)
 		}
 	];
-	const required = emitScripts(headPreconditions(yield* git.resolveRef("HEAD")), steps).required;
+	const required = emitScripts(headPreconditions(tip), steps).required;
 	out.write(combinedScript(required, ""));
 });
 /**
-* `gtd restore`: hard-reset HEAD back to the pre-squash tip a squash or
-* `gtd abandon` retained, undoing either.
+* `gtd restore`: hard-reset HEAD back to the tip `gtd abandon` (or the
+* initial-state collapse's own mixed reset) retained.
 *
 * Guarded by `restorability` so it never discards work it didn't create:
 * refuses on a dirty working tree, no retained history, or HEAD having
@@ -207087,7 +206901,7 @@ const runRestoreCommand = (out) => gen(function* () {
 	if (isNone(retained)) return yield* fail$2(/* @__PURE__ */ new Error("gtd restore: no retained history to restore."));
 	const tip = retained.value;
 	const headHash = yield* git.resolveRef("HEAD");
-	const check = yield* restorability(git, headHash, yield* git.lastCommitMessage(), tip);
+	const check = yield* restorability(git, headHash, tip);
 	if (!check.ok) return yield* fail$2(/* @__PURE__ */ new Error(`gtd restore: ${check.reason} — HEAD ${headHash.slice(0, 7)} is ahead of the retained tip ${tip.slice(0, 7)}.`));
 	const after = yield* restAt(tip);
 	const steps = [
@@ -207394,14 +207208,11 @@ const gatherBeatFields = (rest, rendered) => gen(function* () {
 });
 /**
 * Best-effort resolution of the currently-rested state for the viewer's
-* `/state.json` route: prefers the review window's saved head over HEAD
-* itself, since a request landing mid-window would otherwise read a HEAD
-* that's been temporarily rewound. Any failure is swallowed to `null` — the
-* browser just hides the panel.
+* `/state.json` route. Any failure is swallowed to `null` — the browser just
+* hides the panel.
 */
 const computeCurrentState = (model) => gen(function* () {
-	const reviewHead = yield* (yield* GitService).readRefOption(REVIEW_HEAD_REF);
-	const rest = yield* restAt(getOrUndefined(reviewHead));
+	const rest = yield* restAt(void 0);
 	const group = model.states.find((s) => s.name === rest.state)?.group;
 	return buildCurrentStateModel(rest, rest.changes, rest.on, group);
 });
@@ -207504,6 +207315,8 @@ const dispatchVoidCommand = (command, json, sh, out) => {
 		case "validate": return runValidateCommand(out);
 		case "check": return runCheckCommand(command.mode, command.file, command.openQuestions ?? false);
 		case "install": return runInstallCommand(out);
+		case "summary": return runSummaryCommand(out);
+		case "base": return runBaseCommand(out);
 	}
 };
 /**
@@ -207512,10 +207325,6 @@ const dispatchVoidCommand = (command, json, sh, out) => {
 * repo-root-and-commit guard exactly when `needsOf(command.kind) === "state"`
 * (the `standaloneKinds` run bare). Both guard checks run before `dispatch`,
 * so a refusal writes nothing and emits no script by construction.
-*
-* No review-window close/open bracket runs here — every state-command
-* handler decides for itself, off `ReviewWindow.ts`'s pure decision
-* functions, whether a close/open belongs in the script it emits.
 */
 const runCommand = (command, json, sh, out) => {
 	const dispatch = dispatchVoidCommand(command, json, sh, out);
@@ -207614,11 +207423,7 @@ const FLAGS = [
 		decode: ([raw]) => right(raw ?? ""),
 		scopeError: "gtd: --entry is only valid with no other command — use the bare `gtd --entry <state>` form; landing and entering are different verbs",
 		valueHint: "<state>",
-		help: [
-			"(with no command at all) start a brand new process at",
-			"<state> — any declared, non-commit state — authenticated",
-			"as human"
-		]
+		help: ["(with no command at all) start a brand new process at", "<state> — any declared state — authenticated as human"]
 	},
 	{
 		name: "--var",
@@ -207674,8 +207479,8 @@ const FLAGS = [
 		help: [
 			"enable stderr narration for this invocation: which rest",
 			"resolved, which declared pattern each pending change",
-			"matched, which review-window action was emitted, and how",
-			"config resolved across layers. Aliased to -v"
+			"matched, and how config resolved across layers. Aliased",
+			"to -v"
 		]
 	}
 ];
@@ -207716,8 +207521,8 @@ const COMMAND_ROWS = [
 		arity: "none",
 		details: [
 			"Land whatever the tree now shows at the currently resolved",
-			"rest — a human capture, an agent/check turn, an empty",
-			"attempt (a fruitless prompt turn), or a squash. Pass",
+			"rest — a human capture, an agent/check turn, or an empty",
+			"attempt (a fruitless prompt turn). 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/",
@@ -207736,10 +207541,9 @@ const COMMAND_ROWS = [
 		arity: "none",
 		details: [
 			"End the process currently underway without completing it:",
-			"close any open review checkout window, then rewind HEAD to",
-			"the commit the process started from, keeping everything it",
-			"produced as uncommitted changes. A no-op when no process is",
-			"underway"
+			"rewind HEAD to the commit the process started from,",
+			"keeping everything it produced as uncommitted changes. A",
+			"no-op when no process is underway"
 		]
 	},
 	{
@@ -207747,12 +207551,12 @@ const COMMAND_ROWS = [
 		kind: "restore",
 		arity: "none",
 		details: [
-			"Hard-reset HEAD back to the pre-squash tip retained by the",
-			"last squash/abandon (refs/worktree/gtd/history), undoing a",
-			"squash or bringing back an abandoned process's turns.",
-			"Refuses on a dirty working tree, when there is no retained",
-			"history, or when HEAD has advanced past the squash with",
-			"commits that would be lost"
+			"Hard-reset HEAD back to the tip retained by the last",
+			"abandon (refs/worktree/gtd/history), bringing back an",
+			"abandoned process's turns. Refuses on a dirty working",
+			"tree, when there is no retained history, or when HEAD has",
+			"advanced past the retained tip with commits that would be",
+			"lost"
 		]
 	},
 	{
@@ -207838,6 +207642,39 @@ const COMMAND_ROWS = [
 			"'Writing your own driver'. Writes nothing: this installs",
 			"knowledge into the calling agent's context, not files on disk."
 		]
+	},
+	{
+		token: "summary",
+		kind: "summary",
+		arity: "none",
+		details: [
+			"Print the prompt for an agent to write the process HEAD",
+			"closes or sits inside its own closing message — the entry",
+			"commit, each human-authored commit (a review round, an",
+			"answered question gate), the diff range to inspect, and",
+			"it.processCost/processCostByModel. Writes nothing: no git,",
+			"no state transition, no file, no session identity — the",
+			"driver pipes the output to a cold agent and does what it",
+			"wants with the result (a squash, an amend, a PR body).",
+			"Refuses (exit 1) when the workflow declares no summary:",
+			"template, or when the resolved run has no commits to name",
+			"— runnable any time before the next thing lands on the",
+			"branch"
+		]
+	},
+	{
+		token: "base",
+		kind: "base",
+		arity: "none",
+		details: [
+			"Print the review anchor hash — the diff base an external",
+			"tool (a diff, a PR tool, another agent) should point at —",
+			"bare, newline-terminated, and nothing else. Writes nothing:",
+			"no git, no state transition, no session identity. Before",
+			"the first review round it's the process's diff base;",
+			"afterward it's the most-recent review round's boundary.",
+			"Refuses (exit 1) when no process is underway."
+		]
 	}
 ];
 const commandByToken = (token) => COMMAND_ROWS.find((r) => r.token === token);