@ynhcj/xiaoyi-channel 1.1.31 → 1.1.32

package/dist/src/acp-session-binding.d.ts

@@ -0,0 +1,37 @@
+import { type BindingTargetKind } from "openclaw/plugin-sdk/conversation-runtime";
+type XyBindingTargetKind = "subagent" | "acp";
+type XyAcpBindingRecord = {
+    accountId: string;
+    conversationId: string;
+    parentConversationId?: string;
+    deliveryTo?: string;
+    targetKind: XyBindingTargetKind;
+    targetSessionKey: string;
+    agentId?: string;
+    label?: string;
+    boundBy?: string;
+    boundAt: number;
+    lastActivityAt: number;
+};
+type XyAcpBindingManager = {
+    accountId: string;
+    getByConversationId: (conversationId: string) => XyAcpBindingRecord | undefined;
+    listBySessionKey: (targetSessionKey: string) => XyAcpBindingRecord[];
+    bindConversation: (params: {
+        conversationId: string;
+        parentConversationId?: string;
+        targetKind: BindingTargetKind;
+        targetSessionKey: string;
+        metadata?: Record<string, unknown>;
+    }) => XyAcpBindingRecord | null;
+    touchConversation: (conversationId: string, at?: number) => XyAcpBindingRecord | null;
+    unbindConversation: (conversationId: string) => XyAcpBindingRecord | null;
+    unbindBySessionKey: (targetSessionKey: string) => XyAcpBindingRecord[];
+    stop: () => void;
+};
+export declare function createXyAcpBindingManager(params: {
+    accountId?: string;
+    cfg: any;
+}): XyAcpBindingManager;
+export declare function getXyAcpBindingManager(accountId?: string): XyAcpBindingManager | null;
+export {};

package/dist/src/acp-session-binding.js

