@bridge_gpt/mcp-server 0.2.34 → 0.2.37

package/build/upgrade-cli.js

@@ -1,154 +1,456 @@
 /**
- * Bridge API MCP server one-command upgrade (BAPI-430).
+ * Bridge API MCP server one-command upgrade (BAPI-430, rebuilt for BAPI-728).
  *
  * Extracted from `index.ts` so the upgrade logic always runs from the latest
  * published version (`@bridge_gpt/mcp-server@latest`) rather than the
  * potentially-stale copy npx resolved at the call site.
  *
- * Flow:
- *  1. Fetch latest version from the npm registry.
- *  2. If newer and not already re-exec'd, re-spawn from `@latest` with
- *     `--internal-reexec` so upgrade logic comes from new code.
- *  3. Remove any competing local `node_modules/@bridge_gpt/mcp-server` install
- *     (the silent trap that makes npx always prefer the stale local copy).
- *  4. Rewrite the launcher pin across all per-host configs via `runInit`.
- *  5. Print `old -> new` and open a fresh reconnect session.
+ * ---------------------------------------------------------------------------
+ * BAPI-728 — the defect this file was rebuilt to fix
+ * ---------------------------------------------------------------------------
+ * The old decision was `isNewerVersion(VERSION, latestVersion)`, where `VERSION`
+ * is the version of the CLI process npx just resolved. Invoked the documented
+ * way (`@latest`), `VERSION === latestVersion`, so that expression was ALWAYS
+ * false. Consequences:
+ *
+ *   - `oldVersion` and `targetVersion` both collapsed to `VERSION`, so a run
+ *     that genuinely repinned three configs from 0.2.16 to 0.2.36 announced
+ *     itself as `Upgrade complete: 0.2.36 -> 0.2.36`.
+ *   - The config pin was never an INPUT to anything. It moved only as a side
+ *     effect of `runInit`, and nothing reported that it had.
+ *   - A no-op and a twenty-release jump printed identical output.
+ *
+ * The fix separates two genuinely different questions that were conflated:
+ *
+ *   1. "Is the CLI I am running the newest CLI?"  → `VERSION` vs the registry.
+ *      This decides ONE thing: whether to re-exec from `@latest`.
+ *   2. "Is each project config pinned where it should be?" → the shared,
+ *      read-only launcher inspection. This decides everything the user sees:
+ *      per-config transitions, whether anything changed, and the exit status.
+ *
+ * Every launcher claim is verified by RE-READING the configs after the write.
+ * The command never reports a transition it did not confirm on disk.
  */
 import { spawn } from "child_process";
-import { stat } from "fs/promises";
+import { readFile, stat } from "fs/promises";
 import path from "path";
 import { VERSION } from "./version.generated.js";
 import { runInit } from "./init.js";
+import { InitPreflightError } from "./init.js";
 import { isNewerVersion } from "./update-check.js";
+import { fetchLatestVersion } from "./cli-release.js";
+import { CANONICAL_UPGRADE_COMMAND } from "./upgrade-advice.js";
+import { describeLauncherReason, inspectLauncherConfigs, isApplicableStandardLauncher, isPrerequisiteFailure, LAUNCHER_CONFIG_TARGETS, } from "./launcher-config-inspection.js";
 import { buildGenericAgentShellCommand, detectTerminal, getDefaultSpawnTerminalTabForPlatform, createDefaultStartTicketsDeps, } from "./start-tickets.js";
 import { AGENT_REGISTRY } from "./agent-registry.js";
