cli-wechat-bridge 1.1.2 → 1.1.4

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

@@ -1,13 +1,19 @@
 import { spawn as spawnChildProcess } from "node:child_process";
-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, buildCliEnvironment, isRecord, describeUnknownError, resolveSpawnTarget, reserveLocalPort, waitForTcpPort, delay, } from "./bridge-adapters.shared.js";
+import { randomBytes } from "node:crypto";
+import { OPENCODE_SERVER_HOST, OPENCODE_SERVER_READY_TIMEOUT_MS, OPENCODE_SSE_RECONNECT_DELAY_MS, OPENCODE_SESSION_IDLE_SETTLE_MS, OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS, OPENCODE_HTTP_READY_TIMEOUT_MS, OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS, OPENCODE_HTTP_READY_PROBE_INTERVAL_MS, buildCliEnvironment, isRecord, describeUnknownError, resolveSpawnTarget, reserveLocalPort, waitForTcpPort, delay, } from "./bridge-adapters.shared.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, buildOneTimeCode, isWechatOutboundAttachmentMutationTool, isWechatOutboundAttachmentWriteCommand, normalizeOutput, nowIso, truncatePreview, OutputBatcher, } from "./bridge-utils.js";
 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;
 /* ------------------------------------------------------------------ */
 /*  Adapter                                                            */
 /* ------------------------------------------------------------------ */
