@mutmutco/cli 4.0.18 → 4.1.0

package/dist/main.cjs

@@ -5680,8 +5680,8 @@ var program = new Command();
 
 // src/index.ts
 var import_promises8 = require("node:fs/promises");
-var import_node_fs42 = require("node:fs");
-var import_node_child_process19 = require("node:child_process");
+var import_node_fs43 = require("node:fs");
+var import_node_child_process20 = require("node:child_process");
 init_cli_shared();
 
 // src/issue-surface.ts
@@ -5696,6 +5696,10 @@ function surfaceLabel(value) {
   const v = value.trim();
   return v.toLowerCase().startsWith(SURFACE_PREFIX) ? v : `${SURFACE_PREFIX}${v}`;
 }
+function surfaceLabelsFromParsed(parsed) {
+  if (!Array.isArray(parsed)) return void 0;
+  return parsed.map((entry) => typeof entry === "string" ? entry : entry.name).filter((n) => typeof n === "string" && n.toLowerCase().startsWith(SURFACE_PREFIX));
+}
 async function readRepoSurfaceLabels(repo, deps = {}) {
   const run = deps.run ?? execFileP2;
   try {
@@ -5704,9 +5708,17 @@ async function readRepoSurfaceLabels(repo, deps = {}) {
       ["label", "list", "--repo", repo, "--limit", "1000", "--json", "name"],
       { timeout: SURFACE_READ_TIMEOUT_MS }
     );
-    const parsed = JSON.parse(stdout);
-    if (!Array.isArray(parsed)) return void 0;
-    return parsed.map((l) => l.name).filter((n) => typeof n === "string" && n.toLowerCase().startsWith(SURFACE_PREFIX));
+    const labels = surfaceLabelsFromParsed(JSON.parse(stdout));
+    if (labels !== void 0) return labels;
+  } catch {
+  }
+  try {
+    const { stdout } = await run(
+      "gh",
+      ["api", "--paginate", `repos/${repo}/labels`],
+      { timeout: SURFACE_READ_TIMEOUT_MS }
+    );
+    return surfaceLabelsFromParsed(JSON.parse(stdout));
   } catch {
     return void 0;
   }
@@ -5740,7 +5752,7 @@ async function checkSurfaceRequirement(input, deps = {}) {
       warn: `warning: could not read ${input.repo}'s labels, so the surface-label requirement was not checked; if that board enforces one surface:* label per open issue, add one with \`mmi-cli oracle issue edit <n> --add-label surface:<value>\``
     };
   }
-  if (known.length === 0) return { enforcing: false };
+  if (known.length === 0) return { enforcing: false, taxonomyAbsent: true };
   if (labelsCarrySurface(input.labels)) return { enforcing: true };
   const command = input.command ?? "issue create";
   const where = input.rowLabel ? `${input.rowLabel}: ` : "";
@@ -5774,7 +5786,11 @@ function conflictingSurfaceInputs(surfaceFlag, labels) {
 }
 async function surfaceLabelApplies(repo, deps = {}) {
   const known = await (deps.read ?? readRepoSurfaceLabels)(repo, { run: deps.run });
-  return (known?.length ?? 0) > 0;
+  if (known === void 0) return true;
+  return known.length > 0;
+}
+function shouldWithdrawSurfaceFlag(result) {
+  return result.taxonomyAbsent === true;
 }
 
 // src/index.ts
@@ -6677,7 +6693,8 @@ var COMMAND_LADDER_WRITES = [
   { gh: "gh pr merge", replacement: "mmi-cli devops pr merge (or mmi-cli devops pr land)" }
 ];
 var COMMAND_LADDER_READS = [
-  { gh: "gh issue view <N>", replacement: "mmi-cli oracle issue view <N>" },
+  // #5483: `show` aliases `view` for board-verb callers; advertise the canonical read plus the alias.
+  { gh: "gh issue view <N>", replacement: "mmi-cli oracle issue view <N> (alias: show)" },
   { gh: "gh pr view <N>", replacement: "mmi-cli devops pr view <N>" },
   { gh: "gh pr checks <N>", replacement: "mmi-cli devops pr checks-wait <N>" }
 ];
@@ -6705,7 +6722,7 @@ function commandLadderHint() {
 }
 
 // src/index.ts
-var import_node_path39 = require("node:path");
+var import_node_path40 = require("node:path");
 
 // src/merge-ci-policy.ts
 function resolveMergeCiPolicy(input) {
@@ -7609,7 +7626,7 @@ function extractForwardRefs(markdown) {
   });
   return refs;
 }