@@ -0,0 +1,237 @@
+// ACP Session Binding Adapter for xiaoyi-channel.
+// Follows the feishu thread-bindings.ts pattern.
+//
+// Maps A2A sessionId (stable conversation identifier) to ACP/subagent
+// session keys so that openclaw can bind spawned sessions to the
+// current xiaoyi conversation.
+//
+// Key design: xiaoyi-channel only supports `placement: "current"` —
+// it cannot create child threads (unlike Discord). All spawned sessions
+// are bound to the current A2A conversation identified by sessionId.
+// NOTE: Using `any` for cfg type to avoid version mismatch between
+// local and global openclaw installs (auth.profiles.aws-sdk union).
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel, resolveThreadBindingConversationIdFromBindingId, registerSessionBindingAdapter, unregisterSessionBindingAdapter, } from "openclaw/plugin-sdk/conversation-runtime";
+import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logger } from "./utils/logger.js";
+// ─── Global state (survives module dedup) ─────────────────────
+const XY_ACP_BINDINGS_KEY = Symbol.for("openclaw.xyAcpBindingsState");
+let state;
+function getState() {
+    if (!state) {
+        const globalStore = globalThis;
+        state = globalStore[XY_ACP_BINDINGS_KEY] ?? {
+            managersByAccountId: new Map(),
+            bindingsByAccountConversation: new Map(),
+        };
+        globalStore[XY_ACP_BINDINGS_KEY] = state;
+    }
+    return state;
+}
+function resolveBindingKey(params) {
+    return `${params.accountId}:${params.conversationId}`;
+}
+// ─── Kind conversion ──────────────────────────────────────────
+function toSessionBindingTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "session";
+}
+function toXyTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "acp";
+}
+// ─── Record conversion ────────────────────────────────────────
+function toSessionBindingRecord(record, defaults) {
+    const idleExpiresAt = defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : undefined;
+    const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : undefined;
+    const expiresAt = idleExpiresAt != null && maxAgeExpiresAt != null
+        ? Math.min(idleExpiresAt, maxAgeExpiresAt)
+        : (idleExpiresAt ?? maxAgeExpiresAt);
+    return {
+        bindingId: resolveBindingKey({
+            accountId: record.accountId,
+            conversationId: record.conversationId,
+        }),
+        targetSessionKey: record.targetSessionKey,
+        targetKind: toSessionBindingTargetKind(record.targetKind),
+        conversation: {
+            channel: "xiaoyi-channel",
+            accountId: record.accountId,
+            conversationId: record.conversationId,
+            parentConversationId: record.parentConversationId,
+        },
+        status: "active",
+        boundAt: record.boundAt,
+        expiresAt,
+        metadata: {
+            agentId: record.agentId,
+            label: record.label,
+            boundBy: record.boundBy,
+            deliveryTo: record.deliveryTo,
+            lastActivityAt: record.lastActivityAt,
+            idleTimeoutMs: defaults.idleTimeoutMs,
+            maxAgeMs: defaults.maxAgeMs,
+        },
+    };
+}
+// ─── Manager factory ──────────────────────────────────────────
+export function createXyAcpBindingManager(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const existing = getState().managersByAccountId.get(accountId);
+    if (existing) {
+        return existing;
+    }
+    const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const log = logger.withContext("", "");
+    const manager = {
+        accountId,
+        getByConversationId: (conversationId) => getState().bindingsByAccountConversation.get(resolveBindingKey({ accountId, conversationId })),
+        listBySessionKey: (targetSessionKey) => [...getState().bindingsByAccountConversation.values()].filter((record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey),
+        bindConversation: ({ conversationId, parentConversationId, targetKind, targetSessionKey, metadata, }) => {
+            const normalizedConversationId = conversationId.trim();
+            const normalizedTargetSessionKey = targetSessionKey.trim();
+            if (!normalizedConversationId || !normalizedTargetSessionKey) {
+                return null;
+            }
+            const existingLocal = getState().bindingsByAccountConversation.get(resolveBindingKey({ accountId, conversationId: normalizedConversationId }));
+            const now = Date.now();
+            const record = {
+                accountId,
+                conversationId: normalizedConversationId,
+                parentConversationId: normalizeOptionalString(parentConversationId) ?? existingLocal?.parentConversationId,
+                deliveryTo: typeof metadata?.deliveryTo === "string" && metadata.deliveryTo.trim()
+                    ? metadata.deliveryTo.trim()
+                    : existingLocal?.deliveryTo,
+                targetKind: toXyTargetKind(targetKind),
+                targetSessionKey: normalizedTargetSessionKey,
+                agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim()
+                    ? metadata.agentId.trim()
+                    : (existingLocal?.agentId ?? resolveAgentIdFromSessionKey(normalizedTargetSessionKey)),
+                label: typeof metadata?.label === "string" && metadata.label.trim()
+                    ? metadata.label.trim()
+                    : existingLocal?.label,
+                boundBy: typeof metadata?.boundBy === "string" && metadata.boundBy.trim()
+                    ? metadata.boundBy.trim()
+                    : existingLocal?.boundBy,
+                boundAt: now,
+                lastActivityAt: now,
+            };
+            getState().bindingsByAccountConversation.set(resolveBindingKey({ accountId, conversationId: normalizedConversationId }), record);
+            log.log(`[XY-ACP-BIND] Bound ${targetKind} session ${normalizedTargetSessionKey.slice(0, 30)} to conversation ${normalizedConversationId.slice(0, 12)}`);
+            return record;
+        },
+        touchConversation: (conversationId, at = Date.now()) => {
+            const key = resolveBindingKey({ accountId, conversationId });
+            const existingRecord = getState().bindingsByAccountConversation.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            const updated = { ...existingRecord, lastActivityAt: at };
+            getState().bindingsByAccountConversation.set(key, updated);
+            return updated;
+        },
+        unbindConversation: (conversationId) => {
+            const key = resolveBindingKey({ accountId, conversationId });
+            const existingRecord = getState().bindingsByAccountConversation.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            getState().bindingsByAccountConversation.delete(key);
+            return existingRecord;
+        },
+        unbindBySessionKey: (targetSessionKey) => {
+            const removed = [];
+            for (const record of getState().bindingsByAccountConversation.values()) {
+                if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) {
+                    continue;
+                }
+                getState().bindingsByAccountConversation.delete(resolveBindingKey({ accountId, conversationId: record.conversationId }));
+                removed.push(record);
+            }
+            return removed;
+        },
+        stop: () => {
+            for (const key of getState().bindingsByAccountConversation.keys()) {
+                if (key.startsWith(`${accountId}:`)) {
+                    getState().bindingsByAccountConversation.delete(key);
+                }
+            }
+            getState().managersByAccountId.delete(accountId);
+            unregisterSessionBindingAdapter({
+                channel: "xiaoyi-channel",
+                accountId,
+                adapter: sessionBindingAdapter,
+            });
+            log.log(`[XY-ACP-BIND] Stopped binding manager for account ${accountId}`);
+        },
+    };
+    const sessionBindingAdapter = {
+        channel: "xiaoyi-channel",
+        accountId,
+        capabilities: {
+            placements: ["current"],
+        },
+        bind: async (input) => {
+            if (input.conversation.channel !== "xiaoyi-channel" || input.placement === "child") {
+                return null;
+            }
+            const bound = manager.bindConversation({
+                conversationId: input.conversation.conversationId,
+                parentConversationId: input.conversation.parentConversationId,
+                targetKind: input.targetKind,
+                targetSessionKey: input.targetSessionKey,
+                metadata: input.metadata,
+            });
+            return bound ? toSessionBindingRecord(bound, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        listBySession: (targetSessionKey) => manager
+            .listBySessionKey(targetSessionKey)
+            .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs })),
+        resolveByConversation: (ref) => {
+            if (ref.channel !== "xiaoyi-channel") {
+                return null;
+            }
+            const found = manager.getByConversationId(ref.conversationId);
+            return found ? toSessionBindingRecord(found, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        touch: (bindingId, at) => {
+            const conversationId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId,
+            });
+            if (conversationId) {
+                manager.touchConversation(conversationId, at);
+            }
+        },
+        unbind: async (input) => {
+            if (input.targetSessionKey?.trim()) {
+                return manager
+                    .unbindBySessionKey(input.targetSessionKey.trim())
+                    .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs }));
+            }
+            const conversationId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId: input.bindingId,
+            });
+            if (!conversationId) {
+                return [];
+            }
+            const removed = manager.unbindConversation(conversationId);
+            return removed ? [toSessionBindingRecord(removed, { idleTimeoutMs, maxAgeMs })] : [];
+        },
+    };
+    registerSessionBindingAdapter(sessionBindingAdapter);
+    getState().managersByAccountId.set(accountId, manager);
+    log.log(`[XY-ACP-BIND] Created binding manager for account ${accountId} (idleTimeout=${idleTimeoutMs}ms, maxAge=${maxAgeMs}ms)`);
+    return manager;
+}
+export function getXyAcpBindingManager(accountId) {
+    return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
+}

