@mutmutco/cli 3.119.0 → 3.121.0

package/dist/main.cjs

@@ -7411,6 +7411,7 @@ async function removeWorktreeWithRecovery(wtPath, deps) {
   const backoff = deps.backoffMs ?? [250, 1e3];
   let attempts = 0;
   let lastError;
+  const stillOnDisk = () => deps.pathExists?.(wtPath) ?? false;
   let safeForGitPrimary = true;
   if (deps.detachReparsePoints) {
     try {
@@ -7424,7 +7425,9 @@ async function removeWorktreeWithRecovery(wtPath, deps) {
     attempts++;
     try {
       await deps.git(["worktree", "remove", "--force", wtPath]);
-      return { status: "removed", attempts, recovery: i > 0 ? "retry" : void 0 };
+      if (!stillOnDisk()) return { status: "removed", attempts, recovery: i > 0 ? "retry" : void 0 };
+      lastError = new Error(`worktree directory still present after 'git worktree remove --force': ${wtPath}`);
+      break;
     } catch (e) {
       lastError = e;
       const retriesLeft = i < maxAttempts - 1;
@@ -7439,12 +7442,18 @@ async function removeWorktreeWithRecovery(wtPath, deps) {
     try {
       await deps.removeWorktreeDir(wtPath);
       await deps.git(["worktree", "prune"]).catch(() => "");
-      return { status: "removed", attempts, recovery: "fallback" };
+      if (!stillOnDisk()) return { status: "removed", attempts, recovery: "fallback" };
+      lastError = new Error(`worktree directory still present after on-disk removal: ${wtPath}`);
     } catch (fallbackError) {
       lastError = fallbackError;
     }
   }
-  return { status: "failed", attempts, error: errorMessage(lastError) };
+  return {
+    status: "failed",
+    attempts,
+    error: errorMessage(lastError),
+    ...stillOnDisk() ? { remainsOnDisk: true } : {}
+  };
 }
 var NO_NESTED_LINKS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 function baseName(p) {
@@ -8282,7 +8291,9 @@ async function cleanupPrMergeLocalBranch(branch, options) {
       sleep: options.sleep ?? defaultSleep,
       detachReparsePoints: options.detachReparsePoints,
       // #3064: junction-safe deferred sweep too
-      removeWorktreeDir: options.removeWorktreeDir
+      removeWorktreeDir: options.removeWorktreeDir,
+      pathExists: options.pathExists
+      // #4850: a swept entry is only cleared once its directory is gone
     };
     await sweepDeferredWorktrees(options.deferredStore, removeDeps, options.removalContext).catch(() => void 0);
     let stageTeardown;
@@ -8326,7 +8337,9 @@ async function cleanupPrMergeLocalBranch(branch, options) {
       sleep: options.sleep ?? defaultSleep,
       detachReparsePoints: options.detachReparsePoints,
       // #3064: reach the actual pr-merge teardown path
-      removeWorktreeDir: options.removeWorktreeDir
+      removeWorktreeDir: options.removeWorktreeDir,
+      pathExists: options.pathExists
+      // #4850: never report `removed` while the directory survives
     });
     if (options.removalContext) {
       recordWorktreeRemoval(options.removalContext.primaryRoot, {
@@ -9263,6 +9276,9 @@ function resolveWorktreeBase(from, remote) {
   if (SHA_LIKE_RE.test(from)) return { base: from };
   return { base: from, fetchBranch: from, preferRemote: `${remotePrefix}${from}` };
 }
+function worktreeAddGitPrefix() {
+  return process.platform === "win32" ? ["-c", "core.longpaths=true"] : [];
+}
 var GIT_CONFIG_LOCK_RE = /could not lock config file|unable to write upstream branch configuration|unable to access ['"]?\.git\/config['"]?: Permission denied|unknown error occurred while reading the configuration files/i;
 function isGitConfigLockError(error) {
   return GIT_CONFIG_LOCK_RE.test(error instanceof Error ? error.message : String(error));
@@ -9304,6 +9320,8 @@ async function addWorktreeRobust(wtPath, branch, base, deps) {
       await deps.git(["worktree", "add", wtPath, "-b", branch, base]);
       return;
     } catch (e) {
+      await deps.cleanupPartial?.().catch(() => {
+      });
       await cleanupOrphanBranch(branch, base, preExistingOid, deps).catch(() => {
       });
       const retriesLeft = i < maxAttempts - 1;
@@ -9967,6 +9985,13 @@ var MANAGED_GITIGNORE_LINES = [
   "docs/superpowers/",
   ".playwright-mcp/",
   ".claude/worktrees/",
+  // `.mmi/` is org session scratch (session id, throttle traces, saga queue — AGENTS.md "No committed
+  // `.mmi`"). #2319 retired this rule believing repo-local `.mmi` state was gone; #4833 proved repos
+  // still get `.mmi/` written (older tooling on the machine, product-repo scripts), and dropping the
+  // rule left that scratch untracked-visible one `git add .` away from a commit. Ignore the dir's
+  // contents at ANY depth; an already-tracked `.mmi/config.json` keeps tracking regardless (git never
+  // untracks a tracked file), so no re-inclusion line is needed.
+  "**/.mmi/*",
   // #3425: local agent config the org push wall (`mmi-no-agent-files-org`) forbids committing, at any
   // depth — leaving it untracked is the ONLY legal state, so it is pure `git status` noise. Only the two
   // dirs no repo has cause to track: `.claude/` is excluded because MMI-Hub tracks `.claude/settings.json`,
@@ -9979,6 +10004,12 @@ var MANAGED_GITIGNORE_LINES = [
   // thing blocking the cleanup that gate's own worktree needs. Org-universal: every repo runs the same
   // gate, so this belongs in the managed block rather than in one repo's own ignores.
   ".jerv/",
+  // #4856: the JervCode (pi) host writes its loop journal to `.pi/loops/` in whatever repo it runs in —
+  // the same runtime-state class as `.jerv/` and `.codex/` above, and the one active surface missing from
+  // this list. Left un-ignored it is permanent `?? .pi/` noise that refuses a release clean-tree gate
+  // (measured on the v3.120.0 Hub train), with no legal resolution: committing another host's runtime
+  // state is not an option, so the operator's only move was to park the directory outside the repo.
+  ".pi/",
   // #2321 doctrine: the canonical worktree home is the SIBLING `../mmi-worktrees/<RepoName>/<branch>` (outside the tree,
   // via `mmi-cli worktree create`), so a repo-local `.worktrees/` is NOT un-ignored org-wide — `mmi-cli
   // doctor` flags one explicitly instead (buildRepoLocalWorktreeCheck) rather than baking the fallback path
@@ -15820,10 +15851,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: "3.119.0",
-    tag: "v3.119.0",
-    commit: "32fef9b214ee",
-    npm: "@mutmutco/cli@3.119.0"
+    version: "3.121.0",
+    tag: "v3.121.0",
+    commit: "3fc99b89d353",
+    npm: "@mutmutco/cli@3.121.0"
   },
   exitCriterion: "fleet-n-of-n",
   hubOnlyShortcut: "forbidden",
@@ -15840,14 +15871,14 @@ var rollout_plan_default = {
           repo: "mutmutco/mmi-hub",
           role: "canary",
           schedule: "train",
-          v3Target: "v3.119.0"
+          v3Target: "v3.121.0"
         }
       ],
       rollbackTrigger: "Any red inside the post-cut soak window: `devops train gate` FAIL attributable to the v4 doors, Hub endpoint health probe failure, a v3 client refused while the compat window must still admit it (SUPPORTED_MINOR_WINDOW=2, MIN_CLIENT_VERSION 0.0.0 \u2014 D6a), or npm consumer install/doctor failure on the v4 dist.",
       rollback: {
         independent: true,
-        mechanism: "npm dist-tag latest -> 3.119.0 and redeploy the Hub Lambda from tag v3.119.0 (32fef9b214ee); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
-        v3Target: "v3.119.0 (@mutmutco/cli@3.119.0, tag commit 32fef9b214ee \u2014 the preserved latest-v3 distribution, D6b)"
+        mechanism: "npm dist-tag latest -> 3.121.0 and redeploy the Hub Lambda from tag v3.121.0 (3fc99b89d353); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
+        v3Target: "v3.121.0 (@mutmutco/cli@3.121.0, tag commit 3fc99b89d353 \u2014 the preserved latest-v3 distribution, D6b)"
       }
     },
     {
@@ -24696,7 +24727,7 @@ function collectLeaves(node, acc) {
 function buildHouses(tree) {
   const collect = (node, parentHouse, root, out) => {
     if (node.house === root && parentHouse !== root) {
-      const entry = { path: node.path };
+      const entry = { path: node.path, canonical: node.canonical };
       if (node.description) entry.description = node.description;
       out.push(entry);
     }
@@ -33256,7 +33287,9 @@ function worktreeRemoveDeps(execGit) {
     // #3064: unlink any reparse point (esp. a `node_modules` junction to base) before the git-native
     // `worktree remove --force`, which would otherwise recurse through it and empty the base checkout.
     detachReparsePoints: (worktreePath) => detachReparsePoints(worktreePath, realWorktreeDirRemover),
-    removeWorktreeDir: async (worktreePath) => removeWorktreeTree(worktreePath, await resolvePrimaryCheckout(execGit), realWorktreeDirRemover)
+    removeWorktreeDir: async (worktreePath) => removeWorktreeTree(worktreePath, await resolvePrimaryCheckout(execGit), realWorktreeDirRemover),
+    // #4850: verify the directory is actually gone before any caller reports completion.
+    pathExists: (worktreePath) => (0, import_node_fs39.existsSync)(worktreePath)
   };
 }
 async function worktreeHasStageState(worktreePath) {
@@ -34393,7 +34426,7 @@ function registerWorktreeCommands(program3) {
       );
       report.push({
         step: "remove worktree",
-        status: removeOutcome.status === "removed" ? removeOutcome.recovery ? `done (${removeOutcome.recovery})` : "done" : `failed: ${removeOutcome.error ?? "lock held"} \u2014 run: git -C "${primaryCheckout}" worktree remove --force "${wtPath}"`
+        status: removeOutcome.status === "removed" ? removeOutcome.recovery ? `done (${removeOutcome.recovery})` : "done" : removeOutcome.remainsOnDisk ? `failed: ${removeOutcome.error ?? "lock held"} \u2014 the directory "${wtPath}" is still on disk; cd every shell out of it (a cwd inside holds it open on Windows), then delete that directory` : `failed: ${removeOutcome.error ?? "lock held"} \u2014 run: git -C "${primaryCheckout}" worktree remove --force "${wtPath}"`
       });
       if (!shouldContinueLandCleanup(removeOutcome.status)) {
         const result2 = {
@@ -35865,6 +35898,31 @@ function markerCommentBody(body, markerId) {
   return `${prCommentMarker(markerId)}
 ${body}`;
 }
+var CHECK_LOG_TAIL_LINES = 60;
+var CHECK_LOG_MAX_BUFFER = 32 * 1024 * 1024;
+function parseCheckJobId(details) {
+  const match = /\/job\/(\d+)\b/.exec(details ?? "");
+  return match ? match[1] : null;
+}
+function failingCheckRows(rows) {
+  return rows.filter((row) => row.status === "fail" || row.status === "failure");
+}
+function tailLines(text, max = CHECK_LOG_TAIL_LINES) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim());
+  return { tail: lines.slice(-max).join("\n"), truncated: lines.length > max };
+}
+async function attachFailureLogs(rows, fetchLog) {
+  for (const row of failingCheckRows(rows)) {
+    const jobId = parseCheckJobId(row.details);
+    if (!jobId) continue;
+    try {
+      const { tail, truncated } = tailLines(await fetchLog(jobId));
+      if (tail) row.log = { jobId, tail, truncated };
+    } catch {
+    }
+  }
+  return rows;
+}
 function parsePrChecksTable(stdout) {
   const lines = stdout.trim().split(/\r?\n/).filter((l) => l.trim());
   if (!lines.length) return [];
@@ -36190,7 +36248,7 @@ function registerPrLifecycleCommands(program3) {
       return failGraceful(`pr update-branch: ${(err.stderr || err.message || String(e)).trim()}`);
     }
   });
-  pr2.command("checks <number>").description("one-shot non-blocking check snapshot; --watch streams state with per-check failure log pointers").option("--json", "machine-readable output").option("--watch", "poll until success/failure, streaming one JSON line per poll").option("--repo <owner/repo>", "target repo (defaults to the current repo)").action(async (number, o) => {
+  pr2.command("checks <number>").description("one-shot non-blocking check snapshot; --watch streams state with per-check failure log pointers").option("--json", "machine-readable output").option("--watch", "poll until success/failure, streaming one JSON line per poll").option("--logs", `fold the last ${CHECK_LOG_TAIL_LINES} log lines of every FAILING check into its row, so reading why CI is red needs no second tool (#4853)`).option("--repo <owner/repo>", "target repo (defaults to the current repo)").action(async (number, o) => {
     const n = assertPositiveInt("pr checks", number);
     let repo;
     try {
@@ -36199,6 +36257,15 @@ function registerPrLifecycleCommands(program3) {
       return fail(`pr checks: ${e.message}`);
     }
     const repoArgs = ["--repo", repo];
+    const fetchLog = async (jobId) => {
+      const { stdout } = await execFileP2(
+        "gh",
+        ["run", "view", ...repoArgs, "--job", jobId, "--log-failed"],
+        { timeout: GC_GH_TIMEOUT_MS4, maxBuffer: CHECK_LOG_MAX_BUFFER }
+      );
+      return stdout;
+    };
+    const withLogs = async (rows) => o.logs ? attachFailureLogs(rows, fetchLog) : rows;
     const snap = async () => {
       let stdout = "";
       let stderr = "";
@@ -36218,7 +36285,7 @@ function registerPrLifecycleCommands(program3) {
     try {
       if (!o.watch) {
         const { state, rows } = await snap();
-        const output = { state, checks: rows };
+        const output = { state, checks: await withLogs(rows) };
         console.log(JSON.stringify(output));
         if (state === "failure" || state === "failing") process.exitCode = 1;
         return;
@@ -36227,7 +36294,8 @@ function registerPrLifecycleCommands(program3) {
       let lastState = "";
       while (Date.now() < deadline) {
         const { state, rows } = await snap();
-        const payload = { state, timestamp: (/* @__PURE__ */ new Date()).toISOString(), checks: rows };
+        const checks = state === "failure" ? await withLogs(rows) : rows;
+        const payload = { state, timestamp: (/* @__PURE__ */ new Date()).toISOString(), checks };
         console.log(JSON.stringify(payload));
         if (state === "success") return;
         if (state === "failure") {
@@ -39227,6 +39295,93 @@ function hasRepoLocalWorktrees() {
   return root !== null && (0, import_node_fs46.existsSync)((0, import_node_path43.join)(root, ".worktrees"));
 }
 
+// src/cross-repo-filing-issue.ts
+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/index.ts
 var execFileGitRun = async (file, args) => (await execFileP2(file, args, { timeout: GIT_TIMEOUT_MS })).stdout;
 async function githubRepoReachProbe() {
@@ -40220,7 +40375,31 @@ withExamples(mutating(
           `worktree create: issue ${selector.repo}#${selector.number} belongs to ${selector.repo}, but this checkout is ${resolvedRepo} \u2014 re-run from ${selector.repo}'s primary checkout. Refusing to attach a foreign issue branch here (MMI-Hub#4351).`
         );
       }
-      const slug = o.slug ?? await fetchIssueTitle(selector.repo, selector.number).then((t) => t ? slugifyIssueTitle(t) : "");
+      const issueTitle = await fetchIssueTitle(selector.repo, selector.number);
+      if (!o.slug && !issueTitle && o.claim && /^#?\d+$/.test(target)) {
+        try {
+          const client = defaultGitHubClient();
+          const local = await readExactIssue(client, selector.repo, selector.number);
+          if (!local) {
+            const matches = await discoverSameOrgIssueNumber(client, selector.repo, selector.number);
+            if (matches.length === 1) {
+              const foreign = matches[0];
+              let board = "its registered board";
+              try {
+                const cfg = await loadConfigForBoardSelector2(`${foreign.repo}#${foreign.number}`, foreign.repo);
+                if (cfg.projectOwner && cfg.projectNumber) board = `${cfg.projectOwner} project #${cfg.projectNumber}`;
+              } catch {
+              }
+              return fail(
+                `worktree create: issue #${selector.number} is not in ${selector.repo}; it exists as ${foreign.repo}#${foreign.number} on ${board}. Re-run from ${foreign.repo}'s primary checkout with \`mmi-cli worktree create ${foreign.repo}#${foreign.number} --claim\`.`
+              );
+            }
+          }
+        } catch (e) {
+          console.warn(`  warning: could not discover whether #${selector.number} belongs to another same-org repo (${e.message})`);
+        }
+      }
+      const slug = o.slug ?? (issueTitle ? slugifyIssueTitle(issueTitle) : "");
       branch = buildNewBranchName(selector.number, slug ?? "");
       if (PROTECTED_BRANCHES2.has(branch)) {
         return fail(`worktree create: generated branch name '${branch}' collides with a protected train branch \u2014 pass a branch name instead`);
@@ -40281,8 +40460,13 @@ withExamples(mutating(
     }
     if (!resumed) {
       step = `git worktree add ${wtPath}`;
+      const wtPathPreExisted = (0, import_node_fs47.existsSync)(wtPath);
+      const partialRemove = worktreeRemoveDeps(async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout);
       await withWorktreeAddLock(repoRoot2, () => addWorktreeRobust(wtPath, branch, base, {
-        git: async (args) => (await execFileP2("git", args, { timeout: GH_MUTATION_TIMEOUT_MS })).stdout,
+        // #4834: `-c core.longpaths=true` rides the add command itself — a Windows worktree path
+        // pushes long repos past MAX_PATH while the main checkout still fits. Command-scoped, so
+        // the shared `.git/config` this lock serializes is never touched.
+        git: async (args) => (await execFileP2("git", [...worktreeAddGitPrefix(), ...args], { timeout: GH_MUTATION_TIMEOUT_MS })).stdout,
         revParse: async (ref) => {
           try {
             return (await execFileP2("git", ["rev-parse", "--verify", ref], { timeout: GIT_TIMEOUT_MS })).stdout.trim() || void 0;
@@ -40291,6 +40475,13 @@ withExamples(mutating(
           }
         },
         deleteBranch: (b) => execFileP2("git", ["branch", "-D", b], { timeout: GIT_TIMEOUT_MS }).then(() => void 0),
+        cleanupPartial: async () => {
+          if (wtPathPreExisted || !(0, import_node_fs47.existsSync)(wtPath)) return;
+          partialRemove.detachReparsePoints(wtPath);
+          await execFileP2("git", ["worktree", "remove", "--force", wtPath], { timeout: GIT_TIMEOUT_MS }).catch(() => partialRemove.removeWorktreeDir(wtPath).then(() => void 0));
+          await execFileP2("git", ["worktree", "prune"], { timeout: GIT_TIMEOUT_MS }).catch(() => {
+          });
+        },
         sleep: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms)),
         log: (m) => {
           if (!o.json) console.error(`  ${m}`);
@@ -42318,6 +42509,7 @@ jsonParity(pr.command("merge <number>").description("merge a PR (squash by defau
     };
   }
   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" };
   invalidateStatuslineBoardCache();
   console.log(JSON.stringify({
     ...buildPrMergeResultPayload({
@@ -42331,11 +42523,16 @@ jsonParity(pr.command("merge <number>").description("merge a PR (squash by defau
     // `boardAdvance` keeps its published array shape; `boardAdvanceStatus` is the field a caller reads to
     // tell "merged clean" from "merged, but the board did not follow" without guessing from the exit code.
     ...boardAdvance.entries.length ? { boardAdvance: boardAdvance.entries } : {},
-    boardAdvanceStatus: boardAdvance.status
+    boardAdvanceStatus: boardAdvance.status,
+    ...crossRepoFilingIssue.status !== "not-applicable" ? { crossRepoFilingIssue } : {}
   }));
   const boardAdvanceMessage = boardAdvanceFailureMessage(boardAdvance);
   if (boardAdvanceMessage) console.error(boardAdvanceMessage);
+  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.`);
+  }
   process.exitCode = boardAdvanceExitCode(boardAdvance) ?? process.exitCode;
+  if (crossRepoFilingIssue.status === "failed") process.exitCode = 1;
 });
 registerQueryCommands(program2);
 registerWorktreeCommands(program2);
@@ -42475,6 +42672,21 @@ function renderAlignment(label, alignment) {
   }
   return `${label}: ALIGNMENT PR PENDING \u2014 land it with \`mmi-cli devops pr merge ${alignment.prNumber ?? "<number>"} --auto --merge\`${alignment.prUrl ? ` (${alignment.prUrl})` : ""}`;
 }
+var JERV_POWERTOOLS_REPO = "mutmutco/Jerv-PowerTools";
+async function runPostReleaseJervDoctor(repo) {
+  if (repo.toLowerCase() !== JERV_POWERTOOLS_REPO.toLowerCase()) return void 0;
+  try {
+    await execJervCli(["doctor"], { timeout: 10 * 6e4 });
+    return { status: "completed", note: "jerv-cli doctor completed on this owner machine" };
+  } catch (e) {
+    const err = e;
+    const detail = (err.stderr?.trim() || err.message || "unknown doctor failure").split(/\r?\n/)[0];
+    return {
+      status: "reported-issues",
+      note: `jerv-cli doctor ran but reported issues (${detail})`
+    };
+  }
+}
 function renderTrainApply(commandName, r) {
   let base = `mmi-cli ${commandName}: promoted ${r.repo} \u2014 ${r.stage} at ${r.tag} [${r.deployModel}]; ${renderDeployLine(r)}`;
   if (r.versionFold) base = `${base}; ${r.versionFold}`;
@@ -42493,6 +42705,9 @@ function renderTrainApply(commandName, r) {
   if (r.projectInfoSync) {
     base = `${base}; project info: ${r.projectInfoSync.note}`;
   }
+  if (r.postReleaseJervDoctor) {
+    base = `${base}; Jerv convergence: ${r.postReleaseJervDoctor.note}`;
+  }
   if (r.announceNote) base = `${base}; announce: ${r.announceNote}`;
   if (r.releaseVerdict) {
     const v = r.releaseVerdict;
@@ -42646,6 +42861,7 @@ for (const commandName of ["rcand", "release"]) {
         const ack = (o.ack ?? "").split(",").map((s) => s.trim()).filter(Boolean);
         const result = await runTrainApply(commandName, trainApplyDeps(), { watch: o.watch, announceSummaryFile: o.announceSummaryFile, ack, dev: o.dev });
         let projectInfoSync;
+        const postReleaseJervDoctor = commandName === "release" ? await runPostReleaseJervDoctor(result.repo) : void 0;
         if (commandName === "release") {
           try {
             projectInfoSync = await runProjectInfoSync(result.repo, true);
@@ -42672,6 +42888,7 @@ for (const commandName of ["rcand", "release"]) {
         const reported = {
           ...result,
           ...projectInfoSync ? { projectInfoSync } : {},
+          ...postReleaseJervDoctor ? { postReleaseJervDoctor } : {},
           ...releaseVerdict ? { releaseVerdict } : {}
         };
         printLine(o.json ? JSON.stringify(reported, null, 2) : renderTrainApply(commandName, reported));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "3.119.0",
+  "version": "3.121.0",
   "description": "MMI Future CLI — the org dev toolbox and shared cross-IDE engine for every registry-declared MMI coding surface.",
   "type": "module",
   "license": "UNLICENSED",