@ynhcj/xiaoyi-channel 0.0.190-beta → 0.0.192-beta

package/dist/index.js

@@ -3,7 +3,10 @@ import { xiaoyiProvider } from "./src/provider.js";
 import { xyPlugin } from "./src/channel.js";
 import registerSentinelHook from "./src/cspl/sentinel_hook.js";
 import { setXYRuntime } from "./src/runtime.js";
-import { markCronToolCall, clearCronToolCall } from "./src/tools/session-manager.js";
+import { markCronToolCall, clearCronToolCall, getSessionContext } from "./src/tools/session-manager.js";
+import { configManager } from "./src/utils/config-manager.js";
+import { setJobPushId } from "./src/utils/cron-push-map.js";
+import { getAllPushIds } from "./src/utils/pushid-manager.js";
 import { registerSelfEvolutionToolResultNudge } from "./src/self-evolution-tool-result-nudge.js";
 import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
 import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
@@ -25,8 +28,145 @@ function registerCronDetectionHook(api) {
         if (event.toolCallId) {
             clearCronToolCall(event.toolCallId);
         }
+        // 捕获对话创建的 cron job：agent 调 cron(add) 后，从 result 拿 jobId，
+        // 配合当前会话的 pushId，写入 jobId↔pushId 映射，供 fire 时反查设备。
+        await captureCronAddMapping(event, ctx).catch((err) => {
+            // 捕获失败不影响工具结果
+            console.error("[xy] captureCronAddMapping failed:", err);
+        });
     });
 }
