@unlinearity/cli-wechat-bridge 1.1.6 → 1.2.1

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

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// 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 { spawn as spawnChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import fs from "node:fs";
@@ -6,6 +12,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 ?? "");
@@ -18,7 +25,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);
@@ -77,6 +88,8 @@ export class OpenCodeServerAdapter {
     tuiRoutePort = 0;
     tuiRouteConfigDir = null;
     tuiRouteConfigPath = null;
+    tuiRoutePluginPath = null;
+    openCodeMajor = 1;
     visibleTuiSessionId = null;
     tuiRouteStateReceived = false;
     expectedVisibleTuiSessionId = null;
@@ -85,6 +98,139 @@ export class OpenCodeServerAdapter {
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
     pendingQuestion = null;
+    previousAgentBySession = new Map();
+    async listModels() {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const models = await this.listControlModels();
+        return models.map((model) => ({
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: session.model?.providerID === model.providerID &&
+                session.model.id === model.modelID,
+        }));
+    }
+    async selectModel(modelId) {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const models = await this.listControlModels();
+        const target = models.find((model) => model.id === modelId);
+        if (!target) {
+            throw new Error("This OpenCode model is no longer available. Send /model again.");
+        }
+        const currentVariant = session.model?.variant;
+        const variant = currentVariant && currentVariant !== "default" && target.variants.includes(currentVariant)
+            ? currentVariant
+            : "default";
+        const result = await this.client.v2.session.switchModel({
+            sessionID: session.id,
+            model: {
+                providerID: target.providerID,
+                id: target.modelID,
+                variant,
+            },
+        });
+        this.unwrapOrThrow(result);
+        const updated = await this.getSessionForCurrentDirectory(session.id);
+        if (!updated ||
+            updated.model?.providerID !== target.providerID ||
+            updated.model.id !== target.modelID ||
+            (updated.model.variant ?? "default") !== variant) {
+            throw new Error("OpenCode did not confirm the selected model.");
+        }
+        return { id: target.id, displayName: target.displayName, isCurrent: true };
+    }
+    async setPlanMode(enabled) {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const agents = await this.listPrimaryAgents();
+        const planAgent = agents.find((agent) => agent.name === "plan");
+        if (!planAgent) {
+            throw new Error("OpenCode primary agent 'plan' is not available.");
+        }
+        const currentAgent = session.agent ?? agents[0]?.name;
+        if (!currentAgent) {
+            throw new Error("OpenCode did not return any primary agents.");
+        }
+        if (enabled && currentAgent === "plan") {
+            return true;
+        }
+        if (!enabled && currentAgent !== "plan") {
+            this.previousAgentBySession.delete(session.id);
+            return false;
+        }
+        const previousAgent = this.previousAgentBySession.get(session.id);
+        const target = enabled
+            ? "plan"
+            : agents.some((agent) => agent.name === previousAgent)
+                ? previousAgent
+                : agents.find((agent) => agent.name === "build")?.name ??
+                    agents.find((agent) => agent.name !== "plan")?.name;
+        if (!target) {
+            throw new Error("OpenCode did not return an agent that can replace plan mode.");
+        }
+        const result = await this.client.v2.session.switchAgent({
+            sessionID: session.id,
+            agent: target,
+        });
+        this.unwrapOrThrow(result);
+        const updated = await this.getSessionForCurrentDirectory(session.id);
+        if (!updated || updated.agent !== target) {
+            throw new Error("OpenCode did not confirm the selected agent.");
+        }
+        if (enabled) {
+            this.previousAgentBySession.set(session.id, currentAgent);
+        }
+        else {
+            this.previousAgentBySession.delete(session.id);
+        }
+        return enabled;
+    }
+    assertRemoteControlReady() {
+        if (!this.client) {
+            throw new Error("OpenCode is not running.");
+        }
+        if (this.state.status === "busy") {
+            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.pendingPermission) {
+            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+        }
+        if (this.pendingQuestion) {
+            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+        }
+    }
+    async ensureControlSession() {
+        const session = await this.ensureSession();
+        if (session.id !== this.activeSessionId) {
+            this.switchSharedSession(session, {
+                source: "wechat",
+                reason: "wechat_resume",
+                syncVisible: true,
+                forceVisibleSync: true,
+            });
+        }
+        return session;
+    }
+    async listPrimaryAgents() {
+        if (!this.client)
+            throw new Error("OpenCode is not running.");
+        const agents = this.unwrapOrThrow(await this.client.app.agents({
+            directory: this.options.cwd,
+            workspace: this.activeWorkspaceId ?? undefined,
+        }, { signal: AbortSignal.timeout(10_000) }));
+        return agents.filter((agent) => agent.mode !== "subagent" && !agent.hidden);
+    }
+    async listControlModels() {
+        if (!this.client)
+            throw new Error("OpenCode is not running.");
+        const providers = this.unwrapOrThrow(await this.client.provider.list({ directory: this.options.cwd, workspace: this.activeWorkspaceId ?? undefined }, { signal: AbortSignal.timeout(10_000) }));
+        return providers.all.filter((provider) => providers.connected.includes(provider.id)).flatMap((provider) => Object.entries(provider.models).filter(([id, model]) => model.status !== "deprecated" && !(provider.id === "opencode" && id.includes("-nano"))).map(([id, model]) => ({
+            id: `${provider.id}/${id}`, displayName: `${model.name || id} (${provider.name})`,
+            providerID: provider.id, modelID: id,
+            variants: Object.keys(model.variants ?? {}),
+        })));
+    }
     constructor(options) {
         this.options = options;
         this.state = {
@@ -111,6 +257,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);
@@ -170,10 +317,21 @@ export class OpenCodeServerAdapter {
         this.recordPendingWechatPromptMirrorSuppression(session.id, normalized);
         this.beginTrackedTurn(normalized, "wechat");
         try {
+            const selection = await this.getSessionForCurrentDirectory(session.id) ?? session;
             const result = await this.client.session.promptAsync({
                 sessionID: session.id,
                 directory: this.options.cwd,
                 workspace: session.workspaceID ?? this.activeWorkspaceId ?? undefined,
+                ...(selection.agent ? { agent: selection.agent } : {}),
+                ...(selection.model
+                    ? {
+                        model: {
+                            providerID: selection.model.providerID,
+                            modelID: selection.model.id,
+                        },
+                        variant: selection.model.variant ?? "default",
+                    }
+                    : {}),
                 parts: [{ type: "text", text: normalized }],
             });
             if (result.error !== undefined) {
@@ -411,6 +569,7 @@ export class OpenCodeServerAdapter {
         this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.clearObservedMessageTracking();
         this.recentSdkEventObservations.clear();
+        this.previousAgentBySession.clear();
         this.outputBatcher.clear();
         this.clearStreamedPartState();
         this.clearPendingPermissionState();
@@ -481,13 +640,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: [
                 [
@@ -499,7 +673,6 @@ export class OpenCodeServerAdapter {
                 ],
             ],
         }, null, 2)}\n`, "utf8");
-        this.tuiRouteConfigDir = configDir;
         this.tuiRouteConfigPath = configPath;
     }
     acceptTuiRouteSocket(socket) {
@@ -614,6 +787,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;
@@ -630,6 +804,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");
@@ -735,8 +953,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);
@@ -746,7 +965,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.");
             }
@@ -760,7 +1009,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,
@@ -777,6 +1026,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}`,
@@ -786,7 +1043,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() {
@@ -801,17 +1059,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;
@@ -948,10 +1213,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) {
@@ -1535,7 +1799,11 @@ export class OpenCodeServerAdapter {
             return;
         }
         const sessionId = this.extractSessionId(properties);
-        if (!sessionId || sessionId !== this.activeSessionId) {
+        if (!sessionId) {
+            return;
+        }
+        this.previousAgentBySession.delete(sessionId);
+        if (sessionId !== this.activeSessionId) {
             return;
         }
         this.clearTrackedTurnForLocalSessionSwitch();
@@ -2590,6 +2858,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;
         }

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

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// 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 crypto from "node:crypto";
 import fs from "node:fs";
 import net from "node:net";
@@ -356,6 +362,41 @@ export class PiTuiAdapter {
             this.pendingSessionSwitch = null;
         }
     }
+    async listModels() {
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Wait for the current turn before listing models.");
+        }
+        const response = await this.sendCommand("list_models");
+        if (!isRecord(response.data) || !Array.isArray(response.data.models)) {
+            throw new Error("Pi TUI returned an invalid model list.");
+        }
+        return response.data.models
+            .filter((model) => isRecord(model))
+            .filter((model) => typeof model.id === "string" && typeof model.displayName === "string")
+            .map((model) => ({
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: model.isCurrent === true,
+        }));
+    }
+    async selectModel(modelId) {
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Wait for the current turn before switching models.");
+        }
+        const response = await this.sendCommand("select_model", { modelId });
+        if (!isRecord(response.data) || !isRecord(response.data.model)) {
+            throw new Error("Pi TUI returned an invalid selected model.");
+        }
+        const model = response.data.model;
+        if (typeof model.id !== "string" || typeof model.displayName !== "string") {
+            throw new Error("Pi TUI returned an invalid selected model.");
+        }
+        return {
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: true,
+        };
+    }
     async interrupt() {
         if (!this.socket || this.state.status !== "busy") {
             return false;
@@ -569,6 +610,10 @@ export class PiTuiAdapter {
             else if (this.currentAssistantText) {
                 this.emit({ type: "final_reply", text: this.currentAssistantText, timestamp: nowIso() });
             }
+            // Mirror the other adapters: a settled turn always reports completion so
+            // bridge/daemon ownership state is released even when the turn produced
+            // no visible reply.
+            this.emit({ type: "task_complete", timestamp: nowIso() });
             this.state.lastOutputAt = nowIso();
             this.clearActiveTurn();
             this.setStatus("idle");

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

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// 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 fs from "node:fs";
 import os from "node:os";
 import path from "node:path";

package/dist/bridge/bridge-controller.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// 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 { clearLocalCompanionEndpoint, readLocalCompanionEndpoint, writeLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
 import { hasLocalClientEndpointProvider } from "../runtime/runtime-types.js";
 export class BridgeController {

package/dist/bridge/bridge-final-reply.js

@@ -1,2 +1,8 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// 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.
 /** @deprecated Import from ../channels/wechat/bridge-final-reply.ts instead. */
 export * from "../channels/wechat/bridge-final-reply.js";

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

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// 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 { spawnSync } from "node:child_process";
 import path from "node:path";
 const PEER_BRIDGE_EXIT_TIMEOUT_MS = 4_000;
@@ -113,7 +119,7 @@ function normalizeBridgeProcessRecord(value) {
     }
     return record;
 }
-export function parseWindowsBridgeProcessProbeOutput(stdout, currentPid = process.pid) {
+function parseWindowsProcessProbeRecords(stdout) {
     const trimmed = stdout.trim();
     if (!trimmed) {
         return [];
@@ -128,7 +134,13 @@ export function parseWindowsBridgeProcessProbeOutput(stdout, currentPid = proces
     const values = Array.isArray(parsed) ? parsed : [parsed];
     return values
         .map(normalizeBridgeProcessRecord)
-        .filter((record) => Boolean(record))
+        .filter((record) => Boolean(record));
+}
+export function parseWindowsProcessRecordProbeOutput(stdout, currentPid = process.pid) {
+    return (parseWindowsProcessProbeRecords(stdout).find((record) => record.pid !== currentPid) ?? null);
+}
+export function parseWindowsBridgeProcessProbeOutput(stdout, currentPid = process.pid) {
+    return parseWindowsProcessProbeRecords(stdout)
         .filter((record) => record.pid !== currentPid && isWechatBridgeCommandLine(record.commandLine));
 }
 export function parsePosixBridgeProcessProbeOutput(stdout, currentPid = process.pid) {
@@ -195,10 +207,37 @@ export function listPeerBridgeProcesses(currentPid = process.pid) {
         ? listWindowsBridgeProcesses(currentPid)
         : listPosixBridgeProcesses(currentPid);
 }
+function getWindowsProcessRecordByPid(pid, currentPid = process.pid) {
+    const probe = spawnSync("powershell.exe", [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        [
+            "$ErrorActionPreference='Stop';",
+            `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}'`,
+            "| Select-Object ProcessId,ParentProcessId,Name,CommandLine",
+            "| ConvertTo-Json -Compress",
+        ].join(" "),
+    ], {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 8_000,
+    });
+    if (probe.status !== 0 || typeof probe.stdout !== "string") {
+        return null;
+    }
+    return parseWindowsProcessRecordProbeOutput(probe.stdout, currentPid);
+}
 export function getProcessRecordByPid(pid, currentPid = process.pid) {
     if (!Number.isInteger(pid) || pid <= 0 || pid === currentPid) {
         return null;
     }
+    if (process.platform === "win32") {
+        return getWindowsProcessRecordByPid(pid, currentPid);
+    }
     return listAllProcessesRaw(currentPid).find((record) => record.pid === pid) ?? null;
 }
 export function listWechatDaemonProcesses(params = {}) {