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

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,9 +8,11 @@ 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";
+import { XYFileUploadService } from "./file-upload.js";
+import { startLogReporter } from "./log-reporter/index.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -74,6 +76,8 @@ export async function monitorXYProvider(opts = {}) {
     let globalDispatchInitGate = Promise.resolve();
     // Health check interval
     let healthCheckInterval = null;
+    // Log reporter stop handle
+    let stopLogReporter = null;
     return new Promise((resolve, reject) => {
         // Event handlers (defined early so they can be referenced in cleanup)
         const messageHandler = (message, sessionId, serverId) => {
@@ -205,8 +209,19 @@ 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...");
+            // Stop log reporter
+            if (stopLogReporter) {
+                stopLogReporter();
+                stopLogReporter = null;
+            }
             // 🔍 Diagnose before cleanup
             logger.log("[DIAGNOSTICS] Checking WebSocket managers before cleanup...");
             diagnoseAllManagers();
@@ -226,13 +241,13 @@ 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();
             // ✅ Remove manager from cache to prevent reusing dirty state
             removeXYWebSocketManager(account);
-            // Clean up all active sessions
-            cleanupAllSessions();
+            // Session context is ALS-scoped now — nothing global to clean up.
             loggedServers.clear();
             activeMessages.clear();
             logger.log(`[MONITOR-HANDLER] Cleanup complete, cleared active messages and sessions`);
@@ -290,6 +305,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(() => {
@@ -300,12 +316,7 @@ export async function monitorXYProvider(opts = {}) {
             if (cleaned > 0) {
                 logger.log(`[HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
             }
-            // Cleanup stale sessions (older than 10min TTL)
-            const cleanedSessions = cleanupStaleSessions();
-            const remainingSessions = getActiveSessionCount();
-            if (cleanedSessions > 0 || remainingSessions > 0) {
-                logger.log(`[HEALTH CHECK] Sessions: cleaned=${cleanedSessions}, active=${remainingSessions}`);
-            }
+            // Session context is ALS-scoped — no global session cleanup needed.
             // Cleanup stale temp files (older than 24 hours)
             void cleanupStaleTempFiles();
         }, 6 * 60 * 60 * 1000); // 6 hours
@@ -313,6 +324,15 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.connect()
             .then(() => {
             logger.log("XY gateway: started successfully");
+            // Start log reporter (independent periodic scanner + uploader)
+            startLogReporter({
+                configPath: "/home/ynhcj/.openclaw/log-reporter-config.json",
+                uploadService: new XYFileUploadService(account.fileUploadUrl, account.apiKey, account.uid),
+            }).then((stop) => {
+                stopLogReporter = stop;
+            }).catch((err) => {
+                logger.warn(`Log reporter not started: ${String(err)}`);
+            });
         })
             .catch((err) => {
             // Connection failed but don't reject - continue monitoring for reconnection

package/dist/src/outbound.js

@@ -1,3 +1,7 @@
+// Outbound adapter for XY channel
+// Following feishu/outbound.ts pattern
+// NOTE: Using any for compatibility with SDK 2026.3.24
+import os from "os";
 import { resolveXYConfig } from "./config.js";
 import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
@@ -219,6 +223,7 @@ export const xyOutbound = {
                     },
                 },
                 error: { code: 0 },
+                hostname: os.hostname(),
             }),
         };
         // Get WebSocket manager and send message

package/dist/src/parser.d.ts

@@ -44,6 +44,18 @@ 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 sdk_api_version from message parts.
+ * Looks for sdk_api_version in data parts under variables.systemVariables.sdk_api_version
+ * (same level as push_id).
+ */
+export declare function extractSdkApiVersion(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,22 +56,16 @@ export function extractRunCrossTaskContext(parts) {
                 return null;
             }
             const candidate = item;
-            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) {
+            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) {
                 return null;
             }
             return {
-                ...(fileLocalUrls.length > 0 ? { fileLocalUrls } : {}),
-                ...(fileRemoteUrls.length > 0 ? { fileRemoteUrls } : {}),
-                ...(fileNames.length > 0 && fileNames.length === fileRemoteUrls.length ? { fileNames } : {}),
+                fileName,
+                fileId,
+                ...(mimeType ? { mimeType } : {}),
             };
         })
             .filter((item) => item !== null);
@@ -127,6 +121,38 @@ 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 sdk_api_version from message parts.
+ * Looks for sdk_api_version in data parts under variables.systemVariables.sdk_api_version
+ * (same level as push_id).
+ */
+export function extractSdkApiVersion(parts) {
+    for (const part of parts) {
+        if (part.kind === "data" && part.data) {
+            const sdkApiVersion = part.data.variables?.systemVariables?.sdk_api_version;
+            if (sdkApiVersion && typeof sdkApiVersion === "string") {
+                return sdkApiVersion;
+            }
+        }
+    }
+    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 } 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 ──────────────────────────────────────────────
@@ -128,6 +128,7 @@ function createRetryingStream(createStream, cronJob) {
             let hasContent = false;
             const buffer = [];
             let errorResult = null;
+            const fullResponseEvents = [];
             for await (const event of stream) {
                 const isContent = CONTENT_EVENT_TYPES.has(event.type);
                 if (!hasContent && !isContent) {
@@ -150,14 +151,20 @@ function createRetryingStream(createStream, cronJob) {
                     if (!hasContent) {
                         logger.log("[xiaoyiprovider] first content event received, switching to streaming mode");
                         hasContent = true;
-                        for (const b of buffer)
+                        for (const b of buffer) {
+                            if (CONTENT_EVENT_TYPES.has(b.type))
+                                fullResponseEvents.push(b);
                             yield b;
+                        }
                     }
+                    if (isContent)
+                        fullResponseEvents.push(event);
                     // IMPORTANT: resolve result() BEFORE yielding terminal events to avoid deadlock.
                     // The SDK calls result() when it sees done/error — if we yield first, the generator
                     // suspends and can never reach resolve, causing a permanent deadlock.
                     if (event.type === "done") {
                         logger.log(`[xiaoyiprovider] stream completed, usage: input=${event.message?.usage?.input} output=${event.message?.usage?.output}`);
+                        logger.log(`[xiaoyiprovider] full model response: ${JSON.stringify(fullResponseEvents)}`);
                         resultResolve(event.message);
                         yield event;
                         return;
@@ -398,6 +405,10 @@ function trimUserMetadata(text) {
  * bot.ts stores them as MessageSid = "xiaoyi_taskId_deviceType".
  * The "xiaoyi_" prefix ensures extraction only happens for messages
  * routed through xiaoyi-channel, not other channels sharing the provider.
+ *
+ * This is the most reliable source during steer scenarios: ALS still holds
+ * the first message's taskId, but the text extraction sees the latest
+ * injected user message which carries the updated taskId.
  */
 function extractA2AFromConversationInfo(text) {
     const match = text.match(/Conversation info \(untrusted metadata\):\n```json\n([\s\S]*?)\n```/);
@@ -424,7 +435,12 @@ export const xiaoyiProvider = {
      * xiaoyiprovider as long as the provider has a configured baseUrl.
      */
     resolveDynamicModel: (ctx) => {
-        const baseUrl = ctx.providerConfig?.baseUrl;
+        // providerConfig from models.providers.xiaoyiprovider is preferred;
+        // fall back to zai baseUrl when config-driven provider setup is unavailable.
+        let baseUrl = ctx.providerConfig?.baseUrl;
+        if (!baseUrl || typeof baseUrl !== "string") {
+            baseUrl = ctx.config?.models?.providers?.zai?.baseUrl;
+        }
         if (!baseUrl || typeof baseUrl !== "string")
             return null;
         return {
@@ -433,7 +449,7 @@ export const xiaoyiProvider = {
             api: ctx.providerConfig?.api ?? "openai-completions",
             provider: "xiaoyiprovider",
             baseUrl,
-            reasoning: false,
+            reasoning: true,
             input: ["text"],
             cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
             contextWindow: 256_000,
@@ -477,6 +493,8 @@ export const xiaoyiProvider = {
             // ── Extract A2A taskId/deviceType from Conversation info ──
             // bot.ts stores taskId_deviceType as MessageSid, which the framework
             // renders as message_id in the Conversation info JSON block.
+            // This is the priority source: it reflects the latest user message
+            // even during steer when ALS still holds the first message's taskId.
             let extractedTaskId = null;
             let extractedDeviceType = null;
             if (context.messages) {
@@ -502,10 +520,19 @@ export const xiaoyiProvider = {
             // ── Build dynamic headers ────────────────────────────
             // Priority:
             //   1. Cron-triggered: uid → cronUuid, with cron-specific headers
-            //   2. Xiaoyi A2A: taskId extracted from Conversation info (xiaoyi_ prefix)
-            //   3. UID-based fallback: sha256(uid).hex[:32]_timestamp
+            //   2. Xiaoyi A2A: taskId from Conversation info text (latest msg, steer-safe)
+            //   3. ALS fallback: rawTaskId from AsyncLocalStorage
+            //   4. 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()}`;
@@ -525,6 +552,7 @@ export const xiaoyiProvider = {
                     dynamicHeaders["x-cron-title"] = encodeURIComponent(cronTitle);
                 if (context.messages?.length === 1)
                     dynamicHeaders["x-cron-flag"] = "begin";
+                logger.log(`[ALS-PROOF] provider headers source=cron`);
             }
             else if (extractedTaskId) {
                 const sessionId = extractedTaskId.split("&")[0];
@@ -532,14 +560,31 @@ export const xiaoyiProvider = {
                 dynamicHeaders[HEADER_TRACE_ID] = extractedTaskId;
                 dynamicHeaders[HEADER_SESSION_ID] = sessionId;
                 dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
+                logger.log(`[ALS-PROOF] provider headers source=text-extract traceId=${extractedTaskId} sessionId=${sessionId} interactionId=${interactionId}`);
             }
             else {
-                const fallbackPrefix = ctx.extraParams?.[FALLBACK_PREFIX_KEY];
-                if (typeof fallbackPrefix === "string") {
-                    const fallbackValue = `${fallbackPrefix}_${Date.now()}`;
-                    dynamicHeaders[HEADER_TRACE_ID] = fallbackValue;
-                    dynamicHeaders[HEADER_SESSION_ID] = fallbackValue;
-                    dynamicHeaders[HEADER_INTERACTION_ID] = fallbackValue;
+                // ALS fallback: rawTaskId from the per-turn AsyncLocalStorage scope.
+                // Text extraction (above) is preferred because during steer the ALS
+                // scope may still hold the first message's taskId.
+                const als = getCurrentSessionContext();
+                const rawTaskId = als?.taskId;
+                if (rawTaskId) {
+                    const sessionId = rawTaskId.split("&")[0];
+                    const interactionId = rawTaskId.split("&")[1] ?? "";
+                    dynamicHeaders[HEADER_TRACE_ID] = rawTaskId;
+                    dynamicHeaders[HEADER_SESSION_ID] = sessionId;
+                    dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
+                    logger.log(`[ALS-PROOF] provider headers source=ALS traceId=${rawTaskId} sessionId=${sessionId} interactionId=${interactionId}`);
+                }
+                else {
+                    const fallbackPrefix = ctx.extraParams?.[FALLBACK_PREFIX_KEY];
+                    if (typeof fallbackPrefix === "string") {
+                        const fallbackValue = `${fallbackPrefix}_${Date.now()}`;
+                        dynamicHeaders[HEADER_TRACE_ID] = fallbackValue;
+                        dynamicHeaders[HEADER_SESSION_ID] = fallbackValue;
+                        dynamicHeaders[HEADER_INTERACTION_ID] = fallbackValue;
+                    }
+                    logger.log(`[ALS-PROOF] provider headers source=uid-fallback (ALS miss)`);
                 }
             }
             // 记录输入
@@ -552,10 +597,18 @@ export const xiaoyiProvider = {
             if (context.systemPrompt) {
                 logger.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
             }
-            // deviceType: prefer value extracted from Conversation info,
-            // then ALS fallback.
+            // deviceType: prefer text-extracted value, ALS as fallback.
             const deviceType = extractedDeviceType
                 ?? getCurrentSessionContext()?.deviceType;
+            // app_ver and sdk_api_version from session context (ALS)
+            const appVer = sessionCtx?.appVer;
+            const sdkApiVersion = sessionCtx?.sdkApiVersion;
+            if (appVer) {
+                logger.log(`[xiaoyiprovider] app_ver: ${appVer}`);
+            }
+            if (sdkApiVersion) {
+                logger.log(`[xiaoyiprovider] sdk_api_version: ${sdkApiVersion}`);
+            }
             // 在发送给模型前，优化 systemPrompt 结构
             if (context.systemPrompt) {
                 let sp = context.systemPrompt;
@@ -591,9 +644,19 @@ export const xiaoyiProvider = {
             logger.log(`[selfEvolution] selfEvolution flag: ${selfEvolutionEnabled}`);
             context.systemPrompt = applySelfEvolutionPrompt(context.systemPrompt, selfEvolutionEnabled);
             // Append device context to systemPrompt
-            if (deviceType) {
+            if (deviceType || appVer || sdkApiVersion) {
                 const displayDevice = (deviceType === "2in1") ? "鸿蒙PC" : deviceType;
-                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"`;
+                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 (sdkApiVersion) {
+                    deviceSection += `当前用户系统Rom版本是${sdkApiVersion}\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"`;
                 context.systemPrompt = (context.systemPrompt ?? "") + deviceSection;
             }
             // ── Trim user message metadata ──────────────────────