evolcore 0.0.27 → 0.0.28

package/dist/core/command/diag-service.js

@@ -1,5 +1,9 @@
+import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { isValidAid } from '../../aun/aid/validation.js';
+import { atomicReadJson, atomicWriteJson } from '../../utils/atomic-write.js';
 import { remoteAccessService } from '../auth/remote-access-store.js';
+import { KeyedFairMutex } from '../handoff/mutex.js';
 export const DIAGNOSTIC_AGENT_AID = 'diag.agentid.cn';
 /** IPC verifies local control authority; managed calls must independently prove their actor. */
 export async function executeDiagIpc(service, registry, owners, cmd) {
@@ -55,11 +59,17 @@ export class DiagService {
     context;
     send;
     tokens;
+    sessionControlTail = Promise.resolve();
     constructor(context, send, tokens = remoteAccessService) {
         this.context = context;
         this.send = send;
         this.tokens = tokens;
     }
+    withSessionControl(operation) {
+        const pending = this.sessionControlTail.then(operation, operation);
+        this.sessionControlTail = pending.then(() => undefined, () => undefined);
+        return pending;
+    }
     /** Local CLI authority is checked by IPC; slash identity is authenticated AUN peerId. */
     async execute(command, actorAid) {
         const { controlAid, owners } = this.context();
@@ -72,47 +82,302 @@ export class DiagService {
             if (!previous)
                 return { ok: true, message: '当前没有诊断授权' };
             const diag = previous.diagnostic;
-            try {
-                await this.send(diag.agentAid, `诊断授权已取消。目标 daemon：${controlAid}；case：${diag.caseId}；沟通 Owner：${diag.ownerAid}。请停止这次诊断的后续访问，并告知 Owner。`);
-                return { ok: true, message: '诊断授权已撤销，已通知诊断 Agent' };
-            }
-            catch {
-                return { ok: true, code: 'DIAG_STOP_NOTICE_FAILED', message: '诊断授权已撤销；取消通知发送失败，诊断 Agent 后续访问将被拒绝' };
-            }
+            return this.withSessionControl(async () => {
+                try {
+                    await this.send(diag.agentAid, [
+                        '诊断事件：cancel',
+                        '诊断授权已取消。',
+                        `目标 daemon：${controlAid}`,
+                        `case：${diag.caseId}`,
+                        `沟通 Owner：${diag.ownerAid}`,
+                        '请停止该 case 的后续 Menu 访问，并告知 Owner 该 case 已取消。',
+                        '不要把本通知当作新的诊断请求；请向 Owner 发送取消确认。',
+                    ].join('\n'));
+                }
+                catch {
+                    return { ok: true, code: 'DIAG_STOP_NOTICE_FAILED', message: '诊断授权已撤销；取消通知发送失败，诊断 Agent 后续访问将被拒绝' };
+                }
+                return { ok: true, message: '诊断授权已撤销，已通知诊断 Agent 停止该 case；远端执行状态未确认' };
+            });
         }
         const ownerAid = actorAid ?? command.ownerAid ?? owners[0];
         if (!ownerAid || !isValidAid(ownerAid) || !owners.includes(ownerAid))
             return { ok: false, code: 'DAEMON_OWNER_REQUIRED', message: '请配置本机 owners，或指定其中一个有效 Owner AID' };
         if (!command.problem?.trim() || command.problem.length > 16_000)
             return { ok: false, code: 'INVALID_ARGUMENT', message: '请提供 1 到 16000 字符的问题描述' };
+        const appendExisting = async (existing) => {
+            if (!existing.diagnostic)
+                return { ok: false, code: 'DIAG_AUTH_FAILED', message: '当前诊断授权记录无效' };
+            if (existing.diagnostic.ownerAid !== ownerAid) {
+                return { ok: false, code: 'DIAG_OWNER_MISMATCH', message: `当前诊断已绑定沟通 Owner ${existing.diagnostic.ownerAid}，不能由 ${ownerAid} 追加信息` };
+            }
+            const { caseId } = existing.diagnostic;
+            const append = [
+                '诊断事件：append',
+                '当前诊断 case 的追加信息（不要新建诊断授权或 case）：',
+                `目标 daemon：${controlAid}`,
+                `沟通 Owner：${ownerAid}`,
+                `case：${caseId}`,
+                `问题补充：\n${command.problem.trim()}`,
+                '请在现有诊断上下文中处理；继续使用原有授权，必要时向 Owner 汇报新增影响。',
+            ].join('\n');
+            return this.withSessionControl(async () => {
+                if (this.tokens.getDiagnosticToken(controlAid)?.token !== existing.token) {
+                    return { ok: false, code: 'DIAG_CANCELLED', caseId, ownerAid, agentAid: existing.diagnostic.agentAid, message: '追加信息发送前诊断授权已取消' };
+                }
+                try {
+                    await this.send(existing.diagnostic.agentAid, append);
+                }
+                catch (error) {
+                    const reason = error instanceof Error ? error.message : String(error);
+                    return { ok: false, code: 'DIAG_APPEND_FAILED', caseId, ownerAid, agentAid: existing.diagnostic.agentAid,
+                        message: `诊断追加信息发送失败：${reason}；原诊断授权仍保持有效` };
+                }
+                if (this.tokens.getDiagnosticToken(controlAid)?.token !== existing.token) {
+                    return { ok: false, code: 'DIAG_CANCELLED', caseId, ownerAid, agentAid: existing.diagnostic.agentAid, message: '追加信息发送期间诊断授权已取消' };
+                }
+                return { ok: true, code: 'DIAG_APPENDED', caseId, ownerAid, agentAid: existing.diagnostic.agentAid,
+                    message: `已将补充信息追加到现有诊断 case ${caseId}，未创建新的诊断授权` };
+            });
+        };
+        const existing = this.tokens.getDiagnosticToken(controlAid);
+        if (existing?.diagnostic)
+            return appendExisting(existing);
         let record;
         try {
             record = this.tokens.issueDiagnosticToken(controlAid, DIAGNOSTIC_AGENT_AID, ownerAid);
         }
         catch (error) {
+            // Another request may have reserved the grant after the inspection above.
+            // Treat that reservation as the same case and append instead of surfacing a duplicate error.
+            const current = error?.code === 'DIAG_ALREADY_ACTIVE' ? this.tokens.getDiagnosticToken(controlAid) : undefined;
+            if (current?.diagnostic)
+                return appendExisting(current);
             return { ok: false, code: error.code ?? 'DIAG_AUTH_FAILED', message: error.message };
         }
         const caseId = record.diagnostic.caseId;
-        const invitation = [
-            '请协助诊断以下主机，并主动联系指定 Owner 展示进展、追问和报告。',
-            `目标 daemon Control AID：${controlAid}`, `沟通 Owner AID：${ownerAid}`, `case：${caseId}`,
-            `远程访问 Token：${record.token}`,
-            '请通过标准 Menu 调用诊断；Token 放入 E2EE 受保护头。权限复用该主机既有 Control Menu，包含 restart。有效访问滑动续期，空闲 60 分钟失效。',
-            '先给 Owner 发开始消息，使用通用 handoff 保留目标、Token、问题和发现；无需等待 Owner 回复即可开始。授权失效后停止访问。',
-            `问题描述：\n${command.problem.trim()}`,
-        ].join('\n');
-        try {
-            await this.send(DIAGNOSTIC_AGENT_AID, invitation);
-        }
-        catch (error) {
-            this.tokens.revokeDiagnosticToken(controlAid, record.token);
-            const reason = error instanceof Error ? error.message : String(error);
-            return { ok: false, code: 'DIAG_INVITATION_FAILED', message: `未能确认诊断邀请发送成功：${reason}。本次授权已撤销，请重试` };
+        const sessionName = `diag-${caseId.slice(0, 8)}`;
+        return this.withSessionControl(async () => {
+            if (this.tokens.getDiagnosticToken(controlAid)?.token !== record.token) {
+                return { ok: false, code: 'DIAG_CANCELLED', message: '邀请发送前授权已撤销，本次诊断已取消' };
+            }
+            const invitation = [
+                '诊断事件：new',
+                '请协助诊断以下主机，并主动联系指定 Owner 展示进展、追问和报告。',
+                `目标 daemon Control AID：${controlAid}`, `沟通 Owner AID：${ownerAid}`, `case：${caseId}`,
+                `诊断创建时间（Unix毫秒）：${record.createdAt}`,
+                `远程访问 Token：${record.token}`,
+                '请通过标准 Menu 调用诊断；Token 放入 E2EE 受保护头。权限复用该主机既有 Control Menu，包含 restart。有效访问滑动续期，空闲 60 分钟失效。',
+                `诊断端应在处理前按 case 建立或选择独立 EvolCore 会话「${sessionName}」，不得恢复或复用其他 case 的 Codex 执行会话。`,
+                '先给 Owner 发开始消息，使用通用 handoff 保留目标、Token、问题和发现；无需等待 Owner 回复即可开始。授权失效后停止访问。若会话隔离失败，先告知 Owner 并暂停 Menu 访问。',
+                `问题描述：\n${command.problem.trim()}`,
+            ].join('\n');
+            try {
+                await this.send(DIAGNOSTIC_AGENT_AID, invitation);
+            }
+            catch (error) {
+                this.tokens.revokeDiagnosticToken(controlAid, record.token);
+                const reason = error instanceof Error ? error.message : String(error);
+                return { ok: false, code: 'DIAG_INVITATION_FAILED', message: `未能确认诊断邀请发送成功：${reason}。本次授权已撤销，请重试` };
+            }
+            // A stop may race with delivery; never report an already revoked grant as active.
+            if (this.tokens.getDiagnosticToken(controlAid)?.token !== record.token)
+                return { ok: false, code: 'DIAG_CANCELLED', message: '邀请发送期间授权已撤销，本次诊断已取消' };
+            return { ok: true, caseId, ownerAid, agentAid: DIAGNOSTIC_AGENT_AID,
+                message: `诊断邀请已发出；诊断 Agent 收到后会按 case 建立独立执行会话，并联系 ${ownerAid}。` };
+        });
+    }
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const INVITATION = '请协助诊断以下主机，并主动联系指定 Owner 展示进展、追问和报告。';
+const APPEND = '当前诊断 case 的追加信息（不要新建诊断授权或 case）：';
+const diagnosticLocks = new KeyedFairMutex();
+const diagnosticLedgerPath = (chatDir) => path.join(chatDir, 'diagnostic-cases.json');
+export const diagnosticTokenHash = (token) => createHash('sha256').update(token).digest('hex');
+/** Parse only the generated header, never quoted text or the user's problem. */
+export function parseDiagnosticEvent(content) {
+    const text = content.trim().replace(/\r\n/g, '\n');
+    const first = text.split('\n', 1)[0];
+    const explicit = /^诊断事件[：:]\s*(new|append|cancel)$/.exec(first)?.[1];
+    if (first.startsWith('诊断事件') && !explicit)
+        throw new Error('未知诊断事件，未选择执行会话');
+    // Existing released senders need no new slash command or protocol support.
+    const kind = explicit ?? (first === INVITATION ? 'new' : first === APPEND ? 'append'
+        : text.startsWith('诊断授权已取消。') ? 'cancel' : undefined);
+    if (!kind)
+        return undefined;
+    const header = text.split(/^问题(?:描述|补充)[：:]/m, 1)[0];
+    const legacyCancel = !explicit && kind === 'cancel';
+    const fields = legacyCancel ? header.replace(/^诊断授权已取消。/, '').replace(/；/g, '\n') : header;
+    const field = (label) => {
+        const matches = [...fields.matchAll(new RegExp(`^${label}[：:]([^\\n]*)$`, 'gm'))];
+        return matches.length === 1 ? matches[0][1].trim() : undefined;
+    };
+    const caseId = field('case')?.toLowerCase();
+    const controlAid = field('目标 daemon(?: Control AID)?');
+    const ownerAid = legacyCancel
+        ? field('沟通 Owner')?.split('。', 1)[0]
+        : field('沟通 Owner(?: AID)?');
+    if (!caseId || !UUID.test(caseId) || !controlAid || !isValidAid(controlAid) || !ownerAid || !isValidAid(ownerAid)) {
+        throw new Error('诊断通知字段无效，未选择执行会话');
+    }
+    if (kind !== 'new')
+        return { kind, caseId, controlAid, ownerAid };
+    const token = field('远程访问 Token');
+    if (!token || !/^[0-9a-f]{64}$/i.test(token))
+        throw new Error('诊断邀请缺少有效 Token，未选择执行会话');
+    const created = field('诊断创建时间（Unix毫秒）');
+    const createdAt = created === undefined ? undefined : Number(created);
+    if (createdAt !== undefined && (!Number.isSafeInteger(createdAt) || createdAt <= 0))
+        throw new Error('诊断创建时间无效');
+    return { kind, caseId, controlAid, ownerAid, tokenHash: diagnosticTokenHash(token), createdAt };
+}
+function readDiagnosticLedger(chatDir) {
+    const value = atomicReadJson(diagnosticLedgerPath(chatDir));
+    if (!value)
+        return { version: 1, cases: {} };
+    if (value.version !== 1 || !value.cases || typeof value.cases !== 'object' || Array.isArray(value.cases)
+        || Object.entries(value.cases).some(([key, record]) => !UUID.test(key) || !record
+            || !['active', 'closed'].includes(record.state) || !isValidAid(record.ownerAid))) {
+        throw new Error('诊断会话记录损坏，已阻止恢复旧会话');
+    }
+    return value;
+}
+/** Called again at execution and Menu boundaries, including delayed/recovered work. */
+export function isDiagnosticSessionActive(session, chatDir) {
+    if (session.metadata?.diagnosticStatus === 'cancelled')
+        return false;
+    const binding = session.metadata?.diagnostic;
+    if (!binding)
+        return true;
+    const ledger = readDiagnosticLedger(chatDir);
+    const record = ledger.cases[binding.caseId];
+    return ledger.activeCaseId === binding.caseId && record?.state === 'active'
+        && record.sessionId === session.id && record.tokenHash === binding.tokenHash
+        && record.ownerAid === binding.ownerAid && session.channelId === binding.controlAid;
+}
+/** Invalid authorization is terminal; it must not be revived by a retry/append. */
+export function closeDiagnosticSession(session, chatDir) {
+    const binding = session.metadata?.diagnostic;
+    if (!binding)
+        return;
+    const ledger = readDiagnosticLedger(chatDir);
+    const record = ledger.cases[binding.caseId];
+    if (record?.sessionId !== session.id)
+        return;
+    record.state = 'closed';
+    atomicWriteJson(diagnosticLedgerPath(chatDir), ledger);
+}
+/** The bridge already applies normal authentication/admission before calling this. */
+export class DiagnosticSessionRouter {
+    sessions;
+    stopSession;
+    constructor(sessions, stopSession) {
+        this.sessions = sessions;
+        this.stopSession = stopSession;
+    }
+    async route(input) {
+        const { event, message, channel, channelType, selfAid, chatDir } = input;
+        if (channelType !== 'aun' || selfAid !== DIAGNOSTIC_AGENT_AID || message.chatType !== 'private'
+            || message.threadId || (message.source !== undefined && message.source !== 'user')
+            || !(message.encrypted ?? message.replyContext?.metadata?.encrypted)
+            || message.peerId !== event.controlAid || message.channelId !== event.controlAid || !message.messageId) {
+            throw new Error('诊断通知来源或会话不匹配，未执行会话切换');
         }
-        // A stop may race with delivery; never report an already revoked grant as active.
-        if (this.tokens.getDiagnosticToken(controlAid)?.token !== record.token)
-            return { ok: false, code: 'DIAG_CANCELLED', message: '邀请发送期间授权已撤销，本次诊断已取消' };
-        return { ok: true, caseId, ownerAid, agentAid: DIAGNOSTIC_AGENT_AID,
-            message: `诊断邀请已发出，远程诊断 Agent 将联系 ${ownerAid}，请在与 ${DIAGNOSTIC_AGENT_AID} 的会话中查看处理过程。` };
+        return diagnosticLocks.forKey(diagnosticLedgerPath(chatDir)).runExclusive(async () => {
+            const all = await this.sessions.listSessions(channel, message.channelId, { archiveFilter: 'all' });
+            const ledger = readDiagnosticLedger(chatDir);
+            const find = (caseId) => all.find(s => !s.threadId && s.selfAID === selfAid
+                && s.metadata?.diagnostic?.caseId === caseId && s.metadata.diagnostic.controlAid === event.controlAid);
+            let record = ledger.cases[event.caseId];
+            if (record && record.ownerAid !== event.ownerAid)
+                throw new Error('诊断通知 Owner 与原授权不一致');
+            if (event.kind === 'cancel') {
+                let session = find(event.caseId);
+                if (!session) {
+                    const legacy = this.sessions.getActiveSessionSync(channel, message.channelId, channelType, selfAid);
+                    if (legacy && !legacy.threadId && !legacy.metadata?.diagnostic) {
+                        await this.sessions.patchSessionMetadata(legacy.id, { diagnosticStatus: 'cancelled' });
+                        session = legacy;
+                    }
+                }
+                // Keep a tombstone even if cancellation overtook the first invitation.
+                ledger.cases[event.caseId] = { ...record, ownerAid: event.ownerAid, state: 'closed', sessionId: record?.sessionId ?? session?.id };
+                atomicWriteJson(diagnosticLedgerPath(chatDir), ledger);
+                if (session)
+                    await this.stopSession(session.id);
+                return { notice: '已关闭该诊断并停止其待处理任务。' };
+            }
+            if (record?.state === 'closed')
+                return { notice: '该诊断已结束，旧邀请和追加消息不会重新执行。' };
+            if (event.kind === 'append' && !record)
+                throw new Error('未找到该诊断的独立会话，请停止诊断后重新发起');
+            if (record && event.kind === 'new' && record.tokenHash !== event.tokenHash)
+                throw new Error('相同诊断的授权不一致，未恢复会话');
+            if (!record) {
+                if (find(event.caseId))
+                    throw new Error('诊断生命周期记录缺失，拒绝恢复旧会话');
+                const sequence = Number.isSafeInteger(message.gatewaySeq) ? message.gatewaySeq : undefined;
+                const last = ledger.activeCaseId ? ledger.cases[ledger.activeCaseId] : undefined;
+                const stale = last && (sequence !== undefined && last.sequence !== undefined
+                    ? sequence <= last.sequence
+                    : event.createdAt !== undefined && last.createdAt !== undefined
+                        ? event.createdAt <= last.createdAt : true);
+                if (stale)
+                    return { notice: '邀请顺序已过期或无法确认，未恢复旧诊断。' };
+                // Persist all revocations before interruption/creation. A crash here
+                // cannot let a restored old task use its previous authorization.
+                for (const previous of Object.values(ledger.cases))
+                    previous.state = 'closed';
+                record = { state: 'active', ownerAid: event.ownerAid, tokenHash: event.tokenHash, sequence, createdAt: event.createdAt };
+                ledger.cases[event.caseId] = record;
+                ledger.activeCaseId = event.caseId;
+                atomicWriteJson(diagnosticLedgerPath(chatDir), ledger);
+            }
+            if (ledger.activeCaseId !== event.caseId)
+                return { notice: '该诊断已被新诊断替代。' };
+            const oldActive = this.sessions.getActiveSessionSync(channel, message.channelId, channelType, selfAid);
+            if (!record.cleanupComplete && oldActive && !oldActive.threadId && !oldActive.metadata?.diagnostic) {
+                // Migration from the historical shared Control conversation. Owner
+                // conversations and sessions belonging to other hosts are untouched.
+                await this.sessions.patchSessionMetadata(oldActive.id, { diagnosticStatus: 'cancelled' });
+                await this.stopSession(oldActive.id);
+            }
+            // Retry interruption too after an interrupted creation attempt.
+            for (const previous of record.cleanupComplete ? [] : all) {
+                if (!previous.threadId && previous.metadata?.diagnostic?.controlAid === event.controlAid
+                    && previous.metadata.diagnostic.caseId !== event.caseId)
+                    await this.stopSession(previous.id);
+            }
+            let session = find(event.caseId);
+            if (record.sessionId && (!session || record.sessionId !== session.id))
+                throw new Error('诊断会话绑定缺失，拒绝回退到历史会话');
+            if (!session) {
+                if (event.kind !== 'new' || !input.baseagent)
+                    throw new Error('无法创建诊断执行会话');
+                const metadata = {
+                    channelKey: channel, peerId: event.controlAid, peerName: message.peerName,
+                    diagnostic: { caseId: event.caseId, controlAid: event.controlAid, ownerAid: event.ownerAid, tokenHash: record.tokenHash },
+                };
+                // The case binding is committed in the first session snapshot. Replay
+                // can find it even if the process died before saving the ledger pointer.
+                session = await this.sessions.createNewSession(channel, message.channelId, input.projectPath, `diag-${event.caseId.slice(0, 8)}`, input.baseagent, metadata);
+                if (session.agentSessionId || session.metadata?.agentSessions || session.metadata?.resumeAt) {
+                    throw new Error('诊断会话错误继承了旧执行上下文');
+                }
+            }
+            if (session.metadata?.diagnostic?.tokenHash !== record.tokenHash)
+                throw new Error('诊断会话授权绑定不一致');
+            // A concurrent Menu response can close this case while we await runner
+            // interruption/session creation. Never overwrite that terminal state.
+            const latest = readDiagnosticLedger(chatDir);
+            const current = latest.cases[event.caseId];
+            if (latest.activeCaseId !== event.caseId || current?.state !== 'active')
+                return { notice: '该诊断已结束。' };
+            current.sessionId = session.id;
+            current.cleanupComplete = true;
+            atomicWriteJson(diagnosticLedgerPath(chatDir), latest);
+            return { session };
+        });
     }
 }

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

@@ -13,7 +13,8 @@ import os from 'os';
 import crypto from 'crypto';
 import { CronExpressionParser } from 'cron-parser';
 import { parseDuration } from '../../trigger/parser.js';
-import { checkLatestVersion, getLocalVersion, isLinkedInstall, compareVersions, resolveGlobalPkg } from '../../utils/npm-ops.js';
+import { isLinkedInstall, resolveGlobalPkg } from '../../utils/npm-ops.js';
+import { refreshManagedPackageVersions, VERSION_INFO_PACKAGES } from '../../utils/package-version-info.js';
 import { resolveCliEntry, launchMonitorAndConfirm } from '../../utils/cross-platform.js';
 import { cachedCliVersion } from '../../utils/cross-platform.js';
 import { scanInstances } from '../../utils/instance-registry.js';
@@ -4115,27 +4116,23 @@ export async function execMenuAction(cmd, action, args, channel, channelId, user
         }
         if (action === 'upgrade') {
             const devMode = isLinkedInstall();
-            const localEvolcore = getLocalVersion();
-            // fastaun 本地版本：从 node_modules 读取（与 menu.query name=system 一致）
-            let localFastaun = null;
-            try {
-                const fp = path.join(getPackageRoot(), 'node_modules', '@agentunion', 'fastaun', 'package.json');
-                localFastaun = JSON.parse(fs.readFileSync(fp, 'utf-8'))?.version ?? null;
-            }
-            catch { }
-            const [evolcoreRemote, fastaunRemote, ecwebRemote] = await Promise.all([
-                checkLatestVersion('evolcore'),
-                checkLatestVersion('@agentunion/fastaun'),
-                checkLatestVersion(WEB_PACKAGE_NAME),
-            ]);
-            const cmp = (local, remote) => !!(local && remote && compareVersions(local, remote) < 0);
+            const results = await refreshManagedPackageVersions(VERSION_INFO_PACKAGES, { source: 'menu-upgrade' });
+            const [evolcore, fastaunWeb, web] = [results[0], results[2], results[1]];
+            const item = (result) => ({
+                local: result.entry.currentVersion,
+                remote: result.status === 'ok' ? result.entry.latestVersion ?? null : null,
+                hasUpdate: result.status === 'ok' && result.hasUpdate,
+                status: result.status,
+                checkedAt: result.status === 'ok' ? result.entry.checkedAt ?? null : null,
+                lastCheckedAt: result.entry.checkedAt ?? null,
+                ...(result.error ? { error: result.error } : {}),
+            });
             return {
                 data: {
                     devMode,
-                    evolcore: { local: localEvolcore, remote: evolcoreRemote, hasUpdate: cmp(localEvolcore, evolcoreRemote) },
-                    fastaun: { local: localFastaun, remote: fastaunRemote, hasUpdate: cmp(localFastaun, fastaunRemote), managedBy: 'evolcore' },
-                    // ecweb 本地版本由 ECWeb 进程自身注入（data.ecwebVersion），此处仅给 remote
-                    ecweb: { remote: ecwebRemote },
+                    evolcore: item(evolcore),
+                    fastaun: { ...item(fastaunWeb), managedBy: 'evolcore' },
+                    ecweb: item(web),
                 },
             };
         }

package/dist/core/command/menu-protocol.js

@@ -315,6 +315,9 @@ export function validateMenuRequest(request) {
     if (request.args !== undefined && (!request.args || typeof request.args !== 'object' || Array.isArray(request.args))) {
         return { code: 'INVALID_ARGUMENT', message: 'Menu request args must be an object' };
     }
+    if (type === 'menu.list' && Object.hasOwn(request, 'context')) {
+        return { code: 'INVALID_ARGUMENT', message: 'menu.list context must be inside args.context (for a daemon catalog, use args.context.kind=process)' };
+    }
     if (type === 'menu.update') {
         const args = request.args;
         const scopeError = validateConfigWriteScope(request.name, args)

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

@@ -7,7 +7,7 @@ import { shouldSuppressRealRestart } from '../../utils/restart-safety.js';
 import crypto from 'crypto';
 import path from 'path';
 import fs from 'fs';
-import { checkLatestVersion, getLocalVersion, isLinkedInstall, compareVersions } from '../../utils/npm-ops.js';
+import { ensureFreshPackageVersionInfo, refreshManagedPackageVersions } from '../../utils/package-version-info.js';
 import { loadDaemonConfig } from '../../config-store.js';
 import { remoteAccessService } from '../auth/remote-access-store.js';
 import { read as cfgRead, resolveEffective, routeFieldPath, write as cfgWrite, } from '../../config/config-manager.js';
@@ -667,7 +667,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         const appendProcessCommands = (lines) => {
             if (!isDaemonOwner)
                 return;
-            lines.push('', '🛠️ 进程级运维：', '  /restart - 重启服务', '  /upgrade - 检查版本更新', '  /reload [aid] - 热重载 Agent 配置', '  /fa <提示词> - 单次使用宿主级 fullaccess 执行（别名: /fullaccess）', '  /pair - 获取远程控制配对码', '  /diag <问题描述> - 邀请远程诊断；/diag stop 撤销授权');
+            lines.push('', '🛠️ 进程级运维：', '  /restart - 重启服务', '  /upgrade - 检查版本更新', '  /reload [aid] - 热重载 Agent 配置', '  /fa <提示词> - 单次使用宿主级 fullaccess 执行（别名: /fullaccess）', '  /pair - 获取远程控制配对码', '  /diag <问题描述> - 邀请或追加远程诊断；/diag stop 撤销授权');
         };
         if (!isAdmin && activeChatType === 'group') {
             const lines = [
@@ -913,7 +913,7 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
             cmds.push({ command: '/upgrade', description: '检查版本更新', category: '运维', roles: ['daemon-owner'] });
             cmds.push({ command: '/reload', args: '[aid]', description: '热重载 Agent 配置', category: '运维', roles: ['daemon-owner'] });
             cmds.push({ command: '/pair', description: '获取远程控制配对码', category: '运维', roles: ['daemon-owner'] });
-            cmds.push({ command: '/diag', args: '<问题描述>|stop', description: '邀请远程诊断或撤销授权', category: '运维', roles: ['daemon-owner'] });
+            cmds.push({ command: '/diag', args: '<问题描述>|stop', description: '邀请/追加远程诊断或撤销授权', category: '运维', roles: ['daemon-owner'] });
         }
         if (!isDaemonOwner && isAdmin) {
             cmds.push({ command: '/reload', description: '热重载当前 Agent 配置', category: '运维', roles: ['admin', 'owner'] });
@@ -2997,6 +2997,12 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
                 logger.warn(`[System] Refusing restart while data migration is pending: operations=${migrationRequirement.operationCount}`);
                 return { code: 'DATA_MIGRATION_REQUIRED', operationCount: migrationRequirement.operationCount };
             }
+            if (!suppressRealRestart) {
+                await ensureFreshPackageVersionInfo(undefined, {
+                    source: 'slash-restart',
+                    log: message => logger.info(`[System] ${message}`),
+                });
+            }
             const restartInfo = {
                 channel,
                 channelId,
@@ -3140,18 +3146,21 @@ export async function handleSlashCommand(content, channel, channelId, sendMessag
         });
         if (upgradeAuthDenied)
             return upgradeAuthDenied;
-        if (isLinkedInstall()) {
-            return { kind: 'command.result', text: '⏭ 开发模式，跳过升级检查' };
-        }
-        const localVer = getLocalVersion();
-        const remoteVer = await checkLatestVersion();
-        if (!remoteVer) {
-            return { kind: 'command.result', text: `⚠️ 无法连接 npm registry（当前版本 ${localVer}）` };
-        }
-        if (compareVersions(localVer, remoteVer) >= 0) {
-            return { kind: 'command.result', text: `✓ 已是最新版本 (${localVer})` };
-        }
-        return { kind: 'command.result', text: `📦 发现新版本 ${localVer} → ${remoteVer}\n执行 /restart 升级` };
+        const results = await refreshManagedPackageVersions(undefined, { source: 'slash-upgrade' });
+        const lines = results.filter(result => result.status !== 'not-installed').map(result => {
+            const { packageName, status, entry } = result;
+            if (status === 'skipped')
+                return `⏭ ${packageName}：开发模式，跳过升级检查`;
+            if (status === 'unavailable') {
+                return `⚠️ ${packageName}：本次检查失败（当前 ${entry.currentVersion ?? '未知'}）；`
+                    + (entry.checkedAt ? `最近成功检查：${entry.checkedAt}` : '尚无成功检查记录');
+            }
+            return `${result.hasUpdate ? '📦' : '✓'} ${packageName}：当前 ${entry.currentVersion}，最新 ${entry.latestVersion}`
+                + `；检查时间 ${entry.checkedAt}${result.hasUpdate ? '' : '，无需升级'}`;
+        });
+        if (results.some(result => result.hasUpdate))
+            lines.push('执行 /restart 应用升级');
+        return { kind: 'command.result', text: lines.join('\n') };
     }
     // /pwd 命令：显示当前项目路径
     if (normalizedContent === '/pwd') {

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

@@ -21,6 +21,7 @@ export class IMRenderer {
     /** 自增 callId 兜底（runner 没提供时用） */
     syntheticCallSeq = 0;
     currentAssistantUuid;
+    currentTextPhase;
     constructor(opts) {
         this.opts = opts;
     }
@@ -175,14 +176,24 @@ export class IMRenderer {
     }
     // ── 文本/活动注入（替代 StreamFlusher.addText/addActivity）──
     /** 添加文本片段（流式 text） */
-    async addText(text, outputTokens, turn, assistantUuid) {
+    async addText(text, outputTokens, turn, assistantUuid, phase) {
         if (this.opts.envelope.chatmode === 'proactive')
             return;
-        if (this.textBuffer && this.currentAssistantUuid !== assistantUuid && !this.suppressIntermediateText()) {
+        const sameAssistant = this.currentAssistantUuid === assistantUuid;
+        // In deferred AUN private delivery, only explicit text_start/tool_use
+        // handlers are semantic boundaries. assistantUuid is correlation data and
+        // may be absent or change without proving that the prior text is final.
+        const hadPendingText = this.textBuffer.length > 0;
+        if (hadPendingText && !this.opts.deferTextUntilBoundary && !sameAssistant
+            && !this.suppressIntermediateText()) {
             await this.flushText();
         }
         // Do not carry the previous item's anchor onto unanchored output.
         this.currentAssistantUuid = assistantUuid;
+        // A mixed buffer has no trustworthy phase, even when its latest chunk is commentary.
+        this.currentTextPhase = hadPendingText && this.opts.deferTextUntilBoundary
+            ? this.currentTextPhase === phase ? phase : undefined
+            : phase;
         this.emitProgress('text', outputTokens, turn);
         if (!text)
             return;
@@ -276,6 +287,8 @@ export class IMRenderer {
     }
     /** Notify the client that a new model text block has started. */
     async sendTextStart(contentIndex, turn) {
+        if (this.opts.deferTextUntilBoundary)
+            await this.flushText();
         const payload = {
             kind: 'status.progress',
             metadata: { activityType: 'text', kind: 'text_start', contentIndex, turn },
@@ -453,7 +466,7 @@ export class IMRenderer {
         const elapsed = Date.now() - this.lastFlush;
         const delay = Math.max(0, targetDelay - elapsed);
         this.timer = setTimeout(() => {
-            void this.flushInternal().catch(error => {
+            void this.flushInternal(undefined, undefined, true).catch(error => {
                 logger.warn(`[IMRenderer] scheduled flush failed: ${error instanceof Error ? error.message : String(error)}`);
             });
         }, delay);
@@ -501,7 +514,7 @@ export class IMRenderer {
      * 完整 flush：把 itemsQueue 里所有 items 打包成 activity.batch 发送。
      * 如果 isFinal=true，还会在 batch 之后单独发一条 result.text 作为最终回复。
      */
-    async flushInternal(isFinal, attention) {
+    async flushInternal(isFinal, attention, scheduled = false) {
         if (this.timer) {
             clearTimeout(this.timer);
             this.timer = undefined;
@@ -562,6 +575,10 @@ export class IMRenderer {
         if (!isFinal && this.textBuffer.length > 0) {
             if (this.suppressIntermediateText())
                 return;
+            // A timer cannot decide whether this is the final answer. Keep it for
+            // an explicit boundary; known commentary can still be sent immediately.
+            if (scheduled && this.opts.deferTextUntilBoundary && this.currentTextPhase !== 'commentary')
+                return;
             const text = this.textBuffer;
             this.textBuffer = '';
             const payload = {