-async function fetchLatestVersion() {
+/** The sentinel this CLI passes to the child it re-execs from `@latest`. */
+const INTERNAL_REEXEC_FLAG = "--internal-reexec";
+// ---------------------------------------------------------------------------
+// Default dependency construction
+// ---------------------------------------------------------------------------
+function defaultReexec(cwd, oldVersion) {
+    const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+    return new Promise((resolve) => {
+        const child = spawn(npxCmd, [
+            "-y",
+            "@bridge_gpt/mcp-server@latest",
+            "upgrade",
+            INTERNAL_REEXEC_FLAG,
+            "--old-version",
+            oldVersion,
+        ], { stdio: "inherit", cwd });
+        child.on("close", (code) => resolve(code ?? 0));
+        child.on("error", (err) => {
+            console.error(`Bridge API upgrade failed: could not re-exec npx: ${err.message}`);
+            resolve(1);
+        });
+    });
+}
+function localInstallPath(cwd) {
+    return path.join(cwd, "node_modules", "@bridge_gpt", "mcp-server");
+}
+async function defaultHasCompetingLocalInstall(cwd) {
+    try {
+        await stat(localInstallPath(cwd));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultRemoveCompetingLocalInstall(cwd) {
+    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    return new Promise((resolve) => {
+        const child = spawn(npmCmd, ["uninstall", "@bridge_gpt/mcp-server"], {
+            stdio: "inherit",
+            cwd,
+        });
+        child.on("close", (code) => resolve(code === 0));
+        child.on("error", () => resolve(false));
+    });
+}
+async function defaultSpawnReconnect(cwd, command) {
     try {
-        const res = await fetch("https://registry.npmjs.org/@bridge_gpt/mcp-server/latest", {
-            signal: AbortSignal.timeout(3000),
+        const terminal = detectTerminal(undefined, process.env);
+        const deps = createDefaultStartTicketsDeps();
+        const spawnTerminalTab = getDefaultSpawnTerminalTabForPlatform(process.platform);
+        const result = await spawnTerminalTab(deps, terminal, command, {
+            key: "reconnect",
+            worktreePath: cwd,
         });
-        if (res.ok) {
-            const data = (await res.json());
-            return data.version || null;
-        }
+        return result.ok;
     }
     catch {
-        return null;
+        return false;
     }
-    return null;
 }
-export async function runUpgradeCli(argv) {
-    const cwd = process.cwd();
-    const isDryRun = argv.includes("--dry-run");
-    const isInternalReexec = argv.includes("--internal-reexec");
-    let latestVersion = VERSION;
-    const fetched = await fetchLatestVersion();
+/** Build the production dependency set. */
+export function createDefaultUpgradeCliDeps(cwd) {
+    return {
+        cwd,
+        fetchLatestVersion,
+        readFile: (filePath) => readFile(filePath, "utf-8"),
+        hasCompetingLocalInstall: defaultHasCompetingLocalInstall,
+        removeCompetingLocalInstall: defaultRemoveCompetingLocalInstall,
+        runInit,
+        reexecFromLatest: defaultReexec,
+        spawnReconnect: defaultSpawnReconnect,
+        stdout: (m) => console.log(m),
+        stderr: (m) => console.error(m),
+        env: process.env,
+    };
+}
+// ---------------------------------------------------------------------------
+// Target resolution
+// ---------------------------------------------------------------------------
+/**
+ * Decide the target version and how much we trust it.
+ *
+ * Note what is NOT here: the project's config pins. The target is "what the
+ * newest published version is"; the pins are what we compare AGAINST it. Mixing
+ * the two is precisely the bug this rewrite removes.
+ */
+export async function resolveUpgradeTarget(argv, deps) {
+    const fetched = await deps.fetchLatestVersion();
     if (fetched) {
-        latestVersion = fetched;
+        return { version: fetched, confidence: "registry-confirmed" };
     }
-    const isNewer = isNewerVersion(VERSION, latestVersion);
-    const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
-    // Re-exec from @latest to ensure upgrade logic runs from latest code, not
-    // the stale local copy that npx may have resolved.
-    if (isNewer && !isInternalReexec) {
-        if (!isDryRun) {
-            console.log(`Update available: ${VERSION} -> ${latestVersion}. Re-executing from @latest...`);
-            return new Promise((resolve) => {
-                const childArgs = [
-                    "-y",
-                    "@bridge_gpt/mcp-server@latest",
-                    "upgrade",
-                    "--internal-reexec",
-                    "--old-version",
-                    VERSION,
-                ];
-                const child = spawn(npxCmd, childArgs, { stdio: "inherit", cwd });
-                child.on("close", (code) => resolve(code ?? 0));
-                child.on("error", (err) => {
-                    console.error(`Bridge API upgrade failed: could not re-exec npx: ${err.message}`);
-                    resolve(1);
-                });
-            });
+    if (argv.includes(INTERNAL_REEXEC_FLAG)) {
+        // We ARE the `@latest` child this CLI spawned, so `VERSION` is latest by
+        // construction — the parent resolved it through npx moments ago.
+        return { version: VERSION, confidence: "internal-reexec" };
+    }
+    // No reliable way exists to observe from inside the process whether npx
+    // resolved us via `@latest`, a bare spec, or a local node_modules copy — npm's
+    // exported environment does not carry the requested spec. So a canonical
+    // invocation must be asserted explicitly rather than guessed.
+    const asserted = deps.env?.BAPI_UPGRADE_ASSUME_LATEST;
+    if (typeof asserted === "string" && asserted.trim().toLowerCase() === "true") {
+        return { version: VERSION, confidence: "latest-invocation-confirmed" };
+    }
+    return { version: VERSION, confidence: "running-version-only" };
+}
+// ---------------------------------------------------------------------------
+// Reporting helpers (pure)
+// ---------------------------------------------------------------------------
+/** Render the dry-run preview line for one inspected target. */
+export function formatDryRunLine(found) {
+    const { relPath, targetVersion } = found;
+    switch (found.action) {
+        case "repin":
+            return `    ${relPath}: ${found.currentVersion} -> ${targetVersion}`;
+        case "already-current":
+            return `    ${relPath}: already ${targetVersion}`;
+        case "normalize-unpinned":
+            return `    ${relPath}: would normalize ${found.spec} -> @bridge_gpt/mcp-server@${targetVersion}`;
+        case "add":
+            return `    ${relPath}: would add @bridge_gpt/mcp-server@${targetVersion}`;
+        case "create":
+            return `    ${relPath}: would create with @bridge_gpt/mcp-server@${targetVersion}`;
+        case "skip-worktree-shim":
+            return `    ${relPath}: skipped — worktree mcp-invoke shim (no published-package pin applies)`;
+        case "skip-inactive":
+            return null; // Absent config for an inactive IDE — not worth a line.
+        default:
+            return null;
+    }
+}
+/** Render the real-run result line for one verified config action. */
+export function formatResultLine(action) {
+    const { relPath } = action;
+    switch (action.kind) {
+        case "repinned":
+            return `  ${relPath}: ${action.fromVersion} -> ${action.toVersion}`;
+        case "already-current":
+            return `  ${relPath}: already ${action.toVersion}`;
+        case "normalized":
+            return `  ${relPath}: normalized ${action.fromSpec} -> @bridge_gpt/mcp-server@${action.toVersion}`;
+        case "added":
+            return `  ${relPath}: added @bridge_gpt/mcp-server@${action.toVersion}`;
+        case "created":
+            return `  ${relPath}: created with @bridge_gpt/mcp-server@${action.toVersion}`;
+        case "skipped-worktree-shim":
+            return `  ${relPath}: skipped — worktree mcp-invoke shim preserved`;
+        case "skipped-ahead":
+            // Defensive: upgrade blocks on an ahead pin during preflight, so this is
+            // only reachable if a config changed underneath the run.
+            return `  ${relPath}: skipped — already pinned ahead at ${action.fromVersion}`;
+        case "skipped-inactive":
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * True when the run changed no launcher pin: every applicable standard launcher
+ * was already exactly at the target, and nothing was created, added, or
+ * normalized. This — and ONLY this — is what `Already up-to-date.` means.
+ */
+export function isEveryLauncherAlreadyCurrent(actions) {
+    const applicable = actions.filter((a) => a.kind !== "skipped-worktree-shim" &&
+        a.kind !== "skipped-inactive" &&
+        a.kind !== "skipped-ahead");
+    if (applicable.length === 0)
+        return false; // Nothing applicable ⇒ not "current".
+    return applicable.every((a) => a.kind === "already-current");
+}
+// ---------------------------------------------------------------------------
+// The command
+// ---------------------------------------------------------------------------
+export async function runUpgradeCli(argv, injected) {
+    const deps = {
+        ...createDefaultUpgradeCliDeps(injected?.cwd ?? process.cwd()),
+        ...injected,
+    };
+    const { stdout, stderr } = deps;
+    const isDryRun = argv.includes("--dry-run");
+    const isInternalReexec = argv.includes(INTERNAL_REEXEC_FLAG);
+    // ---- Phase 1: CLI freshness — the ONLY thing `VERSION` decides ----
+    const target = await resolveUpgradeTarget(argv, deps);
+    if (target.confidence === "registry-confirmed" &&
+        isNewerVersion(VERSION, target.version) &&
+        !isInternalReexec &&
+        !isDryRun) {
+        stdout(`Update available: ${VERSION} -> ${target.version}. Re-executing from @latest...`);
+        return deps.reexecFromLatest(deps.cwd, VERSION);
+    }
+    if (target.confidence === "running-version-only") {
+        // Fail closed. Writing the running version into every project config when we
+        // could not confirm it IS the latest would replace an honest stale pin with a
+        // confidently wrong one.
+        stderr("Bridge API upgrade aborted: could not confirm the latest published version " +
+            "(the npm registry lookup failed) and this process was not started from @latest.");
+        stderr(`  Nothing was changed. Re-run the canonical command: ${CANONICAL_UPGRADE_COMMAND}`);
+        return 1;
+    }
+    // ---- Phase 2: read-only launcher preflight, before ANY side effect ----
+    const isCreatable = deps.isCreatable ?? ((relPath) => relPath === ".mcp.json");
+    let inspections;
+    try {
+        inspections = await inspectLauncherConfigs({
+            cwd: deps.cwd,
+            targetVersion: target.version,
+            readFile: deps.readFile,
+            isCreatable,
+            targets: LAUNCHER_CONFIG_TARGETS,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        stderr(`Bridge API upgrade failed: could not inspect launcher configs: ${msg}`);
+        return 1;
+    }
+    const blocking = inspections.filter(isPrerequisiteFailure);
+    const ahead = inspections.filter((i) => i.action === "ahead");
+    if (blocking.length > 0 || ahead.length > 0) {
+        stderr("Bridge API upgrade aborted — these configs cannot be safely reconciled:");
+        for (const found of [...blocking, ...ahead]) {
+            stderr(`  ${found.relPath}: ${describeLauncherReason(found.reason)}`);
         }
+        stderr("  Nothing was changed. Resolve these by hand, then re-run the upgrade.");
+        return 1;
     }
-    const oldVersionIdx = argv.indexOf("--old-version");
-    const oldVersion = oldVersionIdx !== -1 && oldVersionIdx + 1 < argv.length ? argv[oldVersionIdx + 1] : VERSION;
-    const targetVersion = isDryRun && isNewer ? latestVersion : VERSION;
+    // ---- Phase 3: dry run reports the REAL pre-mutation state and stops ----
     if (isDryRun) {
-        const configTargets = [".mcp.json", ".vscode/mcp.json", ".cursor/mcp.json"];
-        console.log(`\n[Dry Run] Upgrade preview:`);
-        if (isNewer && !isInternalReexec) {
-            console.log(`- Would re-exec from @latest to upgrade ${VERSION} -> ${latestVersion}`);
+        stdout(`\n[Dry Run] Upgrade preview:`);
+        if (target.confidence === "registry-confirmed" &&
+            isNewerVersion(VERSION, target.version) &&
+            !isInternalReexec) {
+            stdout(`- Would re-exec from @latest to upgrade the CLI ${VERSION} -> ${target.version}`);
         }
-        console.log(`- Would detect and remove competing local install in node_modules/@bridge_gpt/mcp-server if present.`);
-        console.log(`- Would rewrite launcher pin to @bridge_gpt/mcp-server@${targetVersion} across active per-host configs:`);
-        for (const target of configTargets) {
-            try {
-                await stat(path.join(cwd, target));
-                console.log(`    - ${target}`);
-            }
-            catch { }
+        stdout(`- Would detect and remove competing local install in node_modules/@bridge_gpt/mcp-server if present.`);
+        stdout(`- Launcher pins (target @bridge_gpt/mcp-server@${target.version}):`);
+        const lines = inspections
+            .map(formatDryRunLine)
+            .filter((l) => l !== null);
+        if (lines.length === 0) {
+            stdout("    (no applicable launcher configs found)");
+        }
+        else {
+            for (const line of lines)
+                stdout(line);
+        }
+        if (isEveryLauncherAlreadyCurrent(toPlannedActions(inspections))) {
+            stdout(`- Would print: Already up-to-date.`);
         }
-        console.log(`- Would refresh scaffolded artifacts (commands, agents, pipelines).`);
-        const spawnCommand = buildGenericAgentShellCommand(AGENT_REGISTRY.claude, "Bridge API MCP server has been upgraded. Please reload/reconnect the MCP server in your environment.", cwd, process.platform);
-        console.log(`- Would print: ${oldVersion} -> ${targetVersion} and spawn a fresh reconnect session with command:\n    ${spawnCommand}`);
+        stdout(`- Would refresh scaffolded artifacts (commands, agents, pipelines).`);
+        stdout(`- Would open a fresh reconnect session.`);
         return 0;
     }
-    // Detect and resolve the competing-local-install trap: npx silently prefers
-    // a local node_modules copy over the registry, so the stale version wins even
-    // after an upgrade unless we remove it.
+    // ---- Phase 4: competing local install — a reconciliation, not a transition ----
+    if (await deps.hasCompetingLocalInstall(deps.cwd)) {
+        stdout("Found a competing local installation in node_modules. Removing so npx resolves the pinned version...");
+        const removed = await deps.removeCompetingLocalInstall(deps.cwd);
+        if (!removed) {
+            // Leaving it in place means npx keeps preferring the stale local copy, so
+            // the repin below would be cosmetic. That is not a completed upgrade.
+            stderr("Bridge API upgrade failed: could not remove node_modules/@bridge_gpt/mcp-server.");
+            stderr("  Remove it manually (rm -rf node_modules/@bridge_gpt/mcp-server), then re-run the upgrade.");
+            return 1;
+        }
+        stdout("  Removed competing local install.");
+    }
+    // ---- Phase 5: reconcile ----
+    let initResult;
     try {
-        const localModulePath = path.join(cwd, "node_modules", "@bridge_gpt", "mcp-server");
-        await stat(localModulePath);
-        console.log("Found stale local installation in node_modules. Removing to converge on pinned-npx...");
-        const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-        await new Promise((resolve) => {
-            const child = spawn(npmCmd, ["uninstall", "@bridge_gpt/mcp-server"], {
-                stdio: "inherit",
-                cwd,
-            });
-            child.on("close", (code) => {
-                if (code !== 0)
-                    console.warn("Warning: npm uninstall failed; you may need to remove node_modules/@bridge_gpt/mcp-server manually.");
-                resolve();
-            });
-            child.on("error", () => resolve());
+        stdout(`\nReconciling launcher pins to @bridge_gpt/mcp-server@${target.version}...\n`);
+        initResult = await deps.runInit(deps.cwd, {
+            targetVersion: target.version,
+            // Upgrade renders its own truthful per-config report below; the generic
+            // "updated entry and pinned version" summary would only contradict it.
+            suppressConfigSummary: true,
         });
     }
-    catch {
-        // Not installed locally — nothing to clean up.
+    catch (err) {
+        if (err instanceof InitPreflightError) {
+            stderr("Bridge API upgrade aborted — these configs cannot be safely reconciled:");
+            for (const failure of err.failures) {
+                stderr(`  ${failure.relPath}: ${failure.reason}`);
+            }
+            return 1;
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        stderr(`Bridge API upgrade failed: ${msg}`);
+        return 1;
     }
+    // ---- Phase 6: verify every claim by re-reading the configs ----
+    let verified;
     try {
-        console.log(`\nUpgrading @bridge_gpt/mcp-server to ${targetVersion}...\n`);
-        // Scaffold & rewrite the launcher pin on upgrade.
-        console.log("Refreshing scaffolded artifacts and updating launcher pins...\n");
-        await runInit(cwd);
-        console.log(`\nUpgrade complete: ${oldVersion} -> ${targetVersion}`);
-        console.log("Please reconnect your MCP now.");
+        verified = await inspectLauncherConfigs({
+            cwd: deps.cwd,
+            targetVersion: target.version,
+            readFile: deps.readFile,
+            isCreatable,
+            targets: LAUNCHER_CONFIG_TARGETS,
+        });
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        console.error(`Bridge API upgrade failed: ${msg}`);
+        stderr(`Bridge API upgrade failed: could not verify launcher configs after writing: ${msg}`);
         return 1;
     }
-    // Open a fresh agent session so the user lands in a reconnected environment
-    // rather than having to manually restart.
-    try {
-        const terminal = detectTerminal(undefined, process.env);
-        const deps = createDefaultStartTicketsDeps();
-        const spawnTerminalTab = getDefaultSpawnTerminalTabForPlatform(process.platform);
-        const spawnCommand = buildGenericAgentShellCommand(AGENT_REGISTRY.claude, "Bridge API MCP server has been upgraded. Please reload/reconnect the MCP server in your environment.", cwd, process.platform);
-        console.log("\nOpening a fresh agent session to reconnect...");
-        const spawnResult = await spawnTerminalTab(deps, terminal, spawnCommand, {
-            key: "reconnect",
-            worktreePath: cwd,
-        });
-        if (!spawnResult.ok) {
-            console.log(`\nTo continue, manually run:\n${spawnCommand}\n`);
+    const verifiedByPath = new Map(verified.map((v) => [v.relPath, v]));
+    const verificationFailures = [];
+    for (const action of initResult.configActions) {
+        if (action.kind === "skipped-worktree-shim" ||
+            action.kind === "skipped-inactive" ||
+            action.kind === "skipped-ahead") {
+            // Assert the shim really was left alone rather than quietly rewritten.
+            const after = verifiedByPath.get(action.relPath);
+            if (action.kind === "skipped-worktree-shim" && after?.action !== "skip-worktree-shim") {
+                verificationFailures.push(`${action.relPath}: a worktree shim was expected to be preserved but no longer looks like one`);
+            }
+            continue;
+        }
+        const after = verifiedByPath.get(action.relPath);
+        if (!after) {
+            verificationFailures.push(`${action.relPath}: config disappeared after the write`);
+            continue;
+        }
+        if (after.action !== "already-current" || after.currentVersion !== target.version) {
+            verificationFailures.push(`${action.relPath}: expected @bridge_gpt/mcp-server@${target.version} after the write, ` +
+                `found ${after.spec ?? "no recognizable package token"}`);
         }
     }
-    catch {
-        console.log("To continue, please reload your agent session manually.");
+    // ---- Phase 7: report what actually happened ----
+    const resultLines = initResult.configActions
+        .map(formatResultLine)
+        .filter((l) => l !== null);
+    if (resultLines.length > 0) {
+        stdout("Launcher pins:");
+        for (const line of resultLines)
+            stdout(line);
+    }
+    stdout("Refreshed scaffolded artifacts (commands, agents, pipelines).");
+    if (verificationFailures.length > 0) {
+        stderr("\nBridge API upgrade did NOT converge:");
+        for (const failure of verificationFailures)
+            stderr(`  ${failure}`);
+        stderr("  Re-run the upgrade, or repair the listed configs by hand.");
+        return 1;
+    }
+    if (!initResult.ok) {
+        // `runInit` already printed the path-specific readiness warning. Do not add a
+        // completion line on top of it — a config that authenticates as nobody is not
+        // a finished upgrade.
+        stderr("\nBridge API upgrade finished with an UNCONFIGURED MCP entry (see above).");
+        return 1;
+    }
+    const applicableStandard = verified.filter(isApplicableStandardLauncher);
+    if (isEveryLauncherAlreadyCurrent(initResult.configActions)) {
+        // The exact string `/upgrade-bridge` is contracted to relay verbatim.
+        stdout("\nAlready up-to-date.");
+    }
+    else if (applicableStandard.length === 0 && resultLines.length > 0) {
+        // Only worktree shims (or nothing applicable) — reporting "current" here
+        // would claim something about pins that were never evaluated.
+        stdout("\nNo standard launcher pin was changed.");
+    }
+    else {
+        stdout(`\nUpgrade complete: launcher pins are at ${target.version}.`);
+        stdout("Please reconnect your MCP now.");
+    }
+    // ---- Phase 8: reconnect — convenience only, never changes the verdict ----
+    const spawnCommand = buildGenericAgentShellCommand(AGENT_REGISTRY.claude, "Bridge API MCP server has been upgraded. Please reload/reconnect the MCP server in your environment.", deps.cwd, process.platform);
+    const spawned = await deps.spawnReconnect(deps.cwd, spawnCommand);
+    if (!spawned) {
+        stdout(`\nTo continue, manually run:\n${spawnCommand}\n`);
     }
     return 0;
 }
+/**
+ * Project pre-mutation inspections onto the action shape `isEveryLauncherAlreadyCurrent`
+ * consumes, so the dry run answers the currentness question exactly the way the
+ * real run will rather than with a second, drifting rule.
+ */
+function toPlannedActions(inspections) {
+    const actions = [];
+    for (const found of inspections) {
+        switch (found.action) {
+            case "repin":
+                actions.push({ relPath: found.relPath, kind: "repinned" });
+                break;
+            case "already-current":
+                actions.push({ relPath: found.relPath, kind: "already-current" });
+                break;
+            case "normalize-unpinned":
+                actions.push({ relPath: found.relPath, kind: "normalized" });
+                break;
+            case "add":
+                actions.push({ relPath: found.relPath, kind: "added" });
+                break;
+            case "create":
+                actions.push({ relPath: found.relPath, kind: "created" });
+                break;
+            case "skip-worktree-shim":
+                actions.push({ relPath: found.relPath, kind: "skipped-worktree-shim" });
+                break;
+            case "skip-inactive":
+                actions.push({ relPath: found.relPath, kind: "skipped-inactive" });
+                break;
+            default:
+                break;
+        }
+    }
+    return actions;
+}

package/build/version.generated.js

@@ -1,2 +1,2 @@
 // AUTO-GENERATED — do not edit manually. Regenerate with: npm run build
-export const VERSION = "0.2.34";
+export const VERSION = "0.2.37";