dlinkclaw-openclaw 2026.10.19 → 2026.10.21

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dlinkclaw-openclaw",
-    "version": "2026.10.19",
+    "version": "2026.10.21",
     "description": "DLinkClaw OpenClaw channel plugin — 朵联 OpenClaw 接入通道",
     "keywords": [
         "DLinkClaw",

package/dist/src/account.js

@@ -147,7 +147,7 @@ export function checkConfigured(config) {
  * 1. npm install qrcode-terminal
  * 2. 取消顶部 import qrcode 的注释
  * 3. 取消底部 qrcode.generate 的注释
- * 4. 替换 registerUrl 为沃联实际注册地址
+ * 4. 替换 registerUrl 为朵联实际注册地址
  */
 function getDLIntroLines(registerUrl) {
     const lines = [
@@ -163,12 +163,14 @@ function getDLIntroLines(registerUrl) {
     // } catch (_) {
     //     // 二维码生成失败，降级显示纯文本链接
     // }
-    lines.push("📱 扫码或在浏览器打开以下链接注册沃联账号：", registerUrl, "", "━━━ 方式二：已有 APIKEY ━━━", "直接按提示输入即可。");
+    lines.push("📱 扫码或在浏览器打开以下链接注册朵联账号：", registerUrl, "", "━━━ 方式二：已有 APIKEY ━━━", "直接按提示输入即可。");
     return lines;
 }
 export function dlSetupWizard(channelId) {
     return {
         channel: channelId,
+        // 2026-10-22：先输入 BaseUrl（textInputs），再输入 API Key / Secret（credentials）
+        stepOrder: "text-first",
         status: {
             configuredLabel: "已配置 ✓",
             unconfiguredLabel: "需要 baseUrl, APIKey 和 Secret",
@@ -180,11 +182,11 @@ export function dlSetupWizard(channelId) {
                 return configured;
             },
             resolveStatusLines: ({ configured }) => {
-                return [`沃联 WorkRelay: ${configured ? "已配置" : "需要 baseUrl, APIKey 和 Secret"}`];
+                return [`朵联 WorkRelay: ${configured ? "已配置" : "需要 baseUrl, APIKey 和 Secret"}`];
             },
         },
         introNote: {
-            title: "🔧 沃联 WorkRelay 设置向导",
+            title: "🔧 朵联 WorkRelay 设置向导",
             lines: getDLIntroLines(process.env.DL_REGISTER_URL || "https://WorkRelay.cn/register"),
             shouldShow: ({ cfg, accountId }) => {
                 const account = resolveDLAccount({ cfg, accountId }, channelId);
@@ -192,31 +194,13 @@ export function dlSetupWizard(channelId) {
             },
         },
         credentials: [
-            {
-                inputKey: "url",
-                providerHint: "沃联回调地址 (BaseUrl)",
-                credentialLabel: "BaseUrl",
-                envPrompt: "使用环境变量中的 DL_BASEURL?",
-                keepPrompt: "BaseUrl 已配置，保留当前值？",
-                inputPrompt: "请输入沃联回调地址 (BaseUrl):",
-                inspect: ({ cfg, accountId }) => {
-                    const account = resolveDLAccount({ cfg, accountId }, channelId);
-                    const hasValue = Boolean(account.config.baseUrl?.trim());
-                    return {
-                        accountConfigured: hasValue,
-                        hasConfiguredValue: hasValue,
-                        resolvedValue: account.config.baseUrl || undefined,
-                    };
-                },
-                applySet: ({ cfg, accountId, resolvedValue }) => setDLChannelAccountParamsValue({ cfg, accountId, 'param': 'baseUrl', value: resolvedValue }, channelId)
-            },
             {
                 inputKey: "token",
-                providerHint: "沃联 API Key",
+                providerHint: "朵联 API Key",
                 credentialLabel: "API Key",
                 envPrompt: "使用环境变量中的 DL_APIKEY?",
                 keepPrompt: "API Key 已配置，保留当前值？",
-                inputPrompt: "请输入沃联 API Key:",
+                inputPrompt: "请输入朵联 API Key:",
                 inspect: ({ cfg, accountId }) => {
                     const account = resolveDLAccount({ cfg, accountId }, channelId);
                     const hasValue = Boolean(account.config.apiKey?.trim());
@@ -230,11 +214,11 @@ export function dlSetupWizard(channelId) {
             },
             {
                 inputKey: "privateKey",
-                providerHint: "沃联签名密钥 (Secret)",
+                providerHint: "朵联签名密钥 (Secret)",
                 credentialLabel: "Secret",
                 envPrompt: "使用环境变量中的 DL_SECRET?",
                 keepPrompt: "Secret 已配置，保留当前值？",
-                inputPrompt: "请输入沃联签名密钥 (Secret):",
+                inputPrompt: "请输入朵联签名密钥 (Secret):",
                 inspect: ({ cfg, accountId }) => {
                     const account = resolveDLAccount({ cfg, accountId }, channelId);
                     const hasValue = Boolean(account.config.secret?.trim());
@@ -246,7 +230,21 @@ export function dlSetupWizard(channelId) {
                 },
                 applySet: ({ cfg, accountId, resolvedValue }) => setDLChannelAccountParamsValue({ cfg, accountId, 'param': 'secret', value: resolvedValue }, channelId)
             },
-        ]
+        ],
+        // 2026-10-22：BaseUrl 不是密钥，必须放 textInputs；放 credentials 会被向导掩码成 ***
+        textInputs: [
+            {
+                inputKey: "url",
+                message: "请输入朵联回调地址 (BaseUrl):",
+                placeholder: "https://your-dlink-server.example.com",
+                required: true,
+                currentValue: ({ cfg, accountId }) => {
+                    const account = resolveDLAccount({ cfg, accountId }, channelId);
+                    return account.config.baseUrl?.trim() || undefined;
+                },
+                applySet: ({ cfg, accountId, value }) => setDLChannelAccountParamsValue({ cfg, accountId, 'param': 'baseUrl', value }, channelId),
+            },
+        ],
     };
 }
 export function dlSetupAdapter(channelId) {
@@ -323,7 +321,7 @@ export function dlAccountStatus(channelId) {
                     channel: channelId,
                     accountId,
                     kind: "config",
-                    message: "沃联 baseUrl, apiKey, secret 未配置",
+                    message: "朵联 baseUrl, apiKey, secret 未配置",
                     fix: `Run: openclaw channels add ${channelId} --base-url <baseUrl> --apiKey <apiKey> --secret <secret>`,
                 });
             }

package/dist/src/client/dl-client.d.ts

@@ -28,6 +28,8 @@ export interface MqttConfig {
     clientTopics: Array<string>;
     openUserTopics: Array<string>;
     openUserNotifyTopics: Array<string>;
+    /** 2026-10-21：团队创建人 empId（owner-only 能力校验） */
+    ownerEmpId?: string;
 }
 export declare class DLClient extends EventEmitter {
     private ctx;
@@ -66,6 +68,8 @@ export declare class DLClient extends EventEmitter {
      * 而本方法的目的只是刷新 openUserTopics——它是 publishEventToDLClient（L348）实时读取的，
      * 与 MQTT 订阅目标（clientTopics）、Gateway WS 通道都无关 → 只刷新配置即可，不断连、不重连。
      */
+    /** 2026-10-21：团队创建人（终端等 owner-only 能力使用） */
+    getOwnerEmpId(): string | undefined;
     refreshConfigAndReconnect(): Promise<void>;
     exeCmd(cmdMessage: CmdMessage): Promise<CmdResponse | undefined>;
     publishEventToDLClient(payload: any, event: EventType, sqos?: '0' | '1' | '2', to?: string): Promise<void>;

package/dist/src/client/dl-client.js

@@ -276,6 +276,10 @@ export class DLClient extends EventEmitter {
      * 而本方法的目的只是刷新 openUserTopics——它是 publishEventToDLClient（L348）实时读取的，
      * 与 MQTT 订阅目标（clientTopics）、Gateway WS 通道都无关 → 只刷新配置即可，不断连、不重连。
      */
+    /** 2026-10-21：团队创建人（终端等 owner-only 能力使用） */
+    getOwnerEmpId() {
+        return this.mqttConfig?.ownerEmpId;
+    }
     async refreshConfigAndReconnect() {
         try {
             await this.fetchConfig();

package/dist/src/monitor.js

@@ -2,6 +2,7 @@ import { listDuolinkConfiguredAccounts, resolveDLAccount } from "./account.js";
 import { getDLLogger, getDLRuntime } from "./runtime.js";
 import { DLClient } from "./client/dl-client.js";
 import { checkDmPolicy, checkGroupPolicy } from "./policy.js";
+import { bufferPendingMessage } from "./pending-pairing.js";
 import { buildMessageContext, parseMessageContent, routeAndDispatchMessage } from "./client/message.js";
 import { withTimeout } from "./client/timeout.js";
 import { getDLClient, removeDLClient, setDLClient } from "./client/client-manager.js";
@@ -165,6 +166,12 @@ async function duolinkMessageHandler(dlCtx, client) {
         logger
     });
     if (!dmPolicy.allowed) {
+        // 2026-10-22：首次未配对时原消息会被配对码回复取代而丢失，这里暂存，
+        // 由 pairing.approve 审批通过后补发（见 services.ts handleApprove）。
+        if (dmPolicy.pendingPairing) {
+            bufferPendingMessage(relayId, () => duolinkMessageHandler(dlCtx, client));
+            logger.info(`${accountLogInfo} message buffered until pairing approved, relayId=${relayId}`);
+        }
         client.publishToServer({
             streamId: msg.streamId,
             content: '[tag_error_policy_refuse]',

package/dist/src/pending-pairing.d.ts

@@ -0,0 +1,7 @@
+export declare function bufferPendingMessage(key: string, replay: () => Promise<void>): void;
+/**
+ * 补发暂存消息，返回补发条数。
+ * key 为空时补发所有（兜底场景）。
+ */
+export declare function flushPendingMessages(key?: string): number;
+export declare function pendingMessageCount(key?: string): number;

package/dist/src/pending-pairing.js

@@ -0,0 +1,70 @@
+const MAX_PER_KEY = 20;
+const MAX_KEYS = 100;
+const TTL_MS = 10 * 60 * 1000;
+const pending = new Map();
+function purgeExpired(now = Date.now()) {
+    for (const [key, list] of pending) {
+        const alive = list.filter((entry) => now - entry.at <= TTL_MS);
+        if (alive.length === 0) {
+            pending.delete(key);
+        }
+        else {
+            pending.set(key, alive);
+        }
+    }
+}
+export function bufferPendingMessage(key, replay) {
+    if (!key) {
+        return;
+    }
+    const now = Date.now();
+    purgeExpired(now);
+    const list = pending.get(key) ?? [];
+    list.push({ replay, at: now });
+    while (list.length > MAX_PER_KEY) {
+        list.shift();
+    }
+    pending.set(key, list);
+    while (pending.size > MAX_KEYS) {
+        const oldest = pending.keys().next().value;
+        if (oldest === undefined) {
+            break;
+        }
+        pending.delete(oldest);
+    }
+}
+/**
+ * 补发暂存消息，返回补发条数。
+ * key 为空时补发所有（兜底场景）。
+ */
+export function flushPendingMessages(key) {
+    purgeExpired();
+    const keys = key ? [key] : Array.from(pending.keys());
+    let count = 0;
+    for (const k of keys) {
+        const list = pending.get(k);
+        if (!list || list.length === 0) {
+            continue;
+        }
+        pending.delete(k);
+        for (const entry of list) {
+            count += 1;
+            // 串行补发，避免同时打爆消息链路
+            Promise.resolve()
+                .then(() => entry.replay())
+                .catch(() => { });
+        }
+    }
+    return count;
+}
+export function pendingMessageCount(key) {
+    purgeExpired();
+    if (key) {
+        return pending.get(key)?.length ?? 0;
+    }
+    let total = 0;
+    for (const list of pending.values()) {
+        total += list.length;
+    }
+    return total;
+}

package/dist/src/policy.d.ts

@@ -7,6 +7,8 @@ export type DLGroupPolicyCheckResult = {
 export type DmPolicyCheckResult = {
     allowed: boolean;
     allowFrom?: Array<string | number>;
+    /** 2026-10-22：因未配对被拦截（消息可暂存，配对后补发） */
+    pendingPairing?: boolean;
 };
 export declare function checkGroupPolicy(params: {
     chatId: string;

package/dist/src/policy.js

@@ -174,7 +174,8 @@ export async function checkDmPolicy(params) {
         client.publishEventToDLClient(pairingEvent, 'onPairingRequest', '0').catch(err => logger.error(`${logPreTag}发送对码事件失败:${String(err)}`));
     }
     logger.warn(`account[${account.accountId}] sender=${senderId} access denied`);
-    return { allowed: false };
+    // 2026-10-22：pairing 模式下拦截的消息可暂存，审批通过后补发
+    return { allowed: false, pendingPairing: dmPolicy === "pairing" };
 }
 /**
  * 设置 dmPolicy

package/dist/src/services/index.js

@@ -18,7 +18,13 @@ export class CmdHandler {
     isInitialized = false;
     constructor(config, dlClient, logger) {
         this.dlClient = dlClient;
-        this.services = new ClawServices(config, logger);
+        // 2026-10-21：终端输出经 MQTT 事件回推客户端（协议级能力，品牌无关）
+        this.services = new ClawServices(config, logger, (sessionId, data) => {
+            void this.dlClient.publishEventToDLClient({ sessionId, data }, 'onTerminal');
+        }, (payload) => {
+            // 2026-10-22：用量上报走服务端事件，由中继落库
+            void this.dlClient.publishEventToServer(payload, 'onUsage', '1');
+        });
     }
     log(msg, type) {
         this.services.log(msg, type);
@@ -104,13 +110,21 @@ export class CmdHandler {
                 try {
                     const sessionKey = payload.sessionKey;
                     const message = payload.message;
+                    // 2026-10-23：message 可能缺失
+                    if (!message) {
+                        return;
+                    }
                     const role = message.role;
                     if (role !== 'assistant') {
                         return;
                     }
                     //this.log(`onSessionMessage >>> ${JSON.stringify(payload)}`, 'warn');
                     const stopReason = message.stopReason;
-                    const content = message.content ?? [];
+                    // 2026-10-23：content 可能是字符串（非数组），直接 .map 会 TypeError
+                    const rawContent = message.content;
+                    const content = Array.isArray(rawContent)
+                        ? rawContent
+                        : (typeof rawContent === 'string' ? [{ type: 'text', text: rawContent }] : []);
                     const result_contents = content.map(item => {
                         if (item.type === 'thinking') {
                             return item.thinking;
@@ -125,7 +139,8 @@ export class CmdHandler {
                         if (content.length === 0) {
                             return;
                         }
-                        const label = payload.origin.label || undefined;
+                        // 2026-10-23：origin 可能为空，直接取 .label 会 TypeError
+                        const label = payload.origin?.label || undefined;
                         if (!label) {
                             this.log(`不能StreamId...${label}`, 'error');
                             this.dlClient.publishEventToServer({
@@ -216,6 +231,16 @@ export class CmdHandler {
         else {
             this.log(`🔄CMD 指令:${rawMessage.cmd}, params=${JSON.stringify(rawMessage)}`, 'info');
         }
+        // 2026-10-21：终端能力仅限团队创建人（owner）。
+        // from 是客户端自己的 chat topic：usr_/<empId>/chat，与 ownerEmpId 比对即可。
+        if (typeof rawMessage.cmd === 'string' && rawMessage.cmd.startsWith('terminal.')) {
+            const owner = this.dlClient.getOwnerEmpId();
+            const expected = owner ? `usr_/${owner}/chat` : '';
+            if (!owner || rawMessage.from !== expected) {
+                this.log(`terminal denied: from=${rawMessage.from}, owner=${owner}`, 'warn');
+                return { success: false, error: 'terminal: forbidden (owner only)', timestamp: Date.now() };
+            }
+        }
         try {
             // 调用服务层处理
             return await this.services.handleCmdMessage(rawMessage);

package/dist/src/services/services.d.ts

@@ -5,6 +5,7 @@
 import EventEmitter from 'events';
 import { ClawServiceOptions, CmdMessage, CmdResponse } from './types.js';
 import { PluginLogger } from 'openclaw/plugin-sdk/core';
+import { TerminalDataSink } from './terminal.js';
 /**
  * Claw-Services 主类
  * 处理 CMD 消息并调用相应的 OpenClaw API
@@ -14,7 +15,13 @@ export declare class ClawServices extends EventEmitter {
     private readonly options;
     private isInitialized;
     private readonly logger;
-    constructor(options: ClawServiceOptions, logger: PluginLogger);
+    private readonly terminalManager;
+    /** 2026-10-22：token 用量上报（中继落库，按同事聚合） */
+    private readonly usagePublisher?;
+    private usageTimer;
+    constructor(options: ClawServiceOptions, logger: PluginLogger, terminalSink?: TerminalDataSink, usagePublisher?: (payload: Record<string, unknown>) => void);
+    /** 2026-10-22：每 60 秒把最近一天的 token 用量上报中继（幂等 upsert） */
+    private startUsageReporter;
     log(msg: string, type: 'info' | 'warn' | 'error' | 'debug'): void;
     /**
      * 初始化服务
@@ -50,6 +57,14 @@ export declare class ClawServices extends EventEmitter {
      */
     private handleCurrentSessionModel;
     private handleAgentList;
+    /**
+     * 2026-10-22：网关在 agents.create/update 后会做配置热加载，RPC 响应帧可能丢失，
+     * 插件侧 ws-client 默认要干等 30s，导致中继先超时。
+     * 这里对 RPC 加短超时，超时后由调用方回查 listAgents 确认是否已生效。
+     */
+    private rpcWithTimeout;
+    /** 回查 agent 是否已写入（热加载完成后可见） */
+    private findAgentConfirmed;
     private handleAgentCreate;
     private handleAgentUpdate;
     private handleAgentDelete;
@@ -112,6 +127,7 @@ export declare class ClawServices extends EventEmitter {
      * 新增 cmd 通道 agent.stop 指令
      */
     private handleStopAgent;
+    private handleSessionsAbort;
     private handlChatAbout;
     /**
      * 2026-09-06 适配 openclaw 2026.9.1：对码审批改走宿主 RPC channels.pairing.approve（按 requestId）

package/dist/src/services/services.js

@@ -17,6 +17,8 @@ import { getSessionEntry, patchSessionEntry, resolveStorePath, listSessionEntrie
 import { setGatewayClient, approvePairingRequest } from './gateway-rpc.js';
 import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/core';
 import { markRunStopped } from '../runtime.js';
+import { flushPendingMessages } from '../pending-pairing.js';
+import { TerminalManager } from './terminal.js';
 /**
  * Claw-Services 主类
  * 处理 CMD 消息并调用相应的 OpenClaw API
@@ -26,10 +28,50 @@ export class ClawServices extends EventEmitter {
     options;
     isInitialized = false;
     logger;
-    constructor(options, logger) {
+    // 2026-10-21：终端会话管理（PTY / 管道）
+    terminalManager;
+    /** 2026-10-22：token 用量上报（中继落库，按同事聚合） */
+    usagePublisher;
+    usageTimer = null;
+    constructor(options, logger, terminalSink, usagePublisher) {
         super();
         this.options = options;
         this.logger = logger;
+        this.usagePublisher = usagePublisher;
+        this.terminalManager = new TerminalManager(terminalSink ?? (() => { }), (msg, type) => this.log(msg, type ?? 'info'));
+    }
+    /** 2026-10-22：每 60 秒把最近一天的 token 用量上报中继（幂等 upsert） */
+    startUsageReporter() {
+        if (this.usageTimer || !this.usagePublisher) {
+            return;
+        }
+        const tick = async () => {
+            try {
+                // 2026-10-23：上送绝对时间 + 本机时区，业务日由中继按部署时区归并；
+                // 查询窗口取近 48 小时，避免跨日/跨时区边界漏会话（窗口仅用于取数）
+                const capturedAt = Date.now();
+                const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+                const endDate = new Date().toISOString().slice(0, 10);
+                const startDate = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+                const res = await this.rpcWithTimeout(this.client.getSessionsUsage({ agentScope: 'all', startDate, endDate, limit: 1000 }), 15000, 'sessions.usage');
+                const root = res?.data ?? res;
+                const sessions = Array.isArray(root?.sessions)
+                    ? root.sessions
+                    : Array.isArray(root?.aggregates)
+                        ? root.aggregates
+                        : [];
+                if (sessions.length === 0) {
+                    return;
+                }
+                // relayId 由中继按 apiKey 补齐，这里不传
+                this.usagePublisher({ usageDate: endDate, capturedAt, timeZone, sessions });
+            }
+            catch (e) {
+                this.log(`usage reporter: ${String(e)}`, 'debug');
+            }
+        };
+        this.usageTimer = setInterval(() => { void tick(); }, 60_000);
+        void tick();
     }
     log(msg, type) {
         switch (type) {
@@ -104,6 +146,8 @@ export class ClawServices extends EventEmitter {
             });
             await this.client.connect();
             this.isInitialized = true;
+            // 2026-10-22：启动后开始周期上报用量
+            this.startUsageReporter();
             return true;
         }
         catch (error) {
@@ -266,12 +310,29 @@ export class ClawServices extends EventEmitter {
                     // 新增 cmd 通道 chat.abort ， 以上两个/stop, /queue interrupt都不能立即终止执行中的会话
                     result = await this.handlChatAbout(cmdMessage.params);
                     break;
+                case 'sessions.abort':
+                    // 2026-10-24：会话级中止，无 runId 时也能立即停止，并丢弃排队后续
+                    result = await this.handleSessionsAbort(cmdMessage.params);
+                    break;
+                // 2026-10-21：终端能力（owner-only，见 CmdHandler 校验）
+                case 'terminal.open':
+                    result = await this.terminalManager.open(cmdMessage.params);
+                    break;
+                case 'terminal.input':
+                    result = this.terminalManager.write(cmdMessage.params?.sessionId, cmdMessage.params?.data ?? '');
+                    break;
+                case 'terminal.resize':
+                    result = this.terminalManager.resize(cmdMessage.params?.sessionId, cmdMessage.params?.cols, cmdMessage.params?.rows);
+                    break;
+                case 'terminal.close':
+                    result = this.terminalManager.close(cmdMessage.params?.sessionId);
+                    break;
                 case 'pairing.approve':
                     // 2026-09-06 适配 openclaw 2026.9.1：审批改按 requestId（宿主 RPC），客户端由 onPairingRequest 事件获取；
                     // code 保留解析用于旧客户端兼容提示（9.1 起宿主 list 不再暴露 code，无法按 code 审批）
-                    const { requestId, code, empId, accountId } = cmdMessage.params ?? {};
+                    const { requestId, code, empId, accountId, relayId } = cmdMessage.params ?? {};
                     //注意：accountId目前只能为 DEFAULT_ACCOUNT_ID, 本插件不需要使用多账户,服务端提供多帐户服务(openId提供AGENT路由),在安装插件时需提醒使用"default"
-                    result = await this.handleApprove({ requestId, code, empId, accountId: accountId || DEFAULT_ACCOUNT_ID });
+                    result = await this.handleApprove({ requestId, code, empId, relayId, accountId: accountId || DEFAULT_ACCOUNT_ID });
                     break;
                 // 工作区 / Artifact
                 case 'artifacts.list':
@@ -330,10 +391,19 @@ export class ClawServices extends EventEmitter {
      * @param userId
      */
     async handleUpdateSessionModel(params) {
-        const { sessionKey, provider, model } = params;
-        if (!provider || provider.length === 0 || !sessionKey || sessionKey.length === 0) {
+        const { sessionKey, provider, model, thinkingLevel } = params;
+        if (!sessionKey || sessionKey.length === 0) {
             return null;
         }
+        // 2026-10-21：支持「只改推理强度」的 patch；provider/model 与 thinkingLevel 至少给一个
+        if ((!provider || provider.length === 0 || !model || model.length === 0) && !thinkingLevel) {
+            return null;
+        }
+        // 推理强度合法值校验（off/minimal/low/medium/high），非法值直接忽略
+        const THINK_LEVELS = ['off', 'minimal', 'low', 'medium', 'high'];
+        const thinkOverride = thinkingLevel && THINK_LEVELS.includes(thinkingLevel)
+            ? thinkingLevel
+            : undefined;
         const agentId = sessionKey.split(':')[1];
         const { cfg, channelId } = this.options;
         const storePath = resolveStorePath(cfg.session?.store, { agentId });
@@ -346,19 +416,25 @@ export class ClawServices extends EventEmitter {
             storePath,
             sessionKey: realKey,
             update: (entry) => {
-                applyModelOverrideToSessionEntry({
-                    entry,
-                    selection: {
-                        provider: provider,
-                        model: model,
-                    },
-                    selectionSource: 'user',
-                    markLiveSwitchPending: true, // 让当前 run 立即生效
-                });
+                if (provider && model) {
+                    applyModelOverrideToSessionEntry({
+                        entry,
+                        selection: {
+                            provider: provider,
+                            model: model,
+                        },
+                        selectionSource: 'user',
+                        markLiveSwitchPending: true, // 让当前 run 立即生效
+                    });
+                }
+                // 2026-10-21：会话级推理强度写入（与模型覆盖同层持久化）
+                if (thinkOverride) {
+                    entry.thinkingLevel = thinkOverride;
+                }
                 return { ...entry };
             },
         });
-        return { provider, model };
+        return { provider, model, thinkingLevel: thinkOverride };
     }
     /**
      * 2026-08-28 解析 direct 会话的真实 sessionKey（兼容 chatId 后缀）
@@ -369,11 +445,12 @@ export class ClawServices extends EventEmitter {
      * 策略：先精确匹配传入 key；查不到 entry 时，用前缀匹配 store 中 updatedAt 最新的 direct 会话。
      */
     resolveDirectSessionKey(storePath, sessionKey, agentId, channelId) {
-        // 1. 传入 key 直接命中 entry → 直接用
+        // 1. 精确匹配先记下来，但不直接返回：旧的无后缀 key 可能仍存在，
+        //    直接写入会命中过期会话（表现为「切了模型但下一条消息仍用旧模型」）。
         const exact = getSessionEntry({ storePath, sessionKey });
-        if (exact) {
-            return sessionKey;
-        }
+        const exactUpdated = exact
+            ? Number(exact.updatedAt ?? exact.lastActivityAt ?? 0)
+            : -1;
         // 2. 前缀匹配：agent:<agentId>:<channelId>:direct:<...> 开头的最新会话
         const prefix = `agent:${agentId}:${channelId}:direct:`;
         try {
@@ -389,8 +466,9 @@ export class ClawServices extends EventEmitter {
                     bestKey = s.sessionKey;
                 }
             }
-            if (bestKey) {
-                this.log(`resolveDirectSessionKey: ${sessionKey} -> ${bestKey} (前缀匹配最新会话)`, 'info');
+            // 3. 谁更新得更晚就用谁：避免旧 exact 会话把模型覆盖写丢
+            if (bestKey && bestUpdated > exactUpdated) {
+                this.log(`resolveDirectSessionKey: ${sessionKey} -> ${bestKey} (更晚更新的会话)`, 'info');
                 return bestKey;
             }
         }
@@ -417,13 +495,16 @@ export class ClawServices extends EventEmitter {
         if (!entry)
             return null;
         // 只返回用户主动设置的覆盖，不返回 auto fallback
+        const result = {};
         if (entry.modelOverrideSource === 'user' && entry.modelOverride) {
-            return {
-                provider: entry.providerOverride ?? '',
-                model: entry.modelOverride,
-            };
+            result.provider = entry.providerOverride ?? '';
+            result.model = entry.modelOverride;
         }
-        return null;
+        // 2026-10-21：会话级推理强度回显
+        if (entry.thinkingLevel) {
+            result.thinkingLevel = entry.thinkingLevel;
+        }
+        return Object.keys(result).length > 0 ? result : null;
     }
     //#region ==================== Agent 管理处理器 ====================
     async handleAgentList() {
@@ -439,6 +520,43 @@ export class ClawServices extends EventEmitter {
             sessionCount: 0 // 需要额外API调用获取
         }));
     }
+    /**
+     * 2026-10-22：网关在 agents.create/update 后会做配置热加载，RPC 响应帧可能丢失，
+     * 插件侧 ws-client 默认要干等 30s，导致中继先超时。
+     * 这里对 RPC 加短超时，超时后由调用方回查 listAgents 确认是否已生效。
+     */
+    rpcWithTimeout(p, ms, label) {
+        // 避免落败 promise 产生 unhandledRejection
+        void p.catch(() => { });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`${label} rpc timeout after ${ms}ms`)), ms);
+            p.then((v) => { clearTimeout(timer); resolve(v); }, (e) => { clearTimeout(timer); reject(e); });
+        });
+    }
+    /** 回查 agent 是否已写入（热加载完成后可见） */
+    async findAgentConfirmed(params) {
+        const wantedId = (params.id ?? '').toLowerCase();
+        const wantedName = (params.name ?? '').toLowerCase();
+        for (let i = 0; i < 6; i++) {
+            try {
+                const agents = await this.rpcWithTimeout(this.client.listAgents(), 5000, 'agents.list');
+                const found = agents.agents.find((a) => {
+                    const id = (a.id ?? '').toLowerCase();
+                    const nm = (a.name ?? '').toLowerCase();
+                    return (wantedId.length > 0 && (id === wantedId || nm === wantedId))
+                        || (wantedName.length > 0 && (nm === wantedName || id === wantedName));
+                });
+                if (found) {
+                    return found;
+                }
+            }
+            catch {
+                // 热加载期间 list 可能失败，稍后重试
+            }
+            await new Promise((r) => setTimeout(r, 800));
+        }
+        return undefined;
+    }
     async handleAgentCreate(params) {
         const workspace_path = getOpenclawPath('workspace', params.id.toLowerCase().replace(/\s+/g, '-'));
         const provider = params.provider ?? '';
@@ -450,23 +568,36 @@ export class ClawServices extends EventEmitter {
             avatar: (params.avatar && params.avatar.length > 0) ? this.options.baseUrl + params.avatar : undefined,
             model: provider.length > 0 ? `${provider}/${params.model}` : params.model,
         };
-        const result = await this.client.createAgent(createParams);
+        let result;
+        try {
+            result = await this.rpcWithTimeout(this.client.createAgent(createParams), 8000, 'agents.create');
+        }
+        catch (e) {
+            // 响应可能因热加载丢失，但配置已写入 → 回查确认
+            const confirmed = await this.findAgentConfirmed(params);
+            if (!confirmed) {
+                throw e;
+            }
+            this.log(`agents.create 响应超时但已生效：${confirmed.id}`, 'warn');
+            result = { agentId: confirmed.id };
+        }
         // 2026-09-18 修复（石头哥报：首次点击创建失败，且 name 未写入 openclaw.json）：
         // agents.create 后网关是「异步热加载配置」的（日志：create 186ms 成功，紧跟的
         // agents.update 报 agent "xiaoha" not found，1 秒后 config hot reload applied）。
         // 这里改用「update 快速失败重试」：agents.update 对未就绪 agent 是 2ms 快速返回 not found
         // （ws-client.send 在 WS 未连接时也快速抛错），不会挂起；热加载完成后下一次即成功。
         // 避免原 waitAgentReady 用 listAgents 轮询导致客户端 loading 超时的问题。
-        const MAX_UPDATE_RETRY = 10;
+        // 2026-10-22：单次 update 已加 4s 超时，重试次数收紧，避免最坏情况超过中继 30s
+        const MAX_UPDATE_RETRY = 3;
         const UPDATE_RETRY_MS = 500;
         let nameWritten = false;
         for (let i = 0; i < MAX_UPDATE_RETRY && !nameWritten; i++) {
             try {
-                const up = await this.client.updateAgent({
+                const up = await this.rpcWithTimeout(this.client.updateAgent({
                     agentId: result.agentId,
                     name: params.name,
                     workspace: workspace_path,
-                });
+                }), 4000, 'agents.update');
                 if (up?.ok) {
                     nameWritten = true;
                 }
@@ -493,25 +624,45 @@ export class ClawServices extends EventEmitter {
         };
     }
     async handleAgentUpdate(params) {
-        const agents = await this.client.listAgents();
+        let agents;
+        try {
+            agents = await this.rpcWithTimeout(this.client.listAgents(), 5000, 'agents.list');
+        }
+        catch {
+            agents = { agents: [] };
+        }
         const agent = agents.agents.find(a => a.id === params.agentId);
         const provider = params.provider ?? '';
         if (agent) {
             //agent存在直接更新
-            const result = await this.client.updateAgent({
-                agentId: params.agentId,
-                name: params.name,
-                workspace: params.workspace,
-                model: provider.length > 0 ? `${provider}/${params.model}` : params.model,
-                avatar: params.avatar
-            });
+            let result;
+            try {
+                result = await this.rpcWithTimeout(this.client.updateAgent({
+                    agentId: params.agentId,
+                    name: params.name,
+                    workspace: params.workspace,
+                    model: provider.length > 0 ? `${provider}/${params.model}` : params.model,
+                    avatar: params.avatar
+                }), 8000, 'agents.update');
+            }
+            catch (e) {
+                // 响应可能因热加载丢失，但配置已写入 → 回查确认
+                const confirmed = await this.findAgentConfirmed({ id: params.agentId, name: params.name });
+                if (!confirmed) {
+                    throw e;
+                }
+                this.log(`agents.update 响应超时但已生效：${confirmed.id}`, 'warn');
+                result = { agentId: confirmed.id };
+            }
+            // 兼容旧结构：原来的 updateAgent 调用以 result 收尾，这里保持后续逻辑
+            const legacyResult = result;
             const sessionKey = `agent:${params.agentId}:${this.options.channelId}:direct:${params.userId.toLowerCase()}`;
             await this.handleUpdateSessionModel({
                 sessionKey,
                 provider: provider,
                 model: params.model
             });
-            return { id: result.agentId };
+            return { id: legacyResult.agentId };
         }
         //不存在直接创建一个
         const p = {
@@ -821,6 +972,13 @@ export class ClawServices extends EventEmitter {
             sessionKey
         });
     }
+    async handleSessionsAbort(params) {
+        const { sessionKey } = params;
+        if (!sessionKey) {
+            throw new Error('sessions.abort 缺少 sessionKey 参数');
+        }
+        return await this.client?.sessionsAbort({ sessionKey });
+    }
     async handlChatAbout(params) {
         const { sessionKey, runId } = params;
         if (!sessionKey) {
@@ -843,7 +1001,7 @@ export class ClawServices extends EventEmitter {
      *   服务端暂无该端点会 404 噪音）；服务端回调沿用下方 onPairingResult MQTT 事件（7.1 同款链路）
      */
     async handleApprove(params) {
-        const { requestId, code, empId, accountId } = params;
+        const { requestId, code, empId, accountId, relayId } = params;
         if (!requestId) {
             // 旧客户端只传 code：9.1 无公开按 code 审批 API，提示升级（重新对码后事件会带 requestId）
             throw new Error(`审批失败:缺少 requestId${code ? `（code=${code} 已不被支持）` : ''}，请重新触发对码后重试`);
@@ -856,10 +1014,13 @@ export class ClawServices extends EventEmitter {
                 empId,
                 requestId,
             });
+            // 2026-10-22：补发该中继在未配对期间被拦截的消息；返回条数供客户端决定是否兜底重发
+            const replayed = relayId ? flushPendingMessages(relayId) : 0;
             return {
                 success: true,
                 data: {
-                    ...res
+                    ...res,
+                    replayed
                 },
                 timestamp: Date.now()
             };

package/dist/src/services/terminal.d.ts

@@ -0,0 +1,39 @@
+export type TerminalDataSink = (sessionId: string, data: string) => void;
+export type TerminalLogger = (msg: string, type?: 'info' | 'warn' | 'error' | 'debug') => void;
+export declare class TerminalManager {
+    private readonly sink;
+    private readonly log;
+    private readonly sessions;
+    private ptyModule;
+    constructor(sink: TerminalDataSink, log: TerminalLogger);
+    private defaultCwd;
+    private append;
+    private touch;
+    open(params: {
+        sessionId?: string;
+        cwd?: string;
+        cols?: number;
+        rows?: number;
+    }): Promise<{
+        sessionId: string;
+        mode: string;
+        reused: boolean;
+        replay: string;
+    } | {
+        sessionId: string;
+        mode: string;
+        reused?: undefined;
+        replay?: undefined;
+    }>;
+    write(sessionId: string, data: string): {
+        sessionId: string;
+    };
+    resize(sessionId: string, cols: number, rows: number): {
+        sessionId: string;
+    };
+    close(sessionId: string, alreadyExited?: boolean): {
+        sessionId: string;
+        closed: boolean;
+    };
+    disposeAll(): void;
+}

package/dist/src/services/terminal.js

@@ -0,0 +1,217 @@
+/**
+ * 2026-10-21：终端能力（协议级，非 OpenClaw 专属）。
+ * 通过 PTY（可用时）或 child_process 运行登录 shell，输出经 sink 回推客户端。
+ * 其他品牌插件（如 dsh）实现同一套 terminal.* 契约即可。
+ */
+import { spawn } from 'child_process';
+import os from 'os';
+import path from 'path';
+const FLUSH_MS = 16;
+const IDLE_MS = 30 * 60 * 1000;
+/** 重新 attach 时回放的最大输出量 */
+const HISTORY_LIMIT = 64 * 1024;
+/** 优先用 PTY（交互式 shell），不可用时退回管道模式 */
+async function loadPty() {
+    for (const name of ['node-pty', '@lydell/node-pty']) {
+        try {
+            const mod = await import(name);
+            if (mod) {
+                return mod.default ?? mod;
+            }
+        }
+        catch {
+            // 继续尝试下一个
+        }
+    }
+    return null;
+}
+export class TerminalManager {
+    sink;
+    log;
+    sessions = new Map();
+    ptyModule;
+    constructor(sink, log) {
+        this.sink = sink;
+        this.log = log;
+    }
+    defaultCwd() {
+        return path.join(os.homedir(), '.openclaw', 'workspace');
+    }
+    append(session, chunk) {
+        if (session.closed || !chunk) {
+            return;
+        }
+        session.buffer += chunk;
+        if (session.history.length < HISTORY_LIMIT) {
+            session.history += chunk;
+            if (session.history.length > HISTORY_LIMIT) {
+                session.history = session.history.slice(-HISTORY_LIMIT);
+            }
+        }
+        if (session.flushTimer) {
+            return;
+        }
+        // 16ms 合并，避免高频输出打爆 MQTT
+        session.flushTimer = setTimeout(() => {
+            session.flushTimer = null;
+            const data = session.buffer;
+            session.buffer = '';
+            if (data) {
+                try {
+                    this.sink(session.id, data);
+                }
+                catch (e) {
+                    this.log(`terminal sink failed: ${String(e)}`, 'warn');
+                }
+            }
+        }, FLUSH_MS);
+    }
+    touch(session) {
+        if (session.idleTimer) {
+            clearTimeout(session.idleTimer);
+        }
+        session.idleTimer = setTimeout(() => {
+            this.log(`terminal session idle timeout: ${session.id}`, 'info');
+            this.close(session.id);
+        }, IDLE_MS);
+    }
+    async open(params) {
+        const sessionId = params.sessionId;
+        if (!sessionId) {
+            throw new Error('terminal.open: sessionId required');
+        }
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            // 2026-10-21：客户端切 Tab 后重新 attach，回放最近输出，保持会话连续
+            this.touch(existing);
+            return {
+                sessionId,
+                mode: existing.isPty ? 'pty' : 'pipe',
+                reused: true,
+                replay: existing.history,
+            };
+        }
+        if (this.ptyModule === undefined) {
+            this.ptyModule = await loadPty();
+            if (!this.ptyModule) {
+                this.log('node-pty unavailable, fallback to pipe mode (no TTY)', 'warn');
+            }
+        }
+        const cwd = params.cwd && params.cwd.length > 0 ? params.cwd : this.defaultCwd();
+        const cols = params.cols && params.cols > 0 ? params.cols : 120;
+        const rows = params.rows && params.rows > 0 ? params.rows : 30;
+        const env = { ...process.env, TERM: 'xterm-256color', LANG: process.env.LANG ?? 'C.UTF-8' };
+        let proc;
+        let isPty = false;
+        if (this.ptyModule?.spawn) {
+            proc = this.ptyModule.spawn('bash', ['-il'], {
+                name: 'xterm-256color',
+                cols,
+                rows,
+                cwd,
+                env,
+            });
+            isPty = true;
+        }
+        else {
+            proc = spawn('bash', ['-il'], { cwd, env, stdio: 'pipe' });
+            isPty = false;
+        }
+        const session = {
+            id: sessionId,
+            proc,
+            isPty,
+            buffer: '',
+            history: '',
+            flushTimer: null,
+            idleTimer: null,
+            closed: false,
+        };
+        this.sessions.set(sessionId, session);
+        this.touch(session);
+        const onData = (data) => {
+            this.touch(session);
+            this.append(session, typeof data === 'string' ? data : data.toString('utf8'));
+        };
+        if (isPty) {
+            proc.onData(onData);
+            proc.onExit((e) => {
+                this.log(`terminal exited: ${sessionId}, code=${e?.exitCode}`, 'info');
+                this.close(sessionId, true);
+            });
+        }
+        else {
+            proc.stdout?.on('data', onData);
+            proc.stderr?.on('data', onData);
+            proc.on('exit', (code) => {
+                this.log(`terminal exited: ${sessionId}, code=${code}`, 'info');
+                this.close(sessionId, true);
+            });
+            proc.on('error', (err) => {
+                this.log(`terminal error: ${sessionId}, ${err.message}`, 'error');
+                this.append(session, `\r\n[terminal error] ${err.message}\r\n`);
+            });
+        }
+        this.log(`terminal opened: ${sessionId}, mode=${isPty ? 'pty' : 'pipe'}, cwd=${cwd}`, 'info');
+        return { sessionId, mode: isPty ? 'pty' : 'pipe' };
+    }
+    write(sessionId, data) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.closed) {
+            throw new Error('terminal session not found');
+        }
+        this.touch(session);
+        if (session.isPty) {
+            session.proc.write(data);
+        }
+        else {
+            session.proc.stdin?.write(data);
+        }
+        return { sessionId };
+    }
+    resize(sessionId, cols, rows) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.closed) {
+            throw new Error('terminal session not found');
+        }
+        if (session.isPty && session.proc.resize) {
+            session.proc.resize(cols, rows);
+        }
+        return { sessionId };
+    }
+    close(sessionId, alreadyExited = false) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return { sessionId, closed: false };
+        }
+        session.closed = true;
+        if (session.flushTimer) {
+            clearTimeout(session.flushTimer);
+            session.flushTimer = null;
+        }
+        if (session.idleTimer) {
+            clearTimeout(session.idleTimer);
+            session.idleTimer = null;
+        }
+        if (!alreadyExited) {
+            try {
+                if (session.isPty) {
+                    session.proc.kill();
+                }
+                else {
+                    session.proc.kill('SIGHUP');
+                }
+            }
+            catch {
+                // 忽略
+            }
+        }
+        this.sessions.delete(sessionId);
+        return { sessionId, closed: true };
+    }
+    disposeAll() {
+        for (const id of Array.from(this.sessions.keys())) {
+            this.close(id);
+        }
+    }
+}

package/dist/src/services/types.d.ts

@@ -306,7 +306,7 @@ export interface CmdResult {
     timestamp: string | number;
     timezone: string;
 }
-export type CmdType = 'agent.ask' | 'agent.list' | 'agent.create' | 'agent.update' | 'agent.delete' | 'agent.get' | 'agent.stop' | 'chat.abort' | 'task.list' | 'task.create' | 'task.update' | 'task.delete' | 'task.run' | 'status.health' | 'status.system' | 'status.usage' | 'models.list' | 'sessions.list' | 'sessions.get' | 'sessions.describe' | 'sessions.resolve' | 'sessions.create' | 'sessions.archive' | 'sessions.restore' | 'sessions.delete' | 'sessions.reset' | 'sessions.patch' | 'sessions.currentModel' | 'chat.history' | 'chat.trajectory' | 'skills.status' | 'skills.search' | 'skills.detail' | 'skills.install' | 'skills.update' | 'skills.securityVerdicts' | 'cancelMessage' | 'usage.cost' | 'sessions.usage' | 'sessions.usage.logs' | 'pairing.approve' | 'artifacts.list' | 'artifacts.get' | 'artifacts.download' | 'agents.files.list' | 'agents.files.get' | 'extCapabilities.status' | 'extCapabilities.check' | 'extCapabilities.install';
+export type CmdType = 'agent.ask' | 'agent.list' | 'agent.create' | 'agent.update' | 'agent.delete' | 'agent.get' | 'agent.stop' | 'chat.abort' | 'task.list' | 'task.create' | 'task.update' | 'task.delete' | 'task.run' | 'status.health' | 'status.system' | 'status.usage' | 'models.list' | 'sessions.list' | 'sessions.get' | 'sessions.describe' | 'sessions.resolve' | 'sessions.create' | 'sessions.archive' | 'sessions.restore' | 'sessions.delete' | 'sessions.reset' | 'sessions.patch' | 'sessions.currentModel' | 'sessions.abort' | 'terminal.open' | 'terminal.input' | 'terminal.resize' | 'terminal.close' | 'chat.history' | 'chat.trajectory' | 'skills.status' | 'skills.search' | 'skills.detail' | 'skills.install' | 'skills.update' | 'skills.securityVerdicts' | 'cancelMessage' | 'usage.cost' | 'sessions.usage' | 'sessions.usage.logs' | 'pairing.approve' | 'artifacts.list' | 'artifacts.get' | 'artifacts.download' | 'agents.files.list' | 'agents.files.get' | 'extCapabilities.status' | 'extCapabilities.check' | 'extCapabilities.install';
 export type ReadlineType = Extract<CmdType, 'chat.trajectory'>;
 export interface ClawMessage {
     type: 'res' | 'event';
@@ -316,11 +316,15 @@ export interface ClawMessage {
     payload: any;
     error?: any;
 }
-export type EventType = 'onTick' | 'onHealth' | 'onHandshaked' | 'onConnectState' | 'onError' | 'onAgentReply' | 'onAgentChat' | 'onChatTrajectory' | 'onCron' | 'onShutdown' | 'onSessionsChanged' | 'onSkillInstalled' | 'onSkillInstalling' | 'onSkillError' | 'onPairingRequest' | 'onPairingResult';
+export type EventType = 'onTick' | 'onHealth' | 'onHandshaked' | 'onConnectState' | 'onError' | 'onAgentReply' | 'onAgentChat' | 'onChatTrajectory' | 'onCron' | 'onShutdown' | 'onSessionsChanged' | 'onSkillInstalled' | 'onSkillInstalling' | 'onSkillError' | 'onPairingRequest' | 'onPairingResult'
+/** 2026-10-22：周期上报 token 用量 */
+ | 'onUsage' | 'onTerminal';
 export type CmdParamsPatchSessionEntry = {
     sessionKey: string;
     provider?: string;
-    model: string;
+    model?: string;
+    /** 2026-10-21：会话级推理强度（off/minimal/low/medium/high），与模型选择同通道 */
+    thinkingLevel?: string;
 };
 export interface SkillInfo {
     name: string;
@@ -390,3 +394,21 @@ export interface AgentFilesGetParams {
     agentId: string;
     name: string;
 }
+export type TerminalOpenParams = {
+    sessionId: string;
+    cwd?: string;
+    cols?: number;
+    rows?: number;
+};
+export type TerminalInputParams = {
+    sessionId: string;
+    data: string;
+};
+export type TerminalResizeParams = {
+    sessionId: string;
+    cols: number;
+    rows: number;
+};
+export type TerminalCloseParams = {
+    sessionId: string;
+};

package/dist/src/services/ws-client.d.ts

@@ -141,7 +141,11 @@ export declare class WSClient extends EventEmitter {
     }): Promise<any>;
     chatAbort(params: {
         sessionKey: string;
-        runId: string;
+        runId?: string;
+    }): Promise<any>;
+    /** 2026-10-24：会话级中止（无 runId 时使用），同时丢弃排队后续 */
+    sessionsAbort(params: {
+        sessionKey: string;
     }): Promise<any>;
     getSkillSecurityVerdicts(agentId?: string): Promise<any>;
     getUsageCost(params: Record<string, unknown>): Promise<any>;

package/dist/src/services/ws-client.js

@@ -460,10 +460,19 @@ export class WSClient extends EventEmitter {
             method: 'chat.abort',
             params: {
                 sessionKey,
-                runId
+                ...(runId ? { runId } : {})
             }
         });
     }
+    /** 2026-10-24：会话级中止（无 runId 时使用），同时丢弃排队后续 */
+    async sessionsAbort(params) {
+        const { sessionKey } = params;
+        return this.sendRequest({
+            type: 'req',
+            method: 'sessions.abort',
+            params: { sessionKey }
+        });
+    }
     async getSkillSecurityVerdicts(agentId) {
         const params = {};
         if (agentId)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dlinkclaw-openclaw",
-  "version": "2026.10.19",
+  "version": "2026.10.21",
   "description": "DLinkClaw OpenClaw channel plugin — 朵联 OpenClaw 接入通道",
   "keywords": [
     "DLinkClaw",