@ynhcj/xiaoyi-channel 0.0.171-next → 0.0.172-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, getCurrentSessionContext } from "./src/tools/session-manager.js";
+import { markCronToolCall, clearCronToolCall, getSessionContext } from "./src/tools/session-manager.js";
 import { configManager } from "./src/utils/config-manager.js";
 import { setJobPushId } from "./src/utils/cron-push-map.js";
 import { getAllPushIds } from "./src/utils/pushid-manager.js";
@@ -54,10 +54,10 @@ async function captureCronAddMapping(event, ctx) {
         return;
     }
     console.log(`[CRONMAP] extracted jobId=${jobId}`);
-    const sessionCtx = getCurrentSessionContext();
+    const sessionCtx = ctx.sessionKey ? getSessionContext(ctx.sessionKey) : null;
     const sessionId = sessionCtx?.sessionId;
     if (!sessionId) {
-        console.log(`[CRONMAP] skip: no sessionId in ALS scope (ctxFound=${!!sessionCtx})`);
+        console.log(`[CRONMAP] skip: no sessionId (sessionKey=${ctx.sessionKey}, ctxFound=${!!sessionCtx})`);
         return;
     }
     const pushId = await resolvePushId(sessionId);

package/dist/src/bot.js

@@ -6,7 +6,7 @@ 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 { runWithSessionContext } from "./tools/session-manager.js";
+import { registerSession, unregisterSession, 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";
@@ -169,10 +169,21 @@ export async function handleXYMessage(params) {
             },
         });
         log.log(`[BOT] Resolved route, sessionKey=${route.sessionKey}`);
-        // 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.
+        // Steer injections skip session registration to avoid refCount leaks
         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.
@@ -380,6 +391,7 @@ export async function handleXYMessage(params) {
                 }
                 streamingSignals.delete(parsed.sessionId);
                 decrementTaskIdRef(parsed.sessionId);
