cli-wechat-bridge 1.1.6 → 1.1.8

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

@@ -7,7 +7,8 @@ import { normalizeOutput, nowIso, summarizeOutput, truncatePreview, } from "../c
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import * as shared from "./bridge-adapters.shared.js";
-import { requestCodexVisibleThreadSwitch } from "../companion/codex-visible-client-link.js";
+import { requestCodexVisibleClientShutdown, requestCodexVisibleThreadSwitch, } from "../companion/codex-visible-client-link.js";
+import { readLocalCompanionEndpoint } from "../companion/local-companion-link.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
 export function parseCodexCliVersion(output) {
@@ -21,7 +22,7 @@ export function isCodexVersionInCompatibilityRange(version) {
     }
     const major = parts[0] ?? -1;
     const minor = parts[1] ?? -1;
-    return major === 0 && minor >= 149 && minor <= 151;
+    return major === 0 && minor >= 149 && minor <= 155;
 }
 const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexDynamicToolCallFailureResponse, buildCodexMcpServerElicitationDeclineResponse, buildCodexPermissionsRequestApprovalResponse, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getCodexApprovalAutoResponse, getCodexWechatOutboundAttachmentDenyMessage, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
 const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
@@ -78,6 +79,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     appServerAuthToken = null;
     appServerAuthTokenFilePath = null;
     rpcSocket = null;
+    lastRpcCloseDetail = "";
     rpcShuttingDown = false;
     rpcReconnectPromise = null;
     cleanPanelExitInProgress = false;
@@ -86,6 +88,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     subscribedThreadIds = new Set();
     pendingThreadSubscriptions = new Map();
     sharedThreadId = null;
+    previousCollaborationMode = null;
     announcedThreadId = null;
     localThreadFollowBlockedUntilMs = 0;
     pendingThreadStatusChecks = new Map();
@@ -182,6 +185,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw err;
         }
     }
