cli-wechat-bridge 1.1.3 → 1.1.5

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

@@ -1,15 +1,29 @@
 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;
 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";
 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                                                            */
 /* ------------------------------------------------------------------ */
@@ -20,6 +34,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 +70,17 @@ export class OpenCodeServerAdapter {
     pendingWechatPromptMirrorSuppressions = [];
     recentWechatPromptMirrorSuppressions = [];
     recentSdkEventObservations = new Map();
-    suppressedTuiSessionSelectId = null;
+    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;
@@ -90,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 {
@@ -159,12 +190,77 @@ 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) {
+            throw new Error("OpenCode is not running yet.");
+        }
+        try {
+            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,
+            });
+        }
     }
     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.");
+        }
+        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: false,
+        });
     }
     async createSession() {
         if (!this.client) {
@@ -345,6 +441,7 @@ export class OpenCodeServerAdapter {
                 }
             }
         }
+        await this.stopTuiRouteBridge();
         if (this.serverProcess) {
             const proc = this.serverProcess;
             this.serverProcess = null;
@@ -360,14 +457,183 @@ 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;
     }
     /* ---- 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");
+        env.OPENCODE_SERVER_PASSWORD = this.serverPassword;
         const serverArgs = [
             "serve",
             "--port",
@@ -466,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;
@@ -477,6 +746,20 @@ 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;
+        }
         if (this.activeSessionId) {
             env.OPENCODE_ROUTE = JSON.stringify({
                 type: "session",
@@ -485,6 +768,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 +782,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 +802,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 +839,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 +1011,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 +1089,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;
@@ -814,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.
@@ -849,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":
@@ -930,7 +1231,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 +1243,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();
@@ -1217,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)) {
@@ -1232,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;
@@ -1595,24 +1919,18 @@ 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 = "";
         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)) {
@@ -1625,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();
@@ -2142,13 +2451,130 @@ 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) {
+            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 +2583,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 +2692,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 +2753,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 +2854,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)) {