@pmelab/gtd 8.0.0 → 8.2.0

package/dist/gtd.bundle.mjs

@@ -189759,7 +189759,7 @@ const validateDefinition = (def) => {
 * output so the rest of the compiler (and `KNOWN_TOP_KEYS`) only ever sees the
 * familiar `{ vars?, states, modes? }` shape. The pure engine (`PatternMachine`)
 * is entirely unaware sub-machines exist: expansion is a source-authoring
-* convenience with NO runtime footprint (see STATES.md, "Sub-machines"). Aliasing
+* convenience with NO runtime footprint. Aliasing
 * each invocation's local state names (via `as:`) to the exact concrete names a
 * hand-written workflow would use makes the expanded definition BYTE-IDENTICAL to
 * the flat one — the guarantee the bundled template's golden test pins
@@ -189850,6 +189850,7 @@ const expandOn = (raw, ctx, errors) => {
 		const next = { ...value };
 		if (typeof value["to"] === "string") next["to"] = resolveTarget(value["to"], ctx, errors);
 		if (typeof value["describe"] === "string") next["describe"] = substituteScalar(value["describe"], ctx, errors);
+		if (typeof value["action"] === "string") next["action"] = substituteScalar(value["action"], ctx, errors);
 		out[pattern] = next;
 	} else out[pattern] = value;
 	return out;
@@ -190056,12 +190057,11 @@ const collectGroups = (raw) => {
 //#endregion
 //#region src/PatternConfig.ts
 /**
-* The v3 `.gtdrc` `workflow:` config compiler (see
-* `docs/design/pattern-machine-plan.md`, "Phase 2: Config + templates"). This
+* The v3 `.gtdrc` `workflow:` config compiler. This
 * module turns the raw, unknown-shaped YAML value of the `workflow:` key into
 * a `PatternMachine` `WorkflowDefinition` — the ONLY definition source in v3
 * (no `extends`, no merge-over-a-built-in: the bundled default workflow is
-* itself a YAML asset compiled through this same function, a Phase 3
+* itself a YAML asset compiled through this same function, a
 * concern). Purely a compiler: no git, no Effect, no CLI wiring — those are
 * later phases.
 *
@@ -190337,7 +190337,26 @@ const inlineWorkflowFileRefs = (rawWorkflow, configDir, errors) => {
 		states
 	};
 };
-const KNOWN_EDGE_KEYS = /* @__PURE__ */ new Set(["to", "describe"]);
+const KNOWN_EDGE_KEYS = /* @__PURE__ */ new Set([
+	"to",
+	"describe",
+	"action"
+]);
+/** A missing/malformed field's failure sentinel, distinct from a legitimate `undefined` value. */
+const INVALID = Symbol("invalid edge field");
+/**
+* Validate one optional string field (`describe` or `action`) off an edge
+* object, pushing a finding and returning `INVALID` when it's present but not
+* a string.
+*/
+const compileOptionalEdgeField = (value, pattern, name, field, errors) => {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") {
+		errors.push(`state "${name}": "on.${pattern}.${field}" must be a string`);
+		return INVALID;
+	}
+	return value;
+};
 /**
 * Compile one `on` row's value into an `OnEdge` (or `undefined`, pushing a
 * finding, when the value is malformed). The value is EITHER a target-state
@@ -190353,19 +190372,25 @@ const compileOnEdge = (pattern, value, name, errors) => {
 	}
 	const unknownKeys = Object.keys(value).filter((k) => !KNOWN_EDGE_KEYS.has(k));
 	if (unknownKeys.length > 0) errors.push(`state "${name}": "on" entry for pattern "${pattern}" has unknown key(s) ${unknownKeys.join(", ")}`);
-	const { to, describe } = value;
+	const { to, describe, action } = value;
 	if (typeof to !== "string") {
 		errors.push(`state "${name}": "on.${pattern}.to" must be a target state name (string)`);
 		return;
 	}
-	if (describe !== void 0 && typeof describe !== "string") {
-		errors.push(`state "${name}": "on.${pattern}.describe" must be a string`);
-		return;
-	}
-	return describe !== void 0 ? [
+	const describeField = compileOptionalEdgeField(describe, pattern, name, "describe", errors);
+	if (describeField === INVALID) return void 0;
+	const actionField = compileOptionalEdgeField(action, pattern, name, "action", errors);
+	if (actionField === INVALID) return void 0;
+	if (actionField !== void 0) return [
 		pattern,
 		to,
-		describe
+		describeField,
+		actionField
+	];
+	return describeField !== void 0 ? [
+		pattern,
+		to,
+		describeField
 	] : [pattern, to];
 };
 /**
@@ -190607,14 +190632,22 @@ const compileWorkflowConfig = (raw, configDir, rcModes, inlineFileRefs = true) =
 };
 //#endregion
 //#region src/workflows/unified.yaml
-var unified_default = "# The unified gtd workflow template — gtd's BUILT-IN DEFAULT workflow. When no\n# `workflow:` key is configured anywhere in the cwd→home config chain,\n# src/Config.ts runs this template directly, so a state command works with no\n# configuration at all. `gtd init` seeds only the settings a project tunes\n# (vars.testCommand + a modes: formatting suggestion), never the workflow\n# itself. See STATES.md §10 for the full walkthrough.\n#\n# Compiled through the exact same `compileWorkflowConfig` a user's `.gtdrc`\n# `workflow:` key goes through — no privileged code path\n# (src/workflows/templates.ts does the compiling). Every content string below\n# is INLINE (no `./`-relative file references): the bundled template ships\n# inside a single-file build (`dist/gtd.bundle.mjs`), so its content must\n# already be resolved at BUILD time. `renderInitConfig` (src/workflows/\n# templates.ts) can MATERIALIZE this inline source into a `.gtdrc.json`\n# `workflow:` value — the way to eject/customize the machine, and the hermetic\n# test fixture — but `gtd init` itself no longer writes the workflow.\n#\n# ── Authored with SUB-MACHINES (Option C) ──────────────────────────────────\n#\n# This template is written with `submachines:`/`use:` (see src/Submachines.ts\n# and STATES.md). Expansion is a compile-time raw → raw pre-pass with NO runtime\n# footprint: the pure engine only ever sees the flat concrete states, and each\n# invocation's `as:` rename map reproduces the exact state names the flat\n# template used — so the compiled `WorkflowDefinition` is BYTE-IDENTICAL to the\n# frozen `unified.flat.yaml` (pinned by src/workflows/golden.test.ts). The\n# sub-machines split into DEDUP (a gate/loop authored once, invoked several\n# times) and ENCAPSULATION (a single-instance cluster grouped for reading):\n#\n#   * makeGreen (dedup ×2)    — the check/fix/escalate health triple shared by\n#                               the simple build tail and the advanced package\n#                               loop (identical script/prompt/message).\n#   * assertGreen (dedup ×3)  — the green-baseline gate (check + human blocked)\n#                               guarding the simple, advanced and review entries.\n#   * qaLoop (dedup ×2)       — the checkbox Q&A author/answer loop shared by the\n#                               product (adv-grilling) and technical (architecting)\n#                               phases of the advanced flow.\n#   * planLoop (encap)        — the simple flow's plan-iteration loop.\n#   * humanReview (encap)     — the shared review tail (reviewing → await-review →\n#                               review-deciding → feedback collect/build).\n#   * specGate (encap)        — the advanced flow's per-package agentic review.\n#   * packageLoop (encap)     — the advanced flow's per-package build queue.\n#\n# ── Four entry points behind a green-baseline gate, one shared tail ─────────\n#\n# EVERY entry first runs the test suite and only proceeds when it is GREEN — you\n# never start new work (or a review) on top of a red baseline. A red run halts\n# at a human `*-start-blocked` gate (fix the failures and re-run, exactly like\n# the `escalate` states), or is what `gtd fix` exists to repair.\n#\n# The initial `idle` state FORKS on which steering file the human creates,\n# routing into that flow's OWN start gate:\n#\n#   * the configured requirementsFile (default .gtd/REQUIREMENTS.md) ->\n#     `adv-start-check` -> the ADVANCED flow (product + technical Q&A, package\n#     decomposition, per-package parallel build + agentic spec-review).\n#   * anything else (e.g. the configured todoFile, default .gtd/TODO.md) ->\n#     `start-check` -> the SIMPLE flow (one grilling Q&A loop, a monolithic\n#     build, no decomposition, no agentic review).\n#\n# A third entry, `gtd review <commitish>`, jumps to `review-start-check`\n# (reviewEntry) and, once green, to `reviewing` to review a foreign branch\n# through the same shared tail. A fourth, `gtd fix`, jumps to `fix-check`\n# (fixEntry): a red suite drops straight into the shared `fixing` loop and out\n# through the review + squash tail; a green suite is a no-op back to `idle`.\n#\n# All three converge at `reviewing` -> `await-review`. Ticking a REVIEW.md box\n# means only \"I reviewed this hunk\"; a COMMENT (not an unticked box) is what asks\n# for changes. Every human step at `await-review` goes to `review-deciding`,\n# which inspects the step and routes:\n#   * no comment (every box ticked, no REVIEW.md note, no code edit) -> the diff\n#     is a bare REVIEW.md deletion -> squashing -> done (the ONLY path to the\n#     finale — the whole cycle collapses into one commit).\n#   * any comment — a note in REVIEW.md OR a hand-edit to code — ->\n#     review-deciding writes REVIEW_FEEDBACK.md -> feedback-building implements\n#     it (completing any code the human hand-edited, never reverting their\n#     lines) -> checking -> reviewing regenerates an INCREMENTAL REVIEW.md\n#     (review-deciding carries `reviewBase: true`, so each feedback round's\n#     review + checkout window covers only `last-review..HEAD`, i.e. the agent's\n#     follow-through, not the human's own edit) -> await-review, looping until\n#     sign-off.\n# Two dead ends never commit: the sign-off gate (src/program.ts) REFUSES a step\n# that leaves a box unticked with no comment (finish reviewing first) and a\n# deleted REVIEW.md (restore it and tick the boxes).\n#\n# The shared health segment (`checking`/`fixing`/`escalate`) serves the simple\n# build and the feedback loop — its green edge targets\n# `reviewing`. The advanced per-package loop keeps its OWN health triple\n# (`adv-checking`/`adv-fixing`/`adv-escalate`) because its green edge targets\n# the per-package `spec-review` gate instead.\n#\n# Every `on` pattern's path below is written as the matching var's Eta\n# template (e.g. `\"A <%= it.vars.feedbackFile %>\"`), not a literal `.gtd/...`\n# path — repointing a var reroutes the machine along with every template that\n# reads/writes it (see docs/configuration.md).\n\nvars:\n  testCommand: npm test\n  # Where gtd keeps its own scratch/bookkeeping (the check scripts' temp output\n  # file, review-deciding's state-file exclusion). Independent of the per-file\n  # vars below — relocating a file wholesale means setting both.\n  stateDir: .gtd\n  todoFile: .gtd/TODO.md\n  requirementsFile: .gtd/REQUIREMENTS.md\n  architectureFile: .gtd/ARCHITECTURE.md\n  packagesDir: .gtd/packages\n  nextFile: .gtd/NEXT.md\n  reviewFile: .gtd/REVIEW.md\n  reviewRawFile: .gtd/REVIEW_RAW.md\n  reviewFeedbackFile: .gtd/REVIEW_FEEDBACK.md\n  feedbackFile: .gtd/FEEDBACK.md\n  specFeedbackFile: .gtd/SPEC_FEEDBACK.md\n  commitMsgFile: .gtd/COMMIT_MSG.md\n  # The two opaque model tiers every agent state draws from — repoint them here\n  # (or via a top-level `.gtdrc` `vars:` key / a `GTD_PLANNERMODEL` env var)\n  # to change every state on that tier at once. `plannerModel` (default \"smart\")\n  # is the heavier tier for the one-shot planning/architecting/review turns;\n  # `coderModel` (default \"base\") is the tier for the build/fix turns.\n  plannerModel: smart\n  coderModel: base\n\nsubmachines:\n  # ── DEDUP: the check/fix/escalate health triple ───────────────────────────\n  # Runs the suite; a red run records the configured feedbackFile, a green run\n  # cleans it up.\n  # The `on` rules turn that into \"fix\" vs \"$onGreen\". The fix turn retries up to\n  # 3× before escalating to a human. Invoked for the shared build tail\n  # (checking/fixing/escalate -> reviewing) and the advanced package loop\n  # (adv-checking/adv-fixing/adv-escalate -> spec-review).\n  makeGreen:\n    params: [onGreen, escalateDescribe, checkLabel, fixLabel, escalateLabel]\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        # NOT the shared `&suiteCheck` anchor (that lives on `assertGreen`,\n        # aliased by it and by `fix-check`): this script also sweeps spent\n        # steering files (`todoFile`, `reviewRawFile`, `reviewFeedbackFile`) —\n        # a mechanic the entry/fix gates must NOT run, since they execute\n        # before planning, while a fresh sketch legitimately still exists.\n        script: |\n          #!/usr/bin/env bash\n          # gtd check turn — run the suite; a red run records .gtd/FEEDBACK.md, a\n          # green run cleans it up. The `on` rules decide what that means.\n          set +e\n          mkdir -p \"<%~ it.vars.stateDir %>\"\n          # Hoist every path once, at the TOP: Eta's autoTrim eats the newline\n          # after an interpolation tag, so no tag may be the last token on a\n          # line — it would glue the next line's `else`/`fi` onto it and break\n          # the script. Below this point everything is plain bash.\n          feedback=\"<%~ it.vars.feedbackFile %>\"\n          mkdir -p \"$(dirname \"$feedback\")\"\n          # Sweep steering files spent by the states that led here: the plan\n          # (building), the raw review capture (feedback-collecting), and the\n          # feedback instructions (feedback-building) — each `rm -f` is a\n          # no-op when the file is already gone or never existed on this path.\n          todo=\"<%~ it.vars.todoFile %>\"\n          reviewRaw=\"<%~ it.vars.reviewRawFile %>\"\n          reviewFeedback=\"<%~ it.vars.reviewFeedbackFile %>\"\n          rm -f \"$todo\" \"$reviewRaw\" \"$reviewFeedback\"\n          <%~ it.vars.testCommand %> > <%~ it.vars.stateDir %>/.check-output 2>&1\n          code=$?\n          if [ \"$code\" -ne 0 ]; then\n            if [ -s <%~ it.vars.stateDir %>/.check-output ]; then\n              mv <%~ it.vars.stateDir %>/.check-output \"$feedback\"\n            else\n              rm -f <%~ it.vars.stateDir %>/.check-output\n              printf 'the test command failed with exit code %s and produced no output.' \"$code\" > \"$feedback\"\n            fi\n            # A repeat identical failure would otherwise leave FEEDBACK.md\n            # byte-identical to its committed copy — no diff, so the check would\n            # look GREEN. Stamp each red run with the current HEAD (which always\n            # advances between checks) so a still-red re-run always re-registers\n            # as an M/A edit and takes the red edge.\n            printf '\\n<!-- gtd check %s -->\\n' \"$(git rev-parse --short HEAD 2>/dev/null || echo pending)\" >> \"$feedback\"\n          else\n            rm -f <%~ it.vars.stateDir %>/.check-output\n            rm -f \"$feedback\"\n          fi\n        on:\n          \"A <%= it.vars.feedbackFile %>\": fix\n          \"M <%= it.vars.feedbackFile %>\": fix\n          \"* **\": $onGreen\n          \"C\": $onGreen\n      fix:\n        actor: agent\n        label: $fixLabel\n        file: <%= it.vars.feedbackFile %>\n        model: <%= it.vars.coderModel %>\n        memory: fix\n        retry:\n          max: 3\n          otherwise: escalate\n        prompt: |\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. The only state file this\n          turn touches is `<%= it.vars.feedbackFile %>`; 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 `<%= it.vars.feedbackFile %>` (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          `<%= it.vars.feedbackFile %>` instead of \"fixing\" a non-issue.\n\n          Leave everything uncommitted and finish your turn — do not commit.\n        on:\n          \"* **\": check\n      escalate:\n        actor: human\n        label: $escalateLabel\n        file: <%= it.vars.feedbackFile %>\n        message: |\n          The agent could not get the check to pass after repeated attempts.\n          `<%= it.vars.feedbackFile %>` holds the last failing output.\n\n          What each change does next (then run `gtd step human`):\n          <% it.edges.forEach(function (e) { if (e.describe) { %>\n          <%~ \"- \" + e.describe + \"\\n\" %>\n          <% } }) %>\n        on:\n          \"* **\":\n            to: check\n            describe: $escalateDescribe\n\n  # ── DEDUP: the green-baseline gate ─────────────────────────────────────────\n  # Runs the suite before any work starts (its script is the health check's test\n  # wrapper — red -> the configured feedbackFile, green -> remove it); the `on` rules turn\n  # that into \"halt at blocked\" vs \"proceed to $onGreen\". The script and blocked\n  # message/describe differ per entry, so they ride in as `with:` params.\n  assertGreen:\n    params: [onGreen, blockedMessage, blockedDescribe, checkLabel, blockedLabel]\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        # Anchored here and aliased by `fix-check` (`gtd fix` entry): one\n        # suite-check script shared by all four call sites (this submachine's\n        # ×3 uses plus `fix-check`) instead of four source copies. These gates\n        # run BEFORE planning, so — unlike `makeGreen.check` — they must NOT\n        # sweep `todoFile`/`requirementsFile`: the human's fresh sketch still\n        # legitimately exists here.\n        script: &suiteCheck |\n          #!/usr/bin/env bash\n          # gtd check turn — run the suite; a red run records .gtd/FEEDBACK.md, a\n          # green run cleans it up. The `on` rules decide what that means.\n          set +e\n          mkdir -p \"<%~ it.vars.stateDir %>\"\n          # Hoist the feedback path once, at the TOP: Eta's autoTrim eats the\n          # newline after an interpolation tag, so no tag may be the last token on\n          # a line — it would glue the next line's `else`/`fi` onto it and break\n          # the script. Below this point everything is plain bash.\n          feedback=\"<%~ it.vars.feedbackFile %>\"\n          mkdir -p \"$(dirname \"$feedback\")\"\n          <%~ it.vars.testCommand %> > <%~ it.vars.stateDir %>/.check-output 2>&1\n          code=$?\n          if [ \"$code\" -ne 0 ]; then\n            if [ -s <%~ it.vars.stateDir %>/.check-output ]; then\n              mv <%~ it.vars.stateDir %>/.check-output \"$feedback\"\n            else\n              rm -f <%~ it.vars.stateDir %>/.check-output\n              printf 'the test command failed with exit code %s and produced no output.' \"$code\" > \"$feedback\"\n            fi\n            # A repeat identical failure would otherwise leave FEEDBACK.md\n            # byte-identical to its committed copy — no diff, so the check would\n            # look GREEN. Stamp each red run with the current HEAD (which always\n            # advances between checks) so a still-red re-run always re-registers\n            # as an M/A edit and takes the red edge.\n            printf '\\n<!-- gtd check %s -->\\n' \"$(git rev-parse --short HEAD 2>/dev/null || echo pending)\" >> \"$feedback\"\n          else\n            rm -f <%~ it.vars.stateDir %>/.check-output\n            rm -f \"$feedback\"\n          fi\n        on:\n          \"A <%= it.vars.feedbackFile %>\": blocked\n          \"M <%= it.vars.feedbackFile %>\": blocked\n          \"D <%= it.vars.feedbackFile %>\": $onGreen\n          \"C\": $onGreen\n      blocked:\n        actor: human\n        label: $blockedLabel\n        file: <%= it.vars.feedbackFile %>\n        message: $blockedMessage\n        on:\n          \"* **\":\n            to: check\n            describe: $blockedDescribe\n\n  # ── DEDUP: the checkbox Q&A author/answer loop ─────────────────────────────\n  # The agent develops a plan file, surfacing `## Open Questions` as checkbox\n  # lists; the human answers (answerGate refuses an unanswered step) and either\n  # advances or sends it back. Invoked for the product (adv-grilling) and\n  # technical (architecting) phases of the advanced flow.\n  qaLoop:\n    params:\n      [\n        authorFile,\n        authorPrompt,\n        answerMessage,\n        onAdvance,\n        advanceDescribe,\n        editDescribe,\n        authorLabel,\n        answerLabel,\n      ]\n    states:\n      author:\n        actor: agent\n        label: $authorLabel\n        file: $authorFile\n        mode: qa\n        model: <%= it.vars.plannerModel %>\n        memory: plan\n        prompt: $authorPrompt\n        on:\n          \"* **\": answer\n      answer:\n        actor: human\n        label: $answerLabel\n        file: $authorFile\n        mode: qa\n        answerGate: true\n        message: $answerMessage\n        on:\n          \"C\":\n            to: $onAdvance\n            describe: $advanceDescribe\n          \"* **\":\n            to: author\n            describe: $editDescribe\n\n  # ── ENCAPSULATION: the simple flow's plan-iteration loop ───────────────────\n  planLoop:\n    params: [onAccept]\n    states:\n      planning:\n        actor: agent\n        label: Refining the plan\n        file: <%= it.vars.todoFile %>\n        mode: prose\n        model: <%= it.vars.plannerModel %>\n        memory: plan\n        prompt: |\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. The only state file this\n          turn touches is `<%= it.vars.todoFile %>`; develop it into the plan.\n          Do not create other files to hold notes or output.\n\n          `<%= it.vars.todoFile %>` holds a short sketch of what to build — or, on a\n          return lap, the plan you already wrote plus the human's edits and comments\n          on it. Read it, explore the codebase, and develop it into a concrete\n          implementation plan: the files to change, the approach, and the steps to\n          take.\n\n          Do NOT ask questions and do NOT add an \"Open Questions\" section — decide\n          every open point yourself and write the plan as a set of concrete\n          decisions. Where a decision is genuinely a judgement call, state the\n          choice you made and, in one line, why. The human iterates on the plan by\n          editing it directly, not by answering questions.\n\n          On a return lap, `<%= it.vars.todoFile %>` carries the human's edits and\n          inline comments on your previous plan. Fold every edit and comment into a\n          revised, self-contained plan and remove the addressed comments — the plan\n          is always the current, clean proposal, never a diff.\n\n          Leave `<%= it.vars.todoFile %>` uncommitted and finish your turn — do\n          not commit, and do not run `gtd step agent` yourself; the harness does\n          that.\n        on:\n          \"* **\": plan-review\n\n      plan-review:\n        actor: human\n        label: Awaiting your review\n        file: <%= it.vars.todoFile %>\n        mode: prose\n        message: |\n          `<%= it.vars.todoFile %>` holds the proposed implementation plan. Read it,\n          then either accept it as-is or edit it — rewrite a step, add a\n          constraint, or drop an inline comment — to send it back for another round.\n\n          What each change does next (then run `gtd step human`):\n          <% it.edges.forEach(function (e) { if (e.describe) { %>\n          <%~ \"- \" + e.describe + \"\\n\" %>\n          <% } }) %>\n        on:\n          \"C\":\n            to: $onAccept\n            describe: >-\n              Change nothing to accept the plan as-is and move on to implementation\n              (**building**).\n          \"* **\":\n            to: planning\n            describe: >-\n              Edit the plan — rewrite a step, add a constraint, or leave an inline\n              comment — to send it back for another round (**planning**).\n\n  # ── ENCAPSULATION: the shared review tail ──────────────────────────────────\n  humanReview:\n    params: [onSignoff]\n    states:\n      reviewing:\n        actor: agent\n        label: Reviewing\n        file: <%= it.vars.reviewFile %>\n        mode: review\n        model: <%= it.vars.plannerModel %>\n        memory: review\n        # `gtd review <commitish>` (a plain non-gtd branch, e.g. a colleague's PR)\n        # does NOT enter here directly — it enters `review-start-check` (reviewEntry)\n        # first, which runs the green-baseline gate and, once green, transitions\n        # here. The `Gtd-Review-Base:` trailer rides on that entry commit (the\n        # process's oldest), so everything below still reuses the same\n        # reviewing/await-review/feedback machinery over <commitish>..HEAD.\n        prompt: |\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. The only state file this\n          turn touches is `<%= it.vars.reviewFile %>`; write it at exactly\n          that path. Do not create other files to hold notes or output.\n\n          Write `<%= it.vars.reviewFile %>` to help a human review the diff below in\n          this EXACT format:\n\n          - First non-blank line: `# Review: <%= it.currentCommit.slice(0, 7) %>`\n          - Somewhere in the document: `<!-- base: <%= it.startCommit %> -->`\n          - At least one `## <Chunk Title>` heading, grouping hunks semantically\n            (same feature/refactor/fix, even across files) — a short explanation of\n            what changed and why, then one `- [ ] ./path/to/file.ts#42 — note` file\n            pointer per hunk (checkboxes are for the human to tick, not you; every\n            path is `./`-relative, with an optional `#line` and an optional\n            ` — note`).\n\n          The diff below is `it.reviewDiff` — on a feedback round it covers ONLY the\n          changes made since the previous review, so you review just what changed,\n          not items already signed off. Leave `<%= it.vars.reviewFile %>`\n          uncommitted and finish your turn.\n          <% if (it.reviewDiff.trim()) { %>\n\n          ## Full diff under review\n\n          ```diff\n          <%~ it.reviewDiff %>\n          ```\n          <% } %>\n        on:\n          \"* **\": await-review\n\n      await-review:\n        actor: human\n        label: Awaiting your review\n        file: <%= it.vars.reviewFile %>\n        mode: review\n        # While the cycle rests here, gtd opens a \"review checkout window\": raw HEAD\n        # is rewound to the review base (the most-recent `review-deciding` commit —\n        # so a feedback round shows only `last-review..HEAD` — or the process start\n        # on the first review) with the working tree untouched, surfacing the diff\n        # as ordinary uncommitted changes. It closes on the next invocation.\n        #\n        # Every human step here routes to `review-deciding`, which decides sign-off\n        # vs. feedback from the step's CONTENT (a comment, not a tick). Ticking a box\n        # only records \"I reviewed this hunk\". Two dead ends can't be told apart by a\n        # file-pattern edge, so the sign-off gate (`enforceReviewSignoffGate` in\n        # src/program.ts) catches them BEFORE the step commits and refuses: an\n        # unfinished review (a box still `- [ ]` with no comment) and a deleted\n        # REVIEW.md.\n        reviewWindow: true\n        message: |\n          `<%= it.vars.reviewFile %>` holds the review record for the cycle — 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 step human`:\n\n          - Tick EVERY box and leave no comment — no note in\n            `<%= it.vars.reviewFile %>`, no code edit — to sign off and collapse the\n            cycle into one commit (**squashing**).\n          - Leave a comment to request changes — a note on a\n            `<%= it.vars.reviewFile %>` line, or a direct code edit — to send it to a\n            build + re-review round (**review-deciding** → **feedback-building**). A\n            code edit counts as your own fix: the agent completes the follow-through\n            it implies and never reverts your lines.\n\n          Stepping with a box still unticked and no comment is refused (finish\n          reviewing first); so is deleting `<%= it.vars.reviewFile %>`.\n        on:\n          \"* **\": review-deciding\n\n      review-deciding:\n        actor: check\n        label: Reviewing\n        file: <%= it.vars.reviewFile %>\n        mode: review\n        # Anchors the INCREMENTAL review base: its most-recent in-process commit is\n        # the point the previous review round ended, so the next `reviewing` turn\n        # (and the review checkout window) covers only the changes since then. On\n        # the first review there is no such commit, so the base is the cycle start.\n        reviewBase: true\n        script: |\n          #!/usr/bin/env bash\n          # gtd check turn — decide the human's review step from its CONTENT. HEAD is\n          # the human's `await-review -> review-deciding` commit; HEAD^ is the\n          # `reviewing` commit that wrote the agent's original REVIEW.md (the sign-off\n          # gate refuses an incomplete step, so review-deciding is entered exactly\n          # once per round — nothing commits in between). It is FEEDBACK when the\n          # human left a comment: a note in REVIEW.md (any edit beyond a \"[ ]\"->\"[x]\"\n          # tick) OR a hand-edit to any file this round other than `.gtd/` or the\n          # state's own reviewFile (which is var-configurable and may live outside\n          # `.gtd/`, e.g. a root-level REVIEW.md — issue #128). Otherwise it is a\n          # clean sign-off. This turn only CAPTURES the raw material into REVIEW_RAW.md\n          # (the `feedback-collecting` agent then turns it into instructions); it does\n          # NOT interpret it. Either way, remove REVIEW.md; what the resulting diff\n          # MEANS is decided by this state's own `on` rules — the A/M REVIEW_RAW.md\n          # rows are declared BEFORE the D REVIEW.md row so a feedback round (which\n          # also deletes REVIEW.md) is captured as feedback, not mistaken for a\n          # sign-off.\n          set +e\n          # Hoist the paths once, 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 — it\n          # would glue the next line onto it and break the script. Below this point\n          # everything is plain bash.\n          stateDir=\"<%~ it.vars.stateDir %>\"\n          reviewFile=\"<%~ it.vars.reviewFile %>\"\n          reviewRawFile=\"<%~ it.vars.reviewRawFile %>\"\n          mkdir -p \"$(dirname \"$reviewRawFile\")\"\n          # Which files did the human hand-edit this round, besides stateDir and the\n          # reviewFile itself (var-configurable — may live outside stateDir, so it is\n          # excluded by exact path, not just the stateDir prefix)?\n          codeFiles=$(git diff-tree --no-commit-id --name-only -r HEAD \\\n            | grep -v \"^$stateDir/\" | grep -vxF \"$reviewFile\")\n          # A note is any REVIEW.md change beyond a checkbox flip: normalize every\n          # \"[ ]\"/\"[x]\" to a placeholder, then compare the agent's original (HEAD^)\n          # against the human's version (HEAD).\n          notes=\"\"\n          before=$(git show \"HEAD^:$reviewFile\" 2>/dev/null | sed -E 's/\\[[ xX]\\]/[_]/g')\n          after=$(git show \"HEAD:$reviewFile\" 2>/dev/null | sed -E 's/\\[[ xX]\\]/[_]/g')\n          if [ \"$before\" != \"$after\" ]; then notes=1; fi\n          if [ -n \"$codeFiles\" ] || [ -n \"$notes\" ]; then\n            {\n              echo \"Raw review material captured for classification. The human reviewed the diff and left the feedback below; a downstream agent turns it into an instruction list. This file is machine-captured input, not instructions.\"\n              if [ -n \"$notes\" ]; then\n                echo\n                echo \"## Notes the human added to REVIEW.md this round\"\n                echo\n                echo '```diff'\n                git show HEAD --format= -- \"$reviewFile\"\n                echo '```'\n              fi\n              if [ -n \"$codeFiles\" ]; then\n                echo\n                echo \"## Files the human hand-edited this round (already committed)\"\n                echo\n                echo '```diff'\n                git show HEAD --format= -- $codeFiles\n                echo '```'\n              fi\n            } > \"$reviewRawFile\"\n          fi\n          rm -f \"$reviewFile\"\n        on:\n          \"A <%= it.vars.reviewRawFile %>\": feedback-collecting\n          \"M <%= it.vars.reviewRawFile %>\": feedback-collecting\n          \"D <%= it.vars.reviewFile %>\": $onSignoff\n\n      feedback-collecting:\n        actor: agent\n        label: Collecting your feedback\n        file: <%= it.vars.reviewFeedbackFile %>\n        model: <%= it.vars.plannerModel %>\n        memory: review\n        prompt: |\n          You are an autonomous coding agent turning raw review feedback into an\n          explicit instruction list for a builder. This workflow steers itself\n          through its own state files — treat them as its private scratchpad,\n          never as project code or documentation. The only state files this\n          turn touches are `<%= it.vars.reviewRawFile %>` (read it, then\n          delete it) and `<%= it.vars.reviewFeedbackFile %>` (write it) — do\n          NOT change any other file, you classify, you do not build.\n\n          The raw review material is: <%~ it.read(it.vars.reviewRawFile) %>\n\n          Classify every piece of it into `<%= it.vars.reviewFeedbackFile %>` as a\n          flat, numbered instruction list. Each item is `N. ./path/to/file.ts#line —\n          <imperative>`. Read the two RAW sections and apply these rules exactly:\n\n          1. NOTES the human added to REVIEW.md — each note is a MANDATORY change,\n             regardless of whether its checkbox is ticked (ticking means only \"I read\n             this hunk\", never sign-off). Anchor each to the `./path#line` its review\n             item names (or the chunk it sits under). Emit it as a concrete\n             imperative.\n          2. Every COMMENT the human ADDED this round (a `+` line that is a code\n             comment, in the hand-edited files) is a MANDATORY instruction the human\n             is giving the builder — even a plain-prose one, even if its box is\n             ticked. Emit an imperative to satisfy it and note that the comment line\n             itself must be REMOVED once addressed. If a comment turns out to describe\n             behaviour the code already has, the instruction is still \"confirm the\n             code matches and remove the comment line\".\n          3. Every NON-comment code line the human hand-edited is an already-committed\n             INTENT, NOT a do-then-delete item. Emit an instruction that names those\n             files and says: their lines are final — complete ONLY the follow-through\n             they imply (callers, tests, types, docs) and NEVER revert or rewrite\n             them. Do not turn their own edit into a task.\n\n          Split each hand-edited hunk per line: comment `+` lines follow rule 2, the\n          surrounding real code follows rule 3.\n\n          If — and only if — nothing in the raw material is actionable (e.g. the human\n          left only an approving remark), write `<%= it.vars.reviewFeedbackFile %>`\n          containing exactly one line: `NOTHING ACTIONABLE — <one-sentence reason>`.\n          Never invent work to satisfy a non-actionable remark.\n\n          Delete `<%= it.vars.reviewRawFile %>`, leave everything else uncommitted,\n          and finish your turn.\n        on:\n          \"A <%= it.vars.reviewFeedbackFile %>\": feedback-building\n          \"M <%= it.vars.reviewFeedbackFile %>\": feedback-building\n\n      feedback-building:\n        actor: agent\n        label: Addressing your feedback\n        file: <%= it.vars.reviewFeedbackFile %>\n        model: <%= it.vars.coderModel %>\n        memory: build\n        # Refuse a work-free turn: a step whose only pending change is deleting the\n        # instructions file (the original \"captured then discarded\" bug). The edge\n        # gate (`enforceFeedbackProgressGate` in src/program.ts) reads this flag and\n        # exempts a `NOTHING ACTIONABLE` sentinel (a non-actionable review round,\n        # which legitimately makes no code change). The pure engine carries it inert.\n        requireProgress: true\n        prompt: |\n          You are an autonomous coding agent addressing review feedback. This\n          workflow steers itself through its own state files — treat them as\n          its private scratchpad, never as project code or documentation. The\n          only state file this turn touches is\n          `<%= it.vars.reviewFeedbackFile %>`; address it, then delete it. Do\n          not create other files to hold notes or output.\n\n          The instructions to implement are: <%~ it.read(it.vars.reviewFeedbackFile) %>\n\n          This is a flat instruction list, not a diff — execute every item exactly as\n          written, no Q&A, no re-planning, using TDD discipline:\n\n          - An item that says the human's own lines are final: build ON TOP of them to\n            complete only the follow-through it names (callers, tests, types, docs).\n            NEVER revert or rewrite the lines they already committed.\n          - An item derived from a human comment: satisfy it AND delete that comment\n            line from the code (the human's review comments are transient — none of\n            them survive this round).\n\n          If the file's sole content is a `NOTHING ACTIONABLE` line, make no code\n          change; just delete the instructions file.\n\n          Delete `<%= it.vars.reviewFeedbackFile %>` once every item is addressed.\n          Leave everything else uncommitted and finish your turn. Deleting the\n          instructions file WITHOUT making the changes it asks for is refused — the\n          feedback must actually be addressed.\n        on:\n          \"* **\": checking\n\n  # ── ENCAPSULATION: the advanced flow's per-package agentic review ──────────\n  specGate:\n    params: [onApproved]\n    states:\n      spec-review:\n        actor: agent\n        label: Reviewing the package\n        model: <%= it.vars.plannerModel %>\n        memory: review\n        # Bounded per cycle: once entered `max` times, a transition into it is\n        # redirected to `closing` (force-close the package and move on — the\n        # unresolved concern is deferred to the shared human review at the tail,\n        # which sees the whole diff anyway). NOTE the cap is PROCESS-scoped, so it\n        # pools across packages — the same documented limitation the shared\n        # `fixing` cap has (see STATES.md / docs/configuration.md).\n        retry:\n          max: 3\n          otherwise: $onApproved\n        prompt: |\n          You are an autonomous coding agent reviewing a freshly-built work package\n          against its own spec. This workflow steers itself through its own\n          state files — treat them as its private scratchpad, never as project\n          code or documentation. The only state file this turn touches is\n          `<%= it.vars.specFeedbackFile %>`; 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(it.vars.nextFile) %>\n\n          Read that spec, then verify the package's implementation (the diff below)\n          against it: are all its tasks done, acceptance criteria met, and the code\n          sound and consistent with the codebase?\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 `<%= it.vars.specFeedbackFile %>` 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          <% if (it.processDiff.trim()) { %>\n\n          ## Diff under review\n\n          ```diff\n          <%~ it.processDiff %>\n          ```\n          <% } %>\n        on:\n          \"A <%= it.vars.specFeedbackFile %>\": spec-fix\n          \"M <%= it.vars.specFeedbackFile %>\": spec-fix\n          \"D <%= it.vars.specFeedbackFile %>\": $onApproved\n          \"C\": $onApproved\n\n      spec-fix:\n        actor: agent\n        label: Fixing review feedback\n        file: <%= it.vars.specFeedbackFile %>\n        model: <%= it.vars.coderModel %>\n        memory: fix\n        prompt: |\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. The only state file this\n          turn touches is `<%= it.vars.specFeedbackFile %>`; address it, then\n          delete it. Do not create other files to hold notes or output.\n\n          Read `<%= it.vars.specFeedbackFile %>` (the reviewer's concerns about the\n          current package) and the package spec (`<%= it.read(it.vars.nextFile) %>`),\n          then fix the code to resolve every concern. Keep the change focused.\n\n          Delete `<%= it.vars.specFeedbackFile %>` once every concern is addressed.\n          Leave everything else uncommitted and finish your turn.\n        on:\n          \"* **\": adv-checking\n\n  # ── ENCAPSULATION: the advanced flow's per-package build queue ─────────────\n  packageLoop:\n    params: [onDrained]\n    states:\n      picking:\n        actor: check\n        label: Picking the next package\n        script: |\n          #!/usr/bin/env bash\n          # gtd check turn (the package queue arbiter) — the loop driver executes\n          # this verbatim, then steps the check actor. Mechanics only: take the\n          # first package file (by name) under the packages dir into NEXT.md, or\n          # remove NEXT.md when the queue is empty. What NEXT.md's presence/absence\n          # MEANS (another package to build vs. the queue closing out to review) is\n          # decided by this state's own `on` rules at capture time — never here.\n          set +e\n          # Hoist the NEXT path once, at the TOP: Eta's autoTrim eats the newline\n          # after an interpolation tag, so no tag may be the last token on a line —\n          # it would glue the next line's `else`/`fi` onto it and break the script.\n          # Below this point everything is plain bash.\n          nextFile=\"<%~ it.vars.nextFile %>\"\n          # Sweep the advanced flow's spent Q&A steering files: requirementsFile\n          # is consumed by architecting, architectureFile by decompose — both are\n          # gone by the time the package queue starts. No-op if already removed.\n          requirements=\"<%~ it.vars.requirementsFile %>\"\n          architecture=\"<%~ it.vars.architectureFile %>\"\n          rm -f \"$requirements\" \"$architecture\"\n          next=$(ls <%~ it.vars.packagesDir %>/*.md 2>/dev/null | head -n 1)\n          if [ -n \"$next\" ]; then\n            mkdir -p \"$(dirname \"$nextFile\")\"\n            printf '%s' \"$next\" > \"$nextFile\"\n          else\n            rm -f \"$nextFile\"\n          fi\n        on:\n          \"D <%= it.vars.nextFile %>\": $onDrained\n          \"* <%= it.vars.nextFile %>\": adv-building\n          \"C\": $onDrained\n\n      adv-building:\n        actor: agent\n        label: Building\n        model: <%= it.vars.coderModel %>\n        memory: build\n        prompt: |\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. This turn writes no state\n          file: do NOT delete the package file (the `spec-review` gate reads\n          it after you) and never touch `<%= it.vars.nextFile %>` — the\n          `picking` state owns it.\n\n          The package to implement is: <%~ it.read(it.vars.nextFile) %>\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          \"* **\": adv-checking\n\n      closing:\n        actor: check\n        label: Closing out the package\n        script: |\n          #!/usr/bin/env bash\n          # gtd check turn (the package closer) — remove the just-reviewed package\n          # file (its path is in NEXT.md) plus any leftover spec feedback, so\n          # `picking` selects the NEXT package (or falls through to review when the\n          # queue is empty). Reached on approval (spec-review clean) and on the\n          # spec-review retry cap (force-close, deferring the concern to the tail).\n          set +e\n          pkg=$(cat <%~ it.vars.nextFile %> 2>/dev/null)\n          [ -n \"$pkg\" ] && rm -f \"$pkg\"\n          rm -f <%~ it.vars.specFeedbackFile %> <%~ it.vars.nextFile %>\n        on:\n          \"* **\": picking\n\nuse:\n  # Shared health triple: checking/fixing/escalate -> reviewing.\n  - submachine: makeGreen\n    name: build\n    as: { check: checking, fix: fixing, escalate: escalate }\n    with:\n      onGreen: reviewing\n      escalateDescribe: >-\n        Fix the failure yourself — edit the code and/or `.gtd/FEEDBACK.md` —\n        to re-run the check (**checking**).\n      checkLabel: Running checks\n      fixLabel: Fixing the check\n      escalateLabel: Escalating to a human\n  # Advanced package health triple: adv-checking/adv-fixing/adv-escalate -> spec-review.\n  - submachine: makeGreen\n    name: pkg\n    as: { check: adv-checking, fix: adv-fixing, escalate: adv-escalate }\n    with:\n      onGreen: spec-review\n      escalateDescribe: >-\n        Fix the failure yourself — edit the code and/or\n        `.gtd/FEEDBACK.md` — to re-run the check (**adv-checking**).\n      checkLabel: Running checks\n      fixLabel: Fixing the check\n      escalateLabel: Escalating to a human\n\n  # Green-baseline gate: simple flow entry.\n  - submachine: assertGreen\n    name: start\n    as: { check: start-check, blocked: start-blocked }\n    with:\n      onGreen: planning\n      blockedMessage: |\n        The test baseline is red — gtd will not start new work on a broken suite.\n        `<%= it.vars.feedbackFile %>` holds the failing output.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + e.describe + \"\\n\" %>\n        <% } }) %>\n      blockedDescribe: >-\n        Fix the failing tests — edit the code and/or `.gtd/FEEDBACK.md` — to\n        re-run the baseline check (**start-check**). To repair the baseline as\n        its own separate reviewed commit instead, abandon this start and run\n        `gtd fix` from a clean `idle`.\n      checkLabel: Checking the baseline\n      blockedLabel: Baseline is red\n\n  # Green-baseline gate: advanced flow entry.\n  - submachine: assertGreen\n    name: adv-start\n    as: { check: adv-start-check, blocked: adv-start-blocked }\n    with:\n      onGreen: adv-grilling\n      blockedMessage: |\n        The test baseline is red — gtd will not start new work on a broken suite.\n        `<%= it.vars.feedbackFile %>` holds the failing output.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + e.describe + \"\\n\" %>\n        <% } }) %>\n      blockedDescribe: >-\n        Fix the failing tests — edit the code and/or `.gtd/FEEDBACK.md` — to\n        re-run the baseline check (**adv-start-check**). To repair the baseline\n        as its own separate reviewed commit instead, abandon this start and run\n        `gtd fix` from a clean `idle`.\n      checkLabel: Checking the baseline\n      blockedLabel: Baseline is red\n\n  # Green-baseline gate: `gtd review` entry (reviewEntry -> reviewing).\n  - submachine: assertGreen\n    name: review-start\n    as: { check: review-start-check, blocked: review-start-blocked }\n    set:\n      check: { reviewEntry: true }\n    with:\n      onGreen: reviewing\n      blockedMessage: |\n        The test baseline is red — gtd will not start a review on a broken suite.\n        `<%= it.vars.feedbackFile %>` holds the failing output.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + e.describe + \"\\n\" %>\n        <% } }) %>\n      blockedDescribe: >-\n        Fix the failing tests — edit the code and/or `.gtd/FEEDBACK.md` — to\n        re-run the baseline check (**review-start-check**).\n      checkLabel: Checking the baseline\n      blockedLabel: Baseline is red\n\n  # Advanced flow: product Q&A loop (adv-grilling/adv-grilling-answer -> architecting).\n  - submachine: qaLoop\n    name: grill\n    as: { author: adv-grilling, answer: adv-grilling-answer }\n    with:\n      authorFile: <%= it.vars.requirementsFile %>\n      onAdvance: architecting\n      authorPrompt: |\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. The only state file this turn\n        touches is `<%= it.vars.requirementsFile %>`; develop it. Do not\n        create other files to hold notes or output.\n\n        `<%= it.vars.requirementsFile %>` holds the product requirements (or the\n        plan you already wrote plus the human's answers on a return lap). Read it,\n        explore the codebase, and develop it into a concrete, PRODUCT-level plan\n        in this one turn.\n\n        Scope: product and user-facing decisions only. Leave implementation\n        details (file/module structure, data models, tech-stack choices) for the\n        next phase (`<%= it.vars.architectureFile %>`).\n\n        For every open point you cannot settle yourself, add a question under a\n        `## Open Questions` heading near the top: one `### <question>` sub-heading\n        each, followed by a checkbox list of candidate answers — aim for 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. The\n        last `- [ ] _your answer_` line is the human's own-answer slot; write it\n        with the literal `_your answer_` placeholder and leave it for them.\n\n        On a RETURN lap the human has ticked one option per question (or replaced\n        `_your answer_` with their own text). For each answered question: fold the\n        chosen answer into the plan prose, then MOVE the question down into a\n        `## Answered Questions` section as `### <question>` followed by the\n        resolved answer in plain PROSE (drop the checkboxes). Never re-raise a\n        question the human deleted; if the human deleted the whole\n        `## Open Questions` section, treat the plan as accepted and surface no new\n        questions unless something is genuinely still blocking. Omit\n        `## Open Questions` entirely once there are none left.\n\n        Leave `<%= it.vars.requirementsFile %>` uncommitted and finish your turn.\n      answerMessage: |\n        `<%= it.vars.requirementsFile %>` holds the product plan under\n        development. Each question under `## Open Questions` offers a few options\n        plus a `- [ ] _your answer_` slot. Answer EVERY question by ticking\n        exactly one box (`- [x]`); for your own answer, replace `_your answer_`\n        with your text and tick that line. Stepping is refused while any question\n        is unanswered.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + e.describe + \"\\n\" %>\n        <% } }) %>\n      advanceDescribe: >-\n        With no open questions left (the agent surfaced none, or you deleted\n        the section and it finalized the plan), change nothing to accept the\n        product plan and move on to technical architecting (**architecting**).\n      editDescribe: >-\n        Tick exactly one option per open question (replace `_your answer_` for\n        your own) to send the plan back for the agent to fold your answers in\n        (**adv-grilling**). Delete a question to skip it, or delete the whole\n        `## Open Questions` section to accept the plan as-is.\n      authorLabel: Refining the product plan\n      answerLabel: Awaiting your answers\n\n  # Advanced flow: technical Q&A loop (architecting/architecting-answer -> decompose).\n  - submachine: qaLoop\n    name: arch\n    as: { author: architecting, answer: architecting-answer }\n    with:\n      authorFile: <%= it.vars.architectureFile %>\n      onAdvance: decompose\n      authorPrompt: |\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. The only state files this\n        turn touches are `<%= it.vars.architectureFile %>` (write it) and\n        `<%= it.vars.requirementsFile %>` (delete it once its content is\n        folded in). Do not create other files to hold notes or output.\n\n        Read `<%= it.vars.requirementsFile %>` (the converged product plan) and\n        develop `<%= it.vars.architectureFile %>` from it in this one turn:\n        file/module structure, data models, library/tech-stack choices,\n        error-handling strategy — the *how*, building on the *what* already\n        settled. Do not re-open product-level decisions; treat them as settled.\n\n        For every open point you cannot settle yourself, add a question under a\n        `## Open Questions` heading exactly as the grilling phase does: one\n        `### <question>` each, followed by a checkbox list — TWO concrete options\n        plus a final free-text slot, ALL left UNTICKED:\n\n            ### <the question>\n\n            - [ ] <first option>\n            - [ ] <second option>\n            - [ ] _your answer_\n\n        Never tick a box yourself. On a RETURN lap the human has ticked one option\n        per question (or replaced `_your answer_` with their own text): fold each\n        chosen answer into the plan prose, then MOVE the question into a\n        `## Answered Questions` section as `### <question>` + the resolved answer\n        in plain PROSE (drop the checkboxes). Never re-raise a deleted question;\n        treat a deleted `## Open Questions` section as acceptance. Omit\n        `## Open Questions` once there are none left.\n\n        Once `<%= it.vars.architectureFile %>` is written, delete\n        `<%= it.vars.requirementsFile %>` — its content has been folded in and it\n        must not linger. Leave everything uncommitted and finish your turn.\n      answerMessage: |\n        `<%= it.vars.architectureFile %>` holds the technical plan under\n        development. Each question under `## Open Questions` offers a few options\n        plus a `- [ ] _your answer_` slot. Answer EVERY question by ticking\n        exactly one box (`- [x]`); for your own answer, replace `_your answer_`\n        with your text and tick that line. Stepping is refused while any question\n        is unanswered.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + e.describe + \"\\n\" %>\n        <% } }) %>\n      advanceDescribe: >-\n        With no open questions left (the agent surfaced none, or you deleted\n        the section and it finalized the plan), change nothing to accept the\n        technical plan and move on to decomposing the work into packages\n        (**decompose**).\n      editDescribe: >-\n        Tick exactly one option per open question (replace `_your answer_` for\n        your own) to send the plan back for the agent to fold your answers in\n        (**architecting**). Delete a question to skip it, or delete the whole\n        `## Open Questions` section to accept the plan as-is.\n      authorLabel: Refining the technical plan\n      answerLabel: Awaiting your answers\n\n  # Simple flow plan-iteration loop (planning/plan-review -> building).\n  - submachine: planLoop\n    with:\n      onAccept: building\n\n  # Shared review tail (reviewing -> await-review -> ... -> squashing).\n  - submachine: humanReview\n    with:\n      onSignoff: squashing\n\n  # Advanced per-package agentic review (spec-review/spec-fix -> closing).\n  - submachine: specGate\n    with:\n      onApproved: closing\n\n  # Advanced per-package build queue (picking/adv-building/closing -> reviewing).\n  - submachine: packageLoop\n    with:\n      onDrained: reviewing\n\nstates:\n  # ── Shared entry ────────────────────────────────────────────────────────\n  idle:\n    actor: human\n    initial: true\n    label: Idle\n    # Every human-gate `message:` below closes with the same rendered \"What\n    # each change does next\" list, built from `it.edges` (the resting state's\n    # own `on` edges — each edge's `describe:` is the single source of truth).\n    message: |\n      No active gtd cycle.\n\n      To start one, create a steering file describing what you want built:\n\n      - `<%= it.vars.todoFile %>` — a short sketch — starts the SIMPLE flow\n        (plan, build, review).\n      - `<%= it.vars.requirementsFile %>` — the product requirements — starts\n        the ADVANCED flow (product + technical Q&A, package decomposition,\n        parallel build, per-package agentic review).\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"* <%= it.vars.requirementsFile %>\":\n        to: adv-start-check\n        describe: >-\n          Save the product requirements to `.gtd/REQUIREMENTS.md` to start the\n          ADVANCED flow — gtd first checks the test baseline is green, then the\n          agent develops them through product then technical Q&A, decomposes the\n          work into packages, and builds each in parallel (**adv-start-check**).\n      \"* **\":\n        to: start-check\n        describe: >-\n          Save a short sketch to `.gtd/TODO.md` (or any other change) to start\n          the SIMPLE flow — gtd first checks the test baseline is green, then the\n          agent reads it, explores the codebase, and develops it into a concrete\n          implementation plan (**start-check**).\n\n  # ── Simple flow: monolithic build (plan loop is the `planLoop` sub-machine) ─\n  building:\n    actor: agent\n    label: Building\n    file: <%= it.vars.todoFile %>\n    model: <%= it.vars.coderModel %>\n    memory: build\n    prompt: |\n      You are an autonomous coding agent. This workflow steers itself through\n      its own state files — treat them as its private scratchpad, never as\n      project code or documentation. The only state file this turn touches is\n      `<%= it.vars.todoFile %>`; delete it once its work is complete. Do not\n      create other files to hold notes or output.\n\n      The plan to implement is: <%~ it.read(it.vars.todoFile) %>\n\n      Read that plan and implement it in full. Use TDD discipline: one test,\n      then the implementation that passes it, then the next — never write all\n      the tests first.\n\n      Delete `<%= it.vars.todoFile %>` once the work it describes is complete\n      and verified. Leave everything else uncommitted and finish your turn.\n    on:\n      \"* **\": checking\n\n  # ── Advanced flow: decomposition (Q&A loops are the `qaLoop` sub-machine) ───\n  decompose:\n    actor: agent\n    label: Decomposing into packages\n    model: <%= it.vars.coderModel %>\n    memory: build\n    prompt: |\n      You are an autonomous coding agent. This workflow steers itself through\n      its own state files — treat them as its private scratchpad, never as\n      project code or documentation. The only state files this turn touches\n      are the package files it writes under `<%= it.vars.packagesDir %>/` and\n      `<%= it.vars.architectureFile %>`, which it deletes. Do not create other\n      files to hold notes or output.\n\n      Read `<%= it.vars.architectureFile %>` (the converged technical plan) and\n      decompose it into an ordered set of WORK PACKAGES, one file each under\n      `<%= it.vars.packagesDir %>/` (e.g. `<%= it.vars.packagesDir %>/01-name.md`,\n      `<%= it.vars.packagesDir %>/02-name.md`, ...). Order the packages so the\n      test suite can pass again after each one lands.\n\n      Each package file describes a set of INDEPENDENT tasks that can be\n      implemented concurrently without ordering constraints between them — a\n      single build turn will fan them out to parallel subagents. Give each task\n      a clear description, acceptance criteria as `- [ ]` checkboxes, and the\n      relevant paths. Also state the package's overall requirement so it can be\n      reviewed against its spec. Do NOT put ordering-dependent tasks in the same\n      package — split them across ordered packages instead.\n\n      No package file may reference any other `.gtd/` file. Once the package\n      files are written, delete `<%= it.vars.architectureFile %>`. Leave\n      everything uncommitted and finish your turn.\n    on:\n      \"* <%= it.vars.packagesDir %>/**\": picking\n\n  # ── Green-baseline gate: `gtd fix` entry ──────────────────────────────────\n  # `gtd fix` enters HERE (fixEntry): run the suite, then a red run drops\n  # straight into the shared `fixing` loop (-> checking -> review + squash\n  # tail); a green run is a no-op back to `idle` (nothing to fix).\n  fix-check:\n    actor: check\n    fixEntry: true\n    label: Checking the baseline\n    script: *suiteCheck\n    on:\n      \"A <%= it.vars.feedbackFile %>\": fixing\n      \"M <%= it.vars.feedbackFile %>\": fixing\n      \"D <%= it.vars.feedbackFile %>\": idle\n      \"C\": idle\n\n  # ── Shared tail: squash finale (review loop is the `humanReview` sub-machine) ─\n  squashing:\n    actor: agent\n    label: Squashing\n    file: <%= it.vars.commitMsgFile %>\n    model: <%= it.vars.coderModel %>\n    memory: build\n    prompt: |\n      You are an autonomous coding agent. The cycle is approved and done. This\n      workflow steers itself through its own state files — treat them as its\n      private scratchpad, never as project code or documentation. The only\n      state file this turn touches is `<%= it.vars.commitMsgFile %>`; write\n      it. Do not create other files to hold notes or output.\n\n      Leave `<%= it.vars.commitMsgFile %>` uncommitted and finish your turn —\n      entering this file squashes everything this process retains into one\n      commit using its content as the message. The diff below is exactly what\n      that commit will contain: `it.retainedDiff`, the changes THIS process\n      made (its trace/retry boundary onward). For a normal build cycle that is\n      the whole feature; for a `gtd review` process it is only the fixes made\n      during the review — NOT the changeset that was under review.\n      <% if (it.retainedDiff.trim()) { %>\n\n      Write `<%= it.vars.commitMsgFile %>` with ONE conventional-commits message\n      for the changes below (subject line `type(scope): subject`, imperative\n      mood, <= 72 characters; a body explaining the why, trade-offs, and key\n      decisions). Plain text, no markdown wrapper.\n\n      ## Retained diff\n\n      ```diff\n      <%~ it.retainedDiff %>\n      ```\n      <% } else { %>\n\n      This process retained NO changes (a clean review sign-off with no fixes).\n      Write `<%= it.vars.commitMsgFile %>` with exactly this one line and\n      nothing else:\n\n      chore: human review\n      <% } %>\n    on:\n      \"A <%= it.vars.commitMsgFile %>\": done\n      \"M <%= it.vars.commitMsgFile %>\": done\n\n  done:\n    commit: |\n      <%~ it.read(it.vars.commitMsgFile) %>\n\n      Token cost: <%= it.processCost %>\n      <% it.processCostByModel.forEach(function(m){ %>\n      - <%= m.model %>: <%= m.cost %>\n      <% }) %>\n";
+var unified_default = "# The unified gtd workflow template — gtd's BUILT-IN DEFAULT workflow. When no\n# `workflow:` key is configured anywhere in the cwd→home config chain,\n# src/Config.ts runs this template directly, so a state command works with no\n# configuration at all. `gtd init` seeds only the settings a project tunes\n# (vars.testCommand + a modes: formatting suggestion), never the workflow\n# itself. See STATES.md §10 for the full walkthrough.\n#\n# Compiled through the exact same `compileWorkflowConfig` a user's `.gtdrc`\n# `workflow:` key goes through — no privileged code path\n# (src/workflows/templates.ts does the compiling). Every content string below\n# is INLINE (no `./`-relative file references): the bundled template ships\n# inside a single-file build (`dist/gtd.bundle.mjs`), so its content must\n# already be resolved at BUILD time. `renderInitConfig` (src/workflows/\n# templates.ts) can MATERIALIZE this inline source into a `.gtdrc.json`\n# `workflow:` value — the way to eject/customize the machine, and the hermetic\n# test fixture — but `gtd init` itself no longer writes the workflow.\n#\n# ── Authored with SUB-MACHINES (Option C) ──────────────────────────────────\n#\n# This template is written with `submachines:`/`use:` (see src/Submachines.ts).\n# Expansion is a compile-time raw → raw pre-pass with NO runtime footprint: the\n# pure engine only ever sees the flat concrete states, and each invocation's\n# `as:` rename map spells out the concrete state name every expanded state gets,\n# so the compiled `WorkflowDefinition` is exactly what a hand-written flat\n# workflow would produce. The sub-machines split into DEDUP (a gate/loop\n# authored once, invoked several times) and ENCAPSULATION (a single-instance\n# cluster grouped for reading):\n#\n#   * makeGreen (dedup ×2)    — the check/fix/escalate health triple shared by\n#                               the simple build tail and the advanced package\n#                               loop (identical script/prompt/message).\n#   * assertGreen (dedup ×3)  — the green-baseline gate (check + human blocked)\n#                               guarding the simple, advanced and review entries.\n#   * qaLoop (dedup ×2)       — the checkbox Q&A author/answer loop shared by the\n#                               product (product-qa) and technical (technical-qa)\n#                               phases of the advanced flow.\n#   * planLoop (encap)        — the simple flow's plan-iteration loop.\n#   * humanReview (encap)     — the shared review tail (reviewing → await-review →\n#                               review-deciding → feedback collect/build).\n#   * specGate (encap)        — the advanced flow's per-package agentic review.\n#   * packageLoop (encap)     — the advanced flow's per-package build queue.\n#\n# ── Four entry points behind a green-baseline gate, one shared tail ─────────\n#\n# EVERY entry first runs the test suite and only proceeds when it is GREEN — you\n# never start new work (or a review) on top of a red baseline. A red run halts\n# at a human `*-blocked` gate (fix the failures and re-run, exactly like\n# the `escalate` states), or is what `gtd fix` exists to repair.\n#\n# The initial `idle` state FORKS on which steering file the human creates,\n# routing into that flow's OWN start gate:\n#\n#   * the configured requirementsFile (default .gtd/REQUIREMENTS.md) ->\n#     `spec-precheck` -> the ADVANCED flow (product + technical Q&A, package\n#     decomposition, per-package parallel build + agentic spec-review).\n#   * anything else (e.g. the configured todoFile, default .gtd/TODO.md) ->\n#     `plan-precheck` -> the SIMPLE flow (one grilling Q&A loop, a monolithic\n#     build, no decomposition, no agentic review).\n#\n# A third entry, `gtd review <commitish>`, jumps to `review-precheck`\n# (reviewEntry) and, once green, to `reviewing` to review a foreign branch\n# through the same shared tail. A fourth, `gtd fix`, jumps to `fix-precheck`\n# (fixEntry): a red suite drops straight into the shared `fixing` loop and out\n# through the review + squash tail; a green suite is a no-op back to `idle`.\n#\n# All three converge at `reviewing` -> `await-review`. Ticking a REVIEW.md box\n# means only \"I reviewed this hunk\"; a COMMENT (not an unticked box) is what asks\n# for changes. Every human step at `await-review` goes to `review-deciding`,\n# which inspects the step and routes:\n#   * no comment (every box ticked, no REVIEW.md note, no code edit) -> the diff\n#     is a bare REVIEW.md deletion -> squashing -> done (the ONLY path to the\n#     finale — the whole cycle collapses into one commit).\n#   * any comment — a note in REVIEW.md OR a hand-edit to code — ->\n#     review-deciding writes REVIEW_FEEDBACK.md -> feedback-building implements\n#     it (completing any code the human hand-edited, never reverting their\n#     lines) -> checking -> reviewing regenerates an INCREMENTAL REVIEW.md\n#     (review-deciding carries `reviewBase: true`, so each feedback round's\n#     review + checkout window covers only `last-review..HEAD`, i.e. the agent's\n#     follow-through, not the human's own edit) -> await-review, looping until\n#     sign-off.\n# Two dead ends never commit: the sign-off gate (src/program.ts) REFUSES a step\n# that leaves a box unticked with no comment (finish reviewing first) and a\n# deleted REVIEW.md (restore it and tick the boxes).\n#\n# The shared health segment (`checking`/`fixing`/`escalate`) serves the simple\n# build and the feedback loop — its green edge targets\n# `reviewing`. The advanced per-package loop keeps its OWN health triple\n# (`package-checking`/`package-fixing`/`package-escalate`) because its green edge targets\n# the per-package `spec-review` gate instead.\n#\n# Every `on` pattern's path below is written as the matching var's Eta\n# template (e.g. `\"A <%= it.vars.feedbackFile %>\"`), not a literal `.gtd/...`\n# path — repointing a var reroutes the machine along with every template that\n# reads/writes it (see docs/configuration.md).\n\nvars:\n  testCommand: npm test\n  # Where gtd keeps its own scratch/bookkeeping (the check scripts' temp output\n  # file, review-deciding's state-file exclusion). Independent of the per-file\n  # vars below — relocating a file wholesale means setting both.\n  stateDir: .gtd\n  todoFile: .gtd/TODO.md\n  requirementsFile: .gtd/REQUIREMENTS.md\n  architectureFile: .gtd/ARCHITECTURE.md\n  packagesDir: .gtd/packages\n  nextFile: .gtd/NEXT.md\n  reviewFile: .gtd/REVIEW.md\n  reviewRawFile: .gtd/REVIEW_RAW.md\n  reviewFeedbackFile: .gtd/REVIEW_FEEDBACK.md\n  feedbackFile: .gtd/FEEDBACK.md\n  specFeedbackFile: .gtd/SPEC_FEEDBACK.md\n  commitMsgFile: .gtd/COMMIT_MSG.md\n  # The two opaque model tiers every agent state draws from — repoint them here\n  # (or via a top-level `.gtdrc` `vars:` key / a `GTD_PLANNERMODEL` env var)\n  # to change every state on that tier at once. `plannerModel` (default \"smart\")\n  # is the heavier tier for the one-shot planning/technical-qa/review turns;\n  # `coderModel` (default \"base\") is the tier for the build/fix turns.\n  plannerModel: smart\n  coderModel: base\n\nsubmachines:\n  # ── DEDUP: the check/fix/escalate health triple ───────────────────────────\n  # Runs the suite; a red run records the configured feedbackFile, a green run\n  # cleans it up.\n  # The `on` rules turn that into \"fix\" vs \"$onGreen\". The fix turn retries up to\n  # 3× before escalating to a human. Invoked for the shared build tail\n  # (checking/fixing/escalate -> reviewing) and the advanced package loop\n  # (package-checking/package-fixing/package-escalate -> spec-review).\n  makeGreen:\n    params: [onGreen, escalateDescribe, checkLabel, fixLabel, escalateLabel]\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        # NOT the shared `&suiteCheck` anchor (that lives on `assertGreen`,\n        # aliased by it and by `fix-precheck`): this script also sweeps spent\n        # steering files (`todoFile`, `reviewRawFile`, `reviewFeedbackFile`) —\n        # a mechanic the entry/fix gates must NOT run, since they execute\n        # before planning, while a fresh sketch legitimately still exists.\n        script: |\n          #!/usr/bin/env bash\n          # gtd check turn — run the suite; a red run records .gtd/FEEDBACK.md, a\n          # green run cleans it up. The `on` rules decide what that means.\n          set +e\n          mkdir -p \"<%~ it.vars.stateDir %>\"\n          # Hoist every path once, at the TOP: Eta's autoTrim eats the newline\n          # after an interpolation tag, so no tag may be the last token on a\n          # line — it would glue the next line's `else`/`fi` onto it and break\n          # the script. Below this point everything is plain bash.\n          feedback=\"<%~ it.vars.feedbackFile %>\"\n          mkdir -p \"$(dirname \"$feedback\")\"\n          # Sweep steering files spent by the states that led here: the plan\n          # (building), the raw review capture (feedback-collecting), and the\n          # feedback instructions (feedback-building) — each `rm -f` is a\n          # no-op when the file is already gone or never existed on this path.\n          todo=\"<%~ it.vars.todoFile %>\"\n          reviewRaw=\"<%~ it.vars.reviewRawFile %>\"\n          reviewFeedback=\"<%~ it.vars.reviewFeedbackFile %>\"\n          rm -f \"$todo\" \"$reviewRaw\" \"$reviewFeedback\"\n          <%~ it.vars.testCommand %> > <%~ it.vars.stateDir %>/.check-output 2>&1\n          code=$?\n          if [ \"$code\" -ne 0 ]; then\n            if [ -s <%~ it.vars.stateDir %>/.check-output ]; then\n              mv <%~ it.vars.stateDir %>/.check-output \"$feedback\"\n            else\n              rm -f <%~ it.vars.stateDir %>/.check-output\n              printf 'the test command failed with exit code %s and produced no output.' \"$code\" > \"$feedback\"\n            fi\n            # A repeat identical failure would otherwise leave FEEDBACK.md\n            # byte-identical to its committed copy — no diff, so the check would\n            # look GREEN. Stamp each red run with the current HEAD (which always\n            # advances between checks) so a still-red re-run always re-registers\n            # as an M/A edit and takes the red edge.\n            printf '\\n<!-- gtd check %s -->\\n' \"$(git rev-parse --short HEAD 2>/dev/null || echo pending)\" >> \"$feedback\"\n          else\n            rm -f <%~ it.vars.stateDir %>/.check-output\n            rm -f \"$feedback\"\n          fi\n        on:\n          \"A <%= it.vars.feedbackFile %>\": fix\n          \"M <%= it.vars.feedbackFile %>\": fix\n          \"* **\": $onGreen\n          \"C\": $onGreen\n      fix:\n        actor: agent\n        label: $fixLabel\n        file: <%= it.vars.feedbackFile %>\n        model: <%= it.vars.coderModel %>\n        memory: fix\n        retry:\n          max: 3\n          otherwise: escalate\n        prompt: |\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. The only state file this\n          turn touches is `<%= it.vars.feedbackFile %>`; 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 `<%= it.vars.feedbackFile %>` (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          `<%= it.vars.feedbackFile %>` instead of \"fixing\" a non-issue.\n\n          Leave everything uncommitted and finish your turn — do not commit.\n        on:\n          \"* **\": check\n      escalate:\n        actor: human\n        label: $escalateLabel\n        file: <%= it.vars.feedbackFile %>\n        message: |\n          The agent could not get the check to pass after repeated attempts.\n          `<%= it.vars.feedbackFile %>` holds the last failing output.\n\n          What each change does next (then run `gtd step human`):\n          <% it.edges.forEach(function (e) { if (e.describe) { %>\n          <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n          <% } }) %>\n        on:\n          \"* **\":\n            to: check\n            action: Retry check\n            describe: $escalateDescribe\n\n  # ── DEDUP: the green-baseline gate ─────────────────────────────────────────\n  # Runs the suite before any work starts (its script is the health check's test\n  # wrapper — red -> the configured feedbackFile, green -> remove it); the `on` rules turn\n  # that into \"halt at blocked\" vs \"proceed to $onGreen\". The script and blocked\n  # message/describe differ per entry, so they ride in as `with:` params.\n  assertGreen:\n    params: [onGreen, blockedMessage, blockedDescribe, checkLabel, blockedLabel]\n    states:\n      check:\n        actor: check\n        label: $checkLabel\n        # Anchored here and aliased by `fix-precheck` (`gtd fix` entry): one\n        # suite-check script shared by all four call sites (this submachine's\n        # ×3 uses plus `fix-precheck`) instead of four source copies. These gates\n        # run BEFORE planning, so — unlike `makeGreen.check` — they must NOT\n        # sweep `todoFile`/`requirementsFile`: the human's fresh sketch still\n        # legitimately exists here.\n        script: &suiteCheck |\n          #!/usr/bin/env bash\n          # gtd check turn — run the suite; a red run records .gtd/FEEDBACK.md, a\n          # green run cleans it up. The `on` rules decide what that means.\n          set +e\n          mkdir -p \"<%~ it.vars.stateDir %>\"\n          # Hoist the feedback path once, at the TOP: Eta's autoTrim eats the\n          # newline after an interpolation tag, so no tag may be the last token on\n          # a line — it would glue the next line's `else`/`fi` onto it and break\n          # the script. Below this point everything is plain bash.\n          feedback=\"<%~ it.vars.feedbackFile %>\"\n          mkdir -p \"$(dirname \"$feedback\")\"\n          <%~ it.vars.testCommand %> > <%~ it.vars.stateDir %>/.check-output 2>&1\n          code=$?\n          if [ \"$code\" -ne 0 ]; then\n            if [ -s <%~ it.vars.stateDir %>/.check-output ]; then\n              mv <%~ it.vars.stateDir %>/.check-output \"$feedback\"\n            else\n              rm -f <%~ it.vars.stateDir %>/.check-output\n              printf 'the test command failed with exit code %s and produced no output.' \"$code\" > \"$feedback\"\n            fi\n            # A repeat identical failure would otherwise leave FEEDBACK.md\n            # byte-identical to its committed copy — no diff, so the check would\n            # look GREEN. Stamp each red run with the current HEAD (which always\n            # advances between checks) so a still-red re-run always re-registers\n            # as an M/A edit and takes the red edge.\n            printf '\\n<!-- gtd check %s -->\\n' \"$(git rev-parse --short HEAD 2>/dev/null || echo pending)\" >> \"$feedback\"\n          else\n            rm -f <%~ it.vars.stateDir %>/.check-output\n            rm -f \"$feedback\"\n          fi\n        on:\n          \"A <%= it.vars.feedbackFile %>\": blocked\n          \"M <%= it.vars.feedbackFile %>\": blocked\n          \"D <%= it.vars.feedbackFile %>\": $onGreen\n          \"C\": $onGreen\n      blocked:\n        actor: human\n        label: $blockedLabel\n        file: <%= it.vars.feedbackFile %>\n        message: $blockedMessage\n        on:\n          \"* **\":\n            to: check\n            action: Retry check\n            describe: $blockedDescribe\n\n  # ── DEDUP: the checkbox Q&A author/answer loop ─────────────────────────────\n  # The agent develops a plan file, surfacing `## Open Questions` as checkbox\n  # lists; the human answers (answerGate refuses an unanswered step) and either\n  # advances or sends it back. Invoked for the product (product-qa) and\n  # technical (technical-qa) phases of the advanced flow.\n  qaLoop:\n    params:\n      [\n        authorFile,\n        authorPrompt,\n        answerMessage,\n        onAdvance,\n        advanceDescribe,\n        editDescribe,\n        authorLabel,\n        answerLabel,\n      ]\n    states:\n      author:\n        actor: agent\n        label: $authorLabel\n        file: $authorFile\n        mode: qa\n        model: <%= it.vars.plannerModel %>\n        memory: plan\n        prompt: $authorPrompt\n        on:\n          \"* **\": answer\n      answer:\n        actor: human\n        label: $answerLabel\n        file: $authorFile\n        mode: qa\n        answerGate: true\n        message: $answerMessage\n        on:\n          \"C\":\n            to: $onAdvance\n            action: Accept answers\n            describe: $advanceDescribe\n          \"* **\":\n            to: author\n            action: Revise answers\n            describe: $editDescribe\n\n  # ── ENCAPSULATION: the simple flow's plan-iteration loop ───────────────────\n  planLoop:\n    params: [onAccept]\n    states:\n      planning:\n        actor: agent\n        label: Refining the plan\n        file: <%= it.vars.todoFile %>\n        mode: prose\n        model: <%= it.vars.plannerModel %>\n        memory: plan\n        prompt: |\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. The only state file this\n          turn touches is `<%= it.vars.todoFile %>`; develop it into the plan.\n          Do not create other files to hold notes or output.\n\n          `<%= it.vars.todoFile %>` holds a short sketch of what to build — or, on a\n          return lap, the plan you already wrote plus the human's edits and comments\n          on it. Read it, explore the codebase, and develop it into a concrete\n          implementation plan: the files to change, the approach, and the steps to\n          take.\n\n          Do NOT ask questions and do NOT add an \"Open Questions\" section — decide\n          every open point yourself and write the plan as a set of concrete\n          decisions. Where a decision is genuinely a judgement call, state the\n          choice you made and, in one line, why. The human iterates on the plan by\n          editing it directly, not by answering questions.\n\n          On a return lap, `<%= it.vars.todoFile %>` carries the human's edits and\n          inline comments on your previous plan. Fold every edit and comment into a\n          revised, self-contained plan and remove the addressed comments — the plan\n          is always the current, clean proposal, never a diff.\n\n          Leave `<%= it.vars.todoFile %>` uncommitted and finish your turn — do\n          not commit, and do not run `gtd step agent` yourself; the harness does\n          that.\n        on:\n          \"* **\": await-plan\n\n      await-plan:\n        actor: human\n        label: Awaiting your review\n        file: <%= it.vars.todoFile %>\n        mode: prose\n        message: |\n          `<%= it.vars.todoFile %>` holds the proposed implementation plan. Read it,\n          then either accept it as-is or edit it — rewrite a step, add a\n          constraint, or drop an inline comment — to send it back for another round.\n\n          What each change does next (then run `gtd step human`):\n          <% it.edges.forEach(function (e) { if (e.describe) { %>\n          <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n          <% } }) %>\n        on:\n          \"C\":\n            to: $onAccept\n            action: Accept plan\n            describe: >-\n              change nothing to move on to implementation (**building**).\n          \"* **\":\n            to: planning\n            action: Revise plan\n            describe: >-\n              rewrite a step, add a constraint, or leave an inline comment to\n              send it back for another round (**planning**).\n\n  # ── ENCAPSULATION: the shared review tail ──────────────────────────────────\n  humanReview:\n    params: [onSignoff]\n    states:\n      reviewing:\n        actor: agent\n        label: Reviewing\n        file: <%= it.vars.reviewFile %>\n        mode: review\n        model: <%= it.vars.plannerModel %>\n        memory: review\n        # `gtd review <commitish>` (a plain non-gtd branch, e.g. a colleague's PR)\n        # does NOT enter here directly — it enters `review-precheck` (reviewEntry)\n        # first, which runs the green-baseline gate and, once green, transitions\n        # here. The `Gtd-Review-Base:` trailer rides on that entry commit (the\n        # process's oldest), so everything below still reuses the same\n        # reviewing/await-review/feedback machinery over <commitish>..HEAD.\n        prompt: |\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. The only state file this\n          turn touches is `<%= it.vars.reviewFile %>`; write it at exactly\n          that path. Do not create other files to hold notes or output.\n\n          Write `<%= it.vars.reviewFile %>` to help a human review the diff below in\n          this EXACT format:\n\n          - First non-blank line: `# Review: <%= it.currentCommit.slice(0, 7) %>`\n          - Somewhere in the document: `<!-- base: <%= it.startCommit %> -->`\n          - At least one `## <Chunk Title>` heading, grouping hunks semantically\n            (same feature/refactor/fix, even across files) — a short explanation of\n            what changed and why, then one `- [ ] ./path/to/file.ts#42 — note` file\n            pointer per hunk (checkboxes are for the human to tick, not you; every\n            path is `./`-relative, with an optional `#line` and an optional\n            ` — note`).\n\n          The diff below is `it.reviewDiff` — on a feedback round it covers ONLY the\n          changes made since the previous review, so you review just what changed,\n          not items already signed off. Leave `<%= it.vars.reviewFile %>`\n          uncommitted and finish your turn.\n          <% if (it.reviewDiff.trim()) { %>\n\n          ## Full diff under review\n\n          ```diff\n          <%~ it.reviewDiff %>\n          ```\n          <% } %>\n        on:\n          \"* **\": await-review\n\n      await-review:\n        actor: human\n        label: Awaiting your review\n        file: <%= it.vars.reviewFile %>\n        mode: review\n        # While the cycle rests here, gtd opens a \"review checkout window\": raw HEAD\n        # is rewound to the review base (the most-recent `review-deciding` commit —\n        # so a feedback round shows only `last-review..HEAD` — or the process start\n        # on the first review) with the working tree untouched, surfacing the diff\n        # as ordinary uncommitted changes. It closes on the next invocation.\n        #\n        # Every human step here routes to `review-deciding`, which decides sign-off\n        # vs. feedback from the step's CONTENT (a comment, not a tick). Ticking a box\n        # only records \"I reviewed this hunk\". Two dead ends can't be told apart by a\n        # file-pattern edge, so the sign-off gate (`enforceReviewSignoffGate` in\n        # src/program.ts) catches them BEFORE the step commits and refuses: an\n        # unfinished review (a box still `- [ ]` with no comment) and a deleted\n        # REVIEW.md.\n        reviewWindow: true\n        message: |\n          `<%= it.vars.reviewFile %>` holds the review record for the cycle — 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 step human`:\n\n          - **Sign off** — tick EVERY box and leave no comment — no note in\n            `<%= it.vars.reviewFile %>`, no code edit — to collapse the cycle into\n            one commit (**squashing**).\n          - **Request changes** — leave a comment: a note on a\n            `<%= it.vars.reviewFile %>` line, or a direct code edit — to send it to a\n            build + re-review round (**review-deciding** → **feedback-building**). A\n            code edit counts as your own fix: the agent completes the follow-through\n            it implies and never reverts your lines.\n\n          Stepping with a box still unticked and no comment is refused (finish\n          reviewing first); so is deleting `<%= it.vars.reviewFile %>`.\n        on:\n          \"* **\": review-deciding\n\n      review-deciding:\n        actor: check\n        label: Reviewing\n        file: <%= it.vars.reviewFile %>\n        mode: review\n        # Anchors the INCREMENTAL review base: its most-recent in-process commit is\n        # the point the previous review round ended, so the next `reviewing` turn\n        # (and the review checkout window) covers only the changes since then. On\n        # the first review there is no such commit, so the base is the cycle start.\n        reviewBase: true\n        script: |\n          #!/usr/bin/env bash\n          # gtd check turn — decide the human's review step from its CONTENT. HEAD is\n          # the human's `await-review -> review-deciding` commit; HEAD^ is the\n          # `reviewing` commit that wrote the agent's original REVIEW.md (the sign-off\n          # gate refuses an incomplete step, so review-deciding is entered exactly\n          # once per round — nothing commits in between). It is FEEDBACK when the\n          # human left a comment: a note in REVIEW.md (any edit beyond a \"[ ]\"->\"[x]\"\n          # tick) OR a hand-edit to any file this round other than `.gtd/` or the\n          # state's own reviewFile (which is var-configurable and may live outside\n          # `.gtd/`, e.g. a root-level REVIEW.md — issue #128). Otherwise it is a\n          # clean sign-off. This turn only CAPTURES the raw material into REVIEW_RAW.md\n          # (the `feedback-collecting` agent then turns it into instructions); it does\n          # NOT interpret it. Either way, remove REVIEW.md; what the resulting diff\n          # MEANS is decided by this state's own `on` rules — the A/M REVIEW_RAW.md\n          # rows are declared BEFORE the D REVIEW.md row so a feedback round (which\n          # also deletes REVIEW.md) is captured as feedback, not mistaken for a\n          # sign-off.\n          set +e\n          # Hoist the paths once, 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 — it\n          # would glue the next line onto it and break the script. Below this point\n          # everything is plain bash.\n          stateDir=\"<%~ it.vars.stateDir %>\"\n          reviewFile=\"<%~ it.vars.reviewFile %>\"\n          reviewRawFile=\"<%~ it.vars.reviewRawFile %>\"\n          mkdir -p \"$(dirname \"$reviewRawFile\")\"\n          # Which files did the human hand-edit this round, besides stateDir and the\n          # reviewFile itself (var-configurable — may live outside stateDir, so it is\n          # excluded by exact path, not just the stateDir prefix)?\n          codeFiles=$(git diff-tree --no-commit-id --name-only -r HEAD \\\n            | grep -v \"^$stateDir/\" | grep -vxF \"$reviewFile\")\n          # A note is any REVIEW.md change beyond a checkbox flip: normalize every\n          # \"[ ]\"/\"[x]\" to a placeholder, then compare the agent's original (HEAD^)\n          # against the human's version (HEAD).\n          notes=\"\"\n          before=$(git show \"HEAD^:$reviewFile\" 2>/dev/null | sed -E 's/\\[[ xX]\\]/[_]/g')\n          after=$(git show \"HEAD:$reviewFile\" 2>/dev/null | sed -E 's/\\[[ xX]\\]/[_]/g')\n          if [ \"$before\" != \"$after\" ]; then notes=1; fi\n          if [ -n \"$codeFiles\" ] || [ -n \"$notes\" ]; then\n            {\n              echo \"Raw review material captured for classification. The human reviewed the diff and left the feedback below; a downstream agent turns it into an instruction list. This file is machine-captured input, not instructions.\"\n              if [ -n \"$notes\" ]; then\n                echo\n                echo \"## Notes the human added to REVIEW.md this round\"\n                echo\n                echo '```diff'\n                git show HEAD --format= -- \"$reviewFile\"\n                echo '```'\n              fi\n              if [ -n \"$codeFiles\" ]; then\n                echo\n                echo \"## Files the human hand-edited this round (already committed)\"\n                echo\n                echo '```diff'\n                git show HEAD --format= -- $codeFiles\n                echo '```'\n              fi\n            } > \"$reviewRawFile\"\n          fi\n          rm -f \"$reviewFile\"\n        on:\n          \"A <%= it.vars.reviewRawFile %>\": feedback-collecting\n          \"M <%= it.vars.reviewRawFile %>\": feedback-collecting\n          \"D <%= it.vars.reviewFile %>\": $onSignoff\n\n      feedback-collecting:\n        actor: agent\n        label: Collecting your feedback\n        file: <%= it.vars.reviewFeedbackFile %>\n        model: <%= it.vars.plannerModel %>\n        memory: review\n        prompt: |\n          You are an autonomous coding agent turning raw review feedback into an\n          explicit instruction list for a builder. This workflow steers itself\n          through its own state files — treat them as its private scratchpad,\n          never as project code or documentation. The only state files this\n          turn touches are `<%= it.vars.reviewRawFile %>` (read it, then\n          delete it) and `<%= it.vars.reviewFeedbackFile %>` (write it) — do\n          NOT change any other file, you classify, you do not build.\n\n          The raw review material is: <%~ it.read(it.vars.reviewRawFile) %>\n\n          Classify every piece of it into `<%= it.vars.reviewFeedbackFile %>` as a\n          flat, numbered instruction list. Each item is `N. ./path/to/file.ts#line —\n          <imperative>`. Read the two RAW sections and apply these rules exactly:\n\n          1. NOTES the human added to REVIEW.md — each note is a MANDATORY change,\n             regardless of whether its checkbox is ticked (ticking means only \"I read\n             this hunk\", never sign-off). Anchor each to the `./path#line` its review\n             item names (or the chunk it sits under). Emit it as a concrete\n             imperative.\n          2. Every COMMENT the human ADDED this round (a `+` line that is a code\n             comment, in the hand-edited files) is a MANDATORY instruction the human\n             is giving the builder — even a plain-prose one, even if its box is\n             ticked. Emit an imperative to satisfy it and note that the comment line\n             itself must be REMOVED once addressed. If a comment turns out to describe\n             behaviour the code already has, the instruction is still \"confirm the\n             code matches and remove the comment line\".\n          3. Every NON-comment code line the human hand-edited is an already-committed\n             INTENT, NOT a do-then-delete item. Emit an instruction that names those\n             files and says: their lines are final — complete ONLY the follow-through\n             they imply (callers, tests, types, docs) and NEVER revert or rewrite\n             them. Do not turn their own edit into a task.\n\n          Split each hand-edited hunk per line: comment `+` lines follow rule 2, the\n          surrounding real code follows rule 3.\n\n          If — and only if — nothing in the raw material is actionable (e.g. the human\n          left only an approving remark), write `<%= it.vars.reviewFeedbackFile %>`\n          containing exactly one line: `NOTHING ACTIONABLE — <one-sentence reason>`.\n          Never invent work to satisfy a non-actionable remark.\n\n          Delete `<%= it.vars.reviewRawFile %>`, leave everything else uncommitted,\n          and finish your turn.\n        on:\n          \"A <%= it.vars.reviewFeedbackFile %>\": feedback-building\n          \"M <%= it.vars.reviewFeedbackFile %>\": feedback-building\n\n      feedback-building:\n        actor: agent\n        label: Addressing your feedback\n        file: <%= it.vars.reviewFeedbackFile %>\n        model: <%= it.vars.coderModel %>\n        memory: build\n        # Refuse a work-free turn: a step whose only pending change is deleting the\n        # instructions file (the original \"captured then discarded\" bug). The edge\n        # gate (`enforceFeedbackProgressGate` in src/program.ts) reads this flag and\n        # exempts a `NOTHING ACTIONABLE` sentinel (a non-actionable review round,\n        # which legitimately makes no code change). The pure engine carries it inert.\n        requireProgress: true\n        prompt: |\n          You are an autonomous coding agent addressing review feedback. This\n          workflow steers itself through its own state files — treat them as\n          its private scratchpad, never as project code or documentation. The\n          only state file this turn touches is\n          `<%= it.vars.reviewFeedbackFile %>`; address it, then delete it. Do\n          not create other files to hold notes or output.\n\n          The instructions to implement are: <%~ it.read(it.vars.reviewFeedbackFile) %>\n\n          This is a flat instruction list, not a diff — execute every item exactly as\n          written, no Q&A, no re-planning, using TDD discipline:\n\n          - An item that says the human's own lines are final: build ON TOP of them to\n            complete only the follow-through it names (callers, tests, types, docs).\n            NEVER revert or rewrite the lines they already committed.\n          - An item derived from a human comment: satisfy it AND delete that comment\n            line from the code (the human's review comments are transient — none of\n            them survive this round).\n\n          If the file's sole content is a `NOTHING ACTIONABLE` line, make no code\n          change; just delete the instructions file.\n\n          Delete `<%= it.vars.reviewFeedbackFile %>` once every item is addressed.\n          Leave everything else uncommitted and finish your turn. Deleting the\n          instructions file WITHOUT making the changes it asks for is refused — the\n          feedback must actually be addressed.\n        on:\n          \"* **\": checking\n\n  # ── ENCAPSULATION: the advanced flow's per-package agentic review ──────────\n  specGate:\n    params: [onApproved]\n    states:\n      spec-review:\n        actor: agent\n        label: Reviewing the package\n        model: <%= it.vars.plannerModel %>\n        memory: review\n        # Bounded per cycle: once entered `max` times, a transition into it is\n        # redirected to `closing` (force-close the package and move on — the\n        # unresolved concern is deferred to the shared human review at the tail,\n        # which sees the whole diff anyway). NOTE the cap is PROCESS-scoped, so it\n        # pools across packages — the same documented limitation the shared\n        # `fixing` cap has (see STATES.md / docs/configuration.md).\n        retry:\n          max: 3\n          otherwise: $onApproved\n        prompt: |\n          You are an autonomous coding agent reviewing a freshly-built work package\n          against its own spec. This workflow steers itself through its own\n          state files — treat them as its private scratchpad, never as project\n          code or documentation. The only state file this turn touches is\n          `<%= it.vars.specFeedbackFile %>`; 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(it.vars.nextFile) %>\n\n          Read that spec, then verify the package's implementation (the diff below)\n          against it: are all its tasks done, acceptance criteria met, and the code\n          sound and consistent with the codebase?\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 `<%= it.vars.specFeedbackFile %>` 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          <% if (it.processDiff.trim()) { %>\n\n          ## Diff under review\n\n          ```diff\n          <%~ it.processDiff %>\n          ```\n          <% } %>\n        on:\n          \"A <%= it.vars.specFeedbackFile %>\": spec-fix\n          \"M <%= it.vars.specFeedbackFile %>\": spec-fix\n          \"D <%= it.vars.specFeedbackFile %>\": $onApproved\n          \"C\": $onApproved\n\n      spec-fix:\n        actor: agent\n        label: Fixing review feedback\n        file: <%= it.vars.specFeedbackFile %>\n        model: <%= it.vars.coderModel %>\n        memory: fix\n        prompt: |\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. The only state file this\n          turn touches is `<%= it.vars.specFeedbackFile %>`; address it, then\n          delete it. Do not create other files to hold notes or output.\n\n          Read `<%= it.vars.specFeedbackFile %>` (the reviewer's concerns about the\n          current package) and the package spec (`<%= it.read(it.vars.nextFile) %>`),\n          then fix the code to resolve every concern. Keep the change focused.\n\n          Delete `<%= it.vars.specFeedbackFile %>` once every concern is addressed.\n          Leave everything else uncommitted and finish your turn.\n        on:\n          \"* **\": package-checking\n\n  # ── ENCAPSULATION: the advanced flow's per-package build queue ─────────────\n  packageLoop:\n    params: [onDrained]\n    states:\n      picking:\n        actor: check\n        label: Picking the next package\n        script: |\n          #!/usr/bin/env bash\n          # gtd check turn (the package queue arbiter) — the loop driver executes\n          # this verbatim, then steps the check actor. Mechanics only: take the\n          # first package file (by name) under the packages dir into NEXT.md, or\n          # remove NEXT.md when the queue is empty. What NEXT.md's presence/absence\n          # MEANS (another package to build vs. the queue closing out to review) is\n          # decided by this state's own `on` rules at capture time — never here.\n          set +e\n          # Hoist the NEXT path once, at the TOP: Eta's autoTrim eats the newline\n          # after an interpolation tag, so no tag may be the last token on a line —\n          # it would glue the next line's `else`/`fi` onto it and break the script.\n          # Below this point everything is plain bash.\n          nextFile=\"<%~ it.vars.nextFile %>\"\n          # Sweep the advanced flow's spent Q&A steering files: requirementsFile\n          # is consumed by technical-qa, architectureFile by decompose — both are\n          # gone by the time the package queue starts. No-op if already removed.\n          requirements=\"<%~ it.vars.requirementsFile %>\"\n          architecture=\"<%~ it.vars.architectureFile %>\"\n          rm -f \"$requirements\" \"$architecture\"\n          next=$(ls <%~ it.vars.packagesDir %>/*.md 2>/dev/null | head -n 1)\n          if [ -n \"$next\" ]; then\n            mkdir -p \"$(dirname \"$nextFile\")\"\n            printf '%s' \"$next\" > \"$nextFile\"\n          else\n            rm -f \"$nextFile\"\n          fi\n        on:\n          \"D <%= it.vars.nextFile %>\": $onDrained\n          \"* <%= it.vars.nextFile %>\": package-building\n          \"C\": $onDrained\n\n      package-building:\n        actor: agent\n        label: Building\n        model: <%= it.vars.coderModel %>\n        memory: build\n        prompt: |\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. This turn writes no state\n          file: do NOT delete the package file (the `spec-review` gate reads\n          it after you) and never touch `<%= it.vars.nextFile %>` — the\n          `picking` state owns it.\n\n          The package to implement is: <%~ it.read(it.vars.nextFile) %>\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          \"* **\": package-checking\n\n      closing:\n        actor: check\n        label: Closing out the package\n        script: |\n          #!/usr/bin/env bash\n          # gtd check turn (the package closer) — remove the just-reviewed package\n          # file (its path is in NEXT.md) plus any leftover spec feedback, so\n          # `picking` selects the NEXT package (or falls through to review when the\n          # queue is empty). Reached on approval (spec-review clean) and on the\n          # spec-review retry cap (force-close, deferring the concern to the tail).\n          set +e\n          pkg=$(cat <%~ it.vars.nextFile %> 2>/dev/null)\n          [ -n \"$pkg\" ] && rm -f \"$pkg\"\n          rm -f <%~ it.vars.specFeedbackFile %> <%~ it.vars.nextFile %>\n        on:\n          \"* **\": picking\n\nuse:\n  # Shared health triple: checking/fixing/escalate -> reviewing.\n  - submachine: makeGreen\n    name: build\n    as: { check: checking, fix: fixing, escalate: escalate }\n    with:\n      onGreen: reviewing\n      escalateDescribe: >-\n        edit the code and/or `.gtd/FEEDBACK.md` yourself (**checking**).\n      checkLabel: Running checks\n      fixLabel: Fixing the check\n      escalateLabel: Escalating to a human\n  # Advanced package health triple: package-checking/package-fixing/package-escalate -> spec-review.\n  - submachine: makeGreen\n    name: package\n    as: { check: package-checking, fix: package-fixing, escalate: package-escalate }\n    with:\n      onGreen: spec-review\n      escalateDescribe: >-\n        edit the code and/or `.gtd/FEEDBACK.md` yourself (**package-checking**).\n      checkLabel: Running checks\n      fixLabel: Fixing the check\n      escalateLabel: Escalating to a human\n\n  # Green-baseline gate: simple flow entry.\n  - submachine: assertGreen\n    name: plan\n    as: { check: plan-precheck, blocked: plan-blocked }\n    with:\n      onGreen: planning\n      blockedMessage: |\n        The test baseline is red — gtd will not start new work on a broken suite.\n        `<%= it.vars.feedbackFile %>` holds the failing output.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n        <% } }) %>\n      blockedDescribe: >-\n        edit the code and/or `.gtd/FEEDBACK.md` to fix the failing tests\n        (**plan-precheck**). To repair the baseline as its own separate\n        reviewed commit instead, abandon this start and run `gtd fix` from a\n        clean `idle`.\n      checkLabel: Checking the baseline\n      blockedLabel: Baseline is red\n\n  # Green-baseline gate: advanced flow entry.\n  - submachine: assertGreen\n    name: spec\n    as: { check: spec-precheck, blocked: spec-blocked }\n    with:\n      onGreen: product-qa\n      blockedMessage: |\n        The test baseline is red — gtd will not start new work on a broken suite.\n        `<%= it.vars.feedbackFile %>` holds the failing output.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n        <% } }) %>\n      blockedDescribe: >-\n        edit the code and/or `.gtd/FEEDBACK.md` to fix the failing tests\n        (**spec-precheck**). To repair the baseline as its own separate\n        reviewed commit instead, abandon this start and run `gtd fix` from a\n        clean `idle`.\n      checkLabel: Checking the baseline\n      blockedLabel: Baseline is red\n\n  # Green-baseline gate: `gtd review` entry (reviewEntry -> reviewing).\n  - submachine: assertGreen\n    name: review\n    as: { check: review-precheck, blocked: review-blocked }\n    set:\n      check: { reviewEntry: true }\n    with:\n      onGreen: reviewing\n      blockedMessage: |\n        The test baseline is red — gtd will not start a review on a broken suite.\n        `<%= it.vars.feedbackFile %>` holds the failing output.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + (e.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-precheck**).\n      checkLabel: Checking the baseline\n      blockedLabel: Baseline is red\n\n  # Advanced flow: product Q&A loop (product-qa/product-answer -> technical-qa).\n  - submachine: qaLoop\n    name: product\n    as: { author: product-qa, answer: product-answer }\n    with:\n      authorFile: <%= it.vars.requirementsFile %>\n      onAdvance: technical-qa\n      authorPrompt: |\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. The only state file this turn\n        touches is `<%= it.vars.requirementsFile %>`; develop it. Do not\n        create other files to hold notes or output.\n\n        `<%= it.vars.requirementsFile %>` holds the product requirements (or the\n        plan you already wrote plus the human's answers on a return lap). Read it,\n        explore the codebase, and develop it into a concrete, PRODUCT-level plan\n        in this one turn.\n\n        Scope: product and user-facing decisions only. Leave implementation\n        details (file/module structure, data models, tech-stack choices) for the\n        next phase (`<%= it.vars.architectureFile %>`).\n\n        For every open point you cannot settle yourself, add a question under a\n        `## Open Questions` heading near the top: one `### <question>` sub-heading\n        each, followed by a checkbox list of candidate answers — aim for 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. The\n        last `- [ ] _your answer_` line is the human's own-answer slot; write it\n        with the literal `_your answer_` placeholder and leave it for them.\n\n        On a RETURN lap the human has ticked one option per question (or replaced\n        `_your answer_` with their own text). For each answered question: fold the\n        chosen answer into the plan prose, then MOVE the question down into a\n        `## Answered Questions` section as `### <question>` followed by the\n        resolved answer in plain PROSE (drop the checkboxes). Never re-raise a\n        question the human deleted; if the human deleted the whole\n        `## Open Questions` section, treat the plan as accepted and surface no new\n        questions unless something is genuinely still blocking. Omit\n        `## Open Questions` entirely once there are none left.\n\n        Leave `<%= it.vars.requirementsFile %>` uncommitted and finish your turn.\n      answerMessage: |\n        `<%= it.vars.requirementsFile %>` holds the product plan under\n        development. Each question under `## Open Questions` offers a few options\n        plus a `- [ ] _your answer_` slot. Answer EVERY question by ticking\n        exactly one box (`- [x]`); for your own answer, replace `_your answer_`\n        with your text and tick that line. Stepping is refused while any question\n        is unanswered.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n        <% } }) %>\n      advanceDescribe: >-\n        with no open questions left (the agent surfaced none, or you deleted\n        the section and it finalized the plan), change nothing to move on to\n        technical Q&A (**technical-qa**).\n      editDescribe: >-\n        tick exactly one option per open question (replace `_your answer_` for\n        your own) to send the plan back for the agent to fold your answers in\n        (**product-qa**). Delete a question to skip it, or delete the whole\n        `## Open Questions` section to accept the plan as-is.\n      authorLabel: Refining the product plan\n      answerLabel: Awaiting your answers\n\n  # Advanced flow: technical Q&A loop (technical-qa/technical-answer -> decompose).\n  - submachine: qaLoop\n    name: technical\n    as: { author: technical-qa, answer: technical-answer }\n    with:\n      authorFile: <%= it.vars.architectureFile %>\n      onAdvance: decompose\n      authorPrompt: |\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. The only state files this\n        turn touches are `<%= it.vars.architectureFile %>` (write it) and\n        `<%= it.vars.requirementsFile %>` (delete it once its content is\n        folded in). Do not create other files to hold notes or output.\n\n        Read `<%= it.vars.requirementsFile %>` (the converged product plan) and\n        develop `<%= it.vars.architectureFile %>` from it in this one turn:\n        file/module structure, data models, library/tech-stack choices,\n        error-handling strategy — the *how*, building on the *what* already\n        settled. Do not re-open product-level decisions; treat them as settled.\n\n        For every open point you cannot settle yourself, add a question under a\n        `## Open Questions` heading exactly as the grilling phase does: one\n        `### <question>` each, followed by a checkbox list — TWO concrete options\n        plus a final free-text slot, ALL left UNTICKED:\n\n            ### <the question>\n\n            - [ ] <first option>\n            - [ ] <second option>\n            - [ ] _your answer_\n\n        Never tick a box yourself. On a RETURN lap the human has ticked one option\n        per question (or replaced `_your answer_` with their own text): fold each\n        chosen answer into the plan prose, then MOVE the question into a\n        `## Answered Questions` section as `### <question>` + the resolved answer\n        in plain PROSE (drop the checkboxes). Never re-raise a deleted question;\n        treat a deleted `## Open Questions` section as acceptance. Omit\n        `## Open Questions` once there are none left.\n\n        Once `<%= it.vars.architectureFile %>` is written, delete\n        `<%= it.vars.requirementsFile %>` — its content has been folded in and it\n        must not linger. Leave everything uncommitted and finish your turn.\n      answerMessage: |\n        `<%= it.vars.architectureFile %>` holds the technical plan under\n        development. Each question under `## Open Questions` offers a few options\n        plus a `- [ ] _your answer_` slot. Answer EVERY question by ticking\n        exactly one box (`- [x]`); for your own answer, replace `_your answer_`\n        with your text and tick that line. Stepping is refused while any question\n        is unanswered.\n\n        What each change does next (then run `gtd step human`):\n        <% it.edges.forEach(function (e) { if (e.describe) { %>\n        <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n        <% } }) %>\n      advanceDescribe: >-\n        with no open questions left (the agent surfaced none, or you deleted\n        the section and it finalized the plan), change nothing to move on to\n        decomposing the work into packages (**decompose**).\n      editDescribe: >-\n        tick exactly one option per open question (replace `_your answer_` for\n        your own) to send the plan back for the agent to fold your answers in\n        (**technical-qa**). Delete a question to skip it, or delete the whole\n        `## Open Questions` section to accept the plan as-is.\n      authorLabel: Refining the technical plan\n      answerLabel: Awaiting your answers\n\n  # Simple flow plan-iteration loop (planning/await-plan -> building).\n  - submachine: planLoop\n    with:\n      onAccept: building\n\n  # Shared review tail (reviewing -> await-review -> ... -> squashing).\n  - submachine: humanReview\n    with:\n      onSignoff: squashing\n\n  # Advanced per-package agentic review (spec-review/spec-fix -> closing).\n  - submachine: specGate\n    with:\n      onApproved: closing\n\n  # Advanced per-package build queue (picking/package-building/closing -> reviewing).\n  - submachine: packageLoop\n    with:\n      onDrained: reviewing\n\nstates:\n  # ── Shared entry ────────────────────────────────────────────────────────\n  idle:\n    actor: human\n    initial: true\n    label: Idle\n    # Every human-gate `message:` below closes with the same rendered \"What\n    # each change does next\" list, built from `it.edges` (the resting state's\n    # own `on` edges — each edge's `describe:` is the single source of truth).\n    message: |\n      No active gtd cycle.\n\n      To start one, create a steering file describing what you want built:\n\n      - `<%= it.vars.todoFile %>` — a short sketch — starts the SIMPLE flow\n        (plan, build, review).\n      - `<%= it.vars.requirementsFile %>` — the product requirements — starts\n        the ADVANCED flow (product + technical Q&A, package decomposition,\n        parallel build, per-package agentic review).\n\n      What each change does next (then run `gtd step human`):\n      <% it.edges.forEach(function (e) { if (e.describe) { %>\n      <%~ \"- \" + (e.action ? \"**\" + e.action + \"** — \" : \"\") + e.describe + \"\\n\" %>\n      <% } }) %>\n    on:\n      \"* <%= it.vars.requirementsFile %>\":\n        to: spec-precheck\n        action: Start advanced flow\n        describe: >-\n          save the product requirements to `.gtd/REQUIREMENTS.md` — gtd first\n          checks the test baseline is green, then the agent develops them\n          through product then technical Q&A, decomposes the work into\n          packages, and builds each in parallel (**spec-precheck**).\n      \"* **\":\n        to: plan-precheck\n        action: Start simple flow\n        describe: >-\n          save a short sketch to `.gtd/TODO.md` (or any other change) — gtd\n          first checks the test baseline is green, then the agent reads it,\n          explores the codebase, and develops it into a concrete\n          implementation plan (**plan-precheck**).\n\n  # ── Simple flow: monolithic build (plan loop is the `planLoop` sub-machine) ─\n  building:\n    actor: agent\n    label: Building\n    file: <%= it.vars.todoFile %>\n    model: <%= it.vars.coderModel %>\n    memory: build\n    prompt: |\n      You are an autonomous coding agent. This workflow steers itself through\n      its own state files — treat them as its private scratchpad, never as\n      project code or documentation. The only state file this turn touches is\n      `<%= it.vars.todoFile %>`; delete it once its work is complete. Do not\n      create other files to hold notes or output.\n\n      The plan to implement is: <%~ it.read(it.vars.todoFile) %>\n\n      Read that plan and implement it in full. Use TDD discipline: one test,\n      then the implementation that passes it, then the next — never write all\n      the tests first.\n\n      Delete `<%= it.vars.todoFile %>` once the work it describes is complete\n      and verified. Leave everything else uncommitted and finish your turn.\n    on:\n      \"* **\": checking\n\n  # ── Advanced flow: decomposition (Q&A loops are the `qaLoop` sub-machine) ───\n  decompose:\n    actor: agent\n    label: Decomposing into packages\n    model: <%= it.vars.coderModel %>\n    memory: build\n    prompt: |\n      You are an autonomous coding agent. This workflow steers itself through\n      its own state files — treat them as its private scratchpad, never as\n      project code or documentation. The only state files this turn touches\n      are the package files it writes under `<%= it.vars.packagesDir %>/` and\n      `<%= it.vars.architectureFile %>`, which it deletes. Do not create other\n      files to hold notes or output.\n\n      Read `<%= it.vars.architectureFile %>` (the converged technical plan) and\n      decompose it into an ordered set of WORK PACKAGES, one file each under\n      `<%= it.vars.packagesDir %>/` (e.g. `<%= it.vars.packagesDir %>/01-name.md`,\n      `<%= it.vars.packagesDir %>/02-name.md`, ...). Order the packages so the\n      test suite can pass again after each one lands.\n\n      Each package file describes a set of INDEPENDENT tasks that can be\n      implemented concurrently without ordering constraints between them — a\n      single build turn will fan them out to parallel subagents. Give each task\n      a clear description, acceptance criteria as `- [ ]` checkboxes, and the\n      relevant paths. Also state the package's overall requirement so it can be\n      reviewed against its spec. Do NOT put ordering-dependent tasks in the same\n      package — split them across ordered packages instead.\n\n      No package file may reference any other `.gtd/` file. Once the package\n      files are written, delete `<%= it.vars.architectureFile %>`. Leave\n      everything uncommitted and finish your turn.\n    on:\n      \"* <%= it.vars.packagesDir %>/**\": picking\n\n  # ── Green-baseline gate: `gtd fix` entry ──────────────────────────────────\n  # `gtd fix` enters HERE (fixEntry): run the suite, then a red run drops\n  # straight into the shared `fixing` loop (-> checking -> review + squash\n  # tail); a green run is a no-op back to `idle` (nothing to fix).\n  fix-precheck:\n    actor: check\n    fixEntry: true\n    label: Checking the baseline\n    script: *suiteCheck\n    on:\n      \"A <%= it.vars.feedbackFile %>\": fixing\n      \"M <%= it.vars.feedbackFile %>\": fixing\n      \"D <%= it.vars.feedbackFile %>\": idle\n      \"C\": idle\n\n  # ── Shared tail: squash finale (review loop is the `humanReview` sub-machine) ─\n  squashing:\n    actor: agent\n    label: Squashing\n    file: <%= it.vars.commitMsgFile %>\n    model: <%= it.vars.coderModel %>\n    memory: build\n    prompt: |\n      You are an autonomous coding agent. The cycle is approved and done. This\n      workflow steers itself through its own state files — treat them as its\n      private scratchpad, never as project code or documentation. The only\n      state file this turn touches is `<%= it.vars.commitMsgFile %>`; write\n      it. Do not create other files to hold notes or output.\n\n      Leave `<%= it.vars.commitMsgFile %>` uncommitted and finish your turn —\n      entering this file squashes everything this process retains into one\n      commit using its content as the message. The diff below is exactly what\n      that commit will contain: `it.retainedDiff`, the changes THIS process\n      made (its trace/retry boundary onward). For a normal build cycle that is\n      the whole feature; for a `gtd review` process it is only the fixes made\n      during the review — NOT the changeset that was under review.\n      <% if (it.retainedDiff.trim()) { %>\n\n      Write `<%= it.vars.commitMsgFile %>` with ONE conventional-commits message\n      for the changes below (subject line `type(scope): subject`, imperative\n      mood, <= 72 characters; a body explaining the why, trade-offs, and key\n      decisions). Plain text, no markdown wrapper.\n\n      ## Retained diff\n\n      ```diff\n      <%~ it.retainedDiff %>\n      ```\n      <% } else { %>\n\n      This process retained NO changes (a clean review sign-off with no fixes).\n      Write `<%= it.vars.commitMsgFile %>` with exactly this one line and\n      nothing else:\n\n      chore: human review\n      <% } %>\n    on:\n      \"A <%= it.vars.commitMsgFile %>\": done\n      \"M <%= it.vars.commitMsgFile %>\": done\n\n  done:\n    commit: |\n      <%~ it.read(it.vars.commitMsgFile) %>\n\n      Token cost: <%= it.processCost %>\n      <% it.processCostByModel.forEach(function(m){ %>\n      - <%= m.model %>: <%= m.cost %>\n      <% }) %>\n";
 //#endregion
 //#region src/workflows/templates.ts
 /**
 * The `$schema` URL editors resolve for `.gtdrc.json` completion/validation —
 * written as the first key of every `gtd init` config (see `renderInitScaffold`).
+*
+* Served from the PUBLISHED npm tarball via jsDelivr, not from the git
+* repository: `schema.json` is generated by `scripts/generate-schema.ts` at
+* build time (`postbuild`) and shipped by `package.json`'s `files`, so it never
+* needs to be committed. Unversioned on purpose — `gtd init` writes this into a
+* config the project then commits, and a schema that tracks the installed CLI
+* ages better than a pin that silently goes stale. Pin a major
+* (`@pmelab/gtd@8`) in a `.gtdrc` by hand if you want the opposite trade.
 */
-const SCHEMA_URL = "https://raw.githubusercontent.com/pmelab/gtd/main/schema.json";
+const SCHEMA_URL = "https://cdn.jsdelivr.net/npm/@pmelab/gtd/schema.json";
 /**
 * The default `vars:` `gtd init` seeds into the scaffolded `.gtdrc.json` — the
 * one variable a fresh project almost always changes. It mirrors the bundled
@@ -190634,8 +190667,8 @@ const INIT_VARS = { testCommand: "npm test" };
 * Prettier before gtd validates them. Only `format:` is declared — gtd's
 * built-in `qa`/`review` validators still do the validating, and `prose` (a
 * format-only built-in — see `PatternMachine.isKnownBuiltInMode`) still
-* validates nothing (the two halves layer independently — see STATES.md §12 /
-* docs/configuration.md `modes:`). gtd ships no formatter, so this is the one
+* validates nothing (the two halves layer independently — see
+* `src/SteeringMode.ts`). gtd ships no formatter, so this is the one
 * place a default is suggested; a project edits or drops it freely (swap
 * Prettier for dprint, point at a script, delete the key).
 */
@@ -192680,12 +192713,9 @@ const renderModeCommand = (template, context) => eta.renderString(template, cont
 //#endregion
 //#region src/RetainedHistory.ts
 /**
-* Retention of a squashed (or abandoned) process's turn-by-turn history —
-* Task C of `docs/design/pattern-machine-plan.md`'s follow-up note (see
-* `.gtd/packages/01-retention-primitives.md`). Squashing collapses a whole
-* cycle's turn commits into one; this module records the pre-squash tip so a
-* later `gtd restore` (a separate, not-yet-built command-layer piece of work)
-* can bring those turns back.
+* Retention of a squashed (or abandoned) process's turn-by-turn history.
+* Squashing collapses a whole cycle's turn commits into one; this module
+* records the pre-squash tip so `gtd restore` can bring those turns back.
 */
 /**
 * The retained-history ref lives in git's PER-WORKTREE `refs/worktree/gtd/*`
@@ -192750,8 +192780,7 @@ const clearRetainedHistory = (git) => git.deleteRef(HISTORY_REF);
 //#endregion
 //#region src/Edge.ts
 /**
-* The v3 Effect edge (see `docs/design/pattern-machine-plan.md`, "Phase 3:
-* default workflow re-authoring + CLI"). Everything git/filesystem-shaped
+* The v3 Effect edge. Everything git/filesystem-shaped
 * lives here — `program.ts` calls this module and never touches `GitService`
 * or `PatternMachine`'s pure functions directly.
 *
@@ -192918,33 +192947,43 @@ const resolveVars = (workflowVars, rcVars, env) => {
 	}
 	return merged;
 };
-/** Map a state's raw `on` edges to the `{ pattern, target, describe? }` shape templates see as `it.edges`. `undefined` (a commit state, no `on`) yields an empty list. Callers pass already-rendered edges (see `renderOnEdges`) — this never renders anything itself. */
-const toTemplateEdges = (edges) => (edges ?? []).map(([pattern, target, describe]) => describe !== void 0 ? {
+/** Map a state's raw `on` edges to the `{ pattern, target, describe?, action? }` shape templates see as `it.edges`. `action` follows the same presence discipline as `describe` — included only when defined, never set to `undefined` — so an edge with an `action` but no `describe` (the slot-3 placeholder case) yields `{ pattern, target, action }` with no `describe` key at all. `undefined` (a commit state, no `on`) yields an empty list. Callers pass already-rendered edges (see `renderOnEdges`) — this never renders anything itself. */
+const toTemplateEdges = (edges) => (edges ?? []).map(([pattern, target, describe, action]) => ({
 	pattern,
 	target,
-	describe
-} : {
-	pattern,
-	target
-});
+	...describe !== void 0 ? { describe } : {},
+	...action !== void 0 ? { action } : {}
+}));
 /**
 * Render every `on` edge's pattern key as an Eta template over `vars` ONLY
 * (`PatternTemplates.varsOnlyContext`) — a pattern names a path; it never
 * needs diffs/commit hashes, and restricting to `vars` avoids an ordering
 * circularity (the full `TemplateContext`'s `it.edges` is itself derived from
-* these same `on` edges). `target`/`describe` pass through verbatim —
-* `describe` is inert to the engine and is never rendered, unlike the pattern
-* key. Throws whatever Eta throws on a malformed pattern template; the caller
-* turns that into a step refusal / command error, exactly like a content
-* render failure.
+* these same `on` edges). `target`/`describe`/`action` pass through verbatim —
+* both `describe` and `action` are inert to the engine and are never
+* rendered, unlike the pattern key; an edge carrying an `action` but no
+* `describe` round-trips through the same slot-3 `undefined` placeholder
+* `PatternConfig.compileOnEdge` produces. Throws whatever Eta throws on a
+* malformed pattern template; the caller turns that into a step refusal /
+* command error, exactly like a content render failure.
 */
 const renderOnEdges = (edges, vars) => {
 	const ctx = varsOnlyContext(vars);
-	return (edges ?? []).map(([pattern, target, describe]) => describe !== void 0 ? [
-		renderStateTemplate(pattern, ctx),
-		target,
-		describe
-	] : [renderStateTemplate(pattern, ctx), target]);
+	return (edges ?? []).map(([pattern, target, describe, action]) => {
+		const renderedPattern = renderStateTemplate(pattern, ctx);
+		if (action !== void 0) return [
+			renderedPattern,
+			target,
+			describe,
+			action
+		];
+		if (describe !== void 0) return [
+			renderedPattern,
+			target,
+			describe
+		];
+		return [renderedPattern, target];
+	});
 };
 /**
 * A shallow clone of `def` whose `state`'s `on` is replaced by
@@ -193140,8 +193179,7 @@ const executeDecision = (git, run, decision, context, cost, model) => gen(functi
 //#endregion
 //#region src/ReviewWindow.ts
 /**
-* The review checkout window (v3 re-introduction — see
-* `docs/design/pattern-machine-plan.md`'s follow-up note and STATES.md §11).
+* The review checkout window (v3 re-introduction).
 * While a process RESTS at a state declaring `reviewWindow: true` (the
 * bundled default's `await-review`), HEAD and the index are temporarily
 * rewound to the review base with the working tree untouched, so the entire
@@ -204359,11 +204397,28 @@ const splitQuestionBlocks = (lines, start) => {
 /** A markdown task-list checkbox line: `- [ ]` / `- [x]` / `* [X]`, optional leading indent, optional trailing text. */
 const CHECKBOX_RE = /^\s*[-*]\s*\[([ xX])\]\s?(.*)$/;
 /**
+* The body index of the last line belonging to the list item that starts at
+* `index`: the run of following lines that are neither blank nor a checkbox of
+* their own (see the span rule in the module doc). Indentation is NOT
+* required — an unindented lazy wrap is as much part of the item as an
+* indented one.
+*/
+const itemEndIndex = (body, index) => {
+	let end = index;
+	for (let i = index + 1; i < body.length; i += 1) {
+		const line = body[i];
+		if (line.trim().length === 0 || CHECKBOX_RE.test(line)) break;
+		end = i;
+	}
+	return end;
+};
+/**
 * Extracts the checkbox options from a question block's body, in document
 * order. The LAST option is the free-text slot (`freeText: true`); its text is
 * normalized to `""` when it still carries the unfilled `FREE_TEXT_PLACEHOLDER`.
 * `bodyStart` is the absolute 0-based line index of `body[0]` (the line right
-* after the `###` heading), so each option carries its true source line.
+* after the `###` heading), so each option carries its true source line and
+* span (`itemEndIndex`).
 */
 const parseOptions = (body, bodyStart) => {
 	const raw = [];
@@ -204373,7 +204428,8 @@ const parseOptions = (body, bodyStart) => {
 		raw.push({
 			checked: match[1] !== " ",
 			text: match[2].trim(),
-			sourceLine: bodyStart + i
+			sourceLine: bodyStart + i,
+			bodyIndex: i
 		});
 	});
 	const lastIndex = raw.length - 1;
@@ -204384,7 +204440,8 @@ const parseOptions = (body, bodyStart) => {
 			checked: option.checked,
 			text: normalized,
 			freeText,
-			sourceLine: option.sourceLine
+			sourceLine: option.sourceLine,
+			endLine: bodyStart + itemEndIndex(body, option.bodyIndex)
 		};
 	});
 };
