evolcore 0.0.35 → 0.0.36

package/dist/core/message/aun-ipc-sender.js

@@ -7,12 +7,26 @@ import { isValidAunDeliveryForChannel } from './outbound.js';
 import { isHClassPath } from '../permission/protected-paths.js';
 import { evaluateOutboundContactAdmission } from './message-admission.js';
 import { normalizeAunMentionEntries, withAunAttention } from '../../aun/msg/mention-schema.js';
-import { buildThreadCheckTrigger, resolveManagedSendArgv } from '../../cli/aun-commands.js';
-import { readTriggerLocalFile, resolveTriggerLocalPath } from '../../trigger/local-files.js';
+import { resolveManagedSendArgv } from '../../cli/aun-commands.js';
+import { readTriggerLocalFile, resolveAttachmentLocalPath } from '../../trigger/local-files.js';
+import { TriggerDefinitionManager } from '../../trigger/manager.js';
 import { sameGroupAid } from '../../aun/group/identity.js';
 import { resolveThreadRouteTarget } from '../thread/thread-route.js';
+import { isTopicThreadId, parseMainTopicId, safeFormatMainTopicId, sessionLocalTopicId } from '../thread/topic-id.js';
 import { ThreadService } from '../thread/thread-service.js';
-export function createAunHandoffSender(sessionManager, channelInstances) {
+import { getAunRequestRegistry, requestTtlSeconds } from './aun-request-registry.js';
+/** payload.debug 只是诊断字段：取不到时照常发送，不带 debug。 */
+async function resolveOutboundDebug(resolver, sessionId) {
+    if (!resolver || !sessionId)
+        return undefined;
+    try {
+        return await resolver(sessionId);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createAunHandoffSender(sessionManager, channelInstances, getOutboundDebug) {
     return async (handoff) => {
         const targetSession = await sessionManager.getSessionById(handoff.target_session_id);
         if (!targetSession)
@@ -28,7 +42,8 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
         const log = {
             content: classified.content,
             sessionId: targetSession.id,
-            threadId: targetSession.threadId || '',
+            // 消息日志用本端身份（含主话题规范 id），不上线。
+            threadId: sessionLocalTopicId(targetSession) ?? '',
             msgType: classified.msgType,
             payloadType: classified.payloadType,
             payloadSummary: classified.payloadSummary,
@@ -39,6 +54,8 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
         if (!isValidAunDeliveryForChannel(delivery, targetSession.channelId)) {
             return { ok: false, error: 'handoff is missing a valid immutable AUN delivery route' };
         }
+        // debug 标识写这条消息的会话（发起方），与回复路径一致。
+        const debug = await resolveOutboundDebug(getOutboundDebug, handoff.origin_session_id);
         const result = delivery.chatType === 'group'
             ? typeof channel.sendDaemonGroupMsg === 'function'
                 ? await channel.sendDaemonGroupMsg({
@@ -46,6 +63,7 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
                     payload: { ...handoff.request.payload, [AUN_HANDOFF_MARKER_FIELD]: handoff.handoff_id },
                     encrypt: handoff.request.encrypt,
                     causation: handoff.causation,
+                    debug,
                     log,
                 })
                 : { ok: false, error: 'AUN channel does not support daemon group sends' }
@@ -55,6 +73,7 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
                     payload: handoff.request.payload,
                     encrypt: handoff.request.encrypt,
                     causation: handoff.causation,
+                    debug,
                     log,
                 })
                 : { ok: false, error: 'AUN channel does not support daemon private sends' };
@@ -64,70 +83,94 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
 async function applyManagedCrossThreadSendEffects(input) {
     const originSessionId = input.runtime?.sessionId;
     if (!originSessionId)
-        return undefined;
-    const originThreadId = input.runtime?.threadId || 'main';
+        return { triggerError: 'origin session context unavailable' };
     const originPeer = input.runtime?.channelId || input.targetChannelId;
-    const originChatType = input.runtime?.chatType === 'group' ? 'group' : 'private';
-    const originChannelKey = input.runtime?.channelKey;
-    const originChannelId = input.runtime?.channelId;
-    const originPeerId = input.runtime?.peerId || (originChatType === 'private' ? originChannelId : undefined);
-    const origin = originChannelKey && originChannelId && originPeerId
-        ? {
-            channelKey: originChannelKey,
-            channelType: input.runtime?.channel || 'aun',
-            channelId: originChannelId,
-            session: input.runtime?.threadId ? 'thread' : 'main',
-            ...(input.runtime?.threadId ? { threadId: input.runtime.threadId } : {}),
-            peerId: originPeerId,
-            delivery: originChatType === 'group'
-                ? { chatType: 'group', groupId: originChannelId }
-                : { chatType: 'private' },
-        }
-        : undefined;
+    // 来源话题 id：话题用原 id；主话题用"本端+对端"拼出的规范 id（展示与持久化用）。
+    const originThreadId = isTopicThreadId(input.runtime?.threadId)
+        ? input.runtime.threadId
+        : (safeFormatMainTopicId(input.selfAid, originPeer) ?? '');
+    // origin 指向复查目标对端（A），而非触发本次发送的会话对端（C）。
+    // authorizeTriggerExecution 根据 origin 对端的角色决定 trigger 能否执行；
+    // B 周期性地向 A 发消息，应检查 A 对 B 的角色，而不是 C 对 B 的角色。
+    const targetChatType = input.feedbackChatType ?? 'private';
+    const origin = {
+        channelKey: formatChannelKey({ type: 'aun', selfAID: input.selfAid, name: 'main' }),
+        channelType: 'aun',
+        channelId: input.targetChannelId,
+        session: isTopicThreadId(input.targetThreadId) ? 'thread' : 'main',
+        ...(isTopicThreadId(input.targetThreadId) ? { threadId: input.targetThreadId } : {}),
+        peerId: input.targetChannelId,
+        delivery: targetChatType === 'group'
+            ? { chatType: 'group', groupId: input.targetChannelId }
+            : { chatType: 'private' },
+    };
     const triggerSeed = `${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
     const triggerId = `trig_${triggerSeed}`;
-    const triggerName = `check-${input.targetThreadId}-from-${originThreadId}-${triggerSeed.split('_')[1]}`;
-    const prompt = [
-        `【Trigger 复查】话题 ${input.targetThreadId}（对端 ${input.targetChannelId}）`,
-        `这是周期复查：每 ${input.checkEveryLabel} 唤醒一次，直到你显式结束它。`,
-        '',
-        input.triggerPromptExtra
-            || `请检查该话题的最新进度，根据情况：继续等待、调整周期（ec trigger update ${triggerId} --every <时长>）或结束复查（ec trigger cancel ${triggerId}）。`,
-        '',
-        '参考命令：',
-        `  ec thread history ${input.targetChannelId}/${input.targetThreadId} --limit 10`,
-        `  ec thread history ${originPeer}/${originThreadId} --after ${Date.now()}`,
-        `  ec trigger cancel ${triggerId}`,
-        `  ec trigger update ${triggerId} --every <时长>`,
-        `Trigger id：${triggerId}`,
-        `Trigger 名称：${triggerName}`,
-    ].join('\n');
+    const triggerName = `check-${targetTopicLabel(input.targetThreadId)}-from-${targetTopicLabel(originThreadId)}-${triggerSeed.split('_')[1]}`;
+    // 话题名：从索引取，取不到时降级。
+    const originEntry = isTopicThreadId(originThreadId)
+        ? ThreadService.findThreadById(input.selfAid, originThreadId)
+        : ThreadService.findMainSessionEntry(input.selfAid, originPeer);
+    const targetEntry = isTopicThreadId(input.targetThreadId)
+        ? ThreadService.findThreadById(input.selfAid, input.targetThreadId)
+        : ThreadService.findMainSessionEntry(input.selfAid, input.targetChannelId);
+    const originThreadName = originEntry?.name || (originThreadId || originPeer);
+    const originPeerName = originEntry?.peerName || originPeer;
+    const targetThreadName = targetEntry?.name || input.targetThreadId;
+    const targetPeerName = targetEntry?.peerName || input.targetChannelId;
+    const { buildCrossThreadReviewPrompt } = await import('../../cli/aun-commands.js');
+    const prompt = buildCrossThreadReviewPrompt({
+        triggerId,
+        originThreadId,
+        originThreadName,
+        originPeerName,
+        targetThreadName,
+        targetPeerName,
+        checkEvery: input.checkEveryLabel,
+        firstSentAt: input.timestamp,
+        originalText: input.contentSummary,
+        extra: input.triggerPromptExtra,
+    });
     let createdTriggerId;
+    let triggerError;
     try {
-        if (!origin)
-            throw new Error('managed task runtime context is missing a trusted Trigger origin');
         const scheduler = input.triggerSchedulers.get(input.selfAid);
         if (!scheduler)
             throw new Error(`trigger scheduler not found for agent: ${input.selfAid}`);
-        const definition = buildThreadCheckTrigger({
-            agentAid: input.selfAid,
-            id: triggerId,
-            name: triggerName,
-            prompt,
-            everyMs: input.durationMs,
-            checkEvery: input.checkEveryLabel,
-            channelKey: formatChannelKey({ type: 'aun', selfAID: input.selfAid, name: 'main' }),
-            targetChannelId: input.targetChannelId,
-            targetThreadId: input.targetThreadId,
-            originThreadId,
-            originPeer,
-            origin,
-            feedbackChatType: input.feedbackChatType,
-        });
+        const { buildThreadCheckTrigger } = await import('../../cli/aun-commands.js');
+        // 触发本次发送的会话对端（C）：originPeer 已按 chatType 取对端 AID（私聊 peerId、群聊群 AID）。
+        // 即使 origin 已改指向 A，C 也需要保留操作权（cancel/delete/list），
+        // 所以显式写入 operatorPeers = [C, A]。
+        const operatorPeers = [...new Set([originPeer, input.targetChannelId].filter((p) => !!p))];
+        const definition = {
+            ...buildThreadCheckTrigger({
+                agentAid: input.selfAid,
+                id: triggerId,
+                name: triggerName,
+                prompt,
+                everyMs: input.durationMs,
+                checkEvery: input.checkEveryLabel,
+                channelKey: formatChannelKey({ type: 'aun', selfAID: input.selfAid, name: 'main' }),
+                targetChannelId: input.targetChannelId,
+                targetThreadId: input.targetThreadId,
+                originThreadId,
+                originPeer,
+                origin,
+                feedbackChatType: input.feedbackChatType,
+                originalText: input.contentSummary,
+                firstSentAt: input.timestamp,
+                originThreadName,
+                targetThreadName,
+            }),
+            operatorPeers,
+        };
         createdTriggerId = scheduler.create(definition, [], { enable: true }).id;
     }
     catch (error) {
-        console.warn(`⚠ Trigger 创建失败: ${error instanceof Error ? error.message : String(error)}（inbox 仍会写入）`);
+        // 失败原因随发送回执返回给调用方：只打 daemon 日志时，CLI 照样显示"已投递"，
+        // 复查静默缺失无人察觉（2026-10-20 firstSentAt 类型错误即如此）。
+        triggerError = error instanceof Error ? error.message : String(error);
+        console.warn(`⚠ Trigger 创建失败: ${triggerError}（inbox 仍会写入）`);
     }
     try {
         ThreadService.appendInbox(input.selfAid, {
@@ -144,9 +187,58 @@ async function applyManagedCrossThreadSendEffects(input) {
     catch (error) {
         console.warn(`⚠ 话题 inbox 写入失败: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return createdTriggerId;
+    return { triggerId: createdTriggerId, triggerError };
+}
+/**
+ * Trigger 名称里的话题片段。
+ *
+ * 名称只用于人读与日志，不参与定位；身份在 labels 的 originThreadId /
+ * targetThreadId 里。主话题 id 含两个完整 AID 与冒号，塞进名称又长又难读，
+ * 统一缩成 `main`。
+ */
+function targetTopicLabel(topicId) {
+    if (!topicId)
+        return 'unknown';
+    const parsed = parseMainTopicId(topicId);
+    if (!parsed)
+        return topicId;
+    return 'main';
 }
-export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, triggerSchedulers, }) {
+export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, triggerSchedulers, sessionManager, }) {
+    ipcServer.setAunRequestGetExecutor(async (params) => {
+        if (!params.sessionId || !params.delegationToken) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Request queries require an active delegated session' };
+        }
+        const authorization = agentDelegationRegistry.validateForContext(params.delegationToken, params.sessionId, params.delegationCommandHash);
+        if (!authorization.ok)
+            return { ok: false, code: authorization.code, error: authorization.reason };
+        const runtime = responseEngine.getTaskRuntimeContext(params.sessionId);
+        if (!runtime || runtime.selfAid !== params.aid || authorization.grant.selfAid !== params.aid
+            || runtime.peerKey !== authorization.grant.peerKey) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Request status is limited to the delegated session' };
+        }
+        const request = getAunRequestRegistry().get(params.aid, params.requestId);
+        if (!request?.origin || request.origin.sessionId !== params.sessionId
+            || request.origin.peerKey !== authorization.grant.peerKey || request.origin.threadId !== runtime.threadId) {
+            return { ok: false, code: 'REQUEST_NOT_FOUND', error: 'Request is not available in this session' };
+        }
+        const targetRoute = request.origin.targetThreadId
+            ? resolveThreadRouteTarget(params.aid, request.origin.targetThreadId, 'msg', request.targetAid)
+            : undefined;
+        if (request.origin.targetThreadId && !targetRoute) {
+            return { ok: false, code: 'REQUEST_NOT_FOUND', error: 'Request target topic is no longer available' };
+        }
+        const permitted = await authorizeDelegatedAunMsgSend(agentDelegationRegistry, {
+            aid: params.aid, to: request.targetAid, scope: 'msg', action: 'history',
+            sessionId: params.sessionId, messageId: runtime.messageId,
+            delegationToken: params.delegationToken, delegationCommandHash: params.delegationCommandHash,
+            threadRouted: !!targetRoute,
+        });
+        if (!permitted.ok)
+            return { ok: false, code: permitted.code, error: permitted.reason };
+        return request ? { ok: true, request: request }
+            : { ok: false, code: 'REQUEST_NOT_FOUND', error: `request not found: ${params.requestId}` };
+    });
     const sender = async (params) => {
         let textFile;
         try {
@@ -162,18 +254,56 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
         catch (error) {
             return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
         }
-        const runtime = params.originSessionId ? responseEngine.getTaskRuntimeContext(params.originSessionId) : undefined;
+        // 活跃任务走内存上下文；调试会话（--as-session）和已结束的会话没有内存记录，
+        // 这时从会话本身重建，否则跨话题复查会静默不创建（getTaskRuntimeContext 返回 null）。
+        let runtime = params.originSessionId ? responseEngine.getTaskRuntimeContext(params.originSessionId) : undefined;
+        if (!runtime && params.originSessionId && sessionManager) {
+            try {
+                const session = await sessionManager.getSessionById(params.originSessionId);
+                if (session) {
+                    const { buildDebugTaskContext } = await import('../auth/debug-context.js');
+                    const { ensureSessionRuntimeDir } = await import('../../cli/task-context.js');
+                    runtime = buildDebugTaskContext({
+                        session,
+                        getTrigger: (agentAid, triggerId) => new TriggerDefinitionManager(agentAid).get(triggerId),
+                        sessionRuntimeDir: ensureSessionRuntimeDir(session.id),
+                    });
+                }
+            }
+            catch {
+                // 重建失败时保持 undefined：不影响消息发送，只是不创建复查
+            }
+        }
         const runtimeCausation = runtime?.causation;
-        const threadRoute = params.thread
-            ? resolveThreadRouteTarget(params.aid, params.thread, params.scope, params.to)
+        // 话题引用解析：`threadRef` 是调用方写的原值（可能是主话题 id），
+        // `threadRoute` 非空即"这是跨话题发送"——与话题 id 是否为空无关。
+        const threadRef = params.thread;
+        const threadRoute = threadRef
+            ? resolveThreadRouteTarget(params.aid, threadRef, params.scope, params.to)
             : undefined;
-        if (params.thread && !threadRoute) {
-            return { ok: false, code: 'TOPIC_NOT_FOUND', error: `话题不存在或不属于目标对端: ${params.thread}` };
+        if (threadRef && !threadRoute) {
+            return { ok: false, code: 'TOPIC_NOT_FOUND', error: `话题不存在或不属于目标对端: ${threadRef}` };
         }
+        const threadRouted = !!threadRoute;
+        // 规范目标 id：话题保留原 id；主话题用双方拼出的规范形态（用于 Trigger 标签与通知）。
+        const targetTopicId = threadRoute
+            ? (isTopicThreadId(threadRef)
+                ? threadRef
+                : (safeFormatMainTopicId(params.aid, threadRoute.peer) ?? threadRef))
+            : undefined;
         if (params.argv !== undefined && !params.delegationCommandHash) {
-            return { ok: false, code: 'INVALID_DELEGATION', error: 'Managed AUN sends require an approved command hash' };
+            return {
+                ok: false,
+                code: 'INVALID_DELEGATION',
+                detail_code: 'APPROVED_COMMAND_UNAVAILABLE',
+                error: 'Managed AUN sends require an approved command hash',
+                retryable: false,
+                sent: false,
+            };
         }
-        const delegation = authorizeDelegatedAunMsgSend(agentDelegationRegistry, {
+        const isSystemEvent = params.trustedSystemEvent === true
+            && params.payload?.type === 'event' && params.payload.event === 'topic.renamed';
+        const delegation = await authorizeDelegatedAunMsgSend(agentDelegationRegistry, {
             delegationToken: params.delegationToken,
             delegationCommandHash: params.delegationCommandHash,
             sessionId: params.originSessionId,
@@ -183,13 +313,23 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
             scope: params.scope,
             action: params.file ? 'file' : 'send',
             threadRouted: !!threadRoute,
+            isSystemEvent,
         });
         if (!delegation.ok) {
-            return { ok: false, error: delegation.reason, code: delegation.code };
+            return {
+                ok: false,
+                error: delegation.reason,
+                code: delegation.code,
+                ...(delegation.detailCode ? { detail_code: delegation.detailCode } : {}),
+                ...(delegation.retryable === false ? { retryable: false } : {}),
+                ...(delegation.sent === false ? { sent: false } : {}),
+            };
         }
         try {
-            const fileScope = runtime?.projectPath ? { selfAid: delegation.grant.selfAid, projectPath: runtime.projectPath,
-                sessionRuntimeDir: delegation.grant.sessionRuntimeDir, cwd: runtime.projectPath } : undefined;
+            const fileScope = runtime?.projectPath && delegation.grant
+                ? { selfAid: delegation.grant.selfAid, projectPath: runtime.projectPath,
+                    sessionRuntimeDir: delegation.grant.sessionRuntimeDir, cwd: runtime.projectPath }
+                : undefined;
             if ((textFile || params.file) && !fileScope)
                 throw new Error('Current task project context is unavailable');
             if (textFile) {
@@ -198,14 +338,15 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                     throw new Error('Message file must contain nonempty UTF-8 text');
                 params.payload = { type: 'text', text };
             }
-            if (params.file)
-                params.file = { ...params.file, filePath: resolveTriggerLocalPath(params.file.filePath, fileScope) };
-            if (params.payload)
+            if (params.file) {
+                params.file = { ...params.file, filePath: resolveAttachmentLocalPath(params.file.filePath, fileScope) };
+            }
+            if (params.payload && params.rawPayload !== true)
                 params.payload = withAunAttention(params.payload);
             const currentRelation = runtime?.channel === 'aun' && runtime.selfAid === params.aid
                 && runtime.chatType === (params.scope === 'group' ? 'group' : 'private')
                 && !!runtime.channelId && (params.scope === 'group' ? sameGroupAid(runtime.channelId, params.to) : runtime.channelId === params.to);
-            params.thread = typeof params.payload?.thread_id === 'string' && params.payload.thread_id.trim()
+            params.thread = params.rawPayload === true ? params.thread : typeof params.payload?.thread_id === 'string' && params.payload.thread_id.trim()
                 ? params.payload.thread_id.trim() : params.thread ?? (currentRelation ? runtime?.threadId : undefined);
         }
         catch (error) {
@@ -286,7 +427,7 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
             };
         }
         try {
-            if (Object.prototype.hasOwnProperty.call(payload, 'mentions')) {
+            if (params.rawPayload !== true && Object.prototype.hasOwnProperty.call(payload, 'mentions')) {
                 payload = { ...payload, mentions: normalizeAunMentionEntries(payload.mentions) };
             }
             if (params.scope === 'group' && params.mentions !== undefined) {
@@ -303,11 +444,43 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                 code: error?.code ?? 'INVALID_MENTION_SCHEMA',
             };
         }
-        if (params.thread && typeof payload.thread_id !== 'string') {
+        if (params.rawPayload !== true && isTopicThreadId(params.thread) && typeof payload.thread_id !== 'string') {
             payload = { ...payload, thread_id: params.thread };
         }
+        let preparedRequest;
+        let requestTtl;
+        if (params.scope === 'msg' && params.returnPolicy === 'required') {
+            try {
+                requestTtl = requestTtlSeconds(params.timeoutMs);
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    code: 'INVALID_REQUEST_TTL',
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+            try {
+                preparedRequest = getAunRequestRegistry().prepare({
+                    selfAid: params.aid,
+                    targetAid: params.to,
+                    payload,
+                    timeoutMs: params.timeoutMs ?? 60_000,
+                    ...(runtime && delegation.grant ? { origin: {
+                            sessionId: params.originSessionId, peerKey: delegation.grant.peerKey,
+                            threadId: runtime.threadId, targetThreadId: threadRoute ? params.thread : undefined,
+                        } } : {}),
+                });
+            }
+            catch (error) {
+                return { ok: false, code: error?.code ?? 'REQUEST_REGISTRATION_FAILED',
+                    error: error instanceof Error ? error.message : String(error) };
+            }
+            payload = preparedRequest.payload;
+            getAunRequestRegistry().markSending(params.aid, preparedRequest.requestId);
+        }
         let targetSessionId;
-        if (params.originSessionId && params.originMessageId) {
+        if (params.originSessionId && params.originMessageId && params.returnPolicy !== 'required') {
             try {
                 const created = await handoffRuntime.createOutbound({
                     selfAid: params.aid,
@@ -320,6 +493,9 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                     targetChatType: params.scope === 'group' ? 'group' : 'private',
                     explicitReturnPolicy: params.returnPolicy,
                     handoffContext: params.handoffContext,
+                    // 跨话题发送的目标侧上下文由话题链（thread-inbox）负责注入；
+                    // handoff 只管投递，回复时不再拼"本地发言"段。
+                    threadRouted: threadRouted && params.checkEveryMs !== undefined,
                     originAuthorization: {
                         actorId: delegation.grant.actorId,
                         channelKey: delegation.grant.channel,
@@ -339,24 +515,28 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                         handoff_id: created.handoff.handoff_id,
                         target_session_id: created.targetSession.id,
                     };
-                    if (params.thread && params.checkEveryMs !== undefined && response.message_id && threadRoute) {
-                        const triggerId = await applyManagedCrossThreadSendEffects({
+                    // 排队未投递（无 message_id）时也要写 inbox + 建复查：handoff 已不再
+                    // 承载目标侧上下文，跳过这里就会丢上下文。
+                    if (threadRouted && params.checkEveryMs !== undefined && threadRoute) {
+                        const effects = await applyManagedCrossThreadSendEffects({
                             triggerSchedulers,
                             runtime,
                             selfAid: params.aid,
-                            targetThreadId: params.thread,
+                            targetThreadId: targetTopicId ?? params.thread ?? "",
                             targetSessionId: threadRoute.sessionId,
                             targetChannelId: params.to,
                             feedbackChatType: params.scope === 'group' ? 'group' : 'private',
-                            messageId: response.message_id,
+                            messageId: response.message_id ?? created.handoff.handoff_id,
                             contentSummary: params.log?.content ?? classifyAunPayloadForLog(payload).content,
                             timestamp: response.timestamp ?? Date.now(),
                             durationMs: params.checkEveryMs,
                             checkEveryLabel: params.checkEvery ?? '5m',
                             triggerPromptExtra: params.triggerPromptExtra,
                         });
-                        if (triggerId)
-                            response.trigger_id = triggerId;
+                        if (effects.triggerId)
+                            response.trigger_id = effects.triggerId;
+                        if (effects.triggerError)
+                            response.trigger_error = effects.triggerError;
                     }
                     return response;
                 }
@@ -376,6 +556,7 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                 };
             }
         }
+        const debug = await resolveOutboundDebug(sessionId => responseEngine.getOutboundDebug(sessionId), params.originSessionId);
         if (params.scope === 'group') {
             if (typeof ch.sendDaemonGroupMsg !== 'function') {
                 return { ok: false, error: 'AUN channel does not support daemon group sends', code: 'AUN_GROUP_UNSUPPORTED' };
@@ -385,10 +566,11 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                 payload,
                 mentions: params.mentions,
                 encrypt,
+                debug,
                 log: params.log ? { ...params.log, sessionId: targetSessionId ?? params.log.sessionId } : undefined,
             });
             if (params.thread && params.checkEveryMs !== undefined && sent.ok && sent.message_id && threadRoute) {
-                const triggerId = await applyManagedCrossThreadSendEffects({
+                const effects = await applyManagedCrossThreadSendEffects({
                     triggerSchedulers,
                     runtime,
                     selfAid: params.aid,
@@ -403,8 +585,10 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                     checkEveryLabel: params.checkEvery ?? '5m',
                     triggerPromptExtra: params.triggerPromptExtra,
                 });
-                if (triggerId)
-                    sent.trigger_id = triggerId;
+                if (effects.triggerId)
+                    sent.trigger_id = effects.triggerId;
+                if (effects.triggerError)
+                    sent.trigger_error = effects.triggerError;
             }
             return sent;
         }
@@ -414,12 +598,34 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
         const sent = await ch.sendDaemonMsg({
             to: params.to,
             payload,
+            rawPayload: params.rawPayload,
+            ttl: requestTtl,
             encrypt,
             causation: runtimeCausation,
+            debug,
             log: params.log ? { ...params.log, sessionId: targetSessionId ?? params.log.sessionId } : undefined,
         });
+        if (preparedRequest) {
+            if (!sent.ok || !sent.message_id) {
+                const transportError = sent.error || 'transport send failed';
+                const request = getAunRequestRegistry().markFailed(params.aid, preparedRequest.requestId, transportError);
+                if (request?.state === 'completed') {
+                    return { ok: true, request_id: preparedRequest.requestId, request_state: request.state,
+                        response: request.responsePayload, transport_error: transportError, retryable: false, sent: true };
+                }
+                return { ...sent, ok: false, request_id: preparedRequest.requestId, request_state: request?.state ?? 'failed' };
+            }
+            getAunRequestRegistry().markTransportAccepted(params.aid, preparedRequest.requestId, sent.message_id, sent.status);
+            const completed = await getAunRequestRegistry().wait(params.aid, preparedRequest.requestId, params.timeoutMs ?? 60_000);
+            return {
+                ...sent,
+                request_id: preparedRequest.requestId,
+                request_state: completed?.state ?? 'unknown',
+                ...(completed?.responsePayload ? { response: completed.responsePayload } : {}),
+            };
+        }
         if (params.thread && params.checkEveryMs !== undefined && sent.ok && sent.message_id && threadRoute) {
-            const triggerId = await applyManagedCrossThreadSendEffects({
+            const effects = await applyManagedCrossThreadSendEffects({
                 triggerSchedulers,
                 runtime,
                 selfAid: params.aid,
@@ -434,8 +640,10 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                 checkEveryLabel: params.checkEvery ?? '5m',
                 triggerPromptExtra: params.triggerPromptExtra,
             });
-            if (triggerId)
-                sent.trigger_id = triggerId;
+            if (effects.triggerId)
+                sent.trigger_id = effects.triggerId;
+            if (effects.triggerError)
+                sent.trigger_error = effects.triggerError;
         }
         return sent;
     };