@ynhcj/xiaoyi-channel 0.0.210-beta → 0.0.210-next

package/dist/index.js

@@ -11,6 +11,44 @@ import { registerSelfEvolutionToolResultNudge } from "./src/self-evolution-tool-
 import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
 import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
 import { registerCLIHook } from "./src/tools/hmos-cli.js";
+import { writeSkillUsage } from "./src/utils/skills-logger.js";
+import { logger } from "./src/utils/logger.js";
+/**
+ * Parse a file path string to detect if it refers to a SKILL.md file within
+ * a skills directory. Returns the skill name (parent directory) if so.
+ *
+ * Matches paths like:
+ *   ~/.openclaw/workspace/skills/my-skill/SKILL.md
+ *   /home/user/core_skills/my-skill/SKILL.md
+ *   skills/my-skill/SKILL.md
+ */
+function extractSkillNameFromPath(filePath) {
+    if (typeof filePath !== "string" || !filePath)
+        return null;
+    // Normalize common path prefixes
+    const normalized = filePath.replace(/^~\//, "/home/").replace(/\\/g, "/");
+    // Match: .../skills/<skillName>/SKILL.md  or  .../skills/<skillName>/...
+    // Also match: .../core_skills/<skillName>/SKILL.md
+    const match = normalized.match(/\/(?:core_)?skills\/([^/]+)\/SKILL\.md$/i);
+    return match ? match[1] : null;
+}
+/**
+ * Register the skills diagnostic event listener via after_tool_call hook.
+ *
+ * When openclaw fires a `skill.used` diagnostic event, the skill's SKILL.md
+ * is typically read by the model first.  We detect SKILL.md reads through
+ * the `after_tool_call` hook and write the skill name to the skills log.
+ */
+function registerSkillsDiagnosticHook(api) {
+    api.on("after_tool_call", async (event, _ctx) => {
+        if (event.toolName !== "read")
+            return;
+        const skillName = extractSkillNameFromPath(event.params?.path);
+        if (skillName) {
+            writeSkillUsage(skillName);
+        }
+    });
+}
 /**
  * Register the cron detection hook.
  *
@@ -179,7 +217,10 @@ function registerFullHooks(api) {
         timeoutMs: pluginConfig.skillRetrieverTimeoutMs ?? 1000,
     });
     const beforePromptBuildHandler = createBeforePromptBuildHandler(skillRetrieverConfig);
-    api.on("before_prompt_build", beforePromptBuildHandler);
+    api.on("before_prompt_build", async (event, ctx) => {
+        logger.log(`[BEFORE_PROMPT_BUILD] hook fired, sessionKey=${ctx.sessionKey || "undefined"}, sessionId=${ctx.sessionId || "undefined"}`);
+        return beforePromptBuildHandler(event, ctx);
+    });
     registerSelfEvolutionToolResultNudge(api);
 }
 const pluginEntry = definePluginEntry({
@@ -211,6 +252,8 @@ const pluginEntry = definePluginEntry({
             registerCronDetectionHook(api);
             // CLI exec hook: intercepts built-in exec for HarmonyOS CLI skill tools
             registerCLIHook(api);
+            // Skills diagnostic hook: log skill usage (detected via SKILL.md reads)
+            registerSkillsDiagnosticHook(api);
         }
     },
 });

package/dist/src/bot.d.ts

@@ -24,8 +24,3 @@ export interface HandleXYMessageParams {
  * Runtime is expected to be validated before calling this function.
  */
 export declare function handleXYMessage(params: HandleXYMessageParams): Promise<void>;
-/**
- * 由 provider.ts 在 wrapStreamFn 调用时触发。
- * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
- */
-export declare function notifyModelStreaming(sessionId: string): void;

package/dist/src/bot.js

@@ -7,7 +7,6 @@ import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
 import { appendSelfEvolutionKeywordNudge, shouldNudgeForSelfEvolutionKeyword, } from "./self-evolution-keyword.js";
-import { queueAgentHarnessMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { runWithSessionContext } from "./tools/session-manager.js";
 import { configManager } from "./utils/config-manager.js";
 import { addPushId } from "./utils/pushid-manager.js";
@@ -242,18 +241,20 @@ export async function handleXYMessage(params) {
                     log.error(`[BOT] Failed to patch session model override:`, patchErr);
                 }
             }
-            // 🔑 发送初始状态更新
-            log.log(`[BOT] Sending initial status update`);
-            void sendStatusUpdate({
-                config,
-                sessionId: parsed.sessionId,
-                taskId: parsed.taskId,
-                messageId: parsed.messageId,
-                text: "任务正在处理中，请稍候~",
-                state: "working",
-            }).catch((err) => {
-                log.error(`Failed to send initial status update:`, err);
-            });
+            // 🔑 发送初始状态更新（仅首条消息，steer 不重复发送）
+            if (!isUpdate) {
+                log.log(`[BOT] Sending initial status update`);
+                void sendStatusUpdate({
+                    config,
+                    sessionId: parsed.sessionId,
+                    taskId: parsed.taskId,
+                    messageId: parsed.messageId,
+                    text: "任务正在处理中，请稍候~",
+                    state: "working",
+                }).catch((err) => {
+                    log.error(`Failed to send initial status update:`, err);
+                });
+            }
         }
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
@@ -278,49 +279,26 @@ export async function handleXYMessage(params) {
                 log.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
             }
         }
-        // 🔑 Steer消息: 跳过旧路径直接进入 streaming-signal 队列
-        // /steer 前缀由 dispatchSteerWhenReady 内部添加
-        if (isUpdate) {
-            // 立即释放 init gate——steer 不走 withReplyDispatcher 的 run()
-            // 回调，onInitComplete 永远不会被触发。如果不释放，后续消息
-            // 会被 globalDispatchInitGate 永久阻塞。
-            params.onInitComplete?.();
-            // Steer 也支持文件 —— 提取并下载，附带到 mediaPayload
-            const steerFileParts = extractFileParts(parsed.parts);
-            const steerDownloadedFiles = await downloadFilesFromParts(steerFileParts);
-            const steerMediaPayload = buildXYMediaPayload(steerDownloadedFiles);
-            if (steerFileParts.length > 0) {
-                log.log(`[BOT] Steer message with ${steerFileParts.length} file(s), enqueuing to streaming-signal queue`);
-            }
-            else {
-                log.log(`[BOT] Steer message — enqueuing to streaming-signal queue`);
-            }
-            await enqueueSteer({
-                sessionId: parsed.sessionId,
-                sessionKey: route.sessionKey,
-                steerText: textForAgent, // 原始文本，不带 /steer 前缀
-                mediaPayload: steerMediaPayload,
-                cfg,
-                runtime,
-                parsed,
-                route,
-                deviceType,
-            });
-            log.log(`[BOT] Steer queue completed`);
-            return;
-        }
-        // ── First message (non-steer) path below ──────────────────────
-        // 🔑 立即创建 streaming 信号——必须在文件下载等耗时操作之前，
-        // 否则 steer 消息的 dispatchSteerWhenReady 会找不到信号而跳过等待。
-        createStreamingSignal(parsed.sessionId);
-        // File download — only for real user messages, steer injections have no files
+        // ── Build message and dispatch via auto-reply pipeline ──────────
+        // OpenClaw's auto-reply pipeline (src/auto-reply/reply/agent-runner.ts)
+        // detects active runs and handles steer injection natively — the channel
+        // does not need its own steer detection or polling logic.
+        // File download
         let mediaPayload = {};
