evolcore 0.0.25 → 0.0.27

package/dist/channels/aun.js

@@ -1,9 +1,11 @@
-import { E2EEError } from '@agentunion/fastaun';
+import { E2EEError, validateAIDFormat } from '@agentunion/fastaun';
+import { sanitizeMenuLogValue } from '../core/command/menu-protocol.js';
 import crypto from 'crypto';
 import { performance } from 'node:perf_hooks';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { logger, localTimestamp } from '../utils/logger.js';
 import { LogWriter } from '../utils/log-writer.js';
 import { middleOutputModePolicy, resolveShowActivities, showActivitiesPolicy } from '../core/channel-loader.js';
@@ -14,6 +16,7 @@ import { appendAidEvent } from '../utils/instance-registry.js';
 import { appendMessageLog, appendMessageLogStrict, buildOutboundEntry, buildInboundEntry, classifyAunPayloadForLog, findMessageLogOperationMessageId, hasMessageLogOperation } from '../core/message/message-log.js';
 import { createSendFileMarkerPattern } from '../core/message/file-markers.js';
 import { chatDirPath } from '../core/session/session-fs-store.js';
+import { readTopicLable } from '../core/session/session-mapper.js';
 import { appendHintAdd, appendHintRemove, parseInjectRequest } from '../core/message/pending-hints.js';
 import { appendAidLifecycle } from '../aun/aid/identity.js';
 import { enableFullGroupPullPagination, enableReliableMessageDelivery, getAidStore, loadClient, SLOT } from '../aun/aid/store.js';
@@ -25,18 +28,20 @@ import { isManagementRole } from '../config/builtin-roles.js';
 import { normalizeMentionMode } from '../config/mention-mode.js';
 import { getProcessStartTime } from '../utils/process-introspect.js';
 import * as outbox from '../aun/outbox.js';
-import { guessMime, formatSize } from '../utils/media-cache.js';
+import { formatSize } from '../utils/media-cache.js';
 import { formatPeerKey, PeerIdentityCache } from '../core/relation/peer-identity.js';
 import { isHClassPath } from '../core/permission/protected-paths.js';
 import { consumeAunCausation, registerAunCausation } from '../core/causation/aun-association.js';
 import { deriveCausation, normalizeCausation } from '../core/causation/context.js';
 import { recordCausationSpan } from '../core/causation/audit.js';
-import { refreshAgentDisplayName, resolveAgentDisplayName } from '../aun/aid/agentmd.js';
+import { invalidateAgentDisplayName, refreshAgentDisplayName, resolveAgentDisplayName } from '../aun/aid/agentmd.js';
+import { buildControlAgentName, ensureControlAgentMd } from '../aun/aid/control-aid.js';
 import { readInstalledEvolcoreVersion } from '../utils/evolcore-version.js';
+import { ManagedMenuClient, menuSenderDeviceId, menuTransportParams, } from '../aun/menu/index.js';
 import { toolInputForDisplay } from '../utils/tool-summary.js';
-import { bindPostBootstrapWelcomeOutboxSession, hasPendingPostBootstrapWelcomeOutbox, pendingPostBootstrapWelcomeOwners, isPostBootstrapWelcomeOperationId, findPostBootstrapWelcomeOutbox, bootstrapInitialMessageOperationPrefix, postBootstrapWelcomeOperationId, preparePostBootstrapWelcomeOutbox, } from '../core/bootstrap-messages.js';
+import { bindPostBootstrapWelcomeOutboxSession, hasPendingPostBootstrapWelcomeOutbox, pendingPostBootstrapWelcomeOwners, isPostBootstrapWelcomeOperationId, findPostBootstrapWelcomeOutbox, bootstrapInitialMessageOperationPrefix, postBootstrapWelcomeOperationId, preparePostBootstrapWelcomeOutbox, postBootstrapWelcomeStatus, } from '../core/bootstrap-messages.js';
 import { hasMentionAll, mentionEntryAids, mentionEntryTargets, } from '../core/message/mention-schema.js';
-import { normalizeAunMentionEntries, } from '../aun/msg/mention-schema.js';
+import { aunOutboundAttention, normalizeAunMentionEntries, parseAunAttention, withAunAttention, } from '../aun/msg/mention-schema.js';
 import { isDeliveryTarget, sameDeliveryTarget } from '../core/message/message-utils.js';
 import { sentReceipt, suppressedReceipt } from '../core/message/send-receipt.js';
 export const AUN_HANDOFF_MARKER_FIELD = '_evolcore_handoff_id';
@@ -49,9 +54,148 @@ const OBSERVER_GROUP_MEMBERS_TTL_MS = 60_000;
 const OBSERVER_GROUP_MEMBERS_PAGE_SIZE = 200;
 const OBSERVER_GROUP_MEMBERS_MAX_PAGES = 100;
 const AUN_SEND_LOG_TEXT_MAX_LENGTH = 60;
+const AUN_MAX_PAYLOAD_SIZE = 512 * 1024;
+const AUN_MAX_FIELD_SIZE = 256 * 1024;
+const AUN_MIN_FIELD_SIZE = 1024;
+function jsonUtf8Size(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf8');
+}
+function truncatedString(original, originalSize, maxJsonBytes) {
+    const fallback = '[输出已截断]';
+    if (jsonUtf8Size(fallback) > maxJsonBytes)
+        return fallback;
+    const candidate = (prefix) => (`${prefix}\n\n[截断：原始输出 ${formatSize(originalSize)}，仅显示前 ${formatSize(Buffer.byteLength(prefix, 'utf8'))}]`);
+    let low = 0;
+    let high = original.length;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (jsonUtf8Size(candidate(original.slice(0, middle))) <= maxJsonBytes)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return candidate(original.slice(0, low));
+}
+function collectAunPayloadStrings(value, path, entries) {
+    if (!value || typeof value !== 'object')
+        return;
+    for (const key of Object.keys(value)) {
+        const child = value[key];
+        const childPath = path ? `${path}.${key}` : key;
+        if (typeof child === 'string') {
+            entries.push({
+                parent: value,
+                key,
+                path: childPath,
+                original: child,
+                originalSize: Buffer.byteLength(child, 'utf8'),
+            });
+        }
+        else if (child && typeof child === 'object') {
+            collectAunPayloadStrings(child, childPath, entries);
+        }
+    }
+}
+/** Enforce the AUN payload budget using final JSON/UTF-8 size, including escaping. */
+export function truncateAunPayloadIfNeeded(payload, maxPayloadBytes = AUN_MAX_PAYLOAD_SIZE, maxFieldBytes = AUN_MAX_FIELD_SIZE) {
+    const originalSize = jsonUtf8Size(payload);
+    if (originalSize <= maxPayloadBytes) {
+        return { payload, originalSize, finalSize: originalSize, truncatedFields: [], dropped: false };
+    }
+    const truncated = JSON.parse(JSON.stringify(payload));
+    const entries = [];
+    collectAunPayloadStrings(truncated, '', entries);
+    const changed = new Map();
+    const applyLimit = (entry, targetBytes) => {
+        const current = entry.parent[entry.key];
+        const currentSize = typeof current === 'string' ? jsonUtf8Size(current) : 0;
+        const next = truncatedString(entry.original, entry.originalSize, targetBytes);
+        const nextSize = jsonUtf8Size(next);
+        if (typeof current !== 'string' || nextSize >= currentSize)
+            return false;
+        entry.parent[entry.key] = next;
+        entry.parent[`${String(entry.key)}_truncated`] = true;
+        changed.set(entry.path, { originalSize: entry.originalSize, finalSize: nextSize });
+        return true;
+    };
+    // First cap any individual string by its serialized contribution. This
+    // catches escaped JSON/log output whose raw string is deceptively small.
+    for (const entry of entries) {
+        if (jsonUtf8Size(entry.parent[entry.key]) > maxFieldBytes) {
+            applyLimit(entry, Math.floor(maxFieldBytes / 4));
+        }
+    }
+    let finalSize = jsonUtf8Size(truncated);
+    let guard = 0;
+    while (finalSize > maxPayloadBytes && guard++ < entries.length * 16 + 16) {
+        const candidates = entries
+            .map(entry => ({ entry, size: jsonUtf8Size(entry.parent[entry.key]) }))
+            .filter(item => item.size > jsonUtf8Size('[输出已截断]') + AUN_MIN_FIELD_SIZE)
+            .sort((a, b) => b.size - a.size);
+        const largest = candidates[0];
+        if (!largest)
+            break;
+        if (!applyLimit(largest.entry, Math.max(AUN_MIN_FIELD_SIZE, Math.floor(largest.size / 2))))
+            break;
+        finalSize = jsonUtf8Size(truncated);
+    }
+    const truncatedFields = [...changed.entries()].map(([path, sizes]) => ({ path, ...sizes }));
+    return {
+        payload: truncated,
+        originalSize,
+        finalSize,
+        truncatedFields,
+        dropped: finalSize > maxPayloadBytes,
+    };
+}
 export function formatAunSendLogText(text) {
     return text.replace(/\s+/gu, ' ').trim().slice(0, AUN_SEND_LOG_TEXT_MAX_LENGTH);
 }
