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

package/dist/index.d.ts

@@ -1,8 +1,3 @@
-declare const _default: {
-    id: string;
-    name: string;
-    description: string;
-    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
-    register: NonNullable<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition["register"]>;
-} & Pick<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
-export default _default;
+import { definePluginEntry } from "openclaw/plugin-sdk/core";
+declare const pluginEntry: ReturnType<typeof definePluginEntry>;
+export default pluginEntry;

package/dist/index.js

@@ -3,13 +3,14 @@ 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";
 import { registerSelfEvolutionToolResultNudge } from "./src/self-evolution-tool-result-nudge.js";
 import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
 import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
+import { registerCLIHook } from "./src/tools/hmos-cli.js";
 /**
  * Register the cron detection hook.
  *
@@ -54,10 +55,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);
@@ -181,7 +182,7 @@ function registerFullHooks(api) {
     api.on("before_prompt_build", beforePromptBuildHandler);
     registerSelfEvolutionToolResultNudge(api);
 }
-export default definePluginEntry({
+const pluginEntry = definePluginEntry({
     id: "xiaoyi-channel",
     name: "Xiaoyi Channel",
     description: "Xiaoyi channel plugin - Xiaoyi A2A protocol integration",
@@ -208,6 +209,9 @@ export default definePluginEntry({
             registerSentinelHook(api);
             // Cron detection hook: marks toolCallIds from cron sessions
             registerCronDetectionHook(api);
+            // CLI exec hook: intercepts built-in exec for HarmonyOS CLI skill tools
+            registerCLIHook(api);
         }
     },
 });
+export default pluginEntry;

package/dist/src/acp-session-binding.d.ts

@@ -0,0 +1,37 @@
+import { type BindingTargetKind } from "openclaw/plugin-sdk/conversation-runtime";
+type XyBindingTargetKind = "subagent" | "acp";
+type XyAcpBindingRecord = {
+    accountId: string;
+    conversationId: string;
+    parentConversationId?: string;
+    deliveryTo?: string;
+    targetKind: XyBindingTargetKind;
+    targetSessionKey: string;
+    agentId?: string;
+    label?: string;
+    boundBy?: string;
+    boundAt: number;
+    lastActivityAt: number;
+};
+type XyAcpBindingManager = {
+    accountId: string;
+    getByConversationId: (conversationId: string) => XyAcpBindingRecord | undefined;
+    listBySessionKey: (targetSessionKey: string) => XyAcpBindingRecord[];
+    bindConversation: (params: {
+        conversationId: string;
+        parentConversationId?: string;
+        targetKind: BindingTargetKind;
+        targetSessionKey: string;
+        metadata?: Record<string, unknown>;
+    }) => XyAcpBindingRecord | null;
+    touchConversation: (conversationId: string, at?: number) => XyAcpBindingRecord | null;
+    unbindConversation: (conversationId: string) => XyAcpBindingRecord | null;
+    unbindBySessionKey: (targetSessionKey: string) => XyAcpBindingRecord[];
+    stop: () => void;
+};
+export declare function createXyAcpBindingManager(params: {
+    accountId?: string;
+    cfg: any;
+}): XyAcpBindingManager;
+export declare function getXyAcpBindingManager(accountId?: string): XyAcpBindingManager | null;
+export {};

package/dist/src/acp-session-binding.js

@@ -0,0 +1,237 @@
+// ACP Session Binding Adapter for xiaoyi-channel.
+// Follows the feishu thread-bindings.ts pattern.
+//
+// Maps A2A sessionId (stable conversation identifier) to ACP/subagent
+// session keys so that openclaw can bind spawned sessions to the
+// current xiaoyi conversation.
+//
+// Key design: xiaoyi-channel only supports `placement: "current"` —
+// it cannot create child threads (unlike Discord). All spawned sessions
+// are bound to the current A2A conversation identified by sessionId.
+// NOTE: Using `any` for cfg type to avoid version mismatch between
+// local and global openclaw installs (auth.profiles.aws-sdk union).
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel, resolveThreadBindingConversationIdFromBindingId, registerSessionBindingAdapter, unregisterSessionBindingAdapter, } from "openclaw/plugin-sdk/conversation-runtime";
+import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logger } from "./utils/logger.js";
+// ─── Global state (survives module dedup) ─────────────────────
+const XY_ACP_BINDINGS_KEY = Symbol.for("openclaw.xyAcpBindingsState");
+let state;
+function getState() {
+    if (!state) {
+        const globalStore = globalThis;
+        state = globalStore[XY_ACP_BINDINGS_KEY] ?? {
+            managersByAccountId: new Map(),
+            bindingsByAccountConversation: new Map(),
+        };
+        globalStore[XY_ACP_BINDINGS_KEY] = state;
+    }
+    return state;
+}
+function resolveBindingKey(params) {
+    return `${params.accountId}:${params.conversationId}`;
+}
+// ─── Kind conversion ──────────────────────────────────────────
+function toSessionBindingTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "session";
+}
+function toXyTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "acp";
+}
+// ─── Record conversion ────────────────────────────────────────
+function toSessionBindingRecord(record, defaults) {
+    const idleExpiresAt = defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : undefined;
+    const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : undefined;
+    const expiresAt = idleExpiresAt != null && maxAgeExpiresAt != null
+        ? Math.min(idleExpiresAt, maxAgeExpiresAt)
+        : (idleExpiresAt ?? maxAgeExpiresAt);
+    return {
+        bindingId: resolveBindingKey({
+            accountId: record.accountId,
+            conversationId: record.conversationId,
+        }),
+        targetSessionKey: record.targetSessionKey,
+        targetKind: toSessionBindingTargetKind(record.targetKind),
+        conversation: {
+            channel: "xiaoyi-channel",
+            accountId: record.accountId,
+            conversationId: record.conversationId,
+            parentConversationId: record.parentConversationId,
+        },
+        status: "active",
+        boundAt: record.boundAt,
+        expiresAt,
+        metadata: {
+            agentId: record.agentId,
+            label: record.label,
+            boundBy: record.boundBy,
+            deliveryTo: record.deliveryTo,
+            lastActivityAt: record.lastActivityAt,
+            idleTimeoutMs: defaults.idleTimeoutMs,
+            maxAgeMs: defaults.maxAgeMs,
+        },
+    };
+}
+// ─── Manager factory ──────────────────────────────────────────
+export function createXyAcpBindingManager(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const existing = getState().managersByAccountId.get(accountId);
+    if (existing) {
+        return existing;
+    }
+    const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const log = logger.withContext("", "");
+    const manager = {
+        accountId,
+        getByConversationId: (conversationId) => getState().bindingsByAccountConversation.get(resolveBindingKey({ accountId, conversationId })),
+        listBySessionKey: (targetSessionKey) => [...getState().bindingsByAccountConversation.values()].filter((record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey),
+        bindConversation: ({ conversationId, parentConversationId, targetKind, targetSessionKey, metadata, }) => {
+            const normalizedConversationId = conversationId.trim();
+            const normalizedTargetSessionKey = targetSessionKey.trim();
+            if (!normalizedConversationId || !normalizedTargetSessionKey) {
+                return null;
+            }
+            const existingLocal = getState().bindingsByAccountConversation.get(resolveBindingKey({ accountId, conversationId: normalizedConversationId }));
+            const now = Date.now();
+            const record = {
+                accountId,
+                conversationId: normalizedConversationId,
+                parentConversationId: normalizeOptionalString(parentConversationId) ?? existingLocal?.parentConversationId,
+                deliveryTo: typeof metadata?.deliveryTo === "string" && metadata.deliveryTo.trim()
+                    ? metadata.deliveryTo.trim()
+                    : existingLocal?.deliveryTo,
+                targetKind: toXyTargetKind(targetKind),
+                targetSessionKey: normalizedTargetSessionKey,
+                agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim()
+                    ? metadata.agentId.trim()
+                    : (existingLocal?.agentId ?? resolveAgentIdFromSessionKey(normalizedTargetSessionKey)),
+                label: typeof metadata?.label === "string" && metadata.label.trim()
+                    ? metadata.label.trim()
+                    : existingLocal?.label,
+                boundBy: typeof metadata?.boundBy === "string" && metadata.boundBy.trim()
+                    ? metadata.boundBy.trim()
+                    : existingLocal?.boundBy,
+                boundAt: now,
+                lastActivityAt: now,
+            };
+            getState().bindingsByAccountConversation.set(resolveBindingKey({ accountId, conversationId: normalizedConversationId }), record);
+            log.log(`[XY-ACP-BIND] Bound ${targetKind} session ${normalizedTargetSessionKey.slice(0, 30)} to conversation ${normalizedConversationId.slice(0, 12)}`);
+            return record;
+        },
+        touchConversation: (conversationId, at = Date.now()) => {
+            const key = resolveBindingKey({ accountId, conversationId });
+            const existingRecord = getState().bindingsByAccountConversation.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            const updated = { ...existingRecord, lastActivityAt: at };
+            getState().bindingsByAccountConversation.set(key, updated);
+            return updated;
+        },
+        unbindConversation: (conversationId) => {
+            const key = resolveBindingKey({ accountId, conversationId });
+            const existingRecord = getState().bindingsByAccountConversation.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            getState().bindingsByAccountConversation.delete(key);
+            return existingRecord;
+        },
+        unbindBySessionKey: (targetSessionKey) => {
+            const removed = [];
+            for (const record of getState().bindingsByAccountConversation.values()) {
+                if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) {
+                    continue;
+                }
+                getState().bindingsByAccountConversation.delete(resolveBindingKey({ accountId, conversationId: record.conversationId }));
+                removed.push(record);
+            }
+            return removed;
+        },
+        stop: () => {
+            for (const key of getState().bindingsByAccountConversation.keys()) {
+                if (key.startsWith(`${accountId}:`)) {
+                    getState().bindingsByAccountConversation.delete(key);
+                }
+            }
+            getState().managersByAccountId.delete(accountId);
+            unregisterSessionBindingAdapter({
+                channel: "xiaoyi-channel",
+                accountId,
+                adapter: sessionBindingAdapter,
+            });
+            log.log(`[XY-ACP-BIND] Stopped binding manager for account ${accountId}`);
+        },
+    };
+    const sessionBindingAdapter = {
+        channel: "xiaoyi-channel",
+        accountId,
+        capabilities: {
+            placements: ["current"],
+        },
+        bind: async (input) => {
+            if (input.conversation.channel !== "xiaoyi-channel" || input.placement === "child") {
+                return null;
+            }
+            const bound = manager.bindConversation({
+                conversationId: input.conversation.conversationId,
+                parentConversationId: input.conversation.parentConversationId,
+                targetKind: input.targetKind,
+                targetSessionKey: input.targetSessionKey,
+                metadata: input.metadata,
+            });
+            return bound ? toSessionBindingRecord(bound, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        listBySession: (targetSessionKey) => manager
+            .listBySessionKey(targetSessionKey)
+            .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs })),
+        resolveByConversation: (ref) => {
+            if (ref.channel !== "xiaoyi-channel") {
+                return null;
+            }
+            const found = manager.getByConversationId(ref.conversationId);
+            return found ? toSessionBindingRecord(found, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        touch: (bindingId, at) => {
+            const conversationId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId,
+            });
+            if (conversationId) {
+                manager.touchConversation(conversationId, at);
+            }
+        },
+        unbind: async (input) => {
+            if (input.targetSessionKey?.trim()) {
+                return manager
+                    .unbindBySessionKey(input.targetSessionKey.trim())
+                    .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs }));
+            }
+            const conversationId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId: input.bindingId,
+            });
+            if (!conversationId) {
+                return [];
+            }
+            const removed = manager.unbindConversation(conversationId);
+            return removed ? [toSessionBindingRecord(removed, { idleTimeoutMs, maxAgeMs })] : [];
+        },
+    };
+    registerSessionBindingAdapter(sessionBindingAdapter);
+    getState().managersByAccountId.set(accountId, manager);
+    log.log(`[XY-ACP-BIND] Created binding manager for account ${accountId} (idleTimeout=${idleTimeoutMs}ms, maxAge=${maxAgeMs}ms)`);
+    return manager;
+}
+export function getXyAcpBindingManager(accountId) {
+    return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
+}

package/dist/src/bot.js

@@ -1,12 +1,14 @@
+import { resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
 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, 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 { queueAgentHarnessMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
+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";
@@ -113,6 +115,13 @@ export async function handleXYMessage(params) {
         // Steer injections skip taskId registration to avoid overwriting the active taskId
         if (!skipReg) {
             registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId);
+            // 🔑 steer 场景：同步更新活跃 dispatcher 的 fallback taskId/messageId
+            if (isUpdate) {
+                const updater = dispatcherUpdaters.get(parsed.sessionId);
+                if (updater) {
+                    updater(parsed.taskId, parsed.messageId);
+                }
+            }
             // Extract and update push_id if present
             const pushId = extractPushId(parsed.parts);
             if (pushId) {
@@ -139,6 +148,15 @@ export async function handleXYMessage(params) {
         if (deviceType) {
             log.log(`[BOT] Extracted deviceType: ${deviceType}`);
         }
+        // Extract app_ver and sdk_api_version if present
+        const appVer = extractAppVer(parsed.parts);
+        if (appVer) {
+            log.log(`[BOT] Extracted app_ver: ${appVer}`);
+        }
+        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);
         if (modelName) {
@@ -160,19 +178,23 @@ export async function handleXYMessage(params) {
             },
         });
         log.log(`[BOT] Resolved route, sessionKey=${route.sessionKey}`);
-        // Steer injections skip session registration to avoid refCount leaks
+        // Check for ACP runtime binding on this A2A conversation
+        const runtimeRoute = resolveRuntimeConversationBindingRoute({
+            route,
+            channel: "xiaoyi-channel",
+            accountId,
+            conversationId: parsed.sessionId,
+        });
+        route = runtimeRoute.route;
+        if (runtimeRoute.bindingRecord) {
+            log.log(runtimeRoute.boundSessionKey
+                ? `[BOT] routed via bound conversation ${parsed.sessionId} -> ${runtimeRoute.boundSessionKey}`
+                : `[BOT] plugin-bound conversation ${parsed.sessionId}`);
+        }
+        // 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,
-                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.
@@ -343,7 +365,18 @@ export async function handleXYMessage(params) {
         const steerState = { steered: false };
         // 🔑 创建dispatcher
         log.log(`[BOT-DISPATCHER] Creating reply dispatcher`);
-        const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
+        // Cleanup: 必须在 onIdle 内部执行（参见 reply-dispatcher.ts 中 onIdleComplete 的注释）
+        let cleaned = false;
+        const cleanup = () => {
+            if (cleaned)
+                return;
+            cleaned = true;
+            log.log(`[BOT] Cleanup started`);
+            streamingSignals.delete(parsed.sessionId);
+            decrementTaskIdRef(parsed.sessionId);
+            log.log(`[BOT] Cleanup completed`);
+        };
+        const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval, updateFallbackTaskId } = createXYReplyDispatcher({
             cfg,
             runtime,
             sessionId: parsed.sessionId,
@@ -351,7 +384,10 @@ export async function handleXYMessage(params) {
             messageId: parsed.messageId,
             accountId: route.accountId,
             steerState,
+            onIdleComplete: cleanup,
         });
+        // 🔑 注册 dispatcher 的 fallback taskId 更新函数，供 steer 路径调用
+        dispatcherUpdaters.set(parsed.sessionId, updateFallbackTaskId);
         // Steer injections don't need status intervals
         if (!skipReg) {
             startStatusInterval();
@@ -365,6 +401,8 @@ export async function handleXYMessage(params) {
             messageId: parsed.messageId,
             agentId: route.accountId,
             deviceType,
+            appVer: appVer ?? undefined,
+            sdkApiVersion: sdkApiVersion ?? undefined,
             modelName,
             runCrossTaskContext: runCrossTaskContext ?? undefined,
         };
@@ -373,15 +411,14 @@ export async function handleXYMessage(params) {
             dispatcher,
             onSettled: () => {
                 log.log(`[BOT] onSettled, steered=${steerState.steered}`);
-                // 🔑 When steered, skip heavy cleanup — the first message's dispatcher is still running
+                // 🔑 When steered, skip cleanup — the first message's dispatcher is still running
                 if (steerState.steered) {
                     log.log(`[BOT] Steered dispatch settled, skipping cleanup`);
                     return;
                 }
-                streamingSignals.delete(parsed.sessionId);
-                decrementTaskIdRef(parsed.sessionId);
-                unregisterSession(route.sessionKey);
-                log.log(`[BOT] Cleanup completed`);
+                // cleanup 已由 onIdleComplete 在 onIdle 的 finally 中执行。
+                // onSettled 不做任何清理（直接在这里清理会发生 race condition）。
+                dispatcherUpdaters.delete(parsed.sessionId);
             },
             run: () => {
                 // 🔐 Use AsyncLocalStorage to provide session context to tools.
@@ -390,6 +427,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({
@@ -422,7 +460,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;
@@ -430,18 +468,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`);
             }
         }
@@ -476,8 +502,11 @@ if (!_g.__xyStreamingSignals)
     _g.__xyStreamingSignals = new Map();
 if (!_g.__xySteerQueues)
     _g.__xySteerQueues = new Map();
+if (!_g.__xyDispatcherUpdaters)
+    _g.__xyDispatcherUpdaters = new Map();
 const streamingSignals = _g.__xyStreamingSignals;
 const steerQueues = _g.__xySteerQueues;
+const dispatcherUpdaters = _g.__xyDispatcherUpdaters;
 /**
  * 由 provider.ts 在 wrapStreamFn 调用时触发。
  * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
@@ -524,7 +553,7 @@ function enqueueSteer(params) {
     return next;
 }
 async function dispatchSteerWhenReady(params) {
-    const { sessionId, sessionKey, steerText } = params;
+    const { sessionId, steerText } = params;
     const log = logger.withContext(sessionId, params.parsed.taskId);
     // 1. 等待第一条消息开始 streaming
     //    signal 可能尚未创建（第一条消息还在文件下载等耗时操作中），
@@ -550,7 +579,7 @@ async function dispatchSteerWhenReady(params) {
     }
     else {
         // 轮询超时且 hasActiveTask 仍为 true——说明第一条消息可能卡在异常路径，
-        // 没有创建 signal。此时 dispatch 会与第一条消息的模型调用并发冲突，放弃。
+        // 没有创建 signal。此时放弃，避免并发碰撞。
         log.log(`[STEER-QUEUE] Signal never appeared after polling, skip steer to avoid collision`);
         return;
     }
@@ -559,83 +588,22 @@ async function dispatchSteerWhenReady(params) {
         log.log(`[STEER-QUEUE] First message completed, skip steer`);
         return;
     }
-    // 3. 构建 dispatch 上下文并 dispatch /steer
-    const core = getXYRuntime();
-    const speaker = sessionId;
-    // 如果有文件附件，把路径拼到 steer 文本末尾，让模型通过工具读取
+    // 3. 直接注入到活跃的 Pi run 中，不创建独立 dispatcher。
+    //    模型回复通过第一条消息的 dispatcher 的 onPartialReply 流式发出，
+    //    使用 registerTaskId + updateFallbackTaskId 已同步的最新 taskId。
     const mediaPaths = params.mediaPayload?.MediaPaths;
     const fileHint = mediaPaths && mediaPaths.length > 0
         ? `\n【用户上传附件】：${JSON.stringify(mediaPaths)}`
         : "";
-    const steerCommand = `/steer ${steerText}${fileHint}`;
-    const messageBody = `${speaker}: ${steerCommand}`;
-    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(params.cfg);
-    const body = core.channel.reply.formatAgentEnvelope({
-        channel: "xiaoyi-channel",
-        from: speaker,
-        timestamp: new Date(),
-        envelope: envelopeOptions,
-        body: messageBody,
+    const steerMessage = `${steerText}${fileHint}`;
+    log.log(`[STEER-QUEUE] Injecting steer message directly into active run`);
+    const injected = queueAgentHarnessMessage(sessionId, steerMessage, {
+        steeringMode: "all",
     });
-    const ctxPayload = core.channel.reply.finalizeInboundContext({
-        Body: body,
-        RawBody: steerCommand,
-        CommandBody: steerCommand,
-        From: sessionId,
-        To: sessionId,
-        SessionKey: params.route.sessionKey,
-        AccountId: params.route.accountId,
-        ChatType: "direct",
-        GroupSubject: undefined,
-        SenderName: sessionId,
-        SenderId: sessionId,
-        Provider: "xiaoyi-channel",
-        Surface: "xiaoyi-channel",
-        MessageSid: `xiaoyi_${params.parsed.taskId}_${params.deviceType}`,
-        Timestamp: Date.now(),
-        WasMentioned: false,
-        CommandAuthorized: true,
-        OriginatingChannel: "xiaoyi-channel",
-        OriginatingTo: sessionId,
-        ReplyToBody: undefined,
-        ...params.mediaPayload,
-    });
-    const steerState = { steered: true };
-    const { dispatcher, replyOptions } = createXYReplyDispatcher({
-        cfg: params.cfg,
-        runtime: params.runtime,
-        sessionId,
-        taskId: params.parsed.taskId,
-        messageId: params.parsed.messageId,
-        accountId: params.route.accountId,
-        steerState,
-    });
-    const sessionContext = {
-        config: resolveXYConfig(params.cfg),
-        sessionId,
-        taskId: params.parsed.taskId,
-        messageId: params.parsed.messageId,
-        agentId: params.route.accountId,
-        deviceType: params.deviceType,
-    };
-    log.log(`[STEER-QUEUE] Dispatching steer`);
-    await core.channel.reply.withReplyDispatcher({
-        dispatcher,
-        onSettled: () => {
-            log.log(`[STEER-QUEUE] Steer dispatch settled`);
-        },
-        run: () => {
-            return runWithSessionContext(sessionContext, async () => {
-                const result = await core.channel.reply.dispatchReplyFromConfig({
-                    ctx: ctxPayload,
-                    cfg: params.cfg,
-                    dispatcher,
-                    replyOptions,
-                });
-                log.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
-                return result;
-            });
-        },
-    });
-    log.log(`[STEER-QUEUE] Steer dispatch completed`);
+    if (injected) {
+        log.log(`[STEER-QUEUE] Steer message injected successfully`);
+    }
+    else {
+        log.log(`[STEER-QUEUE] Steer injection failed — run may not be accepting messages`);
+    }
 }