-        if (!skipReg) {
+        if (!skipReg || isUpdate) {
             const fileParts = extractFileParts(parsed.parts);
             const downloadedFiles = await downloadFilesFromParts(fileParts);
             log.log(`[BOT] Downloaded ${downloadedFiles.length} file(s)`);
             mediaPayload = buildXYMediaPayload(downloadedFiles);
         }
+        // 🔑 对于 steer 消息，将文件路径附加到消息文本中。
+        // auto-reply 管道的 steer 注入只携带 prompt 文本（followupRun.prompt），
+        // 不携带 mediaPayload，所以模型需要以文本形式看到附件路径。
+        if (isUpdate && mediaPayload.MediaPaths?.length) {
+            const fileHint = `\n【用户上传附件】：${JSON.stringify(mediaPayload.MediaPaths)}`;
+            textForAgent = `${textForAgent}${fileHint}`;
+            log.log(`[BOT] Steer: appended file paths to text`);
+        }
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
@@ -336,12 +314,17 @@ export async function handleXYMessage(params) {
             envelope: envelopeOptions,
             body: messageBody,
         });
+        // 🔑 Steer messages use /steer prefix to trigger the native slash command
+        // fast path in get-reply, which calls handleSteerCommand → queueEmbedded-
+        // AgentMessageWithOutcomeAsync without going through admitReplyTurn or
+        // the isStreaming guard in runReplyAgent.
+        const steerCommandBody = isUpdate ? `/steer ${textForAgent}` : textForAgent;
         // ✅ Finalize inbound context (following feishu pattern)
         // Use route.accountId and route.sessionKey instead of parsed fields
         const ctxPayload = core.channel.reply.finalizeInboundContext({
             Body: body,
-            RawBody: textForAgent,
-            CommandBody: textForAgent,
+            RawBody: steerCommandBody,
+            CommandBody: steerCommandBody,
             From: parsed.sessionId,
             To: parsed.sessionId, // ✅ Simplified: use sessionId as target (context is managed by SessionKey)
             SessionKey: route.sessionKey, // ✅ Use route.sessionKey
@@ -361,8 +344,9 @@ export async function handleXYMessage(params) {
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
         });
-        // 🔑 Streaming 信号已在上方创建（在文件下载之前）
-        const steerState = { steered: false };
+        // 🔑 For steer messages, pre-set steered=true so the dispatcher skips final
+        // response and cleanup — the first message's dispatcher handles those.
+        const steerState = { steered: isUpdate };
         // 🔑 创建dispatcher
         log.log(`[BOT-DISPATCHER] Creating reply dispatcher`);
         // Cleanup: 必须在 onIdle 内部执行（参见 reply-dispatcher.ts 中 onIdleComplete 的注释）
@@ -372,7 +356,6 @@ export async function handleXYMessage(params) {
                 return;
             cleaned = true;
             log.log(`[BOT] Cleanup started`);
-            streamingSignals.delete(parsed.sessionId);
             decrementTaskIdRef(parsed.sessionId);
             log.log(`[BOT] Cleanup completed`);
         };
@@ -388,8 +371,9 @@ export async function handleXYMessage(params) {
         });
         // 🔑 注册 dispatcher 的 fallback taskId 更新函数，供 steer 路径调用
         dispatcherUpdaters.set(parsed.sessionId, updateFallbackTaskId);
-        // Steer injections don't need status intervals
-        if (!skipReg) {
+        // Steer messages don't need a status interval — the first message's
+        // dispatcher already has one running.
+        if (!isUpdate) {
             startStatusInterval();
         }
         // Build session context for AsyncLocalStorage
@@ -427,8 +411,9 @@ export async function handleXYMessage(params) {
                 // signal init complete to release the global dispatch gate
                 // for the next session.
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
-                    log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=false`);
-                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
+                    const isSteerDispatch = isUpdate && !skipReg;
+                    log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=${isSteerDispatch}`);
+                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}, isSteer=${isSteerDispatch}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
                             ctx: ctxPayload,
@@ -436,7 +421,13 @@ export async function handleXYMessage(params) {
                             dispatcher,
                             replyOptions,
                         });