@@ -204585,7 +204642,7 @@ const parseReviewDoc = (content) => {
 * 1-based (a bare `./path` lands at the top of the file); the target file is
 * not stat-ed, so a stale pointer still jumps and the editor reports the miss.
 *
-* CONFIG-DRIVEN (see `docs/design/state-file-association.md` §3): the server
+* CONFIG-DRIVEN: the server
 * locates the active gtd config the SAME way the CLI does (`ConfigService`'s
 * cosmiconfig search — no second config code path), from the `initialize`
 * request's `workspaceFolders`/`rootUri`, falling back to the open document's
@@ -204666,7 +204723,7 @@ const questionSymbols = (content) => {
 		const children = question.options.map((option) => ({
 			name: `${option.checked ? "[x]" : "[ ]"} ${option.text || "your answer"}`,
 			kind: import_main.SymbolKind.Boolean,
-			range: lineRange(lines, option.sourceLine),
+			range: spanRange(lines, option.sourceLine, option.endLine),
 			selectionRange: lineRange(lines, option.sourceLine)
 		}));
 		return {
@@ -204848,11 +204905,12 @@ const optionCodeAction = (uri, content, question, option) => {
 	};
 };
 /**
-* Code actions for a `qa`-mode file: on an open question's option line, "pick
-* this option" (radio semantics — check it and uncheck every sibling in the
-* same question, so exactly one stays ticked) or "uncheck this option" when it
-* is already the chosen one. No action off an option line, or on an
-* answered-section (prose) question.
+* Code actions for a `qa`-mode file: anywhere on an open question's option's
+* list item — its `- [ ]` line or any of its wrapped continuation lines (see
+* `QuestionOption.endLine`) — "pick this option" (radio semantics — check it
+* and uncheck every sibling in the same question, so exactly one stays
+* ticked) or "uncheck this option" when it is already the chosen one. No
+* action off an option's span, or on an answered-section (prose) question.
 */
 const questionCodeActions = (uri, content, range) => {
 	const { questions } = parseOpenQuestions(content);
@@ -204860,7 +204918,7 @@ const questionCodeActions = (uri, content, range) => {
 	const actions = [];
 	for (const question of questions) {
 		if (question.status !== "open") continue;
-		const option = question.options.find((o) => o.sourceLine === cursorLine);
+		const option = question.options.find((o) => cursorLine >= o.sourceLine && cursorLine <= o.endLine);
 		if (!option) continue;
 		const action = optionCodeAction(uri, content, question, option);
 		if (action) actions.push(action);
@@ -205123,7 +205181,7 @@ const startLspServer = () => gen(function* () {
 });
 //#endregion
 //#region src/visualize.html
-var visualize_default = "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n    <title>gtd · workflow visualizer</title>\n    <style>\n      :root {\n        --bg: #f4f6fa;\n        --surface: #ffffff;\n        --surface-2: #eef1f7;\n        --surface-3: #e6ebf3;\n        --border: #d9dee8;\n        --border-strong: #c2ccdb;\n        --text: #1a2233;\n        --text-dim: #55607a;\n        --text-faint: #8a93a6;\n        --accent: #2d6cdf;\n        --accent-soft: #e4edfd;\n        --human-bg: #fbeccd;\n        --human-fg: #7a5310;\n        --human-dot: #d99413;\n        --agent-bg: #e5e2fb;\n        --agent-fg: #463693;\n        --agent-dot: #6d5ce0;\n        --check-bg: #d3f0ef;\n        --check-fg: #0c524f;\n        --check-dot: #16a39d;\n        --engine-bg: #fbdfe4;\n        --engine-fg: #8a1f38;\n        --engine-dot: #d84a68;\n        --unknown-bg: #eef1f7;\n        --unknown-fg: #55607a;\n        --unknown-dot: #8a93a6;\n        --shadow: 0 1px 2px rgba(20, 30, 50, 0.06), 0 8px 28px rgba(20, 30, 50, 0.1);\n        --shadow-sm: 0 1px 2px rgba(20, 30, 50, 0.08);\n        --radius: 12px;\n        --mono:\n          ui-monospace, \"SF Mono\", \"SFMono-Regular\", Menlo, Consolas, \"Liberation Mono\", monospace;\n        --sans:\n          ui-sans-serif, system-ui, -apple-system, \"Segoe UI\", Roboto, Helvetica, Arial, sans-serif;\n        --dia-bg: #f7f9fc;\n      }\n      @media (prefers-color-scheme: dark) {\n        :root {\n          --bg: #0e1420;\n          --surface: #161d2b;\n          --surface-2: #1c2434;\n          --surface-3: #232c3e;\n          --border: #2b3547;\n          --border-strong: #3a465c;\n          --text: #e6ebf4;\n          --text-dim: #9aa6bd;\n          --text-faint: #6b7690;\n          --accent: #5b8def;\n          --accent-soft: #1b2740;\n          --human-bg: #3a2e12;\n          --human-fg: #f0c674;\n          --human-dot: #e0a83e;\n          --agent-bg: #26224a;\n          --agent-fg: #b6abf7;\n          --agent-dot: #8b7cf0;\n          --check-bg: #123433;\n          --check-fg: #68dcd4;\n          --check-dot: #2dc4bc;\n          --engine-bg: #3a1b24;\n          --engine-fg: #f2a3b3;\n          --engine-dot: #e05f7c;\n          --unknown-bg: #1c2434;\n          --unknown-fg: #9aa6bd;\n          --unknown-dot: #6b7690;\n          --shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 12px 34px rgba(0, 0, 0, 0.45);\n          --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.35);\n          --dia-bg: #0b1018;\n        }\n      }\n      :root[data-theme=\"light\"] {\n        --bg: #f4f6fa;\n        --surface: #ffffff;\n        --surface-2: #eef1f7;\n        --surface-3: #e6ebf3;\n        --border: #d9dee8;\n        --border-strong: #c2ccdb;\n        --text: #1a2233;\n        --text-dim: #55607a;\n        --text-faint: #8a93a6;\n        --accent: #2d6cdf;\n        --accent-soft: #e4edfd;\n        --human-bg: #fbeccd;\n        --human-fg: #7a5310;\n        --human-dot: #d99413;\n        --agent-bg: #e5e2fb;\n        --agent-fg: #463693;\n        --agent-dot: #6d5ce0;\n        --check-bg: #d3f0ef;\n        --check-fg: #0c524f;\n        --check-dot: #16a39d;\n        --engine-bg: #fbdfe4;\n        --engine-fg: #8a1f38;\n        --engine-dot: #d84a68;\n        --unknown-bg: #eef1f7;\n        --unknown-fg: #55607a;\n        --unknown-dot: #8a93a6;\n        --shadow: 0 1px 2px rgba(20, 30, 50, 0.06), 0 8px 28px rgba(20, 30, 50, 0.1);\n        --shadow-sm: 0 1px 2px rgba(20, 30, 50, 0.08);\n        --dia-bg: #f7f9fc;\n      }\n      :root[data-theme=\"dark\"] {\n        --bg: #0e1420;\n        --surface: #161d2b;\n        --surface-2: #1c2434;\n        --surface-3: #232c3e;\n        --border: #2b3547;\n        --border-strong: #3a465c;\n        --text: #e6ebf4;\n        --text-dim: #9aa6bd;\n        --text-faint: #6b7690;\n        --accent: #5b8def;\n        --accent-soft: #1b2740;\n        --human-bg: #3a2e12;\n        --human-fg: #f0c674;\n        --human-dot: #e0a83e;\n        --agent-bg: #26224a;\n        --agent-fg: #b6abf7;\n        --agent-dot: #8b7cf0;\n        --check-bg: #123433;\n        --check-fg: #68dcd4;\n        --check-dot: #2dc4bc;\n        --engine-bg: #3a1b24;\n        --engine-fg: #f2a3b3;\n        --engine-dot: #e05f7c;\n        --unknown-bg: #1c2434;\n        --unknown-fg: #9aa6bd;\n        --unknown-dot: #6b7690;\n        --shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 12px 34px rgba(0, 0, 0, 0.45);\n        --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.35);\n        --dia-bg: #0b1018;\n      }\n\n      * {\n        box-sizing: border-box;\n      }\n      html,\n      body {\n        max-width: 100%;\n        overflow-x: hidden;\n      }\n      body {\n        margin: 0;\n        background: var(--bg);\n        color: var(--text);\n        font-family: var(--sans);\n        font-size: 15px;\n        line-height: 1.55;\n        -webkit-font-smoothing: antialiased;\n      }\n      ::selection {\n        background: var(--accent);\n        color: #fff;\n      }\n      .wrap {\n        max-width: 1180px;\n        margin: 0 auto;\n        padding: 0 20px;\n      }\n\n      /* header */\n      header.top {\n        position: sticky;\n        top: 0;\n        z-index: 40;\n        background: color-mix(in srgb, var(--bg) 88%, transparent);\n        backdrop-filter: blur(10px);\n        border-bottom: 1px solid var(--border);\n      }\n      .top-inner {\n        display: flex;\n        align-items: center;\n        gap: 18px;\n        padding: 12px 20px;\n        max-width: 1180px;\n        margin: 0 auto;\n        flex-wrap: wrap;\n      }\n      .brand {\n        display: flex;\n        align-items: baseline;\n        gap: 10px;\n        margin-right: auto;\n      }\n      .brand .cmd {\n        font-family: var(--mono);\n        font-weight: 700;\n        font-size: 17px;\n        letter-spacing: -0.02em;\n      }\n      .brand .cmd b {\n        color: var(--accent);\n      }\n      .brand .sub {\n        font-size: 12px;\n        color: var(--text-faint);\n        letter-spacing: 0.04em;\n        text-transform: uppercase;\n      }\n      .summary {\n        font-size: 12.5px;\n        color: var(--text-dim);\n        display: flex;\n        gap: 10px;\n        flex-wrap: wrap;\n        align-items: center;\n      }\n      .summary .s-num {\n        font-family: var(--mono);\n        font-weight: 700;\n        color: var(--text);\n      }\n      .summary .sep {\n        color: var(--border-strong);\n      }\n      .theme-btn {\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text-dim);\n        border-radius: 8px;\n        width: 32px;\n        height: 32px;\n        cursor: pointer;\n        font-size: 14px;\n        display: grid;\n        place-items: center;\n      }\n      .theme-btn:hover {\n        color: var(--text);\n        border-color: var(--border-strong);\n      }\n      .theme-btn:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n\n      /* hero */\n      .hero {\n        padding: 40px 0 4px;\n      }\n      h1 {\n        font-size: clamp(26px, 4vw, 36px);\n        line-height: 1.08;\n        letter-spacing: -0.025em;\n        margin: 0 0 12px;\n        font-weight: 780;\n      }\n      h1 .mono {\n        font-family: var(--mono);\n        font-weight: 700;\n      }\n      .lede {\n        font-size: 16px;\n        color: var(--text-dim);\n        max-width: 70ch;\n        margin: 0;\n      }\n      .lede code {\n        font-family: var(--mono);\n        font-size: 0.88em;\n        background: var(--surface-2);\n        padding: 1px 6px;\n        border-radius: 5px;\n        color: var(--text);\n      }\n\n      /* section headers */\n      .sec-head {\n        display: flex;\n        align-items: baseline;\n        gap: 12px;\n        margin: 46px 0 4px;\n      }\n      .sec-head h2 {\n        font-size: 13px;\n        text-transform: uppercase;\n        letter-spacing: 0.12em;\n        color: var(--text-faint);\n        margin: 0;\n        font-weight: 700;\n      }\n      .sec-head .rule {\n        flex: 1;\n        height: 1px;\n        background: var(--border);\n      }\n\n      /* diagram */\n      .diagram-note {\n        font-size: 13px;\n        color: var(--text-dim);\n        margin: 16px 0 14px;\n        max-width: 78ch;\n      }\n      .diagram-note .mono {\n        font-family: var(--mono);\n      }\n      .dia-card {\n        background: var(--surface);\n        border: 1px solid var(--border);\n        border-radius: var(--radius);\n        box-shadow: var(--shadow-sm);\n        overflow: hidden;\n      }\n      .sm-card summary.h {\n        display: flex;\n        align-items: baseline;\n        justify-content: space-between;\n        cursor: pointer;\n        list-style: none;\n        padding: 14px 18px;\n        transition: background 0.12s ease;\n      }\n      .sm-card summary.h:hover {\n        background: var(--surface-2);\n      }\n      .sm-card[open] summary.h {\n        border-bottom: 1px solid var(--border);\n      }\n      .sm-card summary::-webkit-details-marker {\n        display: none;\n      }\n      .sm-card summary::after {\n        content: \"+\";\n        align-self: center;\n        color: var(--text-dim);\n        font-size: 18px;\n        font-weight: 700;\n        line-height: 1;\n        transform: translateY(-0.08em);\n        transition: color 0.15s ease;\n      }\n      .sm-card summary:hover::after {\n        color: var(--text);\n      }\n      .sm-card[open] summary::after {\n        content: \"\\2212\";\n      }\n      .dia-scroll {\n        position: relative;\n        overflow: hidden;\n        background: var(--dia-bg);\n        height: 460px;\n        cursor: grab;\n        touch-action: none;\n      }\n      .dia-scroll.pz-dragging {\n        cursor: grabbing;\n      }\n      .dia-scroll .mflow {\n        position: absolute;\n        top: 0;\n        left: 0;\n        padding: 18px 16px;\n        transform-origin: 0 0;\n      }\n      .dia-scroll .mflow svg {\n        max-width: none;\n        height: auto;\n        display: block;\n      }\n      .pz-controls {\n        position: absolute;\n        right: 12px;\n        bottom: 12px;\n        display: flex;\n        gap: 6px;\n        z-index: 5;\n      }\n      .pz-btn {\n        width: 30px;\n        height: 30px;\n        border-radius: 8px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text-dim);\n        cursor: pointer;\n        font-size: 15px;\n        font-family: var(--mono);\n        display: grid;\n        place-items: center;\n        box-shadow: var(--shadow-sm);\n        padding: 0;\n      }\n      .pz-btn:hover {\n        color: var(--text);\n        border-color: var(--border-strong);\n      }\n      .pz-btn:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .dia-msg {\n        padding: 22px 18px;\n        font-size: 13.5px;\n        color: var(--text-dim);\n      }\n      .dia-msg code {\n        font-family: var(--mono);\n        font-size: 12px;\n        background: var(--surface-2);\n        padding: 1px 6px;\n        border-radius: 5px;\n      }\n      .dia-src {\n        margin: 10px 0 0;\n        padding: 12px 14px;\n        background: var(--surface-2);\n        border-radius: 9px;\n        font-family: var(--mono);\n        font-size: 11.5px;\n        white-space: pre;\n        overflow-x: auto;\n        color: var(--text-dim);\n        max-height: 260px;\n      }\n      .state-content {\n        max-height: 340px;\n        white-space: pre-wrap;\n        word-break: break-word;\n      }\n\n      /* sub-machines */\n      .sm-grid {\n        display: grid;\n        grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));\n        gap: 14px;\n        margin-top: 18px;\n      }\n      .sm-def {\n        border: 1.5px dashed var(--border-strong);\n        border-radius: var(--radius);\n        background: var(--surface);\n        box-shadow: var(--shadow-sm);\n        overflow: hidden;\n      }\n      .sm-def .h {\n        padding: 13px 16px;\n        border-bottom: 1px solid var(--border);\n        background: var(--surface-2);\n      }\n      .sm-def .h .nm {\n        font-family: var(--mono);\n        font-weight: 700;\n        font-size: 15px;\n      }\n      .sm-def .h .pm {\n        font-family: var(--mono);\n        font-size: 12px;\n        color: var(--text-dim);\n        display: block;\n        margin-top: 3px;\n      }\n      .sm-def .h .pm b {\n        color: var(--accent);\n      }\n      .sm-def .body {\n        padding: 12px 16px 16px;\n        display: flex;\n        flex-wrap: wrap;\n        gap: 6px;\n      }\n      .muted-note {\n        color: var(--text-faint);\n        font-style: italic;\n        margin-top: 16px;\n      }\n      .sm-def .h {\n        display: flex;\n        align-items: baseline;\n        justify-content: space-between;\n        gap: 8px;\n      }\n      .sm-def .h .goto-sm {\n        font: inherit;\n        font-family: var(--mono);\n        font-size: 11px;\n        color: var(--accent);\n        background: none;\n        border: none;\n        cursor: pointer;\n        text-decoration: underline;\n        padding: 0;\n      }\n\n      /* current-state panel */\n      .current-panel {\n        background: var(--surface);\n        border: 1px solid var(--border);\n        border-radius: var(--radius);\n        box-shadow: var(--shadow-sm);\n        padding: 18px 20px 20px;\n        margin: 16px 0 34px;\n      }\n      .cur-head {\n        display: flex;\n        align-items: center;\n        gap: 10px;\n        flex-wrap: wrap;\n        cursor: pointer;\n      }\n      .cur-name {\n        font-family: var(--mono);\n        font-weight: 700;\n        font-size: 18px;\n        letter-spacing: -0.01em;\n      }\n      .cur-none {\n        color: var(--text-faint);\n        font-style: italic;\n      }\n      .edge.cur-matched {\n        border-color: var(--accent);\n        background: var(--accent-soft);\n      }\n      .cur-tag {\n        font-family: var(--mono);\n        font-size: 10.5px;\n        font-weight: 700;\n        color: var(--accent);\n        background: var(--surface);\n        border: 1px solid var(--accent);\n        padding: 1px 7px;\n        border-radius: 999px;\n        margin-left: auto;\n      }\n\n      /* pending-changes readout in the current-state panel */\n      .pending-list {\n        display: flex;\n        flex-direction: column;\n        gap: 3px;\n        font-family: var(--mono);\n        font-size: 12.5px;\n        margin-bottom: 14px;\n      }\n      .pending-list .pc {\n        display: flex;\n        gap: 9px;\n      }\n      .pending-list .st {\n        font-weight: 700;\n        width: 1ch;\n        flex: none;\n      }\n      .pending-list .path {\n        color: var(--text-dim);\n        word-break: break-all;\n      }\n      .pending-clean {\n        color: var(--text-faint);\n        font-style: italic;\n        font-size: 12.5px;\n        margin-bottom: 14px;\n      }\n\n      /* mermaid black-box / ghost node labels (rendered inside the SVG via htmlLabels) */\n      .sm-hint {\n        display: block;\n        margin-top: 2px;\n        font-size: 10.5px;\n        opacity: 0.72;\n        font-weight: 500;\n      }\n\n      /* the current-state highlight ring on a rendered SVG node/group box */\n      g.node.gtd-current {\n        filter: drop-shadow(0 0 6px var(--accent));\n      }\n      g.node.gtd-current > rect,\n      g.node.gtd-current > polygon,\n      g.node.gtd-current > circle,\n      g.node.gtd-current > ellipse,\n      g.node.gtd-current > path.basic {\n        stroke: var(--accent) !important;\n        stroke-width: 3px !important;\n      }\n\n      /* toolbar */\n      .toolbar {\n        display: flex;\n        gap: 12px;\n        align-items: center;\n        margin: 18px 0 22px;\n        flex-wrap: wrap;\n      }\n      .search {\n        flex: 1;\n        min-width: 200px;\n        position: relative;\n      }\n      .search input {\n        width: 100%;\n        font-family: var(--mono);\n        font-size: 14px;\n        padding: 10px 12px 10px 34px;\n        border-radius: 10px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text);\n      }\n      .search input:focus {\n        outline: none;\n        border-color: var(--accent);\n        box-shadow: 0 0 0 3px var(--accent-soft);\n      }\n      .search svg {\n        position: absolute;\n        left: 11px;\n        top: 50%;\n        transform: translateY(-50%);\n        color: var(--text-faint);\n      }\n      .chips {\n        display: flex;\n        gap: 6px;\n        flex-wrap: wrap;\n      }\n      .chip-btn {\n        font: inherit;\n        font-size: 12.5px;\n        padding: 7px 12px;\n        border-radius: 999px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text-dim);\n        cursor: pointer;\n      }\n      .chip-btn:hover {\n        border-color: var(--border-strong);\n        color: var(--text);\n      }\n      .chip-btn.on {\n        background: var(--accent);\n        border-color: var(--accent);\n        color: #fff;\n      }\n      .chip-btn:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .legend {\n        display: flex;\n        gap: 8px;\n        flex-wrap: wrap;\n      }\n      .legend .li {\n        display: inline-flex;\n        align-items: center;\n        gap: 6px;\n        font-size: 12.5px;\n        color: var(--text-dim);\n        cursor: pointer;\n        user-select: none;\n        padding: 5px 9px;\n        border-radius: 999px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n      }\n      .legend .li:hover {\n        border-color: var(--border-strong);\n      }\n      .legend .li.off {\n        opacity: 0.4;\n      }\n      .legend .li:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .legend .li .dot {\n        width: 10px;\n        height: 10px;\n        border-radius: 3px;\n      }\n\n      /* groups + cards */\n      .group {\n        margin-bottom: 30px;\n      }\n      .group-head {\n        display: flex;\n        align-items: baseline;\n        gap: 10px;\n        margin: 0 0 12px;\n      }\n      .group-head h3 {\n        font-family: var(--mono);\n        font-size: 15px;\n        margin: 0;\n        letter-spacing: -0.01em;\n      }\n      .group-head .flow-tag {\n        font-family: var(--mono);\n        font-size: 11px;\n        padding: 2px 8px;\n        border-radius: 6px;\n        background: var(--surface-2);\n        color: var(--text-dim);\n        border: 1px solid var(--border);\n      }\n      .grid {\n        display: grid;\n        grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));\n        gap: 12px;\n      }\n      .card {\n        text-align: left;\n        font: inherit;\n        color: var(--text);\n        cursor: pointer;\n        background: var(--surface);\n        border: 1px solid var(--border);\n        border-left: 4px solid var(--card-accent, var(--border));\n        border-radius: 10px;\n        padding: 13px 15px;\n        box-shadow: var(--shadow-sm);\n        transition:\n          transform 0.12s ease,\n          box-shadow 0.12s ease,\n          border-color 0.12s ease;\n        position: relative;\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .card:hover {\n        transform: translateY(-2px);\n        box-shadow: var(--shadow);\n      }\n      .card:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .card[data-actor=\"human\"] {\n        --card-accent: var(--human-dot);\n      }\n      .card[data-actor=\"agent\"] {\n        --card-accent: var(--agent-dot);\n      }\n      .card[data-actor=\"check\"] {\n        --card-accent: var(--check-dot);\n      }\n      .card[data-actor=\"commit\"] {\n        --card-accent: var(--engine-dot);\n      }\n      .card[data-actor=\"unknown\"] {\n        --card-accent: var(--unknown-dot);\n      }\n      .card .name {\n        font-family: var(--mono);\n        font-weight: 700;\n        font-size: 14.5px;\n        letter-spacing: -0.01em;\n        word-break: break-word;\n      }\n      .card .row {\n        display: flex;\n        align-items: center;\n        gap: 6px;\n        flex-wrap: wrap;\n      }\n      .card .init-tick {\n        position: absolute;\n        top: 11px;\n        right: 12px;\n        font-size: 10px;\n        font-family: var(--mono);\n        color: var(--accent);\n        background: var(--accent-soft);\n        padding: 1px 6px;\n        border-radius: 5px;\n        font-weight: 700;\n      }\n\n      .pill {\n        display: inline-flex;\n        align-items: center;\n        gap: 5px;\n        font-family: var(--mono);\n        font-size: 11px;\n        font-weight: 600;\n        padding: 2px 8px;\n        border-radius: 999px;\n      }\n      .pill.actor-human {\n        background: var(--human-bg);\n        color: var(--human-fg);\n      }\n      .pill.actor-agent {\n        background: var(--agent-bg);\n        color: var(--agent-fg);\n      }\n      .pill.actor-check {\n        background: var(--check-bg);\n        color: var(--check-fg);\n      }\n      .pill.actor-engine {\n        background: var(--engine-bg);\n        color: var(--engine-fg);\n      }\n      .pill.actor-unknown {\n        background: var(--unknown-bg);\n        color: var(--unknown-fg);\n      }\n      .pill .dot {\n        width: 7px;\n        height: 7px;\n        border-radius: 2px;\n      }\n      .pill.actor-human .dot {\n        background: var(--human-dot);\n      }\n      .pill.actor-agent .dot {\n        background: var(--agent-dot);\n      }\n      .pill.actor-check .dot {\n        background: var(--check-dot);\n      }\n      .pill.actor-engine .dot {\n        background: var(--engine-dot);\n      }\n      .pill.actor-unknown .dot {\n        background: var(--unknown-dot);\n      }\n      .kind {\n        font-family: var(--mono);\n        font-size: 11px;\n        padding: 2px 7px;\n        border-radius: 6px;\n        border: 1px solid var(--border-strong);\n        color: var(--text-dim);\n        background: var(--surface-2);\n      }\n      .flag {\n        font-family: var(--mono);\n        font-size: 10.5px;\n        padding: 1px 6px;\n        border-radius: 5px;\n        background: var(--accent-soft);\n        color: var(--accent);\n        font-weight: 600;\n        border: 1px solid color-mix(in srgb, var(--accent) 25%, transparent);\n      }\n\n      /* drawer */\n      .backdrop {\n        position: fixed;\n        inset: 0;\n        background: rgba(10, 16, 28, 0.5);\n        backdrop-filter: blur(2px);\n        opacity: 0;\n        pointer-events: none;\n        transition: opacity 0.22s ease;\n        z-index: 90;\n      }\n      .backdrop.open {\n        opacity: 1;\n        pointer-events: auto;\n      }\n      .drawer {\n        position: fixed;\n        top: 0;\n        right: 0;\n        height: 100%;\n        width: min(560px, 100%);\n        background: var(--surface);\n        border-left: 1px solid var(--border);\n        box-shadow: var(--shadow);\n        transform: translateX(100%);\n        transition: transform 0.26s cubic-bezier(0.22, 0.61, 0.36, 1);\n        z-index: 100;\n        display: flex;\n        flex-direction: column;\n      }\n      .drawer.open {\n        transform: translateX(0);\n      }\n      .drawer-head {\n        padding: 18px 22px 14px;\n        border-bottom: 1px solid var(--border);\n        border-top: 4px solid var(--card-accent, var(--accent));\n      }\n      .drawer-head .top {\n        display: flex;\n        align-items: flex-start;\n        gap: 12px;\n      }\n      .drawer-head h3 {\n        font-family: var(--mono);\n        font-size: 20px;\n        font-weight: 700;\n        margin: 0;\n        letter-spacing: -0.02em;\n        word-break: break-word;\n      }\n      .drawer-head .meta-row {\n        display: flex;\n        gap: 6px;\n        flex-wrap: wrap;\n        margin-top: 10px;\n      }\n      .close-x {\n        margin-left: auto;\n        border: 1px solid var(--border);\n        background: var(--surface-2);\n        color: var(--text-dim);\n        border-radius: 8px;\n        width: 30px;\n        height: 30px;\n        cursor: pointer;\n        flex: none;\n        font-size: 15px;\n      }\n      .close-x:hover {\n        color: var(--text);\n      }\n      .close-x:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .drawer-body {\n        overflow-y: auto;\n        padding: 20px 22px 40px;\n        flex: 1;\n      }\n      .field {\n        margin-bottom: 18px;\n      }\n      .field > .k {\n        font-size: 11px;\n        text-transform: uppercase;\n        letter-spacing: 0.09em;\n        color: var(--text-faint);\n        font-weight: 700;\n        margin-bottom: 7px;\n      }\n      .kv {\n        display: grid;\n        grid-template-columns: 88px 1fr;\n        gap: 4px 14px;\n        font-size: 13.5px;\n      }\n      .kv dt {\n        color: var(--text-faint);\n        font-size: 12px;\n      }\n      .kv dd {\n        margin: 0;\n        font-family: var(--mono);\n        font-size: 12.5px;\n        word-break: break-word;\n      }\n      .none {\n        color: var(--text-faint);\n        font-style: italic;\n        font-family: var(--sans);\n      }\n\n      .edges {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .edge {\n        border: 1px solid var(--border);\n        border-radius: 9px;\n        padding: 10px 12px;\n        background: var(--surface-2);\n      }\n      .edge .er {\n        display: flex;\n        align-items: center;\n        gap: 8px;\n        flex-wrap: wrap;\n      }\n      .edge .pat {\n        font-family: var(--mono);\n        font-size: 12px;\n        font-weight: 700;\n        background: var(--surface);\n        border: 1px solid var(--border-strong);\n        padding: 2px 8px;\n        border-radius: 6px;\n        white-space: nowrap;\n      }\n      .edge .arr {\n        color: var(--text-faint);\n      }\n      .goto {\n        font: inherit;\n        font-family: var(--mono);\n        font-size: 12.5px;\n        font-weight: 700;\n        cursor: pointer;\n        border: 1px solid var(--card-accent, var(--accent));\n        background: transparent;\n        color: var(--card-accent, var(--accent));\n        padding: 2px 9px;\n        border-radius: 6px;\n      }\n      .goto:hover {\n        background: var(--card-accent, var(--accent));\n        color: #fff;\n      }\n      .goto:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .goto[data-actor=\"human\"] {\n        --card-accent: var(--human-dot);\n      }\n      .goto[data-actor=\"agent\"] {\n        --card-accent: var(--agent-dot);\n      }\n      .goto[data-actor=\"check\"] {\n        --card-accent: var(--check-dot);\n      }\n      .goto[data-actor=\"commit\"] {\n        --card-accent: var(--engine-dot);\n      }\n      .goto[data-actor=\"unknown\"] {\n        --card-accent: var(--unknown-dot);\n      }\n      .edge .em {\n        font-size: 12.5px;\n        color: var(--text-dim);\n        margin-top: 6px;\n        line-height: 1.45;\n      }\n      .incoming {\n        display: flex;\n        flex-wrap: wrap;\n        gap: 6px;\n      }\n\n      .flag-list {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .flag-item {\n        display: flex;\n        gap: 9px;\n        font-size: 13px;\n        align-items: baseline;\n      }\n      .flag-item .fn {\n        font-family: var(--mono);\n        font-size: 11.5px;\n        font-weight: 700;\n        color: var(--accent);\n        flex: none;\n        padding: 1px 6px;\n        border-radius: 5px;\n        background: var(--accent-soft);\n      }\n      .flag-item .fd {\n        color: var(--text-dim);\n      }\n\n      /* vars */\n      .vars-grid {\n        display: flex;\n        flex-wrap: wrap;\n        gap: 8px;\n        margin-top: 16px;\n      }\n      .var-chip {\n        font-family: var(--mono);\n        font-size: 12px;\n        padding: 6px 10px;\n        border-radius: 8px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        box-shadow: var(--shadow-sm);\n      }\n      .var-chip b {\n        color: var(--accent);\n      }\n\n      footer {\n        border-top: 1px solid var(--border);\n        margin-top: 56px;\n        padding: 40px 0 72px;\n        color: var(--text-faint);\n        font-size: 13px;\n      }\n      footer code {\n        font-family: var(--mono);\n        background: var(--surface-2);\n        padding: 1px 6px;\n        border-radius: 5px;\n      }\n      footer .foot-lead {\n        margin: 0 0 14px;\n        padding-top: 16px;\n        color: var(--text-dim);\n      }\n      footer .foot-legend {\n        display: flex;\n        align-items: center;\n        gap: 8px;\n        flex-wrap: wrap;\n        padding-bottom: 16px;\n      }\n      footer .foot-chip {\n        font-family: var(--mono);\n        font-size: 12px;\n        padding: 3px 9px;\n        border-radius: 7px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text-dim);\n      }\n\n      .hidden {\n        display: none !important;\n      }\n      @media (prefers-reduced-motion: reduce) {\n        *,\n        *::before,\n        *::after {\n          transition: none !important;\n          animation: none !important;\n        }\n      }\n      @media (max-width: 640px) {\n        .brand .sub {\n          display: none;\n        }\n        .kv {\n          grid-template-columns: 74px 1fr;\n        }\n      }\n    </style>\n  </head>\n  <body>\n    <header class=\"top\">\n      <div class=\"top-inner\">\n        <div class=\"brand\">\n          <span class=\"cmd\"><b>gtd</b> · workflow visualizer</span>\n          <span class=\"sub\" id=\"brandSub\">read-only view</span>\n        </div>\n        <div class=\"summary\" id=\"summary\"></div>\n        <button\n          class=\"theme-btn\"\n          id=\"themeBtn\"\n          title=\"Toggle light/dark theme\"\n          aria-label=\"Toggle light/dark theme\"\n        >\n          ◐\n        </button>\n      </div>\n    </header>\n\n    <main class=\"wrap\" id=\"app\">\n      <section class=\"hero\">\n        <h1 id=\"heroTitle\">Loading workflow…</h1>\n        <p class=\"lede\" id=\"heroLede\">\n          Fetching <code>/workflow.json</code> from the local\n          <span class=\"mono\">gtd visualize</span> server.\n        </p>\n      </section>\n\n      <div id=\"content\" class=\"hidden\">\n        <div class=\"sec-head\">\n          <h2>Current state</h2>\n          <span class=\"rule\"></span>\n        </div>\n        <div class=\"current-panel hidden\" id=\"currentPanel\"></div>\n        <div id=\"varsSection\"></div>\n\n        <div class=\"sec-head\">\n          <h2>Main flow</h2>\n          <span class=\"rule\"></span>\n        </div>\n        <p class=\"diagram-note\" id=\"diaNote\"></p>\n        <div class=\"dia-card\">\n          <div class=\"dia-scroll\" id=\"diaScroll\"><div class=\"dia-msg\">Rendering diagram…</div></div>\n        </div>\n\n        <div class=\"sec-head\">\n          <h2>Sub-machines</h2>\n          <span class=\"rule\"></span>\n        </div>\n        <div id=\"smSection\"></div>\n\n        <div class=\"sec-head\">\n          <h2>State catalogue</h2>\n          <span class=\"rule\"></span>\n        </div>\n        <div class=\"toolbar\">\n          <div class=\"search\">\n            <svg\n              width=\"15\"\n              height=\"15\"\n              viewBox=\"0 0 24 24\"\n              fill=\"none\"\n              stroke=\"currentColor\"\n              stroke-width=\"2.4\"\n            >\n              <circle cx=\"11\" cy=\"11\" r=\"7\" />\n              <path d=\"m21 21-4.3-4.3\" />\n            </svg>\n            <input\n              id=\"search\"\n              type=\"search\"\n              placeholder=\"filter by name, actor, kind, file, mode, flag…\"\n              autocomplete=\"off\"\n              spellcheck=\"false\"\n              aria-label=\"Filter states\"\n            />\n          </div>\n          <div class=\"chips\" id=\"kindChips\"></div>\n          <div class=\"legend\" id=\"legend\"></div>\n        </div>\n        <div id=\"groups\"></div>\n      </div>\n    </main>\n\n    <div class=\"backdrop\" id=\"backdrop\"></div>\n    <aside\n      class=\"drawer\"\n      id=\"drawer\"\n      role=\"dialog\"\n      aria-modal=\"true\"\n      aria-label=\"State detail\"\n      tabindex=\"-1\"\n    ></aside>\n\n    <footer class=\"wrap\" id=\"footer\"></footer>\n\n    <script type=\"module\">\n      // ── theme ──────────────────────────────────────────────────────────────\n      const root = document.documentElement\n      const prefersDark = () => matchMedia(\"(prefers-color-scheme: dark)\").matches\n      const isDark = () => {\n        const t = root.getAttribute(\"data-theme\")\n        return t ? t === \"dark\" : prefersDark()\n      }\n      document.getElementById(\"themeBtn\").onclick = () => {\n        const next = isDark() ? \"light\" : \"dark\"\n        root.setAttribute(\"data-theme\", next)\n        reinitializeAndRenderAll()\n      }\n      // Follow the OS when the user hasn't made an explicit choice — an\n      // explicit `data-theme` override always wins over an OS flip.\n      matchMedia(\"(prefers-color-scheme: dark)\").addEventListener(\"change\", () => {\n        if (!root.getAttribute(\"data-theme\")) reinitializeAndRenderAll()\n      })\n\n      const esc = (s) =>\n        String(s).replace(\n          /[&<>\"']/g,\n          (c) => ({ \"&\": \"&amp;\", \"<\": \"&lt;\", \">\": \"&gt;\", '\"': \"&quot;\", \"'\": \"&#39;\" })[c],\n        )\n\n      // Actor metadata: color class, css-var prefix, mermaid classDef name, label.\n      const ACTOR = {\n        human: { cls: \"actor-human\", dot: \"human\", label: \"human\" },\n        agent: { cls: \"actor-agent\", dot: \"agent\", label: \"agent\" },\n        check: { cls: \"actor-check\", dot: \"check\", label: \"check\" },\n        commit: { cls: \"actor-engine\", dot: \"engine\", label: \"commit\" },\n        unknown: { cls: \"actor-unknown\", dot: \"unknown\", label: \"?\" },\n      }\n      // A commit state has no actor — treat it as the engine/commit colour.\n      const actorOf = (s) => s.actor || (s.kind === \"commit\" ? \"commit\" : \"unknown\")\n      const meta = (a) => ACTOR[a] || ACTOR.unknown\n\n      const FLAGS = {\n        initial:\n          \"The one initial state — an unrecognized HEAD (any non-gtd history) resolves here.\",\n        reviewEntry:\n          \"This state is a dedicated CLI entry point (e.g. `gtd review <ref>`) that starts a brand-new process.\",\n        fixEntry:\n          \"This state is the `gtd fix` entry point — a red suite drops into the fixing loop, a green suite is a no-op.\",\n        reviewWindow:\n          \"While resting here, gtd opens the review checkout window: HEAD is rewound to the review base so the whole diff surfaces as ordinary uncommitted changes.\",\n        reviewBase:\n          \"Anchors the incremental review diff base — its most-recent in-process commit is where the next reviewing turn and checkout window start.\",\n        answerGate:\n          \"Edge gate: a step is refused while any open question in the steering file is not answered with exactly one tick.\",\n        requireProgress:\n          \"Edge gate: refuses a work-free turn that only deletes the instructions file (unless it held a NOTHING ACTIONABLE sentinel).\",\n      }\n\n      // ── state ──────────────────────────────────────────────────────────────\n      let MODEL = null\n      let STATES = []\n      let byName = {}\n      let CURRENT = null\n      let lastCurrentSig = undefined\n      let mermaidMod = null\n\n      // Fetches `/state.json`, updates `CURRENT`, and reports whether the\n      // resolved body actually changed since the last call (compared on the\n      // full JSON so an edge's `matched` flag flipping counts as a change too).\n      async function refreshCurrent() {\n        let next = null\n        try {\n          const res = await fetch(\"/state.json\")\n          const body = res.ok ? await res.json() : {}\n          next = body && body.state ? body : null\n        } catch (e) {\n          next = null\n        }\n        const sig = JSON.stringify(next)\n        if (sig === lastCurrentSig) return false\n        lastCurrentSig = sig\n        CURRENT = next\n        return true\n      }\n\n      const actorFilter = new Set([\"human\", \"agent\", \"check\", \"commit\", \"unknown\"])\n      let kindFilter = \"all\"\n\n      // ── boot ─────────────────────────────────────────────────────────────\n      try {\n        const res = await fetch(\"/workflow.json\")\n        if (!res.ok) throw new Error(\"HTTP \" + res.status)\n        MODEL = await res.json()\n      } catch (e) {\n        document.getElementById(\"heroTitle\").textContent = \"Could not load workflow\"\n        document.getElementById(\"heroLede\").innerHTML =\n          \"Fetching <code>/workflow.json</code> failed: \" +\n          esc(e.message) +\n          '. This page must be served by <span class=\"mono\">gtd visualize</span>.'\n        throw e\n      }\n\n      // Resolved at page load, then re-polled every 3s (see `poll()` below) so\n      // advancing the process shows up without a manual refresh. Tolerates a\n      // 404/error (an older server) or an empty `{}` (no active process/not a repo).\n      await refreshCurrent()\n\n      STATES = MODEL.states || []\n      byName = Object.fromEntries(STATES.map((s) => [s.name, s]))\n\n      // ── header summary + hero ───────────────────────────────────────────\n      const counts = { human: 0, agent: 0, check: 0, commit: 0, unknown: 0 }\n      STATES.forEach((s) => {\n        counts[actorOf(s)]++\n      })\n      const nGroups = (MODEL.groups || []).length\n      const cnt = (a) =>\n        counts[a] ? `<span><span class=\"s-num\">${counts[a]}</span> ${meta(a).label}</span>` : \"\"\n      document.getElementById(\"summary\").innerHTML = [\n        `<span><span class=\"s-num\">${STATES.length}</span> states</span>`,\n        `<span><span class=\"s-num\">${nGroups}</span> sub-machine${nGroups === 1 ? \"\" : \"s\"}</span>`,\n        `<span class=\"sep\">·</span>`,\n        cnt(\"human\"),\n        cnt(\"agent\"),\n        cnt(\"check\"),\n        cnt(\"commit\"),\n        cnt(\"unknown\"),\n      ]\n        .filter(Boolean)\n        .join(\" \")\n\n      document.getElementById(\"heroTitle\").innerHTML = `GTD workflow visualization`\n      document.getElementById(\"heroLede\").innerHTML =\n        `Rendered live from your workflow. The initial state is ` +\n        `<code>${esc(MODEL.initial)}</code>. Click any state — in the diagram, a sub-machine chip, ` +\n        `or the catalogue — to open its full definition, walk its outgoing edges, and see what routes into it.`\n      document.getElementById(\"content\").classList.remove(\"hidden\")\n\n      document.getElementById(\"footer\").innerHTML =\n        `<p class=\"foot-lead\">Read-only view served by <code>gtd visualize</code>.</p>` +\n        `<div class=\"foot-legend\">` +\n        `<span class=\"foot-chip\">([message])</span>` +\n        `<span class=\"foot-chip\">[prompt]</span>` +\n        `<span class=\"foot-chip\">{{script}}</span>` +\n        `<span class=\"foot-chip\">[[commit]]</span>` +\n        `<span>— node shape = content kind; colour = actor.</span>` +\n        `</div>`\n\n      // ── pill helper ────────────────────────────────────────────────────\n      const pill = (a) =>\n        `<span class=\"pill ${meta(a).cls}\"><span class=\"dot\"></span>${meta(a).label}</span>`\n\n      // ── mermaid source generation ──────────────────────────────────────\n      // Safe, stable node ids (state names can contain hyphens etc.), with a\n      // reverse lookup — needed to map a rendered SVG node's id back to its\n      // state name when wiring clicks (see `nodeIdOf`/`wire*Clicks` below).\n      const idFor = (() => {\n        const map = new Map()\n        const rev = new Map()\n        const fn = (name) => {\n          if (!map.has(name)) {\n            const id = \"n\" + map.size\n            map.set(name, id)\n            rev.set(id, name)\n          }\n          return map.get(name)\n        }\n        fn.nameOf = (id) => rev.get(id)\n        return fn\n      })()\n      const groupBoxId = (i) => \"g\" + i\n      const groupIndexOf = (name) => (MODEL.groups || []).findIndex((g) => g.name === name)\n      const shapeFor = (kind, label) => {\n        const l = `\"${label.replace(/\"/g, \"&quot;\")}\"`\n        switch (kind) {\n          case \"message\":\n            return `([\"${label.replace(/\"/g, \"&quot;\")}\"])`\n          case \"prompt\":\n            return `[${l}]`\n          case \"script\":\n            return `{{${l}}}`\n          case \"commit\":\n            return `[[${l}]]`\n          default:\n            return `[${l}]`\n        }\n      }\n      const mlabel = (s) => `\"${String(s).replace(/\"/g, \"&quot;\").replace(/\\|/g, \"&#124;\")}\"`\n      /**\n       * The mermaid `classDef` lines for actor/ghost node fills, chosen per\n       * theme so dark mode doesn't render washed-out light pastels.\n       */\n      function classDefs(dark) {\n        return [\n          dark\n            ? \"classDef human fill:#3a2e12,stroke:#e0a83e,color:#f0c674;\"\n            : \"classDef human fill:#fbeccd,stroke:#d99413,color:#5a3d0a;\",\n          dark\n            ? \"classDef agent fill:#26224a,stroke:#8b7cf0,color:#b6abf7;\"\n            : \"classDef agent fill:#e5e2fb,stroke:#6d5ce0,color:#3a2c85;\",\n          dark\n            ? \"classDef check fill:#123433,stroke:#2dc4bc,color:#68dcd4;\"\n            : \"classDef check fill:#d3f0ef,stroke:#16a39d,color:#0c524f;\",\n          dark\n            ? \"classDef commit fill:#3a1b24,stroke:#e05f7c,color:#f2a3b3;\"\n            : \"classDef commit fill:#fbdfe4,stroke:#d84a68,color:#8a1f38;\",\n          dark\n            ? \"classDef unknown fill:#1c2434,stroke:#3a465c,color:#9aa6bd,stroke-dasharray:4 3;\"\n            : \"classDef unknown fill:#eef1f7,stroke:#c2ccdb,color:#55607a,stroke-dasharray:4 3;\",\n          // Sub-machine invocation: a muted slate box (not one of the actor\n          // colours) so it still reads as its own distinct \"black-box\" kind,\n          // without the harsh opaque-black fill clashing with a light theme.\n          dark\n            ? \"classDef submachine fill:#2a3142,stroke:#5a6b8c,color:#dbe4f5,font-weight:700;\"\n            : \"classDef submachine fill:#e4e9f2,stroke:#8695b3,color:#2a3142,font-weight:700;\",\n          // A muted, dashed ghost node standing in for a target OUTSIDE the\n          // current diagram (a sub-machine diagram's external edge).\n          dark\n            ? \"classDef external fill:#1c2434,stroke:#3a465c,color:#9aa6bd,stroke-dasharray:5 4;\"\n            : \"classDef external fill:#eef1f7,stroke:#c2ccdb,color:#55607a,stroke-dasharray:5 4;\",\n        ]\n      }\n\n      /**\n       * Build one flowchart's mermaid source over `states` (a diagram scope):\n       * the whole machine for the main flow (`opts.scope` unset), or one\n       * sub-machine's own member states (`opts.scope` = that group's name).\n       * A member state whose innermost group differs from `opts.scope`\n       * collapses into a black box for ITS group (handles a sub-machine\n       * nested inside another); a target outside `states` entirely renders as\n       * a muted, dashed ghost node instead (only possible in a sub-machine\n       * diagram — the main flow's `states` is every state, so nothing is ever\n       * \"outside\" it).\n       */\n      function buildFlowSrc(states, opts) {\n        const scope = opts && opts.scope\n        const inSet = new Set(states.map((s) => s.name))\n        const lines = [\"flowchart TD\"]\n\n        const unitOf = (name) => {\n          const s = byName[name]\n          if (s && s.group && s.group !== scope) return { kind: \"box\", group: s.group }\n          return { kind: \"node\", name }\n        }\n        const unitId = (name) => {\n          const u = unitOf(name)\n          return u.kind === \"box\" ? groupBoxId(groupIndexOf(u.group)) : idFor(name)\n        }\n\n        const emittedNodes = new Set()\n        const emittedBoxes = new Set()\n        const emittedGhosts = new Set()\n        const nodeLine = (s) => `  ${idFor(s.name)}${shapeFor(s.kind, s.name)}:::${actorOf(s)}`\n        const boxLine = (g, i) =>\n          `  ${groupBoxId(i)}[\"${esc(g.name)}<br/><span class='sm-hint'>▸ ${g.states.length} state${\n            g.states.length === 1 ? \"\" : \"s\"\n          }</span>\"]:::submachine`\n        const ghostLine = (s) => `  e${idFor(s.name)}${shapeFor(s.kind, s.name)}:::external`\n\n        states.forEach((s) => {\n          const u = unitOf(s.name)\n          if (u.kind === \"node\") {\n            if (emittedNodes.has(s.name)) return\n            emittedNodes.add(s.name)\n            lines.push(nodeLine(s))\n          } else if (!emittedBoxes.has(u.group)) {\n            emittedBoxes.add(u.group)\n            const i = groupIndexOf(u.group)\n            if (i >= 0) lines.push(boxLine(MODEL.groups[i], i))\n          }\n        })\n\n        // Edges within this diagram's own state set, collapsed through box\n        // units, deduped, and label-dropped when several patterns land on the\n        // same box-level edge (a black box hides which one specifically).\n        const solid = new Map()\n        const dashed = new Map()\n        const addEdge = (map, from, to, label) => {\n          if (from === to) return\n          const key = from + \" \" + to\n          if (!map.has(key)) map.set(key, [])\n          map.get(key).push(label)\n        }\n        states.forEach((s) => {\n          ;(s.on || []).forEach((e) => {\n            if (!inSet.has(e.to) || !byName[e.to]) return\n            addEdge(solid, unitId(s.name), unitId(e.to), e.pattern)\n          })\n          if (s.retry && inSet.has(s.retry.otherwise)) {\n            addEdge(dashed, unitId(s.name), unitId(s.retry.otherwise), \"retry ×\" + s.retry.max)\n          }\n        })\n        // Ghost edges to a target entirely outside this diagram's state set\n        // (only fires for a sub-machine diagram — the main flow's set is\n        // every state, so nothing is ever \"outside\" it).\n        states.forEach((s) => {\n          ;(s.on || []).forEach((e) => {\n            if (inSet.has(e.to) || !byName[e.to]) return\n            const target = byName[e.to]\n            if (!emittedGhosts.has(e.to)) {\n              emittedGhosts.add(e.to)\n              lines.push(ghostLine(target))\n            }\n            lines.push(`  ${idFor(s.name)} -->|${mlabel(e.pattern)}| e${idFor(e.to)}`)\n          })\n          if (s.retry && byName[s.retry.otherwise] && !inSet.has(s.retry.otherwise)) {\n            const target = byName[s.retry.otherwise]\n            if (!emittedGhosts.has(s.retry.otherwise)) {\n              emittedGhosts.add(s.retry.otherwise)\n              lines.push(ghostLine(target))\n            }\n            lines.push(\n              `  ${idFor(s.name)} -.->|${mlabel(\"retry ×\" + s.retry.max)}| e${idFor(s.retry.otherwise)}`,\n            )\n          }\n        })\n\n        solid.forEach((labels, key) => {\n          const [from, to] = key.split(\" \")\n          const label = labels.length === 1 ? mlabel(labels[0]) : null\n          lines.push(`  ${from} -->${label ? \"|\" + label + \"|\" : \"\"} ${to}`)\n        })\n        dashed.forEach((labels, key) => {\n          const [from, to] = key.split(\" \")\n          const label = labels.length === 1 ? mlabel(labels[0]) : null\n          lines.push(`  ${from} -.->${label ? \"|\" + label + \"|\" : \"\"} ${to}`)\n        })\n\n        lines.push(...classDefs(isDark()))\n        return lines.join(\"\\n\")\n      }\n\n      document.getElementById(\"diaNote\").innerHTML =\n        `Every state as a node — shape is the content kind, colour is the actor. Each edge is an ` +\n        `<span class=\"mono\">on</span> pattern (first match wins); dashed edges are ` +\n        `<span class=\"mono\">retry</span> redirects. A sub-machine invocation collapses into a single ` +\n        `dark box (click it to jump to its own diagram below); an edge label is dropped when several ` +\n        `patterns collapse onto the same box-to-box edge. Scroll/pinch or drag to pan and zoom; use the ` +\n        `<span class=\"mono\">+</span>/<span class=\"mono\">−</span>/<span class=\"mono\">⤢</span> controls in the corner.`\n\n      // ── diagram render (theme-aware, offline-tolerant) ─────────────────\n      async function loadMermaid() {\n        if (mermaidMod) return mermaidMod\n        const m = await import(\"https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs\")\n        mermaidMod = m.default\n        return mermaidMod\n      }\n\n      const renderSeqByBase = new Map()\n      const nextSeq = (base) => {\n        const n = (renderSeqByBase.get(base) || 0) + 1\n        renderSeqByBase.set(base, n)\n        return n\n      }\n\n      /** Render `src` into `host` via mermaid, guarding against a stale (superseded) render; falls back to a readable error + raw source on failure. Returns the mermaid render id used (so the caller can wire clicks/highlight against ITS OWN node ids), or `null` if nothing rendered. */\n      async function renderInto(host, src, renderIdBase) {\n        const seq = nextSeq(renderIdBase)\n        let mermaid\n        try {\n          mermaid = await loadMermaid()\n        } catch (e) {\n          host.innerHTML =\n            `<div class=\"dia-msg\">Could not load the Mermaid renderer (offline?). ` +\n            `The workflow is still fully browsable below. Diagram source:` +\n            `<pre class=\"dia-src\">${esc(src)}</pre></div>`\n          return null\n        }\n        if (seq !== renderSeqByBase.get(renderIdBase)) return null\n        const renderId = renderIdBase + seq\n        try {\n          const { svg } = await mermaid.render(renderId, src)\n          if (seq !== renderSeqByBase.get(renderIdBase)) return null\n          host.innerHTML = `<div class=\"mflow\">${svg}</div>`\n          return renderId\n        } catch (e) {\n          host.innerHTML =\n            `<div class=\"dia-msg\">Diagram render failed: ${esc(e.message)}. ` +\n            `Diagram source:<pre class=\"dia-src\">${esc(src)}</pre></div>`\n          return null\n        }\n      }\n\n      // Every live diagram (main + one per sub-machine) — re-rendered as a\n      // group on every theme toggle (replaces the old single DIAGRAM_SRC).\n      // `build` is a thunk (not a fixed string) because the diagram source\n      // embeds theme-dependent classDefs — it must be re-emitted fresh on\n      // every re-render, not cached from first render.\n      const diagrams = []\n      function registerDiagram(host, build, renderIdBase, onRendered, highlight) {\n        diagrams.push({ host, build, renderIdBase, onRendered, highlight, lastRenderId: null })\n      }\n      async function renderAllDiagrams() {\n        for (const d of diagrams) {\n          const renderId = await renderInto(d.host, d.build(), d.renderIdBase)\n          if (renderId) d.lastRenderId = renderId\n          if (renderId && d.onRendered) d.onRendered(renderId, d.host)\n        }\n      }\n      async function reinitializeAndRenderAll() {\n        const mermaid = await loadMermaid().catch(() => null)\n        if (mermaid) {\n          const dark = isDark()\n          mermaid.initialize({\n            startOnLoad: false,\n            theme: \"base\",\n            securityLevel: \"strict\",\n            flowchart: { useMaxWidth: false, htmlLabels: true },\n            themeVariables: {\n              fontFamily: \"ui-monospace, Menlo, monospace\",\n              fontSize: \"12.5px\",\n              lineColor: dark ? \"#6b7690\" : \"#8a93a6\",\n              primaryBorderColor: dark ? \"#3a465c\" : \"#c2ccdb\",\n              tertiaryColor: dark ? \"#1c2434\" : \"#f0f3f8\",\n              mainBkg: dark ? \"#232c3e\" : \"#ffffff\",\n              clusterBkg: dark ? \"#1c2434\" : \"#f0f3f8\",\n              clusterBorder: dark ? \"#3a465c\" : \"#c2ccdb\",\n              titleColor: dark ? \"#e6ebf4\" : \"#1a2233\",\n              nodeTextColor: dark ? \"#e6ebf4\" : \"#1a2233\",\n              textColor: dark ? \"#e6ebf4\" : \"#1a2233\",\n              edgeLabelBackground: dark ? \"#161d2b\" : \"#f4f6fa\",\n            },\n          })\n        }\n        await renderAllDiagrams()\n      }\n\n      // ── click wiring + current-state highlight (post-render — mermaid's own\n      // `click` callbacks are disabled by securityLevel:\"strict\") ──────────\n      // A rendered node group's `id` is `${renderId}-flowchart-${ourNodeId}-<n>`\n      // (verified against mermaid@11's actual output) — strip that wrapper to\n      // recover the id we generated the diagram with.\n      function nodeIdOf(el, renderId) {\n        const prefix = renderId + \"-flowchart-\"\n        if (!el.id || !el.id.startsWith(prefix)) return null\n        const m = /^(.+)-\\d+$/.exec(el.id.slice(prefix.length))\n        return m ? m[1] : null\n      }\n      const nodeGroupsOf = (host) => [...host.querySelectorAll(\"g.node\")]\n\n      function scrollToSubmachine(i) {\n        const el = document.getElementById(\"sm-\" + i)\n        if (!el) return\n        el.open = true\n        el.scrollIntoView({ behavior: \"smooth\", block: \"start\" })\n      }\n      function navigateTo(name) {\n        const s = byName[name]\n        if (s && s.group) {\n          const gi = groupIndexOf(s.group)\n          if (gi >= 0) return scrollToSubmachine(gi)\n        }\n        openDrawer(name)\n      }\n\n      function applyCurrentHighlight(renderId, host, mode, gi) {\n        if (!CURRENT || !CURRENT.state) return\n        const wantId =\n          mode === \"main\"\n            ? CURRENT.group\n              ? groupBoxId(groupIndexOf(CURRENT.group))\n              : idFor(CURRENT.state)\n            : CURRENT.group === MODEL.groups[gi].name\n              ? idFor(CURRENT.state)\n              : null\n        if (wantId === null) return\n        nodeGroupsOf(host).forEach((el) => {\n          if (nodeIdOf(el, renderId) === wantId) el.classList.add(\"gtd-current\")\n        })\n      }\n\n      // Re-applies the current-state highlight to every already-rendered\n      // diagram, without re-running mermaid — used by the poll loop below.\n      function repaintHighlights() {\n        for (const d of diagrams) {\n          nodeGroupsOf(d.host).forEach((el) => el.classList.remove(\"gtd-current\"))\n          if (d.lastRenderId && d.highlight) {\n            applyCurrentHighlight(d.lastRenderId, d.host, d.highlight.mode, d.highlight.gi)\n          }\n        }\n      }\n\n      function wireMainDiagramClicks(renderId, host) {\n        nodeGroupsOf(host).forEach((el) => {\n          const rawId = nodeIdOf(el, renderId)\n          if (!rawId) return\n          el.classList.add(\"clickable\")\n          el.style.cursor = \"pointer\"\n          if (rawId[0] === \"g\") {\n            el.onclick = () => scrollToSubmachine(Number(rawId.slice(1)))\n          } else {\n            const name = idFor.nameOf(rawId)\n            if (name) el.onclick = () => openDrawer(name)\n          }\n        })\n        applyCurrentHighlight(renderId, host, \"main\")\n        attachPanZoom(host)\n      }\n\n      function wireSubmachineDiagramClicks(renderId, host, gi) {\n        nodeGroupsOf(host).forEach((el) => {\n          const rawId = nodeIdOf(el, renderId)\n          if (!rawId) return\n          el.classList.add(\"clickable\")\n          el.style.cursor = \"pointer\"\n          if (rawId[0] === \"g\") {\n            el.onclick = () => scrollToSubmachine(Number(rawId.slice(1)))\n          } else if (rawId[0] === \"e\") {\n            const name = idFor.nameOf(rawId.slice(1))\n            if (name) el.onclick = () => navigateTo(name)\n          } else {\n            const name = idFor.nameOf(rawId)\n            if (name) el.onclick = () => openDrawer(name)\n          }\n        })\n        applyCurrentHighlight(renderId, host, \"submachine\", gi)\n        attachPanZoom(host)\n      }\n\n      // ── diagram pan & zoom (hand-rolled — no pan-zoom dependency, see plan) ──\n      // `host` is a `.dia-scroll` element whose content mermaid just replaced\n      // wholesale (`renderInto`'s `host.innerHTML = ...`), so old listeners on\n      // its previous children are already gone — this re-creates the control\n      // cluster and re-attaches fresh listeners on every render, never\n      // accumulating stale ones.\n      const REDUCED_MOTION = matchMedia(\"(prefers-reduced-motion: reduce)\").matches\n      const clampScale = (s) => Math.min(3, Math.max(0.4, s))\n\n      function attachPanZoom(host) {\n        const flow = host.querySelector(\".mflow\")\n        const svg = flow && flow.querySelector(\"svg\")\n        if (!flow || !svg) return\n\n        const controls = document.createElement(\"div\")\n        controls.className = \"pz-controls\"\n        controls.innerHTML =\n          `<button class=\"pz-btn\" data-act=\"in\" title=\"Zoom in\" aria-label=\"Zoom in\">+</button>` +\n          `<button class=\"pz-btn\" data-act=\"out\" title=\"Zoom out\" aria-label=\"Zoom out\">−</button>` +\n          `<button class=\"pz-btn\" data-act=\"fit\" title=\"Fit to width\" aria-label=\"Fit to width\">⤢</button>`\n        host.appendChild(controls)\n\n        const box = svg.getBBox ? svg.getBBox() : { width: 0, height: 0 }\n        const naturalWidth = box.width || svg.clientWidth || 1\n        const naturalHeight = box.height || svg.clientHeight || 1\n\n        const state = { scale: 1, tx: 0, ty: 0 }\n        const apply = () => {\n          flow.style.transform = `translate(${state.tx}px, ${state.ty}px) scale(${state.scale})`\n        }\n        // Fit-to-width, capped at 1× so a small workflow renders at its\n        // natural size (the pre-pan/zoom default) instead of being blown up.\n        const fit = () => {\n          const r = host.getBoundingClientRect()\n          state.scale = clampScale(Math.min(1, Math.max(r.width - 32, 40) / naturalWidth))\n          state.tx = (r.width - naturalWidth * state.scale) / 2\n          state.ty = (r.height - naturalHeight * state.scale) / 2\n          apply()\n        }\n        const zoomBy = (factor, cx, cy) => {\n          const r = host.getBoundingClientRect()\n          const px = cx == null ? r.width / 2 : cx\n          const py = cy == null ? r.height / 2 : cy\n          const next = clampScale(state.scale * factor)\n          const ratio = next / state.scale\n          state.tx = px - (px - state.tx) * ratio\n          state.ty = py - (py - state.ty) * ratio\n          state.scale = next\n          apply()\n        }\n        // Animate only a button-triggered zoom/fit (an explicit, discrete\n        // action) — wheel/drag stay instant so the transform tracks the\n        // cursor/finger with no lag. Skipped entirely under\n        // prefers-reduced-motion.\n        const animated = (fn) => {\n          if (REDUCED_MOTION) return fn()\n          flow.style.transition = \"transform 0.18s ease\"\n          fn()\n          flow.addEventListener(\"transitionend\", () => (flow.style.transition = \"\"), {\n            once: true,\n          })\n        }\n        fit()\n\n        host.addEventListener(\n          \"wheel\",\n          (e) => {\n            e.preventDefault()\n            flow.style.transition = \"none\"\n            const r = host.getBoundingClientRect()\n            zoomBy(e.deltaY < 0 ? 1.12 : 1 / 1.12, e.clientX - r.left, e.clientY - r.top)\n          },\n          { passive: false },\n        )\n\n        // Drag-to-pan: a small movement threshold before a pointerdown counts\n        // as a drag (rather than a click), and — once it does — the resulting\n        // synthetic `click` is swallowed so dragging over a node never opens\n        // its drawer. Pointer capture is deferred until that threshold is\n        // actually crossed: a captured pointer retargets its WHOLE mouse-event\n        // sequence (including the eventual `click`) to `host`, so capturing\n        // eagerly on every pointerdown would silently break a plain click on\n        // any node (or the zoom/fit buttons) — not just an actual drag.\n        let drag = null\n        host.addEventListener(\"pointerdown\", (e) => {\n          if (e.button !== 0 || e.target.closest(\".pz-controls\")) return\n          drag = { x: e.clientX, y: e.clientY, tx: state.tx, ty: state.ty, moved: false }\n          flow.style.transition = \"none\"\n        })\n        host.addEventListener(\"pointermove\", (e) => {\n          if (!drag) return\n          const dx = e.clientX - drag.x\n          const dy = e.clientY - drag.y\n          if (!drag.moved && Math.hypot(dx, dy) > 4) {\n            drag.moved = true\n            host.classList.add(\"pz-dragging\")\n            host.setPointerCapture(e.pointerId)\n          }\n          if (drag.moved) {\n            state.tx = drag.tx + dx\n            state.ty = drag.ty + dy\n            apply()\n          }\n        })\n        const endDrag = () => {\n          if (!drag) return\n          if (drag.moved) {\n            host.classList.remove(\"pz-dragging\")\n            host.addEventListener(\n              \"click\",\n              (ev) => {\n                ev.stopPropagation()\n                ev.preventDefault()\n              },\n              { capture: true, once: true },\n            )\n          }\n          drag = null\n        }\n        host.addEventListener(\"pointerup\", endDrag)\n        host.addEventListener(\"pointercancel\", endDrag)\n\n        controls.querySelector('[data-act=\"in\"]').onclick = (e) => {\n          e.stopPropagation()\n          animated(() => zoomBy(1.25))\n        }\n        controls.querySelector('[data-act=\"out\"]').onclick = (e) => {\n          e.stopPropagation()\n          animated(() => zoomBy(1 / 1.25))\n        }\n        controls.querySelector('[data-act=\"fit\"]').onclick = (e) => {\n          e.stopPropagation()\n          animated(fit)\n        }\n\n        // Exposed so a collapsed sub-machine `<details>` panel can re-fit once\n        // it's actually opened (its content renders at zero width while hidden).\n        host.__pz = { fit, zoomBy }\n      }\n\n      // ── main flow ────────────────────────────────────────────────────────\n      registerDiagram(\n        document.getElementById(\"diaScroll\"),\n        () => buildFlowSrc(STATES, {}),\n        \"gtdmain\",\n        wireMainDiagramClicks,\n        { mode: \"main\" },\n      )\n\n      // ── sub-machines panel — one real mermaid diagram per invocation ─────\n      ;(function renderSubmachines() {\n        const el = document.getElementById(\"smSection\")\n        const groups = MODEL.groups || []\n        if (!groups.length) {\n          el.innerHTML = `<p class=\"muted-note\">This workflow declares no sub-machines.</p>`\n          return\n        }\n        el.innerHTML = \"\"\n        groups.forEach((g, i) => {\n          const card = document.createElement(\"details\")\n          card.className = \"dia-card sm-card\"\n          card.id = \"sm-\" + i\n          card.style.marginBottom = \"16px\"\n          if (CURRENT && CURRENT.group === g.name) card.open = true\n          card.innerHTML =\n            `<summary class=\"h\"><span class=\"nm\">${esc(g.name)} · instantiates <b>${esc(g.submachine)}</b></span></summary>` +\n            `<div class=\"dia-scroll\" id=\"smDia${i}\"><div class=\"dia-msg\">Rendering diagram…</div></div>`\n          el.appendChild(card)\n\n          const members = (g.states || []).map((n) => byName[n]).filter(Boolean)\n          registerDiagram(\n            card.querySelector(`#smDia${i}`),\n            () => buildFlowSrc(members, { scope: g.name }),\n            \"gtdsm\" + i + \"-\",\n            (renderId, host) => wireSubmachineDiagramClicks(renderId, host, i),\n            { mode: \"submachine\", gi: i },\n          )\n          // A collapsed <details> renders its content at zero width, so the\n          // pan/zoom \"fit\" computed while hidden is wrong — recompute it once\n          // the panel is actually opened.\n          card.addEventListener(\"toggle\", () => {\n            if (!card.open) return\n            const host = card.querySelector(`#smDia${i}`)\n            if (host && host.__pz) host.__pz.fit()\n          })\n        })\n      })()\n\n      // ── vars ─────────────────────────────────────────────────────────────\n      ;(function renderVars() {\n        const vars = MODEL.vars || {}\n        const keys = Object.keys(vars)\n        if (!keys.length) return\n        const el = document.getElementById(\"varsSection\")\n        el.innerHTML =\n          `<div class=\"sec-head\"><h2>Workflow variables</h2><span class=\"rule\"></span></div>` +\n          `<div class=\"vars-grid\">${keys\n            .map((k) => `<span class=\"var-chip\"><b>${esc(k)}</b> = ${esc(vars[k])}</span>`)\n            .join(\"\")}</div>`\n      })()\n\n      // ── current-state panel ─────────────────────────────────────────────\n      // Status-letter colour reuses existing actor tokens rather than adding new\n      // theme variables: A (added) reads as the check colour, M (modified) as\n      // the accent, D (deleted) as the engine/commit colour.\n      const PENDING_STATUS_COLOR = {\n        A: \"var(--check-fg)\",\n        M: \"var(--accent)\",\n        D: \"var(--engine-fg)\",\n      }\n      function pendingListHtml(pending) {\n        if (!pending || !pending.length) {\n          return `<p class=\"pending-clean\">working tree clean</p>`\n        }\n        return (\n          `<div class=\"pending-list\">` +\n          pending\n            .map(\n              (c) =>\n                `<div class=\"pc\"><span class=\"st\" style=\"color:${PENDING_STATUS_COLOR[c.status] || \"var(--text-dim)\"}\">${esc(c.status)}</span><span class=\"path\">${esc(c.path)}</span></div>`,\n            )\n            .join(\"\") +\n          `</div>`\n        )\n      }\n      function renderCurrentPanel() {\n        const panel = document.getElementById(\"currentPanel\")\n        if (!CURRENT || !CURRENT.state) {\n          panel.classList.add(\"hidden\")\n          return\n        }\n        panel.classList.remove(\"hidden\")\n        const a = CURRENT.actor\n        const edgeRow = (pattern, to, matched, retryOf) => {\n          const t = byName[to]\n          return (\n            `<div class=\"edge${matched ? \" cur-matched\" : \"\"}\"><div class=\"er\">` +\n            `<span class=\"pat\">${retryOf ? \"after \" + esc(retryOf) + \" tries\" : \"if \" + esc(pattern)}</span>` +\n            `<span class=\"arr\">→</span>` +\n            `<button class=\"goto\" data-actor=\"${t ? actorOf(t) : \"unknown\"}\" data-to=\"${esc(to)}\">${esc(to)}</button>` +\n            `${matched ? '<span class=\"cur-tag\">current match</span>' : \"\"}</div></div>`\n          )\n        }\n        const rows = (CURRENT.edges || []).map((e) => edgeRow(e.pattern, e.to, e.matched)).join(\"\")\n        const retryRow = CURRENT.retry\n          ? edgeRow(null, CURRENT.retry.otherwise, false, CURRENT.retry.max)\n          : \"\"\n        panel.innerHTML =\n          `<div class=\"cur-head\"><span class=\"cur-name\">${esc(CURRENT.state)}</span>` +\n          `${pill(a)}<span class=\"kind\">${esc(CURRENT.kind)}</span>` +\n          `${CURRENT.group ? `<span class=\"flow-tag\">${esc(CURRENT.group)}</span>` : \"\"}</div>` +\n          `<div style=\"margin-top:14px\">${pendingListHtml(CURRENT.pending)}</div>` +\n          `<div class=\"edges\">${\n            rows || retryRow ? rows + retryRow : '<p class=\"none\">No outgoing edges declared.</p>'\n          }</div>`\n        panel.querySelector(\".cur-head\").onclick = () => navigateTo(CURRENT.state)\n        panel.querySelectorAll(\".goto\").forEach((b) => (b.onclick = () => navigateTo(b.dataset.to)))\n      }\n      renderCurrentPanel()\n\n      reinitializeAndRenderAll()\n\n      // ── live current-state polling ──────────────────────────────────────\n      // Keeps the panel + diagram highlight in sync with an in-progress\n      // process without a manual page refresh. Skipped while the tab is\n      // hidden; becoming visible again triggers an immediate refresh. No\n      // in-flight guard — a slow tick just means the next one also awaits.\n      async function poll() {\n        if (document.hidden) return\n        const changed = await refreshCurrent()\n        if (changed) {\n          renderCurrentPanel()\n          repaintHighlights()\n        }\n      }\n      setInterval(poll, 3000)\n      document.addEventListener(\"visibilitychange\", () => {\n        if (!document.hidden) poll()\n      })\n\n      // ── kind chips + actor legend ──────────────────────────────────────\n      const kindChipsEl = document.getElementById(\"kindChips\")\n      const presentKinds = [\"all\", ...Array.from(new Set(STATES.map((s) => s.kind)))]\n      presentKinds.forEach((k) => {\n        const b = document.createElement(\"button\")\n        b.className = \"chip-btn\" + (k === \"all\" ? \" on\" : \"\")\n        b.textContent = k\n        b.dataset.kind = k\n        b.onclick = () => {\n          kindFilter = k\n          ;[...kindChipsEl.children].forEach((c) =>\n            c.classList.toggle(\"on\", c.dataset.kind === kindFilter),\n          )\n          renderCatalogue()\n        }\n        kindChipsEl.appendChild(b)\n      })\n\n      const legendEl = document.getElementById(\"legend\")\n      ;[\"human\", \"agent\", \"check\", \"commit\", \"unknown\"].forEach((a) => {\n        if (!counts[a]) return\n        const el = document.createElement(\"button\")\n        el.className = \"li\"\n        el.dataset.actor = a\n        el.setAttribute(\"aria-pressed\", \"true\")\n        el.innerHTML = `<span class=\"dot\" style=\"background:var(--${meta(a).dot}-dot)\"></span>${meta(a).label}`\n        el.onclick = () => {\n          const on = actorFilter.has(a)\n          on ? actorFilter.delete(a) : actorFilter.add(a)\n          el.classList.toggle(\"off\", on)\n          el.setAttribute(\"aria-pressed\", String(!on))\n          renderCatalogue()\n        }\n        legendEl.appendChild(el)\n      })\n\n      // ── catalogue ──────────────────────────────────────────────────────\n      const groupsEl = document.getElementById(\"groups\")\n      function stateMatches(s, q) {\n        if (!actorFilter.has(actorOf(s))) return false\n        if (kindFilter !== \"all\" && s.kind !== kindFilter) return false\n        if (!q) return true\n        const hay = [\n          s.name,\n          s.actor,\n          s.kind,\n          s.file,\n          s.mode,\n          s.model,\n          s.memory,\n          (s.flags || []).join(\" \"),\n        ]\n          .filter(Boolean)\n          .join(\" \")\n          .toLowerCase()\n        return hay.includes(q)\n      }\n      function cardFor(s) {\n        const a = actorOf(s)\n        const card = document.createElement(\"button\")\n        card.className = \"card\"\n        card.dataset.actor = a\n        const flags = (s.flags || [])\n          .filter((f) => f !== \"initial\")\n          .map((f) => `<span class=\"flag\">${esc(f)}</span>`)\n          .join(\"\")\n        const retry = s.retry ? `<span class=\"flag\">retry ${s.retry.max}</span>` : \"\"\n        const initTick = s.initial ? `<div class=\"init-tick\">initial</div>` : \"\"\n        card.innerHTML =\n          `${initTick}<div class=\"name\">${esc(s.name)}</div>` +\n          `<div class=\"row\">${pill(a)}<span class=\"kind\">${esc(s.kind)}</span>${retry}${flags}</div>`\n        card.onclick = () => openDrawer(s.name)\n        return card\n      }\n      function renderCatalogue() {\n        const q = document.getElementById(\"search\").value.trim().toLowerCase()\n        groupsEl.innerHTML = \"\"\n        const sections = []\n        ;(MODEL.groups || []).forEach((g) => {\n          sections.push({\n            label: g.name,\n            flow: g.submachine,\n            items: STATES.filter((s) => s.group === g.name),\n          })\n        })\n        const ungrouped = STATES.filter((s) => !s.group)\n        if (ungrouped.length) sections.push({ label: \"Ungrouped\", flow: \"\", items: ungrouped })\n\n        let shown = 0\n        sections.forEach((sec) => {\n          const items = sec.items.filter((s) => stateMatches(s, q))\n          if (!items.length) return\n          shown += items.length\n          const wrap = document.createElement(\"div\")\n          wrap.className = \"group\"\n          wrap.innerHTML =\n            `<div class=\"group-head\">${sec.flow ? `<span class=\"flow-tag\">${esc(sec.flow)}</span>` : \"\"}` +\n            `<h3>${esc(sec.label)}</h3></div>`\n          const grid = document.createElement(\"div\")\n          grid.className = \"grid\"\n          items.forEach((s) => grid.appendChild(cardFor(s)))\n          wrap.appendChild(grid)\n          groupsEl.appendChild(wrap)\n        })\n        if (!shown)\n          groupsEl.innerHTML = `<p class=\"none\" style=\"padding:20px 0\">No states match this filter.</p>`\n      }\n      document.getElementById(\"search\").addEventListener(\"input\", renderCatalogue)\n      renderCatalogue()\n\n      // ── drawer ─────────────────────────────────────────────────────────\n      const drawer = document.getElementById(\"drawer\")\n      const backdrop = document.getElementById(\"backdrop\")\n      let lastFocus = null\n\n      function openDrawer(name) {\n        const s = byName[name]\n        if (!s) return\n        const a = actorOf(s)\n        if (!drawer.classList.contains(\"open\")) lastFocus = document.activeElement\n\n        const kv = []\n        kv.push([\"actor\", pill(a)])\n        kv.push([\"kind\", `<span class=\"kind\">${esc(s.kind)}</span>`])\n        kv.push([\"model\", s.model ? esc(s.model) : '<span class=\"none\">—</span>'])\n        kv.push([\"memory\", s.memory ? esc(s.memory) : '<span class=\"none\">—</span>'])\n        kv.push([\"file\", s.file ? esc(s.file) : '<span class=\"none\">—</span>'])\n        kv.push([\"mode\", s.mode ? esc(s.mode) : '<span class=\"none\">—</span>'])\n        if (s.retry)\n          kv.push([\n            \"retry\",\n            `max ${s.retry.max} → <span style=\"color:var(--accent)\">${esc(s.retry.otherwise)}</span>`,\n          ])\n        if (s.group) kv.push([\"group\", esc(s.group)])\n\n        const contentBlock = s.content\n          ? `<div class=\"field\"><div class=\"k\">content — ${esc(s.kind)}</div><pre class=\"dia-src state-content\">${esc(s.content)}</pre></div>`\n          : \"\"\n\n        const flags = s.flags || []\n        const flagBlock = flags.length\n          ? `<div class=\"field\"><div class=\"k\">flags & gates</div><div class=\"flag-list\">${flags\n              .map(\n                (f) =>\n                  `<div class=\"flag-item\"><span class=\"fn\">${esc(f)}</span><span class=\"fd\">${esc(FLAGS[f] || \"\")}</span></div>`,\n              )\n              .join(\"\")}</div></div>`\n          : \"\"\n\n        const edges = s.on || []\n        const edgesBlock = edges.length\n          ? `<div class=\"field\"><div class=\"k\">outgoing edges — on (first match wins)</div><div class=\"edges\">${edges\n              .map((e) => {\n                const t = byName[e.to]\n                const ta = t ? actorOf(t) : \"unknown\"\n                return (\n                  `<div class=\"edge\"><div class=\"er\"><span class=\"pat\">${esc(e.pattern)}</span><span class=\"arr\">→</span>` +\n                  `<button class=\"goto\" data-actor=\"${ta}\" data-to=\"${esc(e.to)}\">${esc(e.to)}</button></div>` +\n                  `${e.describe ? `<div class=\"em\">${esc(e.describe)}</div>` : \"\"}</div>`\n                )\n              })\n              .join(\"\")}</div></div>`\n          : `<div class=\"field\"><div class=\"k\">outgoing edges</div><p class=\"none\">${\n              s.kind === \"commit\"\n                ? \"Commit state — no outgoing edges. Entering it ends the process in one squash.\"\n                : \"No outgoing edges declared.\"\n            }</p></div>`\n\n        const retryOut =\n          s.retry && byName[s.retry.otherwise]\n            ? `<div class=\"field\"><div class=\"k\">retry redirect</div><div class=\"edge\"><div class=\"er\">` +\n              `<span class=\"pat\">after ${esc(s.retry.max)} tries</span><span class=\"arr\">→</span>` +\n              `<button class=\"goto\" data-actor=\"${actorOf(byName[s.retry.otherwise])}\" data-to=\"${esc(s.retry.otherwise)}\">${esc(s.retry.otherwise)}</button>` +\n              `</div></div></div>`\n            : \"\"\n\n        const inc = s.incoming || []\n        const incBlock =\n          `<div class=\"field\"><div class=\"k\">routes in from (${inc.length})</div>` +\n          (inc.length\n            ? `<div class=\"incoming\">${inc\n                .map((i) => {\n                  const f = byName[i.from]\n                  return `<button class=\"goto\" data-actor=\"${f ? actorOf(f) : \"unknown\"}\" data-to=\"${esc(i.from)}\" title=\"${esc(i.pattern)}\">${esc(i.from)}</button>`\n                })\n                .join(\"\")}</div>`\n            : `<p class=\"none\">Reached only as an entry point (a CLI command enters it directly).</p>`) +\n          `</div>`\n\n        drawer.style.setProperty(\"--card-accent\", `var(--${meta(a).dot}-dot)`)\n        drawer.innerHTML =\n          `<div class=\"drawer-head\" style=\"--card-accent:var(--${meta(a).dot}-dot)\">` +\n          `<div class=\"top\"><h3>${esc(s.name)}</h3>` +\n          `<button class=\"close-x\" id=\"closeX\" aria-label=\"Close detail\">✕</button></div>` +\n          `<div class=\"meta-row\">${pill(a)}<span class=\"kind\">${esc(s.kind)}</span>` +\n          `${s.initial ? '<span class=\"flag\">initial</span>' : \"\"}` +\n          `${s.retry ? `<span class=\"flag\">retry ${s.retry.max}</span>` : \"\"}` +\n          `${flags\n            .filter((f) => f !== \"initial\")\n            .map((f) => `<span class=\"flag\">${esc(f)}</span>`)\n            .join(\"\")}</div></div>` +\n          `<div class=\"drawer-body\">` +\n          `<div class=\"field\"><div class=\"k\">definition</div><dl class=\"kv\">${kv\n            .map(([k, v]) => `<dt>${esc(k)}</dt><dd>${v}</dd>`)\n            .join(\"\")}</dl></div>` +\n          contentBlock +\n          flagBlock +\n          edgesBlock +\n          retryOut +\n          incBlock +\n          `</div>`\n\n        drawer\n          .querySelectorAll(\".goto\")\n          .forEach((b) => (b.onclick = () => openDrawer(b.dataset.to)))\n        drawer.querySelector(\"#closeX\").onclick = closeDrawer\n\n        backdrop.classList.add(\"open\")\n        drawer.classList.add(\"open\")\n        drawer.querySelector(\".drawer-body\").scrollTop = 0\n        drawer.querySelector(\"#closeX\").focus()\n      }\n      function closeDrawer() {\n        backdrop.classList.remove(\"open\")\n        drawer.classList.remove(\"open\")\n        if (lastFocus && lastFocus.focus) lastFocus.focus()\n      }\n      backdrop.onclick = closeDrawer\n      document.addEventListener(\"keydown\", (e) => {\n        if (e.key === \"Escape\" && drawer.classList.contains(\"open\")) closeDrawer()\n      })\n\n      // expose for interactions\n      window.__openState = openDrawer\n    <\/script>\n  </body>\n</html>\n";
+var visualize_default = "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n    <title>gtd · workflow visualizer</title>\n    <style>\n      :root {\n        --bg: #f4f6fa;\n        --surface: #ffffff;\n        --surface-2: #eef1f7;\n        --surface-3: #e6ebf3;\n        --border: #d9dee8;\n        --border-strong: #c2ccdb;\n        --text: #1a2233;\n        --text-dim: #55607a;\n        --text-faint: #8a93a6;\n        --accent: #2d6cdf;\n        --accent-soft: #e4edfd;\n        --human-bg: #fbeccd;\n        --human-fg: #7a5310;\n        --human-dot: #d99413;\n        --agent-bg: #e5e2fb;\n        --agent-fg: #463693;\n        --agent-dot: #6d5ce0;\n        --check-bg: #d3f0ef;\n        --check-fg: #0c524f;\n        --check-dot: #16a39d;\n        --engine-bg: #fbdfe4;\n        --engine-fg: #8a1f38;\n        --engine-dot: #d84a68;\n        --unknown-bg: #eef1f7;\n        --unknown-fg: #55607a;\n        --unknown-dot: #8a93a6;\n        --shadow: 0 1px 2px rgba(20, 30, 50, 0.06), 0 8px 28px rgba(20, 30, 50, 0.1);\n        --shadow-sm: 0 1px 2px rgba(20, 30, 50, 0.08);\n        --radius: 12px;\n        --mono:\n          ui-monospace, \"SF Mono\", \"SFMono-Regular\", Menlo, Consolas, \"Liberation Mono\", monospace;\n        --sans:\n          ui-sans-serif, system-ui, -apple-system, \"Segoe UI\", Roboto, Helvetica, Arial, sans-serif;\n        --dia-bg: #f7f9fc;\n      }\n      @media (prefers-color-scheme: dark) {\n        :root {\n          --bg: #0e1420;\n          --surface: #161d2b;\n          --surface-2: #1c2434;\n          --surface-3: #232c3e;\n          --border: #2b3547;\n          --border-strong: #3a465c;\n          --text: #e6ebf4;\n          --text-dim: #9aa6bd;\n          --text-faint: #6b7690;\n          --accent: #5b8def;\n          --accent-soft: #1b2740;\n          --human-bg: #3a2e12;\n          --human-fg: #f0c674;\n          --human-dot: #e0a83e;\n          --agent-bg: #26224a;\n          --agent-fg: #b6abf7;\n          --agent-dot: #8b7cf0;\n          --check-bg: #123433;\n          --check-fg: #68dcd4;\n          --check-dot: #2dc4bc;\n          --engine-bg: #3a1b24;\n          --engine-fg: #f2a3b3;\n          --engine-dot: #e05f7c;\n          --unknown-bg: #1c2434;\n          --unknown-fg: #9aa6bd;\n          --unknown-dot: #6b7690;\n          --shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 12px 34px rgba(0, 0, 0, 0.45);\n          --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.35);\n          --dia-bg: #0b1018;\n        }\n      }\n      :root[data-theme=\"light\"] {\n        --bg: #f4f6fa;\n        --surface: #ffffff;\n        --surface-2: #eef1f7;\n        --surface-3: #e6ebf3;\n        --border: #d9dee8;\n        --border-strong: #c2ccdb;\n        --text: #1a2233;\n        --text-dim: #55607a;\n        --text-faint: #8a93a6;\n        --accent: #2d6cdf;\n        --accent-soft: #e4edfd;\n        --human-bg: #fbeccd;\n        --human-fg: #7a5310;\n        --human-dot: #d99413;\n        --agent-bg: #e5e2fb;\n        --agent-fg: #463693;\n        --agent-dot: #6d5ce0;\n        --check-bg: #d3f0ef;\n        --check-fg: #0c524f;\n        --check-dot: #16a39d;\n        --engine-bg: #fbdfe4;\n        --engine-fg: #8a1f38;\n        --engine-dot: #d84a68;\n        --unknown-bg: #eef1f7;\n        --unknown-fg: #55607a;\n        --unknown-dot: #8a93a6;\n        --shadow: 0 1px 2px rgba(20, 30, 50, 0.06), 0 8px 28px rgba(20, 30, 50, 0.1);\n        --shadow-sm: 0 1px 2px rgba(20, 30, 50, 0.08);\n        --dia-bg: #f7f9fc;\n      }\n      :root[data-theme=\"dark\"] {\n        --bg: #0e1420;\n        --surface: #161d2b;\n        --surface-2: #1c2434;\n        --surface-3: #232c3e;\n        --border: #2b3547;\n        --border-strong: #3a465c;\n        --text: #e6ebf4;\n        --text-dim: #9aa6bd;\n        --text-faint: #6b7690;\n        --accent: #5b8def;\n        --accent-soft: #1b2740;\n        --human-bg: #3a2e12;\n        --human-fg: #f0c674;\n        --human-dot: #e0a83e;\n        --agent-bg: #26224a;\n        --agent-fg: #b6abf7;\n        --agent-dot: #8b7cf0;\n        --check-bg: #123433;\n        --check-fg: #68dcd4;\n        --check-dot: #2dc4bc;\n        --engine-bg: #3a1b24;\n        --engine-fg: #f2a3b3;\n        --engine-dot: #e05f7c;\n        --unknown-bg: #1c2434;\n        --unknown-fg: #9aa6bd;\n        --unknown-dot: #6b7690;\n        --shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 12px 34px rgba(0, 0, 0, 0.45);\n        --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.35);\n        --dia-bg: #0b1018;\n      }\n\n      * {\n        box-sizing: border-box;\n      }\n      html,\n      body {\n        max-width: 100%;\n        overflow-x: hidden;\n      }\n      body {\n        margin: 0;\n        background: var(--bg);\n        color: var(--text);\n        font-family: var(--sans);\n        font-size: 15px;\n        line-height: 1.55;\n        -webkit-font-smoothing: antialiased;\n      }\n      ::selection {\n        background: var(--accent);\n        color: #fff;\n      }\n      .wrap {\n        max-width: 1180px;\n        margin: 0 auto;\n        padding: 0 20px;\n      }\n\n      /* header */\n      header.top {\n        position: sticky;\n        top: 0;\n        z-index: 40;\n        background: color-mix(in srgb, var(--bg) 88%, transparent);\n        backdrop-filter: blur(10px);\n        border-bottom: 1px solid var(--border);\n      }\n      .top-inner {\n        display: flex;\n        align-items: center;\n        gap: 18px;\n        padding: 12px 20px;\n        max-width: 1180px;\n        margin: 0 auto;\n        flex-wrap: wrap;\n      }\n      .brand {\n        display: flex;\n        align-items: baseline;\n        gap: 10px;\n        margin-right: auto;\n      }\n      .brand .cmd {\n        font-family: var(--mono);\n        font-weight: 700;\n        font-size: 17px;\n        letter-spacing: -0.02em;\n      }\n      .brand .cmd b {\n        color: var(--accent);\n      }\n      .brand .sub {\n        font-size: 12px;\n        color: var(--text-faint);\n        letter-spacing: 0.04em;\n        text-transform: uppercase;\n      }\n      .summary {\n        font-size: 12.5px;\n        color: var(--text-dim);\n        display: flex;\n        gap: 10px;\n        flex-wrap: wrap;\n        align-items: center;\n      }\n      .summary .s-num {\n        font-family: var(--mono);\n        font-weight: 700;\n        color: var(--text);\n      }\n      .summary .sep {\n        color: var(--border-strong);\n      }\n      .theme-btn {\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text-dim);\n        border-radius: 8px;\n        width: 32px;\n        height: 32px;\n        cursor: pointer;\n        font-size: 14px;\n        display: grid;\n        place-items: center;\n      }\n      .theme-btn:hover {\n        color: var(--text);\n        border-color: var(--border-strong);\n      }\n      .theme-btn:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n\n      /* hero */\n      .hero {\n        padding: 40px 0 4px;\n      }\n      h1 {\n        font-size: clamp(26px, 4vw, 36px);\n        line-height: 1.08;\n        letter-spacing: -0.025em;\n        margin: 0 0 12px;\n        font-weight: 780;\n      }\n      h1 .mono {\n        font-family: var(--mono);\n        font-weight: 700;\n      }\n      .lede {\n        font-size: 16px;\n        color: var(--text-dim);\n        max-width: 70ch;\n        margin: 0;\n      }\n      .lede code {\n        font-family: var(--mono);\n        font-size: 0.88em;\n        background: var(--surface-2);\n        padding: 1px 6px;\n        border-radius: 5px;\n        color: var(--text);\n      }\n\n      /* section headers */\n      .sec-head {\n        display: flex;\n        align-items: baseline;\n        gap: 12px;\n        margin: 46px 0 4px;\n      }\n      .sec-head h2 {\n        font-size: 13px;\n        text-transform: uppercase;\n        letter-spacing: 0.12em;\n        color: var(--text-faint);\n        margin: 0;\n        font-weight: 700;\n      }\n      .sec-head .rule {\n        flex: 1;\n        height: 1px;\n        background: var(--border);\n      }\n\n      /* diagram */\n      .diagram-note {\n        font-size: 13px;\n        color: var(--text-dim);\n        margin: 16px 0 14px;\n        max-width: 78ch;\n      }\n      .diagram-note .mono {\n        font-family: var(--mono);\n      }\n      .dia-card {\n        background: var(--surface);\n        border: 1px solid var(--border);\n        border-radius: var(--radius);\n        box-shadow: var(--shadow-sm);\n        overflow: hidden;\n      }\n      .sm-card summary.h {\n        display: flex;\n        align-items: baseline;\n        justify-content: space-between;\n        cursor: pointer;\n        list-style: none;\n        padding: 14px 18px;\n        transition: background 0.12s ease;\n      }\n      .sm-card summary.h:hover {\n        background: var(--surface-2);\n      }\n      .sm-card[open] summary.h {\n        border-bottom: 1px solid var(--border);\n      }\n      .sm-card summary::-webkit-details-marker {\n        display: none;\n      }\n      .sm-card summary::after {\n        content: \"+\";\n        align-self: center;\n        color: var(--text-dim);\n        font-size: 18px;\n        font-weight: 700;\n        line-height: 1;\n        transform: translateY(-0.08em);\n        transition: color 0.15s ease;\n      }\n      .sm-card summary:hover::after {\n        color: var(--text);\n      }\n      .sm-card[open] summary::after {\n        content: \"\\2212\";\n      }\n      .dia-scroll {\n        position: relative;\n        overflow: hidden;\n        background: var(--dia-bg);\n        height: 460px;\n        cursor: grab;\n        touch-action: none;\n      }\n      .dia-scroll.pz-dragging {\n        cursor: grabbing;\n      }\n      .dia-scroll .mflow {\n        position: absolute;\n        top: 0;\n        left: 0;\n        padding: 18px 16px;\n        transform-origin: 0 0;\n      }\n      .dia-scroll .mflow svg {\n        max-width: none;\n        height: auto;\n        display: block;\n      }\n      .pz-controls {\n        position: absolute;\n        right: 12px;\n        bottom: 12px;\n        display: flex;\n        gap: 6px;\n        z-index: 5;\n      }\n      .pz-btn {\n        width: 30px;\n        height: 30px;\n        border-radius: 8px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text-dim);\n        cursor: pointer;\n        font-size: 15px;\n        font-family: var(--mono);\n        display: grid;\n        place-items: center;\n        box-shadow: var(--shadow-sm);\n        padding: 0;\n      }\n      .pz-btn:hover {\n        color: var(--text);\n        border-color: var(--border-strong);\n      }\n      .pz-btn:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .dia-msg {\n        padding: 22px 18px;\n        font-size: 13.5px;\n        color: var(--text-dim);\n      }\n      .dia-msg code {\n        font-family: var(--mono);\n        font-size: 12px;\n        background: var(--surface-2);\n        padding: 1px 6px;\n        border-radius: 5px;\n      }\n      .dia-src {\n        margin: 10px 0 0;\n        padding: 12px 14px;\n        background: var(--surface-2);\n        border-radius: 9px;\n        font-family: var(--mono);\n        font-size: 11.5px;\n        white-space: pre;\n        overflow-x: auto;\n        color: var(--text-dim);\n        max-height: 260px;\n      }\n      .state-content {\n        max-height: 340px;\n        white-space: pre-wrap;\n        word-break: break-word;\n      }\n\n      /* sub-machines */\n      .sm-grid {\n        display: grid;\n        grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));\n        gap: 14px;\n        margin-top: 18px;\n      }\n      .sm-def {\n        border: 1.5px dashed var(--border-strong);\n        border-radius: var(--radius);\n        background: var(--surface);\n        box-shadow: var(--shadow-sm);\n        overflow: hidden;\n      }\n      .sm-def .h {\n        padding: 13px 16px;\n        border-bottom: 1px solid var(--border);\n        background: var(--surface-2);\n      }\n      .sm-def .h .nm {\n        font-family: var(--mono);\n        font-weight: 700;\n        font-size: 15px;\n      }\n      .sm-def .h .pm {\n        font-family: var(--mono);\n        font-size: 12px;\n        color: var(--text-dim);\n        display: block;\n        margin-top: 3px;\n      }\n      .sm-def .h .pm b {\n        color: var(--accent);\n      }\n      .sm-def .body {\n        padding: 12px 16px 16px;\n        display: flex;\n        flex-wrap: wrap;\n        gap: 6px;\n      }\n      .muted-note {\n        color: var(--text-faint);\n        font-style: italic;\n        margin-top: 16px;\n      }\n      .sm-def .h {\n        display: flex;\n        align-items: baseline;\n        justify-content: space-between;\n        gap: 8px;\n      }\n      .sm-def .h .goto-sm {\n        font: inherit;\n        font-family: var(--mono);\n        font-size: 11px;\n        color: var(--accent);\n        background: none;\n        border: none;\n        cursor: pointer;\n        text-decoration: underline;\n        padding: 0;\n      }\n\n      /* current-state panel */\n      .current-panel {\n        background: var(--surface);\n        border: 1px solid var(--border);\n        border-radius: var(--radius);\n        box-shadow: var(--shadow-sm);\n        padding: 18px 20px 20px;\n        margin: 16px 0 34px;\n      }\n      .cur-head {\n        display: flex;\n        align-items: center;\n        gap: 10px;\n        flex-wrap: wrap;\n        cursor: pointer;\n      }\n      .cur-name {\n        font-family: var(--mono);\n        font-weight: 700;\n        font-size: 18px;\n        letter-spacing: -0.01em;\n      }\n      .cur-none {\n        color: var(--text-faint);\n        font-style: italic;\n      }\n      .edge.cur-matched {\n        border-color: var(--accent);\n        background: var(--accent-soft);\n      }\n      .cur-tag {\n        font-family: var(--mono);\n        font-size: 10.5px;\n        font-weight: 700;\n        color: var(--accent);\n        background: var(--surface);\n        border: 1px solid var(--accent);\n        padding: 1px 7px;\n        border-radius: 999px;\n        margin-left: auto;\n      }\n\n      /* pending-changes readout in the current-state panel */\n      .pending-list {\n        display: flex;\n        flex-direction: column;\n        gap: 3px;\n        font-family: var(--mono);\n        font-size: 12.5px;\n        margin-bottom: 14px;\n      }\n      .pending-list .pc {\n        display: flex;\n        gap: 9px;\n      }\n      .pending-list .st {\n        font-weight: 700;\n        width: 1ch;\n        flex: none;\n      }\n      .pending-list .path {\n        color: var(--text-dim);\n        word-break: break-all;\n      }\n      .pending-clean {\n        color: var(--text-faint);\n        font-style: italic;\n        font-size: 12.5px;\n        margin-bottom: 14px;\n      }\n\n      /* mermaid black-box / ghost node labels (rendered inside the SVG via htmlLabels) */\n      .sm-hint {\n        display: block;\n        margin-top: 2px;\n        font-size: 10.5px;\n        opacity: 0.72;\n        font-weight: 500;\n      }\n\n      /* the current-state highlight ring on a rendered SVG node/group box */\n      g.node.gtd-current {\n        filter: drop-shadow(0 0 6px var(--accent));\n      }\n      g.node.gtd-current > rect,\n      g.node.gtd-current > polygon,\n      g.node.gtd-current > circle,\n      g.node.gtd-current > ellipse,\n      g.node.gtd-current > path.basic {\n        stroke: var(--accent) !important;\n        stroke-width: 3px !important;\n      }\n\n      /* toolbar */\n      .toolbar {\n        display: flex;\n        gap: 12px;\n        align-items: center;\n        margin: 18px 0 22px;\n        flex-wrap: wrap;\n      }\n      .search {\n        flex: 1;\n        min-width: 200px;\n        position: relative;\n      }\n      .search input {\n        width: 100%;\n        font-family: var(--mono);\n        font-size: 14px;\n        padding: 10px 12px 10px 34px;\n        border-radius: 10px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text);\n      }\n      .search input:focus {\n        outline: none;\n        border-color: var(--accent);\n        box-shadow: 0 0 0 3px var(--accent-soft);\n      }\n      .search svg {\n        position: absolute;\n        left: 11px;\n        top: 50%;\n        transform: translateY(-50%);\n        color: var(--text-faint);\n      }\n      .chips {\n        display: flex;\n        gap: 6px;\n        flex-wrap: wrap;\n      }\n      .chip-btn {\n        font: inherit;\n        font-size: 12.5px;\n        padding: 7px 12px;\n        border-radius: 999px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text-dim);\n        cursor: pointer;\n      }\n      .chip-btn:hover {\n        border-color: var(--border-strong);\n        color: var(--text);\n      }\n      .chip-btn.on {\n        background: var(--accent);\n        border-color: var(--accent);\n        color: #fff;\n      }\n      .chip-btn:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .legend {\n        display: flex;\n        gap: 8px;\n        flex-wrap: wrap;\n      }\n      .legend .li {\n        display: inline-flex;\n        align-items: center;\n        gap: 6px;\n        font-size: 12.5px;\n        color: var(--text-dim);\n        cursor: pointer;\n        user-select: none;\n        padding: 5px 9px;\n        border-radius: 999px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n      }\n      .legend .li:hover {\n        border-color: var(--border-strong);\n      }\n      .legend .li.off {\n        opacity: 0.4;\n      }\n      .legend .li:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .legend .li .dot {\n        width: 10px;\n        height: 10px;\n        border-radius: 3px;\n      }\n\n      /* groups + cards */\n      .group {\n        margin-bottom: 30px;\n      }\n      .group-head {\n        display: flex;\n        align-items: baseline;\n        gap: 10px;\n        margin: 0 0 12px;\n      }\n      .group-head h3 {\n        font-family: var(--mono);\n        font-size: 15px;\n        margin: 0;\n        letter-spacing: -0.01em;\n      }\n      .group-head .flow-tag {\n        font-family: var(--mono);\n        font-size: 11px;\n        padding: 2px 8px;\n        border-radius: 6px;\n        background: var(--surface-2);\n        color: var(--text-dim);\n        border: 1px solid var(--border);\n      }\n      .grid {\n        display: grid;\n        grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));\n        gap: 12px;\n      }\n      .card {\n        text-align: left;\n        font: inherit;\n        color: var(--text);\n        cursor: pointer;\n        background: var(--surface);\n        border: 1px solid var(--border);\n        border-left: 4px solid var(--card-accent, var(--border));\n        border-radius: 10px;\n        padding: 13px 15px;\n        box-shadow: var(--shadow-sm);\n        transition:\n          transform 0.12s ease,\n          box-shadow 0.12s ease,\n          border-color 0.12s ease;\n        position: relative;\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .card:hover {\n        transform: translateY(-2px);\n        box-shadow: var(--shadow);\n      }\n      .card:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .card[data-actor=\"human\"] {\n        --card-accent: var(--human-dot);\n      }\n      .card[data-actor=\"agent\"] {\n        --card-accent: var(--agent-dot);\n      }\n      .card[data-actor=\"check\"] {\n        --card-accent: var(--check-dot);\n      }\n      .card[data-actor=\"commit\"] {\n        --card-accent: var(--engine-dot);\n      }\n      .card[data-actor=\"unknown\"] {\n        --card-accent: var(--unknown-dot);\n      }\n      .card .name {\n        font-family: var(--mono);\n        font-weight: 700;\n        font-size: 14.5px;\n        letter-spacing: -0.01em;\n        word-break: break-word;\n      }\n      .card .row {\n        display: flex;\n        align-items: center;\n        gap: 6px;\n        flex-wrap: wrap;\n      }\n      .card .init-tick {\n        position: absolute;\n        top: 11px;\n        right: 12px;\n        font-size: 10px;\n        font-family: var(--mono);\n        color: var(--accent);\n        background: var(--accent-soft);\n        padding: 1px 6px;\n        border-radius: 5px;\n        font-weight: 700;\n      }\n\n      .pill {\n        display: inline-flex;\n        align-items: center;\n        gap: 5px;\n        font-family: var(--mono);\n        font-size: 11px;\n        font-weight: 600;\n        padding: 2px 8px;\n        border-radius: 999px;\n      }\n      .pill.actor-human {\n        background: var(--human-bg);\n        color: var(--human-fg);\n      }\n      .pill.actor-agent {\n        background: var(--agent-bg);\n        color: var(--agent-fg);\n      }\n      .pill.actor-check {\n        background: var(--check-bg);\n        color: var(--check-fg);\n      }\n      .pill.actor-engine {\n        background: var(--engine-bg);\n        color: var(--engine-fg);\n      }\n      .pill.actor-unknown {\n        background: var(--unknown-bg);\n        color: var(--unknown-fg);\n      }\n      .pill .dot {\n        width: 7px;\n        height: 7px;\n        border-radius: 2px;\n      }\n      .pill.actor-human .dot {\n        background: var(--human-dot);\n      }\n      .pill.actor-agent .dot {\n        background: var(--agent-dot);\n      }\n      .pill.actor-check .dot {\n        background: var(--check-dot);\n      }\n      .pill.actor-engine .dot {\n        background: var(--engine-dot);\n      }\n      .pill.actor-unknown .dot {\n        background: var(--unknown-dot);\n      }\n      .kind {\n        font-family: var(--mono);\n        font-size: 11px;\n        padding: 2px 7px;\n        border-radius: 6px;\n        border: 1px solid var(--border-strong);\n        color: var(--text-dim);\n        background: var(--surface-2);\n      }\n      .flag {\n        font-family: var(--mono);\n        font-size: 10.5px;\n        padding: 1px 6px;\n        border-radius: 5px;\n        background: var(--accent-soft);\n        color: var(--accent);\n        font-weight: 600;\n        border: 1px solid color-mix(in srgb, var(--accent) 25%, transparent);\n      }\n\n      /* drawer */\n      .backdrop {\n        position: fixed;\n        inset: 0;\n        background: rgba(10, 16, 28, 0.5);\n        backdrop-filter: blur(2px);\n        opacity: 0;\n        pointer-events: none;\n        transition: opacity 0.22s ease;\n        z-index: 90;\n      }\n      .backdrop.open {\n        opacity: 1;\n        pointer-events: auto;\n      }\n      .drawer {\n        position: fixed;\n        top: 0;\n        right: 0;\n        height: 100%;\n        width: min(560px, 100%);\n        background: var(--surface);\n        border-left: 1px solid var(--border);\n        box-shadow: var(--shadow);\n        transform: translateX(100%);\n        transition: transform 0.26s cubic-bezier(0.22, 0.61, 0.36, 1);\n        z-index: 100;\n        display: flex;\n        flex-direction: column;\n      }\n      .drawer.open {\n        transform: translateX(0);\n      }\n      .drawer-head {\n        padding: 18px 22px 14px;\n        border-bottom: 1px solid var(--border);\n        border-top: 4px solid var(--card-accent, var(--accent));\n      }\n      .drawer-head .top {\n        display: flex;\n        align-items: flex-start;\n        gap: 12px;\n      }\n      .drawer-head h3 {\n        font-family: var(--mono);\n        font-size: 20px;\n        font-weight: 700;\n        margin: 0;\n        letter-spacing: -0.02em;\n        word-break: break-word;\n      }\n      .drawer-head .meta-row {\n        display: flex;\n        gap: 6px;\n        flex-wrap: wrap;\n        margin-top: 10px;\n      }\n      .close-x {\n        margin-left: auto;\n        border: 1px solid var(--border);\n        background: var(--surface-2);\n        color: var(--text-dim);\n        border-radius: 8px;\n        width: 30px;\n        height: 30px;\n        cursor: pointer;\n        flex: none;\n        font-size: 15px;\n      }\n      .close-x:hover {\n        color: var(--text);\n      }\n      .close-x:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .drawer-body {\n        overflow-y: auto;\n        padding: 20px 22px 40px;\n        flex: 1;\n      }\n      .field {\n        margin-bottom: 18px;\n      }\n      .field > .k {\n        font-size: 11px;\n        text-transform: uppercase;\n        letter-spacing: 0.09em;\n        color: var(--text-faint);\n        font-weight: 700;\n        margin-bottom: 7px;\n      }\n      .kv {\n        display: grid;\n        grid-template-columns: 88px 1fr;\n        gap: 4px 14px;\n        font-size: 13.5px;\n      }\n      .kv dt {\n        color: var(--text-faint);\n        font-size: 12px;\n      }\n      .kv dd {\n        margin: 0;\n        font-family: var(--mono);\n        font-size: 12.5px;\n        word-break: break-word;\n      }\n      .none {\n        color: var(--text-faint);\n        font-style: italic;\n        font-family: var(--sans);\n      }\n\n      .edges {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .edge {\n        border: 1px solid var(--border);\n        border-radius: 9px;\n        padding: 10px 12px;\n        background: var(--surface-2);\n      }\n      .edge .er {\n        display: flex;\n        align-items: center;\n        gap: 8px;\n        flex-wrap: wrap;\n      }\n      .edge .pat {\n        font-family: var(--mono);\n        font-size: 12px;\n        font-weight: 700;\n        background: var(--surface);\n        border: 1px solid var(--border-strong);\n        padding: 2px 8px;\n        border-radius: 6px;\n        white-space: nowrap;\n      }\n      .edge .act {\n        font-size: 12.5px;\n        font-weight: 700;\n        color: var(--accent);\n      }\n      .edge .arr {\n        color: var(--text-faint);\n      }\n      .goto {\n        font: inherit;\n        font-family: var(--mono);\n        font-size: 12.5px;\n        font-weight: 700;\n        cursor: pointer;\n        border: 1px solid var(--card-accent, var(--accent));\n        background: transparent;\n        color: var(--card-accent, var(--accent));\n        padding: 2px 9px;\n        border-radius: 6px;\n      }\n      .goto:hover {\n        background: var(--card-accent, var(--accent));\n        color: #fff;\n      }\n      .goto:focus-visible {\n        outline: 2px solid var(--accent);\n        outline-offset: 2px;\n      }\n      .goto[data-actor=\"human\"] {\n        --card-accent: var(--human-dot);\n      }\n      .goto[data-actor=\"agent\"] {\n        --card-accent: var(--agent-dot);\n      }\n      .goto[data-actor=\"check\"] {\n        --card-accent: var(--check-dot);\n      }\n      .goto[data-actor=\"commit\"] {\n        --card-accent: var(--engine-dot);\n      }\n      .goto[data-actor=\"unknown\"] {\n        --card-accent: var(--unknown-dot);\n      }\n      .edge .em {\n        font-size: 12.5px;\n        color: var(--text-dim);\n        margin-top: 6px;\n        line-height: 1.45;\n      }\n      .incoming {\n        display: flex;\n        flex-wrap: wrap;\n        gap: 6px;\n      }\n\n      .flag-list {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .flag-item {\n        display: flex;\n        gap: 9px;\n        font-size: 13px;\n        align-items: baseline;\n      }\n      .flag-item .fn {\n        font-family: var(--mono);\n        font-size: 11.5px;\n        font-weight: 700;\n        color: var(--accent);\n        flex: none;\n        padding: 1px 6px;\n        border-radius: 5px;\n        background: var(--accent-soft);\n      }\n      .flag-item .fd {\n        color: var(--text-dim);\n      }\n\n      /* vars */\n      .vars-grid {\n        display: flex;\n        flex-wrap: wrap;\n        gap: 8px;\n        margin-top: 16px;\n      }\n      .var-chip {\n        font-family: var(--mono);\n        font-size: 12px;\n        padding: 6px 10px;\n        border-radius: 8px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        box-shadow: var(--shadow-sm);\n      }\n      .var-chip b {\n        color: var(--accent);\n      }\n\n      footer {\n        border-top: 1px solid var(--border);\n        margin-top: 56px;\n        padding: 40px 0 72px;\n        color: var(--text-faint);\n        font-size: 13px;\n      }\n      footer code {\n        font-family: var(--mono);\n        background: var(--surface-2);\n        padding: 1px 6px;\n        border-radius: 5px;\n      }\n      footer .foot-lead {\n        margin: 0 0 14px;\n        padding-top: 16px;\n        color: var(--text-dim);\n      }\n      footer .foot-legend {\n        display: flex;\n        align-items: center;\n        gap: 8px;\n        flex-wrap: wrap;\n        padding-bottom: 16px;\n      }\n      footer .foot-chip {\n        font-family: var(--mono);\n        font-size: 12px;\n        padding: 3px 9px;\n        border-radius: 7px;\n        border: 1px solid var(--border);\n        background: var(--surface);\n        color: var(--text-dim);\n      }\n\n      .hidden {\n        display: none !important;\n      }\n      @media (prefers-reduced-motion: reduce) {\n        *,\n        *::before,\n        *::after {\n          transition: none !important;\n          animation: none !important;\n        }\n      }\n      @media (max-width: 640px) {\n        .brand .sub {\n          display: none;\n        }\n        .kv {\n          grid-template-columns: 74px 1fr;\n        }\n      }\n    </style>\n  </head>\n  <body>\n    <header class=\"top\">\n      <div class=\"top-inner\">\n        <div class=\"brand\">\n          <span class=\"cmd\"><b>gtd</b> · workflow visualizer</span>\n          <span class=\"sub\" id=\"brandSub\">read-only view</span>\n        </div>\n        <div class=\"summary\" id=\"summary\"></div>\n        <button\n          class=\"theme-btn\"\n          id=\"themeBtn\"\n          title=\"Toggle light/dark theme\"\n          aria-label=\"Toggle light/dark theme\"\n        >\n          ◐\n        </button>\n      </div>\n    </header>\n\n    <main class=\"wrap\" id=\"app\">\n      <section class=\"hero\">\n        <h1 id=\"heroTitle\">Loading workflow…</h1>\n        <p class=\"lede\" id=\"heroLede\">\n          Fetching <code>/workflow.json</code> from the local\n          <span class=\"mono\">gtd visualize</span> server.\n        </p>\n      </section>\n\n      <div id=\"content\" class=\"hidden\">\n        <div class=\"sec-head\">\n          <h2>Current state</h2>\n          <span class=\"rule\"></span>\n        </div>\n        <div class=\"current-panel hidden\" id=\"currentPanel\"></div>\n        <div id=\"varsSection\"></div>\n\n        <div class=\"sec-head\">\n          <h2>Main flow</h2>\n          <span class=\"rule\"></span>\n        </div>\n        <p class=\"diagram-note\" id=\"diaNote\"></p>\n        <div class=\"dia-card\">\n          <div class=\"dia-scroll\" id=\"diaScroll\"><div class=\"dia-msg\">Rendering diagram…</div></div>\n        </div>\n\n        <div class=\"sec-head\">\n          <h2>Sub-machines</h2>\n          <span class=\"rule\"></span>\n        </div>\n        <div id=\"smSection\"></div>\n\n        <div class=\"sec-head\">\n          <h2>State catalogue</h2>\n          <span class=\"rule\"></span>\n        </div>\n        <div class=\"toolbar\">\n          <div class=\"search\">\n            <svg\n              width=\"15\"\n              height=\"15\"\n              viewBox=\"0 0 24 24\"\n              fill=\"none\"\n              stroke=\"currentColor\"\n              stroke-width=\"2.4\"\n            >\n              <circle cx=\"11\" cy=\"11\" r=\"7\" />\n              <path d=\"m21 21-4.3-4.3\" />\n            </svg>\n            <input\n              id=\"search\"\n              type=\"search\"\n              placeholder=\"filter by name, actor, kind, file, mode, flag…\"\n              autocomplete=\"off\"\n              spellcheck=\"false\"\n              aria-label=\"Filter states\"\n            />\n          </div>\n          <div class=\"chips\" id=\"kindChips\"></div>\n          <div class=\"legend\" id=\"legend\"></div>\n        </div>\n        <div id=\"groups\"></div>\n      </div>\n    </main>\n\n    <div class=\"backdrop\" id=\"backdrop\"></div>\n    <aside\n      class=\"drawer\"\n      id=\"drawer\"\n      role=\"dialog\"\n      aria-modal=\"true\"\n      aria-label=\"State detail\"\n      tabindex=\"-1\"\n    ></aside>\n\n    <footer class=\"wrap\" id=\"footer\"></footer>\n\n    <script type=\"module\">\n      // ── theme ──────────────────────────────────────────────────────────────\n      const root = document.documentElement\n      const prefersDark = () => matchMedia(\"(prefers-color-scheme: dark)\").matches\n      const isDark = () => {\n        const t = root.getAttribute(\"data-theme\")\n        return t ? t === \"dark\" : prefersDark()\n      }\n      document.getElementById(\"themeBtn\").onclick = () => {\n        const next = isDark() ? \"light\" : \"dark\"\n        root.setAttribute(\"data-theme\", next)\n        reinitializeAndRenderAll()\n      }\n      // Follow the OS when the user hasn't made an explicit choice — an\n      // explicit `data-theme` override always wins over an OS flip.\n      matchMedia(\"(prefers-color-scheme: dark)\").addEventListener(\"change\", () => {\n        if (!root.getAttribute(\"data-theme\")) reinitializeAndRenderAll()\n      })\n\n      const esc = (s) =>\n        String(s).replace(\n          /[&<>\"']/g,\n          (c) => ({ \"&\": \"&amp;\", \"<\": \"&lt;\", \">\": \"&gt;\", '\"': \"&quot;\", \"'\": \"&#39;\" })[c],\n        )\n\n      // Actor metadata: color class, css-var prefix, mermaid classDef name, label.\n      const ACTOR = {\n        human: { cls: \"actor-human\", dot: \"human\", label: \"human\" },\n        agent: { cls: \"actor-agent\", dot: \"agent\", label: \"agent\" },\n        check: { cls: \"actor-check\", dot: \"check\", label: \"check\" },\n        commit: { cls: \"actor-engine\", dot: \"engine\", label: \"commit\" },\n        unknown: { cls: \"actor-unknown\", dot: \"unknown\", label: \"?\" },\n      }\n      // A commit state has no actor — treat it as the engine/commit colour.\n      const actorOf = (s) => s.actor || (s.kind === \"commit\" ? \"commit\" : \"unknown\")\n      const meta = (a) => ACTOR[a] || ACTOR.unknown\n\n      const FLAGS = {\n        initial:\n          \"The one initial state — an unrecognized HEAD (any non-gtd history) resolves here.\",\n        reviewEntry:\n          \"This state is a dedicated CLI entry point (e.g. `gtd review <ref>`) that starts a brand-new process.\",\n        fixEntry:\n          \"This state is the `gtd fix` entry point — a red suite drops into the fixing loop, a green suite is a no-op.\",\n        reviewWindow:\n          \"While resting here, gtd opens the review checkout window: HEAD is rewound to the review base so the whole diff surfaces as ordinary uncommitted changes.\",\n        reviewBase:\n          \"Anchors the incremental review diff base — its most-recent in-process commit is where the next reviewing turn and checkout window start.\",\n        answerGate:\n          \"Edge gate: a step is refused while any open question in the steering file is not answered with exactly one tick.\",\n        requireProgress:\n          \"Edge gate: refuses a work-free turn that only deletes the instructions file (unless it held a NOTHING ACTIONABLE sentinel).\",\n      }\n\n      // ── state ──────────────────────────────────────────────────────────────\n      let MODEL = null\n      let STATES = []\n      let byName = {}\n      let CURRENT = null\n      let lastCurrentSig = undefined\n      let mermaidMod = null\n\n      // Fetches `/state.json`, updates `CURRENT`, and reports whether the\n      // resolved body actually changed since the last call (compared on the\n      // full JSON so an edge's `matched` flag flipping counts as a change too).\n      async function refreshCurrent() {\n        let next = null\n        try {\n          const res = await fetch(\"/state.json\")\n          const body = res.ok ? await res.json() : {}\n          next = body && body.state ? body : null\n        } catch (e) {\n          next = null\n        }\n        const sig = JSON.stringify(next)\n        if (sig === lastCurrentSig) return false\n        lastCurrentSig = sig\n        CURRENT = next\n        return true\n      }\n\n      const actorFilter = new Set([\"human\", \"agent\", \"check\", \"commit\", \"unknown\"])\n      let kindFilter = \"all\"\n\n      // ── boot ─────────────────────────────────────────────────────────────\n      try {\n        const res = await fetch(\"/workflow.json\")\n        if (!res.ok) throw new Error(\"HTTP \" + res.status)\n        MODEL = await res.json()\n      } catch (e) {\n        document.getElementById(\"heroTitle\").textContent = \"Could not load workflow\"\n        document.getElementById(\"heroLede\").innerHTML =\n          \"Fetching <code>/workflow.json</code> failed: \" +\n          esc(e.message) +\n          '. This page must be served by <span class=\"mono\">gtd visualize</span>.'\n        throw e\n      }\n\n      // Resolved at page load, then re-polled every 3s (see `poll()` below) so\n      // advancing the process shows up without a manual refresh. Tolerates a\n      // 404/error (an older server) or an empty `{}` (no active process/not a repo).\n      await refreshCurrent()\n\n      STATES = MODEL.states || []\n      byName = Object.fromEntries(STATES.map((s) => [s.name, s]))\n\n      // ── header summary + hero ───────────────────────────────────────────\n      const counts = { human: 0, agent: 0, check: 0, commit: 0, unknown: 0 }\n      STATES.forEach((s) => {\n        counts[actorOf(s)]++\n      })\n      const nGroups = (MODEL.groups || []).length\n      const cnt = (a) =>\n        counts[a] ? `<span><span class=\"s-num\">${counts[a]}</span> ${meta(a).label}</span>` : \"\"\n      document.getElementById(\"summary\").innerHTML = [\n        `<span><span class=\"s-num\">${STATES.length}</span> states</span>`,\n        `<span><span class=\"s-num\">${nGroups}</span> sub-machine${nGroups === 1 ? \"\" : \"s\"}</span>`,\n        `<span class=\"sep\">·</span>`,\n        cnt(\"human\"),\n        cnt(\"agent\"),\n        cnt(\"check\"),\n        cnt(\"commit\"),\n        cnt(\"unknown\"),\n      ]\n        .filter(Boolean)\n        .join(\" \")\n\n      document.getElementById(\"heroTitle\").innerHTML = `GTD workflow visualization`\n      document.getElementById(\"heroLede\").innerHTML =\n        `Rendered live from your workflow. The initial state is ` +\n        `<code>${esc(MODEL.initial)}</code>. Click any state — in the diagram, a sub-machine chip, ` +\n        `or the catalogue — to open its full definition, walk its outgoing edges, and see what routes into it.`\n      document.getElementById(\"content\").classList.remove(\"hidden\")\n\n      document.getElementById(\"footer\").innerHTML =\n        `<p class=\"foot-lead\">Read-only view served by <code>gtd visualize</code>.</p>` +\n        `<div class=\"foot-legend\">` +\n        `<span class=\"foot-chip\">([message])</span>` +\n        `<span class=\"foot-chip\">[prompt]</span>` +\n        `<span class=\"foot-chip\">{{script}}</span>` +\n        `<span class=\"foot-chip\">[[commit]]</span>` +\n        `<span>— node shape = content kind; colour = actor.</span>` +\n        `</div>`\n\n      // ── pill helper ────────────────────────────────────────────────────\n      const pill = (a) =>\n        `<span class=\"pill ${meta(a).cls}\"><span class=\"dot\"></span>${meta(a).label}</span>`\n\n      // ── mermaid source generation ──────────────────────────────────────\n      // Safe, stable node ids (state names can contain hyphens etc.), with a\n      // reverse lookup — needed to map a rendered SVG node's id back to its\n      // state name when wiring clicks (see `nodeIdOf`/`wire*Clicks` below).\n      const idFor = (() => {\n        const map = new Map()\n        const rev = new Map()\n        const fn = (name) => {\n          if (!map.has(name)) {\n            const id = \"n\" + map.size\n            map.set(name, id)\n            rev.set(id, name)\n          }\n          return map.get(name)\n        }\n        fn.nameOf = (id) => rev.get(id)\n        return fn\n      })()\n      const groupBoxId = (i) => \"g\" + i\n      const groupIndexOf = (name) => (MODEL.groups || []).findIndex((g) => g.name === name)\n      const shapeFor = (kind, label) => {\n        const l = `\"${label.replace(/\"/g, \"&quot;\")}\"`\n        switch (kind) {\n          case \"message\":\n            return `([\"${label.replace(/\"/g, \"&quot;\")}\"])`\n          case \"prompt\":\n            return `[${l}]`\n          case \"script\":\n            return `{{${l}}}`\n          case \"commit\":\n            return `[[${l}]]`\n          default:\n            return `[${l}]`\n        }\n      }\n      const mlabel = (s) => `\"${String(s).replace(/\"/g, \"&quot;\").replace(/\\|/g, \"&#124;\")}\"`\n      /**\n       * The mermaid `classDef` lines for actor/ghost node fills, chosen per\n       * theme so dark mode doesn't render washed-out light pastels.\n       */\n      function classDefs(dark) {\n        return [\n          dark\n            ? \"classDef human fill:#3a2e12,stroke:#e0a83e,color:#f0c674;\"\n            : \"classDef human fill:#fbeccd,stroke:#d99413,color:#5a3d0a;\",\n          dark\n            ? \"classDef agent fill:#26224a,stroke:#8b7cf0,color:#b6abf7;\"\n            : \"classDef agent fill:#e5e2fb,stroke:#6d5ce0,color:#3a2c85;\",\n          dark\n            ? \"classDef check fill:#123433,stroke:#2dc4bc,color:#68dcd4;\"\n            : \"classDef check fill:#d3f0ef,stroke:#16a39d,color:#0c524f;\",\n          dark\n            ? \"classDef commit fill:#3a1b24,stroke:#e05f7c,color:#f2a3b3;\"\n            : \"classDef commit fill:#fbdfe4,stroke:#d84a68,color:#8a1f38;\",\n          dark\n            ? \"classDef unknown fill:#1c2434,stroke:#3a465c,color:#9aa6bd,stroke-dasharray:4 3;\"\n            : \"classDef unknown fill:#eef1f7,stroke:#c2ccdb,color:#55607a,stroke-dasharray:4 3;\",\n          // Sub-machine invocation: a muted slate box (not one of the actor\n          // colours) so it still reads as its own distinct \"black-box\" kind,\n          // without the harsh opaque-black fill clashing with a light theme.\n          dark\n            ? \"classDef submachine fill:#2a3142,stroke:#5a6b8c,color:#dbe4f5,font-weight:700;\"\n            : \"classDef submachine fill:#e4e9f2,stroke:#8695b3,color:#2a3142,font-weight:700;\",\n          // A muted, dashed ghost node standing in for a target OUTSIDE the\n          // current diagram (a sub-machine diagram's external edge).\n          dark\n            ? \"classDef external fill:#1c2434,stroke:#3a465c,color:#9aa6bd,stroke-dasharray:5 4;\"\n            : \"classDef external fill:#eef1f7,stroke:#c2ccdb,color:#55607a,stroke-dasharray:5 4;\",\n        ]\n      }\n\n      /**\n       * Build one flowchart's mermaid source over `states` (a diagram scope):\n       * the whole machine for the main flow (`opts.scope` unset), or one\n       * sub-machine's own member states (`opts.scope` = that group's name).\n       * A member state whose innermost group differs from `opts.scope`\n       * collapses into a black box for ITS group (handles a sub-machine\n       * nested inside another); a target outside `states` entirely renders as\n       * a muted, dashed ghost node instead (only possible in a sub-machine\n       * diagram — the main flow's `states` is every state, so nothing is ever\n       * \"outside\" it).\n       */\n      function buildFlowSrc(states, opts) {\n        const scope = opts && opts.scope\n        const inSet = new Set(states.map((s) => s.name))\n        const lines = [\"flowchart TD\"]\n\n        const unitOf = (name) => {\n          const s = byName[name]\n          if (s && s.group && s.group !== scope) return { kind: \"box\", group: s.group }\n          return { kind: \"node\", name }\n        }\n        const unitId = (name) => {\n          const u = unitOf(name)\n          return u.kind === \"box\" ? groupBoxId(groupIndexOf(u.group)) : idFor(name)\n        }\n\n        const emittedNodes = new Set()\n        const emittedBoxes = new Set()\n        const emittedGhosts = new Set()\n        const nodeLine = (s) => `  ${idFor(s.name)}${shapeFor(s.kind, s.name)}:::${actorOf(s)}`\n        const boxLine = (g, i) =>\n          `  ${groupBoxId(i)}[\"${esc(g.name)}<br/><span class='sm-hint'>▸ ${g.states.length} state${\n            g.states.length === 1 ? \"\" : \"s\"\n          }</span>\"]:::submachine`\n        const ghostLine = (s) => `  e${idFor(s.name)}${shapeFor(s.kind, s.name)}:::external`\n\n        states.forEach((s) => {\n          const u = unitOf(s.name)\n          if (u.kind === \"node\") {\n            if (emittedNodes.has(s.name)) return\n            emittedNodes.add(s.name)\n            lines.push(nodeLine(s))\n          } else if (!emittedBoxes.has(u.group)) {\n            emittedBoxes.add(u.group)\n            const i = groupIndexOf(u.group)\n            if (i >= 0) lines.push(boxLine(MODEL.groups[i], i))\n          }\n        })\n\n        // Edges within this diagram's own state set, collapsed through box\n        // units, deduped, and label-dropped when several patterns land on the\n        // same box-level edge (a black box hides which one specifically).\n        const solid = new Map()\n        const dashed = new Map()\n        const addEdge = (map, from, to, label) => {\n          if (from === to) return\n          const key = from + \" \" + to\n          if (!map.has(key)) map.set(key, [])\n          map.get(key).push(label)\n        }\n        states.forEach((s) => {\n          ;(s.on || []).forEach((e) => {\n            if (!inSet.has(e.to) || !byName[e.to]) return\n            addEdge(solid, unitId(s.name), unitId(e.to), e.action || e.pattern)\n          })\n          if (s.retry && inSet.has(s.retry.otherwise)) {\n            addEdge(dashed, unitId(s.name), unitId(s.retry.otherwise), \"retry ×\" + s.retry.max)\n          }\n        })\n        // Ghost edges to a target entirely outside this diagram's state set\n        // (only fires for a sub-machine diagram — the main flow's set is\n        // every state, so nothing is ever \"outside\" it).\n        states.forEach((s) => {\n          ;(s.on || []).forEach((e) => {\n            if (inSet.has(e.to) || !byName[e.to]) return\n            const target = byName[e.to]\n            if (!emittedGhosts.has(e.to)) {\n              emittedGhosts.add(e.to)\n              lines.push(ghostLine(target))\n            }\n            lines.push(`  ${idFor(s.name)} -->|${mlabel(e.action || e.pattern)}| e${idFor(e.to)}`)\n          })\n          if (s.retry && byName[s.retry.otherwise] && !inSet.has(s.retry.otherwise)) {\n            const target = byName[s.retry.otherwise]\n            if (!emittedGhosts.has(s.retry.otherwise)) {\n              emittedGhosts.add(s.retry.otherwise)\n              lines.push(ghostLine(target))\n            }\n            lines.push(\n              `  ${idFor(s.name)} -.->|${mlabel(\"retry ×\" + s.retry.max)}| e${idFor(s.retry.otherwise)}`,\n            )\n          }\n        })\n\n        solid.forEach((labels, key) => {\n          const [from, to] = key.split(\" \")\n          const label = labels.length === 1 ? mlabel(labels[0]) : null\n          lines.push(`  ${from} -->${label ? \"|\" + label + \"|\" : \"\"} ${to}`)\n        })\n        dashed.forEach((labels, key) => {\n          const [from, to] = key.split(\" \")\n          const label = labels.length === 1 ? mlabel(labels[0]) : null\n          lines.push(`  ${from} -.->${label ? \"|\" + label + \"|\" : \"\"} ${to}`)\n        })\n\n        lines.push(...classDefs(isDark()))\n        return lines.join(\"\\n\")\n      }\n\n      document.getElementById(\"diaNote\").innerHTML =\n        `Every state as a node — shape is the content kind, colour is the actor. Each edge is an ` +\n        `<span class=\"mono\">on</span> pattern (first match wins); dashed edges are ` +\n        `<span class=\"mono\">retry</span> redirects. A sub-machine invocation collapses into a single ` +\n        `dark box (click it to jump to its own diagram below); an edge label is dropped when several ` +\n        `patterns collapse onto the same box-to-box edge. Scroll/pinch or drag to pan and zoom; use the ` +\n        `<span class=\"mono\">+</span>/<span class=\"mono\">−</span>/<span class=\"mono\">⤢</span> controls in the corner.`\n\n      // ── diagram render (theme-aware, offline-tolerant) ─────────────────\n      async function loadMermaid() {\n        if (mermaidMod) return mermaidMod\n        const m = await import(\"https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs\")\n        mermaidMod = m.default\n        return mermaidMod\n      }\n\n      const renderSeqByBase = new Map()\n      const nextSeq = (base) => {\n        const n = (renderSeqByBase.get(base) || 0) + 1\n        renderSeqByBase.set(base, n)\n        return n\n      }\n\n      /** Render `src` into `host` via mermaid, guarding against a stale (superseded) render; falls back to a readable error + raw source on failure. Returns the mermaid render id used (so the caller can wire clicks/highlight against ITS OWN node ids), or `null` if nothing rendered. */\n      async function renderInto(host, src, renderIdBase) {\n        const seq = nextSeq(renderIdBase)\n        let mermaid\n        try {\n          mermaid = await loadMermaid()\n        } catch (e) {\n          host.innerHTML =\n            `<div class=\"dia-msg\">Could not load the Mermaid renderer (offline?). ` +\n            `The workflow is still fully browsable below. Diagram source:` +\n            `<pre class=\"dia-src\">${esc(src)}</pre></div>`\n          return null\n        }\n        if (seq !== renderSeqByBase.get(renderIdBase)) return null\n        const renderId = renderIdBase + seq\n        try {\n          const { svg } = await mermaid.render(renderId, src)\n          if (seq !== renderSeqByBase.get(renderIdBase)) return null\n          host.innerHTML = `<div class=\"mflow\">${svg}</div>`\n          return renderId\n        } catch (e) {\n          host.innerHTML =\n            `<div class=\"dia-msg\">Diagram render failed: ${esc(e.message)}. ` +\n            `Diagram source:<pre class=\"dia-src\">${esc(src)}</pre></div>`\n          return null\n        }\n      }\n\n      // Every live diagram (main + one per sub-machine) — re-rendered as a\n      // group on every theme toggle (replaces the old single DIAGRAM_SRC).\n      // `build` is a thunk (not a fixed string) because the diagram source\n      // embeds theme-dependent classDefs — it must be re-emitted fresh on\n      // every re-render, not cached from first render.\n      const diagrams = []\n      function registerDiagram(host, build, renderIdBase, onRendered, highlight) {\n        diagrams.push({ host, build, renderIdBase, onRendered, highlight, lastRenderId: null })\n      }\n      async function renderAllDiagrams() {\n        for (const d of diagrams) {\n          const renderId = await renderInto(d.host, d.build(), d.renderIdBase)\n          if (renderId) d.lastRenderId = renderId\n          if (renderId && d.onRendered) d.onRendered(renderId, d.host)\n        }\n      }\n      async function reinitializeAndRenderAll() {\n        const mermaid = await loadMermaid().catch(() => null)\n        if (mermaid) {\n          const dark = isDark()\n          mermaid.initialize({\n            startOnLoad: false,\n            theme: \"base\",\n            securityLevel: \"strict\",\n            flowchart: { useMaxWidth: false, htmlLabels: true },\n            themeVariables: {\n              fontFamily: \"ui-monospace, Menlo, monospace\",\n              fontSize: \"12.5px\",\n              lineColor: dark ? \"#6b7690\" : \"#8a93a6\",\n              primaryBorderColor: dark ? \"#3a465c\" : \"#c2ccdb\",\n              tertiaryColor: dark ? \"#1c2434\" : \"#f0f3f8\",\n              mainBkg: dark ? \"#232c3e\" : \"#ffffff\",\n              clusterBkg: dark ? \"#1c2434\" : \"#f0f3f8\",\n              clusterBorder: dark ? \"#3a465c\" : \"#c2ccdb\",\n              titleColor: dark ? \"#e6ebf4\" : \"#1a2233\",\n              nodeTextColor: dark ? \"#e6ebf4\" : \"#1a2233\",\n              textColor: dark ? \"#e6ebf4\" : \"#1a2233\",\n              edgeLabelBackground: dark ? \"#161d2b\" : \"#f4f6fa\",\n            },\n          })\n        }\n        await renderAllDiagrams()\n      }\n\n      // ── click wiring + current-state highlight (post-render — mermaid's own\n      // `click` callbacks are disabled by securityLevel:\"strict\") ──────────\n      // A rendered node group's `id` is `${renderId}-flowchart-${ourNodeId}-<n>`\n      // (verified against mermaid@11's actual output) — strip that wrapper to\n      // recover the id we generated the diagram with.\n      function nodeIdOf(el, renderId) {\n        const prefix = renderId + \"-flowchart-\"\n        if (!el.id || !el.id.startsWith(prefix)) return null\n        const m = /^(.+)-\\d+$/.exec(el.id.slice(prefix.length))\n        return m ? m[1] : null\n      }\n      const nodeGroupsOf = (host) => [...host.querySelectorAll(\"g.node\")]\n\n      function scrollToSubmachine(i) {\n        const el = document.getElementById(\"sm-\" + i)\n        if (!el) return\n        el.open = true\n        el.scrollIntoView({ behavior: \"smooth\", block: \"start\" })\n      }\n      function navigateTo(name) {\n        const s = byName[name]\n        if (s && s.group) {\n          const gi = groupIndexOf(s.group)\n          if (gi >= 0) return scrollToSubmachine(gi)\n        }\n        openDrawer(name)\n      }\n\n      function applyCurrentHighlight(renderId, host, mode, gi) {\n        if (!CURRENT || !CURRENT.state) return\n        const wantId =\n          mode === \"main\"\n            ? CURRENT.group\n              ? groupBoxId(groupIndexOf(CURRENT.group))\n              : idFor(CURRENT.state)\n            : CURRENT.group === MODEL.groups[gi].name\n              ? idFor(CURRENT.state)\n              : null\n        if (wantId === null) return\n        nodeGroupsOf(host).forEach((el) => {\n          if (nodeIdOf(el, renderId) === wantId) el.classList.add(\"gtd-current\")\n        })\n      }\n\n      // Re-applies the current-state highlight to every already-rendered\n      // diagram, without re-running mermaid — used by the poll loop below.\n      function repaintHighlights() {\n        for (const d of diagrams) {\n          nodeGroupsOf(d.host).forEach((el) => el.classList.remove(\"gtd-current\"))\n          if (d.lastRenderId && d.highlight) {\n            applyCurrentHighlight(d.lastRenderId, d.host, d.highlight.mode, d.highlight.gi)\n          }\n        }\n      }\n\n      function wireMainDiagramClicks(renderId, host) {\n        nodeGroupsOf(host).forEach((el) => {\n          const rawId = nodeIdOf(el, renderId)\n          if (!rawId) return\n          el.classList.add(\"clickable\")\n          el.style.cursor = \"pointer\"\n          if (rawId[0] === \"g\") {\n            el.onclick = () => scrollToSubmachine(Number(rawId.slice(1)))\n          } else {\n            const name = idFor.nameOf(rawId)\n            if (name) el.onclick = () => openDrawer(name)\n          }\n        })\n        applyCurrentHighlight(renderId, host, \"main\")\n        attachPanZoom(host)\n      }\n\n      function wireSubmachineDiagramClicks(renderId, host, gi) {\n        nodeGroupsOf(host).forEach((el) => {\n          const rawId = nodeIdOf(el, renderId)\n          if (!rawId) return\n          el.classList.add(\"clickable\")\n          el.style.cursor = \"pointer\"\n          if (rawId[0] === \"g\") {\n            el.onclick = () => scrollToSubmachine(Number(rawId.slice(1)))\n          } else if (rawId[0] === \"e\") {\n            const name = idFor.nameOf(rawId.slice(1))\n            if (name) el.onclick = () => navigateTo(name)\n          } else {\n            const name = idFor.nameOf(rawId)\n            if (name) el.onclick = () => openDrawer(name)\n          }\n        })\n        applyCurrentHighlight(renderId, host, \"submachine\", gi)\n        attachPanZoom(host)\n      }\n\n      // ── diagram pan & zoom (hand-rolled — no pan-zoom dependency, see plan) ──\n      // `host` is a `.dia-scroll` element whose content mermaid just replaced\n      // wholesale (`renderInto`'s `host.innerHTML = ...`), so old listeners on\n      // its previous children are already gone — this re-creates the control\n      // cluster and re-attaches fresh listeners on every render, never\n      // accumulating stale ones.\n      const REDUCED_MOTION = matchMedia(\"(prefers-reduced-motion: reduce)\").matches\n      const clampScale = (s) => Math.min(3, Math.max(0.4, s))\n\n      function attachPanZoom(host) {\n        const flow = host.querySelector(\".mflow\")\n        const svg = flow && flow.querySelector(\"svg\")\n        if (!flow || !svg) return\n\n        const controls = document.createElement(\"div\")\n        controls.className = \"pz-controls\"\n        controls.innerHTML =\n          `<button class=\"pz-btn\" data-act=\"in\" title=\"Zoom in\" aria-label=\"Zoom in\">+</button>` +\n          `<button class=\"pz-btn\" data-act=\"out\" title=\"Zoom out\" aria-label=\"Zoom out\">−</button>` +\n          `<button class=\"pz-btn\" data-act=\"fit\" title=\"Fit to width\" aria-label=\"Fit to width\">⤢</button>`\n        host.appendChild(controls)\n\n        const box = svg.getBBox ? svg.getBBox() : { width: 0, height: 0 }\n        const naturalWidth = box.width || svg.clientWidth || 1\n        const naturalHeight = box.height || svg.clientHeight || 1\n\n        const state = { scale: 1, tx: 0, ty: 0 }\n        const apply = () => {\n          flow.style.transform = `translate(${state.tx}px, ${state.ty}px) scale(${state.scale})`\n        }\n        // Fit-to-width, capped at 1× so a small workflow renders at its\n        // natural size (the pre-pan/zoom default) instead of being blown up.\n        const fit = () => {\n          const r = host.getBoundingClientRect()\n          state.scale = clampScale(Math.min(1, Math.max(r.width - 32, 40) / naturalWidth))\n          state.tx = (r.width - naturalWidth * state.scale) / 2\n          state.ty = (r.height - naturalHeight * state.scale) / 2\n          apply()\n        }\n        const zoomBy = (factor, cx, cy) => {\n          const r = host.getBoundingClientRect()\n          const px = cx == null ? r.width / 2 : cx\n          const py = cy == null ? r.height / 2 : cy\n          const next = clampScale(state.scale * factor)\n          const ratio = next / state.scale\n          state.tx = px - (px - state.tx) * ratio\n          state.ty = py - (py - state.ty) * ratio\n          state.scale = next\n          apply()\n        }\n        // Animate only a button-triggered zoom/fit (an explicit, discrete\n        // action) — wheel/drag stay instant so the transform tracks the\n        // cursor/finger with no lag. Skipped entirely under\n        // prefers-reduced-motion.\n        const animated = (fn) => {\n          if (REDUCED_MOTION) return fn()\n          flow.style.transition = \"transform 0.18s ease\"\n          fn()\n          flow.addEventListener(\"transitionend\", () => (flow.style.transition = \"\"), {\n            once: true,\n          })\n        }\n        fit()\n\n        host.addEventListener(\n          \"wheel\",\n          (e) => {\n            e.preventDefault()\n            flow.style.transition = \"none\"\n            const r = host.getBoundingClientRect()\n            zoomBy(e.deltaY < 0 ? 1.12 : 1 / 1.12, e.clientX - r.left, e.clientY - r.top)\n          },\n          { passive: false },\n        )\n\n        // Drag-to-pan: a small movement threshold before a pointerdown counts\n        // as a drag (rather than a click), and — once it does — the resulting\n        // synthetic `click` is swallowed so dragging over a node never opens\n        // its drawer. Pointer capture is deferred until that threshold is\n        // actually crossed: a captured pointer retargets its WHOLE mouse-event\n        // sequence (including the eventual `click`) to `host`, so capturing\n        // eagerly on every pointerdown would silently break a plain click on\n        // any node (or the zoom/fit buttons) — not just an actual drag.\n        let drag = null\n        host.addEventListener(\"pointerdown\", (e) => {\n          if (e.button !== 0 || e.target.closest(\".pz-controls\")) return\n          drag = { x: e.clientX, y: e.clientY, tx: state.tx, ty: state.ty, moved: false }\n          flow.style.transition = \"none\"\n        })\n        host.addEventListener(\"pointermove\", (e) => {\n          if (!drag) return\n          const dx = e.clientX - drag.x\n          const dy = e.clientY - drag.y\n          if (!drag.moved && Math.hypot(dx, dy) > 4) {\n            drag.moved = true\n            host.classList.add(\"pz-dragging\")\n            host.setPointerCapture(e.pointerId)\n          }\n          if (drag.moved) {\n            state.tx = drag.tx + dx\n            state.ty = drag.ty + dy\n            apply()\n          }\n        })\n        const endDrag = () => {\n          if (!drag) return\n          if (drag.moved) {\n            host.classList.remove(\"pz-dragging\")\n            host.addEventListener(\n              \"click\",\n              (ev) => {\n                ev.stopPropagation()\n                ev.preventDefault()\n              },\n              { capture: true, once: true },\n            )\n          }\n          drag = null\n        }\n        host.addEventListener(\"pointerup\", endDrag)\n        host.addEventListener(\"pointercancel\", endDrag)\n\n        controls.querySelector('[data-act=\"in\"]').onclick = (e) => {\n          e.stopPropagation()\n          animated(() => zoomBy(1.25))\n        }\n        controls.querySelector('[data-act=\"out\"]').onclick = (e) => {\n          e.stopPropagation()\n          animated(() => zoomBy(1 / 1.25))\n        }\n        controls.querySelector('[data-act=\"fit\"]').onclick = (e) => {\n          e.stopPropagation()\n          animated(fit)\n        }\n\n        // Exposed so a collapsed sub-machine `<details>` panel can re-fit once\n        // it's actually opened (its content renders at zero width while hidden).\n        host.__pz = { fit, zoomBy }\n      }\n\n      // ── main flow ────────────────────────────────────────────────────────\n      registerDiagram(\n        document.getElementById(\"diaScroll\"),\n        () => buildFlowSrc(STATES, {}),\n        \"gtdmain\",\n        wireMainDiagramClicks,\n        { mode: \"main\" },\n      )\n\n      // ── sub-machines panel — one real mermaid diagram per invocation ─────\n      ;(function renderSubmachines() {\n        const el = document.getElementById(\"smSection\")\n        const groups = MODEL.groups || []\n        if (!groups.length) {\n          el.innerHTML = `<p class=\"muted-note\">This workflow declares no sub-machines.</p>`\n          return\n        }\n        el.innerHTML = \"\"\n        groups.forEach((g, i) => {\n          const card = document.createElement(\"details\")\n          card.className = \"dia-card sm-card\"\n          card.id = \"sm-\" + i\n          card.style.marginBottom = \"16px\"\n          if (CURRENT && CURRENT.group === g.name) card.open = true\n          card.innerHTML =\n            `<summary class=\"h\"><span class=\"nm\">${esc(g.name)} · instantiates <b>${esc(g.submachine)}</b></span></summary>` +\n            `<div class=\"dia-scroll\" id=\"smDia${i}\"><div class=\"dia-msg\">Rendering diagram…</div></div>`\n          el.appendChild(card)\n\n          const members = (g.states || []).map((n) => byName[n]).filter(Boolean)\n          registerDiagram(\n            card.querySelector(`#smDia${i}`),\n            () => buildFlowSrc(members, { scope: g.name }),\n            \"gtdsm\" + i + \"-\",\n            (renderId, host) => wireSubmachineDiagramClicks(renderId, host, i),\n            { mode: \"submachine\", gi: i },\n          )\n          // A collapsed <details> renders its content at zero width, so the\n          // pan/zoom \"fit\" computed while hidden is wrong — recompute it once\n          // the panel is actually opened.\n          card.addEventListener(\"toggle\", () => {\n            if (!card.open) return\n            const host = card.querySelector(`#smDia${i}`)\n            if (host && host.__pz) host.__pz.fit()\n          })\n        })\n      })()\n\n      // ── vars ─────────────────────────────────────────────────────────────\n      ;(function renderVars() {\n        const vars = MODEL.vars || {}\n        const keys = Object.keys(vars)\n        if (!keys.length) return\n        const el = document.getElementById(\"varsSection\")\n        el.innerHTML =\n          `<div class=\"sec-head\"><h2>Workflow variables</h2><span class=\"rule\"></span></div>` +\n          `<div class=\"vars-grid\">${keys\n            .map((k) => `<span class=\"var-chip\"><b>${esc(k)}</b> = ${esc(vars[k])}</span>`)\n            .join(\"\")}</div>`\n      })()\n\n      // ── current-state panel ─────────────────────────────────────────────\n      // Status-letter colour reuses existing actor tokens rather than adding new\n      // theme variables: A (added) reads as the check colour, M (modified) as\n      // the accent, D (deleted) as the engine/commit colour.\n      const PENDING_STATUS_COLOR = {\n        A: \"var(--check-fg)\",\n        M: \"var(--accent)\",\n        D: \"var(--engine-fg)\",\n      }\n      function pendingListHtml(pending) {\n        if (!pending || !pending.length) {\n          return `<p class=\"pending-clean\">working tree clean</p>`\n        }\n        return (\n          `<div class=\"pending-list\">` +\n          pending\n            .map(\n              (c) =>\n                `<div class=\"pc\"><span class=\"st\" style=\"color:${PENDING_STATUS_COLOR[c.status] || \"var(--text-dim)\"}\">${esc(c.status)}</span><span class=\"path\">${esc(c.path)}</span></div>`,\n            )\n            .join(\"\") +\n          `</div>`\n        )\n      }\n      function renderCurrentPanel() {\n        const panel = document.getElementById(\"currentPanel\")\n        if (!CURRENT || !CURRENT.state) {\n          panel.classList.add(\"hidden\")\n          return\n        }\n        panel.classList.remove(\"hidden\")\n        const a = CURRENT.actor\n        const edgeRow = (pattern, to, matched, retryOf, action) => {\n          const t = byName[to]\n          return (\n            `<div class=\"edge${matched ? \" cur-matched\" : \"\"}\"><div class=\"er\">` +\n            `${action ? `<span class=\"act\">${esc(action)}</span>` : \"\"}` +\n            `<span class=\"pat\">${retryOf ? \"after \" + esc(retryOf) + \" tries\" : \"if \" + esc(pattern)}</span>` +\n            `<span class=\"arr\">→</span>` +\n            `<button class=\"goto\" data-actor=\"${t ? actorOf(t) : \"unknown\"}\" data-to=\"${esc(to)}\">${esc(to)}</button>` +\n            `${matched ? '<span class=\"cur-tag\">current match</span>' : \"\"}</div></div>`\n          )\n        }\n        const rows = (CURRENT.edges || [])\n          .map((e) => edgeRow(e.pattern, e.to, e.matched, undefined, e.action))\n          .join(\"\")\n        const retryRow = CURRENT.retry\n          ? edgeRow(null, CURRENT.retry.otherwise, false, CURRENT.retry.max, undefined)\n          : \"\"\n        panel.innerHTML =\n          `<div class=\"cur-head\"><span class=\"cur-name\">${esc(CURRENT.state)}</span>` +\n          `${pill(a)}<span class=\"kind\">${esc(CURRENT.kind)}</span>` +\n          `${CURRENT.group ? `<span class=\"flow-tag\">${esc(CURRENT.group)}</span>` : \"\"}</div>` +\n          `<div style=\"margin-top:14px\">${pendingListHtml(CURRENT.pending)}</div>` +\n          `<div class=\"edges\">${\n            rows || retryRow ? rows + retryRow : '<p class=\"none\">No outgoing edges declared.</p>'\n          }</div>`\n        panel.querySelector(\".cur-head\").onclick = () => navigateTo(CURRENT.state)\n        panel.querySelectorAll(\".goto\").forEach((b) => (b.onclick = () => navigateTo(b.dataset.to)))\n      }\n      renderCurrentPanel()\n\n      reinitializeAndRenderAll()\n\n      // ── live current-state polling ──────────────────────────────────────\n      // Keeps the panel + diagram highlight in sync with an in-progress\n      // process without a manual page refresh. Skipped while the tab is\n      // hidden; becoming visible again triggers an immediate refresh. No\n      // in-flight guard — a slow tick just means the next one also awaits.\n      async function poll() {\n        if (document.hidden) return\n        const changed = await refreshCurrent()\n        if (changed) {\n          renderCurrentPanel()\n          repaintHighlights()\n        }\n      }\n      setInterval(poll, 3000)\n      document.addEventListener(\"visibilitychange\", () => {\n        if (!document.hidden) poll()\n      })\n\n      // ── kind chips + actor legend ──────────────────────────────────────\n      const kindChipsEl = document.getElementById(\"kindChips\")\n      const presentKinds = [\"all\", ...Array.from(new Set(STATES.map((s) => s.kind)))]\n      presentKinds.forEach((k) => {\n        const b = document.createElement(\"button\")\n        b.className = \"chip-btn\" + (k === \"all\" ? \" on\" : \"\")\n        b.textContent = k\n        b.dataset.kind = k\n        b.onclick = () => {\n          kindFilter = k\n          ;[...kindChipsEl.children].forEach((c) =>\n            c.classList.toggle(\"on\", c.dataset.kind === kindFilter),\n          )\n          renderCatalogue()\n        }\n        kindChipsEl.appendChild(b)\n      })\n\n      const legendEl = document.getElementById(\"legend\")\n      ;[\"human\", \"agent\", \"check\", \"commit\", \"unknown\"].forEach((a) => {\n        if (!counts[a]) return\n        const el = document.createElement(\"button\")\n        el.className = \"li\"\n        el.dataset.actor = a\n        el.setAttribute(\"aria-pressed\", \"true\")\n        el.innerHTML = `<span class=\"dot\" style=\"background:var(--${meta(a).dot}-dot)\"></span>${meta(a).label}`\n        el.onclick = () => {\n          const on = actorFilter.has(a)\n          on ? actorFilter.delete(a) : actorFilter.add(a)\n          el.classList.toggle(\"off\", on)\n          el.setAttribute(\"aria-pressed\", String(!on))\n          renderCatalogue()\n        }\n        legendEl.appendChild(el)\n      })\n\n      // ── catalogue ──────────────────────────────────────────────────────\n      const groupsEl = document.getElementById(\"groups\")\n      function stateMatches(s, q) {\n        if (!actorFilter.has(actorOf(s))) return false\n        if (kindFilter !== \"all\" && s.kind !== kindFilter) return false\n        if (!q) return true\n        const hay = [\n          s.name,\n          s.actor,\n          s.kind,\n          s.file,\n          s.mode,\n          s.model,\n          s.memory,\n          (s.flags || []).join(\" \"),\n        ]\n          .filter(Boolean)\n          .join(\" \")\n          .toLowerCase()\n        return hay.includes(q)\n      }\n      function cardFor(s) {\n        const a = actorOf(s)\n        const card = document.createElement(\"button\")\n        card.className = \"card\"\n        card.dataset.actor = a\n        const flags = (s.flags || [])\n          .filter((f) => f !== \"initial\")\n          .map((f) => `<span class=\"flag\">${esc(f)}</span>`)\n          .join(\"\")\n        const retry = s.retry ? `<span class=\"flag\">retry ${s.retry.max}</span>` : \"\"\n        const initTick = s.initial ? `<div class=\"init-tick\">initial</div>` : \"\"\n        card.innerHTML =\n          `${initTick}<div class=\"name\">${esc(s.name)}</div>` +\n          `<div class=\"row\">${pill(a)}<span class=\"kind\">${esc(s.kind)}</span>${retry}${flags}</div>`\n        card.onclick = () => openDrawer(s.name)\n        return card\n      }\n      function renderCatalogue() {\n        const q = document.getElementById(\"search\").value.trim().toLowerCase()\n        groupsEl.innerHTML = \"\"\n        const sections = []\n        ;(MODEL.groups || []).forEach((g) => {\n          sections.push({\n            label: g.name,\n            flow: g.submachine,\n            items: STATES.filter((s) => s.group === g.name),\n          })\n        })\n        const ungrouped = STATES.filter((s) => !s.group)\n        if (ungrouped.length) sections.push({ label: \"Ungrouped\", flow: \"\", items: ungrouped })\n\n        let shown = 0\n        sections.forEach((sec) => {\n          const items = sec.items.filter((s) => stateMatches(s, q))\n          if (!items.length) return\n          shown += items.length\n          const wrap = document.createElement(\"div\")\n          wrap.className = \"group\"\n          wrap.innerHTML =\n            `<div class=\"group-head\">${sec.flow ? `<span class=\"flow-tag\">${esc(sec.flow)}</span>` : \"\"}` +\n            `<h3>${esc(sec.label)}</h3></div>`\n          const grid = document.createElement(\"div\")\n          grid.className = \"grid\"\n          items.forEach((s) => grid.appendChild(cardFor(s)))\n          wrap.appendChild(grid)\n          groupsEl.appendChild(wrap)\n        })\n        if (!shown)\n          groupsEl.innerHTML = `<p class=\"none\" style=\"padding:20px 0\">No states match this filter.</p>`\n      }\n      document.getElementById(\"search\").addEventListener(\"input\", renderCatalogue)\n      renderCatalogue()\n\n      // ── drawer ─────────────────────────────────────────────────────────\n      const drawer = document.getElementById(\"drawer\")\n      const backdrop = document.getElementById(\"backdrop\")\n      let lastFocus = null\n\n      function openDrawer(name) {\n        const s = byName[name]\n        if (!s) return\n        const a = actorOf(s)\n        if (!drawer.classList.contains(\"open\")) lastFocus = document.activeElement\n\n        const kv = []\n        kv.push([\"actor\", pill(a)])\n        kv.push([\"kind\", `<span class=\"kind\">${esc(s.kind)}</span>`])\n        kv.push([\"model\", s.model ? esc(s.model) : '<span class=\"none\">—</span>'])\n        kv.push([\"memory\", s.memory ? esc(s.memory) : '<span class=\"none\">—</span>'])\n        kv.push([\"file\", s.file ? esc(s.file) : '<span class=\"none\">—</span>'])\n        kv.push([\"mode\", s.mode ? esc(s.mode) : '<span class=\"none\">—</span>'])\n        if (s.retry)\n          kv.push([\n            \"retry\",\n            `max ${s.retry.max} → <span style=\"color:var(--accent)\">${esc(s.retry.otherwise)}</span>`,\n          ])\n        if (s.group) kv.push([\"group\", esc(s.group)])\n\n        const contentBlock = s.content\n          ? `<div class=\"field\"><div class=\"k\">content — ${esc(s.kind)}</div><pre class=\"dia-src state-content\">${esc(s.content)}</pre></div>`\n          : \"\"\n\n        const flags = s.flags || []\n        const flagBlock = flags.length\n          ? `<div class=\"field\"><div class=\"k\">flags & gates</div><div class=\"flag-list\">${flags\n              .map(\n                (f) =>\n                  `<div class=\"flag-item\"><span class=\"fn\">${esc(f)}</span><span class=\"fd\">${esc(FLAGS[f] || \"\")}</span></div>`,\n              )\n              .join(\"\")}</div></div>`\n          : \"\"\n\n        const edges = s.on || []\n        const edgesBlock = edges.length\n          ? `<div class=\"field\"><div class=\"k\">outgoing edges — on (first match wins)</div><div class=\"edges\">${edges\n              .map((e) => {\n                const t = byName[e.to]\n                const ta = t ? actorOf(t) : \"unknown\"\n                return (\n                  `<div class=\"edge\"><div class=\"er\">${\n                    e.action ? `<span class=\"act\">${esc(e.action)}</span>` : \"\"\n                  }<span class=\"pat\">${esc(e.pattern)}</span><span class=\"arr\">→</span>` +\n                  `<button class=\"goto\" data-actor=\"${ta}\" data-to=\"${esc(e.to)}\">${esc(e.to)}</button></div>` +\n                  `${e.describe ? `<div class=\"em\">${esc(e.describe)}</div>` : \"\"}</div>`\n                )\n              })\n              .join(\"\")}</div></div>`\n          : `<div class=\"field\"><div class=\"k\">outgoing edges</div><p class=\"none\">${\n              s.kind === \"commit\"\n                ? \"Commit state — no outgoing edges. Entering it ends the process in one squash.\"\n                : \"No outgoing edges declared.\"\n            }</p></div>`\n\n        const retryOut =\n          s.retry && byName[s.retry.otherwise]\n            ? `<div class=\"field\"><div class=\"k\">retry redirect</div><div class=\"edge\"><div class=\"er\">` +\n              `<span class=\"pat\">after ${esc(s.retry.max)} tries</span><span class=\"arr\">→</span>` +\n              `<button class=\"goto\" data-actor=\"${actorOf(byName[s.retry.otherwise])}\" data-to=\"${esc(s.retry.otherwise)}\">${esc(s.retry.otherwise)}</button>` +\n              `</div></div></div>`\n            : \"\"\n\n        const inc = s.incoming || []\n        const incBlock =\n          `<div class=\"field\"><div class=\"k\">routes in from (${inc.length})</div>` +\n          (inc.length\n            ? `<div class=\"incoming\">${inc\n                .map((i) => {\n                  const f = byName[i.from]\n                  return `<button class=\"goto\" data-actor=\"${f ? actorOf(f) : \"unknown\"}\" data-to=\"${esc(i.from)}\" title=\"${esc(i.pattern)}\">${esc(i.from)}</button>`\n                })\n                .join(\"\")}</div>`\n            : `<p class=\"none\">Reached only as an entry point (a CLI command enters it directly).</p>`) +\n          `</div>`\n\n        drawer.style.setProperty(\"--card-accent\", `var(--${meta(a).dot}-dot)`)\n        drawer.innerHTML =\n          `<div class=\"drawer-head\" style=\"--card-accent:var(--${meta(a).dot}-dot)\">` +\n          `<div class=\"top\"><h3>${esc(s.name)}</h3>` +\n          `<button class=\"close-x\" id=\"closeX\" aria-label=\"Close detail\">✕</button></div>` +\n          `<div class=\"meta-row\">${pill(a)}<span class=\"kind\">${esc(s.kind)}</span>` +\n          `${s.initial ? '<span class=\"flag\">initial</span>' : \"\"}` +\n          `${s.retry ? `<span class=\"flag\">retry ${s.retry.max}</span>` : \"\"}` +\n          `${flags\n            .filter((f) => f !== \"initial\")\n            .map((f) => `<span class=\"flag\">${esc(f)}</span>`)\n            .join(\"\")}</div></div>` +\n          `<div class=\"drawer-body\">` +\n          `<div class=\"field\"><div class=\"k\">definition</div><dl class=\"kv\">${kv\n            .map(([k, v]) => `<dt>${esc(k)}</dt><dd>${v}</dd>`)\n            .join(\"\")}</dl></div>` +\n          contentBlock +\n          flagBlock +\n          edgesBlock +\n          retryOut +\n          incBlock +\n          `</div>`\n\n        drawer\n          .querySelectorAll(\".goto\")\n          .forEach((b) => (b.onclick = () => openDrawer(b.dataset.to)))\n        drawer.querySelector(\"#closeX\").onclick = closeDrawer\n\n        backdrop.classList.add(\"open\")\n        drawer.classList.add(\"open\")\n        drawer.querySelector(\".drawer-body\").scrollTop = 0\n        drawer.querySelector(\"#closeX\").focus()\n      }\n      function closeDrawer() {\n        backdrop.classList.remove(\"open\")\n        drawer.classList.remove(\"open\")\n        if (lastFocus && lastFocus.focus) lastFocus.focus()\n      }\n      backdrop.onclick = closeDrawer\n      document.addEventListener(\"keydown\", (e) => {\n        if (e.key === \"Escape\" && drawer.classList.contains(\"open\")) closeDrawer()\n      })\n\n      // expose for interactions\n      window.__openState = openDrawer\n    <\/script>\n  </body>\n</html>\n";
 //#endregion
 //#region src/Visualize.ts
 const FLAG_KEYS = [
@@ -205135,14 +205193,12 @@ const FLAG_KEYS = [
 	"answerGate"
 ];
 const flagsOf = (def) => FLAG_KEYS.filter((k) => def[k] === true);
-const edgeToViz = ([pattern, to, describe]) => describe !== void 0 ? {
+const edgeToViz = ([pattern, to, describe, action]) => stripUndefined({
 	pattern,
 	to,
-	describe
-} : {
-	pattern,
-	to
-};
+	describe,
+	action
+});
 /** Drop keys whose value is `undefined` (so `exactOptionalPropertyTypes` optionals stay absent, not `undefined`). */
 const stripUndefined = (o) => {
 	for (const key of Object.keys(o)) if (o[key] === void 0) delete o[key];
@@ -205173,12 +205229,21 @@ const renderPatternOrRaw = (pattern, vars) => {
 		return pattern;
 	}
 };
-/** Render every `on` edge of every state against `vars` (pattern key only — `target`/`describe` pass through verbatim), keyed by state name. */
-const renderedOnByState = (workflow, vars) => new Map(Object.entries(workflow.states).map(([name, def]) => [name, (def.on ?? []).map(([pattern, target, describe]) => describe !== void 0 ? [
-	renderPatternOrRaw(pattern, vars),
-	target,
-	describe
-] : [renderPatternOrRaw(pattern, vars), target])]));
+/** Render every `on` edge of every state against `vars` (pattern key only — `target`/`describe`/`action` pass through verbatim), keyed by state name. */
+const renderedOnByState = (workflow, vars) => new Map(Object.entries(workflow.states).map(([name, def]) => [name, (def.on ?? []).map(([pattern, target, describe, action]) => {
+	const renderedPattern = renderPatternOrRaw(pattern, vars);
+	if (action !== void 0) return [
+		renderedPattern,
+		target,
+		describe,
+		action
+	];
+	return describe !== void 0 ? [
+		renderedPattern,
+		target,
+		describe
+	] : [renderedPattern, target];
+})]));
 /**
 * Build the viewer's JSON description from the active COMPILED workflow plus its
 * RAW value (the pre-expansion `submachines:`/`use:` form — `rawWorkflow` from
@@ -205237,10 +205302,11 @@ const buildCurrentStateModel = (rest, changes, onEdges, group) => {
 		const parsed = parsePattern(patternStr);
 		return parsed !== void 0 && matchesPattern(parsed, changes);
 	});
-	const edges = onEdges.map(([pattern, to], i) => ({
+	const edges = onEdges.map(([pattern, to, , action], i) => ({
 		pattern,
 		to,
-		matched: i === matchedIndex
+		matched: i === matchedIndex,
+		...action !== void 0 ? { action } : {}
 	}));
 	return stripUndefined({
 		state: rest.state,
@@ -205761,7 +205827,7 @@ const runStepCommand = (argv, json, write, cost, model) => gen(function* () {
 *
 * a. The machine must currently rest at the workflow's INITIAL state — a
 *    plain non-gtd branch (the normal case) resolves there via the
-*    inert-subject rule (STATES.md §5); a process already underway refuses.
+*    inert-subject rule (see `resolveState`); a process already underway refuses.
 * b. The working tree must be clean.
 * c. The active workflow must declare a `reviewEntry: true` state.
 * d. `<commitish>` must resolve to a commit, be an ancestor of HEAD, and
@@ -205913,7 +205979,7 @@ const runRestoreCommand = (argv, json, write) => gen(function* () {
 * output (for a human or a simple driver who reads the prompt and hands it to
 * an agent, so the agent self-validates); withheld from `gtd next --json`,
 * where the driving loop instead runs `gtd validate` after the turn and
-* re-prompts on findings (see `bin/gtd-loop` / `skills/loop/SKILL.md`). This is
+* re-prompts on findings (see the `bin/gtd` loop driver). This is
 * advisory: `gtd step` runs the same format-and-validate gate and REFUSES a
 * turn whose steering file is invalid (see `stepAsActor`), so a malformed file
 * is never captured whether or not this instruction was followed.
@@ -206124,7 +206190,7 @@ const classifyAnswerCompleteness = (input) => {
 /**
 * The answer-completeness gate (edge, like the sign-off gate above). At an
 * `answerGate: true` state with `mode: qa` (the unified template's
-* `adv-grilling-answer`/`architecting-answer`), a human step is refused unless
+* `product-answer`/`technical-answer`), a human step is refused unless
 * every open question in the file is answered — the pure
 * `classifyAnswerCompleteness` decides over the WORKING-TREE contents. A no-op
 * when the state is not an answer gate (so the agent's own authoring step, which
@@ -206198,6 +206264,30 @@ const computeStatusChanges = (onEdges, changes) => changes.map((change) => {
 	};
 });
 /**
+* First declared `on` edge (in declaration order) whose pattern matches the
+* WHOLE pending change list — mirroring `PatternMachine.step`'s own
+* first-match-wins semantics (`matchOn`) exactly, unlike `computeStatusChanges`
+* above which matches each change independently. `null` when no edge matches,
+* covering both a clean tree with no declared `C` row and a dirty tree
+* matching none of the declared patterns.
+*
+* This reports the DECLARED route only: a capped `retry` target may redirect
+* elsewhere at real step time (`applyRetry` in `PatternMachine.ts`), which
+* this does not apply — same pre-retry, pure-over-already-fetched-inputs
+* contract as `computeStatusChanges`.
+*/
+const computeNextMatch = (onEdges, changes) => {
+	for (const [pattern, target, , action] of onEdges) {
+		const parsed = parsePattern(pattern);
+		if (parsed !== void 0 && matchesPattern(parsed, changes)) return {
+			action,
+			pattern,
+			target
+		};
+	}
+	return null;
+};
+/**
 * True when the per-model breakdown adds information beyond the `Cost:` total:
 * more than one model, or a single model that carries an actual `--model` tag
 * (a lone `unspecified` bucket just restates the total, so it's suppressed).
@@ -206210,38 +206300,60 @@ const costStatusLines = (cost, byModel) => {
 	if (breakdownIsInformative(byModel)) for (const m of byModel) lines.push(`  ${m.model}: ${m.cost}`);
 	return lines;
 };
-/** `gtd status --json`'s emission — `{state, actor, changes, model?, memory?, label?, file?, mode?, cost?, costByModel?, edges?}`. `renderedOn` is the resting state's `on` edges already rendered against `it.vars` (`renderOnEdges`), so the emitted `edges[].pattern` carries the same rendered path as `changes[].pattern`. */
-const writeStatusJson = (write, rest, statusChanges, renderedOn, model, memory, label, file, cost, costByModel) => {
+/** Builds `{[key]: value}` for each entry whose value isn't `undefined` — the shared "omit absent optional fields" shape behind both `writeStatusJson` and `writeStatusPlain`. */
+const definedFields = (entries) => {
+	const result = {};
+	for (const [key, value] of entries) if (value !== void 0) result[key] = value;
+	return result;
+};
+/** `gtd status --json`'s `next` key — `null` on no match, else the matched edge's pattern/target plus its `action` when declared. */
+const nextField = (next) => next === null ? null : {
+	...definedFields([["action", next.action]]),
+	pattern: next.pattern,
+	target: next.target
+};
+/** `gtd status`'s `Next:` line — the plain-text counterpart to `nextField`. */
+const nextStatusLine = (next) => next === null ? "Next: (no match — nothing would happen)" : `Next: ${next.action ?? next.pattern} → ${next.target}`;
+/** `gtd status`'s `Pending:` block — `(clean)` when nothing is pending, else one indented line per change. */
+const pendingStatusLines = (statusChanges) => statusChanges.length === 0 ? ["Pending: (clean)"] : ["Pending:", ...statusChanges.map((c) => `  ${c.status} ${c.path} -> ${c.pattern ?? "(no match)"}`)];
+/** `gtd status --json`'s emission — `{state, actor, changes, next, model?, memory?, label?, file?, mode?, cost?, costByModel?, edges?}`. `renderedOn` is the resting state's `on` edges already rendered against `it.vars` (`renderOnEdges`), so the emitted `edges[].pattern` carries the same rendered path as `changes[].pattern`. `next` is ALWAYS present (an object, or `null` on no match) — the headline conclusion, never omit-vs-null, same as `changes`. */
+const writeStatusJson = (write, rest, statusChanges, renderedOn, next, model, memory, label, file, cost, costByModel) => {
 	const edges = toTemplateEdges(renderedOn);
+	const hasCost = cost > 0;
 	write(JSON.stringify({
 		state: rest.state,
 		actor: rest.actor,
 		changes: statusChanges,
-		...model !== void 0 ? { model } : {},
-		...memory !== void 0 ? { memory } : {},
-		...label !== void 0 ? { label } : {},
-		...file !== void 0 ? { file } : {},
-		...rest.stateDef.mode !== void 0 ? { mode: rest.stateDef.mode } : {},
-		...cost > 0 ? { cost } : {},
-		...cost > 0 ? { costByModel } : {},
-		...edges.length > 0 ? { edges } : {}
+		next: nextField(next),
+		...definedFields([
+			["model", model],
+			["memory", memory],
+			["label", label],
+			["file", file],
+			["mode", rest.stateDef.mode],
+			["cost", hasCost ? cost : void 0],
+			["costByModel", hasCost ? costByModel : void 0],
+			["edges", edges.length > 0 ? edges : void 0]
+		])
 	}) + "\n");
 };
-/** `gtd status`'s plain-text emission — `State:`/`Awaits:`/`Label:`/`Model:`/`Memory:`/`File:`/`Mode:`/`Cost:`/`Pending:` lines. */
-const writeStatusPlain = (write, rest, statusChanges, model, memory, label, file, cost, costByModel) => {
-	const lines = [`State: ${rest.state}`, `Awaits: ${rest.actor}`];
-	if (label !== void 0) lines.push(`Label: ${label}`);
-	if (model !== void 0) lines.push(`Model: ${model}`);
-	if (memory !== void 0) lines.push(`Memory: ${memory}`);
-	if (file !== void 0) lines.push(`File: ${file}`);
-	if (rest.stateDef.mode !== void 0) lines.push(`Mode: ${rest.stateDef.mode}`);
-	lines.push(...costStatusLines(cost, costByModel));
-	if (statusChanges.length === 0) lines.push("Pending: (clean)");
-	else {
-		lines.push("Pending:");
-		for (const c of statusChanges) lines.push(`  ${c.status} ${c.path} -> ${c.pattern ?? "(no match)"}`);
-	}
-	write(lines.join("\n") + "\n");
+/** `gtd status`'s plain-text emission — `State:`/`Awaits:`/`Label:`/`Model:`/`Memory:`/`File:`/`Mode:`/`Cost:`/`Pending:`/`Next:` lines. */
+const writeStatusPlain = (write, rest, statusChanges, next, model, memory, label, file, cost, costByModel) => {
+	const optional = definedFields([
+		["Label", label],
+		["Model", model],
+		["Memory", memory],
+		["File", file],
+		["Mode", rest.stateDef.mode]
+	]);
+	write([
+		`State: ${rest.state}`,
+		`Awaits: ${rest.actor}`,
+		...Object.entries(optional).map(([key, value]) => `${key}: ${value}`),
+		...costStatusLines(cost, costByModel),
+		...pendingStatusLines(statusChanges),
+		nextStatusLine(next)
+	].join("\n") + "\n");
 };
 /** `gtd status`: pure dry-run reporter — the resolved state/actor, and which declared pattern (if any) each pending change matches. */
 const runStatusCommand = (argv, json, write) => gen(function* () {
@@ -206254,8 +206366,9 @@ const runStatusCommand = (argv, json, write) => gen(function* () {
 	const label = yield* renderLabel(rest.stateDef, context);
 	const file = yield* renderFile(rest.stateDef, context);
 	const statusChanges = computeStatusChanges(renderedOn, changes);
-	if (json) writeStatusJson(write, rest, statusChanges, renderedOn, model, memory, label, file, context.processCost, context.processCostByModel);
-	else writeStatusPlain(write, rest, statusChanges, model, memory, label, file, context.processCost, context.processCostByModel);
+	const next = computeNextMatch(renderedOn, changes);
+	if (json) writeStatusJson(write, rest, statusChanges, renderedOn, next, model, memory, label, file, context.processCost, context.processCostByModel);
+	else writeStatusPlain(write, rest, statusChanges, next, model, memory, label, file, context.processCost, context.processCostByModel);
 });
 /** Parse a `--port` value: an integer 0–65535, or `undefined` if invalid/absent. */
 const parsePort = (value) => {
@@ -206419,7 +206532,7 @@ const assertRunningFromRepoRoot = (git, fs) => gen(function* () {
 * so unlike the state commands it need not sit in a git repository at all. It
 * may run EITHER at a repository root OR in a directory outside any repository —
 * the latter scaffolds a shared config a nested repo picks up by walking up the
-* cwd→home chain (see the parent-dir layout in docs/configuration.md). The one
+* cwd→home chain. The one
 * placement it must refuse is a repository SUBDIRECTORY: gtd runs from the repo
 * root and discovers config by walking UP, so a config written below the root
 * would silently never be found. Returns whether cwd is inside a repository (at
@@ -206454,8 +206567,7 @@ const dispatchKnownSubcommand = (sub, argv, json, write, cost, model) => {
 * captures stdout via the `write` callback.
 *
 * v3 command surface: `step <actor>` / `review <commitish>` / `fix` / `next` /
-* `status` / `validate` (see `src/Edge.ts` and
-* `docs/design/pattern-machine-plan.md` §3),
+* `status` / `validate` (see `src/Edge.ts`),
 * plus `lsp` and `init` — both dispatched before the config-reading
 * path since neither needs to touch the config. Bare `gtd` or an
 * unknown subcommand is a usage error. Shared setup (argv parsing, the