diff --git a/.github/scripts/stack-breadcrumb.cjs b/.github/scripts/stack-breadcrumb.cjs
new file mode 100644
index 00000000..d7e7e67a
--- /dev/null
+++ b/.github/scripts/stack-breadcrumb.cjs
@@ -0,0 +1,343 @@
+"use strict";
+
+/**
+ * Stack breadcrumb — pure, zero-dependency logic.
+ *
+ * A portable port of the `@taskless/stack-breadcrumb` package's core: it derives
+ * a stacked-PR forest from `base`/`head` relationships, renders a breadcrumb
+ * region, and plans the minimal body edits to keep every PR in a stack pointing
+ * at its siblings. There is NO GitHub I/O here — the workflow supplies the PR
+ * list (via `actions/github-script`'s octokit) and a `writeBody` callback, so
+ * this file needs no npm install, no build step, and stays unit-testable with
+ * `node --test`.
+ *
+ * The two-stage workflow keeps reconciliation serialized per stack root:
+ *   stage 1 (dispatch)  — on PR shape events, resolve the affected root(s) and
+ *                         fire a `repository_dispatch`.
+ *   stage 2 (reconcile) — on that dispatch, render and propagate the breadcrumb.
+ */
+
+// ---------------------------------------------------------------------------
+// Marker-region surgery
+//
+// Each managed PR body carries at most one region delimited by
+// `<!-- stack root=N pr=… -->` … `<!-- /stack -->`. Replacing a region in place
+// leaves every other byte untouched, so a git-town breadcrumb or any other
+// content is never disturbed. Appending trims the body's trailing whitespace
+// before adding the region after a blank line; removing collapses the blank
+// lines the region left behind and trims trailing whitespace.
+// ---------------------------------------------------------------------------
+
+/** Matches the whole region, opening marker through `<!-- /stack -->`. */
+const REGION_PATTERN = /<!-- stack [^>]*-->[\S\s]*?<!-- \/stack -->/;
+
+/** Matches just the opening marker, capturing `root` and the `pr=` list. */
+const OPEN_MARKER_PATTERN = /<!-- stack root=(\d+) pr=([\d,]*) -->/;
+
+/**
+ * Parse the opening marker's `root` and ordered `pr=` membership list — but only
+ * inside a COMPLETE region (both markers present), so a stray or pasted opening
+ * marker without its closing tag is not mistaken for a managed region.
+ */
+function parseStackComment(body) {
+  const region = getRegion(body);
+  if (region === undefined) {
+    return undefined;
+  }
+  const match = OPEN_MARKER_PATTERN.exec(region);
+  if (!match) {
+    return undefined;
+  }
+  const root = Number(match[1]);
+  const members = match[2]
+    .split(",")
+    .filter((part) => part.length > 0)
+    .map(Number);
+  return { root, members };
+}
+
+/** Return the existing region (including both markers), or `undefined` if absent. */
+function getRegion(body) {
+  const match = REGION_PATTERN.exec(body);
+  return match ? match[0] : undefined;
+}
+
+/**
+ * Splice `region` into `body`:
+ * - an empty `region` removes an existing region (non-stacked PR);
+ * - an existing region is replaced in place;
+ * - otherwise the region is appended after a blank line.
+ * Content outside the markers is preserved.
+ */
+function spliceRegion(body, region) {
+  const existing = getRegion(body);
+
+  if (region.length === 0) {
+    if (!existing) {
+      return body;
+    }
+    // Remove the region and only the blank lines hugging it, rejoining the
+    // surrounding text with a single blank line. Spacing elsewhere in the body
+    // is left exactly as-is.
+    const start = body.indexOf(existing);
+    const before = body.slice(0, start).replace(/\n+$/, "");
+    const after = body.slice(start + existing.length).replace(/^\n+/, "");
+    if (before.length === 0) {
+      return after.trimEnd();
+    }
+    if (after.length === 0) {
+      return before.trimEnd();
+    }
+    return `${before}\n\n${after}`;
+  }
+
+  if (existing) {
+    // Function replacer so `$` sequences in a PR title are not treated as
+    // `String.replace` special patterns ($&, $1, …).
+    return body.replace(REGION_PATTERN, () => region);
+  }
+
+  const trimmed = body.trimEnd();
+  return trimmed.length === 0 ? region : `${trimmed}\n\n${region}`;
+}
+
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+
+const HERE_PREFIX = "➡️ "; // ➡️
+const HERE_SUFFIX = " (you are here)";
+const STACK_HEADING = "**Stack** (root → tip):"; // root → tip
+
+/** Render the full `<!-- stack … -->` … `<!-- /stack -->` region, or `''` for a non-stacked PR. */
+function renderRegion(tree, currentNumber) {
+  if (tree.members.length <= 1) {
+    return "";
+  }
+
+  const open = `<!-- stack root=${tree.root} pr=${tree.members.join(",")} -->`;
+  const lines = [open, STACK_HEADING, ""];
+
+  const renderNode = (number_, depth) => {
+    const indent = "  ".repeat(depth);
+    lines.push(
+      number_ === currentNumber
+        ? `${indent}- ${HERE_PREFIX}#${number_}${HERE_SUFFIX}`
+        : `${indent}- #${number_}`
+    );
+    for (const child of tree.childrenOf.get(number_) ?? []) {
+      renderNode(child, depth + 1);
+    }
+  };
+
+  renderNode(tree.root, 0);
+  lines.push("<!-- /stack -->");
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Tree derivation (pure, from the open-PR list)
+// ---------------------------------------------------------------------------
+
+function indexPullRequests(pullRequests) {
+  const byNumber = new Map();
+  const byHead = new Map();
+  for (const pullRequest of pullRequests) {
+    byNumber.set(pullRequest.number, pullRequest);
+    byHead.set(pullRequest.headRefName, pullRequest);
+  }
+  return { byNumber, byHead };
+}
+
+function parentOf(pullRequest, byHead, defaultBranch) {
+  if (pullRequest.baseRefName === defaultBranch) {
+    return undefined;
+  }
+  return byHead.get(pullRequest.baseRefName);
+}
+
+/** Walk `base` pointers up from `startNumber` to the root of its stack. */
+function findRoot(startNumber, pullRequests, defaultBranch) {
+  const { byNumber, byHead } = indexPullRequests(pullRequests);
+  let current = byNumber.get(startNumber);
+  if (!current) {
+    return undefined;
+  }
+  const seen = new Set();
+  let parent = parentOf(current, byHead, defaultBranch);
+  while (parent && !seen.has(current.number)) {
+    seen.add(current.number);
+    current = parent;
+    parent = parentOf(current, byHead, defaultBranch);
+  }
+  return current.number;
+}
+
+/** Build the tree rooted at `rootNumber`: DFS pre-order members + sorted child map. */
+function buildTree(rootNumber, pullRequests) {
+  const { byNumber } = indexPullRequests(pullRequests);
+
+  const childrenByHead = new Map();
+  for (const pullRequest of pullRequests) {
+    const siblings = childrenByHead.get(pullRequest.baseRefName) ?? [];
+    siblings.push(pullRequest.number);
+    childrenByHead.set(pullRequest.baseRefName, siblings);
+  }
+
+  const childrenOf = new Map();
+  const members = [];
+  const visited = new Set();
+
+  const visit = (number_) => {
+    const node = byNumber.get(number_);
+    // Guard against a base/head cycle (A←B and B←A): never visit a PR twice.
+    if (!node || visited.has(number_)) {
+      return;
+    }
+    visited.add(number_);
+    members.push(number_);
+    const childNumbers = (childrenByHead.get(node.headRefName) ?? [])
+      .filter((candidate) => candidate !== number_)
+      .toSorted((a, b) => a - b);
+    childrenOf.set(number_, childNumbers);
+    for (const child of childNumbers) {
+      visit(child);
+    }
+  };
+
+  visit(rootNumber);
+  return { root: rootNumber, members, childrenOf };
+}
+
+/** Find the root of `triggerNumber`'s stack, then build the tree. */
+function resolveTree(triggerNumber, pullRequests, defaultBranch) {
+  const root = findRoot(triggerNumber, pullRequests, defaultBranch);
+  if (root === undefined) {
+    return undefined;
+  }
+  return buildTree(root, pullRequests);
+}
+
+/**
+ * Resolve the root(s) of the stack(s) a PR event affects.
+ * - An OPEN trigger affects exactly its own root.
+ * - A CLOSED/merged trigger's stack still needs a redraw: union the survivors
+ *   found via the parent route (open PR headed at the closed PR's base) and the
+ *   marker route (open PRs whose last breadcrumb listed the closed PR), then map
+ *   each surviving member to its (possibly new) root.
+ */
+function resolveAffectedRoots(trigger, pullRequests, defaultBranch) {
+  const isOpen = pullRequests.some(
+    (pullRequest) => pullRequest.number === trigger.number
+  );
+  if (isOpen) {
+    const root = findRoot(trigger.number, pullRequests, defaultBranch);
+    return root === undefined ? [] : [root];
+  }
+
+  const affected = new Set();
+  for (const candidate of pullRequests) {
+    const isParentOfClosed = candidate.headRefName === trigger.baseRefName;
+    const marker = parseStackComment(candidate.body);
+    const markerNamedClosed =
+      marker !== undefined &&
+      (marker.root === trigger.number ||
+        marker.members.includes(trigger.number));
+    if (isParentOfClosed || markerNamedClosed) {
+      affected.add(candidate.number);
+    }
+  }
+
+  const roots = new Set();
+  for (const number_ of affected) {
+    const root = findRoot(number_, pullRequests, defaultBranch);
+    if (root !== undefined) {
+      roots.add(root);
+    }
+  }
+  return [...roots].toSorted((a, b) => a - b);
+}
+
+/** Every distinct stack root among the open PRs (deduped, ascending). */
+function findAllRoots(pullRequests, defaultBranch) {
+  const roots = new Set();
+  for (const pullRequest of pullRequests) {
+    const root = findRoot(pullRequest.number, pullRequests, defaultBranch);
+    if (root !== undefined) {
+      roots.add(root);
+    }
+  }
+  return [...roots].toSorted((a, b) => a - b);
+}
+
+// ---------------------------------------------------------------------------
+// Reconcile orchestration
+// ---------------------------------------------------------------------------
+
+/** Compute the new body for one PR given its desired region (`''` removes it). */
+function planUpdate(pullRequest, region) {
+  const body = spliceRegion(pullRequest.body, region);
+  return {
+    number: pullRequest.number,
+    changed: body !== pullRequest.body,
+    body,
+  };
+}
+
+/**
+ * Reconcile the tree rooted at `root`: render the breadcrumb for each member and
+ * write only changed bodies via `deps.writeBody`. A write that throws is logged
+ * and the PR is recorded as failed; the rest of the tree still reconciles.
+ */
+async function reconcile(root, deps) {
+  const { pullRequests, writeBody } = deps;
+  const byNumber = new Map(
+    pullRequests.map((pullRequest) => [pullRequest.number, pullRequest])
+  );
+  const tree = buildTree(root, pullRequests);
+
+  const updated = [];
+  const skipped = [];
+  const failed = [];
+
+  for (const number_ of tree.members) {
+    const pullRequest = byNumber.get(number_);
+    if (!pullRequest) {
+      continue;
+    }
+    const region = renderRegion(tree, number_);
+    const plan = planUpdate(pullRequest, region);
+    if (!plan.changed) {
+      skipped.push(number_);
+      continue;
+    }
+    try {
+      await writeBody(number_, plan.body);
+      updated.push(number_);
+    } catch (error) {
+      console.error(
+        `stack-breadcrumb: could not update PR #${number_}: ${String(error)}`
+      );
+      failed.push(number_);
+    }
+  }
+
+  return { root, updated, skipped, failed };
+}
+
+module.exports = {
+  parseStackComment,
+  getRegion,
+  spliceRegion,
+  renderRegion,
+  findRoot,
+  buildTree,
+  resolveTree,
+  resolveAffectedRoots,
+  findAllRoots,
+  planUpdate,
+  reconcile,
+  HERE_PREFIX,
+  HERE_SUFFIX,
+  STACK_HEADING,
+};
diff --git a/.github/scripts/stack-breadcrumb.test.cjs b/.github/scripts/stack-breadcrumb.test.cjs
new file mode 100644
index 00000000..15c42292
--- /dev/null
+++ b/.github/scripts/stack-breadcrumb.test.cjs
@@ -0,0 +1,278 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+  parseStackComment,
+  getRegion,
+  spliceRegion,
+  renderRegion,
+  findRoot,
+  buildTree,
+  resolveTree,
+  resolveAffectedRoots,
+  findAllRoots,
+  planUpdate,
+  reconcile,
+} = require("./stack-breadcrumb.cjs");
+
+const DEFAULT_BRANCH = "main";
+
+function pr(number, head, base, body = "") {
+  return { number, title: `PR ${number}`, headRefName: head, baseRefName: base, body };
+}
+
+const REGION = [
+  "<!-- stack root=10 pr=10,11,12 -->",
+  "**Stack** (root → tip):",
+  "",
+  "- #10",
+  "  - ➡️ #11 (you are here)",
+  "    - #12",
+  "<!-- /stack -->",
+].join("\n");
+
+test("parseStackComment: parses root and ordered membership", () => {
+  assert.deepEqual(parseStackComment(`intro\n\n${REGION}`), {
+    root: 10,
+    members: [10, 11, 12],
+  });
+});
+
+test("parseStackComment: parses an empty membership list", () => {
+  assert.deepEqual(
+    parseStackComment("<!-- stack root=10 pr= -->\nx\n<!-- /stack -->"),
+    { root: 10, members: [] }
+  );
+});
+
+test("parseStackComment: undefined when no marker", () => {
+  assert.equal(parseStackComment("just a normal PR body"), undefined);
+});
+
+test("parseStackComment: undefined for a bare opening marker without a closing tag", () => {
+  // A pasted/stray opening marker must not be treated as a managed region.
+  assert.equal(
+    parseStackComment("intro\n<!-- stack root=10 pr=10,11 -->\nno closing tag"),
+    undefined
+  );
+});
+
+test("getRegion: extracts the full region", () => {
+  assert.equal(getRegion(`before\n${REGION}\nafter`), REGION);
+});
+
+test("getRegion: undefined when absent", () => {
+  assert.equal(getRegion("no region here"), undefined);
+});
+
+test("spliceRegion: appends to a body with none", () => {
+  assert.equal(spliceRegion("Original body.", REGION), `Original body.\n\n${REGION}`);
+});
+
+test("spliceRegion: returns just the region for an empty body", () => {
+  assert.equal(spliceRegion("", REGION), REGION);
+});
+
+test("spliceRegion: replaces an existing region in place", () => {
+  const oldRegion = "<!-- stack root=10 pr=10,11 -->\nold\n<!-- /stack -->";
+  const body = `top\n\n${oldRegion}\n\nbottom`;
+  assert.equal(spliceRegion(body, REGION), `top\n\n${REGION}\n\nbottom`);
+});
+
+test("spliceRegion: removes the region when given an empty region", () => {
+  assert.equal(spliceRegion(`keep this\n\n${REGION}`, ""), "keep this");
+});
+
+test("spliceRegion: no-op removing when no region exists", () => {
+  assert.equal(spliceRegion("nothing to remove", ""), "nothing to remove");
+});
+
+test("spliceRegion: removing preserves unrelated blank runs elsewhere", () => {
+  // A 3+ newline run unrelated to the region must survive removal.
+  const body = `line1\n\n\n\nline2\n\n${REGION}`;
+  assert.equal(spliceRegion(body, ""), "line1\n\n\n\nline2");
+});
+
+test("spliceRegion: removing a middle region rejoins with one blank line", () => {
+  assert.equal(spliceRegion(`top\n\n${REGION}\n\nbottom`, ""), "top\n\nbottom");
+});
+
+test("spliceRegion: skip-when-equal is a no-op", () => {
+  const body = `intro\n\n${REGION}\n\noutro`;
+  assert.equal(spliceRegion(body, REGION), body);
+});
+
+test("spliceRegion: does not treat $ sequences as replacement patterns", () => {
+  const dollarRegion =
+    "<!-- stack root=10 pr=10,11 -->\ncost is $1 and $& too\n<!-- /stack -->";
+  const body = "<!-- stack root=10 pr=10 -->\nold\n<!-- /stack -->";
+  assert.equal(spliceRegion(body, dollarRegion), dollarRegion);
+});
+
+const chain = [pr(10, "a", DEFAULT_BRANCH), pr(11, "b", "a"), pr(12, "c", "b")];
+const branching = [
+  pr(10, "a", DEFAULT_BRANCH),
+  pr(11, "b", "a"),
+  pr(12, "c", "a"),
+  pr(13, "d", "b"),
+];
+
+test("renderRegion: nested list with current PR marked", () => {
+  assert.equal(renderRegion(buildTree(10, chain), 11), REGION);
+});
+
+test("renderRegion: empty for a non-stacked single-member tree", () => {
+  assert.equal(renderRegion(buildTree(10, [pr(10, "a", "main")]), 10), "");
+});
+
+test("findRoot: walks a chain up to the root", () => {
+  assert.equal(findRoot(12, chain, DEFAULT_BRANCH), 10);
+  assert.equal(findRoot(11, chain, DEFAULT_BRANCH), 10);
+  assert.equal(findRoot(10, chain, DEFAULT_BRANCH), 10);
+});
+
+test("findRoot: resolves from any branch of a branching tree", () => {
+  assert.equal(findRoot(13, branching, DEFAULT_BRANCH), 10);
+  assert.equal(findRoot(12, branching, DEFAULT_BRANCH), 10);
+});
+
+test("findRoot: a PR whose base has no open PR is its own root", () => {
+  assert.equal(findRoot(11, [pr(11, "b", "deleted-parent")], DEFAULT_BRANCH), 11);
+});
+
+test("findRoot: undefined for a PR that is not open", () => {
+  assert.equal(findRoot(99, chain, DEFAULT_BRANCH), undefined);
+});
+
+test("buildTree: DFS pre-order for a chain", () => {
+  assert.deepEqual(buildTree(10, chain).members, [10, 11, 12]);
+});
+
+test("buildTree: DFS pre-order with sorted children for a branching tree", () => {
+  assert.deepEqual(buildTree(10, branching).members, [10, 11, 13, 12]);
+});
+
+test("buildTree: records sorted children per node", () => {
+  const tree = buildTree(10, branching);
+  assert.deepEqual(tree.childrenOf.get(10), [11, 12]);
+  assert.deepEqual(tree.childrenOf.get(11), [13]);
+  assert.deepEqual(tree.childrenOf.get(13), []);
+});
+
+test("buildTree: terminates on a base/head cycle, visiting each once", () => {
+  const cycle = [pr(10, "a", "b"), pr(11, "b", "a")];
+  assert.deepEqual(buildTree(10, cycle).members, [10, 11]);
+});
+
+test("resolveTree: finds root and builds tree in one step", () => {
+  const tree = resolveTree(12, chain, DEFAULT_BRANCH);
+  assert.equal(tree.root, 10);
+  assert.deepEqual(tree.members, [10, 11, 12]);
+});
+
+test("resolveTree: undefined when the trigger is not open", () => {
+  assert.equal(resolveTree(99, chain, DEFAULT_BRANCH), undefined);
+});
+
+test("findAllRoots: each distinct root once, ascending", () => {
+  const twoStacks = [...chain, pr(20, "x", DEFAULT_BRANCH), pr(21, "y", "x")];
+  assert.deepEqual(findAllRoots(twoStacks, DEFAULT_BRANCH), [10, 20]);
+});
+
+test("findAllRoots: empty when there are no open PRs", () => {
+  assert.deepEqual(findAllRoots([], DEFAULT_BRANCH), []);
+});
+
+test("resolveAffectedRoots: open trigger returns its own root", () => {
+  assert.deepEqual(
+    resolveAffectedRoots({ number: 12, baseRefName: "b" }, chain, DEFAULT_BRANCH),
+    [10]
+  );
+});
+
+test("resolveAffectedRoots: parent route when a leaf closes", () => {
+  const open = [pr(10, "a", DEFAULT_BRANCH), pr(11, "b", "a")];
+  assert.deepEqual(
+    resolveAffectedRoots({ number: 12, baseRefName: "b" }, open, DEFAULT_BRANCH),
+    [10]
+  );
+});
+
+test("resolveAffectedRoots: marker route when the root merges and children retarget", () => {
+  const marker = "<!-- stack root=10 pr=10,11,12 -->\nx\n<!-- /stack -->";
+  const open = [pr(11, "b", DEFAULT_BRANCH, marker), pr(12, "c", "b", marker)];
+  assert.deepEqual(
+    resolveAffectedRoots(
+      { number: 10, baseRefName: DEFAULT_BRANCH },
+      open,
+      DEFAULT_BRANCH
+    ),
+    [11]
+  );
+});
+
+test("resolveAffectedRoots: nothing when a closed PR affects no open stack", () => {
+  assert.deepEqual(
+    resolveAffectedRoots(
+      { number: 99, baseRefName: "gone" },
+      [pr(10, "a", DEFAULT_BRANCH)],
+      DEFAULT_BRANCH
+    ),
+    []
+  );
+});
+
+test("planUpdate: appends the region and flags a change", () => {
+  const plan = planUpdate(pr(10, "a", "main", "intro"), REGION);
+  assert.equal(plan.changed, true);
+  assert.ok(plan.body.includes(REGION));
+});
+
+test("planUpdate: skips when the body already has the region", () => {
+  const plan = planUpdate(pr(10, "a", "main", `intro\n\n${REGION}`), REGION);
+  assert.equal(plan.changed, false);
+});
+
+test("planUpdate: removes the region when the desired region is empty", () => {
+  const plan = planUpdate(pr(10, "a", "main", `x\n\n${REGION}`), "");
+  assert.equal(plan.changed, true);
+  assert.ok(!plan.body.includes("<!-- stack"));
+});
+
+test("reconcile: writes only changed bodies and reports updated/skipped", async () => {
+  const twoChain = [pr(10, "a", "main"), pr(11, "b", "a")];
+  const calls = [];
+  const result = await reconcile(10, {
+    pullRequests: twoChain,
+    writeBody: (number_, body) => calls.push([number_, body]),
+  });
+  assert.equal(result.root, 10);
+  assert.deepEqual(result.updated, [10, 11]);
+  assert.deepEqual(result.skipped, []);
+  assert.equal(calls.length, 2);
+});
+
+test("reconcile: skips a PR whose body already matches", async () => {
+  const twoChain = [pr(10, "a", "main"), pr(11, "b", "a")];
+  const tree = buildTree(10, twoChain);
+  const seeded = twoChain.map((p) =>
+    p.number === 10 ? { ...p, body: renderRegion(tree, 10) } : p
+  );
+  const result = await reconcile(10, { pullRequests: seeded, writeBody() {} });
+  assert.ok(result.skipped.includes(10));
+  assert.ok(result.updated.includes(11));
+});
+
+test("reconcile: records a failed write and continues", async () => {
+  const twoChain = [pr(10, "a", "main"), pr(11, "b", "a")];
+  const result = await reconcile(10, {
+    pullRequests: twoChain,
+    writeBody(number_) {
+      if (number_ === 10) throw new Error("forbidden");
+    },
+  });
+  assert.deepEqual(result.failed, [10]);
+  assert.deepEqual(result.updated, [11]);
+});
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c7b0c05d..ffde2078 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -40,3 +40,6 @@ jobs:
 
       - name: Test
         run: pnpm test
