cli-wechat-bridge 1.1.4 → 1.1.5

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

@@ -1,7 +1,12 @@
 import { spawn as spawnChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 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 { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, buildOneTimeCode, isWechatOutboundAttachmentMutationTool, isWechatOutboundAttachmentWriteCommand, normalizeOutput, nowIso, truncatePreview, OutputBatcher, } from "./bridge-utils.js";
 const OPENCODE_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(process.env.WECHAT_OPENCODE_DEBUG ?? "");
 const OPENCODE_DUPLICATE_EVENT_TTL_MS = 150;
@@ -14,6 +19,11 @@ 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";
 const OPENCODE_MAXIMUM_SUPPORTED_MAJOR = 2;
+const OPENCODE_TUI_ROUTE_READY_TIMEOUT_MS = 10_000;
+const OPENCODE_TUI_ROUTE_MAX_BUFFER_SIZE = 1024 * 1024;
+const MODULE_FILE = fileURLToPath(import.meta.url);
+const MODULE_DIR = path.dirname(MODULE_FILE);
+const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".js";
 /* ------------------------------------------------------------------ */
 /*  Adapter                                                            */
 /* ------------------------------------------------------------------ */
@@ -61,6 +71,16 @@ export class OpenCodeServerAdapter {
     recentWechatPromptMirrorSuppressions = [];
     recentSdkEventObservations = new Map();
     suppressedTuiSessionSelect = null;
+    tuiRouteServer = null;
+    tuiRouteSocket = null;
+    tuiRouteToken = "";
+    tuiRoutePort = 0;
+    tuiRouteConfigDir = null;
+    tuiRouteConfigPath = null;
+    visibleTuiSessionId = null;
+    tuiRouteStateReceived = false;
+    expectedVisibleTuiSessionId = null;
+    localSessionFollowChain = Promise.resolve();
     lastMirroredLocalPrompt = null;
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
@@ -99,7 +119,9 @@ export class OpenCodeServerAdapter {
             await this.initializeSessions();
             this.startSseListener();
             if (this.options.renderMode === "companion") {
+                await this.startTuiRouteBridge();
                 await this.startNativeClient();
+                await this.waitForTuiRouteBridgeReady();
                 await this.syncVisibleSessionToShared({ force: true, retry: true });
             }
             else {
@@ -169,48 +191,75 @@ export class OpenCodeServerAdapter {
     }
     async listResumeSessions(limit = 10) {
         if (!this.client) {
-            return [];
+            throw new Error("OpenCode is not running yet.");
         }
-        let sessions;
         try {
-            sessions = this.unwrapOrThrow(await this.client.session.list()) ?? [];
+            const sessions = this.unwrapOrThrow(await this.client.session.list({
+                directory: this.options.cwd,
+                workspace: this.activeWorkspaceId ?? undefined,
+                roots: true,
+                limit: Math.max(1, limit),
+            })) ?? [];
+            return sessions
+                .filter((session) => !session.parentID && this.isCurrentDirectorySession(session))
+                .sort((left, right) => right.time.updated - left.time.updated)
+                .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",
+                };
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to list OpenCode sessions: ${describeUnknownError(error)}`, {
+                cause: error,
+            });
         }
-        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) {
         if (!this.client) {
             throw new Error("OpenCode is not running yet.");
         }
+        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.");
+        }
+        if (this.state.status === "busy") {
+            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.state.status !== "idle") {
+            throw new Error(`OpenCode cannot switch sessions while its status is ${this.state.status}.`);
+        }
         const session = await this.getSessionForCurrentDirectory(sessionId, []);
         if (!session) {
             throw new Error(`No OpenCode session ${sessionId} was found for ${this.options.cwd}.`);
         }
+        const sessionStatuses = this.unwrapOrThrow(await this.client.session.status({
+            workspace: session.workspaceID ?? this.activeWorkspaceId ?? undefined,
+        }));
+        const targetStatus = sessionStatuses[session.id];
+        if (targetStatus && targetStatus.type !== "idle") {
+            const statusLabel = targetStatus.type === "retry" ? "retrying" : "busy";
+            throw new Error(`OpenCode session ${session.id} is still ${statusLabel}. Wait for it to become idle before resuming it.`);
+        }
+        await this.selectVisibleSessionForResume(session);
         this.switchSharedSession(session, {
             source: "wechat",
             reason: "wechat_resume",
             notify: true,
             clearTrackedTurn: true,
-            syncVisible: true,
-            forceVisibleSync: true,
+            syncVisible: false,
         });
     }
     async createSession() {
@@ -392,6 +441,7 @@ export class OpenCodeServerAdapter {
                 }
             }
         }
+        await this.stopTuiRouteBridge();
         if (this.serverProcess) {
             const proc = this.serverProcess;
             this.serverProcess = null;
@@ -413,6 +463,173 @@ export class OpenCodeServerAdapter {
         this.state.startedAt = undefined;
     }
     /* ---- Server management ---- */
+    async startTuiRouteBridge() {
+        this.tuiRouteToken = randomBytes(24).toString("hex");
+        this.tuiRouteStateReceived = false;
+        this.visibleTuiSessionId = null;
+        const server = net.createServer((socket) => this.acceptTuiRouteSocket(socket));
+        this.tuiRouteServer = server;
+        this.tuiRoutePort = await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, OPENCODE_SERVER_HOST, () => {
+                server.removeListener("error", reject);
+                const address = server.address();
+                if (!address || typeof address === "string") {
+                    reject(new Error("OpenCode TUI route bridge did not expose a local port."));
+                    return;
+                }
+                resolve(address.port);
+            });
+        });
+        const workspaceDir = ensureWorkspaceChannelDir(this.options.cwd).workspaceDir;
+        const configDir = fs.mkdtempSync(path.join(workspaceDir, "opencode-tui-route-"));
+        const configPath = path.join(configDir, "tui.json");
+        const pluginPath = path.join(MODULE_DIR, "..", "companion", `opencode-tui-bridge-plugin${RUNTIME_ENTRY_EXTENSION}`);
+        if (!fs.existsSync(pluginPath)) {
+            throw new Error(`OpenCode TUI bridge plugin was not found: ${pluginPath}`);
+        }
+        fs.writeFileSync(configPath, `${JSON.stringify({
+            plugin: [
+                [
+                    pluginPath,
+                    {
+                        port: this.tuiRoutePort,
+                        token: this.tuiRouteToken,
+                    },
+                ],
+            ],
+        }, null, 2)}\n`, "utf8");
+        this.tuiRouteConfigDir = configDir;
+        this.tuiRouteConfigPath = configPath;
+    }
+    acceptTuiRouteSocket(socket) {
+        socket.setEncoding("utf8");
+        socket.setNoDelay(true);
+        let buffer = "";
+        let authenticated = false;
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            if (buffer.length > OPENCODE_TUI_ROUTE_MAX_BUFFER_SIZE) {
+                socket.destroy();
+                return;
+            }
+            while (true) {
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex < 0) {
+                    return;
+                }
+                const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+                buffer = buffer.slice(newlineIndex + 1);
+                if (!line.trim()) {
+                    continue;
+                }
+                try {
+                    const frame = JSON.parse(line);
+                    if (!isRecord(frame)) {
+                        continue;
+                    }
+                    if (!authenticated) {
+                        if (frame.type !== "hello" || frame.token !== this.tuiRouteToken) {
+                            socket.destroy();
+                            return;
+                        }
+                        authenticated = true;
+                        const previousSocket = this.tuiRouteSocket;
+                        this.tuiRouteSocket = socket;
+                        if (previousSocket && previousSocket !== socket) {
+                            previousSocket.destroy();
+                        }
+                        continue;
+                    }
+                    this.handleTuiRouteFrame(frame);
+                }
+                catch {
+                    // Ignore malformed plugin frames and keep the visible TUI alive.
+                }
+            }
+        });
+        socket.once("close", () => {
+            if (this.tuiRouteSocket === socket) {
+                this.tuiRouteSocket = null;
+            }
+        });
+        socket.once("error", () => {
+            // Close handling owns route observer cleanup.
+        });
+    }
+    handleTuiRouteFrame(frame) {
+        if (frame.type !== "route_state") {
+            return;
+        }
+        const sessionId = typeof frame.sessionId === "string" ? frame.sessionId : null;
+        this.tuiRouteStateReceived = true;
+        this.visibleTuiSessionId = sessionId;
+        if (!sessionId ||
+            sessionId === this.activeSessionId ||
+            sessionId === this.expectedVisibleTuiSessionId) {
+            return;
+        }
+        this.queueLocalVisibleSessionFollow(sessionId);
+    }
+    async waitForTuiRouteBridgeReady() {
+        const deadline = Date.now() + OPENCODE_TUI_ROUTE_READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (this.tuiRouteSocket && this.tuiRouteStateReceived) {
+                return;
+            }
+            await delay(100);
+        }
+        throw new Error("The OpenCode TUI route bridge did not become ready. OpenCode 1.18 or newer with TUI plugin support is required.");
+    }
+    async waitForVisibleTuiSession(sessionId) {
+        const deadline = Date.now() + OPENCODE_TUI_ROUTE_READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (!this.tuiRouteSocket) {
+                throw new Error("The visible OpenCode TUI route bridge disconnected.");
+            }
+            if (this.visibleTuiSessionId === sessionId) {
+                return;
+            }
+            await delay(100);
+        }
+        throw new Error(`The visible OpenCode TUI did not confirm session ${sessionId} before the timeout.`);
+    }
+    async stopTuiRouteBridge() {
+        this.tuiRouteSocket?.destroy();
+        this.tuiRouteSocket = null;
+        if (this.tuiRouteServer) {
+            const server = this.tuiRouteServer;
+            this.tuiRouteServer = null;
+            if (server.listening) {
+                await new Promise((resolve) => {
+                    try {
+                        server.close(() => resolve());
+                    }
+                    catch {
+                        resolve();
+                    }
+                });
+            }
+        }
+        const configDir = this.tuiRouteConfigDir;
+        this.tuiRouteConfigDir = null;
+        this.tuiRouteConfigPath = null;
+        this.tuiRoutePort = 0;
+        this.tuiRouteToken = "";
+        this.tuiRouteStateReceived = false;
+        this.visibleTuiSessionId = null;
+        this.expectedVisibleTuiSessionId = null;
+        if (configDir) {
+            const workspaceDir = ensureWorkspaceChannelDir(this.options.cwd).workspaceDir;
+            const resolvedConfigDir = path.resolve(configDir);
+            const resolvedWorkspaceDir = path.resolve(workspaceDir);
+            const isManagedConfigDir = resolvedConfigDir.startsWith(`${resolvedWorkspaceDir}${path.sep}`) &&
+                path.basename(resolvedConfigDir).startsWith("opencode-tui-route-");
+            if (isManagedConfigDir) {
+                fs.rmSync(resolvedConfigDir, { recursive: true, force: true });
+            }
+        }
+    }
     async startServerProcess() {
         const env = buildCliEnvironment(this.options.kind);
         this.serverPassword = randomBytes(24).toString("hex");
@@ -515,6 +732,9 @@ export class OpenCodeServerAdapter {
         });
     }
     async buildNativeAttachArgs() {
+        if ((this.options.extraCliArgs ?? []).includes("--pure")) {
+            throw new Error("OpenCode --pure cannot be used with the WeChat bridge because local session following requires the managed TUI plugin.");
+        }
         const args = ["attach", this.getServerUrl()];
         args.push("--dir", this.options.cwd);
         const sessionId = this.activeSessionId;
@@ -526,6 +746,17 @@ export class OpenCodeServerAdapter {
     }
     buildNativeClientEnv() {
         const env = buildCliEnvironment(this.options.kind);
+        if (this.tuiRouteConfigDir && this.tuiRouteConfigPath) {
+            if (env.OPENCODE_CONFIG_DIR && env.OPENCODE_TUI_CONFIG) {
+                throw new Error("OpenCode cannot inject the managed TUI session plugin while both OPENCODE_CONFIG_DIR and OPENCODE_TUI_CONFIG are set.");
+            }
+            if (env.OPENCODE_CONFIG_DIR) {
+                env.OPENCODE_TUI_CONFIG = this.tuiRouteConfigPath;
+            }
+            else {
+                env.OPENCODE_CONFIG_DIR = this.tuiRouteConfigDir;
+            }
+        }
         if (this.serverPassword) {
             env.OPENCODE_SERVER_PASSWORD = this.serverPassword;
         }
@@ -881,6 +1112,10 @@ export class OpenCodeServerAdapter {
                 this.handleSessionUpdated(payload);
                 return;
             }
+            case "session.deleted": {
+                this.handleSessionDeleted(payload);
+                return;
+            }
             case "message.updated": {
                 // Full message update — not used for incremental text extraction.
                 // Text output comes from message.part.updated events.
@@ -916,7 +1151,6 @@ export class OpenCodeServerAdapter {
             }
             case "session.diff":
             case "session.diff.delta":
-            case "session.deleted":
             case "message.removed":
             case "permission.replied":
             case "tui.toast.show":
@@ -1287,13 +1521,7 @@ export class OpenCodeServerAdapter {
         }
         this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.logDebug(`[opencode-adapter:local-follow] session.created ${session.id}`);
-        this.switchSharedSession(session, {
-            source: "local",
-            reason: "local_follow",
-            notify: true,
-            clearTrackedTurn: true,
-            syncVisible: true,
-        });
+        this.queueLocalVisibleSessionFollow(session.id, session.workspaceID);
     }
     handleSessionUpdated(properties) {
         if (!isRecord(properties)) {
@@ -1302,6 +1530,32 @@ export class OpenCodeServerAdapter {
         const session = this.extractSessionReference(properties);
         this.syncTrackedSessionFromEvent(session, { allowLocalTurnFollow: false });
     }
+    handleSessionDeleted(properties) {
+        if (!isRecord(properties)) {
+            return;
+        }
+        const sessionId = this.extractSessionId(properties);
+        if (!sessionId || sessionId !== this.activeSessionId) {
+            return;
+        }
+        this.clearTrackedTurnForLocalSessionSwitch();
+        this.activeSessionId = null;
+        this.state.sharedSessionId = undefined;
+        this.state.sharedThreadId = undefined;
+        this.state.activeRuntimeSessionId = undefined;
+        this.suppressedTuiSessionSelect = null;
+        if (this.state.status !== "idle") {
+            this.setStatus("idle");
+        }
+        else {
+            this.emit({
+                type: "status",
+                status: "idle",
+                message: "The active OpenCode session was deleted locally.",
+                timestamp: nowIso(),
+            });
+        }
+    }
     handleMessageUpdated(properties) {
         if (!isRecord(properties)) {
             return;
@@ -1676,16 +1930,7 @@ export class OpenCodeServerAdapter {
         this.localPromptNoticeSent = false;
         this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.logDebug(`[opencode-adapter:local-follow] tui.session.select ${sessionId}`);
-        this.switchSharedSession({
-            id: sessionId,
-            workspaceID: this.extractWorkspaceId(properties) ?? undefined,
-        }, {
-            source: "local",
-            reason: "local_follow",
-            notify: true,
-            clearTrackedTurn: true,
-            syncVisible: true,
-        });
+        this.queueLocalVisibleSessionFollow(sessionId, this.extractWorkspaceId(properties) ?? undefined);
     }
     handleCommandExecuted(properties) {
         if (!isRecord(properties)) {
@@ -1698,16 +1943,7 @@ export class OpenCodeServerAdapter {
         const sessionId = this.extractSessionId(properties);
         if (sessionId) {
             this.logDebug(`[opencode-adapter:local-follow] command.executed ${name} -> ${sessionId}`);
-            this.switchSharedSession({
-                id: sessionId,
-                workspaceID: this.extractWorkspaceId(properties) ?? undefined,
-            }, {
-                source: "local",
-                reason: "local_follow",
-                notify: true,
-                clearTrackedTurn: true,
-                syncVisible: true,
-            });
+            this.queueLocalVisibleSessionFollow(sessionId, this.extractWorkspaceId(properties) ?? undefined);
             return;
         }
         this.markPendingLocalSessionCreateFollow();
@@ -2215,6 +2451,109 @@ export class OpenCodeServerAdapter {
             workspaceID: this.activeWorkspaceId ?? undefined,
         }, { force: options.force, retry: options.retry });
     }
+    queueLocalVisibleSessionFollow(sessionId, workspaceID) {
+        if (!this.client?.session?.get) {
+            this.switchSharedSession({ id: sessionId, workspaceID }, {
+                source: "local",
+                reason: "local_follow",
+                notify: true,
+                clearTrackedTurn: true,
+                syncVisible: false,
+            });
+            return;
+        }
+        const run = this.localSessionFollowChain.then(async () => {
+            await this.followLocalVisibleSession(sessionId, workspaceID);
+        });
+        this.localSessionFollowChain = run.catch((error) => {
+            this.logDebug(`[opencode-adapter:local-follow] failed for ${sessionId}: ${describeUnknownError(error)}`);
+        });
+    }
+    async followLocalVisibleSession(sessionId, workspaceID) {
+        if (this.shuttingDown || !this.client || sessionId === this.activeSessionId) {
+            return;
+        }
+        const session = await this.getSessionForCurrentDirectory(sessionId, []);
+        if (!session) {
+            throw new Error(`The locally selected OpenCode session ${sessionId} does not belong to ${this.options.cwd}.`);
+        }
+        if (workspaceID && !session.workspaceID) {
+            session.workspaceID = workspaceID;
+        }
+        const previousSessionId = this.activeSessionId;
+        const interruptedWechatTurn = Boolean(previousSessionId) &&
+            this.state.activeTurnOrigin === "wechat" &&
+            this.hasTrackedTurnState();
+        if (interruptedWechatTurn && previousSessionId) {
+            try {
+                const result = await this.client.session.abort({
+                    sessionID: previousSessionId,
+                    directory: this.options.cwd,
+                    workspace: this.activeWorkspaceId ?? undefined,
+                });
+                if (result.error !== undefined) {
+                    throw result.error;
+                }
+            }
+            catch (error) {
+                this.logDebug(`[opencode-adapter:local-follow] failed to abort ${previousSessionId}: ${describeUnknownError(error)}`);
+            }
+            this.failTrackedTurn("The active WeChat task was interrupted because the local OpenCode terminal switched sessions.");
+        }
+        else {
+            this.clearTrackedTurnForLocalSessionSwitch();
+        }
+        this.switchSharedSession(session, {
+            source: "local",
+            reason: "local_follow",
+            notify: true,
+            clearTrackedTurn: false,
+            syncVisible: false,
+        });
+    }
+    async selectVisibleSessionForResume(session) {
+        if (!this.client?.tui || this.options.renderMode !== "companion") {
+            throw new Error("The visible OpenCode companion is not connected.");
+        }
+        this.suppressedTuiSessionSelect = {
+            sessionId: session.id,
+            setAtMs: Date.now(),
+        };
+        this.expectedVisibleTuiSessionId = session.id;
+        let lastError;
+        let confirmed = false;
+        try {
+            let selected = false;
+            for (const delayMs of [0, ...OPENCODE_TUI_SELECT_RETRY_DELAYS_MS]) {
+                if (delayMs > 0) {
+                    await delay(delayMs);
+                }
+                try {
+                    await this.sendVisibleSessionSelection(session);
+                    selected = true;
+                    break;
+                }
+                catch (error) {
+                    lastError = error;
+                }
+            }
+            if (selected) {
+                await this.waitForVisibleTuiSession(session.id);
+                confirmed = true;
+                return;
+            }
+        }
+        finally {
+            if (this.expectedVisibleTuiSessionId === session.id) {
+                this.expectedVisibleTuiSessionId = null;
+            }
+            if (!confirmed &&
+                this.suppressedTuiSessionSelect?.sessionId === session.id) {
+                this.suppressedTuiSessionSelect = null;
+            }
+        }
+        throw new Error(`Failed to switch the visible OpenCode session: ${describeUnknownError(lastError)}`, { cause: lastError });
+    }
     isTuiSessionSelectSuppressed(sessionId) {
         const suppression = this.suppressedTuiSessionSelect;
         if (!suppression || suppression.sessionId !== sessionId) {

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();

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,