evolclaw 2.3.0 → 2.5.0

package/dist/channels/aun.js

@@ -1,21 +1,66 @@
-import { AUNClient } from '@eleans/aun-core-node';
+import { AUNClient, GatewayDiscovery } from '@eleans/aun-core-sdk';
+import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { logger, localTimestamp } from '../utils/logger.js';
-import { normalizeChannelInstances } from '../config.js';
+import { normalizeChannelInstances, getChannelShowActivities } from '../config.js';
 import { resolvePaths } from '../paths.js';
+import { saveToUploads, sanitizeFileName } from '../utils/media-cache.js';
+function guessMime(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    const map = {
+        '.txt': 'text/plain', '.md': 'text/markdown', '.json': 'application/json',
+        '.js': 'text/javascript', '.ts': 'text/typescript', '.py': 'text/x-python',
+        '.html': 'text/html', '.css': 'text/css', '.csv': 'text/csv',
+        '.pdf': 'application/pdf', '.zip': 'application/zip', '.gz': 'application/gzip',
+        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+        '.xml': 'application/xml', '.yaml': 'application/x-yaml', '.yml': 'application/x-yaml',
+    };
+    return map[ext] || 'application/octet-stream';
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1048576)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+}
 export class AUNChannel {
     config;
     client = null;
+    projectPathProvider;
     messageHandler;
+    recallHandler;
     connected = false;
     traceStream = null;
+    traceDate = ''; // 当前 trace 文件对应的日期 (YYYYMMDD)
     trace(dir, event, data) {
+        if (!this.config.aunTrace)
+            return;
+        this.rotateTraceIfNeeded();
         if (!this.traceStream)
             return;
         const line = JSON.stringify({ ts: localTimestamp(), dir, event, data });
         this.traceStream.write(line + '\n');
     }
+    rotateTraceIfNeeded() {
+        const d = new Date();
+        const today = `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, '0')}${String(d.getDate()).padStart(2, '0')}`;
+        if (this.traceDate === today && this.traceStream)
+            return;
+        if (this.traceStream) {
+            this.traceStream.end();
+            this.traceStream = null;
+        }
+        this.traceDate = today;
+        const logPath = path.join(resolvePaths().logs, `aun-${today}.log`);
+        this.traceStream = fs.createWriteStream(logPath, { flags: 'a' });
+    }
+    /** 判断 channelId 是否为群组 ID（g-xxx.agentid.pub 或 grp_ 前缀） */
+    isGroupId(id) {
+        return id.startsWith('grp_') || (id.startsWith('g-') && id.includes('.'));
+    }
     getShortAid(aid) {
         if (!aid)
             return undefined;
@@ -39,25 +84,23 @@ export class AUNChannel {
         const escaped = target.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         return new RegExp(`(^|\\s)@${escaped}(?=$|\\s|[.,!?;:，。！？；：]|[\\u4e00-\\u9fff])`).test(text);
     }
-    stripTriggerMentions(text, selfAid) {
-        let result = text;
-        if (selfAid) {
-            const escapedAid = selfAid.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            result = result.replace(new RegExp(`(^|\\s)@${escapedAid}(?=$|\\s|[.,!?;:，。！？；：]|[\\u4e00-\\u9fff])`, 'g'), '$1');
-        }
-        result = result.replace(/(^|\s)@all(?=$|\s|[.,!?;:，。！？；：]|[\u4e00-\u9fff])/gi, '$1');
-        return result.replace(/[ \t]+/g, ' ').trim();
+    stripSelfMentionIfOnly(text, selfAid) {
+        if (!selfAid)
+            return text;
+        const mentions = text.match(/@[\w.-]+/g) || [];
+        if (mentions.length !== 1)
+            return text;
+        const escapedAid = selfAid.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return text
+            .replace(new RegExp(`(^|\\s)@${escapedAid}(?=$|\\s|[.,!?;:，。！？；：]|[\\u4e00-\\u9fff])`, 'g'), '$1')
+            .replace(/[ \t]+/g, ' ')
+            .trim();
     }
-    buildGroupReplyContext(taskId, senderAid, text) {
+    buildGroupReplyContext(taskId, senderAid) {
         const replyContext = {};
         if (taskId)
             replyContext.threadId = taskId;
-        if (this.hasExplicitMention(text, 'all')) {
-            replyContext.mentionUserIds = ['all'];
-        }
-        else {
-            replyContext.mentionUserIds = [senderAid];
-        }
+        replyContext.peerId = senderAid;
         return replyContext;
     }
     acknowledgeImmediately(messageId, seq) {
@@ -70,7 +113,9 @@ export class AUNChannel {
             this.messageSeqMap.delete(messageId);
     }
     _aid;
+    _chatId = ''; // aid:device_id:slot_id — 多实例回声过滤
     seenMessages = new Map();
+    peerInfoCache = new Map();
     messageSeqMap = new Map(); // messageId → seq (for ack)
     sentCount = new Map(); // channelId → 已发消息计数（用于判断最终回复）
     // Reconnect state (TS-layer fallback, on top of SDK auto_reconnect)
@@ -79,12 +124,17 @@ export class AUNChannel {
     reconnectTimer = null;
     static RECONNECT_DELAYS = [60, 120, 300, 600]; // seconds
     onChannelDown;
+    // SDK reconnect throttling — avoid log spam when SDK enters tight reconnect loop
+    lastReconnectLogTime = 0;
+    lastReconnectLogAttempt = 0;
+    static RECONNECT_LOG_INTERVAL = 60_000; // log at most every 60s
+    static RECONNECT_LOG_STEP = 100; // or every 100 attempts
+    static SDK_RECONNECT_GIVEUP = 50; // force TS-layer fallback after this many SDK attempts
     constructor(config) {
         this.config = config;
         if (config.aunTrace) {
-            const logPath = path.join(resolvePaths().logs, 'aun-trace.log');
-            this.traceStream = fs.createWriteStream(logPath, { flags: 'a' });
-            logger.info(`[AUN] Trace logging enabled: ${logPath}`);
+            this.rotateTraceIfNeeded();
+            logger.info(`[AUN] Trace logging enabled (daily rotation): ${resolvePaths().logs}/aun-YYYYMMDD.log`);
         }
     }
     async connect() {
@@ -105,18 +155,22 @@ export class AUNChannel {
         const aunPath = this.config.keystorePath || `${process.env.HOME || '~'}/.aun`;
         const aidName = this.config.aid;
         const encryptionSeed = this.config.encryptionSeed || process.env.AUN_ENCRYPTION_SEED || undefined;
-        // Gateway URL: 旧配置 gatewayUrl 优先，否则从 AID 推导
+        // Gateway URL 解析：优先用配置的 gatewayUrl，否则通过 well-known 自动发现
         let gateway = this.config.gatewayUrl || '';
         if (!gateway) {
-            const parts = aidName.split('.');
-            if (parts.length >= 3) {
-                const domain = parts.slice(1).join('.'); // alice.agentid.pub → agentid.pub
-                const port = this.config.gatewayPort || 443;
-                gateway = `wss://gateway.${domain}:${port}/aun`;
+            // AID 本身即域名（如 evolai.agentid.pub），用其查询 well-known，与 Python SDK 行为对齐
+            const wellKnownUrl = `https://${aidName}/.well-known/aun-gateway`;
+            try {
+                const discovery = new GatewayDiscovery({});
+                gateway = await discovery.discover(wellKnownUrl);
+                logger.info(`[AUN] Gateway discovered: ${gateway}`);
+            }
+            catch (e) {
+                logger.warn(`[AUN] Well-known discovery failed (${e}), no fallback available`);
             }
         }
         if (!gateway) {
-            logger.error('[AUN] Cannot derive gateway URL from AID');
+            logger.error('[AUN] Cannot resolve gateway URL from AID');
             return;
         }
         logger.info(`[AUN] Initializing: aid=${aidName}, gateway=${gateway}, aun_path=${aunPath}`);
@@ -146,10 +200,36 @@ export class AUNChannel {
             this.handleIncomingGroupMessage(data);
         });
         this.client.on('connection.state', (data) => {
-            this.trace('IN', 'connection.state', data);
+            // trace is handled inside handleConnectionState with throttling
             this.handleConnectionState(data);
         });
+        this.client.on('message.recalled', (data) => {
+            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(`[AUN] Message recalled: ${id}`);
+                            this.recallHandler?.(id);
+                        }
+                    }
+                }
+            }
+        });
         // Authenticate
+        // Workaround: SDK 0.3.x _loadIdentityOrRaise doesn't set identity.aid from requested aid,
+        // causing gateway "missing aid" error. Patch to backfill aid on loaded identity.
+        const authFlow = this.client._auth;
+        if (authFlow && typeof authFlow._loadIdentityOrRaise === 'function') {
+            const origLoad = authFlow._loadIdentityOrRaise.bind(authFlow);
+            authFlow._loadIdentityOrRaise = (aid) => {
+                const identity = origLoad(aid);
+                if (identity && !identity.aid)
+                    identity.aid = aid ?? authFlow._aid;
+                return identity;
+            };
+        }
         let accessToken;
         try {
             logger.info(`[AUN] Authenticating as ${aidName}...`);
@@ -169,7 +249,8 @@ export class AUNChannel {
             // Fallback: try direct token from env/config (legacy)
             accessToken = this.config.accessToken || process.env.AUN_ACCESS_TOKEN || '';
             if (!accessToken) {
-                logger.error(`[AUN] No accessToken fallback available, AUN channel disabled`);
+                logger.error(`[AUN] No accessToken fallback available, scheduling retry`);
+                this.scheduleReconnect();
                 return;
             }
             logger.warn(`[AUN] Using accessToken fallback`);
@@ -178,16 +259,88 @@ export class AUNChannel {
         try {
             await this.client.connect({ access_token: accessToken, gateway: this.client._gatewayUrl }, { auto_reconnect: true, retry: { max_attempts: 5, initial_delay: 1.0, max_delay: 30.0 } });
             this._aid = this.client.aid ?? undefined;
+            const deviceId = this.client._device_id ?? '';
+            this._chatId = this._aid ? `${this._aid}:${deviceId}:` : '';
             this.connected = true;
             this.reconnectAttempt = 0;
+            // Workaround: SDK e2ee uses _identity.cert for sender_cert_fingerprint;
+            // if cert is missing, it falls back to public key SPKI fingerprint which
+            // causes peer cert lookup failures. Backfill from keystore if needed.
+            const clientAny = this.client;
+            if (clientAny._identity && !clientAny._identity.cert) {
+                const cert = clientAny._keystore?.loadCert?.(aidName);
+                if (cert) {
+                    clientAny._identity.cert = cert;
+                    logger.info('[AUN] Backfilled identity.cert from keystore for e2ee fingerprint');
+                }
+            }
             logger.info(`[AUN] Connected as ${this._aid}`);
         }
         catch (e) {
             logger.error(`[AUN] Connection failed: ${e}`);
+            this.scheduleReconnect();
             return;
         }
     }
     // ── Event handlers ──────────────────────────────────────────
+    async downloadAttachment(att, channelId) {
+        const ownerAid = att.owner_aid || this._aid || '';
+        const objectKey = att.object_key;
+        const filename = att.filename || objectKey.split('/').pop() || 'unknown';
+        if (!objectKey) {
+            logger.warn('[AUN] Attachment missing object_key, skipping');
+            return null;
+        }
+        let downloadUrl;
+        try {
+            const ticket = await this.client.call('storage.create_download_ticket', {
+                owner_aid: ownerAid,
+                object_key: objectKey,
+            });
+            downloadUrl = ticket.download_url || '';
+            if (!downloadUrl) {
+                logger.warn(`[AUN] No download_url for attachment: ${filename}`);
+                return null;
+            }
+        }
+        catch (e) {
+            logger.warn(`[AUN] create_download_ticket failed for ${filename}: ${e}`);
+            return null;
+        }
+        let buffer;
+        try {
+            const res = await fetch(downloadUrl);
+            if (!res.ok) {
+                logger.warn(`[AUN] Download failed for ${filename}: HTTP ${res.status}`);
+                return null;
+            }
+            buffer = Buffer.from(await res.arrayBuffer());
+        }
+        catch (e) {
+            logger.warn(`[AUN] Download error for ${filename}: ${e}`);
+            return null;
+        }
+        if (att.sha256) {
+            const { createHash } = await import('node:crypto');
+            const actual = createHash('sha256').update(buffer).digest('hex');
+            if (actual !== att.sha256) {
+                logger.warn(`[AUN] SHA256 mismatch for ${filename}: expected ${att.sha256.slice(0, 8)}… got ${actual.slice(0, 8)}…`);
+                return null;
+            }
+        }
+        const projectPath = this.projectPathProvider
+            ? await this.projectPathProvider(channelId)
+            : process.cwd();
+        try {
+            const result = saveToUploads(buffer, filename, projectPath);
+            logger.info(`[AUN] Saved attachment: ${result.filePath} (${result.size} bytes)`);
+            return result.filePath;
+        }
+        catch (e) {
+            logger.warn(`[AUN] saveToUploads failed for ${filename}: ${e}`);
+            return null;
+        }
+    }
     async handleIncomingPrivateMessage(data) {
         if (!data || typeof data !== 'object')
             return;
@@ -195,23 +348,62 @@ export class AUNChannel {
         const fromAid = msg.from ?? '';
         const payload = msg.payload ?? '';
         const text = this.extractTextPayload(payload);
-        const taskId = msg.task_id;
+        const taskId = typeof payload === 'object' && payload !== null ? payload.thread_id : undefined;
         const messageId = msg.message_id ?? '';
         const seq = msg.seq;
+        // 回声过滤：自己发出的消息会被 gateway fanout 回来，
+        // 只有 from_aid == self 且 chat_id 不匹配时才丢弃（说明是其它实例发的）
+        const msgChatId = typeof payload === 'object' && payload !== null && payload.chat_id;
+        if (this._aid && fromAid === this._aid && (!msgChatId || !this._chatId || msgChatId !== this._chatId)) {
+            this.acknowledgeImmediately(messageId, seq);
+            return;
+        }
         // Detect @mentions
         const mentions = [];
         if (this._aid && text.includes(`@${this._aid}`)) {
             mentions.push(this._aid);
         }
+        // Process attachments
+        const rawAttachments = Array.isArray(payload?.attachments)
+            ? payload.attachments
+            : [];
+        let finalText = text;
+        if (rawAttachments.length > 0 && this.client) {
+            const fileParts = [];
+            for (const att of rawAttachments) {
+                const filePath = await this.downloadAttachment(att, fromAid);
+                if (filePath) {
+                    const name = sanitizeFileName(att.filename || att.object_key?.split('/').pop() || 'file');
+                    fileParts.push(`[文件: ${name} → ${filePath}]`);
+                }
+            }
+            if (fileParts.length > 0) {
+                const parts = [];
+                if (text)
+                    parts.push(text);
+                parts.push(...fileParts);
+                parts.push('请使用 Read 工具读取文件内容。');
+                finalText = parts.join('\n\n');
+            }
+        }
+        // Extract chat_id from payload for multi-instance routing (falls back to fromAid)
+        const chatId = (typeof payload === 'object' && payload !== null && payload.chat_id)
+            ? String(payload.chat_id)
+            : fromAid;
+        const peerInfo = await this.fetchPeerInfo(fromAid);
+        const shortAid = this.getShortAid(fromAid);
+        const displayName = peerInfo.name || shortAid;
         this.dispatchMessage({
-            channelId: fromAid,
+            channelId: chatId,
             userId: fromAid,
-            text,
+            text: finalText,
             chatType: 'private',
             messageId,
             seq,
             taskId,
             mentions,
+            peerName: displayName || undefined,
+            peerType: peerInfo.type || 'unknown',
         });
     }
     async handleIncomingGroupMessage(data) {
@@ -219,12 +411,16 @@ export class AUNChannel {
             return;
         const msg = data;
         const groupId = msg.group_id ?? '';
-        const senderAid = msg.sender_aid ?? msg.from ?? '';
+        const senderAid = msg.sender_aid ?? '';
         const payload = msg.payload ?? '';
         const text = this.extractTextPayload(payload);
-        const taskId = msg.task_id;
+        const taskId = typeof payload === 'object' && payload !== null ? payload.thread_id : undefined;
         const messageId = msg.message_id ?? '';
         const seq = msg.seq;
+        // Extract structured mentions from payload (e.g. payload.mentions: ["evolai.agentid.pub"])
+        const payloadMentions = Array.isArray(payload?.mentions)
+            ? payload.mentions.filter((m) => typeof m === 'string')
+            : [];
         logger.info(`[AUN][DIAG-GRP] full_msg=${JSON.stringify(msg).substring(0, 500)}`);
         if (!groupId || !senderAid) {
             this.acknowledgeImmediately(messageId, seq);
@@ -234,29 +430,61 @@ export class AUNChannel {
             this.acknowledgeImmediately(messageId, seq);
             return;
         }
-        const mentionedSelf = this._aid ? this.hasExplicitMention(text, this._aid) : false;
-        const mentionedAll = this.hasExplicitMention(text, 'all');
+        const mentionedSelf = this._aid
+            ? (this.hasExplicitMention(text, this._aid) || payloadMentions.includes(this._aid))
+            : false;
+        const mentionedAll = this.hasExplicitMention(text, 'all') || payloadMentions.includes('all');
         if (!mentionedSelf && !mentionedAll) {
             this.acknowledgeImmediately(messageId, seq);
             return;
         }
-        const strippedText = this.stripTriggerMentions(text, this._aid);
-        if (!strippedText) {
+        const strippedText = this.stripSelfMentionIfOnly(text, this._aid);
+        // Detect attachments before the empty-text guard
+        const rawAttachments = Array.isArray(payload?.attachments)
+            ? payload.attachments
+            : [];
+        const hasAttachments = rawAttachments.length > 0;
+        // Allow through if there's text OR attachments; both-empty messages are silently dropped
+        if (!strippedText && !hasAttachments) {
             this.acknowledgeImmediately(messageId, seq);
             return;
         }
         const mentions = mentionedAll ? ['all'] : (this._aid ? [this._aid] : []);
+        // Process attachments
+        let finalText = strippedText;
+        if (hasAttachments && this.client) {
+            const fileParts = [];
+            for (const att of rawAttachments) {
+                const filePath = await this.downloadAttachment(att, groupId);
+                if (filePath) {
+                    const name = sanitizeFileName(att.filename || att.object_key?.split('/').pop() || 'file');
+                    fileParts.push(`[文件: ${name} → ${filePath}]`);
+                }
+            }
+            if (fileParts.length > 0) {
+                const parts = [];
+                if (strippedText)
+                    parts.push(strippedText);
+                parts.push(...fileParts);
+                parts.push('请使用 Read 工具读取文件内容。');
+                finalText = parts.join('\n\n');
+            }
+        }
+        const peerInfo = await this.fetchPeerInfo(senderAid);
+        const shortAid = this.getShortAid(senderAid);
+        const displayName = peerInfo.name || shortAid;
         this.dispatchMessage({
             channelId: groupId,
             userId: senderAid,
-            peerName: this.getShortAid(senderAid),
-            text: strippedText,
+            peerName: displayName || undefined,
+            peerType: peerInfo.type || 'unknown',
+            text: finalText,
             chatType: 'group',
             messageId,
             seq,
             taskId,
             mentions,
-            replyContext: this.buildGroupReplyContext(taskId, senderAid, text),
+            replyContext: this.buildGroupReplyContext(taskId, senderAid),
         });
     }
     dispatchMessage(event) {
@@ -286,6 +514,7 @@ export class AUNChannel {
             chatType: event.chatType,
             peerId: event.userId || event.channelId || '',
             peerName: event.peerName,
+            peerType: event.peerType,
             messageId: event.messageId,
             threadId: event.taskId,
             mentions: mentionObjects,
@@ -301,6 +530,8 @@ export class AUNChannel {
         if (state === 'connected') {
             this.connected = true;
             this.reconnectAttempt = 0;
+            this.lastReconnectLogTime = 0;
+            this.lastReconnectLogAttempt = 0;
             logger.info('[AUN] Connected');
         }
         else if (state === 'disconnected') {
@@ -308,21 +539,50 @@ export class AUNChannel {
             logger.warn(`[AUN] Disconnected: ${data.error ?? 'unknown'}`);
         }
         else if (state === 'reconnecting') {
-            logger.info(`[AUN] SDK reconnecting (attempt ${data.attempt})`);
+            const attempt = data.attempt ?? 0;
+            const now = Date.now();
+            // Throttled logging: first attempt, every N attempts, or every M seconds
+            const isFirst = attempt <= 1;
+            const isStep = attempt - this.lastReconnectLogAttempt >= AUNChannel.RECONNECT_LOG_STEP;
+            const isInterval = now - this.lastReconnectLogTime >= AUNChannel.RECONNECT_LOG_INTERVAL;
+            if (isFirst || isStep || isInterval) {
+                const suppressed = attempt - this.lastReconnectLogAttempt - 1;
+                const suffix = suppressed > 0 ? `, ${suppressed} suppressed since last log` : '';
+                logger.info(`[AUN] SDK reconnecting (attempt ${attempt}${suffix})`);
+                this.lastReconnectLogTime = now;
+                this.lastReconnectLogAttempt = attempt;
+                this.trace('IN', 'connection.state', data);
+            }
+            // Detect runaway SDK reconnect loop: force disconnect and use TS-layer backoff
+            if (attempt >= AUNChannel.SDK_RECONNECT_GIVEUP && !this.intentionalDisconnect) {
+                logger.warn(`[AUN] SDK reconnect stuck at attempt ${attempt}, forcing TS-layer reconnect with backoff`);
+                this.connected = false;
+                if (this.client) {
+                    this.client.close().catch(() => { });
+                    this.client = null;
+                }
+                this.scheduleReconnect();
+            }
         }
         else if (state === 'terminal_failed') {
             this.connected = false;
-            logger.error(`[AUN] Terminal failure: ${data.error ?? 'unknown'}`);
-            // SDK auto_reconnect exhausted; fall back to TS-layer reconnect
+            const reason = data.reason ?? '';
+            logger.error(`[AUN] Terminal failure: ${data.error ?? 'unknown'}${reason ? ` (${reason})` : ''}`);
             if (!this.intentionalDisconnect) {
                 this.scheduleReconnect();
             }
         }
     }
     // ── Public API (same interface as before) ───────────────────
+    onProjectPathRequest(provider) {
+        this.projectPathProvider = provider;
+    }
     onMessage(handler) {
         this.messageHandler = handler;
     }
+    onRecall(handler) {
+        this.recallHandler = handler;
+    }
     async sendMessage(channelId, text, context) {
         if (!this.connected || !this.client) {
             logger.warn('[AUN] Cannot send: not connected');
@@ -338,24 +598,30 @@ export class AUNChannel {
             finalText = '最终回复\n' + text;
         }
         this.sentCount.set(channelId, (this.sentCount.get(channelId) || 0) + 1);
-        // Render outbound mentions for group sends
-        if (channelId.startsWith('grp_') && context?.mentionUserIds?.length) {
-            const mentionPrefix = context.mentionUserIds.includes('all')
-                ? '@all '
-                : context.mentionUserIds.map(id => `@${id}`).join(' ') + ' ';
-            finalText = mentionPrefix + finalText;
-        }
-        const params = { payload: { text: finalText }, encrypt: true };
+        // 群聊 @ 兜底：提示词已告知 agent 要 @，但如果 agent 没写，系统自动补上
+        if (this.isGroupId(channelId) && context?.peerId) {
+            if (!finalText.includes(`@${context.peerId}`)) {
+                finalText = `@${context.peerId} ` + finalText;
+            }
+        }
+        const payload = { type: 'text', text: finalText };
         if (context?.threadId)
-            params.task_id = context.threadId;
+            payload.thread_id = context.threadId;
+        const params = { payload, encrypt: true };
+        // Multi-instance routing: channelId may be "aid:device_id:slot_id"
+        const colonIdx = channelId.indexOf(':');
+        const targetAid = colonIdx > 0 ? channelId.substring(0, colonIdx) : channelId;
+        if (colonIdx > 0) {
+            params.payload.chat_id = channelId;
+        }
         try {
-            if (channelId.startsWith('grp_')) {
+            if (this.isGroupId(channelId)) {
                 params.group_id = channelId;
                 this.trace('OUT', 'group.send', params);
                 await this.client.call('group.send', params);
             }
             else {
-                params.to = channelId;
+                params.to = targetAid;
                 this.trace('OUT', 'message.send', params);
                 await this.client.call('message.send', params);
             }
@@ -365,33 +631,136 @@ export class AUNChannel {
             logger.error(`[AUN] Send failed to ${channelId}: ${e}`);
         }
     }
-    acknowledge(messageId) {
-        const seq = this.messageSeqMap.get(messageId);
-        if (seq != null && this.client) {
-            this.client.call('message.ack', { seq }).catch(e => {
-                logger.debug(`[AUN] Ack failed: ${e}`);
-            });
-            this.messageSeqMap.delete(messageId);
+    async sendFile(channelId, filePath, context) {
+        if (!this.connected || !this.client) {
+            logger.warn('[AUN] Cannot sendFile: not connected');
+            return;
+        }
+        const absPath = path.resolve(filePath);
+        if (!fs.existsSync(absPath)) {
+            logger.warn(`[AUN] sendFile: file not found: ${absPath}`);
+            return;
+        }
+        const stat = fs.statSync(absPath);
+        if (stat.size === 0) {
+            logger.warn('[AUN] sendFile: file is empty');
+            return;
+        }
+        if (stat.size > 10 * 1024 * 1024) {
+            logger.warn(`[AUN] sendFile: file too large (${formatSize(stat.size)}, max 10 MB)`);
+            return;
+        }
+        const filename = path.basename(absPath);
+        const fileData = fs.readFileSync(absPath);
+        const sha256 = crypto.createHash('sha256').update(fileData).digest('hex');
+        const contentType = guessMime(filename);
+        const objectKey = `shared/${crypto.randomUUID()}/${filename}`;
+        try {
+            // Upload to storage
+            if (stat.size <= 64 * 1024) {
+                // Inline upload for small files (≤64KB)
+                await this.client.call('storage.put_object', {
+                    object_key: objectKey,
+                    content: fileData.toString('base64'),
+                    content_type: contentType,
+                    is_private: false,
+                    overwrite: true,
+                });
+            }
+            else {
+                // Ticket upload for large files
+                const session = await this.client.call('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');
+                const uploadResp = await fetch(uploadUrl, { method: 'PUT', body: fileData });
+                if (!uploadResp.ok)
+                    throw new Error(`HTTP upload failed: ${uploadResp.status}`);
+                await this.client.call('storage.complete_upload', {
+                    object_key: objectKey,
+                    sha256,
+                    content_type: contentType,
+                    is_private: false,
+                    size_bytes: stat.size,
+                });
+            }
+            // Send message with attachment
+            const attachment = {
+                owner_aid: this._aid || '',
+                object_key: objectKey,
+                filename,
+                size_bytes: stat.size,
+                sha256,
+                content_type: contentType,
+            };
+            const filePayload = {
+                type: 'file',
+                text: `📎 ${filename} (${formatSize(stat.size)})`,
+                attachments: [attachment],
+            };
+            if (context?.threadId)
+                filePayload.thread_id = context.threadId;
+            const params = { payload: filePayload, encrypt: true };
+            // Multi-instance routing
+            const fileColonIdx = channelId.indexOf(':');
+            const fileTargetAid = fileColonIdx > 0 ? channelId.substring(0, fileColonIdx) : channelId;
+            if (fileColonIdx > 0) {
+                params.payload.chat_id = channelId;
+            }
+            if (this.isGroupId(channelId)) {
+                params.group_id = channelId;
+                this.trace('OUT', 'group.send.file', params);
+                await this.client.call('group.send', params);
+            }
+            else {
+                params.to = fileTargetAid;
+                this.trace('OUT', 'message.send.file', params);
+                await this.client.call('message.send', params);
+            }
+            logger.info(`[AUN] File sent: ${filename} (${formatSize(stat.size)}) → ${channelId}`);
+        }
+        catch (e) {
+            this.trace('OUT', 'sendFile.error', { channelId, filePath, error: String(e) });
+            logger.error(`[AUN] sendFile failed for ${channelId}: ${e}`);
         }
     }
+    acknowledge(messageId) {
+        // Gateway auto-delivery-ack is sufficient; skip explicit message.ack RPC
+        // to avoid duplicate "已送达" at the sender CLI
+        this.messageSeqMap.delete(messageId);
+    }
     sendProcessingStatus(channelId, status, sessionId, context) {
         if (status === 'start')
             this.sentCount.delete(channelId); // 新任务开始，重置计数
         if (!this.client || !this.connected)
             return;
-        const payload = {
-            type: 'processing',
-            status,
-            sessionId,
-            timestamp: Math.floor(Date.now() / 1000),
+        const eventMap = {
+            start: 'task.started',
+            done: 'task.completed',
+            interrupted: 'task.interrupted',
+            error: 'task.error',
+            timeout: 'task.timeout',
         };
-        const params = {
-            payload,
-            encrypt: true, persist: false,
+        const payload = {
+            type: 'event',
+            event: eventMap[status] ?? `task.${status}`,
+            data: { session_id: sessionId },
+            severity: status === 'error' || status === 'timeout' ? 'error' : 'info',
         };
         if (context?.threadId)
-            params.task_id = context.threadId;
-        if (channelId.startsWith('grp_')) {
+            payload.thread_id = context.threadId;
+        const params = { payload, encrypt: true };
+        // Multi-instance routing
+        const statusColonIdx = channelId.indexOf(':');
+        const statusTargetAid = statusColonIdx > 0 ? channelId.substring(0, statusColonIdx) : channelId;
+        if (statusColonIdx > 0) {
+            payload.chat_id = channelId;
+        }
+        if (this.isGroupId(channelId)) {
             params.group_id = channelId;
             this.trace('OUT', 'group.send.status', params);
             this.client.call('group.send', params).catch(e => {
@@ -399,7 +768,7 @@ export class AUNChannel {
             });
         }
         else {
-            params.to = channelId;
+            params.to = statusTargetAid;
             this.trace('OUT', 'message.send.status', params);
             this.client.call('message.send', params).catch(e => {
                 logger.debug(`[AUN] Processing status failed: ${e}`);
@@ -419,9 +788,15 @@ export class AUNChannel {
         catch {
             payloadObj = { text: payload };
         }
+        // Multi-instance routing
+        const customColonIdx = channelId.indexOf(':');
+        const customTargetAid = customColonIdx > 0 ? channelId.substring(0, customColonIdx) : channelId;
+        if (customColonIdx > 0) {
+            payloadObj.chat_id = channelId;
+        }
         const sendParams = {
-            to: channelId, payload: payloadObj,
-            encrypt: true, persist: false,
+            to: customTargetAid, payload: payloadObj,
+            encrypt: true,
         };
         this.trace('OUT', 'message.send.custom', sendParams);
         this.client.call('message.send', sendParams).catch(e => {
@@ -507,6 +882,37 @@ export class AUNChannel {
             maxAttempts: AUNChannel.RECONNECT_DELAYS.length,
         };
     }
+    async fetchPeerInfo(aid) {
+        const cached = this.peerInfoCache.get(aid);
+        if (cached !== undefined)
+            return cached;
+        if (!this.client)
+            return { type: null };
+        try {
+            const md = await this.client.auth.downloadAgentMd(aid);
+            const typeMatch = md.match(/^type:\s*["']?(\w+)["']?/m);
+            const nameMatch = md.match(/^name:\s*["']?(.+?)["']?\s*$/m);
+            const type = typeMatch?.[1] === 'human' ? 'human' : 'ai';
+            const name = nameMatch?.[1]?.trim() || undefined;
+            const info = { type, name };
+            this.peerInfoCache.set(aid, info);
+            setTimeout(() => this.peerInfoCache.delete(aid), 30 * 60 * 1000);
+            return info;
+        }
+        catch {
+            return { type: null }; // no agent.md → unknown
+        }
+    }
+    async uploadAgentMd(content) {
+        if (!this.client)
+            throw new Error('not connected');
+        await this.client.auth.uploadAgentMd(content);
+    }
+    async downloadAgentMd(aid) {
+        if (!this.client)
+            throw new Error('not connected');
+        return this.client.auth.downloadAgentMd(aid);
+    }
 }
 // Plugin implementation
 export class AUNChannelPlugin {
@@ -529,7 +935,6 @@ export class AUNChannelPlugin {
             const channel = new AUNChannel({
                 aid: inst.aid,
                 keystorePath: inst.keystorePath,
-                gatewayPort: inst.gatewayPort,
                 gatewayUrl: inst.gatewayUrl,
                 accessToken: inst.accessToken,
                 flushDelay: inst.flushDelay,
@@ -539,19 +944,23 @@ export class AUNChannelPlugin {
             const adapter = {
                 channelName: inst.name,
                 sendText: (id, text, context) => channel.sendMessage(id, text, context),
+                sendFile: (id, filePath, context) => channel.sendFile(id, filePath, context),
                 acknowledge: (messageId) => { channel.acknowledge(messageId); return Promise.resolve(); },
                 sendProcessingStatus: (id, status, sessionId, context) => channel.sendProcessingStatus(id, status, sessionId, context),
                 sendCustomPayload: (id, payload) => channel.sendCustomPayload(id, payload),
+                uploadAgentMd: (content) => channel.uploadAgentMd(content),
+                downloadAgentMd: (aid) => channel.downloadAgentMd(aid),
+                _selfAid: () => channel.getStatus().aid,
             };
             const policy = {
-                canSwitchProject: (chatType, identity) => identity === 'owner',
-                canListProjects: (chatType, identity) => identity === 'owner',
+                canSwitchProject: (chatType, identity) => identity === 'owner' || identity === 'admin',
+                canListProjects: (chatType, identity) => identity === 'owner' || identity === 'admin',
                 canCreateSession: (chatType, identity) => true,
                 canDeleteSession: (chatType, identity) => true,
-                canImportCliSession: (chatType, identity) => identity === 'owner',
-                messagePrefix: () => '',
+                canImportCliSession: (chatType, identity) => identity === 'owner' || identity === 'admin',
+                messagePrefix: (chatType, peerName) => (chatType === 'group' && peerName) ? `[${peerName}] ` : '',
                 showMiddleResult: (chatType, identity) => {
-                    const mode = inst.showActivities ?? config.showActivities ?? 'all';
+                    const mode = getChannelShowActivities(config, inst.name);
                     if (mode === 'none')
                         return false;
                     if (mode === 'dm-only')
@@ -561,7 +970,7 @@ export class AUNChannelPlugin {
                     return true;
                 },
                 showIdleMonitor: (chatType, identity) => {
-                    const mode = inst.showActivities ?? config.showActivities ?? 'all';
+                    const mode = getChannelShowActivities(config, inst.name);
                     if (mode === 'none')
                         return false;
                     if (mode === 'dm-only')
@@ -584,6 +993,7 @@ export class AUNChannelPlugin {
                 options,
                 connect: () => channel.connect(),
                 disconnect: () => channel.disconnect(),
+                onProjectPathRequest: (channelId) => Promise.resolve(config.projects?.defaultPath || process.cwd()),
             });
         }
         return result;