+/** 从 cron add 工具结果中提取 jobId 并写入 pushId 映射。 */
+async function captureCronAddMapping(event, ctx) {
+    // 两条创建路径都要捕获：
+    //   1) cron agent 工具：toolName==="cron", params.action==="add"
+    //   2) exec 跑 CLI：toolName==="exec", params.command 含 "cron add"
+    //      （agent 实际用的是这条：openclaw cron add --name ... --cron ... --message ...）
+    const isCronAddTool = event.toolName === "cron" &&
+        (event.params?.action === "add" || event.params?.action === "create");
+    const isExecCronAdd = event.toolName === "exec" && isExecCronAddCommand(event.params?.command);
+    if (!isCronAddTool && !isExecCronAdd)
+        return;
+    console.log(`[CRONMAP] after_tool_call path=${event.toolName}, resultType=${typeof event.result}`);
+    const jobId = readJobIdFromResult(event.result);
+    if (!jobId) {
+        console.log(`[CRONMAP] skip: could not extract jobId. preview=${preview(event.result)}`);
+        return;
+    }
+    console.log(`[CRONMAP] extracted jobId=${jobId}`);
+    const sessionCtx = ctx.sessionKey ? getSessionContext(ctx.sessionKey) : null;
+    const sessionId = sessionCtx?.sessionId;
+    if (!sessionId) {
+        console.log(`[CRONMAP] skip: no sessionId (sessionKey=${ctx.sessionKey}, ctxFound=${!!sessionCtx})`);
+        return;
+    }
+    const pushId = await resolvePushId(sessionId);
+    if (!pushId) {
+        console.log(`[CRONMAP] skip: no pushId available for sessionId=${sessionId} (no session match, no global, no file)`);
+        return;
+    }
+    console.log(`[CRONMAP] writing map: jobId=${jobId}, sessionId=${sessionId}, pushId=${pushId.substring(0, 16)}...`);
+    await setJobPushId(jobId, {
+        pushId,
+        sessionId,
+        deviceType: sessionCtx?.deviceType,
+        source: event.toolName === "exec" ? "exec-cli" : "conversation",
+    });
+    console.log(`[CRONMAP] map written OK`);
+}
+/** 回退链取 pushId：当前会话 → 全局兜底 → 本地文件首个（保底）。 */
+async function resolvePushId(sessionId) {
+    // 1. 同会话
+    const session = configManager.getPushId(sessionId);
+    if (session)
+        return session;
+    // 2. 全局（任何会话注册过的）
+    const global = configManager.getPushId();
+    if (global)
+        return global;
+    // 3. 文件兜底
+    try {
+        const all = await getAllPushIds();
+        if (all.length > 0)
+            return all[0];
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/** 判断 exec 命令是否为 cron add（匹配 "openclaw cron add" 或裸 "cron add"，排除 list/remove 等）。 */
+function isExecCronAddCommand(command) {
+    if (typeof command !== "string")
+        return false;
+    return /\bcron\s+add\b/.test(command);
+}
+/** 取结果的短预览，用于诊断。 */
+function preview(value) {
+    if (value == null)
+        return String(value);
+    const s = typeof value === "string" ? value : JSON.stringify(value);
+    return s.length > 200 ? s.slice(0, 200) + "…" : s;
+}
+/** 防御性地从 cron add 结果中取 job id。
+ *  覆盖：裸 job 对象、JSON 字符串、exec 输出文本、
+ *  {content:[{text}]} / {stdout} / data/result/job 嵌套。 */
+function readJobIdFromResult(result) {
+    if (!result)
+        return undefined;
+    // {content: [{type:"text", text: "..."}]} — exec 工具的输出信封
+    if (result && typeof result === "object") {
+        const contentArr = result.content;
+        if (Array.isArray(contentArr)) {
+            for (const item of contentArr) {
+                if (item && typeof item === "object") {
+                    const text = item.text;
+                    if (typeof text === "string" && text.trim()) {
+                        const fromContent = readJobIdFromResult(text);
+                        if (fromContent)
+                            return fromContent;
+                    }
+                }
+            }
+        }
+    }
+    // {stdout} — 备选 exec 输出信封
+    if (result && typeof result === "object") {
+        const stdout = result.stdout;
+        if (typeof stdout === "string" && stdout.trim()) {
+            const fromStdout = readJobIdFromResult(stdout);
+            if (fromStdout)
+                return fromStdout;
+        }
+    }
+    let obj = result;
+    if (typeof result === "string") {
+        try {
+            obj = JSON.parse(result);
+        }
+        catch {
+            // 纯文本：可能含 stderr 前缀行 + JSON。用正则抓 "id":"..."。
+            const m = result.match(/"id"\s*:\s*"([^"]+)"/);
+            if (m)
+                return m[1];
+            return undefined;
+        }
+    }
+    if (obj && typeof obj === "object") {
+        const id = obj.id;
+        if (typeof id === "string" && id.trim())
+            return id.trim();
+        for (const k of ["data", "result", "job"]) {
+            const inner = obj[k];
+            if (inner && typeof inner === "object") {
+                const innerId = inner.id;
+                if (typeof innerId === "string" && innerId.trim())
+                    return innerId.trim();
+            }
+        }
+    }
+    return undefined;
+}
 function registerFullHooks(api) {
     // SKILL RETRIEVER HOOK: before_prompt_build hook
     const pluginConfig = api.pluginConfig || {};

package/dist/src/cron-command.d.ts

@@ -2,6 +2,8 @@ import type { XYChannelConfig, A2ACommand } from "./types.js";
 export interface SendCommandViaPushParams {
     config: XYChannelConfig;
     command: A2ACommand;
+    /** 指定设备的 pushId（多设备路由）。未传时回退到 getAllPushIds()[0]。 */
+    pushId?: string;
 }
 /**
  * Send a tool command through the push channel (for cron-triggered tool calls).

package/dist/src/cron-command.js

@@ -24,16 +24,22 @@ export async function sendCommandViaPush(params) {
         command.header?.name ??
         "Command";
     logger.log(`[CRON-CMD] Sending command via push, intent=${intentName}`);
-    // 1. Load push IDs, use first one
+    // 1. 选 pushId：优先用调用方解析出的设备 pushId（多设备路由正确）；
+    //    未提供时回退到 getAllPushIds()[0]（单设备兼容旧行为）。
     let pushId = config.pushId;
-    try {
-        const pushIdList = await getAllPushIds();
-        if (pushIdList.length > 0) {
-            pushId = pushIdList[0];
-        }
+    if (params.pushId) {
+        pushId = params.pushId;
     }
-    catch (error) {
-        logger.error("[CRON-CMD] Failed to load pushIds:", error);
+    else {
+        try {
+            const pushIdList = await getAllPushIds();
+            if (pushIdList.length > 0) {
+                pushId = pushIdList[0];
+            }
+        }
+        catch (error) {
+            logger.error("[CRON-CMD] Failed to load pushIds:", error);
+        }
     }
     // 2. Build and send push notification with command in directives
     const pushService = new XYPushService(config);

package/dist/src/cron-query-handler.js

@@ -7,6 +7,8 @@ import { callGatewayTool } from "openclaw/plugin-sdk/agent-harness-runtime";
 import * as os from "os";
 import { sendCommand } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
+import { configManager } from "./utils/config-manager.js";
+import { setJobPushId } from "./utils/cron-push-map.js";
 import { logger } from "./utils/logger.js";
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
@@ -39,6 +41,11 @@ export async function handleCronQueryEvent(context, cfg) {
                 break;
             case "add":
                 result = await callGatewayTool("cron.add", { timeoutMs: GATEWAY_TIMEOUT_MS }, params ?? {});
+                // 捕获 jobId↔pushId：cron-query 路径由 channel 自己建 job，
+                // 此处 context 握着 sessionId，configManager 有对应设备 pushId。
+                await persistCronPushMap(context.sessionId, result).catch((err) => {
+                    logger.error(`[CRON-QUERY] Failed to persist cron-push-map:`, err);
+                });
                 break;
             case "update":
                 result = await callGatewayTool("cron.update", { timeoutMs: GATEWAY_TIMEOUT_MS }, {
@@ -106,6 +113,35 @@ export async function handleCronQueryEvent(context, cfg) {
         log.warn(`[CRON-QUERY] Missing cfg/sessionId/taskId/messageId, skipping sendCommand`);
     }
 }
+/**
+ * 从 cron.add 结果中提取 jobId，配合 sessionId 对应的 pushId 写入映射。
+ */
+async function persistCronPushMap(sessionId, result) {
+    logger.log(`[CRONMAP] cron-query persist: sessionId=${sessionId ?? "(none)"}, resultType=${typeof result}`);
+    if (!sessionId) {
+        logger.log(`[CRONMAP] cron-query skip: no sessionId in context`);
+        return;
+    }
+    let jobId;
+    if (result && typeof result === "object") {
+        const id = result.id;
+        if (typeof id === "string" && id.trim())
+            jobId = id.trim();
+    }
+    if (!jobId) {
+        const preview = typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result)?.slice(0, 200);
+        logger.log(`[CRONMAP] cron-query skip: no jobId in result. preview=${preview ?? "(empty)"}`);
+        return;
+    }
+    const pushId = configManager.getPushId(sessionId);
+    if (!pushId) {
+        logger.log(`[CRONMAP] cron-query skip: configManager has no pushId for sessionId=${sessionId}`);
+        return;
+    }
+    logger.log(`[CRONMAP] cron-query writing map: jobId=${jobId}, pushId=${pushId.substring(0, 16)}...`);
+    await setJobPushId(jobId, { pushId, sessionId, source: "cron-query" });
+    logger.log(`[CRONMAP] cron-query map written OK`);
+}
 /**
  * Read local cron folder directly (bypassing openclaw RPC) and return
  * run records from the last 7 days, grouped by date and sorted by time.

package/dist/src/formatter.js

@@ -5,7 +5,10 @@ import { logger } from "./utils/logger.js";
 import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 import { redactSensitiveText, containsSensitiveInfo } from "./sensitive-redactor.js";
 import { rewriteOutboundApprovalText } from "./approval-bridge.js";
-import { isCronToolCall } from "./tools/session-manager.js";
+import { isCronToolCall, getCurrentCronJobId } from "./tools/session-manager.js";
+import { configManager } from "./utils/config-manager.js";
+import { getPushIdByJobId } from "./utils/cron-push-map.js";
+import { getAllPushIds } from "./utils/pushid-manager.js";
 // ─────────────────────────────────────────────────────────────
 // 敏感信息脱敏辅助函数
 // ─────────────────────────────────────────────────────────────
@@ -201,6 +204,45 @@ export async function sendStatusUpdate(params) {
     log.log(`[A2A_STATUS] Sending status-update, text="${redactedText}"`);
     await wsManager.sendMessage(sessionId, outboundMessage);
 }
+/**
+ * 解析 cron fire 时应使用的 pushId（多设备路由）。
+ *
+ * 查询链（逐级回退）：
+ *   1. 合成 sessionId → jobId → cron-push-map.json → 创建时记录的设备 pushId
+ *   2. configManager 同进程的 sessionId→pushId（进程未重启时兜底）
+ *   3. getAllPushIds()[0]（单设备兼容旧行为）
+ * 返回 undefined 表示走兜底（由 sendCommandViaPush 内部处理）。
+ */
+async function resolveCronPushId(sessionId, config) {
+    // 1. jobId → 持久化映射
+    const jobId = getCurrentCronJobId(sessionId);
+    if (jobId) {
+        const hit = await getPushIdByJobId(jobId);
+        if (hit?.pushId) {
+            logger.log(`[CRON-PUSH] Resolved pushId via map, jobId=${jobId}`);
+            return hit.pushId;
+        }
+    }
+    // 2. 同进程 configManager 兜底
+    const sessionPushId = configManager.getPushId(sessionId);
+    if (sessionPushId) {
+        logger.log(`[CRON-PUSH] Resolved pushId via configManager (fallback)`);
+        return sessionPushId;
+    }
+    // 3. config.pushId / getAllPushIds()[0] 交给 sendCommandViaPush 内部处理
+    void config;
+    try {
+        const all = await getAllPushIds();
+        if (all.length > 0) {
+            logger.log(`[CRON-PUSH] Resolved pushId via getAllPushIds[0] (legacy fallback)`);
+            return all[0];
+        }
+    }
+    catch (error) {
+        logger.error(`[CRON-PUSH] getAllPushIds failed:`, error);
+    }
+    return undefined;
+}
 /**
  * Send a command as an artifact update (final=false).
  *
@@ -222,7 +264,10 @@ export async function sendCommand(params) {
     //               (b) toolCallId marked by before_tool_call hook from openclaw's sessionKey.
     if (sessionId.startsWith("cron-") || isCronToolCall(toolCallId)) {
         const { sendCommandViaPush } = await import("./cron-command.js");
-        return sendCommandViaPush({ config, command: commands[0] });
+        // 解析正确设备的 pushId：合成 sessionId → jobId → cron-push-map。
+        // provider.ts 在 isCron 分支已把 jobId 绑定到该 sessionId。
+        const pushId = await resolveCronPushId(sessionId, config);
+        return sendCommandViaPush({ config, command: commands[0], pushId });
     }
     // ── Normal mode: WebSocket ─────────────────────────────────────
     // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),

package/dist/src/memory-query-handler.d.ts

@@ -0,0 +1 @@
+export declare function handleMemoryQueryEvent(context: any, cfg: any): Promise<void>;

package/dist/src/memory-query-handler.js

@@ -0,0 +1,164 @@
+// Memory query event handler.
+// Listens for memory-query-event from the WebSocket manager,
+// handles memory state read/write and MEMORY.md/USER.md file queries.
+import * as os from "os";
+import * as path from "path";
+import { readFileSync, writeFileSync } from "fs";
+import { sendCommand } from "./formatter.js";
+import { resolveXYConfig } from "./config.js";
+import { logger } from "./utils/logger.js";
+const XIAOYIRUNTIME_PATH_PRIMARY = "/home/sandbox/.openclaw/.xiaoyiruntime";
+const XIAOYIRUNTIME_PATH_FALLBACK = `${os.homedir()}/.openclaw/.xiaoyiruntime`;
+const MEMORY_STATE_KEY = "MEMORYSTATE";
+/** Resolve writable .xiaoyiruntime path: try sandbox path first, fallback to user home. */
+function resolveXiaoyiRuntimePath() {
+    try {
+        // If primary path's parent dir exists and is writable, use it
+        const fs = require("fs");
+        fs.accessSync(XIAOYIRUNTIME_PATH_PRIMARY, fs.constants.W_OK);
+        return XIAOYIRUNTIME_PATH_PRIMARY;
+    }
+    catch {
+        // If primary path doesn't exist, try creating parent
+        try {
+            const fs = require("fs");
+            const dir = require("path").dirname(XIAOYIRUNTIME_PATH_PRIMARY);
+            fs.mkdirSync(dir, { recursive: true });
+            return XIAOYIRUNTIME_PATH_PRIMARY;
+        }
+        catch {
+            // Fallback to user home
+        }
+    }
+    return XIAOYIRUNTIME_PATH_FALLBACK;
+}
+export async function handleMemoryQueryEvent(context, cfg) {
+    const { action, params, sessionId, taskId, messageId } = context;
+    const log = logger.withContext(sessionId ?? "", taskId ?? "");
+    log.log(`[MEMORY-QUERY] Received event: action=${action}`);
+    let result;
+    try {
+        switch (action) {
+            case "memoryStateSet":
+                result = handleMemoryStateSet(params);
+                break;
+            case "userMdQuery":
+                result = handleUserMdQuery();
+                break;
+            case "memoryMdQuery":
+                result = handleMemoryMdQuery();
+                break;
+            default:
+                log.error(`[MEMORY-QUERY] Unknown action: ${action}`);
+                result = { error: `Unknown action: ${action}` };
+        }
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        log.error(`[MEMORY-QUERY] Handler failed for action=${action}:`, err);
+        result = { error: errorMsg };
+    }
+    log.log(`[MEMORY-QUERY] Result for action=${action}: ${JSON.stringify(result)}`);
+    // Send result back via sendCommand
+    if (cfg && sessionId && taskId && messageId) {
+        try {
+            const config = resolveXYConfig(cfg);
+            const command = {
+                header: {
+                    namespace: "AgentEvent",
+                    name: "memoryQuery",
+                },
+                payload: {
+                    action,
+                    ans: result,
+                },
+            };
+            await sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+                final: true,
+            });
+            log.log(`[MEMORY-QUERY] Sent response via sendCommand, action=${action}`);
+        }
+        catch (sendErr) {
+            log.error(`[MEMORY-QUERY] Failed to send response via sendCommand:`, sendErr);
+        }
+    }
+    else {
+        log.warn(`[MEMORY-QUERY] Missing cfg/sessionId/taskId/messageId, skipping sendCommand`);
+    }
+}
+/**
+ * Write MEMORYSTATE=true/false to .xiaoyiruntime.
+ */
+function handleMemoryStateSet(params) {
+    const memoryState = params?.memoryState;
+    if (typeof memoryState !== "boolean") {
+        logger.error(`[MEMORY-QUERY] memoryStateSet: invalid memoryState type: ${typeof memoryState}`);
+        return { code: 0 };
+    }
+    const value = String(memoryState);
+    const filePath = resolveXiaoyiRuntimePath();
+    let content;
+    try {
+        content = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        logger.log(`[MEMORY-QUERY] ${filePath} not found, creating new file`);
+        writeFileSync(filePath, `${MEMORY_STATE_KEY}=${value}\n`, "utf-8");
+        logger.log(`[MEMORY-QUERY] wrote ${MEMORY_STATE_KEY}=${value}`);
+        return { code: 0 };
+    }
+    const lines = content.split("\n");
+    const key = MEMORY_STATE_KEY;
+    let found = false;
+    const updated = lines.map((line) => {
+        if (line.startsWith(`${key}=`)) {
+            found = true;
+            return `${key}=${value}`;
+        }
+        return line;
+    });
+    if (!found) {
+        const trimmed = content.trimEnd();
+        writeFileSync(filePath, `${trimmed}\n${key}=${value}\n`, "utf-8");
+    }
+    else {
+        writeFileSync(filePath, updated.join("\n"), "utf-8");
+    }
+    logger.log(`[MEMORY-QUERY] updated ${MEMORY_STATE_KEY}=${value} in ${filePath}`);
+    return { code: 0 };
+}
+/**
+ * Read ~/.openclaw/workspace/USER.md and return content in fileDetail.
+ */
+function handleUserMdQuery() {
+    const filePath = path.join(os.homedir(), ".openclaw", "workspace", "USER.md");
+    return readMdFile(filePath);
+}
+/**
+ * Read ~/.openclaw/workspace/MEMORY.md and return content in fileDetail.
+ */
+function handleMemoryMdQuery() {
+    const filePath = path.join(os.homedir(), ".openclaw", "workspace", "MEMORY.md");
+    return readMdFile(filePath);
+}
+function readMdFile(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        logger.log(`[MEMORY-QUERY] Read file: ${filePath}, size: ${content.length}`);
+        return { fileDetail: content };
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            logger.log(`[MEMORY-QUERY] File not found: ${filePath}`);
+        }
+        else {
+            logger.error(`[MEMORY-QUERY] Failed to read ${filePath}:`, err);
+        }
+        return { fileDetail: "" };
+    }
+}

