evolcore 0.0.21 → 0.0.22

package/dist/core/command/slash-handler.js

@@ -26,6 +26,7 @@ import { normalizePermissionMode as normalizePermissionModeContract, PUBLIC_PERM
 import { isManagementRole } from '../../config/builtin-roles.js';
 import { isSystemControlChannel } from '../system-channels.js';
 import { spawnDetachedNode } from '../../utils/cross-platform.js';
+import { inspectDataMigrationRequirement } from '../data-migration.js';
 import { guardIdleCommand, guardKnownCommand, guardRoleCommand, guardThreadCommand, isRecognizedSlashCommand, normalizeSlashContent, probeSessionActivity, } from './slash-gate.js';
 const allEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
 const PERMISSION_MODE_KEYS = PUBLIC_PERMISSION_MODES;
@@ -2142,15 +2143,15 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
     // 才会在新的 TurnLease 中懒创建并绑定新 backend。
     if (normalizedContent === '/renew' || /^\/renew\s/.test(normalizedContent)) {
         if (normalizedContent !== '/renew') {
-            return { kind: 'command.error', text: '❌ /renew 不接受参数，请直接使用 /renew' };
+            return { kind: 'system.error', text: '❌ /renew 不接受参数，请直接使用 /renew', subtype: 'session.renew.invalid_arguments', recoverable: true };
         }
         if (!threadId) {
-            return { kind: 'command.error', text: '⚠️ /renew 仅支持话题会话' };
+            return { kind: 'system.error', text: '⚠️ /renew 仅支持话题会话', subtype: 'session.renew.unsupported', recoverable: true };
         }
         // Card callbacks use synthetic message IDs on several adapters. They are
         // suitable for UI correlation, but not for the durable inbound claim.
         if (source === 'card-trigger') {
-            return { kind: 'command.error', text: '⚠️ /renew 仅支持携带原生消息 ID 的普通消息' };
+            return { kind: 'system.error', text: '⚠️ /renew 仅支持携带原生消息 ID 的普通消息', subtype: 'session.renew.invalid_source', recoverable: true };
         }
         let renewSession;
         try {
@@ -2160,19 +2161,19 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         }
         catch (error) {
             logger.warn(`[CommandHandler] /renew topic lookup failed: thread=${threadId}: ${error instanceof Error ? error.message : String(error)}`);
-            return { kind: 'command.error', text: '⚠️ 当前会话状态未知，无法安全轮换，请稍后再试' };
+            return { kind: 'system.error', text: '⚠️ 当前会话状态未知，无法安全轮换，请稍后再试', subtype: 'session.renew.state_unknown', recoverable: true };
         }
         if (!renewSession) {
-            return { kind: 'command.error', text: '❌ 找不到当前话题会话' };
+            return { kind: 'system.error', text: '❌ 找不到当前话题会话', subtype: 'session.renew.session_missing', recoverable: true };
         }
         const inboundMessageId = messageId?.trim();
         if (!inboundMessageId) {
-            return { kind: 'command.error', text: '❌ /renew 缺少稳定的消息 ID，当前渠道不支持安全重试' };
+            return { kind: 'system.error', text: '❌ /renew 缺少稳定的消息 ID，当前渠道不支持安全重试', subtype: 'session.renew.message_id_missing', recoverable: true };
         }
         if (typeof this.sessionManager.rotateTopicBackend !== 'function'
             || typeof this.messageQueue.withSessionBarrier !== 'function'
             || typeof this.messageQueue.claimInbound !== 'function') {
-            return { kind: 'command.error', text: '❌ 当前运行环境不支持安全 backend 轮换' };
+            return { kind: 'system.error', text: '❌ 当前运行环境不支持安全 backend 轮换', subtype: 'session.renew.unavailable', recoverable: true };
         }
         try {
             const outcome = await this.messageQueue.withSessionBarrier(renewSession.id, async (snapshot) => {
@@ -2211,33 +2212,36 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
                 };
             });
             if (outcome.kind === 'missing') {
-                return { kind: 'command.error', text: '❌ 当前话题会话已不存在或归属已变化' };
+                return { kind: 'system.error', text: '❌ 当前话题会话已不存在或归属已变化', subtype: 'session.renew.session_changed', recoverable: true };
             }
             if (outcome.kind === 'claim_failed') {
-                return { kind: 'command.error', text: '❌ 当前渠道无法安全记录该请求，未执行 backend 轮换' };
+                return { kind: 'system.error', text: '❌ 当前渠道无法安全记录该请求，未执行 backend 轮换', subtype: 'session.renew.claim_failed', recoverable: true };
             }
             if (outcome.kind === 'duplicate') {
-                return { kind: 'command.result', text: 'ℹ️ 该请求已接收过，不再重复执行' };
+                return { kind: 'system.notice', text: 'ℹ️ 该请求已接收过，不再重复执行', subtype: 'session.renew.duplicate' };
             }
             if (outcome.kind === 'busy' || outcome.kind === 'unknown') {
                 return {
-                    kind: 'command.error',
+                    kind: 'system.error',
                     text: outcome.kind === 'busy'
                         ? '⚠️ 当前会话忙碌，无法安全轮换，请稍后再试'
                         : '⚠️ 当前会话状态未知，无法安全轮换，请稍后再试',
+                    subtype: outcome.kind === 'busy' ? 'session.renew.busy' : 'session.renew.state_unknown',
+                    recoverable: true,
                 };
             }
             if (outcome.kind !== 'rotated') {
-                return { kind: 'command.error', text: '⚠️ 当前会话状态未知，无法安全轮换，请稍后再试' };
+                return { kind: 'system.error', text: '⚠️ 当前会话状态未知，无法安全轮换，请稍后再试', subtype: 'session.renew.state_unknown', recoverable: true };
             }
             return {
-                kind: 'command.result',
+                kind: 'system.notice',
                 text: `✅ backend 已切换${outcome.wasBound ? '' : '（当前未绑定 backend）'}；下一条消息将初始化新 backend（阶段一不携带历史摘要）`,
+                subtype: 'session.renewed',
             };
         }
         catch (error) {
             logger.error(`[CommandHandler] /renew failed: session=${renewSession.id}: ${error instanceof Error ? error.message : String(error)}`);
-            return { kind: 'command.error', text: `❌ backend 轮换失败：${error instanceof Error ? error.message : String(error)}` };
+            return { kind: 'system.error', text: `❌ backend 轮换失败：${error instanceof Error ? error.message : String(error)}`, subtype: 'session.renew.failed', recoverable: true };
         }
     }
     // /compact 命令：手动压缩会话上下文
