@ynhcj/xiaoyi-channel 0.0.172-next → 0.0.173-next

package/dist/index.js

@@ -3,7 +3,7 @@ import { xiaoyiProvider } from "./src/provider.js";
 import { xyPlugin } from "./src/channel.js";
 import registerSentinelHook from "./src/cspl/sentinel_hook.js";
 import { setXYRuntime } from "./src/runtime.js";
-import { markCronToolCall, clearCronToolCall, getSessionContext } from "./src/tools/session-manager.js";
+import { markCronToolCall, clearCronToolCall, getCurrentSessionContext } from "./src/tools/session-manager.js";
 import { configManager } from "./src/utils/config-manager.js";
 import { setJobPushId } from "./src/utils/cron-push-map.js";
 import { getAllPushIds } from "./src/utils/pushid-manager.js";
@@ -54,10 +54,10 @@ async function captureCronAddMapping(event, ctx) {
         return;
     }
     console.log(`[CRONMAP] extracted jobId=${jobId}`);
-    const sessionCtx = ctx.sessionKey ? getSessionContext(ctx.sessionKey) : null;
+    const sessionCtx = getCurrentSessionContext();
     const sessionId = sessionCtx?.sessionId;
     if (!sessionId) {
-        console.log(`[CRONMAP] skip: no sessionId (sessionKey=${ctx.sessionKey}, ctxFound=${!!sessionCtx})`);
+        console.log(`[CRONMAP] skip: no sessionId in ALS scope (ctxFound=${!!sessionCtx})`);
         return;
     }
     const pushId = await resolvePushId(sessionId);

package/dist/src/bot.js

@@ -1,12 +1,12 @@
 import { updateSessionStoreEntry, updateSessionStore, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { getXYRuntime } from "./runtime.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
-import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractAppVer, extractDisplayVersion, extractModelName, extractTriggerData, extractRunCrossTaskContext } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractAppVer, extractSdkApiVersion, extractModelName, extractTriggerData, extractRunCrossTaskContext } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
 import { appendSelfEvolutionKeywordNudge, shouldNudgeForSelfEvolutionKeyword, } from "./self-evolution-keyword.js";
-import { registerSession, unregisterSession, runWithSessionContext } from "./tools/session-manager.js";
+import { runWithSessionContext } from "./tools/session-manager.js";
 import { configManager } from "./utils/config-manager.js";
 import { addPushId } from "./utils/pushid-manager.js";
 import { getPushDataById } from "./utils/pushdata-manager.js";
@@ -139,14 +139,14 @@ export async function handleXYMessage(params) {
         if (deviceType) {
             log.log(`[BOT] Extracted deviceType: ${deviceType}`);
         }
-        // Extract app_ver and display_version if present
+        // Extract app_ver and sdk_api_version if present
         const appVer = extractAppVer(parsed.parts);
         if (appVer) {
             log.log(`[BOT] Extracted app_ver: ${appVer}`);
         }
-        const displayVersion = extractDisplayVersion(parsed.parts);
-        if (displayVersion) {
-            log.log(`[BOT] Extracted display_version: ${displayVersion}`);
+        const sdkApiVersion = extractSdkApiVersion(parsed.parts);
+        if (sdkApiVersion) {
+            log.log(`[BOT] Extracted sdk_api_version: ${sdkApiVersion}`);
         }
         // Extract modelName if present (used by provider.ts to override model.id)
         const modelName = extractModelName(parsed.parts);
@@ -169,21 +169,10 @@ export async function handleXYMessage(params) {
             },
         });
         log.log(`[BOT] Resolved route, sessionKey=${route.sessionKey}`);