+/**
+ * Echo trace 行的墙钟前缀。
+ *
+ * 格式必须保持 `HH:MM:SS.mmm` 且毫秒后紧跟空格——Evol App 的
+ * `evol/lib/utils/echo_utils.dart` 用 `^(\d{2}):(\d{2}):(\d{2})\.(\d{3})\s` 匹配这一段，
+ * 在毫秒和空格之间插任何东西（比如时区偏移）都会让旧版 App 静默失配、不再显示 RTT。
+ * 时区信息改由行尾的 {@link echoTraceOriginLabel} 提供，前缀一字不动，两端发版顺序因此解耦。
+ */
+export function echoTraceClock(now = Date.now()) {
+    const d = new Date(now);
+    const pad = (n, width = 2) => String(n).padStart(width, '0');
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+}
+/**
+ * Echo trace 行尾的权威时间标记：`epoch=<ms> tz=<±HH:MM>`。
+ *
+ * 前缀的墙钟没有日期也没有时区，消费方只能按自己的本地时区解析，两端 TZ 不一致时算出的
+ * RTT 会整小时偏移（UTC 对 Asia/Shanghai 就是 +28800000ms），跨午夜还会得到负值。
+ * `epoch` 是绝对值，消费方应当用它相减算延迟；`tz` 仅供人工核对墙钟，不参与计算。
+ */
+export function echoTraceOriginLabel(now = Date.now()) {
+    const d = new Date(now);
+    const pad = (n, width = 2) => String(n).padStart(width, '0');
+    const offsetMinutes = -d.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? '+' : '-';
+    const absOffset = Math.abs(offsetMinutes);
+    return ` epoch=${now} tz=${sign}${pad(Math.floor(absOffset / 60))}:${pad(absOffset % 60)}`;
+}
+/**
+ * 入站腿延迟（对端/网关发出 → 本进程收到）。
+ *
+ * `created_at` 由对端或网关打戳，因此结果含对端时钟漂移，只能当估算值——标签用
+ * `inbound_est` 而非 `inbound` 就是为了让消费方知道这点。负值说明对端时钟快于本机，
+ * 照实输出而不夹到 0：那本身就是有用的时钟偏移信号。
+ */
+export function echoInboundLegLabel(createdAt, receivedAt) {
+    if (typeof createdAt !== 'number' || !Number.isFinite(createdAt) || createdAt <= 0)
+        return '';
+    // 网关历史上有按秒打戳的实现，按量级归一到毫秒。
+    const createdMs = createdAt < 1e12 ? createdAt * 1000 : createdAt;
+    const delta = receivedAt - createdMs;
+    if (!Number.isFinite(delta))
+        return '';
+    return ` inbound_est=${Math.round(delta)}ms`;
+}
 function attachmentDownloadHost(url) {
     try {
         return new URL(url).host || '<unknown>';
@@ -201,7 +345,7 @@ export function buildAunFilePayload(params) {
         payload.name = params.filename;
         payload.content_type = params.contentType;
     }
-    return payload;
+    return withAunAttention(payload, params.context?.attention);
 }
 const AUN_PERMANENT_ERROR_CODES = new Set([
     400, 401, 403, 404,
@@ -431,6 +575,8 @@ export function aunOptsToInbound(opts, channel, channelType) {
         content: opts.content,
         chatType: opts.chatType || 'private',
         peerId: opts.peerId || '',
+        peerDeviceId: opts.peerDeviceId,
+        peerSlotId: opts.peerSlotId,
         peerName: opts.peerName,
         peerType: opts.peerType,
         sameDevice: opts.sameDevice,
@@ -473,22 +619,8 @@ function verifiedProtectedHeaders(msg, env) {
     }
     return undefined;
 }
-function redactMenuTokensForTrace(value, seen = new WeakSet()) {
-    if (!value || typeof value !== 'object')
-        return value;
-    if (seen.has(value))
-        return '[Circular]';
-    seen.add(value);
-    if (Array.isArray(value))
-        return value.map(item => redactMenuTokensForTrace(item, seen));
-    const redacted = {};
-    for (const [key, item] of Object.entries(value)) {
-        const normalizedKey = key.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/-/g, '_').toLowerCase();
-        redacted[key] = /^(?:menu|ecweb)_token$/.test(normalizedKey)
-            ? '[REDACTED]'
-            : redactMenuTokensForTrace(item, seen);
-    }
-    return redacted;
+export function redactMenuTokensForTrace(value) {
+    return sanitizeMenuLogValue(value);
 }
 function payloadTypeForObserver(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -502,9 +634,26 @@ function payloadTypeForObserver(value) {
     const type = payload.type;
     return typeof type === 'string' ? type : undefined;
 }
+function errorCodeForLog(error) {
+    if (!error || typeof error !== 'object')
+        return '';
+    const value = error;
+    return typeof value.code === 'string' || typeof value.code === 'number' ? String(value.code) : '';
+}
 export class AUNChannel {
     config;
+    managedMenuClient = new ManagedMenuClient(params => {
+        if (!this.connected || !this.client)
+            return Promise.reject(new Error('AUN channel is not connected'));
+        return this.callAndTrace('message.send', params);
+    });
+    requestRemoteMenu(options) {
+        if (options.fromAid !== (this._aid || this.config.aid))
+            throw new Error('Menu sender does not match channel identity');
+        return this.managedMenuClient.request(options);
+    }
     client = null;
+    localSenderInstallation;
     store = null;
     /** 实际连接的网关 URL（来自 authenticate() 返回值 / connection.state 事件），替代旧 (client as any)._gatewayUrl。 */
     gatewayUrl = '';
@@ -515,6 +664,10 @@ export class AUNChannel {
     traceWriter = null;
     eventBus = null;
     queuedHandler = null;
+    groupInviteHandler;
+    groupInviteConnectedHandler;
+    groupInviteDeliveryGate;
+    groupInviteDelivered;
     pendingEchoMessages = new Map();
     isEchoSending = false;
     agentDir;
@@ -562,46 +715,89 @@ export class AUNChannel {
      * 统一的 RPC 调用包装：自动记录 OUT 发送、.ok 结果、.error 错误（含 trace + daemon.log 失败日志）。
      * 所有 client.call() 都应通过此方法调用，保证 aun-trace 里每个 OUT 调用都有"发+收/错"成对记录。
      */
-    callClient(method, params) {
-        return this.withOutboundSendGate(method, () => (this.client.call(method, params).then(value => value)));
+    callClient(method, params, lane = 'normal', onStart) {
+        params = menuTransportParams(method, params);
+        return this.withOutboundSendGate(method, () => (this.client.call(method, params).then(value => value)), lane, onStart);
     }
-    withOutboundSendGate(method, run) {
-        if (!AUNChannel.OUTBOUND_SEND_METHODS.has(method))
+    withOutboundSendGate(method, run, lane = 'normal', onStart) {
+        if (!AUNChannel.OUTBOUND_SEND_METHODS.has(method)) {
+            onStart?.();
             return run();
+        }
+        const queue = lane === 'observer' ? this.observerSendQueue : this.outboundSendQueue;
+        if (lane === 'observer' && queue.length >= AUNChannel.OBSERVER_SEND_QUEUE_MAX) {
+            this.noteObserverQueueDrop();
+            const error = Object.assign(new Error('observer send queue is full'), {
+                code: 'AUN_OBSERVER_QUEUE_FULL',
+            });
+            return Promise.reject(error);
+        }
         return new Promise((resolve, reject) => {
-            this.outboundSendQueue.push({
+            queue.push({
                 run: run,
                 resolve: resolve,
                 reject,
+                onStart,
             });
             this.pumpOutboundSendGate();
         });
     }
     pumpOutboundSendGate() {
-        while (this.outboundSendActive < AUNChannel.OUTBOUND_SEND_CONCURRENCY
-            && this.outboundSendQueue.length > 0) {
-            const job = this.outboundSendQueue.shift();
+        while (this.outboundSendActive + this.observerSendActive < AUNChannel.OUTBOUND_SEND_CONCURRENCY && this.outboundSendQueue.length > 0) {
+            this.startOutboundSendJob(this.outboundSendQueue.shift(), 'normal');
+        }
+        while (this.outboundSendActive + this.observerSendActive < AUNChannel.OUTBOUND_SEND_CONCURRENCY
+            && this.observerSendActive < AUNChannel.OBSERVER_SEND_CONCURRENCY
+            && this.outboundSendQueue.length === 0
+            && this.observerSendQueue.length > 0) {
+            this.startOutboundSendJob(this.observerSendQueue.shift(), 'observer');
+        }
+    }
+    clearQueuedObserverSends(reason) {
+        if (this.observerSendQueue.length === 0)
+            return;
+        const error = Object.assign(new Error(`observer send discarded while ${reason}`), {
+            code: 'AUN_OBSERVER_QUEUE_DROPPED',
+        });
+        const queued = this.observerSendQueue.splice(0);
+        for (const job of queued)
+            job.reject(error);
+        this.noteObserverQueueDrop(queued.length);
+    }
+    startOutboundSendJob(job, lane) {
+        if (lane === 'observer')
+            this.observerSendActive++;
+        else
             this.outboundSendActive++;
-            Promise.resolve()
-                .then(job.run)
-                .then(job.resolve, job.reject)
-                .finally(() => {
+        Promise.resolve()
+            .then(() => {
+            job.onStart?.();
+            return job.run();
+        })
+            .then(job.resolve, job.reject)
+            .finally(() => {
+            if (lane === 'observer')
+                this.observerSendActive--;
+            else
                 this.outboundSendActive--;
-                this.pumpOutboundSendGate();
-            });
-        }
+            this.pumpOutboundSendGate();
+        });
     }
     async callAndTrace(method, params, opts) {
         this.trace('OUT', method, params);
-        // RPC 往返计时：区分「网关慢」与「本地队列堵塞」。message.send/group.send 的
-        // duration 若普遍逼近 SDK 的 rpc 超时（默认 10s），说明发送管线已饱和或链路抖动，
-        // 是 /evolhelp 等命令「回复慢/无回复」的直接可观测信号。
+        // 计时同时覆盖排队和 SDK 往返；callStartedAt 让日志能区分「本地队列堵塞」
+        // 与「网关慢」。两者对 /evolhelp 等命令的回复延迟都有直接影响。
         const rpcStart = Date.now();
         // SLOW_RPC_WARN_MS 需明显低于 SDK 默认 10s 超时，以便在真正超时前提前告警。
         const SLOW_RPC_WARN_MS = 3000;
+        let callStartedAt = rpcStart;
         try {
-            const result = await this.callClient(method, params);
+            const result = await this.callClient(method, params, opts?.lane ?? 'normal', () => {
+                callStartedAt = Date.now();
+            });
             const durationMs = Date.now() - rpcStart;
+            const rpcDurationMs = Date.now() - callStartedAt;
+            const queueWaitMs = Math.max(0, callStartedAt - rpcStart);
             if (!opts?.silentOk) {
                 const r = result;
                 const snap = r && typeof r === 'object'
@@ -609,25 +805,66 @@ export class AUNChannel {
                     : { duration_ms: durationMs };
                 this.trace('OUT', `${method}.ok`, snap);
             }
-            if (durationMs >= SLOW_RPC_WARN_MS) {
-                logger.warn(`${this.logPrefix()} rpc ${method} SLOW: duration=${durationMs}ms (发送管线可能饱和或链路抖动)`);
-            }
+            if (durationMs >= SLOW_RPC_WARN_MS)
+                this.logRpcWarning('slow', method, params, durationMs, queueWaitMs, rpcDurationMs);
             return result;
         }
         catch (e) {
             const durationMs = Date.now() - rpcStart;
+            const queueWaitMs = Math.max(0, callStartedAt - rpcStart);
+            const rpcDurationMs = Math.max(0, Date.now() - callStartedAt);
             this.trace('OUT', `${method}.error`, {
                 error: e?.message ?? String(e),
                 code: e?.code,
                 name: e?.name,
                 duration_ms: durationMs,
             });
-            if (!opts?.silentError) {
-                logger.warn(`${this.logPrefix()} rpc ${method} failed after ${durationMs}ms: ${e?.name ?? ''}(${e?.code ?? ''}) ${e?.message ?? e}`);
+            if (!opts?.silentError && e?.code !== 'AUN_OBSERVER_QUEUE_FULL' && e?.code !== 'AUN_OBSERVER_QUEUE_DROPPED') {
+                this.logRpcWarning('failed', method, params, durationMs, queueWaitMs, rpcDurationMs, e);
             }
             throw e;
         }
     }
+    logRpcWarning(kind, method, params, durationMs, queueWaitMs, rpcDurationMs, error) {
+        const payloadType = payloadTypeForObserver(params) ?? 'unknown';
+        const code = kind === 'failed' ? errorCodeForLog(error) : '';
+        const key = `${kind}|${method}|${payloadType}`;
+        const now = Date.now();
+        const state = this.rpcWarningStates.get(key) ?? { lastWarnAt: 0, suppressed: 0, maxDurationMs: 0 };
+        state.maxDurationMs = Math.max(state.maxDurationMs, durationMs);
+        if (state.lastWarnAt > 0 && now - state.lastWarnAt < AUNChannel.RPC_WARN_INTERVAL_MS) {
+            state.suppressed++;
+            this.rpcWarningStates.set(key, state);
+            return;
+        }
+        const suppressed = state.suppressed;
+        const maxDurationMs = state.maxDurationMs;
+        state.lastWarnAt = now;
+        state.suppressed = 0;
+        state.maxDurationMs = 0;
+        this.rpcWarningStates.set(key, state);
+        const summary = suppressed > 0 ? ` suppressed=${suppressed} max_duration=${maxDurationMs}ms` : '';
+        if (kind === 'failed') {
+            const name = error instanceof Error ? error.name : '';
+            const message = error instanceof Error ? error.message : String(error ?? '');
+            const errorLabel = `${name}${code ? `(${code})` : ''} ${message}`.trim();
+            logger.warn(`${this.logPrefix()} rpc ${method} failed after ${durationMs}ms: ${errorLabel} queue_wait=${queueWaitMs}ms rpc=${rpcDurationMs}ms payload=${payloadType}${summary}`);
+            return;
+        }
+        logger.warn(`${this.logPrefix()} rpc ${method} SLOW: duration=${durationMs}ms queue_wait=${queueWaitMs}ms rpc=${rpcDurationMs}ms payload=${payloadType}${summary} (发送管线可能饱和或链路抖动)`);
+    }
+    observerQueueDropCount = 0;
+    observerQueueDropLastWarnAt = 0;
+    noteObserverQueueDrop(count = 1) {
+        this.observerQueueDropCount += count;
+        const now = Date.now();
+        if (now - this.observerQueueDropLastWarnAt < AUNChannel.RPC_WARN_INTERVAL_MS)
+            return;
+        const dropped = this.observerQueueDropCount;
+        this.observerQueueDropCount = 0;
+        this.observerQueueDropLastWarnAt = now;
+        logger.warn(`${this.logPrefix()} observer send queue full: dropped=${dropped} (observer telemetry is being sampled while the gateway is unavailable)`);
+    }
     /** Resolve the authenticated transport route for an ordinary outbound send.
      * The channel id is an address only; it is intentionally never used to infer
      * whether the address is a group.
@@ -689,11 +926,17 @@ export class AUNChannel {
             return;
         }
         const context = { delivery };
-        if (threadId)
+        if (typeof threadId === 'string')
             context.threadId = threadId;
         if (operatorId && delivery.chatType === 'group')
             context.peerId = operatorId;
-        void this.sendMessage(channelId, text, context).catch((err) => {
+        const payload = {
+            type: 'notice',
+            ...this.buildTaskPayloadBase({}, context),
+            text,
+            severity: 'info',
+        };
+        void this.sendReliableStructured(channelId, payload, context, text).catch((err) => {
             logger.error(`${this.logPrefix()} Failed to send card action error:`, err);
         });
     }
@@ -713,6 +956,12 @@ export class AUNChannel {
                     : typeof obj.card_message_id === 'string' ? obj.card_message_id : '';
                 const cardInfo = cardMsgId ? this.cardMessageIdMap.get(cardMsgId) : undefined;
                 const cardDelivery = cardInfo?.delivery ?? delivery;
+                const savedTopic = this.ownedCardTopics.get(cardMsgId);
+                // Keep the topic after the actionable mapping expires, including for
+                // older clients that omit thread_id in their callbacks.
+                const threadId = cardInfo?.replyContext?.threadId
+                    ?? (savedTopic?.channelId === channelId ? savedTopic?.threadId : undefined)
+                    ?? (typeof obj.thread_id === 'string' ? obj.thread_id : undefined);
                 if (cardInfo) {
                     // compose 按钮由新版客户端在卡片内采集输入；旧版客户端可继续从主编辑器
                     // 采集。两者最终都回传 action_card_reply{behavior:"compose", text}。
@@ -728,10 +977,6 @@ export class AUNChannel {
                     const actionValue = isComposeReply ? '_custom_input'
                         : typeof obj.value === 'string' ? obj.value
                             : typeof obj.action_value === 'string' ? obj.action_value : text;
-                    // Prefer the trusted context persisted with the card. A callback's
-                    // thread_id is client-controlled and may be absent or stale.
-                    const threadId = cardInfo?.replyContext?.threadId
-                        ?? (typeof obj.thread_id === 'string' ? obj.thread_id : undefined);
                     // 卡片点击者身份：只信认证信封（senderAid 参数，由调用方从 msg.from / msg.sender_aid 提取）。
                     // payload 自报字段（from / sender_aid / user_id）不可信，可被客户端伪造，不读取。
                     // 两类卡片共用：CommandCard → 伪入站消息的 peerId，ActionInteraction → operatorId。
@@ -774,9 +1019,11 @@ export class AUNChannel {
                                 peerName: typeof obj.label === 'string' ? obj.label : typeof obj.action_label === 'string' ? obj.action_label : undefined,
                                 messageId: `card-trigger-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
                                 threadId,
-                                replyContext: cardInfo?.replyContext ?? ((threadId || cardDelivery)
-                                    ? { ...(threadId ? { threadId } : {}), ...(cardDelivery ? { delivery: cardDelivery } : {}) }
-                                    : undefined),
+                                replyContext: {
+                                    ...(cardInfo.replyContext ?? {}),
+                                    ...(typeof threadId === 'string' ? { threadId } : {}),
+                                    ...(cardDelivery ? { delivery: cardDelivery } : {}),
+                                },
                                 source: 'card-trigger',
                             })).catch((err) => {
                                 logger.error(`${this.logPrefix()} CommandCard handler failed: action=${actionValue} mid=${cardMsgId}`, err);
@@ -887,9 +1134,9 @@ export class AUNChannel {
                     }
                 }
                 else if (this.ownedCardMsgIds.has(cardMsgId)) {
-                    // 本 agent 发出的卡片，但 entry 已过期（24h TTL）
+                    // 本 agent 发出的卡片，但 entry 已过期或被清理。
                     logger.debug(`${this.logPrefix()} action_card_reply expired: cardMsgId=${cardMsgId}`);
-                    this.notifyCardActionFailure(channelId, '⚠️ 卡片已失效，请重新发起', undefined, undefined, delivery);
+                    this.notifyCardActionFailure(channelId, '⚠️ 卡片已失效，请重新发起', senderAid, threadId, delivery);
                 }
                 else {
                     // 非本 agent 发出的卡片（broadcast 模式下其他 agent 的卡）→ 静默忽略
@@ -1136,14 +1383,14 @@ export class AUNChannel {
             return sanitized;
         return undefined;
     }
-    buildGroupReplyContext(threadId, senderAid, encrypted, messageId, chatmode, topicName, groupId) {
+    buildGroupReplyContext(threadId, senderAid, encrypted, messageId, chatmode, topicName, groupId, lable) {
         if (!groupId)
             throw new Error('buildGroupReplyContext requires groupId');
         const replyContext = {
             metadata: { encrypted, chatmode },
             delivery: { chatType: 'group', groupId },
         };
-        if (threadId)
+        if (typeof threadId === 'string')
             replyContext.threadId = threadId;
         replyContext.peerId = senderAid;
         if (messageId)
@@ -1154,20 +1401,24 @@ export class AUNChannel {
                 replyContext.metadata = {};
             replyContext.metadata.topicName = topicName;
         }
+        if (lable && threadId)
+            replyContext.metadata.lable = lable;
         return replyContext;
     }
-    buildPrivateReplyContext(threadId, senderAid, encrypted, messageId, chatmode, topicName, refMessageId) {
+    buildPrivateReplyContext(threadId, senderAid, encrypted, messageId, chatmode, topicName, refMessageId, lable) {
         const replyContext = {
             metadata: { encrypted, chatmode, refMessageId },
             delivery: { chatType: 'private' },
             peerId: senderAid,
         };
-        if (threadId)
+        if (typeof threadId === 'string')
             replyContext.threadId = threadId;
         if (messageId)
             replyContext.replyToMessageId = messageId;
         if (topicName && threadId)
             replyContext.metadata.topicName = topicName;
+        if (lable && threadId)
+            replyContext.metadata.lable = lable;
         return replyContext;
     }
     claimInboundMessage(kind, messageId, seq) {
@@ -1284,6 +1535,7 @@ export class AUNChannel {
     invalidInboundEnvelopeLastLogAt = 0;
     groupNameCache = new Map(); // groupId → 群显示名（进程内缓存，群名极少变）
     peerInfoCache = new Map();
+    peerInfoRevision = 0;
     messageSeqMap = new Map(); // messageId → seq (for ack/diagnostics)
     sentCount = new Map(); // channelId → 已发消息计数（用于判断最终回复）
     peerE2ee = new Map();
@@ -1295,6 +1547,7 @@ export class AUNChannel {
     cardMessageIdMap = new Map();
     /** 本 agent 曾发出过的卡片 msgId（只增不删，用于区分"过期失效"vs"他人发的卡"） */
     ownedCardMsgIds = new Set();
+    ownedCardTopics = new Map();
     /** requestId → 已投递的卡片 message_id 集合（撤权/超时时撤回） */
     interactionCardMessageIds = new Map();
     /** 撤权可能先于 outbox 卡片投递完成；迟到卡片注册后立即撤回。 */
@@ -1304,7 +1557,7 @@ export class AUNChannel {
     groupSlashRequireMentionsResolver;
     static PROACTIVE_ALLOW_TYPES = new Set([
         'text', 'quote', 'image', 'video', 'voice', 'file', 'json',
-        'merge', 'link', 'location', 'personal_card',
+        'merge', 'link', 'location', 'personal_card', 'contact.request.response',
     ]);
     /** 观察者插话请求类型（owner → agent.AID）。详见 docs/observer-insert-design.md。 */
     static INJECT_REQUEST_TYPE = 'observer.inject';
@@ -1344,7 +1597,7 @@ export class AUNChannel {
     aidState;
     aidStatsCollector;
     outboxInFlight = new Set();
-    /** Shared gateway-facing send limit for replies, activity, observer and thought messages. */
+    /** Shared total gateway-facing send capacity; normal traffic has priority over observer telemetry. */
     static OUTBOUND_SEND_METHODS = new Set([
         'message.send',
         'group.send',
@@ -1352,8 +1605,14 @@ export class AUNChannel {
         'group.thought.put',
     ]);
     static OUTBOUND_SEND_CONCURRENCY = 4;
+    static OBSERVER_SEND_CONCURRENCY = 1;
+    static OBSERVER_SEND_QUEUE_MAX = 256;
+    static RPC_WARN_INTERVAL_MS = 60_000;
     outboundSendActive = 0;
     outboundSendQueue = [];
+    observerSendActive = 0;
+    observerSendQueue = [];
+    rpcWarningStates = new Map();
     constructor(config) {
         this.config = config;
         this.agentDir = agentDirPath(config.aid);
@@ -1391,6 +1650,44 @@ export class AUNChannel {
     getAid() {
         return this._aid ?? this.config.aid;
     }
+    setGroupInviteReviewHandlers(handlers) {
+        if (this.config.pureIdentity && handlers)
+            return;
+        this.groupInviteHandler = handlers?.onInvite;
+        this.groupInviteConnectedHandler = handlers?.onConnected;
+        this.groupInviteDeliveryGate = handlers?.canDeliver;
+        this.groupInviteDelivered = handlers?.onDelivered;
+    }
+    async getGroupInviteSummary(groupId) {
+        if (!this.client || !this.connected)
+            return {};
+        try {
+            const result = await this.callAndTrace('group.get_info', { group_id: groupId });
+            const group = result?.group ?? result;
+            return {
+                ...(typeof group?.name === 'string' ? { name: group.name.slice(0, 120) } : {}),
+                ...(typeof group?.description === 'string' ? { description: group.description.slice(0, 240) } : {}),
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    getGroupInviteDeliveryState(outboxId) {
+        return outbox.deliveryState(this.config.aid, outboxId);
+    }
+    async invalidateGroupInviteCard(interactionId, ownerAid, messageIds) {
+        const known = new Set(this.interactionCardMessageIds.get(interactionId) ?? []);
+        await this.invalidateInteraction(interactionId, 'group_invite_review');
+        // After a daemon restart only the review store knows the delivered cards.
+        for (const id of messageIds) {
+            if (!known.has(id))
+                await this.recallInteractionCard(id, ownerAid, { chatType: 'private' });
+        }
+    }
+    refreshGroupInviteMembership(groupId) {
+        this.invalidateObserverGroupMembers(groupId);
+    }
     /** 是否已连接（client 存在且认证完成）。 */
     isConnected() {
         return this.connected && this.client !== null;
@@ -1425,6 +1722,27 @@ export class AUNChannel {
             this.initInProgress = false;
         }
     }
+    /** Optional local compatibility code is never required by a clean checkout or npm install. */
+    async loadLocalSenderInstallation(client) {
+        this.localSenderInstallation = undefined;
+        const currentFile = fileURLToPath(import.meta.url);
+        const modulePath = path.join(path.dirname(currentFile), '..', 'aun', `sender-installation${path.extname(currentFile)}`);
+        if (!fs.existsSync(modulePath))
+            return;
+        try {
+            // Use a runtime URL so TypeScript can build when the local file is absent.
+            const extension = await import(pathToFileURL(modulePath).href);
+            if (typeof extension.enableAunSenderInstallation !== 'function'
+                || typeof extension.aunSenderInstallation !== 'function') {
+                throw new Error('Invalid local sender installation module');
+            }
+            extension.enableAunSenderInstallation(client);
+            this.localSenderInstallation = extension;
+        }
+        catch (error) {
+            logger.warn(`${this.logPrefix()} Optional local sender installation disabled: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     async _initClientInner() {
         this.observerGroupMembers.clear();
         for (const groupId of new Set([
@@ -1454,6 +1772,7 @@ export class AUNChannel {
             this.store = null;
         }
         this.connected = false;
+        this.clearQueuedObserverSends('client reinitialization');
         this.lastConnectionStateSignature = '';
         const aunPath = this.config.keystorePath || resolveRoot();
         const aidName = this.config.aid;
@@ -1473,11 +1792,39 @@ export class AUNChannel {
         const client = await loadClient(store, aidName);
         enableFullGroupPullPagination(client);
         enableReliableMessageDelivery(client);
+        await this.loadLocalSenderInstallation(client);
         this.client = client;
         // A reconnect replaces the SDK client. Late events from the retired
         // instance must not mutate the new instance's health or message state.
         const isCurrentClient = () => this.client === client;
         // Register event handlers before connecting
+        client.on('agentmd.changed', (data) => {
+            if (!isCurrentClient() || this.intentionalDisconnect || typeof data !== 'string')
+                return;
+            let aid;
+            try {
+                aid = validateAIDFormat(data);
+            }
+            catch {
+                return;
+            }
+            this.peerInfoRevision++;
+            this.peerInfoCache.delete(aid);
+            this.groupNameCache.delete(aid);
+            invalidateAgentDisplayName(aid);
+            PeerIdentityCache.invalidate('aun', aid, path.join(resolvePaths().agentsDir, this.config.aid));
+            this.trace('IN', 'agentmd.changed', { aid });
+            // Peer snapshots refresh lazily on the next lookup. The self name is
+            // held separately by this channel, so refresh it with the existing API.
+            if (aid === (this._aid || this.config.aid)) {
+                void refreshAgentDisplayName(aid).then(name => {
+                    if (!name || !isCurrentClient() || this.intentionalDisconnect)
+                        return;
+                    this._selfName = name;
+                    this.aidStatsCollector?.setSelfName(this.config.aid, name);
+                });
+            }
+        });
         client.on('message.received', async (data) => {
             if (!isCurrentClient())
                 return;
@@ -1523,6 +1870,9 @@ export class AUNChannel {
                 const inviteIds = Array.isArray(record.invite_ids) ? record.invite_ids : [];
                 this.trace('IN', 'group.invite_received', data);
                 logger.info(`${this.logPrefix()} Group invitation received: group=${groupId} pending=${inviteIds.length || 1}`);
+                void Promise.resolve(this.groupInviteHandler?.(data)).catch(error => {
+                    logger.warn(`${this.logPrefix()} Group invitation review dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
             });
         }
         // 0.5.10/0.5.11 local lifecycle events summarize SDK delivery and Pull
@@ -1562,18 +1912,7 @@ export class AUNChannel {
         client.on('message.recalled', (data) => {
             if (!isCurrentClient())
                 return;
-            this.trace('IN', 'message.recalled', data);
-            if (data && typeof data === 'object') {
-                const ids = data.message_ids;
-                if (Array.isArray(ids)) {
-                    for (const id of ids) {
-                        if (typeof id === 'string') {
-                            logger.info(`${this.logPrefix()} Message recalled: ${id}`);
-                            this.recallHandler?.(id, this._aid || this.config.aid);
-                        }
-                    }
-                }
-            }
+            this.handleMessageRecalled(data, client, isCurrentClient);
         });
         client.on('message.undecryptable', (data) => {
             if (!isCurrentClient())
@@ -1659,13 +1998,37 @@ export class AUNChannel {
             this._aid = this.client.aid ?? undefined;
             const deviceId = this.client._device_id ?? '';
             this._chatId = this._aid ? `${this._aid}:${deviceId}:` : '';
-            // pureIdentity（控制 AID）：无 agent.md，跳过自身 agent.md 拉取，省一次 404
-            this._selfName = this.config.pureIdentity ? undefined : this.loadSelfName(aidName);
+            // 控制 AID 也有标准 host agent.md。发布在后台执行，短暂的 Name
+            // Service/Gateway 故障不能把控制通道判定为连接失败。
+            if (this.config.pureIdentity) {
+                this._selfName = buildControlAgentName(aidName);
+                void ensureControlAgentMd(aidName, {
+                    store: this.store ?? undefined,
+                    aunPath,
+                    cacheRoot: resolveRoot(),
+                })
+                    .then(result => {
+                    this._selfName = result.name;
+                    if (this.aidStatsCollector)
+                        this.aidStatsCollector.setSelfName(this.config.aid, result.name);
+                    if (result.published)
+                        logger.info(`${this.logPrefix()} 控制 AID agent.md 已发布: ${result.name}`);
+                })
+                    .catch(error => logger.warn(`${this.logPrefix()} 控制 AID agent.md 补全失败（后台重试）: ${error instanceof Error ? error.message : String(error)}`));
+            }
+            else {
+                this._selfName = this.loadSelfName(aidName, aunPath);
+            }
             if (this._selfName && this.aidStatsCollector)
                 this.aidStatsCollector.setSelfName(this.config.aid, this._selfName);
             this.connected = true;
             this.connectedAt = Date.now();
             this.setAidStatus('connected', { lastConnectedAt: Date.now(), lastError: undefined, gatewayUrl: this.gatewayUrl });
+            if (!this.config.pureIdentity) {
+                void Promise.resolve(this.groupInviteConnectedHandler?.()).catch(error => {
+                    logger.warn(`${this.logPrefix()} Group invitation recovery failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
             // AUN seq_tracker is transport-scoped, while this channel's durable
             // dedup log is application-scoped.  A diagnostic consumer can advance
             // the former without the application having seen those messages.  On a
@@ -1723,7 +2086,7 @@ export class AUNChannel {
                 if (hasMessageLogOperation(chatDir, operationId)
                     || hasMessageLogOperation(chatDir, postBootstrapWelcomeOperationId(aidName)))
                     continue;
-                const prepared = outbox.findByDedupeKey(aidName, operationId);
+                const prepared = outbox.findByDedupeKey(aidName, operationId, { includeTerminal: true });
                 if (prepared && prepared.channelId === owner && isDeliveryTarget(prepared.delivery) && sameDeliveryTarget(prepared.delivery, delivery))
                     continue;
                 const ownerAidClean = owner.startsWith('@') ? owner.slice(1) : owner;
@@ -1759,7 +2122,7 @@ export class AUNChannel {
     }
     async sendPostBootstrapWelcome() {
         if (!await this.preparePostBootstrapWelcome())
-            return false;
+            throw new Error('Failed to persist post-bootstrap welcome');
         return this.reconcilePostBootstrapWelcome();
     }
     async hasPendingPostBootstrapWelcome() {
@@ -1777,6 +2140,8 @@ export class AUNChannel {
         const pull = client?._pullV2;
         if (typeof repair !== 'function' || typeof pull !== 'function')
             return;
+        if (this.inboundP2PCursorRepairTimer)
+            clearTimeout(this.inboundP2PCursorRepairTimer);
         const ns = `p2p:${this.config.aid}`;
         let appSeq = 0;
         for (const [key, value] of this.inboundSeenMessages) {
@@ -1789,7 +2154,8 @@ export class AUNChannel {
         }
         if (appSeq <= 0)
             return;
-        setTimeout(() => {
+        this.inboundP2PCursorRepairTimer = setTimeout(() => {
+            this.inboundP2PCursorRepairTimer = null;
             if (!isCurrentClient() || !this.connected)
                 return;
             const transportSeq = Number(tracker.getContiguousSeq?.(ns) ?? 0);
@@ -1807,6 +2173,24 @@ export class AUNChannel {
             }
         }, 250);
     }
+    inboundP2PCursorRepairTimer = null;
+    handleMessageRecalled(data, client, isCurrentClient) {
+        this.trace('IN', 'message.recalled', data);
+        if (data && typeof data === 'object') {
+            const ids = data.message_ids;
+            if (Array.isArray(ids)) {
+                for (const id of ids) {
+                    if (typeof id === 'string') {
+                        logger.info(`${this.logPrefix()} Message recalled: ${id}`);
+                        this.recallHandler?.(id, this._aid || this.config.aid);
+                    }
+                }
+            }
+        }
+        // A recall tombstone may arrive at a high transport sequence and advance
+        // the SDK cursor past messages that were never delivered to the app.
+        this.scheduleInboundP2PCursorRepair(client, isCurrentClient);
+    }
     pendingPostBootstrapWelcomeOwners() {
         return pendingPostBootstrapWelcomeOwners(this.config.aid);
     }
@@ -1822,25 +2206,35 @@ export class AUNChannel {
         const configuredAid = this.config.aid;
         const aid = configuredAid.startsWith('@') ? configuredAid.slice(1) : configuredAid;
         const entries = findPostBootstrapWelcomeOutbox(aid);
-        if (entries.length === 0)
-            return false;
         const agentConfig = loadAgent(aid);
+        const owners = agentConfig?.owners ?? [];
+        if (entries.length === 0)
+            return postBootstrapWelcomeStatus(aid, owners);
         if (!agentConfig || resolveAgentLifecycle(agentConfig) !== 'active') {
             logger.info(`${this.logPrefix()} Post-bootstrap welcome prepared; waiting for lifecycle=active`);
-            return true;
+            return postBootstrapWelcomeStatus(aid, owners);
         }
         if (!this.connected || !this.client)
-            return true;
+            return postBootstrapWelcomeStatus(aid, owners);
         for (const entry of entries) {
             if (!outbox.isDeliveryForChannel(entry.delivery, entry.channelId))
                 continue;
-            const sent = await this.withOutboxInFlight(entry, () => this.deliverTextEntry(entry), { status: 'retry', error: 'outbox send is already in flight' });
-            if (sent.status === 'sent')
-                this.removeDeliveredOutboxEntry(entry);
-            else if (sent.status === 'permanent')
-                this.markPermanentOutboxFailure(entry, sent);
+            try {
+                const sent = await this.withOutboxInFlight(entry, () => this.deliverTextEntry(entry), { status: 'retry', error: 'outbox send is already in flight' });
+                if (sent.status === 'sent')
+                    this.removeDeliveredOutboxEntry(entry);
+                else if (sent.status === 'permanent')
+                    this.markPermanentOutboxFailure(entry, sent);
+                else
+                    outbox.recordRetry(this.config.aid, entry, sent);
+            }
+            catch (error) {
+                // Lifecycle has already committed. Preserve its success and the
+                // durable operation even when local post-send bookkeeping fails.
+                logger.warn(`${this.logPrefix()} Welcome reconciliation failed: entry=${entry.id} error=${error}`);
+            }
         }
-        return true;
+        return postBootstrapWelcomeStatus(aid, owners);
     }
     // ── Event handlers ──────────────────────────────────────────
     /**
@@ -2115,6 +2509,15 @@ export class AUNChannel {
             return;
         const protectedHeaders = verifiedProtectedHeaders(msg, env);
         const payload = msg.payload ?? '';
+        if (this.managedMenuClient.accept(fromAid, payload, !!env.encrypted)) {
+            this.acknowledgeImmediately(messageId, seq);
+            return;
+        }
+        if (payloadTypeForObserver(msg) === 'observer.forward') {
+            this.acknowledgeImmediately(messageId, seq);
+            logger.debug(`${this.logPrefix()} P2P dropped observer.forward control envelope: mid=${messageId}`);
+            return;
+        }
         const mentions = this.parsePayloadMentionsOrReject(payload, 'p2p.inbound', messageId, seq);
         if (!mentions)
             return;
@@ -2174,7 +2577,7 @@ export class AUNChannel {
         const chatId = fromAid;
         // 解析对端身份（30天缓存）
         const selfAgentDir = path.join(resolvePaths().agentsDir, this.config.aid);
-        const peerIdentity = await PeerIdentityCache.resolve('aun', fromAid, selfAgentDir, this.store, false);
+        const peerIdentity = await PeerIdentityCache.resolve('aun', fromAid, selfAgentDir, this.store, false, this.config.keystorePath || resolveRoot());
         const shortAid = this.getShortAid(fromAid);
         const displayName = peerIdentity.name || shortAid;
         // 详细 dispatch 决策日志：记录消息为何被路由到 agent
@@ -2191,19 +2594,33 @@ export class AUNChannel {
         if (p2pPayloadType.startsWith('menu.')
             || p2pPayloadType === AUNChannel.CONTACT_REQUEST_QUERY_TYPE
             || p2pPayloadType === AUNChannel.CONTACT_REQUEST_SUBMIT_TYPE) {
+            const installation = p2pPayloadType.startsWith('menu.')
+                ? this.localSenderInstallation?.aunSenderInstallation(msg) : undefined;
+            const peerDeviceId = p2pPayloadType.startsWith('menu.')
+                ? menuSenderDeviceId(msg.sender_device_id) : undefined;
             this.acknowledgeImmediately(messageId, seq);
             this.appendInboundPayloadJsonl(chatId, fromAid, messageId, msgEncrypted, false, logDescriptor, threadId, receivedAt, seq);
             this.dispatchMessage({
                 channelId: chatId, userId: fromAid,
                 text: JSON.stringify(payload),
                 chatType: 'private', messageId, seq, receivedAt, receivedAtMono, gatewaySeq: seq,
+                peerDeviceId,
+                peerSlotId: installation?.slotId,
+                threadId,
                 peerName: displayName || undefined,
                 peerType: peerIdentity.type,
                 encrypted: msgEncrypted,
                 protectedHeaders,
                 mentions,
                 mentionAids: mentionEntryAids(mentions),
-                replyContext: this.buildPrivateReplyContext(threadId, fromAid, msgEncrypted, messageId),
+                replyContext: {
+                    ...this.buildPrivateReplyContext(threadId, fromAid, msgEncrypted, messageId),
+                    metadata: {
+                        ...this.buildPrivateReplyContext(threadId, fromAid, msgEncrypted, messageId).metadata,
+                        ...(protectedHeaders?.sdk_version ? { menuClientSdkVersion: protectedHeaders.sdk_version } : {}),
+                    },
+                    ...(peerDeviceId ? { toDeviceId: peerDeviceId } : {}),
+                },
                 msgType: logDescriptor.msgType,
                 payloadType: logDescriptor.payloadType,
                 payloadSummary: logDescriptor.payloadSummary,
@@ -2228,6 +2645,7 @@ export class AUNChannel {
                 channelId: chatId, userId: fromAid,
                 text: JSON.stringify(payload),
                 chatType: 'private', messageId, seq, receivedAt, gatewaySeq: seq,
+                threadId,
                 peerName: displayName || undefined,
                 peerType: peerIdentity.type,
                 encrypted: msgEncrypted,
@@ -2252,7 +2670,7 @@ export class AUNChannel {
         appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_in', aid: this.config.aid, from: fromAid, msgId: messageId, kind: 'text', len: finalText.length });
         const isSystemP2P = p2pPayloadType === 'event';
         this.aidStatsCollector?.recordInbound(this.config.aid, fromAid, Buffer.byteLength(finalText, 'utf-8'), finalText, isSystemP2P, msgEncrypted, msgChatmode, isSystemP2P ? 'notify' : 'send');
-        const replyContext = this.buildPrivateReplyContext(threadId, fromAid, msgEncrypted, messageId, msgChatmode, topicName, refMessageId);
+        const replyContext = this.buildPrivateReplyContext(threadId, fromAid, msgEncrypted, messageId, msgChatmode, topicName, refMessageId, readTopicLable(payload));
         this.dispatchMessage({
             channelId: chatId,
             userId: fromAid,
@@ -2260,6 +2678,7 @@ export class AUNChannel {
             chatType: 'private',
             messageId,
             receivedAt,
+            createdAt: typeof msg.created_at === 'number' ? msg.created_at : undefined,
             gatewaySeq: seq,
             causation,
             seq,
@@ -2297,6 +2716,12 @@ export class AUNChannel {
         const groupId = env.group_id ?? '';
         const senderAid = env.from ?? '';
         const payload = msg.payload ?? '';
+        const inboundType = (payload && typeof payload === 'object') ? payload.type : undefined;
+        if (inboundType === 'observer.forward') {
+            this.acknowledgeImmediately(messageId, seq);
+            logger.debug(`${this.logPrefix()} Group dropped observer.forward control envelope: mid=${messageId}`);
+            return;
+        }
         const payloadMentionEntries = this.parsePayloadMentionsOrReject(payload, 'group.inbound', messageId, seq);
         if (!payloadMentionEntries)
             return;
@@ -2307,7 +2732,6 @@ export class AUNChannel {
         const topicName = (typeof payload === 'object' && payload !== null)
             ? this.sanitizeTopicName(payload.topicName)
             : undefined;
-        const inboundType = (payload && typeof payload === 'object') ? payload.type : undefined;
         // 终态错误只作为展示信号，不能进入 Agent，也不能被 observer 再次传播。
         if (inboundType === 'error') {
             this.acknowledgeImmediately(messageId, seq);
@@ -2358,7 +2782,7 @@ export class AUNChannel {
                     peerName: displayName,
                     peerType: peerInfo?.type || 'unknown',
                     seq,
-                    replyContext: this.buildGroupReplyContext(threadId, senderAid, msgEncryptedFast, messageId, msgChatmodeFast, topicName, groupId),
+                    replyContext: this.buildGroupReplyContext(threadId, senderAid, msgEncryptedFast, messageId, msgChatmodeFast, topicName, groupId, readTopicLable(payload)),
                     createdAt,
                 });
                 return;
@@ -2377,27 +2801,10 @@ export class AUNChannel {
         {
             const payloadObj = (payload && typeof payload === 'object') ? payload : null;
             const payloadType = typeof payloadObj?.type === 'string' ? payloadObj.type : '';
-            // menu.* 协议：自定义消息快速路径
+            // Menu control requests are private-only, including token issuance.
             if (payloadType.startsWith('menu.')) {
-                const menuEncrypted = !!env.encrypted;
                 this.acknowledgeImmediately(messageId, seq);
-                this.appendInboundPayloadJsonl(groupId, senderAid, messageId, menuEncrypted, true, logDescriptor, threadId, receivedAt, seq);
-                this.dispatchMessage({
-                    channelId: groupId, userId: senderAid,
-                    text: JSON.stringify(payload),
-                    chatType: 'group', messageId, seq, receivedAt, receivedAtMono, gatewaySeq: seq, groupId,
-                    encrypted: menuEncrypted,
-                    protectedHeaders,
-                    mentions: payloadMentionEntries,
-                    mentionAids: payloadMentionAids,
-                    isMentioned: hasMentionAll(payloadMentionEntries)
-                        || (!!this._aid && mentionEntryTargets(payloadMentionEntries).includes(this._aid)),
-                    replyContext: this.buildGroupReplyContext(threadId, senderAid, menuEncrypted, messageId, payloadObj?.chatmode, topicName, groupId),
-                    msgType: logDescriptor.msgType,
-                    payloadType: logDescriptor.payloadType,
-                    payloadSummary: logDescriptor.payloadSummary,
-                    messageLogContent: logDescriptor.content,
-                });
+                logger.debug(`${this.logPrefix()} Group Menu dropped: code=MENU_PRIVATE_ONLY mid=${messageId}`);
                 return;
             }
             if (payloadType && !AUNChannel.PROACTIVE_ALLOW_TYPES.has(payloadType)) {
@@ -2437,17 +2844,15 @@ export class AUNChannel {
         if (isEchoMsg) {
             // 短 echo（≤10 字符）已在前面的快速通道命中并 return，这里只处理长 echo
             // >10 字符：追加 trace,存 pending echo,跳过 mention 过滤继续走 Agent 流程
-            const echoTs = () => {
-                const d = new Date();
-                return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}.${String(d.getMilliseconds()).padStart(3, '0')}`;
-            };
+            const echoCreatedAt = data.created_at;
+            const echoReceiveTs = Date.now();
             let echoText = text;
-            echoText += `\n${echoTs()} [EvolCore.receive] from=${senderAid} mid=${messageId} chat=group self=${this._aid || 'unknown'} conn_uptime=${this.connectedAt ? Math.round((Date.now() - this.connectedAt) / 1000) + 's' : 'unknown'}`;
+            echoText += `\n${echoTraceClock(echoReceiveTs)} [EvolCore.receive] from=${senderAid} mid=${messageId} chat=group self=${this._aid || 'unknown'} conn_uptime=${this.connectedAt ? Math.round((echoReceiveTs - this.connectedAt) / 1000) + 's' : 'unknown'}${echoInboundLegLabel(echoCreatedAt, receivedAt)}${echoTraceOriginLabel(echoReceiveTs)}`;
             const msgChatmodeEcho = (payload && typeof payload === 'object') ? payload.chatmode : undefined;
             this.pendingEchoMessages.set(messageId, {
                 text: echoText,
                 channelId: groupId,
-                context: this.buildGroupReplyContext(undefined, senderAid, msgEncrypted, messageId, msgChatmodeEcho, undefined, groupId),
+                context: this.buildGroupReplyContext(threadId, senderAid, msgEncrypted, messageId, msgChatmodeEcho, topicName, groupId, readTopicLable(payload)),
                 receiveTs: Date.now(),
             });
             // 继续走正常 Agent 流程（下面的代码会 dispatch）
@@ -2469,8 +2874,20 @@ export class AUNChannel {
             // 但为了保持现有行为兼容（避免大量未 @ 消息涌入），暂时保留过滤
             // TODO: Phase 6 实施 selective-response 模式后，移除此过滤，只保留 isMentioned 标记
             if (enforceMention && !isMentioned && !isOwnHandoff) {
+                try {
+                    if (text.trim() || this.collectAllAttachments(payload).length) {
+                        this.appendInboundPayloadJsonl(groupId, senderAid, messageId, msgEncrypted, true, logDescriptor, threadId, receivedAt, seq, 'unmentioned', 'filtered');
+                    }
+                }
+                catch (error) {
+                    // A failed local append must not suppress a subsequent SDK redelivery.
+                    const namespace = this.config.aid + ':' + (this.config.channelName ?? 'aun') + ':aun:group';
+                    this.inboundSeenMessages.delete(JSON.stringify([namespace, messageId]));
+                    this.rewriteInboundDedupe();
+                    logger.warn(`${this.logPrefix()} Deferred group message was not recorded; awaiting redelivery: ${error}`);
+                    return;
+                }
                 this.acknowledgeImmediately(messageId, seq);
-                this.appendInboundPayloadJsonl(groupId, senderAid, messageId, msgEncrypted, true, logDescriptor, threadId, receivedAt, seq);
                 logger.info(`${this.logPrefix()} Group dropped: unmentioned (group=${groupId} sender=${senderAid} mid=${messageId} mentionMode=${mentionMode} slashRequireMentions=${groupSlashRequireMentions} isCommand=${isCommandMsg} textPreview=${JSON.stringify(text.slice(0, 80))})`);
                 return;
             }
@@ -2493,7 +2910,7 @@ export class AUNChannel {
         // Process attachments
         const { finalText, images: inboundImages } = await this.processAttachments(payload, strippedText, groupId, rawAttachments, { chatType: 'group', groupId });
         const selfAgentDir = path.join(resolvePaths().agentsDir, this.config.aid);
-        const peerIdentity = await PeerIdentityCache.resolve('aun', senderAid, selfAgentDir, this.store, false);
+        const peerIdentity = await PeerIdentityCache.resolve('aun', senderAid, selfAgentDir, this.store, false, this.config.keystorePath || resolveRoot());
         const shortAid = this.getShortAid(senderAid);
         const displayName = peerIdentity.name || shortAid;
         // 详细 dispatch 决策日志：记录消息为何被路由到 agent
@@ -2536,6 +2953,7 @@ export class AUNChannel {
             chatType: 'group',
             messageId,
             receivedAt,
+            createdAt: typeof msg.created_at === 'number' ? msg.created_at : undefined,
             gatewaySeq: seq,
             seq,
             threadId,
@@ -2544,7 +2962,7 @@ export class AUNChannel {
             isMentioned: isOwnHandoff || mentionedSelf || mentionedAll,
             source: isOwnHandoff ? 'handoff' : undefined,
             encrypted: msgEncrypted,
-            replyContext: this.buildGroupReplyContext(threadId, senderAid, msgEncrypted, messageId, msgChatmode, topicName, groupId),
+            replyContext: this.buildGroupReplyContext(threadId, senderAid, msgEncrypted, messageId, msgChatmode, topicName, groupId, readTopicLable(payload)),
             mentionMode: serverMentionMode,
             images: inboundImages.length > 0 ? inboundImages : undefined,
             msgType: logDescriptor.msgType,
@@ -2564,6 +2982,7 @@ export class AUNChannel {
                 && authenticatedDelivery.chatType === 'group'
                 && suppliedDelivery.groupId === authenticatedDelivery.groupId;
         const delivery = suppliedDelivery && suppliedMatches ? suppliedDelivery : authenticatedDelivery;
+        const threadId = event.threadId ?? event.replyContext?.threadId;
         if (suppliedDelivery && delivery !== suppliedDelivery) {
             logger.warn(`${this.logPrefix()} Ignoring mismatched inbound reply route: channel=${event.channelId} chatType=${event.chatType}`);
         }
@@ -2585,17 +3004,15 @@ export class AUNChannel {
         }
         // 长 echo（>10 字符）：存 pending,继续交给 agent 处理
         if (/echo/i.test(firstLine) && firstLine.trim().length > 10 && !hasEvolCoreTracePrivate) {
-            const echoTs = () => {
-                const d = new Date();
-                return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}.${String(d.getMilliseconds()).padStart(3, '0')}`;
-            };
+            const echoReceiveTs = Date.now();
             let echoText = event.text;
-            echoText += `\n${echoTs()} [EvolCore.receive] from=${event.userId}${event.peerName ? `(${event.peerName})` : ''} mid=${event.messageId} chat=${event.chatType} self=${this._aid || 'unknown'} conn_uptime=${this.connectedAt ? Math.round((Date.now() - this.connectedAt) / 1000) + 's' : 'unknown'}`;
+            echoText += `\n${echoTraceClock(echoReceiveTs)} [EvolCore.receive] from=${event.userId}${event.peerName ? `(${event.peerName})` : ''} mid=${event.messageId} chat=${event.chatType} self=${this._aid || 'unknown'} conn_uptime=${this.connectedAt ? Math.round((echoReceiveTs - this.connectedAt) / 1000) + 's' : 'unknown'}${echoInboundLegLabel(event.createdAt, event.receivedAt ?? echoReceiveTs)}${echoTraceOriginLabel(echoReceiveTs)}`;
             this.pendingEchoMessages.set(event.messageId, {
                 text: echoText,
                 channelId: event.channelId,
                 context: {
                     ...(event.replyContext?.metadata ? { metadata: event.replyContext.metadata } : {}),
+                    ...(typeof threadId === 'string' ? { threadId } : {}),
                     delivery,
                 },
                 receiveTs: Date.now(),
@@ -2610,7 +3027,7 @@ export class AUNChannel {
         const replyContext = {
             ...(event.replyContext ?? {}),
             delivery,
-            ...(event.threadId && !event.replyContext?.threadId ? { threadId: event.threadId } : {}),
+            ...(typeof threadId === 'string' ? { threadId } : {}),
         };
         this.messageHandler({
             channelId: event.channelId || '',
@@ -2622,6 +3039,8 @@ export class AUNChannel {
             peerId: event.userId || event.channelId || '',
             peerName: event.peerName,
             peerType: event.peerType,
+            peerDeviceId: event.peerDeviceId,
+            peerSlotId: event.peerSlotId,
             sameDevice: event.sameDevice,
             sameNetwork: event.sameNetwork,
             sameEgressIp: event.sameEgressIp,
@@ -2632,7 +3051,7 @@ export class AUNChannel {
             receivedAtMono: event.receivedAtMono,
             gatewaySeq: event.gatewaySeq ?? event.seq,
             causation: event.causation,
-            threadId: event.threadId,
+            threadId,
             mentions: event.mentions,
             mentionAids: event.mentionAids,
             isMentioned: event.isMentioned, // ← 新增：传递 isMentioned 标记
@@ -2648,10 +3067,10 @@ export class AUNChannel {
             logger.error(`${this.logPrefix()} Message handler error:`, err);
         });
     }
-    appendInboundPayloadJsonl(channelId, fromAid, msgId, encrypt, isGroup, descriptor, threadId, receivedAt, gatewaySeq) {
+    appendInboundPayloadJsonl(channelId, fromAid, msgId, encrypt, isGroup, descriptor, threadId, receivedAt, gatewaySeq, groupAttention, groupDelivery) {
         try {
             const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', channelId, this.config.aid);
-            appendMessageLog(chatDir, buildInboundEntry({
+            const entry = buildInboundEntry({
                 from: fromAid,
                 to: this.config.aid,
                 threadId: threadId || null,
@@ -2666,10 +3085,18 @@ export class AUNChannel {
                 timestamp: receivedAt,
                 receivedAt,
                 gatewaySeq,
-            }));
+                groupAttention,
+                groupDelivery,
+            });
+            if (groupDelivery === 'filtered')
+                appendMessageLogStrict(chatDir, entry, true);
+            else
+                appendMessageLog(chatDir, entry);
         }
         catch (e) {
-            logger.debug(`${this.logPrefix()} appendInboundPayloadJsonl failed: ${e}`);
+            logger.warn(`${this.logPrefix()} appendInboundPayloadJsonl failed: ${e}`);
+            if (groupDelivery === 'filtered')
+                throw e;
         }
     }
     // ── 观察者模式（Observer Mode） ──────────────────────────────
@@ -2797,7 +3224,10 @@ export class AUNChannel {
     forwardInbound(data) {
         if (!this.connected || !this.client)
             return Promise.resolve();
-        if (payloadTypeForObserver(data)?.startsWith('menu.'))
+        const inboundType = payloadTypeForObserver(data);
+        // Observer envelopes are control-plane telemetry. Mirroring one again
+        // would amplify every activity event across observer-connected agents.
+        if (inboundType === 'observer.forward' || inboundType?.startsWith('menu.'))
             return Promise.resolve();
         const { observable, owners } = this.getObserverConfig();
         if (!observable || owners.length === 0)
@@ -2833,7 +3263,8 @@ export class AUNChannel {
     forwardOutbound(result) {
         if (!this.connected || !this.client)
             return Promise.resolve();
-        if (payloadTypeForObserver(result)?.startsWith('menu.'))
+        const outboundType = payloadTypeForObserver(result);
+        if (outboundType === 'observer.forward' || outboundType?.startsWith('menu.'))
             return Promise.resolve();
         const { observable, owners } = this.getObserverConfig();
         if (!observable || owners.length === 0)
@@ -2874,8 +3305,8 @@ export class AUNChannel {
         };
         const encrypt = this.shouldEncrypt('observer.forward');
         for (const ownerAid of owners) {
-            this.callAndTrace('message.send', { to: ownerAid, payload: forwardPayload, encrypt })
-                .catch(e => logger.warn(`${this.logPrefix()} observer.forward send to ${ownerAid} failed: ${e}`));
+            this.callAndTrace('message.send', { to: ownerAid, payload: forwardPayload, encrypt }, { lane: 'observer' })
+                .catch(e => logger.debug(`${this.logPrefix()} observer.forward send to ${ownerAid} failed: ${e}`));
         }
     }
     // ── 观察者插话（Observer Insert，v0.3 待用上下文提示） ──────────────
@@ -2978,14 +3409,12 @@ export class AUNChannel {
         }
     }
     handleEcho(event) {
-        const ts = () => {
-            const d = new Date();
-            return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}.${String(d.getMilliseconds()).padStart(3, '0')}`;
-        };
+        const receiveTs = Date.now();
         // 在收到的消息文本末尾追加 trace 行（只追加,不修改原文）
         let echoText = event.text;
-        echoText += `\n${ts()} [EvolCore.receive] from=${event.userId}${event.peerName ? `(${event.peerName})` : ''} mid=${event.messageId} chat=${event.chatType} self=${this._aid || 'unknown'} conn_uptime=${this.connectedAt ? Math.round((Date.now() - this.connectedAt) / 1000) + 's' : 'unknown'}`;
-        echoText += `\n${ts()} [EvolCore.reply] echo回声发出 conn_uptime=${this.connectedAt ? Math.round((Date.now() - this.connectedAt) / 1000) + 's' : 'unknown'}`;
+        echoText += `\n${echoTraceClock(receiveTs)} [EvolCore.receive] from=${event.userId}${event.peerName ? `(${event.peerName})` : ''} mid=${event.messageId} chat=${event.chatType} self=${this._aid || 'unknown'} conn_uptime=${this.connectedAt ? Math.round((receiveTs - this.connectedAt) / 1000) + 's' : 'unknown'}${echoInboundLegLabel(event.createdAt, receiveTs)}${echoTraceOriginLabel(receiveTs)}`;
+        const replyTs = Date.now();
+        echoText += `\n${echoTraceClock(replyTs)} [EvolCore.reply] echo回声发出 conn_uptime=${this.connectedAt ? Math.round((replyTs - this.connectedAt) / 1000) + 's' : 'unknown'}${echoTraceOriginLabel(replyTs)}`;
         if (Buffer.byteLength(echoText, 'utf-8') > 4096) {
             echoText += `\n[TRUNCATED]`;
         }
@@ -2995,7 +3424,7 @@ export class AUNChannel {
             ? { chatType: 'group', groupId: event.channelId }
             : { chatType: 'private' };
         const context = {
-            threadId: event.threadId,
+            threadId: event.threadId ?? event.replyContext?.threadId,
             metadata: event.replyContext?.metadata,
             delivery: authenticatedDelivery,
         };
@@ -3098,6 +3527,7 @@ export class AUNChannel {
         else if (state === 'disconnected' || state === 'reconnecting') {
             const wasConnected = this.connected;
             this.connected = false;
+            this.clearQueuedObserverSends(state);
             // The nine-state SDK emits standby -> retry_backoff -> reconnecting for
             // one reconnect cycle. Count the connected-to-down edge once instead of
             // inflating the metric for every intermediate state.
@@ -3281,6 +3711,7 @@ export class AUNChannel {
             this.client = null;
         }
         this.connected = false;
+        this.clearQueuedObserverSends(`takeover_${reason}`);
         const delaySec = Math.round(delayMs / 1000);
         logger.info(`${this.logPrefix()} Scheduling TS-layer reconnect (${reason}) in ${delaySec}s`);
         this.trace('OUT', 'reconnect.scheduled', { reason, delayMs, generation: gen });
@@ -3444,7 +3875,9 @@ export class AUNChannel {
         return Buffer.byteLength(logText, 'utf-8');
     }
     applyReplyContextToPayload(payload, context) {
-        const finalPayload = this.stripUndefinedDeep({ ...payload });
+        const finalPayload = this.stripUndefinedDeep(withAunAttention({ ...payload }, context?.attention));
+        if (finalPayload.thread_id === '')
+            delete finalPayload.thread_id;
         if (context?.threadId && !finalPayload.thread_id)
             finalPayload.thread_id = context.threadId;
         if (context?.replyToMessageId && !finalPayload.ref_message_id)
@@ -3456,13 +3889,14 @@ export class AUNChannel {
         return finalPayload;
     }
     /**
-     * Validate the AUN-specific structured field before it crosses the durable
+     * Validate AUN-specific structured fields before crossing the durable
      * send boundary. Return a copy when mentions are present so callers do not
      * retain an unvalidated array reference.
      */
     normalizeAunPayloadMentions(payload) {
         if (!payload || typeof payload !== 'object' || Array.isArray(payload))
             return payload;
+        payload = withAunAttention(payload);
         if (!Object.prototype.hasOwnProperty.call(payload, 'mentions'))
             return payload;
         return {
@@ -3498,6 +3932,9 @@ export class AUNChannel {
                 if (!current || typeof current !== 'object')
                     continue;
                 for (const key of Object.keys(current)) {
+                    // Topic routing must survive content truncation and fallback.
+                    if (current === limited && key === 'thread_id')
+                        continue;
                     const value = current[key];
                     if (typeof value === 'string') {
                         leaves.push({ parent: current, key, value, bytes: Buffer.byteLength(value, 'utf8') });
@@ -3544,6 +3981,8 @@ export class AUNChannel {
         };
         if (typeof payload.chatmode === 'string')
             fallback.chatmode = truncateUtf8ToBytes(payload.chatmode, 32);
+        if (typeof payload.thread_id === 'string')
+            fallback.thread_id = payload.thread_id;
         logger.info(`${this.logPrefix()} Thought payload reduced to fallback (${Buffer.byteLength(JSON.stringify(fallback), 'utf8')} bytes)`);
         return fallback;
     }
@@ -3602,15 +4041,23 @@ export class AUNChannel {
     registerCardPostSend(messageId, action, channelId, delivery, replyContext) {
         if (action.type !== 'register_interaction_card')
             return;
+        // Card replies start a new input; an outbound attention marker must not
+        // become the default for every message produced after clicking the card.
+        const callbackContext = replyContext ? { ...replyContext } : undefined;
+        if (callbackContext)
+            delete callbackContext.attention;
         this.cardMessageIdMap.set(messageId, {
             requestId: action.requestId,
             isCommandCard: action.isCommandCard,
             initiatorAid: action.initiatorAid,
             channelId,
             delivery: delivery ?? action.delivery,
-            replyContext,
+            replyContext: callbackContext,
         });
         this.ownedCardMsgIds.add(messageId);
+        if (typeof replyContext?.threadId === 'string') {
+            this.ownedCardTopics.set(messageId, { channelId, threadId: replyContext.threadId });
+        }
         let messageIds = this.interactionCardMessageIds.get(action.requestId);
         if (!messageIds) {
             messageIds = new Set();
@@ -3629,7 +4076,10 @@ export class AUNChannel {
                 this.interactionCardMessageIds.delete(action.requestId);
         }, mapTtl);
         mapTimer.unref?.();
-        const ownedTimer = setTimeout(() => this.ownedCardMsgIds.delete(messageId), 24 * 60 * 60 * 1000);
+        const ownedTimer = setTimeout(() => {
+            this.ownedCardMsgIds.delete(messageId);
+            this.ownedCardTopics.delete(messageId);
+        }, 24 * 60 * 60 * 1000);
         ownedTimer.unref?.();
         const invalidationReason = this.invalidatedInteractions.get(action.requestId);
         if (invalidationReason) {
@@ -3642,6 +4092,8 @@ export class AUNChannel {
             return;
         if (entry.postSend.type === 'register_interaction_card') {
             this.registerCardPostSend(messageId, entry.postSend, entry.channelId, entry.delivery, entry.context);
+            if (entry.postSend.requestId.startsWith('gir-'))
+                this.groupInviteDelivered?.(entry.postSend.requestId, messageId);
         }
     }
     async sendAunPayload(channelId, payload, context, label) {
@@ -3673,9 +4125,20 @@ export class AUNChannel {
         const payloadWithCausationRef = causationRef
             ? { ...normalizedPayload, _evolcore_causation_ref: causationRef }
             : normalizedPayload;
+        if (payloadWithCausationRef.thread_id === '')
+            delete payloadWithCausationRef.thread_id;
         // Truncate payload if too large (AUN SDK limit: 1MB)
         const truncatedPayload = this.truncatePayloadIfNeeded(payloadWithCausationRef, label);
         const params = { payload: truncatedPayload, encrypt };
+        const isMenuPayload = typeof truncatedPayload.type === 'string' && truncatedPayload.type.startsWith('menu.');
+        if (!isGroup && truncatedPayload.type === 'menu.response')
+            params.to_device_id = context?.toDeviceId;
+        if (isMenuPayload && typeof context?.metadata?.menuClientSdkVersion === 'string') {
+            params.menu_client_sdk_version = context.metadata.menuClientSdkVersion;
+        }
+        if (isMenuPayload && encrypt && context?.metadata?.protectedHeaders) {
+            params.protected_headers = context.metadata.protectedHeaders;
+        }
         if (isGroup)
             params.group_id = delivery.groupId;
         else
@@ -3696,7 +4159,7 @@ export class AUNChannel {
             return await callOnce(params, false);
         }
         catch (e) {
-            if (encrypt && e instanceof E2EEError) {
+            if (encrypt && e instanceof E2EEError && !isMenuPayload) {
                 this.peerE2ee.set(encryptTarget, { ok: false, ts: Date.now() });
                 logger.warn(`${this.logPrefix()} E2EE ${label} send failed to ${channelId}, retrying plaintext: ${e}`);
                 const fallbackParams = { ...params, encrypt: false };
@@ -3749,7 +4212,8 @@ export class AUNChannel {
             ...classifyAunPayloadForLog(payload), msgId: messageId, encrypt, context, isGroup, source,
             transport: this.sendReceiptFromResult(result),
         });
-        this.forwardOutbound(result);
+        if (typeof payload.type !== 'string' || !payload.type.startsWith('menu.'))
+            this.forwardOutbound(result);
     }
     async sendContentPayload(channelId, payload, opts) {
         const delivery = this.requireDelivery(channelId, opts.context);
@@ -3792,6 +4256,7 @@ export class AUNChannel {
                 queue: opts.queue,
                 channelId,
                 delivery,
+                dedupeKey: opts.dedupeKey,
                 type: 'payload',
                 contentKind: opts.contentKind,
                 payload: finalPayload,
@@ -3863,7 +4328,7 @@ export class AUNChannel {
             base.initiator = context.peerId;
         if (context?.replyToMessageId)
             base.ref_message_id = context.replyToMessageId;
-        return base;
+        return withAunAttention(base, context?.attention);
     }
     activityLogText(raw) {
         // 兼容两种入参：原始 ThoughtItem（顶层字段），或已构建的 activity payload（字段收在 .item 里）
@@ -3889,68 +4354,27 @@ export class AUNChannel {
     /**
      * Truncate payload if it exceeds AUN protocol limits.
      * AUN SDK enforces MAX_WS_PAYLOAD_SIZE = 1_000_000 bytes (1MB) for the entire JSON-RPC message.
-     * We use a conservative 800KB limit for the payload itself to leave room for RPC envelope.
+     * We use a conservative 512KB limit for the payload itself to leave room for
+     * the encrypted AUN envelope and RPC framing.
      */
     truncatePayloadIfNeeded(payload, label) {
-        const MAX_PAYLOAD_SIZE = 800 * 1024; // 800KB conservative limit
-        const MAX_FIELD_SIZE = 256 * 1024; // 256KB per field
-        // First check total size
-        const payloadJson = JSON.stringify(payload);
-        const totalSize = Buffer.byteLength(payloadJson, 'utf-8');
-        if (totalSize <= MAX_PAYLOAD_SIZE) {
+        const result = truncateAunPayloadIfNeeded(payload);
+        if (result.originalSize <= AUN_MAX_PAYLOAD_SIZE) {
             return payload; // No truncation needed
         }
-        logger.warn(`${this.logPrefix()} Payload too large (${formatSize(totalSize)}), truncating... label=${label}`);
-        // Deep clone to avoid mutating original
-        const truncated = JSON.parse(payloadJson);
-        // Truncate large string fields recursively
-        const truncateObject = (obj, path) => {
-            if (!obj || typeof obj !== 'object')
-                return false;
-            let changed = false;
-            for (const key of Object.keys(obj)) {
-                const value = obj[key];
-                const fieldPath = path ? `${path}.${key}` : key;
-                if (typeof value === 'string') {
-                    const fieldSize = Buffer.byteLength(value, 'utf-8');
-                    if (fieldSize > MAX_FIELD_SIZE) {
-                        const truncatedValue = value.substring(0, MAX_FIELD_SIZE / 4); // Rough estimate, UTF-8 safe
-                        const actualTruncatedSize = Buffer.byteLength(truncatedValue, 'utf-8');
-                        obj[key] = truncatedValue + `\n\n[截断：原始输出 ${formatSize(fieldSize)}，仅显示前 ${formatSize(actualTruncatedSize)}]`;
-                        obj[`${key}_truncated`] = true;
-                        logger.info(`${this.logPrefix()} Truncated field ${fieldPath}: ${formatSize(fieldSize)} → ${formatSize(actualTruncatedSize)}`);
-                        changed = true;
-                    }
-                }
-                else if (Array.isArray(value)) {
-                    for (let i = 0; i < value.length; i++) {
-                        if (truncateObject(value[i], `${fieldPath}[${i}]`)) {
-                            changed = true;
-                        }
-                    }
-                }
-                else if (typeof value === 'object' && value !== null) {
-                    if (truncateObject(value, fieldPath)) {
-                        changed = true;
-                    }
-                }
-            }
-            return changed;
-        };
-        truncateObject(truncated, '');
-        // Check size again after truncation
-        const newJson = JSON.stringify(truncated);
-        const newSize = Buffer.byteLength(newJson, 'utf-8');
-        if (newSize > MAX_PAYLOAD_SIZE) {
-            // Still too large - this shouldn't happen with 256KB field limit, but log it
-            logger.error(`${this.logPrefix()} Payload still too large after truncation: ${formatSize(newSize)}, dropping payload`);
+        logger.warn(`${this.logPrefix()} Payload too large (${formatSize(result.originalSize)}), truncating... label=${label}`);
+        for (const field of result.truncatedFields) {
+            logger.info(`${this.logPrefix()} Truncated field ${field.path}: ${formatSize(field.originalSize)} → ${formatSize(field.finalSize)}`);
+        }
+        if (result.dropped) {
+            logger.error(`${this.logPrefix()} Payload still too large after truncation: ${formatSize(result.finalSize)}, dropping payload`);
             return {
                 type: 'text',
                 text: '消息内容过大，无法完整发送，请缩小输出后重试',
             };
         }
-        logger.info(`${this.logPrefix()} Payload truncated: ${formatSize(totalSize)} → ${formatSize(newSize)}`);
-        return truncated;
+        logger.info(`${this.logPrefix()} Payload truncated: ${formatSize(result.originalSize)} → ${formatSize(result.finalSize)}`);
+        return result.payload;
     }
     buildActivityPayload(envelope, context, item) {
         const rawItem = item && typeof item === 'object' && !Array.isArray(item)
@@ -3962,11 +4386,11 @@ export class AUNChannel {
         const activityItem = rawItem.kind === 'tool_call' && displayArguments !== rawItem.arguments
             ? { ...rawItem, arguments: displayArguments }
             : rawItem;
-        return {
+        return withAunAttention({
             ...this.buildTaskPayloadBase(envelope, context),
             type: 'activity',
             item: this.stripUndefinedDeep(activityItem),
-        };
+        });
     }
     async sendReliableStructured(channelId, payload, context, logText) {
         const result = await this.sendContentPayload(channelId, payload, {
@@ -3981,11 +4405,14 @@ export class AUNChannel {
             throw Object.assign(new Error(result.error ?? 'AUN structured send failed'), {
                 code: result.code ?? 'AUN_SEND_FAILED',
                 outboxId: result.outboxId,
+                permanent: true,
+                status: 'failed',
             });
         }
         return result;
     }
     async sendMessage(channelId, text, context) {
+        parseAunAttention(context?.attention);
         if (!text?.trim()) {
             logger.warn(`${this.logPrefix()} Attempted to send empty message, skipping`);
             return { status: 'failed', error: 'message text is empty', code: 'EMPTY_MESSAGE' };
@@ -3994,7 +4421,7 @@ export class AUNChannel {
         const routedContext = this.withDelivery(context, delivery);
         // 长 echo: agent 首次回复前先发 echo trace（echo 自身发送时跳过）
         if (!this.isEchoSending) {
-            await this.flushPendingEcho(channelId, delivery);
+            await this.flushPendingEcho(channelId, delivery, context?.threadId);
         }
         let finalText = text;
         this.sentCount.set(channelId, (this.sentCount.get(channelId) || 0) + 1);
@@ -4102,6 +4529,7 @@ export class AUNChannel {
         if (entry.deliveryReceipt?.messageId) {
             return { status: 'sent', messageId: entry.deliveryReceipt.messageId };
         }
+        outbox.recordRetry(this.config.aid, entry, result);
         return {
             status: 'queued',
             outboxId: entry.id,
@@ -4121,6 +4549,8 @@ export class AUNChannel {
         try {
             const validatedPayload = this.normalizeAunPayloadMentions(args.payload);
             finalPayload = this.stripUndefinedDeep(validatedPayload);
+            if (finalPayload.thread_id === '')
+                delete finalPayload.thread_id;
         }
         catch (e) {
             return {
@@ -4222,11 +4652,7 @@ export class AUNChannel {
                 code: 'H_CLASS_PROTECTED',
             });
         }
-        const connection = {
-            call: (method, params) => this.callAndTrace(method, params),
-            close: async () => { },
-        };
-        const built = await uploadFileAndBuildPayload(connection, this.config.aid, file.filePath, {
+        const built = await uploadFileAndBuildPayload(this.client, this.config.aid, file.filePath, {
             as: file.as,
             contentType: file.contentType,
             text: file.text,
@@ -4247,6 +4673,8 @@ export class AUNChannel {
             // removed from a malformed mentions array.
             const validatedPayload = this.normalizeAunPayloadMentions(args.payload);
             const finalPayload = this.stripUndefinedDeep(validatedPayload);
+            if (finalPayload.thread_id === '')
+                delete finalPayload.thread_id;
             const payloadMentions = Object.prototype.hasOwnProperty.call(finalPayload, 'mentions')
                 ? normalizeAunMentionEntries(finalPayload.mentions)
                 : undefined;
@@ -4321,20 +4749,20 @@ export class AUNChannel {
             return { ok: false, error: e?.message || String(e), code: e?.code };
         }
     }
-    async flushPendingEcho(channelId, delivery) {
+    async flushPendingEcho(channelId, delivery, threadId) {
         // 查找该 channelId 是否有 pending echo（长 echo 等待 agent 首次回复）
         for (const [key, echo] of this.pendingEchoMessages) {
-            if (echo.channelId === channelId) {
+            if (echo.channelId === channelId
+                && (echo.context?.threadId ?? '') === (threadId ?? '')
+                && echo.context?.delivery?.chatType === delivery.chatType) {
                 this.pendingEchoMessages.delete(key);
                 logger.info(`${this.logPrefix()} [Echo] flushPendingEcho triggered: key=${key} channelId=${channelId} pendingCount=${this.pendingEchoMessages.size}`);
-                const ts = () => {
-                    const d = new Date();
-                    return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}.${String(d.getMilliseconds()).padStart(3, '0')}`;
-                };
-                const agentDuration = Date.now() - echo.receiveTs;
+                const agentDoneTs = Date.now();
+                const agentDuration = agentDoneTs - echo.receiveTs;
                 let echoText = echo.text;
-                echoText += `\n${ts()} [EvolCore.agent] duration=${agentDuration}ms`;
-                echoText += `\n${ts()} [EvolCore.reply] echo回声发出 conn_uptime=${this.connectedAt ? Math.round((Date.now() - this.connectedAt) / 1000) + 's' : 'unknown'}`;
+                echoText += `\n${echoTraceClock(agentDoneTs)} [EvolCore.agent] duration=${agentDuration}ms${echoTraceOriginLabel(agentDoneTs)}`;
+                const replyTs = Date.now();
+                echoText += `\n${echoTraceClock(replyTs)} [EvolCore.reply] echo回声发出 conn_uptime=${this.connectedAt ? Math.round((replyTs - this.connectedAt) / 1000) + 's' : 'unknown'}${echoTraceOriginLabel(replyTs)}`;
                 if (Buffer.byteLength(echoText, 'utf-8') > 4096) {
                     echoText += `\n[TRUNCATED]`;
                 }
@@ -4401,10 +4829,16 @@ export class AUNChannel {
                     return { status: 'retry', error: 'post-bootstrap welcome is waiting for active lifecycle', code: 'BOOTSTRAP_NOT_ACTIVE' };
                 }
             }
+            if (operationId.startsWith(bootstrapInitialMessageOperationPrefix(this.config.aid)) && !entry.deliveryReceipt) {
+                const config = loadAgent(this.config.aid);
+                if (config && resolveAgentLifecycle(config) === 'active') {
+                    return { status: 'permanent', code: 'BOOTSTRAP_SUPERSEDED', error: 'Bootstrap is complete; initial prompt cancelled' };
+                }
+            }
         }
         // 从 context.metadata.source 读取 source，默认为 'daemon'
         const source = context?.metadata?.source ?? 'daemon';
-        const payload = { type: 'text', text: finalText };
+        const payload = withAunAttention({ type: 'text', text: finalText }, context?.attention);
         if (delivery.chatType === 'group') {
             const extracted = this.extractMentionEntriesFromText(finalText);
             if (extracted.length > 0)
@@ -4418,6 +4852,8 @@ export class AUNChannel {
             payload.task_id = context.metadata.taskId;
         if (context?.metadata?.chatmode)
             payload.chatmode = context.metadata.chatmode;
+        if (context?.metadata?.forkAnchor)
+            payload.fork_anchor = context.metadata.forkAnchor;
         const causation = normalizeCausation(context?.metadata?.causation);
         const causationRef = delivery.chatType !== 'group' && causation
             ? `caus_${crypto.randomUUID().replace(/-/g, '')}`
@@ -4608,6 +5044,7 @@ export class AUNChannel {
             queue: entry.queue,
         };
         const receipt = {
+            acceptedAt: Date.now(),
             messageId,
             encrypt,
             transport: this.sendReceiptFromResult(result),
@@ -4630,6 +5067,15 @@ export class AUNChannel {
             logger.info(`${this.logPrefix()} Discarded invalidated interaction from durable outbox: request=${interactionId} entry=${entry.id}`);
             return { ok: true, status: 'sent' };
         }
+        if (interactionId?.startsWith('gir-')) {
+            const result = this.groupInviteDeliveryGate?.(interactionId, entry.channelId) ?? 'stale';
+            if (result === 'defer')
+                return { ok: false, status: 'retry', error: 'group invitation callback is not ready', code: 'INVITE_REVIEW_NOT_READY' };
+            if (result !== 'allow') {
+                logger.info(`${this.logPrefix()} Discarded stale group invitation card: request=${interactionId} entry=${entry.id}`);
+                return { ok: true, status: 'sent' };
+            }
+        }
         const interactionExpiresAt = entry.postSend?.type === 'register_interaction_card'
             ? entry.postSend.expiresAt
             : undefined;
@@ -4777,6 +5223,10 @@ export class AUNChannel {
         const payloadWithChatmode = context?.metadata?.chatmode && !finalPayload.chatmode
             ? { ...finalPayload, chatmode: context.metadata.chatmode }
             : finalPayload;
+        if (payloadWithChatmode.thread_id === '')
+            delete payloadWithChatmode.thread_id;
+        if (context?.threadId && !payloadWithChatmode.thread_id)
+            payloadWithChatmode.thread_id = context.threadId;
         const params = {
             context: { type: 'task', id: taskId },
             payload: this.limitThoughtPayload(payloadWithChatmode),
@@ -4857,7 +5307,7 @@ export class AUNChannel {
         // Validate before checking connection state so malformed producer payloads
         // are reported deterministically instead of being hidden by a disconnect.
         const validatedPayload = this.normalizeAunPayloadMentions(payload);
-        const finalPayload = this.stripUndefinedDeep(validatedPayload);
+        const finalPayload = this.stripUndefinedDeep(withAunAttention(validatedPayload, context?.attention));
         if (!this.connected || !this.client) {
             return {
                 ok: false,
@@ -4872,12 +5322,19 @@ export class AUNChannel {
         const encrypt = context?.metadata?.encrypted != null
             ? !!(context.metadata.encrypted)
             : this.shouldEncrypt(encryptTarget);
+        if (finalPayload.thread_id === '')
+            delete finalPayload.thread_id;
         if (context?.threadId && !finalPayload.thread_id)
             finalPayload.thread_id = context.threadId;
         if (context?.replyToMessageId && !finalPayload.ref_message_id)
             finalPayload.ref_message_id = context.replyToMessageId;
         const isMenuPayload = typeof finalPayload.type === 'string' && finalPayload.type.startsWith('menu.');
         const params = { payload: finalPayload, encrypt };
+        if (!isGroup && finalPayload.type === 'menu.response')
+            params.to_device_id = context?.toDeviceId;
+        if (isMenuPayload && typeof context?.metadata?.menuClientSdkVersion === 'string') {
+            params.menu_client_sdk_version = context.metadata.menuClientSdkVersion;
+        }
         const rawHeaders = context?.metadata?.protectedHeaders;
         if (encrypt && rawHeaders && typeof rawHeaders === 'object' && !Array.isArray(rawHeaders)) {
             const protectedHeaders = {};
@@ -4943,21 +5400,23 @@ export class AUNChannel {
         });
     }
     async sendFile(channelId, filePath, context) {
+        parseAunAttention(context?.attention);
         const delivery = this.requireDelivery(channelId, context);
         context = this.withDelivery(context, delivery);
+        const isFetch = typeof context?.metadata?.correlationId === 'string' && !!context.metadata.correlationId;
         const absPath = path.resolve(filePath);
         if (!fs.existsSync(absPath)) {
             logger.warn(`${this.logPrefix()} sendFile: file not found: ${absPath}`);
-            return;
+            return { status: 'failed', error: 'file no longer exists', code: 'FILE_NOT_FOUND' };
         }
         const stat = fs.statSync(absPath);
         if (stat.size === 0) {
             logger.warn(`${this.logPrefix()} sendFile: file is empty`);
-            return;
+            return { status: 'failed', error: 'file is empty', code: 'EMPTY_FILE' };
         }
         if (stat.size > 10 * 1024 * 1024) {
             logger.warn(`${this.logPrefix()} sendFile: file too large (${formatSize(stat.size)}, max 10 MB)`);
-            return;
+            return { status: 'failed', error: `file too large (max ${formatSize(MAX_AUN_ATTACHMENT_SIZE)})`, code: 'FILE_TOO_LARGE' };
         }
         // Write-ahead: persist to outbox
         const entry = outbox.enqueue(this.config.aid, {
@@ -4975,17 +5434,47 @@ export class AUNChannel {
             if (!this.reconnectTimer && !this.client) {
                 this.initClient().catch(e => logger.error(`${this.logPrefix()} Reconnect from sendFile failed: ${e}`));
             }
-            return;
+            const error = 'AUN channel is not connected';
+            if (isFetch) {
+                this.markPermanentOutboxFailure(entry, { error, code: 'AUN_NOT_CONNECTED' });
+                return { status: 'failed', outboxId: entry.id, error, code: 'AUN_NOT_CONNECTED' };
+            }
+            return { status: 'queued', outboxId: entry.id, error, code: 'AUN_NOT_CONNECTED' };
         }
         const result = await this.withOutboxInFlight(entry, () => this.deliverFileEntry(entry), { status: 'retry', error: 'outbox send is already in flight' });
         if (result.status === 'sent') {
+            const messageId = result.messageId ?? entry.deliveryReceipt?.messageId;
+            if (!messageId) {
+                const error = 'file send returned no message_id';
+                this.markPermanentOutboxFailure(entry, { error, code: 'MISSING_MESSAGE_ID' });
+                return { status: 'failed', outboxId: entry.id, error, code: 'MISSING_MESSAGE_ID' };
+            }
             this.removeDeliveredOutboxEntry(entry);
+            return { status: 'sent', messageId };
         }
-        else if (result.status === 'permanent') {
+        // Remote acceptance is authoritative even if local bookkeeping needs retry.
+        if (entry.deliveryReceipt?.messageId)
+            return { status: 'sent', messageId: entry.deliveryReceipt.messageId };
+        if (result.status === 'permanent' || isFetch) {
+            // A correlated fetch must resolve promptly. Retrying it after reporting
+            // failure could deliver an unsolicited file for an already closed request.
             this.markPermanentOutboxFailure(entry, result);
+            return {
+                status: 'failed',
+                outboxId: entry.id,
+                error: result.error ?? 'permanent file send failure',
+                ...(result.code !== undefined ? { code: result.code } : {}),
+            };
         }
+        return {
+            status: 'queued',
+            outboxId: entry.id,
+            ...(result.error !== undefined ? { error: result.error } : {}),
+            ...(result.code !== undefined ? { code: result.code } : {}),
+        };
     }
     async sendImage(channelId, data, mimeType, alt, context) {
+        parseAunAttention(context?.attention);
         const delivery = this.requireDelivery(channelId, context);
         context = this.withDelivery(context, delivery);
         if (!Buffer.isBuffer(data)) {
@@ -5055,11 +5544,7 @@ export class AUNChannel {
         }
         const digest = crypto.createHash('sha256').update(data).digest('hex').slice(0, 12);
         const filename = `image-${digest}.${extension}`;
-        const connection = {
-            call: (method, params) => this.callAndTrace(method, params),
-            close: async () => { },
-        };
-        const built = await uploadBufferAndBuildPayload(connection, this.config.aid, data, filename, { as: 'image', contentType });
+        const built = await uploadBufferAndBuildPayload(this.client, this.config.aid, data, filename, { as: 'image', contentType });
         const imagePayload = { ...built.payload };
         setIfDefined(imagePayload, 'alt', alt);
         return imagePayload;
@@ -5146,57 +5631,14 @@ export class AUNChannel {
             logger.warn(`${this.logPrefix()} deliverFileEntry: file gone: ${absPath}`);
             return { status: 'permanent', error: 'file no longer exists', code: 'FILE_NOT_FOUND' };
         }
-        const filename = path.basename(absPath);
-        const fileData = fs.readFileSync(absPath);
-        const stat = fs.statSync(absPath);
-        const sha256 = crypto.createHash('sha256').update(fileData).digest('hex');
-        const contentType = guessMime(filename);
-        const objectKey = `shared/${crypto.randomUUID()}/${filename}`;
         try {
-            if (stat.size <= 64 * 1024) {
-                await this.callAndTrace('storage.put_object', {
-                    object_key: objectKey,
-                    content: fileData.toString('base64'),
-                    content_type: contentType,
-                    is_private: false,
-                    overwrite: true,
-                });
-            }
-            else {
-                const session = await this.callAndTrace('storage.create_upload_session', {
-                    object_key: objectKey,
-                    size_bytes: stat.size,
-                    content_type: contentType,
-                });
-                const uploadUrl = session.upload_url;
-                if (!uploadUrl)
-                    throw new Error('No upload_url in session response');
-                this.trace('OUT', 'http.put.upload_url', { object_key: objectKey, size: stat.size });
-                const uploadResp = await fetch(uploadUrl, { method: 'PUT', body: fileData });
-                this.trace('OUT', uploadResp.ok ? 'http.put.upload_url.ok' : 'http.put.upload_url.error', { status: uploadResp.status });
-                if (!uploadResp.ok)
-                    throw new Error(`HTTP upload failed: ${uploadResp.status}`);
-                await this.callAndTrace('storage.complete_upload', {
-                    object_key: objectKey,
-                    sha256,
-                    content_type: contentType,
-                    is_private: false,
-                    size_bytes: stat.size,
-                });
-            }
-            const attachment = {
-                owner_aid: this._aid || '',
-                object_key: objectKey,
-                filename,
-                size_bytes: stat.size,
-                sha256,
-                content_type: contentType,
-            };
+            const { attachment } = await uploadFileAndBuildPayload(this.client, this.config.aid, absPath, { as: 'file' });
+            const { filename, size_bytes: size, content_type: contentType } = attachment;
             const filePayload = buildAunFilePayload({
                 filename,
-                size: stat.size,
+                size,
                 contentType,
-                attachment,
+                attachment: { ...attachment },
                 context,
             });
             const fileTargetAid = channelId;
@@ -5282,7 +5724,7 @@ export class AUNChannel {
                 logger.error(`${this.logPrefix()} AUN accepted the durable file but its receipt could not be persisted: id=${entry.id} mid=${sentMid} error=${detail}`);
                 return { status: 'permanent', error: detail, code: 'OUTBOX_RECEIPT_CHECKPOINT_FAILED' };
             }
-            logger.info(`${this.logPrefix()} File sent: ${filename} (${formatSize(stat.size)}) → ${channelId}`);
+            logger.info(`${this.logPrefix()} File sent: ${filename} (${formatSize(size)}) → ${channelId}`);
             const fileText = filePayload.text;
             appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_out', aid: this.config.aid, to: channelId, msgId: sentMid, kind: 'file', len: fileText.length, ...(isGroup && { groupId: channelId }) });
             const statsContext = isGroup ? await this.groupStatsContext(channelId) : undefined;
@@ -5401,11 +5843,12 @@ export class AUNChannel {
             // corrected Owner route was delivered.
             if (entry.channelId !== owner || entry.delivery?.chatType !== 'private') {
                 delete repaired.deliveryReceipt;
+                delete repaired.deliveryResult;
+                delete repaired.terminal;
+                delete repaired.lastError;
+                delete repaired.lastErrorCode;
+                delete repaired.attempts;
             }
-            delete repaired.terminal;
-            delete repaired.lastError;
-            delete repaired.lastErrorCode;
-            delete repaired.attempts;
             if (outbox.replaceIfRouteMatches(aid, entry, repaired) !== 'replaced')
                 continue;
             logger.warn(`${this.logPrefix()} Repaired bootstrap outbox route to private Owner delivery: entry=${entry.id} owner=${owner}`);
@@ -5445,17 +5888,21 @@ export class AUNChannel {
             notice: 'notice',
             requires_action: 'requires_action',
         };
-        const statusPayload = {
+        const statusPayload = withAunAttention({
             type: 'task.status',
             status: stateMap[status] ?? status,
             task_id: taskId,
             session_id: sessionId,
             severity,
-            terminal: ['done', 'interrupted', 'error', 'timeout'].includes(status),
-        };
+        });
         const metadataInput = extraMeta ? { ...extraMeta } : undefined;
         if (metadataInput)
             delete metadataInput.severity;
+        const statusKind = typeof extraMeta?.kind === 'string' ? extraMeta.kind : undefined;
+        if (statusKind)
+            statusPayload.kind = statusKind;
+        if (metadataInput)
+            delete metadataInput.kind;
         const metadata = metadataInput ? this.stripUndefinedDeep(metadataInput) : undefined;
         if (metadata && Object.keys(metadata).length > 0)
             statusPayload.metadata = metadata;
@@ -5508,10 +5955,6 @@ export class AUNChannel {
         // returns until the channel reconnects.
         const delivery = this.requireDelivery(channelId, context);
         context = this.withDelivery(context, delivery);
-        if (!this.connected || !this.client) {
-            logger.debug(`${this.logPrefix()} Custom payload skipped while disconnected: channel=${channelId}`);
-            return;
-        }
         // SDK 0.3.0 E2EE requires payload to be an object
         let payloadObj;
         try {
@@ -5522,9 +5965,20 @@ export class AUNChannel {
         catch {
             payloadObj = { text: payload };
         }
+        // File fetch was already acknowledged. Its terminal error must survive a
+        // disconnect so the pending App request is not silently abandoned.
+        if (payloadObj.type === 'menu.response' && payloadObj.name === 'file' && payloadObj.error) {
+            await this.sendReliableStructured(channelId, payloadObj, context);
+            return;
+        }
+        if (!this.connected || !this.client) {
+            logger.debug(`${this.logPrefix()} Custom payload skipped while disconnected: channel=${channelId}`);
+            return;
+        }
         await this.sendStructuredOrThrow(channelId, payloadObj, context);
     }
     async disconnect() {
+        this.managedMenuClient.close();
         this.intentionalDisconnect = true;
         if (this.reconnectTimer) {
             clearTimeout(this.reconnectTimer);
@@ -5549,6 +6003,7 @@ export class AUNChannel {
             this.store = null;
         }
         this.connected = false;
+        this.clearQueuedObserverSends('intentional disconnect');
         appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'disconnected', aid: this.config.aid, reason: 'intentional' });
         appendAidLifecycle({ ts: Date.now(), iso: new Date().toISOString(), event: 'disconnected', aid: this.config.aid, reason: 'intentional' });
         this.setAidStatus('disabled');
@@ -5599,15 +6054,15 @@ export class AUNChannel {
         };
     }
     /** 读取本地 agent.md 中的 name（用于身份上下文展示），若本地不存在则尝试远程拉取 */
-    loadSelfName(aid) {
+    loadSelfName(aid, aunPath) {
         const aidName = aid.startsWith('@') ? aid.slice(1) : aid;
-        const name = resolveAgentDisplayName(aidName);
+        const name = resolveAgentDisplayName(aidName, { aunPath });
         if (!name)
-            void this.fetchAndCacheSelfName(aidName);
+            void this.fetchAndCacheSelfName(aidName, aunPath);
         return name;
     }
-    async fetchAndCacheSelfName(aidName) {
-        const name = await refreshAgentDisplayName(aidName);
+    async fetchAndCacheSelfName(aidName, aunPath) {
+        const name = await refreshAgentDisplayName(aidName, { aunPath });
         if (name) {
             this._selfName = name;
             if (this.aidStatsCollector)
@@ -5624,13 +6079,20 @@ export class AUNChannel {
         if (!this.client)
             return { type: null };
         try {
+            const client = this.client;
+            const revision = this.peerInfoRevision;
             const selfAgentDir = path.join(resolvePaths().agentsDir, this.config.aid);
-            const identity = await PeerIdentityCache.resolve('aun', aid, selfAgentDir, this.store, false);
-            const type = identity.type === 'human' ? 'human' : 'ai';
+            const identity = await PeerIdentityCache.resolve('aun', aid, selfAgentDir, this.store, false, this.config.keystorePath || resolveRoot());
+            const type = identity.type === 'human' ? 'human' : 'agent';
             const name = identity.name || undefined;
             const info = { type, name };
-            this.peerInfoCache.set(aid, info);
-            setTimeout(() => this.peerInfoCache.delete(aid), 30 * 60 * 1000);
+            if (identity.lastCheckedAt !== 0 && this.client === client && this.peerInfoRevision === revision) {
+                this.peerInfoCache.set(aid, info);
+                setTimeout(() => {
+                    if (this.peerInfoCache.get(aid) === info)
+                        this.peerInfoCache.delete(aid);
+                }, 30 * 60 * 1000);
+            }
             return info;
         }
         catch (e) {
@@ -5652,13 +6114,20 @@ export class AUNChannel {
         if (!this.store)
             throw new Error('not connected');
         const { agentmdPut } = await import('../aun/aid/agentmd.js');
-        await agentmdPut(content, { aid: this.config.aid, store: this.store });
+        await agentmdPut(content, {
+            aid: this.config.aid,
+            store: this.store,
+            aunPath: this.config.keystorePath || resolveRoot(),
+        });
     }
     async downloadAgentMd(aid) {
         if (!this.store)
             throw new Error('not connected');
         const { agentmdSync } = await import('../aun/aid/agentmd.js');
-        const result = await agentmdSync(aid, { store: this.store ?? undefined });
+        const result = await agentmdSync(aid, {
+            store: this.store ?? undefined,
+            aunPath: this.config.keystorePath || resolveRoot(),
+        });
         return result.content ?? '';
     }
     /**
@@ -5757,7 +6226,7 @@ export class AUNChannelPlugin {
                 const dedupeOperationId = payload.kind === 'result.text' && payload.isFinal === false
                     ? undefined
                     : operationId;
-                const replyCtx = outboundCausation
+                let replyCtx = outboundCausation
                     ? {
                         ...(envelope.replyContext ?? {}),
                         delivery,
@@ -5766,6 +6235,13 @@ export class AUNChannelPlugin {
                     : (envelope.replyContext || envelope.delivery)
                         ? { ...(envelope.replyContext ?? {}), delivery }
                         : undefined;
+                const attention = aunOutboundAttention(payload);
+                if (replyCtx) {
+                    replyCtx = { ...replyCtx };
+                    delete replyCtx.attention;
+                }
+                if (attention !== undefined)
+                    replyCtx = { ...(replyCtx ?? {}), attention };
                 if (outboundCausation) {
                     recordCausationSpan(outboundCausation, 'message.outbound', {
                         status: 'started',
@@ -5777,12 +6253,34 @@ export class AUNChannelPlugin {
                     case 'result.text':
                     case 'command.result':
                     case 'command.error': {
+                        // Group command feedback is control traffic, not model input for
+                        // the other agents in the conversation.
+                        if (delivery.chatType === 'group'
+                            && (payload.kind === 'command.result' || payload.kind === 'command.error')) {
+                            const isError = payload.kind === 'command.error';
+                            const feedback = {
+                                type: isError ? 'error' : 'notice',
+                                ...taskBase(),
+                                subtype: payload.kind,
+                                text: payload.text,
+                                ...(isError
+                                    ? { message: payload.text, user_message: payload.text, recoverable: true }
+                                    : { severity: 'info' }),
+                            };
+                            for (const key of ['format', 'reason', 'reasonCode', 'nextStep']) {
+                                setIfDefined(feedback, key, payload[key]);
+                            }
+                            await channel.sendReliableStructured(channelId, feedback, { ...(replyCtx ?? {}), suppressPeerMention: true }, payload.text);
+                            return;
+                        }
                         const sendCtx = {
                             ...(replyCtx ?? {}),
                             metadata: {
                                 ...Object.fromEntries(Object.entries(replyCtx?.metadata ?? {})
                                     .filter(([key]) => key !== 'operationId')),
                                 ...(dedupeOperationId ? { operationId: dedupeOperationId } : {}),
+                                ...(payload.kind === 'result.text' && payload.metadata?.forkAnchor
+                                    ? { forkAnchor: payload.metadata.forkAnchor } : {}),
                             },
                         };
                         if (payload.kind === 'result.text' && payload.isFinal)
@@ -5810,7 +6308,7 @@ export class AUNChannelPlugin {
                                 messages: [{
                                         messageId: result.messageId,
                                         partIndex: 0,
-                                        ...(sendCtx.threadId ? { threadId: sendCtx.threadId } : {}),
+                                        ...(typeof sendCtx.threadId === 'string' ? { threadId: sendCtx.threadId } : {}),
                                     }],
                             };
                         }
@@ -5846,14 +6344,13 @@ export class AUNChannelPlugin {
                     }
                     case 'system.error': {
                         const errorPayload = {
-                            type: 'error',
+                            type: payload.recoverable === true ? 'notice' : 'error',
                             ...taskBase(),
                             subtype: payload.subtype,
                             text: payload.text,
-                            message: payload.text,
-                            user_message: payload.text,
-                            recoverable: payload.recoverable === true,
-                            terminal: payload.recoverable !== true,
+                            ...(payload.recoverable === true
+                                ? { severity: 'warn' }
+                                : { message: payload.text, user_message: payload.text, recoverable: false }),
                         };
                         await channel.sendReliableStructured(channelId, errorPayload, { ...(replyCtx ?? {}), suppressPeerMention: true }, payload.text);
                         return;
@@ -5866,7 +6363,6 @@ export class AUNChannelPlugin {
                             text: payload.text,
                             message: payload.text,
                             user_message: payload.text,
-                            terminal: true,
                         };
                         await channel.sendReliableStructured(channelId, errorPayload, { ...(replyCtx ?? {}), suppressPeerMention: true }, payload.text);
                         return;
@@ -5875,8 +6371,27 @@ export class AUNChannelPlugin {
                         const fileCtx = payload.correlationId
                             ? { ...(replyCtx ?? {}), metadata: { ...(replyCtx?.metadata ?? {}), correlationId: payload.correlationId } }
                             : replyCtx;
-                        await channel.sendFile(channelId, payload.filePath, fileCtx);
-                        return;
+                        const result = await channel.sendFile(channelId, payload.filePath, fileCtx);
+                        if (result.status === 'sent')
+                            return sentReceipt(envelope, [result.messageId], fileCtx?.threadId);
+                        if (result.status === 'queued') {
+                            return {
+                                status: 'queued',
+                                operationId,
+                                messages: [],
+                                outboxId: result.outboxId,
+                                ...(result.error !== undefined ? { error: result.error } : {}),
+                                ...(result.code !== undefined ? { code: result.code } : {}),
+                            };
+                        }
+                        return {
+                            status: 'failed',
+                            operationId,
+                            messages: [],
+                            ...(result.outboxId !== undefined ? { outboxId: result.outboxId } : {}),
+                            error: result.error,
+                            ...(result.code !== undefined ? { code: result.code } : {}),
+                        };
                     }
                     case 'result.image': {
                         await channel.sendImage(channelId, payload.data, payload.mimeType, payload.alt, replyCtx);
@@ -6020,13 +6535,13 @@ export class AUNChannelPlugin {
                         };
                         if (req.kind.kind === 'action') {
                             const action = req.kind;
-                            const aunCard = {
+                            const aunCard = withAunAttention({
                                 type: 'action_card',
                                 title: action.title,
                                 actions: action.buttons.map(btn => ({
                                     label: btn.label, value: btn.key, style: btn.style ?? 'default', behavior: 'reply',
                                 })),
-                            };
+                            });
                             // AUN action_card 以 compose behavior 声明自由文本动作。新版客户端
                             // 在卡片内采集并确认；旧版客户端可继续从主编辑器采集。两者都结构化
                             // 回传 action_card_reply{behavior:"compose"}，Core 不拦截普通消息队列。
@@ -6044,6 +6559,7 @@ export class AUNChannelPlugin {
                             const result = await channel.sendContentPayload(channelId, aunCard, {
                                 contentKind: 'card',
                                 context: replyCtx,
+                                dedupeKey: req.id.startsWith('gir-') ? operationId : undefined,
                                 logText: action.title ? `[card] ${action.title}` : '[card]',
                                 postSend: {
                                     type: 'register_interaction_card',
@@ -6058,7 +6574,7 @@ export class AUNChannelPlugin {
                         }
                         else if (req.kind.kind === 'command-card') {
                             const card = req.kind;
-                            const aunCard = {
+                            const aunCard = withAunAttention({
                                 type: 'action_card',
                                 title: card.title,
                                 actions: card.buttons.map(btn => {
@@ -6071,7 +6587,7 @@ export class AUNChannelPlugin {
                                     setIfDefined(action, 'disabled', btn.disabled);
                                     return action;
                                 }),
-                            };
+                            });
                             if (card.body) {
                                 aunCard.text = card.body;
                                 setIfDefined(aunCard, 'format', card.bodyFormat);
@@ -6162,6 +6678,14 @@ export class AUNChannelPlugin {
                 bridge.register(adapter.channelName, (handler) => channel.onMessage(async (opts) => {
                     handler(aunOptsToInbound(opts, adapter.channelName, channelType));
                 }), async (channelId, text, replyContext) => { await channel.sendMessage(channelId, text, replyContext); }, adapter, channelType);
+                bridge.registerGroupInviteReviewChannel({
+                    selfAid: aid,
+                    channelName: adapter.channelName,
+                    channelKey: adapter.channelKey,
+                    agentName: ctx.agentName,
+                    channel,
+                    adapter,
+                });
             },
             registerHooks(hookCtx) {
                 channel.setEventBus(hookCtx.eventBus);