@@ -2451,13 +2455,17 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         if (sessionName) {
             const existing = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
             if (existing) {
-                return { kind: 'command.error', text: `❌ 会话名称 "${sessionName}" 已存在，请使用其他名称` };
+                return { kind: 'system.error', text: `❌ 会话名称 "${sessionName}" 已存在，请使用其他名称`, subtype: 'session.new.name_conflict', recoverable: true };
             }
         }
         await interruptPausedSessionBeforeReplacement(session || activeSession);
         const projectPath = this.getEffectiveDefaultPath(channel);
         if (sendMessage && session) {
-            await sendMessage(channelId, `⏳ 正在创建新会话${sessionName ? `: ${sessionName}` : ''}...`, this.getReplyContext(session));
+            await sendMessage(channelId, `⏳ 正在创建新会话${sessionName ? `: ${sessionName}` : ''}...`, this.getReplyContext(session), {
+                kind: 'system.notice',
+                text: `⏳ 正在创建新会话${sessionName ? `: ${sessionName}` : ''}...`,
+                subtype: 'session.creating',
+            });
         }
         const newSessionBaseagent = this.agentRegistry?.resolveByChannel(channel)?.baseagent || this.parseDefaultBaseagent();
         const previousMetadata = session?.metadata || activeSession?.metadata || {};
@@ -2524,7 +2532,11 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             ?? newRunner.getEffort?.()
             ?? newAgent?.effort;
         const backendBits = [newBaseagent, backendModel, backendEffort].filter(Boolean).join(' · ');
-        return { kind: 'command.result', text: `✓ 已创建新会话${sessionName ? `: ${sessionName}` : ''}\n  项目: ${this.getProjectName(projectPath)}\n  后端: ${backendBits}\n  之前的对话历史已保留，可通过 /s 查看${handoffDiscardWarning ? `\n${handoffDiscardWarning}` : ''}` };
+        return {
+            kind: 'system.notice',
+            text: `✓ 已创建新会话${sessionName ? `: ${sessionName}` : ''}\n  项目: ${this.getProjectName(projectPath)}\n  后端: ${backendBits}\n  之前的对话历史已保留，可通过 /s 查看${handoffDiscardWarning ? `\n${handoffDiscardWarning}` : ''}`,
+            subtype: 'session.created',
+        };
     }
     // /check 命令：检查 EvolAgent 实例健康（visitor/member 可用，详情仅 admin）
     if (normalizedContent === '/check' || normalizedContent.startsWith('/check ')) {
@@ -2773,7 +2785,6 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             const count = this.messageCache.getCount(s.id);
             return `${s.projectPath} 有 ${count} 条新消息`;
         });
