evolcore 0.0.28 → 0.0.29

package/dist/core/message/auto-mention-gate.js

@@ -0,0 +1,454 @@
+import path from 'path';
+import { readGroupHistoryContext } from '../../aun/group/history.js';
+import { getPackageRoot } from '../../paths.js';
+import { createErrorCapturingReader, fileCache } from '../daemon-file-cache.js';
+import { logger } from '../../utils/logger.js';
+const MAX_HISTORY_MESSAGES = 20;
+const MAX_HISTORY_MESSAGE_CHARS = 800;
+const MAX_STATE_CONTENT_CHARS = 16_000;
+const HISTORY_HEAD_COUNT = 5;
+const HISTORY_TAIL_COUNT = 15;
+const ADMISSION_GRACE_MS = 5_000;
+const DEFAULT_QUIET_WINDOW_MS = 3_000;
+function parseExecutionPolicyTemplate(source) {
+    const sections = new Map();
+    const matches = [...source.matchAll(/^##[ \t]+([^\r\n]+)\r?$/gmu)];
+    for (const [index, match] of matches.entries()) {
+        const name = match[1].trim();
+        if (sections.has(name))
+            throw new Error(`Duplicate attention prompt section: ${name}`);
+        const start = (match.index ?? 0) + match[0].length;
+        const end = matches[index + 1]?.index ?? source.length;
+        sections.set(name, source.slice(start, end).trim());
+    }
+    const requiredSection = (name) => {
+        const content = sections.get(name);
+        if (!content)
+            throw new Error(`Missing or empty attention prompt section: ${name}`);
+        return content;
+    };
+    return {
+        execution_policy: {
+            type: 'choice',
+            instructions: requiredSection('Instructions'),
+            criteria: {
+                interrupt: requiredSection('Interrupt Criteria'),
+                defer: requiredSection('Defer Criteria'),
+                ignore: requiredSection('Ignore Criteria'),
+            },
+        },
+    };
+}
+function decisionFromHistory(entry) {
+    return entry.decision;
+}
+function lifecycleForHistory(entry, item, resolveMessageState) {
+    const decision = decisionFromHistory(entry);
+    if (decision === 'ignore')
+        return 'consumed';
+    if (!entry.message_id || !resolveMessageState)
+        return entry.lifecycle;
+    const state = resolveMessageState({
+        value: undefined,
+        selfAid: item.selfAid,
+        groupId: item.groupId,
+        threadId: item.threadId,
+        channelKey: item.channelKey,
+        sessionId: entry.session_id ?? item.sessionId,
+        projectPath: item.projectPath,
+        messageId: entry.message_id,
+        sender: entry.sender,
+        role: entry.role,
+        mentions: [],
+        content: entry.content,
+        receivedAt: Date.parse(entry.timestamp),
+    });
+    return state === 'queued' ? 'pending' : state === 'active' ? 'processing' : 'consumed';
+}
+function withLifecycle(entry, lifecycle) {
+    return { ...entry, lifecycle };
+}
+function dedupeMessages(messages) {
+    const seen = new Set();
+    return messages.filter(message => {
+        const key = message.message_id || `${message.timestamp}\n${message.sender}\n${message.content}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function chooseRecent(messages) {
+    const ordered = dedupeMessages(messages).sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+    if (ordered.length <= MAX_HISTORY_MESSAGES)
+        return ordered;
+    return [...ordered.slice(0, HISTORY_HEAD_COUNT), ...ordered.slice(-HISTORY_TAIL_COUNT)];
+}
+function compactHistoryContent(content, maxChars = MAX_HISTORY_MESSAGE_CHARS) {
+    if (content.length <= maxChars)
+        return content;
+    const marker = '[中间内容已省略]';
+    const paragraphs = content.split(/\n\s*\n/).map(value => value.trim()).filter(Boolean);
+    const headBudget = 600;
+    const tailBudget = Math.max(0, maxChars - headBudget - marker.length - 2);
+    if (paragraphs.length > 1) {
+        const head = [];
+        let headLength = 0;
+        for (const paragraph of paragraphs) {
+            if (headLength + paragraph.length + (head.length ? 2 : 0) > headBudget)
+                break;
+            head.push(paragraph);
+            headLength += paragraph.length + (head.length > 1 ? 2 : 0);
+        }
+        const tail = [];
+        let tailLength = 0;
+        for (let index = paragraphs.length - 1; index >= 0; index--) {
+            const paragraph = paragraphs[index];
+            if (tailLength + paragraph.length + (tail.length ? 2 : 0) > tailBudget)
+                break;
+            tail.unshift(paragraph);
+            tailLength += paragraph.length + (tail.length > 1 ? 2 : 0);
+        }
+        if (head.length > 0 && tail.length > 0 && head.join('\n\n') !== tail.join('\n\n')) {
+            const compacted = `${head.join('\n\n')}\n${marker}\n${tail.join('\n\n')}`;
+            if (compacted.length <= maxChars)
+                return compacted;
+        }
+    }
+    const head = Math.max(1, Math.floor((maxChars - marker.length) * 0.75));
+    const tail = Math.max(0, maxChars - marker.length - head);
+    return `${content.slice(0, head)}${marker}${tail ? content.slice(-tail) : ''}`.slice(0, maxChars);
+}
+function formatMessage(message, lifecycle, decision, compact = true) {
+    const sender = message.sender || '<unknown>';
+    const role = message.role || 'unknown';
+    const timestamp = 'timestamp' in message ? message.timestamp : '';
+    const body = compact ? compactHistoryContent(message.content) : message.content;
+    return `[lifecycle=${lifecycle} decision=${decision ?? 'none'} sender=${sender} role=${role} time=${timestamp}]\n${body}`;
+}
+function section(title, body) {
+    return `${title}\n${body || '（无）'}`;
+}
+function formatResources(resources) {
+    return [
+        section('当前群规则', resources.groupRules ?? ''),
+        section('当前 Agent 的个人资料', resources.personal ?? ''),
+        section('当前项目适用的项目指令', resources.projectInstructions ?? ''),
+    ].join('\n\n');
+}
+function buildStateContent(processingNow, recentMessages, pendingMessages, newMessages, resources) {
+    const fixed = [
+        `当前处理状态：${processingNow ? '当前 Agent 正在处理其他任务。' : '当前 Agent 当前没有正在处理的任务。'}`,
+        section('尚未完成处理的消息', pendingMessages.map(message => formatMessage(message, message.lifecycle, message.decision, false)).join('\n\n')),
+        section('本次新消息', newMessages.map(message => formatMessage(message, 'new', null, false)).join('\n\n')),
+        formatResources(resources),
+    ].join('\n\n');
+    const historyPrefix = '当前群会话历史对话\n';
+    const candidates = chooseRecent(recentMessages);
+    let kept = [...candidates];
+    const renderHistory = () => section(historyPrefix.trim(), kept.map(message => formatMessage(message, message.lifecycle, message.decision)).join('\n\n'));
+    while (`${fixed}\n\n${renderHistory()}`.length > MAX_STATE_CONTENT_CHARS && kept.length > 0) {
+        const removeIndex = kept.length > HISTORY_HEAD_COUNT ? HISTORY_HEAD_COUNT : 0;
+        kept.splice(removeIndex, 1);
+    }
+    const content = `${fixed}\n\n${renderHistory()}`;
+    if (content.length > MAX_STATE_CONTENT_CHARS) {
+        logger.warn(`[AutoMentionGate] required attention state exceeds ${MAX_STATE_CONTENT_CHARS} characters; preserving pending and new messages`);
+    }
+    return content;
+}
+export function parseAttentionDecision(text) {
+    return parseAttentionDecisionDetails(text).decision;
+}
+export function parseAttentionDecisionDetails(text) {
+    const parsed = JSON.parse(text.trim());
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('Invalid attention result');
+    const payload = parsed;
+    const answers = payload.answers;
+    const answer = answers && typeof answers === 'object' && !Array.isArray(answers)
+        ? answers.execution_policy
+        : undefined;
+    const rawAnswer = answer ?? payload.execution_policy ?? payload.decision;
+    const choice = typeof rawAnswer === 'string'
+        ? { choice: rawAnswer }
+        : rawAnswer && typeof rawAnswer === 'object' && !Array.isArray(rawAnswer)
+            ? rawAnswer
+            : undefined;
+    if (!choice)
+        throw new Error('Missing execution policy');
+    if (choice.type !== undefined && choice.type !== 'choice')
+        throw new Error('Invalid execution policy type');
+    const decision = choice.choice ?? choice.decision ?? rawAnswer;
+    if (decision !== 'interrupt' && decision !== 'defer' && decision !== 'ignore') {
+        throw new Error('Invalid attention decision');
+    }
+    const confidence = choice.confidence;
+    const probabilities = choice.probabilities;
+    const requestId = payload.request_id;
+    const sanitized = {};
+    if (probabilities !== undefined) {
+        if (!probabilities || typeof probabilities !== 'object' || Array.isArray(probabilities)) {
+            throw new Error('Invalid attention probabilities');
+        }
+        for (const [policy, value] of Object.entries(probabilities)) {
+            if (policy !== 'interrupt' && policy !== 'defer' && policy !== 'ignore') {
+                throw new Error('Unexpected attention probability');
+            }
+            if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {
+                throw new Error('Invalid attention probability');
+            }
+            sanitized[policy] = value;
+        }
+    }
+    if (confidence !== undefined && (typeof confidence !== 'number' || !Number.isFinite(confidence)
+        || confidence < 0 || confidence > 1))
+        throw new Error('Invalid attention confidence');
+    return {
+        decision,
+        ...(typeof confidence === 'number' ? { confidence } : {}),
+        ...(probabilities !== undefined ? { probabilities: sanitized } : {}),
+        ...(typeof requestId === 'string' && requestId ? { requestId: requestId.slice(0, 128) } : {}),
+    };
+}
+export class AutoMentionGate {
+    options;
+    states = new Map();
+    lastValidQuestions;
+    constructor(options) {
+        this.options = options;
+    }
+    loadExecutionPolicyQuestions() {
+        const templatePath = path.join(getPackageRoot(), 'kits', 'templates', 'decision', 'auto-mention.md');
+        const reader = createErrorCapturingReader();
+        try {
+            const questions = fileCache.get(templatePath, raw => {
+                if (raw === null) {
+                    throw new Error(`Failed to read attention prompt ${templatePath}: ${reader.lastError()}`, {
+                        cause: reader.lastErrorCause(),
+                    });
+                }
+                return parseExecutionPolicyTemplate(raw);
+            }, { policy: 'mtime', group: 'decision-prompts', read: reader.read });
+            this.lastValidQuestions = questions;
+            return questions;
+        }
+        catch (error) {
+            if (!this.lastValidQuestions)
+                throw error;
+            logger.warn(`[AutoMentionGate] prompt template unavailable, using last valid prompt: ${String(error)}`);
+            return this.lastValidQuestions;
+        }
+    }
+    background(item, excludeMessageIds = []) {
+        try {
+            return (this.options.readContext ?? readGroupHistoryContext)({
+                from: item.selfAid,
+                groupId: item.groupId,
+                thread: item.threadId || 'main',
+                channelKey: item.channelKey,
+                excludeMessageIds,
+                maxMessages: MAX_HISTORY_MESSAGES,
+            });
+        }
+        catch (error) {
+            logger.warn(`[AutoMentionGate] history unavailable, continuing without background: ${String(error)}`);
+            return [];
+        }
+    }
+    async offer(item) {
+        const key = JSON.stringify([item.selfAid, item.groupId, item.threadId || 'main']);
+        let state = this.states.get(key);
+        if (!state) {
+            state = { pending: [], admitted: [], processing: false };
+            this.states.set(key, state);
+        }
+        if (state.maintenanceTimer) {
+            clearTimeout(state.maintenanceTimer);
+            state.maintenanceTimer = undefined;
+        }
+        this.pruneAdmitted(state);
+        const currentState = state;
+        const result = new Promise(resolve => {
+            currentState.pending.push({ item, queuedAt: Date.now(), resolve });
+        });
+        this.schedule(key, currentState);
+        return result;
+    }
+    pruneAdmitted(state) {
+        const now = Date.now();
+        state.admitted = state.admitted.filter(entry => {
+            if (!entry.item.messageId || !this.options.resolveMessageState) {
+                return now - entry.admittedAt < ADMISSION_GRACE_MS;
+            }
+            const messageState = this.options.resolveMessageState(entry.item);
+            if (messageState === 'queued')
+                return true;
+            if (messageState === 'active')
+                return false;
+            // A decision is resolved before the bridge persists and enqueues the
+            // message. Keep the in-memory copy briefly so the next classification
+            // cannot lose it during that admission gap.
+            return now - entry.admittedAt < ADMISSION_GRACE_MS;
+        });
+    }
+    scheduleMaintenance(key, state) {
+        if (state.maintenanceTimer)
+            clearTimeout(state.maintenanceTimer);
+        state.maintenanceTimer = setTimeout(() => {
+            state.maintenanceTimer = undefined;
+            this.pruneAdmitted(state);
+            if (state.pending.length > 0 || state.processing)
+                return;
+            if (state.admitted.length > 0) {
+                this.scheduleMaintenance(key, state);
+            }
+            else if (this.states.get(key) === state) {
+                this.states.delete(key);
+            }
+        }, ADMISSION_GRACE_MS);
+    }
+    schedule(key, state) {
+        if (state.timer)
+            clearTimeout(state.timer);
+        state.timer = undefined;
+        if (state.processing || state.pending.length === 0)
+            return;
+        const latestPending = state.pending.at(-1);
+        const latestItem = latestPending.item;
+        const configuredQuietWindowMs = this.options.resolveQuietWindowMs?.(latestItem) ?? this.options.quietWindowMs;
+        const quietWindowMs = typeof configuredQuietWindowMs === 'number'
+            && Number.isFinite(configuredQuietWindowMs)
+            && configuredQuietWindowMs >= 0
+            ? configuredQuietWindowMs
+            : DEFAULT_QUIET_WINDOW_MS;
+        state.timer = setTimeout(() => {
+            state.timer = undefined;
+            void this.flush(key, state);
+        }, Math.max(0, latestPending.queuedAt + quietWindowMs - Date.now()));
+    }
+    async flush(key, state) {
+        if (state.processing || state.pending.length === 0)
+            return;
+        state.processing = true;
+        const batch = state.pending.splice(0, state.pending.length);
+        const items = batch.map(pending => pending.item);
+        const first = items[0];
+        const current = items.map(item => ({
+            source: 'current',
+            message_id: item.messageId ?? null,
+            sender: item.sender,
+            role: item.role,
+            mentions: item.mentions,
+            timestamp: new Date(item.receivedAt).toISOString(),
+            content: item.content,
+        }));
+        const history = this.readAllHistory(first, items.flatMap(item => item.messageId ? [item.messageId] : []));
+        const recent = history.map(entry => withLifecycle(entry, lifecycleForHistory(entry, first, this.options.resolveMessageState)));
+        const pendingHistory = recent.filter(entry => entry.lifecycle === 'pending');
+        const pendingItems = state.admitted.map(entry => this.asPendingMessage(entry.item, entry.decision));
+        const pendingMessages = dedupeMessages([...pendingHistory, ...pendingItems]);
+        let stateSnapshot;
+        let details = { decision: 'ignore' };
+        let source = 'fallback';
+        const processingNow = this.options.resolveProcessing?.(first) ?? !!first.mainSessionBusy;
+        try {
+            const inference = this.options.resolveInference(first);
+            if (!inference?.model)
+                throw new Error('Decision Model is not configured');
+            const resources = await this.options.resolveResources?.(first) ?? {};
+            const recentMessages = recent.filter(entry => entry.lifecycle !== 'pending');
+            const content = buildStateContent(processingNow, recentMessages, pendingMessages, current, resources);
+            stateSnapshot = {
+                processingNow,
+                recentMessages: chooseRecent(recentMessages),
+                pendingMessages,
+                newMessages: current,
+                resources,
+                content,
+            };
+            const questions = this.loadExecutionPolicyQuestions();
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 3000);
+            try {
+                const response = await Promise.race([
+                    inference.provider.completeDecision({
+                        model: inference.model,
+                        state: { content },
+                        questions,
+                        signal: controller.signal,
+                    }),
+                    new Promise((_, reject) => controller.signal.addEventListener('abort', () => reject(new Error('Attention inference timeout')), { once: true })),
+                ]);
+                details = parseAttentionDecisionDetails(response);
+                source = 'model';
+            }
+            finally {
+                clearTimeout(timeout);
+                controller.abort();
+            }
+        }
+        catch (error) {
+            details = { decision: 'ignore' };
+            source = 'fallback';
+            logger.warn(`[AutoMentionGate] decision model unavailable, falling back to mention-only: ${String(error)}`);
+        }
+        if (details.decision !== 'ignore') {
+            for (const item of items) {
+                if (!state.admitted.some(existing => existing.item.messageId && item.messageId
+                    ? existing.item.messageId === item.messageId
+                    : existing.item === item)) {
+                    state.admitted.push({ item, decision: details.decision, admittedAt: Date.now() });
+                }
+            }
+        }
+        batch.forEach((pending, index) => pending.resolve({
+            decision: details.decision,
+            source,
+            leader: index === batch.length - 1,
+            batch: items,
+            background: stateSnapshot?.recentMessages ?? chooseRecent(recent),
+            current,
+            state: stateSnapshot,
+            details,
+        }));
+        state.processing = false;
+        if (state.pending.length) {
+            this.schedule(key, state);
+        }
+        else {
+            this.scheduleMaintenance(key, state);
+        }
+    }
+    readAllHistory(item, excludeMessageIds) {
+        try {
+            return (this.options.readContext ?? readGroupHistoryContext)({
+                from: item.selfAid,
+                groupId: item.groupId,
+                thread: item.threadId || 'main',
+                channelKey: item.channelKey,
+                excludeMessageIds,
+                maxMessages: Number.MAX_SAFE_INTEGER,
+                maxChars: Number.MAX_SAFE_INTEGER,
+            });
+        }
+        catch (error) {
+            logger.warn(`[AutoMentionGate] history unavailable, continuing without background: ${String(error)}`);
+            return [];
+        }
+    }
+    asPendingMessage(item, decision) {
+        return {
+            source: 'background',
+            message_id: item.messageId ?? null,
+            session_id: item.sessionId,
+            sender: item.sender,
+            role: item.role,
+            timestamp: new Date(item.receivedAt).toISOString(),
+            content: item.content,
+            lifecycle: 'pending',
+            decision,
+            msg_type: 'text',
+        };
+    }
+}

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

@@ -3,7 +3,7 @@ import { summarizeToolInput, summarizeToolInputForDisplay, toolInputForDisplay }
 import { getErrorMessage, isContextTooLongText } from '../../utils/error-utils.js';
 import { tagErrorTextWithEvolcoreVersion } from '../../utils/evolcore-version.js';
 import { DEFAULT_FLUSH_DELAY_MS } from '../../types.js';
-import { classifyAunToolErrorCode } from '../permission/tool-error-code.js';
+import { classifyAunToolErrorCode, normalizeToolErrorClassification } from '../permission/tool-error-code.js';
 export class IMRenderer {
     opts;
     itemsQueue = [];
@@ -212,41 +212,67 @@ export class IMRenderer {
         this.scheduleFlush();
     }
     /** 添加工具调用 */
-    addToolCall(name, input, callId, descText, turn, outputTokens) {
+    addToolCall(name, input, callId, descText, turn, outputTokens, assistantUuid) {
         if (this.opts.envelope.chatmode === 'proactive')
             return;
         this.emitProgress('tool_call', outputTokens, turn, { toolName: name, callId });
-        if (this.suppressActivityItems())
-            return;
         const displayInput = toolInputForDisplay(name, input);
-        this.itemsQueue.push({
+        // If this is a shell tool executing an EC command, extract the subcommand
+        // for the ext.evolCommand hint so the frontend can render it distinctly.
+        let evolCommand;
+        if ((name === 'Bash' || name === 'Shell') && typeof input?.command === 'string') {
+            const m = input.command.trim().match(/^(?:ec|evolcore)\s+([a-z][a-z0-9-]*)/i);
+            if (m)
+                evolCommand = m[1].toLowerCase();
+        }
+        const item = {
             kind: 'tool_call',
             call_id: callId || this.synthCallId(),
             name,
             arguments: displayInput,
             text: displayInput !== input ? summarizeToolInput(name, displayInput || {}) : descText,
-        });
+            ...(evolCommand ? { evolCommand } : {}),
+            ...(assistantUuid ? { forkAnchor: { assistantMessageId: assistantUuid } } : {}),
+        };
+        this.recordActivity(item);
+        if (this.suppressActivityItems())
+            return;
+        this.itemsQueue.push(item);
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
     /** 添加工具结果 */
-    addToolResult(name, ok, result, error, callId, durationMs, descText, classification) {
+    addToolResult(name, ok, result, error, callId, durationMs, descText, classification, assistantUuid) {
         if (this.opts.envelope.chatmode === 'proactive')
             return;
         this.emitProgress('tool_result', undefined, undefined, { toolName: name, callId, ok, durationMs });
-        if (this.suppressActivityItems())
-            return;
-        this.itemsQueue.push({
+        const normalizedClassification = !ok
+            ? normalizeToolErrorClassification(classification ?? {})
+            : undefined;
+        const item = {
             kind: 'tool_result',
             call_id: callId || this.synthCallId(),
             name,
             ok,
             ...(result !== undefined && { result }),
             ...(error !== undefined && { error }),
-            ...(!ok && { error_code: classifyAunToolErrorCode(classification ?? {}) }),
+            ...(!ok && {
+                error_code: classifyAunToolErrorCode({
+                    ...(classification ?? {}),
+                    ...(normalizedClassification ?? {}),
+                }),
+                ...(normalizedClassification?.errorDetailCode
+                    ? { detail_code: normalizedClassification.errorDetailCode }
+                    : {}),
+            }),
             ...(durationMs !== undefined && { duration_ms: durationMs }),
             ...(descText !== undefined && { text: descText }),
-        });
+            ...(assistantUuid ? { forkAnchor: { assistantMessageId: assistantUuid } } : {}),
+        };
+        this.recordActivity(item);
+        if (this.suppressActivityItems())
+            return;
+        this.itemsQueue.push(item);
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
@@ -318,6 +344,7 @@ export class IMRenderer {
         if (this.suppressActivityItems())
             return;
         this.itemsQueue.push(item);
+        this.recordActivity(item);
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
@@ -345,7 +372,9 @@ export class IMRenderer {
         }
         if (this.suppressActivityItems() && !force)
             return;
-        this.itemsQueue.push({ kind: 'notice', text, severity, subtype });
+        const item = { kind: 'notice', text, severity, subtype };
+        this.itemsQueue.push(item);
+        this.recordActivity(item);
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
@@ -498,7 +527,12 @@ export class IMRenderer {
         this.itemsQueue = this.itemsQueue.filter(it => it.kind === 'text');
         if (this.suppressActivityItems())
             return;
-        const payload = { kind: 'activity.batch', items: nonThinking };
+        // If any tool_call item carries an EC subcommand hint, surface it on the batch payload ext.
+        const evolCommandItem = nonThinking.find(it => it.kind === 'tool_call' && !!it.evolCommand);
+        const evolCommand = evolCommandItem ? evolCommandItem.evolCommand : undefined;
+        const payload = evolCommand
+            ? { kind: 'activity.batch', items: nonThinking, ext: { evolCommand } }
+            : { kind: 'activity.batch', items: nonThinking };
         this.sentContent = true;
         try {
             await this.sendPayload(payload);
@@ -686,8 +720,25 @@ export class IMRenderer {
         this.emitProactiveItem(item);
     }
     /** proactive 模式逐条投影：单个 ThoughtItem 包成 activity.batch[1] 发出（fire-and-forget）。 */
+    recordActivity(item) {
+        try {
+            const result = this.opts.recordActivity?.(item);
+            if (result && typeof result.catch === 'function') {
+                result.catch(error => {
+                    logger.warn(`[IMRenderer] task activity record failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
+        }
+        catch (error) {
+            logger.warn(`[IMRenderer] task activity record failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     emitProactiveItem(item) {
-        const payload = { kind: 'activity.batch', items: [item] };
+        this.recordActivity(item);
+        const evolCommand = item.kind === 'tool_call' ? item.evolCommand : undefined;
+        const payload = evolCommand
+            ? { kind: 'activity.batch', items: [item], ext: { evolCommand } }
+            : { kind: 'activity.batch', items: [item] };
         this.opts.send(payload).catch(err => {
             logger.debug(`[IMRenderer] proactive send failed: ${err.message}`);
         });
@@ -712,12 +763,14 @@ export class IMRenderer {
             }
             case 'tool_result':
                 if (event.isError) {
+                    const classification = normalizeToolErrorClassification(event);
                     return {
                         kind: 'tool_result',
                         call_id: event.callId || this.synthCallId(),
                         name: event.name,
                         ok: false,
-                        error_code: classifyAunToolErrorCode(event),
+                        error_code: classifyAunToolErrorCode({ ...event, ...classification }),
+                        ...(classification.errorDetailCode ? { detail_code: classification.errorDetailCode } : {}),
                         error: event.error || (typeof event.result === 'string' ? event.result : '执行失败'),
                         ...(event.durationMs !== undefined && { duration_ms: event.durationMs }),
                     };