@ynhcj/xiaoyi-channel 0.0.226-next → 0.0.228-next

package/dist/index.js

@@ -15,8 +15,6 @@ import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
 import { registerCLIHook } from "./src/tools/hmos-cli.js";
 import { recoverCronState } from "./src/cron-recovery.js";
 import { writeSkillUsage } from "./src/utils/skills-logger.js";
-import { markSubagentSpawned, markSubagentEnded, deliverSubagentFinalResult, } from "./src/conversation/conversation-manager.js";
-import { notifyCronAgentEnd } from "./src/conversation/cron-buffer.js";
 import { logger } from "./src/utils/logger.js";
 /**
  * Parse a file path string to detect if it refers to a SKILL.md file within
@@ -45,23 +43,37 @@ function extractSkillNameFromPath(filePath) {
  * the `after_tool_call` hook and write the skill name to the skills log.
  */
 function registerSkillsDiagnosticHook(api) {
-    // Tool name → skill name mapping for direct tool-based skill usage logging
-    const TOOL_SKILL_MAP = {
-        get_user_location: "GetCurrentLocation",
-        get_calendar_tool_schema: "Schedule",
-        get_note_tool_schema: "memorandum",
-        get_photo_tool_schema: "gallery",
-        get_contact_tool_schema: "contact",
-        get_device_file_tool_schema: "file",
-        get_alarm_tool_schema: "clock",
-        message: "message",
-        get_phone_tool_schema: "phone",
-        get_collection_tool_schema: "xiaoyi-collection",
-        image_reading: "xiaoyi-image-understanding"
+    // Skill name → tool names mapping for direct tool-based skill usage logging
+    const SKILL_TOOLS = {
+        GetCurrentLocation: ["get_user_location"],
+        Schedule: ["create_calendar_event", "search_calendar_event"],
+        memorandum: ["create_note", "search_notes", "modify_note"],
+        gallery: ["search_photo_gallery", "save_media_to_gallery"],
+        contact: ["search_contact"],
+        file: ["search_file", "upload_file", "save_file_to_file_manager"],
+        clock: ["create_alarm", "delete_alarm", "search_alarm", "modify_alarm"],
+        message: ["search_message", "send_message"],
+        phone: ["call_phone"],
+        "xiaoyi-collection": ["add_collection", "query_collection", "delete_collection"],
+        "xiaoyi-image-understanding": ["image_reading"],
     };
+    // Inverted to tool name → skill name for lookup
+    const TOOL_SKILL_MAP = Object.fromEntries(Object.entries(SKILL_TOOLS).flatMap(([skill, tools]) => tools.map((t) => [t, skill])));
+    // Resolve the actual tool name from call_device_tool wrapper.
+    // The model calls call_device_tool({ toolName: "...", arguments: {...} })
+    // — the real tool name is inside params, not event.toolName.
+    function resolveActualToolName(event) {
+        if (event.toolName === "call_device_tool") {
+            const inner = event.params?.toolName;
+            if (typeof inner === "string" && inner.length > 0)
+                return inner;
+        }
+        return event.toolName;
+    }
     // Log skill usage for known device tools on before_tool_call
     api.on("before_tool_call", async (event, _ctx) => {
-        const skillName = TOOL_SKILL_MAP[event.toolName];
+        const actualToolName = resolveActualToolName(event);
+        const skillName = TOOL_SKILL_MAP[actualToolName];
         if (skillName) {
             writeSkillUsage(skillName);
         }
@@ -306,152 +318,7 @@ function registerCronRecoveryHook(api) {
         logger.log(`${logTag} ═══════════════════════════════════════════`);
     });
 }
-/**
- * 从 sessions_spawn 工具结果中提取 ACP child sessionKey。
- * 兼容三种 result 形态：{status, childSessionKey} 直返、JSON 字符串、
- * {content:[{text: "<json>"}], details:{...}} 工具信封。
- * 仅接受 status="accepted" 且 key 形如 agent:<id>:acp:<uuid> 的结果。
- */
-function extractAcceptedAcpChildSessionKey(result) {
-    const pick = (obj) => {
-        if (!obj || typeof obj !== "object")
-            return null;
-        const record = obj;
-        if (record.status !== "accepted")
-            return null;
-        const key = record.childSessionKey;
-        return typeof key === "string" && key.includes(":acp:") ? key : null;
-    };
-    const direct = pick(result);
-    if (direct)
-        return direct;
-    const envelope = result;
-    const fromDetails = pick(envelope?.details);
-    if (fromDetails)
-        return fromDetails;
-    if (Array.isArray(envelope?.content)) {
-        for (const item of envelope.content) {
-            if (typeof item?.text !== "string")
-                continue;
-            try {
-                const fromText = pick(JSON.parse(item.text));
-                if (fromText)
-                    return fromText;
-            }
-            catch {
-                // 非 JSON 文本，忽略
-            }
-        }
-    }
-    if (typeof result === "string") {
-        try {
-            return pick(JSON.parse(result));
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-function registerSubagentHooks(api) {
-    // subagent_spawned: fires after a subagent run is successfully registered.
-    // We increment the expected completion count so that onIdle knows to wait.
-    api.on("subagent_spawned", async (_event, ctx) => {
-        const requesterSessionKey = ctx?.requesterSessionKey;
-        if (!requesterSessionKey)
-            return;
-        const count = markSubagentSpawned(requesterSessionKey);
-        if (count > 0) {
-            logger.log(`[XY-SUBAGENT] spawned, requesterSessionKey=${requesterSessionKey.slice(0, 30)}, expected=${count}`);
-        }
-    });
-    // ACP SPAWN TRACKING: openclaw 的 subagent_spawned hook 仅由内嵌 subagent
-    // 路径（subagent-spawn.ts）发射；acp-spawn.ts（runtime="acp"，如 Claude Code）
-    // 不发射 —— 实测 ACP run 仅在结束时经 run registry 触发 subagent_ended，
-    // 导致等待态从未建立、父 turn onIdle 直接发 final 结束对话。
-    // 因此在 after_tool_call 补记：sessions_spawn 成功且 childSessionKey 为 ACP
-    // 形态时递增等待计数。内嵌 subagent 的 childKey 形如 agent:<id>:subagent:<id>，
-    // 不命中此分支，仍由 subagent_spawned hook 负责，不会重复计数。
-    api.on("after_tool_call", async (event, ctx) => {
-        try {
-            if (event?.toolName !== "sessions_spawn" || event?.error)
-                return;
-            const childKey = extractAcceptedAcpChildSessionKey(event?.result);
-            if (!childKey)
-                return;
-            const sessionKey = ctx?.sessionKey;
-            if (!sessionKey)
-                return;
-            const count = markSubagentSpawned(sessionKey);
-            if (count > 0) {
-                logger.log(`[XY-SUBAGENT] ACP spawned, childSessionKey=${childKey.slice(0, 40)}, expected=${count}`);
-            }
-        }
-        catch (err) {
-            logger.error(`[XY-SUBAGENT] Error tracking ACP spawn:`, err);
-        }
-    });
-    // subagent_ended: fires when a subagent run terminates (complete/error/killed).
-    // This is the PRIMARY delivery tracking mechanism. When all expected
-    // subagents have ended and parent has settled, we finalize the A2A session.
-    api.on("subagent_ended", async (event, ctx) => {
-        try {
-            const requesterSessionKey = ctx?.requesterSessionKey;
-            if (!requesterSessionKey) {
-                logger.log(`[XY-SUBAGENT-END] no requesterSessionKey in ctx`);
-                return;
-            }
-            const transition = markSubagentEnded(requesterSessionKey);
-            logger.log(`[XY-SUBAGENT-END] ended, targetSessionKey=${event?.targetSessionKey?.slice(0, 30)}, outcome=${event?.outcome}, complete=${transition?.isComplete ?? false}, shouldFinalize=${transition?.shouldFinalize ?? false}, transition=${!!transition}`);
-            if (transition?.shouldFinalize) {
-                logger.log(`[XY-SUBAGENT-END] Starting finalization...`);
-                // Grace: announce 投递的 sendText 与 subagent_ended hook 并发到达
-                // （实测 sendText 可能先于 hook 约 1s，也可能略晚于 hook），
-                // 短等让最后一条完成文本先落入 completionTexts 再合并发 final 帧。
-                await new Promise((r) => setTimeout(r, 1500));
-                // 最终交付由对话管理层统一负责（含 config 解析、final 帧、清理）
-                await deliverSubagentFinalResult({
-                    state: transition.state,
-                    reason: "all-subagents-ended-after-parent-settled",
-                });
-                logger.log(`[XY-SUBAGENT-END] Finalized A2A session after all subagents ended`);
-            }
-        }
-        catch (err) {
-            logger.error(`[XY-SUBAGENT-END] Error in subagent_ended hook:`, err);
-        }
-    });
-}
 function registerFullHooks(api) {
-    // SUBAGENT HOOKS: track subagent spawn/end lifecycle for session keep-alive
-    registerSubagentHooks(api);
-    // CRON AGGREGATION: 通过 agent 事件总线感知 cron isolated run 结束。
-    // 注意：agent_end 插件 hook 只在 dispatch-from-config 路径触发，cron
-    // isolated run 不会触发它；embedded run 的 lifecycle 事件才是可靠信号。
-    // phase=end/error 后到达的 sendText 即为 announce 最终结果（放行）。
-    api.agent.events.registerAgentEventSubscription({
-        id: "xy-cron-turn-tracker",
-        description: "Track cron isolated run completion for sendText aggregation",
-        streams: ["lifecycle"],
-        handle: (event) => {
-            try {
-                const phase = event?.data?.phase;
-                // 仅 phase=end 是 run 级终态信号；phase=error 可能是单次模型调用
-                // 失败（后续还有重试/start），不能据此放行 announce。
-                // 真正失败的 run（无 end）由 120s 安全超时兜底 flush 缓冲文本。
-                if (phase !== "end")
-                    return;
-                const sessionKey = event?.sessionKey ?? "";
-                if (sessionKey.startsWith("cron:") || sessionKey.includes(":cron:") || isCronActive()) {
-                    logger.log(`[XY-CRON] Cron run lifecycle end, sessionKey=${sessionKey || "unknown"}`);
-                    notifyCronAgentEnd();
-                }
-            }
-            catch (err) {
-                logger.error(`[XY-CRON] Error in cron lifecycle subscription:`, err);
-            }
-        },
-    });
     // SKILL RETRIEVER HOOK: before_prompt_build hook
     const pluginConfig = api.pluginConfig || {};
     const skillRetrieverConfig = normalizeToolRetrieverConfig({

package/dist/src/bot.js

@@ -242,20 +242,18 @@ export async function handleXYMessage(params) {
                     log.error(`[BOT] Failed to patch session model override:`, patchErr);
                 }
             }
-            // 🔑 发送初始状态更新（仅首条消息，steer 不重复发送）
-            if (!isUpdate) {
-                log.log(`[BOT] Sending initial status update`);
-                void sendStatusUpdate({
-                    config,
-                    sessionId: parsed.sessionId,
-                    taskId: parsed.taskId,
-                    messageId: parsed.messageId,
-                    text: "任务正在处理中，请稍候~",
-                    state: "working",
-                }).catch((err) => {
-                    log.error(`Failed to send initial status update:`, err);
-                });
-            }
+            // 🔑 发送初始状态更新
+            log.log(`[BOT] Sending initial status update`);
+            void sendStatusUpdate({
+                config,
+                sessionId: parsed.sessionId,
+                taskId: parsed.taskId,
+                messageId: parsed.messageId,
+                text: "任务正在处理中，请稍候~",
+                state: "working",
+            }).catch((err) => {
+                log.error(`Failed to send initial status update:`, err);
+            });
         }
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
@@ -281,10 +279,8 @@ export async function handleXYMessage(params) {
             }
         }
         // ── Build message and dispatch via auto-reply pipeline ──────────
-        // OpenClaw's auto-reply pipeline (src/auto-reply/reply/agent-runner.ts)
-        // detects active runs and handles steer injection natively — the channel
-        // does not need its own steer detection or polling logic.
-        // File download
+        // 首条消息和 steer 回退都走此统一 dispatch 路径。
+        // File download — for both first message and steer fallthrough
         let mediaPayload = {};
         if (!skipReg || isUpdate) {
             const fileParts = extractFileParts(parsed.parts);
@@ -305,7 +301,7 @@ export async function handleXYMessage(params) {
         // per-session ReplyOperation lock in admitReplyTurn which would otherwise
         // block the steer message until the first message completes — making steer
         // indistinguishable from a followup.
-        if (isUpdate && !skipReg && route.sessionKey) {
+        if (isUpdate && route.sessionKey) {
             const activeSessionId = resolveActiveEmbeddedRunSessionId(route.sessionKey);
             if (activeSessionId) {
                 log.log(`[BOT-STEER] Direct steer attempt: activeSessionId=${activeSessionId}, textLen=${textForAgent.length}`);
@@ -314,8 +310,10 @@ export async function handleXYMessage(params) {
                 });
                 if (queued) {
                     log.log(`[BOT-STEER] Direct steer succeeded — message injected into active run`);
-                    // Steer message taskId refCount is no longer needed since we skip the dispatcher.
-                    decrementTaskIdRef(parsed.sessionId);
+                    // Steer message taskId stays in the binding so getActiveTaskId()
+                    // resolves to the latest taskId for onPartialReply replies.
+                    // Cleanup happens via the original dispatcher's onIdleComplete →
+                    // decrementTaskIdRef(sessionId) which removes the entire binding.
                     return;
                 }
                 log.log(`[BOT-STEER] Direct steer failed (queued=false), falling through to dispatchReplyFromConfig`);
@@ -327,10 +325,8 @@ export async function handleXYMessage(params) {
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
-        let messageBody = textForAgent;
-        // Add speaker prefix for clarity
         const speaker = parsed.sessionId;
-        messageBody = `${speaker}: ${messageBody}`;
+        const messageBody = `${speaker}: ${textForAgent}`;
         // Format agent envelope (following feishu pattern)
         const body = core.channel.reply.formatAgentEnvelope({
             channel: "xiaoyi-channel",
@@ -430,7 +426,7 @@ export async function handleXYMessage(params) {
         log.log(`[BOT-DISPATCH] withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
-            onSettled: () => {
+            onSettled: async () => {
                 log.log(`[BOT] onSettled, steered=${steerState.steered}`);
                 // 🔑 When steered, skip cleanup — the first message's dispatcher is still running
                 if (steerState.steered) {
@@ -448,9 +444,9 @@ export async function handleXYMessage(params) {
                 // signal init complete to release the global dispatch gate
                 // for the next session.
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
-                    const isSteerDispatch = isUpdate && !skipReg;
+                    const isSteerDispatch = isUpdate;
                     log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=${isSteerDispatch}`);
-                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}, isSteer=${isSteerDispatch}`);
+                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
                             ctx: ctxPayload,
@@ -458,13 +454,7 @@ export async function handleXYMessage(params) {
                             dispatcher,
                             replyOptions,
                         });
-                        // 区分 steer 成功（undefined）和 steer 失败/正常 run（有结果）
-                        if (result === undefined) {
-                            log.log(`[BOT-STEER] dispatchReplyFromConfig returned undefined — steer injected via fast path OK, sessionKey=${route.sessionKey}`);
-                        }
-                        else {
-                            log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, resultType=${typeof result}, isSteer=${isSteerDispatch}, steered=${steerState.steered}`);
-                        }
+                        log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, result=${JSON.stringify(result)}`);
                         return result;
                     }
                     catch (dispatchErr) {
@@ -515,19 +505,21 @@ export async function handleXYMessage(params) {
 function buildXYMediaPayload(mediaList) {
     const first = mediaList[0];
     const mediaPaths = mediaList.map((media) => media.path);
+    const mediaUrls = mediaList.map((media) => media.uri);
     const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
     return {
         MediaPath: first?.path,
         MediaType: first?.mimeType,
+        MediaUrl: first?.uri,
         MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrls: mediaUrls.length > 0 ? mediaUrls : undefined,
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
 // ─────────────────────────────────────────────────────────────
 // Dispatcher updaters (cross-chain taskId bridging)
 // ─────────────────────────────────────────────────────────────
-// Use globalThis to survive module deduplication — provider.ts may load a
-// different copy of bot.ts, so a plain module-level Map would be two objects.
+// Use globalThis to survive module deduplication
 const _g = globalThis;
 if (!_g.__xyDispatcherUpdaters)
     _g.__xyDispatcherUpdaters = new Map();

package/dist/src/channel.js

@@ -1,6 +1,6 @@
 import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./config.js";
 import { xyConfigSchema } from "./config-schema.js";
-import { xyOutbound } from "./dispatch/outbound.js";
+import { xyOutbound } from "./outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
@@ -23,16 +23,11 @@ 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 { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
-import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
 import { invokeTool } from "./tools/invoke.js";
 import { xiaoyiAppendReferenceTool } from "./tools/xiaoyi-append-reference.js";
 const ALL_TOOLS = [
     locationTool,
-    discoverCrossDevicesTool,
-    sendCrossDeviceTaskTool,
     displayA2UICardByPathTool,
     callDeviceTool,
     getNoteToolSchemaTool,
@@ -51,7 +46,6 @@ const ALL_TOOLS = [
     saveSelfEvolutionSkillTool,
     loginTokenTool,
     agentAsSkillTool,
-    checkPluginPrivilegeTool,
     invokeTool,
     xiaoyiAppendReferenceTool,
 ];
@@ -158,7 +152,7 @@ export const xyPlugin = {
     },
     gateway: {
         async startAccount(context) {
-            const { monitorXYProvider } = await import("./dispatch/monitor.js");
+            const { monitorXYProvider } = await import("./monitor.js");
             const { createXyAcpBindingManager } = await import("./acp-session-binding.js");
             const account = resolveXYConfig(context.cfg);
             context.setStatus?.({

package/dist/src/config-schema.d.ts

@@ -49,6 +49,11 @@ export declare const xyConfigSchema: {
             readonly type: "string";
             readonly description: "Default session ID for push notifications (used when no target is specified, e.g., in cron jobs)";
         };
+        readonly terminalFrameDelayMs: {
+            readonly type: "number";
+            readonly description: "Delay in ms before sending terminal frames (completed status + final) so the content artifact clears downstream pipelines first; 0 disables";
+            readonly default: 300;
+        };
     };
     readonly required: readonly ["apiKey", "agentId", "uid", "apiId", "pushId"];
 };

package/dist/src/config-schema.js

@@ -50,6 +50,11 @@ export const xyConfigSchema = {
             type: "string",
             description: "Default session ID for push notifications (used when no target is specified, e.g., in cron jobs)",
         },
+        terminalFrameDelayMs: {
+            type: "number",
+            description: "Delay in ms before sending terminal frames (completed status + final) so the content artifact clears downstream pipelines first; 0 disables",
+            default: 300,
+        },
     },
     required: ["apiKey", "agentId", "uid", "apiId", "pushId"],
 };

package/dist/src/config.js

@@ -27,6 +27,7 @@ export function resolveXYConfig(cfg) {
         fileUploadUrl: xyConfig.fileUploadUrl ?? "http://localhost:8767",
         pushUrl: xyConfig.pushUrl,
         defaultSessionId: xyConfig.defaultSessionId,
+        terminalFrameDelayMs: xyConfig.terminalFrameDelayMs ?? 300,
     };
 }
 /**

package/dist/src/conversation/conversation-manager.js

@@ -261,6 +261,7 @@ export function markSubagentSpawned(sessionKey) {
             completionTexts: [],
             parentSettled: false,
             finalizationClaimed: false,
+            finalDeliveryStarted: false,
         };
         states.push(state);
     }
@@ -367,6 +368,9 @@ export async function deliverSubagentFinalResult(params) {
         log.error(`[SUBAGENT-FINAL] No cached XY config, cannot deliver final result`);
         return;
     }
+    // 关闭捕获窗口：此后到达的 sendText 不再并入 final 文本。
+    // 等待态在发送后立即清除，迟到的 announce 文本回退 push 通道兜底（不丢消息）。
+    state.finalDeliveryStarted = true;
     const finalText = state.completionTexts.length > 0
         ? state.completionTexts.join("\n\n")
         : (params.text || undefined) ?? "子任务已完成";

package/dist/src/conversation/conversation-session.d.ts

@@ -16,6 +16,12 @@ export interface SubagentWaitState {
     completionTexts: string[];
     parentSettled: boolean;
     finalizationClaimed: boolean;
+    /**
+     * final 帧开始交付（deliverSubagentFinalResult 入口）后置位。
+     * 捕获窗口以此为准：grace 期间迟到的 announce 文本仍可并入 final；
+     * 置位后到达的 sendText 不再捕获（等待态随即清除，回退 push 兜底）。
+     */
+    finalDeliveryStarted: boolean;
 }
 export interface SubagentWaitTransition {
     state: SubagentWaitState;

package/dist/src/cron-command.js

@@ -5,7 +5,9 @@
 // independently of any session. The device processes the command and returns
 // results through the normal WebSocket connection, so response listening
 // works the same as for regular tool calls.
-import { pushCommand } from "./conversation/outbound-gateway.js";
+import { randomUUID } from "crypto";
+import { XYPushService } from "./push.js";
+import { getAllPushIds } from "./utils/pushid-manager.js";
 import { logger } from "./utils/logger.js";
 /**
  * Send a tool command through the push channel (for cron-triggered tool calls).
@@ -22,8 +24,28 @@ export async function sendCommandViaPush(params) {
         command.header?.name ??
         "Command";
     logger.log(`[CRON-CMD] Sending command via push, intent=${intentName}`);
+    // 1. 选 pushId：优先用调用方解析出的设备 pushId（多设备路由正确）；
+    //    未提供时回退到 getAllPushIds()[0]（单设备兼容旧行为）。
+    let pushId = config.pushId;
+    if (params.pushId) {
+        pushId = params.pushId;
+    }
+    else {
+        try {
+            const pushIdList = await getAllPushIds();
+            if (pushIdList.length > 0) {
+                pushId = pushIdList[0];
+            }
+        }
+        catch (error) {
+            logger.error("[CRON-CMD] Failed to load pushIds:", error);
+        }
+    }
+    // 2. Build and send push notification with command in directives
+    const pushService = new XYPushService(config);
+    const sessionId = randomUUID();
     try {
-        await pushCommand({ config, command, pushId: params.pushId });
+        await pushService.sendPushWithDirectives(pushId, sessionId, [command]);
         logger.log(`[CRON-CMD] Push sent successfully, intent=${intentName}`);
     }
     catch (error) {

package/dist/src/cspl/sentinel_hook.js

@@ -7,11 +7,11 @@ import { callApi } from './call_api.js';
 import { processText, extractResultText, validateAndTruncateText, parseSecurityResult, handleExecToolInput, handleMessageToolInput, handleOtherToolInput, buildToolOutputPayload, extractInterActionId, extractSessionId } from './utils.js';
 import { ALLOWED_TOOLS, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, MAX_TEXT_LENGTH, STEER_ABORT_MESSAGE } from './constants.js';
 import { getCurrentSessionContext } from '../tools/session-manager.js';
-import { steer } from '../conversation/steer-service.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}`);
+        logger.log(`[SENTINEL HOOK] toolCallId=${event.toolCallId}, before_tool_call_event toolName: ${event.toolName}`);
         // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
         const sessionCtx = getCurrentSessionContext();
         const sessionId = sessionCtx?.sessionId || event.runId || crypto.randomBytes(16).toString('hex');
@@ -46,7 +46,7 @@ export default function register(api) {
             return;
         }
         try {
-            logger.log(`[SENTINEL HOOK] after_tool_call_event toolName: ${event.toolName}`);
+            logger.log(`[SENTINEL HOOK] toolCallId=${event.toolCallId}, after_tool_call_event toolName: ${event.toolName}`);
             // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
             const sessionCtx = getCurrentSessionContext();
             const sessionId = sessionCtx?.sessionId || event.runId || crypto.randomBytes(16).toString('hex');
@@ -81,13 +81,16 @@ export default function register(api) {
             try {
                 const response = await callApi(outputPayload, api, sessionId);
                 const result = parseSecurityResult(response);
-                logger.log(`[SENTINEL HOOK] TOOL_OUTPUT response: status=${result.status}.`);
+                logger.log(`[SENTINEL HOOK] toolCallId=${event.toolCallId}, TOOL_OUTPUT response: status=${result.status}.`);
                 if (result.status === 'REJECT') {
                     logger.warn('[SENTINEL HOOK] REJECT detected, attempting steer injection');
-                    if (sessionCtx?.sessionId) {
-                        // CSPL steer：经对话管理层直接 steer 当前会话；
-                        // 注入失败即失败，仅记录日志，不做兜底（不新建 dispatcher）
-                        await steer(sessionCtx.sessionId, STEER_ABORT_MESSAGE, 'cspl');
+                    if (sessionCtx?.sessionId && sessionCtx?.taskId) {
+                        await tryInjectSteer({
+                            sessionId: sessionCtx.sessionId,
+                            taskId: sessionCtx.taskId,
+                            message: STEER_ABORT_MESSAGE,
+                            source: 'cspl',
+                        });
                     }
                     else {
                         logger.warn(`[SENTINEL HOOK] Cannot inject steer: sessionKey=${ctx.sessionKey}, sessionCtx found=${!!sessionCtx}`);

package/dist/src/cspl/utils.js

@@ -270,10 +270,10 @@ export function buildToolOutputPayload(taskID, sessionID, funcName, content, too
     };
 }
 // 发送新接口请求并处理响应，返回扫描结果（保留block/steer能力）
-async function sendToolInputRequest(payload, api, sessionId) {
+async function sendToolInputRequest(payload, api, sessionId, toolCallId) {
     const response = await callApi(payload, api, sessionId);
     const result = parseSecurityResult(response);
-    logger.log(`[SENTINEL HOOK] TOOL_INPUT response: status=${result.status}`);
+    logger.log(`[SENTINEL HOOK] toolCallId=${toolCallId}, TOOL_INPUT response: status=${result.status}`);
     return result;
 }
 // 处理exec工具的TOOL_INPUT数据采集，返回扫描结果（保留block/steer能力）
@@ -309,7 +309,7 @@ export async function handleExecToolInput(event, api, sessionId, taskId) {
             const toolInputPayload = buildToolInputPayload(taskId, sessionId, 'exec', command, event.toolCallId, interActionID, { file: { type: 'doc', url: obsUrl, hash: fileHash, size: fileSize, body: bodyContent } });
             logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for file: ${path.basename(filePath)}, body length: ${JSON.stringify(toolInputPayload).length}`);
             try {
-                lastResult = await sendToolInputRequest(toolInputPayload, api, sessionId);
+                lastResult = await sendToolInputRequest(toolInputPayload, api, sessionId, event.toolCallId);
                 if (lastResult.status === 'REJECT') {
                     return lastResult;
                 }
@@ -330,7 +330,7 @@ export async function handleExecToolInput(event, api, sessionId, taskId) {
         logger.log('[SENTINEL HOOK] No code files found in command, treating as direct code execution');
         const toolInputPayload = buildToolInputPayload(taskId, sessionId, 'exec', command, event.toolCallId, interActionID);
         logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for direct code execution, body length: ${JSON.stringify(toolInputPayload).length}`);
-        return await sendToolInputRequest(toolInputPayload, api, sessionId);
+        return await sendToolInputRequest(toolInputPayload, api, sessionId, event.toolCallId);
     }
 }
 // 处理message工具的TOOL_INPUT数据采集，返回扫描结果（保留block/steer能力）
@@ -344,7 +344,7 @@ export async function handleMessageToolInput(event, api, sessionId, taskId) {
     const interActionID = extractInterActionId(taskId);
     const toolInputPayload = buildToolInputPayload(taskId, sessionId, 'message', message, event.toolCallId, interActionID);
     logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for message, body length: ${JSON.stringify(toolInputPayload).length}`);
-    return await sendToolInputRequest(toolInputPayload, api, sessionId);
+    return await sendToolInputRequest(toolInputPayload, api, sessionId, event.toolCallId);
 }
 // 计算项目目录的哈希值（遍历所有文件）
 export function calculateProjectHash(sourcePath) {
@@ -456,10 +456,10 @@ export async function handleOtherToolInput(event, api, sessionId, taskId) {
         return null;
     }
     logger.log(`[SENTINEL HOOK] Processing other tool input, toolName: ${event.toolName}`);
-    // 将 params 序列化为 JSON 字符串
-    const paramsJson = JSON.stringify(params);
+    // 将 params 序列化为 JSON 字符串，并限制长度
+    const paramsJson = JSON.stringify(params).substring(0, MAX_TEXT_LENGTH);
     const interActionID = extractInterActionId(taskId);
     const toolInputPayload = buildToolInputPayload(taskId, sessionId, event.toolName, paramsJson, event.toolCallId, interActionID);
     logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for ${event.toolName}, body length: ${JSON.stringify(toolInputPayload).length}`);
-    return await sendToolInputRequest(toolInputPayload, api, sessionId);
+    return await sendToolInputRequest(toolInputPayload, api, sessionId, event.toolCallId);
 }

package/dist/src/dispatch/outbound.js

@@ -136,19 +136,28 @@ export const xyOutbound = {
             // 改用 parentSettled 区分：父 run 存活期间的 sendText 是父自己的 message
             // 工具调用（不捕获、push 照常）；父 settle 后命中 waitState 的 sendText
             // 即为 subagent 完成结果的 announce 投递（捕获 + 吞掉 push）。
+            // 捕获窗口以 finalDeliveryStarted 为准（而非 finalizationClaimed）：
+            // finalizationClaimed 在 markSubagentEnded 时就置位，若 announce 的
+            // sendText 晚于 subagent_ended hook 到达（如长文本被 textChunkLimit
+            // 分片、投递时序竞争），claim 会提前关闭捕获导致内容丢失——配合
+            // push 抑制，丢失是永久的。finalDeliveryStarted 在 grace 结束后、
+            // final 帧发送前才置位，grace 期间迟到的文本仍能并入 final。
             const isFromWaitState = waitState && waitState.parentSettled;
             if (isFromWaitState) {
                 const log = logger.withContext(waitState.sessionId, waitState.taskId);
-                if (!waitState.finalizationClaimed) {
+                if (!waitState.finalDeliveryStarted) {
                     log.log(`[xyOutbound.sendText] Subagent completion text captured, len=${text?.length ?? 0}`);
                     addCompletionText(targetSessionId, targetTaskId, text);
+                    log.log(`[xyOutbound.sendText] Subagent announce — swallowing push (result delivered via A2A final frame)`);
+                    return {
+                        channel: "xiaoyi-channel",
+                        messageId: `subagent-swallowed-${Date.now()}`,
+                        chatId: typeof to === "string" ? to : "",
+                    };
                 }
-                log.log(`[xyOutbound.sendText] Subagent announce — swallowing push (result delivered via A2A final frame)`);
-                return {
-                    channel: "xiaoyi-channel",
-                    messageId: `subagent-swallowed-${Date.now()}`,
-                    chatId: typeof to === "string" ? to : "",
-                };
+                // final 帧已开始交付：不再捕获也不再吞没，fall through 走 push 兜底，
+                // 避免迟到的 announce 文本被静默丢弃。
+                log.log(`[xyOutbound.sendText] Subagent announce arrived after final delivery started — falling back to push`);
             }
         }
         // ── End subagent text capture ───────────────────────────────