package/dist/src/log-reporter/config-loader.d.ts

@@ -0,0 +1,11 @@
+import type { LogReporterConfig } from "./types.js";
+/**
+ * Load and validate the JSON config file.
+ * Falls back to defaults for optional fields.
+ */
+export declare function loadConfig(configPath: string): LogReporterConfig;
+/**
+ * Resolve a path template with date wildcards to actual file paths on disk.
+ * Scans the directory and returns all files matching the pattern.
+ */
+export declare function resolveLogFiles(templatePath: string): string[];

package/dist/src/log-reporter/config-loader.js

@@ -0,0 +1,68 @@
+// Config loader: reads JSON config file, validates fields, resolves date wildcards to actual files
+import { readFileSync, readdirSync } from "fs";
+import { dirname, basename, join } from "path";
+// Replace longer tokens first to avoid partial matches
+const WILDCARD_TOKENS = [
+    ["{year-month-day}", "\\d{4}-\\d{2}-\\d{2}"],
+    ["{year}{month}{day}", "\\d{8}"],
+    ["{year}", "\\d{4}"],
+    ["{month}", "\\d{2}"],
+    ["{day}", "\\d{2}"],
+];
+/**
+ * Load and validate the JSON config file.
+ * Falls back to defaults for optional fields.
+ */
+export function loadConfig(configPath) {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.logFiles || !Array.isArray(parsed.logFiles) || parsed.logFiles.length === 0) {
+        throw new Error("log-reporter config: 'logFiles' must be a non-empty array");
+    }
+    for (const lf of parsed.logFiles) {
+        if (!lf.path || !lf.name) {
+            throw new Error(`log-reporter config: each logFile must have 'path' and 'name', got ${JSON.stringify(lf)}`);
+        }
+    }
+    return {
+        scanIntervalMs: parsed.scanIntervalMs ?? 600000,
+        bakDir: parsed.bakDir ?? "/tmp/openclaw",
+        reportUrl: parsed.reportUrl ?? "",
+        logFiles: parsed.logFiles,
+    };
+}
+/**
+ * Convert a path with date wildcards into a RegExp that matches the filename part only.
+ * Returns { dir, regex } where dir is the directory portion and regex matches filenames.
+ */
+function pathToPattern(templatePath) {
+    const dir = dirname(templatePath);
+    let pattern = basename(templatePath);
+    // Escape regex special chars in the literal parts, then replace tokens
+    pattern = escapeRegex(pattern);
+    for (const [token, replacement] of WILDCARD_TOKENS) {
+        pattern = pattern.replaceAll(escapeRegex(token), replacement);
+    }
+    return { dir, regex: new RegExp(`^${pattern}$`) };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Resolve a path template with date wildcards to actual file paths on disk.
+ * Scans the directory and returns all files matching the pattern.
+ */
+export function resolveLogFiles(templatePath) {
+    const { dir, regex } = pathToPattern(templatePath);
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((f) => regex.test(f))
+        .map((f) => join(dir, f))
+        .sort(); // chronological order for date-named logs
+}

package/dist/src/log-reporter/cursor-store.d.ts

@@ -0,0 +1,5 @@
+import type { CursorStore, FileCursor } from "./types.js";
+export declare function loadCursorStore(storePath: string): CursorStore;
+export declare function saveCursorStore(storePath: string, store: CursorStore): void;
+export declare function getCursor(store: CursorStore, filePath: string): FileCursor | undefined;
+export declare function setCursor(store: CursorStore, filePath: string, cursor: FileCursor): void;

package/dist/src/log-reporter/cursor-store.js

@@ -0,0 +1,26 @@
+// Cursor state persistence — reads/writes FileCursor entries keyed by file path
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+export function loadCursorStore(storePath) {
+    try {
+        const raw = readFileSync(storePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return { files: parsed.files ?? {} };
+    }
+    catch {
+        return { files: {} };
+    }
+}
+export function saveCursorStore(storePath, store) {
+    try {
+        mkdirSync(dirname(storePath), { recursive: true });
+    }
+    catch { }
+    writeFileSync(storePath, JSON.stringify(store, null, 2), "utf-8");
+}
+export function getCursor(store, filePath) {
+    return store.files[filePath];
+}
+export function setCursor(store, filePath, cursor) {
+    store.files[filePath] = cursor;
+}

package/dist/src/log-reporter/index.d.ts

@@ -0,0 +1,10 @@
+import type { LogReporterOptions } from "./types.js";
+/**
+ * Start the log reporter. Runs the first scan immediately, then on the configured interval.
+ * Returns a stop function.
+ */
+export declare function startLogReporter(options: LogReporterOptions): Promise<() => void>;
+/**
+ * Stop the log reporter timer.
+ */
+export declare function stopLogReporter(): void;

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

@@ -0,0 +1,77 @@
+// Log Reporter Framework
+// Self-contained periodic log scanner + uploader + reporter.
+// Start via startLogReporter(), stop via stopLogReporter().
+import { resolveLogFiles, loadConfig } from "./config-loader.js";
+import { scanFile } from "./scanner.js";
+import { uploadIncrementalContent } from "./uploader.js";
+import { sendReport } from "./reporter.js";
+import { loadCursorStore, saveCursorStore, setCursor } from "./cursor-store.js";
+import { join } from "path";
+let intervalId = null;
+let isRunning = false;
+/**
+ * Start the log reporter. Runs the first scan immediately, then on the configured interval.
+ * Returns a stop function.
+ */
+export async function startLogReporter(options) {
+    const config = loadConfig(options.configPath);
+    const cursorPath = join(config.bakDir, ".log-reporter-cursor.json");
+    console.log(`[log-reporter] Starting with interval ${config.scanIntervalMs}ms, ${config.logFiles.length} log file(s) configured`);
+    async function doScan() {
+        if (isRunning)
+            return; // skip if previous scan still running
+        isRunning = true;
+        try {
+            const cursorStore = loadCursorStore(cursorPath);
+            for (const logFile of config.logFiles) {
+                const resolvedFiles = resolveLogFiles(logFile.path);
+                console.log(`[log-reporter] Scanning "${logFile.name}": pattern=${logFile.path}, resolved ${resolvedFiles.length} file(s)`);
+                for (const filePath of resolvedFiles) {
+                    await processFile(filePath, logFile.name, config, cursorStore, options);
+                }
+            }
+            saveCursorStore(cursorPath, cursorStore);
+        }
+        catch (err) {
+            console.error("[log-reporter] Scan failed:", err);
+        }
+        finally {
+            isRunning = false;
+        }
+    }
+    // Run first scan immediately
+    await doScan();
+    // Schedule periodic scans
+    intervalId = setInterval(doScan, config.scanIntervalMs);
+    intervalId.unref?.();
+    return () => stopLogReporter();
+}
+async function processFile(filePath, name, config, cursorStore, options) {
+    try {
+        const result = await scanFile(filePath, name, cursorStore);
+        if (!result)
+            return;
+        console.log(`[log-reporter] New content in "${name}": ${filePath} lines ${result.lineStart}-${result.lineEnd} (${result.newLineCount} lines)`);
+        // Upload .bak → get URL
+        const url = await uploadIncrementalContent(result, config.bakDir, options.uploadService);
+        console.log(`[log-reporter] Uploaded .bak for "${name}", url: ${url}`);
+        // Send report (mock)
+        await sendReport(config.reportUrl, url, result);
+        // Only persist cursor after successful upload + report
+        setCursor(cursorStore, filePath, result.newCursor);
+    }
+    catch (err) {
+        console.error(`[log-reporter] Failed processing "${name}" (${filePath}):`, err);
+        // Cursor NOT updated — will retry on next scan
+    }
+}
+/**
+ * Stop the log reporter timer.
+ */
+export function stopLogReporter() {
+    if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+        console.log("[log-reporter] Stopped");
+    }
+}

package/dist/src/log-reporter/reporter.d.ts

@@ -0,0 +1,6 @@
+import type { ScanResult } from "./types.js";
+/**
+ * Send a log report to the server with the uploaded file URL.
+ * MOCK implementation — real request logic will be added later.
+ */
+export declare function sendReport(reportUrl: string, fileUrl: string, result: ScanResult): Promise<void>;

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

@@ -0,0 +1,17 @@
+/**
+ * Send a log report to the server with the uploaded file URL.
+ * MOCK implementation — real request logic will be added later.
+ */
+export async function sendReport(reportUrl, fileUrl, result) {
+    // TODO: Replace with actual HTTP request
+    const payload = {
+        logName: result.name,
+        filePath: result.filePath,
+        lineStart: result.lineStart,
+        lineEnd: result.lineEnd,
+        newLineCount: result.newLineCount,
+        fileUrl,
+        timestamp: new Date().toISOString(),
+    };
+    console.log(`[log-reporter] Mock report to ${reportUrl}:`, JSON.stringify(payload, null, 2));
+}

package/dist/src/log-reporter/scanner.d.ts

@@ -0,0 +1,6 @@
+import type { ScanResult, CursorStore } from "./types.js";
+/**
+ * Scan a single log file for new content.
+ * Returns a ScanResult if there are new lines, or null if no changes.
+ */
+export declare function scanFile(filePath: string, name: string, cursorStore: CursorStore): Promise<ScanResult | null>;

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

@@ -0,0 +1,82 @@
+// Core scanner: resolves wildcard paths, reads incremental log content using byte-offset cursors
+import { statSync, createReadStream } from "fs";
+import { getCursor } from "./cursor-store.js";
+/**
+ * Read file content starting from a byte offset.
+ * Returns the full text content from that offset to end of file.
+ */
+function readFromOffset(filePath, startByte) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const stream = createReadStream(filePath, {
+            start: startByte,
+            encoding: "utf-8",
+        });
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => resolve(chunks.join("")));
+        stream.on("error", reject);
+    });
+}
+/**
+ * Determine the byte offset to start reading from, based on file state and cursor.
+ * Returns the startByte (0-based) or null if no new content.
+ */
+function resolveStartByte(currentSize, currentMtimeMs, cursor) {
+    if (!cursor) {
+        // New file: first scan — read from beginning
+        return 0;
+    }
+    if (currentSize > cursor.lastSize) {
+        // File grew: read from where we left off
+        return cursor.lastSize;
+    }
+    if (currentSize < cursor.lastSize && currentMtimeMs > cursor.lastModified) {
+        // File was rotated (truncated + rewritten): reset to beginning
+        return 0;
+    }
+    // No change (currentSize === cursor.lastSize) or edge case — skip
+    return null;
+}
+/**
+ * Scan a single log file for new content.
+ * Returns a ScanResult if there are new lines, or null if no changes.
+ */
+export async function scanFile(filePath, name, cursorStore) {
+    let stats;
+    try {
+        stats = statSync(filePath);
+    }
+    catch {
+        // File doesn't exist (yet) or was deleted — skip
+        return null;
+    }
+    const currentSize = stats.size;
+    const currentMtimeMs = stats.mtimeMs;
+    const cursor = getCursor(cursorStore, filePath);
+    const startByte = resolveStartByte(currentSize, currentMtimeMs, cursor);
+    if (startByte === null) {
+        return null; // no new content
+    }
+    const content = await readFromOffset(filePath, startByte);
+    // Count new lines — each \n represents one log line
+    const newLineCount = content.length > 0 ? content.split("\n").length - 1 : 0;
+    if (newLineCount === 0) {
+        // No complete lines yet (partial write), don't report
+        return null;
+    }
+    const prevLine = cursor?.lastLine ?? 0;
+    const newCursor = {
+        lastSize: currentSize,
+        lastLine: prevLine + newLineCount,
+        lastModified: currentMtimeMs,
+    };
+    return {
+        filePath,
+        name,
+        content,
+        lineStart: prevLine + 1,
+        lineEnd: prevLine + newLineCount,
+        newLineCount,
+        newCursor,
+    };
+}

