evolcore 0.0.26 → 0.0.28

package/dist/core/message/message-bridge.js

@@ -1,9 +1,13 @@
+import { loadAgent } from '../../config-store.js';
+import { initializationBlocksTasks } from '../../cli/agent-create.js';
 import { createHash, randomBytes } from 'crypto';
+import { agentStorageMenuService, isAgentStorageMenuRequest } from '../command/agent-storage-menu.js';
 import { logger } from '../../utils/logger.js';
 import { StreamDebouncer } from './stream-debouncer.js';
 import { appendMessageLog, appendMessageLogStrict, buildInboundEntry, isTransientProtocolMessage } from './message-log.js';
 import { buildEnvelope, isInteractionSendAccepted, sendInteractionPayload } from './message-utils.js';
 import { chatDirPath } from '../session/session-fs-store.js';
+import { readTopicLable } from '../session/session-mapper.js';
 import { formatChannelKey, tryParseChannelKey } from '../channel-loader.js';
 import { agentDir, resolvePaths } from '../../paths.js';
 import { listStaticAgentAdmins, listStaticAgentOwners, resolvePeerRoleDetail, } from '../../config/peer-role-resolver.js';
@@ -27,7 +31,9 @@ import { renderActionAsText } from '../interaction-router.js';
 import { planApprovalRoute } from '../permission/approval-gateway.js';
 import { guardGroupSlashCommand, parseFullAccessCommand } from '../command/slash-gate.js';
 import { isFullAccessEnabled } from '../../config-store.js';
+import { createAgentPolicyAuthorization } from '../role/runtime-policy.js';
 import { auditFullAccessEvent } from '../auth/authorization-audit.js';
+import { DIAGNOSTIC_AGENT_AID, DiagnosticSessionRouter, parseDiagnosticEvent, isDiagnosticSessionActive } from '../command/diag-service.js';
 import { consumeAdmissionReplyBudget, clearAdmissionReplyBudgets, evaluateInboundAdmissionPreflight, evaluateOrdinaryInboundAdmission, } from './message-admission.js';
 const CONTACT_REJECTION_NOTICE = '[rejection] Not accepting messages from you.';
 const REJECTABLE_PEER_TYPES = new Set(['ai', 'bot', 'agent', 'service']);
