@unlinearity/cli-wechat-bridge 1.2.0 → 1.2.2

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

@@ -4,6 +4,7 @@
 // This file is part of CLI-WeChat-Bridge. Modifications and derivative works
 // must be released under AGPL-3.0-or-later with full source code; see
 // LICENSE.txt. Network services built on it must offer source to users.
+import { t } from "../i18n/index.js";
 import { spawn as spawnChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import fs from "node:fs";
@@ -12,6 +13,7 @@ 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 { createOpenCodeV2CompatClient } from "./opencode-v2-compat.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 ?? "");
@@ -24,7 +26,11 @@ 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_MAXIMUM_SUPPORTED_MAJOR = 3;
+const OPENCODE_VERSION_PROBE_TIMEOUT_MS = 5_000;
+export function parseOpenCodeCliVersion(output) {
+    return /\bv?(\d+\.\d+\.\d+)\b/.exec(output)?.[1] ?? null;
+}
 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);
@@ -83,6 +89,8 @@ export class OpenCodeServerAdapter {
     tuiRoutePort = 0;
     tuiRouteConfigDir = null;
     tuiRouteConfigPath = null;
+    tuiRoutePluginPath = null;
+    openCodeMajor = 1;
     visibleTuiSessionId = null;
     tuiRouteStateReceived = false;
     expectedVisibleTuiSessionId = null;
@@ -90,8 +98,14 @@ export class OpenCodeServerAdapter {
     lastMirroredLocalPrompt = null;
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
+    pendingPermissions = new Map();
+    approvalOwnershipGeneration = 0;
+    settledPermissionIds = new Set();
+    resolvingPermissions = new Set();
+    childSessionParents = new Map();
     pendingQuestion = null;
     previousAgentBySession = new Map();
+    childSessionIds = new Set();
     async listModels() {
         this.assertRemoteControlReady();
         const session = await this.ensureControlSession();
@@ -109,7 +123,7 @@ export class OpenCodeServerAdapter {
         const models = await this.listControlModels();
         const target = models.find((model) => model.id === modelId);
         if (!target) {
-            throw new Error("This OpenCode model is no longer available. Send /model again.");
+            throw new Error(t("adapter.opencode.modelUnavailable"));
         }
         const currentVariant = session.model?.variant;
         const variant = currentVariant && currentVariant !== "default" && target.variants.includes(currentVariant)
@@ -129,7 +143,7 @@ export class OpenCodeServerAdapter {
             updated.model?.providerID !== target.providerID ||
             updated.model.id !== target.modelID ||
             (updated.model.variant ?? "default") !== variant) {
-            throw new Error("OpenCode did not confirm the selected model.");
+            throw new Error(t("adapter.opencode.modelUnconfirmed"));
         }
         return { id: target.id, displayName: target.displayName, isCurrent: true };
     }
@@ -139,11 +153,11 @@ export class OpenCodeServerAdapter {
         const agents = await this.listPrimaryAgents();
         const planAgent = agents.find((agent) => agent.name === "plan");
         if (!planAgent) {
-            throw new Error("OpenCode primary agent 'plan' is not available.");
+            throw new Error(t("adapter.opencode.planUnavailable"));
         }
         const currentAgent = session.agent ?? agents[0]?.name;
         if (!currentAgent) {
-            throw new Error("OpenCode did not return any primary agents.");
+            throw new Error(t("adapter.opencode.agentsMissing"));
         }
         if (enabled && currentAgent === "plan") {
             return true;
@@ -160,7 +174,7 @@ export class OpenCodeServerAdapter {
                 : agents.find((agent) => agent.name === "build")?.name ??
                     agents.find((agent) => agent.name !== "plan")?.name;
         if (!target) {
-            throw new Error("OpenCode did not return an agent that can replace plan mode.");
+            throw new Error(t("adapter.opencode.planReplacementMissing"));
         }
         const result = await this.client.v2.session.switchAgent({
             sessionID: session.id,
@@ -169,7 +183,7 @@ export class OpenCodeServerAdapter {
         this.unwrapOrThrow(result);
         const updated = await this.getSessionForCurrentDirectory(session.id);
         if (!updated || updated.agent !== target) {
-            throw new Error("OpenCode did not confirm the selected agent.");
+            throw new Error(t("adapter.opencode.agentUnconfirmed"));
         }
         if (enabled) {
             this.previousAgentBySession.set(session.id, currentAgent);
@@ -181,16 +195,16 @@ export class OpenCodeServerAdapter {
     }
     assertRemoteControlReady() {
         if (!this.client) {
-            throw new Error("OpenCode is not running.");
+            throw new Error(t("adapter.opencode.notRunning"));
         }
         if (this.state.status === "busy") {
-            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.opencode.busy"));
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.opencode.approvalPending"));
         }
         if (this.pendingQuestion) {
-            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.opencode.inputPending"));
         }
     }
     async ensureControlSession() {
@@ -207,7 +221,7 @@ export class OpenCodeServerAdapter {
     }
     async listPrimaryAgents() {
         if (!this.client)
-            throw new Error("OpenCode is not running.");
+            throw new Error(t("adapter.opencode.notRunning"));
         const agents = this.unwrapOrThrow(await this.client.app.agents({
             directory: this.options.cwd,
             workspace: this.activeWorkspaceId ?? undefined,
@@ -216,7 +230,7 @@ export class OpenCodeServerAdapter {
     }
     async listControlModels() {
         if (!this.client)
-            throw new Error("OpenCode is not running.");
+            throw new Error(t("adapter.opencode.notRunning"));
         const providers = this.unwrapOrThrow(await this.client.provider.list({ directory: this.options.cwd, workspace: this.activeWorkspaceId ?? undefined }, { signal: AbortSignal.timeout(10_000) }));
         return providers.all.filter((provider) => providers.connected.includes(provider.id)).flatMap((provider) => Object.entries(provider.models).filter(([id, model]) => model.status !== "deprecated" && !(provider.id === "opencode" && id.includes("-nano"))).map(([id, model]) => ({
             id: `${provider.id}/${id}`, displayName: `${model.name || id} (${provider.name})`,
@@ -229,6 +243,8 @@ export class OpenCodeServerAdapter {
         this.state = {
             kind: options.kind,
             status: "stopped",
+            supportsApprovalRequestIds: true,
+            pendingApprovals: [],
             cwd: options.cwd,
             command: options.command,
             profile: options.profile,
@@ -250,6 +266,7 @@ export class OpenCodeServerAdapter {
         this.shuttingDown = false;
         this.setStatus("starting", "Starting OpenCode companion...");
         try {
+            await this.probeOpenCodeVersion();
             this.serverPort = await reserveLocalPort();
             const serverProcess = await this.startServerProcess();
             await waitForTcpPort(OPENCODE_SERVER_HOST, this.serverPort, OPENCODE_SERVER_READY_TIMEOUT_MS);
@@ -282,16 +299,16 @@ export class OpenCodeServerAdapter {
     }
     async sendInput(text) {
         if (!this.client) {
-            throw new Error("OpenCode adapter is not running.");
+            throw new Error(t("adapter.opencode.adapterNotRunning"));
         }
         if (this.state.status === "busy") {
-            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.opencode.busy"));
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.opencode.approvalPending"));
         }
         if (this.pendingQuestion) {
-            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.opencode.inputPending"));
         }
         const normalized = normalizeOutput(text).trim();
         if (!normalized) {
@@ -341,7 +358,7 @@ export class OpenCodeServerAdapter {
     }
     async listResumeSessions(limit = 10) {
         if (!this.client) {
-            throw new Error("OpenCode is not running yet.");
+            throw new Error(t("adapter.opencode.notReady"));
         }
         try {
             const sessions = this.unwrapOrThrow(await this.client.session.list({
@@ -377,16 +394,16 @@ export class OpenCodeServerAdapter {
     }
     async resumeSession(sessionId) {
         if (!this.client) {
-            throw new Error("OpenCode is not running yet.");
+            throw new Error(t("adapter.opencode.notReady"));
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.opencode.approvalPending"));
         }
         if (this.pendingQuestion) {
-            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.opencode.inputPending"));
         }
         if (this.state.status === "busy") {
-            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.opencode.busy"));
         }
         if (this.state.status !== "idle") {
             throw new Error(`OpenCode cannot switch sessions while its status is ${this.state.status}.`);
@@ -414,16 +431,16 @@ export class OpenCodeServerAdapter {
     }
     async createSession() {
         if (!this.client) {
-            throw new Error("OpenCode adapter is not running.");
+            throw new Error(t("adapter.opencode.adapterNotRunning"));
         }
         if (this.state.status === "busy") {
-            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.opencode.busy"));
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.opencode.approvalPending"));
         }
         if (this.pendingQuestion) {
-            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.opencode.inputPending"));
         }
         this.outputBatcher.clear();
         this.clearStreamedPartState();
@@ -490,22 +507,30 @@ export class OpenCodeServerAdapter {
         await this.dispose();
         await this.start();
     }
-    async resolveApproval(action) {
-        if (!this.pendingPermission || !this.client) {
+    async resolveApproval(action, requestId) {
+        const pending = requestId === undefined
+            ? this.pendingPermission
+            : this.pendingPermissions.get(requestId);
+        if (!pending || !this.client || this.resolvingPermissions.has(pending.permissionId)) {
             return false;
         }
-        const { permissionId } = this.pendingPermission;
-        const response = action === "confirm" ? "once" : "reject";
+        this.resolvingPermissions.add(pending.permissionId);
         try {
             const result = await this.client.permission.reply({
-                requestID: permissionId,
+                requestID: pending.permissionId,
+                sessionID: pending.sessionId,
                 directory: this.options.cwd,
                 workspace: this.activeWorkspaceId ?? undefined,
-                reply: response,
+                reply: action === "confirm" ? "once" : "reject",
             });
             if (result.error !== undefined) {
                 throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
             }
+            this.rememberSettledPermission(pending.permissionId);
+            this.pendingPermissions.delete(pending.permissionId);
+            this.clearWechatWorkingNotice();
+            this.syncPendingPermissions();
+            return true;
         }
         catch (err) {
             this.emit({
@@ -515,14 +540,17 @@ export class OpenCodeServerAdapter {
             });
             return false;
         }
-        this.clearWechatWorkingNotice();
-        this.clearPendingPermissionState();
-        this.setStatus("busy");
-        return true;
+        finally {
+            this.resolvingPermissions.delete(pending.permissionId);
+        }
     }
     async resolveAllApprovals(action) {
-        const ok = await this.resolveApproval(action);
-        return ok ? 1 : 0;
+        let count = 0;
+        for (const id of Array.from(this.pendingPermissions.keys())) {
+            if (await this.resolveApproval(action, id))
+                count++;
+        }
+        return count;
     }
     async submitUserInput(answers) {
         if (!this.pendingQuestion || !this.client) {
@@ -550,11 +578,14 @@ export class OpenCodeServerAdapter {
             return false;
         }
         this.clearPendingQuestionState();
-        this.setStatus("busy", "OpenCode user input submitted.");
+        this.setStatus(this.pendingPermissions.size ? "awaiting_approval" : "busy", "OpenCode user input submitted.");
         return true;
     }
     async dispose() {
         this.shuttingDown = true;
+        this.childSessionIds.clear();
+        this.childSessionParents.clear();
+        this.settledPermissionIds.clear();
         this.clearWechatWorkingNotice(true);
         this.pendingLocalPrompt = "";
         this.localPromptNoticeSent = false;
@@ -632,13 +663,28 @@ export class OpenCodeServerAdapter {
                 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}`);
+        const pluginName = this.openCodeMajor >= 2
+            ? "opencode-v2-tui-bridge-plugin"
+            : "opencode-tui-bridge-plugin";
+        const pluginPath = path.join(MODULE_DIR, "..", "companion", `${pluginName}${RUNTIME_ENTRY_EXTENSION}`);
         if (!fs.existsSync(pluginPath)) {
             throw new Error(`OpenCode TUI bridge plugin was not found: ${pluginPath}`);
         }
+        const workspaceDir = ensureWorkspaceChannelDir(this.options.cwd).workspaceDir;
+        const configDir = fs.mkdtempSync(path.join(workspaceDir, "opencode-tui-route-"));
+        this.tuiRouteConfigDir = configDir;
+        if (this.openCodeMajor >= 2) {
+            fs.copyFileSync(pluginPath, path.join(configDir, `tui${RUNTIME_ENTRY_EXTENSION}`));
+            fs.writeFileSync(path.join(configDir, "package.json"), `${JSON.stringify({
+                name: "cli-wechat-bridge-opencode-tui-route",
+                private: true,
+                type: "module",
+            }, null, 2)}\n`, "utf8");
+            this.tuiRoutePluginPath = configDir;
+            return;
+        }
+        this.tuiRoutePluginPath = pluginPath;
+        const configPath = path.join(configDir, "tui.json");
         fs.writeFileSync(configPath, `${JSON.stringify({
             plugin: [
                 [
@@ -650,7 +696,6 @@ export class OpenCodeServerAdapter {
                 ],
             ],
         }, null, 2)}\n`, "utf8");
-        this.tuiRouteConfigDir = configDir;
         this.tuiRouteConfigPath = configPath;
     }
     acceptTuiRouteSocket(socket) {
@@ -765,6 +810,7 @@ export class OpenCodeServerAdapter {
         const configDir = this.tuiRouteConfigDir;
         this.tuiRouteConfigDir = null;
         this.tuiRouteConfigPath = null;
+        this.tuiRoutePluginPath = null;
         this.tuiRoutePort = 0;
         this.tuiRouteToken = "";
         this.tuiRouteStateReceived = false;
@@ -781,6 +827,50 @@ export class OpenCodeServerAdapter {
             }
         }
     }
+    async probeOpenCodeVersion() {
+        const env = buildCliEnvironment(this.options.kind);
+        const target = resolveSpawnTarget(this.options.command, this.options.kind, { env });
+        const version = await new Promise((resolve, reject) => {
+            const child = spawnChildProcess(target.file, [...target.args, "--version"], {
+                cwd: this.options.cwd,
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            let output = "";
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                if (error)
+                    reject(error);
+                else
+                    resolve(output);
+            };
+            const timer = setTimeout(() => {
+                if (child.pid != null) {
+                    killProcessTreeSync(child.pid);
+                }
+                finish(new Error("Timed out checking the OpenCode CLI version."));
+            }, OPENCODE_VERSION_PROBE_TIMEOUT_MS);
+            child.stdout?.on("data", (chunk) => { output += chunk.toString("utf8"); });
+            child.stderr?.on("data", (chunk) => { output += chunk.toString("utf8"); });
+            child.once("error", (error) => finish(error));
+            child.once("exit", (code) => {
+                if (code === 0)
+                    finish();
+                else
+                    finish(new Error(`OpenCode --version exited with code ${code ?? "unknown"}.`));
+            });
+        });
+        const parsed = parseOpenCodeCliVersion(version);
+        if (!parsed || !this.isSupportedOpenCodeVersion(parsed)) {
+            throw new Error(`Unsupported OpenCode version ${parsed ?? (version.trim() || "unknown")}. Install OpenCode >=${OPENCODE_MINIMUM_SUPPORTED_VERSION} <${OPENCODE_MAXIMUM_SUPPORTED_MAJOR}.0.0.`);
+        }
+        this.openCodeMajor = Number(parsed.split(".")[0]);
+    }
     async startServerProcess() {
         const env = buildCliEnvironment(this.options.kind);
         this.serverPassword = randomBytes(24).toString("hex");
@@ -886,8 +976,9 @@ export class OpenCodeServerAdapter {
         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 args = this.openCodeMajor >= 2
+            ? ["--server", this.getServerUrl()]
+            : ["attach", this.getServerUrl(), "--dir", this.options.cwd];
         const sessionId = this.activeSessionId;
         if (sessionId && (await this.hasSession(sessionId))) {
             args.push("--session", sessionId);
@@ -897,7 +988,37 @@ export class OpenCodeServerAdapter {
     }
     buildNativeClientEnv() {
         const env = buildCliEnvironment(this.options.kind);
-        if (this.tuiRouteConfigDir && this.tuiRouteConfigPath) {
+        if (this.openCodeMajor >= 2 && this.tuiRoutePluginPath) {
+            let existingConfig = {};
+            if (env.OPENCODE_CLI_CONFIG_CONTENT) {
+                try {
+                    const parsed = JSON.parse(env.OPENCODE_CLI_CONFIG_CONTENT);
+                    if (isRecord(parsed))
+                        existingConfig = parsed;
+                }
+                catch (error) {
+                    throw new Error(`OpenCode cannot merge the managed TUI plugin into invalid OPENCODE_CLI_CONFIG_CONTENT: ${describeUnknownError(error)}`, { cause: error });
+                }
+            }
+            const existingPlugins = Array.isArray(existingConfig.plugins)
+                ? existingConfig.plugins
+                : [];
+            env.OPENCODE_CLI_CONFIG_CONTENT = JSON.stringify({
+                ...existingConfig,
+                plugins: [
+                    ...existingPlugins,
+                    {
+                        package: this.tuiRoutePluginPath,
+                        options: {
+                            port: this.tuiRoutePort,
+                            token: this.tuiRouteToken,
+                        },
+                    },
+                ],
+            });
+            env.OPENCODE_PASSWORD = this.serverPassword ?? "";
+        }
+        else 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.");
             }
@@ -911,7 +1032,7 @@ export class OpenCodeServerAdapter {
         if (this.serverPassword) {
             env.OPENCODE_SERVER_PASSWORD = this.serverPassword;
         }
-        if (this.activeSessionId) {
+        if (this.activeSessionId && this.openCodeMajor < 2) {
             env.OPENCODE_ROUTE = JSON.stringify({
                 type: "session",
                 sessionID: this.activeSessionId,
@@ -928,6 +1049,14 @@ export class OpenCodeServerAdapter {
     }
     async createSdkClient() {
         try {
+            if (this.openCodeMajor >= 2) {
+                this.client = await createOpenCodeV2CompatClient({
+                    baseUrl: `http://${OPENCODE_SERVER_HOST}:${this.serverPort}`,
+                    directory: this.options.cwd,
+                    headers: this.buildServerAuthHeaders(),
+                });
+                return;
+            }
             const { createOpencodeClient } = await import("@opencode-ai/sdk/v2");
             this.client = createOpencodeClient({
                 baseUrl: `http://${OPENCODE_SERVER_HOST}:${this.serverPort}`,
@@ -937,7 +1066,8 @@ export class OpenCodeServerAdapter {
             });
         }
         catch (err) {
-            throw new Error(`Failed to load @opencode-ai/sdk. Make sure it is installed: ${describeUnknownError(err)}`, { cause: err });
+            const packageName = this.openCodeMajor >= 2 ? "@opencode/client" : "@opencode-ai/sdk";
+            throw new Error(`Failed to load ${packageName}. Make sure it is installed: ${describeUnknownError(err)}`, { cause: err });
         }
     }
     async checkHealth() {
@@ -952,17 +1082,24 @@ export class OpenCodeServerAdapter {
         let lastError;
         while (Date.now() < deadline) {
             try {
-                const response = await fetch(`${baseUrl}/global/health`, {
+                const healthPath = this.openCodeMajor >= 2 ? "/api/info" : "/global/health";
+                const response = await fetch(`${baseUrl}${healthPath}`, {
                     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") {
+                    const version = isRecord(health) && typeof health.version === "string"
+                        ? health.version
+                        : undefined;
+                    const healthy = this.openCodeMajor >= 2
+                        ? Boolean(version)
+                        : isRecord(health) && health.healthy === true;
+                    if (!healthy || !version) {
                         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 if (!this.isSupportedOpenCodeVersion(version)) {
+                        throw new Error(`Unsupported OpenCode version ${version}. Install OpenCode >=${OPENCODE_MINIMUM_SUPPORTED_VERSION} <${OPENCODE_MAXIMUM_SUPPORTED_MAJOR}.0.0.`);
                     }
                     else {
                         return;
@@ -1099,10 +1236,9 @@ export class OpenCodeServerAdapter {
             return;
         }
         this.sseAbortController = new AbortController();
-        const sseLoops = [
-            this.runSseLoop("event"),
-            this.runSseLoop("global-event"),
-        ];
+        const sseLoops = this.openCodeMajor >= 2
+            ? [this.runSseLoop("event")]
+            : [this.runSseLoop("event"), this.runSseLoop("global-event")];
         this.sseLoopPromise = Promise.all(sseLoops).then(() => undefined);
     }
     async runSseLoop(streamName) {
@@ -1242,6 +1378,10 @@ export class OpenCodeServerAdapter {
             }
             // Note: only permission.asked exists in the OpenCode wire protocol;
             // permission.updated was never emitted by the server.
+            case "permission.replied": {
+                this.handlePermissionSettled(payload);
+                return;
+            }
             case "permission.asked": {
                 this.handlePermissionRequest(payload);
                 return;
@@ -1303,7 +1443,6 @@ export class OpenCodeServerAdapter {
             case "session.diff":
             case "session.diff.delta":
             case "message.removed":
-            case "permission.replied":
             case "tui.toast.show":
                 return;
             default:
@@ -1410,7 +1549,17 @@ export class OpenCodeServerAdapter {
             return;
         }
         const sessionId = this.extractSessionId(properties);
-        if (sessionId && !this.syncTrackedSessionFromEvent(sessionId)) {
+        if (!sessionId)
+            return;
+        if (!this.isApprovalSessionOwned(sessionId)) {
+            const ownerSessionId = this.activeSessionId;
+            const generation = this.approvalOwnershipGeneration;
+            void this.discoverApprovalSessionOwnership(sessionId).then((owned) => {
+                if (owned && ownerSessionId === this.activeSessionId && generation === this.approvalOwnershipGeneration)
+                    this.handlePermissionRequest(properties);
+            }).catch((error) => {
+                this.logDebug(`[opencode-adapter:approval-owner] ${describeUnknownError(error)}`);
+            });
             return;
         }
         const pendingPermission = this.buildPendingPermission(properties);
@@ -1423,21 +1572,86 @@ export class OpenCodeServerAdapter {
             this.rejectPermission(pendingPermission, denyMessage);
             return;
         }
-        const approval = this.toPendingApproval(pendingPermission);
-        this.pendingPermission = pendingPermission;
-        this.state.pendingApproval = approval;
-        this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
-        this.setStatus("awaiting_approval", "OpenCode approval is required.");
-        this.emit({
-            type: "approval_required",
-            request: approval,
-            timestamp: nowIso(),
-        });
+        if (this.pendingPermissions.has(pendingPermission.permissionId) || this.settledPermissionIds.has(pendingPermission.permissionId))
+            return;
+        this.pendingPermissions.set(pendingPermission.permissionId, pendingPermission);
+        this.syncPendingPermissions();
+    }
+    isApprovalSessionOwned(sessionId) {
+        const seen = new Set();
+        let current = sessionId;
+        while (current && !seen.has(current)) {
+            if (current === this.activeSessionId)
+                return true;
+            seen.add(current);
+            current = this.childSessionParents.get(current);
+        }
+        return false;
+    }
+    async discoverApprovalSessionOwnership(sessionId, seen = new Set()) {
+        if (this.isApprovalSessionOwned(sessionId))
+            return true;
+        if (seen.has(sessionId) || seen.size >= 32 || !this.client?.session?.get)
+            return false;
+        seen.add(sessionId);
+        const result = await this.client.session.get({ sessionID: sessionId, directory: this.options.cwd });
+        const session = result.data;
+        if (!session || !this.isCurrentDirectorySession(session) || !session.parentID)
+            return false;
+        this.childSessionIds.add(sessionId);
+        if (!await this.discoverApprovalSessionOwnership(session.parentID, seen))
+            return false;
+        this.childSessionParents.set(sessionId, session.parentID);
+        return this.isApprovalSessionOwned(sessionId);
+    }
+    rememberSettledPermission(id) {
+        this.settledPermissionIds.add(id);
+        if (this.settledPermissionIds.size > 512) {
+            this.settledPermissionIds.delete(this.settledPermissionIds.values().next().value);
+        }
+    }
+    handlePermissionSettled(properties) {
+        if (!isRecord(properties))
+            return;
+        const id = typeof properties.requestID === "string" ? properties.requestID : properties.id;
+        if (typeof id !== "string")
+            return;
+        const pending = this.pendingPermissions.get(id);
+        if (!pending) {
+            this.rememberSettledPermission(id);
+            return;
+        }
+        if (typeof properties.sessionID === "string" && properties.sessionID !== pending.sessionId)
+            return;
+        this.rememberSettledPermission(id);
+        this.pendingPermissions.delete(id);
+        this.syncPendingPermissions();
+    }
+    syncPendingPermissions() {
+        const previousId = this.state.pendingApproval?.requestId;
+        this.pendingPermission = this.pendingPermissions.values().next().value ?? null;
+        const requests = Array.from(this.pendingPermissions.values(), (pending) => this.toPendingApproval(pending));
+        this.state.pendingApprovals = requests;
+        this.state.pendingApproval = requests[0] ?? null;
+        this.state.pendingApprovalOrigin = this.pendingPermission?.origin;
+        this.setStatus(requests.length ? "awaiting_approval" : this.state.pendingUserInput ? "awaiting_input" : "busy");
+        this.emit({ type: "approval_state_changed", requests, timestamp: nowIso() });
+        if (requests[0] && requests[0].requestId !== previousId) {
+            this.emit({ type: "approval_required", request: requests[0], timestamp: nowIso() });
+        }
     }
     clearPendingPermissionState() {
+        this.approvalOwnershipGeneration++;
+        const hadPending = this.pendingPermissions.size > 0;
+        for (const id of this.pendingPermissions.keys())
+            this.rememberSettledPermission(id);
+        this.pendingPermissions.clear();
         this.pendingPermission = null;
         this.state.pendingApproval = null;
+        this.state.pendingApprovals = [];
         this.state.pendingApprovalOrigin = undefined;
+        if (hadPending)
+            this.emit({ type: "approval_state_changed", requests: [], timestamp: nowIso() });
     }
     handleQuestionAsked(properties) {
         if (!isRecord(properties) || !this.client) {
@@ -1486,7 +1700,7 @@ export class OpenCodeServerAdapter {
             return;
         }
         const request = {
-            summary: `OpenCode requested answers to ${questions.length} question${questions.length === 1 ? "" : "s"}.`,
+            summary: t("input.request.opencode", { count: questions.length, questions: t(questions.length === 1 ? "input.request.singular" : "input.request.plural") }),
             questions,
         };
         this.pendingQuestion = {
@@ -1497,7 +1711,7 @@ export class OpenCodeServerAdapter {
         this.state.pendingUserInput = request;
         this.state.pendingUserInputOrigin = this.state.activeTurnOrigin;
         this.clearWechatWorkingNotice();
-        this.setStatus("awaiting_input", "OpenCode is waiting for user input.");
+        this.setStatus(this.pendingPermissions.size ? "awaiting_approval" : "awaiting_input", "OpenCode is waiting for user input.");
         this.emit({
             type: "user_input_required",
             request,
@@ -1580,6 +1794,7 @@ export class OpenCodeServerAdapter {
             try {
                 const result = await client.permission.reply({
                     requestID: pendingPermission.permissionId,
+                    sessionID: pendingPermission.sessionId,
                     directory: this.options.cwd,
                     workspace: this.activeWorkspaceId ?? undefined,
                     reply: "reject",
@@ -1623,12 +1838,14 @@ export class OpenCodeServerAdapter {
         const metadata = isRecord(properties.metadata) ? properties.metadata : {};
         const command = this.extractPermissionCommand(properties, metadata);
         return {
+            origin: this.state.activeTurnOrigin,
             sessionId,
             permissionId,
             code: buildOneTimeCode(),
             createdAt: nowIso(),
             request: {
                 source: "cli",
+                requestId: permissionId,
                 summary: title ?? `OpenCode needs approval${toolName ? ` for tool: ${toolName}` : ""}.`,
                 commandPreview: truncatePreview(command ?? title ?? "Permission request", 180),
                 toolName,
@@ -1664,6 +1881,17 @@ export class OpenCodeServerAdapter {
             return;
         }
         const session = this.extractSessionReference(properties);
+        if (session?.parentID) {
+            // Subagent creation is not a visible TUI selection. Remember the child
+            // so its later status/output events cannot implicitly follow it either.
+            this.childSessionIds.add(session.id);
+            const directory = this.extractSessionDirectory(properties);
+            if ((!directory || this.normalizeDirectory(directory) === this.normalizeDirectory(this.options.cwd))
+                && (!session.workspaceID || !this.activeWorkspaceId || session.workspaceID === this.activeWorkspaceId)) {
+                this.childSessionParents.set(session.id, session.parentID);
+            }
+            return;
+        }
         if (this.syncTrackedSessionFromEvent(session)) {
             return;
         }
@@ -1689,6 +1917,31 @@ export class OpenCodeServerAdapter {
         if (!sessionId) {
             return;
         }
+        const removedSessions = new Set([sessionId]);
+        let expanded = true;
+        while (expanded) {
+            expanded = false;
+            for (const [child, parent] of this.childSessionParents) {
+                if (removedSessions.has(parent) && !removedSessions.has(child)) {
+                    removedSessions.add(child);
+                    expanded = true;
+                }
+            }
+        }
+        for (const id of removedSessions) {
+            this.childSessionIds.delete(id);
+            this.childSessionParents.delete(id);
+        }
+        let removedApproval = false;
+        for (const [id, pending] of this.pendingPermissions) {
+            if (removedSessions.has(pending.sessionId)) {
+                this.rememberSettledPermission(id);
+                this.pendingPermissions.delete(id);
+                removedApproval = true;
+            }
+        }
+        if (removedApproval)
+            this.syncPendingPermissions();
         this.previousAgentBySession.delete(sessionId);
         if (sessionId !== this.activeSessionId) {
             return;
@@ -2479,6 +2732,9 @@ export class OpenCodeServerAdapter {
             this.assignActiveSession(session);
             return true;
         }
+        if (this.childSessionIds.has(sessionId)) {
+            return false;
+        }
         if (options.allowLocalTurnFollow !== false && this.shouldFollowLocalTurnSession(sessionId)) {
             this.switchSharedSession(session ?? sessionId, {
                 source: "local",
@@ -2491,6 +2747,9 @@ export class OpenCodeServerAdapter {
         return false;
     }
     extractSessionReference(properties) {
+        const session = isRecord(properties.session) ? properties.session : undefined;
+        const info = isRecord(properties.info) ? properties.info : undefined;
+        const parentID = [properties.parentID, session?.parentID, info?.parentID].find((value) => typeof value === "string" && value.length > 0);
         if (typeof properties.sessionID === "string" || typeof properties.sessionId === "string") {
             const id = typeof properties.sessionID === "string"
                 ? properties.sessionID
@@ -2498,20 +2757,21 @@ export class OpenCodeServerAdapter {
             return {
                 id,
                 workspaceID: this.extractWorkspaceId(properties) ?? undefined,
+                parentID,
             };
         }
-        const session = isRecord(properties.session) ? properties.session : undefined;
         if (typeof session?.id === "string") {
             return {
                 id: session.id,
                 workspaceID: this.extractWorkspaceId(session) ?? this.extractWorkspaceId(properties) ?? undefined,
+                parentID,
             };
         }
-        const info = isRecord(properties.info) ? properties.info : undefined;
         if (typeof info?.id === "string") {
             return {
                 id: info.id,
                 workspaceID: this.extractWorkspaceId(info) ?? this.extractWorkspaceId(properties) ?? undefined,
+                parentID,
             };
         }
         return null;
@@ -2557,7 +2817,7 @@ export class OpenCodeServerAdapter {
             return false;
         }
         const session = this.extractSessionReference(payload);
-        if (!session?.id || session.id === this.activeSessionId) {
+        if (!session?.id || session.parentID || session.id === this.activeSessionId) {
             return false;
         }
         if (typeof event.directory === "string" ||
@@ -2745,6 +3005,16 @@ export class OpenCodeServerAdapter {
         }
     }
     async sendVisibleSessionSelection(session) {
+        if (this.openCodeMajor >= 2) {
+            if (!this.tuiRouteSocket || this.tuiRouteSocket.destroyed) {
+                throw new Error("The OpenCode 2 TUI route bridge is not connected.");
+            }
+            this.tuiRouteSocket.write(`${JSON.stringify({
+                type: "select_session",
+                sessionId: session.id,
+            })}\n`);
+            return;
+        }
         if (!this.client?.tui) {
             return;
         }