-                        log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, result=${JSON.stringify(result)}`);
+                        // 区分 steer 成功（undefined）和 steer 失败/正常 run（有结果）
+                        if (result === undefined) {
+                            log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned undefined — steer injected successfully`);
+                        }
+                        else {
+                            log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, resultType=${typeof result}, isSteer=${isSteerDispatch}, steered=${steerState.steered}`);
+                        }
                         return result;
                     }
                     catch (dispatchErr) {
@@ -495,115 +486,12 @@ function buildXYMediaPayload(mediaList) {
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
+// ─────────────────────────────────────────────────────────────
+// Dispatcher updaters (cross-chain taskId bridging)
+// ─────────────────────────────────────────────────────────────
 // Use globalThis to survive module deduplication — provider.ts may load a
 // different copy of bot.ts, so a plain module-level Map would be two objects.
 const _g = globalThis;
-if (!_g.__xyStreamingSignals)
-    _g.__xyStreamingSignals = new Map();
-if (!_g.__xySteerQueues)
-    _g.__xySteerQueues = new Map();
 if (!_g.__xyDispatcherUpdaters)
     _g.__xyDispatcherUpdaters = new Map();
-const streamingSignals = _g.__xyStreamingSignals;
-const steerQueues = _g.__xySteerQueues;
 const dispatcherUpdaters = _g.__xyDispatcherUpdaters;
-/**
- * 由 provider.ts 在 wrapStreamFn 调用时触发。
- * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
- */
-export function notifyModelStreaming(sessionId) {
-    const log = logger.withContext(sessionId, "");
-    const signal = streamingSignals.get(sessionId);
-    if (signal) {
-        // 不删除 signal——后续 steer 需要靠它判断模型已在 streaming。
-        // 清理由第一条消息的 onSettled 兜底。
-        signal.notify();
-        log.log(`[STEER-QUEUE] Model streaming signal fired`);
-    }
-}
-function createStreamingSignal(sessionId) {
-    const log = logger.withContext(sessionId, "");
-    let resolve;
-    const promise = new Promise(r => { resolve = r; });
-    const signal = { promise, notify: resolve };
-    streamingSignals.set(sessionId, signal);
-    log.log(`[STEER-QUEUE] Streaming signal created`);
-    return signal;
-}
-/**
- * 将 steer 消息放入 per-session 串行队列。
- * 等待第一条消息的 streaming 信号（deliver 首次触发），然后 dispatch。
- * 多个 steer 按到达顺序串行处理，无需重试。
- */
-function enqueueSteer(params) {
-    const { sessionId } = params;
-    const log = logger.withContext(sessionId, params.parsed.taskId);
-    // 取出当前队列尾部（或 undefined），然后链上新的 Promise
-    const prev = steerQueues.get(sessionId);
-    const next = (prev ?? Promise.resolve()).then(() => dispatchSteerWhenReady(params));
-    steerQueues.set(sessionId, next);
-    // 链条结束后清理
-    next.catch((err) => {
-        log.error(`[STEER-QUEUE] Steer chain failed: ${String(err)}`);
-    }).finally(() => {
-        if (steerQueues.get(sessionId) === next) {
-            steerQueues.delete(sessionId);
-        }
-    });
-    return next;
-}
-async function dispatchSteerWhenReady(params) {
-    const { sessionId, steerText } = params;
-    const log = logger.withContext(sessionId, params.parsed.taskId);
-    // 1. 等待第一条消息开始 streaming
-    //    signal 可能尚未创建（第一条消息还在文件下载等耗时操作中），
-    //    轮询等待直到 signal 出现，最長等待 ~5 秒。
-    let signal = streamingSignals.get(sessionId);
-    if (!signal) {
-        log.log(`[STEER-QUEUE] Signal not yet created, polling`);
-        for (let i = 0; i < 50; i++) {
-            await new Promise(r => setTimeout(r, 100));
-            signal = streamingSignals.get(sessionId);
-            if (signal)
-                break;
-            if (!hasActiveTask(sessionId)) {
-                log.log(`[STEER-QUEUE] First message completed while waiting, skip steer`);
-                return;
-            }
-        }
-    }
-    if (signal) {
-        log.log(`[STEER-QUEUE] Waiting for streaming signal`);
-        await signal.promise;
-        log.log(`[STEER-QUEUE] Streaming signal received`);
-    }
-    else {
-        // 轮询超时且 hasActiveTask 仍为 true——说明第一条消息可能卡在异常路径，
-        // 没有创建 signal。此时放弃，避免并发碰撞。
-        log.log(`[STEER-QUEUE] Signal never appeared after polling, skip steer to avoid collision`);
-        return;
-    }
-    // 2. 第一条消息已结束 → 放弃
-    if (!hasActiveTask(sessionId)) {
-        log.log(`[STEER-QUEUE] First message completed, skip steer`);
-        return;
-    }
-    // 3. 直接注入到活跃的 Pi run 中，不创建独立 dispatcher。
-    //    模型回复通过第一条消息的 dispatcher 的 onPartialReply 流式发出，
-    //    使用 registerTaskId + updateFallbackTaskId 已同步的最新 taskId。
-    const mediaPaths = params.mediaPayload?.MediaPaths;
-    const fileHint = mediaPaths && mediaPaths.length > 0
-        ? `\n【用户上传附件】：${JSON.stringify(mediaPaths)}`
-        : "";
-    const steerMessage = `${steerText}${fileHint}`;
-    log.log(`[STEER-QUEUE] Injecting steer message directly into active run`);
-    const injected = queueAgentHarnessMessage(sessionId, steerMessage, {
-        steeringMode: "all",
-    });
-    if (injected) {
-        log.log(`[STEER-QUEUE] Steer message injected successfully`);
-    }
-    else {
-        log.log(`[STEER-QUEUE] Steer injection failed — run may not be accepting messages`);
-    }
-}

package/dist/src/channel.js

@@ -27,6 +27,7 @@ import { discoverCrossDevicesTool } from "./tools/discover-cross-devices-tool.js
 import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js";
 import { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
 import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
+import { invokeTool } from "./tools/invoke.js";
 const ALL_TOOLS = [
     locationTool,
     discoverCrossDevicesTool,
@@ -50,6 +51,7 @@ const ALL_TOOLS = [
     loginTokenTool,
     agentAsSkillTool,
     checkPluginPrivilegeTool,
+    invokeTool,
 ];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.

package/dist/src/cspl/call_api.js

@@ -3,6 +3,7 @@
  */
 import https from 'https';
 import { URL } from 'url';
+import { logger } from '../utils/logger.js';
 import { getConfig } from './config.js';
 import { DEFAULT_HTTPS_PORT, DEFAULT_HTTP_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
 function buildHeadersForCelia(config, sessionId) {
@@ -69,6 +70,7 @@ function handleResponse(res, resolve, reject) {
         data += chunk;
     });
     res.on('end', () => {
+        logger.log(`[SENTINEL HOOK] callApi response body: ${data}`);
         try {
             const result = parseResponseData(data);
             resolve(result);
@@ -85,6 +87,8 @@ export async function callApi(payload, api, sessionId) {
     const payloadWithUid = { ...payload, uid: config.uid };
     const httpBody = JSON.stringify(payloadWithUid);
     const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
+    logger.log(`[SENTINEL HOOK] callApi URL: ${apiUrl}`);
+    logger.log(`[SENTINEL HOOK] callApi request body: ${httpBody}`);
     return new Promise((resolve, reject) => {
         const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
         const req = https.request(options, (res) => {

package/dist/src/log-reporter/index.js

@@ -32,6 +32,11 @@ const MONITORS = [
         businessType: "openclaw-init",
         jsonParse: false,
     },
+    {
+        path: "/tmp/openclaw/skills-{year}{month}{day}.log",
+        businessType: "openclaw-skill",
+        jsonParse: false,
+    },
 ];
 // ── State ────────────────────────────────────────────────────────────────────
 let intervalId = null;

package/dist/src/monitor.js

@@ -119,8 +119,11 @@ export async function monitorXYProvider(opts = {}) {
                     activeMessages.delete(messageKey);
                 }
             };
-            // 🔑 核心改造：检测steer模式
-            // clearContext / tasks/cancel 没有 params，跳过 parseA2AMessage 直接入队
+            // Steer detection: when queue mode is "steer" and the session has an active
+            // run, process the message concurrently (skip the per-session serial queue).
+            // This prevents the steer message from waiting behind the first message's
+            // completion. The actual steer injection is handled by OpenClaw's auto-reply
+            // pipeline (agent-runner.ts), not by the channel itself.
             const messageMethod = message.method;
             if (messageMethod === "clearContext" || messageMethod === "clear_context"
                 || messageMethod === "tasks/cancel" || messageMethod === "tasks_cancel") {
@@ -135,24 +138,20 @@ export async function monitorXYProvider(opts = {}) {
                     const steerMode = cfg.messages?.queue?.mode === "steer";
                     const hasActiveRun = hasActiveTask(parsed.sessionId);
                     if (steerMode && hasActiveRun) {
-                        // Steer模式且有活跃任务：不入队列，直接并发执行
-                        logger.log(`[MONITOR-HANDLER] STEER MODE: Executing concurrently for messageKey=${messageKey}`);
+                        logger.log(`[MONITOR-HANDLER] STEER MODE: Concurrent execution for ${messageKey}`);
                         void task().catch((err) => {
                             logger.error(`XY gateway: concurrent steer task failed for ${messageKey}: ${String(err)}`);
                             activeMessages.delete(messageKey);
                         });
                     }
                     else {
-                        // 正常模式：入队列串行执行
                         void enqueue(sessionId, task).catch((err) => {
                             logger.error(`XY gateway: queue processing failed: ${String(err)}`);
                             activeMessages.delete(messageKey);
                         });
                     }
                 }
-                catch (parseErr) {
-                    // 解析失败，回退到正常队列模式
-                    logger.error(`[MONITOR-HANDLER] Failed to parse message for steer detection: ${String(parseErr)}`);
+                catch {
                     void enqueue(sessionId, task).catch((err) => {
                         logger.error(`XY gateway: queue processing failed: ${String(err)}`);
                         activeMessages.delete(messageKey);

package/dist/src/provider.js

@@ -11,7 +11,6 @@ import { createHash } from "crypto";
 import { logger } from "./utils/logger.js";
 import { getCurrentSessionContext, setCurrentCronJobId } from "./tools/session-manager.js";
 import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
-import { notifyModelStreaming } from "./bot.js";
 // ── Retry config ──────────────────────────────────────────────
 const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000, 60_000];
 const MAX_RETRY_ATTEMPTS = 5;
@@ -588,17 +587,13 @@ export const xiaoyiProvider = {
             }
             // 记录输入
             logger.log(`[xiaoyiprovider] input messages count: ${context.messages?.length ?? 0}`);
-            // 🔑 通知 steer 队列：模型 API 已被调用，此时 isStreaming 一定为 true
-            const sessionCtx = getCurrentSessionContext();
-            if (sessionCtx?.sessionId) {
-                notifyModelStreaming(sessionCtx.sessionId);
-            }
             if (context.systemPrompt) {
                 logger.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
             }
             // deviceType: prefer text-extracted value, ALS as fallback.
+            const sessionCtx = getCurrentSessionContext();
             const deviceType = extractedDeviceType
-                ?? getCurrentSessionContext()?.deviceType;
+                ?? sessionCtx?.deviceType;
             // app_ver and sdk_api_version from session context (ALS)
             const appVer = sessionCtx?.appVer;
             const sdkApiVersion = sessionCtx?.sdkApiVersion;

package/dist/src/reply-dispatcher.js

@@ -230,6 +230,7 @@ export function createXYReplyDispatcher(params) {
             if (steerState.steered && !hasSentResponse) {
                 scopedLog().log(`[ON-IDLE] Steered dispatch, no response generated, skipping`);
                 stopStatusInterval();
+                await onIdleComplete?.();
                 return;
             }
             // 🔑 用 try/finally 确保 cleanup 在 onIdle 的 async 工作全部完成后才执行。

package/dist/src/skill-retriever/hooks.js

@@ -1,10 +1,10 @@
 import { searchTools, formatToolsForContext, extractUserQuery } from "./tool-search.js";
 import { logger } from "../utils/logger.js";
-const TOOL_RETRIEVER_HEADER = `[系统消息，非用户发言]
-
+const TOOL_RETRIEVER_HEADER = `<system-reminder>
 `;
 const TOOL_RETRIEVER_FOOTER = `
-以上是检索到的、与当前用户请求相关但用户尚未安装的skill，请按照TOOLS.md中find-skills中的[隐式推荐触发规则]来判断是否要给用户推荐。
+以上是与用户请求相关但尚未安装的skill，请按照TOOLS.md中find-skills中的[隐式推荐触发规则]来判断是否要安装并使用。
+</system-reminder>
 `;
 const PLUGIN_LOG_PREFIX = "[skill-retriever]";
 const SKIP_KEYWORDS = ["安装", "装一下", "下载", "查询", "查找", "install", "卸载", "删除", "重载", "定时任务", "重装", "进化"];

package/dist/src/steer-queue.d.ts

@@ -0,0 +1 @@
+export declare function getSteerQueue(): Map<string, string[]>;

package/dist/src/steer-queue.js

@@ -0,0 +1,9 @@
+// Shared steer injection queue — bot.ts writes, index.ts agent_turn_prepare hook reads.
+// Uses globalThis to survive module deduplication (same pattern as dispatcherUpdaters).
+const _g = globalThis;
+if (!_g.__xySteerInjectionQueue) {
+    _g.__xySteerInjectionQueue = new Map();
+}
+export function getSteerQueue() {
+    return _g.__xySteerInjectionQueue;
+}

package/dist/src/task-manager.d.ts

@@ -3,6 +3,8 @@ interface TaskIdBinding {
     currentTaskId: string;
     currentMessageId: string;
     updatedAt: number;
+    /** 引用计数：每次 registerTaskId +1，每次 decrementTaskIdRef -1，归零时删除 */
+    refCount: number;
 }
 /**
  * 注册或更新session的活跃taskId。

package/dist/src/task-manager.js

@@ -19,10 +19,11 @@ const activeTaskIds = _g.__xyActiveTaskIds;
 export function registerTaskId(sessionId, taskId, messageId) {
     const existing = activeTaskIds.get(sessionId);
     if (existing) {
-        logger.log(`[TASK_MANAGER] Updating taskId: ${existing.currentTaskId} → ${taskId}`);
+        logger.log(`[TASK_MANAGER] Updating taskId: ${existing.currentTaskId} → ${taskId}, refCount: ${existing.refCount} → ${existing.refCount + 1}`);
         existing.currentTaskId = taskId;
         existing.currentMessageId = messageId;
         existing.updatedAt = Date.now();
+        existing.refCount++;
         return true; // isUpdate
     }
     else {
@@ -31,8 +32,9 @@ export function registerTaskId(sessionId, taskId, messageId) {
             currentTaskId: taskId,
             currentMessageId: messageId,
             updatedAt: Date.now(),
+            refCount: 1,
         });
-        logger.log(`[TASK_MANAGER] Registered new taskId: ${taskId}`);
+        logger.log(`[TASK_MANAGER] Registered new taskId: ${taskId}, refCount: 1`);
         return false;
     }
 }
@@ -40,8 +42,17 @@ export function registerTaskId(sessionId, taskId, messageId) {
  * 移除session的活跃taskId（消息处理完成时调用）。
  */
 export function decrementTaskIdRef(sessionId) {
-    logger.log(`[TASK_MANAGER] Removing taskId`);
-    activeTaskIds.delete(sessionId);
+    const binding = activeTaskIds.get(sessionId);
+    if (!binding) {
+        logger.log(`[TASK_MANAGER] decrementTaskIdRef: no binding for ${sessionId}`);
+        return;
+    }
+    binding.refCount--;
+    logger.log(`[TASK_MANAGER] decrementTaskIdRef: taskId=${binding.currentTaskId}, refCount: ${binding.refCount + 1} → ${binding.refCount}`);
+    if (binding.refCount <= 0) {
+        activeTaskIds.delete(sessionId);
+        logger.log(`[TASK_MANAGER] Removed taskId binding (refCount reached 0)`);
+    }
 }
 /**
  * 获取session的当前活跃taskId。

package/dist/src/tools/hmos-cli.d.ts

@@ -38,6 +38,11 @@ export interface CLICache {
     getCLIs(skillName: string): CLICacheEntry[] | null;
     getCLI(skillName: string, cliName: string): CLICacheEntry | null;
     hasCLI(skillName: string, cliName: string): boolean;
+    /** Search all cached skills for a CLI whose name matches the command prefix. */
+    findCLIByCommand(command: string): {
+        entry: CLICacheEntry;
+        skillName: string;
+    } | null;
     refresh(): Promise<void>;
     getRootDir(): string;
 }
