evolcore 0.0.26 → 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/group-menu.js

@@ -2,7 +2,7 @@ import crypto from 'crypto';
 import { ConfigTarget, mutateConfig, read as readConfig, resolveEffectiveFieldWithSource, } from '../../config/config-manager.js';
 import { normalizeMentionMode } from '../../config/mention-mode.js';
 import { readRolesConfig } from '../../config/roles.js';
-import { groupInfo, groupList, groupDirectoryErrorCode } from '../../aun/msg/group.js';
+import { groupInfo, groupList, groupDirectoryErrorCode, normalizeGroupAid } from '../../aun/group/index.js';
 import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
 const DEFAULT_DIRECTORY = {
     getGroup: groupInfo,
@@ -185,7 +185,12 @@ function groupIdFromArgs(args, currentGroupId) {
     if (!groupId) {
         throw new GroupMenuError('INVALID_ARGUMENT', 'relation settings require args.groupId or args.peerKey');
     }
-    return groupId;
+    try {
+        return normalizeGroupAid(groupId);
+    }
+    catch (error) {
+        throw new GroupMenuError('INVALID_ARGUMENT', error.message);
+    }
 }
 function settingOptions(key, target) {
     const state = readSettingState(key, target);

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

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { groupInfo, groupMembers } from '../../aun/msg/group.js';
+import { groupInfo, groupMembers } from '../../aun/group/index.js';
 import { formatPeerKey } from '../relation/peer-identity.js';
 import { authorizeAccess, authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
 import { authorizationDenialData, formatAuthorizationDenial } from '../auth/authorization-denial.js';
@@ -8,6 +8,7 @@ import { readRolesConfig } from '../../config/roles.js';
 import { normalizeMenuError } from './menu-protocol.js';
 import { isValidAid } from '../../aun/aid/validation.js';
 const DEFAULT_DIRECTORY = { getGroup: groupInfo, getMembers: groupMembers };
+const HOST_BASEAGENTS = ['claude', 'codex', 'ecagent', 'gemini'];
 export function validateMenuValueBatchArgs(args) {
     if (!args || typeof args !== 'object' || Array.isArray(args))
         throw { code: 'INVALID_ARGUMENT', message: 'batch args must be an object' };
@@ -80,11 +81,11 @@ const ENTRIES = [
     { id: 'activity.agent', type: 'setting', contexts: ['agent'], name: 'activity', label: 'Agent 中间输出', section: 'agent', order: 50, query: { cmd: '/activity', args: { scope: 'agent' }, operation: 'activity.current', scope: 'agent' }, options: { cmd: '/activity', args: { scope: 'agent' }, operation: 'activity.current', scope: 'agent' }, update: { cmd: '/activity', args: { scope: 'agent' }, operation: 'activity.update', scope: 'agent' }, control: 'select' },
     { id: 'observable.agent', type: 'setting', contexts: ['agent'], name: 'observable', label: '观察模式', section: 'agent', order: 60, query: { cmd: '/observable', operation: 'observable.current', scope: 'agent' }, update: { cmd: '/observable', operation: 'observable.update', scope: 'agent' }, valueSchema: { type: 'boolean' }, control: 'toggle' },
     { id: 'aid.avatar', type: 'action', contexts: ['agent'], name: 'aid', label: '更换头像', section: 'agent', order: 70, action: { cmd: '/aid', action: 'avatar', operation: 'ec.aid.avatar', scope: 'agent' }, valueSchema: { type: 'object', properties: { data: { type: 'string' }, url: { type: 'string', format: 'uri' } }, oneOf: [{ required: ['data'] }, { required: ['url'] }] }, control: 'action' },
+    { id: 'baseagents.inventory', type: 'list', contexts: ['process'], name: 'baseagents', label: 'Base Agent 清单', section: 'process', order: 9, query: { cmd: '/baseagents', operation: 'system.status', scope: 'process' }, control: 'list' },
     { id: 'system.status', type: 'list', contexts: ['process'], name: 'system', label: '系统状态', section: 'process', order: 10, query: { cmd: '/system', operation: 'system.status', scope: 'process' }, control: 'list' },
     { id: 'system.monitor', type: 'list', contexts: ['process'], name: 'system', label: '运行监控快照', section: 'process', order: 11, query: { cmd: '/system', args: { view: 'monitor' }, operation: 'system.status', scope: 'process' }, control: 'list' },
     { id: 'system.logs', type: 'list', contexts: ['process'], name: 'system', label: 'Daemon 日志', section: 'process', order: 12, query: { cmd: '/system', args: { view: 'logs' }, operation: 'system.status', scope: 'process' }, options: { cmd: '/system', args: { option: 'logs' }, operation: 'system.status', scope: 'process', mode: 'dynamic' }, control: 'list' },
     { id: 'config.rawFile', type: 'list', contexts: ['process'], name: 'config', label: '原始配置文件', section: 'process', order: 13, query: { cmd: '/config', args: { view: 'rawFile' }, operation: 'config.read', scope: 'process' }, options: { cmd: '/config', args: { option: 'rawFile' }, operation: 'config.read', scope: 'process', mode: 'dynamic' }, control: 'list' },
-    { id: 'baseagent.models', type: 'list', contexts: ['process'], name: 'baseagent-models', label: 'Baseagent 模型目录', section: 'process', order: 41, query: { cmd: '/baseagent-models', args: { baseagent: 'claude' }, operation: 'baseagent.models.list', scope: 'process' }, control: 'list' },
     { id: 'system.restart', type: 'action', contexts: ['process'], name: 'system', label: '重启服务', section: 'process', order: 20, action: { cmd: '/system', action: 'restart', operation: 'system.restart', scope: 'process' } },
     { id: 'system.upgrade', type: 'action', contexts: ['process'], name: 'system', label: '升级服务', section: 'process', order: 30, action: { cmd: '/system', action: 'upgrade', operation: 'system.upgrade', scope: 'process' } },
     { id: 'system.paircode', type: 'action', contexts: ['process'], name: 'system', label: '获取配对码', section: 'process', order: 35, action: { cmd: '/system', action: 'paircode', operation: 'system.paircode', scope: 'process' } },
@@ -304,6 +305,34 @@ export async function resolveExplicitMenuExecutionContext(input) {
     };
 }
 function entryVisible(entry, context) { return entry.contexts.includes(context.kind); }
+function configuredHostBaseagentEntries() {
+    const defaults = readConfig(ConfigTarget.Defaults);
+    const configured = defaults?.baseagents;
+    if (!configured || typeof configured !== 'object' || Array.isArray(configured))
+        return [];
+    return HOST_BASEAGENTS
+        .filter(baseagent => {
+        const block = configured[baseagent];
+        return Object.hasOwn(configured, baseagent) && block !== null
+            && typeof block === 'object' && !Array.isArray(block);
+    })
+        .map((baseagent, index) => ({
+        // Value batches only carry entry IDs, so each configured backend gets a
+        // binding with an explicit backend instead of an implicit Claude default.
+        id: `baseagent.models.${baseagent}`,
+        type: 'list',
+        contexts: ['process'],
+        name: 'baseagent-models',
+        label: `${baseagent} 模型目录`,
+        section: 'process',
+        order: 41 + index,
+        query: { cmd: '/baseagent-models', args: { baseagent }, operation: 'baseagent.models.list', scope: 'process' },
+        control: 'list',
+    }));
+}
+function menuEntryDefinitions(context) {
+    return context.kind === 'process' ? [...ENTRIES, ...configuredHostBaseagentEntries()] : ENTRIES;
+}
 function intentFor(binding, context) { return { operation: binding.operation, scope: binding.scope, source: 'menu', args: { ...bindingArgs(binding, context) } }; }
 async function operationView(binding, context, options = {}) {
     if (!binding)
@@ -340,7 +369,8 @@ export async function getMenuCatalog(input) {
     const context = await resolveMenuCatalogContext(input);
     const entries = [];
     const paircodeAllowed = input.paircodeAllowed ?? input.channelScope !== 'control';
-    for (const entry of ENTRIES.filter(candidate => entryVisible(candidate, context)).sort((a, b) => a.order - b.order)) {
+    const definitions = menuEntryDefinitions(context);
+    for (const entry of definitions.filter(candidate => entryVisible(candidate, context)).sort((a, b) => a.order - b.order)) {
         const operations = {};
         for (const [key, binding] of [['query', entry.query], ['options', entry.options], ['update', entry.update], ['action', entry.action]]) {
             const view = await operationView(binding, context, { paircodeAllowed });
@@ -378,7 +408,7 @@ export async function execMenuValueBatch(input) {
         normalizedItems.push({ itemId, entryId });
     }
     const results = new Array(normalizedItems.length);
-    const byId = new Map(ENTRIES.map(entry => [entry.id, entry]));
+    const byId = new Map(menuEntryDefinitions(context).map(entry => [entry.id, entry]));
     let cursor = 0;
     const resolveItem = async (item) => {
         const { itemId, entryId } = item;