+                unregisterSession(route.sessionKey);
                 log.log(`[BOT] Cleanup completed`);
             },
             run: () => {
@@ -389,7 +401,6 @@ 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({
@@ -422,7 +433,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 走 ALS，作用域退出自动清理）
+        // 🔑 错误时也要清理taskId和session
         try {
             const params = message.params;
             const sessionId = params?.sessionId;
@@ -430,6 +441,18 @@ 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`);
             }
         }
@@ -614,7 +637,6 @@ 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,55 +2,15 @@ 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 } from "./tools/session-manager.js";
+import { getCurrentSessionContext, registerSession } from "./tools/session-manager.js";
+import { createAllTools } from "./tools/create-all-tools.js";
 import { logger } from "./utils/logger.js";
-// 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 { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
-const ALL_TOOLS = [
-    locationTool,
-    discoverCrossDevicesTool,
-    sendCrossDeviceTaskTool,
-    displayA2UICardTool,
-    callDeviceTool,
-    getNoteToolSchemaTool,
-    getCalendarToolSchemaTool,
-    getContactToolSchemaTool,
-    getPhotoToolSchemaTool,
-    xiaoyiGuiTool,
-    getDeviceFileToolSchemaTool,
-    getAlarmToolSchemaTool,
-    getCollectionToolSchemaTool,
-    sendFileToUserTool,
-    sendHtmlCardTool,
-    viewPushResultTool,
-    imageReadingTool,
-    timestampToUtc8Tool,
-    saveSelfEvolutionSkillTool,
-    loginTokenTool,
-    agentAsSkillTool,
-    checkPluginPrivilegeTool,
-];
+/**
+ * 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-";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -72,7 +32,7 @@ export const xyPlugin = {
         ],
     },
     capabilities: {
-        chatTypes: ["direct"],
+        chatTypes: ["direct"], // Only private chat (no group support)
         polls: false,
         threads: false,
         media: true,
@@ -89,11 +49,59 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    /** 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(", ")})`);
+    /**
+     * 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(", ")})`);
         return filtered;
     },
     messaging: {
@@ -105,6 +113,7 @@ export const xyPlugin = {
         },
         targetResolver: {
             looksLikeId: (raw) => {
+                // 信任所有非空字符串作为有效的 sessionId
                 const trimmed = raw.trim();
                 return trimmed.length > 0;
             },
@@ -130,20 +139,16 @@ 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,11 +1,6 @@
 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,16 +13,6 @@ 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,7 +5,6 @@ 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');
@@ -90,7 +89,6 @@ 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,16 +6,15 @@ 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 { getCurrentSessionContext } from '../tools/session-manager.js';
+import { getSessionContext } 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：优先使用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})`);
+        // 生成sessionID
+        const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+        logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
         // 处理 TOOL_INPUT 数据采集、发送数据，根据扫描结果决定是否阻塞
         try {
             let scanResult = null;
@@ -44,10 +43,9 @@ export default function register(api) {
         }
         try {
             logger.log(`[SENTINEL HOOK] after_tool_call_event toolName: ${event.toolName}`);
-            // 获取真实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})`);
+            // 生成sessionID
+            const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+            logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
             // 处理TOOL_OUTPUT数据采集（保持现有逻辑）
             const resultText = extractResultText(event, event.toolName);
             const resultTextLength = resultText.length;
@@ -80,6 +78,7 @@ 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,6 +2,7 @@
 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";
@@ -157,7 +158,11 @@ export async function sendReasoningTextUpdate(params) {
  */
 export async function sendStatusUpdate(params) {
     const { config, sessionId, taskId, messageId, text, state } = params;
-    const log = logger.withContext(sessionId, taskId);
+    // 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 bridgedText = rewriteOutboundApprovalText(sessionId, text);
     const redactedText = redactSensitiveText(bridgedText);
@@ -172,7 +177,7 @@ export async function sendStatusUpdate(params) {
         ],
     });
     const statusUpdate = {
-        taskId,
+        taskId: currentTaskId,
         kind: "status-update",
         final: false, // Status updates should not end the stream
         status: {
@@ -183,7 +188,7 @@ export async function sendStatusUpdate(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: messageId,
+        id: currentMessageId,
         result: statusUpdate,
     };
     // Send via WebSocket
@@ -192,7 +197,7 @@ export async function sendStatusUpdate(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId,
+        taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // Log complete response body
@@ -265,11 +270,15 @@ export async function sendCommand(params) {
         return sendCommandViaPush({ config, command: commands[0], pushId });
     }
     // ── Normal mode: WebSocket ─────────────────────────────────────
-    const log = logger.withContext(sessionId, taskId);
+    // 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);
     // Build artifact update with command as data
     // Wrap command in commands array as per protocol requirement
     const artifact = {
-        taskId,
+        taskId: currentTaskId,
         kind: "artifact-update",
         append: false,
         lastChunk: true,
@@ -291,7 +300,7 @@ export async function sendCommand(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: messageId,
+        id: currentMessageId,
         result: artifact,
     };
     // Send via WebSocket
@@ -300,7 +309,7 @@ export async function sendCommand(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId,
+        taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // Log complete response body
@@ -320,10 +329,12 @@ export async function sendCard(params) {
         throw new Error("sendCard does not support cron mode");
     }
     // ── Normal mode: WebSocket ─────────────────────────────────────
-    const log = logger.withContext(sessionId, taskId);
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+    const log = logger.withContext(sessionId, currentTaskId);
     // Build artifact update with cardsInfo as data
     const artifact = {
-        taskId,
+        taskId: currentTaskId,
         kind: "artifact-update",
         append: false,
         lastChunk: true,
@@ -343,7 +354,7 @@ export async function sendCard(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: messageId,
+        id: currentMessageId,
         result: artifact,
     };
     // Send via WebSocket
@@ -352,7 +363,7 @@ export async function sendCard(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId,
+        taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     log.log(`[A2A_CARD] Sending card`);

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

@@ -42,6 +42,9 @@ export async function handleMemoryQueryEvent(context, cfg) {
             case "MemoryStateSet":
                 result = handleMemoryStateSet(params);
                 break;
+            case "MemoryStateGet":
+                result = handleMemoryStateGet();
+                break;
             case "UserMdQuery":
                 result = handleUserMdQuery();
                 break;
@@ -135,6 +138,35 @@ 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.
  */
@@ -235,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/monitor.js

@@ -10,9 +10,8 @@ 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.
@@ -76,8 +75,6 @@ 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) => {
@@ -217,11 +214,6 @@ 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();
@@ -247,7 +239,8 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.disconnect();
             // ✅ Remove manager from cache to prevent reusing dirty state
             removeXYWebSocketManager(account);
-            // Session context is ALS-scoped now — nothing global to clean up.
+            // Clean up all active sessions
+            cleanupAllSessions();
             loggedServers.clear();
             activeMessages.clear();
             logger.log(`[MONITOR-HANDLER] Cleanup complete, cleared active messages and sessions`);
@@ -316,7 +309,12 @@ export async function monitorXYProvider(opts = {}) {
             if (cleaned > 0) {
                 logger.log(`[HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
             }
-            // Session context is ALS-scoped — no global session cleanup needed.
+            // 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}`);
+            }
             // Cleanup stale temp files (older than 24 hours)
             void cleanupStaleTempFiles();
         }, 6 * 60 * 60 * 1000); // 6 hours
@@ -324,15 +322,6 @@ 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