@@ -18,6 +24,11 @@ export class OpenCodeServerAdapter {
     serverProcess = null;
     nativeProcess = null;
     serverPort = 0;
+    // Random per-instance password handed to `opencode serve` via
+    // OPENCODE_SERVER_PASSWORD. Without it the server accepts unauthenticated
+    // connections from any local process; the attach client inherits the env
+    // automatically, and the SDK/health calls send the matching Basic header.
+    serverPassword = null;
     client = null;
     sseAbortController = null;
     sseLoopPromise = null;
@@ -49,10 +60,11 @@ export class OpenCodeServerAdapter {
     pendingWechatPromptMirrorSuppressions = [];
     recentWechatPromptMirrorSuppressions = [];
     recentSdkEventObservations = new Map();
-    suppressedTuiSessionSelectId = null;
+    suppressedTuiSessionSelect = null;
     lastMirroredLocalPrompt = null;
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
+    pendingQuestion = null;
     constructor(options) {
         this.options = options;
         this.state = {
@@ -117,6 +129,9 @@ export class OpenCodeServerAdapter {
         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.");
+        }
         const normalized = normalizeOutput(text).trim();
         if (!normalized) {
             return;
@@ -153,12 +168,50 @@ export class OpenCodeServerAdapter {
         }
     }
     async listResumeSessions(limit = 10) {
-        void limit;
-        throw new Error('WeChat /resume is disabled in opencode mode. Use /session directly inside "wechat-opencode"; WeChat will follow the active local session.');
+        if (!this.client) {
+            return [];
+        }
+        let sessions;
+        try {
+            sessions = this.unwrapOrThrow(await this.client.session.list()) ?? [];
+        }
+        catch {
+            return [];
+        }
+        return sessions
+            .filter((session) => this.isCurrentDirectorySession(session))
+            .slice(0, limit)
+            .map((session) => {
+            const rawTime = typeof session.time?.updated === "number"
+                ? session.time.updated
+                : typeof session.time?.created === "number"
+                    ? session.time.created
+                    : 0;
+            const updatedMs = rawTime > 0 && rawTime < 1_000_000_000_000 ? rawTime * 1_000 : rawTime;
+            return {
+                sessionId: session.id,
+                title: session.title?.trim() || "untitled",
+                lastUpdatedAt: new Date(updatedMs > 0 ? updatedMs : Date.now()).toISOString(),
+                source: "opencode",
+            };
+        });
     }
     async resumeSession(sessionId) {
-        void sessionId;
-        throw new Error('WeChat /resume is disabled in opencode mode. Use /session directly inside "wechat-opencode"; WeChat will follow the active local session.');
+        if (!this.client) {
+            throw new Error("OpenCode is not running yet.");
+        }
+        const session = await this.getSessionForCurrentDirectory(sessionId, []);
+        if (!session) {
+            throw new Error(`No OpenCode session ${sessionId} was found for ${this.options.cwd}.`);
+        }
+        this.switchSharedSession(session, {
+            source: "wechat",
+            reason: "wechat_resume",
+            notify: true,
+            clearTrackedTurn: true,
+            syncVisible: true,
+            forceVisibleSync: true,
+        });
     }
     async createSession() {
         if (!this.client) {
@@ -170,6 +223,9 @@ export class OpenCodeServerAdapter {
         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.");
+        }
         this.outputBatcher.clear();
         this.clearStreamedPartState();
         const session = this.unwrapOrThrow(await this.client.session.create({
@@ -190,10 +246,16 @@ export class OpenCodeServerAdapter {
         if (!this.client || !this.activeSessionId) {
             return false;
         }
-        if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+        if (this.state.status !== "busy" &&
+            this.state.status !== "awaiting_approval" &&
+            this.state.status !== "awaiting_input") {
             return false;
         }
         this.clearWechatWorkingNotice(true);
+        if (this.pendingQuestion) {
+            await this.rejectPendingQuestion(this.pendingQuestion);
+            this.clearPendingQuestionState();
+        }
         try {
             await this.client.session.abort({
                 sessionID: this.activeSessionId,
@@ -214,6 +276,7 @@ export class OpenCodeServerAdapter {
         this.clearObservedMessageTracking();
         this.recentSdkEventObservations.clear();
         this.clearPendingPermissionState();
+        this.clearPendingQuestionState();
         this.activeSessionId = null;
         this.state.sharedSessionId = undefined;
         this.state.sharedThreadId = undefined;
@@ -232,15 +295,14 @@ export class OpenCodeServerAdapter {
         if (!this.pendingPermission || !this.client) {
             return false;
         }
-        const { sessionId, permissionId } = this.pendingPermission;
+        const { permissionId } = this.pendingPermission;
         const response = action === "confirm" ? "once" : "reject";
         try {
-            const result = await this.client.permission.respond({
-                sessionID: sessionId,
-                permissionID: permissionId,
+            const result = await this.client.permission.reply({
+                requestID: permissionId,
                 directory: this.options.cwd,
                 workspace: this.activeWorkspaceId ?? undefined,
-                response,
+                reply: response,
             });
             if (result.error !== undefined) {
                 throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
@@ -263,8 +325,34 @@ export class OpenCodeServerAdapter {
         const ok = await this.resolveApproval(action);
         return ok ? 1 : 0;
     }
-    async submitUserInput(_answers) {
-        return false;
+    async submitUserInput(answers) {
+        if (!this.pendingQuestion || !this.client) {
+            return false;
+        }
+        const pending = this.pendingQuestion;
+        const orderedAnswers = pending.request.questions.map((question) => answers[question.id] ?? []);
+        try {
+            const result = await this.client.question.reply({
+                requestID: pending.requestId,
+                directory: this.options.cwd,
+                workspace: this.activeWorkspaceId ?? undefined,
+                answers: orderedAnswers,
+            });
+            if (result.error !== undefined) {
+                throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
+            }
+        }
+        catch (err) {
+            this.emit({
+                type: "stderr",
+                text: `Failed to submit OpenCode user input: ${describeUnknownError(err)}`,
+                timestamp: nowIso(),
+            });
+            return false;
+        }
+        this.clearPendingQuestionState();
+        this.setStatus("busy", "OpenCode user input submitted.");
+        return true;
     }
     async dispose() {
         this.shuttingDown = true;
@@ -277,6 +365,7 @@ export class OpenCodeServerAdapter {
         this.outputBatcher.clear();
         this.clearStreamedPartState();
         this.clearPendingPermissionState();
+        this.clearPendingQuestionState();
         // Stop SSE listener
         if (this.sseAbortController) {
             this.sseAbortController.abort();
@@ -318,7 +407,7 @@ export class OpenCodeServerAdapter {
         this.client = null;
         this.activeSessionId = null;
         this.activeWorkspaceId = null;
-        this.suppressedTuiSessionSelectId = null;
+        this.suppressedTuiSessionSelect = null;
         this.state.status = "stopped";
         this.state.pid = undefined;
         this.state.startedAt = undefined;
@@ -326,6 +415,8 @@ export class OpenCodeServerAdapter {
     /* ---- Server management ---- */
     async startServerProcess() {
         const env = buildCliEnvironment(this.options.kind);
+        this.serverPassword = randomBytes(24).toString("hex");
+        env.OPENCODE_SERVER_PASSWORD = this.serverPassword;
         const serverArgs = [
             "serve",
             "--port",
@@ -435,6 +526,9 @@ export class OpenCodeServerAdapter {
     }
     buildNativeClientEnv() {
         const env = buildCliEnvironment(this.options.kind);
+        if (this.serverPassword) {
+            env.OPENCODE_SERVER_PASSWORD = this.serverPassword;
+        }
         if (this.activeSessionId) {
             env.OPENCODE_ROUTE = JSON.stringify({
                 type: "session",
@@ -443,6 +537,13 @@ export class OpenCodeServerAdapter {
         }
         return env;
     }
+    buildServerAuthHeaders() {
+        if (!this.serverPassword) {
+            return {};
+        }
+        const credentials = Buffer.from(`opencode:${this.serverPassword}`, "utf8").toString("base64");
+        return { Authorization: `Basic ${credentials}` };
+    }
     async createSdkClient() {
         try {
             const { createOpencodeClient } = await import("@opencode-ai/sdk/v2");
@@ -450,6 +551,7 @@ export class OpenCodeServerAdapter {
                 baseUrl: `http://${OPENCODE_SERVER_HOST}:${this.serverPort}`,
                 directory: this.options.cwd,
                 experimental_workspaceID: this.activeWorkspaceId ?? undefined,
+                headers: this.buildServerAuthHeaders(),
             });
         }
         catch (err) {
@@ -458,10 +560,57 @@ export class OpenCodeServerAdapter {
     }
     async checkHealth() {
         const baseUrl = `http://${OPENCODE_SERVER_HOST}:${this.serverPort}`;
-        const response = await fetch(`${baseUrl}/session/status`);
-        if (!response.ok) {
-            throw new Error(`OpenCode health check failed (HTTP ${response.status}).`);
+        // `opencode serve` binds its TCP port before the HTTP layer is ready,
+        // so a fetch fired the instant `waitForTcpPort` returns can be accepted
+        // into the listen backlog but never answered, hanging until undici's
+        // ~300s `headersTimeout` and surfacing as `fetch failed` after ~5min.
+        // Retry with a short per-attempt timeout so the startup race
+        // self-heals once the server finishes booting.
+        const deadline = Date.now() + OPENCODE_HTTP_READY_TIMEOUT_MS;
+        let lastError;
+        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) {
+                    const health = await response.json();
+                    if (!isRecord(health) || health.healthy !== true || typeof health.version !== "string") {
+                        lastError = new Error("OpenCode health check returned an invalid response.");
+                    }
+                    else if (!this.isSupportedOpenCodeVersion(health.version)) {
+                        throw new Error(`Unsupported OpenCode version ${health.version}. Install OpenCode >=${OPENCODE_MINIMUM_SUPPORTED_VERSION} <${OPENCODE_MAXIMUM_SUPPORTED_MAJOR}.0.0.`);
+                    }
+                    else {
+                        return;
+                    }
+                }
+                else {
+                    lastError = new Error(`OpenCode health check failed (HTTP ${response.status}).`);
+                }
+            }
+            catch (err) {
+                if (err instanceof Error &&
+                    err.message.startsWith("Unsupported OpenCode version ")) {
+                    throw err;
+                }
+                lastError = err;
+            }
+            await delay(OPENCODE_HTTP_READY_PROBE_INTERVAL_MS);
+        }
+        throw lastError ?? new Error("OpenCode health check timed out.");
+    }
+    isSupportedOpenCodeVersion(version) {
+        const match = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version.trim());
+        if (!match) {
+            return false;
         }
+        const major = Number(match[1]);
+        const minor = Number(match[2]);
+        return (major >= 1 &&
+            major < OPENCODE_MAXIMUM_SUPPORTED_MAJOR &&
+            (major > 1 || minor >= 18));
     }
     async initializeSessions() {
         if (!this.client) {
@@ -568,11 +717,11 @@ export class OpenCodeServerAdapter {
             return;
         }
         this.sseAbortController = new AbortController();
-        this.sseLoopPromise = Promise.all([
+        const sseLoops = [
             this.runSseLoop("event"),
             this.runSseLoop("global-event"),
-            this.runSseLoop("global-sync"),
-        ]).then(() => undefined);
+        ];
+        this.sseLoopPromise = Promise.all(sseLoops).then(() => undefined);
     }
     async runSseLoop(streamName) {
         while (!this.shuttingDown) {
@@ -607,9 +756,6 @@ export class OpenCodeServerAdapter {
     }
     subscribeToSseStream(streamName) {
         const signal = this.sseAbortController?.signal;
-        if (streamName === "global-sync") {
-            return this.client.global.syncEvent.subscribe({ signal });
-        }
         if (streamName === "global-event") {
             return this.client.global.event({ signal });
         }
@@ -623,11 +769,20 @@ export class OpenCodeServerAdapter {
             return null;
         }
         if (typeof rawEvent.type === "string") {
+            if (rawEvent.type === "sync") {
+                return this.normalizeGlobalSyncPayload(rawEvent, rawEvent);
+            }
             return rawEvent;
         }
         const payload = rawEvent.payload;
         if (isRecord(payload) && typeof payload.type === "string") {
+            if (payload.type === "sync") {
+                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;
             }
@@ -635,6 +790,17 @@ export class OpenCodeServerAdapter {
         }
         return null;
     }
+    normalizeGlobalSyncPayload(payload, envelope) {
+        const syncEvent = isRecord(payload.syncEvent) ? payload.syncEvent : undefined;
+        if (!syncEvent || typeof syncEvent.type !== "string") {
+            return null;
+        }
+        const normalized = { ...syncEvent };
+        if (typeof envelope.directory === "string") {
+            normalized.directory = envelope.directory;
+        }
+        return normalized;
+    }
     shouldHandleSseEvent(event, streamName) {
         if (streamName === "event") {
             return true;
@@ -647,7 +813,10 @@ export class OpenCodeServerAdapter {
                 type !== "command.executed" &&
                 type !== "session.created" &&
                 type !== "session.updated" &&
-                type !== "session.deleted") {
+                type !== "session.deleted" &&
+                type !== "question.asked" &&
+                type !== "question.replied" &&
+                type !== "question.rejected") {
                 return false;
             }
             if (this.isImplicitLocalCompanionUiEvent(type)) {
@@ -656,13 +825,6 @@ export class OpenCodeServerAdapter {
             return (this.matchesCurrentDirectoryEvent(event) ||
                 this.shouldAcceptUnscopedLocalSessionCreatedEvent(event));
         }
-        if (type === "session.created" ||
-            type === "session.updated" ||
-            type === "session.deleted") {
-            return (this.matchesCurrentDirectoryEvent(event) ||
-                (type === "session.created" &&
-                    this.shouldAcceptUnscopedLocalSessionCreatedEvent(event)));
-        }
         return false;
     }
     isImplicitLocalCompanionUiEvent(type) {
@@ -696,11 +858,21 @@ 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;
             }
+            case "question.asked": {
+                this.handleQuestionAsked(payload);
+                return;
+            }
+            case "question.replied":
+            case "question.rejected": {
+                this.handleQuestionSettled(payload);
+                return;
+            }
             case "session.created": {
                 this.handleSessionCreated(payload);
                 return;
@@ -762,18 +934,23 @@ export class OpenCodeServerAdapter {
         if (!this.syncTrackedSessionFromEvent(sessionId, { allowLocalTurnFollow: false })) {
             return;
         }
-        if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+        if (this.state.status !== "busy" &&
+            this.state.status !== "awaiting_approval" &&
+            this.state.status !== "awaiting_input") {
             return;
         }
         // Wait a short settle time before emitting task_complete,
         // in case more events follow the idle signal.
         setTimeout(() => {
-            if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+            if (this.state.status !== "busy" &&
+                this.state.status !== "awaiting_approval" &&
+                this.state.status !== "awaiting_input") {
                 return;
             }
             this.clearWechatWorkingNotice(true);
             this.pendingLocalPrompt = "";
             this.clearPendingPermissionState();
+            this.clearPendingQuestionState();
             this.state.activeTurnOrigin = undefined;
             this.hasAcceptedInput = false;
             const completedPreview = this.currentPreview;
@@ -820,7 +997,10 @@ export class OpenCodeServerAdapter {
         if (sessionId && !this.syncTrackedSessionFromEvent(sessionId)) {
             return;
         }
-        // properties: { sessionID: string, status: { type: "busy" | "idle" | ... } }
+        // properties: { sessionID, status: { type: "busy" | "idle" | "retry" | ... } }
+        // "retry" means the model call is being retried (attempt, message): the
+        // session is still working, so it must keep the busy state instead of
+        // letting WeChat messages race a retried turn.
         const status = properties.status;
         if (!isRecord(status)) {
             return;
@@ -829,7 +1009,7 @@ export class OpenCodeServerAdapter {
         if (!statusType) {
             return;
         }
-        if (statusType === "busy" || statusType === "running") {
+        if (statusType === "busy" || statusType === "running" || statusType === "retry") {
             if (this.state.status === "idle") {
                 this.outputBatcher.clear();
                 this.clearStreamedPartState();
@@ -874,6 +1054,114 @@ export class OpenCodeServerAdapter {
         this.state.pendingApproval = null;
         this.state.pendingApprovalOrigin = undefined;
     }
+    handleQuestionAsked(properties) {
+        if (!isRecord(properties) || !this.client) {
+            return;
+        }
+        const sessionId = this.extractSessionId(properties);
+        if (!sessionId || !this.syncTrackedSessionFromEvent(sessionId)) {
+            return;
+        }
+        const requestId = typeof properties.id === "string" ? properties.id : null;
+        if (!requestId || !Array.isArray(properties.questions)) {
+            return;
+        }
+        const questions = properties.questions.flatMap((candidate, index) => {
+            if (!isRecord(candidate)) {
+                return [];
+            }
+            const header = typeof candidate.header === "string" ? candidate.header.trim() : "";
+            const question = typeof candidate.question === "string" ? candidate.question.trim() : "";
+            if (!header || !question) {
+                return [];
+            }
+            const options = Array.isArray(candidate.options)
+                ? candidate.options.flatMap((option) => {
+                    if (!isRecord(option) || typeof option.label !== "string") {
+                        return [];
+                    }
+                    return [{
+                            label: option.label,
+                            description: typeof option.description === "string" ? option.description : "",
+                        }];
+                })
+                : [];
+            return [{
+                    id: `question_${index + 1}`,
+                    header,
+                    question,
+                    isOther: candidate.custom === true,
+                    isSecret: false,
+                    multiple: candidate.multiple === true,
+                    customAnswerMode: "value",
+                    options,
+                }];
+        });
+        if (questions.length !== properties.questions.length || questions.length === 0) {
+            return;
+        }
+        const request = {
+            summary: `OpenCode requested answers to ${questions.length} question${questions.length === 1 ? "" : "s"}.`,
+            questions,
+        };
+        this.pendingQuestion = {
+            sessionId,
+            requestId,
+            request,
+        };
+        this.state.pendingUserInput = request;
+        this.state.pendingUserInputOrigin = this.state.activeTurnOrigin;
+        this.clearWechatWorkingNotice();
+        this.setStatus("awaiting_input", "OpenCode is waiting for user input.");
+        this.emit({
+            type: "user_input_required",
+            request,
+            timestamp: nowIso(),
+        });
+    }
+    handleQuestionSettled(properties) {
+        if (!isRecord(properties) || !this.pendingQuestion) {
+            return;
+        }
+        const sessionId = this.extractSessionId(properties);
+        const requestId = typeof properties.requestID === "string" ? properties.requestID : null;
+        if (sessionId !== this.pendingQuestion.sessionId ||
+            requestId !== this.pendingQuestion.requestId) {
+            return;
+        }
+        this.clearPendingQuestionState();
+        if (this.state.status === "awaiting_input") {
+            this.setStatus("busy", "OpenCode user input resolved.");
+        }
+    }
+    clearPendingQuestionState() {
+        this.pendingQuestion = null;
+        this.state.pendingUserInput = null;
+        this.state.pendingUserInputOrigin = undefined;
+    }
+    async rejectPendingQuestion(pending) {
+        const client = this.client;
+        if (!client) {
+            return;
+        }
+        try {
+            const result = await client.question.reject({
+                requestID: pending.requestId,
+                directory: this.options.cwd,
+                workspace: this.activeWorkspaceId ?? undefined,
+            });
+            if (result.error !== undefined) {
+                throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
+            }
+        }
+        catch (err) {
+            this.emit({
+                type: "stderr",
+                text: `Failed to reject OpenCode user input: ${describeUnknownError(err)}`,
+                timestamp: nowIso(),
+            });
+        }
+    }
     getWechatOutboundAttachmentPermissionDenyMessage(properties, pendingPermission) {
         const metadata = isRecord(properties.metadata) ? properties.metadata : {};
         const command = this.extractPermissionCommand(properties, metadata);
@@ -905,12 +1193,11 @@ export class OpenCodeServerAdapter {
         }
         void (async () => {
             try {
-                const result = await client.permission.respond({
-                    sessionID: pendingPermission.sessionId,
-                    permissionID: pendingPermission.permissionId,
+                const result = await client.permission.reply({
+                    requestID: pendingPermission.permissionId,
                     directory: this.options.cwd,
                     workspace: this.activeWorkspaceId ?? undefined,
-                    response: "reject",
+                    reply: "reject",
                 });
                 if (result.error !== undefined) {
                     throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
@@ -1378,8 +1665,11 @@ export class OpenCodeServerAdapter {
         if (!sessionId) {
             return;
         }
-        if (sessionId === this.suppressedTuiSessionSelectId) {
-            this.suppressedTuiSessionSelectId = null;
+        if (this.suppressedTuiSessionSelect &&
+            sessionId === this.suppressedTuiSessionSelect.sessionId) {
+            // Echo of our own selectSession — swallow it once. The TTL guard in
+            // isSuppressedTuiSessionSelectExpired covers the lost-echo case.
+            this.suppressedTuiSessionSelect = null;
             return;
         }
         this.pendingLocalPrompt = "";
@@ -1661,8 +1951,10 @@ export class OpenCodeServerAdapter {
     hasTrackedTurnState() {
         return (this.state.status === "busy" ||
             this.state.status === "awaiting_approval" ||
+            this.state.status === "awaiting_input" ||
             this.hasAcceptedInput ||
             this.pendingPermission !== null ||
+            this.pendingQuestion !== null ||
             this.state.activeTurnOrigin !== undefined ||
             this.currentPreview !== "(idle)");
     }
@@ -1671,6 +1963,7 @@ export class OpenCodeServerAdapter {
         this.pendingLocalPrompt = "";
         this.localPromptNoticeSent = false;
         this.clearPendingPermissionState();
+        this.clearPendingQuestionState();
         this.state.activeTurnOrigin = undefined;
         this.hasAcceptedInput = false;
         this.currentPreview = "(idle)";
@@ -1922,13 +2215,27 @@ export class OpenCodeServerAdapter {
             workspaceID: this.activeWorkspaceId ?? undefined,
         }, { force: options.force, retry: options.retry });
     }
+    isTuiSessionSelectSuppressed(sessionId) {
+        const suppression = this.suppressedTuiSessionSelect;
+        if (!suppression || suppression.sessionId !== sessionId) {
+            return false;
+        }
+        // Bound the suppression window: if the echo never arrives (TUI not ready,
+        // dropped event), a stale flag must not swallow a later genuine local
+        // switch to the same session.
+        if (Date.now() - suppression.setAtMs > TUI_SESSION_SELECT_SUPPRESSION_TTL_MS) {
+            this.suppressedTuiSessionSelect = null;
+            return false;
+        }
+        return true;
+    }
     async syncVisibleSessionSelection(session, options = {}) {
         if (!this.client?.tui ||
             this.options.renderMode !== "companion" ||
-            (!options.force && session.id === this.suppressedTuiSessionSelectId)) {
+            (!options.force && this.isTuiSessionSelectSuppressed(session.id))) {
             return;
         }
-        this.suppressedTuiSessionSelectId = session.id;
+        this.suppressedTuiSessionSelect = { sessionId: session.id, setAtMs: Date.now() };
         this.logDebug(`[opencode-adapter:tui] selectSession session=${session.id} workspace=${session.workspaceID ?? this.activeWorkspaceId ?? "(none)"}`);
         try {
             await this.sendVisibleSessionSelection(session);
@@ -1937,8 +2244,8 @@ export class OpenCodeServerAdapter {
             }
         }
         catch (err) {
-            if (this.suppressedTuiSessionSelectId === session.id) {
-                this.suppressedTuiSessionSelectId = null;
+            if (this.suppressedTuiSessionSelect?.sessionId === session.id) {
+                this.suppressedTuiSessionSelect = null;
             }
             this.logDebug(`[opencode-adapter:tui] selectSession failed for ${session.id}: ${describeUnknownError(err)}`);
         }
@@ -2046,8 +2353,10 @@ export class OpenCodeServerAdapter {
         }
         return true;
     }
+    // Fold both path separators to "/" so directory comparisons behave
+    // identically on Windows (backslash-native) and POSIX hosts.
     normalizeDirectory(directory) {
-        return directory.replace(/[\\/]+/g, "\\").replace(/\\$/, "").toLowerCase();
+        return directory.replace(/[\\/]+/g, "/").replace(/\/+$/, "").toLowerCase();
     }
     recordSessionSwitch(sessionId, source, reason, notify = false) {
         const timestamp = nowIso();
@@ -2105,13 +2414,20 @@ export class OpenCodeServerAdapter {
             return "";
         }
         const previousText = this.emittedTextByPartId.get(partId) ?? "";
-        if (nextChunk === previousText || previousText.endsWith(nextChunk)) {
+        if (nextChunk === previousText) {
+            // Full replay of everything emitted for this part (an SSE replay after
+            // a reconnect): nothing new.
             return "";
         }
         if (previousText && nextChunk.startsWith(previousText)) {
+            // The "delta" actually carries the accumulated part text: keep the tail.
             this.emittedTextByPartId.set(partId, nextChunk);
             return nextChunk.slice(previousText.length);
         }
+        // Plain incremental delta: append. Duplicated fragments that legitimately
+        // occur in model output (repeated words, table separators, markdown
+        // rules) must still be forwarded, so there is deliberately no
+        // suffix-based dedup here — it silently truncated real content.
         this.emittedTextByPartId.set(partId, `${previousText}${nextChunk}`);
         return nextChunk;
     }
@@ -2199,18 +2515,31 @@ export class OpenCodeServerAdapter {
         if (!key) {
             return false;
         }
+        // Frame-id keys identify one exact server event, so any repeat — even on
+        // the same stream (SSE replay) — is a duplicate; the wide TTL absorbs
+        // reconnect replays. Synthetic keys still rely on the narrow cross-stream
+        // window only, because they cannot distinguish a replay from a legitimate
+        // repeated payload.
+        const idKeyTtlMs = 30_000;
+        const isIdKey = key.startsWith("evt:");
+        const ttlMs = isIdKey ? idKeyTtlMs : OPENCODE_DUPLICATE_EVENT_TTL_MS;
         const now = Date.now();
-        const cutoff = now - OPENCODE_DUPLICATE_EVENT_TTL_MS;
         for (const [candidateKey, observed] of this.recentSdkEventObservations.entries()) {
-            if (observed.observedAtMs < cutoff) {
+            if (observed.observedAtMs < now - idKeyTtlMs) {
                 this.recentSdkEventObservations.delete(candidateKey);
             }
         }
         const previous = this.recentSdkEventObservations.get(key);
         this.recentSdkEventObservations.set(key, { streamName, observedAtMs: now });
-        return Boolean(previous && previous.streamName !== streamName && previous.observedAtMs >= cutoff);
+        return Boolean(previous &&
+            previous.observedAtMs >= now - ttlMs &&
+            (isIdKey || previous.streamName !== streamName));
     }
     getDuplicateSdkEventKey(event) {
+        // Exact frame ids (when the stream provides them) dedupe precisely.
+        if (typeof event.id === "string" && event.id) {
+            return `evt:${event.id}`;
+        }
         const type = this.normalizeEventType(event.type);
         const payload = this.extractEventPayload(event);
         if (!isRecord(payload)) {
@@ -2241,6 +2570,15 @@ export class OpenCodeServerAdapter {
                 const sessionId = this.extractSessionId(payload);
                 return sessionId ? `${type}:${sessionId}` : null;
             }
+            case "question.asked": {
+                const requestId = typeof payload.id === "string" ? payload.id : undefined;
+                return requestId ? `${type}:${requestId}` : null;
+            }
+            case "question.replied":
+            case "question.rejected": {
+                const requestId = typeof payload.requestID === "string" ? payload.requestID : undefined;
+                return requestId ? `${type}:${requestId}` : null;
+            }
             default:
                 return null;
         }