-        // 执行重启逻辑（共用于卡片回调和文本确认）
         const executeRestart = async () => {
             const suppressRealRestart = shouldSuppressRealRestart();
             let restartReplyContext = replyContext;
@@ -2814,6 +2825,11 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
                 logger.warn(`[System] Refusing restart without a valid explicit delivery route: channel=${channel} channelId=${channelId}`);
                 return false;
             }
+            const migrationRequirement = inspectDataMigrationRequirement(resolvePaths().root);
+            if (migrationRequirement.required) {
+                logger.warn(`[System] Refusing restart while data migration is pending: operations=${migrationRequirement.operationCount}`);
+                return { code: 'DATA_MIGRATION_REQUIRED', operationCount: migrationRequirement.operationCount };
+            }
             const restartInfo = {
                 channel,
                 channelId,
@@ -2892,6 +2908,13 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             }
         }
         const restarted = await executeRestart();
+        if (typeof restarted === 'object' && restarted.code === 'DATA_MIGRATION_REQUIRED') {
+            return {
+                kind: 'command.error',
+                text: `❌ 待处理的用户数据迁移（${restarted.operationCount} 项）阻止重启。请先运行 ec data migrate --dry-run，然后运行 ec data migrate --apply。`,
+                reason: restarted.code,
+            };
+        }
         if (!restarted) {
             return { kind: 'command.error', text: '❌ 无法确定重启通知的出站路由，请从可信会话上下文重试' };
         }

package/dist/core/data-migration.js

@@ -768,7 +768,17 @@ export function planDataMigration(root) {
     }
     catch { }
     const contactAudit = path.join(root, 'data', 'contact-book-audit.jsonl');
