evolcore 0.0.10 → 0.0.12

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

@@ -9,6 +9,7 @@ import { isManagementRole } from '../../config/builtin-roles.js';
 import { formatPeerKey } from '../relation/peer-identity.js';
 import crypto from 'crypto';
 import path from 'path';
+import fs from 'fs';
 import { parseDuration, parseTriggerSet, parseTriggerUpdate } from '../../trigger/parser.js';
 import { applyTriggerPatch, replaceEditableTriggerDefinition } from '../../trigger/patch.js';
 import { definitionRevision } from '../../trigger/validation.js';
@@ -19,14 +20,19 @@ import { resolveConfigCommand } from '../../config/resolved-config-op.js';
 import { AUTHENTICATED_CONFIG_ROLE_ENV, executeResolvedConfigCommand } from '../../config/config-operation-service.js';
 import { hashArgv } from '../auth/authorization-audit.js';
 import { executeResolvedContactCommand, resolveContactCommand } from '../../config/contact-operation-service.js';
+import { executeManagedAidOperation, ManagedAidOperationError, resolveManagedAidOperation, } from '../../aun/aid/managed-operation.js';
+import { executeManagedGroupOperation, isManagedGroupRelationRead, ManagedGroupOperationError, resolveManagedGroupOperation, executeManagedMsgOperation, ManagedMsgOperationError, resolveManagedMsgOperation, executeManagedFsOperation, ManagedFsOperationError, resolveManagedFsOperation, } from '../../aun/msg/managed-operation.js';
 import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
+import { isHClassPath, isLClassPath, isSameOrDescendant } from '../protected-paths.js';
 import { validateModelSelectionForRole } from '../model/model-permission.js';
+import { getModelInfo } from '../model/model-catalog.js';
 import { constrainRuntimePermissionMode, validateRuntimeStringFieldOverride } from '../role/runtime-policy.js';
 import { parsePeerKey } from '../relation/peer-identity.js';
 import { isQuickCommand } from './slash-gate.js';
 import { handleSlashCommand } from './slash-handler.js';
 import { resolveChatMode } from '../message/peer-mode.js';
 import { execMenuAction as menuExecMenuAction, execMenuForEcweb as menuExecMenuForEcweb, execMenuForControl as menuExecMenuForControl, execMenuQuery as menuExecMenuQuery, execMenuUpdate as menuExecMenuUpdate, getMenuItems as menuGetMenuItems, getSubMenuItems as menuGetSubMenuItems, } from './menu-handler.js';
+import { getMenuCatalog, execMenuValueBatch, validateMenuValueBatchArgs } from './menu-catalog.js';
 export { isProcessLevelOwner } from './menu-handler.js';
 const CLI_EXEC_TIMEOUT_MS = 15_000;
 const CLI_EXEC_MAX_OUTPUT = 128 * 1024;