+
+      - name: Test workflow scripts
+        run: node --test .github/scripts/*.test.cjs
diff --git a/.github/workflows/stack-breadcrumb.yml b/.github/workflows/stack-breadcrumb.yml
new file mode 100644
index 00000000..f5e02304
--- /dev/null
+++ b/.github/workflows/stack-breadcrumb.yml
@@ -0,0 +1,216 @@
+name: Stack Breadcrumb
+
+# Self-contained stacked-PR breadcrumb. All logic lives in a zero-dependency
+# module (.github/scripts/stack-breadcrumb.cjs) that each job loads via
+# actions/github-script — no pnpm/tsx/package install, no build step.
+#
+# Two stages keep reconciliation serialized per stack root:
+#   STAGE 1 (dispatch)  — on PR shape-change events, resolve the affected
+#                         root(s) and fire a `repository_dispatch`.
+#   STAGE 2 (reconcile) — on that dispatch (or a manual `workflow_dispatch`),
+#                         render and propagate the breadcrumb, serialized per root.
+#
+# Stage 1 fires the dispatch with the built-in GITHUB_TOKEN: although that token
+# normally suppresses recursive workflow runs, `repository_dispatch` is a
+# documented exception, so stage 2 fires. NOTE: `repository_dispatch` always runs
+# from the DEFAULT BRANCH's copy of this file, so the live breadcrumb (driven by
+# PR events → dispatch → reconcile) activates only once this is merged to `main`.
+# `workflow_dispatch` instead runs from the branch you select in the "Run
+# workflow" menu, so it can be used to test the reconcile stage before merge.
+
+on:
+  pull_request:
+    # Tree SHAPE only — no `synchronize` (a head push never changes membership).
+    types: [opened, reopened, edited, closed]
+  repository_dispatch:
+    types: [stack-reconcile]
+  workflow_dispatch:
+    inputs:
+      root:
+        description: "Root PR number to reconcile (leave empty to reconcile all open stacks)"
+        required: false
+        default: ""
+
+# Permissions are least-privilege per job: stage 1 only POSTs a dispatch; only
+# stage 2 writes PR bodies.
+permissions: {}
+
+jobs:
+  dispatch:
+    name: Resolve root and dispatch reconcile
+    # Skip fork PRs (read-only token) and the bot's own body edits. The built-in
+    # GITHUB_TOKEN already won't retrigger workflows, but the actor guard makes
+    # the no-loop guarantee explicit for any non-token edit too.
+    if: >-
+      github.event_name == 'pull_request'
+      && github.event.pull_request.head.repo.full_name == github.repository
+      && github.event.sender.login != 'github-actions[bot]'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # required to POST repository_dispatch
+      pull-requests: read # walk the tree
+    concurrency:
+      group: stack-breadcrumb-dispatch-${{ github.event.pull_request.number }}
+      cancel-in-progress: true
+    steps:
+      # Check out the DEFAULT branch's copy of the script, not the PR head: this
+      # privileged job (contents: write) must run trusted, reviewed logic, never
+      # PR-supplied code.
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.repository.default_branch }}
+
+      - uses: actions/github-script@v7
+        with:
+          script: |
+            const scriptPath = `${process.env.GITHUB_WORKSPACE}/.github/scripts/stack-breadcrumb.cjs`;
+            let stack;
+            try {
+              stack = require(scriptPath);
+            } catch (error) {
+              // Bootstrap: before this workflow is on the default branch the
+              // script isn't there yet. Skip rather than fail.
+              if (error.code === "MODULE_NOT_FOUND") {
+                core.info("stack-breadcrumb script not on the default branch yet; skipping until merged.");
+                return;
+              }
+              throw error;
+            }
+            const { owner, repo } = context.repo;
+
+            const defaultBranch = (await github.rest.repos.get({ owner, repo })).data.default_branch;
+            const rawPulls = await github.paginate(github.rest.pulls.list, {
+              owner, repo, state: "open", per_page: 100,
+            });
+            // Same-repo PRs only: the tree keys parents by branch name, so a fork
+            // PR sharing a branch name would corrupt root resolution.
+            const pullRequests = rawPulls
+              .filter((pr) => pr.head.repo?.full_name === `${owner}/${repo}`)
+              .map((pr) => ({
+                number: pr.number,
+                title: pr.title,
+                headRefName: pr.head.ref,
+                baseRefName: pr.base.ref,
+                body: pr.body ?? "",
+              }));
+
+            const trigger = {
+              number: context.payload.pull_request.number,
+              baseRefName: context.payload.pull_request.base.ref,
+            };
+            const roots = stack.resolveAffectedRoots(trigger, pullRequests, defaultBranch);
+            if (roots.length === 0) {
+              core.info(`PR #${trigger.number} affects no open stack; nothing to dispatch`);
+              return;
+            }
+            for (const root of roots) {
+              await github.rest.repos.createDispatchEvent({
+                owner, repo, event_type: "stack-reconcile", client_payload: { root },
+              });
+              core.info(`dispatched reconcile for root #${root}`);
+            }
+
+  reconcile:
+    name: Reconcile breadcrumb across the stack
+    if: github.event_name == 'repository_dispatch' || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read # checkout
+      pull-requests: write # edit PR bodies
+    # One reconcile per root at a time. A burst for one root collapses to the
+    # latest run; convergent writes make cancellation safe.
+    concurrency:
+      group: stack-reconcile-${{ github.event.client_payload.root || github.event.inputs.root || 'all' }}
+      cancel-in-progress: true
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/github-script@v7
+        with:
+          script: |
+            const stack = require(`${process.env.GITHUB_WORKSPACE}/.github/scripts/stack-breadcrumb.cjs`);
+            const { owner, repo } = context.repo;
+
+            const defaultBranch = (await github.rest.repos.get({ owner, repo })).data.default_branch;
+            const rawPulls = await github.paginate(github.rest.pulls.list, {
+              owner, repo, state: "open", per_page: 100,
+            });
+            // Same-repo PRs only: a fork PR sharing a branch name would corrupt
+            // branch-name-keyed tree derivation.
+            const pullRequests = rawPulls
+              .filter((pr) => pr.head.repo?.full_name === `${owner}/${repo}`)
+              .map((pr) => ({
+                number: pr.number,
+                title: pr.title,
+                headRefName: pr.head.ref,
+                baseRefName: pr.base.ref,
+                body: pr.body ?? "",
+              }));
+
+            const writeBody = async (number, body) => {
+              await github.rest.pulls.update({ owner, repo, pull_number: number, body });
+            };
+
+            // Root values can arrive as strings (dispatch payloads) or typos
+            // (manual input); coerce to a positive integer.
+            const parseRoot = (value) => {
+              const parsed = Number(value);
+              return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+            };
+
+            // repository_dispatch always carries client_payload.root (stage 1 sets
+            // it); workflow_dispatch carries inputs.root (empty → reconcile all).
+            let roots;
+            if (context.eventName === "repository_dispatch") {
+              const root = parseRoot(context.payload.client_payload?.root);
+              if (root === undefined) {
+                core.setFailed(`repository_dispatch requires a positive integer client_payload.root; got ${JSON.stringify(context.payload.client_payload?.root)}`);
+                return;
+              }
+              // The root came from stage 1 but the stack may have shifted since.
+              const actualRoot = stack.findRoot(root, pullRequests, defaultBranch);
+              if (actualRoot === undefined) {
+                // Documented race: the root merged/closed between dispatch and
+                // reconcile. Safe, explicit no-op — a later event re-resolves.
+                core.info(`root #${root} is no longer an open PR; nothing to reconcile.`);
+                return;
+              }
+              // Normalize to the current true root in case membership changed.
+              roots = [actualRoot];
+            } else {
+              const rawInput = context.payload.inputs?.root;
+              if (rawInput) {
+                const root = parseRoot(rawInput);
+                if (root === undefined) {
+                  core.setFailed(`workflow_dispatch input "root" must be a positive integer PR number; got "${rawInput}"`);
+                  return;
+                }
+                // Manual input: fail loudly if it isn't an open PR or isn't the
+                // actual stack root, rather than reconciling the wrong subtree.
+                const actualRoot = stack.findRoot(root, pullRequests, defaultBranch);
+                if (actualRoot === undefined) {
+                  core.setFailed(`workflow_dispatch input #${root} is not an open PR.`);
+                  return;
+                }
+                if (actualRoot !== root) {
+                  core.setFailed(`workflow_dispatch input #${root} is not a stack root; its root is #${actualRoot}. Re-run with #${actualRoot}, or leave the input empty to reconcile all stacks.`);
+                  return;
+                }
+                roots = [root];
+              } else {
+                roots = stack.findAllRoots(pullRequests, defaultBranch);
+              }
+            }
+
+            // reconcile() continues past an individual failed write (safe
+            // failure) and records it; surface any such failures as a job
+            // failure so an inconsistent breadcrumb doesn't pass silently.
+            const failures = [];
+            for (const root of roots) {
+              const result = await stack.reconcile(root, { pullRequests, writeBody });
+              core.info(`reconciled root #${root}: ${JSON.stringify(result)}`);
+              failures.push(...result.failed);
+            }
+            if (failures.length > 0) {
+              core.setFailed(`Failed to update ${failures.length} PR body/bodies: ${failures.map((n) => `#${n}`).join(", ")}. See logs above.`);
+            }
diff --git a/eslint.config.js b/eslint.config.js
index 9eec9137..112c58c7 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -17,6 +17,9 @@ export default tseslint.config(
       "openspec/",
       "**/test/fixtures/",
       "tmp/",
+      // Zero-dependency CommonJS workflow scripts (covered by their own
+      // node:test suite); the app's TS/ESM-oriented rules don't apply.
+      ".github/scripts/",
     ],
   },
   eslint.configs.recommended,