@unlinearity/cli-wechat-bridge 1.1.6 → 1.2.0

package/dist/companion/local-companion-start.js

@@ -1,10 +1,18 @@
 #!/usr/bin/env node
+// 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 net from "node:net";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { BRIDGE_LOG_FILE } from "../wechat/channel-config.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
+import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { isDirectModuleRun } from "../core/direct-run.js";
 import { readBridgeLockFile, shouldAutoReclaimBridgeLock, } from "../bridge/bridge-state.js";
 import { clearLocalCompanionOccupancy, clearLocalCompanionEndpoint, readLocalCompanionEndpoint, } from "./local-companion-link.js";
 import { runCodexRemoteClient } from "./codex-remote-client.js";
@@ -15,8 +23,8 @@ const MODULE_DIR = path.dirname(MODULE_FILE);
 const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".js";
 const DEFAULT_WAIT_TIMEOUT_MS = 15_000;
 const DEFAULT_ADAPTER = "codex";
-function log(adapter, message) {
-    process.stderr.write(`[wechat-${adapter}] ${message}\n`);
+function log(adapter, message, channelId = "wechat") {
+    process.stderr.write(`[${channelId}-${adapter}] ${message}\n`);
 }
 export function normalizeComparablePath(cwd) {
     const normalized = path.resolve(cwd);
@@ -37,8 +45,13 @@ export function formatSwitchFailureMessage(cwd) {
 export function formatRestartUnhealthyMessage(cwd) {
     return `Detected unhealthy companion state for ${cwd}. Restarting bridge...`;
 }
-export function defaultSessionStartMode(adapter) {
-    return adapter === "codex" ? "restore" : "new";
+export function defaultSessionStartMode(_adapter) {
+    // Codex 0.155+ persists app-server threads lazily, so launching the visible
+    // client with a freshly prepared (not yet persisted) thread id crashes its
+    // bootstrap with "no rollout found". Start every adapter fresh by default;
+    // explicit --session-start-mode restore remains available for deliberate
+    // restores of already persisted threads.
+    return "new";
 }
 export function decideLaunchAction(input) {
     if (input.lockShouldAutoReclaim) {
@@ -48,6 +61,8 @@ export function decideLaunchAction(input) {
         };
     }
     const sameWorkspace = input.runningLock.adapter === input.requestedAdapter &&
+        (input.runningLock.channelId ?? "wechat") ===
+            (input.requestedChannelId ?? "wechat") &&
         isSameWorkspaceCwd(input.runningLock.cwd, input.requestedCwd);
     if (!sameWorkspace) {
         return {
@@ -99,6 +114,7 @@ export function parseCliArgs(argv) {
     let profile;
     let timeoutMs = DEFAULT_WAIT_TIMEOUT_MS;
     let sessionStartMode;
+    let channelId = "wechat";
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -108,7 +124,7 @@ export function parseCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             const helpAdapter = adapter;
-            const commandName = `wechat-${helpAdapter}`;
+            const commandName = `${channelId}-${helpAdapter}`;
             const adapterLabel = {
                 codex: "Codex",
                 claude: "Claude Code",
@@ -118,7 +134,7 @@ export function parseCliArgs(argv) {
             process.stdout.write([
                 `Usage: ${commandName} [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [--session-start-mode <restore|new>] [...${helpAdapter} args]`,
                 "",
-                "Ensures the WeChat runtime for the current directory, then opens or reuses the visible CLI.",
+                `Ensures the ${channelId === "wecom" ? "WeCom" : "WeChat"} runtime for the current directory, then opens or reuses the visible CLI.`,
                 "If a same-workspace daemon is running, the command delegates to that daemon.",
                 helpAdapter === "codex"
                     ? "Codex restores the current session by default."
@@ -136,6 +152,14 @@ export function parseCliArgs(argv) {
         if (arg === "--doctor") {
             continue;
         }
+        if (arg === "--channel") {
+            if (!next || (next !== "wechat" && next !== "wecom")) {
+                throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
+            }
+            channelId = next;
+            i += 1;
+            continue;
+        }
         if (arg === "--adapter") {
             if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
@@ -189,6 +213,7 @@ export function parseCliArgs(argv) {
         timeoutMs,
         sessionStartMode: sessionStartMode ?? defaultSessionStartMode(adapter),
         cliArgs,
+        channelId,
     };
 }
 function isPidAlive(pid) {
@@ -295,6 +320,9 @@ export function buildBackgroundBridgeArgs(entryPath, options) {
         args.push("--experimental-strip-types");
     }
     args.push(entryPath, "--adapter", options.adapter, "--cwd", options.cwd, "--lifecycle", lifecycle);
+    if (options.channelId === "wecom") {
+        args.push("--channel", "wecom");
+    }
     if (options.sessionStartMode !== "restore") {
         args.push("--session-start-mode", options.sessionStartMode);
     }
@@ -361,6 +389,7 @@ async function ensureBridgeReady(options) {
         endpointIsReachable: Boolean(endpointResult.endpoint),
         companionIsAlive: isCompanionAlive(endpointResult.endpoint),
         sessionStartMode: options.sessionStartMode,
+        requestedChannelId: options.channelId,
     });
     log(options.adapter, decision.message);
     if (decision.kind === "already_active") {
@@ -408,8 +437,13 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         clearEndpoint(endpoint.pid);
         return false;
     }
+    const requestedChannel = options.channelId ?? "wechat";
+    const endpointChannel = endpoint.channelId ?? "wechat";
+    if (requestedChannel !== endpointChannel) {
+        throw new Error(`${endpointChannel}-daemon is running for ${endpoint.cwd}. Stop it before starting the ${requestedChannel} channel.`);
+    }
     if (!isSameWorkspaceCwd(endpoint.cwd, options.cwd)) {
-        throw new Error(`wechat-daemon is running for ${endpoint.cwd}. This launcher requested ${options.cwd}; v1 daemon switching is limited to its startup cwd.`);
+        throw new Error(`${requestedChannel}-daemon is running for ${endpoint.cwd}. This launcher requested ${options.cwd}; v1 daemon switching is limited to its startup cwd.`);
     }
     const response = await sendRequest(endpoint, {
         command: "ensure_slot",
@@ -429,7 +463,7 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         log(options.adapter, `Daemon delegation failed (${response.error ?? "unknown error"}). Falling back to a local bridge.`);
         return false;
     }
-    log(options.adapter, `Delegated to running wechat-daemon for ${options.cwd}.`);
+    log(options.adapter, `Delegated to running ${requestedChannel}-daemon for ${options.cwd}.`, requestedChannel);
     return true;
 }
 export async function runVisibleClient(options, runners = {}) {
@@ -456,6 +490,15 @@ export async function ensureCompanionStartWechatCredentials(adapter, ensureCrede
         log: (message) => log(adapter, message),
     });
 }
+export async function ensureCompanionStartChannelCredentials(options) {
+    if (options.channelId === "wecom") {
+        await ensureWecomAccount({
+            log: (message) => log(options.adapter, message, "wecom"),
+        });
+        return;
+    }
+    await ensureCompanionStartWechatCredentials(options.adapter);
+}
 export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     if (argv.includes("--doctor")) {
         const { runDoctorCheck } = await import("../utils/doctor.js");
@@ -463,7 +506,7 @@ export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
         return 0;
     }
     const options = parseCliArgs(argv);
-    await ensureCompanionStartWechatCredentials(options.adapter);
+    await ensureCompanionStartChannelCredentials(options);
     if (await tryDelegateToDaemon(options)) {
         return 0;
     }
@@ -487,11 +530,19 @@ export async function main(argv = process.argv.slice(2)) {
                 return DEFAULT_ADAPTER;
             }
         })();
-        log(adapter, error instanceof Error ? error.message : String(error));
+        const channelId = (() => {
+            try {
+                return parseCliArgs(argv).channelId ?? "wechat";
+            }
+            catch {
+                return "wechat";
+            }
+        })();
+        log(adapter, error instanceof Error ? error.message : String(error), channelId);
         process.exit(1);
     }
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     void main();
 }

package/dist/companion/local-companion.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env bun
+// 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 net from "node:net";
 import path from "node:path";
 import { createBridgeAdapter } from "../bridge/bridge-adapters.js";
@@ -6,6 +12,7 @@ import { LOCAL_COMPANION_RECONNECT_GRACE_MS, } from "../bridge/bridge-adapters.s
 import { runCodexRemoteClientFromEndpoint } from "./codex-remote-client.js";
 import { attachLocalCompanionMessageListener, readLocalCompanionEndpoint, sendLocalCompanionMessage, } from "./local-companion-link.js";
 import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
+import { isDirectModuleRun } from "../core/direct-run.js";
 export const LOCAL_COMPANION_RECONNECT_RETRY_MS = 250;
 function log(adapter, message) {
     process.stderr.write(`[${adapter}-companion] ${message}\n`);
@@ -230,6 +237,23 @@ export async function runLocalCompanion(options) {
                     publishState();
                     sendResponse(socket, message.id, true);
                     break;
+                case "list_models":
+                    if (!adapter.listModels)
+                        throw new Error("Model listing is not supported by this companion.");
+                    sendResponse(socket, message.id, true, await adapter.listModels());
+                    break;
+                case "select_model":
+                    if (!adapter.selectModel)
+                        throw new Error("Model selection is not supported by this companion.");
+                    sendResponse(socket, message.id, true, await adapter.selectModel(message.payload.modelId));
+                    publishState();
+                    break;
+                case "set_plan_mode":
+                    if (!adapter.setPlanMode)
+                        throw new Error("Plan mode is not supported by this companion.");
+                    sendResponse(socket, message.id, true, await adapter.setPlanMode(message.payload.enabled));
+                    publishState();
+                    break;
                 case "interrupt":
                     sendResponse(socket, message.id, true, await adapter.interrupt());
                     break;
@@ -439,7 +463,7 @@ export async function main(argv = process.argv.slice(2)) {
         process.exit(1);
     }
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     void main();
 }

package/dist/companion/opencode-tui-bridge-plugin.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 net from "node:net";
 const ROUTE_POLL_INTERVAL_MS = 100;
 const MAX_BUFFER_SIZE = 1024 * 1024;

package/dist/companion/pi-tui-bridge-extension.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 net from "node:net";
 import path from "node:path";
@@ -167,7 +173,7 @@ export default function piTuiBridgeExtension(pi) {
             }
         },
     });
-    const executeCommand = (command) => {
+    const executeCommand = async (command) => {
         try {
             if (command.type === "prompt" && typeof command.text === "string") {
                 if (!latestContext?.isIdle()) {
@@ -180,6 +186,59 @@ export default function piTuiBridgeExtension(pi) {
                 latestContext?.abort();
                 writeFrame({ type: "response", id: command.id, success: true });
             }
+            else if (command.type === "list_models") {
+                if (!latestContext) {
+                    throw new Error("Pi session context is not ready.");
+                }
+                const models = latestContext.scopedModels.length > 0
+                    ? latestContext.scopedModels.map((entry) => entry.model)
+                    : latestContext.modelRegistry.getAvailable();
+                writeFrame({
+                    type: "response",
+                    id: command.id,
+                    success: true,
+                    data: {
+                        models: models.map((model) => ({
+                            id: `${model.provider}/${model.id}`,
+                            displayName: model.name
+                                ? `${model.name} (${model.provider})`
+                                : `${model.id} (${model.provider})`,
+                            isCurrent: latestContext?.model?.provider === model.provider &&
+                                latestContext.model.id === model.id,
+                        })),
+                    },
+                });
+            }
+            else if (command.type === "select_model" && typeof command.modelId === "string") {
+                if (!latestContext?.isIdle()) {
+                    throw new Error("Pi TUI is already processing a turn.");
+                }
+                const models = latestContext.scopedModels.length > 0
+                    ? latestContext.scopedModels.map((entry) => entry.model)
+                    : latestContext.modelRegistry.getAvailable();
+                const model = models.find((candidate) => `${candidate.provider}/${candidate.id}` === command.modelId);
+                if (!model) {
+                    throw new Error(`Pi model is no longer available: ${command.modelId}`);
+                }
+                const selected = await pi.setModel(model);
+                if (!selected) {
+                    throw new Error(`Pi could not switch to model: ${command.modelId}`);
+                }
+                writeFrame({
+                    type: "response",
+                    id: command.id,
+                    success: true,
+                    data: {
+                        model: {
+                            id: `${model.provider}/${model.id}`,
+                            displayName: model.name
+                                ? `${model.name} (${model.provider})`
+                                : `${model.id} (${model.provider})`,
+                            isCurrent: true,
+                        },
+                    },
+                });
+            }
             else if (command.type === "new_session" && typeof command.id === "string") {
                 pi.sendUserMessage(`/${INTERNAL_NEW_COMMAND} ${command.id}`, {
                     expandPromptTemplates: true,
@@ -245,7 +304,7 @@ export default function piTuiBridgeExtension(pi) {
             try {
                 const parsed = JSON.parse(line);
                 if (isRecord(parsed)) {
-                    dispatchCommand(parsed);
+                    void dispatchCommand(parsed);
                 }
             }
             catch {
@@ -260,7 +319,7 @@ export default function piTuiBridgeExtension(pi) {
         latestContext = context;
         writeSessionState(context, typeof event.reason === "string" ? event.reason : "startup");
         for (const command of queuedCommands.splice(0)) {
-            executeCommand(command);
+            void executeCommand(command);
         }
     });
     pi.on("input", (event, context) => {

package/dist/core/bridge-control.js

@@ -26,6 +26,16 @@ export function parseBridgeControlCommand(text) {
             return { type: "deny" };
         case "/answer":
             return argument ? { type: "answer", raw: argument } : null;
+        case "/model":
+            return { type: "model", target: argument || undefined };
+        case "/plan":
+            if (!argument || argument.toLowerCase() === "on")
+                return { type: "plan", enabled: true };
+            if (argument.toLowerCase() === "off")
+                return { type: "plan", enabled: false };
+            return null;
+        case "/all":
+            return argument ? { type: "broadcast", text: argument } : null;
         default:
             return null;
     }

package/dist/core/bridge-defer.js

@@ -0,0 +1,25 @@
+export function shouldDeferCodexInboundMessage(params) {
+    return (params.adapter === "codex" &&
+        !params.hasPendingConfirmation &&
+        !params.hasSystemCommand &&
+        params.activeTurnOrigin === "local" &&
+        (params.status === "busy" || params.status === "awaiting_approval"));
+}
+export function canDrainDeferredCodexInboundQueue(params) {
+    return (params.adapter === "codex" &&
+        params.deferredCount > 0 &&
+        !params.hasPendingConfirmation &&
+        !params.hasPendingUserInput &&
+        !params.hasPendingApproval &&
+        !params.hasActiveTask &&
+        !params.activeTurnId &&
+        params.status !== "busy" &&
+        params.status !== "awaiting_approval" &&
+        params.status !== "awaiting_input");
+}
+export function formatDeferredCodexInboundQueueMessage(queuePosition) {
+    return `Queued for delivery after the current local Codex turn finishes. Queue position: ${queuePosition}.`;
+}
+export function isRetryableDeferredCodexDrainError(errorText) {
+    return /still working|approval request is pending|waiting for local terminal input/i.test(errorText);
+}

package/dist/core/channel-driver.js

@@ -0,0 +1 @@
+export {};

package/dist/core/channel-types.js

@@ -1 +1,3 @@
-export {};
+export function normalizeBridgeChannelId(value) {
+    return value === "wecom" ? "wecom" : "wechat";
+}

package/dist/core/conversation-routing.js

@@ -0,0 +1,58 @@
+// 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 { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * Keeps the reply target scoped to one inbound async call chain. Different
+ * conversations may run concurrently without overwriting each other's target.
+ */
+export class InboundConversationContext {
+    storage = new AsyncLocalStorage();
+    run(conversation, callback) {
+        return this.storage.run(conversation, callback);
+    }
+    get() {
+        return this.storage.getStore();
+    }
+}
+export function tryBeginTurn(state, task, conversation) {
+    if (state.activeTask) {
+        return null;
+    }
+    const lease = {
+        task,
+        previousConversation: state.activeConversation,
+        previousLastConversation: state.lastConversation,
+    };
+    state.activeTask = task;
+    if (conversation) {
+        state.activeConversation = conversation;
+        state.lastConversation = conversation;
+    }
+    return lease;
+}
+export function rollbackTurn(state, lease, options = {}) {
+    if (state.activeTask !== lease.task) {
+        return false;
+    }
+    state.activeTask = null;
+    state.activeConversation = lease.previousConversation;
+    if (options.restoreLastConversation) {
+        state.lastConversation = lease.previousLastConversation;
+    }
+    return true;
+}
+export function clearTurn(state, expectedTask) {
+    if (expectedTask && state.activeTask !== expectedTask) {
+        return false;
+    }
+    state.activeTask = null;
+    state.activeConversation = undefined;
+    return true;
+}
+export function resolveConversationTarget(params) {
+    return params.active ?? params.last ?? params.fallback;
+}

package/dist/core/direct-run.js

@@ -0,0 +1,23 @@
+// 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 path from "node:path";
+import { fileURLToPath } from "node:url";
+function normalizeComparablePath(filePath) {
+    const normalized = path.resolve(filePath);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+export function isDirectModuleRun(importMetaUrl, argv = process.argv, importMetaMain) {
+    if (typeof importMetaMain === "boolean") {
+        return importMetaMain;
+    }
+    const entryPath = argv[1];
+    if (!entryPath) {
+        return false;
+    }
+    return normalizeComparablePath(fileURLToPath(importMetaUrl)) ===
+        normalizeComparablePath(entryPath);
+}

package/dist/core/inbound-message-claims.js

@@ -0,0 +1,67 @@
+// 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 path from "node:path";
+export const DEFAULT_INBOUND_MESSAGE_CLAIM_TTL_MS = 10 * 60 * 1000;
+export function buildInboundMessageClaimPath(messageKey, claimsDir) {
+    const fileName = `${crypto.createHash("sha1").update(messageKey).digest("hex")}.json`;
+    return path.join(claimsDir, fileName);
+}
+export function tryClaimChannelInboundMessage(messageKey, options) {
+    if (!messageKey) {
+        return false;
+    }
+    const nowMs = options.nowMs ?? Date.now();
+    const ttlMs = options.ttlMs ?? DEFAULT_INBOUND_MESSAGE_CLAIM_TTL_MS;
+    const claimPath = buildInboundMessageClaimPath(messageKey, options.claimsDir);
+    const attemptClaim = () => {
+        fs.mkdirSync(options.claimsDir, { recursive: true });
+        const handle = fs.openSync(claimPath, "wx");
+        try {
+            fs.writeFileSync(handle, JSON.stringify({
+                key: messageKey,
+                claimedAt: new Date(nowMs).toISOString(),
+                pid: process.pid,
+            }, null, 2), "utf-8");
+        }
+        finally {
+            fs.closeSync(handle);
+        }
+        return true;
+    };
+    try {
+        return attemptClaim();
+    }
+    catch (error) {
+        const code = typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            typeof error.code === "string"
+            ? error.code
+            : "";
+        if (code !== "EEXIST") {
+            return false;
+        }
+    }
+    try {
+        const stat = fs.statSync(claimPath);
+        if (Number.isFinite(stat.mtimeMs) && nowMs - stat.mtimeMs > ttlMs) {
+            fs.rmSync(claimPath, { force: true });
+            return attemptClaim();
+        }
+    }
+    catch {
+        try {
+            return attemptClaim();
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}

package/dist/core/outbound-target.js

@@ -0,0 +1,32 @@
+/**
+ * Outbound target priority for standalone bridges:
+ * 1. an explicit override captured at enqueue time;
+ * 2. for the operator on multi-conversation channels, the pre-resolved turn
+ *    target (callers pass `TurnCoordinator.resolveTarget(operatorConversation)`);
+ * 3. otherwise a direct conversation to the sender.
+ */
+export function resolveOutboundConversationTarget(params) {
+    if (params.override) {
+        return params.override;
+    }
+    if (params.multiConversation && params.senderId === params.operatorId) {
+        return params.operatorTarget;
+    }
+    return params.directConversation(params.senderId);
+}
+/**
+ * Outbound target priority for daemon sends. Multi-conversation operators
+ * resolve through the current inbound conversation first, then the active
+ * slot's remembered target, then the daemon fallback conversation.
+ */
+export function resolveDaemonOutboundTarget(params) {
+    if (params.override) {
+        return params.override;
+    }
+    if (params.multiConversation && params.senderId === params.operatorId) {
+        return params.inboundConversation
+            ?? params.activeSlotTarget
+            ?? params.fallbackConversation;
+    }
+    return params.directConversation(params.senderId);
+}

package/dist/core/text-utils.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.
 const ANSI_ESCAPE_RE = 
 // eslint-disable-next-line no-control-regex
 /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;