cli-wechat-bridge 1.1.3 → 1.1.5

package/dist/bridge/bridge-adapters.pi.js

@@ -319,9 +319,17 @@ export class PiTuiAdapter {
         if (!sessionPath) {
             throw new Error(`Pi session not found for this workspace: ${sessionId}`);
         }
+        const verifiedSession = summarizePiSessionFile(sessionPath, this.options.cwd);
+        if (!verifiedSession || verifiedSession.sessionId !== sessionId) {
+            throw new Error(`Pi session changed or became unavailable before it could be resumed: ${sessionId}`);
+        }
         this.pendingSessionSwitch = { source: "wechat", reason: "wechat_resume" };
         try {
-            const response = await this.sendCommand("switch_session", { sessionPath });
+            const response = await this.sendCommand("switch_session", {
+                sessionPath,
+                sessionId,
+                cwd: this.options.cwd,
+            });
             this.applySessionState(response.data, "wechat", "wechat_resume", true);
             if (isRecord(response.data) && response.data.cancelled === true) {
                 throw new Error("Pi session switch was cancelled by an extension.");
@@ -482,6 +490,14 @@ export class PiTuiAdapter {
         switch (frame.type) {
             case "session_state": {
                 const pending = this.pendingSessionSwitch;
+                const nextSessionId = typeof frame.sessionId === "string" ? frame.sessionId : undefined;
+                const isLocalSessionSwitch = !pending &&
+                    Boolean(nextSessionId) &&
+                    Boolean(this.state.sharedSessionId) &&
+                    nextSessionId !== this.state.sharedSessionId;
+                if (isLocalSessionSwitch) {
+                    this.prepareForLocalSessionSwitch();
+                }
                 this.applySessionState(frame, pending?.source ?? "local", pending?.reason ?? "local_follow", Boolean(this.state.sharedSessionId));
                 this.setStatus(this.state.status);
                 break;
@@ -520,6 +536,19 @@ export class PiTuiAdapter {
             timestamp: nowIso(),
         });
     }
+    prepareForLocalSessionSwitch() {
+        if (this.state.activeTurnOrigin === "wechat") {
+            this.emit({
+                type: "task_failed",
+                message: "The active WeChat task was interrupted because the local Pi terminal switched sessions.",
+                timestamp: nowIso(),
+            });
+        }
+        this.currentAssistantText = "";
+        this.currentTurnError = "";
+        this.clearActiveTurn();
+        this.setStatus("idle");
+    }
     beginTurn(origin) {
         this.currentAssistantText = "";
         this.currentTurnError = "";
@@ -533,14 +562,11 @@ export class PiTuiAdapter {
             return;
         }
         this.finalizingTurn = true;
-        const origin = this.state.activeTurnOrigin;
         try {
             if (this.currentTurnError) {
-                if (origin === "wechat") {
-                    this.emit({ type: "task_failed", message: this.currentTurnError, timestamp: nowIso() });
-                }
+                this.emit({ type: "task_failed", message: this.currentTurnError, timestamp: nowIso() });
             }
-            else if (origin === "wechat" && this.currentAssistantText) {
+            else if (this.currentAssistantText) {
                 this.emit({ type: "final_reply", text: this.currentAssistantText, timestamp: nowIso() });
             }
             this.state.lastOutputAt = nowIso();
@@ -636,6 +662,12 @@ export class PiTuiAdapter {
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = null;
             if (!this.socket && !this.disposing) {
+                // Reset the turn state alongside the fatal error: leaving status at
+                // "busy" would keep rejecting every message with "still working"
+                // while /stop stays unavailable (no socket) and /reset is the only
+                // way out.
+                this.clearActiveTurn();
+                this.setStatus("idle", "The Pi TUI extension disconnected; the bridge is waiting for a reconnect.");
                 this.emit({
                     type: "fatal_error",
                     message: "The native Pi TUI bridge extension disconnected and did not reconnect.",
@@ -680,9 +712,13 @@ export class PiTuiAdapter {
         this.extensionReady = false;
         this.clearActiveTurn();
         if (!this.disposing) {
+            // Report unexpected exits as fatal errors, matching the other adapters:
+            // a bare "stopped" status is only logged by the bridge, so WeChat users
+            // would get no signal that the TUI is gone until their next message
+            // fails with a cryptic not-connected error.
             this.emit({
-                type: "status",
-                status: "stopped",
+                type: "fatal_error",
+                message: `Pi TUI exited unexpectedly (code=${code ?? "none"}, signal=${signal ?? "none"}). Restart the bridge or use /reset to recover.`,
                 timestamp: nowIso(),
             });
         }

package/dist/bridge/bridge-adapters.shared.js

@@ -32,8 +32,6 @@ export const LOCAL_COMPANION_RECONNECT_GRACE_MS = 15_000;
 export const CLAUDE_HOOK_LISTEN_HOST = "127.0.0.1";
 export const CLAUDE_HELP_PROBE_TIMEOUT_MS = 5_000;
 export const CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS = 12_000;
-export const DEFAULT_UNIX_SHELL_CANDIDATES = ["pwsh", "bash", "zsh", "sh"];
-export const POSIX_SHELL_NAMES = new Set(["bash", "zsh", "sh", "dash", "ksh"]);
 export const CLAUDE_FLAG_SUPPORT_CACHE = new Map();
 export const OPENCODE_SERVER_HOST = "127.0.0.1";
 export const OPENCODE_SERVER_READY_TIMEOUT_MS = 10_000;
@@ -678,44 +676,25 @@ function applyLoopbackNoProxy(env) {
     env.no_proxy = mergeNoProxyValue(env.no_proxy);
     return env;
 }
-export function resolveDefaultAdapterCommand(kind, options = {}) {
-    const platform = options.platform ?? process.platform;
-    if (kind !== "shell") {
-        return kind;
-    }
-    if (platform === "win32") {
-        return "powershell.exe";
-    }
-    const env = options.env ?? process.env;
-    for (const candidate of DEFAULT_UNIX_SHELL_CANDIDATES) {
-        if (resolveCommandPath(candidate, platform, env)) {
-            return candidate;
-        }
-    }
-    throw new Error(`No default shell executable was found on ${platform}. Tried: ${DEFAULT_UNIX_SHELL_CANDIDATES.join(", ")}. Use --cmd <executable>.`);
+export function resolveDefaultAdapterCommand(kind, _options = {}) {
+    return kind;
 }
-export function buildCliEnvironment(kind, options = {}) {
+export function buildCliEnvironment(_kind, options = {}) {
     const sourceEnv = options.env ?? process.env;
     const platform = options.platform ?? process.platform;
-    if (kind === "codex" || kind === "claude" || kind === "opencode" || kind === "pi") {
-        // Pass the full environment through on every platform. A previous
-        // Windows-only allowlist silently dropped user-configured variables such
-        // as ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN / OPENAI_API_KEY, which
-        // broke CLIs that authenticate via environment variables even though the
-        // same CLI worked when launched manually from the user's shell.
-        const env = {
-            ...copyDefinedEnv(sourceEnv),
-            TERM: sourceEnv.TERM || "xterm-256color",
-        };
-        if (platform === "win32" && !env.HOME && env.USERPROFILE) {
-            env.HOME = env.USERPROFILE;
-        }
-        return applyLoopbackNoProxy(env);
-    }
-    return {
+    // Pass the full environment through on every platform. A previous
+    // Windows-only allowlist silently dropped user-configured variables such
+    // as ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN / OPENAI_API_KEY, which
+    // broke CLIs that authenticate via environment variables even though the
+    // same CLI worked when launched manually from the user's shell.
+    const env = {
         ...copyDefinedEnv(sourceEnv),
         TERM: sourceEnv.TERM || "xterm-256color",
     };
+    if (platform === "win32" && !env.HOME && env.USERPROFILE) {
+        env.HOME = env.USERPROFILE;
+    }
+    return applyLoopbackNoProxy(env);
 }
 // ConPTY shipped in Windows 10 build 18309; on older builds node-pty must be
 // left to auto-select its winpty fallback instead of being forced onto ConPTY.
@@ -738,72 +717,6 @@ export function buildPtySpawnOptions(params) {
     }
     return options;
 }
-export function normalizeShellCommandName(command) {
-    return path.parse(path.basename(command)).name.toLowerCase();
-}
-export function resolveShellRuntime(command, options = {}) {
-    const platform = options.platform ?? process.platform;
-    const name = normalizeShellCommandName(command);
-    if (name === "powershell" || name === "pwsh") {
-        return {
-            family: "powershell",
-            launchArgs: platform === "win32"
-                ? ["-NoLogo", "-NoProfile", "-ExecutionPolicy", "Bypass", "-NoExit"]
-                : ["-NoLogo", "-NoProfile", "-NoExit"],
-        };
-    }
-    if (POSIX_SHELL_NAMES.has(name)) {
-        return {
-            family: "posix",
-            launchArgs: ["-i"],
-        };
-    }
-    throw new Error(`Unsupported shell executable for shell adapter: ${command}. Supported shells: powershell, pwsh, bash, zsh, sh, dash, ksh.`);
-}
-export function escapePowerShellString(text) {
-    return text.replace(/`/g, "``").replace(/"/g, '`"');
-}
-export function escapePosixShellString(text) {
-    return `'${text.replace(/'/g, `'"'"'`)}'`;
-}
-export function buildShellProfileCommand(profilePath, family) {
-    const resolved = path.resolve(profilePath);
-    if (family === "powershell") {
-        return `. "${escapePowerShellString(resolved)}"`;
-    }
-    return `. ${escapePosixShellString(resolved)}`;
-}
-export function buildShellInputPayload(text, family, completionMarker = "__WECHAT_BRIDGE_DONE__") {
-    if (family === "powershell") {
-        const encodedCommand = Buffer.from(text, "utf8").toString("base64");
-        const script = [
-            "$__wechatBridgePreviousErrorActionPreference = $ErrorActionPreference",
-            "$ErrorActionPreference = 'Continue'",
-            "$global:LASTEXITCODE = 0",
-            "try {",
-            `  $decoded = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String("${escapePowerShellString(encodedCommand)}"))`,
-            "  $scriptBlock = [scriptblock]::Create($decoded)",
-            "  & $scriptBlock",
-            "} catch {",
-            "  Write-Error $_",
-            "  $global:LASTEXITCODE = 1",
-            "} finally {",
-            "  if (-not ($global:LASTEXITCODE -is [int])) { $global:LASTEXITCODE = 0 }",
-            `  Write-Output "${escapePowerShellString(completionMarker)}:$global:LASTEXITCODE"`,
-            "  $ErrorActionPreference = $__wechatBridgePreviousErrorActionPreference",
-            "}",
-            "",
-        ];
-        return `${script.join("\r")}\r`;
-    }
-    const script = [
-        text,
-        "__wechat_bridge_status=$?",
-        `printf '%s:%s\\n' ${escapePosixShellString(completionMarker)} "$__wechat_bridge_status"`,
-        "",
-    ];
-    return `${script.join("\r")}\r`;
-}
 export async function reserveLocalPort() {
     return await new Promise((resolve, reject) => {
         const server = net.createServer();

package/dist/bridge/bridge-controller.js

@@ -29,6 +29,9 @@ export class BridgeController {
                 companionStatus: adapterState.status,
                 companionLastStateAt: new Date().toISOString(),
                 companionWorkerPid: adapterState.pid,
+                codexControlPort: endpoint.codexControlPort ?? existing.codexControlPort,
+                codexControlToken: endpoint.codexControlToken ?? existing.codexControlToken,
+                codexVisibleThreadId: endpoint.codexVisibleThreadId ?? existing.codexVisibleThreadId,
             }
             : {
                 ...endpoint,

package/dist/bridge/bridge-final-reply.js

@@ -8,9 +8,24 @@ export async function forwardWechatFinalReply(params) {
     if (visibleText) {
         // Send long replies in bounded chunks: a single oversized sendmessage call
         // can be rejected by the WeChat API, silently losing the whole reply.
-        for (const chunk of splitWechatTextIntoChunks(visibleText)) {
-            const sent = await sender.sendText(chunk);
+        const chunks = splitWechatTextIntoChunks(visibleText);
+        for (let index = 0; index < chunks.length; index += 1) {
+            const sent = await sender.sendText(chunks[index]);
             if (sent === false) {
+                // The send channel is failing (e.g. an expired context token).
+                // Report what was dropped instead of ending mid-reply silently;
+                // this notice itself is best effort and may also fail.
+                const remainingChunks = chunks.length - index - 1;
+                if (remainingChunks > 0 || parsed.attachments.length > 0) {
+                    const parts = [];
+                    if (remainingChunks > 0) {
+                        parts.push(`${remainingChunks} reply chunk(s)`);
+                    }
+                    if (parsed.attachments.length > 0) {
+                        parts.push(`${parsed.attachments.length} attachment(s)`);
+                    }
+                    await sender.sendText(`[bridge] Reply delivery was interrupted; ${parts.join(" and ")} could not be sent. Send a new message to retry.`);
+                }
                 return;
             }
         }

package/dist/bridge/bridge-process-reaper.js

@@ -56,9 +56,14 @@ export function isWechatDaemonCommandLineForCwd(commandLine, cwd) {
  *   opencode serve --port 12345 --hostname 127.0.0.1
  *   opencode.exe serve --port 12345
  * Also matches wrapper invocations (opencode.cmd / opencode.bat) on Windows.
+ *
+ * `serve` must be the first subcommand token after the executable so that
+ * unrelated command lines merely containing both words (e.g.
+ * `node opencode-lint/serve.js` or `mytool --theme opencode --mode serve`)
+ * are not reaped as orphans.
  */
 export function isOpencodeServeCommandLine(commandLine) {
-    return /\bopencode(?:\.exe|\.cmd|\.bat)?\b.*\bserve\b/i.test(commandLine);
+    return /\bopencode(?:\.exe|\.cmd|\.bat)?["']?\s+serve\b/i.test(commandLine);
 }
 /**
  * Detects `opencode attach` command lines spawned by the local OpenCode companion.
@@ -67,7 +72,7 @@ export function isOpencodeServeCommandLine(commandLine) {
  *   opencode.exe attach http://127.0.0.1:12345 --session ses_123
  */
 export function isOpencodeAttachCommandLine(commandLine) {
-    return /\bopencode(?:\.exe|\.cmd|\.bat)?\b.*\battach\b/i.test(commandLine);
+    return /\bopencode(?:\.exe|\.cmd|\.bat)?["']?\s+attach\b/i.test(commandLine);
 }
 function normalizeBridgeProcessRecord(value) {
     if (!isRecord(value)) {
@@ -158,7 +163,8 @@ function listWindowsBridgeProcesses(currentPid = process.pid) {
         "Bypass",
         "-Command",
         [
-            "$ErrorActionPreference='Stop'",
+            // Trailing semicolon required — see the note in listAllProcessesRaw.
+            "$ErrorActionPreference='Stop';",
             "Get-CimInstance Win32_Process",
             "| Where-Object { $_.CommandLine }",
             "| Select-Object ProcessId,ParentProcessId,Name,CommandLine",
@@ -236,7 +242,11 @@ function listAllProcessesRaw(currentPid = process.pid) {
             "Bypass",
             "-Command",
             [
-                "$ErrorActionPreference='Stop'",
+                // Statement separator required: without the trailing semicolon
+                // PowerShell parses the preference assignment and the first command
+                // as one statement and fails with a ParserError, silently
+                // returning an empty process list on every probe.
+                "$ErrorActionPreference='Stop';",
                 "Get-CimInstance Win32_Process",
                 "| Where-Object { $_.CommandLine }",
                 "| Select-Object ProcessId,ParentProcessId,Name,CommandLine",

package/dist/bridge/bridge-session-resume.js

@@ -0,0 +1,151 @@
+import { formatResumeSessionList, formatSessionSwitchMessage, } from "./bridge-utils.js";
+export const RESUME_SESSION_LIST_LIMIT = 8;
+export const RESUME_SESSION_SNAPSHOT_TTL_MS = 5 * 60 * 1_000;
+const RESUME_SESSION_PREFIX_SCAN_LIMIT = 100;
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function adapterDisplayName(adapter) {
+    switch (adapter) {
+        case "codex":
+            return "Codex";
+        case "claude":
+            return "Claude";
+        case "opencode":
+            return "OpenCode";
+        case "pi":
+            return "Pi";
+    }
+}
+function adapterSessionNoun(adapter) {
+    return adapter === "codex" ? "thread" : "session";
+}
+export function isWechatResumeEnabled(adapter) {
+    return (adapter === "codex" ||
+        adapter === "claude" ||
+        adapter === "opencode" ||
+        adapter === "pi");
+}
+export function shouldForwardSessionSwitchEvent(reason) {
+    return reason !== "wechat_resume";
+}
+export class ResumeSessionCoordinator {
+    adapter;
+    runtime;
+    now;
+    snapshot = null;
+    constructor(options) {
+        this.adapter = options.adapter;
+        this.runtime = options.runtime;
+        this.now = options.now ?? Date.now;
+    }
+    clear() {
+        this.snapshot = null;
+    }
+    async execute(target) {
+        const normalizedTarget = target?.trim() ?? "";
+        if (!normalizedTarget) {
+            const candidates = await this.listCandidates(RESUME_SESSION_LIST_LIMIT);
+            this.snapshot = {
+                createdAtMs: this.now(),
+                candidates,
+            };
+            return {
+                kind: "list",
+                message: formatResumeSessionList({
+                    adapter: this.adapter,
+                    candidates,
+                    currentSessionId: this.runtime.getState().sharedSessionId ??
+                        this.runtime.getState().sharedThreadId,
+                }),
+            };
+        }
+        const candidate = await this.resolveCandidate(normalizedTarget);
+        const currentSessionId = this.runtime.getState().sharedSessionId ??
+            this.runtime.getState().sharedThreadId;
+        if (candidate.sessionId === currentSessionId) {
+            return {
+                kind: "already_active",
+                sessionId: candidate.sessionId,
+                message: `${adapterDisplayName(this.adapter)} ${adapterSessionNoun(this.adapter)} ${candidate.sessionId.slice(0, 12)} is already active.`,
+            };
+        }
+        await this.runtime.resumeSession(candidate.sessionId);
+        return {
+            kind: "resumed",
+            sessionId: candidate.sessionId,
+            message: formatSessionSwitchMessage({
+                adapter: this.adapter,
+                sessionId: candidate.sessionId,
+                source: "wechat",
+                reason: "wechat_resume",
+            }),
+        };
+    }
+    async resolveCandidate(target) {
+        if (/^\d+$/.test(target)) {
+            const snapshot = this.getCurrentSnapshot();
+            if (!snapshot) {
+                throw new Error("The recent session list has expired. Send /resume again before choosing a number.");
+            }
+            const index = Number(target) - 1;
+            const candidate = snapshot.candidates[index];
+            if (!candidate) {
+                throw new Error(`Resume selection ${target} is outside the displayed range. Send /resume again to refresh the list.`);
+            }
+            return candidate;
+        }
+        const snapshot = this.getCurrentSnapshot();
+        const snapshotMatch = this.findIdMatch(snapshot?.candidates ?? [], target);
+        if (snapshotMatch) {
+            return snapshotMatch;
+        }
+        const candidates = await this.listCandidates(RESUME_SESSION_PREFIX_SCAN_LIMIT);
+        const candidate = this.findIdMatch(candidates, target);
+        if (candidate) {
+            return candidate;
+        }
+        // A complete ID may be older than the recent candidate window. The
+        // adapter remains responsible for validating its existence and cwd.
+        return {
+            sessionId: target,
+            title: target,
+            lastUpdatedAt: new Date(0).toISOString(),
+            source: this.adapter,
+        };
+    }
+    findIdMatch(candidates, target) {
+        const normalizedTarget = target.toLowerCase();
+        const exact = candidates.find((candidate) => candidate.sessionId.toLowerCase() === normalizedTarget);
+        if (exact) {
+            return exact;
+        }
+        const prefixMatches = candidates.filter((candidate) => candidate.sessionId.toLowerCase().startsWith(normalizedTarget));
+        if (prefixMatches.length > 1) {
+            throw new Error(`Session ID prefix ${target} is ambiguous. Send /resume again and use a longer ID prefix.`);
+        }
+        return prefixMatches[0] ?? null;
+    }
+    getCurrentSnapshot() {
+        if (!this.snapshot) {
+            return null;
+        }
+        if (this.now() - this.snapshot.createdAtMs > RESUME_SESSION_SNAPSHOT_TTL_MS) {
+            this.snapshot = null;
+            return null;
+        }
+        return this.snapshot;
+    }
+    async listCandidates(limit) {
+        try {
+            return await this.runtime.listResumeSessions(limit);
+        }
+        catch (error) {
+            const message = describeError(error);
+            if (/^Failed to list\s/i.test(message)) {
+                throw error;
+            }
+            throw new Error(`Failed to list ${adapterDisplayName(this.adapter)} ${adapterSessionNoun(this.adapter)}s: ${message}`, { cause: error });
+        }
+    }
+}

package/dist/bridge/bridge-state.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureWorkspaceChannelDir, ensureChannelDataDir, } from "../wechat/channel-config.js";
 import { buildInstanceId } from "./bridge-utils.js";
+import { writeJsonFileAtomic } from "../utils/atomic-file.js";
+import { getProcessRecordByPid, isWechatBridgeCommandLine, } from "./bridge-process-reaper.js";
 const ORPHAN_LOCK_RECLAIM_TIMEOUT_MS = 2_000;
 const ORPHAN_LOCK_RECLAIM_POLL_MS = 100;
 export function resolveRestorableSharedSessionId(persisted, options) {
@@ -137,7 +139,37 @@ export function evaluateBridgeRuntimeOwnership(params) {
 function buildLockConflictError(lock) {
     return new Error(`Another bridge instance is already running (pid=${lock.pid}, instanceId=${lock.instanceId}, adapter=${lock.adapter}, cwd=${lock.cwd}, startedAt=${lock.startedAt}, lifecycle=${lock.lifecycle}). Stop it before starting a new bridge.`);
 }
+/**
+ * Check whether the process currently holding a stale lock is still a
+ * wechat-bridge process. OS pid reuse can hand the recorded pid to an
+ * unrelated process; terminating that pid would kill an innocent process.
+ *
+ * Returns "bridge" when the command line matches a bridge, "foreign" when the
+ * pid is alive but belongs to something else, and "unknown" when the command
+ * line could not be resolved (probe failure, restricted permissions).
+ */
+export function classifyLockHolderProcess(pid) {
+    if (!isPidAlive(pid)) {
+        return "unknown";
+    }
+    const record = getProcessRecordByPid(pid);
+    if (!record) {
+        return "unknown";
+    }
+    return isWechatBridgeCommandLine(record.commandLine) ? "bridge" : "foreign";
+}
 function tryTerminateOrphanedBridge(lock) {
+    const holderKind = classifyLockHolderProcess(lock.pid);
+    if (holderKind === "foreign") {
+        // The lock-holding bridge is gone and its pid was reused by an unrelated
+        // process. Reclaim the lock without killing that process.
+        return true;
+    }
+    if (holderKind === "unknown") {
+        // Could not confirm the pid still belongs to a bridge. Do not risk
+        // killing an innocent process; keep the conflict error instead.
+        return false;
+    }
     try {
         process.kill(lock.pid);
     }
@@ -295,13 +327,9 @@ export class BridgeStateStore {
         }
     }
     writeAtomicJsonFile(filePath, value) {
-        ensureChannelDataDir();
-        const data = JSON.stringify(value, null, 2);
         // temp + rename so a crash mid-write cannot leave a truncated/half-written
         // state or lock file that would break the next launch or look like a stale lock.
-        const tempPath = `${filePath}.${process.pid}.tmp`;
-        fs.writeFileSync(tempPath, data, "utf-8");
-        fs.renameSync(tempPath, filePath);
+        writeJsonFileAtomic(filePath, value);
     }
     save() {
         this.writeAtomicJsonFile(this.stateFilePath, this.state);
@@ -311,7 +339,14 @@ export class BridgeStateStore {
         if (existing &&
             existing.pid !== process.pid &&
             isPidAlive(existing.pid)) {
-            if (shouldAutoReclaimBridgeLock(existing)) {
+            const holderKind = classifyLockHolderProcess(existing.pid);
+            if (holderKind === "foreign") {
+                // The recorded bridge exited and the OS reused its pid for an
+                // unrelated process. The lock is stale: reclaim it instead of
+                // dead-locking new bridges on a phantom holder.
+                this.appendLog(`stale_lock_pid_reuse: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);
+            }
+            else if (shouldAutoReclaimBridgeLock(existing)) {
                 this.appendLog(`lock_reclaim_attempt: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);
                 if (tryTerminateOrphanedBridge(existing)) {
                     this.appendLog(`lock_reclaimed: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);