package/dist/src/monitor.js

@@ -8,6 +8,7 @@ import { handleTriggerEvent } from "./trigger-handler.js";
 import { handleSelfEvolutionEvent, handleSelfEvolutionStateGetEvent } from "./self-evolution-handler.js";
 import { handleLoginTokenEvent } from "./login-token-handler.js";
 import { handleCronQueryEvent } from "./cron-query-handler.js";
+import { handleMemoryQueryEvent } from "./memory-query-handler.js";
 import { cleanupStaleTempFiles } from "./reply-dispatcher.js";
 import { cleanupStaleSessions, getActiveSessionCount, cleanupAllSessions } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
@@ -205,6 +206,12 @@ export async function monitorXYProvider(opts = {}) {
                 logger.error(`[MONITOR] Failed to handle cron-query-event:`, err);
             });
         };
+        const memoryQueryEventHandler = (context) => {
+            logger.log(`[MONITOR] Received memory-query-event, dispatching to handler...`);
+            handleMemoryQueryEvent(context, cfg).catch((err) => {
+                logger.error(`[MONITOR] Failed to handle memory-query-event:`, err);
+            });
+        };
         const cleanup = () => {
             logger.log("XY gateway: cleaning up...");
             // 🔍 Diagnose before cleanup
@@ -226,6 +233,7 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.off("self-evolution-state-get-event", selfEvolutionStateGetHandler);
             wsManager.off("login-token-event", loginTokenEventHandler);
             wsManager.off("cron-query-event", cronQueryEventHandler);
+            wsManager.off("memory-query-event", memoryQueryEventHandler);
             // ✅ Disconnect the wsManager to prevent connection leaks
             // This is safe because each gateway lifecycle should have clean connections
             wsManager.disconnect();
@@ -290,6 +298,7 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("self-evolution-state-get-event", selfEvolutionStateGetHandler);
         wsManager.on("login-token-event", loginTokenEventHandler);
         wsManager.on("cron-query-event", cronQueryEventHandler);
+        wsManager.on("memory-query-event", memoryQueryEventHandler);
         // Start periodic health check (every 6 hours)
         logger.log("Starting periodic health check (every 6 hours)...");
         healthCheckInterval = setInterval(() => {

package/dist/src/provider.js

@@ -9,7 +9,7 @@
 //   models.providers.xiaoyiprovider.models = [...]
 import { createHash } from "crypto";
 import { logger } from "./utils/logger.js";
-import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { getCurrentSessionContext, setCurrentCronJobId } from "./tools/session-manager.js";
 import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
 import { notifyModelStreaming } from "./bot.js";
 // ── Retry config ──────────────────────────────────────────────
@@ -506,6 +506,14 @@ export const xiaoyiProvider = {
             //   3. UID-based fallback: sha256(uid).hex[:32]_timestamp
             const isCron = isCronTriggered(context.messages);
             if (isCron) {
+                // fire 期 jobId 桥：把首条消息 `[cron:<jobId> ...]` 解析出的真实 jobId
+                // 绑定到本次 cron run 的合成 sessionId。sendCommand 凭同一 sessionId
+                // 反查 jobId → cron-push-map → 正确设备的 pushId（多设备路由）。
+                const cronJobId = extractCronUuid(context.messages);
+                const cronCtx = getCurrentSessionContext();
+                if (cronJobId && cronCtx?.sessionId) {
+                    setCurrentCronJobId(cronCtx.sessionId, cronJobId);
+                }
                 const fallbackPrefix = ctx.extraParams?.[FALLBACK_PREFIX_KEY];
                 if (typeof fallbackPrefix === "string") {
                     const fallbackValue = `${fallbackPrefix}_${Date.now()}`;

package/dist/src/tools/session-manager.d.ts

@@ -27,6 +27,12 @@ export declare function markCronToolCall(toolCallId: string): void;
 export declare function isCronToolCall(toolCallId?: string): boolean;
 /** Clean up a cron tool call marker after use. */
 export declare function clearCronToolCall(toolCallId: string): void;
+/** 把 fire 期解析出的 jobId 绑定到当前 cron run 的合成 sessionId。 */
+export declare function setCurrentCronJobId(cronSessionId: string, jobId: string): void;
+/** 凭合成 cron sessionId 取本次 run 的 jobId（供 sendCommand 反查 pushId）。 */
+export declare function getCurrentCronJobId(cronSessionId?: string): string | undefined;
+/** cron run 结束后清理。 */
+export declare function clearCronJobId(cronSessionId: string): void;
 export declare const asyncLocalStorage: AsyncLocalStorage<SessionContext>;
 /**
  * Register a session context for tool access.

package/dist/src/tools/session-manager.js

@@ -48,6 +48,32 @@ export function isCronToolCall(toolCallId) {
 export function clearCronToolCall(toolCallId) {
     cronToolCallMap.delete(toolCallId);
 }
+// ── Cron session ↔ jobId bridge ────────────────────────────────────
+// fire 期 jobId 传递桥。provider.ts 在 isCron 分支从首条消息
+// `[cron:<jobId> ...]` 解析出真实 jobId，写入合成 cron sessionId；
+// sendCommand/formatter 凭同一合成 sessionId 反查 jobId，再去
+// cron-push-map 取对应设备的 pushId。同一 cron run 内 ALS 上下文共享，
+// 合成 sessionId 在 provider 与 sendCommand 之间一致。
+if (!_g.__xyCronSessionJobId) {
+    _g.__xyCronSessionJobId = new Map();
+}
+const cronSessionJobIdMap = _g.__xyCronSessionJobId;
+/** 把 fire 期解析出的 jobId 绑定到当前 cron run 的合成 sessionId。 */
+export function setCurrentCronJobId(cronSessionId, jobId) {
+    if (cronSessionId && jobId) {
+        cronSessionJobIdMap.set(cronSessionId, jobId);
+    }
+}
+/** 凭合成 cron sessionId 取本次 run 的 jobId（供 sendCommand 反查 pushId）。 */
+export function getCurrentCronJobId(cronSessionId) {
+    if (!cronSessionId)
+        return undefined;
+    return cronSessionJobIdMap.get(cronSessionId);
+}
+/** cron run 结束后清理。 */
+export function clearCronJobId(cronSessionId) {
+    cronSessionJobIdMap.delete(cronSessionId);
+}
 // AsyncLocalStorage for thread-safe session context isolation
 export const asyncLocalStorage = new AsyncLocalStorage();
 // Export AsyncLocalStorage to globalThis so logger.ts can access it

package/dist/src/utils/config-manager.d.ts

@@ -3,8 +3,9 @@
  * Specifically handles pushId which can be updated per-session.
  */
 declare class ConfigManager {
-    private sessionPushIds;
-    private globalPushId;
+    private get sessionPushIds();
+    private get globalPushId();
+    private set globalPushId(value);
     /**
      * Update push ID for a specific session.
      */

package/dist/src/utils/config-manager.js

@@ -1,12 +1,32 @@
 // Dynamic configuration manager for runtime updates
+//
+// NOTE: xy_channel is loaded from multiple module resolution paths
+// (plugin entry vs tool registration), which duplicates class instances.
+// sessionPushIds and globalPushId must live on globalThis so all copies
+// share the same Map — same reason activeSessions is on globalThis in
+// session-manager.ts.
 import { logger } from "./logger.js";
+const _g = globalThis;
+if (!_g.__xyConfigSessionPushIds) {
+    _g.__xyConfigSessionPushIds = new Map();
+}
+if (!_g.__xyConfigGlobalPushId) {
+    _g.__xyConfigGlobalPushId = null;
+}
 /**
  * Manages dynamic configuration updates that can change at runtime.
  * Specifically handles pushId which can be updated per-session.
  */
 class ConfigManager {
-    sessionPushIds = new Map();
-    globalPushId = null;
+    get sessionPushIds() {
+        return _g.__xyConfigSessionPushIds;
+    }
+    get globalPushId() {
+        return _g.__xyConfigGlobalPushId;
+    }
+    set globalPushId(value) {
+        _g.__xyConfigGlobalPushId = value;
+    }
     /**
      * Update push ID for a specific session.
      */

package/dist/src/utils/cron-push-map.d.ts

@@ -0,0 +1,26 @@
+/** 映射来源，区分两种创建路径。 */
+export type CronPushMapSource = "conversation" | "cron-query" | "exec-cli";
+export interface CronPushMapEntry {
+    pushId: string;
+    /** 创建该 cron 时的 xy sessionId，便于同进程兜底。 */
+    sessionId?: string;
+    /** 冗余记录设备类型，fire 时可按设备类型做差异化处理。 */
+    deviceType?: string;
+    source?: CronPushMapSource;
+    createdAt: number;
+}
+export interface CronPushMapFile {
+    version: 1;
+    entries: Record<string, CronPushMapEntry>;
+}
+/** 写入/更新一条 jobId → pushId 映射。 */
+export declare function setJobPushId(jobId: string, entry: Omit<CronPushMapEntry, "createdAt">): Promise<void>;
+/** fire 时主查询：按 jobId 取 pushId。 */
+export declare function getPushIdByJobId(jobId: string): Promise<{
+    pushId: string;
+    entry: CronPushMapEntry;
+} | null>;
+/** 删除一条映射（cron job 被移除时清理）。 */
+export declare function removeJob(jobId: string): Promise<void>;
+/** 对账：删除 openclaw 里已不存在的 job，避免映射无限增长。 */
+export declare function pruneStale(existingJobIds: Set<string>): Promise<void>;

package/dist/src/utils/cron-push-map.js

@@ -0,0 +1,131 @@
+// Cron job ↔ pushId 持久化映射
+//
+// 背景：cron 定时任务触发时，工具调用走 push 通道（sendCommandViaPush），
+// 需要正确的 pushId 才能推到"创建该任务的那台设备"。pushIdList.json 是
+// 扁平去重数组，无法区分设备；本文件按真实 jobId 保存创建时的 pushId，
+// fire 时通过 jobId 反查即可定位到正确设备。
+//
+// jobId 的两端来源（均为真实 jobId，无需规范化反解）：
+//   - 写入：after_tool_call 拦 cron/add → event.result.id；
+//           cron-query-handler inline → result.id
+//   - 读取：provider.ts extractCronUuid(context.messages) → "[cron:<jobId> ...]"
+import { promises as fs } from "fs";
+import * as path from "path";
+import { logger } from "./logger.js";
+const CRON_PUSH_MAP_FILE = "/home/sandbox/.openclaw/cron-push-map.json";
+async function ensureDirectoryExists(filePath) {
+    const dir = path.dirname(filePath);
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch (error) {
+        logger.error(`[CronPushMap] Failed to create directory ${dir}:`, error);
+    }
+}
+async function readMap() {
+    try {
+        await ensureDirectoryExists(CRON_PUSH_MAP_FILE);
+        const content = await fs.readFile(CRON_PUSH_MAP_FILE, "utf-8");
+        const parsed = JSON.parse(content);
+        if (parsed &&
+            typeof parsed === "object" &&
+            parsed.version === 1 &&
+            parsed.entries &&
+            typeof parsed.entries === "object") {
+            return parsed;
+        }
+        logger.warn(`[CronPushMap] Unexpected file shape, returning empty map`);
+        return { version: 1, entries: {} };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { version: 1, entries: {} };
+        }
+        logger.error(`[CronPushMap] Failed to read map:`, error);
+        return { version: 1, entries: {} };
+    }
+}
+async function writeMap(map) {
+    try {
+        await ensureDirectoryExists(CRON_PUSH_MAP_FILE);
+        await fs.writeFile(CRON_PUSH_MAP_FILE, JSON.stringify(map, null, 2), "utf-8");
+    }
+    catch (error) {
+        logger.error(`[CronPushMap] Failed to write map:`, error);
+        throw error;
+    }
+}
+/** 写入/更新一条 jobId → pushId 映射。 */
+export async function setJobPushId(jobId, entry) {
+    if (!jobId || typeof jobId !== "string") {
+        logger.warn(`[CronPushMap] Invalid jobId: ${jobId}`);
+        return;
+    }
+    if (!entry.pushId || typeof entry.pushId !== "string") {
+        logger.warn(`[CronPushMap] Skipping setJobPushId: missing pushId for jobId=${jobId}`);
+        return;
+    }
+    try {
+        const map = await readMap();
+        map.entries[jobId] = { ...entry, createdAt: Date.now() };
+        await writeMap(map);
+        logger.log(`[CronPushMap] Saved jobId=${jobId}, source=${entry.source ?? "?"}, pushId=${entry.pushId.substring(0, 20)}...`);
+    }
+    catch (error) {
+        logger.error(`[CronPushMap] Failed to setJobPushId:`, error);
+        // 不抛出，避免影响主流程
+    }
+}
+/** fire 时主查询：按 jobId 取 pushId。 */
+export async function getPushIdByJobId(jobId) {
+    if (!jobId)
+        return null;
+    try {
+        const map = await readMap();
+        const entry = map.entries[jobId];
+        if (entry && entry.pushId) {
+            return { pushId: entry.pushId, entry };
+        }
+        return null;
+    }
+    catch (error) {
+        logger.error(`[CronPushMap] Failed to getPushIdByJobId:`, error);
+        return null;
+    }
+}
+/** 删除一条映射（cron job 被移除时清理）。 */
+export async function removeJob(jobId) {
+    if (!jobId)
+        return;
+    try {
+        const map = await readMap();
+        if (map.entries[jobId]) {
+            delete map.entries[jobId];
+            await writeMap(map);
+            logger.log(`[CronPushMap] Removed jobId=${jobId}`);
+        }
+    }
+    catch (error) {
+        logger.error(`[CronPushMap] Failed to removeJob:`, error);
+    }
+}
+/** 对账：删除 openclaw 里已不存在的 job，避免映射无限增长。 */
+export async function pruneStale(existingJobIds) {
+    try {
+        const map = await readMap();
+        let removed = 0;
+        for (const key of Object.keys(map.entries)) {
+            if (!existingJobIds.has(key)) {
+                delete map.entries[key];
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            await writeMap(map);
+            logger.log(`[CronPushMap] Pruned ${removed} stale entries`);
+        }
+    }
+    catch (error) {
+        logger.error(`[CronPushMap] Failed to pruneStale:`, error);
+    }
+}

package/dist/src/websocket.js

@@ -630,6 +630,15 @@ export class XYWebSocketManager extends EventEmitter {
                                     messageId: a2aRequest.id,
                                 });
                             }
+                            else if (item.header?.namespace === "AgentEvent" && item.header?.name === "memoryQuery") {
+                                log.log("[XY] AgentEvent.memoryQuery detected, emitting memory-query-event");
+                                this.emit("memory-query-event", {
+                                    ...(item.payload ?? {}),
+                                    sessionId,
+                                    taskId: a2aRequest.params?.id,
+                                    messageId: a2aRequest.id,
+                                });
+                            }
                             else if (item.header?.namespace === "System" && item.header?.name === "ExecuteAgentAsSkillResponse") {
                                 log.log("[XY] ExecuteAgentAsSkillResponse detected, emitting agent-as-skill-response");
                                 this.emit("agent-as-skill-response", item);
@@ -719,6 +728,15 @@ export class XYWebSocketManager extends EventEmitter {
                                         messageId: a2aRequest.id,
                                     });
                                 }
+                                else if (item.header?.namespace === "AgentEvent" && item.header?.name === "memoryQuery") {
+                                    log.log("[XY] AgentEvent.memoryQuery detected (wrapped format), emitting memory-query-event");
+                                    this.emit("memory-query-event", {
+                                        ...(item.payload ?? {}),
+                                        sessionId: inboundMsg.sessionId || a2aRequest.params?.sessionId,
+                                        taskId: inboundMsg.taskId || a2aRequest.params?.id,
+                                        messageId: a2aRequest.id,
+                                    });
+                                }
                                 else if (item.header?.namespace === "System" && item.header?.name === "ExecuteAgentAsSkillResponse") {
                                     log.log("[XY] ExecuteAgentAsSkillResponse detected (wrapped format), emitting agent-as-skill-response");
                                     this.emit("agent-as-skill-response", item);

package/package.json

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