@@ -93,6 +99,7 @@ export class CommandHandler {
     triggerSchedulerFallbackAid;
     daemonStatusProvider;
     agentDelegationRegistry;
+    handoffRuntime;
     /**
      * Get the runner for a (channel, baseagent) pair.
      *
@@ -675,6 +682,9 @@ export class CommandHandler {
     setMessageQueue(messageQueue) {
         this.messageQueue = messageQueue;
     }
+    setHandoffRuntime(handoffRuntime) {
+        this.handoffRuntime = handoffRuntime;
+    }
     setPermissionGateway(gateway) {
         this.permissionGateway = gateway;
     }
@@ -818,6 +828,29 @@ export class CommandHandler {
     getMenuItems(role, chatType = 'private', scope = 'agent', authSubject) {
         return menuGetMenuItems.call(this, role, chatType, scope, authSubject);
     }
+    async getMenuCatalog(channel, channelId, subject, request, channelScope = 'agent') {
+        return await getMenuCatalog({
+            subject,
+            channelType: this.resolveChannelType(channel),
+            channelScope,
+            channelId,
+            request,
+        });
+    }
+    async execMenuValueBatch(channel, channelId, subject, args, request, channelScope = 'agent') {
+        validateMenuValueBatchArgs(args);
+        return await execMenuValueBatch({
+            subject,
+            channelType: this.resolveChannelType(channel),
+            channelScope,
+            channelId,
+            request,
+            items: args?.items,
+            schemaVersion: args?.schemaVersion,
+            consistency: args?.consistency,
+            execQuery: async (cmd, resolvedChannelId, queryArgs, context) => this.execMenuQuery(cmd, channel, resolvedChannelId, context.subject.actorId, queryArgs, context.subject.chatType, context.subject.fromControlChannel, context.subject.identity, context.subject, channelScope === 'control' ? 'control' : 'menu'),
+        });
+    }
     /** 动态子菜单：根据 cmd 路径返回选项列表（供 menu.query + cmd 使用） */
     async getSubMenuItems(cmd, channel, channelId, userId, args, overrideIdentity, explicitChatType, fromControlChannel = false, authSubject, source = 'menu') {
         return await menuGetSubMenuItems.call(this, cmd, channel, channelId, userId, args, overrideIdentity, explicitChatType, fromControlChannel, authSubject, source);
@@ -1569,6 +1602,337 @@ export class CommandHandler {
             ? { ok: true, result }
             : { ok: false, code: result.code, error: result.error, ...(result.data ? { data: result.data } : {}) };
     }
+    /** Agent-managed AID CLI entrypoint. Private key and CA access stay inside the daemon. */
+    async handleAidOperation(argv, sessionId, delegationToken, delegationCommandHash) {
+        if (!this.agentDelegationRegistry) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task delegation is not configured' };
+        }
+        const delegation = this.agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session)
+            return { ok: false, code: 'INVALID_SESSION', error: 'Invalid session' };
+        const parsed = resolveManagedAidOperation(argv);
+        if (!parsed.ok)
+            return { ok: false, code: parsed.code, error: parsed.reason };
+        const grantSelfAid = delegation.grant.selfAid.replace(/^@/, '');
+        const sessionSelfAid = session.selfAID?.replace(/^@/, '');
+        if (sessionSelfAid && sessionSelfAid !== grantSelfAid) {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation self agent does not match the active session' };
+        }
+        if (parsed.command.aid !== grantSelfAid) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current Agent AID can be targeted' };
+        }
+        let conversationId;
+        try {
+            conversationId = parsePeerKey(delegation.grant.peerKey).channelId;
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        }
+        const subject = buildAuthSubject({
+            selfAid: delegation.grant.selfAid,
+            actorId: delegation.grant.actorId,
+            channel: delegation.grant.channel,
+            channelType: delegation.grant.channelType,
+            channelId: conversationId,
+            chatType: delegation.grant.chatType,
+            conversationId,
+            processOwners: loadDaemonConfig().owners ?? [],
+        });
+        const managementRole = isManagementRole(subject.role);
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation: parsed.command.operationId,
+                scope: managementRole ? 'agent' : 'relation',
+                source: 'agent-tool',
+                args: { self: parsed.command.aid, targetId: parsed.command.aid },
+            },
+            auditMetadata: {
+                argvHash: hashArgv(parsed.command.canonicalArgv),
+                taskId: delegation.grant.taskId,
+                messageId: delegation.grant.messageId,
+            },
+        });
+        if (!decision.allow)
+            return { ok: false, code: decision.code, error: decision.reason };
+        try {
+            return { ok: true, result: await executeManagedAidOperation(parsed.command) };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                code: error instanceof ManagedAidOperationError ? error.code : 'AID_OPERATION_FAILED',
+                error: message,
+            };
+        }
+    }
+    /** Agent-managed group CLI entrypoint. AUN private material remains daemon-owned. */
+    async handleGroupOperation(argv, sessionId, delegationToken, delegationCommandHash) {
+        if (!this.agentDelegationRegistry) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task delegation is not configured' };
+        }
+        const delegation = this.agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session)
+            return { ok: false, code: 'INVALID_SESSION', error: 'Invalid session' };
+        const parsed = resolveManagedGroupOperation(argv);
+        if (!parsed.ok)
+            return { ok: false, code: parsed.code, error: parsed.reason };
+        const grant = delegation.grant;
+        const grantSelfAid = grant.selfAid.replace(/^@/, '');
+        const sessionSelfAid = session.selfAID?.replace(/^@/, '');
+        if (sessionSelfAid && sessionSelfAid !== grantSelfAid) {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation self agent does not match the active session' };
+        }
+        if (parsed.command.from !== grantSelfAid) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current Agent AID can perform managed group operations' };
+        }
+        let conversationId;
+        try {
+            conversationId = parsePeerKey(grant.peerKey).channelId;
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        }
+        const subject = buildAuthSubject({
+            selfAid: grant.selfAid,
+            actorId: grant.actorId,
+            channel: grant.channel,
+            channelType: grant.channelType,
+            channelId: conversationId,
+            chatType: grant.chatType,
+            conversationId,
+            processOwners: loadDaemonConfig().owners ?? [],
+        });
+        const managementRole = isManagementRole(subject.role);
+        if (!managementRole && (grant.channelType !== 'aun' || !isManagedGroupRelationRead(parsed.command))) {
+            return { ok: false, code: 'ROLE_ACCESS_DENIED', error: `Role ${subject.role} cannot manage Agent group membership or settings` };
+        }
+        if ((parsed.command.kind === 'dissolve' || parsed.command.kind === 'owner') && subject.role !== 'owner') {
+            return { ok: false, code: 'ROLE_ACCESS_DENIED', error: `${parsed.command.kind} requires Agent owner permission` };
+        }
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation: parsed.command.operationId,
+                scope: managementRole ? 'agent' : 'relation',
+                source: 'agent-tool',
+                args: {
+                    self: parsed.command.from,
+                    ...(parsed.command.groupId ? {
+                        targetId: parsed.command.groupId,
+                        peer: parsed.command.groupId,
+                        peerKey: formatPeerKey(grant.channelType, parsed.command.groupId),
+                    } : {}),
+                },
+            },
+            auditMetadata: {
+                argvHash: hashArgv(parsed.command.canonicalArgv),
+                taskId: grant.taskId,
+                messageId: grant.messageId,
+            },
+        });
+        if (!decision.allow)
+            return { ok: false, code: decision.code, error: decision.reason };
+        let rulesContent;
+        if (parsed.command.kind === 'rules.set') {
+            const filePath = String(parsed.command.filePath || '');
+            const projectPath = path.resolve(session.projectPath);
+            const resolvedPath = path.resolve(projectPath, filePath);
+            if (!filePath || !isSameOrDescendant(resolvedPath, projectPath)) {
+                return { ok: false, code: 'INVALID_RULES_PATH', error: 'Rules file must be inside the current session project' };
+            }
+            if (isHClassPath(resolvedPath) || isLClassPath(resolvedPath)) {
+                return { ok: false, code: 'PROTECTED_RULES_PATH', error: 'Rules file cannot be read from a protected EvolCore path' };
+            }
+            try {
+                const realProjectPath = fs.realpathSync(projectPath);
+                const realPath = fs.realpathSync(resolvedPath);
+                if (!isSameOrDescendant(realPath, realProjectPath)) {
+                    return { ok: false, code: 'INVALID_RULES_PATH', error: 'Rules file resolves outside the current session project' };
+                }
+                const stat = fs.statSync(realPath);
+                if (!stat.isFile() || stat.size < 1 || stat.size > 4 * 1024) {
+                    return { ok: false, code: 'INVALID_RULES_CONTENT', error: 'Rules file must be a regular file from 1 to 4096 bytes' };
+                }
+                rulesContent = new TextDecoder('utf-8', { fatal: true }).decode(fs.readFileSync(realPath));
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    code: 'INVALID_RULES_CONTENT',
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }
+        try {
+            return { ok: true, result: await executeManagedGroupOperation(parsed.command, rulesContent) };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: error instanceof ManagedGroupOperationError ? error.code : 'GROUP_OPERATION_FAILED',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /** Agent-managed private msg read entrypoint. AUN credentials and history roots remain daemon-owned. */
+    async handleMsgOperation(argv, sessionId, delegationToken, delegationCommandHash) {
+        if (!this.agentDelegationRegistry) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task delegation is not configured' };
+        }
+        const delegation = this.agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session)
+            return { ok: false, code: 'INVALID_SESSION', error: 'Invalid session' };
+        const parsed = resolveManagedMsgOperation(argv);
+        if (!parsed.ok)
+            return { ok: false, code: parsed.code, error: parsed.reason };
+        const grant = delegation.grant;
+        const grantSelfAid = grant.selfAid.replace(/^@/, '');
+        const sessionSelfAid = session.selfAID?.replace(/^@/, '');
+        if (sessionSelfAid && sessionSelfAid !== grantSelfAid) {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation self agent does not match the active session' };
+        }
+        if (grant.channelType !== 'aun' || grant.chatType !== 'private') {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Managed msg reads require the current AUN private relation' };
+        }
+        let peerAid;
+        try {
+            peerAid = parsePeerKey(grant.peerKey).channelId.replace(/^@/, '');
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        }
+        if (parsed.command.from !== grantSelfAid || parsed.command.target !== peerAid) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current AUN private relation can be targeted' };
+        }
+        const subject = buildAuthSubject({
+            selfAid: grant.selfAid,
+            actorId: grant.actorId,
+            channel: grant.channel,
+            channelType: grant.channelType,
+            channelId: peerAid,
+            chatType: grant.chatType,
+            conversationId: peerAid,
+            processOwners: loadDaemonConfig().owners ?? [],
+        });
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation: parsed.command.operationId,
+                scope: 'relation',
+                source: 'agent-tool',
+                args: {
+                    self: parsed.command.from,
+                    targetId: parsed.command.target,
+                    peer: parsed.command.target,
+                    peerKey: formatPeerKey('aun', parsed.command.target),
+                },
+            },
+            auditMetadata: {
+                argvHash: hashArgv(parsed.command.canonicalArgv),
+                taskId: grant.taskId,
+                messageId: grant.messageId,
+            },
+        });
+        if (!decision.allow)
+            return { ok: false, code: decision.code, error: decision.reason };
+        try {
+            return { ok: true, result: await executeManagedMsgOperation(parsed.command) };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: error instanceof ManagedMsgOperationError ? error.code : 'MSG_OPERATION_FAILED',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /** Agent-managed current-group filesystem read entrypoint. */
+    async handleFsOperation(argv, sessionId, delegationToken, delegationCommandHash) {
+        if (!this.agentDelegationRegistry) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task delegation is not configured' };
+        }
+        const delegation = this.agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session)
+            return { ok: false, code: 'INVALID_SESSION', error: 'Invalid session' };
+        const parsed = resolveManagedFsOperation(argv);
+        if (!parsed.ok)
+            return { ok: false, code: parsed.code, error: parsed.reason };
+        const grant = delegation.grant;
+        const actorAid = grant.selfAid.replace(/^@/, '');
+        const sessionSelfAid = session.selfAID?.replace(/^@/, '');
+        if (sessionSelfAid && sessionSelfAid !== actorAid) {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation self agent does not match the active session' };
+        }
+        if (grant.channelType !== 'aun' || grant.chatType !== 'group') {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Managed fs reads require the current AUN group relation' };
+        }
+        let currentGroup;
+        try {
+            currentGroup = parsePeerKey(grant.peerKey).channelId;
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        }
+        if ((parsed.command.actorAid && parsed.command.actorAid !== actorAid) || parsed.command.groupId !== currentGroup) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current AUN group can be targeted' };
+        }
+        parsed.command.actorAid = actorAid;
+        const subject = buildAuthSubject({
+            selfAid: grant.selfAid,
+            actorId: grant.actorId,
+            channel: grant.channel,
+            channelType: grant.channelType,
+            channelId: currentGroup,
+            chatType: grant.chatType,
+            conversationId: currentGroup,
+            processOwners: loadDaemonConfig().owners ?? [],
+        });
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation: parsed.command.operationId,
+                scope: 'relation',
+                source: 'agent-tool',
+                args: {
+                    self: actorAid,
+                    targetId: currentGroup,
+                    peer: currentGroup,
+                    peerKey: formatPeerKey('aun', currentGroup),
+                },
+            },
+            auditMetadata: { argvHash: hashArgv(parsed.command.canonicalArgv), taskId: grant.taskId, messageId: grant.messageId },
+        });
+        if (!decision.allow)
+            return { ok: false, code: decision.code, error: decision.reason };
+        try {
+            return { ok: true, result: await executeManagedFsOperation(parsed.command) };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: error instanceof ManagedFsOperationError ? error.code : 'FS_OPERATION_FAILED',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
     setAgentDelegationRegistry(registry) {
         this.agentDelegationRegistry = registry;
     }
@@ -1576,7 +1940,7 @@ export class CommandHandler {
      * Agent ctl 入口：通过 IPC 接收 Agent 自主管理指令
      * 复用现有 slash cmd 逻辑，权限继承 session 用户角色
      */
-    async handleCtl(cmd, sessionId) {
+    async handleCtl(cmd, sessionId, grant) {
         logger.info(`[ctl] cmd="${cmd}" sessionId=${sessionId}`);
         // 1. 白名单检查
         const inputCmd = cmd.split(' ')[0];
@@ -1588,9 +1952,56 @@ export class CommandHandler {
         if (!session) {
             return { ok: false, error: '无效的 session' };
         }
+        if (!grant || grant.sessionId !== sessionId) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'An active task delegation grant is required' };
+        }
+        const sessionSelfAid = session.selfAID?.replace(/^@/, '');
+        const grantSelfAid = grant.selfAid.replace(/^@/, '');
+        if (sessionSelfAid && sessionSelfAid !== grantSelfAid) {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation self agent does not match the active session' };
+        }
+        let conversationId;
+        try {
+            conversationId = parsePeerKey(grant.peerKey).channelId;
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        }
+        const ctlSubject = buildAuthSubject({
+            selfAid: grant.selfAid,
+            actorId: grant.actorId,
+            channel: grant.channel,
+            channelType: grant.channelType,
+            channelId: conversationId,
+            chatType: grant.chatType,
+            conversationId,
+            processOwners: loadDaemonConfig().owners ?? [],
+        });
+        const ctlIntent = this.resolveCtlIntent(cmd, grantSelfAid, grant.peerKey);
+        if (!ctlIntent)
+            return { ok: false, code: 'NOT_ALLOWED', error: `不允许的指令: ${inputCmd}` };
+        const ctlDecision = authorizeOperation({
+            source: 'agent-tool',
+            subject: ctlSubject,
+            intent: ctlIntent,
+            auditMetadata: {
+                argvHash: hashArgv(['ctl', ...cmd.slice(1).split(/\s+/).filter(Boolean)]),
+                taskId: grant.taskId,
+                messageId: grant.messageId,
+            },
+        });
+        if (!ctlDecision.allow)
+            return { ok: false, code: ctlDecision.code, error: ctlDecision.reason };
+        if (cmd.startsWith('/model info ')) {
+            const modelId = cmd.slice('/model info '.length).trim();
+            if (!modelId || /\s/.test(modelId))
+                return { ok: false, code: 'INVALID_ARGUMENT', error: 'model info requires one model id' };
+            const info = await getModelInfo(modelId, grantSelfAid, session.baseagent);
+            return { ok: true, result: JSON.stringify(info, null, 2), data: { ok: true, ...info } };
+        }
         // 3. 从 session.metadata.peerId 获取 userId（用于权限判断）
         const userId = session.metadata?.peerId;
-        const ctlIdentity = this.resolveCtlIdentity(session, userId);
+        const ctlIdentity = ctlSubject.identity;
         // 4. /send 文本消息：直接通过 adapter 主动发送，不走 handle()
         if (cmd.startsWith('/send ') || cmd === '/send') {
             // 解析 --encrypt 标志和消息文本
@@ -1625,9 +2036,9 @@ export class CommandHandler {
             const parts = sendArgs.split(/\s+/);
             const filePath = parts[parts.length - 1];
             if (filePath) {
-                const resolved = path.resolve(session.projectPath, filePath).replace(/\\/g, '/');
-                const projectPath = session.projectPath.replace(/\\/g, '/');
-                if (!resolved.startsWith(projectPath)) {
+                const resolved = path.resolve(session.projectPath, filePath);
+                const relative = path.relative(path.resolve(session.projectPath), resolved);
+                if (relative.startsWith('..') || path.isAbsolute(relative)) {
                     return { ok: false, error: '路径越界：只能发送项目目录下的文件' };
                 }
             }
@@ -1640,7 +2051,7 @@ export class CommandHandler {
         // 6. 调用现有 handle()，不传 sendMessage 回调（结果直接返回）
         try {
             const result = await this._handleInternal(cmd, session.channel, session.channelId, undefined, // 不发送消息
-            userId, session.threadId || undefined, session.chatType, undefined, undefined, session.selfAID, ctlIdentity);
+            userId, session.threadId || undefined, session.chatType, undefined, undefined, session.selfAID, ctlIdentity, ctlSubject);
             const text = typeof result === 'string' ? result : (result && 'text' in result ? result.text : '(无输出)');
             if (result && typeof result === 'object' && 'kind' in result && result.kind === 'command.error') {
                 return { ok: false, error: text || '执行失败' };
@@ -1651,6 +2062,56 @@ export class CommandHandler {
             return { ok: false, error: err.message };
         }
     }
+    resolveCtlIntent(cmd, selfAid, peerKey) {
+        const [name = '', ...args] = cmd.trim().slice(1).trim().split(/\s+/);
+        const relationArgs = { self: selfAid, peer: peerKey, peerKey };
+        const intent = (operation, extra = {}) => ({
+            operation,
+            scope: 'relation',
+            source: 'agent-tool',
+            args: { ...relationArgs, ...extra },
+        });
+        if (name === 'send')
+            return intent('ec.ctl.send');
+        if (name === 'file')
+            return intent('ec.ctl.file');
+        if (name === 'status')
+            return intent('session.current');
+        if (name === 'pwd')
+            return intent('project.current');
+        if (name === 'name' || name === 'rename')
+            return intent('session.rename');
+        if (name === 'queue') {
+            const action = args.includes('--clear') ? 'clear'
+                : args.includes('--cancel') ? 'cancel'
+                    : args.includes('--interrupt') ? 'interrupt'
+                        : 'read';
+            return intent(`ec.ctl.queue.${action}`);
+        }
+        if (name === 'model') {
+            if (args.length === 0 || args[0] === 'list')
+                return intent('model.list');
+            if (args[0] === 'current')
+                return intent('model.current');
+            if (args[0] === 'info')
+                return intent('model.info', { model: args[1] });
+            if (args[0] === 'reset')
+                return intent('model.reset');
+            if (args[0] === 'check') {
+                return { operation: 'model.check', scope: 'agent', source: 'agent-tool', args: { self: selfAid } };
+            }
+            return intent('model.use', { model: args[0] });
+        }
+        if (name === 'effort') {
+            return args.length === 0
+                ? intent('model.effort.current')
+                : intent('model.effort', { effort: args[0] });
+        }
+        if (name === 'restart') {
+            return { operation: 'system.restart', scope: 'process', source: 'agent-tool', args: { self: selfAid } };
+        }
+        return null;
+    }
     // ── Queue command ──
     /** 提取命名参数值（如 --cancel msg123 → "msg123"） */
     extractArg(args, flag) {

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

@@ -331,6 +331,21 @@ async function actionReviewRequest(req, self, context, decision) {
         decision,
     });
     if (reviewed.code === 'approved' || reviewed.code === 'rejected' || reviewed.code === 'blocked') {
+        if (reviewed.requestId && reviewed.expiresAt) {
+            try {
+                await context.notifyContactRequestReviewed?.({
+                    applicantAid: primaryId,
+                    requestId: reviewed.requestId,
+                    expiresAt: reviewed.expiresAt,
+                    status: reviewed.code === 'approved'
+                        ? 'APPROVED'
+                        : reviewed.code === 'rejected' ? 'REJECTED' : 'NOT_ALLOWED',
+                });
+            }
+            catch {
+                // Review state is authoritative; notification delivery is best-effort.
+            }
+        }
         return ok({
             self,
             action: `${decision}-request`,

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

@@ -1,6 +1,6 @@
 import crypto from 'crypto';
 import { ConfigTarget, mutateConfig, read as readConfig, resolveEffectiveFieldWithSource, } from '../../config/config-manager.js';
-import { dispatchToMentionMode } from '../../config/mention-mode.js';
+import { normalizeMentionMode } from '../../config/mention-mode.js';
 import { readRolesConfig } from '../../config/roles.js';
 import { groupInfo, groupList } from '../../aun/msg/group.js';
 import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
@@ -156,9 +156,9 @@ async function resolveTarget(args, context) {
         scope,
         selector: { self: context.self, peerKey: formatPeerKey('aun', canonicalGroupId) },
         groupId: canonicalGroupId,
-        aunMentionMode: dispatchToMentionMode(group.dispatch_mode
-            ?? group.settings?.dispatch_mode
-            ?? group.metadata?.dispatch_mode),
+        aunMentionMode: normalizeMentionMode(group.mention_mode)
+            ?? normalizeMentionMode(group.settings?.mention_mode)
+            ?? normalizeMentionMode(group.metadata?.mention_mode),
     };
 }
 function groupIdFromArgs(args, currentGroupId) {