+    async prepareVisibleClientSession() {
+        if (this.isNativePanelMode() || this.sharedThreadId) {
+            return Boolean(this.sharedThreadId);
+        }
+        const threadId = await this.ensureThreadStarted();
+        return Boolean(threadId);
+    }
     buildSpawnArgs() {
         if (!this.appServerPort) {
             throw new Error("Codex app-server is not ready.");
@@ -248,6 +258,74 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         await this.resumeVisibleSharedThread(threadId);
     }
+    async listModels() {
+        if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
+            throw new Error("Codex model selection requires an active app-server thread.");
+        }
+        const response = await this.sendRpcRequest("model/list", { includeHidden: false });
+        const data = isRecord(response) && Array.isArray(response.data) ? response.data : [];
+        const current = await this.readCodexThreadSettings();
+        const models = data.flatMap((item) => {
+            if (!isRecord(item))
+                return [];
+            const id = typeof item.id === "string" ? item.id : typeof item.model === "string" ? item.model : "";
+            if (!id)
+                return [];
+            const displayName = typeof item.displayName === "string" ? item.displayName : id;
+            const efforts = Array.isArray(item.supportedReasoningEfforts)
+                ? item.supportedReasoningEfforts.filter((value) => typeof value === "string")
+                : undefined;
+            return [{ id, displayName, isCurrent: id === current.model, supportedReasoningEfforts: efforts }];
+        });
+        return models;
+    }
+    async selectModel(modelId) {
+        const models = await this.listModels();
+        const selected = models.find((model) => model.id === modelId);
+        if (!selected)
+            throw new Error(`Codex model ${modelId} is not available.`);
+        await this.sendRpcRequest("thread/settings/update", { threadId: this.sharedThreadId, model: selected.id });
+        return selected;
+    }
+    async setPlanMode(enabled) {
+        if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
+            throw new Error("Codex plan mode requires an active app-server thread.");
+        }
+        const settings = await this.readCodexThreadSettings();
+        if (enabled) {
+            const response = await this.sendRpcRequest("collaborationMode/list", {});
+            const modes = isRecord(response) && Array.isArray(response.data) ? response.data : [];
+            const plan = modes.find((item) => isRecord(item) && (item.mode === "plan" || item.name?.toString().toLowerCase() === "plan"));
+            if (!isRecord(plan))
+                throw new Error("Codex plan mode is not available in this app-server.");
+            this.previousCollaborationMode = isRecord(settings.collaborationMode) ? settings.collaborationMode : null;
+            const mode = typeof plan.mode === "string" ? plan.mode : "plan";
+            const model = typeof plan.model === "string" ? plan.model : settings.model;
+            const effort = plan.reasoning_effort ?? plan.reasoningEffort ?? null;
+            await this.sendRpcRequest("thread/settings/update", {
+                threadId: this.sharedThreadId,
+                collaborationMode: { mode, settings: { model, reasoning_effort: effort, developer_instructions: null } },
+            });
+            return true;
+        }
+        const previous = this.previousCollaborationMode ?? {
+            mode: "default",
+            settings: { model: settings.model, reasoning_effort: settings.effort ?? null, developer_instructions: null },
+        };
+        await this.sendRpcRequest("thread/settings/update", {
+            threadId: this.sharedThreadId,
+            collaborationMode: previous,
+        });
+        this.previousCollaborationMode = null;
+        return false;
+    }
+    async readCodexThreadSettings() {
+        const response = await this.sendRpcRequest("thread/read", { threadId: this.sharedThreadId, includeTurns: false });
+        const thread = isRecord(response) && isRecord(response.thread) ? response.thread : null;
+        if (!thread || typeof thread.model !== "string")
+            throw new Error("Codex did not return the current thread model.");
+        return { model: thread.model, effort: thread.reasoningEffort, collaborationMode: thread.collaborationMode };
+    }
     async interrupt() {
         if (this.usesRpcTurnTransport()) {
             return await this.interruptPanelTurn();
@@ -315,6 +393,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return true;
     }
     async dispose() {
+        await this.shutdownVisibleClient();
         this.resetTurnTracking({ preserveThread: false });
         if (this.isEmbeddedCliMode()) {
             this.detachLocalInputForwarding();
@@ -346,6 +425,25 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         await this.stopAppServer();
     }
+    async shutdownVisibleClient() {
+        const endpoint = readLocalCompanionEndpoint(this.options.cwd, { adapter: "codex" });
+        if (!endpoint?.companionPid ||
+            endpoint.instanceId !== this.localClientInstanceId ||
+            !endpoint.codexControlPort ||
+            !endpoint.codexControlToken) {
+            return;
+        }
+        try {
+            await requestCodexVisibleClientShutdown({
+                cwd: this.options.cwd,
+                instanceId: endpoint.instanceId,
+            });
+        }
+        catch {
+            // The visible client may already be exiting. Its endpoint is cleared
+            // by the supervisor when the child process finishes.
+        }
+    }
     getLocalClientEndpoint() {
         if (!this.isHeadlessRuntimeMode() || !this.appServerPort || !this.appServerAuthToken) {
             return null;
@@ -1192,8 +1290,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         socket.addEventListener("message", (event) => {
             this.handleRpcMessageData(event.data);
         });
-        socket.addEventListener("close", () => {
-            this.handleRpcSocketClosed();
+        socket.addEventListener("close", (event) => {
+            this.handleRpcSocketClosed(event.code, event.reason);
         });
     }
     async disconnectRpcClient() {
@@ -1231,13 +1329,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         });
         this.rpcShuttingDown = false;
     }
-    handleRpcSocketClosed() {
+    handleRpcSocketClosed(code, reason) {
         const expectedShutdown = shouldSuppressCodexTransportFatalError({
             transportShuttingDown: this.rpcShuttingDown,
             shuttingDown: this.shuttingDown,
             cleanPanelExitInProgress: this.cleanPanelExitInProgress,
         });
         this.rpcSocket = null;
+        this.lastRpcCloseDetail = `close_code=${code ?? "unknown"}${reason ? ` reason=${truncatePreview(reason, 240)}` : ""}`;
         this.subscribedThreadIds.clear();
         this.rejectPendingRpcRequests("Codex websocket connection closed.");
         this.rpcShuttingDown = false;
@@ -1269,7 +1368,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 const details = this.describeAppServerLog();
                 this.emit({
                     type: "fatal_error",
-                    message: `codex app-server websocket closed unexpectedly.${details}`,
+                    message: `codex app-server websocket closed unexpectedly (${this.lastRpcCloseDetail || "no close details"}).${details}`,
                     timestamp: nowIso(),
                 });
                 this.terminateCodexClient();
@@ -1307,7 +1406,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             }
             this.emit({
                 type: "fatal_error",
-                message: `codex app-server websocket closed unexpectedly and could not reconnect: ${lastError}.${details}`,
+                message: `codex app-server websocket closed unexpectedly and could not reconnect (${this.lastRpcCloseDetail || "no close details"}): ${lastError}.${details}`,
                 timestamp: nowIso(),
             });
             this.terminateCodexClient();
@@ -1460,6 +1559,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (typeof thread.parentThreadId === "string") {
             throw new Error(`Codex thread ${targetThreadId} is a subagent thread and cannot be resumed.`);
         }
+        if (thread.canAcceptDirectInput === false) {
+            throw new Error(`Codex thread ${targetThreadId} is owned by a parent agent and cannot accept direct input.`);
+        }
         if (thread.ephemeral === true) {
             throw new Error(`Codex thread ${targetThreadId} is ephemeral and cannot be resumed.`);
         }
@@ -1483,6 +1585,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (typeof thread.parentThreadId === "string") {
             throw new Error(`Codex thread ${targetThreadId} is a subagent thread.`);
         }
+        if (thread.canAcceptDirectInput === false) {
+            throw new Error(`Codex thread ${targetThreadId} is owned by a parent agent.`);
+        }
         if (thread.ephemeral === true) {
             throw new Error(`Codex thread ${targetThreadId} is ephemeral.`);
         }

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

@@ -15,7 +15,7 @@ const { CODEX_APP_SERVER_HOST, INTERRUPT_SETTLE_DELAY_MS, buildCliEnvironment, b
  * the script path contains spaces: node-pty quotes the already-quoted path,
  * making cmd.exe treat the literal quotes as part of the filename.
  */
-function unwrapCmdExeForPty(rawTarget) {
+export function unwrapCmdExeForPty(rawTarget) {
     if (process.platform !== "win32") {
         return rawTarget;
     }
@@ -166,6 +166,15 @@ export class LocalCompanionProxyAdapter {
             command: "create_session",
         });
     }
+    async listModels() {
+        return await this.sendRequest({ command: "list_models" });
+    }
+    async selectModel(modelId) {
+        return await this.sendRequest({ command: "select_model", modelId });
+    }
+    async setPlanMode(enabled) {
+        return await this.sendRequest({ command: "set_plan_mode", enabled });
+    }
     async interrupt() {
         const result = await this.sendRequest({
             command: "interrupt",
@@ -612,6 +621,15 @@ export class AbstractPtyAdapter {
     setEventSink(sink) {
         this.eventSink = sink;
     }
+    async listModels() {
+        throw new Error(`/${this.options.kind} model selection is not available.`);
+    }
+    async selectModel(_modelId) {
+        throw new Error(`/${this.options.kind} model selection is not available.`);
+    }
+    async setPlanMode(_enabled) {
+        throw new Error(`/${this.options.kind} plan mode is not available.`);
+    }
     async start() {
         if (this.pty) {
             return;

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

@@ -85,6 +85,139 @@ export class OpenCodeServerAdapter {
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
     pendingQuestion = null;
+    previousAgentBySession = new Map();
+    async listModels() {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const models = await this.listControlModels();
+        return models.map((model) => ({
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: session.model?.providerID === model.providerID &&
+                session.model.id === model.modelID,
+        }));
+    }
+    async selectModel(modelId) {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const models = await this.listControlModels();
+        const target = models.find((model) => model.id === modelId);
+        if (!target) {
+            throw new Error("This OpenCode model is no longer available. Send /model again.");
+        }
+        const currentVariant = session.model?.variant;
+        const variant = currentVariant && currentVariant !== "default" && target.variants.includes(currentVariant)
+            ? currentVariant
+            : "default";
+        const result = await this.client.v2.session.switchModel({
+            sessionID: session.id,
+            model: {
+                providerID: target.providerID,
+                id: target.modelID,
+                variant,
+            },
+        });
+        this.unwrapOrThrow(result);
+        const updated = await this.getSessionForCurrentDirectory(session.id);
+        if (!updated ||
+            updated.model?.providerID !== target.providerID ||
+            updated.model.id !== target.modelID ||
+            (updated.model.variant ?? "default") !== variant) {
+            throw new Error("OpenCode did not confirm the selected model.");
+        }
+        return { id: target.id, displayName: target.displayName, isCurrent: true };
+    }
+    async setPlanMode(enabled) {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const agents = await this.listPrimaryAgents();
+        const planAgent = agents.find((agent) => agent.name === "plan");
+        if (!planAgent) {
+            throw new Error("OpenCode primary agent 'plan' is not available.");
+        }
+        const currentAgent = session.agent ?? agents[0]?.name;
+        if (!currentAgent) {
+            throw new Error("OpenCode did not return any primary agents.");
+        }
+        if (enabled && currentAgent === "plan") {
+            return true;
+        }
+        if (!enabled && currentAgent !== "plan") {
+            this.previousAgentBySession.delete(session.id);
+            return false;
+        }
+        const previousAgent = this.previousAgentBySession.get(session.id);
+        const target = enabled
+            ? "plan"
+            : agents.some((agent) => agent.name === previousAgent)
+                ? previousAgent
+                : agents.find((agent) => agent.name === "build")?.name ??
+                    agents.find((agent) => agent.name !== "plan")?.name;
+        if (!target) {
+            throw new Error("OpenCode did not return an agent that can replace plan mode.");
+        }
+        const result = await this.client.v2.session.switchAgent({
+            sessionID: session.id,
+            agent: target,
+        });
+        this.unwrapOrThrow(result);
+        const updated = await this.getSessionForCurrentDirectory(session.id);
+        if (!updated || updated.agent !== target) {
+            throw new Error("OpenCode did not confirm the selected agent.");
+        }
+        if (enabled) {
+            this.previousAgentBySession.set(session.id, currentAgent);
+        }
+        else {
+            this.previousAgentBySession.delete(session.id);
+        }
+        return enabled;
+    }
+    assertRemoteControlReady() {
+        if (!this.client) {
+            throw new Error("OpenCode is not running.");
+        }
+        if (this.state.status === "busy") {
+            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.pendingPermission) {
+            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+        }
+        if (this.pendingQuestion) {
+            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+        }
+    }
+    async ensureControlSession() {
+        const session = await this.ensureSession();
+        if (session.id !== this.activeSessionId) {
+            this.switchSharedSession(session, {
+                source: "wechat",
+                reason: "wechat_resume",
+                syncVisible: true,
+                forceVisibleSync: true,
+            });
+        }
+        return session;
+    }
+    async listPrimaryAgents() {
+        if (!this.client)
+            throw new Error("OpenCode is not running.");
+        const agents = this.unwrapOrThrow(await this.client.app.agents({
+            directory: this.options.cwd,
+            workspace: this.activeWorkspaceId ?? undefined,
+        }, { signal: AbortSignal.timeout(10_000) }));
+        return agents.filter((agent) => agent.mode !== "subagent" && !agent.hidden);
+    }
+    async listControlModels() {
+        if (!this.client)
+            throw new Error("OpenCode is not running.");
+        const providers = this.unwrapOrThrow(await this.client.provider.list({ directory: this.options.cwd, workspace: this.activeWorkspaceId ?? undefined }, { signal: AbortSignal.timeout(10_000) }));
+        return providers.all.filter((provider) => providers.connected.includes(provider.id)).flatMap((provider) => Object.entries(provider.models).filter(([id, model]) => model.status !== "deprecated" && !(provider.id === "opencode" && id.includes("-nano"))).map(([id, model]) => ({
+            id: `${provider.id}/${id}`, displayName: `${model.name || id} (${provider.name})`,
+            providerID: provider.id, modelID: id,
+            variants: Object.keys(model.variants ?? {}),
+        })));
+    }
     constructor(options) {
         this.options = options;
         this.state = {
@@ -170,10 +303,21 @@ export class OpenCodeServerAdapter {
         this.recordPendingWechatPromptMirrorSuppression(session.id, normalized);
         this.beginTrackedTurn(normalized, "wechat");
         try {
+            const selection = await this.getSessionForCurrentDirectory(session.id) ?? session;
             const result = await this.client.session.promptAsync({
                 sessionID: session.id,
                 directory: this.options.cwd,
                 workspace: session.workspaceID ?? this.activeWorkspaceId ?? undefined,
+                ...(selection.agent ? { agent: selection.agent } : {}),
+                ...(selection.model
+                    ? {
+                        model: {
+                            providerID: selection.model.providerID,
+                            modelID: selection.model.id,
+                        },
+                        variant: selection.model.variant ?? "default",
+                    }
+                    : {}),
                 parts: [{ type: "text", text: normalized }],
             });
             if (result.error !== undefined) {
@@ -411,6 +555,7 @@ export class OpenCodeServerAdapter {
         this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.clearObservedMessageTracking();
         this.recentSdkEventObservations.clear();
+        this.previousAgentBySession.clear();
         this.outputBatcher.clear();
         this.clearStreamedPartState();
         this.clearPendingPermissionState();
@@ -1535,7 +1680,11 @@ export class OpenCodeServerAdapter {
             return;
         }
         const sessionId = this.extractSessionId(properties);
-        if (!sessionId || sessionId !== this.activeSessionId) {
+        if (!sessionId) {
+            return;
+        }
+        this.previousAgentBySession.delete(sessionId);
+        if (sessionId !== this.activeSessionId) {
             return;
         }
         this.clearTrackedTurnForLocalSessionSwitch();

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

@@ -356,6 +356,41 @@ export class PiTuiAdapter {
             this.pendingSessionSwitch = null;
         }
     }
+    async listModels() {
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Wait for the current turn before listing models.");
+        }
+        const response = await this.sendCommand("list_models");
+        if (!isRecord(response.data) || !Array.isArray(response.data.models)) {
+            throw new Error("Pi TUI returned an invalid model list.");
+        }
+        return response.data.models
+            .filter((model) => isRecord(model))
+            .filter((model) => typeof model.id === "string" && typeof model.displayName === "string")
+            .map((model) => ({
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: model.isCurrent === true,
+        }));
+    }
+    async selectModel(modelId) {
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Wait for the current turn before switching models.");
+        }
+        const response = await this.sendCommand("select_model", { modelId });
+        if (!isRecord(response.data) || !isRecord(response.data.model)) {
+            throw new Error("Pi TUI returned an invalid selected model.");
+        }
+        const model = response.data.model;
+        if (typeof model.id !== "string" || typeof model.displayName !== "string") {
+            throw new Error("Pi TUI returned an invalid selected model.");
+        }
+        return {
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: true,
+        };
+    }
     async interrupt() {
         if (!this.socket || this.state.status !== "busy") {
             return false;
@@ -569,6 +604,10 @@ export class PiTuiAdapter {
             else if (this.currentAssistantText) {
                 this.emit({ type: "final_reply", text: this.currentAssistantText, timestamp: nowIso() });
             }
+            // Mirror the other adapters: a settled turn always reports completion so
+            // bridge/daemon ownership state is released even when the turn produced
+            // no visible reply.
+            this.emit({ type: "task_complete", timestamp: nowIso() });
             this.state.lastOutputAt = nowIso();
             this.clearActiveTurn();
             this.setStatus("idle");

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

@@ -113,7 +113,7 @@ function normalizeBridgeProcessRecord(value) {
     }
     return record;
 }
-export function parseWindowsBridgeProcessProbeOutput(stdout, currentPid = process.pid) {
+function parseWindowsProcessProbeRecords(stdout) {
     const trimmed = stdout.trim();
     if (!trimmed) {
         return [];
@@ -128,7 +128,13 @@ export function parseWindowsBridgeProcessProbeOutput(stdout, currentPid = proces
     const values = Array.isArray(parsed) ? parsed : [parsed];
     return values
         .map(normalizeBridgeProcessRecord)
-        .filter((record) => Boolean(record))
+        .filter((record) => Boolean(record));
+}
+export function parseWindowsProcessRecordProbeOutput(stdout, currentPid = process.pid) {
+    return (parseWindowsProcessProbeRecords(stdout).find((record) => record.pid !== currentPid) ?? null);
+}
+export function parseWindowsBridgeProcessProbeOutput(stdout, currentPid = process.pid) {
+    return parseWindowsProcessProbeRecords(stdout)
         .filter((record) => record.pid !== currentPid && isWechatBridgeCommandLine(record.commandLine));
 }
 export function parsePosixBridgeProcessProbeOutput(stdout, currentPid = process.pid) {
@@ -195,10 +201,37 @@ export function listPeerBridgeProcesses(currentPid = process.pid) {
         ? listWindowsBridgeProcesses(currentPid)
         : listPosixBridgeProcesses(currentPid);
 }
+function getWindowsProcessRecordByPid(pid, currentPid = process.pid) {
+    const probe = spawnSync("powershell.exe", [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        [
+            "$ErrorActionPreference='Stop';",
+            `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}'`,
+            "| Select-Object ProcessId,ParentProcessId,Name,CommandLine",
+            "| ConvertTo-Json -Compress",
+        ].join(" "),
+    ], {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 8_000,
+    });
+    if (probe.status !== 0 || typeof probe.stdout !== "string") {
+        return null;
+    }
+    return parseWindowsProcessRecordProbeOutput(probe.stdout, currentPid);
+}
 export function getProcessRecordByPid(pid, currentPid = process.pid) {
     if (!Number.isInteger(pid) || pid <= 0 || pid === currentPid) {
         return null;
     }
+    if (process.platform === "win32") {
+        return getWindowsProcessRecordByPid(pid, currentPid);
+    }
     return listAllProcessesRaw(currentPid).find((record) => record.pid === pid) ?? null;
 }
 export function listWechatDaemonProcesses(params = {}) {

package/dist/bridge/bridge-state.js

@@ -79,6 +79,9 @@ export function normalizeBridgeLockPayload(value) {
         startedAt: record.startedAt,
         lifecycle: record.lifecycle === "companion_bound" ? "companion_bound" : "persistent",
         legacyLifecycleFallback: hasExplicitLifecycle ? undefined : true,
+        ...(record.channelId === "wechat" || record.channelId === "wecom"
+            ? { channelId: record.channelId }
+            : {}),
     };
 }
 export function readBridgeLockFile() {
@@ -148,11 +151,13 @@ function buildLockConflictError(lock) {
  * 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)) {
+export function classifyLockHolderProcess(pid, dependencies = {}) {
+    const isProcessAlive = dependencies.isPidAlive ?? isPidAlive;
+    const getProcessRecord = dependencies.getProcessRecordByPid ?? getProcessRecordByPid;
+    if (!isProcessAlive(pid)) {
         return "unknown";
     }
-    const record = getProcessRecordByPid(pid);
+    const record = getProcessRecord(pid);
     if (!record) {
         return "unknown";
     }
@@ -200,6 +205,7 @@ export class BridgeStateStore {
             cwd: options.cwd,
             startedAt: new Date(this.bridgeStartedAtMs).toISOString(),
             lifecycle: options.lifecycle,
+            channelId: options.channelId,
         };
         this.acquireLock();
         const shouldRestoreSessionState = options.sessionStartMode !== "new";
@@ -231,6 +237,7 @@ export class BridgeStateStore {
             resumeConversationId: persistedResumeConversationId,
             transcriptPath: persistedTranscriptPath,
             lastActivityAt: persisted?.lastActivityAt,
+            channelId: options.channelId,
             pendingConfirmation: null,
             pendingUserInput: null,
         };