@@ -110,9 +116,11 @@ export class MessageBridge {
     menuTokenStore = new MenuTokenStore();
     handoffRuntime;
     sessionRenewService;
+    diagnosticRouter;
     aidStatsCollector;
     contactBindRuntimeChecker;
     interactionRouter;
+    groupInviteReviewService;
     constructor(defaultProjectPath, sessionManager, processor, messageQueue, cmdHandler, eventBus, defaultDebounce, processOwnersProvider) {
         this.defaultProjectPath = defaultProjectPath;
         this.sessionManager = sessionManager;
@@ -123,6 +131,13 @@ export class MessageBridge {
         this.processOwnersProvider = processOwnersProvider;
         this.defaultDebounce = defaultDebounce ?? 0;
         this.sessionRenewService = new SessionRenewService(sessionManager, processor, { eventBus });
+        this.diagnosticRouter = new DiagnosticSessionRouter(sessionManager, async (sessionId) => {
+            // Revoke in the router first, then clear pending work before awaiting the
+            // runner interruption. Delayed debounce and recovery are fenced below.
+            this.messageQueue.clearBySession(sessionId);
+            this.messageQueue.markActiveTerminal(sessionId, 'stop');
+            await this.processor.interruptSession(sessionId, 'stop');
+        });
     }
     /** Inject EvolAgentRegistry so owner lookups/writes route to agent.json for agent-owned channels. */
     setAgentRegistry(registry) {
@@ -144,6 +159,12 @@ export class MessageBridge {
     setInteractionRouter(router) {
         this.interactionRouter = router;
     }
+    setGroupInviteReviewService(service) {
+        this.groupInviteReviewService = service;
+    }
+    registerGroupInviteReviewChannel(binding) {
+        this.groupInviteReviewService?.attach(binding);
+    }
     /**
      * AUN supplies an authenticated sender AID, while the IM-side code proves
      * possession of the external account. This command only creates that
@@ -483,7 +504,7 @@ export class MessageBridge {
                 ...(msg.replyContext ?? {}),
                 metadata: {
                     ...(msg.replyContext?.metadata ?? {}),
-                    ...evolMenuResponseTransportMetadata(),
+                    ...evolMenuResponseTransportMetadata(msg.protectedHeaders?.sdk_version),
                 },
             },
         }), {
@@ -795,6 +816,20 @@ export class MessageBridge {
                     }
                     return;
                 }
+                if (!trustedHandoffEcho && selfAid && actorId && this.groupInviteReviewService) {
+                    const inviteCommand = await this.groupInviteReviewService.handleCommand({
+                        selfAid,
+                        ownerAid: actorId,
+                        channelKey,
+                        channelType: resolvedChannelType,
+                        chatType,
+                        content,
+                    });
+                    if (inviteCommand.handled) {
+                        await this.sendAdmissionControlReply(admissionPreflight.context, msg, sendReply, inviteCommand.text ?? '群邀请命令已处理。');
+                        return;
+                    }
+                }
                 if (!trustedHandoffEcho && await this.handleReservedContactControl({
                     context: admissionPreflight.context,
                     msg,
@@ -945,6 +980,37 @@ export class MessageBridge {
                     await this.sendAccessDenied(adapter, channelName, msg, sendReply);
                     return;
                 }
+                // Diagnostic invitations carry their own execution boundary. Resolve
+                // that boundary before ordinary command/session routing so a new case
+                // cannot inherit an older Codex thread.
+                let diagnosticSession;
+                if (selfAid === DIAGNOSTIC_AGENT_AID && resolvedChannelType === 'aun'
+                    && chatType === 'private' && msg.source !== 'handoff') {
+                    try {
+                        const diagnosticEvent = parseDiagnosticEvent(content);
+                        if (diagnosticEvent) {
+                            releaseAdmission = await this.acquireAdmission(admissionRoute);
+                            const routed = await this.diagnosticRouter.route({
+                                event: diagnosticEvent, message: msg, channel: channelName,
+                                channelType: resolvedChannelType, selfAid,
+                                chatDir: chatDirPath(resolvePaths().sessionsDir, resolvedChannelType, msg.channelId, selfAid, channelName),
+                                projectPath: owningAgent?.projectPath ?? this.defaultProjectPath,
+                                baseagent: owningAgent?.baseagent,
+                            });
+                            if ('notice' in routed) {
+                                await sendReply(msg.channelId, routed.notice, msg.replyContext);
+                                return;
+                            }
+                            diagnosticSession = routed.session;
+                            diagnosticSession.identity = identity;
+                        }
+                    }
+                    catch (error) {
+                        logger.warn(`[MessageBridge] Diagnostic admission failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+                        await sendReply(msg.channelId, '诊断会话隔离未完成，本次未执行诊断。请检查诊断端日志后重试。', msg.replyContext);
+                        return;
+                    }
+                }
                 // /fa is an execution prefix, not a session-mode switch or a normal
                 // quick command. Only this trusted bridge path can construct the
                 // internal per-call authorization carried into ResponseEngine.
@@ -1027,6 +1093,11 @@ export class MessageBridge {
                         ...(chatType === 'private' ? { routeId: msg.channelId } : {}),
                     });
                 }
+                const initializationConfig = selfAid ? loadAgent(selfAid) : null;
+                if (initializationConfig && initializationBlocksTasks(initializationConfig)) {
+                    await sendReply(msg.channelId, 'Agent 初始化尚未完成，请由创建者查询 ec agent show 或恢复初始化。');
+                    return;
+                }
                 // 1. owner 绑定（按实例名绑定）
                 if (adapter && actorId && roleDetail.effectiveRole === 'owner') {
                     await this.bootstrapService?.tryStartBootstrap({
@@ -1106,6 +1177,14 @@ export class MessageBridge {
                         return sendReply(msg.channelId, text, msg.replyContext);
                     }, msg.peerId, msg.threadId, msg.chatType, msg.source, msg.replyContext, msg.messageId, msg.selfAID, authSubject))
                     return;
+                // Commands retain their normal route. Only authenticated direct model
+                // input can obtain the Agent policy's per-call authorization.
+                if (!executionPermissionOverride && selfAid && owningAgent?.aid === selfAid) {
+                    executionPermissionOverride = createAgentPolicyAuthorization({
+                        agentAid: selfAid, actor: roleDetail.actor, chatType,
+                        source: msg.source, peerType: msg.peerType,
+                    });
+                }
                 // 3. session 解析（使用 Channel 层填充的 chatType）
                 if (!(await this.canCreateThreadSession(channelName, msg, chatType))) {
                     // 静默丢弃：绝不向群里注入回复。
@@ -1147,9 +1226,10 @@ export class MessageBridge {
                 // transaction. Without this per-route single-flight, a second message
                 // can observe the just-renewed empty session before the first message
                 // has been appended and create another renewed session.
-                releaseAdmission = await this.acquireAdmission(admissionRoute);
+                if (!releaseAdmission)
+                    releaseAdmission = await this.acquireAdmission(admissionRoute);
                 const hadMainSession = msg.threadId ? true : this.sessionManager.hasMainSession(channelName, msg.channelId, msg.channelType || effectiveChannelType, msg.selfAID || selfAid);
-                let session = await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, this.extractTopicName(msg), msg.peerId, chatType, owningAgent?.baseagent, msg.selfAID, msg.channelType || effectiveChannelType, msg.peerType, identity);
+                let session = diagnosticSession ?? await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, this.extractTopicName(msg), msg.peerId, chatType, owningAgent?.baseagent, msg.selfAID, msg.channelType || effectiveChannelType, msg.peerType, identity, readTopicLable(msg) ?? readTopicLable(msg.replyContext?.metadata));
                 if (session.threadId && typeof this.messageQueue.reserveSessionIngress === 'function') {
                     releaseSessionIngress = this.messageQueue.reserveSessionIngress(session.id);
                 }
@@ -1162,7 +1242,7 @@ export class MessageBridge {
                 const inboundCausation = restoredCausation
                     ? deriveCausation(restoredCausation)
                     : createRootCausation();
-                const renewResult = await this.sessionRenewService.resolve({
+                const renewResult = session.metadata?.diagnostic ? { session } : await this.sessionRenewService.resolve({
                     session,
                     channelName,
                     channelType: msg.channelType || effectiveChannelType,
@@ -1205,6 +1285,7 @@ export class MessageBridge {
                     mentions: msg.mentions, mentionAids: msg.mentionAids, threadId: msg.threadId,
                     isMentioned: msg.isMentioned,
                     topicName: this.extractTopicName(msg),
+                    lable: session.lable,
                     replyContext: msg.replyContext,
                     source: msg.source,
                     ...(executionPermissionOverride ? { executionPermissionOverride } : {}),
@@ -1298,6 +1379,9 @@ export class MessageBridge {
                 const enqueueAgentName = owningAgent?.name ?? '<unknown>';
                 const selfAID = session.selfAID;
                 const doEnqueue = async (m) => {
+                    // A cancellation can arrive while this message is being debounced.
+                    if (!isDiagnosticSessionActive(session, this.sessionManager.getChatDir(session)))
+                        return;
                     const enqueue = handoffCandidate ? this.messageQueue.enqueuePersisted.bind(this.messageQueue) : this.messageQueue.enqueue.bind(this.messageQueue);
                     try {
                         return await enqueue(session.id, m, session.projectPath, {
@@ -1427,6 +1511,8 @@ export class MessageBridge {
         const menuAuthSubject = {
             ...authSubject,
             requestId: parsed.id,
+            menuEncrypted: msg.encrypted === true,
+            fromControlChannel: authSubject.fromControlChannel || msg.isControlChannel === true,
             ...(activeSession?.id ? { sessionId: activeSession.id } : {}),
         };
         const isTokenRequest = parsed.type === 'menu.token.request';
@@ -1457,6 +1543,17 @@ export class MessageBridge {
                 return;
             }
         }
+        // Reauthorize even cached responses: roots expire and static owners can be revoked.
+        const isStorageRequest = isAgentStorageMenuRequest(parsed.request);
+        if (isStorageRequest) {
+            try {
+                agentStorageMenuService.preflight(parsed.request, menuAuthSubject);
+            }
+            catch (error) {
+                await this.sendMenuResponse(adapter, channel, msg, menuFailure(header, normalizeMenuError(error)));
+                return;
+            }
+        }
         const scope = msg.chatType === 'group' ? (msg.groupId || msg.channelId) : msg.peerId;
         // Separate installations can generate identical request IDs. Token
         // issuance and replay must remain scoped to the authenticated requester.
@@ -1474,6 +1571,16 @@ export class MessageBridge {
             }));
             return;
         }
+        // A replay may have awaited an in-flight request; check again before release.
+        if (isStorageRequest) {
+            try {
+                agentStorageMenuService.preflight(parsed.request, menuAuthSubject, false);
+            }
+            catch (error) {
+                await this.sendMenuResponse(adapter, channel, msg, menuFailure(header, normalizeMenuError(error)));
+                return;
+            }
+        }
         if (deduped.replayed)
             this.logMenuDiagnostic('request-replay', channel, msg, parsed);
         if (deduped.retry)
@@ -1488,7 +1595,20 @@ export class MessageBridge {
                 await deferredEffect();
             }
             catch (error) {
-                logger.warn(`[MenuControl] deferred effect failed: request=${parsed.id} error=${error instanceof Error ? error.message : String(error)}`);
+                const detail = error instanceof Error ? error.message : String(error);
+                const code = error && typeof error === 'object' && 'code' in error
+                    ? String(error.code ?? 'EXEC_FAILED')
+                    : 'EXEC_FAILED';
+                logger.warn(`[MenuControl] deferred effect failed: request=${parsed.id} error=${detail}`);
+                // File fetch is acknowledged before the upload completes. Send a
+                // second response with the same request id so the client can finish
+                // the pending fetch with an actionable error instead of timing out.
+                const failedResponse = menuFailure(header, {
+                    code,
+                    message: detail.startsWith('文件发送失败') ? detail : `文件发送失败: ${detail}`,
+                });
+                await this.menuDeduper.replaceResult(dedupKey, menuPayloadFingerprint(parsed.raw), deduped.value, failedResponse);
+                await this.sendMenuResponse(adapter, channel, msg, failedResponse);
             }
         }
     }
@@ -1498,6 +1618,13 @@ export class MessageBridge {
             const name = header.name ?? '';
             const cmd = typeof request.cmd === 'string' ? request.cmd : undefined;
             const args = request.args;
+            const transportReplyContext = {
+                ...(msg.replyContext ?? {}),
+                ...(msg.threadId ? { threadId: msg.threadId } : {}),
+            };
+            // Explicit group context can target a different conversation. Its
+            // sessions must not inherit the thread of the source conversation.
+            const replyContextFor = (channelId) => channelId === msg.channelId ? transportReplyContext : undefined;
             switch (request.type) {
                 case 'menu.list':
                     if (args?.view === 'catalog') {
@@ -1514,7 +1641,7 @@ export class MessageBridge {
                 case 'menu.query': {
                     if (name === 'menu' && args?.view === 'values') {
                         validateMenuValueBatchArgs(args);
-                        const data = await this.cmdHandler.execMenuValueBatch(channel, msg.channelId, authSubject, args, args.context, msg.isControlChannel ? 'control' : 'agent');
+                        const data = await this.cmdHandler.execMenuValueBatch(channel, msg.channelId, authSubject, args, args.context, msg.isControlChannel ? 'control' : 'agent', transportReplyContext);
                         return menuSuccess(header, data);
                     }
                     if (name === 'menu') {
@@ -1527,7 +1654,7 @@ export class MessageBridge {
                         channelId: msg.channelId,
                         args,
                     });
-                    const result = await this.cmdHandler.execMenuQuery(this.resolveCmd(name, cmd), channel, execution.channelId, execution.subject.actorId, execution.args, execution.subject.chatType, execution.subject.fromControlChannel, execution.subject.identity, execution.subject);
+                    const result = await this.cmdHandler.execMenuQuery(this.resolveCmd(name, cmd), channel, execution.channelId, execution.subject.actorId, execution.args, execution.subject.chatType, execution.subject.fromControlChannel, execution.subject.identity, execution.subject, 'menu', replyContextFor(execution.channelId));
                     if ('error' in result)
                         throw result;
                     return menuSuccess(header, result.data);
@@ -1544,7 +1671,7 @@ export class MessageBridge {
                     if ((name === 'topic' || cmd === '/topic') && args?.mode === 'fork-turns' && msg.threadId && !args?.sourceThreadId) {
                         optionArgs = { ...(execution.args ?? {}), sourceThreadId: msg.threadId };
                     }
-                    const data = await this.cmdHandler.getSubMenuItems(this.resolveCmd(name, cmd), channel, execution.channelId, execution.subject.actorId, optionArgs, execution.subject.identity, execution.subject.chatType, execution.subject.fromControlChannel, execution.subject) ?? [];
+                    const data = await this.cmdHandler.getSubMenuItems(this.resolveCmd(name, cmd), channel, execution.channelId, execution.subject.actorId, optionArgs, execution.subject.identity, execution.subject.chatType, execution.subject.fromControlChannel, execution.subject, 'menu', replyContextFor(execution.channelId)) ?? [];
                     return menuSuccess(header, data);
                 }
                 case 'menu.update': {
@@ -1555,10 +1682,7 @@ export class MessageBridge {
                         channelId: msg.channelId,
                         args,
                     });
-                    const result = await this.cmdHandler.execMenuUpdate(this.resolveCmd(name, cmd), request.value, channel, execution.channelId, execution.subject.actorId, execution.subject.identity, execution.subject.fromControlChannel, execution.args, execution.subject, 'menu', {
-                        ...(msg.replyContext ?? {}),
-                        ...(msg.threadId ? { threadId: msg.threadId } : {}),
-                    });
+                    const result = await this.cmdHandler.execMenuUpdate(this.resolveCmd(name, cmd), request.value, channel, execution.channelId, execution.subject.actorId, execution.subject.identity, execution.subject.fromControlChannel, execution.args, execution.subject, 'menu', replyContextFor(execution.channelId));
                     if ('error' in result)
                         throw result;
                     return menuSuccess(header, result.data);
@@ -1621,9 +1745,11 @@ export class MessageBridge {
         const agentName = this.agentRegistry?.resolveByChannel(channel)?.name ?? '<unknown>';
         const replyContext = {
             ...(msg.replyContext ?? {}),
+            ...(msg.peerDeviceId ? { toDeviceId: msg.peerDeviceId } : {}),
             metadata: {
                 ...(msg.replyContext?.metadata ?? {}),
-                ...evolMenuResponseTransportMetadata(),
+                ...evolMenuResponseTransportMetadata(msg.protectedHeaders?.sdk_version),
+                ...(isAgentStorageMenuRequest(request) ? { encrypted: true } : {}),
             },
         };
         if (msg.channelType === 'aun' && !replyContext.delivery) {
@@ -1890,6 +2016,7 @@ export class MessageBridge {
     }
     /** 注销单个渠道的 debouncer（热重载断开渠道时调用） */
     removeChannel(channelName) {
+        this.groupInviteReviewService?.detach(channelName);
         const d = this.debouncers.get(channelName);
         if (d) {
             d.dispose();

package/dist/core/message/message-log.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { appendJsonl, chatDirPath } from '../session/session-fs-store.js';
+import { appendJsonl, appendJsonlDurable, chatDirPath } from '../session/session-fs-store.js';
 import { logger } from '../../utils/logger.js';
 const TRANSIENT_PROTOCOL_TYPE_PREFIXES = [
     'contact.request.',
@@ -313,13 +313,13 @@ export function appendMessageLog(chatDir, entry) {
     }
 }
 /** Strict conversation-history append used by handoff reply binding. */
-export function appendMessageLogStrict(chatDir, entry) {
+export function appendMessageLogStrict(chatDir, entry, durable = false) {
     if (isTransientProtocolMessage(entry))
         return;
     if (entry.dir === 'in' && hasDuplicate(chatDir, entry.msgId))
         return;
     fs.mkdirSync(chatDir, { recursive: true });
-    appendJsonl(messageLogPath(chatDir), entry);
+    (durable ? appendJsonlDurable : appendJsonl)(messageLogPath(chatDir), entry);
     if (entry.dir === 'in')
         rememberMessageId(chatDir, entry.msgId);
 }
@@ -343,6 +343,8 @@ export function buildInboundEntry(opts) {
         msgType: isCommand ? 'command' : (opts.msgType ?? 'text'),
         payloadType: opts.payloadType,
         payloadSummary: opts.payloadSummary,
+        groupAttention: opts.groupAttention,
+        groupDelivery: opts.groupDelivery,
         content: opts.content,
         replyTo: opts.replyTo ?? null,
         agent: null,

package/dist/core/message/message-queue.js

@@ -4,6 +4,7 @@ import { logger } from '../../utils/logger.js';
 import { LogicalQueueBridge } from './logical-queue-bridge.js';
 import { normalizeCausation } from '../causation/context.js';
 import { KeyedFairMutex } from '../handoff/mutex.js';
+import { ExecutionTimeoutError, OrphanedTargetSessionError, isExecutionFailure } from '../../utils/error-utils.js';
 const DEFAULT_AGENT_NAME = '<unknown>';
 const RESTART_RESUME_CONTENT = 'evolcore 服务已重启，请继续之前未完成的任务。';
 export class MessageQueue {
@@ -52,7 +53,7 @@ export class MessageQueue {
     setInterruptCallback(callback) {
         this.interruptCallback = callback;
     }
-    triggerInterrupt(queueKey, sessionKey, baseagent, evolagentName, reason) {
+    triggerInterrupt(queueKey, sessionKey, baseagent, evolagentName, reason, timeout) {
         const existing = this.interruptBarriers.get(queueKey);
         if (existing)
             return existing;
@@ -61,7 +62,9 @@ export class MessageQueue {
         this.activeTerminalReasons.set(queueKey, reason);
         let interruption;
         try {
-            interruption = Promise.resolve(this.interruptCallback(sessionKey, baseagent, evolagentName, reason));
+            interruption = Promise.resolve(timeout
+                ? this.interruptCallback(sessionKey, baseagent, evolagentName, reason, timeout)
+                : this.interruptCallback(sessionKey, baseagent, evolagentName, reason));
         }
         catch (error) {
             interruption = Promise.reject(error);
@@ -980,7 +983,8 @@ export class MessageQueue {
                     this.persistQueuesImmediate();
                 }
                 else if (message.messageId) {
-                    void this.cancelActiveAndWait(message.messageId, message.selfAID).finally(() => {
+                    const timeout = isExecutionFailure(options?.signal?.reason) ? options.signal.reason : undefined;
+                    void this.cancelActiveAndWait(message.messageId, message.selfAID, timeout).finally(() => {
                         this.forgetProcessed(sessionKey, message);
                         settleReject(error);
                     });
@@ -1262,7 +1266,9 @@ export class MessageQueue {
         return result;
     }
     isMergeBarrier(message) {
-        return !!message.executionPermissionOverride
+        return !!message.taskRecovery
+            || !!message.asyncQuestionAnswer
+            || !!message.executionPermissionOverride
             || !!message.handoffDelivery
             || !!message.triggerMeta
             || !!message.causation?.trigger?.path.length;
@@ -1525,12 +1531,14 @@ export class MessageQueue {
         return cancellation.found;
     }
     /** Cancel an active message and wait until the runner interrupt barrier settles. */
-    async cancelActiveAndWait(messageId, selfAID) {
-        const cancellation = this.beginActiveCancellation(messageId, selfAID);
+    async cancelActiveAndWait(messageId, selfAID, cause) {
+        const cancellation = this.beginActiveCancellation(messageId, selfAID, cause);
         await cancellation.barrier;
         return cancellation.found;
     }
-    beginActiveCancellation(messageId, selfAID) {
+    beginActiveCancellation(messageId, selfAID, cause) {
+        const reason = cause instanceof ExecutionTimeoutError ? 'timeout'
+            : cause instanceof OrphanedTargetSessionError ? 'execution_error' : cause ?? 'recalled';
         for (const [queueKey, activeState] of this.activeStates.entries()) {
             if (!activeState.messageIds.has(messageId))
                 continue;
@@ -1558,18 +1566,20 @@ export class MessageQueue {
             }
             const sessionKey = this.sessionKeyFromQueueKey(queueKey);
             const agentName = this.processingAgent.get(queueKey);
-            logger.info(`[Queue] Recalled active message ${messageId}, interrupting session ${sessionKey}`);
-            this.eventBus?.publish({
-                type: 'task:interrupted',
-                sessionId: sessionKey,
-                reason: 'recalled',
-                agentName,
-                taskId: activeState?.taskId,
-                generation: activeState?.generation,
-                causation: active?.message.causation,
-            });
+            logger.info(`[Queue] Cancelled active message ${messageId}, interrupting session ${sessionKey}: ${reason}`);
+            // TimeoutController owns the failure event and outbound timeout terminal.
+            if (reason !== 'timeout' && reason !== 'execution_error')
+                this.eventBus?.publish({
+                    type: 'task:interrupted',
+                    sessionId: sessionKey,
+                    reason,
+                    agentName,
+                    taskId: activeState?.taskId,
+                    generation: activeState?.generation,
+                    causation: active?.message.causation,
+                });
             const barrier = this.interruptCallback
-                ? this.triggerInterrupt(queueKey, sessionKey, activeState.baseagent, agentName, 'recalled')
+                ? this.triggerInterrupt(queueKey, sessionKey, activeState.baseagent, agentName, reason, isExecutionFailure(cause) ? cause : undefined)
                 : Promise.resolve();
             return { found: true, barrier };
         }
@@ -1603,33 +1613,11 @@ export class MessageQueue {
         }
         let releasePromise;
         const promise = new Promise(resolve => { releasePromise = resolve; });
-        let queued = 0;
-        let active = false;
-        let dispatching = false;
-        for (const [queueKey, queue] of this.queues.entries()) {
-            if (!this.matchesSession(queueKey, sessionKey))
-                continue;
-            queued += this.queueRawMessageCount(queue);
-            if (this.processing.has(queueKey) || this.activeBatches.has(queueKey))
-                active = true;
-            if (this.processing.has(queueKey) && !this.activeBatches.has(queueKey))
-                dispatching = true;
-        }
-        for (const queueKey of this.activeBatches.keys()) {
-            if (this.matchesSession(queueKey, sessionKey))
-                active = true;
-        }
         const state = {
             promise,
             releasePromise,
             holders: 1,
-            snapshot: {
-                prequeue: this.prequeueReservations.get(sessionKey) ?? 0,
-                active,
-                queued,
-                dispatching,
-                cutoff: this.enqueueSequence,
-            },
+            snapshot: this.getSessionSnapshot(sessionKey),
         };
         this.externalLocks.set(sessionKey, state);
         let released = false;
@@ -1648,6 +1636,50 @@ export class MessageQueue {
             },
         };
     }
+    /** Live admission state, including work that arrived after an older gate. */
+    getMessageState(sessionId, messageId, selfAid) {
+        for (const [key, queue] of this.queues) {
+            if (this.matchesSession(key, sessionId) && queue.some(item => this.partsOf(item)
+                .some(part => this.partMatchesMessage(part, messageId, selfAid, key))))
+                return { state: 'queued' };
+        }
+        for (const [key, item] of this.activeBatches) {
+            if (this.matchesSession(key, sessionId) && this.partsOf(item)
+                .some(part => this.partMatchesMessage(part, messageId, selfAid, key))) {
+                return { state: 'active' };
+            }
+        }
+        return { state: 'missing' };
+    }
+    /** Live admission state, including work that arrived after an older gate. */
+    getSessionSnapshot(sessionKey) {
+        let queued = 0;
+        let active = false;
+        let dispatching = false;
+        const activeTaskIds = new Set();
+        for (const [queueKey, queue] of this.queues.entries()) {
+            if (!this.matchesSession(queueKey, sessionKey))
+                continue;
+            queued += this.queueRawMessageCount(queue);
+            if (this.processing.has(queueKey) || this.activeBatches.has(queueKey))
+                active = true;
+            if (this.processing.has(queueKey) && !this.activeBatches.has(queueKey))
+                dispatching = true;
+        }
+        for (const queueKey of this.activeBatches.keys()) {
+            if (!this.matchesSession(queueKey, sessionKey))
+                continue;
+            active = true;
+            const taskId = this.activeStates.get(queueKey)?.taskId;
+            if (taskId)
+                activeTaskIds.add(taskId);
+        }
+        return {
+            prequeue: this.prequeueReservations.get(sessionKey) ?? 0,
+            active, queued, dispatching, cutoff: this.enqueueSequence,
+            activeTaskIds: [...activeTaskIds],
+        };
+    }
     /**
      * Mark an admitted message before it enters debounce or other pre-queue
      * work. The returned release is idempotent so callers can use it both from