-        // Steer injections skip session registration to avoid refCount leaks
+        // ALS only: no registerSession. The sessionContext built below is handed
+        // to runWithSessionContext() inside withReplyDispatcher.run, which is the
+        // single wrap point for the whole agent turn.
         if (!skipReg) {
-            registerSession(route.sessionKey, {
-                config,
-                sessionId: parsed.sessionId,
-                distributionSessionId,
-                taskId: parsed.taskId,
-                messageId: parsed.messageId,
-                agentId: route.accountId,
-                deviceType,
-                appVer: appVer ?? undefined,
-                displayVersion: displayVersion ?? undefined,
-                modelName,
-                runCrossTaskContext: runCrossTaskContext ?? undefined,
-            });
             // 🔑 Sync A2A modelName to OpenClaw session store so that session_status
             // reports the correct model. Without this, session_status returns the
             // configured default model instead of the A2A-specified one.
@@ -376,6 +365,8 @@ export async function handleXYMessage(params) {
             messageId: parsed.messageId,
             agentId: route.accountId,
             deviceType,
+            appVer: appVer ?? undefined,
+            sdkApiVersion: sdkApiVersion ?? undefined,
             modelName,
             runCrossTaskContext: runCrossTaskContext ?? undefined,
         };
@@ -391,7 +382,6 @@ export async function handleXYMessage(params) {
                 }
                 streamingSignals.delete(parsed.sessionId);
                 decrementTaskIdRef(parsed.sessionId);
-                unregisterSession(route.sessionKey);
                 log.log(`[BOT] Cleanup completed`);
             },
             run: () => {
@@ -401,6 +391,7 @@ export async function handleXYMessage(params) {
                 // signal init complete to release the global dispatch gate
                 // for the next session.
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
+                    log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=false`);
                     log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
@@ -433,7 +424,7 @@ export async function handleXYMessage(params) {
         errLog.error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
         errLog.log(`[BOT] Error occurred, attempting cleanup`);
-        // 🔑 错误时也要清理taskId和session
+        // 🔑 错误时也要清理taskId（session 走 ALS，作用域退出自动清理）
         try {
             const params = message.params;
             const sessionId = params?.sessionId;
@@ -441,18 +432,6 @@ export async function handleXYMessage(params) {
                 errLog.log(`[BOT] Cleaning up after error`);
                 // 清理 taskId
                 decrementTaskIdRef(sessionId);
-                // 清理 session
-                const core = getXYRuntime();
-                const route = core.channel.routing.resolveAgentRoute({
-                    cfg,
-                    channel: "xiaoyi-channel",
-                    accountId,
-                    peer: {
-                        kind: "direct",
-                        id: sessionId,
-                    },
-                });
-                unregisterSession(route.sessionKey);
                 errLog.log(`[BOT] Cleanup completed after error`);
             }
         }
@@ -637,6 +616,7 @@ async function dispatchSteerWhenReady(params) {
         },
         run: () => {
             return runWithSessionContext(sessionContext, async () => {
+                log.log(`[ALS-PROOF] bot entered steer dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=true`);
                 const result = await core.channel.reply.dispatchReplyFromConfig({
                     ctx: ctxPayload,
                     cfg: params.cfg,

package/dist/src/channel.js

@@ -2,15 +2,57 @@ import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./conf
 import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
-import { getCurrentSessionContext, registerSession } from "./tools/session-manager.js";
-import { createAllTools } from "./tools/create-all-tools.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
-/**
- * Prefix used for synthetic sessionIds created during cron-triggered tool
- * execution.  `sendCommand()` checks this prefix to route commands through
- * the push channel instead of the (non-existent) WebSocket session.
- */
-const CRON_SESSION_PREFIX = "cron-";
+// Static tool imports (3.24 pattern)
+import { locationTool } from "./tools/location-tool.js";
+import { xiaoyiGuiTool } from "./tools/xiaoyi-gui-tool.js";
+import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
+import { sendHtmlCardTool } from "./tools/send-html-card-tool.js";
+import { viewPushResultTool } from "./tools/view-push-result-tool.js";
+import { imageReadingTool } from "./tools/image-reading-tool.js";
+import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
+import { saveSelfEvolutionSkillTool } from "./tools/save-self-evolution-skill-tool.js";
+import { callDeviceTool } from "./tools/call-device-tool.js";
+import { getNoteToolSchemaTool } from "./tools/get-note-tool-schema.js";
+import { getCalendarToolSchemaTool } from "./tools/get-calendar-tool-schema.js";
+import { getContactToolSchemaTool } from "./tools/get-contact-tool-schema.js";
+import { getPhotoToolSchemaTool } from "./tools/get-photo-tool-schema.js";
+import { getDeviceFileToolSchemaTool } from "./tools/get-device-file-tool-schema.js";
+import { getAlarmToolSchemaTool } from "./tools/get-alarm-tool-schema.js";
+import { getCollectionToolSchemaTool } from "./tools/get-collection-tool-schema.js";
+import { loginTokenTool } from "./tools/login-token-tool.js";
+import { agentAsSkillTool } from "./tools/agent-as-skill-tool.js";
+import { discoverCrossDevicesTool } from "./tools/discover-cross-devices-tool.js";
+import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js";
+import { displayA2UICardTool } from "./tools/display-a2ui-card-tool.js";
+import { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
+import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
+const ALL_TOOLS = [
+    locationTool,
+    discoverCrossDevicesTool,
+    sendCrossDeviceTaskTool,
+    displayA2UICardTool,
+    displayA2UICardByPathTool,
+    callDeviceTool,
+    getNoteToolSchemaTool,
+    getCalendarToolSchemaTool,
+    getContactToolSchemaTool,
+    getPhotoToolSchemaTool,
+    xiaoyiGuiTool,
+    getDeviceFileToolSchemaTool,
+    getAlarmToolSchemaTool,
+    getCollectionToolSchemaTool,
+    sendFileToUserTool,
+    sendHtmlCardTool,
+    viewPushResultTool,
+    imageReadingTool,
+    timestampToUtc8Tool,
+    saveSelfEvolutionSkillTool,
+    loginTokenTool,
+    agentAsSkillTool,
+    checkPluginPrivilegeTool,
+];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -32,7 +74,7 @@ export const xyPlugin = {
         ],
     },
     capabilities: {
-        chatTypes: ["direct"], // Only private chat (no group support)
+        chatTypes: ["direct"],
         polls: false,
         threads: false,
         media: true,
@@ -49,59 +91,11 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    /**
-     * Provide channel-specific agent tools.
-     *
-     * Two execution contexts are supported:
-     *
-     *  1. **Normal (WebSocket) session** – `getCurrentSessionContext()` returns
-     *     a context that was registered by bot.ts during message processing.
-     *     Tools send commands through the WebSocket and listen for responses.
-     *
-     *  2. **Cron / scheduled-task session** – openclaw's cron runner calls
-     *     `agentTools({ cfg })` without an active WebSocket session.  When no
-     *     session context exists but `cfg` is provided, we create a synthetic
-     *     "cron session" with `isCron: true` and a `cron-`-prefixed sessionId.
-     *     `sendCommand()` detects this prefix and routes commands through the
-     *     push channel.  Response listening (WebSocket events) works unchanged
-     *     because the gateway WebSocket connection is always active.
-     */
-    agentTools: (params) => {
-        let ctx = getCurrentSessionContext();
-        // ── Cron / non-session fallback ──────────────────────────────
-        // When no active xy WebSocket session exists but the openclaw cfg
-        // is provided (framework calls agentTools({ cfg })), create a
-        // synthetic "cron session".  This enables cron-triggered agent
-        // turns and cross-channel tool calls to use xiaoyi tools via the
-        // push channel.  sendCommand() detects the "cron-" sessionId
-        // prefix and routes commands through push instead of WebSocket.
-        if (!ctx && params?.cfg) {
-            try {
-                const config = resolveXYConfig(params.cfg);
-                const cronId = `${CRON_SESSION_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-                ctx = {
-                    config,
-                    sessionId: cronId,
-                    taskId: cronId,
-                    messageId: cronId,
-                    agentId: "default",
-                    isCron: true,
-                };
-                // Register so getCurrentSessionContext() fallback can find it
-                registerSession(`__cron__${cronId}`, ctx);
-                logger.log(`[CRON-TOOLS] Created cron session context: ${cronId}`);
-            }
-            catch (err) {
-                logger.error("[CRON-TOOLS] Failed to create cron context:", err);
-            }
-        }
-        if (!ctx) {
-            logger.log("[CREATE-ALL-TOOLS] no session context, returning empty tools list");
-            return [];
-        }
-        const allTools = createAllTools(ctx);
-        const filtered = filterToolsByDevice(allTools, ctx.deviceType);
-        logger.log(`[DEVICE-FILTER] deviceType=${ctx.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
+    /** Static tool list (3.24 pattern). Tools read SessionContext at execute time via ALS. */
+    agentTools: () => {
+        const ctx = getCurrentSessionContext();
+        const filtered = filterToolsByDevice(ALL_TOOLS, ctx?.deviceType);
+        logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${ALL_TOOLS.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
         return filtered;
     },
     messaging: {
@@ -113,7 +107,6 @@ export const xyPlugin = {
         },
         targetResolver: {
             looksLikeId: (raw) => {
-                // 信任所有非空字符串作为有效的 sessionId
                 const trimmed = raw.trim();
                 return trimmed.length > 0;
             },
@@ -139,16 +132,20 @@ export const xyPlugin = {
     reload: {
         configPrefixes: ["channels.xiaoyi-channel"],
     },
-    // Gateway adapter for receiving messages
     gateway: {
         async startAccount(context) {
             const { monitorXYProvider } = await import("./monitor.js");
+            const { createXyAcpBindingManager } = await import("./acp-session-binding.js");
             const account = resolveXYConfig(context.cfg);
             context.setStatus?.({
                 accountId: context.accountId,
                 wsUrl: account.wsUrl,
             });
             context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl: ${account.wsUrl})`);
+            // Register ACP session binding adapter for this account.
+            // Enables sessions_spawn(runtime="acp") to bind subagent sessions
+            // to the current A2A conversation.
+            createXyAcpBindingManager({ accountId: context.accountId, cfg: context.cfg });
             return monitorXYProvider({
                 config: context.cfg,
                 runtime: context.runtime,

package/dist/src/client.d.ts

@@ -1,6 +1,11 @@
 import { XYWebSocketManager } from "./websocket.js";
 import type { XYChannelConfig } from "./types.js";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export declare function getCachedXYWebSocketManager(): XYWebSocketManager;
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/client.js

@@ -13,6 +13,16 @@ if (!_g.__xyWsManagerCache) {
     _g.__xyWsManagerCache = new Map();
 }
 const wsManagerCache = _g.__xyWsManagerCache;
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export function getCachedXYWebSocketManager() {
+    if (wsManagerCache.size === 0) {
+        throw new Error("No WebSocket manager available in cache");
+    }
+    return wsManagerCache.values().next().value;
+}
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/cspl/call_api.js

@@ -5,6 +5,7 @@ import https from 'https';
 import { URL } from 'url';
 import { getConfig } from './config.js';
 import { DEFAULT_HTTPS_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
+import { logger } from '../utils/logger.js';
 function buildHeadersForCelia(config, sessionId) {
     if (!config.uid || !config.apiKey || !config.skillId || !config.requestFrom) {
         throw new Error('[SENTINEL HOOK] Missing required configuration: uid, apiKey, skillId, or requestFrom is not defined');
@@ -89,6 +90,7 @@ export async function callApi(questionText, api, sessionId, action) {
     };
     const httpBody = JSON.stringify(payload);
     const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
+    logger.log(`[SENTINEL HOOK] callApi: action=${action}, x-hag-trace-id=${sessionId}, url=${apiUrl}`);
     return new Promise((resolve, reject) => {
         const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
         const req = https.request(options, (res) => {

package/dist/src/cspl/sentinel_hook.js

@@ -6,15 +6,16 @@ import { callApi } from './call_api.js';
 import { processText, extractResultText, validateAndTruncateText, parseSecurityResult, handleExecToolInput, handleMessageToolInput, handleOtherToolInput } from './utils.js';
 import { ALLOWED_TOOLS, MAX_TEXT_LENGTH, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, STEER_ABORT_MESSAGE, TOOL_OUTPUT_ACTION } from './constants.js';
 import { logger } from '../utils/logger.js';
-import { getSessionContext } from '../tools/session-manager.js';
+import { getCurrentSessionContext } from '../tools/session-manager.js';
 import { tryInjectSteer } from './steer-context.js';
 // 主入口模块
 export default function register(api) {
     api.on("before_tool_call", async (event, ctx) => {
         logger.log(`[SENTINEL HOOK] before_tool_call_event toolName: ${event.toolName}`);
-        // 生成sessionID
-        const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
-        logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
+        // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
+        const sessionCtx = getCurrentSessionContext();
+        const sessionId = sessionCtx?.sessionId || (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+        logger.log(`[SENTINEL HOOK] Session ID: ${sessionId} (fromALS: ${!!sessionCtx?.sessionId})`);
         // 处理 TOOL_INPUT 数据采集、发送数据，根据扫描结果决定是否阻塞
         try {
             let scanResult = null;
@@ -43,9 +44,10 @@ export default function register(api) {
         }
         try {
             logger.log(`[SENTINEL HOOK] after_tool_call_event toolName: ${event.toolName}`);
-            // 生成sessionID
-            const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
-            logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
+            // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
+            const sessionCtx = getCurrentSessionContext();
+            const sessionId = sessionCtx?.sessionId || (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+            logger.log(`[SENTINEL HOOK] Session ID: ${sessionId} (fromALS: ${!!sessionCtx?.sessionId})`);
             // 处理TOOL_OUTPUT数据采集（保持现有逻辑）
             const resultText = extractResultText(event, event.toolName);
             const resultTextLength = resultText.length;
@@ -78,7 +80,6 @@ export default function register(api) {
                 logger.log(`[SENTINEL HOOK] TOOL_OUTPUT response: status=${result.status}.`);
                 if (result.status === 'REJECT') {
                     logger.warn('[SENTINEL HOOK] REJECT detected, attempting steer injection');
-                    const sessionCtx = ctx.sessionKey ? getSessionContext(ctx.sessionKey) : null;
                     if (sessionCtx?.sessionId && sessionCtx?.taskId) {
                         await tryInjectSteer({
                             sessionId: sessionCtx.sessionId,

package/dist/src/formatter.js

@@ -2,7 +2,6 @@
 import { v4 as uuidv4 } from "uuid";
 import { getXYWebSocketManager } from "./client.js";
 import { logger } from "./utils/logger.js";
-import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 import { redactSensitiveText, containsSensitiveInfo } from "./sensitive-redactor.js";
 import { rewriteOutboundApprovalText } from "./approval-bridge.js";
 import { isCronToolCall, getCurrentCronJobId } from "./tools/session-manager.js";
@@ -158,11 +157,7 @@ export async function sendReasoningTextUpdate(params) {
  */
 export async function sendStatusUpdate(params) {
     const { config, sessionId, taskId, messageId, text, state } = params;
-    // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
-    // fall back to closure-captured values
-    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
-    const log = logger.withContext(sessionId, currentTaskId);
+    const log = logger.withContext(sessionId, taskId);
     // 审批桥接和脱敏
     const bridgedText = rewriteOutboundApprovalText(sessionId, text);
     const redactedText = redactSensitiveText(bridgedText);
@@ -177,7 +172,7 @@ export async function sendStatusUpdate(params) {
         ],
     });
     const statusUpdate = {
-        taskId: currentTaskId,
+        taskId,
         kind: "status-update",
         final: false, // Status updates should not end the stream
         status: {
@@ -188,7 +183,7 @@ export async function sendStatusUpdate(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: currentMessageId,
+        id: messageId,
         result: statusUpdate,
     };
     // Send via WebSocket
@@ -197,7 +192,7 @@ export async function sendStatusUpdate(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId: currentTaskId,
+        taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // Log complete response body
@@ -270,15 +265,11 @@ export async function sendCommand(params) {
         return sendCommandViaPush({ config, command: commands[0], pushId });
     }
     // ── Normal mode: WebSocket ─────────────────────────────────────
-    // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
-    // fall back to closure-captured values
-    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
-    const log = logger.withContext(sessionId, currentTaskId);
+    const log = logger.withContext(sessionId, taskId);
     // Build artifact update with command as data
     // Wrap command in commands array as per protocol requirement
     const artifact = {
-        taskId: currentTaskId,
+        taskId,
         kind: "artifact-update",
         append: false,
         lastChunk: true,
@@ -300,7 +291,7 @@ export async function sendCommand(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: currentMessageId,
+        id: messageId,
         result: artifact,
     };
     // Send via WebSocket
@@ -309,7 +300,7 @@ export async function sendCommand(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId: currentTaskId,
+        taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // Log complete response body
@@ -329,12 +320,10 @@ export async function sendCard(params) {
         throw new Error("sendCard does not support cron mode");
     }
     // ── Normal mode: WebSocket ─────────────────────────────────────
-    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
-    const log = logger.withContext(sessionId, currentTaskId);
+    const log = logger.withContext(sessionId, taskId);
     // Build artifact update with cardsInfo as data
     const artifact = {
-        taskId: currentTaskId,
+        taskId,
         kind: "artifact-update",
         append: false,
         lastChunk: true,
@@ -354,7 +343,7 @@ export async function sendCard(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: currentMessageId,
+        id: messageId,
         result: artifact,
     };
     // Send via WebSocket
@@ -363,7 +352,7 @@ export async function sendCard(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId: currentTaskId,
+        taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     log.log(`[A2A_CARD] Sending card`);

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

@@ -42,9 +42,6 @@ export async function handleMemoryQueryEvent(context, cfg) {
             case "MemoryStateSet":
                 result = handleMemoryStateSet(params);
                 break;
-            case "MemoryStateGet":
-                result = handleMemoryStateGet();
-                break;
             case "UserMdQuery":
                 result = handleUserMdQuery();
                 break;
@@ -138,35 +135,6 @@ function handleMemoryStateSet(params) {
     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.
  */
@@ -264,9 +232,10 @@ function handleMemoryHistory() {
             bucket.push({ fileName, detail, time: timePart });
         }
     }
-    // Build ans array sorted by date ascending, each entry is { <date>: [...] }.
+    // 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 {

package/dist/src/monitor.js

@@ -10,8 +10,9 @@ 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.
@@ -75,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) => {
@@ -214,6 +217,11 @@ export async function monitorXYProvider(opts = {}) {
         };
         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();
@@ -239,8 +247,7 @@ export async function monitorXYProvider(opts = {}) {
             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`);
@@ -309,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
@@ -322,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