evolcore 0.0.1 → 0.0.2

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

@@ -0,0 +1,3354 @@
+import { normalizePeer, writeScope } from '../model/config-scope.js';
+import { formatPeerKey } from '../relation/peer-identity.js';
+import { modelMatches } from '../model/model-catalog.js';
+import { constrainResolvedModelForRole, filterModelsForRole, validateModelSelectionForRole } from '../model/model-permission.js';
+import { hasModelSwitcher } from '../../agents/runner-types.js';
+import { getCodexEfforts } from '../../agents/codex-runner.js';
+import { resolvePaths, getPackageRoot } from '../../paths.js';
+import { buildEnvelope } from '../message/message-utils.js';
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import { execFileSync } from 'child_process';
+import { CronExpressionParser } from 'cron-parser';
+import { parseDuration } from '../../trigger/parser.js';
+import { checkLatestVersion, getLocalVersion, isLinkedInstall, compareVersions, resolveGlobalPkg } from '../../utils/npm-ops.js';
+import { commandExists } from '../../utils/cross-platform.js';
+import { loadDefaults, loadDaemonConfig } from '../../config-store.js';
+import { WEB_PACKAGE_NAME } from '../../product.js';
+import { read as cfgRead, resolveEffective, resolveEffectiveFieldWithSource, routeFieldPath, write as cfgWrite, ConfigTarget, } from '../../config/config-manager.js';
+import { execAgentAction, execAgentQuery, execAgentOptions, resolveProjectPath } from './agent-control.js';
+import { gatewayList, gatewayUpdate, gatewayDelete, gatewayTest, gatewayModels, gatewaySetPrice, gatewaySyncEnv } from '../../config/gateway-config.js';
+import { displaySessionTitle } from '../session/session-title.js';
+import { buildSessionTurnList } from '../session/session-turns.js';
+import { isCapabilityType, listCapabilityOptions, queryCapabilityTypes, resolveCapabilityContext, updateCapabilityPolicy, } from '../capability/capability-manager.js';
+import { normalizeCliArgv, parseCliIntent, parseLegacyCliCommand, validateCliArgv, withDefaultRelationContext } from './cli-intent-parser.js';
+import { auditCommandAuthorization, hashArgv } from '../auth/authorization-audit.js';
+import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
+import { splitConfigBatchGetArgv } from '../../config/config-batch-get.js';
+import { chatmodeFieldForPeer, resolveChatModeForField } from '../message/peer-mode.js';
+import { PUBLIC_PERMISSION_MODES } from '../permission/mode.js';
+import { resolveRuntimePermissionMode, resolveRuntimeStringField, validateRuntimeStringFieldOverride, } from '../role/runtime-policy.js';
+import { isManagementRole } from '../../config/builtin-roles.js';
+import { SYSTEM_CONTROL_CHANNEL } from '../system-channels.js';
+import { logger } from '../../utils/logger.js';
+import { dispatchToMentionMode } from '../../config/mention-mode.js';
+import { menuFailure, menuSuccess, normalizeMenuError, validateConfigWriteScope, validateMenuRequest } from './menu-protocol.js';
+import { roleMenuAction, roleMenuOperation, roleMenuOptions, roleMenuQuery, roleMenuUpdate, } from './role-menu.js';
+/**
+ * 获取 baseagent CLI 的版本号（claude/gemini/codex）。
+ * 失败返回 null（命令不存在或执行失败）。
+ */
+function getBaseagentVersion(cmd) {
+    try {
+        const output = execFileSync(cmd, ['--version'], {
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+        // claude: "2.1.187 (Claude Code)" → 提取 "2.1.187"
+        // gemini: "0.38.0" → 直接返回
+        // codex: "codex-cli 0.142.0" → 提取 "0.142.0"
+        const match = output.match(/(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+const allEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
+const PERMISSION_MODE_KEYS = PUBLIC_PERMISSION_MODES;
+/** menu file: fetch 文件大小上限（与 /file 一致） */
+const FILE_FETCH_MAX_SIZE = 10 * 1024 * 1024;
+/** menu file: query 的 sha256 仅对 ≤ 2 MB 文件计算，超过返回 null（见设计文档 §7 决策 2） */
+const FILE_HASH_MAX_SIZE = 2 * 1024 * 1024;
+const FILE_LIST_DEFAULT_LIMIT = 500;
+const FILE_LIST_MAX_LIMIT = 1000;
+const topicForkTargetsInFlight = new Set();
+function validateCapabilityScope(args) {
+    const scope = args?.scope ?? 'project';
+    return scope === 'project' ? null : { error: 'MVP 只支持 scope=project', code: 'INVALID_SCOPE' };
+}
+function sanitizeCapabilityOptionsForRole(items, role) {
+    if (isManagementRole(role))
+        return items;
+    return items.map(item => {
+        const { desc: _desc, ...rest } = item;
+        return rest;
+    });
+}
+/**
+ * 从菜单上下文的 session 推导 resolveIdentity 所需的 chatType/conversationId，
+ * 保证群聊场景命中群成员角色表（否则回退私聊语义会误判角色）。
+ * 返回可展开到 resolveIdentity 位置参数的元组：[chatType, conversationId]。
+ */
+function menuIdentityArgs(session) {
+    if (!session)
+        return [];
+    const chatType = session.chatType === 'group' ? 'group' : session.chatType === 'private' ? 'private' : undefined;
+    const conversationId = chatType === 'group' ? (session.metadata?.groupId || session.channelId) : session.metadata?.peerId;
+    return [chatType, conversationId];
+}
+function sanitizeCapabilityQueryForRole(data, role) {
+    if (isManagementRole(role))
+        return data;
+    const { projectPath: _projectPath, ...rest } = data;
+    return rest;
+}
+function resolveCapabilityTarget(params) {
+    const scopeError = validateCapabilityScope(params.args);
+    if (scopeError)
+        return scopeError;
+    const requestedAid = params.args?.aid ?? params.args?.agent;
+    const targetAgent = requestedAid
+        ? this.agentRegistry?.get?.(String(requestedAid))
+        : params.evolagent ?? this.getOwningAgent?.(params.channel);
+    if (!targetAgent) {
+        return { error: requestedAid ? `未找到 Agent: ${requestedAid}` : '当前 channel 无绑定 agent', code: requestedAid ? 'NOT_FOUND' : 'FORBIDDEN' };
+    }
+    if (!params.fromControlChannel) {
+        const selfAid = this.getOwningAgent?.(params.channel)?.aid;
+        if (selfAid && targetAgent.aid !== selfAid) {
+            return { error: '跨 agent 操作仅允许通过控制 AID channel 执行', code: 'FORBIDDEN' };
+        }
+    }
+    const freshConfig = (() => {
+        try {
+            return resolveEffective({ self: targetAgent.aid }, { cache: true });
+        }
+        catch {
+            return targetAgent.config;
+        }
+    })();
+    const fallbackBaseagent = (() => {
+        try {
+            return targetAgent.baseagent;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const ctx = resolveCapabilityContext({
+        aid: targetAgent.aid,
+        baseagent: params.args?.baseagent ?? params.session?.baseagent ?? freshConfig?.active_baseagent ?? fallbackBaseagent,
+        projectPath: targetAgent.projectPath,
+        sessionProjectPath: params.session?.projectPath,
+        sessionBaseagent: params.session?.baseagent,
+        config: freshConfig,
+    });
+    if ('error' in ctx)
+        return ctx;
+    return { ctx, config: freshConfig, agent: targetAgent };
+}
+function getRenameName(args) {
+    return (args?.name ?? args?.title ?? args?.value ?? '').toString().trim();
+}
+function buildSessionPayload(session, name) {
+    const payload = { id: session.id, name };
+    if (session.agentSessionId)
+        payload.agentSessionId = session.agentSessionId;
+    return payload;
+}
+async function findMainSessionTarget(sessionManager, channel, channelId, target, activeSession) {
+    if (!target) {
+        return activeSession && !activeSession.threadId ? activeSession : undefined;
+    }
+    const sessions = (await sessionManager.listSessions(channel, channelId))
+        .filter((s) => !s.threadId);
+    return sessions.find((s) => s.name === target ||
+        s.id === target ||
+        (target.length >= 8 && s.id.startsWith(target)) ||
+        s.agentSessionId === target ||
+        (!!s.agentSessionId && target.length >= 8 && s.agentSessionId.startsWith(target)));
+}
+async function resolveTopicForkSource(sessionManager, channel, channelId, sourceThreadId) {
+    const threadId = typeof sourceThreadId === 'string' ? sourceThreadId.trim() : '';
+    if (threadId)
+        return sessionManager.getThreadSession(channel, channelId, threadId);
+    const active = await sessionManager.getActiveSession(channel, channelId);
+    return active && !active.threadId ? active : undefined;
+}
+/**
+ * 解析并校验 menu `name=file` 的目标路径（query/fetch 共用）。
+ *
+ * 与文本 `/file` 的差异（见设计文档 §6.2）：
+ *   - 接受项目内**绝对路径**（文本 /file 仍拒绝绝对路径）
+ *   - 项目外文件仅 aid channel owner（identity.role === 'owner'）可取
+ *
+ * 沿用 /file 的安全校验链：拒绝 `..` 穿越、realpathSync 后验证落点。
+ * 成功返回 `{ realPath, projectPath, stat }`；失败返回 `{ error, code }`。
+ */
+function resolveMenuFilePath(input, session, role, expectType) {
+    if (!session?.projectPath)
+        return { error: '当前无活跃会话', code: 'NO_ACTIVE_SESSION' };
+    const raw = (input ?? '').toString().trim();
+    if (!raw)
+        return { error: '缺少 path 参数', code: 'MISSING_VALUE' };
+    // 拒绝 .. 路径穿越（兼容两种分隔符）
+    if (raw.split(path.sep).includes('..') || raw.split('/').includes('..')) {
+        return { error: '不支持 .. 路径穿越', code: 'NO_PERMISSION' };
+    }
+    // 相对路径基于 projectPath 解析；绝对路径原样
+    const resolved = path.isAbsolute(raw) ? raw : path.resolve(session.projectPath, raw);
+    if (!fs.existsSync(resolved)) {
+        return { error: '文件不存在', code: 'NOT_FOUND' };
+    }
+    let realPath;
+    let realProjectPath;
+    try {
+        realPath = fs.realpathSync(resolved);
+        realProjectPath = fs.realpathSync(session.projectPath);
+    }
+    catch {
+        return { error: '文件不存在', code: 'NOT_FOUND' };
+    }
+    const inProject = realPath === realProjectPath || realPath.startsWith(realProjectPath + path.sep);
+    // 项目外文件：仅 aid channel owner 可取（§6.2）
+    if (!inProject && role !== 'owner') {
+        return { error: '无权限：项目外文件仅 owner 可取', code: 'NO_PERMISSION' };
+    }
+    let stat;
+    try {
+        stat = fs.statSync(realPath);
+    }
+    catch {
+        return { error: '文件不存在', code: 'NOT_FOUND' };
+    }
+    if (expectType === 'file' && stat.isDirectory()) {
+        return { error: '暂不支持目录', code: 'NOT_SUPPORTED' };
+    }
+    if (expectType === 'directory' && !stat.isDirectory()) {
+        return { error: '不是目录', code: 'NOT_A_DIRECTORY' };
+    }
+    return { realPath, projectPath: realProjectPath, stat };
+}
+function parseFileListOffset(value) {
+    const n = Number(value);
+    return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+}
+function parseFileListLimit(value) {
+    const raw = value === undefined || value === null || value === ''
+        ? FILE_LIST_DEFAULT_LIMIT
+        : Number(value);
+    const n = Number.isFinite(raw) ? Math.floor(raw) : FILE_LIST_DEFAULT_LIMIT;
+    return Math.min(Math.max(1, n), FILE_LIST_MAX_LIMIT);
+}
+function isInProject(realPath, realProjectPath) {
+    return realPath === realProjectPath || realPath.startsWith(realProjectPath + path.sep);
+}
+function getDirectoryEntryInfo(realPath, realProjectPath, role, dirent) {
+    if (dirent.isDirectory())
+        return { isDirectory: true, followTarget: true };
+    if (!dirent.isSymbolicLink())
+        return { isDirectory: false, followTarget: true };
+    const full = path.join(realPath, dirent.name);
+    let targetRealPath;
+    try {
+        targetRealPath = fs.realpathSync(full);
+    }
+    catch {
+        return { isDirectory: false, followTarget: false };
+    }
+    if (role !== 'owner' && !isInProject(targetRealPath, realProjectPath)) {
+        return { isDirectory: false, followTarget: false };
+    }
+    try {
+        return { isDirectory: fs.statSync(full).isDirectory(), followTarget: true };
+    }
+    catch {
+        return { isDirectory: false, followTarget: false };
+    }
+}
+function listDirectory(realPath, options) {
+    const { offset, limit, includeHidden, projectPath, role } = options;
+    let dirents;
+    try {
+        dirents = fs.readdirSync(realPath, { withFileTypes: true });
+    }
+    catch (e) {
+        const code = e?.code === 'EACCES' || e?.code === 'EPERM' ? 'NO_PERMISSION' : 'EXEC_FAILED';
+        return { error: `目录读取失败: ${e?.message ?? e}`, code };
+    }
+    if (!includeHidden) {
+        dirents = dirents.filter(d => !d.name.startsWith('.'));
+    }
+    const entryInfoByName = new Map();
+    for (const dirent of dirents) {
+        entryInfoByName.set(dirent.name, getDirectoryEntryInfo(realPath, projectPath, role, dirent));
+    }
+    dirents.sort((a, b) => {
+        const ad = entryInfoByName.get(a.name)?.isDirectory ?? false;
+        const bd = entryInfoByName.get(b.name)?.isDirectory ?? false;
+        if (ad !== bd)
+            return ad ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+    const total = dirents.length;
+    const page = dirents.slice(offset, offset + limit);
+    const entries = page.map(dirent => {
+        const full = path.join(realPath, dirent.name);
+        const info = entryInfoByName.get(dirent.name) ?? { isDirectory: false, followTarget: true };
+        // Only stat when we need size/mtime (dirent already tells us if it's a directory)
+        let size = null;
+        let mtime = 0;
+        let birthtime = 0;
+        if (!info.isDirectory) {
+            try {
+                const stat = info.followTarget ? fs.statSync(full) : fs.lstatSync(full);
+                size = stat.size;
+                mtime = stat.mtimeMs;
+                birthtime = stat.birthtimeMs;
+            }
+            catch { }
+        }
+        return {
+            name: dirent.name,
+            type: info.isDirectory ? 'directory' : 'file',
+            size,
+            mtime,
+            birthtime,
+        };
+    });
+    return {
+        data: {
+            entries,
+            total,
+            offset,
+            limit,
+            hasMore: offset + entries.length < total,
+        },
+    };
+}
+const CLI_EXEC_WHITELIST = {
+    status: '*',
+    model: '*',
+    stats: '*',
+    agent: new Set(['list', 'show', 'get']),
+    aid: new Set(['list', 'show', 'lookup']),
+    storage: new Set(['ls', 'quota']),
+};
+function tokenizeArgv(line) {
+    const out = [];
+    const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let m;
+    while ((m = re.exec(line)) !== null) {
+        out.push(m[1] ?? m[2] ?? m[3] ?? '');
+    }
+    return out;
+}
+function getAvailableEfforts(agent, model) {
+    if (agent.name === 'claude') {
+        return allEfforts;
+    }
+    if (agent.name === 'codex') {
+        return getCodexEfforts(model);
+    }
+    return [];
+}
+function modelDisplayLabel(agent, model) {
+    const full = agent.resolveModelId?.(model);
+    return full && full !== model ? `${model} (${full})` : model;
+}
+function menuStringArg(args, key) {
+    const value = args?.[key];
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+const LEGACY_SESSION_CONFIG_ARG_KEYS = [
+    'session',
+    'sessionId',
+    'session_id',
+    'sessionKey',
+    'session_key',
+    'currentSession',
+    'current_session',
+    'threadId',
+    'thread_id',
+    'targetSession',
+    'target_session',
+    'targetSessionId',
+    'target_session_id',
+    'targetSessionStrategy',
+    'targetThreadId',
+    'target_thread_id',
+];
+function withoutLegacySessionConfigArgs(args) {
+    if (!args || !LEGACY_SESSION_CONFIG_ARG_KEYS.some(key => key in args))
+        return args;
+    const sanitized = { ...args };
+    for (const key of LEGACY_SESSION_CONFIG_ARG_KEYS)
+        delete sanitized[key];
+    return sanitized;
+}
+function toMenuSource(source) {
+    if (source?.target === ConfigTarget.Relation)
+        return 'relation';
+    if (source?.target === ConfigTarget.Agent)
+        return 'agent';
+    if (source?.target === ConfigTarget.Defaults)
+        return 'defaults';
+    return null;
+}
+function menuConfigSource(fieldPath, sel) {
+    try {
+        const source = resolveEffectiveFieldWithSource(fieldPath, sel, { cache: true }).source;
+        return toMenuSource(source);
+    }
+    catch { }
+    return null;
+}
+function menuModelConfigFieldPath(target) {
+    if (target.field === 'effort' && target.baseagent === 'codex') {
+        return `baseagents.${target.baseagent}.reasoning`;
+    }
+    return target.fieldPath;
+}
+function menuChatmodeScope(args) {
+    const raw = menuStringArg(args, 'scope') ?? 'relation';
+    if (raw === 'agent' || raw === 'relation')
+        return raw;
+    return { error: `无效 scope: ${raw}，可选: agent / relation`, code: 'INVALID_SCOPE' };
+}
+function menuChatmodeField(args, session, explicitChatType) {
+    const raw = menuStringArg(args, 'field')
+        ?? menuStringArg(args, 'key')
+        ?? menuStringArg(args, 'chatType');
+    if (raw) {
+        const key = raw.startsWith('chatmode.') ? raw.slice('chatmode.'.length) : raw;
+        if (key === 'private' || key === 'group' || key === 'nothuman')
+            return key;
+        return { error: `无效 chatmode 字段: ${raw}，可选: private / group / nothuman`, code: 'INVALID_FIELD' };
+    }
+    return chatmodeFieldForPeer(session?.chatType ?? explicitChatType, session?.metadata?.peerType);
+}
+function defaultChatmodeForField(field) {
+    return field === 'private' ? 'interactive' : 'proactive';
+}
+function normalizeMenuPeer(input) {
+    try {
+        return normalizePeer(input);
+    }
+    catch (e) {
+        return { error: e?.message || String(e), code: e?.code || 'INVALID_PEER' };
+    }
+}
+function resolveMenuChatmodeTarget(params) {
+    const scope = menuChatmodeScope(params.args);
+    if (typeof scope !== 'string')
+        return scope;
+    const field = menuChatmodeField(params.args, params.session, params.explicitChatType);
+    if (typeof field !== 'string')
+        return field;
+    const explicitSelf = menuStringArg(params.args, 'self')
+        ?? menuStringArg(params.args, 'aid');
+    const currentSelf = this.getOwningAgent?.(params.channel)?.aid
+        ?? params.session?.selfAID
+        ?? undefined;
+    const self = explicitSelf ?? currentSelf;
+    if (!self)
+        return { error: '缺少 self/aid 参数', code: 'MISSING_AID' };
+    if (!params.fromControlChannel && explicitSelf && currentSelf && explicitSelf !== currentSelf) {
+        return { error: '只能设置当前 agent 的 chatmode', code: 'FORBIDDEN' };
+    }
+    const sel = { self };
+    if (scope === 'agent') {
+        return { scope, sel, role: params.role, field, fieldPath: `chatmode.${field}` };
+    }
+    const explicitPeer = menuStringArg(params.args, 'peer') ?? menuStringArg(params.args, 'peerKey');
+    let peerKey;
+    if (explicitPeer) {
+        const normalized = normalizeMenuPeer(explicitPeer);
+        if (typeof normalized !== 'string')
+            return normalized;
+        peerKey = normalized;
+    }
+    else {
+        const chatType = params.session?.chatType ?? params.explicitChatType ?? 'private';
+        const channelType = this.resolveChannelType?.(params.channel) ?? params.session?.channelType;
+        const peerKeyId = chatType === 'group'
+            ? (params.session?.metadata?.groupId || params.channelId)
+            : (params.userId || params.session?.metadata?.peerId || params.channelId);
+        if (channelType && peerKeyId)
+            peerKey = formatPeerKey(channelType, peerKeyId);
+    }
+    if (!peerKey)
+        return { error: 'relation scope 需要 peer/peerKey，或可推导的当前对端', code: 'MISSING_PEER' };
+    return { scope, sel: { ...sel, peerKey }, role: params.role, field, fieldPath: `chatmode.${field}` };
+}
+function readMenuChatmode(target) {
+    try {
+        const resolved = resolveEffectiveFieldWithSource(target.fieldPath, target.sel, { cache: true });
+        const decision = resolveRuntimeStringField({
+            selfAid: target.sel.self,
+            role: target.role,
+            field: target.fieldPath,
+            configuredValue: resolved.value,
+        });
+        const mode = decision.effectiveValue ?? resolveChatModeForField({ ...target.sel, role: target.role, field: target.field });
+        if (mode === 'interactive' || mode === 'proactive') {
+            return {
+                value: mode,
+                source: decision.decidedBy === 'role'
+                    ? 'role'
+                    : toMenuSource(resolved.source) ?? 'builtin',
+            };
+        }
+    }
+    catch { }
+    return { value: defaultChatmodeForField(target.field), source: 'builtin' };
+}
+function writeMenuChatmode(target, value) {
+    const route = routeFieldPath(target.fieldPath, target.scope);
+    const cur = cfgRead(route.target, target.sel) || {};
+    const block = cur.chatmode && typeof cur.chatmode === 'object' && !Array.isArray(cur.chatmode)
+        ? { ...cur.chatmode }
+        : {};
+    block[target.field] = value;
+    cur.chatmode = block;
+    cfgWrite(route.target, cur, target.sel);
+}
+function menuMentionModeScope(args) {
+    const raw = menuStringArg(args, 'scope') ?? 'relation';
+    if (raw === 'agent' || raw === 'relation')
+        return raw;
+    return { error: `无效 scope: ${raw}，可选: agent / relation`, code: 'INVALID_SCOPE' };
+}
+function resolveMenuMentionModeTarget(params) {
+    const scope = menuMentionModeScope(params.args);
+    if (typeof scope !== 'string')
+        return scope;
+    const explicitSelf = menuStringArg(params.args, 'self')
+        ?? menuStringArg(params.args, 'aid');
+    const currentSelf = this.getOwningAgent?.(params.channel)?.aid
+        ?? params.session?.selfAID
+        ?? undefined;
+    const self = explicitSelf ?? currentSelf;
+    if (!self)
+        return { error: '缺少 self/aid 参数', code: 'MISSING_AID' };
+    if (!params.fromControlChannel && explicitSelf && currentSelf && explicitSelf !== currentSelf) {
+        return { error: '只能设置当前 agent 的 mentionMode', code: 'FORBIDDEN' };
+    }
+    const sel = { self };
+    if (scope === 'agent')
+        return { scope, sel, fieldPath: 'mentionMode' };
+    const explicitPeer = menuStringArg(params.args, 'peer') ?? menuStringArg(params.args, 'peerKey');
+    let peerKey;
+    if (explicitPeer) {
+        const normalized = normalizeMenuPeer(explicitPeer);
+        if (typeof normalized !== 'string')
+            return normalized;
+        peerKey = normalized;
+    }
+    else {
+        const chatType = params.session?.chatType ?? params.explicitChatType ?? 'private';
+        const channelType = this.resolveChannelType?.(params.channel) ?? params.session?.channelType;
+        const peerKeyId = chatType === 'group'
+            ? (params.session?.metadata?.groupId || params.channelId)
+            : (params.userId || params.session?.metadata?.peerId || params.channelId);
+        if (channelType && peerKeyId)
+            peerKey = formatPeerKey(channelType, peerKeyId);
+    }
+    if (!peerKey)
+        return { error: 'relation scope 需要 peer/peerKey，或可推导的当前对端', code: 'MISSING_PEER' };
+    return { scope, sel: { ...sel, peerKey }, fieldPath: 'mentionMode' };
+}
+function readMenuMentionMode(target, fallback = null, fallbackSource = null) {
+    try {
+        const resolved = resolveEffectiveFieldWithSource(target.fieldPath, target.sel, { cache: true });
+        if (resolved.value === 'disabled' || resolved.value === 'mention-only') {
+            return { value: resolved.value, source: toMenuSource(resolved.source) };
+        }
+    }
+    catch { }
+    return { value: fallback, source: fallback === null ? null : fallbackSource };
+}
+function writeMenuMentionMode(target, value) {
+    const route = routeFieldPath(target.fieldPath, target.scope);
+    const cur = cfgRead(route.target, target.sel) || {};
+    if (value === null)
+        delete cur.mentionMode;
+    else
+        cur.mentionMode = value;
+    cfgWrite(route.target, cur, target.sel);
+}
+function menuPermissionScope(args) {
+    const raw = menuStringArg(args, 'scope') ?? 'role';
+    if (raw === 'role')
+        return raw;
+    return { error: `无效 scope: ${raw}，permissionMode 只能在角色定义中配置`, code: 'INVALID_SCOPE' };
+}
+function resolveMenuPermissionTarget(params) {
+    const scope = menuPermissionScope(params.args);
+    if (typeof scope !== 'string')
+        return scope;
+    const explicitSelf = menuStringArg(params.args, 'self')
+        ?? menuStringArg(params.args, 'aid');
+    const currentSelf = this.getOwningAgent?.(params.channel)?.aid
+        ?? params.session?.selfAID
+        ?? undefined;
+    const self = explicitSelf ?? currentSelf;
+    if (!self)
+        return { error: '缺少 self/aid 参数', code: 'MISSING_AID' };
+    if (!params.fromControlChannel && explicitSelf && currentSelf && explicitSelf !== currentSelf) {
+        return { error: '只能设置当前 agent 的 permission', code: 'FORBIDDEN' };
+    }
+    return { scope, sel: { self }, role: params.role || 'none', fieldPath: 'permissionMode' };
+}
+function readMenuPermission(target) {
+    const decision = resolveRuntimePermissionMode({ selfAid: target.sel.self, role: target.role });
+    return {
+        value: decision.effectiveValue,
+        source: decision.decidedBy === 'role' ? 'role' : 'builtin',
+    };
+}
+function menuModelScope(args) {
+    const raw = menuStringArg(args, 'scope') ?? 'relation';
+    if (raw === 'agent' || raw === 'relation')
+        return raw;
+    return { error: `无效 scope: ${raw}，可选: agent / relation`, code: 'INVALID_SCOPE' };
+}
+function resolveMenuModelTarget(params) {
+    const scope = menuModelScope(params.args);
+    if (typeof scope !== 'string')
+        return scope;
+    const explicitSelf = menuStringArg(params.args, 'self')
+        ?? menuStringArg(params.args, 'aid');
+    const currentAgent = this.getOwningAgent?.(params.channel) ?? null;
+    const requestedAgent = explicitSelf
+        ? (this.agentRegistry?.get?.(explicitSelf) ?? null)
+        : null;
+    const currentSelf = currentAgent?.aid
+        ?? params.session?.selfAID
+        ?? undefined;
+    const self = explicitSelf ?? currentSelf;
+    if (!self)
+        return { error: '缺少 self/aid 参数', code: 'MISSING_AID' };
+    if (!params.fromControlChannel && explicitSelf && currentSelf && explicitSelf !== currentSelf) {
+        return { error: '只能设置当前 agent 的 model/effort', code: 'FORBIDDEN' };
+    }
+    const baseagent = menuStringArg(params.args, 'baseagent')
+        ?? params.session?.baseagent
+        ?? params.session?.agentId
+        ?? requestedAgent?.baseagent
+        ?? currentAgent?.baseagent
+        ?? this.parseDefaultBaseagent?.();
+    if (!baseagent)
+        return { error: '缺少 baseagent 参数', code: 'MISSING_BASEAGENT' };
+    const sel = { self };
+    if (scope === 'agent') {
+        return { scope, sel, role: params.role, baseagent, field: params.field, fieldPath: `baseagents.${baseagent}.${params.field}` };
+    }
+    const explicitPeer = menuStringArg(params.args, 'peer') ?? menuStringArg(params.args, 'peerKey');
+    let peerKey;
+    if (explicitPeer) {
+        const normalized = normalizeMenuPeer(explicitPeer);
+        if (typeof normalized !== 'string')
+            return normalized;
+        peerKey = normalized;
+    }
+    else {
+        const chatType = params.session?.chatType ?? params.explicitChatType ?? 'private';
+        const channelType = this.resolveChannelType?.(params.channel) ?? params.session?.channelType;
+        const peerKeyId = chatType === 'group'
+            ? (params.session?.metadata?.groupId || params.channelId)
+            : (params.userId || params.session?.metadata?.peerId || params.channelId);
+        if (channelType && peerKeyId)
+            peerKey = formatPeerKey(channelType, peerKeyId);
+    }
+    if (!peerKey)
+        return { error: 'relation scope 需要 peer/peerKey，或可推导的当前对端', code: 'MISSING_PEER' };
+    return { scope, sel: { ...sel, peerKey }, role: params.role, baseagent, field: params.field, fieldPath: `baseagents.${baseagent}.${params.field}` };
+}
+function readMenuModel(target, agent) {
+    try {
+        const fieldPath = menuModelConfigFieldPath(target);
+        const resolved = resolveEffectiveFieldWithSource(fieldPath, target.sel, { cache: true });
+        if (target.field === 'model') {
+            const decision = constrainResolvedModelForRole({
+                selfAid: target.sel.self,
+                role: target.role,
+                baseagent: target.baseagent,
+                model: resolved.value,
+                resolveModelId: typeof agent?.resolveModelId === 'function' ? agent.resolveModelId.bind(agent) : undefined,
+            });
+            if (decision.model) {
+                return { value: decision.model, source: decision.constrained ? 'role' : toMenuSource(resolved.source) };
+            }
+        }
+        else {
+            const decision = resolveRuntimeStringField({
+                selfAid: target.sel.self,
+                role: target.role,
+                field: fieldPath,
+                configuredValue: resolved.value,
+            });
+            if (decision.effectiveValue) {
+                return {
+                    value: decision.effectiveValue,
+                    source: decision.decidedBy === 'role' ? 'role' : toMenuSource(resolved.source),
+                };
+            }
+        }
+    }
+    catch { }
+    const fallback = target.field === 'model'
+        ? (typeof agent?.getModel === 'function' ? agent.getModel() : agent?.name)
+        : (typeof agent?.getEffort === 'function' ? agent.getEffort() : undefined);
+    return {
+        value: fallback ?? null,
+        source: fallback == null ? null : 'runner',
+    };
+}
+function menuActivityScope(args) {
+    const raw = menuStringArg(args, 'scope') ?? 'relation';
+    if (raw === 'agent' || raw === 'relation')
+        return raw;
+    return { error: `无效 scope: ${raw}，可选: agent / relation`, code: 'INVALID_SCOPE' };
+}
+function resolveMenuActivityTarget(params) {
+    const scope = menuActivityScope(params.args);
+    if (typeof scope !== 'string')
+        return scope;
+    const explicitSelf = menuStringArg(params.args, 'self') ?? menuStringArg(params.args, 'aid');
+    const currentSelf = this.getOwningAgent?.(params.channel)?.aid
+        ?? params.session?.selfAID
+        ?? undefined;
+    const self = explicitSelf ?? currentSelf;
+    if (!self)
+        return { error: '缺少 self/aid 参数', code: 'MISSING_AID' };
+    if (!params.fromControlChannel && explicitSelf && currentSelf && explicitSelf !== currentSelf) {
+        return { error: '只能设置当前 agent 的 activity', code: 'FORBIDDEN' };
+    }
+    const sel = { self };
+    if (scope === 'agent')
+        return { scope, sel, fieldPath: 'show_activities' };
+    const explicitPeer = menuStringArg(params.args, 'peer') ?? menuStringArg(params.args, 'peerKey');
+    let peerKey;
+    if (explicitPeer) {
+        const normalized = normalizeMenuPeer(explicitPeer);
+        if (typeof normalized !== 'string')
+            return normalized;
+        peerKey = normalized;
+    }
+    else {
+        const chatType = params.session?.chatType ?? params.explicitChatType ?? 'private';
+        const channelType = this.resolveChannelType?.(params.channel) ?? params.session?.channelType;
+        const peerKeyId = chatType === 'group'
+            ? (params.session?.metadata?.groupId || params.channelId)
+            : (params.userId || params.session?.metadata?.peerId || params.channelId);
+        if (channelType && peerKeyId)
+            peerKey = formatPeerKey(channelType, peerKeyId);
+    }
+    if (!peerKey)
+        return { error: 'relation scope 需要 peer/peerKey，或可推导的当前对端', code: 'MISSING_PEER' };
+    return { scope, sel: { ...sel, peerKey }, fieldPath: 'show_activities' };
+}
+function readMenuActivity(target, fallback = 'all') {
+    try {
+        const resolved = resolveEffectiveFieldWithSource(target.fieldPath, target.sel, { cache: true });
+        if (resolved.value === 'all' || resolved.value === 'text' || resolved.value === 'none') {
+            return { value: resolved.value, source: toMenuSource(resolved.source) ?? 'builtin' };
+        }
+    }
+    catch { }
+    return { value: fallback, source: 'builtin' };
+}
+function writeMenuActivity(target, value) {
+    const route = routeFieldPath(target.fieldPath, target.scope);
+    const cur = cfgRead(route.target, target.sel) || {};
+    cur.show_activities = value;
+    cfgWrite(route.target, cur, target.sel);
+}
+function writeMenuModel(target, value) {
+    if (target.field === 'model') {
+        writeScope(target.scope, target.sel, target.baseagent, { model: value });
+    }
+    else {
+        writeScope(target.scope, target.sel, target.baseagent, { effort: value });
+    }
+}
+export function isProcessLevelOwner(peerId, owners) {
+    if (!peerId)
+        return false;
+    return (owners ?? []).includes(peerId);
+}
+// ── 控制面双轨鉴权（见 docs/.../2026-06-10-control-channel-auth-design.md）──
+// 白名单而非黑名单：默认安全，新增进程级 action 需显式加入。
+/** /agent 的进程级 action：仅控制 channel 可执行。 */
+export const PROCESS_LEVEL_AGENT_ACTIONS = new Set(['create', 'delete', 'enable', 'disable']);
+/** /agent 的「本 agent 自管理」action：agent channel 仅 owner/admin 可对自身 aid 执行；update 另行收紧为 owner。 */
+export const SELF_MANAGE_AGENT_ACTIONS = new Set(['update', 'reload']);
+/** 判断 (cmdBase, action) 是否为进程级操作（仅控制 channel 可执行）。
+ *  /system 全部进程级；/agent 仅 create/delete/enable/disable 进程级；其余关系级。 */
+export function isProcessLevelAction(cmdBase, action) {
+    if (cmdBase === '/system')
+        return true;
+    if (cmdBase === '/gateway')
+        return true; // 网关改 baseagent 凭证，进程级，仅控制 channel
+    if (cmdBase === '/config')
+        return true; // 配置查询/修改，进程级，仅控制 channel
+    if (cmdBase === '/agent')
+        return PROCESS_LEVEL_AGENT_ACTIONS.has(action ?? '');
+    return false;
+}
+/** 控制面作用域闸门：在每个 exec 入口算出 cmdBase/action 后调用。
+ *  闸1 进程级 action：仅控制 channel。
+ *  闸2 跨 agent 寻址（args.aid ≠ 自身）：仅控制 channel。
+ *  命中返回 FORBIDDEN 结果，否则返回 null（放行，后续走原有 owner/role 鉴权）。 */
+function gateControlScope(opts) {
+    const { cmdBase, action, args, channel, fromControlChannel } = opts;
+    if (fromControlChannel)
+        return null;
+    if (isProcessLevelAction(cmdBase, action)) {
+        return { error: '此操作仅允许通过控制 AID channel 执行', code: 'FORBIDDEN' };
+    }
+    const targetAid = args?.aid;
+    if (targetAid) {
+        const currentAgentAid = this.getOwningAgent?.(channel)?.aid;
+        if (targetAid !== currentAgentAid) {
+            return { error: '跨 agent 操作仅允许通过控制 AID channel 执行', code: 'FORBIDDEN' };
+        }
+    }
+    return null;
+}
+function buildMenuIntent(verb, cmdBase, args, action, value, fromControlChannel = false) {
+    const payload = { ...(args ?? {}), ...(value !== undefined ? { value } : {}) };
+    const intent = (operation, scope = 'relation', extra) => ({
+        operation,
+        scope,
+        source: 'menu',
+        args: { ...payload, ...(extra ?? {}) },
+    });
+    const modelScope = args?.scope === 'agent' ? 'agent' : 'relation';
+    if (verb === 'query') {
+        if (cmdBase === '/model')
+            return intent('model.current', modelScope);
+        if (cmdBase === '/effort')
+            return intent('model.current', modelScope);
+        if (cmdBase === '/chatmode')
+            return intent('chatmode.current', args?.scope === 'agent' ? 'agent' : 'relation');
+        if (cmdBase === '/mentionmode')
+            return intent('mentionmode.current', args?.scope === 'agent' ? 'agent' : 'relation');
+        if (cmdBase === '/gateway')
+            return intent('gateway.read', 'process');
+        if (cmdBase === '/config')
+            return intent('config.read', 'process');
+        if (cmdBase === '/system')
+            return intent('system.status', 'process');
+        if (cmdBase === '/agent') {
+            return intent(fromControlChannel && !args?.aid ? 'agent.list' : 'agent.show', fromControlChannel ? 'control' : 'agent');
+        }
+        if (cmdBase === '/trigger')
+            return intent('trigger.list', 'relation');
+    }
+    if (verb === 'update') {
+        if (cmdBase === '/model')
+            return intent('model.use', modelScope, { model: value });
+        if (cmdBase === '/effort')
+            return intent('model.effort', modelScope, { effort: value });
+        if (cmdBase === '/chatmode')
+            return intent('chatmode.update', args?.scope === 'agent' ? 'agent' : 'relation', { value });
+        if (cmdBase === '/mentionmode')
+            return intent('mentionmode.update', args?.scope === 'agent' ? 'agent' : 'relation', { value });
+        if (cmdBase === '/gateway')
+            return intent('gateway.write', 'process');
+        if (cmdBase === '/config')
+            return intent('config.write', 'process');
+        if (cmdBase === '/trigger')
+            return intent('trigger.update', 'relation', { action: 'update' });
+    }
+    if (verb === 'action') {
+        if (cmdBase === '/file') {
+            if (action === 'list')
+                return intent('file.list', 'filesystem');
+            if (action === 'fetch')
+                return intent('file.fetch', 'filesystem');
+        }
+        if (cmdBase === '/gateway')
+            return intent('gateway.write', 'process', { action });
+        if (cmdBase === '/system') {
+            if (action === 'restart')
+                return intent('system.restart', 'process', { action });
+            if (action === 'upgrade')
+                return intent('system.upgrade', 'process', { action });
+            if (action === 'check')
+                return intent('system.status', 'process', { action });
+        }
+        if (cmdBase === '/agent') {
+            if (action === 'reload')
+                return intent('agent.reload', fromControlChannel ? 'control' : 'agent', { action });
+            if (action === 'create')
+                return intent('agent.create', 'control', { action });
+            if (action === 'delete' || action === 'disable')
+                return intent('agent.delete', 'control', { action });
+        }
+        if (cmdBase === '/trigger') {
+            if (action === 'set')
+                return intent('trigger.create', 'relation', { action });
+            if (action === 'show')
+                return intent('trigger.show', 'relation', { action });
+            if (action === 'history')
+                return intent('trigger.history', 'relation', { action });
+            if (action === 'enable' || action === 'disable')
+                return intent('trigger.setEnabled', 'relation', { action });
+            if (action === 'cancel')
+                return intent('trigger.cancel', 'relation', { action });
+            if (action === 'delete')
+                return intent('trigger.delete', 'relation', { action });
+            if (action === 'run' || action === 'test')
+                return intent('trigger.run', 'relation', { action });
+        }
+    }
+    return null;
+}
+function buildRelationIntentArgs(params) {
+    const out = { ...(params.args ?? {}) };
+    if (params.selfAid && out.self === undefined)
+        out.self = params.selfAid;
+    if (params.peerKey && out.peer === undefined && out.peerKey === undefined)
+        out.peer = params.peerKey;
+    return out;
+}
+function buildMenuAuthSubject(owner, params) {
+    if (params.subject)
+        return params.subject;
+    const agent = owner.getOwningAgent?.(params.channel);
+    const selfAid = agent?.aid || params.session?.selfAID;
+    const channelType = owner.resolveChannelType?.(params.channel) || params.session?.channelType;
+    const chatType = params.session?.chatType ?? params.explicitChatType ?? 'private';
+    const peerKeyId = chatType === 'group'
+        ? (params.session?.metadata?.groupId || params.channelId)
+        : params.userId;
+    return buildAuthSubject({
+        selfAid,
+        actorId: params.userId,
+        channel: params.channel,
+        channelType: channelType || params.channel.split('#')[0],
+        channelId: params.channelId,
+        chatType,
+        conversationId: peerKeyId,
+        identity: params.identity,
+        processOwners: loadDaemonConfig().owners ?? [],
+        fromControlChannel: params.fromControlChannel,
+    });
+}
+async function authorizeMenuIntent(params) {
+    const { intent, identity, session, channel, channelId, userId, fromControlChannel } = params;
+    if (!intent)
+        return null;
+    const subject = buildMenuAuthSubject(this, {
+        identity,
+        session,
+        explicitChatType: params.explicitChatType,
+        channel,
+        channelId,
+        userId,
+        fromControlChannel,
+        subject: params.subject,
+    });
+    if (intent.operation.startsWith('trigger.') && !subject.selfAid) {
+        return { error: 'Trigger operation requires a channel bound to an Agent', code: 'ROLE_ACCESS_DENIED' };
+    }
+    if (intent.scope === 'relation') {
+        intent.args = buildRelationIntentArgs({
+            args: intent.args,
+            selfAid: subject.selfAid,
+            peerKey: subject.peerKey,
+        });
+    }
+    const source = params.source ?? 'menu';
+    intent.source = source;
+    const decision = await authorizeOperation({ source, intent, subject });
+    if (!decision.allow) {
+        if (intent.operation.startsWith('role.')) {
+            return {
+                error: decision.reason,
+                code: 'PERMISSION_DENIED',
+                data: {
+                    $schema_version: 1,
+                    kind: 'role_permission_denied',
+                    self: subject.selfAid ?? null,
+                    actorRole: subject.role,
+                    operation: intent.operation,
+                },
+            };
+        }
+        return { error: decision.reason, code: decision.code };
+    }
+    return null;
+}
+function buildRoleMenuContext(owner, channel, subject) {
+    const owningAgent = owner.getOwningAgent?.(channel);
+    const self = owningAgent?.aid ?? subject.selfAid;
+    if (!self) {
+        throw {
+            code: 'NOT_FOUND',
+            message: 'Role Menu requires a receiving Agent',
+            data: { $schema_version: 1, kind: 'agent_not_found' },
+        };
+    }
+    const aunAvailable = (owningAgent?.channelInstanceNames?.() ?? [])
+        .some((channelName) => owner.hasRegisteredChannel?.(channelName, 'aun') === true);
+    return {
+        self,
+        actorRole: subject.role,
+        actorAid: subject.actorId,
+        chatType: subject.chatType,
+        aunAvailable,
+        availableBaseagents: Array.from(new Set([
+            ...Object.keys(owningAgent?.config?.baseagents ?? {}),
+            ...(owningAgent?.baseagent ? [owningAgent.baseagent] : []),
+            ...(owningAgent?.name ? (owner.getAvailableBaseagentsForOwner?.(owningAgent.name) ?? []) : []),
+        ])),
+        listModels: async (baseagent) => {
+            const runner = owner.getAgent?.(channel, baseagent);
+            if (!runner?.listModels)
+                return [];
+            return await runner.listModels() ?? [];
+        },
+        resolveModelId: (baseagent, model) => {
+            const runner = owner.getAgent?.(channel, baseagent);
+            return typeof runner?.resolveModelId === 'function' ? runner.resolveModelId(model) : undefined;
+        },
+    };
+}
+async function authorizeRoleMenu(owner, params) {
+    const subject = buildMenuAuthSubject(owner, {
+        identity: params.identity,
+        session: params.session,
+        channel: params.channel,
+        channelId: params.channelId,
+        userId: params.userId,
+        fromControlChannel: params.fromControlChannel,
+        subject: params.subject,
+    });
+    const operation = roleMenuOperation(params.kind, params.args, params.value);
+    const denied = await authorizeMenuIntent.call(owner, {
+        intent: { operation, scope: 'agent', source: params.source, args: { ...(params.args ?? {}) } },
+        identity: params.identity,
+        subject,
+        session: params.session,
+        channel: params.channel,
+        channelId: params.channelId,
+        userId: params.userId,
+        fromControlChannel: params.fromControlChannel,
+        source: params.source,
+    });
+    if (denied)
+        return denied;
+    return { context: buildRoleMenuContext(owner, params.channel, subject) };
+}
+function ecwebErr(id, name, code, message) {
+    return menuFailure({ id, ...(name ? { name } : {}) }, normalizeMenuError({ code, message }));
+}
+function ecwebResp(id, name, result) {
+    return 'error' in result
+        ? menuFailure({ id, ...(name ? { name } : {}) }, normalizeMenuError(result))
+        : menuSuccess({ id, ...(name ? { name } : {}) }, result.data);
+}
+function menuResultFailure(error) {
+    const normalized = normalizeMenuError(error);
+    return { error: normalized.message, code: normalized.code, ...(normalized.data !== undefined ? { data: normalized.data } : {}) };
+}
+function resolveExternalMenuAgentChannel(owner, payload, fallbackChannel, required) {
+    const requestedAid = typeof payload?.agent === 'string' ? payload.agent.trim() : '';
+    if (!requestedAid) {
+        return required
+            ? { error: '缺少顶层 agent 参数', code: 'MISSING_AID' }
+            : { channel: fallbackChannel };
+    }
+    const agent = owner.agentRegistry?.get?.(requestedAid) ?? null;
+    if (!agent)
+        return { error: `未找到 Agent: ${requestedAid}`, code: 'NOT_FOUND' };
+    const channel = agent.channelInstanceNames?.()[0];
+    if (!channel)
+        return { error: `Agent 无可用 channel: ${requestedAid}`, code: 'NOT_FOUND' };
+    return { channel };
+}
+function parseScheduleDurationMs(value) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric))
+        return numeric;
+    const parsed = parseDuration(value);
+    return parsed ?? Number.NaN;
+}
+export function validateScheduleParams(scheduleType, scheduleValue) {
+    if (!['once', 'delay', 'at', 'cron', 'interval', 'event'].includes(scheduleType)) {
+        return `无效 scheduleType: ${scheduleType}（可选: once / delay / at / cron / interval / event）`;
+    }
+    if (scheduleType === 'once')
+        return null;
+    if (scheduleType === 'delay' || scheduleType === 'interval') {
+        const ms = parseScheduleDurationMs(scheduleValue);
+        if (!Number.isFinite(ms) || ms <= 0)
+            return `${scheduleType} 的 scheduleValue 需为正数时长（如 30s / 15m / 2h / 1d）: ${scheduleValue}`;
+    }
+    else if (scheduleType === 'at') {
+        const ts = new Date(scheduleValue).getTime();
+        if (!Number.isFinite(ts))
+            return `at 的 scheduleValue 需为合法时间: ${scheduleValue}`;
+    }
+    else if (scheduleType === 'cron') {
+        try {
+            CronExpressionParser.parse(scheduleValue);
+        }
+        catch {
+            return `无效 cron 表达式: ${scheduleValue}`;
+        }
+    }
+    else if (!scheduleValue) {
+        return 'event 的 scheduleValue 不能为空';
+    }
+    return null;
+}
+/**
+ * 返回结构化命令菜单（供 menu.query 使用）
+ * owner 看到全部命令，admin 看到管理级命令（不含 owner-only），visitor/member 仅看到用户级命令
+ */
+export function getMenuItems(role, chatType = 'private', scope = 'agent') {
+    const isOwner = role === 'owner';
+    const isAdmin = isManagementRole(role);
+    const isControlScope = scope === 'control';
+    const canReadTopic = role !== 'none';
+    const items = [];
+    if (!isAdmin && chatType === 'group') {
+        return [
+            ...(canReadTopic ? [{
+                    group: '话题管理',
+                    commands: [
+                        { cmd: '/topic', label: '话题管理', desc: '查看当前聊天的话题会话', next: { type: 'select', dynamic: true } },
+                    ]
+                }] : []),
+            {
+                group: '其他',
+                commands: [
+                    { cmd: '/status', label: '显示会话状态' },
+                    { cmd: '/check', label: '检查 EvolAgent 实例健康' },
+                    { cmd: '/help', label: '显示帮助信息' },
+                ]
+            }
+        ];
+    }
+    items.push({
+        group: '会话管理',
+        commands: [
+            { cmd: '/new', label: '创建新会话', desc: '清空历史，开始全新对话', next: { type: 'text' } },
+            { cmd: '/s', label: '切换会话', desc: '切换到同项目下的其他会话', next: { type: 'select', dynamic: true } },
+            ...(canReadTopic ? [{ cmd: '/topic', label: '话题管理', desc: '查看与管理当前聊天的话题会话', next: { type: 'select', dynamic: true } }] : []),
+            { cmd: '/name', label: '重命名当前会话', desc: '为当前会话设置一个易识别的名称', next: { type: 'text' } },
+            { cmd: '/del', label: '删除指定会话', desc: '永久删除一个非活跃会话', next: { type: 'select', dynamic: true } },
+            ...(isAdmin ? [
+                { cmd: '/fork', label: '分支当前会话', desc: '基于当前会话创建独立分支', next: { type: 'text' } },
+                { cmd: '/rewind', label: '查看历史/撤销指定轮次', desc: '回退会话到指定轮次，可选择撤销文件改动' },
+                { cmd: '/compact', label: '压缩会话上下文', desc: '将长对话压缩为摘要以节省 token' },
+            ] : []),
+        ]
+    });
+    if (isAdmin) {
+        items.push({
+            group: 'Agent 与模型',
+            commands: [
+                { cmd: '/baseagent', label: '切换 Agent 后端', desc: '切换 Agent 当前 Baseagent', next: { type: 'select', dynamic: true } },
+                { cmd: '/model', label: '切换模型', desc: '切换当前 Agent 使用的模型版本', next: { type: 'select', dynamic: true } },
+                { cmd: '/effort', label: '切换推理强度', desc: '调整模型推理深度，影响响应速度与质量', next: { type: 'select', items: [
+                            { value: 'low', label: 'Low' },
+                            { value: 'medium', label: 'Medium' },
+                            { value: 'high', label: 'High' },
+                            { value: 'max', label: 'Max' },
+                        ] } },
+                { cmd: '/chatmode', label: '切换会话模式', desc: '控制 Agent 主动性（被动响应或主动推进）', next: { type: 'select', items: [
+                            { value: 'interactive', label: '交互模式', desc: '仅在收到消息时响应' },
+                            { value: 'proactive', label: '主动模式', desc: 'Agent 可主动推进任务' },
+                        ] } },
+                { cmd: '/mentionmode', label: '切换 @ 处理模式', desc: '控制群聊消息过滤（仅@提及或全部响应）', next: { type: 'select', items: [
+                            { value: 'mention-only', label: '@ 提及', desc: '仅在被 @ 提及时响应' },
+                            { value: 'disabled', label: '全部响应', desc: '响应群内所有消息' },
+                        ] } },
+                { cmd: '/capability', label: '能力开关管理', desc: '查看并管理 Skills / MCP / Plugins' },
+            ]
+        });
+        items.push({
+            group: '权限管理',
+            commands: [
+                { cmd: '/perm', label: '查看权限模式', desc: '权限模式由当前角色定义决定' },
+            ]
+        });
+        items.push({
+            group: '运维',
+            commands: [
+                { cmd: '/status', label: '显示会话状态', desc: '查看当前会话、项目、Agent 的详细状态' },
+                { cmd: '/stop', label: '中断当前任务', desc: '立即中断正在执行的 Agent 任务' },
+                { cmd: '/check', label: '检查 EvolAgent 实例健康', desc: '检查各 EvolAgent 实例、后端与消息通道的健康状态' },
+                ...(isOwner && !isControlScope ? [{
+                        cmd: '/observable',
+                        label: '观察者模式',
+                        desc: '向 owners 转发 Agent 入站和出站消息',
+                        next: { type: 'select', items: [
+                                { value: 'true', label: '开启' },
+                                { value: 'false', label: '关闭' },
+                            ] },
+                    }] : []),
+                { cmd: '/activity', label: '控制中间输出显示', desc: '设置工具调用过程的可见范围', next: { type: 'select', items: [
+                            { value: 'all', label: '全部显示', desc: '所有用户均可见中间输出' },
+                            { value: 'text', label: '仅文字进展', desc: '显示文字进展，隐藏工具活动' },
+                            { value: 'none', label: '不显示', desc: '关闭所有中间输出' },
+                        ] } },
+                ...(isControlScope && isOwner ? [
+                    { cmd: '/restart', label: '重启服务', desc: '重启整个 EvolCore 服务进程' },
+                ] : []),
+                ...(isAdmin ? [
+                    { cmd: '/file', label: '发送项目内文件', desc: '将项目目录内的文件发送给用户' },
+                ] : []),
+            ]
+        });
+    }
+    else {
+        items.push({
+            group: '其他',
+            commands: [
+                { cmd: '/status', label: '显示会话状态', desc: '查看当前会话的基本状态' },
+                { cmd: '/check', label: '检查 EvolAgent 实例健康', desc: '检查 EvolAgent 实例与消息通道健康状态' },
+            ]
+        });
+    }
+    items.push({
+        group: '帮助',
+        commands: [
+            { cmd: '/help', label: '显示帮助信息', desc: '列出所有可用命令及说明' },
+        ]
+    });
+    return items;
+}
+/** 动态子菜单：根据 cmd 路径返回选项列表（供 menu.query + cmd 使用） */
+export async function getSubMenuItems(cmd, channel, channelId, userId, args, overrideIdentity, explicitChatType, fromControlChannel = false, authSubject, source = 'menu') {
+    const session = await this.sessionManager.getActiveSession(channel, channelId);
+    const subject = buildMenuAuthSubject(this, {
+        identity: overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session)),
+        session,
+        explicitChatType,
+        channel,
+        channelId,
+        userId,
+        fromControlChannel,
+        subject: authSubject,
+    });
+    const cmdBase0 = cmd.trim().split(' ')[0];
+    const gated0 = gateControlScope.call(this, { cmdBase: cmdBase0, args, channel, fromControlChannel });
+    if (gated0)
+        throw { code: gated0.code, message: gated0.error };
+    if (cmdBase0 === '/role') {
+        const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+        const authorized = await authorizeRoleMenu(this, {
+            kind: 'options', args, identity, subject: authSubject, session, channel, channelId,
+            userId, fromControlChannel, source,
+        });
+        if ('error' in authorized)
+            throw authorized;
+        return await roleMenuOptions(authorized.context, args);
+    }
+    // ── /agent list（只读） ──
+    // 控制 channel：验 evolcore.owners，返回全量；agent channel：放行但仅返回自身单条。
+    if (cmd === '/agent') {
+        if (fromControlChannel) {
+            if (!subject.isDaemonOwner) {
+                throw { code: 'FORBIDDEN', message: '操作需要 owner 权限' };
+            }
+            const res = await execAgentOptions(args);
+            if ('error' in res)
+                throw { code: res.code, message: res.error };
+            return res.data.agents.map(ag => ({ value: ag.aid, label: ag.name || ag.aid, desc: ag.status }));
+        }
+        // agent channel：作用域绑定自身，仅返回自身单条
+        const selfAid = this.getOwningAgent?.(channel)?.aid;
+        if (!selfAid)
+            throw { code: 'FORBIDDEN', message: '当前 channel 无绑定 agent' };
+        const res = await execAgentOptions(args);
+        if ('error' in res)
+            throw { code: res.code, message: res.error };
+        return res.data.agents
+            .filter(ag => ag.aid === selfAid)
+            .map(ag => ({ value: ag.aid, label: ag.name || ag.aid, desc: ag.status }));
+    }
+    if (cmd === '/capability') {
+        const type = args?.type;
+        if (!isCapabilityType(type)) {
+            throw { code: type ? 'INVALID_TYPE' : 'INVALID_ARGS', message: 'args.type 必须是 skill / mcp / plugin' };
+        }
+        const target = resolveCapabilityTarget.call(this, { channel, args, session, fromControlChannel });
+        if ('error' in target)
+            throw { code: target.code, message: target.error };
+        const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+        const options = await listCapabilityOptions(target.ctx, target.config, type);
+        return sanitizeCapabilityOptionsForRole(options, identity.role);
+    }
+    // ── 关系级 /trigger list（每个 trigger 一个 MenuItem） ──
+    if (cmd === '/trigger') {
+        const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+        const authDenied = await authorizeMenuIntent.call(this, {
+            intent: buildMenuIntent('query', cmd, args, undefined, undefined, fromControlChannel),
+            identity,
+            subject,
+            session,
+            explicitChatType,
+            channel,
+            channelId,
+            userId,
+            fromControlChannel,
+            source,
+        });
+        if (authDenied)
+            throw { code: authDenied.code, message: authDenied.error, data: authDenied.data };
+        const triggerScheduler = this.getTriggerSchedulerForChannel?.(channel);
+        const scope = args?.options === 'all' ? 'all' : 'enabled';
+        const role = identity.role;
+        const isAdmin = isManagementRole(role);
+        if (!triggerScheduler)
+            return [];
+        const list = triggerScheduler.list({ all: scope === 'all' });
+        return list
+            .filter((definition) => this.canAccessTriggerDefinition(definition, userId ?? '', channel, isAdmin))
+            .map((definition) => {
+            const view = this.definitionToTriggerView(definition, triggerScheduler);
+            return {
+                ...view,
+                value: definition.id,
+                label: definition.name,
+                desc: `${view.scheduleType}${view.nextFireAt ? ` | 下次 ${new Date(view.nextFireAt).toLocaleString()}` : ''}`,
+                status: definition.enabled ? 'active' : 'disabled',
+            };
+        });
+    }
+    if (cmd === '/topic') {
+        const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+        if (!this.canReadTopics(identity.role)) {
+            throw { code: 'FORBIDDEN', message: '无权限查看话题' };
+        }
+        if (args?.mode === 'fork-turns') {
+            const source = await resolveTopicForkSource(this.sessionManager, channel, channelId, args?.sourceThreadId);
+            if (!source)
+                throw { code: 'NOT_FOUND', message: '来源会话不存在' };
+            if (source.chatType !== 'private' || explicitChatType === 'group') {
+                throw { code: 'NOT_SUPPORTED', message: '历史上下文分叉仅支持私聊' };
+            }
+            if (!source.agentSessionId)
+                return [];
+            const agent = this.getAgent(channel, source.baseagent);
+            if (!agent.capabilities?.forkAtTurn || !agent.getSessionMessages || !agent.forkSessionAt)
+                return [];
+            const turns = buildSessionTurnList(await agent.getSessionMessages(source.agentSessionId, source.projectPath));
+            return turns.map((turn) => ({
+                value: turn.assistantUuid,
+                label: `#${turn.index} ${turn.userContent}`,
+                preview: turn.userContent,
+                turn: turn.index,
+                assistantMessageId: turn.assistantUuid,
+                userMessageId: turn.userUuid,
+            }));
+        }
+        const sessions = await this.sessionManager.listSessions(channel, channelId);
+        return sessions
+            .filter((s) => !!s.threadId)
+            .map((s) => this.buildTopicMenuItem(s));
+    }
+    if (cmd === '/s' || cmd === '/session' || cmd === '/del') {
+        const sessions = await this.sessionManager.listSessions(channel, channelId);
+        const active = cmd === '/del' ? await this.sessionManager.getActiveSession(channel, channelId) : null;
+        const currentSession = session;
+        const items = sessions
+            .filter((s) => !s.threadId)
+            .filter((s) => !active || s.id !== active.id)
+            .map((s) => {
+            const displayName = displaySessionTitle(s.name, s.id.slice(0, 8));
+            const item = {
+                value: s.name || s.id.slice(0, 8),
+                label: displayName,
+                selected: currentSession ? s.id === currentSession.id : false,
+            };
+            if (s.agentSessionId) {
+                item.agentSessionId = s.agentSessionId;
+                const fileInfo = this.sessionManager.getSessionFileInfo(s.projectPath, s.agentSessionId, s.baseagent);
+                if (fileInfo.turns)
+                    item.turns = fileInfo.turns;
+                const firstMsg = this.sessionManager.readSessionFirstMessage(s.projectPath, s.agentSessionId, s.baseagent);
+                if (firstMsg)
+                    item.preview = firstMsg.length > 80 ? firstMsg.slice(0, 80) + '…' : firstMsg;
+            }
+            if (s.updatedAt)
+                item.lastActive = s.updatedAt;
+            return item;
+        });
+        if (cmd === '/s' || cmd === '/session') {
+            items.push({ value: 'cli', label: '查看 CLI 会话', desc: '列出未导入的 CLI 本地会话' });
+        }
+        return items;
+    }
+    if (cmd === '/baseagent') {
+        const requestedAgent = typeof args?.aid === 'string'
+            ? (this.agentRegistry?.get?.(args.aid) ?? null)
+            : null;
+        const currentAgent = requestedAgent?.baseagent
+            ?? this.agentRegistry?.resolveByChannel(channel)?.baseagent
+            ?? this.parseDefaultBaseagent?.();
+        const available = requestedAgent?.name
+            ? (this.getAvailableBaseagentsForOwner?.(requestedAgent.name) ?? [])
+            : this.getAvailableBaseagents(channel);
+        return available.map((name) => ({ value: name, label: name, selected: name === currentAgent }));
+    }
+    if (cmd === '/model') {
+        const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+        const target = resolveMenuModelTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+            field: 'model',
+        });
+        if ('error' in target)
+            throw { code: target.code, message: target.error };
+        const agent = this.getAgent(channel, target.baseagent);
+        if (hasModelSwitcher(agent) && agent.listModels) {
+            const role = identity.role;
+            const authIntent = {
+                operation: 'model.list',
+                scope: target.scope,
+                source: 'menu',
+                args: {},
+            };
+            const subject = buildMenuAuthSubject(this, {
+                identity,
+                session,
+                explicitChatType,
+                channel,
+                channelId,
+                userId,
+                fromControlChannel,
+                subject: authSubject,
+            });
+            authIntent.args = target.scope === 'relation'
+                ? buildRelationIntentArgs({ args, selfAid: target.sel.self, peerKey: target.sel.peerKey })
+                : { ...(args ?? {}), self: target.sel.self };
+            const decision = await authorizeOperation({ source: 'menu', intent: authIntent, subject, audit: false });
+            if (!decision.allow)
+                throw { code: decision.code, message: decision.reason };
+            const rawModels = await agent.listModels() ?? [];
+            const models = filterModelsForRole(role, target.baseagent, rawModels, agent.resolveModelId?.bind(agent));
+            const requestedModel = menuStringArg(args, 'model') ?? menuStringArg(args, 'current');
+            const currentModel = requestedModel || readMenuModel(target, agent).value || agent.getModel();
+            if (models.length > 0)
+                return models.map((m) => ({ value: m, label: modelDisplayLabel(agent, m), selected: modelMatches(agent, m, currentModel) }));
+        }
+        return null;
+    }
+    // if (cmd === '/restart') {
+    //   const isOwner = userId ? this.sessionManager.resolveIdentity(channel, userId).role === 'owner' : false;
+    //   // 列出所有 channel type
+    //   const visibleTypes = new Set<string>();
+    //   for (const [name] of this.adapters) {
+    //     const t = this.channelTypeMap.get(name);
+    //     if (t) visibleTypes.add(t);
+    //   }
+    //   const channels = [...visibleTypes].map(type => ({ value: type, label: type, desc: '重连此类型所有渠道实例' }));
+    //   if (isOwner) channels.unshift({ value: '', label: '重启服务', desc: '重启整个 EvolCore 服务进程' });
+    //   return channels;
+    // }
+    if (cmd === '/activity') {
+        const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+        const target = resolveMenuActivityTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            throw { code: target.code, message: target.error };
+        const fallback = this.agentRegistry?.getShowActivities?.(channel) ?? 'all';
+        const currentMode = readMenuActivity(target, fallback).value;
+        return [
+            { value: 'all', label: '私聊显示', selected: currentMode === 'all' },
+            { value: 'text', label: '仅文字进展', selected: currentMode === 'text' },
+            { value: 'none', label: '全部静默', selected: currentMode === 'none' },
+        ];
+    }
+    if (cmd === '/effort') {
+        const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+        const target = resolveMenuModelTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+            field: 'effort',
+        });
+        if ('error' in target)
+            throw { code: target.code, message: target.error };
+        const agent = this.getAgent(channel, target.baseagent);
+        const requestedModel = menuStringArg(args, 'model') ?? menuStringArg(args, 'currentModel');
+        const modelTarget = { ...target, field: 'model', fieldPath: `baseagents.${target.baseagent}.model` };
+        const currentModel = requestedModel || (hasModelSwitcher(agent) ? (readMenuModel(modelTarget, agent).value || agent.getModel()) : agent.name);
+        const efforts = getAvailableEfforts(agent, currentModel);
+        const currentEffort = menuStringArg(args, 'effort') ?? menuStringArg(args, 'current') ?? readMenuModel(target, agent).value ?? 'auto';
+        const allItems = [...efforts, 'auto'];
+        return allItems.map(e => ({ value: e, label: e === 'auto' ? 'auto (SDK默认)' : e, selected: e === currentEffort }));
+    }
+    if (cmd === '/chatmode') {
+        const target = resolveMenuChatmodeTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: (overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session))).role,
+            explicitChatType,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            throw { code: target.code, message: target.error };
+        const currentMode = readMenuChatmode(target).value;
+        return [
+            { value: 'interactive', label: '交互模式', selected: currentMode === 'interactive' },
+            { value: 'proactive', label: '主动模式', selected: currentMode === 'proactive' },
+        ];
+    }
+    if (cmd === '/mentionmode') {
+        const target = resolveMenuMentionModeTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: (overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session))).role,
+            explicitChatType,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            throw { code: target.code, message: target.error };
+        const fallback = dispatchToMentionMode(session?.metadata?.dispatchMode) ?? null;
+        const currentMode = readMenuMentionMode(target, fallback, fallback === null ? null : 'session').value;
+        return [
+            { value: 'mention-only', label: '@提及时响应', selected: currentMode === 'mention-only' },
+            { value: 'disabled', label: '所有消息响应', selected: currentMode === 'disabled' },
+        ];
+    }
+    if (cmd === '/perm') {
+        return [];
+    }
+    return null;
+}
+// ── Menu Protocol exec ────────────────────────────────────────────────
+//
+// 三个入口对应 menu.query / menu.update / menu.action：
+//   execMenuQuery  — 查询某项当前值（无会话时多数 fallback 到 evolagent config）
+//   execMenuUpdate — 写入新值（持久化到 session 或 evolagent config）
+//   execMenuAction — 触发动词（stop/restart/new/delete/compact/fork/switch/check/upgrade）
+//
+// 所有方法返回 { data } 或 { error, code? }。code 是结构化错误码（NO_ACTIVE_SESSION 等），
+// 客户端可据此决定降级策略。message-bridge 把 code 透传到 menu.response。
+/** menu.query — 查询当前值。 */
+export async function execMenuQuery(cmd, channel, channelId, userId, args, explicitChatType, fromControlChannel = false, overrideIdentity, authSubject, source = 'menu') {
+    const cmdBase = cmd.trim().split(' ')[0];
+    if (!cmdBase)
+        return { error: '缺少命令', code: 'MISSING_CMD' };
+    const gated = gateControlScope.call(this, { cmdBase, args, channel, fromControlChannel });
+    if (gated)
+        return gated;
+    const { session, evolagent } = await this.loadMenuContext(channel, channelId);
+    const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+    const subject = buildMenuAuthSubject(this, {
+        identity,
+        session,
+        explicitChatType,
+        channel,
+        channelId,
+        userId,
+        fromControlChannel,
+        subject: authSubject,
+    });
+    if (cmdBase === '/role') {
+        const authorized = await authorizeRoleMenu(this, {
+            kind: 'query', args, identity, subject, session, channel, channelId,
+            userId, fromControlChannel, source,
+        });
+        if ('error' in authorized)
+            return authorized;
+        try {
+            return { data: await roleMenuQuery(authorized.context, args) };
+        }
+        catch (error) {
+            return menuResultFailure(error);
+        }
+    }
+    const authDenied = await authorizeMenuIntent.call(this, {
+        intent: buildMenuIntent('query', cmdBase, args, undefined, undefined, fromControlChannel),
+        identity,
+        subject,
+        session,
+        explicitChatType,
+        channel,
+        channelId,
+        userId,
+        fromControlChannel,
+        source,
+    });
+    if (authDenied)
+        return authDenied;
+    // ── /agent 查询（只读） ──
+    // 控制 channel：验 owners，按 args.aid 查任意 agent；agent channel：强制查自身。
+    if (cmdBase === '/agent') {
+        if (fromControlChannel) {
+            if (!subject.isDaemonOwner) {
+                return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
+            }
+            return await execAgentQuery(args);
+        }
+        const selfAid = this.getOwningAgent?.(channel)?.aid;
+        if (!selfAid)
+            return { error: '当前 channel 无绑定 agent', code: 'FORBIDDEN' };
+        return await execAgentQuery({ ...(args ?? {}), aid: selfAid });
+    }
+    // ── /gateway 查询（只读，列出全部作用域的网关配置；apiKey 已掩码） ──
+    // 进程级：闸门已要求 fromControlChannel；此处再验 owners 非空。
+    if (cmdBase === '/gateway') {
+        if (!subject.isDaemonOwner) {
+            return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
+        }
+        return gatewayList();
+    }
+    // ── /config 查询（只读，查询各层配置） ──
+    if (cmdBase === '/config') {
+        const scope = args?.scope || 'process';
+        if (scope === 'process') {
+            // 进程级配置需要 owner 权限
+            if (!fromControlChannel || !subject.isDaemonOwner) {
+                return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
+            }
+            const cfg = loadDaemonConfig();
+            return { data: { scope: 'process', config: cfg } };
+        }
+        if (scope === 'defaults') {
+            // 全局默认配置需要 owner 权限
+            if (!fromControlChannel || !subject.isDaemonOwner) {
+                return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
+            }
+            const { read, ConfigTarget } = await import('../../config/config-manager.js');
+            const cfg = read(ConfigTarget.Defaults, undefined, { cache: true });
+            return { data: { scope: 'defaults', config: cfg } };
+        }
+        if (scope === 'agent') {
+            const aid = args?.aid;
+            if (!aid)
+                return { error: '缺少 aid 参数', code: 'MISSING_AID' };
+            // 控制 channel 可以查任意 agent，agent channel 只能查自身
+            if (!fromControlChannel) {
+                const selfAid = this.getOwningAgent?.(channel)?.aid;
+                if (selfAid !== aid) {
+                    return { error: '只能查询自己的配置', code: 'FORBIDDEN' };
+                }
+            }
+            const { read, ConfigTarget } = await import('../../config/config-manager.js');
+            const cfg = read(ConfigTarget.Agent, { self: aid }, { cache: true });
+            return { data: { scope: 'agent', aid, config: cfg } };
+        }
+        return { error: '未知的 scope', code: 'INVALID_SCOPE' };
+    }
+    if (cmdBase === '/capability') {
+        const type = args?.type;
+        if (type !== undefined && !isCapabilityType(type)) {
+            return { error: 'type 必须是 skill / mcp / plugin', code: 'INVALID_TYPE' };
+        }
+        const target = resolveCapabilityTarget.call(this, { channel, args, session, evolagent, fromControlChannel });
+        if ('error' in target)
+            return target;
+        const identity = this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+        const data = queryCapabilityTypes(target.ctx, target.config, type);
+        return { data: sanitizeCapabilityQueryForRole(data, identity.role) };
+    }
+    if (cmdBase === '/pwd') {
+        const sessPath = session?.projectPath;
+        const fallbackPath = evolagent?.config?.projects?.defaultPath;
+        const path = sessPath ?? fallbackPath ?? null;
+        const name = path ? this.getProjectName(path) : null;
+        const source = sessPath != null
+            ? 'session'
+            : fallbackPath != null
+                ? (evolagent?.aid
+                    ? menuConfigSource('projects.defaultPath', { self: evolagent.aid }) ?? 'agent'
+                    : 'agent')
+                : null;
+        return { data: { name, path, source } };
+    }
+    if (cmdBase === '/session' || cmdBase === '/s') {
+        if (!session) {
+            return { data: { status: 'no-session' } };
+        }
+        const sessionKey = this.getQueueKey(session, channel, channelId);
+        const sessionAgent = this.getAgent(channel, session.baseagent);
+        const isProcessing = this.messageQueue.isProcessing(sessionKey) || sessionAgent.hasActiveStream(sessionKey);
+        const queueLength = this.messageQueue.getQueueLength(sessionKey);
+        const health = await this.sessionManager.getHealthStatus(session.id);
+        let processingDuration;
+        if (isProcessing && session.processingState) {
+            const elapsed = Date.now() - parseInt(session.processingState, 10);
+            if (!isNaN(elapsed) && elapsed > 0)
+                processingDuration = Math.floor(elapsed / 1000);
+        }
+        let turns = 0;
+        if (session.agentSessionId) {
+            const fileInfo = this.sessionManager.getSessionFileInfo(session.projectPath, session.agentSessionId, session.baseagent);
+            turns = fileInfo.turns;
+        }
+        const data = {
+            name: session.name || null,
+            agentSessionId: session.agentSessionId || null,
+            status: isProcessing ? 'processing' : 'idle',
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+        };
+        if (processingDuration !== undefined)
+            data.processingDuration = processingDuration;
+        if (queueLength > 0)
+            data.queueLength = queueLength;
+        if (turns > 0)
+            data.turns = turns;
+        if (health.lastSuccessTime)
+            data.lastSuccess = health.lastSuccessTime;
+        if (health.consecutiveErrors)
+            data.consecutiveErrors = health.consecutiveErrors;
+        if (health.lastError)
+            data.lastError = { type: health.lastErrorType || 'unknown', message: health.lastError.substring(0, 100) };
+        return { data };
+    }
+    if (cmdBase === '/topic') {
+        if (!this.canReadTopics(identity.role)) {
+            return { error: '无权限查看话题', code: 'FORBIDDEN' };
+        }
+        const target = (args?.target ?? '').toString().trim();
+        if (!target)
+            return { error: '缺少 args.target', code: 'MISSING_VALUE' };
+        const topic = await this.sessionManager.getThreadSession(channel, channelId, target);
+        if (!topic)
+            return { error: '话题不存在', code: 'NOT_FOUND' };
+        const sessionKey = this.getQueueKey(topic, channel, channelId);
+        const sessionAgent = this.getAgent(channel, topic.baseagent);
+        const isProcessing = this.messageQueue.isProcessing(sessionKey) || sessionAgent.hasActiveStream(sessionKey);
+        const queueLength = this.messageQueue.getQueueLength(sessionKey);
+        const health = await this.sessionManager.getHealthStatus(topic.id);
+        let processingDuration;
+        if (isProcessing && topic.processingState) {
+            const elapsed = Date.now() - parseInt(topic.processingState, 10);
+            if (!isNaN(elapsed) && elapsed > 0)
+                processingDuration = Math.floor(elapsed / 1000);
+        }
+        let turns = 0;
+        if (topic.agentSessionId) {
+            turns = this.sessionManager.getSessionFileInfo(topic.projectPath, topic.agentSessionId, topic.baseagent).turns;
+        }
+        const data = {
+            threadId: topic.threadId,
+            name: topic.name || null,
+            agentSessionId: topic.agentSessionId || null,
+            status: isProcessing ? 'processing' : 'idle',
+            createdAt: topic.createdAt,
+            updatedAt: topic.updatedAt,
+        };
+        if (processingDuration !== undefined)
+            data.processingDuration = processingDuration;
+        if (queueLength > 0)
+            data.queueLength = queueLength;
+        if (turns > 0)
+            data.turns = turns;
+        if (health.lastSuccessTime)
+            data.lastSuccess = health.lastSuccessTime;
+        if (health.consecutiveErrors)
+            data.consecutiveErrors = health.consecutiveErrors;
+        if (health.lastError)
+            data.lastError = { type: health.lastErrorType || 'unknown', message: health.lastError.substring(0, 100) };
+        return { data };
+    }
+    if (cmdBase === '/baseagent') {
+        const requestedAgent = typeof args?.aid === 'string'
+            ? (this.agentRegistry?.get?.(args.aid) ?? null)
+            : null;
+        const targetAgent = requestedAgent ?? evolagent;
+        const value = targetAgent?.baseagent ?? targetAgent?.config?.active_baseagent ?? null;
+        const source = value == null
+            ? null
+            : targetAgent?.aid
+                ? menuConfigSource('active_baseagent', { self: targetAgent.aid }) ?? 'agent'
+                : 'agent';
+        return { data: { baseagent: value, scope: 'agent', source } };
+    }
+    if (cmdBase === '/model') {
+        const target = resolveMenuModelTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+            field: 'model',
+        });
+        if ('error' in target)
+            return target;
+        const agent = this.getAgent(channel, target.baseagent);
+        const current = readMenuModel(target, agent);
+        return {
+            data: {
+                model: current.value,
+                baseagent: target.baseagent,
+                source: current.source,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/effort') {
+        const target = resolveMenuModelTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+            field: 'effort',
+        });
+        if ('error' in target)
+            return target;
+        const agent = this.getAgent(channel, target.baseagent);
+        const current = readMenuModel(target, agent);
+        return {
+            data: {
+                effort: current.value,
+                baseagent: target.baseagent,
+                source: current.source,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/chatmode') {
+        const target = resolveMenuChatmodeTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            return target;
+        const current = readMenuChatmode(target);
+        return {
+            data: {
+                mode: current.value,
+                source: current.source,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/mentionmode') {
+        const chatType = session?.chatType ?? explicitChatType ?? 'private';
+        if (chatType !== 'group') {
+            return { error: 'mentionMode 仅在群聊会话中有效', code: 'NOT_APPLICABLE' };
+        }
+        const target = resolveMenuMentionModeTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            return target;
+        // session metadata 是 AUN 协议词汇，翻译成 mentionMode 词汇；evolagent.config 已是 mentionMode 字段
+        const fallback = dispatchToMentionMode(session?.metadata?.dispatchMode) ?? null;
+        const current = readMenuMentionMode(target, fallback, fallback === null ? null : 'session');
+        return {
+            data: {
+                mode: current.value,
+                source: current.source,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/observable') {
+        if (identity.role !== 'owner')
+            return { error: '观察者模式仅限 owner 查看', code: 'NO_PERMISSION' };
+        if (!evolagent)
+            return { error: '找不到通道所属 agent', code: 'MISSING_AID' };
+        const observable = evolagent?.getObservable() ?? false;
+        const source = evolagent?.aid
+            ? menuConfigSource('observable', { self: evolagent.aid }) ?? 'builtin'
+            : 'builtin';
+        return { data: { observable, source } };
+    }
+    if (cmdBase === '/perm') {
+        const target = resolveMenuPermissionTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            return target;
+        const current = readMenuPermission(target);
+        return {
+            data: {
+                mode: current.value,
+                source: current.source,
+                scope: target.scope,
+                role: target.role,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/activity') {
+        const target = resolveMenuActivityTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            explicitChatType,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            return target;
+        const fallback = this.agentRegistry?.getShowActivities?.(channel) ?? 'all';
+        const current = readMenuActivity(target, fallback);
+        return {
+            data: {
+                mode: current.value,
+                source: current.source,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/system') {
+        if (!subject.isDaemonOwner) {
+            return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
+        }
+        const owningAgent = this.getOwningAgent(channel);
+        const data = {
+            aid: loadDaemonConfig().aid ?? null,
+            pid: process.pid,
+            node: process.version,
+            uptime: Math.floor(process.uptime()),
+        };
+        try {
+            const pkgPath = path.join(getPackageRoot(), 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            if (pkg?.version)
+                data.version = pkg.version;
+        }
+        catch { }
+        try {
+            const fp = path.join(getPackageRoot(), 'node_modules', '@agentunion', 'fastaun', 'package.json');
+            const fp2 = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+            if (fp2?.version)
+                data.fastaunVersion = fp2.version;
+        }
+        catch { }
+        // ecweb 是独立全局包，读其已装版本（与 /upgrade 一致）
+        const ecwebPkg = resolveGlobalPkg(WEB_PACKAGE_NAME);
+        if (ecwebPkg?.version)
+            data.ecwebVersion = ecwebPkg.version;
+        const channels = owningAgent?.channelInstanceNames?.() ?? [];
+        if (channels.length) {
+            // 将 channelKey 字符串（如 "feishu#aid#name"）解析为对象 { type, instName }
+            data.channels = channels.map((key) => {
+                const parts = key.split('#');
+                return { type: parts[0], instName: parts[2] || parts[0] };
+            });
+        }
+        // 收集主机级可用的所有 baseagent 类型（检测已安装的 CLI + 版本）
+        const baseagents = [];
+        for (const cmd of ['claude', 'gemini', 'codex']) {
+            if (commandExists(cmd)) {
+                baseagents.push({ name: cmd, version: getBaseagentVersion(cmd) });
+            }
+        }
+        data.baseagents = baseagents;
+        return { data };
+    }
+    // ── name=file：文件元信息（§5.1） ──
+    // 权限（§6.3）：agent owner/admin 或 aid channel owner。项目外文件仅 owner 可取（§6.2，由 resolveMenuFilePath 校验）。
+    if (cmdBase === '/file') {
+        const role = identity.role;
+        if (!isManagementRole(role)) {
+            return { error: '无权限', code: 'NO_PERMISSION' };
+        }
+        const resolved = resolveMenuFilePath(args?.path, session, role, 'file');
+        if ('error' in resolved)
+            return resolved;
+        const { realPath, stat } = resolved;
+        // sha256 仅对 ≤ 2 MB 文件计算，超过返回 null，客户端降级到 size+mtime（§4、§7 决策 2）
+        let sha256 = null;
+        if (stat.size <= FILE_HASH_MAX_SIZE) {
+            try {
+                sha256 = crypto.createHash('sha256').update(fs.readFileSync(realPath)).digest('hex');
+            }
+            catch {
+                sha256 = null;
+            }
+        }
+        return {
+            data: {
+                path: (args?.path ?? '').toString(),
+                sha256,
+                size: stat.size,
+                mtime: stat.mtimeMs,
+            },
+        };
+    }
+    return { error: `不支持 query: ${cmdBase}`, code: 'NOT_SUPPORTED' };
+}
+/** menu.update — 写入新值。 */
+export async function execMenuUpdate(cmd, value, channel, channelId, userId, overrideIdentity, fromControlChannel = false, args, authSubject, source = 'menu') {
+    const cmdBase = cmd.trim().split(' ')[0];
+    if (!cmdBase)
+        return { error: '缺少命令', code: 'MISSING_CMD' };
+    if (cmdBase === '/perm') {
+        return { error: 'permissionMode 只能通过角色策略编辑器修改', code: 'ROLE_POLICY_MANAGED' };
+    }
+    const scopeError = validateConfigWriteScope(cmdBase, args);
+    if (scopeError)
+        return { error: scopeError.message, code: scopeError.code };
+    args = withoutLegacySessionConfigArgs(args);
+    const gated = gateControlScope.call(this, { cmdBase, args, channel, fromControlChannel });
+    if (gated)
+        return gated;
+    const arg = value.trim();
+    if (!arg)
+        return { error: '缺少 value 参数', code: 'MISSING_VALUE' };
+    const { session, evolagent } = await this.loadMenuContext(channel, channelId);
+    const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+    const isAdmin = isManagementRole(identity.role);
+    const subject = buildMenuAuthSubject(this, {
+        identity,
+        session,
+        channel,
+        channelId,
+        userId,
+        fromControlChannel,
+        subject: authSubject,
+    });
+    if (cmdBase === '/role') {
+        const authorized = await authorizeRoleMenu(this, {
+            kind: 'update', args, value: arg, identity, subject: authSubject, session, channel, channelId,
+            userId, fromControlChannel, source,
+        });
+        if ('error' in authorized)
+            return authorized;
+        try {
+            return { data: await roleMenuUpdate(authorized.context, args, arg) };
+        }
+        catch (error) {
+            return menuResultFailure(error);
+        }
+    }
+    const authDenied = await authorizeMenuIntent.call(this, {
+        intent: buildMenuIntent('update', cmdBase, args, undefined, arg, fromControlChannel),
+        identity,
+        subject,
+        session,
+        channel,
+        channelId,
+        userId,
+        fromControlChannel,
+        source,
+    });
+    if (authDenied)
+        return authDenied;
+    // ── 进程级 /gateway update（网关配置，value 为 JSON：{scope,type,patch}） ──
+    if (cmdBase === '/gateway') {
+        let body;
+        try {
+            body = JSON.parse(arg);
+        }
+        catch {
+            return { error: 'value 需为 JSON', code: 'INVALID_ARGS' };
+        }
+        return await gatewayUpdate(body);
+    }
+    // ── 关系级 /trigger update（调度参数，value 为 JSON 字符串） ──
+    if (cmdBase === '/trigger') {
+        let patch;
+        try {
+            patch = JSON.parse(arg);
+        }
+        catch {
+            return { error: 'value 需为 JSON', code: 'INVALID_ARGS' };
+        }
+        if (!patch?.nameOrId)
+            return { error: '缺少 nameOrId', code: 'INVALID_ARGS' };
+        const isAdmin = isManagementRole(identity.role);
+        if (!isAdmin && !userId)
+            return { error: '无法确认身份，请确保渠道提供发送者 ID', code: 'FORBIDDEN' };
+        const triggerScheduler = this.getTriggerSchedulerForChannel?.(channel);
+        if (!triggerScheduler)
+            return { error: '触发器功能未启用', code: 'NOT_SUPPORTED' };
+        const updated = await this.updateTriggerFromPatch(triggerScheduler, patch.nameOrId, patch, channel, channelId, userId ?? '', isAdmin);
+        if (!updated.ok) {
+            return {
+                error: updated.error,
+                code: updated.code ?? (/不存在|无权限/.test(updated.error) ? 'NOT_FOUND' : 'INVALID_ARGS'),
+                ...(updated.currentRevision ? { data: { currentRevision: updated.currentRevision } } : {}),
+            };
+        }
+        return { data: { id: updated.trigger.id, nextFireAt: updated.trigger.nextFireAt, revision: updated.revision } };
+    }
+    if (cmdBase === '/capability') {
+        const type = args?.type;
+        if (!isCapabilityType(type)) {
+            return { error: 'args.type 必须是 skill / mcp / plugin', code: type ? 'INVALID_TYPE' : 'INVALID_ARGS' };
+        }
+        const name = (args?.name ?? '').toString().trim();
+        if (name) {
+            if (!isAdmin)
+                return { error: '无权限', code: 'NO_PERMISSION' };
+        }
+        else if (identity.role !== 'owner') {
+            return { error: '类型级能力策略仅 owner 可修改', code: 'NO_PERMISSION' };
+        }
+        const target = resolveCapabilityTarget.call(this, { channel, args, session, evolagent, fromControlChannel });
+        if ('error' in target)
+            return target;
+        const support = queryCapabilityTypes(target.ctx, target.config, type).capabilities[type];
+        if (!support?.canUpdate) {
+            return { error: support?.reason || '当前 baseagent 不支持 capability 更新', code: 'NOT_SUPPORTED' };
+        }
+        if (name) {
+            const options = await listCapabilityOptions(target.ctx, target.config, type);
+            if (!options.some(item => item.value === name)) {
+                return { error: `未发现能力: ${name}`, code: 'NOT_FOUND' };
+            }
+        }
+        try {
+            const data = updateCapabilityPolicy(target.ctx.aid, target.ctx.baseagent, type, arg, name || undefined);
+            return { data };
+        }
+        catch (e) {
+            return { error: e?.message || String(e), code: e?.code || 'EXEC_FAILED' };
+        }
+    }
+    if (cmdBase === '/baseagent') {
+        if (identity.role !== 'owner')
+            return { error: '无权限', code: 'NO_PERMISSION' };
+        if (!evolagent)
+            return { error: '当前 channel 无绑定 agent，无法设置 active_baseagent', code: 'EXEC_FAILED' };
+        const valid = this.getAvailableBaseagents(channel);
+        if (valid.length && !valid.includes(arg)) {
+            return { error: `无效 baseagent: ${arg}，可选: ${valid.join(' / ')}`, code: 'INVALID_VALUE' };
+        }
+        const previousBaseagent = evolagent.baseagent;
+        evolagent.setActiveBaseagent(arg);
+        this.eventBus.publish({
+            type: 'agent:baseagent-changed',
+            aid: evolagent.aid,
+            baseagent: arg,
+            previousBaseagent,
+            scope: 'agent',
+            timestamp: Date.now(),
+        });
+        return { data: { baseagent: arg, scope: 'agent' } };
+    }
+    if (cmdBase === '/model') {
+        const target = resolveMenuModelTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            fromControlChannel,
+            field: 'model',
+        });
+        if ('error' in target)
+            return target;
+        const agent = this.getAgent(channel, target.baseagent);
+        let targetModel = arg;
+        if (hasModelSwitcher(agent)) {
+            const models = (await agent.listModels?.()) ?? [];
+            const decision = validateModelSelectionForRole({
+                role: identity.role,
+                baseagent: target.baseagent,
+                requestedModel: arg,
+                models,
+                resolveModelId: agent.resolveModelId?.bind(agent),
+            });
+            if (!decision.ok)
+                return { error: decision.message || `invalid model: ${arg}`, code: decision.code || 'INVALID_VALUE' };
+            targetModel = decision.model || arg;
+            if (models.length && !models.includes(targetModel)) {
+                return { error: `无效模型: ${arg}`, code: 'INVALID_VALUE' };
+            }
+        }
+        try {
+            writeMenuModel(target, targetModel);
+        }
+        catch (e) {
+            return { error: e?.message || String(e), code: e?.code || 'CONFIG_WRITE_FAILED', ...(e?.data !== undefined ? { data: e.data } : {}) };
+        }
+        this.eventBus.publish({
+            type: 'runner:model-changed',
+            sessionId: session?.id,
+            agentName: evolagent?.name,
+            baseagent: target.baseagent,
+            model: targetModel,
+            timestamp: Date.now(),
+        });
+        return {
+            data: {
+                model: targetModel,
+                baseagent: target.baseagent,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/effort') {
+        const target = resolveMenuModelTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            fromControlChannel,
+            field: 'effort',
+        });
+        if ('error' in target)
+            return target;
+        const agent = this.getAgent(channel, target.baseagent);
+        const modelTarget = { ...target, field: 'model', fieldPath: `baseagents.${target.baseagent}.model` };
+        const currentModel = hasModelSwitcher(agent) ? (readMenuModel(modelTarget, agent).value || agent.getModel()) : agent.name;
+        const validEfforts = getAvailableEfforts(agent, currentModel);
+        const allValid = [...validEfforts, 'auto'];
+        if (!allValid.includes(arg)) {
+            return { error: `无效推理强度: ${arg}，可选: ${allValid.join(' / ')}`, code: 'INVALID_VALUE' };
+        }
+        const roleDecision = validateRuntimeStringFieldOverride({
+            selfAid: target.sel.self,
+            role: target.role,
+            field: menuModelConfigFieldPath(target),
+            value: arg,
+        });
+        if (!roleDecision.ok) {
+            return { error: roleDecision.message || '当前角色不允许修改推理强度', code: roleDecision.code || 'ROLE_VALUE_NOT_ALLOWED' };
+        }
+        try {
+            writeMenuModel(target, arg === 'auto' ? null : arg);
+        }
+        catch (e) {
+            return { error: e?.message || String(e), code: e?.code || 'CONFIG_WRITE_FAILED', ...(e?.data !== undefined ? { data: e.data } : {}) };
+        }
+        this.eventBus.publish({
+            type: 'runner:model-changed',
+            sessionId: session?.id,
+            agentName: evolagent?.name,
+            baseagent: target.baseagent,
+            effort: arg,
+            timestamp: Date.now(),
+        });
+        return {
+            data: {
+                effort: arg,
+                baseagent: target.baseagent,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/chatmode') {
+        if (arg !== 'interactive' && arg !== 'proactive') {
+            return { error: `无效模式: ${arg}`, code: 'INVALID_VALUE' };
+        }
+        const target = resolveMenuChatmodeTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            return target;
+        const roleDecision = validateRuntimeStringFieldOverride({
+            selfAid: target.sel.self,
+            role: target.role,
+            field: target.fieldPath,
+            value: arg,
+        });
+        if (!roleDecision.ok) {
+            return { error: roleDecision.message || '当前角色不允许修改对话模式', code: roleDecision.code || 'ROLE_VALUE_NOT_ALLOWED' };
+        }
+        try {
+            writeMenuChatmode(target, arg);
+        }
+        catch (e) {
+            return { error: e?.message || String(e), code: e?.code || 'CONFIG_WRITE_FAILED', ...(e?.data !== undefined ? { data: e.data } : {}) };
+        }
+        return {
+            data: {
+                mode: arg,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/mentionmode') {
+        if (arg !== 'mention-only' && arg !== 'disabled' && arg !== 'clear') {
+            return { error: `无效模式: ${arg}`, code: 'INVALID_VALUE' };
+        }
+        const chatType = session?.chatType;
+        if (!session || chatType !== 'group') {
+            return { error: 'mentionMode 仅在群聊会话中有效', code: 'NOT_APPLICABLE' };
+        }
+        const target = resolveMenuMentionModeTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            return target;
+        try {
+            writeMenuMentionMode(target, arg === 'clear' ? null : arg);
+        }
+        catch (e) {
+            return { error: e?.message || String(e), code: e?.code || 'CONFIG_WRITE_FAILED', ...(e?.data !== undefined ? { data: e.data } : {}) };
+        }
+        return {
+            data: {
+                mode: arg === 'clear' ? null : arg,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/activity') {
+        const modeMap = { all: 'all', text: 'text', none: 'none' };
+        const newMode = modeMap[arg];
+        if (!newMode)
+            return { error: `无效模式: ${arg}，可选: all / text / none`, code: 'INVALID_VALUE' };
+        if (identity.role !== 'owner')
+            return { error: '中间输出模式切换仅限 owner', code: 'NO_PERMISSION' };
+        const target = resolveMenuActivityTarget.call(this, {
+            args,
+            session,
+            channel,
+            channelId,
+            userId,
+            role: identity.role,
+            fromControlChannel,
+        });
+        if ('error' in target)
+            return target;
+        try {
+            writeMenuActivity(target, newMode);
+        }
+        catch (e) {
+            return { error: e?.message || String(e), code: e?.code || 'CONFIG_WRITE_FAILED', ...(e?.data !== undefined ? { data: e.data } : {}) };
+        }
+        return {
+            data: {
+                mode: newMode,
+                scope: target.scope,
+                field: target.fieldPath,
+                self: target.sel.self,
+                ...(target.sel.peerKey ? { peerKey: target.sel.peerKey } : {}),
+            },
+        };
+    }
+    if (cmdBase === '/observable') {
+        if (identity.role !== 'owner')
+            return { error: '观察者模式仅限 owner 开关', code: 'NO_PERMISSION' };
+        if (arg !== 'true' && arg !== 'false')
+            return { error: `无效值: ${arg}，可选: true / false`, code: 'INVALID_VALUE' };
+        if (!evolagent)
+            return { error: '找不到通道所属 agent，无法持久化', code: 'MISSING_AID' };
+        evolagent.setObservable(arg === 'true');
+        return { data: { observable: arg === 'true' } };
+    }
+    return { error: `不支持 update: ${cmdBase}`, code: 'NOT_SUPPORTED' };
+}
+/** menu.action — 触发动词。 */
+export async function execMenuAction(cmd, action, args, channel, channelId, userId, overrideIdentity, explicitChatType, requestId, fromControlChannel = false, authSubject, source = 'menu') {
+    const cmdBase = cmd.trim().split(' ')[0];
+    if (!cmdBase)
+        return { error: '缺少命令', code: 'MISSING_CMD' };
+    if (!action)
+        return { error: '缺少 action', code: 'MISSING_VALUE' };
+    const gated = gateControlScope.call(this, { cmdBase, action, args, channel, fromControlChannel });
+    if (gated)
+        return gated;
+    const { session: authSession } = await this.loadMenuContext(channel, channelId);
+    const authIdentity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(authSession));
+    const subject = buildMenuAuthSubject(this, {
+        identity: authIdentity,
+        session: authSession,
+        explicitChatType,
+        channel,
+        channelId,
+        userId,
+        fromControlChannel,
+        subject: authSubject,
+    });
+    if (cmdBase === '/system' && fromControlChannel && !subject.isDaemonOwner) {
+        return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
+    }
+    if (cmdBase === '/role') {
+        const authorized = await authorizeRoleMenu(this, {
+            kind: 'action', args, identity: authIdentity, subject, session: authSession,
+            channel, channelId, userId, fromControlChannel, source,
+        });
+        if ('error' in authorized)
+            return authorized;
+        try {
+            return { data: await roleMenuAction(authorized.context, action, args) };
+        }
+        catch (error) {
+            return menuResultFailure(error);
+        }
+    }
+    if (cmdBase === '/agent' && !fromControlChannel && !args?.aid) {
+        const selfAid = this.getOwningAgent?.(channel)?.aid;
+        if (selfAid)
+            args = { ...(args ?? {}), aid: selfAid };
+    }
+    const authDenied = await authorizeMenuIntent.call(this, {
+        intent: buildMenuIntent('action', cmdBase, args, action, undefined, fromControlChannel),
+        identity: authIdentity,
+        subject,
+        session: authSession,
+        explicitChatType,
+        channel,
+        channelId,
+        userId,
+        fromControlChannel,
+        source,
+    });
+    if (authDenied)
+        return authDenied;
+    // ── /gateway action（进程级，gate 已确保 fromControlChannel） ──
+    // test=连通性测试；delete=删除配置；models=模型+价格；set-price=改网关价格；sync-env=同步环境变量。
+    if (cmdBase === '/gateway') {
+        if (action === 'test')
+            return await gatewayTest(args);
+        if (action === 'delete')
+            return await gatewayDelete(args);
+        if (action === 'models')
+            return await gatewayModels(args);
+        if (action === 'set-price')
+            return gatewaySetPrice(args);
+        if (action === 'sync-env')
+            return await gatewaySyncEnv(args);
+        return { error: `不支持 gateway action: ${action}`, code: 'NOT_SUPPORTED' };
+    }
+    const { session } = await this.loadMenuContext(channel, channelId);
+    const identity = overrideIdentity ?? this.sessionManager.resolveIdentity(channel, userId, ...menuIdentityArgs(session));
+    const isMenuAdmin = isManagementRole(identity.role);
+    // ── /agent action ──
+    // 控制 channel：验 evolcore.owners，可执行进程级（create/delete/enable/disable）+ 自管理（update/reload）。
+    // agent channel：闸门已挡掉进程级 + 跨 agent，仅 update/reload 能到此；reload 允许 owner/admin，update 仅 owner。
+    if (cmdBase === '/agent') {
+        if (fromControlChannel) {
+            if (!subject.isDaemonOwner) {
+                return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
+            }
+        }
+        else {
+            // 本 agent 自管理：reload 允许 owner/admin；update 会改鉴权相关元配置，仍仅 owner。
+            const isAgentOwner = identity.role === 'owner';
+            const isAgentAdmin = isManagementRole(identity.role);
+            if (action === 'update' ? !isAgentOwner : !isAgentAdmin) {
+                return { error: action === 'update' ? '本 agent 配置更新仅 owner 可执行' : '本 agent 自管理操作仅 owner/admin 可执行', code: 'FORBIDDEN' };
+            }
+            const selfAid = this.getOwningAgent?.(channel)?.aid;
+            if (!selfAid)
+                return { error: '当前 channel 无绑定 agent', code: 'FORBIDDEN' };
+            args = { ...(args ?? {}), aid: selfAid };
+        }
+        const a = { ...(args ?? {}) };
+        if (action === 'create') {
+            a.project = resolveProjectPath(a.project, a.aid ?? '', loadDefaults());
+        }
+        // queue-clear：清空指定 agent 的待处理消息（不影响处理中），直接走 messageQueue。
+        if (action === 'queue-clear') {
+            if (!a.aid)
+                return { error: '缺少 aid', code: 'INVALID_ARGS' };
+            const handle = this.agentRegistry?.get(a.aid) ?? null;
+            const agentName = handle?.name;
+            if (!agentName)
+                return { error: `未找到 Agent: ${a.aid}`, code: 'NOT_FOUND' };
+            const cleared = this.messageQueue.clearByAgent(agentName);
+            return { data: { cleared } };
+        }
+        // mute / unmute：禁言/解禁。禁言后消息照常入队但不消费，解禁后恢复。
+        if (action === 'mute' || action === 'unmute') {
+            if (!a.aid)
+                return { error: '缺少 aid', code: 'INVALID_ARGS' };
+            const handle = this.agentRegistry?.get(a.aid) ?? null;
+            const agentName = handle?.name;
+            if (!agentName)
+                return { error: `未找到 Agent: ${a.aid}`, code: 'NOT_FOUND' };
+            if (action === 'mute')
+                this.messageQueue.muteAgent(agentName);
+            else
+                this.messageQueue.unmuteAgent(agentName);
+            return { data: { aid: a.aid, muted: action === 'mute' } };
+        }
+        // interrupt：只打断当前处理中的任务，不断开 Agent 渠道，也不清空待处理队列。
+        if (action === 'interrupt') {
+            if (!a.aid)
+                return { error: '缺少 aid', code: 'INVALID_ARGS' };
+            const handle = this.agentRegistry?.get(a.aid) ?? null;
+            const agentName = handle?.name;
+            if (!agentName)
+                return { error: `未找到 Agent: ${a.aid}`, code: 'NOT_FOUND' };
+            const interrupted = this.messageQueue.interruptByAgent(agentName);
+            if (interrupted === 0)
+                return { error: '当前没有正在处理的任务', code: 'NO_ACTIVE_TASK' };
+            return { data: { aid: a.aid, action, interrupted } };
+        }
+        // start / stop：运行时连/断渠道，不改 config.enabled。
+        if (action === 'start' || action === 'stop') {
+            if (!a.aid)
+                return { error: '缺少 aid', code: 'INVALID_ARGS' };
+            const hooks = globalThis.__evolcore_reloadHooks;
+            if (!hooks)
+                return { error: 'Reload hooks 未初始化', code: 'INTERNAL' };
+            try {
+                if (action === 'stop') {
+                    if (!this.agentRegistry?.stopAgent)
+                        return { error: 'stopAgent 不可用', code: 'INTERNAL' };
+                    await this.agentRegistry.stopAgent(a.aid, hooks);
+                    this.eventBus.publish({ type: 'agent:stopped', aid: a.aid, timestamp: Date.now() });
+                    // 中断该 agent 正在执行的大模型调用
+                    const handle = this.agentRegistry.get(a.aid);
+                    if (handle)
+                        this.messageQueue.interruptByAgent(handle.name);
+                }
+                else {
+                    if (!this.agentRegistry?.startAgent)
+                        return { error: 'startAgent 不可用', code: 'INTERNAL' };
+                    await this.agentRegistry.startAgent(a.aid, hooks);
+                    this.eventBus.publish({ type: 'agent:started', aid: a.aid, timestamp: Date.now() });
+                }
+                return { data: { aid: a.aid, action } };
+            }
+            catch (e) {
+                this.eventBus.publish({ type: 'agent:error', aid: a.aid, action, error: e?.message || String(e), timestamp: Date.now() });
+                return { error: e?.message || String(e), code: 'INTERNAL' };
+            }
+        }
+        // reload / disable / delete 会中断 agent 正在处理的任务，执行前检查是否繁忙。
+        // 队列按 agent 名计数，故先用 registry 把 aid 解析成 name；force 跳过。
+        if ((action === 'reload' || action === 'disable' || action === 'delete') && a.aid && !a.force) {
+            const handle = this.agentRegistry?.get(a.aid) ?? null;
+            const agentName = handle?.name;
+            if (agentName) {
+                const busy = this.messageQueue.getProcessingCountByAgent(agentName)
+                    + this.messageQueue.getQueueLengthByAgent(agentName);
+                if (busy > 0) {
+                    return { error: `该 Agent 有 ${busy} 个任务执行中`, code: 'BUSY' };
+                }
+            }
+        }
+        return await execAgentAction(action, a, userId ?? '', this.eventBus);
+    }
+    // ── 关系级 /trigger（不走 owners；复用 isAdmin + scoped 逻辑，D4 直调底层） ──
+    if (cmdBase === '/trigger') {
+        const role = identity.role;
+        const isAdmin = isManagementRole(role);
+        const triggerScheduler = this.getTriggerSchedulerForChannel?.(channel);
+        if (!triggerScheduler)
+            return { error: '触发器功能未启用', code: 'NOT_SUPPORTED' };
+        if (action === 'set') {
+            // args 结构化 → 直接组装 ParsedTriggerSet（绕过 parseTriggerSet 文本解析，无注入风险）
+            if (!args?.scheduleType || (args.scheduleType !== 'once' && !args?.scheduleValue) || !args?.prompt) {
+                return { error: '缺少必填参数：scheduleType / scheduleValue / prompt', code: 'INVALID_ARGS' };
+            }
+            // menu 路径绕过了 parseTriggerSet 的校验，必须自行校验枚举/数值，
+            // 避免非法调度参数进入 scheduler。
+            const schedErr = validateScheduleParams(args.scheduleType, String(args.scheduleValue ?? ''));
+            if (schedErr)
+                return { error: schedErr, code: 'INVALID_ARGS' };
+            const targetSession = args.targetSession ?? args.targetSessionStrategy ?? 'main';
+            if (!['main', 'thread'].includes(targetSession)) {
+                return { error: `无效 targetSession: ${targetSession}`, code: 'INVALID_ARGS' };
+            }
+            const triggerThread = args.triggerThread;
+            if (triggerThread !== undefined && triggerThread !== 'per_run' && triggerThread !== 'by_trigger') {
+                return { error: `无效 triggerThread: ${triggerThread}`, code: 'INVALID_ARGS' };
+            }
+            const parsed = {
+                scheduleType: args.scheduleType,
+                scheduleValue: String(args.scheduleValue ?? ''),
+                executionType: args.executionType ?? 'target_session',
+                feedbackStrategy: args.feedbackStrategy ?? (args.targetChannel ? 'target' : 'origin'),
+                targetSession,
+                prompt: String(args.prompt),
+                name: args.name,
+                targetChannel: args.targetChannel,
+                targetChannelId: args.targetChannelId,
+                targetThreadId: args.targetThreadId,
+                agentId: args.agentId,
+                model: args.model,
+                effort: args.effort,
+                permissionMode: args.permissionMode,
+                triggerThread,
+            };
+            const r = await this.registerTriggerFromParsed(parsed, channel, channelId, userId ?? '', undefined, this.resolveMenuChatType(channel, channelId, explicitChatType), undefined, isAdmin);
+            if (!r.ok)
+                return { error: r.error, code: /已存在|exists|重复/.test(r.error) ? 'CONFLICT' : 'INVALID_ARGS' };
+            return { data: { id: r.trigger.id, name: r.trigger.name, nextFireAt: r.trigger.nextFireAt } };
+        }
+        if (action === 'cancel') {
+            const nameOrId = args?.nameOrId;
+            if (!nameOrId)
+                return { error: '缺少 nameOrId', code: 'INVALID_ARGS' };
+            if (!isAdmin && !userId)
+                return { error: '无法确认身份，请确保渠道提供发送者 ID', code: 'FORBIDDEN' };
+            const trigger = this.findTriggerDefinition(triggerScheduler, nameOrId, userId ?? '', channel, isAdmin);
+            if (!trigger)
+                return { error: '触发器不存在或无权限', code: 'NOT_FOUND' };
+            const cancelled = triggerScheduler.cancel(trigger.id);
+            this.eventBus.publish({ type: 'trigger:cancelled', triggerId: cancelled.id, name: cancelled.name, by: userId ?? '' });
+            return { data: { id: cancelled.id, cancelled: true } };
+        }
+        if (action === 'enable' || action === 'disable') {
+            const nameOrId = args?.nameOrId;
+            if (!nameOrId)
+                return { error: '缺少 nameOrId', code: 'INVALID_ARGS' };
+            if (!isAdmin && !userId)
+                return { error: '无法确认身份，请确保渠道提供发送者 ID', code: 'FORBIDDEN' };
+            const trigger = this.findTriggerDefinition(triggerScheduler, nameOrId, userId ?? '', channel, isAdmin);
+            if (!trigger)
+                return { error: '触发器不存在或无权限', code: 'NOT_FOUND' };
+            const updated = triggerScheduler.setEnabled(trigger.id, action === 'enable');
+            return { data: { id: updated.id, enabled: updated.enabled } };
+        }
+        if (action === 'delete') {
+            const nameOrId = args?.nameOrId;
+            if (!nameOrId)
+                return { error: '缺少 nameOrId', code: 'INVALID_ARGS' };
+            if (!isAdmin && !userId)
+                return { error: '无法确认身份，请确保渠道提供发送者 ID', code: 'FORBIDDEN' };
+            const trigger = this.findTriggerDefinition(triggerScheduler, nameOrId, userId ?? '', channel, isAdmin);
+            if (!trigger)
+                return { error: '触发器不存在或无权限', code: 'NOT_FOUND' };
+            if (trigger.enabled)
+                return { error: '请先禁用触发器再删除', code: 'INVALID_STATE' };
+            const deleted = triggerScheduler.delete(trigger.id);
+            return { data: { id: deleted.id, deleted: true } };
+        }
+        if (action === 'run' || action === 'test') {
+            const nameOrId = args?.nameOrId;
+            if (!nameOrId)
+                return { error: '缺少 nameOrId', code: 'INVALID_ARGS' };
+            if (!isAdmin && !userId)
+                return { error: '无法确认身份，请确保渠道提供发送者 ID', code: 'FORBIDDEN' };
+            const trigger = this.findTriggerDefinition(triggerScheduler, nameOrId, userId ?? '', channel, isAdmin);
+            if (!trigger)
+                return { error: '触发器不存在或无权限', code: 'NOT_FOUND' };
+            if (!trigger.enabled)
+                return { error: '触发器已禁用，不能立即执行', code: 'INVALID_STATE' };
+            let eventPayload;
+            if (action === 'test') {
+                if (trigger.source.type !== 'event') {
+                    return { error: '测试执行仅支持 Event Trigger', code: 'INVALID_ARGS' };
+                }
+                if (!args?.eventPayload || typeof args.eventPayload !== 'object' || Array.isArray(args.eventPayload)) {
+                    return { error: '模拟事件 Payload 必须是 JSON 对象', code: 'INVALID_ARGS' };
+                }
+                const payloadJson = JSON.stringify(args.eventPayload);
+                if (Buffer.byteLength(payloadJson, 'utf8') > 64 * 1024) {
+                    return { error: '模拟事件 Payload 不能超过 64 KiB', code: 'INVALID_ARGS' };
+                }
+                eventPayload = args.eventPayload;
+            }
+            const result = await triggerScheduler.run(trigger.id, {
+                dryRun: action === 'run' && args?.dryRun === true,
+                ...(eventPayload ? { eventPayload } : {}),
+            });
+            return {
+                data: {
+                    id: trigger.id,
+                    runId: result.runId,
+                    status: result.status,
+                    reason: result.reason,
+                    ...(result.conflictRunId ? { conflictRunId: result.conflictRunId } : {}),
+                },
+            };
+        }
+        return { error: `不支持的 trigger action: ${action}`, code: 'INVALID_ARGS' };
+    }
+    if (cmdBase === '/topic') {
+        if (action === 'fork') {
+            if (!this.canReadTopics(identity.role))
+                return { error: '无权限创建话题分支', code: 'FORBIDDEN' };
+            const targetThreadId = (args?.targetThreadId ?? '').toString().trim();
+            const sourceAssistantMessageId = (args?.sourceAssistantMessageId ?? '').toString().trim();
+            const name = getRenameName(args);
+            if (!targetThreadId)
+                return { error: '缺少 args.targetThreadId', code: 'MISSING_VALUE' };
+            if (targetThreadId.length > 512 || /[\x00-\x1F\x7F]/.test(targetThreadId)) {
+                return { error: 'args.targetThreadId 无效', code: 'INVALID_ARGS' };
+            }
+            if (!sourceAssistantMessageId)
+                return { error: '缺少 args.sourceAssistantMessageId', code: 'MISSING_VALUE' };
+            if (explicitChatType === 'group')
+                return { error: '历史上下文分叉仅支持私聊', code: 'NOT_SUPPORTED' };
+            const existingTopic = await this.sessionManager.getThreadSession(channel, channelId, targetThreadId);
+            if (existingTopic) {
+                const forkSource = existingTopic.metadata?.forkSource;
+                const requestedSourceThreadId = typeof args?.sourceThreadId === 'string' && args.sourceThreadId.trim()
+                    ? args.sourceThreadId.trim()
+                    : null;
+                if (requestId
+                    && forkSource?.requestId === requestId
+                    && forkSource.assistantMessageId === sourceAssistantMessageId
+                    && forkSource.threadId === requestedSourceThreadId) {
+                    return {
+                        data: {
+                            action: 'fork',
+                            success: true,
+                            topic: {
+                                ...buildSessionPayload(existingTopic, existingTopic.name || ''),
+                                threadId: existingTopic.threadId,
+                                sourceSessionId: forkSource.sessionId,
+                                sourceThreadId: forkSource.threadId,
+                                sourceAssistantMessageId: forkSource.assistantMessageId,
+                                sourceTurn: forkSource.turn,
+                            },
+                        },
+                    };
+                }
+                return { error: '目标话题已存在', code: 'CONFLICT' };
+            }
+            if (name) {
+                const existingName = await this.sessionManager.getSessionByName?.(channel, channelId, name);
+                if (existingName)
+                    return { error: `名称 "${name}" 已存在`, code: 'CONFLICT' };
+            }
+            const source = await resolveTopicForkSource(this.sessionManager, channel, channelId, args?.sourceThreadId);
+            if (!source)
+                return { error: '来源会话不存在', code: 'NOT_FOUND' };
+            if (source.chatType !== 'private')
+                return { error: '历史上下文分叉仅支持私聊', code: 'NOT_SUPPORTED' };
+            if (!source.agentSessionId)
+                return { error: '来源会话暂无对话历史', code: 'INVALID_STATE' };
+            const agent = this.getAgent(channel, source.baseagent);
+            if (!agent.capabilities?.forkAtTurn || !agent.getSessionMessages || !agent.forkSessionAt) {
+                return { error: `当前 Agent (${agent.name}) 不支持按轮次分叉`, code: 'NOT_SUPPORTED' };
+            }
+            const sourceKey = this.getQueueKey(source, channel, channelId);
+            const isBusy = !!source.processingState
+                || this.messageQueue.isProcessing?.(sourceKey)
+                || this.messageQueue.getQueueLength?.(sourceKey) > 0
+                || agent.hasActiveStream(sourceKey);
+            if (isBusy)
+                return { error: '来源会话正在处理消息，请完成后重试', code: 'BUSY' };
+            const targetKey = JSON.stringify([source.channelType || source.channel, source.selfAID || '', channelId, targetThreadId]);
+            if (topicForkTargetsInFlight.has(targetKey))
+                return { error: '目标话题正在创建', code: 'CONFLICT' };
+            topicForkTargetsInFlight.add(targetKey);
+            const releaseLock = this.messageQueue.acquireLock?.(sourceKey) ?? (() => { });
+            try {
+                if (this.messageQueue.isProcessing?.(sourceKey) || agent.hasActiveStream(sourceKey)) {
+                    return { error: '来源会话正在处理消息，请完成后重试', code: 'BUSY' };
+                }
+                const messages = await agent.getSessionMessages(source.agentSessionId, source.projectPath);
+                const turns = buildSessionTurnList(messages);
+                const forkTurn = turns.find((turn) => turn.assistantUuid === sourceAssistantMessageId);
+                if (!forkTurn)
+                    return { error: '分叉点已失效，请刷新历史后重试', code: 'NOT_FOUND' };
+                const forkedAgentSessionId = await agent.forkSessionAt(source.agentSessionId, source.projectPath, sourceAssistantMessageId, name || undefined);
+                const topic = await this.sessionManager.createForkedThreadSession(source, forkedAgentSessionId, targetThreadId, {
+                    name: name || undefined,
+                    creatorPeerId: userId,
+                    sourceAssistantMessageId,
+                    sourceTurn: forkTurn.index,
+                    requestId,
+                });
+                await agent.updateSessionMetadata?.(forkedAgentSessionId, {
+                    evolcoreSessionId: topic.id,
+                    sourceSessionId: source.id,
+                    sourceAssistantMessageId,
+                    sourceTurn: forkTurn.index,
+                }).catch((error) => {
+                    logger.debug(`[MenuHandler] Topic fork metadata sync failed: ${error}`);
+                });
+                this.eventBus.publish({
+                    type: 'session:forked',
+                    sessionId: topic.id,
+                    sourceSessionId: source.id,
+                    name: topic.name,
+                    threadId: topic.threadId,
+                    sourceAssistantMessageId,
+                    sourceTurn: forkTurn.index,
+                });
+                return {
+                    data: {
+                        action: 'fork',
+                        success: true,
+                        topic: {
+                            ...buildSessionPayload(topic, topic.name || ''),
+                            threadId: topic.threadId,
+                            sourceSessionId: source.id,
+                            sourceThreadId: source.threadId || null,
+                            sourceAssistantMessageId,
+                            sourceTurn: forkTurn.index,
+                        },
+                    },
+                };
+            }
+            catch (error) {
+                logger.error('[MenuHandler] Topic history fork failed:', error);
+                return { error: error instanceof Error ? error.message : '话题分叉失败', code: 'EXEC_FAILED' };
+            }
+            finally {
+                releaseLock();
+                topicForkTargetsInFlight.delete(targetKey);
+            }
+        }
+        if (action !== 'delete' && action !== 'rename') {
+            return { error: `不支持的 topic action: ${action}`, code: 'NOT_SUPPORTED' };
+        }
+        const target = (args?.target ?? '').toString().trim();
+        if (!target)
+            return { error: '缺少 args.target', code: 'MISSING_VALUE' };
+        const renameName = action === 'rename' ? getRenameName(args) : '';
+        if (action === 'rename' && !renameName)
+            return { error: '缺少 args.name', code: 'MISSING_VALUE' };
+        const topic = await this.sessionManager.getThreadSession(channel, channelId, target);
+        if (!topic)
+            return { error: '话题不存在', code: 'NOT_FOUND' };
+        const chatType = topic.chatType === 'group'
+            ? 'group'
+            : topic.chatType === 'private'
+                ? 'private'
+                : this.resolveMenuChatType(channel, channelId, explicitChatType);
+        if (!this.canDeleteTopic(identity.role, chatType, topic, userId)) {
+            return { error: action === 'rename' ? '无权限重命名话题' : '无权限删除话题', code: 'FORBIDDEN' };
+        }
+        if (action === 'rename') {
+            const newName = renameName;
+            const existing = await this.sessionManager.getSessionByName?.(channel, channelId, newName);
+            if (existing && existing.id !== topic.id) {
+                return { error: `名称 "${newName}" 已存在`, code: 'CONFLICT' };
+            }
+            const oldName = displaySessionTitle(topic.name, topic.threadId || '(未命名)');
+            const success = await this.sessionManager.renameSession(topic.id, newName);
+            if (!success)
+                return { error: '重命名失败', code: 'EXEC_FAILED' };
+            if (topic.agentSessionId) {
+                try {
+                    const targetAgent = this.getAgent(channel, topic.baseagent);
+                    await targetAgent.setSessionName?.(topic.agentSessionId, newName);
+                }
+                catch { }
+            }
+            this.eventBus.publish({ type: 'session:renamed', sessionId: topic.id, oldName, newName });
+            return {
+                data: {
+                    action: 'rename',
+                    success: true,
+                    topic: {
+                        ...buildSessionPayload(topic, newName),
+                        threadId: topic.threadId,
+                    },
+                },
+            };
+        }
+        const success = await this.sessionManager.unbindSession(topic.id);
+        if (!success)
+            return { error: '删除失败', code: 'DELETE_FAILED' };
+        this.eventBus.publish({ type: 'session:deleted', sessionId: topic.id });
+        const targetAgent = this.getAgent(channel, topic.baseagent);
+        await targetAgent.closeSession?.(topic.id);
+        return { data: { deleted: true } };
+    }
+    // ── /session 系列 ──
+    if (cmdBase === '/session' || cmdBase === '/s') {
+        if (action === 'stop') {
+            if (!session)
+                return { error: '当前无活跃会话', code: 'NO_ACTIVE_SESSION' };
+            const sessionKey = this.getQueueKey(session, channel, channelId);
+            const sessionAgent = this.getAgent(channel, session.baseagent);
+            const hasActive = sessionAgent.hasActiveStream(sessionKey);
+            const queueLength = this.messageQueue.getQueueLength(sessionKey);
+            if (queueLength === 0 && !hasActive) {
+                return { error: '当前没有正在处理的任务', code: 'NO_ACTIVE_TASK' };
+            }
+            this.eventBus.publish({
+                type: 'task:interrupted',
+                sessionId: sessionKey,
+                reason: 'stop',
+                agentName: this.agentRegistry?.resolveByChannel(channel)?.name ?? '<unknown>',
+            });
+            await this.processor.interruptSession(sessionKey, 'stop');
+            return { data: { action: 'stop', success: true } };
+        }
+        if (action === 'new') {
+            const name = (args?.name ?? '').toString().trim();
+            return await this.delegateAsAction(action, name ? `/new ${name}` : '/new', channel, channelId, userId, { enrichSession: true, authSubject: subject });
+        }
+        if (action === 'rename') {
+            const newName = getRenameName(args);
+            if (!newName)
+                return { error: '缺少 args.name', code: 'MISSING_VALUE' };
+            const target = (args?.target ?? '').toString().trim();
+            const targetSession = await findMainSessionTarget(this.sessionManager, channel, channelId, target, session);
+            if (!targetSession) {
+                return target
+                    ? { error: `会话不存在: ${target}`, code: 'NOT_FOUND' }
+                    : { error: '当前无活跃会话', code: 'NO_ACTIVE_SESSION' };
+            }
+            const targetChatType = targetSession.chatType === 'group'
+                ? 'group'
+                : targetSession.chatType === 'private'
+                    ? 'private'
+                    : this.resolveMenuChatType(channel, channelId, explicitChatType);
+            if (targetChatType === 'group' && !isMenuAdmin) {
+                return { error: '无权限：群聊中仅管理员可重命名会话', code: 'NO_PERMISSION' };
+            }
+            const existing = await this.sessionManager.getSessionByName?.(channel, channelId, newName);
+            if (existing && existing.id !== targetSession.id) {
+                return { error: `名称 "${newName}" 已存在`, code: 'CONFLICT' };
+            }
+            const oldName = displaySessionTitle(targetSession.name, '(未命名)');
+            const success = await this.sessionManager.renameSession(targetSession.id, newName);
+            if (!success)
+                return { error: '重命名失败', code: 'EXEC_FAILED' };
+            if (targetSession.agentSessionId) {
+                try {
+                    const targetAgent = this.getAgent(channel, targetSession.baseagent);
+                    await targetAgent.setSessionName?.(targetSession.agentSessionId, newName);
+                }
+                catch { }
+            }
+            this.eventBus.publish({ type: 'session:renamed', sessionId: targetSession.id, oldName, newName });
+            return { data: { action: 'rename', success: true, session: buildSessionPayload(targetSession, newName) } };
+        }
+        if (action === 'delete') {
+            const target = (args?.target ?? '').toString().trim();
+            if (!target)
+                return { error: '缺少 args.target', code: 'MISSING_VALUE' };
+            return await this.delegateAsAction(action, `/del ${target}`, channel, channelId, userId, { authSubject: subject });
+        }
+        if (action === 'switch') {
+            const target = (args?.target ?? '').toString().trim();
+            if (!target)
+                return { error: '缺少 args.target', code: 'MISSING_VALUE' };
+            return await this.delegateAsAction(action, `/s ${target}`, channel, channelId, userId, { enrichSession: true, authSubject: subject });
+        }
+        if (action === 'compact') {
+            const need = this.requireSession(session);
+            if (need)
+                return need;
+            return await this.delegateAsAction(action, '/compact', channel, channelId, userId, { authSubject: subject });
+        }
+        if (action === 'fork') {
+            const need = this.requireSession(session);
+            if (need)
+                return need;
+            const name = (args?.name ?? '').toString().trim();
+            return await this.delegateAsAction(action, name ? `/fork ${name}` : '/fork', channel, channelId, userId, { enrichSession: true, authSubject: subject });
+        }
+        return { error: `不支持的 session action: ${action}`, code: 'NOT_SUPPORTED' };
+    }
+    // ── /system 系列 ──
+    if (cmdBase === '/system') {
+        // D1 迁移：进程级鉴权统一查 daemon.json owners，替代各 action 内联的 identity.role 判断
+        if (!subject.isDaemonOwner) {
+            return { error: '操作需要 owner 权限', code: 'FORBIDDEN' };
+        }
+        if (action === 'restart') {
+            const restartInfo = { channel, channelId, timestamp: Date.now() };
+            const dataDir = resolvePaths().dataDir;
+            fs.mkdirSync(dataDir, { recursive: true });
+            fs.writeFileSync(path.join(dataDir, 'restart-pending.json'), JSON.stringify(restartInfo));
+            const { spawn } = await import('child_process');
+            spawn('node', [path.join(getPackageRoot(), 'dist', 'cli', 'index.js'), 'restart-monitor'], {
+                detached: true,
+                stdio: 'ignore',
+                env: { ...process.env, EVOLCORE_HOME: resolvePaths().root }
+            }).unref();
+            this.eventBus.publish({ type: 'system:restart', channel, channelId });
+            setTimeout(() => { process.kill(process.pid, 'SIGTERM'); }, 1000);
+            return { data: { action: 'restart', success: true } };
+        }
+        if (action === 'check') {
+            const r = await this.delegateAsAction(action, '/check', channel, channelId, userId, { overrideIdentity, authSubject: subject });
+            // delegateAsAction 会把 structured 展开到 data 顶层，并保留 data.structured 兼容旧客户端。
+            return r;
+        }
+        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);
+            return {
+                data: {
+                    devMode,
+                    evolcore: { local: localEvolcore, remote: evolcoreRemote, hasUpdate: cmp(localEvolcore, evolcoreRemote) },
+                    fastaun: { local: localFastaun, remote: fastaunRemote, hasUpdate: cmp(localFastaun, fastaunRemote) },
+                    // ecweb 本地版本由 ECWeb 进程自身注入（data.ecwebVersion），此处仅给 remote
+                    ecweb: { remote: ecwebRemote },
+                },
+            };
+        }
+        return { error: `不支持的 system action: ${action}`, code: 'NOT_SUPPORTED' };
+    }
+    // ── /cli 透传 ──
+    if (cmdBase === '/cli') {
+        if (action !== 'exec')
+            return { error: `不支持的 cli action: ${action}`, code: 'NOT_SUPPORTED' };
+        const argvValidation = Array.isArray(args?.argv)
+            ? validateCliArgv(args.argv)
+            : typeof args?.command === 'string'
+                ? parseLegacyCliCommand(args.command)
+                : { ok: false, reason: 'CLI exec requires args.argv' };
+        if (!argvValidation.ok)
+            return { error: argvValidation.reason, code: 'INVALID_ARGUMENT' };
+        let argv = argvValidation.argv;
+        argv = normalizeCliArgv(argv);
+        const cliAgent = this.getOwningAgent?.(channel);
+        const cliSelfAid = cliAgent?.aid;
+        const cliChannelType = this.resolveChannelType?.(channel);
+        const cliChatType = session?.chatType ?? explicitChatType;
+        const cliPeerKeyId = cliChatType === 'group'
+            ? (session?.metadata?.groupId || channelId)
+            : userId;
+        const cliPeerKey = cliChannelType && cliPeerKeyId ? formatPeerKey(cliChannelType, cliPeerKeyId) : undefined;
+        if (Array.isArray(args?.argv)) {
+            argv = withDefaultRelationContext(argv, { self: cliSelfAid, peer: cliPeerKey });
+        }
+        // Batch get is a CLI-only aggregate; authorize each underlying get before spawning once.
+        const batchGet = splitConfigBatchGetArgv(argv);
+        const isBatchGet = !!batchGet && batchGet.fields.length > 1;
+        const intentArgvs = isBatchGet
+            ? batchGet.fields.map(field => ['config', 'get', field, ...batchGet.rest])
+            : [argv];
+        const parsedCommands = [];
+        for (const intentArgv of intentArgvs) {
+            const parsed = parseCliIntent(intentArgv, 'menu.cli', { defaultRelation: { self: cliSelfAid, peer: cliPeerKey } });
+            if (parsed.kind === 'invalid')
+                return { error: parsed.reason, code: parsed.code };
+            if (parsed.kind === 'raw') {
+                await auditCommandAuthorization({
+                    ts: Date.now(), source: 'menu.cli', operation: parsed.intent.operation,
+                    scope: parsed.intent.scope, dangerous: true, actorId: userId,
+                    channel, channelId, role: identity.role, decision: 'deny', code: 'NOT_ALLOWED',
+                    reason: 'Unrecognized CLI command', taskId: requestId, argvHash: hashArgv(intentArgv),
+                });
+                return { error: 'CLI command is not allowed', code: 'NOT_ALLOWED' };
+            }
+            parsedCommands.push(parsed);
+        }
+        const subject = buildMenuAuthSubject(this, {
+            identity,
+            session,
+            explicitChatType,
+            channel,
+            channelId,
+            userId,
+            fromControlChannel: fromControlChannel ?? false,
+            subject: authSubject,
+        });
+        const selfAid = subject.selfAid;
+        const peerKey = subject.peerKey;
+        const isDaemonOwner = subject.isDaemonOwner;
+        if (isBatchGet) {
+            const first = parsedCommands[0].resolvedConfigCommand;
+            if (!first)
+                return { error: 'Unable to resolve batch config get', code: 'INVALID_CONFIG_COMMAND' };
+            argv = ['config', 'get', ...batchGet.fields, ...first.canonicalArgv.slice(3)];
+        }
+        else if (parsedCommands[0].resolvedConfigCommand) {
+            argv = parsedCommands[0].resolvedConfigCommand.canonicalArgv;
+        }
+        const authorizedCommands = [];
+        for (let i = 0; i < parsedCommands.length; i++) {
+            const parsed = parsedCommands[i];
+            const authArgv = parsed.resolvedConfigCommand?.canonicalArgv ?? intentArgvs[i] ?? argv;
+            const decision = await authorizeOperation({
+                source: 'menu.cli',
+                intent: parsed.intent,
+                subject,
+                resolvedConfigCommand: parsed.resolvedConfigCommand,
+                allowExplicitRelationTarget: true,
+                auditAllowed: false,
+                auditMetadata: { taskId: requestId, argvHash: hashArgv(authArgv) },
+            });
+            if (!decision.allow) {
+                return { error: decision.reason, code: decision.code };
+            }
+            authorizedCommands.push({ parsed, decision });
+        }
+        const execution = await this.execCliPassthrough(argv, subject.role);
+        const executionData = 'data' in execution ? execution.data : undefined;
+        for (const { parsed, decision } of authorizedCommands) {
+            await auditCommandAuthorization({
+                ts: Date.now(), source: 'menu.cli', operation: parsed.intent.operation,
+                scope: parsed.intent.scope, dangerous: parsed.intent.dangerous ?? false,
+                actorId: userId, selfAid, peerKey,
+                channel, channelId, role: identity.role, isDaemonOwner,
+                fromControlChannel: fromControlChannel ?? false, decision: 'allow',
+                matchedRule: decision.command?.matchedRule, taskId: requestId, argvHash: hashArgv(argv),
+                durationMs: executionData?.durationMs, exitCode: executionData?.exitCode,
+            });
+        }
+        return execution;
+    }
+    // ── name=file action=list/fetch：目录浏览 / 拉取文件 ──
+    // list 返回 JSON 目录项；fetch 内部等价于 /file <path>，复用 resolveMenuFilePath 校验链 + adapter.send(result.file)。
+    // fetch 文件作为独立 result.file 消息异步发回；把请求 id 作为 correlationId 透传，
+    // 客户端用它把异步到达的文件消息对回这次 fetch 点击。
+    if (cmdBase === '/file') {
+        // 权限（§6.3）：agent owner/admin 或 aid channel owner。项目外文件仅 owner（§6.2，由 resolveMenuFilePath 校验）。
+        if (!isManagementRole(identity.role)) {
+            return { error: '无权限', code: 'NO_PERMISSION' };
+        }
+        if (action === 'list') {
+            const dirArg = (args?.path ?? '.').toString().trim() || '.';
+            const resolved = resolveMenuFilePath(dirArg, session, identity.role, 'directory');
+            if ('error' in resolved)
+                return resolved;
+            const offset = parseFileListOffset(args?.offset);
+            const limit = parseFileListLimit(args?.limit);
+            const includeHidden = args?.includeHidden === true;
+            const listed = listDirectory(resolved.realPath, { offset, limit, includeHidden, projectPath: resolved.projectPath, role: identity.role });
+            if ('error' in listed)
+                return listed;
+            return { data: { path: dirArg, ...listed.data } };
+        }
+        if (action !== 'fetch')
+            return { error: `不支持的 file action: ${action}`, code: 'NOT_SUPPORTED' };
+        const resolved = resolveMenuFilePath(args?.path, session, identity.role, 'file');
+        if ('error' in resolved)
+            return resolved;
+        const { realPath, stat } = resolved;
+        if (stat.size > FILE_FETCH_MAX_SIZE) {
+            return { error: `文件过大: ${(stat.size / 1024 / 1024).toFixed(1)} MB (限制 ${FILE_FETCH_MAX_SIZE / 1024 / 1024} MB)`, code: 'FILE_TOO_LARGE' };
+        }
+        const adapter = this.adapters.get(channel);
+        if (!adapter)
+            return { error: '通道不存在', code: 'EXEC_FAILED' };
+        if (!adapter.capabilities?.file)
+            return { error: '通道不支持文件发送', code: 'NOT_SUPPORTED' };
+        try {
+            const replyCtx = session ? this.getReplyContext(session) : undefined;
+            await adapter.send(buildEnvelope({ channel: adapter.channelName, channelId, replyContext: replyCtx }), { kind: 'result.file', filePath: realPath, correlationId: requestId });
+            return { data: { accepted: true } };
+        }
+        catch (e) {
+            return { error: `文件发送失败: ${e?.message ?? e}`, code: 'EXEC_FAILED' };
+        }
+    }
+    return { error: `不支持 action: ${cmdBase}`, code: 'NOT_SUPPORTED' };
+}
+const SYSTEM_CONTROL_NAME_MAP = {
+    pwd: '/pwd', session: '/session', baseagent: '/baseagent', model: '/model',
+    topic: '/topic',
+    effort: '/effort', chatmode: '/chatmode', mentionmode: '/mentionmode',
+    permission: '/perm', activity: '/activity', system: '/system',
+    observable: '/observable',
+    agent: '/agent', trigger: '/trigger', file: '/file', gateway: '/gateway',
+    config: '/config', capability: '/capability', role: '/role',
+};
+function isProcessLevelMenu(name, cmd) {
+    return name === 'system' || name === 'agent' || name === 'gateway' || name === 'config'
+        || cmd === '/system' || cmd === '/agent' || cmd === '/gateway' || cmd === '/config';
+}
+async function execMenuForSystemControl(payload, context) {
+    const id = payload?.id ?? '';
+    const name = payload?.name;
+    if (name === 'cli' || payload?.cmd === '/cli') {
+        const message = context.source === 'ecweb'
+            ? 'cli 不在 ECWeb 控制范围'
+            : 'cli 不在控制 channel 范围';
+        return { type: 'menu.response', id, name, error: { code: 'NOT_SUPPORTED', message } };
+    }
+    const isProcessLevel = isProcessLevelMenu(name, payload?.cmd);
+    const isRoleRequest = name === 'role' || payload?.cmd === '/role';
+    const requiresAgentTarget = isRoleRequest || [
+        'observable', 'baseagent', 'model', 'effort', 'trigger', 'capability',
+    ].includes(name)
+        || ['/observable', '/baseagent', '/model', '/effort', '/trigger', '/capability'].includes(payload?.cmd);
+    const target = isProcessLevel
+        ? { channel: SYSTEM_CONTROL_CHANNEL }
+        : resolveExternalMenuAgentChannel(this, payload, SYSTEM_CONTROL_CHANNEL, requiresAgentTarget);
+    if ('error' in target)
+        return ecwebErr(id, name, target.code, target.error);
+    const targetChannel = target.channel;
+    const targetAid = this.getOwningAgent?.(targetChannel)?.aid;
+    const trustedSubject = buildAuthSubject({
+        selfAid: targetAid,
+        actorId: context.actorAid,
+        channel: targetChannel,
+        channelType: 'aun',
+        channelId: context.actorAid || SYSTEM_CONTROL_CHANNEL,
+        chatType: 'private',
+        conversationId: context.actorAid || SYSTEM_CONTROL_CHANNEL,
+        identity: context.localDirect ? { role: 'owner', mode: 'interactive' } : undefined,
+        processOwners: context.owners,
+        fromControlChannel: true,
+    });
+    const trustedIdentity = trustedSubject.identity;
+    const cmd = name ? (SYSTEM_CONTROL_NAME_MAP[name] ?? payload.cmd) : payload.cmd;
+    try {
+        switch (payload?.type) {
+            case 'menu.list':
+                return menuSuccess({ id }, this.getMenuItems(trustedIdentity.role, 'private', 'control'));
+            case 'menu.query': {
+                if (!cmd)
+                    return ecwebErr(id, name, 'MISSING_CMD', '缺少 name/cmd');
+                const r = await this.execMenuQuery(cmd, targetChannel, targetChannel, context.actorAid, payload.args, undefined, true, trustedIdentity, trustedSubject, context.source);
+                return ecwebResp(id, name, r);
+            }
+            case 'menu.options': {
+                if (!cmd)
+                    return ecwebErr(id, name, 'MISSING_CMD', '缺少 name/cmd');
+                const data = await this.getSubMenuItems(cmd, targetChannel, targetChannel, context.actorAid, payload.args, trustedIdentity, undefined, true, trustedSubject, context.source) ?? [];
+                return menuSuccess({ id, ...(name ? { name } : {}) }, data);
+            }
+            case 'menu.update': {
+                if (!cmd)
+                    return ecwebErr(id, name, 'MISSING_CMD', '缺少 name/cmd');
+                if (!payload.value)
+                    return ecwebErr(id, name, 'MISSING_VALUE', '缺少 value');
+                const r = await this.execMenuUpdate(cmd, payload.value, targetChannel, targetChannel, context.actorAid, trustedIdentity, true, payload.args, trustedSubject, context.source);
+                return ecwebResp(id, name, r);
+            }
+            case 'menu.action': {
+                if (!cmd)
+                    return ecwebErr(id, name, 'MISSING_CMD', '缺少 name/cmd');
+                if (!payload.action)
+                    return ecwebErr(id, name, 'MISSING_VALUE', '缺少 action');
+                const r = await this.execMenuAction(cmd, payload.action, payload.args, targetChannel, targetChannel, context.actorAid, trustedIdentity, undefined, id, true, trustedSubject, context.source);
+                return ecwebResp(id, name, r);
+            }
+            default:
+                return ecwebErr(id, name, 'METHOD_NOT_FOUND', `未知类型: ${payload?.type}`);
+        }
+    }
+    catch (e) {
+        return menuFailure({ id, ...(name ? { name } : {}) }, normalizeMenuError(e));
+    }
+}
+/** ECWeb 专用入口：只信任 IPC 信封中的服务端认证上下文，不信任 Menu payload 自报身份。 */
+export async function execMenuForEcweb(payload, trusted) {
+    const id = payload?.id ?? '';
+    const name = payload?.name;
+    const validationError = validateMenuRequest(payload ?? {});
+    if (validationError)
+        return menuFailure({ id, ...(name ? { name } : {}) }, validationError);
+    const isProcessLevel = isProcessLevelMenu(name, payload?.cmd);
+    const owners = loadDaemonConfig().owners ?? [];
+    if (isProcessLevel && owners.length === 0) {
+        return { type: 'menu.response', id, name, error: { code: 'FORBIDDEN', message: '请在 daemon.json 配置 owners 后使用进程级操作' } };
+    }
+    if (!trusted || (!trusted.localDirect && !trusted.actorAid)) {
+        return menuFailure({ id, ...(name ? { name } : {}) }, {
+            code: 'PERMISSION_DENIED',
+            message: 'ECWeb operation requires a trusted local connection or authenticated actor',
+            data: { $schema_version: 1, kind: 'role_permission_denied', self: payload?.args?.self ?? null },
+        });
+    }
+    const userId = trusted.actorAid ?? (trusted.localDirect ? (isProcessLevel ? owners[0] : 'local-direct') : undefined);
+    return execMenuForSystemControl.call(this, payload, {
+        source: 'ecweb',
+        actorAid: userId || 'local-direct',
+        localDirect: trusted.localDirect,
+        owners,
+    });
+}
+/** 控制 AID channel 专用入口：peerId 必须 ∈ evolcore.owners。
+ *  全量权限（进程级 + 跨 agent + 关系级），fromControlChannel=true 放行闸门。
+ *  与 ECWeb 入口的区别：鉴权主体是真实 peerId（而非注入 owner），按 evolcore.owners 校验。 */
+export async function execMenuForControl(payload, peerId) {
+    const id = payload?.id ?? '';
+    const name = payload?.name;
+    const validationError = validateMenuRequest(payload ?? {});
+    if (validationError)
+        return menuFailure({ id, ...(name ? { name } : {}) }, validationError);
+    const owners = loadDaemonConfig().owners ?? [];
+    const isRoleRequest = name === 'role' || payload?.cmd === '/role';
+    if (!isRoleRequest && !isProcessLevelOwner(peerId, owners)) {
+        return menuFailure({ id, ...(name ? { name } : {}) }, { code: 'ROLE_ACCESS_DENIED', message: '控制 channel 操作需要 owner 权限' });
+    }
+    return execMenuForSystemControl.call(this, payload, {
+        source: 'control',
+        actorAid: peerId,
+        localDirect: false,
+        owners,
+    });
+}