package/dist/src/log-reporter/types.d.ts

@@ -0,0 +1,59 @@
+/** Configuration for a single log file to monitor */
+export interface LogFileConfig {
+    /** File path with optional date wildcards: {year}, {month}, {day}, {year-month-day}, {year}{month}{day} */
+    path: string;
+    /** Logical name used in .bak filename and reporting */
+    name: string;
+}
+/** Top-level log reporter configuration (loaded from JSON file) */
+export interface LogReporterConfig {
+    /** Scan interval in milliseconds (default: 600000 = 10 min) */
+    scanIntervalMs: number;
+    /** Directory for .bak files and cursor state */
+    bakDir: string;
+    /** Report server URL (mock for now) */
+    reportUrl: string;
+    /** Log files to monitor */
+    logFiles: LogFileConfig[];
+}
+/** Cursor state for a single log file */
+export interface FileCursor {
+    /** Byte offset we last read to */
+    lastSize: number;
+    /** Cumulative line count read so far */
+    lastLine: number;
+    /** File mtime (ms) at last read */
+    lastModified: number;
+}
+/** Persisted cursor store structure */
+export interface CursorStore {
+    files: Record<string, FileCursor>;
+}
+/** Result of scanning a single log file */
+export interface ScanResult {
+    /** Resolved absolute file path */
+    filePath: string;
+    /** Logical name from config */
+    name: string;
+    /** The new log lines (incremental content) */
+    content: string;
+    /** Start line number (1-based, inclusive) */
+    lineStart: number;
+    /** End line number (1-based, inclusive) */
+    lineEnd: number;
+    /** Number of new lines */
+    newLineCount: number;
+    /** Updated cursor to persist after successful upload */
+    newCursor: FileCursor;
+}
+/** Options passed to startLogReporter */
+export interface LogReporterOptions {
+    /** Absolute path to the JSON config file */
+    configPath: string;
+    /** File upload service instance (from xy_channel) */
+    uploadService: UploadService;
+}
+/** Minimal interface for the upload service (duck-typed from XYFileUploadService) */
+export interface UploadService {
+    uploadFileAndGetUrl(filePath: string, objectType?: string): Promise<string>;
+}

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