-function checkPins(root, readFile6, docs2) {
+function checkPins(root, readFile7, docs2) {
   const findings = [];
   for (const [doc, markdown] of Object.entries(docs2)) {
     for (const pin of extractPins(markdown)) {
@@ -7617,7 +7634,7 @@ function checkPins(root, readFile6, docs2) {
         findings.push({ kind: "malformed-pin", doc, line: pin.line, detail: pin.text });
         continue;
       }
-      const source = readFile6((0, import_node_path11.join)(root, pin.file));
+      const source = readFile7((0, import_node_path11.join)(root, pin.file));
       if (source == null) {
         findings.push({ kind: "missing-test", doc, line: pin.line, detail: pin.file });
         continue;
@@ -7831,7 +7848,7 @@ function defaultTrackedFirstSegments(root, firstSegments, exec = import_node_chi
   }
 }
 function runDocRefs(root, deps = {}) {
-  const readFile6 = deps.readFile ?? readFileOrNull;
+  const readFile7 = deps.readFile ?? readFileOrNull;
   const exists = deps.exists ?? import_node_fs13.existsSync;
   const listDocs = deps.listDocs ?? defaultListDocs;
   const isIgnored = deps.isIgnored ?? ((paths) => defaultIsIgnored(root, paths));
@@ -7840,11 +7857,11 @@ function runDocRefs(root, deps = {}) {
   const walked = listDocs(root);
   const ignoredDocs = walked.length ? isIgnored(walked) : /* @__PURE__ */ new Set();
   const docs2 = Object.fromEntries(
-    walked.filter((rel) => !ignoredDocs.has(rel)).map((rel) => [rel, readFile6((0, import_node_path11.join)(root, rel))]).filter(([, body]) => body != null)
+    walked.filter((rel) => !ignoredDocs.has(rel)).map((rel) => [rel, readFile7((0, import_node_path11.join)(root, rel))]).filter(([, body]) => body != null)
   );
   const refResult = checkRefs(root, { exists, isIgnored, trackedFirstSegments }, docs2);
   const findings = [
-    ...checkPins(root, readFile6, docs2).findings,
+    ...checkPins(root, readFile7, docs2).findings,
     ...refResult.findings
   ];
   if (commandPaths == null) {
@@ -7867,11 +7884,11 @@ function runDocRefs(root, deps = {}) {
 
 // src/docs-index-command.ts
 var DOCS_INDEX_PATH = "docs/index.md";
+var GENERATED_HEADER = "<!-- Generated by `mmi-cli oracle docs index --write`. Do not edit by hand. -->";
 function isRoutableDocsPath(relPath) {
   const normalized = relPath.replace(/\\/g, "/");
   return normalized !== "index.md" && normalized.split("/")[0]?.toLowerCase() !== "archive";
 }
-var GENERATED_HEADER = "<!-- Generated by `mmi-cli oracle docs index --write`. Do not edit by hand. -->";
 function plainInline(text) {
   return text.replace(/\r?\n/g, " ").replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/`/g, "").replace(/\*+/g, "").replace(/~~/g, "").replace(/__([^_]+)__/g, "$1").replace(/(^|[\s(])_([^_]+)_($|[\s).,!?:;])/g, "$1$2$3").replace(/^>\s*/, "").replace(/\\([\\`*_\[\]{}()#+.!|>-])/g, "$1").replace(/\s+/g, " ").trim();
 }
@@ -8580,22 +8597,22 @@ function labelsToPrune(orgLabelNames) {
   const org = new Set(orgLabelNames);
   return GITHUB_DEFAULT_LABELS.filter((name) => !org.has(name));
 }
-function resolveSeedContent(seed, vars, readFile6) {
-  if (seed.source === "self") return readFile6(seed.target);
+function resolveSeedContent(seed, vars, readFile7) {
+  if (seed.source === "self") return readFile7(seed.target);
   if (seed.source.startsWith("seed:")) {
-    const tmpl = readFile6(`skills/bootstrap/seeds/${seed.source.slice("seed:".length)}`);
+    const tmpl = readFile7(`skills/bootstrap/seeds/${seed.source.slice("seed:".length)}`);
     return tmpl == null ? null : renderSeed(tmpl, vars);
   }
   return null;
 }
-function resolveSeedWriteContent(seed, vars, readFile6, remoteContent) {
+function resolveSeedWriteContent(seed, vars, readFile7, remoteContent) {
   if (!seed.managedBlock) {
-    return { ok: true, content: resolveSeedContent(seed, vars, readFile6), managed: seed.source === "managed-block" };
+    return { ok: true, content: resolveSeedContent(seed, vars, readFile7), managed: seed.source === "managed-block" };
   }
-  const base = remoteContent ?? resolveSeedContent(seed, vars, readFile6);
+  const base = remoteContent ?? resolveSeedContent(seed, vars, readFile7);
   if (base == null) return { ok: true, content: null, managed: true };
   const blockSeed = { ...seed, source: seed.managedBlock.source, managedBlock: void 0 };
-  const desired = resolveSeedContent(blockSeed, vars, readFile6);
+  const desired = resolveSeedContent(blockSeed, vars, readFile7);
   if (desired == null) return { ok: true, content: null, managed: true };
   const result = upsertManagedSeedBlock(base, desired, seed.managedBlock.begin, seed.managedBlock.end);
   return result.ok ? { ok: true, content: result.content, managed: true } : { ok: false, reason: result.reason, managed: true };
@@ -9318,6 +9335,7 @@ init_github_client();
 
 // ../infra/registry-endpoints.mjs
 var PROJECTS_LIST_PATH = "/projects/list";
+var DEPLOY_PORT_COLLISIONS_PATH = "/projects/deploy-port-collisions";
 var ORG_CONFIG_PATH = "/org/config";
 var PROJECTS_ENVELOPE_KEY = "projects";
 var REGISTRY_FETCH_TIMEOUT_MS = 8e3;
@@ -10318,6 +10336,188 @@ function isPriorityFieldConfigured(cfg) {
 
 // src/gh-create.ts
 init_cli_shared();
+init_github_client();
+
+// src/github-quota.ts
+init_github_client();
+var RATE_LIMIT_WAIT_CAP_MS = 12e4;
+var RateLimitedError = class extends Error {
+  receipt;
+  constructor(receipt) {
+    super(receipt.message);
+    this.name = "RateLimitedError";
+    this.receipt = receipt;
+  }
+};
+function isRateLimitedError(e) {
+  return e instanceof RateLimitedError;
+}
+function isRateLimitText(text) {
+  return /API rate limit already exceeded|rate limit already exceeded|RATE_LIMITED|secondary rate|abuse detection|HTTP\/?\d*(?:\.\d)?\s+429\b|\b429\b.*rate limit/i.test(text) || /rate limit/i.test(text) && !/not rate.?limit/i.test(text);
+}
+function isRateLimitRefusal(e) {
+  if (e instanceof GitHubApiError && e.rateLimited) return true;
+  if (e instanceof GitHubApiError && e.status === 403) {
+    return /rate limit|abuse detection|secondary rate/i.test(e.message);
+  }
+  if (e instanceof RateLimitedError) return true;
+  const text = e instanceof Error ? `${e.message}
+${e.stderr ?? ""}` : String(e ?? "");
+  return isRateLimitText(text);
+}
+function resetEpochFromError(e) {
+  if (e instanceof GitHubApiError && typeof e.rateLimitReset === "number") return e.rateLimitReset;
+  if (e instanceof RateLimitedError && typeof e.receipt.resetEpochSeconds === "number") {
+    return e.receipt.resetEpochSeconds;
+  }
+  return void 0;
+}
+function rateLimitWaitMs(resetEpochSeconds, nowMs, capMs = RATE_LIMIT_WAIT_CAP_MS) {
+  if (typeof resetEpochSeconds !== "number" || !Number.isFinite(resetEpochSeconds)) return void 0;
+  const wait = resetEpochSeconds * 1e3 - nowMs;
+  if (wait <= 0) return 0;
+  if (wait > capMs) return void 0;
+  return wait;
+}
+function rateLimitedReceipt(opts) {
+  const resetEpochSeconds = opts.resetEpochSeconds;
+  const resetAt = typeof resetEpochSeconds === "number" ? new Date(resetEpochSeconds * 1e3).toISOString() : void 0;
+  const note = rateLimitResetNote(resetEpochSeconds, opts.nowMs ?? Date.now());
+  const context = opts.context ?? "GitHub API";
+  const remaining = opts.remaining && (opts.remaining.graphql !== void 0 || opts.remaining.core !== void 0) ? opts.remaining : void 0;
+  return {
+    status: "rate_limited",
+    ...resetEpochSeconds !== void 0 ? { resetEpochSeconds } : {},
+    ...resetAt ? { resetAt } : {},
+    message: opts.message ?? `${context}: ${note}`,
+    retryCommand: opts.retryCommand,
+    ...remaining ? { remaining } : {}
+  };
+}
+async function runWithRateLimitBackoff(operation, opts) {
+  const sleep2 = opts.sleep ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
+  const now = opts.now ?? Date.now;
+  const log = opts.log ?? ((message) => console.warn(message));
+  const capMs = opts.capMs ?? RATE_LIMIT_WAIT_CAP_MS;
+  const tryOnce = async () => {
+    try {
+      return await operation();
+    } catch (e) {
+      if (!isRateLimitRefusal(e) || !opts.fallback) throw e;
+      try {
+        return await opts.fallback();
+      } catch (e2) {
+        if (isRateLimitRefusal(e2)) throw e2;
+        throw e2;
+      }
+    }
+  };
+  try {
+    return await tryOnce();
+  } catch (e) {
+    if (!isRateLimitRefusal(e)) throw e;
+    const reset = resetEpochFromError(e);
+    const waitMs = rateLimitWaitMs(reset, now(), capMs);
+    if (waitMs === void 0) {
+      throw new RateLimitedError(rateLimitedReceipt({
+        resetEpochSeconds: reset,
+        retryCommand: opts.retryCommand,
+        context: opts.context,
+        nowMs: now()
+      }));
+    }
+    if (waitMs > 0) {
+      log(`${opts.context}: rate-limited \u2014 waiting ${Math.round(waitMs / 1e3)}s for pool reset`);
+      await sleep2(waitMs);
+    }
+    try {
+      return await tryOnce();
+    } catch (e2) {
+      if (!isRateLimitRefusal(e2)) throw e2;
+      throw new RateLimitedError(rateLimitedReceipt({
+        resetEpochSeconds: resetEpochFromError(e2) ?? reset,
+        retryCommand: opts.retryCommand,
+        context: opts.context,
+        nowMs: now()
+      }));
+    }
+  }
+}
+
+// src/repo-resolve.ts
+init_cli_shared();
+
+// src/registry-degrade.ts
+function registryDegradeError(error) {
+  return new Error(
+    `Hub registry read failed (${error}) \u2014 board coords could not be discovered. This is NOT necessarily the registry: a local DNS/network fault reaches this path as a timeout too. Check in order \u2014 (1) resolve the Hub API host (fails in seconds and rules out the local-network class), (2) if it resolves, retry: a Lambda cold start clears shortly, (3) if it still fails, check auth (a rejected credential is not a timeout).`
+  );
+}
+
+// src/config-discovery.ts
+function stripMutableBoardConfig(cfg) {
+  const {
+    projectOwner: _projectOwner,
+    projectNumber: _projectNumber,
+    projectId: _projectId,
+    statusFieldId: _statusFieldId,
+    statusOptions: _statusOptions,
+    priorityFieldId: _priorityFieldId,
+    priorityOptions: _priorityOptions,
+    ...rest
+  } = cfg;
+  return rest;
+}
+function boardConfigFromProject(meta, floor = {}) {
+  return {
+    ...stripMutableBoardConfig(floor),
+    projectOwner: meta.projectOwner,
+    projectNumber: meta.projectNumber,
+    projectId: meta.projectId,
+    statusFieldId: meta.statusFieldId,
+    statusOptions: meta.statusOptions,
+    priorityFieldId: meta.priorityFieldId,
+    priorityOptions: meta.priorityOptions
+  };
+}
+
+// src/repo-resolve.ts
+function slugOf(repoOrSlug) {
+  return (repoOrSlug.includes("/") ? repoOrSlug.split("/").pop() : repoOrSlug).toLowerCase();
+}
+function repoFromRemoteUrl(remoteUrl) {
+  const m = remoteUrl.trim().match(/^(?:[a-z][a-z0-9+.-]*:\/\/)?(?:[^@\s/]+@)?github\.com[:/]([^/\s:]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+  return m ? `${m[1]}/${m[2]}` : void 0;
+}
+function repoFromSelector(selector) {
+  const trimmed = selector.trim();
+  const url = trimmed.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/(?:issues|pull)\/\d+$/i);
+  if (url) return url[1];
+  const qualified = trimmed.match(/^([^/\s#]+\/[^/\s#]+)#\d+$/);
+  return qualified?.[1];
+}
+async function resolveRepo(repo) {
+  if (repo) return repo;
+  const fromOrigin = repoFromRemoteUrl(await gitOut(["remote", "get-url", "origin"])) ?? repoFromRemoteUrl(originUrlFromGitConfig() ?? "");
+  if (fromOrigin) return fromOrigin;
+  try {
+    const { stdout } = await execFileP2("gh", ["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"], { timeout: 5e3 });
+    return stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function loadConfigForBoardSelector(selector, repoOption) {
+  const targetRepo3 = repoFromSelector(selector) ?? repoOption;
+  const floor = await loadConfig();
+  if (!floor.sagaApiUrl) return stripMutableBoardConfig(floor);
+  const slug = targetRepo3 ? slugOf(targetRepo3) : await repoSlug();
+  const read = await fetchProjectBySlugChecked(slug, registryClientDeps(floor));
+  if (!read.ok) throw registryDegradeError(read.error);
+  return read.project ? boardConfigFromProject(read.project, floor) : stripMutableBoardConfig(floor);
+}
+
+// src/gh-create.ts
 var ISSUE_TYPES = ["bug", "feature", "task"];
 var GH_MUTATION_TIMEOUT_MS = 12e4;
 function timeoutKillNote(err, timeoutMs) {
@@ -10440,6 +10640,101 @@ function parseExistingPr(stderr) {
 }
 var GH_CREATE_UPSTREAM_RETRIES = 3;
 var GH_CREATE_RETRY_BACKOFF_MS = [2e3, 5e3];
+function isGhCreateRateLimited(result) {
+  return result.status === "rate_limited";
+}
+var isGhRateLimitError = isRateLimitText;
+function flagValue(args, flag) {
+  const i = args.indexOf(flag);
+  if (i === -1 || i + 1 >= args.length) return void 0;
+  return args[i + 1];
+}
+function buildPrCreateRetryCommand(args) {
+  const parts = ["mmi-cli", "devops", "pr", "create"];
+  for (const flag of ["--repo", "--base", "--head", "--title"]) {
+    const v = flagValue(args, flag);
+    if (v !== void 0) parts.push(flag, shellQuote(v));
+  }
+  const bodyFile = flagValue(args, "--body-file");
+  if (bodyFile !== void 0) parts.push("--body-file", shellQuote(bodyFile));
+  else {
+    const body = flagValue(args, "--body");
+    if (body !== void 0) parts.push("--body", shellQuote(body));
+  }
+  if (args.includes("--draft")) parts.push("--draft");
+  return parts.join(" ");
+}
+function collectLabelFlags(args) {
+  const labels = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--label" && i + 1 < args.length) {
+      labels.push(args[i + 1]);
+      i++;
+    }
+  }
+  return labels;
+}
+function buildIssueCreateRetryCommand(args) {
+  const parts = ["mmi-cli", "oracle", "issue", "create"];
+  const repo = flagValue(args, "--repo");
+  if (repo !== void 0) parts.push("--repo", shellQuote(repo));
+  const labels = collectLabelFlags(args);
+  const type = labels.find((l) => ISSUE_TYPES.includes(l));
+  if (type) parts.push("--type", type);
+  const title = flagValue(args, "--title");
+  if (title !== void 0) parts.push("--title", shellQuote(title));
+  const bodyFile = flagValue(args, "--body-file");
+  if (bodyFile !== void 0) parts.push("--body-file", shellQuote(bodyFile));
+  else {
+    const body = flagValue(args, "--body");
+    if (body !== void 0) parts.push("--body", shellQuote(body));
+  }
+  for (const label of labels) {
+    if (label === type) continue;
+    parts.push("--label", shellQuote(label));
+  }
+  return parts.join(" ");
+}
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:@+=,-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function parseRateLimitPools(stdout) {
+  try {
+    const resources = JSON.parse(stdout).resources;
+    const out = {};
+    if (typeof resources?.graphql?.remaining === "number" && typeof resources.graphql.reset === "number") {
+      out.graphql = { remaining: resources.graphql.remaining, reset: resources.graphql.reset };
+    }
+    if (typeof resources?.core?.remaining === "number" && typeof resources.core.reset === "number") {
+      out.core = { remaining: resources.core.remaining, reset: resources.core.reset };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function rateLimitedResult(opts) {
+  const remaining = opts.remaining ?? remainingFromPools(opts.pools);
+  return rateLimitedReceipt({
+    ...opts,
+    context: opts.context ?? "pr create",
+    message: opts.message,
+    remaining
+  });
+}
+function remainingFromPools(pools) {
+  if (!pools) return void 0;
+  const remaining = {};
+  if (typeof pools.graphql?.remaining === "number") remaining.graphql = pools.graphql.remaining;
+  if (typeof pools.core?.remaining === "number") remaining.core = pools.core.remaining;
+  return remaining.graphql !== void 0 || remaining.core !== void 0 ? remaining : void 0;
+}
+function execErrorText(err) {
+  if (typeof err !== "object" || err === null) return String(err ?? "");
+  const e = err;
+  return [e.stderr, e.stdout, e.message].filter((s) => typeof s === "string" && s.trim()).join("\n");
+}
 function httpStatusCodes(stderr) {
   const out = [];
   for (const m of stderr.matchAll(/\bHTTP\/?\d*(?:\.\d)?\s+(\d{3})\b/g)) out.push(Number(m[1]));
@@ -10460,19 +10755,362 @@ function upstreamFaultMessage(verb, stderr) {
   const advice = mayRetryCreate(verb) ? "Retrying is the right action" : "The write may have completed server-side before the error \u2014 VERIFY before retrying, or a retry will duplicate it";
   return `gh ${verb} create failed: GitHub's API is failing (server-side 5xx) \u2014 this is NOT a problem with your diff or arguments. GitHub request ID: ${requestId ?? "unavailable"}. ${advice}; note githubstatus.com may still read green while this is happening.`;
 }
+async function resolveRepoForCreate(args, exec) {
+  const fromFlag = flagValue(args, "--repo");
+  if (fromFlag) return fromFlag;
+  try {
+    const { stdout } = await exec("git", ["remote", "get-url", "origin"], { timeout: 1e4 });
+    const fromOrigin = repoFromRemoteUrl(stdout.trim());
+    if (fromOrigin) return fromOrigin;
+  } catch {
+  }
+  return repoFromRemoteUrl(originUrlFromGitConfig() ?? "") || void 0;
+}
+async function resolveHeadForCreate(args, exec) {
+  const fromFlag = flagValue(args, "--head");
+  if (fromFlag) return fromFlag;
+  try {
+    const { stdout } = await exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: 1e4 });
+    const head = stdout.trim();
+    return head && head !== "HEAD" ? head : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveBodyForCreate(args, read) {
+  const bodyFile = flagValue(args, "--body-file");
+  if (bodyFile !== void 0) return read(bodyFile, "utf8");
+  return flagValue(args, "--body") ?? "";
+}
+async function defaultFindOpenPr(exec, input) {
+  const owner = input.repo.split("/")[0];
+  if (!owner) return void 0;
+  const qs = new URLSearchParams({ state: "open", head: `${owner}:${input.head}` });
+  if (input.base) qs.set("base", input.base);
+  try {
+    const { stdout } = await exec("gh", ["api", `repos/${input.repo}/pulls?${qs.toString()}`], { timeout: GH_MUTATION_TIMEOUT_MS });
+    const rows = JSON.parse(stdout);
+    const first = Array.isArray(rows) ? rows[0] : void 0;
+    if (typeof first?.number === "number" && typeof first.html_url === "string") {
+      return { number: first.number, url: first.html_url, existing: true };
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function defaultRestCreatePr(exec, input, deps = {}) {
+  const write = deps.write ?? import_promises.writeFile;
+  const remove2 = deps.remove ?? import_promises.unlink;
+  const ensureDir = deps.ensureDir ?? import_promises.mkdir;
+  const dir = deps.dir ?? (0, import_node_os4.tmpdir)();
+  const file = (0, import_node_path13.join)(dir, `mmi-rest-pr-${process.pid}-${(0, import_node_crypto3.randomBytes)(4).toString("hex")}.json`);
+  const payload = {
+    title: input.title,
+    head: input.head,
+    body: input.body
+  };
+  if (input.base) payload.base = input.base;
+  if (input.draft) payload.draft = true;
+  await ensureDir((0, import_node_path13.dirname)(file), { recursive: true }).catch(() => {
+  });
+  await write(file, JSON.stringify(payload), "utf8");
+  const args = [
+    "api",
+    "--method",
+    "POST",
+    `repos/${input.repo}/pulls`,
+    "--input",
+    file
+  ];
+  try {
+    const { stdout } = await exec("gh", args, { timeout: GH_MUTATION_TIMEOUT_MS });
+    const parsed = JSON.parse(stdout);
+    if (typeof parsed.number === "number" && typeof parsed.html_url === "string") {
+      return { number: parsed.number, url: parsed.html_url };
+    }
+    throw Object.assign(new Error(`REST pr create: unexpected payload: ${stdout.slice(0, 200)}`), { stderr: stdout });
+  } catch (e) {
+    const err = e;
+    const text = execErrorText(err);
+    const fromText = parseExistingPr(text);
+    if (fromText) return { ...fromText, existing: true };
+    if (/already exists/i.test(text)) {
+      const found = await defaultFindOpenPr(exec, { repo: input.repo, head: input.head, base: input.base });
+      if (found) return found;
+    }
+    throw e;
+  } finally {
+    try {
+      await remove2(file);
+    } catch {
+    }
+  }
+}
+async function defaultRestCreateIssue(exec, input) {
+  const args = [
+    "api",
+    "--method",
+    "POST",
+    `repos/${input.repo}/issues`,
+    "-f",
+    `title=${input.title}`,
+    "-f",
+    `body=${input.body}`
+  ];
+  for (const label of input.labels ?? []) {
+    args.push("-f", `labels[]=${label}`);
+  }
+  try {
+    const { stdout } = await exec("gh", args, { timeout: GH_MUTATION_TIMEOUT_MS });
+    const parsed = JSON.parse(stdout);
+    if (typeof parsed.number === "number" && typeof parsed.html_url === "string") {
+      return { number: parsed.number, url: parsed.html_url };
+    }
+    throw Object.assign(new Error(`REST issue create: unexpected payload: ${stdout.slice(0, 200)}`), { stderr: stdout });
+  } catch (e) {
+    const err = e;
+    const text = `${err.stderr ?? ""}
+${err.message ?? ""}
+${err.stdout ?? ""}`;
+    if (isRateLimitText(text)) {
+      throw Object.assign(new Error(text.trim() || "REST issue create rate-limited"), {
+        stderr: err.stderr ?? text
+      });
+    }
+    throw e;
+  }
+}
+async function defaultReadRateLimit(exec) {
+  try {
+    const { stdout } = await exec("gh", ["api", "rate_limit"], { timeout: 15e3 });
+    return parseRateLimitPools(stdout);
+  } catch {
+    return {};
+  }
+}
+async function createIssueViaRestFallback(args, swappedArgs, deps) {
+  const retryCommand = buildIssueCreateRetryCommand(args);
+  const repo = await resolveRepoForCreate(args, deps.exec);
+  const title = flagValue(args, "--title");
+  if (!repo || !title) {
+    const pools2 = await deps.readRateLimit();
+    const reset = pools2.graphql?.reset ?? pools2.core?.reset;
+    return rateLimitedResult({
+      resetEpochSeconds: reset,
+      retryCommand,
+      nowMs: deps.now(),
+      pools: pools2,
+      context: "issue create",
+      message: `issue create: GraphQL rate-limited and cannot REST-fallback (need --repo/--title; have repo=${repo ?? "\u2205"} title=${title ? "set" : "\u2205"}) \u2014 ${rateLimitResetNote(reset, deps.now())}`
+    });
+  }
+  const body = await resolveBodyForCreate(swappedArgs, deps.readFile);
+  const labels = collectLabelFlags(args);
+  const pools = await deps.readRateLimit();
+  const coreRemaining = pools.core?.remaining;
+  const coreReset = pools.core?.reset;
+  const graphqlReset = pools.graphql?.reset;
+  if (typeof coreRemaining === "number" && coreRemaining <= 0) {
+    const reset = coreReset ?? graphqlReset;
+    const waitMs = rateLimitWaitMs(reset, deps.now());
+    if (waitMs === void 0) {
+      return rateLimitedResult({
+        resetEpochSeconds: reset,
+        retryCommand,
+        nowMs: deps.now(),
+        pools,
+        context: "issue create",
+        message: `issue create: GraphQL and REST rate limits exhausted \u2014 ${rateLimitResetNote(reset, deps.now())}`
+      });
+    }
+  }
+  console.warn(`issue create: GraphQL rate-limited \u2014 creating via REST POST repos/${repo}/issues (#5489)`);
+  try {
+    return await runWithRateLimitBackoff(
+      () => deps.restCreateIssue({ repo, title, body, labels }),
+      {
+        context: "issue create",
+        retryCommand,
+        sleep: deps.sleep,
+        now: deps.now,
+        log: (message) => console.warn(message)
+      }
+    );
+  } catch (e) {
+    if (isRateLimitedError(e)) {
+      const after = await deps.readRateLimit();
+      return {
+        ...e.receipt,
+        remaining: e.receipt.remaining ?? remainingFromPools(after)
+      };
+    }
+    throw e;
+  }
+}
+async function createPrViaRestFallback(args, swappedArgs, deps, knownPools) {
+  const retryCommand = buildPrCreateRetryCommand(args);
+  const repo = await resolveRepoForCreate(args, deps.exec);
+  const head = await resolveHeadForCreate(args, deps.exec);
+  const base = flagValue(args, "--base");
+  const title = flagValue(args, "--title");
+  if (!repo || !head || !title) {
+    const pools2 = knownPools ?? await deps.readRateLimit();
+    const reset = pools2.graphql?.reset ?? pools2.core?.reset;
+    return rateLimitedResult({
+      resetEpochSeconds: reset,
+      retryCommand,
+      nowMs: deps.now(),
+      pools: pools2,
+      message: `pr create: GraphQL rate-limited and cannot REST-fallback (need --repo/--head/--title; have repo=${repo ?? "\u2205"} head=${head ?? "\u2205"} title=${title ? "set" : "\u2205"}) \u2014 ${rateLimitResetNote(reset, deps.now())}`
+    });
+  }
+  const existing = await deps.findOpenPr({ repo, head, base });
+  if (existing) {
+    console.warn(`pr create: GraphQL rate-limited \u2014 reusing existing open PR #${existing.number} for ${head} (#5451/#5487)`);
+    return existing;
+  }
+  const pools = knownPools ?? await deps.readRateLimit();
+  const coreRemaining = pools.core?.remaining;
+  const graphqlReset = pools.graphql?.reset;
+  const coreReset = pools.core?.reset;
+  if (typeof coreRemaining === "number" && coreRemaining <= 0) {
+    const reset = coreReset ?? graphqlReset;
+    const waitMs = rateLimitWaitMs(reset, deps.now());
+    if (waitMs === void 0) {
+      return rateLimitedResult({
+        resetEpochSeconds: reset,
+        retryCommand,
+        nowMs: deps.now(),
+        pools,
+        message: `pr create: GraphQL and REST rate limits exhausted \u2014 ${rateLimitResetNote(reset, deps.now())}`
+      });
+    }
+    if (waitMs > 0) {
+      console.warn(`pr create: REST pool exhausted \u2014 waiting ${Math.round(waitMs / 1e3)}s for reset (#5451)`);
+      await deps.sleep(waitMs);
+    }
+  } else if (typeof pools.graphql?.remaining === "number" && pools.graphql.remaining <= 0) {
+    const waitMs = typeof coreRemaining === "number" && coreRemaining > 0 ? void 0 : rateLimitWaitMs(graphqlReset, deps.now());
+    if (waitMs && waitMs > 0) {
+      console.warn(`pr create: GraphQL exhausted \u2014 waiting ${Math.round(waitMs / 1e3)}s before REST fallback (#5451)`);
+      await deps.sleep(waitMs);
+    }
+  }
+  const body = await resolveBodyForCreate(swappedArgs, deps.readFile);
+  console.warn(`pr create: GraphQL rate-limited \u2014 creating via REST POST repos/${repo}/pulls (#5451/#5487)`);
+  try {
+    return await deps.restCreatePr({
+      repo,
+      title,
+      body,
+      head,
+      base,
+      draft: args.includes("--draft")
+    });
+  } catch (e) {
+    const err = e;
+    const text = execErrorText(err);
+    if (isGhRateLimitError(text) || /HTTP\/?\d*(?:\.\d)?\s+403\b.*rate limit/i.test(text)) {
+      const after = await deps.readRateLimit();
+      const reset = after.core?.reset ?? after.graphql?.reset ?? err.rateLimitReset ?? coreReset ?? graphqlReset;
+      const waitMs = rateLimitWaitMs(reset, deps.now());
+      if (waitMs !== void 0) {
+        if (waitMs > 0) {
+          console.warn(`pr create: REST also rate-limited \u2014 waiting ${Math.round(waitMs / 1e3)}s for reset (#5451)`);
+          await deps.sleep(waitMs);
+        }
+        try {
+          return await deps.restCreatePr({
+            repo,
+            title,
+            body,
+            head,
+            base,
+            draft: args.includes("--draft")
+          });
+        } catch (e2) {
+          const text2 = execErrorText(e2);
+          if (isGhRateLimitError(text2)) {
+            const after2 = await deps.readRateLimit();
+            return rateLimitedResult({
+              resetEpochSeconds: after2.core?.reset ?? after2.graphql?.reset ?? reset,
+              retryCommand,
+              nowMs: deps.now(),
+              pools: after2,
+              message: `pr create: GraphQL and REST rate limits exhausted \u2014 ${rateLimitResetNote(after2.core?.reset ?? after2.graphql?.reset ?? reset, deps.now())}`
+            });
+          }
+          throw e2;
+        }
+      }
+      return rateLimitedResult({
+        resetEpochSeconds: reset,
+        retryCommand,
+        nowMs: deps.now(),
+        pools: after,
+        message: `pr create: GraphQL and REST rate limits exhausted \u2014 ${rateLimitResetNote(reset, deps.now())}`
+      });
+    }
+    throw e;
+  }
+}
 async function ghCreate(args, deps = {}) {
   const exec = deps.exec ?? execFileP2;
   const sleep2 = deps.sleep ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
+  const now = deps.now ?? Date.now;
+  const read = deps.readFile ?? import_promises.readFile;
+  const restCreatePr = deps.restCreatePr ?? ((input) => defaultRestCreatePr(exec, input));
+  const restCreateIssue = deps.restCreateIssue ?? ((input) => defaultRestCreateIssue(exec, input));
+  const findOpenPr = deps.findOpenPr ?? ((input) => defaultFindOpenPr(exec, input));
+  const readRateLimit = deps.readRateLimit ?? (() => defaultReadRateLimit(exec));
   const swapped = await bodyArgsViaFile(args);
+  const restDeps = {
+    exec,
+    sleep: sleep2,
+    now,
+    readFile: read,
+    restCreatePr,
+    findOpenPr,
+    readRateLimit
+  };
+  const viaRest = async (pools) => {
+    try {
+      const result = await createPrViaRestFallback(args, swapped.args, restDeps, pools);
+      await swapped.cleanup();
+      return result;
+    } catch (restErr) {
+      await swapped.cleanup();
+      const restText = execErrorText(restErr);
+      if (isGhRateLimitError(restText)) {
+        const pools2 = await readRateLimit();
+        return rateLimitedResult({
+          resetEpochSeconds: pools2.core?.reset ?? pools2.graphql?.reset,
+          retryCommand: buildPrCreateRetryCommand(args),
+          nowMs: now(),
+          pools: pools2,
+          message: `pr create: GraphQL and REST rate limits exhausted \u2014 ${rateLimitResetNote(pools2.core?.reset ?? pools2.graphql?.reset, now())}`
+        });
+      }
+      return fail(`gh pr create failed (GraphQL rate-limited; REST fallback also failed): ${restText.trim()}`);
+    }
+  };
   try {
+    if (args[0] === "pr") {
+      const pools = await readRateLimit();
+      if (typeof pools.graphql?.remaining === "number" && pools.graphql.remaining <= 0) {
+        console.warn(
+          typeof pools.core?.remaining === "number" && pools.core.remaining > 0 ? `pr create: GraphQL pool already exhausted (REST core remaining=${pools.core.remaining}) \u2014 skipping gh pr create, using REST (#5487)` : "pr create: GraphQL pool already exhausted \u2014 attempting REST fallback / typed receipt (#5487)"
+        );
+        return await viaRest(pools);
+      }
+    }
     for (let attempt = 1; attempt <= GH_CREATE_UPSTREAM_RETRIES; attempt++) {
       try {
         const { stdout } = await exec("gh", swapped.args, { timeout: GH_MUTATION_TIMEOUT_MS });
         return parseCreatedUrl(stdout);
       } catch (e) {
         const err = e;
-        const errText = `${err.stderr ?? ""}
-${err.message ?? ""}`;
+        const errText = execErrorText(err);
         const faultText = (err.stderr ?? "").trim() ? err.stderr : err.message ?? "";
         const existing = args[0] === "pr" ? parseExistingPr(errText) : void 0;
         if (existing) {
@@ -10480,6 +11118,38 @@ ${err.message ?? ""}`;
           console.warn(`${args[0]} create: a PR already exists for this branch \u2014 #${existing.number} (nothing to do)`);
           return { ...existing, existing: true };
         }
+        if (args[0] === "pr" && isGhRateLimitError(errText)) {
+          return await viaRest();
+        }
+        if (args[0] === "issue" && isGhRateLimitError(errText)) {
+          try {
+            const result = await createIssueViaRestFallback(args, swapped.args, {
+              exec,
+              sleep: sleep2,
+              now,
+              readFile: read,
+              restCreateIssue,
+              readRateLimit
+            });
+            await swapped.cleanup();
+            return result;
+          } catch (restErr) {
+            await swapped.cleanup();
+            const restText = execErrorText(restErr);
+            if (isGhRateLimitError(restText)) {
+              const pools = await readRateLimit();
+              return rateLimitedResult({
+                resetEpochSeconds: pools.core?.reset ?? pools.graphql?.reset,
+                retryCommand: buildIssueCreateRetryCommand(args),
+                nowMs: now(),
+                pools,
+                context: "issue create",
+                message: `issue create: GraphQL and REST rate limits exhausted \u2014 ${rateLimitResetNote(pools.core?.reset ?? pools.graphql?.reset, now())}`
+              });
+            }
+            return fail(`gh issue create failed (GraphQL rate-limited; REST fallback also failed): ${restText.trim()}`);
+          }
+        }
         const note = timeoutKillNote(e, GH_MUTATION_TIMEOUT_MS);
         if (isUpstreamGitHubFault(faultText) && mayRetryCreate(args[0]) && attempt < GH_CREATE_UPSTREAM_RETRIES) {
           const waitMs = GH_CREATE_RETRY_BACKOFF_MS[attempt - 1];
@@ -10488,8 +11158,21 @@ ${err.message ?? ""}`;
           continue;
         }
         await swapped.cleanup();
+        if ((args[0] === "pr" || args[0] === "issue") && isGhRateLimitError(errText)) {
+          const pools = await readRateLimit();
+          const context = args[0] === "issue" ? "issue create" : "pr create";
+          const retryCommand = args[0] === "issue" ? buildIssueCreateRetryCommand(args) : buildPrCreateRetryCommand(args);
+          return rateLimitedResult({
+            resetEpochSeconds: pools.graphql?.reset ?? pools.core?.reset,
+            retryCommand,
+            nowMs: now(),
+            pools,
+            context,
+            message: `${context}: GraphQL rate-limited \u2014 ${rateLimitResetNote(pools.graphql?.reset ?? pools.core?.reset, now())}`
+          });
+        }
         if (isUpstreamGitHubFault(faultText)) return fail(upstreamFaultMessage(args[0], faultText));
-        return fail(`gh ${args[0]} create failed: ${(err.stderr || err.message || String(e)).trim()}${note ? ` (${note})` : ""}`);
+        return fail(`gh ${args[0]} create failed: ${(err.stderr || err.stdout || err.message || String(e)).trim()}${note ? ` (${note})` : ""}`);
       }
     }
     throw new Error("ghCreate: retry loop exhausted without a verdict");
@@ -10497,6 +11180,14 @@ ${err.message ?? ""}`;
     await swapped.cleanup();
   }
 }
+function requireGhCreateOk(result, context = "pr create") {
+  if (isGhCreateRateLimited(result)) {
+    return fail(
+      `${context}: rate_limited \u2014 ${result.message}. retry: ${result.retryCommand}` + (result.resetAt ? ` (resets at ${result.resetAt})` : "")
+    );
+  }
+  return result;
+}
 
 // src/secrets.ts
 var OWNER2 = "mutmutco";
@@ -12176,10 +12867,10 @@ var rollout_plan_default = {
     note: "The v4.0.0 stamp happens at cut time (D6e #4463); until then the candidate is the origin/development head artifacts (built cli/dist + npm pack), identity proven by dist content hash (D6a)."
   },
   baseline: {
-    version: "4.0.18",
-    tag: "v4.0.18",
-    commit: "3d17c6647468",
-    npm: "@mutmutco/cli@4.0.18"
+    version: "4.1.0",
+    tag: "v4.1.0",
+    commit: "4080226297a9",
+    npm: "@mutmutco/cli@4.1.0"
   },
   exitCriterion: "fleet-n-of-n",
   hubOnlyShortcut: "forbidden",
@@ -12196,14 +12887,14 @@ var rollout_plan_default = {
           repo: "mutmutco/mmi-hub",
           role: "canary",
           schedule: "train",
-          v3Target: "v4.0.18"
+          v3Target: "v4.1.0"
         }
       ],
       rollbackTrigger: "Any red inside the post-contract soak window: `devops train gate` FAIL attributable to the v4 doors, Hub endpoint health probe failure, a pre-v4 client admitted instead of receiving actionable HTTP 426, or npm consumer install/doctor failure on the v4-only dist.",
       rollback: {
         independent: true,
-        mechanism: "npm dist-tag latest -> 4.0.18 and redeploy the Hub Lambda from tag v4.0.18 (3d17c6647468); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
-        v3Target: "v4.0.18 (@mutmutco/cli@4.0.18, tag commit 3d17c6647468 \u2014 last known-good release carrying the repo-index v4-only contract)"
+        mechanism: "npm dist-tag latest -> 4.1.0 and redeploy the Hub Lambda from tag v4.1.0 (4080226297a9); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
+        v3Target: "v4.1.0 (@mutmutco/cli@4.1.0, tag commit 4080226297a9 \u2014 last known-good release carrying the repo-index v4-only contract)"
       }
     },
     {
@@ -12687,79 +13378,6 @@ function parentLinkFields(result, error) {
   return {};
 }
 
-// src/config-discovery.ts
-function stripMutableBoardConfig(cfg) {
-  const {
-    projectOwner: _projectOwner,
-    projectNumber: _projectNumber,
-    projectId: _projectId,
-    statusFieldId: _statusFieldId,
-    statusOptions: _statusOptions,
-    priorityFieldId: _priorityFieldId,
-    priorityOptions: _priorityOptions,
-    ...rest
-  } = cfg;
-  return rest;
-}
-function boardConfigFromProject(meta, floor = {}) {
-  return {
-    ...stripMutableBoardConfig(floor),
-    projectOwner: meta.projectOwner,
-    projectNumber: meta.projectNumber,
-    projectId: meta.projectId,
-    statusFieldId: meta.statusFieldId,
-    statusOptions: meta.statusOptions,
-    priorityFieldId: meta.priorityFieldId,
-    priorityOptions: meta.priorityOptions
-  };
-}
-
-// src/repo-resolve.ts
-init_cli_shared();
-
-// src/registry-degrade.ts
-function registryDegradeError(error) {
-  return new Error(
-    `Hub registry read failed (${error}) \u2014 board coords could not be discovered. This is NOT necessarily the registry: a local DNS/network fault reaches this path as a timeout too. Check in order \u2014 (1) resolve the Hub API host (fails in seconds and rules out the local-network class), (2) if it resolves, retry: a Lambda cold start clears shortly, (3) if it still fails, check auth (a rejected credential is not a timeout).`
-  );
-}
-
-// src/repo-resolve.ts
-function slugOf(repoOrSlug) {
-  return (repoOrSlug.includes("/") ? repoOrSlug.split("/").pop() : repoOrSlug).toLowerCase();
-}
-function repoFromRemoteUrl(remoteUrl) {
-  const m = remoteUrl.trim().match(/^(?:[a-z][a-z0-9+.-]*:\/\/)?(?:[^@\s/]+@)?github\.com[:/]([^/\s:]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
-  return m ? `${m[1]}/${m[2]}` : void 0;
-}
-function repoFromSelector(selector) {
-  const trimmed = selector.trim();
-  const url = trimmed.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/(?:issues|pull)\/\d+$/i);
-  if (url) return url[1];
-  const qualified = trimmed.match(/^([^/\s#]+\/[^/\s#]+)#\d+$/);
-  return qualified?.[1];
-}
-async function resolveRepo(repo) {
-  if (repo) return repo;
-  const fromOrigin = repoFromRemoteUrl(await gitOut(["remote", "get-url", "origin"])) ?? repoFromRemoteUrl(originUrlFromGitConfig() ?? "");
-  if (fromOrigin) return fromOrigin;
-  try {
-    const { stdout } = await execFileP2("gh", ["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"], { timeout: 5e3 });
-    return stdout.trim() || void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function loadConfigForBoardSelector(selector, repoOption) {
-  const targetRepo3 = repoFromSelector(selector) ?? repoOption;
-  const floor = await loadConfig();
-  if (!floor.sagaApiUrl) return stripMutableBoardConfig(floor);
-  const slug = targetRepo3 ? slugOf(targetRepo3) : await repoSlug();
-  const read = await fetchProjectBySlugChecked(slug, registryClientDeps(floor));
-  if (!read.ok) throw registryDegradeError(read.error);
-  return read.project ? boardConfigFromProject(read.project, floor) : stripMutableBoardConfig(floor);
-}
-
 // src/issue-view-json.ts
 var DEFAULT_ISSUE_VIEW_FIELDS = "number,title,state,url,labels,author,assignees,milestone,body";
 function normalizeIssueViewJsonFields(tokens2) {
@@ -18764,10 +19382,69 @@ var import_node_path17 = require("node:path");
 var import_node_util6 = require("node:util");
 init_github_client();
 
+// src/board-snapshot.ts
+init_fetch_retry();
+init_client_version();
+var BOARD_SNAPSHOT_TIMEOUT_MS = 25e3;
+function isSnapshotShape(body) {
+  const b = body;
+  return Boolean(
+    b && typeof b === "object" && typeof b.project?.id === "string" && typeof b.project?.title === "string" && typeof b.viewer === "string" && b.viewer.length > 0 && Array.isArray(b.nodes) && Array.isArray(b.writableRepos) && Array.isArray(b.unreadableRepos) && Array.isArray(b.pullRequests) && Array.isArray(b.warnings) && typeof b.partial === "boolean"
+  );
+}
+async function fetchHubBoardSnapshot(request, deps) {
+  if (!deps.baseUrl) return { state: "unavailable", reason: "no Hub API URL (set MMI_HUB_URL or use a current MMI CLI/plugin build)" };
+  const token = await deps.token();
+  if (!token) return { state: "unavailable", reason: "no Hub session token (run `gh auth login`)" };
+  let res;
+  try {
+    res = await fetchWithRetry(
+      deps.fetch ?? fetch,
+      `${deps.baseUrl.replace(/\/$/, "")}/board/snapshot`,
+      {
+        method: "POST",
+        headers: { ...clientVersionHeaders(), Authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify({
+          owner: request.owner,
+          number: request.number,
+          ...request.statusFieldId ? { statusFieldId: request.statusFieldId } : {},
+          activeOnly: request.activeOnly !== false,
+          allowPartial: request.allowPartial === true,
+          includePullRequests: request.includePullRequests !== false
+        })
+      },
+      { attempts: 3, timeoutMs: deps.timeoutMs ?? BOARD_SNAPSHOT_TIMEOUT_MS, sleep: deps.retrySleep }
+    );
+  } catch (e) {
+    return { state: "unavailable", reason: e.message };
+  }
+  if (res.status === 426) return { state: "refused", reason: upgradeRequiredError(res, await res.json().catch(() => null)) };
+  if (res.status === 400 || res.status === 401 || res.status === 403) {
+    const detail = (await res.json().catch(() => null))?.error;
+    return { state: "refused", reason: detail ? `board snapshot HTTP ${res.status}: ${detail}` : `board snapshot HTTP ${res.status}` };
+  }
+  if (!res.ok) return { state: "unavailable", reason: `board snapshot HTTP ${res.status}` };
+  const body = await res.json().catch(() => null);
+  if (!isSnapshotShape(body)) return { state: "unavailable", reason: "malformed board snapshot response" };
+  return { state: "ok", snapshot: body };
+}
+
 // src/board-dependency.ts
 var DEPENDS_ON_LINE = /^\s*[-*]?\s*\*\*Depends on:\*\*\s*(.+)$/im;
 var ISSUE_REF = /([a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+)#(\d+)/g;
 var DEPENDENCY_FETCH_CONCURRENCY = 8;
+var ISSUE_BODY_GRAPHQL = `
+query($repoOwner: String!, $repoName: String!, $number: Int!) {
+  repository(owner: $repoOwner, name: $repoName) {
+    issue(number: $number) { body }
+  }
+}`;
+var ISSUE_STATE_GRAPHQL = `
+query($repoOwner: String!, $repoName: String!, $number: Int!) {
+  repository(owner: $repoOwner, name: $repoName) {
+    issue(number: $number) { state }
+  }
+}`;
 function parseDependsOnRefs(body) {
   const match = body.match(DEPENDS_ON_LINE);
   if (!match) return [];
@@ -18777,27 +19454,66 @@ function parseDependsOnRefs(body) {
   }
   return refs;
 }
-async function issueState(client, repo, number) {
-  try {
+async function readIssueBodyWithQuota(client, repo, number, opts) {
+  const [owner, name] = repo.split("/");
+  if (!owner || !name) throw new Error(`invalid repository ref for issue-body read: ${repo}`);
+  const viaRest = async () => {
+    const data = await client.rest("GET", `repos/${repo}/issues/${number}`);
+    return data?.body ?? "";
+  };
+  const viaGraphql = async () => {
+    const data = await client.graphql(ISSUE_BODY_GRAPHQL, { repoOwner: owner, repoName: name, number });
+    return data.repository?.issue?.body ?? "";
+  };
+  return runWithRateLimitBackoff(viaRest, {
+    context: opts.context ?? `issue-body ${repo}#${number}`,
+    retryCommand: opts.retryCommand,
+    fallback: viaGraphql,
+    sleep: opts.sleep,
+    now: opts.now,
+    log: opts.log,
+    capMs: opts.capMs
+  });
+}
+async function issueState(client, repo, number, quota) {
+  const [owner, name] = repo.split("/");
+  const viaRest = async () => {
     const data = await client.rest("GET", `repos/${repo}/issues/${number}`);
     const state = data?.state?.toLowerCase();
     if (state === "open") return "open";
     if (state === "closed") return "closed";
     return "unknown";
-  } catch {
+  };
+  const viaGraphql = async () => {
+    if (!owner || !name) return "unknown";
+    const data = await client.graphql(ISSUE_STATE_GRAPHQL, { repoOwner: owner, repoName: name, number });
+    const state = data.repository?.issue?.state?.toLowerCase();
+    if (state === "open") return "open";
+    if (state === "closed") return "closed";
+    return "unknown";
+  };
+  try {
+    return await runWithRateLimitBackoff(viaRest, {
+      context: `dependency state ${repo}#${number}`,
+      retryCommand: quota.retryCommand,
+      fallback: viaGraphql
+    });
+  } catch (e) {
+    if (isRateLimitRefusal(e)) throw e;
     return "unknown";
   }
 }
-async function dependencyBlocksClaim(client, body) {
+async function dependencyBlocksClaim(client, body, opts = {}) {
   const refs = parseDependsOnRefs(body);
   if (!refs.length) return { blocked: false, openDependencies: [] };
+  const retryCommand = opts.retryCommand ?? "mmi-cli oracle board claim --check";
   const states = new Array(refs.length);
   let next = 0;
   const worker = async () => {
     while (next < refs.length) {
       const index = next++;
       const ref = refs[index];
-      states[index] = await issueState(client, ref.repo, ref.number);
+      states[index] = await issueState(client, ref.repo, ref.number, { retryCommand });
     }
   };
   await Promise.all(Array.from({ length: Math.min(DEPENDENCY_FETCH_CONCURRENCY, refs.length) }, () => worker()));
@@ -18840,15 +19556,27 @@ async function filterDependencyBlockedClaimables(items, client, opts = {}) {
           continue;
         }
       }
-      const gate = await dependencyBlocksClaim(client, body);
-      if (gate.blocked) {
-        results[index] = {
-          bucket: "blocked",
-          item,
-          warnings: [`${item.ref} blocked on open ${gate.openDependencies.join(", ")}`]
-        };
-      } else {
-        results[index] = { bucket: "claimable", item, warnings: [] };
+      try {
+        const gate = await dependencyBlocksClaim(client, body);
+        if (gate.blocked) {
+          results[index] = {
+            bucket: "blocked",
+            item,
+            warnings: [`${item.ref} blocked on open ${gate.openDependencies.join(", ")}`]
+          };
+        } else {
+          results[index] = { bucket: "claimable", item, warnings: [] };
+        }
+      } catch (e) {
+        if (isRateLimitRefusal(e)) {
+          results[index] = {
+            bucket: "claimable",
+            item,
+            warnings: [`dependency check skipped for ${item.ref} (rate-limited): ${e.message}`]
+          };
+          continue;
+        }
+        throw e;
       }
     }
   };
@@ -19553,10 +20281,64 @@ function renderBoardSource() {
 async function readBoard(options, deps = {}) {
   const cfg = resolveBoardConfig(options.config);
   const client = deps.client ?? defaultGitHubClient();
-  const collected = await collectBoardItems(cfg, { repo: options.repo, allowPartial: options.allowPartial, activeOnly: true }, deps);
-  const writable = await resolveWritableReposForClaimables(collected.items, client);
-  collected.warnings.push(...writable.warnings);
-  collected.partial = collected.partial || writable.partial;
+  let collected;
+  let writable;
+  let pullRequests;
+  let snapshotFallback;
+  const attempt = deps.snapshot ? await fetchHubBoardSnapshot(
+    {
+      owner: cfg.projectOwner,
+      number: cfg.projectNumber,
+      statusFieldId: cfg.statusFieldId,
+      activeOnly: true,
+      allowPartial: options.allowPartial === true
+    },
+    deps.snapshot
+  ) : void 0;
+  if (attempt?.state === "refused") {
+    throw new Error(attempt.reason);
+  }
+  if (attempt?.state === "ok") {
+    const snapshot = attempt.snapshot;
+    const currentRepo = await resolveCurrentRepo(options, deps);
+    const warnings = [...snapshot.warnings];
+    let partial = snapshot.partial;
+    const read = nodesToItems(snapshot.nodes, warnings, cfg);
+    if (read.failures.length) {
+      const message = `partial board read: ${read.failures.length} item(s) came back truncated and were not read \u2014 ${read.failures.join(" | ")}`;
+      if (!options.allowPartial) throw new Error(message);
+      warnings.push(message);
+      partial = true;
+    }
+    for (const unreadable of snapshot.unreadableRepos) {
+      warnings.push(`partial claimable access read: ${unreadable.repo}: viewer write access UNREAD (${unreadable.error})`);
+      partial = true;
+    }
+    collected = {
+      items: read.items,
+      viewer: snapshot.viewer,
+      repo: currentRepo,
+      projectId: snapshot.project.id,
+      projectTitle: snapshot.project.title,
+      warnings,
+      partial
+    };
+    writable = {
+      repos: new Set(snapshot.writableRepos.map((repo) => repo.toLowerCase())),
+      unknown: new Set(snapshot.unreadableRepos.map((entry) => entry.repo.toLowerCase()))
+    };
+    pullRequests = snapshot.pullRequests;
+  } else {
+    if (attempt?.state === "unavailable") snapshotFallback = attempt.reason;
+    collected = await collectBoardItems(cfg, { repo: options.repo, allowPartial: options.allowPartial, activeOnly: true }, deps);
+    if (snapshotFallback) {
+      collected.warnings.push(`Hub board snapshot unavailable (${snapshotFallback}) \u2014 served by the direct user-auth read (emergency fallback)`);
+    }
+    const probed = await resolveWritableReposForClaimables(collected.items, client);
+    collected.warnings.push(...probed.warnings);
+    collected.partial = collected.partial || probed.partial;
+    writable = { repos: probed.repos, unknown: probed.unknown };
+  }
   const groups = partitionBoardItems(collected.items, collected.viewer, collected.repo, writableOrUnknown(writable));
   const report = {
     project: { owner: cfg.projectOwner, number: cfg.projectNumber, id: collected.projectId, title: collected.projectTitle || String(cfg.projectNumber) },
@@ -19565,7 +20347,8 @@ async function readBoard(options, deps = {}) {
     ...groups,
     warnings: collected.warnings,
     partial: collected.partial,
-    source: "live"
+    source: "live",
+    ...pullRequests ? { pullRequests } : {}
   };
   if (options.includeBundleDetails || options.includeAllBodies) {
     await attachBundleDetails(report, client, options.allowPartial ?? false, { all: options.includeAllBodies });
@@ -19752,15 +20535,21 @@ async function claimOneBoardItem(ctx, selector, options) {
     let body = flatItem.details?.body;
     if (body === void 0) {
       try {
-        const data = await client.rest("GET", `repos/${flatItem.repository}/issues/${flatItem.number}`);
-        body = data?.body ?? "";
+        const retryCommand = `mmi-cli oracle board claim ${flatItem.number}${options.check ? " --check" : ""}`;
+        body = await readIssueBodyWithQuota(client, flatItem.repository, flatItem.number, {
+          retryCommand,
+          context: `board claim ${flatItem.ref} issue-body`
+        });
       } catch (e) {
+        if (isRateLimitRefusal(e)) throw e;
         throw new Error(
           `${flatItem.ref} claim refused: could not read the issue body to check dependencies (${ghError(e)}); retry once the GitHub API is reachable`
         );
       }
     }
-    const gate = await dependencyBlocksClaim(client, body);
+    const gate = await dependencyBlocksClaim(client, body, {
+      retryCommand: `mmi-cli oracle board claim ${flatItem.number}${options.check ? " --check" : ""}`
+    });
     if (gate.blocked) {
       throw new Error(`${flatItem.ref} is not claimable: blocked on open ${gate.openDependencies.join(", ")}`);
     }
@@ -20065,11 +20854,7 @@ async function fetchIssueProjectItem(client, cfg, selector) {
   return { viewer, ...read.state === "ok" ? { item: read.item } : {} };
 }
 function isGitHubRateLimitError(e) {
-  if (e instanceof GitHubApiError && e.rateLimited) return true;
-  if (e instanceof GitHubApiError && e.status === 403) {
-    return /rate limit|abuse detection|secondary rate/i.test(e.message);
-  }
-  return /rate limit|API rate limit|secondary rate|abuse detection/i.test(ghError(e));
+  return isRateLimitRefusal(e);
 }
 var ISSUE_DETAILS_GRAPHQL_COMMENTS_PAGE = 100;
 var ISSUE_DETAILS_GRAPHQL_QUERY = `
@@ -20745,6 +21530,13 @@ function ghError(e) {
 }
 
 // src/attach-to-project.ts
+function boardAttachRateLimitedReceipt(resetEpochSeconds) {
+  return {
+    onBoard: false,
+    boardAttach: "rate_limited",
+    ...typeof resetEpochSeconds === "number" ? { resetEpochSeconds, resetAt: new Date(resetEpochSeconds * 1e3).toISOString() } : {}
+  };
+}
 async function resolveAutoAddBoardAttach(client, cfg, selector, priority, warn = (m) => process.stderr.write(m), retry = {}) {
   let projectItemId;
   try {
@@ -22335,7 +23127,7 @@ function checkHotfixCoverage(options = {}) {
     const out = git3(["rev-list", "--no-merges", range]).trim();
     return out ? out.split("\n") : [];
   };
-  const isAncestor = (sha, ref) => {
+  const isAncestor2 = (sha, ref) => {
     try {
       git3(["merge-base", "--is-ancestor", sha, ref]);
       return true;
@@ -22349,7 +23141,7 @@ function checkHotfixCoverage(options = {}) {
     const out = git3(["patch-id", "--stable"], { input: diff }).trim();
     return out ? out.split(" ")[0] : null;
   };
-  const changedPaths = (sha) => {
+  const changedPaths2 = (sha) => {
     const out = git3(["show", "--no-color", "--name-only", "--pretty=format:", sha]).trim();
     return out ? out.split("\n") : [];
   };
@@ -22370,13 +23162,13 @@ function checkHotfixCoverage(options = {}) {
   };
   const commits = mainOnly.map((sha) => {
     const subject = git3(["log", "-1", "--format=%s", sha]).trim();
-    const paths = changedPaths(sha);
+    const paths = changedPaths2(sha);
     if (paths.length > 0 && paths.every((p) => manifestPaths.includes(p))) {
       return { sha, subject, coverage: "exempt-distribution" };
     }
     const sources = cherrySources(sha);
     if (sources.length > 0) {
-      if (sources.every((s) => isAncestor(s, rcRef))) {
+      if (sources.every((s) => isAncestor2(s, rcRef))) {
         return { sha, subject, coverage: "trailer", sources };
       }
       if (ack.some((a) => sha.startsWith(a))) return { sha, subject, coverage: "acked", sources };
@@ -22399,7 +23191,7 @@ function checkHotfixCoverage(options = {}) {
 function checkHotfixCarries(options) {
   const { cwd = process.cwd(), branch, baseRef, targets } = options;
   const git3 = options.git ?? ((args, opts) => (0, import_node_child_process11.execFileSync)("git", args, { cwd, encoding: "utf8", input: opts?.input, stdio: ["pipe", "pipe", "pipe"] }));
-  const isAncestor = (sha, ref) => {
+  const isAncestor2 = (sha, ref) => {
     try {
       git3(["merge-base", "--is-ancestor", sha, ref]);
       return true;
@@ -22421,7 +23213,7 @@ function checkHotfixCarries(options) {
   }
   const shaMatches = (a, b) => a.startsWith(b) || b.startsWith(a);
   const evaluated = targets.map((t) => {
-    if (isAncestor(t.sha, branch)) return { ...t, carried: true, via: "ancestor" };
+    if (isAncestor2(t.sha, branch)) return { ...t, carried: true, via: "ancestor" };
     if ([...carried].some((s) => shaMatches(s, t.sha))) return { ...t, carried: true, via: "trailer" };
     return { ...t, carried: false };
   });
@@ -22533,7 +23325,7 @@ function pathIsTolerated(path2, tolerated) {
     return path2.startsWith(root);
   });
 }
-var HOTFIX_SKILL_TOLERATED_ROOTS = ["skills", ".kilo-plugin/skills"];
+var HOTFIX_SKILL_TOLERATED_ROOTS = ["skills"];
 async function cherryPickWithToleratedPaths(deps, sha, tolerated) {
   try {
     await deps.run("git", ["cherry-pick", "-x", sha]);
@@ -23425,6 +24217,80 @@ async function announceRelease(deps, args) {
 init_github_client();
 init_hub_auth();
 
+// src/deploy-port-doctor.ts
+init_fetch_retry();
+init_client_version();
+
+// ../infra/src/deploy-port-collision.ts
+function formatDeployPortCollisionReportLine(collision) {
+  const owners = collision.owners.map((o) => `${o.slug}/${o.stage}`).join(", ");
+  return `${collision.sshHost}:${collision.port} owned by ${owners} \u2014 reassign one with mmi-cli oracle org project set-deploy mutmutco/<slug> --stage <stage> --port <free-port> (do not auto-reassign live ports from doctor)`;
+}
+
+// src/deploy-port-doctor.ts
+async function fetchDeployPortCollisions(deps) {
+  if (!deps.baseUrl) return { ok: false, collisions: [], error: "no Hub API base URL configured" };
+  const token = await deps.token();
+  if (!token) return { ok: false, collisions: [], error: "no Hub session token", status: 401 };
+  try {
+    const res = await fetchWithRetry(
+      deps.fetch ?? fetch,
+      `${deps.baseUrl.replace(/\/$/, "")}${DEPLOY_PORT_COLLISIONS_PATH}`,
+      {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          Authorization: `Bearer ${token}`,
+          ...clientVersionHeaders()
+        }
+      },
+      { attempts: 3, timeoutMs: deps.timeoutMs ?? REGISTRY_FETCH_TIMEOUT_MS, sleep: deps.retrySleep }
+    );
+    if (res.status === 426) {
+      return { ok: false, collisions: [], error: upgradeRequiredError(res, await res.json().catch(() => null)), status: 426 };
+    }
+    if (res.status === 403) {
+      return { ok: false, collisions: [], error: "master-admin only", status: 403 };
+    }
+    if (!res.ok) {
+      const detail = (await res.json().catch(() => null))?.error;
+      return { ok: false, collisions: [], error: detail ?? `HTTP ${res.status}`, status: res.status };
+    }
+    const body = await res.json();
+    const collisions = [];
+    for (const c of body.collisions ?? []) {
+      if (typeof c.sshHost !== "string" || typeof c.port !== "number" || !Array.isArray(c.owners)) continue;
+      const owners = c.owners.filter((o) => typeof o?.slug === "string" && typeof o?.stage === "string").map((o) => ({ slug: o.slug, stage: o.stage }));
+      if (!owners.length) continue;
+      const report = typeof c.report === "string" && c.report.trim() ? c.report : formatDeployPortCollisionReportLine({
+        sshHost: c.sshHost,
+        port: c.port,
+        owners: owners.map((o) => ({ ...o, sshHost: c.sshHost, port: c.port }))
+      });
+      collisions.push({ sshHost: c.sshHost, port: c.port, owners, report });
+    }
+    return { ok: collisions.length === 0, collisions };
+  } catch (e) {
+    return { ok: false, collisions: [], error: e.message };
+  }
+}
+function renderDeployPortDoctor(report) {
+  if (report.error) {
+    return [`org project deploy doctor: ${report.error}`];
+  }
+  if (report.ok) {
+    return ["org project deploy doctor: OK \u2014 no duplicate (sshHost, port) DEPLOY# coordinates"];
+  }
+  const lines = [
+    `org project deploy doctor: CHECK \u2014 ${report.collisions.length} colliding (sshHost, port) coordinate(s)`
+  ];
+  for (const c of report.collisions) lines.push(`  ${c.report}`);
+  lines.push(
+    "Recovery: reassign one owner with mmi-cli oracle org project set-deploy mutmutco/<slug> --stage <stage> --port <free-port> (never auto-reassign from doctor)"
+  );
+  return lines;
+}
+
 // src/repo-index.ts
 var import_node_crypto6 = require("node:crypto");
 var import_node_child_process12 = require("node:child_process");
@@ -23454,6 +24320,66 @@ function isSafeRepoIndexPath(value) {
   if (segments.some((segment) => !segment || segment === "." || segment === "..")) return false;
   return !isHardDeniedRepoIndexPath(value);
 }
+var REPO_INDEX_ALGORITHM_VERSION = 1;
+var REPO_INDEX_FILTER_VERSION = 2;
+var REPO_INDEX_MATERIAL_LAYOUT_VERSION = 2;
+var LEGACY_REPO_INDEX_PROVENANCE = Object.freeze({
+  algorithmVersion: 1,
+  filterVersion: 1,
+  materialLayoutVersion: 1
+});
+var CURRENT_REPO_INDEX_PROVENANCE = Object.freeze({
+  algorithmVersion: REPO_INDEX_ALGORITHM_VERSION,
+  filterVersion: REPO_INDEX_FILTER_VERSION,
+  materialLayoutVersion: REPO_INDEX_MATERIAL_LAYOUT_VERSION
+});
+function repoIndexProvenanceToken(provenance = CURRENT_REPO_INDEX_PROVENANCE) {
+  const resolved = provenance && typeof provenance === "object" ? provenance : {};
+  return `a${resolved.algorithmVersion}-f${resolved.filterVersion}-l${resolved.materialLayoutVersion}`;
+}
+var CURRENT_REPO_INDEX_PROVENANCE_TOKEN = repoIndexProvenanceToken(CURRENT_REPO_INDEX_PROVENANCE);
+var GENERATED_PROJECTION = Object.freeze([
+  // Host plugin packages: the assembled skills/hooks/scripts/bin payload and the copied host
+  // manifest directory. `packages/<host>-plugin/<file>` at the root stays admitted.
+  /^packages\/(?:claude|codex|kimi|cursor|hermes)-plugin\/(?:skills|hooks|scripts|bin)\//,
+  /^packages\/(?:claude|codex|kimi|cursor|hermes)-plugin\/\.[A-Za-z0-9-]+-plugin\//,
+  // In-repo plugin roots assembled by the same declaration.
+  /^\.kilo-plugin\/(?:skills|scripts)\//,
+  /^\.pi-plugin\/(?:skills|scripts|extensions)\//,
+  // Release metadata regenerated from the tracked tree at every prepare.
+  /^distribution-bom\.json$/,
+  // Cross-repo generator outputs the estate audit named.
+  /^product\/connector\/generated\//,
+  /^packages\/jerv-pi\/generated\/roster\//,
+  /^docs\/\.release-inbox\//
+]);
+function isGeneratedRepoIndexProjection(value) {
+  return typeof value === "string" && GENERATED_PROJECTION.some((pattern) => pattern.test(value));
+}
+function isCanonicalRepoIndexPath(value) {
+  return isSafeRepoIndexPath(value) && !isGeneratedRepoIndexProjection(value);
+}
+function readRepoIndexProvenance(manifest) {
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) return null;
+  const provenance = manifest.indexProvenance;
+  if (provenance === void 0) return { ...LEGACY_REPO_INDEX_PROVENANCE };
+  if (!provenance || typeof provenance !== "object" || Array.isArray(provenance)) return null;
+  const keys = ["algorithmVersion", "filterVersion", "materialLayoutVersion"];
+  if (Object.keys(provenance).length !== keys.length) return null;
+  for (const key of keys) {
+    const value = provenance[key];
+    if (!Number.isInteger(value) || value < 1) return null;
+  }
+  return {
+    algorithmVersion: provenance.algorithmVersion,
+    filterVersion: provenance.filterVersion,
+    materialLayoutVersion: provenance.materialLayoutVersion
+  };
+}
+function isRepoIndexDeltaCompatible(manifest) {
+  const provenance = readRepoIndexProvenance(manifest);
+  return provenance !== null && provenance.algorithmVersion === REPO_INDEX_ALGORITHM_VERSION && provenance.filterVersion === REPO_INDEX_FILTER_VERSION && provenance.materialLayoutVersion === REPO_INDEX_MATERIAL_LAYOUT_VERSION;
+}
 
 // src/repo-index.ts
 var REPO_INDEX_SCHEMA = 1;
@@ -23721,20 +24647,115 @@ function inferRepoSlug(cwd, exec = import_node_child_process12.execFileSync) {
 }
 
 // src/repo-index-cloud-client.ts
-var import_node_crypto9 = require("node:crypto");
+var import_node_crypto10 = require("node:crypto");
 init_fetch_retry();
 init_client_version();
 init_compat();
 
 // src/repo-index-v4/builder.ts
-var import_node_crypto8 = require("node:crypto");
-var import_node_child_process13 = require("node:child_process");
+var import_node_crypto9 = require("node:crypto");
+var import_node_child_process14 = require("node:child_process");
 var import_node_fs25 = require("node:fs");
 var import_node_os12 = require("node:os");
 var import_node_path23 = require("node:path");
 
-// src/repo-index-v4/chunks.ts
+// ../infra/repo-index-material-buckets.mjs
 var import_node_crypto7 = require("node:crypto");
+var REPO_INDEX_MATERIAL_BUCKET_COUNT = 2;
+var REPO_INDEX_MATERIAL_KINDS = Object.freeze(["chunks", "embeddings"]);
+var REPO_INDEX_MATERIAL_PREFIX = "material-v2";
+function canonicalMaterialJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalMaterialJson).join(",")}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalMaterialJson(value[key])}`).join(",")}}`;
+}
+function repoIndexMaterialDigest(value) {
+  return (0, import_node_crypto7.createHash)("sha256").update(canonicalMaterialJson(value)).digest("hex");
+}
+function normalizeRepoIndexMaterialPath(path2) {
+  return String(path2).replace(/^\.\//, "").normalize("NFC");
+}
+function repoIndexMaterialBucket(path2) {
+  const hash = (0, import_node_crypto7.createHash)("sha256").update(normalizeRepoIndexMaterialPath(path2), "utf8").digest();
+  return hash.readUInt32BE(0) % REPO_INDEX_MATERIAL_BUCKET_COUNT;
+}
+function compareRepoIndexChunks(a, b) {
+  const aPath = String(a?.path ?? "");
+  const bPath = String(b?.path ?? "");
+  if (aPath !== bPath) return aPath < bPath ? -1 : 1;
+  const aLine = Number(a?.citations?.[0]?.startLine ?? 0);
+  const bLine = Number(b?.citations?.[0]?.startLine ?? 0);
+  if (aLine !== bLine) return aLine - bLine;
+  const aId = String(a?.id ?? "");
+  const bId = String(b?.id ?? "");
+  return aId === bId ? 0 : aId < bId ? -1 : 1;
+}
+function compareRepoIndexEmbeddings(a, b) {
+  const aId = String(a?.chunkId ?? "");
+  const bId = String(b?.chunkId ?? "");
+  return aId === bId ? 0 : aId < bId ? -1 : 1;
+}
+function stripRepoIndexChunkCommit(chunk) {
+  const citations = Array.isArray(chunk?.citations) ? chunk.citations : [];
+  return {
+    ...chunk,
+    citations: citations.map((citation2) => {
+      const rest = { ...citation2 };
+      delete rest.commit;
+      return rest;
+    })
+  };
+}
+function repoIndexMaterialIndexKey(repoBase, digest) {
+  return `${repoBase}/${REPO_INDEX_MATERIAL_PREFIX}/index/${digest}.json`;
+}
+function repoIndexMaterialIndexUri(repo, digest) {
+  return `s3://${repoIndexMaterialIndexKey(`repo-index/v4/${repo}`, digest)}`;
+}
+function repoIndexMaterialBucketBody(kind, bucket, records) {
+  return { schemaVersion: 4, materialLayoutVersion: 2, kind, bucket, bucketCount: REPO_INDEX_MATERIAL_BUCKET_COUNT, count: records.length, records };
+}
+var bucketBody = repoIndexMaterialBucketBody;
+function buildRepoIndexMaterialLayout(repo, chunks, embeddings) {
+  const chunkList = Array.isArray(chunks) ? chunks : [];
+  const embeddingList = Array.isArray(embeddings) ? embeddings : [];
+  const pathByChunkId = new Map(chunkList.map((chunk) => [String(chunk?.id), String(chunk?.path)]));
+  const grouped = /* @__PURE__ */ new Map();
+  for (const kind of REPO_INDEX_MATERIAL_KINDS) {
+    for (let bucket = 0; bucket < REPO_INDEX_MATERIAL_BUCKET_COUNT; bucket++) grouped.set(`${kind}:${bucket}`, []);
+  }
+  for (const chunk of chunkList) {
+    grouped.get(`chunks:${repoIndexMaterialBucket(chunk?.path)}`).push(stripRepoIndexChunkCommit(chunk));
+  }
+  for (const embedding of embeddingList) {
+    const path2 = pathByChunkId.get(String(embedding?.chunkId));
+    if (path2 === void 0) throw new Error("repo-index material embeds a chunk that is not in the corpus");
+    grouped.get(`embeddings:${repoIndexMaterialBucket(path2)}`).push(embedding);
+  }
+  const buckets = [];
+  for (const kind of REPO_INDEX_MATERIAL_KINDS) {
+    for (let bucket = 0; bucket < REPO_INDEX_MATERIAL_BUCKET_COUNT; bucket++) {
+      const records = grouped.get(`${kind}:${bucket}`);
+      records.sort(kind === "chunks" ? compareRepoIndexChunks : compareRepoIndexEmbeddings);
+      const body = bucketBody(kind, bucket, records);
+      buckets.push({ kind, bucket, count: records.length, digest: repoIndexMaterialDigest(body), body });
+    }
+  }
+  const index = {
+    schemaVersion: 4,
+    materialLayoutVersion: 2,
+    repo,
+    bucketCount: REPO_INDEX_MATERIAL_BUCKET_COUNT,
+    chunkCount: chunkList.length,
+    embeddingCount: embeddingList.length,
+    // Ordered descriptors: chunks buckets ascending, then embeddings buckets ascending.
+    buckets: buckets.map(({ kind, bucket, count, digest }) => ({ kind, bucket, count, digest }))
+  };
+  return { bucketCount: REPO_INDEX_MATERIAL_BUCKET_COUNT, buckets, index, indexDigest: repoIndexMaterialDigest(index) };
+}
+
+// src/repo-index-v4/chunks.ts
+var import_node_crypto8 = require("node:crypto");
 var import_node_fs24 = require("node:fs");
 var import_node_path22 = require("node:path");
 
@@ -23801,7 +24822,7 @@ async function parserFor(language) {
   return parser;
 }
 function sha256(value) {
-  return (0, import_node_crypto7.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto8.createHash)("sha256").update(value).digest("hex");
 }
 function pointerId(path2, kind, contentHash, start, end, symbol) {
   return sha256(["repo-index-v4", path2, kind, contentHash, String(start), String(end), symbol ?? ""].join("\0"));
@@ -23889,12 +24910,17 @@ async function structuralChunksForSource(repo, commit, path2, source) {
     parser?.delete();
   }
 }
-async function buildStructuralChunks(cwd, repo, commit) {
+function canonicalRepoIndexPaths(cwd) {
   const candidates = listCandidatePaths(cwd).filter(isIndexablePath).sort((a, b) => a.localeCompare(b));
   const ignored = defaultIsIgnored(cwd, candidates);
+  return candidates.filter((path2) => !ignored.has(path2) && !isHardDeniedPath(path2) && isCanonicalRepoIndexPath(path2));
+}
+function compareV4Chunks(a, b) {
+  return compareRepoIndexChunks(a, b);
+}
+async function buildStructuralChunksForPaths(cwd, repo, commit, paths) {
   const chunks = [];
-  for (const path2 of candidates) {
-    if (ignored.has(path2) || isHardDeniedPath(path2)) continue;
+  for (const path2 of paths) {
     const absolute = (0, import_node_path22.join)(cwd, ...path2.split("/"));
     if (!(0, import_node_fs24.existsSync)(absolute)) continue;
     let source;
@@ -23905,7 +24931,84 @@ async function buildStructuralChunks(cwd, repo, commit) {
     }
     chunks.push(...await structuralChunksForSource(repo, commit, path2, source));
   }
-  return chunks.sort((a, b) => a.path.localeCompare(b.path) || a.citations[0].startLine - b.citations[0].startLine || a.id.localeCompare(b.id));
+  return chunks.sort(compareV4Chunks);
+}
+async function buildStructuralChunks(cwd, repo, commit) {
+  return buildStructuralChunksForPaths(cwd, repo, commit, canonicalRepoIndexPaths(cwd));
+}
+
+// src/repo-index-v4/delta.ts
+var import_node_child_process13 = require("node:child_process");
+var COMMIT = /^[a-f0-9]{40}$/;
+var V4_DELTA_DEEPEN_STEPS = [50, 250, 1e3];
+function gitRunner(cwd) {
+  return (args) => {
+    const result = (0, import_node_child_process13.spawnSync)("git", [...args], { cwd, encoding: "utf8", windowsHide: true, maxBuffer: 64 * 1024 * 1024 });
+    if (result.error) return { status: -1, stdout: "" };
+    return { status: typeof result.status === "number" ? result.status : -1, stdout: String(result.stdout ?? "") };
+  };
+}
+function parseNameStatusZ(output) {
+  const fields = output.split("\0");
+  if (fields.length && fields[fields.length - 1] === "") fields.pop();
+  const changes = [];
+  for (let i = 0; i < fields.length; ) {
+    const raw = fields[i++] ?? "";
+    const letter = raw[0];
+    if (!letter || !/^[AMDTRC]\d*$/.test(raw)) return null;
+    if (letter === "R" || letter === "C") {
+      const oldPath = fields[i++];
+      const path3 = fields[i++];
+      if (!oldPath || !path3) return null;
+      changes.push(letter === "C" ? { status: "A", path: path3 } : { status: "R", path: path3, oldPath });
+      continue;
+    }
+    const path2 = fields[i++];
+    if (!path2) return null;
+    changes.push({ status: letter, path: path2 });
+  }
+  return changes;
+}
+function changedPaths(changes) {
+  return [...new Set(changes.filter((change) => change.status !== "D").map((change) => change.path))].sort();
+}
+function removedPaths(changes) {
+  const removed = changes.flatMap((change) => change.status === "D" ? [change.path] : change.status === "R" && change.oldPath ? [change.oldPath] : []);
+  return [...new Set(removed)].sort();
+}
+function commitPresent(git3, commit) {
+  return git3(["cat-file", "-e", `${commit}^{commit}`]).status === 0;
+}
+function isAncestor(git3, base, head) {
+  return git3(["merge-base", "--is-ancestor", base, head]).status === 0;
+}
+function planRepoIndexV4Delta(opts) {
+  const headCommit = opts.headCommit.toLowerCase();
+  const baseCommit = opts.baseCommit ? opts.baseCommit.toLowerCase() : null;
+  const full = (fallbackReason) => ({ mode: "full", headCommit, fallbackReason, ...baseCommit ? { baseCommit } : {} });
+  if (opts.forceFull) return full("explicit-full-rebuild");
+  if (!baseCommit || !COMMIT.test(baseCommit) || baseCommit === headCommit) return full("no-active-authority");
+  if (opts.basePipelineCompatible === false) return full("incompatible-base-provenance");
+  if (opts.hasPriorMaterial === false) return full("no-prior-material");
+  const { git: git3 } = opts;
+  let usable = commitPresent(git3, baseCommit) && isAncestor(git3, baseCommit, headCommit);
+  for (const depth of V4_DELTA_DEEPEN_STEPS) {
+    if (usable || !opts.deepen) break;
+    try {
+      opts.deepen(depth);
+    } catch {
+      break;
+    }
+    usable = commitPresent(git3, baseCommit) && isAncestor(git3, baseCommit, headCommit);
+  }
+  if (!usable) {
+    return full(commitPresent(git3, baseCommit) ? "base-not-ancestor" : "base-commit-unavailable");
+  }
+  const diff = git3(["diff", "--name-status", "-z", "--find-renames", baseCommit, headCommit]);
+  if (diff.status !== 0) return full("diff-unreadable");
+  const changes = parseNameStatusZ(diff.stdout);
+  if (!changes) return full("unsupported-change-status");
+  return { mode: "delta", baseCommit, headCommit, changes };
 }
 
 // src/repo-index-v4/builder.ts
@@ -23913,7 +25016,7 @@ var V4_MAX_CHUNKS = 1e4;
 var V4_MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
 var V4_EMBED_BATCH = 32;
 var V4_VECTOR_DECIMAL_PLACES = 6;
-var COMMIT = /^[a-f0-9]{40}$/;
+var COMMIT2 = /^[a-f0-9]{40}$/;
 function canonicalJson(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
@@ -23921,7 +25024,7 @@ function canonicalJson(value) {
   return `{${Object.keys(record).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(record[k])}`).join(",")}}`;
 }
 function sha2562(value) {
-  return (0, import_node_crypto8.createHash)("sha256").update(canonicalJson(value)).digest("hex");
+  return (0, import_node_crypto9.createHash)("sha256").update(canonicalJson(value)).digest("hex");
 }
 function quantizeV4Vector(vector) {
   return vector.map((value) => Number(value.toFixed(V4_VECTOR_DECIMAL_PLACES)));
@@ -23930,11 +25033,11 @@ function statePath(cwd) {
   return repoRuntimeStatePath(cwd, "repo-index", "v4.json");
 }
 function git(cwd, args) {
-  return String((0, import_node_child_process13.execFileSync)("git", args, { cwd, encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "ignore"] })).trim();
+  return String((0, import_node_child_process14.execFileSync)("git", args, { cwd, encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "ignore"] })).trim();
 }
 function gitInfo(cwd) {
   const commit = git(cwd, ["rev-parse", "HEAD"]).toLowerCase();
-  if (!COMMIT.test(commit)) throw new Error("repo-index v4 requires an exact git HEAD commit");
+  if (!COMMIT2.test(commit)) throw new Error("repo-index v4 requires an exact git HEAD commit");
   let defaultBranch = "main";
   try {
     defaultBranch = git(cwd, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]).replace(/^origin\//, "") || defaultBranch;
@@ -23956,6 +25059,9 @@ function prior(cwd) {
     return null;
   }
 }
+function repoIndexV4DeltaBase(envelope) {
+  return envelope && isRepoIndexDeltaCompatible(envelope.manifest) ? envelope : null;
+}
 function tombstone(repo, commit, path2, createdAt) {
   const base = { repo, commit, path: path2, reason: "deleted", createdAt };
   return { ...base, id: sha2562(base) };
@@ -23990,7 +25096,7 @@ function runEmbedderOnce(cwd, chunks, modelDirectory, createdAt) {
   (0, import_node_fs25.writeFileSync)(requestFile, JSON.stringify(request));
   let result;
   try {
-    result = (0, import_node_child_process13.spawnSync)(process.execPath, [file, requestFile], { encoding: "utf8", windowsHide: true, timeout: V4_EMBED_TIMEOUT_MS, maxBuffer: V4_MAX_ARTIFACT_BYTES, env });
+    result = (0, import_node_child_process14.spawnSync)(process.execPath, [file, requestFile], { encoding: "utf8", windowsHide: true, timeout: V4_EMBED_TIMEOUT_MS, maxBuffer: V4_MAX_ARTIFACT_BYTES, env });
   } finally {
     (0, import_node_fs25.rmSync)(requestDir, { recursive: true, force: true });
   }
@@ -24046,23 +25152,53 @@ function runEmbedder(cwd, chunks, modelDirectory, createdAt) {
   const stderr = runner.stderrTail ? ` stderr=${runner.stderrTail}` : "";
   throw new Error(`repo-index v4 embedding runner failed: ${runner.detail ?? "unknown"}${code}${stdout}${stderr}`);
 }
+function restampCitations(chunk, repo, commit) {
+  return { ...chunk, citations: chunk.citations.map((citation2) => ({ ...citation2, repo, commit })) };
+}
 async function buildRepoIndexV4(cwd, repo, opts = {}) {
+  return (await buildRepoIndexV4Detailed(cwd, repo, opts)).envelope;
+}
+async function buildRepoIndexV4Detailed(cwd, repo, opts = {}) {
   const { commit, defaultBranch, createdAt } = gitInfo(cwd);
-  const chunks = await buildStructuralChunks(cwd, repo, commit);
-  if (chunks.length > V4_MAX_CHUNKS) throw new Error(`repo-index v4 exceeds ${V4_MAX_CHUNKS} chunk ceiling`);
+  const delta = opts.delta;
   const old = prior(cwd);
+  const deltaBase = repoIndexV4DeltaBase(old);
+  let chunks;
+  let carried = 0;
+  let built = 0;
+  let changedCount = 0;
+  let removedCount = 0;
+  if (delta) {
+    const admitted = new Set(canonicalRepoIndexPaths(cwd));
+    const changed = new Set(changedPaths(delta.changes));
+    const removed = new Set(removedPaths(delta.changes));
+    changedCount = changed.size;
+    removedCount = removed.size;
+    const rebuilt = await buildStructuralChunksForPaths(cwd, repo, commit, [...changed].filter((path3) => admitted.has(path3)).sort());
+    const kept = delta.prior.chunks.filter((chunk) => !changed.has(chunk.path) && !removed.has(chunk.path) && admitted.has(chunk.path)).map((chunk) => restampCitations(chunk, repo, commit));
+    carried = kept.length;
+    built = rebuilt.length;
+    chunks = [...kept, ...rebuilt].sort(compareV4Chunks);
+  } else {
+    chunks = await buildStructuralChunks(cwd, repo, commit);
+    built = chunks.length;
+  }
+  if (chunks.length > V4_MAX_CHUNKS) throw new Error(`repo-index v4 exceeds ${V4_MAX_CHUNKS} chunk ceiling`);
   const currentPaths = new Set(chunks.map((c) => c.path));
+  const priorChunks = delta ? delta.prior.chunks : old?.manifest.chunks ?? [];
+  const priorTombstones = delta ? delta.prior.tombstones ?? [] : old?.manifest.tombstones ?? [];
   const tombstonePaths = [
-    ...(old?.manifest.tombstones ?? []).map((t) => t.path),
-    ...(old?.manifest.chunks ?? []).map((c) => c.path).filter((path3) => !currentPaths.has(path3))
+    ...priorTombstones.map((t) => t.path),
+    ...priorChunks.map((c) => c.path).filter((path3) => !currentPaths.has(path3))
   ];
   const tombstones = [...new Set(tombstonePaths)].sort().map((path3) => tombstone(repo, commit, path3, createdAt));
-  const oldChunkHashById = new Map((old?.manifest.chunks ?? []).map((c) => [c.id, c.contentHash]));
+  const embeddingSource = delta ? delta.prior : { chunks: deltaBase?.manifest.chunks ?? [], embeddings: deltaBase?.manifest.embeddings ?? [] };
+  const oldChunkHashById = new Map(embeddingSource.chunks.map((c) => [c.id, c.contentHash]));
   const reusableEmbedding = (embedding) => {
     const norm = Math.hypot(...embedding.vector);
     return embedding.vector.length === 384 && embedding.vector.every(Number.isFinite) && norm >= 0.98 && norm <= 1.02 && embedding.provenance.provider === "local" && embedding.provenance.modelDigest === "828e1496d7fabb79cfa4dcd84fa38625c0d3d21da474a00f08db0f559940cf35" && embedding.provenance.dimensions === 384 && embedding.provenance.input === "pointer-safe-structural-chunk";
   };
-  const oldEmbeddingByHash = new Map((old?.manifest.embeddings ?? []).filter(reusableEmbedding).map((e) => [oldChunkHashById.get(e.chunkId), e]));
+  const oldEmbeddingByHash = new Map(embeddingSource.embeddings.filter(reusableEmbedding).map((e) => [oldChunkHashById.get(e.chunkId), e]));
   const reusable = chunks.flatMap((chunk) => {
     const priorEmbedding = oldEmbeddingByHash.get(chunk.contentHash);
     return priorEmbedding ? [{ ...priorEmbedding, chunkId: chunk.id }] : [];
@@ -24070,21 +25206,21 @@ async function buildRepoIndexV4(cwd, repo, opts = {}) {
   const reusableIds = new Set(reusable.map((e) => e.chunkId));
   const missing = chunks.filter((chunk) => !reusableIds.has(chunk.id));
   const generated = missing.length === 0 ? { embeddings: [] } : opts.embed === false ? { embeddings: [], reason: "embeddings-unavailable" } : runEmbedder(cwd, missing, opts.modelDirectory, createdAt);
-  const embeddings = [...reusable, ...generated.embeddings].map((embedding) => ({ ...embedding, vector: quantizeV4Vector(embedding.vector) })).sort((a, b) => a.chunkId.localeCompare(b.chunkId));
-  const chunksDigest = sha2562(chunks);
-  const embeddingsDigest = sha2562(embeddings);
-  const artifact = (kind, digest) => {
-    const identity2 = { repo, commit, immutable: true, kind, uri: `s3://repo-index/v4/${repo}/${commit}/${digest}.${kind}.json`, sha256: digest, createdAt };
+  const embeddings = [...reusable, ...generated.embeddings].map((embedding) => ({ ...embedding, vector: quantizeV4Vector(embedding.vector) })).sort(compareRepoIndexEmbeddings);
+  const materialIndexDigest = buildRepoIndexMaterialLayout(repo, chunks, embeddings).indexDigest;
+  const artifact = (kind, digest, uri) => {
+    const identity2 = { repo, commit, immutable: true, kind, uri, sha256: digest, createdAt };
     return { ...identity2, id: sha2562(identity2) };
   };
-  const artifacts = [artifact("chunks", chunksDigest), artifact("embeddings", embeddingsDigest)];
+  const artifacts = [artifact("material-index", materialIndexDigest, repoIndexMaterialIndexUri(repo, materialIndexDigest))];
   const grammarProvenance = {
     runtime: { name: "web-tree-sitter", version: "0.26.12", license: "MIT" },
     grammarPack: { name: "tree-sitter-wasm", version: "1.1.4", license: "MIT", digest: "f3089ddf2c9615a423783b645c4dfb23ccda30807bbd059746f583952357c489" },
     languages: ["go", "java", "javascript", "jsx", "kotlin", "python", "rust", "tsx", "typescript"]
   };
   const rrf = { algorithm: "reciprocal-rank-fusion", k: 60, lexicalWeight: 1, semanticWeight: 1 };
-  const identity = { repo, commit, defaultBranch, immutable: true, createdAt, grammarProvenance, chunks, embeddings, artifacts, tombstones, rrf };
+  const indexProvenance = { ...CURRENT_REPO_INDEX_PROVENANCE };
+  const identity = { repo, commit, defaultBranch, immutable: true, ...delta ? { parentCommit: delta.baseCommit } : {}, createdAt, grammarProvenance, indexProvenance, chunks, embeddings, artifacts, tombstones, rrf };
   const manifest = { ...identity, id: sha2562(identity) };
   const complete = embeddings.length === chunks.length;
   const envelope = {
@@ -24098,7 +25234,23 @@ async function buildRepoIndexV4(cwd, repo, opts = {}) {
   (0, import_node_fs25.mkdirSync)((0, import_node_path23.dirname)(path2), { recursive: true });
   (0, import_node_fs25.writeFileSync)(path2, `${JSON.stringify(envelope, null, 2)}
 `, "utf8");
-  return envelope;
+  const metrics = {
+    mode: delta ? "delta" : "full",
+    ...delta ? { baseCommit: delta.baseCommit } : {},
+    changedPaths: changedCount,
+    removedPaths: removedCount,
+    chunksTotal: chunks.length,
+    chunksCarried: carried,
+    chunksBuilt: built,
+    embeddingsReused: reusable.length,
+    embeddingsEmbedded: generated.embeddings.length,
+    tombstones: tombstones.length
+  };
+  return { envelope, metrics };
+}
+function formatV4BuildMetrics(repo, metrics) {
+  const base = metrics.baseCommit ? ` base=${metrics.baseCommit.slice(0, 12)}` : "";
+  return `${repo}: ${metrics.mode}${base} changed=${metrics.changedPaths} removed=${metrics.removedPaths} chunks=${metrics.chunksTotal} (carried=${metrics.chunksCarried} built=${metrics.chunksBuilt}) embeddings(reused=${metrics.embeddingsReused} new=${metrics.embeddingsEmbedded}) tombstones=${metrics.tombstones}`;
 }
 function repoIndexV4StorePath(cwd) {
   return statePath(cwd);
@@ -24111,12 +25263,12 @@ var V4_STAGE_MAX_SHARDS = 128;
 function encodedBytes(value) {
   return Buffer.byteLength(JSON.stringify(value));
 }
-function split(kind, records, manifest) {
+function split(kind, records, manifest, bucket) {
   const groups = [];
   let group = [];
   for (const record of records) {
     const next = [...group, record];
-    const probe = { repo: manifest.repo, commit: manifest.commit, manifestId: manifest.id, kind, index: 127, total: 128, digest: "0".repeat(64), records: next };
+    const probe = { repo: manifest.repo, commit: manifest.commit, manifestId: manifest.id, kind, ...bucket === void 0 ? {} : { bucket }, index: 127, total: 128, digest: "0".repeat(64), records: next };
     if (group.length && (group.length >= V4_STAGE_MAX_RECORDS || encodedBytes(probe) > V4_STAGE_MAX_BODY_BYTES)) {
       groups.push(group);
       group = [record];
@@ -24132,6 +25284,7 @@ function split(kind, records, manifest) {
       commit: manifest.commit,
       manifestId: manifest.id,
       kind,
+      ...bucket === void 0 ? {} : { bucket },
       index,
       total: groups.length,
       digest: sha2562(items),
@@ -24141,11 +25294,30 @@ function split(kind, records, manifest) {
     return request;
   });
 }
-function shardRepoIndexV4(envelope) {
+function shardRepoIndexV4(envelope, opts = {}) {
   const { chunks, embeddings, ...header } = envelope.manifest;
-  const stages = [...split("chunks", chunks, envelope.manifest), ...split("embeddings", embeddings ?? [], envelope.manifest)];
-  const shards = stages.map(({ kind, index, total, digest, records }) => ({ kind, index, total, digest, count: records.length }));
-  return { stages, finalize: { repo: header.repo, commit: header.commit, manifestId: header.id, header, status: envelope.status, shards } };
+  const identity = { repo: header.repo, commit: header.commit, manifestId: header.id, header, status: envelope.status };
+  if ((header.indexProvenance?.materialLayoutVersion ?? 1) < 2) {
+    const stages2 = [...split("chunks", chunks, envelope.manifest), ...split("embeddings", embeddings ?? [], envelope.manifest)];
+    const shards2 = stages2.map(({ kind, index, total, digest, records }) => ({ kind, index, total, digest, count: records.length }));
+    return { stages: stages2, finalize: { ...identity, shards: shards2 } };
+  }
+  const reusable = new Set(opts.priorBucketDigests ?? []);
+  const layout = buildRepoIndexMaterialLayout(header.repo, chunks, embeddings ?? []);
+  const stages = [];
+  const shards = [];
+  const buckets = layout.buckets.map((bucket) => {
+    if (reusable.has(bucket.digest)) return { kind: bucket.kind, bucket: bucket.bucket, count: bucket.count, digest: bucket.digest, shards: 0 };
+    const fragments = split(bucket.kind, bucket.body.records, envelope.manifest, bucket.bucket);
+    stages.push(...fragments);
+    shards.push(...fragments.map(({ kind, index, total, digest, records }) => ({ kind, bucket: bucket.bucket, index, total, digest, count: records.length })));
+    return { kind: bucket.kind, bucket: bucket.bucket, count: bucket.count, digest: bucket.digest, shards: fragments.length };
+  });
+  if (buckets.length !== 2 * REPO_INDEX_MATERIAL_BUCKET_COUNT) throw new Error("repo-index v4 material layout is incomplete");
+  return { stages, finalize: { ...identity, shards, materialLayout: 2, buckets } };
+}
+function repoIndexV4BucketDigests(repo, chunks, embeddings) {
+  return buildRepoIndexMaterialLayout(repo, chunks, embeddings).buckets.map((bucket) => bucket.digest);
 }
 
 // src/repo-index-cloud-client.ts
@@ -24154,6 +25326,55 @@ async function repoIndexSourceHostHeaders() {
   const { detectSurface: detectSurface2 } = await Promise.resolve().then(() => (init_plugin_guard_io(), plugin_guard_io_exports));
   return { [SOURCE_HOST_HEADER]: detectSurface2(process.env) };
 }
+var REPO_INDEX_SEARCH_LEGACY_V4_UNAVAILABLE = "repo-index search gap \u2014 Hub returned untyped v4 unavailability (not a CLI version gate); run `mmi-cli oracle repo-index status --cloud --json`, then `mmi-cli harbour org schedules run MMI-Hub/repo-index-reconcile` if authorities are incomplete";
+function isBareRepoIndexV4Unavailable(msg) {
+  return /^v4\s+unavailable$/i.test(msg.replace(/\s+/g, " ").trim());
+}
+function refuseBareRepoIndexV4Unavailable(msg) {
+  return isBareRepoIndexV4Unavailable(msg) ? REPO_INDEX_SEARCH_LEGACY_V4_UNAVAILABLE : msg;
+}
+function explainRepoIndexSearchError(body, status) {
+  const errorClass = typeof body.errorClass === "string" ? body.errorClass.trim().toLowerCase() : "";
+  const failures = Array.isArray(body.v4Authority?.authorityFailures) ? body.v4Authority.authorityFailures : [];
+  const failureSummary = failures.length ? ` \u2014 ${failures.length} authority failure(s): ${failures.slice(0, 8).map((f) => `${f.repo}:${f.reason}`).join(", ")}${failures.length > 8 ? "\u2026" : ""}` : "";
+  const next = typeof body.next === "string" && body.next.trim() ? ` \u2014 ${body.next.trim()}` : "";
+  switch (errorClass) {
+    case "incomplete-authority-cohort":
+      return "v4 authority cohort incomplete \u2014 missing or unreadable active v4 authority for one or more roster repos" + failureSummary + (next || " \u2014 run `mmi-cli harbour org schedules run MMI-Hub/repo-index-reconcile`");
+    case "query-embedding-unavailable":
+      return "v4 query embedding unavailable \u2014 Hub could not embed the query (pinned BGE path)";
+    case "estate-exceeds-v4-reader-bound":
+      return "v4 search refused \u2014 estate exceeds bounded v4 reader";
+    case "v4-read-failure":
+      return "v4 authority read failed \u2014 Hub could not load v4 index material";
+    default:
+      break;
+  }
+  const raw = typeof body.error === "string" ? body.error.replace(/\s+/g, " ").trim() : "";
+  if (isBareRepoIndexV4Unavailable(raw)) return REPO_INDEX_SEARCH_LEGACY_V4_UNAVAILABLE;
+  return refuseBareRepoIndexV4Unavailable(raw || `search HTTP ${status ?? "error"}`);
+}
+var REPO_INDEX_SEARCH_NOT_READY_NEXT = "run `mmi-cli harbour org schedules run MMI-Hub/repo-index-reconcile` then re-check `mmi-cli oracle repo-index status --cloud --json`";
+function asCloudSearchNotReadyReceipt(failure) {
+  return {
+    ok: false,
+    error: refuseBareRepoIndexV4Unavailable(failure.error),
+    ...failure.status !== void 0 ? { status: failure.status } : {},
+    ...typeof failure.errorClass === "string" ? { errorClass: failure.errorClass } : {},
+    retrieval: failure.retrieval?.served === "unavailable" ? failure.retrieval : { requested: "v4", served: "unavailable" },
+    ...failure.v4Authority ? { v4Authority: failure.v4Authority } : {},
+    ...Array.isArray(failure.omittedRepos) ? { omittedRepos: failure.omittedRepos } : {},
+    next: typeof failure.next === "string" && failure.next.trim() ? failure.next : REPO_INDEX_SEARCH_NOT_READY_NEXT
+  };
+}
+function shouldRetryRepoIndexSearchLexical(failure, attemptedMode) {
+  if (attemptedMode === "lexical") return false;
+  const errorClass = typeof failure.errorClass === "string" ? failure.errorClass.trim().toLowerCase() : "";
+  if (errorClass === "query-embedding-unavailable") return true;
+  const error = typeof failure.error === "string" ? failure.error : "";
+  if (isBareRepoIndexV4Unavailable(error)) return true;
+  return /not a CLI version gate/i.test(error);
+}
 var WARMUP_MAX_PASSES = 3;
 async function probeRepoIndexV4ReadinessCloud(queries, deps) {
   if (!deps.baseUrl) return { ok: false, error: "Hub API URL not configured" };
@@ -24202,28 +25423,128 @@ async function probeRepoIndexV4ReadinessCloud(queries, deps) {
     return { ok: false, error: error.message };
   }
 }
-async function reconcileRepoIndexCloud(repo, deps) {
+function priorV4BucketDigests(repo, prior2) {
+  return prior2.deltaCompatible ? repoIndexV4BucketDigests(repo, prior2.chunks, prior2.embeddings) : [];
+}
+var REPO_INDEX_V4_MATERIAL_ROUTE = "/repo-index/v4/material";
+var V4_MATERIAL_MAX_PAGES = 256;
+async function fetchV4MaterialKind(repo, kind, deps, request, pin) {
+  const records = [];
+  let pageToken;
+  let commit = pin?.commit;
+  let digest = pin?.digest;
+  let arrayDigest;
+  let total;
+  let deltaCompatible;
+  for (let page = 0; page < V4_MATERIAL_MAX_PAGES; page++) {
+    const params = new URLSearchParams({ repo });
+    if (pageToken) params.set("pageToken", pageToken);
+    else {
+      params.set("kind", kind);
+      if (digest) params.set("digest", digest);
+    }
+    const result = await request(`${REPO_INDEX_V4_MATERIAL_ROUTE}?${params}`);
+    if (!result.ok) return result;
+    const body = result.body;
+    if (!Array.isArray(body.records) || typeof body.total !== "number" || typeof body.offset !== "number") return { ok: false, error: "v4 material page is malformed" };
+    if (body.repo !== repo || body.kind !== kind) return { ok: false, error: "v4 material page identity does not match the request" };
+    if (commit === void 0) commit = body.commit;
+    else if (body.commit !== commit) return { ok: false, error: "v4 material page changed commit mid-walk" };
+    if (digest === void 0) digest = body.digest;
+    else if (body.digest !== digest) return { ok: false, error: "v4 material page changed digest mid-walk" };
+    if (arrayDigest === void 0) arrayDigest = body.arrayDigest;
+    else if (body.arrayDigest !== arrayDigest) return { ok: false, error: "v4 material page changed content digest mid-walk" };
+    if (total === void 0) total = body.total;
+    else if (body.total !== total) return { ok: false, error: "v4 material page changed record count mid-walk" };
+    if (body.offset !== records.length) return { ok: false, error: "v4 material page arrived out of order" };
+    if (body.deltaCompatible !== void 0) deltaCompatible = body.deltaCompatible;
+    records.push(...body.records);
+    pageToken = body.nextPageToken;
+    if (!pageToken) break;
+  }
+  if (pageToken) return { ok: false, error: `v4 material walk exceeded ${V4_MATERIAL_MAX_PAGES} pages` };
+  if (typeof commit !== "string" || typeof digest !== "string" || typeof arrayDigest !== "string") return { ok: false, error: "v4 material response omitted its authority identity" };
+  if (records.length !== total) return { ok: false, error: `v4 material walk reassembled ${records.length} ${kind} records, expected ${total}` };
+  if (sha2562(records) !== arrayDigest) return { ok: false, error: `v4 ${kind} material failed its declared content digest` };
+  return { ok: true, records, commit, digest, ...deltaCompatible === void 0 ? {} : { deltaCompatible } };
+}
+async function fetchRepoIndexV4MaterialCloud(repo, deps) {
   if (!deps.baseUrl) return { ok: false, error: "Hub API URL not configured" };
   const token = await deps.token();
   if (!token) return { ok: false, error: "no Hub session token (run `gh auth login`)" };
+  const baseUrl = deps.baseUrl.replace(/\/$/, "");
+  const request = async (path2) => {
+    const res = await fetchWithRetry(deps.fetch ?? fetch, `${baseUrl}${path2}`, {
+      method: "GET",
+      headers: { ...clientVersionHeaders(), Authorization: `Bearer ${token}` }
+    }, { attempts: RETRY_ATTEMPTS2, timeoutMs: 12e4, sleep: deps.retrySleep });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) return { ok: false, error: typeof body.error === "string" ? body.error : `v4 material HTTP ${res.status}`, status: res.status };
+    return { ok: true, body };
+  };
   try {
-    const res = await fetchWithRetry(deps.fetch ?? fetch, `${deps.baseUrl.replace(/\/$/, "")}/repo-index/reconcile`, {
-      method: "POST",
-      headers: { ...clientVersionHeaders(), Authorization: `Bearer ${token}`, "content-type": "application/json" },
-      body: JSON.stringify({ repo, reachable: false })
+    const chunks = await fetchV4MaterialKind(repo, "chunks", deps, request);
+    if (!chunks.ok) return chunks;
+    const pin = { commit: chunks.commit, digest: chunks.digest };
+    const embeddings = await fetchV4MaterialKind(repo, "embeddings", deps, request, pin);
+    if (!embeddings.ok) return embeddings;
+    const tombstones = await fetchV4MaterialKind(repo, "tombstones", deps, request, pin);
+    if (!tombstones.ok) return tombstones;
+    const chunkRecords = chunks.records;
+    const chunkIds = new Set(chunkRecords.map((chunk) => chunk?.id));
+    if (chunkRecords.some((chunk) => !chunk?.id || !chunk.path || !Array.isArray(chunk.citations) || chunk.citations.some((citation2) => citation2.repo !== repo || citation2.commit !== pin.commit || citation2.path !== chunk.path))) {
+      return { ok: false, error: "v4 prior material contains a foreign or malformed citation" };
+    }
+    const embeddingRecords = embeddings.records;
+    if (embeddingRecords.some((embedding) => !chunkIds.has(embedding?.chunkId))) return { ok: false, error: "v4 prior material embeds a chunk that is not in the corpus" };
+    return {
+      ok: true,
+      material: {
+        commit: pin.commit,
+        digest: pin.digest,
+        chunks: chunkRecords,
+        embeddings: embeddingRecords,
+        tombstones: tombstones.records,
+        // A Hub that did not answer the question has not proved the base is same-pipeline, and an
+        // unproved base is a full rebuild — never an assumed-compatible one.
+        deltaCompatible: tombstones.deltaCompatible === true
+      }
+    };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+async function fetchRepoIndexV4ProvenanceCloud(repo, deps) {
+  if (!deps.baseUrl) return { ok: false, error: "Hub API URL not configured" };
+  const token = await deps.token();
+  if (!token) return { ok: false, error: "no Hub session token (run `gh auth login`)" };
+  const params = new URLSearchParams({ repo, kind: "tombstones", limit: "1" });
+  try {
+    const res = await fetchWithRetry(deps.fetch ?? fetch, `${deps.baseUrl.replace(/\/$/, "")}${REPO_INDEX_V4_MATERIAL_ROUTE}?${params}`, {
+      method: "GET",
+      headers: { ...clientVersionHeaders(), Authorization: `Bearer ${token}` }
     }, { attempts: RETRY_ATTEMPTS2, timeoutMs: deps.timeoutMs ?? REGISTRY_FETCH_TIMEOUT_MS, sleep: deps.retrySleep });
     const body = await res.json().catch(() => ({}));
-    if (!res.ok) return { ok: false, error: typeof body.error === "string" ? body.error : `reconcile HTTP ${res.status}`, status: res.status };
-    return { ok: true };
-  } catch (e) {
-    return { ok: false, error: e.message };
+    if (!res.ok) return { ok: false, error: typeof body.error === "string" ? body.error : `v4 material HTTP ${res.status}`, status: res.status };
+    if (body.repo !== repo || typeof body.commit !== "string" || typeof body.digest !== "string") {
+      return { ok: false, error: "v4 provenance probe answered for a different authority" };
+    }
+    return {
+      ok: true,
+      commit: body.commit,
+      digest: body.digest,
+      deltaCompatible: body.deltaCompatible === true,
+      ...body.indexProvenance ? { indexProvenance: body.indexProvenance } : {}
+    };
+  } catch (error) {
+    return { ok: false, error: error.message };
   }
 }
-async function publishRepoIndexV4Cloud(envelope, deps) {
+async function publishRepoIndexV4Cloud(envelope, deps, opts = {}) {
   if (!deps.baseUrl) return { ok: false, error: "Hub API URL not configured" };
   const token = await deps.token();
   if (!token) return { ok: false, error: "no Hub session token (run `gh auth login`)" };
-  const upload = shardRepoIndexV4(envelope);
+  const upload = shardRepoIndexV4(envelope, { ...opts.priorBucketDigests ? { priorBucketDigests: opts.priorBucketDigests } : {} });
   const post = async (path2, payload) => {
     const res = await fetchWithRetry(deps.fetch ?? fetch, `${deps.baseUrl.replace(/\/$/, "")}${path2}`, {
       method: "POST",
@@ -24239,7 +25560,10 @@ async function publishRepoIndexV4Cloud(envelope, deps) {
       const result = await post("/repo-index/v4/stage", stage);
       if (!result.ok) return result;
     }
-    const finalized = await post("/repo-index/v4/finalize", upload.finalize);
+    const finalized = await post("/repo-index/v4/finalize", {
+      ...upload.finalize,
+      ...opts.expectedActiveDigest ? { expectedActiveDigest: opts.expectedActiveDigest } : {}
+    });
     if (!finalized.ok) return finalized;
     return { ok: true, active: finalized.body.active ?? {} };
   } catch (error) {
@@ -24279,9 +25603,13 @@ async function getRepoIndexV4GraphCloud(opts, deps) {
   }
 }
 async function searchRepoIndexCloud(query, opts, deps) {
-  if (!deps.baseUrl) return { ok: false, error: "Hub API URL not configured" };
+  if (!deps.baseUrl) {
+    return asCloudSearchNotReadyReceipt({ ok: false, error: "Hub API URL not configured" });
+  }
   const token = await deps.token();
-  if (!token) return { ok: false, error: "no Hub session token (run `gh auth login`)" };
+  if (!token) {
+    return asCloudSearchNotReadyReceipt({ ok: false, error: "no Hub session token (run `gh auth login`)" });
+  }
   const params = new URLSearchParams({
     q: query,
     mode: opts.mode ?? "hybrid",
@@ -24298,13 +25626,36 @@ async function searchRepoIndexCloud(query, opts, deps) {
       deps.fetch ?? fetch,
       `${deps.baseUrl.replace(/\/$/, "")}/repo-index/search?${params}`,
       { method: "GET", headers },
-      { attempts: RETRY_ATTEMPTS2, timeoutMs: opts.mode === "semantic" || opts.mode === "hybrid" ? 6e4 : deps.timeoutMs ?? REGISTRY_FETCH_TIMEOUT_MS, sleep: deps.retrySleep }
+      {
+        attempts: RETRY_ATTEMPTS2,
+        timeoutMs: opts.mode === "semantic" || opts.mode === "hybrid" ? 6e4 : deps.timeoutMs ?? REGISTRY_FETCH_TIMEOUT_MS,
+        sleep: deps.retrySleep,
+        retryOn: (response) => response.status >= 500 && response.status !== 503
+      }
     );
-    if (res.status === 426) return { ok: false, error: upgradeRequiredError(res, await res.json().catch(() => null)), status: 426 };
+    if (res.status === 426) {
+      return asCloudSearchNotReadyReceipt({
+        ok: false,
+        error: upgradeRequiredError(res, await res.json().catch(() => null)),
+        status: 426
+      });
+    }
     const body = await res.json().catch(() => ({}));
-    if (!res.ok) return { ok: false, error: body.error ?? `search HTTP ${res.status}`, status: res.status };
+    if (!res.ok) {
+      const error = refuseBareRepoIndexV4Unavailable(explainRepoIndexSearchError(body, res.status));
+      return asCloudSearchNotReadyReceipt({
+        ok: false,
+        error,
+        status: res.status,
+        ...typeof body.errorClass === "string" ? { errorClass: body.errorClass } : {},
+        ...body.retrieval && body.retrieval.served === "unavailable" ? { retrieval: body.retrieval } : {},
+        ...body.v4Authority ? { v4Authority: body.v4Authority } : {},
+        ...Array.isArray(body.omittedRepos) ? { omittedRepos: body.omittedRepos } : {},
+        ...typeof body.next === "string" ? { next: body.next } : {}
+      });
+    }
     const shadowRate = Math.max(0, Math.min(1, Number(process.env.MMI_REPO_INDEX_V4_SHADOW_RATE ?? 0.1) || 0));
-    if ((0, import_node_crypto9.createHash)("sha256").update(query).digest()[0] / 256 < shadowRate) {
+    if ((0, import_node_crypto10.createHash)("sha256").update(query).digest()[0] / 256 < shadowRate) {
       void fetchWithRetry(
         deps.fetch ?? fetch,
         `${deps.baseUrl.replace(/\/$/, "")}/repo-index/v4/shadow`,
@@ -24319,10 +25670,15 @@ async function searchRepoIndexCloud(query, opts, deps) {
       mode: body.mode ?? opts.mode ?? "hybrid",
       hits: Array.isArray(body.hits) ? body.hits : [],
       note: body.note,
-      ...body.retrieval ? { retrieval: body.retrieval } : {}
+      ...Array.isArray(body.degradedReasons) ? { degradedReasons: body.degradedReasons } : {},
+      ...Array.isArray(body.omittedRepos) ? { omittedRepos: body.omittedRepos } : {},
+      ...body.retrieval && body.retrieval.served === "v4" ? { retrieval: body.retrieval } : {}
     };
   } catch (e) {
-    return { ok: false, error: e.message };
+    return asCloudSearchNotReadyReceipt({
+      ok: false,
+      error: refuseBareRepoIndexV4Unavailable(e.message)
+    });
   }
 }
 function isRepoIndexStatusError(st) {
@@ -24398,7 +25754,7 @@ async function gcRepoIndexCloud(deps) {
 var import_node_fs27 = require("node:fs");
 var import_node_os13 = require("node:os");
 var import_node_path25 = require("node:path");
-var import_node_child_process14 = require("node:child_process");
+var import_node_child_process15 = require("node:child_process");
 
 // ../infra/src/repo-index-roster.ts
 var ORG2 = "mutmutco";
@@ -24537,7 +25893,7 @@ function buildGraphEdges(cwd, repo, commit, rosterRepos2) {
 }
 
 // src/repo-index-sync.ts
-var COMMIT2 = /^[a-f0-9]{40}$/;
+var COMMIT3 = /^[a-f0-9]{40}$/;
 var SHA256 = /^[a-f0-9]{64}$/;
 var UTC_MILLIS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 function normalizeRepo(raw) {
@@ -24550,15 +25906,31 @@ function rosterRepos(projects) {
 }
 function shallowClone(repo, dest, token) {
   const basic = Buffer.from(`x-access-token:${token}`, "utf8").toString("base64");
-  (0, import_node_child_process14.execFileSync)(
+  (0, import_node_child_process15.execFileSync)(
     "git",
     ["-c", `http.extraHeader=Authorization: Basic ${basic}`, "clone", "--depth", "1", "--single-branch", `https://github.com/${repo}.git`, dest],
     { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], windowsHide: true }
   );
 }
+function checkoutExactCommit(repo, dest, token, commit) {
+  const git3 = (args, authenticated = false) => {
+    const basic = Buffer.from(`x-access-token:${token}`, "utf8").toString("base64");
+    return String((0, import_node_child_process15.execFileSync)(
+      "git",
+      [...authenticated ? ["-c", `http.extraHeader=Authorization: Basic ${basic}`] : [], "-C", dest, ...args],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], windowsHide: true }
+    ));
+  };
+  if (git3(["rev-parse", "HEAD"]).trim().toLowerCase() !== commit) {
+    git3(["fetch", "--no-tags", "--depth", "1", "origin", commit], true);
+    git3(["checkout", "--quiet", "--detach", commit]);
+  }
+  const head = git3(["rev-parse", "HEAD"]).trim().toLowerCase();
+  if (head !== commit) throw new Error(`checkout of ${repo} resolved ${head}, not the requested commit ${commit}`);
+}
 function remoteHead(repo, token) {
   const basic = Buffer.from(`x-access-token:${token}`, "utf8").toString("base64");
-  const output = (0, import_node_child_process14.execFileSync)(
+  const output = (0, import_node_child_process15.execFileSync)(
     "git",
     ["-c", `http.extraHeader=Authorization: Basic ${basic}`, "ls-remote", "--exit-code", `https://github.com/${repo}.git`, "HEAD"],
     { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], windowsHide: true }
@@ -24567,7 +25939,7 @@ function remoteHead(repo, token) {
   if (!match) throw new Error(`could not resolve remote HEAD for ${repo}`);
   return match[1];
 }
-function verifiedReadyCommit(statusValue, repo) {
+function verifiedReadyBase(statusValue, repo) {
   if (!statusValue || typeof statusValue !== "object" || Array.isArray(statusValue)) return null;
   const status = statusValue;
   const v4 = status.v4;
@@ -24575,13 +25947,84 @@ function verifiedReadyCommit(statusValue, repo) {
   const pointer = v4;
   const artifactDigests = pointer.artifactDigests;
   const counts = [pointer.chunkCount, pointer.embeddingCount, pointer.tombstoneCount];
-  const structurallyVerified = status.repo === repo && pointer.repo === repo && pointer.state === "ready" && pointer.integrity === "verified" && typeof pointer.commit === "string" && COMMIT2.test(pointer.commit) && typeof pointer.digest === "string" && SHA256.test(pointer.digest) && Array.isArray(artifactDigests) && artifactDigests.length === 2 && new Set(artifactDigests).size === artifactDigests.length && artifactDigests.every((digest) => typeof digest === "string" && SHA256.test(digest)) && counts.every((count) => Number.isInteger(count) && Number(count) >= 0) && pointer.embeddingCount === pointer.chunkCount && typeof pointer.activatedAt === "string" && UTC_MILLIS.test(pointer.activatedAt) && Number.isFinite(Date.parse(pointer.activatedAt)) && new Date(pointer.activatedAt).toISOString() === pointer.activatedAt;
-  return structurallyVerified && typeof pointer.commit === "string" ? pointer.commit : null;
+  const structurallyVerified = status.repo === repo && pointer.repo === repo && pointer.state === "ready" && pointer.integrity === "verified" && typeof pointer.commit === "string" && COMMIT3.test(pointer.commit) && typeof pointer.digest === "string" && SHA256.test(pointer.digest) && Array.isArray(artifactDigests) && artifactDigests.length === 2 && new Set(artifactDigests).size === artifactDigests.length && artifactDigests.every((digest) => typeof digest === "string" && SHA256.test(digest)) && counts.every((count) => Number.isInteger(count) && Number(count) >= 0) && pointer.embeddingCount === pointer.chunkCount && typeof pointer.activatedAt === "string" && UTC_MILLIS.test(pointer.activatedAt) && Number.isFinite(Date.parse(pointer.activatedAt)) && new Date(pointer.activatedAt).toISOString() === pointer.activatedAt;
+  return structurallyVerified && typeof pointer.commit === "string" && typeof pointer.digest === "string" ? { commit: pointer.commit, digest: pointer.digest } : null;
+}
+function activePointerDigest(statusValue) {
+  if (!statusValue || typeof statusValue !== "object" || Array.isArray(statusValue)) return null;
+  const v4 = statusValue.v4;
+  if (!v4 || typeof v4 !== "object" || Array.isArray(v4)) return null;
+  const digest = v4.digest;
+  return typeof digest === "string" && SHA256.test(digest) ? digest : null;
+}
+function deepenClone(repo, dest, token, depth) {
+  const basic = Buffer.from(`x-access-token:${token}`, "utf8").toString("base64");
+  (0, import_node_child_process15.execFileSync)(
+    "git",
+    ["-c", `http.extraHeader=Authorization: Basic ${basic}`, "-C", dest, "fetch", "--no-tags", "--depth", String(depth), "origin"],
+    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], windowsHide: true }
+  );
+}
+async function planDeltaBuild(repo, dir, base, deps, githubToken2, forceFull = false) {
+  const git3 = gitRunner(dir);
+  const headCommit = git3(["rev-parse", "HEAD"]).stdout.trim().toLowerCase();
+  if (forceFull) return { plan: planRepoIndexV4Delta({ headCommit, baseCommit: base?.commit ?? null, forceFull: true, git: git3 }) };
+  if (!base) return { plan: planRepoIndexV4Delta({ headCommit, baseCommit: null, git: git3 }) };
+  const material = await fetchRepoIndexV4MaterialCloud(repo, deps);
+  if (!material.ok) {
+    return { plan: planRepoIndexV4Delta({ headCommit, baseCommit: base.commit, hasPriorMaterial: false, git: git3 }) };
+  }
+  const prior2 = material.material;
+  const plan = planRepoIndexV4Delta({
+    headCommit,
+    // The material walk pins its own commit; trust that over the status read that raced it.
+    baseCommit: prior2.commit,
+    basePipelineCompatible: prior2.deltaCompatible,
+    hasPriorMaterial: true,
+    git: git3,
+    deepen: (depth) => deepenClone(repo, dir, githubToken2, depth)
+  });
+  return { plan, prior: prior2 };
 }
 async function syncEstateRepoIndex(opts) {
+  const published = [];
+  const failed = [];
+  const skipped = [];
+  const drift = [];
+  const needsFullRebuild = [];
+  const answer = (ok) => ({
+    ok: ok ?? failed.length === 0,
+    published,
+    failed,
+    skipped,
+    provenanceToken: CURRENT_REPO_INDEX_PROVENANCE_TOKEN,
+    drift,
+    needsFullRebuild
+  });
+  const fullRebuildToken = (opts.fullRebuild ?? "").trim();
+  const forceFull = fullRebuildToken !== "";
+  if (forceFull && fullRebuildToken !== CURRENT_REPO_INDEX_PROVENANCE_TOKEN) {
+    failed.push({
+      repo: opts.repo ? normalizeRepo(opts.repo) : "*",
+      error: `full-rebuild token ${JSON.stringify(fullRebuildToken)} does not match this pipeline's provenance token ${CURRENT_REPO_INDEX_PROVENANCE_TOKEN} \u2014 refusing before any clone, embedding or upload`
+    });
+    return answer(false);
+  }
+  const requestedCommit = (opts.commit ?? "").trim().toLowerCase();
+  if (requestedCommit) {
+    if (!opts.repo) {
+      failed.push({ repo: "*", error: "--commit names one repository tip and requires --repo" });
+      return answer(false);
+    }
+    if (!COMMIT3.test(requestedCommit)) {
+      failed.push({ repo: normalizeRepo(opts.repo), error: `--commit must be a 40-hex commit sha, got ${JSON.stringify(requestedCommit)}` });
+      return answer(false);
+    }
+  }
   const projects = await fetchProjectsList(opts.deps);
   if (!projects) {
-    return { ok: false, published: [], failed: [{ repo: "*", error: "could not read /projects/list" }], skipped: [] };
+    failed.push({ repo: "*", error: "could not read /projects/list" });
+    return answer(false);
   }
   const allRosterRepos = rosterRepos(projects);
   let repos = allRosterRepos;
@@ -24589,37 +26032,85 @@ async function syncEstateRepoIndex(opts) {
     const want = normalizeRepo(opts.repo);
     repos = repos.filter((r) => r.toLowerCase() === want.toLowerCase());
     if (repos.length === 0) {
-      return { ok: false, published: [], failed: [{ repo: want, error: "not on registry code roster" }], skipped: [] };
+      failed.push({ repo: want, error: "not on registry code roster" });
+      return answer(false);
     }
   }
-  const published = [];
-  const failed = [];
-  const skipped = [];
+  const busy = new Set(
+    (opts.skipRepos ?? []).map((repo) => normalizeRepoIndexRepo(repo)).filter((repo) => repo !== null)
+  );
   for (const repo of repos) {
+    if (busy.has(repo)) {
+      drift.push({ repo, reason: "busy-elsewhere", action: "skip" });
+      skipped.push(`${repo}: a per-repo reconcile run is already publishing it`);
+      continue;
+    }
+    let base = null;
+    let expectedActiveDigest;
+    let reason;
     try {
       const status = await statusRepoIndexCloud(repo, opts.deps);
-      const activeCommit = verifiedReadyCommit(status, repo);
-      if (activeCommit) {
-        const head = remoteHead(repo, opts.githubToken);
-        if (head === activeCommit) {
-          skipped.push(`${repo}: unchanged verified-ready authority at ${head}`);
-          continue;
-        }
+      if (isRepoIndexStatusError(status)) {
+        reason = "status-unreadable";
+      } else {
+        expectedActiveDigest = activePointerDigest(status) ?? "none";
+        base = verifiedReadyBase(status, repo);
+        reason = base ? "changed" : expectedActiveDigest === "none" ? "missing-authority" : "unverified-authority";
       }
     } catch {
+      base = null;
+      expectedActiveDigest = void 0;
+      reason = "status-unreadable";
     }
-    const dir = (0, import_node_fs27.mkdtempSync)((0, import_node_path25.join)((0, import_node_os13.tmpdir)(), "mmi-repo-index-"));
-    try {
-      const reconciled = await reconcileRepoIndexCloud(repo, opts.deps);
-      if (!reconciled.ok) {
-        failed.push({ repo, error: reconciled.error });
+    let targetCommit = requestedCommit || void 0;
+    if (base && !forceFull) {
+      if (!targetCommit) {
+        try {
+          targetCommit = remoteHead(repo, opts.githubToken);
+        } catch {
+          targetCommit = void 0;
+        }
+      }
+      const provenance = await fetchRepoIndexV4ProvenanceCloud(repo, opts.deps).catch(
+        (error) => ({ ok: false, error: error.message })
+      );
+      if (provenance.ok && !provenance.deltaCompatible) {
+        drift.push({ repo, reason: "incompatible-provenance", action: "needs-full-rebuild", activeCommit: base.commit, ...targetCommit ? { targetCommit } : {} });
+        needsFullRebuild.push(repo);
+        skipped.push(`${repo}: DRIFT incompatible index provenance \u2014 the active authority at ${base.commit} was not built by ${CURRENT_REPO_INDEX_PROVENANCE_TOKEN}; migrate it explicitly with \`oracle repo-index sync-estate --repo ${repo} --full-rebuild ${CURRENT_REPO_INDEX_PROVENANCE_TOKEN}\``);
+        continue;
+      }
+      if (targetCommit && targetCommit === base.commit) {
+        drift.push({ repo, reason: "healthy", action: "skip", activeCommit: base.commit, targetCommit });
+        skipped.push(`${repo}: unchanged verified-ready authority at ${targetCommit}`);
         continue;
       }
+    }
+    drift.push({
+      repo,
+      reason,
+      action: "build",
+      ...base ? { activeCommit: base.commit } : {},
+      ...targetCommit ? { targetCommit } : {}
+    });
+    if (opts.plan) continue;
+    const dir = (0, import_node_fs27.mkdtempSync)((0, import_node_path25.join)((0, import_node_os13.tmpdir)(), "mmi-repo-index-"));
+    try {
       shallowClone(repo, dir, opts.githubToken);
+      if (requestedCommit) checkoutExactCommit(repo, dir, opts.githubToken, requestedCommit);
       let v4;
       try {
-        v4 = await buildRepoIndexV4(dir, repo, { modelDirectory: process.env.MMI_REPO_INDEXER_MODEL_DIR });
-        const v4Published = await publishRepoIndexV4Cloud(v4, opts.deps);
+        const plan = await planDeltaBuild(repo, dir, base, opts.deps, opts.githubToken, forceFull);
+        if (base && plan.plan.mode === "full") skipped.push(`${repo}: full rebuild (${plan.plan.fallbackReason})`);
+        v4 = await buildRepoIndexV4Detailed(dir, repo, {
+          modelDirectory: process.env.MMI_REPO_INDEXER_MODEL_DIR,
+          ...plan.plan.mode === "delta" && plan.prior ? { delta: { baseCommit: plan.plan.baseCommit, prior: plan.prior, changes: plan.plan.changes } } : {}
+        });
+        const priorBucketDigests = plan.plan.mode === "delta" && plan.prior ? priorV4BucketDigests(repo, plan.prior) : [];
+        const v4Published = await publishRepoIndexV4Cloud(v4.envelope, opts.deps, {
+          ...expectedActiveDigest ? { expectedActiveDigest } : {},
+          ...priorBucketDigests.length ? { priorBucketDigests } : {}
+        });
         if (!v4Published.ok) {
           failed.push({ repo, error: `v4 failed: ${v4Published.error}` });
           continue;
@@ -24628,7 +26119,7 @@ async function syncEstateRepoIndex(opts) {
         failed.push({ repo, error: `v4 failed: ${error.message}` });
         continue;
       }
-      const v4Commit = v4.manifest.commit;
+      const v4Commit = v4.envelope.manifest.commit;
       let graphEdges;
       try {
         const edges = buildGraphEdges(dir, repo, v4Commit, allRosterRepos);
@@ -24638,15 +26129,16 @@ async function syncEstateRepoIndex(opts) {
       } catch (error) {
         skipped.push(`${repo}: optional v4 graph unavailable: ${error.message}`);
       }
-      const fileCount = v4.manifest.chunks.length;
-      const embCount = v4.manifest.embeddings.length;
+      const fileCount = v4.envelope.manifest.chunks.length;
+      const embCount = v4.envelope.manifest.embeddings.length;
       const embGap = Math.max(0, fileCount - embCount);
       published.push({
         repo,
         fileCount,
         embCount,
         embGap,
-        graphEdges
+        graphEdges,
+        metrics: v4.metrics
       });
     } catch (e) {
       failed.push({ repo, error: e.message });
@@ -24657,7 +26149,7 @@ async function syncEstateRepoIndex(opts) {
       }
     }
   }
-  return { ok: failed.length === 0, published, failed, skipped };
+  return answer();
 }
 
 // src/repo-index-health.ts
@@ -24934,7 +26426,7 @@ async function runRepoIndexHealth(opts) {
 }
 
 // src/spawn-policy-core.ts
-var import_node_child_process15 = require("node:child_process");
+var import_node_child_process16 = require("node:child_process");
 var import_node_fs29 = require("node:fs");
 var import_node_path26 = require("node:path");
 var SPAWNERS = ["spawn", "spawnSync", "exec", "execSync", "execFile", "execFileSync"];
@@ -25005,7 +26497,7 @@ function findViolationsInSource(raw) {
   return found;
 }
 function policedFiles(root) {
-  const r = (0, import_node_child_process15.spawnSync)("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const r = (0, import_node_child_process16.spawnSync)("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "utf8",
     windowsHide: true,
@@ -25039,7 +26531,7 @@ function runSpawnPolicy(root) {
 }
 
 // src/test-policy-core.ts
-var import_node_child_process16 = require("node:child_process");
+var import_node_child_process17 = require("node:child_process");
 var import_node_fs30 = require("node:fs");
 var import_node_path27 = require("node:path");
 var POLICY_FILE = "test-policy.json";
@@ -25093,8 +26585,252 @@ function globToRegExp(glob) {
 function isTestPath(path2) {
   return TEST_RE.test(path2) || PY_TEST_RE.test(path2);
 }
-function loadPolicy(root, readFile6 = readFileOrNull2) {
-  const raw = readFile6((0, import_node_path27.join)(root, POLICY_FILE));
+var SUPPORTED_SOURCE = /\.[cm]?[jt]s$/;
+var MAX_ANALYZED_BYTES = 512 * 1024;
+var WORD_CHAR = /[\w$\u0080-\uffff]/;
+var LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
+var PLAIN_IDENTIFIER = /^[A-Za-z_$\u0080-\uffff][\w$\u0080-\uffff]*$/;
+var REGEX_POSITION_WORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "yield",
+  "await",
+  "case",
+  "do",
+  "else",
+  "if",
+  "while",
+  "for",
+  "switch",
+  "catch",
+  "default",
+  "extends"
+]);
+var VALUE_END = /^[\w$\u0080-\uffff"'`]/;
+var AMBIGUOUS_BEFORE_SLASH = /* @__PURE__ */ new Set([")", "]", "}"]);
+var PUNCTUATORS = [
+  ">>>=",
+  "...",
+  "===",
+  "!==",
+  "**=",
+  "<<=",
+  ">>=",
+  ">>>",
+  "&&=",
+  "||=",
+  "??=",
+  "=>",
+  "==",
+  "!=",
+  "<=",
+  ">=",
+  "&&",
+  "||",
+  "??",
+  "?.",
+  "++",
+  "--",
+  "+=",
+  "-=",
+  "*=",
+  "%=",
+  "&=",
+  "|=",
+  "^=",
+  "**",
+  "<<",
+  ">>"
+];
+function scanTemplateChunk(src, start) {
+  let i = start;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === "`") return { text: src.slice(start, i + 1), end: i + 1, expr: false };
+    if (c === "$" && src[i + 1] === "{") return { text: src.slice(start, i + 2), end: i + 2, expr: true };
+    i++;
+  }
+  return null;
+}
+function scanRegex(src, start) {
+  let i = start + 1;
+  let inClass = false;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (LINE_TERMINATOR.test(c)) return null;
+    if (inClass) {
+      if (c === "]") inClass = false;
+    } else if (c === "[") {
+      inClass = true;
+    } else if (c === "/") {
+      i++;
+      while (i < src.length && WORD_CHAR.test(src[i])) i++;
+      return { text: src.slice(start, i), end: i };
+    }
+    i++;
+  }
+  return null;
+}
+function lexSource(src) {
+  const out = [];
+  const templates = [];
+  let nl = true;
+  let i = 0;
+  const push = (text) => {
+    out.push({ text, nl });
+    nl = false;
+  };
+  if (src.startsWith("#!")) {
+    const end = src.search(LINE_TERMINATOR);
+    push(src.slice(0, end === -1 ? src.length : end));
+    i = end === -1 ? src.length : end;
+  }
+  while (i < src.length) {
+    const c = src[i];
+    if (LINE_TERMINATOR.test(c)) {
+      nl = true;
+      i++;
+      continue;
+    }
+    if (c === " " || c === "	" || c === "\f" || c === "\v" || c === "\xA0" || c === "\uFEFF") {
+      i++;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "/") {
+      let j = i + 2;
+      while (j < src.length && !LINE_TERMINATOR.test(src[j])) j++;
+      i = j;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      if (end === -1) return null;
+      if (LINE_TERMINATOR.test(src.slice(i, end + 2))) nl = true;
+      i = end + 2;
+      continue;
+    }
+    if (c === "/") {
+      const prev = out[out.length - 1]?.text;
+      if (prev && AMBIGUOUS_BEFORE_SLASH.has(prev)) return null;
+      if (prev && VALUE_END.test(prev) && !(PLAIN_IDENTIFIER.test(prev) && REGEX_POSITION_WORDS.has(prev))) {
+        push("/");
+        i++;
+        continue;
+      }
+      const re = scanRegex(src, i);
+      if (!re) return null;
+      push(re.text);
+      i = re.end;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      let j = i + 1;
+      for (; ; ) {
+        if (j >= src.length) return null;
+        const d = src[j];
+        if (d === "\\") {
+          j += 2;
+          continue;
+        }
+        if (d === c) {
+          j++;
+          break;
+        }
+        if (d === "\n" || d === "\r") return null;
+        j++;
+      }
+      push(src.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (c === "`") {
+      const chunk = scanTemplateChunk(src, i + 1);
+      if (!chunk) return null;
+      push(`\`${chunk.text}`);
+      i = chunk.end;
+      if (chunk.expr) templates.push(0);
+      continue;
+    }
+    if (WORD_CHAR.test(c)) {
+      let j = i;
+      while (j < src.length && WORD_CHAR.test(src[j])) j++;
+      push(src.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (c === "{") {
+      if (templates.length) templates[templates.length - 1]++;
+      push("{");
+      i++;
+      continue;
+    }
+    if (c === "}") {
+      if (templates.length && templates[templates.length - 1] === 0) {
+        templates.pop();
+        push("}");
+        const chunk = scanTemplateChunk(src, i + 1);
+        if (!chunk) return null;
+        push(chunk.text);
+        i = chunk.end;
+        if (chunk.expr) templates.push(0);
+        continue;
+      }
+      if (templates.length) templates[templates.length - 1]--;
+      push("}");
+      i++;
+      continue;
+    }
+    const punct = PUNCTUATORS.find((p) => src.startsWith(p, i));
+    push(punct ?? c);
+    i += punct ? punct.length : 1;
+  }
+  return templates.length ? null : out;
+}
+function isMeaningfulChange(path2, before, after) {
+  if (before == null || after == null) return true;
+  if (before === after) return true;
+  if (!SUPPORTED_SOURCE.test(path2)) return true;
+  if (before.length > MAX_ANALYZED_BYTES || after.length > MAX_ANALYZED_BYTES) return true;
+  if (before.includes("\0") || after.includes("\0")) return true;
+  const a = lexSource(before);
+  const b = lexSource(after);
+  if (!a || !b || a.length !== b.length) return true;
+  return !a.every((t, k) => t.text === b[k].text && t.nl === b[k].nl);
+}
+function annotateChangeMeaning(changed, policy, read) {
+  const matchers = (policy.mandatory ?? []).map((m) => globToRegExp(m.glob));
+  return changed.map((file) => {
+    if (file.status !== "M" || !SUPPORTED_SOURCE.test(file.path)) return file;
+    if (!matchers.some((re) => re.test(file.path)) && !isTestPath(file.path)) return file;
+    let pair;
+    try {
+      pair = read(file.path);
+    } catch {
+      return file;
+    }
+    return isMeaningfulChange(file.path, pair.before, pair.after) ? file : { ...file, meaningful: false };
+  });
+}
+function isMeaningfulRow(file) {
+  return file.meaningful !== false;
+}
+function loadPolicy(root, readFile7 = readFileOrNull2) {
+  const raw = readFile7((0, import_node_path27.join)(root, POLICY_FILE));
   if (raw == null) return { mandatory: [], declared: false };
   try {
     return { ...JSON.parse(raw), declared: true };
@@ -25109,7 +26845,7 @@ function readFileOrNull2(path2) {
     return null;
   }
 }
-function removedPaths(changed) {
+function removedPaths2(changed) {
   return new Set(
     changed.map((f) => f.status === "D" ? f.path : f.status === "R" || f.status === "C" ? f.from : void 0).filter((p) => typeof p === "string")
   );
@@ -25119,9 +26855,10 @@ function classify(changed, policy, present = () => false) {
   const mandatoryHits = changed.filter((f) => matchers.some((m) => m.re.test(f.path)));
   const testChanges = changed.filter((f) => isTestPath(f.path));
   const addedTests = testChanges.filter((f) => f.status === "A");
-  const removed = removedPaths(changed);
+  const removed = removedPaths2(changed);
   const discharged = (m) => (m.satisfiedBy?.length ?? 0) > 0 && m.satisfiedBy.every((p) => present(p) && !removed.has(p));
-  const untestedHits = changed.filter((f) => matchers.some((m) => m.re.test(f.path) && !discharged(m)));
+  const untestedHits = changed.filter((f) => isMeaningfulRow(f) && matchers.some((m) => m.re.test(f.path) && !discharged(m)));
+  const meaningfulTestChanges = testChanges.filter(isMeaningfulRow);
   const protectedBy = new Map((policy.protected ?? []).map((p) => [p.path, p.why ?? ""]));
   for (const m of policy.mandatory ?? []) {
     for (const p of m.satisfiedBy ?? []) {
@@ -25129,7 +26866,7 @@ function classify(changed, policy, present = () => false) {
     }
   }
   const removedProtected = [...removed].filter((p) => protectedBy.has(p)).map((p) => ({ path: p, why: protectedBy.get(p) ?? "" }));
-  return { mandatoryHits, untestedHits, testChanges, addedTests, removedProtected };
+  return { mandatoryHits, untestedHits, testChanges, meaningfulTestChanges, addedTests, removedProtected };
 }
 function unresolvedProtectedEntries(policy, root, exists = (path2) => (0, import_node_fs30.existsSync)(path2)) {
   return (policy.protected ?? []).map((p) => p.path).filter((p) => !exists((0, import_node_path27.join)(root, p)));
@@ -25139,7 +26876,7 @@ function unresolvedSatisfiers(policy, root, exists = (path2) => (0, import_node_
   return [...new Set(declared)].filter((p) => !exists((0, import_node_path27.join)(root, p)));
 }
 function evaluate(changed, policy, present = () => false) {
-  const { mandatoryHits, untestedHits, testChanges, addedTests, removedProtected } = classify(changed, policy, present);
+  const { mandatoryHits, untestedHits, meaningfulTestChanges, addedTests, removedProtected } = classify(changed, policy, present);
   const findings = [];
   if (removedProtected.length > 0) {
     findings.push({
@@ -25150,7 +26887,7 @@ function evaluate(changed, policy, present = () => false) {
       ${f.why}`).join("\n") + "\n  If you are removing one because it looked unrequired, read the reason above first \u2014 it is\n  the answer to exactly that question. If this removal was asked for, add a commit trailer:\n  Test-Policy-Override: <reason>"
     });
   }
-  if (untestedHits.length > 0 && testChanges.length === 0) {
+  if (untestedHits.length > 0 && meaningfulTestChanges.length === 0) {
     findings.push({
       kind: "mandatory-zone-untested",
       paths: untestedHits.map((f) => f.path),
@@ -25169,14 +26906,14 @@ function evaluate(changed, policy, present = () => false) {
   return findings;
 }
 function git2(args, cwd) {
-  return (0, import_node_child_process16.execFileSync)("git", args, { windowsHide: true, cwd, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+  return (0, import_node_child_process17.execFileSync)("git", args, { windowsHide: true, cwd, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
 }
 var COAUTHOR_KEY = "Co-authored-by";
 var GH_MESSAGE_SEPARATOR = /^-{5,}$/;
 var LIFTED_KEYS = new RegExp(`^(?:${TRAILER_KEY}|${COAUTHOR_KEY}):`, "i");
 function parseTrailers(message, cwd) {
   try {
-    return (0, import_node_child_process16.execFileSync)("git", ["interpret-trailers", "--parse", "--unfold"], {
+    return (0, import_node_child_process17.execFileSync)("git", ["interpret-trailers", "--parse", "--unfold"], {
       windowsHide: true,
       cwd,
       input: message,
@@ -25316,16 +27053,27 @@ function changedFilesSince(base, cwd) {
   const untracked = git2(["ls-files", "--others", "--exclude-standard", "-z"], cwd).split("\0").filter(Boolean).map((path2) => ({ status: "A", path: path2.replace(/\\/g, "/") }));
   return [...changed, ...untracked];
 }
+function blobAt(base, path2, cwd) {
+  try {
+    return git2(["show", `${base}:${path2}`], cwd);
+  } catch {
+    return null;
+  }
+}
 function runTestPolicy(root, deps = {}) {
   const policy = deps.policy ?? loadPolicy(root);
   const exists = deps.exists ?? ((path2) => (0, import_node_fs30.existsSync)(path2));
   const counts = { mandatoryCount: (policy.mandatory ?? []).length, protectedCount: (policy.protected ?? []).length };
   const base = deps.changed ? "(injected)" : resolveBase(root, deps.base);
   const refusal = deps.changed ? null : untrustworthyRange(root, base);
-  const changed = deps.changed ?? (refusal ? [] : changedFilesSince(base, root));
+  const raw = deps.changed ?? (refusal ? [] : changedFilesSince(base, root));
+  const changed = deps.changed ? raw : annotateChangeMeaning(raw, policy, (path2) => ({
+    before: blobAt(base, path2, root),
+    after: readFileOrNull2((0, import_node_path27.join)(root, path2))
+  }));
   const lookup = deps.override !== void 0 ? { override: deps.override, refusals: [] } : !deps.changed && !refusal ? readOverride(base, root) : { override: null, refusals: [] };
   const present = (path2) => exists((0, import_node_path27.join)(root, path2));
-  const removedByThisDiff = removedPaths(changed);
+  const removedByThisDiff = removedPaths2(changed);
   const staleFindings = [];
   const unresolved = unresolvedProtectedEntries(policy, root, exists).filter((p) => !removedByThisDiff.has(p));
   if (unresolved.length > 0) {
@@ -26665,7 +28413,7 @@ function registerSecretsCommands(program3) {
 }
 
 // src/app-actor.ts
-var import_node_crypto10 = require("node:crypto");
+var import_node_crypto11 = require("node:crypto");
 var APP_ACTOR_ENV = "MMI_ACTOR";
 var APP_VAULT_REPO = "mutmutco/MMI-Hub";
 var APP_VAULT_KEYS = ["GITHUB_APP_ID", "GITHUB_APP_INSTALLATION_ID", "GITHUB_APP_PRIVATE_KEY"];
@@ -26709,7 +28457,7 @@ function mintAppJwt(appId, privateKeyPem, nowSec) {
     exp: now + APP_JWT_TTL_S,
     iss: appId
   }));
-  const signer = (0, import_node_crypto10.createSign)("RSA-SHA256");
+  const signer = (0, import_node_crypto11.createSign)("RSA-SHA256");
   signer.update(`${header}.${payload}`);
   return `${header}.${payload}.${signer.sign(privateKeyPem, "base64url")}`;
 }
@@ -27046,12 +28794,12 @@ ${SSH_RECIPE_AGENT_NOTE}`);
 
 // src/schedules-commands.ts
 var import_promises4 = require("node:fs/promises");
-var import_node_child_process17 = require("node:child_process");
+var import_node_child_process18 = require("node:child_process");
 var import_node_util7 = require("node:util");
 init_clean_exit();
 init_github_client();
 init_cli_shared();
-var execFileP5 = (0, import_node_util7.promisify)(import_node_child_process17.execFile);
+var execFileP5 = (0, import_node_util7.promisify)(import_node_child_process18.execFile);
 var AWS_REGION = "eu-central-1";
 var AWS_TIMEOUT_MS = 3e4;
 var AWS_RETRY_DELAY_MS = 1500;
@@ -27651,7 +29399,7 @@ init_clean_exit();
 init_github_client();
 
 // src/bootstrap-drift.ts
-var import_node_crypto11 = require("node:crypto");
+var import_node_crypto12 = require("node:crypto");
 function byteComparableSeeds(manifest, cls) {
   return manifest.seeds.filter((s) => s.ownership === "org" && s.source === "self" && s.classes.includes(cls));
 }
@@ -27671,7 +29419,7 @@ function compareSeedBytes(hubContent, repoContent) {
   return normalize(hubContent) === normalize(repoContent) ? "match" : "drift";
 }
 function seedContentHash(content) {
-  return (0, import_node_crypto11.createHash)("sha256").update(content.replace(/\r\n/g, "\n"), "utf8").digest("hex");
+  return (0, import_node_crypto12.createHash)("sha256").update(content.replace(/\r\n/g, "\n"), "utf8").digest("hex");
 }
 function auditRepoSeedDrift(repo, seeds, hubContents, repoReads) {
   const byTarget = new Map(repoReads.map((r) => [r.target, r.content]));
@@ -27747,10 +29495,8 @@ function statusFor(read, currentSha) {
   if (read.drift === "match") return { status: "match", record: { mergeSha: read.pr?.mergeSha } };
   const pr2 = read.pr;
   if (!pr2) return { status: "pending", record: {} };
+  if (pr2.sourceSha && pr2.sourceSha !== currentSha) return { status: "pending", record: {} };
   if (pr2.state === "closed") return { status: "closed-unmerged", record: { prNumber: pr2.number, prUrl: pr2.url } };
-  if (pr2.state === "merged" && pr2.sourceSha && pr2.sourceSha !== currentSha) {
-    return { status: "pending", record: {} };
-  }
   if (pr2.checks === "red") return { status: "red", record: { prNumber: pr2.number, prUrl: pr2.url } };
   return { status: "open-pending", record: { prNumber: pr2.number, prUrl: pr2.url, mergeSha: pr2.mergeSha } };
 }
@@ -27834,7 +29580,7 @@ function renderPropagationReport(plan) {
 }
 
 // src/bootstrap-propagation-identity.ts
-var import_node_crypto12 = require("node:crypto");
+var import_node_crypto13 = require("node:crypto");
 var PROPAGATION_BRANCH_PREFIX = "seed-propagate-";
 var TARGET_MARKER_NAME = "mmi-bootstrap-propagation-target";
 function safeBranchPart(value, maxLength, fallback) {
@@ -27847,7 +29593,7 @@ function repoSlug2(repo) {
 function propagationBranch(repo, target) {
   const repoPart = safeBranchPart(repoSlug2(repo), 32, "repo");
   const targetPart = safeBranchPart(target, 48, "target");
-  const hash = (0, import_node_crypto12.createHash)("sha256").update(repo.trim().toLowerCase()).update("\0").update(target).digest("hex").slice(0, 12);
+  const hash = (0, import_node_crypto13.createHash)("sha256").update(repo.trim().toLowerCase()).update("\0").update(target).digest("hex").slice(0, 12);
   return `${PROPAGATION_BRANCH_PREFIX}${repoPart}-${targetPart}-${hash}`;
 }
 function legacyPropagationBranch(repo) {
@@ -28848,7 +30594,7 @@ function registerBootstrapCommands(program3) {
     }
     const onlyManagedBlock = onlyTarget ? seedsToApply[0]?.managedBlock != null : false;
     const gh = async (args) => execFileP2("gh", args, { timeout: 2e4 });
-    const readFile6 = (p) => (0, import_node_fs34.existsSync)(p) ? (0, import_node_fs34.readFileSync)(p, "utf8") : null;
+    const readFile7 = (p) => (0, import_node_fs34.existsSync)(p) ? (0, import_node_fs34.readFileSync)(p, "utf8") : null;
     const enc = (p) => p.split("/").map(encodeURIComponent).join("/");
     const putSeed = async (target, content, ref, sha) => {
       const tmp = (0, import_node_path32.join)((0, import_node_os15.tmpdir)(), `mmi-seed-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
@@ -28963,7 +30709,7 @@ function registerBootstrapCommands(program3) {
         if (isLegacyBlock) {
           content = upsertManagedGitignoreBlock(remoteContent).content;
         } else {
-          const writeContent = resolveSeedWriteContent(resolved, vars, readFile6, remoteContent);
+          const writeContent = resolveSeedWriteContent(resolved, vars, readFile7, remoteContent);
           if (!writeContent.ok) {
             return fail(`bootstrap apply: ${resolved.target}: ${writeContent.reason} \u2014 refusing to overwrite repo-owned content`);
           }
@@ -29014,7 +30760,7 @@ function registerBootstrapCommands(program3) {
       if (prDecision.action === "reuse") {
         seedPrUrl = prDecision.url;
       } else {
-        const created = await ghCreate([
+        const created = requireGhCreateOk(await ghCreate([
           "pr",
           "create",
           "--repo",
@@ -29031,7 +30777,7 @@ function registerBootstrapCommands(program3) {
 ${onlyManagedBlock ? `Only the marker-bounded Hub-managed block inside repo-owned \`${onlyTarget}\`` : `The org-owned \`${onlyTarget}\` seed`} is declared by MMI-Hub's \`skills/bootstrap/seeds/manifest.json\` at MMI-Hub@${seedSource.sha}; this PR reconciles that declared scope and preserves everything outside it. It carries that file and nothing else \u2014 no labels, ruleset, merge settings or registry META were touched.
 
 \`${baseBranch}\` is protected (${seedPlan.reason}), so delivery goes via this branch + PR \u2014 a direct contents PUT 409s on a protected base.` : `Auto-opened by \`mmi-cli devops bootstrap apply --execute ${repo}\` (#2286): \`${baseBranch}\` is protected (${seedPlan.reason}), so the org-managed seed files are delivered via this branch + PR \u2014 a direct contents PUT 409s on a protected base ("N of N required status checks are expected"). Seeds are from MMI-Hub@${seedSource.sha}.`
-        ]);
+        ]), "bootstrap apply pr create");
         seedPrUrl = created.url;
       }
       let autoMergeEnabled = true;
@@ -29063,7 +30809,7 @@ ${onlyManagedBlock ? `Only the marker-bounded Hub-managed block inside repo-owne
       }
       const rulesetSeed = manifest.seeds.find((s) => s.target === ".github/rulesets/mmi-product-required-checks.json");
       if (rulesetSeed) {
-        const rulesetContent = resolveSeedContent({ ...rulesetSeed, target: rulesetSeed.target.replace("{{REPO_SLUG}}", slug) }, vars, readFile6);
+        const rulesetContent = resolveSeedContent({ ...rulesetSeed, target: rulesetSeed.target.replace("{{REPO_SLUG}}", slug) }, vars, readFile7);
         if (rulesetContent) {
           try {
             const client = defaultGitHubClient();
@@ -29342,11 +31088,18 @@ LIVE apply to ${repo}:
           []
         );
         const prDecision = decideSeedPrAction(identifiedOpenPrs);
+        const prBody = `Auto-opened by \`mmi-cli devops bootstrap propagate --target ${seed.target} --execute\` (#4238), wave ${rec.wave}.
+
+Propagates MMI-Hub@${headSha}'s ${seed.managedBlock ? "declared marker-bounded block inside repo-owned" : "org-owned copy of"} \`${seed.target}\` \u2014 the file this PR carries and nothing else; content outside a managed block remains untouched.
+${renderPropagationTargetMarker(seed.target)}
+
+Rollback: \`mmi-cli devops bootstrap rollback ${rec.repo} --target ${seed.target} --execute\` (#4240) reverts this PR's merge commit; never re-run propagate with old bytes.`;
         let prUrl;
         if (prDecision.action === "reuse") {
           prUrl = prDecision.url;
+          await gh(["pr", "edit", prUrl, "--repo", rec.repo, "--body", prBody]);
         } else {
-          const created = await ghCreate([
+          const created = requireGhCreateOk(await ghCreate([
             "pr",
             "create",
             "--repo",
@@ -29358,13 +31111,8 @@ LIVE apply to ${repo}:
             "--title",
             `chore: propagate ${seed.managedBlock ? "Hub-managed block in" : "org-owned"} ${seed.target} from MMI-Hub (wave ${rec.wave})`,
             "--body",
-            `Auto-opened by \`mmi-cli devops bootstrap propagate --target ${seed.target} --execute\` (#4238), wave ${rec.wave}.
-
-Propagates MMI-Hub@${headSha}'s ${seed.managedBlock ? "declared marker-bounded block inside repo-owned" : "org-owned copy of"} \`${seed.target}\` \u2014 the file this PR carries and nothing else; content outside a managed block remains untouched.
-${renderPropagationTargetMarker(seed.target)}
-
-Rollback: \`mmi-cli devops bootstrap rollback ${rec.repo} --target ${seed.target} --execute\` (#4240) reverts this PR's merge commit; never re-run propagate with old bytes.`
-          ]);
+            prBody
+          ]), "bootstrap propagate pr create");
           prUrl = created.url;
         }
         if (rec.wave !== 0) {
@@ -29511,7 +31259,10 @@ Rollback: \`mmi-cli devops bootstrap rollback ${rec.repo} --target ${seed.target
       if (prDecision.action === "reuse") {
         prUrl = prDecision.url;
       } else {
-        const created = await ghCreate(["pr", "create", "--repo", repo, "--base", baseBranch, "--head", plan.branch, "--title", plan.title, "--body", plan.body]);
+        const created = requireGhCreateOk(
+          await ghCreate(["pr", "create", "--repo", repo, "--base", baseBranch, "--head", plan.branch, "--title", plan.title, "--body", plan.body]),
+          "bootstrap rollback pr create"
+        );
         prUrl = created.url;
       }
       plan.prUrl = prUrl;
@@ -29711,6 +31462,15 @@ async function detectPublicIpFrom(url, fetchImpl) {
   if (!validStageLiveIp(ip)) throw new Error(`public IP detection returned a non-IP body from ${url}: "${ip.slice(0, 80)}"`);
   return ip;
 }
+function isStageLiveDeployModel(deployModel, projectType) {
+  if (deployModel) return deployModel === "tenant-container";
+  return projectType === "web-app";
+}
+function stageLiveUnsupportedReason(deployModel, projectType) {
+  if (isStageLiveDeployModel(deployModel, projectType)) return null;
+  const got = deployModel ?? (projectType ? `projectType=${projectType}` : "unset");
+  return `stage --live applies to tenant-container repos only (registry deployModel = ${got}; registry-publish and other models have no personal cloud dev stage)`;
+}
 function stageLiveUpSteps(t) {
   return [
     { label: `detect your public IPv4 and IPv6 (${IP_ECHO_URL} + ${IP6_ECHO_URL}, bounded, in parallel)` },
@@ -29725,6 +31485,16 @@ function stageLiveDownSteps(t) {
     { label: `remove the Cloudflare edge gate for ${t.host} via the Hub backend (tenant-control cf-gate-clear)` }
   ];
 }
+function stageLiveDownNoop(t, reason) {
+  return {
+    command: "stage --live",
+    mode: "down",
+    slug: t.slug,
+    repo: t.repo,
+    dispatched: [],
+    message: `no live stage to tear down \u2014 ${reason}`
+  };
+}
 async function runStageLiveUp(deps, t) {
   if (!t.ref?.trim()) throw new Error("stage --live: cannot resolve the current branch to deploy");
   const detected = await deps.detectIp();
@@ -29969,7 +31739,14 @@ function registerStageCommands(program3) {
     const meta = await fetchProjectBySlug(slug, registryClientDeps(await loadConfig())).catch(() => null);
     const host = requireEdgeDomain(meta, "dev", slug);
     if (!host.trim()) throw new Error(`stage --live: no dev edge host for ${slug} (registry edgeDomains.dev)`);
-    return { slug, repo, host, ref };
+    return {
+      slug,
+      repo,
+      host,
+      ref,
+      deployModel: typeof meta?.deployModel === "string" ? meta.deployModel : void 0,
+      projectType: typeof meta?.projectType === "string" ? meta.projectType : void 0
+    };
   }
   async function runStageLiveCommand(o) {
     let target;
@@ -29978,6 +31755,19 @@ function registerStageCommands(program3) {
     } catch (e) {
       return failGraceful(e.message);
     }
+    const unsupported = stageLiveUnsupportedReason(target.deployModel, target.projectType);
+    if (unsupported) {
+      if (o.down) {
+        const result = stageLiveDownNoop(target, unsupported);
+        if (!o.apply) {
+          const steps = [{ label: result.message }];
+          if (o.json) return console.log(JSON.stringify({ command: "stage --live", mode: "down", slug: target.slug, repo: target.repo, noop: true, steps }, null, 2));
+          return console.log(renderSteps("mmi-cli stage --live --down: dry-run plan", steps));
+        }
+        return printLine(o.json ? JSON.stringify(result) : `mmi-cli stage --live: ${result.message}`);
+      }
+      return failGraceful(unsupported);
+    }
     const mode = o.down ? "down" : "up";
     if (!o.apply) {
       const steps = o.down ? stageLiveDownSteps(target) : stageLiveUpSteps(target);
@@ -30510,6 +32300,13 @@ async function remoteBranchExists2(branch, options = {}) {
 init_cli_shared();
 init_clean_exit();
 init_error_codes();
+function refuseRateLimited(e, json) {
+  if (!isRateLimitedError(e)) return false;
+  if (json) console.log(JSON.stringify(e.receipt));
+  else console.error(`mmi-cli board claim failed: ${e.receipt.message} \u2014 retry: ${e.receipt.retryCommand}`);
+  process.exitCode = 1;
+  return true;
+}
 function registerBoardCommands(program3) {
   function withDiscoverMissDetail(message) {
     const miss = lastBoardDiscoverMiss();
@@ -30521,13 +32318,14 @@ function registerBoardCommands(program3) {
   }
   async function runBoardRead(o) {
     try {
+      const config = await loadConfigForRepo(o.repo);
       const report = await readBoard({
-        config: await loadConfigForRepo(o.repo),
+        config,
         repo: o.repo,
         includeBundleDetails: o.bundleDetails,
         includeAllBodies: o.bodies,
         allowPartial: o.allowPartial
-      });
+      }, { snapshot: registryClientDeps(config) });
       console.log(o.json ? JSON.stringify(report) : renderBoardReport(report));
     } catch (e) {
       return failGraceful(`board read failed: ${withDiscoverMissDetail(e.message)}`);
@@ -30558,6 +32356,7 @@ function registerBoardCommands(program3) {
         if (o.json) return console.log(JSON.stringify(result));
         console.log(result.checked ? checkVerdict(result.item.ref, result.alreadyClaimed) : result.partial ? `Partially claimed ${result.item.ref}: ${result.warning}` : result.alreadyClaimed ? `Already claimed ${result.item.ref} - In Progress (no change)` : `Claimed ${result.item.ref} - In Progress`);
       } catch (e) {
+        if (refuseRateLimited(e, o.json)) return;
         return failGraceful(`board claim failed: ${e.message}`);
       }
       return;
@@ -30582,6 +32381,7 @@ function registerBoardCommands(program3) {
       }
       if (bulk.failed > 0) process.exitCode = 1;
     } catch (e) {
+      if (refuseRateLimited(e, o.json)) return;
       return failGraceful(`board claim failed: ${e.message}`);
     }
   }), [
@@ -31183,7 +32983,7 @@ async function checkDocsIndexAtHead(opts, deps) {
 
 // src/issue-commands.ts
 var import_node_fs38 = require("node:fs");
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 init_cli_shared();
 init_clean_exit();
 init_error_codes();
@@ -31656,7 +33456,7 @@ function rowIdempotencyKey(batchKey, spec) {
   const identity = `${spec.type}
 ${spec.title.trim()}
 ${spec.body ?? ""}`;
-  const hash = (0, import_node_crypto13.createHash)("sha256").update(identity).digest("hex").slice(0, 16);
+  const hash = (0, import_node_crypto14.createHash)("sha256").update(identity).digest("hex").slice(0, 16);
   return `${batchKey}:${hash}`;
 }
 var BATCH_SPEC_KEYS = /* @__PURE__ */ new Set(["type", "title", "body", "priority", "labels", "label", "parent", "repo", "surface"]);
@@ -31803,6 +33603,11 @@ ${lines}`);
         const attached = await deps.attach(row.number, rowRepo(spec), rowPriority);
         row.onBoard = attached.onBoard;
         if (attached.projectItemId) row.projectItemId = attached.projectItemId;
+        if (attached.boardAttach) {
+          row.boardAttach = attached.boardAttach;
+          if (attached.resetAt) row.resetAt = attached.resetAt;
+          if (attached.resetEpochSeconds !== void 0) row.resetEpochSeconds = attached.resetEpochSeconds;
+        }
       }
       const parentRef = spec.parent ?? options.parent;
       if (parentRef) {
@@ -33098,6 +34903,214 @@ function registerPrLifecycleCommands(program3) {
   });
 }
 
+// src/post-merge-recon.ts
+var import_node_fs41 = require("node:fs");
+var import_node_path38 = require("node:path");
+
+// src/cross-repo-filing-issue.ts
+init_github_client();
+function crossRepoFilingRetryCommand(prRepo, prNumber) {
+  return `mmi-cli devops pr merge ${prNumber} --repo ${prRepo}`;
+}
+function crossRepoFilingRateLimitedResult(e, prRepo, prNumber) {
+  return {
+    status: "rate-limited",
+    error: e instanceof Error ? e.message : String(e ?? "rate-limited"),
+    rateLimited: rateLimitedReceipt({
+      resetEpochSeconds: resetEpochFromError(e),
+      retryCommand: crossRepoFilingRetryCommand(prRepo, prNumber),
+      context: "cross-repo filing-issue reconciliation"
+    })
+  };
+}
+async function discoverSameOrgIssueNumber(client, currentRepo, number) {
+  const [owner] = currentRepo.split("/");
+  if (!owner) throw new Error(`cannot derive an organization from ${currentRepo}`);
+  const repositories = await client.restPaginate(`orgs/${owner}/repos?type=all`);
+  const hits = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < repositories.length) {
+      const repo = repositories[next++]?.full_name;
+      if (!repo || repo.toLowerCase() === currentRepo.toLowerCase()) continue;
+      const issue2 = await readExactIssue(client, repo, number);
+      if (issue2) hits.push(issue2);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(8, repositories.length) }, () => worker()));
+  return hits.sort((left, right) => left.repo.localeCompare(right.repo));
+}
+async function readExactIssue(client, repo, number) {
+  try {
+    const issue2 = await client.rest("GET", `repos/${repo}/issues/${number}`);
+    if (issue2.pull_request || issue2.number !== number || !issue2.title || !issue2.html_url) return void 0;
+    const state = issue2.state?.toUpperCase();
+    if (state !== "OPEN" && state !== "CLOSED") return void 0;
+    return { repo, number, title: issue2.title, url: issue2.html_url, state };
+  } catch (e) {
+    if (e instanceof GitHubApiError && e.status === 404) return void 0;
+    throw e;
+  }
+}
+function explicitSameOrgIssueUrls(text, prRepo, closingNumbers) {
+  const [owner] = prRepo.split("/");
+  const found = /* @__PURE__ */ new Map();
+  for (const match of text.matchAll(/https:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/issues\/(\d+)\b/gi)) {
+    const repo = match[1];
+    const number = Number(match[2]);
+    if (!repo || !Number.isInteger(number) || !closingNumbers.has(number)) continue;
+    if (repo.split("/")[0]?.toLowerCase() !== owner.toLowerCase() || repo.toLowerCase() === prRepo.toLowerCase()) continue;
+    found.set(`${repo.toLowerCase()}#${number}`, { repo, number });
+  }
+  return [...found.values()];
+}
+async function reconcileCrossRepoFilingIssue(client, prRepo, prNumber) {
+  try {
+    const pr2 = await client.rest("GET", `repos/${prRepo}/pulls/${prNumber}`);
+    if (!pr2.merged_at) return { status: "not-applicable" };
+    const text = `${pr2.title ?? ""}
+${pr2.body ?? ""}`;
+    const closingNumbers = new Set(findClosingMentions(text).filter((mention) => !mention.negated).map((mention) => mention.issue));
+    if (closingNumbers.size === 0) return { status: "not-applicable" };
+    const explicit = explicitSameOrgIssueUrls(text, prRepo, closingNumbers);
+    let target;
+    if (explicit.length > 1) {
+      return { status: "failed", error: `multiple same-org issue URLs match bare closing references (${explicit.map((x) => `${x.repo}#${x.number}`).join(", ")})` };
+    }
+    if (explicit.length === 1) {
+      target = await readExactIssue(client, explicit[0].repo, explicit[0].number);
+      if (!target) return { status: "failed", issue: `${explicit[0].repo}#${explicit[0].number}`, error: "the explicit foreign issue URL did not resolve to an issue" };
+    } else {
+      const branchNumber = Number(/^#?(\d+)(?:-|$)/.exec(pr2.head?.ref ?? "")?.[1]);
+      if (!Number.isInteger(branchNumber) || !closingNumbers.has(branchNumber)) return { status: "not-applicable" };
+      if (await readExactIssue(client, prRepo, branchNumber)) return { status: "not-applicable" };
+      const matches = await discoverSameOrgIssueNumber(client, prRepo, branchNumber);
+      if (matches.length !== 1) {
+        return {
+          status: "failed",
+          error: matches.length === 0 ? `branch #${branchNumber} matches a bare closing reference, but no same-org filing issue was found` : `branch #${branchNumber} is ambiguous across ${matches.map((match) => match.repo).join(", ")}`
+        };
+      }
+      target = matches[0];
+    }
+    const issue2 = `${target.repo}#${target.number}`;
+    if (target.state === "CLOSED") return { status: "already-closed", issue: issue2, url: target.url };
+    const prUrl = pr2.html_url ?? `https://github.com/${prRepo}/pull/${prNumber}`;
+    const comment = await client.rest("POST", `repos/${target.repo}/issues/${target.number}/comments`, {
+      body: { body: `Resolved by merged PR ${prUrl}.
+
+<!-- mmi-cross-repo-close:${prRepo}#${prNumber} -->` }
+    });
+    if (!comment.html_url) throw new Error(`GitHub created no evidence URL on ${issue2}`);
+    await closeIssue(client, { ref: issue2, reason: "completed", evidence: comment.html_url });
+    return { status: "closed", issue: issue2, url: target.url, evidence: comment.html_url };
+  } catch (e) {
+    if (isRateLimitRefusal(e)) return crossRepoFilingRateLimitedResult(e, prRepo, prNumber);
+    return { status: "failed", error: e.message };
+  }
+}
+
+// src/post-merge-recon.ts
+var POST_MERGE_RECON_SCHEMA_VERSION = 1;
+function postMergeReconRetryCommand(repo, pr2) {
+  return crossRepoFilingRetryCommand(repo, Number(pr2));
+}
+function postMergeReconStatePath(cwd, repo, pr2) {
+  const safe = repo.replace(/[^A-Za-z0-9._-]+/g, "_");
+  return repoRuntimeStatePath(cwd, "post-merge-recon", `${safe}-${pr2}.json`);
+}
+function isBoardAdvanceRateLimitedOnly(result) {
+  if (!result) return false;
+  if (result.status === "fetch-failed") {
+    return isRateLimitText(result.error ?? "");
+  }
+  const failures = boardAdvanceFailures(result);
+  if (!failures.length) return false;
+  return failures.every((f) => typeof f.error === "string" && isRateLimitText(f.error));
+}
+function postMergeReconExitCode(input) {
+  if (input.crossRepoFilingIssue.status === "failed") return 1;
+  if (isBoardAdvanceRateLimitedOnly(input.boardAdvance)) {
+  } else {
+    const boardCode = boardAdvanceExitCode(input.boardAdvance);
+    if (boardCode !== void 0) return boardCode;
+  }
+  return void 0;
+}
+function buildPostMergeReconRecovery(input) {
+  const pending = [];
+  if (isBoardAdvanceRateLimitedOnly(input.boardAdvance)) pending.push("board-advance");
+  if (input.crossRepoFilingIssue.status === "rate-limited") pending.push("cross-repo-filing");
+  if (!pending.length) return void 0;
+  const pr2 = Number(input.pr);
+  const retryCommand = postMergeReconRetryCommand(input.repo, pr2);
+  const nowMs = input.nowMs ?? Date.now();
+  let rateLimited;
+  if (input.crossRepoFilingIssue.status === "rate-limited") {
+    rateLimited = input.crossRepoFilingIssue.rateLimited;
+  } else if (isBoardAdvanceRateLimitedOnly(input.boardAdvance)) {
+    rateLimited = rateLimitedReceipt({
+      resetEpochSeconds: void 0,
+      retryCommand,
+      context: "post-merge board advance",
+      nowMs,
+      message: input.boardAdvance.status === "fetch-failed" ? `post-merge board advance: ${input.boardAdvance.error ?? "rate-limited"}` : "post-merge board advance: rate-limited while moving closed issues to Done"
+    });
+  }
+  return {
+    schemaVersion: POST_MERGE_RECON_SCHEMA_VERSION,
+    mergeStatus: "merged",
+    repo: input.repo,
+    pr: pr2,
+    pending,
+    retryCommand,
+    createdAt: new Date(nowMs).toISOString(),
+    ...rateLimited ? { rateLimited } : {},
+    boardAdvanceStatus: input.boardAdvance.status,
+    crossRepoFilingStatus: input.crossRepoFilingIssue.status
+  };
+}
+function writePostMergeReconRecovery(cwd, recovery) {
+  const path2 = postMergeReconStatePath(cwd, recovery.repo, recovery.pr);
+  (0, import_node_fs41.mkdirSync)((0, import_node_path38.dirname)(path2), { recursive: true });
+  (0, import_node_fs41.writeFileSync)(path2, `${JSON.stringify(recovery, null, 2)}
+`, "utf8");
+  return path2;
+}
+function clearPostMergeReconRecovery(cwd, repo, pr2) {
+  const path2 = postMergeReconStatePath(cwd, repo, pr2);
+  if (!(0, import_node_fs41.existsSync)(path2)) return;
+  try {
+    (0, import_node_fs41.unlinkSync)(path2);
+  } catch {
+  }
+}
+function postMergeReconWarnings(input) {
+  const lines = [];
+  const boardMsg = boardAdvanceFailureMessage(input.boardAdvance);
+  if (boardMsg) {
+    if (isBoardAdvanceRateLimitedOnly(input.boardAdvance)) {
+      const reset = input.recovery?.rateLimited?.resetAt ? ` (reset ${input.recovery.rateLimited.resetAt})` : "";
+      lines.push(
+        `${input.context}: board advance deferred \u2014 GitHub rate-limited${reset}; the PR MERGED. Retry board/filing later: ${input.recovery?.retryCommand ?? postMergeReconRetryCommand("(repo)", "(pr)")}`
+      );
+    } else {
+      lines.push(boardMsg);
+    }
+  }
+  if (input.crossRepoFilingIssue.status === "rate-limited") {
+    const r = input.crossRepoFilingIssue.rateLimited;
+    lines.push(
+      `${input.context}: cross-repo filing-issue reconciliation deferred \u2014 ${r.message}. The PR MERGED. Retry: ${r.retryCommand}` + (input.recoveryPath ? ` (recovery state: ${input.recoveryPath})` : "")
+    );
+  } else if (input.crossRepoFilingIssue.status === "failed") {
+    lines.push(
+      `${input.context}: cross-repo filing-issue reconciliation failed (${input.crossRepoFilingIssue.error}) \u2014 the PR MERGED, but a foreign filing issue may remain open.`
+    );
+  }
+  return lines;
+}
+
 // src/session-report.ts
 init_cli_shared();
 var GC_GH_TIMEOUT_MS4 = 2e4;
@@ -35366,6 +37379,13 @@ function checkDocsIndex(probe) {
     verbose: evidence
   };
 }
+var REPO_INDEX_RECONCILE_SCHEDULE_ID = "MMI-Hub/repo-index-reconcile";
+function isHubOwnedRepoIndexGap(probe) {
+  if (probe.kind === "missing-authority") return true;
+  if (probe.kind !== "healthy") return false;
+  const readiness = probe.v4Readiness;
+  return probe.cloudV4State === "invalid" || probe.cloudV4State === "tombstoned" || probe.cloudV4State === "degraded" && (probe.localV4EmbeddingCoverage ?? 1) < 0.95 || !readiness || readiness.verdict === "not-ready";
+}
 function checkRepoIndexCloud(probe) {
   if (!probe) return null;
   const percent = (value) => value == null ? "n/a" : `${Math.round(value * 100)}%`;
@@ -35389,14 +37409,14 @@ function checkRepoIndexCloud(probe) {
   ];
   switch (probe.kind) {
     case "healthy": {
-      const v4Unready = probe.cloudV4State === "invalid" || probe.cloudV4State === "tombstoned" || probe.cloudV4State === "degraded" && (probe.localV4EmbeddingCoverage ?? 1) < 0.95 || !readiness || readiness.verdict === "not-ready";
+      const v4Unready = isHubOwnedRepoIndexGap(probe);
       const detail = probe.detail ?? `cloud v4 ${probe.cloudV4State ?? "absent"}, readiness ${readiness?.verdict ?? "unknown"}`;
       return {
         ok: !v4Unready,
         id: "repo-index",
         label: "repo-index",
         detail,
-        ...v4Unready ? { fix: "run `mmi-hub update`, then dispatch `mmi-cli harbour org schedules run MMI-Hub/repo-index-reconcile`; require v4 authority and readiness to become ready" } : {},
+        ...v4Unready ? { fix: `Hub-owned: run \`mmi-cli harbour org schedules run ${REPO_INDEX_RECONCILE_SCHEDULE_ID}\` (or \`mmi-hub update\` then that schedule); require v4 authority and readiness to become ready` } : {},
         verbose: evidence
       };
     }
@@ -35425,7 +37445,7 @@ function checkRepoIndexCloud(probe) {
         id: "repo-index",
         label: "repo-index",
         detail: probe.detail ?? "no active v4 authority for this repo",
-        fix: "dispatch `mmi-cli harbour org schedules run MMI-Hub/repo-index-reconcile` or run the authenticated per-repo sync",
+        fix: `Hub-owned: dispatch \`mmi-cli harbour org schedules run ${REPO_INDEX_RECONCILE_SCHEDULE_ID}\` or run the authenticated per-repo sync`,
         verbose: evidence
       };
     case "auth":
@@ -35801,7 +37821,30 @@ async function runDoctorClean(opts, io, deps) {
       return;
     }
     const row = checkRepoIndexCloud(probe);
-    if (row) emitNow(row);
+    if (!row) return;
+    if (opts.self && probe && !row.ok && isHubOwnedRepoIndexGap(probe)) {
+      row.reportOnly = true;
+      const evidence = [...row.verbose ?? [], `owner: Hub schedule ${REPO_INDEX_RECONCILE_SCHEDULE_ID}`];
+      if (deps.dispatchRepoIndexReconcile) {
+        healIntent(`repo-index \u2014 dispatching ${REPO_INDEX_RECONCILE_SCHEDULE_ID}`);
+        try {
+          const dispatched = await deps.dispatchRepoIndexReconcile();
+          evidence.push(`self-route: ${dispatched.detail}`);
+          row.fix = dispatched.ok ? `dispatched Hub-owned ${REPO_INDEX_RECONCILE_SCHEDULE_ID} \u2014 orientation may continue; re-run doctor after reconcile settles` : `Hub-owned ${REPO_INDEX_RECONCILE_SCHEDULE_ID} \u2014 dispatch failed (${dispatched.detail}); run \`mmi-cli harbour org schedules run ${REPO_INDEX_RECONCILE_SCHEDULE_ID}\``;
+          if (dispatched.ok) {
+            row.detail = `${row.detail} \u2014 reconcile dispatched`;
+          }
+        } catch (e) {
+          const message = e instanceof Error ? e.message : String(e);
+          evidence.push(`self-route threw: ${message}`);
+          row.fix = `Hub-owned ${REPO_INDEX_RECONCILE_SCHEDULE_ID} \u2014 dispatch threw (${message}); run \`mmi-cli harbour org schedules run ${REPO_INDEX_RECONCILE_SCHEDULE_ID}\``;
+        }
+      } else {
+        row.fix = `Hub-owned ${REPO_INDEX_RECONCILE_SCHEDULE_ID} \u2014 run \`mmi-cli harbour org schedules run ${REPO_INDEX_RECONCILE_SCHEDULE_ID}\`; orientation may continue`;
+      }
+      row.verbose = evidence;
+    }
+    emitNow(row);
   }
   async function runBoardDoctorRow() {
     if (!deps.boardDoctorFix) return;
@@ -35966,6 +38009,79 @@ async function runDoctorClean(opts, io, deps) {
       });
     }
   }
+  async function runDeployPortCollisionsRow() {
+    if (!deps.deployPortCollisionsState) return;
+    try {
+      const state = await deps.deployPortCollisionsState();
+      if (!state) {
+        emitNow({
+          ok: true,
+          warn: true,
+          reportOnly: true,
+          id: "deploy-port-collisions",
+          label: "deploy port collisions",
+          detail: "skipped",
+          verbose: ["deployPortCollisionsState returned undefined"]
+        });
+        return;
+      }
+      if (state.forbidden) {
+        emitNow({
+          ok: true,
+          reportOnly: true,
+          id: "deploy-port-collisions",
+          label: "deploy port collisions",
+          detail: "skipped \u2014 master-admin only",
+          verbose: ["deployPortCollisionsState returned 403"]
+        });
+        return;
+      }
+      if (state.readFailed) {
+        emitNow({
+          ok: false,
+          warn: true,
+          reportOnly: true,
+          id: "deploy-port-collisions",
+          label: "deploy port collisions",
+          detail: `could not be read \u2014 ${state.error ?? "unknown error"}`,
+          fix: "run `mmi-cli oracle org project deploy doctor`",
+          verbose: [`deployPortCollisionsState failed: ${state.error ?? "unknown error"}`]
+        });
+        return;
+      }
+      if (state.ok) {
+        emitNow({
+          ok: true,
+          reportOnly: true,
+          id: "deploy-port-collisions",
+          label: "deploy port collisions",
+          detail: "no duplicate (sshHost, port)",
+          verbose: ["no colliding DEPLOY# coordinates"]
+        });
+        return;
+      }
+      emitNow({
+        ok: false,
+        reportOnly: true,
+        id: "deploy-port-collisions",
+        label: "deploy port collisions",
+        detail: `${state.lines.length} colliding coordinate(s)`,
+        fix: "run `mmi-cli oracle org project deploy doctor` then set-deploy one owner to a free port",
+        verbose: state.lines
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      emitNow({
+        ok: true,
+        warn: true,
+        reportOnly: true,
+        id: "deploy-port-collisions",
+        label: "deploy port collisions",
+        detail: `skipped \u2014 ${message}`,
+        verbose: [`deployPortCollisionsState threw: ${message}`]
+      });
+    }
+  }
   async function runHousekeeperRows() {
     const repoRoot2 = await deps.repoRoot();
     const scratch = deps.executeScratchGc(repoRoot2, { apply: false });
@@ -36010,7 +38126,8 @@ async function runDoctorClean(opts, io, deps) {
       // Hub cloud probe (short timeout). Full lane + `--self`; `--preflight` may emit command-absent only (#4156).
       { id: "repo-index", when: isOrgRepo && (lane.full || Boolean(opts.self) || lane.preflight), run: runRepoIndexRow },
       { id: "board-doctor", when: isOrgRepo && lane.full, run: runBoardDoctorRow },
-      { id: "schedules-drift", when: isOrgRepo && lane.full, run: runSchedulesDriftRow }
+      { id: "schedules-drift", when: isOrgRepo && lane.full, run: runSchedulesDriftRow },
+      { id: "deploy-port-collisions", when: isOrgRepo && lane.full, run: runDeployPortCollisionsRow }
     ];
     await Promise.all(parallelRows.filter((entry) => entry.when).map((entry) => entry.run()));
     const suffix = [
@@ -36142,19 +38259,19 @@ function ghAccountCaveat(announcedLogin, accounts) {
 }
 
 // src/doctor-io.ts
-var import_node_fs41 = require("node:fs");
+var import_node_fs42 = require("node:fs");
 var import_node_os18 = require("node:os");
-var import_node_path38 = require("node:path");
-var import_node_child_process18 = require("node:child_process");
+var import_node_path39 = require("node:path");
+var import_node_child_process19 = require("node:child_process");
 var import_node_util8 = require("node:util");
 init_version_lag();
 init_plugin_guard_io();
-var execFileP6 = (0, import_node_util8.promisify)(import_node_child_process18.execFile);
+var execFileP6 = (0, import_node_util8.promisify)(import_node_child_process19.execFile);
 var MMI_PLUGIN_ID2 = "mmi@mutmutco";
 function installedClaudePluginVersion() {
   try {
     const file = JSON.parse(
-      (0, import_node_fs41.readFileSync)((0, import_node_path38.join)((0, import_node_os18.homedir)(), ".claude", "plugins", "installed_plugins.json"), "utf8")
+      (0, import_node_fs42.readFileSync)((0, import_node_path39.join)((0, import_node_os18.homedir)(), ".claude", "plugins", "installed_plugins.json"), "utf8")
     );
     const versions = (file.plugins?.[MMI_PLUGIN_ID2] ?? []).map((r) => r.version).filter((v) => Boolean(v));
     if (versions.length === 0) return void 0;
@@ -36165,7 +38282,7 @@ function installedClaudePluginVersion() {
 }
 function manifestVersion(path2) {
   try {
-    const manifest = JSON.parse((0, import_node_fs41.readFileSync)(path2, "utf8"));
+    const manifest = JSON.parse((0, import_node_fs42.readFileSync)(path2, "utf8"));
     return typeof manifest.version === "string" && manifest.version.trim() ? manifest.version.trim() : void 0;
   } catch {
     return void 0;
@@ -36174,12 +38291,12 @@ function manifestVersion(path2) {
 function readHermesPluginEvidence(env = process.env) {
   const host = hermesConfigRoot(env);
   const root = hermesPluginRoot(env);
-  const installRecordPresent = (0, import_node_fs41.existsSync)(root);
-  const manifestPath = (0, import_node_path38.join)(root, "plugin.yaml");
+  const installRecordPresent = (0, import_node_fs42.existsSync)(root);
+  const manifestPath = (0, import_node_path39.join)(root, "plugin.yaml");
   let installedVersion;
   let manifest = "missing";
   try {
-    const text = (0, import_node_fs41.readFileSync)(manifestPath, "utf8");
+    const text = (0, import_node_fs42.readFileSync)(manifestPath, "utf8");
     let version;
     try {
       const parsed = JSON.parse(text).version;
@@ -36193,20 +38310,20 @@ function readHermesPluginEvidence(env = process.env) {
     if (version) {
       installedVersion = version;
       manifest = "valid";
-    } else if ((0, import_node_fs41.existsSync)(manifestPath)) manifest = "invalid";
+    } else if ((0, import_node_fs42.existsSync)(manifestPath)) manifest = "invalid";
   } catch {
-    if ((0, import_node_fs41.existsSync)(manifestPath)) manifest = "invalid";
+    if ((0, import_node_fs42.existsSync)(manifestPath)) manifest = "invalid";
   }
   let skills = false;
   try {
-    skills = (0, import_node_fs41.existsSync)((0, import_node_path38.join)(root, "skills")) && (0, import_node_fs41.statSync)((0, import_node_path38.join)(root, "skills")).isDirectory();
+    skills = (0, import_node_fs42.existsSync)((0, import_node_path39.join)(root, "skills")) && (0, import_node_fs42.statSync)((0, import_node_path39.join)(root, "skills")).isDirectory();
   } catch {
   }
   return {
-    hostPresent: (0, import_node_fs41.existsSync)(host),
+    hostPresent: (0, import_node_fs42.existsSync)(host),
     installRecordPresent,
     manifest,
-    payloadPresent: (0, import_node_fs41.existsSync)((0, import_node_path38.join)(root, "__init__.py")) && skills && manifest === "valid",
+    payloadPresent: (0, import_node_fs42.existsSync)((0, import_node_path39.join)(root, "__init__.py")) && skills && manifest === "valid",
     ...installedVersion ? { installedVersion } : {}
   };
 }
@@ -36214,7 +38331,7 @@ function installedSurfacePluginVersion(surface) {
   const token = surfaceToken(surface);
   if (token === "kilo") {
     try {
-      const stamp = (0, import_node_fs41.readFileSync)((0, import_node_path38.join)((0, import_node_os18.homedir)(), ".kilo", ".mmi-kilo-version"), "utf8").trim();
+      const stamp = (0, import_node_fs42.readFileSync)((0, import_node_path39.join)((0, import_node_os18.homedir)(), ".kilo", ".mmi-kilo-version"), "utf8").trim();
       return stamp || void 0;
     } catch {
       return void 0;
@@ -36222,23 +38339,23 @@ function installedSurfacePluginVersion(surface) {
   }
   if (token === "hermes") return readHermesPluginEvidence().installedVersion;
   if (token === "cursor") {
-    return manifestVersion((0, import_node_path38.join)(cursorLocalPluginRoot(), ".cursor-plugin", "plugin.json"));
+    return manifestVersion((0, import_node_path39.join)(cursorLocalPluginRoot(), ".cursor-plugin", "plugin.json"));
   }
   if (token === "jervcode") {
     return installedJervCodePackageVersion();
   }
   if (token === "kimi") {
-    return manifestVersion((0, import_node_path38.join)(surfaceConfigRoot(surface), "plugins", "managed", "mmi", ".kimi-plugin", "plugin.json"));
+    return manifestVersion((0, import_node_path39.join)(surfaceConfigRoot(surface), "plugins", "managed", "mmi", ".kimi-plugin", "plugin.json"));
   }
   if (token === "claude") return installedClaudePluginVersion();
   if (token !== "codex") return void 0;
   try {
-    const raw = process.platform === "win32" ? (0, import_node_child_process18.execFileSync)("cmd.exe", ["/c", "codex", "plugin", "list", "--json"], {
+    const raw = process.platform === "win32" ? (0, import_node_child_process19.execFileSync)("cmd.exe", ["/c", "codex", "plugin", "list", "--json"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 15e3,
       windowsHide: true
-    }) : (0, import_node_child_process18.execFileSync)("codex", ["plugin", "list", "--json"], {
+    }) : (0, import_node_child_process19.execFileSync)("codex", ["plugin", "list", "--json"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 15e3,
@@ -36256,7 +38373,7 @@ function installedActivePluginVersion(surface = detectSurface(process.env)) {
 }
 function worktreeRootSync() {
   try {
-    const out = (0, import_node_child_process18.execFileSync)("git", ["rev-parse", "--show-toplevel"], { windowsHide: true, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const out = (0, import_node_child_process19.execFileSync)("git", ["rev-parse", "--show-toplevel"], { windowsHide: true, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     let root = out.endsWith("\n") ? out.slice(0, -1) : out;
     if (process.platform === "win32" && root.endsWith("\r")) root = root.slice(0, -1);
     return root || null;
@@ -36266,13 +38383,13 @@ function worktreeRootSync() {
 }
 var gitignorePath = () => {
   const root = worktreeRootSync();
-  return root === null ? null : (0, import_node_path38.join)(root, ".gitignore");
+  return root === null ? null : (0, import_node_path39.join)(root, ".gitignore");
 };
 function readGitignore() {
   const path2 = gitignorePath();
   if (path2 === null) return null;
   try {
-    return (0, import_node_fs41.readFileSync)(path2, "utf8");
+    return (0, import_node_fs42.readFileSync)(path2, "utf8");
   } catch {
     return null;
   }
@@ -36281,16 +38398,16 @@ function writeGitignore(content) {
   const path2 = gitignorePath();
   if (path2 === null) return false;
   try {
-    (0, import_node_fs41.writeFileSync)(path2, content, "utf8");
+    (0, import_node_fs42.writeFileSync)(path2, content, "utf8");
     return true;
   } catch {
     return false;
   }
 }
 function lineEndingState(root) {
-  const attributesPresent = (0, import_node_fs41.existsSync)((0, import_node_path38.join)(root, ".gitattributes"));
+  const attributesPresent = (0, import_node_fs42.existsSync)((0, import_node_path39.join)(root, ".gitattributes"));
   try {
-    const output = (0, import_node_child_process18.execFileSync)("git", ["-C", root, "ls-files", "--eol", "--", ":(glob)**/*.sh"], {
+    const output = (0, import_node_child_process19.execFileSync)("git", ["-C", root, "ls-files", "--eol", "--", ":(glob)**/*.sh"], {
       windowsHide: true,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -36313,94 +38430,6 @@ async function repoRoot() {
   return worktreeRootSync() ?? process.cwd();
 }
 
-// src/cross-repo-filing-issue.ts
-init_github_client();
-async function discoverSameOrgIssueNumber(client, currentRepo, number) {
-  const [owner] = currentRepo.split("/");
-  if (!owner) throw new Error(`cannot derive an organization from ${currentRepo}`);
-  const repositories = await client.restPaginate(`orgs/${owner}/repos?type=all`);
-  const hits = [];
-  let next = 0;
-  const worker = async () => {
-    while (next < repositories.length) {
-      const repo = repositories[next++]?.full_name;
-      if (!repo || repo.toLowerCase() === currentRepo.toLowerCase()) continue;
-      const issue2 = await readExactIssue(client, repo, number);
-      if (issue2) hits.push(issue2);
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(8, repositories.length) }, () => worker()));
-  return hits.sort((left, right) => left.repo.localeCompare(right.repo));
-}
-async function readExactIssue(client, repo, number) {
-  try {
-    const issue2 = await client.rest("GET", `repos/${repo}/issues/${number}`);
-    if (issue2.pull_request || issue2.number !== number || !issue2.title || !issue2.html_url) return void 0;
-    const state = issue2.state?.toUpperCase();
-    if (state !== "OPEN" && state !== "CLOSED") return void 0;
-    return { repo, number, title: issue2.title, url: issue2.html_url, state };
-  } catch (e) {
-    if (e instanceof GitHubApiError && e.status === 404) return void 0;
-    throw e;
-  }
-}
-function explicitSameOrgIssueUrls(text, prRepo, closingNumbers) {
-  const [owner] = prRepo.split("/");
-  const found = /* @__PURE__ */ new Map();
-  for (const match of text.matchAll(/https:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/issues\/(\d+)\b/gi)) {
-    const repo = match[1];
-    const number = Number(match[2]);
-    if (!repo || !Number.isInteger(number) || !closingNumbers.has(number)) continue;
-    if (repo.split("/")[0]?.toLowerCase() !== owner.toLowerCase() || repo.toLowerCase() === prRepo.toLowerCase()) continue;
-    found.set(`${repo.toLowerCase()}#${number}`, { repo, number });
-  }
-  return [...found.values()];
-}
-async function reconcileCrossRepoFilingIssue(client, prRepo, prNumber) {
-  try {
-    const pr2 = await client.rest("GET", `repos/${prRepo}/pulls/${prNumber}`);
-    if (!pr2.merged_at) return { status: "not-applicable" };
-    const text = `${pr2.title ?? ""}
-${pr2.body ?? ""}`;
-    const closingNumbers = new Set(findClosingMentions(text).filter((mention) => !mention.negated).map((mention) => mention.issue));
-    if (closingNumbers.size === 0) return { status: "not-applicable" };
-    const explicit = explicitSameOrgIssueUrls(text, prRepo, closingNumbers);
-    let target;
-    if (explicit.length > 1) {
-      return { status: "failed", error: `multiple same-org issue URLs match bare closing references (${explicit.map((x) => `${x.repo}#${x.number}`).join(", ")})` };
-    }
-    if (explicit.length === 1) {
-      target = await readExactIssue(client, explicit[0].repo, explicit[0].number);
-      if (!target) return { status: "failed", issue: `${explicit[0].repo}#${explicit[0].number}`, error: "the explicit foreign issue URL did not resolve to an issue" };
-    } else {
-      const branchNumber = Number(/^#?(\d+)(?:-|$)/.exec(pr2.head?.ref ?? "")?.[1]);
-      if (!Number.isInteger(branchNumber) || !closingNumbers.has(branchNumber)) return { status: "not-applicable" };
-      if (await readExactIssue(client, prRepo, branchNumber)) return { status: "not-applicable" };
-      const matches = await discoverSameOrgIssueNumber(client, prRepo, branchNumber);
-      if (matches.length !== 1) {
-        return {
-          status: "failed",
-          error: matches.length === 0 ? `branch #${branchNumber} matches a bare closing reference, but no same-org filing issue was found` : `branch #${branchNumber} is ambiguous across ${matches.map((match) => match.repo).join(", ")}`
-        };
-      }
-      target = matches[0];
-    }
-    const issue2 = `${target.repo}#${target.number}`;
-    if (target.state === "CLOSED") return { status: "already-closed", issue: issue2, url: target.url };
-    const prUrl = pr2.html_url ?? `https://github.com/${prRepo}/pull/${prNumber}`;
-    const comment = await client.rest("POST", `repos/${target.repo}/issues/${target.number}/comments`, {
-      body: { body: `Resolved by merged PR ${prUrl}.
-
-<!-- mmi-cross-repo-close:${prRepo}#${prNumber} -->` }
-    });
-    if (!comment.html_url) throw new Error(`GitHub created no evidence URL on ${issue2}`);
-    await closeIssue(client, { ref: issue2, reason: "completed", evidence: comment.html_url });
-    return { status: "closed", issue: issue2, url: target.url, evidence: comment.html_url };
-  } catch (e) {
-    return { status: "failed", error: e.message };
-  }
-}
-
 // src/pr-deploy-dev.ts
 function slugOfRepo(repo) {
   return repo.split("/")[1]?.toLowerCase() ?? "";
@@ -36445,8 +38474,8 @@ ${r.stderr ?? ""}`).catch(() => "");
 function ghMultiAccountCaveat(announcedLogin) {
   try {
     const hostsPath = ghHostsConfigPath(process.env, process.platform);
-    if (!hostsPath || !(0, import_node_fs42.existsSync)(hostsPath)) return void 0;
-    return ghAccountCaveat(announcedLogin, parseGhHostsAccounts((0, import_node_fs42.readFileSync)(hostsPath, "utf8")));
+    if (!hostsPath || !(0, import_node_fs43.existsSync)(hostsPath)) return void 0;
+    return ghAccountCaveat(announcedLogin, parseGhHostsAccounts((0, import_node_fs43.readFileSync)(hostsPath, "utf8")));
   } catch {
     return void 0;
   }
@@ -36454,7 +38483,7 @@ function ghMultiAccountCaveat(announcedLogin) {
 var ENV_HEAL_LOCK_STALE_MS = 10 * 6e4;
 var ENV_HEAL_LOCK_MAX_WAIT_MS = 2 * 6e4;
 function envHealLockPath(home) {
-  return (0, import_node_path39.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
+  return (0, import_node_path40.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
 }
 async function withEnvHealLock(what, run) {
   try {
@@ -36589,7 +38618,7 @@ function mmiDoctorDeps(opts = {}) {
       );
       const result = applyPluginCachePlan(
         plan,
-        (p) => (0, import_node_fs42.rmSync)(p, { recursive: true }),
+        (p) => (0, import_node_fs43.rmSync)(p, { recursive: true }),
         stagingApplyFsGuard(configRoot)
       );
       return {
@@ -36627,7 +38656,7 @@ function mmiDoctorDeps(opts = {}) {
     // adopted the generated routing index (MMG-Unlive: `docs/Archive/**` only, no index, no gate.yml) would
     // get a permanent — demanding an artifact it never asked for.
     docsIndexState: (root) => {
-      if (!(0, import_node_fs42.existsSync)((0, import_node_path39.join)(root, DOCS_INDEX_PATH))) return void 0;
+      if (!(0, import_node_fs43.existsSync)((0, import_node_path40.join)(root, DOCS_INDEX_PATH))) return void 0;
       const real = createDocsIndexDeps(root);
       let docs2;
       const listDocs = () => docs2 ??= real.listDocs();
@@ -36636,7 +38665,7 @@ function mmiDoctorDeps(opts = {}) {
     },
     // #4168: working-tree heal — write if drifted, then re-check. Commit remains the operator's step.
     healDocsIndex: (root) => {
-      if (!(0, import_node_fs42.existsSync)((0, import_node_path39.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
+      if (!(0, import_node_fs43.existsSync)((0, import_node_path40.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
       const real = createDocsIndexDeps(root);
       let docs2;
       const listDocs = () => docs2 ??= real.listDocs();
@@ -36703,6 +38732,21 @@ function mmiDoctorDeps(opts = {}) {
         clearTimeout(ceiling);
       }
     },
+    // #5431: estate DEPLOY# (sshHost, port) uniqueness — master-only Hub read; report-only.
+    deployPortCollisionsState: async () => {
+      try {
+        const cfg = await loadConfig();
+        const report = await fetchDeployPortCollisions(registryClientDeps(cfg));
+        if (report.status === 403) return { ok: true, lines: [], forbidden: true };
+        if (report.error) return { ok: false, lines: [], readFailed: true, error: report.error };
+        return {
+          ok: report.ok,
+          lines: report.collisions.map((c) => c.report)
+        };
+      } catch (e) {
+        return { ok: false, lines: [], readFailed: true, error: e instanceof Error ? e.message : String(e) };
+      }
+    },
     // #4173: estate commands absent from the running Commander program (stale global CLI).
     missingCliCommands: () => {
       const required = ["repo-index"];
@@ -36713,7 +38757,7 @@ function mmiDoctorDeps(opts = {}) {
     repoIndexCloudState: async (root) => {
       let localV4 = { state: "absent" };
       try {
-        const parsed = JSON.parse((0, import_node_fs42.readFileSync)(repoIndexV4StorePath(root), "utf8"));
+        const parsed = JSON.parse((0, import_node_fs43.readFileSync)(repoIndexV4StorePath(root), "utf8"));
         const state = parsed.status?.state;
         if (parsed.schemaVersion === 4 && (state === "ready" || state === "degraded")) {
           const chunks = parsed.manifest?.chunks?.length ?? 0;
@@ -36765,6 +38809,21 @@ function mmiDoctorDeps(opts = {}) {
           ...localFields
         };
       }
+    },
+    // #5437: `--self` self-routes Hub-owned v4 readiness via the harbour reconcile schedule.
+    dispatchRepoIndexReconcile: async () => {
+      try {
+        const res = await postSchedulesRun(REPO_INDEX_RECONCILE_SCHEDULE_ID, registryClientDeps(await loadConfig()));
+        if (!res.ok) {
+          return {
+            ok: false,
+            detail: res.error ?? `HTTP ${res.status}${res.body ? ` \u2014 ${JSON.stringify(res.body)}` : ""}`
+          };
+        }
+        return { ok: true, detail: `accepted ${REPO_INDEX_RECONCILE_SCHEDULE_ID}` };
+      } catch (e) {
+        return { ok: false, detail: e instanceof Error ? e.message : String(e) };
+      }
     }
   };
 }
@@ -36976,19 +39035,19 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 var rules = program2.command("rules").description("org-managed .gitignore delivery");
 rules.command("gitignore").option("--write", "upsert the managed block into .gitignore (default: check only, non-zero exit on drift)").option("--json", "machine-readable output").description("verify (or --write) this repo's org-managed .gitignore block matches the SSOT").action((opts) => {
-  const path2 = (0, import_node_path39.join)(process.cwd(), ".gitignore");
-  const current = (0, import_node_fs42.existsSync)(path2) ? (0, import_node_fs42.readFileSync)(path2, "utf8") : null;
+  const path2 = (0, import_node_path40.join)(process.cwd(), ".gitignore");
+  const current = (0, import_node_fs43.existsSync)(path2) ? (0, import_node_fs43.readFileSync)(path2, "utf8") : null;
   const plan = planManagedGitignore(current);
   const drift = [...plan.added.map((l) => `+${l}`), ...plan.removed.map((l) => `-${l}`)].join(", ") || "block normalize";
   if (opts.json) {
-    if (opts.write && plan.changed) (0, import_node_fs42.writeFileSync)(path2, plan.content, "utf8");
+    if (opts.write && plan.changed) (0, import_node_fs43.writeFileSync)(path2, plan.content, "utf8");
     console.log(JSON.stringify(plan, null, 2));
     if (!opts.write && plan.changed) process.exitCode = 1;
     return;
   }
   if (opts.write) {
     if (plan.changed) {
-      (0, import_node_fs42.writeFileSync)(path2, plan.content, "utf8");
+      (0, import_node_fs43.writeFileSync)(path2, plan.content, "utf8");
       console.log(`mmi-cli devops org rules gitignore: updated .gitignore (${drift})`);
     } else {
       console.log("mmi-cli devops org rules gitignore: up to date");
@@ -37126,8 +39185,14 @@ async function attachToProject(issueNumber, repo, priority) {
         await setBoardItemPriority(defaultGitHubClient(), cfg, projectItemId, priority);
       } catch (e) {
         const err = e;
-        process.stderr.write(`warning: issue #${issueNumber} board Priority not set: ${(err.stderr || err.message || String(e)).trim()}
+        const detail = (err.stderr || err.message || String(e)).trim();
+        if (isRateLimitText(detail)) {
+          process.stderr.write(`warning: issue #${issueNumber} on board but Priority not set (rate-limited): ${detail}
+`);
+        } else {
+          process.stderr.write(`warning: issue #${issueNumber} board Priority not set: ${detail}
 `);
+        }
       }
     }
     return { projectItemId, onBoard: true };
@@ -37146,6 +39211,18 @@ async function attachToProject(issueNumber, repo, priority) {
       }
       return { onBoard: true };
     }
+    if (isRateLimitText(detail)) {
+      process.stderr.write(`warning: issue #${issueNumber} created but board attach rate-limited: ${detail}
+`);
+      let resetEpochSeconds;
+      try {
+        const { stdout } = await execFileP2("gh", ["api", "rate_limit"], { timeout: 15e3 });
+        const pools = parseRateLimitPools(stdout);
+        resetEpochSeconds = pools.graphql?.reset ?? pools.core?.reset;
+      } catch {
+      }
+      return boardAttachRateLimitedReceipt(resetEpochSeconds);
+    }
     process.stderr.write(`warning: issue #${issueNumber} created but NOT added to the project board: ${detail}
 `);
     return { onBoard: false };
@@ -37156,7 +39233,7 @@ function scheduleRelatedDiscovery(o) {
   try {
     const args = ["issue", "discover-related", "--number", String(o.number), "--title", o.title, "--body", o.body, "--fail-soft"];
     if (o.repo) args.push("--repo", o.repo);
-    spawnDetachedSelf(args, { spawn: import_node_child_process19.spawn, execPath: process.execPath, scriptPath: process.argv[1] }, { cwd: process.cwd() });
+    spawnDetachedSelf(args, { spawn: import_node_child_process20.spawn, execPath: process.execPath, scriptPath: process.argv[1] }, { cwd: process.cwd() });
   } catch {
   }
 }
@@ -37231,12 +39308,57 @@ async function runRepoIndexSearchCommand(query, o, defaultMode) {
     }
     const mode = o.semantic ? "semantic" : o.lexical ? "lexical" : defaultMode;
     const cfg = await loadConfig();
-    const res = await searchRepoIndexCloud(query, { mode, limit, repo: o.repo }, registryClientDeps(cfg));
-    if (!res.ok) return await failGraceful(res.error);
+    const deps = registryClientDeps(cfg);
+    let res = await searchRepoIndexCloud(query, { mode, limit, repo: o.repo }, deps);
+    if (!res.ok && shouldRetryRepoIndexSearchLexical(res, mode)) {
+      const lexical = await searchRepoIndexCloud(query, { mode: "lexical", limit, repo: o.repo }, deps);
+      if (lexical.ok) {
+        res = {
+          ...lexical,
+          degradedReasons: [...lexical.degradedReasons ?? [], "query-embedding-unavailable"],
+          note: [
+            lexical.note,
+            "query embedding unavailable \u2014 served lexical citations (v4 semantic not claimed ready)"
+          ].filter(Boolean).join("; ")
+        };
+      }
+    }
+    if (!res.ok) {
+      const receipt = asCloudSearchNotReadyReceipt(res);
+      const typed = refuseBareRepoIndexV4Unavailable(receipt.error);
+      if (o.json) {
+        consoleIo.log(JSON.stringify({ source: "cloud", ...receipt, error: typed }, null, 2));
+      } else {
+        console.error(`mmi-cli ${typed}`);
+        const authority = receipt.v4Authority;
+        if (authority) {
+          const ready = authority.readyAuthorities ?? 0;
+          const roster = authority.rosterCount ?? 0;
+          console.error(`repo-index: v4 status not-ready \u2014 readyAuthorities=${ready}/${roster} nOfN=${authority.nOfN === true}`);
+        } else {
+          console.error("repo-index: v4 status not-ready \u2014 Hub search unavailable (see cause above)");
+        }
+        if (authority?.authorityFailures?.length) {
+          for (const failure of authority.authorityFailures.slice(0, 12)) {
+            console.error(`repo-index: authority ${failure.repo} ${failure.reason}`);
+          }
+          if (authority.authorityFailures.length > 12) {
+            console.error(`repo-index: \u2026 ${authority.authorityFailures.length - 12} more authority failure(s)`);
+          }
+        }
+        if (receipt.omittedRepos?.length) {
+          console.error(`repo-index: omittedRepos ${receipt.omittedRepos.slice(0, 8).join(", ")}${receipt.omittedRepos.length > 8 ? "\u2026" : ""}`);
+        }
+        if (receipt.next) console.error(`repo-index: next \u2014 ${receipt.next}`);
+        console.error("repo-index: status remains not-ready until reconcile repairs authorities (search did not claim v4 ready)");
+      }
+      return await cleanExit(1);
+    }
     if (o.json) {
       consoleIo.log(JSON.stringify({ source: "cloud", ...res }, null, 2));
       return;
     }
+    if (res.note) console.error(`repo-index: ${res.note}`);
     if (res.hits.length === 0) {
       console.log(`repo-index: no cloud hits for ${JSON.stringify(query)} (${res.mode})`);
       return;
@@ -37246,7 +39368,7 @@ async function runRepoIndexSearchCommand(query, o, defaultMode) {
       console.log(`${h.score.toFixed(2)}  ${h.kind.padEnd(8)}  ${h.repo}  ${h.path}${sym}  (${h.why})`);
     }
   } catch (e) {
-    return await failGraceful(e.message);
+    return await failGraceful(refuseBareRepoIndexV4Unavailable(e.message));
   }
 }
 var REPO_INDEX_SEARCH_WHEN = 'beats grep for cross-repo questions, "where does X happen", and unknown filenames; grep wins inside a known checkout';
@@ -37357,7 +39479,7 @@ repoIndex.command("gc").description("remove v4 cloud authority material for repo
     return await failGraceful(e.message);
   }
 });
-repoIndex.command("sync-estate").description("Hub indexer: shallow-clone registry repos, build and publish v4 authorities (CI / operator)").option("--repo <owner/name>", "limit to one registered repo").option("--json", "machine-readable result").action(async (o) => {
+repoIndex.command("sync-estate").description("Hub indexer: publish a pushed commit as a delta, or run the estate drift/repair lane (CI / operator)").option("--repo <owner/name>", "limit to one registered repo").option("--commit <sha>", "index this exact 40-hex commit (requires --repo); the checkout is proved against it").option("--full-rebuild <token>", `explicit full rebuild \u2014 must quote this pipeline's provenance token (${CURRENT_REPO_INDEX_PROVENANCE_TOKEN})`).option("--skip-repo <owner/name>", "estate lane: a repo a per-repo run is already publishing (repeatable)", (value, all) => [...all, value], []).option("--plan", "read-only: classify every repo and print the plan without cloning, embedding or publishing").option("--json", "machine-readable result").action(async (o) => {
   try {
     const cfg = await loadConfig();
     const gh = process.env.GH_TOKEN || process.env.GITHUB_TOKEN || "";
@@ -37365,6 +39487,10 @@ repoIndex.command("sync-estate").description("Hub indexer: shallow-clone registr
     const res = await syncEstateRepoIndex({
       deps: registryClientDeps(cfg),
       repo: o.repo,
+      commit: o.commit,
+      fullRebuild: o.fullRebuild,
+      skipRepos: o.skipRepo,
+      plan: Boolean(o.plan),
       githubToken: gh
     });
     if (o.json) {
@@ -37372,11 +39498,22 @@ repoIndex.command("sync-estate").description("Hub indexer: shallow-clone registr
       if (!res.ok) process.exitCode = 1;
       return;
     }
+    console.log(`repo-index: pipeline provenance ${res.provenanceToken} \u2014 delta is the normal path${o.plan ? " (plan only: nothing was cloned, embedded or published)" : ""}`);
+    for (const row of res.drift) {
+      if (row.reason === "healthy") continue;
+      const at = row.targetCommit ? ` target=${row.targetCommit.slice(0, 12)}` : "";
+      const active = row.activeCommit ? ` active=${row.activeCommit.slice(0, 12)}` : "";
+      console.log(`repo-index: ${row.repo} ${row.reason} \u2192 ${row.action}${active}${at}`);
+    }
     for (const p of res.published) {
       const gap = p.embGap ?? Math.max(0, p.fileCount - (p.embCount ?? 0));
       console.log(`repo-index: published v4 ${p.repo} \u2014 ${p.fileCount} chunks emb=${p.embCount ?? 0}/${p.fileCount} gap=${gap} graph=${p.graphEdges ?? "unavailable"}`);
+      if (p.metrics) console.log(`repo-index: ${formatV4BuildMetrics(p.repo, p.metrics)}`);
     }
     for (const warning of res.skipped) console.error(`repo-index: WARN ${warning}`);
+    if (res.needsFullRebuild.length) {
+      console.error(`repo-index: ${res.needsFullRebuild.length} repo(s) need an explicit tokened migration: ${res.needsFullRebuild.join(", ")}`);
+    }
     for (const f of res.failed) {
       console.error(`repo-index: FAILED ${f.repo}: ${f.error}`);
     }
@@ -37724,6 +39861,17 @@ projectDeploy.command("get [owner/repo]").description("read nonsecret DEPLOY# fa
   const payload = stage ? { slug: out.slug, stage, deploy: out.stages[stage] ?? null } : out;
   console.log(JSON.stringify(payload));
 });
+projectDeploy.command("doctor").description("read-only estate scan for duplicate Hetzner (sshHost, port) DEPLOY# coordinates (#5431); master-only; never auto-reassigns ports").option("--json", "machine-readable output").action(async (o) => {
+  const cfg = await loadConfig();
+  const report = await fetchDeployPortCollisions(registryClientDeps(cfg));
+  if (o.json) {
+    printLine(JSON.stringify(report, null, 2));
+  } else {
+    for (const line of renderDeployPortDoctor(report)) printLine(line);
+  }
+  if (report.error && report.status !== 403) return failGraceful(`org project deploy doctor: ${report.error}`);
+  if (!report.ok && !report.error) process.exitCode = 1;
+});
 project.command("set [owner/repo]").description("upsert project META (idempotent merge; master-gated)").addOption(new Option("--class <class>", "deployable | content").choices(["deployable", "content"])).addOption(new Option("--project-type <type>", `${PROJECT_TYPES.join(" | ")} (capability shape)`).choices([...PROJECT_TYPES])).addOption(new Option("--deploy-model <model>", `${DEPLOY_MODELS.join(" | ")} (release/deploy path; none means no Hub deploy registration)`).choices([...DEPLOY_MODELS])).addOption(new Option("--release-track <track>", `${RELEASE_TRACKS.join(" | ")} (branch topology; direct skips rc)`).choices([...RELEASE_TRACKS])).option("--var <KEY=VALUE...>", settableVarHelp()).option("--set <KEY=VALUE...>", "alias of --var (one KEY=VALUE per flag; repeat the flag to set several)").option("--secrets-file <path>", 'read the #2244 secrets catalog map (JSON) from a file and merge it per entry into the existing catalog (clear all with --unset secrets). SHAPE: a JSON object keyed by env name, each entry {"key":"UPPER_SNAKE" (repeat the env name), "purpose":"<non-empty>", "group":"<e.g. auth|database>", "owner":"<github login>", "stages":[] (empty = the one stageless shared value; else any of dev/rc/main), "consumers":["runtime"|"box"|?], "provider":"<optional>"}').option("--unset <KEY...>", "META field to remove (repeatable): oauth, requiredRuntimeSecrets, requiredBuildSecrets, secrets, edgeDomains, requiredGcpApis, publishRequired").option("--clear-web-profile", "remove web-only registry fields (oauth, edgeDomains) for non-web/content projects").option("--json", "machine-readable output").action(async (repoOrSlug, o) => {
   const cfg = await loadConfig();
   let target;
@@ -37740,7 +39888,7 @@ project.command("set [owner/repo]").description("upsert project META (idempotent
   if (dupe) return fail(`org project set: KEY "${dupe}" was passed to both --var and --set; --set is an alias of --var, so pass each KEY once`);
   if (o.secretsFile) {
     try {
-      vars.push(`secrets=${(0, import_node_fs42.readFileSync)(o.secretsFile, "utf8")}`);
+      vars.push(`secrets=${(0, import_node_fs43.readFileSync)(o.secretsFile, "utf8")}`);
     } catch (e) {
       return fail(`org project set: cannot read --secrets-file ${o.secretsFile}: ${e.message}`);
     }
@@ -38090,7 +40238,7 @@ function resolveCreateSurface(opts) {
 function surfaceWaived() {
   return rawFlag("--no-surface");
 }
-var issue = program2.command("issue").description("issues \u2014 reliable create with structured output");
+var issue = program2.command("issue").description("issues \u2014 create and view with structured JSON (view; show is an alias for board-verb callers)");
 withExamples(mutating(
   issue.command("create").description("create an issue (type \u2014 label) and print {number,url,label} JSON").addOption(new Option("--type <type>", "bug | feature | task (sets the matching label; required unless --batch)").choices([...ISSUE_TYPES])).option("--title <title>", "issue title").option("--title-file <path|->", "read the issue title from a UTF-8 file, or from stdin with -").option("--body <body>", "issue body (markdown)").option("--body-file <path|->", "read issue body from a UTF-8 file. `-` (stdin) needs a heredoc, which the agent inline-body guard denies (#1473/#2125) \u2014 prefer a real path; a title with backticks needs --title-file for the same reason (#3381)").option("--priority <priority>", "urgent | high | medium | low (defaults to medium; sets the board Priority field only \u2014 never a priority:* label, #416)").option("--repo <owner/repo>", "target repo (defaults to the current repo)").option("--label <label...>", "extra label(s) to attach (repeatable; auto-created if missing)").option("--surface <surface>", "issue surface, with or without the surface: prefix (#3789). Required when the target repo runs the one-surface-label board rule; any value satisfies it, so this is not a closed enum").option("--no-surface", "file without a surface label on a repo that requires one \u2014 for a genuinely exempt filing (e.g. a coop proof issue that spans every surface)").option("--parent <ref>", "file as a native sub-issue of this parent (#123, owner/repo#123, or URL)").option("--no-related", "skip the auto related-issues comment"),
   // --dry-run/--validate-only plan: resolve the same title source and validate the same type, priority,
@@ -38174,10 +40322,11 @@ withExamples(mutating(
     return fail(`issue create: ${e.message}`, e instanceof TextArgError ? { code: e.code, offending_flag: e.offendingFlag } : void 0);
   }
   {
-    const { refusal, warn, enforcing } = await checkSurfaceRequirement({ repo: targetRepo3, labels: extraLabels });
+    const surfaceCheck = await checkSurfaceRequirement({ repo: targetRepo3, labels: extraLabels });
+    const { refusal, warn } = surfaceCheck;
     if (warn) process.stderr.write(`${warn}
 `);
-    if (!enforcing && surfaceFlagLabel) {
+    if (shouldWithdrawSurfaceFlag(surfaceCheck) && surfaceFlagLabel) {
       extraLabels = extraLabels.filter((l) => l !== surfaceFlagLabel);
       args = buildIssueArgs({
         type: issueType,
@@ -38196,7 +40345,13 @@ withExamples(mutating(
   }
   await ensureLabelsExist(extraLabels, targetRepo3);
   const created = await ghCreate(args);
-  const { projectItemId, onBoard } = await attachToProject(created.number, targetRepo3, priority);
+  if (isGhCreateRateLimited(created)) {
+    console.log(JSON.stringify(created));
+    process.exitCode = 1;
+    return;
+  }
+  const attached = await attachToProject(created.number, targetRepo3, priority);
+  const { projectItemId, onBoard } = attached;
   let parent;
   let parentLinkError;
   if (o.parent !== void 0) {
@@ -38217,6 +40372,12 @@ withExamples(mutating(
     priority,
     projectItemId,
     onBoard,
+    // #5489: partial receipt when the GitHub issue landed but Project v2 attach hit GraphQL quota.
+    ...attached.boardAttach ? {
+      boardAttach: attached.boardAttach,
+      ...attached.resetAt ? { resetAt: attached.resetAt } : {},
+      ...attached.resetEpochSeconds !== void 0 ? { resetEpochSeconds: attached.resetEpochSeconds } : {}
+    } : {},
     ...parentLinkFields(parent, parentLinkError)
   }));
 }), [
@@ -38238,7 +40399,7 @@ async function readParentField(number, repo) {
   }
   return resolveParentField(payload);
 }
-issue.command("view <number>").description('read an issue as structured JSON \u2014 the mmi-cli path for non-board issue reads (#2347). --comments folds in every comment; --context also adds linkedPrs + children (the one-shot "load the whole item" read, #2894)').option("--repo <owner/repo>", "target repo (defaults to the current repo)").option("--json [fields...]", 'gh --json field list (overrides the default field set). Accepts commas, spaces, or repeated --json flags \u2014 in PowerShell an unquoted comma list is an array literal, so QUOTE it: --json "number,title,body,url"').option("--comments", 'include every comment (body + comments in one call) \u2014 the agentic "read the whole item before working it" read (#2894)').option("--context", "full working context in one call: implies --comments and also adds linkedPrs and, for an epic, a children summary (#2894)").action(async (number, o) => {
+issue.command("view <number>").alias("show").description('read an issue as structured JSON \u2014 the mmi-cli path for non-board issue reads (#2347). --comments folds in every comment; --context also adds linkedPrs + children (the one-shot "load the whole item" read, #2894). `show` is an alias (#5483)').option("--repo <owner/repo>", "target repo (defaults to the current repo)").option("--json [fields...]", 'gh --json field list (overrides the default field set). Accepts commas, spaces, or repeated --json flags \u2014 in PowerShell an unquoted comma list is an array literal, so QUOTE it: --json "number,title,body,url"').option("--comments", 'include every comment (body + comments in one call) \u2014 the agentic "read the whole item before working it" read (#2894)').option("--context", "full working context in one call: implies --comments and also adds linkedPrs and, for an epic, a children summary (#2894)").action(async (number, o) => {
   const n = Number(number);
   if (!Number.isInteger(n) || n <= 0) return fail("issue view: <number> must be a positive integer");
   const repo = await resolveRepo(o.repo);
@@ -38495,9 +40656,8 @@ program2.command("skill-lesson").description("file a skill-lesson on the Hub boa
     } catch {
     }
   }
-  const created = await ghCreate(args);
+  const created = requireGhCreateOk(await ghCreate(args), "skill-lesson");
   const { projectItemId, onBoard } = await attachToProject(created.number, targetRepo3, priority);
-  console.log(JSON.stringify({ ...created, deduped: false, label: SKILL_LESSON_LABEL, skill, priority, projectItemId, onBoard }));
 });
 var pr = program2.command("pr").description("pull requests \u2014 reliable create with structured output");
 withExamples(pr.command("create").description("create a PR and print {number,url} JSON").option("--title <title>", "PR title").option("--title-file <path|->", "read the PR title from a UTF-8 file, or from stdin with -").option("--body <body>", "PR body (markdown)").option("--body-file <path|->", "read PR body from a UTF-8 file, or from stdin with -").option("--base <branch>", "base branch (defaults to the repo default)").option("--head <branch>", "head branch (defaults to the current branch)").option("--repo <owner/repo>", "target repo (defaults to the current repo)").option("--draft", "open the PR in draft state (#2667)").option("--json", "machine-readable output (default; accepted for parity)").action(async (o) => {
@@ -38516,6 +40676,11 @@ withExamples(pr.command("create").description("create a PR and print {number,url
     return fail(`pr create: ${docsCheck.detail} \u2014 ${docsCheck.fix}`);
   }
   const created = await ghCreate(buildPrArgs({ title, body, base: o.base, head: o.head, repo: o.repo, draft: o.draft }));
+  if (isGhCreateRateLimited(created)) {
+    console.log(JSON.stringify(created));
+    process.exitCode = 1;
+    return;
+  }
   invalidateStatuslineBoardCache();
   console.log(JSON.stringify(created));
 }), [
@@ -38547,11 +40712,11 @@ pr.command("view <number>").description("read a PR as structured JSON (merged st
   }
 });
 async function listCiWorkflowPaths(cwd = process.cwd()) {
-  const wfDir = (0, import_node_path39.join)(cwd, ".github", "workflows");
-  if (!(0, import_node_fs42.existsSync)(wfDir)) return [];
-  return (0, import_node_fs42.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).filter((name) => {
+  const wfDir = (0, import_node_path40.join)(cwd, ".github", "workflows");
+  if (!(0, import_node_fs43.existsSync)(wfDir)) return [];
+  return (0, import_node_fs43.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).filter((name) => {
     try {
-      return workflowReportsPrChecks((0, import_node_fs42.readFileSync)((0, import_node_path39.join)(wfDir, name), "utf8"));
+      return workflowReportsPrChecks((0, import_node_fs43.readFileSync)((0, import_node_path40.join)(wfDir, name), "utf8"));
     } catch {
       return true;
     }
@@ -38603,16 +40768,16 @@ function ciAuditDeps() {
     // gate re-seed step is skipped gracefully rather than failing mid-run.
     readSeedFile: (path2) => {
       if (!root) return null;
-      const fullPath = (0, import_node_path39.join)(root, path2);
-      return (0, import_node_fs42.existsSync)(fullPath) ? (0, import_node_fs42.readFileSync)(fullPath, "utf8") : null;
+      const fullPath = (0, import_node_path40.join)(root, path2);
+      return (0, import_node_fs43.existsSync)(fullPath) ? (0, import_node_fs43.readFileSync)(fullPath, "utf8") : null;
     }
   };
 }
 function hubRoot() {
-  const fromPkg = (0, import_node_path39.join)(__dirname, "..", "..");
+  const fromPkg = (0, import_node_path40.join)(__dirname, "..", "..");
   const marker = "skills/bootstrap/seeds/manifest.json";
-  if ((0, import_node_fs42.existsSync)((0, import_node_path39.join)(fromPkg, marker))) return fromPkg;
-  if ((0, import_node_fs42.existsSync)((0, import_node_path39.join)(process.cwd(), marker))) return process.cwd();
+  if ((0, import_node_fs43.existsSync)((0, import_node_path40.join)(fromPkg, marker))) return fromPkg;
+  if ((0, import_node_fs43.existsSync)((0, import_node_path40.join)(process.cwd(), marker))) return process.cwd();
   return null;
 }
 async function waitLoopCorePool(label) {
@@ -38834,16 +40999,36 @@ pr.command("land <number>").description("agent merge path (#1440): train probe \
   if (result.status !== "failed") {
     const boardAdvance = await advanceClosedIssuesToDone2(number, result.repo);
     const crossRepoFilingIssue = result.repo ? await reconcileCrossRepoFilingIssue(defaultGitHubClient(), result.repo, Number(number)) : { status: "failed", error: "could not resolve the PR repo for cross-repo filing-issue reconciliation" };
+    const recovery = result.repo ? buildPostMergeReconRecovery({
+      repo: result.repo,
+      pr: number,
+      boardAdvance,
+      crossRepoFilingIssue
+    }) : void 0;
+    let recoveryPath;
+    if (recovery) {
+      try {
+        recoveryPath = writePostMergeReconRecovery(process.cwd(), recovery);
+      } catch {
+      }
+    } else if (result.repo) {
+      clearPostMergeReconRecovery(process.cwd(), result.repo, number);
+    }
     Object.assign(result, {
       ...boardAdvance.entries.length ? { boardAdvance: boardAdvance.entries } : {},
       boardAdvanceStatus: boardAdvance.status,
-      ...crossRepoFilingIssue.status !== "not-applicable" ? { crossRepoFilingIssue } : {}
+      ...crossRepoFilingIssue.status !== "not-applicable" ? { crossRepoFilingIssue } : {},
+      ...recovery ? { postMergeReconRecovery: recovery } : {}
     });
     invalidateStatuslineBoardCache();
-    const boardAdvanceMessage = boardAdvanceFailureMessage(boardAdvance);
-    if (boardAdvanceMessage) console.error(boardAdvanceMessage);
-    if (crossRepoFilingIssue.status === "failed") {
-      console.error(`pr land: cross-repo filing-issue reconciliation failed (${crossRepoFilingIssue.error}) \u2014 the PR MERGED, but a foreign filing issue may remain open.`);
+    for (const line of postMergeReconWarnings({
+      context: "pr land",
+      boardAdvance,
+      crossRepoFilingIssue,
+      recovery,
+      recoveryPath
+    })) {
+      console.error(line);
     }
   }
   if (o.json) printLine(JSON.stringify(result));
@@ -38936,7 +41121,7 @@ jsonParity(pr.command("merge <number>").description("merge a PR (squash by defau
         }
         if (!repoForPostCleanup) throw e;
         console.warn(`pr merge: gh GraphQL rate-limited \u2014 merging PR #${number} via REST PUT instead (#4588).`);
-        const commitMessage = bodyFile ? (0, import_node_fs42.readFileSync)(bodyFile, "utf8") : void 0;
+        const commitMessage = bodyFile ? (0, import_node_fs43.readFileSync)(bodyFile, "utf8") : void 0;
         await defaultGitHubClient().rest("PUT", `repos/${repoForPostCleanup}/pulls/${number}/merge`, {
           body: { merge_method: method.slice(2), ...commitMessage ? { commit_message: commitMessage } : {} },
           timeoutMs: GH_MUTATION_TIMEOUT_MS
@@ -39016,6 +41201,21 @@ jsonParity(pr.command("merge <number>").description("merge a PR (squash by defau
   const remoteBranch = { branch: headRef, existedBefore: remoteBefore, attempted: false, reason: remoteNotAttemptedReason };
   const boardAdvance = await advanceClosedIssuesToDone2(number, repoForPostCleanup);
   const crossRepoFilingIssue = repoForPostCleanup ? await reconcileCrossRepoFilingIssue(defaultGitHubClient(), repoForPostCleanup, Number(number)) : { status: "failed", error: "could not resolve the PR repo for cross-repo filing-issue reconciliation" };
+  const recovery = repoForPostCleanup ? buildPostMergeReconRecovery({
+    repo: repoForPostCleanup,
+    pr: number,
+    boardAdvance,
+    crossRepoFilingIssue
+  }) : void 0;
+  let recoveryPath;
+  if (recovery) {
+    try {
+      recoveryPath = writePostMergeReconRecovery(process.cwd(), recovery);
+    } catch {
+    }
+  } else if (repoForPostCleanup) {
+    clearPostMergeReconRecovery(process.cwd(), repoForPostCleanup, number);
+  }
   invalidateStatuslineBoardCache();
   const devDeploy = devDeployPlan.applicable && devDeployDeps && remoteNotAttemptedReason !== "pr-already-merged" ? await dispatchDevDeploy(repoForPostCleanup, devDeployDeps) : void 0;
   const devDeployManual = devDeployPlan.applicable ? devDeployPlan.manualPointer : void 0;
@@ -39047,18 +41247,22 @@ jsonParity(pr.command("merge <number>").description("merge a PR (squash by defau
     ...boardAdvance.entries.length ? { boardAdvance: boardAdvance.entries } : {},
     boardAdvanceStatus: boardAdvance.status,
     ...crossRepoFilingIssue.status !== "not-applicable" ? { crossRepoFilingIssue } : {},
+    ...recovery ? { postMergeReconRecovery: recovery } : {},
     ...devDeploy ? { devDeploy: devDeploy.ok ? { dispatched: true } : { dispatched: false, manual: devDeployManual } } : {}
   }));
-  const boardAdvanceMessage = boardAdvanceFailureMessage(boardAdvance);
-  if (boardAdvanceMessage) console.error(boardAdvanceMessage);
   if (devDeploy && !devDeploy.ok) {
     console.error(`pr merge: ${devDeployManual} (${devDeploy.detail})`);
   }
-  if (crossRepoFilingIssue.status === "failed") {
-    console.error(`pr merge: cross-repo filing-issue reconciliation failed (${crossRepoFilingIssue.error}) \u2014 the PR MERGED, but a foreign filing issue may remain open.`);
+  for (const line of postMergeReconWarnings({
+    context: "pr merge",
+    boardAdvance,
+    crossRepoFilingIssue,
+    recovery,
+    recoveryPath
+  })) {
+    console.error(line);
   }
-  process.exitCode = boardAdvanceExitCode(boardAdvance) ?? process.exitCode;
-  if (crossRepoFilingIssue.status === "failed") process.exitCode = 1;
+  process.exitCode = postMergeReconExitCode({ boardAdvance, crossRepoFilingIssue }) ?? process.exitCode;
 });
 registerQueryCommands(program2);
 registerIssueLifecycleCommands(program2, { attach: attachToProject });
@@ -39613,12 +41817,12 @@ access.command("audit").description("audit collaborator roles + train-branch pus
     targets = resolution.targets;
   }
   const derivedMatrix = registryProjects ? accessMatrixFromProjects(registryProjects) : {};
-  const fileMatrix = (0, import_node_fs42.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs42.readFileSync)("access-matrix.json", "utf8")) : {};
+  const fileMatrix = (0, import_node_fs43.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs43.readFileSync)("access-matrix.json", "utf8")) : {};
   const matrix = mergeAccessMatrix(fileMatrix, derivedMatrix);
   const derivedContracts = registryProjects ? dataAccessContractsFromProjects(registryProjects) : { consumers: {} };
-  const fileContracts = (0, import_node_fs42.existsSync)("data-access-contracts.json") ? loadDataAccessContracts((0, import_node_fs42.readFileSync)("data-access-contracts.json", "utf8")) : { consumers: {} };
+  const fileContracts = (0, import_node_fs43.existsSync)("data-access-contracts.json") ? loadDataAccessContracts((0, import_node_fs43.readFileSync)("data-access-contracts.json", "utf8")) : { consumers: {} };
   const dataAccess = mergeDataAccessContracts(fileContracts, derivedContracts);
-  const sanctioned = (0, import_node_fs42.existsSync)("access-matrix.json") ? loadSanctionedAdmins((0, import_node_fs42.readFileSync)("access-matrix.json", "utf8")) : {};
+  const sanctioned = (0, import_node_fs43.existsSync)("access-matrix.json") ? loadSanctionedAdmins((0, import_node_fs43.readFileSync)("access-matrix.json", "utf8")) : {};
   const report = await auditOrgAccess(targets, deps, matrix, dataAccess, sanctioned);
   console.log(o.json ? JSON.stringify(report, null, 2) : renderAccessReport(report));
   if (!report.ok) process.exitCode = 1;
@@ -39650,16 +41854,16 @@ function directoryBytes(path2) {
   let total = 0;
   let entries;
   try {
-    entries = (0, import_node_fs42.readdirSync)(path2, { withFileTypes: true });
+    entries = (0, import_node_fs43.readdirSync)(path2, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child2 = (0, import_node_path39.join)(path2, entry.name);
+    const child2 = (0, import_node_path40.join)(path2, entry.name);
     if (entry.isDirectory()) total += directoryBytes(child2);
     else {
       try {
-        total += (0, import_node_fs42.statSync)(child2).size;
+        total += (0, import_node_fs43.statSync)(child2).size;
       } catch {
       }
     }
@@ -39667,25 +41871,25 @@ function directoryBytes(path2) {
   return total;
 }
 function listDirEntries(dir) {
-  return (0, import_node_fs42.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
+  return (0, import_node_fs43.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
 }
 function readInstalledPluginRefs(configRoot) {
   const p = installedPluginsPathForConfig(configRoot);
-  if (!(0, import_node_fs42.existsSync)(p)) return [];
+  if (!(0, import_node_fs43.existsSync)(p)) return [];
   try {
-    return installedPluginPaths((0, import_node_fs42.readFileSync)(p, "utf8"));
+    return installedPluginPaths((0, import_node_fs43.readFileSync)(p, "utf8"));
   } catch {
     return null;
   }
 }
 function pluginCacheFsDeps(configRoot, dirBytes) {
   return {
-    exists: (p) => (0, import_node_fs42.existsSync)(p),
-    listVersionDirs: (root) => (0, import_node_fs42.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
+    exists: (p) => (0, import_node_fs43.existsSync)(p),
+    listVersionDirs: (root) => (0, import_node_fs43.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
     dirBytes,
-    listStagingDirs: (root) => (0, import_node_fs42.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+    listStagingDirs: (root) => (0, import_node_fs43.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
       try {
-        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path39.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs42.statSync)(p).mtimeMs) };
+        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path40.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs43.statSync)(p).mtimeMs) };
       } catch {
         return { name: d.name, mtimeMs: Date.now() };
       }
@@ -39699,10 +41903,10 @@ function stagingApplyFsGuard(configRoot) {
   return {
     referencedPaths: () => readInstalledPluginRefs(configRoot),
     mtimeMs: (name) => {
-      const p = (0, import_node_path39.join)(stagingRoot, name);
-      if (!(0, import_node_fs42.existsSync)(p)) return null;
+      const p = (0, import_node_path40.join)(stagingRoot, name);
+      if (!(0, import_node_fs43.existsSync)(p)) return null;
       try {
-        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs42.statSync)(q).mtimeMs);
+        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs43.statSync)(q).mtimeMs);
       } catch {
         return null;
       }
@@ -39728,7 +41932,7 @@ program2.command("plugin-prune").description(`prune stale cached MMI plugin vers
     { withBytes: true, configRoot, includeStaging: surface !== "codex" }
   );
   const anythingToDelete = plan.prune.length > 0 || plan.staging.length > 0;
-  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs42.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard(configRoot)) : void 0;
+  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs43.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard(configRoot)) : void 0;
   const warnings = plan.prune.length > 0 ? [CONCURRENT_SESSION_WARNING] : [];
   if (o.json) console.log(JSON.stringify({ ...plan, warnings, applied: result ?? null }));
   else console.log(renderPluginCachePlan(plan, result));