-    if (fs.existsSync(contactAudit)) {
+    // The legacy audit file may be provisioned as an empty placeholder (for
+    // example by a protected-path sandbox). An empty source has nothing to
+    // partition and must not block daemon startup.
+    let hasContactAuditRecords = false;
+    try {
+        const stat = fs.statSync(contactAudit);
+        hasContactAuditRecords = stat.isFile()
+            && fs.readFileSync(contactAudit, 'utf8').trim().length > 0;
+    }
+    catch { }
+    if (hasContactAuditRecords) {
         const operationId = nextId('contact-audit');
         operations.push({ id: operationId, kind: 'contact-audit-partition', source: contactAudit, staging: path.join(stagingDir, operationId), status: 'planned' });
     }

package/dist/core/event-catalog.js

@@ -246,6 +246,8 @@ const CATALOG = [
         description: 'agent 任务开始',
         fields: [
             { path: 'sessionId', type: 'string' },
+            { path: 'taskId', type: 'string', optional: true },
+            { path: 'generation', type: 'number', optional: true },
             { path: 'agentName', type: 'string', optional: true },
             { path: 'encrypt', type: 'boolean', optional: true },
             { path: 'chatmode', type: 'string', optional: true },
@@ -269,6 +271,8 @@ const CATALOG = [
         description: 'agent 任务完成',
         fields: [
             { path: 'sessionId', type: 'string' },
+            { path: 'taskId', type: 'string', optional: true },
+            { path: 'generation', type: 'number', optional: true },
             { path: 'channel', type: 'string' },
             { path: 'channelName', type: 'string', optional: true },
             { path: 'channelId', type: 'string' },
@@ -287,6 +291,8 @@ const CATALOG = [
         description: 'agent 任务失败',
         fields: [
             { path: 'sessionId', type: 'string' },
+            { path: 'taskId', type: 'string', optional: true },
+            { path: 'generation', type: 'number', optional: true },
             { path: 'error', type: 'string' },
             { path: 'errorType', type: 'string' },
             { path: 'terminalReason', type: 'string', optional: true },
@@ -300,6 +306,8 @@ const CATALOG = [
         description: 'agent 任务被中断',
         fields: [
             { path: 'sessionId', type: 'string' },
+            { path: 'taskId', type: 'string', optional: true },
+            { path: 'generation', type: 'number', optional: true },
             { path: 'reason', type: 'string', optional: true },
             { path: 'agentName', type: 'string', optional: true },
         ],
@@ -339,13 +347,17 @@ const CATALOG = [
             { path: 'eventPhase', type: 'string' },
             { path: 'isError', type: 'boolean', optional: true },
             { path: 'errorCode', type: 'string', optional: true },
+            { path: 'classificationMissing', type: 'boolean', optional: true },
             { path: 'agentName', type: 'string', optional: true },
             { path: 'callId', type: 'string', optional: true },
             { path: 'correlationId', type: 'string', optional: true },
+            { path: 'requestId', type: 'string', optional: true },
             { path: 'agentAid', type: 'string', optional: true },
             { path: 'permissionMode', type: 'string', optional: true },
             { path: 'decision', type: 'string' },
             { path: 'decisionSource', type: 'string' },
+            { path: 'policyCode', type: 'string', optional: true },
+            { path: 'reason', type: 'string', optional: true },
             { path: 'executed', type: 'boolean' },
             { path: 'executionState', type: 'string' },
             { path: 'timestamp', type: 'number', optional: true },
@@ -399,6 +411,21 @@ const CATALOG = [
         description: 'runner 开始压缩',
         fields: [{ path: 'sessionId', type: 'string' }],
     },
+    {
+        type: 'runner:proactive-reminder',
+        namespace: 'runner',
+        name: 'proactive-reminder',
+        description: '主动模式提醒已生成并请求注入模型上下文',
+        fields: [
+            { path: 'sessionId', type: 'string' },
+            { path: 'kind', type: 'string' },
+            { path: 'text', type: 'string' },
+            { path: 'queueLength', type: 'number', optional: true },
+            { path: 'toolCount', type: 'number', optional: true },
+            { path: 'injection', type: 'string' },
+            { path: 'timestamp', type: 'number', optional: true },
+        ],
+    },
     {
         type: 'runner:compact-complete',
         namespace: 'runner',
@@ -690,6 +717,11 @@ const CATALOG = [
             { path: 'runId', type: 'string' },
             { path: 'originTriggerId', type: 'string' },
             { path: 'reason', type: 'string' },
+            { path: 'reasonCode', type: 'string', optional: true },
+            { path: 'decisionSource', type: 'string', optional: true },
+            { path: 'executionState', type: 'string', optional: true },
+            { path: 'generation', type: 'number', optional: true },
+            { path: 'currentGeneration', type: 'number', optional: true },
             { path: 'targetChannel', type: 'string' },
             { path: 'targetChannelId', type: 'string' },
             { path: 'fireTime', type: 'number', optional: true },

package/dist/core/handoff/runtime.js

@@ -266,8 +266,8 @@ export class HandoffRuntime {
             }
         }
     }
-    buildPromptItem(message) {
-        return this.buildPromptItems(message)[0] ?? null;
+    buildPromptItem(message, fallbackPeerRole) {
+        return this.buildPromptItems(message, fallbackPeerRole)[0] ?? null;
     }
     isDiscardedDelivery(message) {
         const delivery = message.handoffDelivery;
@@ -277,7 +277,7 @@ export class HandoffRuntime {
         const ids = delivery.handoffIds?.length ? delivery.handoffIds : [delivery.handoffId];
         return ids.length > 0 && ids.every(handoffId => this.store.get(selfAid, handoffId)?.state === 'discarded');
     }
-    buildPromptItems(message) {
+    buildPromptItems(message, fallbackPeerRole) {
         const delivery = message.handoffDelivery;
         const selfAid = message.selfAID;
         if (!delivery || !selfAid)
@@ -310,8 +310,18 @@ export class HandoffRuntime {
                     peerId: message.peerId,
                     peerName: message.peerName,
                     peerType: message.peerType,
+                    peerRole: message.batchRole ?? message.resolvedIdentity?.role ?? fallbackPeerRole,
+                    sameDevice: message.sameDevice,
+                    sameNetwork: message.sameNetwork,
+                    sameEgressIp: message.sameEgressIp,
+                    encrypted: message.encrypted,
                     content: message.content,
                     timestamp: message.timestamp,
+                    receivedAt: message.receivedAt,
+                    gatewaySeq: message.gatewaySeq,
+                    images: message.images,
+                    mentions: message.mentions,
+                    mentionAids: message.mentionAids,
                     causation: message.causation,
                     handoff: {
                         kind: 'response_to_origin',
@@ -348,8 +358,18 @@ export class HandoffRuntime {
                 peerId: message.peerId,
                 peerName: message.peerName,
                 peerType: message.peerType,
+                peerRole: message.batchRole ?? message.resolvedIdentity?.role ?? fallbackPeerRole,
+                sameDevice: message.sameDevice,
+                sameNetwork: message.sameNetwork,
+                sameEgressIp: message.sameEgressIp,
+                encrypted: message.encrypted,
                 content: message.content,
                 timestamp: message.timestamp,
+                receivedAt: message.receivedAt,
+                gatewaySeq: message.gatewaySeq,
+                images: message.images,
+                mentions: message.mentions,
+                mentionAids: message.mentionAids,
                 causation: message.causation,
                 handoff: {
                     kind: 'request_to_target',

package/dist/core/message/im-renderer.js

@@ -1,5 +1,5 @@
 import { logger } from '../../utils/logger.js';
-import { summarizeToolInput } from '../../utils/tool-summary.js';
+import { summarizeToolInput, toolInputForDisplay } from '../../utils/tool-summary.js';
 import { getErrorMessage, isContextTooLongText } from '../../utils/error-utils.js';
 import { DEFAULT_FLUSH_DELAY_MS } from '../../types.js';
 export class IMRenderer {
@@ -34,6 +34,9 @@ export class IMRenderer {
             const correlatedEvent = event.type === 'tool_use' || event.type === 'tool_result'
                 ? { ...event, correlationId: event.correlationId ?? event.callId }
                 : event;
+            const permissionMode = typeof this.opts.permissionMode === 'function'
+                ? this.opts.permissionMode()
+                : this.opts.permissionMode;
             logger.event({
                 source: 'runner',
                 taskId: this.opts.envelope.taskId,
@@ -41,6 +44,7 @@ export class IMRenderer {
                 channelId: this.opts.envelope.channelId,
                 agentAid: this.opts.agentAid,
                 agentName: this.opts.envelope.agentName,
+                ...(permissionMode ? { permissionMode } : {}),
                 ...(correlatedEvent.type === 'tool_use' || correlatedEvent.type === 'tool_result'
                     ? { correlationId: correlatedEvent.correlationId, toolName: correlatedEvent.name }
                     : {}),
@@ -184,7 +188,7 @@ export class IMRenderer {
             kind: 'tool_call',
             call_id: callId || this.synthCallId(),
             name,
-            arguments: input,
+            arguments: toolInputForDisplay(name, input),
             text: descText,
         });
         this.messageTimestamps.push(Date.now());
@@ -568,7 +572,7 @@ export class IMRenderer {
                     text: desc,
                 };
                 if (event.input !== undefined)
-                    item.arguments = event.input;
+                    item.arguments = toolInputForDisplay(event.name, event.input);
                 return item;
             }
             case 'tool_result':

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

@@ -101,6 +101,8 @@ export class MessageBridge {
     processOwnersProvider;
     debouncers = new Map();
     defaultDebounce;
+    /** Serializes session selection/renewal with inbound log admission per route. */
+    admissionLocks = new Map();
     agentRegistry;
     bootstrapService;
     menuDeduper = new MenuRequestDeduper();
@@ -724,6 +726,7 @@ export class MessageBridge {
     register(channelName, onMessage, sendReply, adapter, channelType) {
         const effectiveChannelType = channelType || channelName;
         onMessage(async (msg) => {
+            let releaseAdmission;
             let releaseSessionIngress;
             const releaseIngress = () => {
                 releaseSessionIngress?.();
@@ -754,6 +757,12 @@ export class MessageBridge {
                 const conversationId = chatType === 'group' ? (msg.groupId || msg.channelId) : msg.peerId;
                 const selfAid = msg.selfAID || owningAgent?.aid || parsedChannelKey?.selfAID;
                 const resolvedChannelType = msg.channelType || parsedChannelKey?.type || effectiveChannelType;
+                const admissionRoute = [
+                    resolvedChannelType,
+                    selfAid || '',
+                    msg.channelId,
+                    msg.threadId || '',
+                ].join('#');
                 const trustedHandoffEcho = msg.source === 'handoff'
                     && resolvedChannelType === 'aun'
                     && !!selfAid
@@ -1034,6 +1043,12 @@ export class MessageBridge {
                     && !executionPermissionOverride
                     && !parseFullAccessCommand(cmdContent).matched
                     && this.cmdHandler.isCommand(cmdContent);
+                if (isCmd && /^\/new(?:\s|$)/i.test(cmdContent)) {
+                    // /new changes the active main-session boundary. Serialize it with
+                    // ordinary session admission so an in-flight renew cannot append or
+                    // enqueue against a superseded session after /new commits.
+                    releaseAdmission = await this.acquireAdmission(admissionRoute);
+                }
                 if (isCmd) {
                     logger.debug(`[MessageBridge] Command detected: "${cmdContent}", routing to handler`);
                     // 命令也要记录入方向 jsonl（不创建 session，直接用 chatDirPath 计算路径）
@@ -1115,6 +1130,11 @@ export class MessageBridge {
                 // 通道找不到归属时退回到 globalConfig（一般是测试场景）
                 const effectiveProjectPath = owningAgent?.projectPath
                     ?? this.defaultProjectPath;
+                // Session renewal and inbound history append form one admission
+                // 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);
                 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);
                 if (session.threadId && typeof this.messageQueue.reserveSessionIngress === 'function') {
@@ -1244,6 +1264,12 @@ export class MessageBridge {
                 }
                 if (!handoffCandidate)
                     appendMessageLog(inboundEntry.chatDir, inboundEntry.entry);
+                // The authoritative session choice is now paired with its first
+                // conversation record. Release before waiting for queue completion so
+                // later group messages can still exercise the normal interrupt/FIFO
+                // policy instead of being serialized behind the whole model turn.
+                releaseAdmission?.();
+                releaseAdmission = undefined;
                 // 6. ACK + debounce/enqueue
                 //    ACK 在到达时立即做（每条独立 ACK），不等合并
                 //    Interrupt 模式（单聊）→ 入队前 debounce 合并
@@ -1305,10 +1331,28 @@ export class MessageBridge {
                 logger.error(`[MessageBridge] Error in onMessage handler for ${channelName}:`, error);
             }
             finally {
+                releaseAdmission?.();
                 releaseIngress();
             }
         });
     }
+    async acquireAdmission(key) {
+        const previous = this.admissionLocks.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise(resolve => { release = resolve; });
+        const tail = previous.then(() => current);
+        this.admissionLocks.set(key, tail);
+        await previous;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            release();
+            if (this.admissionLocks.get(key) === tail)
+                this.admissionLocks.delete(key);
+        };
+    }
     // ── Menu Protocol ──
     extractTopicName(msg) {
         const raw = msg.topicName
@@ -1717,7 +1761,22 @@ export class MessageBridge {
         if (!this.cmdHandler.isCommand(content))
             return false;
         logger.info(`[${channel}] ${channelId}: ${content}${source === 'card-trigger' ? ' [card]' : ''}`);
-        const cmdResult = await this.cmdHandler.handle(content, channel, channelId, (_cid, text, opts) => sendReply(text), userId, threadId, chatType, source, messageId, selfAID, authSubject?.identity, authSubject, replyContext);
+        const adapter = this.processor.getChannelInfo?.(channel)?.adapter;
+        const cmdResult = await this.cmdHandler.handle(content, channel, channelId, async (_cid, text, opts, updatePayload) => {
+            if (updatePayload && adapter?.send) {
+                const envelope = buildEnvelope({
+                    taskId: `cmd-update-${randomBytes(5).toString('hex')}`,
+                    channel,
+                    channelId,
+                    agentName: this.agentRegistry?.resolveByChannel(channel)?.name ?? '<unknown>',
+                    chatmode: 'interactive',
+                    replyContext: opts ?? replyContext,
+                });
+                await adapter.send(envelope, updatePayload);
+                return;
+            }
+            await sendReply(text, opts, updatePayload);
+        }, userId, threadId, chatType, source, messageId, selfAID, authSubject?.identity, authSubject, replyContext);
         logger.debug(`[MessageBridge] handleCommand: result type=${typeof cmdResult}`);
         if (cmdResult === undefined)
             return false;
@@ -1735,7 +1794,6 @@ export class MessageBridge {
                 return true;
             }
             // 出站走 adapter.send 统一入口
-            const adapter = this.processor.getChannelInfo?.(channel)?.adapter;
             let responseSessionId;
             try {
                 const responseSession = threadId

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

@@ -233,6 +233,39 @@ export function messageLogPath(chatDir) {
 export function hasMessageLogOperation(chatDir, operationId) {
     return findMessageLogOperationMessageId(chatDir, operationId) !== undefined;
 }
+/** Find the newest completed outbound operation whose ID starts with prefix. */
+export function findLatestMessageLogOperation(chatDir, operationPrefix) {
+    const file = messageLogPath(chatDir);
+    if (!fs.existsSync(file))
+        return undefined;
+    let latest;
+    try {
+        for (const line of fs.readFileSync(file, 'utf-8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry?.dir !== 'out'
+                    || typeof entry.operationId !== 'string'
+                    || (!entry.operationId.startsWith(operationPrefix))
+                    || typeof entry.msgId !== 'string'
+                    || !entry.msgId)
+                    continue;
+                const ts = typeof entry.ts === 'number' && Number.isFinite(entry.ts) ? entry.ts : 0;
+                if (!latest || ts >= latest.ts) {
+                    latest = { messageId: entry.msgId, operationId: entry.operationId, ts };
+                }
+            }
+            catch {
+                // skip malformed message log lines
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return latest;
+}
 export function findMessageLogOperationMessageId(chatDir, operationId) {
     const file = messageLogPath(chatDir);
     if (!fs.existsSync(file))

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

@@ -88,6 +88,17 @@ export class MessageQueue {
                 this.markActiveTerminal(event.sessionId, event.reason || 'interrupted');
             }
         });
+        subscribe.call(eventBus, 'task:started', event => {
+            if (!('sessionId' in event) || !event.sessionId)
+                return;
+            const taskEvent = event;
+            for (const [queueKey, state] of this.activeStates) {
+                if (this.matchesSession(queueKey, taskEvent.sessionId)) {
+                    state.taskId = taskEvent.taskId;
+                    state.generation = taskEvent.generation;
+                }
+            }
+        });
         subscribe.call(eventBus, 'task:completed', event => {
             if ('sessionId' in event && event.sessionId)
                 this.markActiveTerminal(event.sessionId, 'completed');
@@ -623,6 +634,8 @@ export class MessageQueue {
                 sessionId: sessionKey,
                 reason: 'daemon_restart',
                 agentName,
+                taskId: this.activeStates.get(queueKey)?.taskId,
+                generation: this.activeStates.get(queueKey)?.generation,
                 causation: item.message.causation,
             });
             barriers.push(this.triggerInterrupt(queueKey, sessionKey, this.activeStates.get(queueKey)?.baseagent, agentName, 'daemon_restart'));
@@ -1022,6 +1035,8 @@ export class MessageQueue {
                         sessionId: sessionKey,
                         reason: 'new_message',
                         agentName: this.processingAgent.get(queueKey),
+                        taskId: this.activeStates.get(queueKey)?.taskId,
+                        generation: this.activeStates.get(queueKey)?.generation,
                         causation: this.activeBatches.get(queueKey)?.message.causation,
                     });
                     if (this.interruptCallback) {
@@ -1518,6 +1533,8 @@ export class MessageQueue {
                 sessionId: sessionKey,
                 reason: 'recalled',
                 agentName,
+                taskId: activeState?.taskId,
+                generation: activeState?.generation,
                 causation: active?.message.causation,
             });
             const barrier = this.interruptCallback
@@ -1766,6 +1783,8 @@ export class MessageQueue {
                     sessionId: sessionKey,
                     reason: 'stop',
                     agentName: name,
+                    taskId: this.activeStates.get(queueKey)?.taskId,
+                    generation: this.activeStates.get(queueKey)?.generation,
                     causation: this.activeBatches.get(queueKey)?.message.causation,
                 });
                 if (this.interruptCallback) {
@@ -2038,6 +2057,8 @@ export class MessageQueue {
             sessionId: sessionKey,
             reason: 'new_message',
             agentName: targetAgentName,
+            taskId: this.activeStates.get(targetQueueKey)?.taskId,
+            generation: this.activeStates.get(targetQueueKey)?.generation,
             causation: this.activeBatches.get(targetQueueKey)?.message.causation,
         });
         if (this.interruptCallback) {