@@ -0,0 +1,2 @@
+// Type definitions for log reporter framework
+export {};

package/dist/src/log-reporter/uploader.d.ts

@@ -0,0 +1,6 @@
+import type { UploadService, ScanResult } from "./types.js";
+/**
+ * Write incremental content to .bak file, upload, and return the URL.
+ * Cleans up .bak file regardless of success/failure.
+ */
+export declare function uploadIncrementalContent(result: ScanResult, bakDir: string, uploadService: UploadService): Promise<string>;

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

@@ -0,0 +1,32 @@
+// Uploader: creates .bak file, uploads via XYFileUploadService, cleans up
+import { writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { mkdirSync } from "fs";
+/**
+ * Write incremental content to .bak file, upload, and return the URL.
+ * Cleans up .bak file regardless of success/failure.
+ */
+export async function uploadIncrementalContent(result, bakDir, uploadService) {
+    const timestamp = Date.now();
+    const bakFileName = `${result.name}_${timestamp}.bak`;
+    const bakPath = join(bakDir, bakFileName);
+    // Ensure bakDir exists
+    try {
+        mkdirSync(bakDir, { recursive: true });
+    }
+    catch { }
+    try {
+        // Write incremental content to .bak file
+        writeFileSync(bakPath, result.content, "utf-8");
+        // Upload and get URL
+        const url = await uploadService.uploadFileAndGetUrl(bakPath);
+        return url;
+    }
+    finally {
+        // Always clean up the .bak file
+        try {
+            unlinkSync(bakPath);
+        }
+        catch { }
+    }
+}

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,283 @@
+// 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 "MemoryStateGet":
+                result = handleMemoryStateGet();
+                break;
+            case "UserMdQuery":
+                result = handleUserMdQuery();
+                break;
+            case "MemoryMdQuery":
+                result = handleMemoryMdQuery();
+                break;
+            case "MemoryHistory":
+                result = handleMemoryHistory();
+                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 MEMORYSTATE from .xiaoyiruntime and return its boolean value.
+ * Missing file or key defaults to false.
+ */
+function handleMemoryStateGet() {
+    const filePath = resolveXiaoyiRuntimePath();
+    let content;
+    try {
+        content = readFileSync(filePath, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            logger.log(`[MEMORY-QUERY] ${filePath} not found`);
+        }
+        else {
+            logger.error(`[MEMORY-QUERY] Failed to read ${filePath}:`, err);
+        }
+        return { memoryState: false };
+    }
+    for (const line of content.split("\n")) {
+        if (line.startsWith(`${MEMORY_STATE_KEY}=`)) {
+            const value = line.slice(`${MEMORY_STATE_KEY}=`.length).trim();
+            logger.log(`[MEMORY-QUERY] read ${MEMORY_STATE_KEY}=${value} from ${filePath}`);
+            return { memoryState: value === "true" };
+        }
+    }
+    logger.log(`[MEMORY-QUERY] ${MEMORY_STATE_KEY} not found in ${filePath}`);
+    return { memoryState: false };
+}
+/**
+ * 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: "" };
+    }
+}
+const MEMORY_LOG_PATH = path.join(os.homedir(), ".openclaw", ".memory.log");
+const MEMORY_HISTORY_DAYS = 7;
+const MEMORY_RETENTION_DAYS = 30;
+/**
+ * Read ~/.openclaw/.memory.log, return last 7 days grouped by date,
+ * then prune entries older than 30 days.
+ *
+ * Log line format: `2026-06-22T15:18:00|user.md|更新了xxxx`
+ * Only split on the first two `|`; everything after is the detail
+ * (detail itself may contain `|`).
+ */
+function handleMemoryHistory() {
+    let content;
+    try {
+        content = readFileSync(MEMORY_LOG_PATH, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            logger.log(`[MEMORY-QUERY] memory.log not found: ${MEMORY_LOG_PATH}`);
+        }
+        else {
+            logger.error(`[MEMORY-QUERY] Failed to read memory.log:`, err);
+        }
+        return [];
+    }
+    const lines = content.split("\n");
+    const now = new Date();
+    const historySince = new Date(now);
+    historySince.setDate(now.getDate() - (MEMORY_HISTORY_DAYS - 1));
+    historySince.setHours(0, 0, 0, 0);
+    const retentionSince = new Date(now);
+    retentionSince.setDate(now.getDate() - (MEMORY_RETENTION_DAYS - 1));
+    retentionSince.setHours(0, 0, 0, 0);
+    const byDate = new Map();
+    const keptLines = [];
+    for (const raw of lines) {
+        const line = raw.trimEnd();
+        if (!line)
+            continue;
+        // Split on only the first two `|`; rest is detail (may contain `|`).
+        const firstPipe = line.indexOf("|");
+        if (firstPipe === -1)
+            continue;
+        const secondPipe = line.indexOf("|", firstPipe + 1);
+        if (secondPipe === -1)
+            continue;
+        const timestamp = line.slice(0, firstPipe);
+        const fileName = line.slice(firstPipe + 1, secondPipe);
+        const detail = line.slice(secondPipe + 1);
+        // timestamp format: 2026-06-22T15:18:00 → extract hh:mm
+        const datePart = timestamp.slice(0, 10);
+        const timePart = timestamp.slice(11, 16);
+        const entryDate = new Date(`${datePart}T00:00:00`);
+        // Retain log lines within the 30-day window.
+        if (!isNaN(entryDate.getTime()) && entryDate >= retentionSince) {
+            keptLines.push(line);
+        }
+        // Include in response if within the 7-day window.
+        if (!isNaN(entryDate.getTime()) && entryDate >= historySince) {
+            let bucket = byDate.get(datePart);
+            if (!bucket) {
+                bucket = [];
+                byDate.set(datePart, bucket);
+            }
+            bucket.push({ fileName, detail, time: timePart });
+        }
+    }
+    // Build ans array sorted by date descending, each entry is { <date>: [...] }.
+    const ans = Array.from(byDate.keys())
+        .sort()
+        .reverse()
+        .map((dateStr) => ({ [dateStr]: byDate.get(dateStr).reverse() }));
+    // Prune memory.log: keep only the last 30 days.
+    try {
+        const newContent = keptLines.length > 0 ? `${keptLines.join("\n")}\n` : "";
+        writeFileSync(MEMORY_LOG_PATH, newContent, "utf-8");
+        logger.log(`[MEMORY-QUERY] Pruned memory.log, kept ${keptLines.length} entries (>= ${retentionSince.toISOString().slice(0, 10)})`);
+    }
+    catch (err) {
+        logger.error(`[MEMORY-QUERY] Failed to prune memory.log:`, err);
+    }
+    logger.log(`[MEMORY-QUERY] MemoryHistory: returning ${ans.length} date buckets`);
+    return ans;
+}

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/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

@@ -632,6 +632,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);
@@ -721,6 +730,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": "1.1.31",
+  "version": "1.1.32",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",