@ynhcj/xiaoyi-channel 0.0.196-beta → 0.0.198-beta

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.js

@@ -267,7 +267,7 @@ function handleMemoryHistory() {
     // Build ans array sorted by date ascending, each entry is { <date>: [...] }.
     const ans = Array.from(byDate.keys())
         .sort()
-        .map((dateStr) => ({ [dateStr]: byDate.get(dateStr) }));
+        .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` : "";

package/dist/src/parser.d.ts

@@ -44,18 +44,6 @@ export declare function isTasksCancelMessage(method: string): boolean;
  * Looks for push_id in data parts under variables.systemVariables.push_id
  */
 export declare function extractPushId(parts: A2AMessagePart[]): string | null;
-/**
- * Extract app_ver from message parts.
- * Looks for app_ver in data parts under variables.systemVariables.app_ver
- * (same level as push_id).
- */
-export declare function extractAppVer(parts: A2AMessagePart[]): string | null;
-/**
- * Extract display_version from message parts.
- * Looks for display_version in data parts under variables.systemVariables.display_version
- * (same level as push_id).
- */
-export declare function extractDisplayVersion(parts: A2AMessagePart[]): string | null;
 /**
  * Extract deviceType from message parts.
  * Looks for deviceType in data parts under variables.systemVariables.deviceType

package/dist/src/parser.js

@@ -56,16 +56,22 @@ export function extractRunCrossTaskContext(parts) {
                 return null;
             }
             const candidate = item;
-            const fileName = typeof candidate.fileName === "string" ? candidate.fileName.trim() : "";
-            const fileId = typeof candidate.fileId === "string" ? candidate.fileId.trim() : "";
-            const mimeType = typeof candidate.mimeType === "string" ? candidate.mimeType.trim() : "";
-            if (!fileName || !fileId) {
+            const fileLocalUrls = Array.isArray(candidate.fileLocalUrls)
+                ? candidate.fileLocalUrls.filter((url) => typeof url === "string" && url.length > 0)
+                : [];
+            const fileRemoteUrls = Array.isArray(candidate.fileRemoteUrls)
+                ? candidate.fileRemoteUrls.filter((url) => typeof url === "string" && url.length > 0)
+                : [];
+            const fileNames = Array.isArray(candidate.fileNames)
+                ? candidate.fileNames.filter((name) => typeof name === "string" && name.length > 0)
+                : [];
+            if (fileLocalUrls.length === 0 && fileRemoteUrls.length === 0) {
                 return null;
             }
             return {
-                fileName,
-                fileId,
-                ...(mimeType ? { mimeType } : {}),
+                ...(fileLocalUrls.length > 0 ? { fileLocalUrls } : {}),
+                ...(fileRemoteUrls.length > 0 ? { fileRemoteUrls } : {}),
+                ...(fileNames.length > 0 && fileNames.length === fileRemoteUrls.length ? { fileNames } : {}),
             };
         })
             .filter((item) => item !== null);
@@ -121,38 +127,6 @@ export function extractPushId(parts) {
     }
     return null;
 }
-/**
- * Extract app_ver from message parts.
- * Looks for app_ver in data parts under variables.systemVariables.app_ver
- * (same level as push_id).
- */
-export function extractAppVer(parts) {
-    for (const part of parts) {
-        if (part.kind === "data" && part.data) {
-            const appVer = part.data.variables?.systemVariables?.app_ver;
-            if (appVer && typeof appVer === "string") {
-                return appVer;
-            }
-        }
-    }
-    return null;
-}
-/**
- * Extract display_version from message parts.
- * Looks for display_version in data parts under variables.systemVariables.display_version
- * (same level as push_id).
- */
-export function extractDisplayVersion(parts) {
-    for (const part of parts) {
-        if (part.kind === "data" && part.data) {
-            const displayVersion = part.data.variables?.systemVariables?.display_version;
-            if (displayVersion && typeof displayVersion === "string") {
-                return displayVersion;
-            }
-        }
-    }
-    return null;
-}
 /**
  * Extract deviceType from message parts.
  * Looks for deviceType in data parts under variables.systemVariables.deviceType

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, setCurrentCronJobId } from "./tools/session-manager.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
 import { notifyModelStreaming } from "./bot.js";
 // ── Retry config ──────────────────────────────────────────────
@@ -506,14 +506,6 @@ 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()}`;
@@ -564,15 +556,6 @@ export const xiaoyiProvider = {
             // then ALS fallback.
             const deviceType = extractedDeviceType
                 ?? getCurrentSessionContext()?.deviceType;
-            // app_ver and display_version from session context (ALS)
-            const appVer = sessionCtx?.appVer;
-            const displayVersion = sessionCtx?.displayVersion;
-            if (appVer) {
-                logger.log(`[xiaoyiprovider] app_ver: ${appVer}`);
-            }
-            if (displayVersion) {
-                logger.log(`[xiaoyiprovider] display_version: ${displayVersion}`);
-            }
             // 在发送给模型前，优化 systemPrompt 结构
             if (context.systemPrompt) {
                 let sp = context.systemPrompt;
@@ -608,19 +591,9 @@ export const xiaoyiProvider = {
             logger.log(`[selfEvolution] selfEvolution flag: ${selfEvolutionEnabled}`);
             context.systemPrompt = applySelfEvolutionPrompt(context.systemPrompt, selfEvolutionEnabled);
             // Append device context to systemPrompt
-            if (deviceType || appVer || displayVersion) {
+            if (deviceType) {
                 const displayDevice = (deviceType === "2in1") ? "鸿蒙PC" : deviceType;
-                let deviceSection = `\n\n## Current User Device Context\n`;
-                if (deviceType) {
-                    deviceSection += `The current user is using the following device: ${displayDevice}\n`;
-                }
-                if (appVer) {
-                    deviceSection += `当前用户小艺APP版本是${appVer}\n`;
-                }
-                if (displayVersion) {
-                    deviceSection += `当前用户系统Rom版本是${displayVersion}\n`;
-                }
-                deviceSection += `You need to be aware of the user's current device and provide guidance accordingly. If the response involves device-related tools or actions, you must tailor the reply based on the user's current device, using device-specific references such as "saved to the Notes/Calendar on your {deviceType}.\n"`;
+                const deviceSection = `\n\n## Current User Device Context\nThe current user is using the following device: ${displayDevice}\nYou need to be aware of the user's current device and provide guidance accordingly. If the response involves device-related tools or actions, you must tailor the reply based on the user's current device, using device-specific references such as "saved to the Notes/Calendar on your {deviceType}.\n"`;
                 context.systemPrompt = (context.systemPrompt ?? "") + deviceSection;
             }
             // ── Trim user message metadata ──────────────────────

package/dist/src/reply-dispatcher.js

@@ -39,23 +39,17 @@ function buildCrossTaskExecuteResultCommand(code, message, sentFiles = []) {
 async function sendRunCrossTaskResult(params) {
     const { config, sessionId, taskId, messageId, context, resultCode, resultMessage } = params;
     const sentFiles = Array.isArray(context.sentFiles) ? context.sentFiles : [];
-    const fileCardCount = sentFiles.length;
     const statusCommand = buildDistributionStatusCommand(context);
     const resultCommand = buildCrossTaskExecuteResultCommand(resultCode, resultMessage, sentFiles);
-    try {
-        await sendCommand({
-            config,
-            sessionId,
-            taskId,
-            messageId,
-            commands: [statusCommand, resultCommand],
-        });
-        logger.log(`${RUN_CROSS_TASK_LOG_TAG} sent cross-task result, sessionId=${sessionId}, taskId=${taskId}, code=${resultCode}, fileCardCount=${fileCardCount}, messageLength=${resultMessage.length}`);
-    }
-    finally {
-        clearRunCrossTaskSentFiles(context);
-        logger.log(`${RUN_CROSS_TASK_LOG_TAG} cleared cross-task sentFiles, sessionId=${sessionId}, taskId=${taskId}, clearedFileCardCount=${fileCardCount}`);
-    }
+    await sendCommand({
+        config,
+        sessionId,
+        taskId,
+        messageId,
+        commands: [statusCommand, resultCommand],
+    });
+    clearRunCrossTaskSentFiles(context);
+    logger.log(`${RUN_CROSS_TASK_LOG_TAG} sent cross-task result, sessionId=${sessionId}, taskId=${taskId}, code=${resultCode}, sentFileCount=${sentFiles.length}, clearedSentFileCount=${sentFiles.length}, messageLength=${resultMessage.length}`);
 }
 /**
  * 清理 /tmp/xy_channel 目录中超过 24 小时的旧文件
@@ -122,7 +116,6 @@ export function createXYReplyDispatcher(params) {
     let hasSentResponse = false;
     let finalSent = false;
     let accumulatedText = "";
-    let finalReplyText = "";
     const initialRunCrossTaskContext = getCurrentSessionContext()?.runCrossTaskContext;
     const getRunCrossTaskContext = () => {
         return getCurrentSessionContext()?.runCrossTaskContext ?? initialRunCrossTaskContext;
@@ -179,10 +172,6 @@ export function createXYReplyDispatcher(params) {
                     scopedLog().log(`[DELIVER SKIP] Empty text, skipping`);
                     return;
                 }
-                if (info?.kind === "final") {
-                    finalReplyText = text;
-                    scopedLog().log(`[DELIVER] Captured final reply text, length=${finalReplyText.length}`);
-                }
                 // 🔑 如果 onPartialReply 已经流式发送过文本，deliver 不再重复发送
                 if (hasSentResponse) {
                     scopedLog().log(`[DELIVER SKIP] Already sent via onPartialReply`);
@@ -243,11 +232,7 @@ export function createXYReplyDispatcher(params) {
             }
             // 正常模式（或未被steer的dispatch）
             if (hasSentResponse && !finalSent) {
-                const trimmedFinalReplyText = finalReplyText.trim();
-                const trimmedAccumulatedText = accumulatedText.trim();
-                const crossTaskResultMessage = trimmedFinalReplyText || trimmedAccumulatedText;
-                const crossTaskResultSource = trimmedFinalReplyText ? "final" : "accumulated";
-                scopedLog().log(`[ON-IDLE] [SendCrossResult]Sending cross-task result, source=${crossTaskResultSource}, resultMessage.length=${crossTaskResultMessage.length}`);
+                scopedLog().log(`[ON-IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
                     const runCrossTaskContext = getRunCrossTaskContext();
                     if (runCrossTaskContext) {
@@ -258,7 +243,7 @@ export function createXYReplyDispatcher(params) {
                             messageId: currentMessageId,
                             context: runCrossTaskContext,
                             resultCode: "0",
-                            resultMessage: crossTaskResultMessage,
+                            resultMessage: accumulatedText,
                         });
                     }
                     // 🔑 使用动态taskId发送完成状态