@@ -90,7 +95,8 @@ interface HookResult {
  * before_tool_call hook for CLI exec interception.
  *
  * Only handles built-in `exec` calls whose command prefix matches a CLI
- * declared in the current skill's metadata.clis + available_clis.json.
+ * from any skill's metadata.clis + available_clis.json (searched across
+ * all cached skills, not just the current session's skill).
  * Non-matching commands return undefined (noop) so native exec handles them.
  */
 export declare function cliBeforeToolCallHandler(event: BeforeToolCallEvent, ctx: HookContext): Promise<HookResult | undefined>;

package/dist/src/tools/hmos-cli.js

@@ -15,6 +15,7 @@ import path from "path";
 import os from "os";
 import { logger } from "../utils/logger.js";
 import { InvokeError, invokeErrorToResult } from "./invoke.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentTaskId } from "../task-manager.js";
@@ -215,6 +216,23 @@ function wrapState(state) {
             return entries.find(e => e.cliName === cliName) ?? null;
         },
         hasCLI(skillName, cliName) { return this.getCLI(skillName, cliName) !== null; },
+        findCLIByCommand(command) {
+            maybeRefresh(state);
+            const all = [];
+            for (const [skillName, entries] of state.skillClis) {
+                for (const entry of entries) {
+                    all.push({ entry, skillName });
+                }
+            }
+            // Longest CLI name first so "foo bar" matches before "foo"
+            all.sort((a, b) => b.entry.cliName.length - a.entry.cliName.length);
+            for (const item of all) {
+                if (command === item.entry.cliName || command.startsWith(item.entry.cliName + " ")) {
+                    return item;
+                }
+            }
+            return null;
+        },
         async refresh() {
             state.skillClis = scanCLIDirectories(state.rootDir);
             state.lastScanMs = Date.now();
@@ -469,7 +487,8 @@ export { parseSkillName as deriveSkillName };
  * before_tool_call hook for CLI exec interception.
  *
  * Only handles built-in `exec` calls whose command prefix matches a CLI
- * declared in the current skill's metadata.clis + available_clis.json.
+ * from any skill's metadata.clis + available_clis.json (searched across
+ * all cached skills, not just the current session's skill).
  * Non-matching commands return undefined (noop) so native exec handles them.
  */
 export async function cliBeforeToolCallHandler(event, ctx) {
@@ -480,37 +499,15 @@ export async function cliBeforeToolCallHandler(event, ctx) {
         return undefined;
     const t0 = performance.now();
     const command = rawCommand.trim();
-    // Need a current skill context
-    const workspaceDir = ctx.workspaceDir;
-    if (!workspaceDir) {
-        logger.log(`[CLI-HOOK] no workspaceDir, noop (${(performance.now() - t0).toFixed(1)}ms)`);
-        return undefined;
-    }
-    const skillName = parseSkillName(workspaceDir);
-    if (!skillName) {
-        logger.log(`[CLI-HOOK] no skill name in ${workspaceDir}, noop (${(performance.now() - t0).toFixed(1)}ms)`);
-        return undefined;
-    }
+    // Search all cached skills for a CLI matching the command prefix
     const cache = getCLICache();
-    const skillCLIs = cache.getCLIs(skillName);
-    if (!skillCLIs || skillCLIs.length === 0) {
-        logger.log(`[CLI-HOOK] Skill '${skillName}' has no CLIs, noop (${(performance.now() - t0).toFixed(1)}ms)`);
-        return undefined;
-    }
-    // Match longest CLI name first
-    const sorted = [...skillCLIs].sort((a, b) => b.cliName.length - a.cliName.length);
-    let matchedCLI = null;
-    for (const entry of sorted) {
-        if (command === entry.cliName || command.startsWith(entry.cliName + " ")) {
-            matchedCLI = entry;
-            break;
-        }
-    }
-    if (!matchedCLI) {
-        logger.log(`[CLI-HOOK] No CLI match for command prefix, noop (${(performance.now() - t0).toFixed(1)}ms)`);
+    const match = cache.findCLIByCommand(command);
+    if (!match) {
+        logger.log(`[CLI-HOOK] No CLI match for '${command}', noop (${(performance.now() - t0).toFixed(1)}ms)`);
         return undefined;
     }
-    logger.log(`[CLI-HOOK] Matched CLI '${matchedCLI.cliName}' (${(performance.now() - t0).toFixed(1)}ms)`);
+    const { entry: matchedCLI, skillName } = match;
+    logger.log(`[CLI-HOOK] Matched CLI '${matchedCLI.cliName}' in skill '${skillName}' (${(performance.now() - t0).toFixed(1)}ms)`);
     // Parse and validate
     let parsed;
     try {
@@ -534,8 +531,8 @@ export async function cliBeforeToolCallHandler(event, ctx) {
             },
         };
     }
-    // Get session context and execute
-    const sessionCtx = (await import("./session-manager.js")).getCurrentSessionContext();
+    // Get session context via ALS (propagated through the async call chain)
+    const sessionCtx = getCurrentSessionContext();
     if (!sessionCtx) {
         logger.warn(`[CLI-HOOK] No session context, blocking (${(performance.now() - t0).toFixed(1)}ms)`);
         return { block: true, blockReason: JSON.stringify({ code: "CONFIG_MISSING", message: "No active session context for CLI execution", retryable: false }) };

package/dist/src/tools/invoke.d.ts

@@ -18,8 +18,6 @@
  *   7. Device executor
  *   8. Invoke tool factory (public API)
  */
-import type { ChannelAgentTool } from "openclaw/plugin-sdk";
-import type { SessionContext } from "./session-manager.js";
 export type InvokeErrorCode = "INVALID_PARAM" | "INVALID_TOOL_DEFINITION" | "CONFIG_MISSING" | "AUTH_FAIL" | "PERMISSION_DENIED" | "CLI_COMMAND_BLOCKED" | "RATE_LIMIT" | "TIMEOUT" | "TOOL_NOT_FOUND" | "TOOL_CONFLICT" | "UNSUPPORTED_PLUGIN_TYPE" | "UNSUPPORTED_PROTOCOL" | "DEVICE_TOOL_BLOCKED" | "UPSTREAM_ERROR" | "NETWORK_ERROR" | "UNKNOWN";
 interface ExecuteResult {
     content: Array<{
@@ -38,11 +36,53 @@ export declare class InvokeError extends Error {
     get status(): number;
 }
 export declare function invokeErrorToResult(error: InvokeError): ExecuteResult;
-/**
- * Create the invoke meta-tool for the given session context.
- *
- * This is the ONLY exported function — the single integration point for
- * create-all-tools.ts.
- */
-export declare function createInvokeTool(ctx: SessionContext): ChannelAgentTool;
+export declare const invokeTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            functionName: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            funcName: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            arguments: {
+                type: string;
+                description: string;
+                properties: {
+                    bundleName: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            params: {
+                type: string;
+                description: string;
+                properties: {
+                    bundleName: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        required: any[];
+        additionalProperties: boolean;
+    };
+    execute(toolCallId: string, rawParams: unknown, _signal?: AbortSignal, _onUpdate?: (partialResult: any) => void): Promise<ExecuteResult>;
+};
 export {};

package/dist/src/tools/invoke.js

@@ -27,6 +27,7 @@ import { logger } from "../utils/logger.js";
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentTaskId } from "../task-manager.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 const RETRYABLE_CODES = new Set([
     "RATE_LIMIT",
     "TIMEOUT",
@@ -46,6 +47,13 @@ const CLIENT_ERROR_CODES = new Set([
     "DEVICE_TOOL_BLOCKED",
     "UNKNOWN",
 ]);
+/** Parse the &-separated taskId into sessionId (part 0) and interactionId (part 1). */
+function parseTaskId(taskId) {
+    const parts = taskId.split("&");
+    const taskSessionId = parts[0] ?? taskId;
+    const interactionId = parseInt(parts[1] ?? "1", 10) || 1;
+    return { taskSessionId, interactionId };
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // 2. Errors
 // ═══════════════════════════════════════════════════════════════════════════
@@ -126,7 +134,7 @@ const REFRESH_INTERVAL_MS = 30_000;
 const REQUIRED_FIELDS = ["schemaVersion", "bundleName", "toolName", "pluginType", "description", "arguments"];
 const CORE_FIELDS = ["bundleName", "toolName", "toolType", "pluginType", "protocol", "description", "arguments", "deviceCommand"];
 const VALID_PLUGIN_TYPES = new Set(["Cloud", "Device", "MCP"]);
-const VALID_PROTOCOLS = new Set(["REST", "SSE", "Websocket"]);
+const VALID_PROTOCOLS = new Set(["REST", "SSE", "Websocket", "WebSocket"]);
 const FILENAME_PATTERN = /^(.+)__(.+)\.json$/;
 const _g = globalThis;
 const CACHE_SLOT = "__xyInvokeToolCache";
@@ -525,13 +533,14 @@ function loadCloudConfig() {
     return { serviceUrl: env["SERVICE_URL"], apiKey: env["PERSONAL-API-KEY"], uid: env["PERSONAL-UID"] };
 }
 function buildCloudRequest(p) {
+    const { taskSessionId, interactionId } = parseTaskId(p.taskId);
     return {
         version: "1.0",
         session: {
             isNew: "true",
-            sessionId: p.sessionId,
-            interactionId: 1,
-            conversationId: uuidv4(),
+            sessionId: taskSessionId,
+            interactionId,
+            conversationId: p.sessionId, // ctx.sessionId
             agentLoginSessionId1: p.agentId,
         },
         endpoint: {
@@ -563,11 +572,11 @@ function buildCloudRequest(p) {
         },
     };
 }
-function buildHeaders(config, skillName, protocol) {
+function buildHeaders(config, skillName, protocol, taskId) {
     return {
         "content-type": "application/json",
         accept: protocol === "REST" ? "application/json" : "text/event-stream",
-        "x-hag-trace-id": uuidv4(),
+        "x-hag-trace-id": taskId,
         "x-uid": config.uid,
         "x-api-key": config.apiKey,
         "x-request-from": "openclaw",
@@ -581,10 +590,10 @@ function buildHeaders(config, skillName, protocol) {
 //   - REST: single JSON frame
 //   - SSE/Websocket: multiple SSE frames; only the final frame is used (§4.7)
 async function executePluginExecutor(config, requestBody, headers, toolName, bundleName, protocol) {
-    // Convert serviceUrl to wss:// regardless of original protocol (http, https, etc.)
-    const wsBaseUrl = config.serviceUrl.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//i, "wss://");
+    // Map http→ws, https→wss
+    const wsBaseUrl = config.serviceUrl.replace(/^http(s)?:\/\//i, "ws$1://");
     const url = `${wsBaseUrl}${UNIFIED_API_SUFFIX}`;
-    const isStreaming = protocol === "SSE" || protocol === "Websocket";
+    const isStreaming = protocol === "SSE" || protocol === "Websocket" || protocol === "WebSocket";
     logger.log(`[INVOKE-CLOUD] calling PluginExecutor via WebSocket`, { url, toolName, bundleName, protocol });
     const urlObj = new URL(url);
     const isWssWithIP = urlObj.protocol === "wss:" && /^(\d{1,3}\.){3}\d{1,3}$/.test(urlObj.hostname);
@@ -856,14 +865,14 @@ async function executeCloudTool(params) {
         toolName, bundleName, skillName, protocol,
         businessKeysCount: Object.keys(businessParams).length,
     });
-    if (protocol !== "REST" && protocol !== "SSE" && protocol !== "Websocket") {
+    if (protocol !== "REST" && protocol !== "SSE" && protocol !== "Websocket" && protocol !== "WebSocket") {
         logger.warn("[INVOKE-CLOUD] unknown protocol", { toolName, bundleName, protocol });
         throw new InvokeError("UNSUPPORTED_PROTOCOL", `Unknown protocol: ${protocol}`);
     }
     // Per invoke.md §4.3: REST, SSE, and Websocket all use the same endpoint.
     // Only the accept header and response handling differ.
     const config = loadCloudConfig();
-    return executePluginExecutor(config, buildCloudRequest(params), buildHeaders(config, skillName, protocol), toolName, bundleName, protocol);
+    return executePluginExecutor(config, buildCloudRequest(params), buildHeaders(config, skillName, protocol, params.taskId), toolName, bundleName, protocol);
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // 7. Device executor
@@ -1066,136 +1075,135 @@ function validateBusinessParams(businessParams, definition) {
     }
     return null;
 }
-/**
- * Create the invoke meta-tool for the given session context.
- *
- * This is the ONLY exported function — the single integration point for
- * create-all-tools.ts.
- */
-export function createInvokeTool(ctx) {
-    return {
-        name: "invoke",
-        label: "Invoke",
-        description: "调用已安装 skill 中声明的工具。必须传 functionName(或funcName) 与 arguments(或params)；functionName 的值等于工具定义中的 toolName；arguments 是包含 bundleName 和业务参数字段的对象；完整业务参数定义见 references/tools/<bundleName>__<toolName>.json。",
-        parameters: {
-            type: "object",
-            properties: {
-                functionName: {
-                    type: "string",
-                    minLength: 1,
-                    description: "工具名称，值等于对应 references/tools JSON 中的 toolName，如 weather_query（优先使用；funcName 已废弃但仍兼容）。",
-                },
-                funcName: {
-                    type: "string",
-                    minLength: 1,
-                    description: "[废弃] 请使用 functionName 替代。工具名称，值等于对应 references/tools JSON 中的 toolName。",
-                },
-                arguments: {
-                    type: "object",
-                    description: "包含定位字段 bundleName 与业务参数字段；除 bundleName 外的字段遵循对应 references/tools JSON 中的 arguments schema（优先使用；params 已废弃但仍兼容）。",
-                    properties: {
-                        bundleName: {
-                            type: "string",
-                            minLength: 1,
-                            description: "HarmonyOS 应用唯一标识，如 com.example.weather。",
-                        },
+// ═══════════════════════════════════════════════════════════════════════════
+// 8. Invoke tool (static — matches ALL_TOOLS pattern)
+// ═══════════════════════════════════════════════════════════════════════════
+export const invokeTool = {
+    name: "invoke",
+    label: "Invoke",
+    description: "调用已安装 skill 中声明的工具。必须传 functionName(或funcName) 与 arguments(或params)；functionName 的值等于工具定义中的 toolName；arguments 是包含 bundleName 和业务参数字段的对象；完整业务参数定义见 references/tools/<bundleName>__<toolName>.json。",
+    parameters: {
+        type: "object",
+        properties: {
+            functionName: {
+                type: "string",
+                minLength: 1,
+                description: "工具名称，值等于对应 references/tools JSON 中的 toolName，如 weather_query（优先使用；funcName 已废弃但仍兼容）。",
+            },
+            funcName: {
+                type: "string",
+                minLength: 1,
+                description: "[废弃] 请使用 functionName 替代。工具名称，值等于对应 references/tools JSON 中的 toolName。",
+            },
+            arguments: {
+                type: "object",
+                description: "包含定位字段 bundleName 与业务参数字段；除 bundleName 外的字段遵循对应 references/tools JSON 中的 arguments schema（优先使用；params 已废弃但仍兼容）。",
+                properties: {
+                    bundleName: {
+                        type: "string",
+                        minLength: 1,
+                        description: "HarmonyOS 应用唯一标识，如 com.example.weather。",
                     },
-                    required: ["bundleName"],
-                    additionalProperties: true,
                 },
-                params: {
-                    type: "object",
-                    description: "[废弃] 请使用 arguments 替代。包含定位字段 bundleName 与业务参数字段。",
-                    properties: {
-                        bundleName: {
-                            type: "string",
-                            minLength: 1,
-                            description: "HarmonyOS 应用唯一标识，如 com.example.weather。",
-                        },
+                required: ["bundleName"],
+                additionalProperties: true,
+            },
+            params: {
+                type: "object",
+                description: "[废弃] 请使用 arguments 替代。包含定位字段 bundleName 与业务参数字段。",
+                properties: {
+                    bundleName: {
+                        type: "string",
+                        minLength: 1,
+                        description: "HarmonyOS 应用唯一标识，如 com.example.weather。",
                     },
-                    required: ["bundleName"],
-                    additionalProperties: true,
                 },
+                required: ["bundleName"],
+                additionalProperties: true,
             },
-            required: [],
-            additionalProperties: false,
         },
-        async execute(toolCallId, rawParams, _signal, _onUpdate) {
-            // Layer 1: input validation
-            const validated = validateAndExtract(rawParams);
-            if ("content" in validated) {
-                logger.warn("[INVOKE] input validation failed", { toolCallId });
-                return validated;
-            }
-            const { toolName, bundleName, businessParams } = validated;
-            const businessKeys = Object.keys(businessParams);
-            logger.log("[INVOKE] tool called", {
-                toolCallId, toolName, bundleName,
-                businessKeys: businessKeys.join(","),
-                businessKeysCount: businessKeys.length,
-            });
-            // Layer 2: cache lookup
-            const cache = getToolCache();
-            const entry = cache.get(bundleName, toolName);
-            if (!entry) {
-                const conflict = cache.getConflict(bundleName, toolName);
-                if (conflict) {
-                    const files = conflict.entries.map((e) => e.filePath).join(", ");
-                    logger.warn("[INVOKE] tool conflict", { toolCallId, toolName, bundleName, conflictCount: conflict.entries.length });
-                    return invokeErrorToResult(new InvokeError("TOOL_CONFLICT", `Multiple conflicting definitions for '${toolName}' in bundle '${bundleName}': ${files}`));
-                }
-                logger.warn("[INVOKE] tool not found", { toolCallId, toolName, bundleName });
-                return invokeErrorToResult(new InvokeError("TOOL_NOT_FOUND", `Tool '${toolName}' not found in bundle '${bundleName}'.`));
+        required: [],
+        additionalProperties: false,
+    },
+    async execute(toolCallId, rawParams, _signal, _onUpdate) {
+        const ctx = getCurrentSessionContext();
+        // Layer 1: input validation
+        const validated = validateAndExtract(rawParams);
+        if ("content" in validated) {
+            logger.warn("[INVOKE] input validation failed", { toolCallId });
+            return validated;
+        }
+        const { toolName, bundleName, businessParams } = validated;
+        const businessKeys = Object.keys(businessParams);
+        logger.log("[INVOKE] tool called", {
+            toolCallId, toolName, bundleName,
+            businessKeys: businessKeys.join(","),
+            businessKeysCount: businessKeys.length,
+        });
+        // Layer 2: cache lookup
+        const cache = getToolCache();
+        const entry = cache.get(bundleName, toolName);
+        if (!entry) {
+            const conflict = cache.getConflict(bundleName, toolName);
+            if (conflict) {
+                const files = conflict.entries.map((e) => e.filePath).join(", ");
+                logger.warn("[INVOKE] tool conflict", { toolCallId, toolName, bundleName, conflictCount: conflict.entries.length });
+                return invokeErrorToResult(new InvokeError("TOOL_CONFLICT", `Multiple conflicting definitions for '${toolName}' in bundle '${bundleName}': ${files}`));
             }
-            const { definition, skillName } = entry;
-            logger.log("[INVOKE] cache hit", {
-                toolCallId, toolName, bundleName, skillName,
-                pluginType: definition.pluginType,
-                protocol: definition.protocol ?? "N/A",
-            });
-            // Layer 2b: business param validation
-            const paramError = validateBusinessParams(businessParams, definition);
-            if (paramError) {
-                logger.warn("[INVOKE] business param validation failed", { toolCallId, toolName, bundleName });
-                return paramError;
+            logger.warn("[INVOKE] tool not found", { toolCallId, toolName, bundleName });
+            return invokeErrorToResult(new InvokeError("TOOL_NOT_FOUND", `Tool '${toolName}' not found in bundle '${bundleName}'.`));
+        }
+        const { definition, skillName } = entry;
+        logger.log("[INVOKE] cache hit", {
+            toolCallId, toolName, bundleName, skillName,
+            pluginType: definition.pluginType,
+            protocol: definition.protocol ?? "N/A",
+        });
+        // Layer 2b: business param validation
+        const paramError = validateBusinessParams(businessParams, definition);
+        if (paramError) {
+            logger.warn("[INVOKE] business param validation failed", { toolCallId, toolName, bundleName });
+            return paramError;
+        }
+        // Layer 3: execute
+        const pluginType = definition.pluginType;
+        logger.log(`[INVOKE] dispatching to ${pluginType} executor`, { toolCallId, toolName, bundleName, pluginType });
+        try {
+            if (pluginType === "Cloud" || pluginType === "MCP") {
+                const result = await executeCloudTool({ definition, businessParams, skillName, sessionId: ctx?.sessionId ?? "", agentId: ctx?.agentId ?? "", taskId: ctx?.taskId ?? toolCallId });
+                logger.log("[INVOKE] cloud execution succeeded", {
+                    toolCallId, toolName, bundleName, pluginType,
+                    resultLength: result.content[0]?.text?.length ?? 0,
+                });
+                return result;
             }
-            // Layer 3: execute
-            const pluginType = definition.pluginType;
-            logger.log(`[INVOKE] dispatching to ${pluginType} executor`, { toolCallId, toolName, bundleName, pluginType });
-            try {
-                if (pluginType === "Cloud" || pluginType === "MCP") {
-                    const result = await executeCloudTool({ definition, businessParams, skillName, sessionId: ctx.sessionId, agentId: ctx.agentId });
-                    logger.log("[INVOKE] cloud execution succeeded", {
-                        toolCallId, toolName, bundleName, pluginType,
-                        resultLength: result.content[0]?.text?.length ?? 0,
-                    });
-                    return result;
+            if (pluginType === "Device") {
+                if (!ctx) {
+                    return invokeErrorToResult(new InvokeError("DEVICE_TOOL_BLOCKED", "Device tools require an active session context."));
                 }
-                if (pluginType === "Device") {
-                    const result = await executeDeviceTool({ definition, businessParams, toolCallId }, ctx);
-                    logger.log("[INVOKE] device execution succeeded", {
-                        toolCallId, toolName, bundleName,
-                        resultLength: result.content[0]?.text?.length ?? 0,
-                    });
-                    return result;
-                }
-                logger.warn("[INVOKE] unsupported pluginType", { toolCallId, toolName, bundleName, pluginType });
-                return invokeErrorToResult(new InvokeError("UNSUPPORTED_PLUGIN_TYPE", `Unsupported pluginType '${pluginType}'. Must be Cloud, Device, or MCP.`));
+                const result = await executeDeviceTool({ definition, businessParams, toolCallId }, ctx);
+                logger.log("[INVOKE] device execution succeeded", {
+                    toolCallId, toolName, bundleName,
+                    resultLength: result.content[0]?.text?.length ?? 0,
+                });
+                return result;
             }
-            catch (err) {
-                if (err instanceof InvokeError) {
-                    logger.warn("[INVOKE] invocation error", {
-                        toolCallId, toolName, bundleName, pluginType,
-                        errorCode: err.code, errorMessage: err.message, retryable: err.retryable,
-                    });
-                    return invokeErrorToResult(err);
-                }
-                logger.error("[INVOKE] unexpected execution error", {
+            logger.warn("[INVOKE] unsupported pluginType", { toolCallId, toolName, bundleName, pluginType });
+            return invokeErrorToResult(new InvokeError("UNSUPPORTED_PLUGIN_TYPE", `Unsupported pluginType '${pluginType}'. Must be Cloud, Device, or MCP.`));
+        }
+        catch (err) {
+            if (err instanceof InvokeError) {
+                logger.warn("[INVOKE] invocation error", {
                     toolCallId, toolName, bundleName, pluginType,
-                    error: err instanceof Error ? `${err.name}: ${err.message}` : String(err),
+                    errorCode: err.code, errorMessage: err.message, retryable: err.retryable,
                 });
-                return unknownErrorToResult(err);
+                return invokeErrorToResult(err);
             }
-        },
-    };
-}
+            logger.error("[INVOKE] unexpected execution error", {
+                toolCallId, toolName, bundleName, pluginType,
+                error: err instanceof Error ? `${err.name}: ${err.message}` : String(err),
+            });
+            return unknownErrorToResult(err);
+        }
+    },
+};

package/dist/src/utils/skills-logger.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Write a skill-usage record to the skills log.
+ * Format: |YYYYMMDDThhmmss|skillName|
+ */
+export declare function writeSkillUsage(skillName: string): void;

package/dist/src/utils/skills-logger.js

@@ -0,0 +1,76 @@
+// Skills usage logger
+// Format: |timestamp|skillName|
+import { mkdirSync, readdirSync, unlinkSync, statSync } from "fs";
+import { join } from "path";
+import pino from "pino";
+// ── Configuration ──
+const LOG_DIR = "/tmp/openclaw";
+const LOG_PREFIX = "skills";
+const MAX_AGE_DAYS = 30;
+// ── UTC+8 helpers ──
+function getTodayDateStr() {
+    const utc8 = new Date(Date.now() + 8 * 60 * 60 * 1000);
+    return `${utc8.getUTCFullYear()}${String(utc8.getUTCMonth() + 1).padStart(2, "0")}${String(utc8.getUTCDate()).padStart(2, "0")}`;
+}
+function formatTimestampUTC8() {
+    const utc8 = new Date(Date.now() + 8 * 60 * 60 * 1000);
+    const y = utc8.getUTCFullYear();
+    const M = String(utc8.getUTCMonth() + 1).padStart(2, "0");
+    const D = String(utc8.getUTCDate()).padStart(2, "0");
+    const h = String(utc8.getUTCHours()).padStart(2, "0");
+    const m = String(utc8.getUTCMinutes()).padStart(2, "0");
+    const s = String(utc8.getUTCSeconds()).padStart(2, "0");
+    return `${y}${M}${D}T${h}${m}${s}`;
+}
+function getLogFilePath(dateStr) {
+    return join(LOG_DIR, `${LOG_PREFIX}-${dateStr ?? getTodayDateStr()}.log`);
+}
+// ── Ensure log directory ──
+try {
+    mkdirSync(LOG_DIR, { recursive: true });
+}
+catch { }
+// ── Cleanup expired logs (older than MAX_AGE_DAYS) ──
+function cleanupOldLogs() {
+    try {
+        const files = readdirSync(LOG_DIR);
+        const cutoff = Date.now() - MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+        for (const f of files) {
+            if (!f.startsWith(LOG_PREFIX) || !f.endsWith(".log"))
+                continue;
+            const fp = join(LOG_DIR, f);
+            try {
+                if (statSync(fp).mtimeMs < cutoff)
+                    unlinkSync(fp);
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+// Run cleanup on module load
+cleanupOldLogs();
+// Schedule periodic cleanup every 6 hours
+const cleanupTimer = setInterval(cleanupOldLogs, 6 * 60 * 60 * 1000);
+cleanupTimer.unref?.();
+// ── File destination with daily rotation ──
+let currentDate = getTodayDateStr();
+const dest = pino.destination({ dest: getLogFilePath(currentDate), sync: false, mkdir: true });
+// ── Rotation check ──
+function checkRotation() {
+    const today = getTodayDateStr();
+    if (today !== currentDate) {
+        currentDate = today;
+        dest.reopen(getLogFilePath(today));
+        cleanupOldLogs();
+    }
+}
+/**
+ * Write a skill-usage record to the skills log.
+ * Format: |YYYYMMDDThhmmss|skillName|
+ */
+export function writeSkillUsage(skillName) {
+    checkRotation();
+    const timestamp = formatTimestampUTC8();
+    dest.write(`|${timestamp}|${skillName}|\n`);
+}

package/dist/src/websocket.js

@@ -512,6 +512,7 @@ export class XYWebSocketManager extends EventEmitter {
                 ? logger.withContext(sessionId, taskId)
                 : { log: (msg, ...args) => logger.log(msg, ...args) };
             log.log(`[WS-RECV] Raw message frame, size: ${messageStr.length} characters`);
+            log.log(`[WS-RECV] Full message body: ${messageStr}`);
             // Handle direct cross-task requests (top-level networkId)
             const directRunCrossTaskRequest = this.toRunCrossTaskA2ARequest(parsed);
             if (directRunCrossTaskRequest) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.210-beta",
+  "version": "0.0.210-next",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",