@unlinearity/cli-wechat-bridge 1.1.3 → 1.1.4

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

@@ -1,4 +1,5 @@
 import { spawn as spawnChildProcess } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import { OPENCODE_SERVER_HOST, OPENCODE_SERVER_READY_TIMEOUT_MS, OPENCODE_SSE_RECONNECT_DELAY_MS, OPENCODE_SESSION_IDLE_SETTLE_MS, OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS, OPENCODE_HTTP_READY_TIMEOUT_MS, OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS, OPENCODE_HTTP_READY_PROBE_INTERVAL_MS, buildCliEnvironment, isRecord, describeUnknownError, resolveSpawnTarget, reserveLocalPort, waitForTcpPort, delay, } from "./bridge-adapters.shared.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, buildOneTimeCode, isWechatOutboundAttachmentMutationTool, isWechatOutboundAttachmentWriteCommand, normalizeOutput, nowIso, truncatePreview, OutputBatcher, } from "./bridge-utils.js";
@@ -6,6 +7,9 @@ const OPENCODE_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(process.env.WECHAT_OPEN
 const OPENCODE_DUPLICATE_EVENT_TTL_MS = 150;
 const OPENCODE_WECHAT_MIRROR_SUPPRESSION_TTL_MS = 30_000;
 const OPENCODE_RECENT_LOCAL_PROMPT_TTL_MS = 10_000;
+// How long a selectSession echo suppression stays valid before it is treated
+// as lost and cleared.
+const TUI_SESSION_SELECT_SUPPRESSION_TTL_MS = 5_000;
 const OPENCODE_LOCAL_SESSION_CREATE_FOLLOW_TTL_MS = 5_000;
 const OPENCODE_TUI_SELECT_RETRY_DELAYS_MS = [250, 750, 1_500];
 const OPENCODE_MINIMUM_SUPPORTED_VERSION = "1.18.0";
@@ -20,6 +24,11 @@ export class OpenCodeServerAdapter {
     serverProcess = null;
     nativeProcess = null;
     serverPort = 0;
+    // Random per-instance password handed to `opencode serve` via
+    // OPENCODE_SERVER_PASSWORD. Without it the server accepts unauthenticated
+    // connections from any local process; the attach client inherits the env
+    // automatically, and the SDK/health calls send the matching Basic header.
+    serverPassword = null;
     client = null;
     sseAbortController = null;
     sseLoopPromise = null;
@@ -51,7 +60,7 @@ export class OpenCodeServerAdapter {
     pendingWechatPromptMirrorSuppressions = [];
     recentWechatPromptMirrorSuppressions = [];
     recentSdkEventObservations = new Map();
-    suppressedTuiSessionSelectId = null;
+    suppressedTuiSessionSelect = null;
     lastMirroredLocalPrompt = null;
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
@@ -159,12 +168,50 @@ export class OpenCodeServerAdapter {
         }
     }
     async listResumeSessions(limit = 10) {
-        void limit;
-        throw new Error('WeChat /resume is disabled in opencode mode. Use /session directly inside "wechat-opencode"; WeChat will follow the active local session.');
+        if (!this.client) {
+            return [];
+        }
+        let sessions;
+        try {
+            sessions = this.unwrapOrThrow(await this.client.session.list()) ?? [];
+        }
+        catch {
+            return [];
+        }
+        return sessions
+            .filter((session) => this.isCurrentDirectorySession(session))
+            .slice(0, limit)
+            .map((session) => {
+            const rawTime = typeof session.time?.updated === "number"
+                ? session.time.updated
+                : typeof session.time?.created === "number"
+                    ? session.time.created
+                    : 0;
+            const updatedMs = rawTime > 0 && rawTime < 1_000_000_000_000 ? rawTime * 1_000 : rawTime;
+            return {
+                sessionId: session.id,
+                title: session.title?.trim() || "untitled",
+                lastUpdatedAt: new Date(updatedMs > 0 ? updatedMs : Date.now()).toISOString(),
+                source: "opencode",
+            };
+        });
     }
     async resumeSession(sessionId) {
-        void sessionId;
-        throw new Error('WeChat /resume is disabled in opencode mode. Use /session directly inside "wechat-opencode"; WeChat will follow the active local session.');
+        if (!this.client) {
+            throw new Error("OpenCode is not running yet.");
+        }
+        const session = await this.getSessionForCurrentDirectory(sessionId, []);
+        if (!session) {
+            throw new Error(`No OpenCode session ${sessionId} was found for ${this.options.cwd}.`);
+        }
+        this.switchSharedSession(session, {
+            source: "wechat",
+            reason: "wechat_resume",
+            notify: true,
+            clearTrackedTurn: true,
+            syncVisible: true,
+            forceVisibleSync: true,
+        });
     }
     async createSession() {
         if (!this.client) {
@@ -360,7 +407,7 @@ export class OpenCodeServerAdapter {
         this.client = null;
         this.activeSessionId = null;
         this.activeWorkspaceId = null;
-        this.suppressedTuiSessionSelectId = null;
+        this.suppressedTuiSessionSelect = null;
         this.state.status = "stopped";
         this.state.pid = undefined;
         this.state.startedAt = undefined;
@@ -368,6 +415,8 @@ export class OpenCodeServerAdapter {
     /* ---- Server management ---- */
     async startServerProcess() {
         const env = buildCliEnvironment(this.options.kind);
+        this.serverPassword = randomBytes(24).toString("hex");
+        env.OPENCODE_SERVER_PASSWORD = this.serverPassword;
         const serverArgs = [
             "serve",
             "--port",
@@ -477,6 +526,9 @@ export class OpenCodeServerAdapter {
     }
     buildNativeClientEnv() {
         const env = buildCliEnvironment(this.options.kind);
+        if (this.serverPassword) {
+            env.OPENCODE_SERVER_PASSWORD = this.serverPassword;
+        }
         if (this.activeSessionId) {
             env.OPENCODE_ROUTE = JSON.stringify({
                 type: "session",
@@ -485,6 +537,13 @@ export class OpenCodeServerAdapter {
         }
         return env;
     }
+    buildServerAuthHeaders() {
+        if (!this.serverPassword) {
+            return {};
+        }
+        const credentials = Buffer.from(`opencode:${this.serverPassword}`, "utf8").toString("base64");
+        return { Authorization: `Basic ${credentials}` };
+    }
     async createSdkClient() {
         try {
             const { createOpencodeClient } = await import("@opencode-ai/sdk/v2");
@@ -492,6 +551,7 @@ export class OpenCodeServerAdapter {
                 baseUrl: `http://${OPENCODE_SERVER_HOST}:${this.serverPort}`,
                 directory: this.options.cwd,
                 experimental_workspaceID: this.activeWorkspaceId ?? undefined,
+                headers: this.buildServerAuthHeaders(),
             });
         }
         catch (err) {
@@ -511,6 +571,7 @@ export class OpenCodeServerAdapter {
         while (Date.now() < deadline) {
             try {
                 const response = await fetch(`${baseUrl}/global/health`, {
+                    headers: this.buildServerAuthHeaders(),
                     signal: AbortSignal.timeout(OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS),
                 });
                 if (response.ok) {
@@ -547,7 +608,9 @@ export class OpenCodeServerAdapter {
         }
         const major = Number(match[1]);
         const minor = Number(match[2]);
-        return major === 1 && minor >= 18;
+        return (major >= 1 &&
+            major < OPENCODE_MAXIMUM_SUPPORTED_MAJOR &&
+            (major > 1 || minor >= 18));
     }
     async initializeSessions() {
         if (!this.client) {
@@ -717,6 +780,9 @@ export class OpenCodeServerAdapter {
                 return this.normalizeGlobalSyncPayload(payload, rawEvent);
             }
             const normalized = { ...payload };
+            if (typeof payload.id === "string") {
+                normalized.id = payload.id;
+            }
             if (typeof rawEvent.directory === "string") {
                 normalized.directory = rawEvent.directory;
             }
@@ -792,7 +858,8 @@ export class OpenCodeServerAdapter {
                 this.handleSessionError(isRecord(payload) ? payload : undefined);
                 return;
             }
-            case "permission.updated":
+            // Note: only permission.asked exists in the OpenCode wire protocol;
+            // permission.updated was never emitted by the server.
             case "permission.asked": {
                 this.handlePermissionRequest(payload);
                 return;
@@ -930,7 +997,10 @@ export class OpenCodeServerAdapter {
         if (sessionId && !this.syncTrackedSessionFromEvent(sessionId)) {
             return;
         }
-        // properties: { sessionID: string, status: { type: "busy" | "idle" | ... } }
+        // properties: { sessionID, status: { type: "busy" | "idle" | "retry" | ... } }
+        // "retry" means the model call is being retried (attempt, message): the
+        // session is still working, so it must keep the busy state instead of
+        // letting WeChat messages race a retried turn.
         const status = properties.status;
         if (!isRecord(status)) {
             return;
@@ -939,7 +1009,7 @@ export class OpenCodeServerAdapter {
         if (!statusType) {
             return;
         }
-        if (statusType === "busy" || statusType === "running") {
+        if (statusType === "busy" || statusType === "running" || statusType === "retry") {
             if (this.state.status === "idle") {
                 this.outputBatcher.clear();
                 this.clearStreamedPartState();
@@ -1595,8 +1665,11 @@ export class OpenCodeServerAdapter {
         if (!sessionId) {
             return;
         }
-        if (sessionId === this.suppressedTuiSessionSelectId) {
-            this.suppressedTuiSessionSelectId = null;
+        if (this.suppressedTuiSessionSelect &&
+            sessionId === this.suppressedTuiSessionSelect.sessionId) {
+            // Echo of our own selectSession — swallow it once. The TTL guard in
+            // isSuppressedTuiSessionSelectExpired covers the lost-echo case.
+            this.suppressedTuiSessionSelect = null;
             return;
         }
         this.pendingLocalPrompt = "";
@@ -2142,13 +2215,27 @@ export class OpenCodeServerAdapter {
             workspaceID: this.activeWorkspaceId ?? undefined,
         }, { force: options.force, retry: options.retry });
     }
+    isTuiSessionSelectSuppressed(sessionId) {
+        const suppression = this.suppressedTuiSessionSelect;
+        if (!suppression || suppression.sessionId !== sessionId) {
+            return false;
+        }
+        // Bound the suppression window: if the echo never arrives (TUI not ready,
+        // dropped event), a stale flag must not swallow a later genuine local
+        // switch to the same session.
+        if (Date.now() - suppression.setAtMs > TUI_SESSION_SELECT_SUPPRESSION_TTL_MS) {
+            this.suppressedTuiSessionSelect = null;
+            return false;
+        }
+        return true;
+    }
     async syncVisibleSessionSelection(session, options = {}) {
         if (!this.client?.tui ||
             this.options.renderMode !== "companion" ||
-            (!options.force && session.id === this.suppressedTuiSessionSelectId)) {
+            (!options.force && this.isTuiSessionSelectSuppressed(session.id))) {
             return;
         }
-        this.suppressedTuiSessionSelectId = session.id;
+        this.suppressedTuiSessionSelect = { sessionId: session.id, setAtMs: Date.now() };
         this.logDebug(`[opencode-adapter:tui] selectSession session=${session.id} workspace=${session.workspaceID ?? this.activeWorkspaceId ?? "(none)"}`);
         try {
             await this.sendVisibleSessionSelection(session);
@@ -2157,8 +2244,8 @@ export class OpenCodeServerAdapter {
             }
         }
         catch (err) {
-            if (this.suppressedTuiSessionSelectId === session.id) {
-                this.suppressedTuiSessionSelectId = null;
+            if (this.suppressedTuiSessionSelect?.sessionId === session.id) {
+                this.suppressedTuiSessionSelect = null;
             }
             this.logDebug(`[opencode-adapter:tui] selectSession failed for ${session.id}: ${describeUnknownError(err)}`);
         }
@@ -2266,8 +2353,10 @@ export class OpenCodeServerAdapter {
         }
         return true;
     }
+    // Fold both path separators to "/" so directory comparisons behave
+    // identically on Windows (backslash-native) and POSIX hosts.
     normalizeDirectory(directory) {
-        return directory.replace(/[\\/]+/g, "\\").replace(/\\$/, "").toLowerCase();
+        return directory.replace(/[\\/]+/g, "/").replace(/\/+$/, "").toLowerCase();
     }
     recordSessionSwitch(sessionId, source, reason, notify = false) {
         const timestamp = nowIso();
@@ -2325,13 +2414,20 @@ export class OpenCodeServerAdapter {
             return "";
         }
         const previousText = this.emittedTextByPartId.get(partId) ?? "";
-        if (nextChunk === previousText || previousText.endsWith(nextChunk)) {
+        if (nextChunk === previousText) {
+            // Full replay of everything emitted for this part (an SSE replay after
+            // a reconnect): nothing new.
             return "";
         }
         if (previousText && nextChunk.startsWith(previousText)) {
+            // The "delta" actually carries the accumulated part text: keep the tail.
             this.emittedTextByPartId.set(partId, nextChunk);
             return nextChunk.slice(previousText.length);
         }
+        // Plain incremental delta: append. Duplicated fragments that legitimately
+        // occur in model output (repeated words, table separators, markdown
+        // rules) must still be forwarded, so there is deliberately no
+        // suffix-based dedup here — it silently truncated real content.
         this.emittedTextByPartId.set(partId, `${previousText}${nextChunk}`);
         return nextChunk;
     }
@@ -2419,18 +2515,31 @@ export class OpenCodeServerAdapter {
         if (!key) {
             return false;
         }
+        // Frame-id keys identify one exact server event, so any repeat — even on
+        // the same stream (SSE replay) — is a duplicate; the wide TTL absorbs
+        // reconnect replays. Synthetic keys still rely on the narrow cross-stream
+        // window only, because they cannot distinguish a replay from a legitimate
+        // repeated payload.
+        const idKeyTtlMs = 30_000;
+        const isIdKey = key.startsWith("evt:");
+        const ttlMs = isIdKey ? idKeyTtlMs : OPENCODE_DUPLICATE_EVENT_TTL_MS;
         const now = Date.now();
-        const cutoff = now - OPENCODE_DUPLICATE_EVENT_TTL_MS;
         for (const [candidateKey, observed] of this.recentSdkEventObservations.entries()) {
-            if (observed.observedAtMs < cutoff) {
+            if (observed.observedAtMs < now - idKeyTtlMs) {
                 this.recentSdkEventObservations.delete(candidateKey);
             }
         }
         const previous = this.recentSdkEventObservations.get(key);
         this.recentSdkEventObservations.set(key, { streamName, observedAtMs: now });
-        return Boolean(previous && previous.streamName !== streamName && previous.observedAtMs >= cutoff);
+        return Boolean(previous &&
+            previous.observedAtMs >= now - ttlMs &&
+            (isIdKey || previous.streamName !== streamName));
     }
     getDuplicateSdkEventKey(event) {
+        // Exact frame ids (when the stream provides them) dedupe precisely.
+        if (typeof event.id === "string" && event.id) {
+            return `evt:${event.id}`;
+        }
         const type = this.normalizeEventType(event.type);
         const payload = this.extractEventPayload(event);
         if (!isRecord(payload)) {

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

@@ -636,6 +636,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 +686,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-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-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}`);