evolcore 0.0.11 → 0.0.12

package/dist/core/capability/providers/codex-capability-provider.js

@@ -1,19 +1,7 @@
-import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { execCodexCliSync } from '../../../utils/codex-cli.js';
-function listDirectories(dir) {
-    try {
-        if (!fs.existsSync(dir))
-            return [];
-        return fs.readdirSync(dir, { withFileTypes: true })
-            .filter(entry => entry.isDirectory())
-            .map(entry => entry.name);
-    }
-    catch {
-        return [];
-    }
-}
+import { discoverSkillDirectories } from '../skill-discovery.js';
 function discoverSkills(ctx) {
     const roots = [
         { dir: path.join(ctx.projectPath, '.codex', 'skills'), source: 'project' },
@@ -23,11 +11,12 @@ function discoverSkills(ctx) {
     const seen = new Set();
     const out = [];
     for (const root of roots) {
-        for (const id of listDirectories(root.dir)) {
+        for (const skill of discoverSkillDirectories(root.dir)) {
+            const { id } = skill;
             if (seen.has(id))
                 continue;
             seen.add(id);
-            out.push({ id, label: id, source: root.source });
+            out.push({ id, label: id, desc: skill.description, source: root.source });
         }
     }
     return out;

package/dist/core/capability/skill-discovery.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+import { parseDocument } from 'yaml';
+function readSkillMetadata(skillDir) {
+    const skillFile = path.join(skillDir, 'SKILL.md');
+    try {
+        if (!fs.statSync(skillFile).isFile())
+            return undefined;
+        const text = fs.readFileSync(skillFile, 'utf-8');
+        const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+        if (!match)
+            return undefined;
+        const document = parseDocument(match[1]);
+        if (document.errors.length > 0)
+            return undefined;
+        const metadata = document.toJS();
+        if (typeof metadata?.name !== 'string' || !metadata.name.trim())
+            return undefined;
+        if (typeof metadata.description !== 'string' || !metadata.description.trim())
+            return undefined;
+        return {
+            id: metadata.name.trim(),
+            description: metadata.description.trim(),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Return only directories that satisfy the Codex/Claude skill file contract. */
+export function discoverSkillDirectories(root) {
+    try {
+        if (!fs.existsSync(root))
+            return [];
+        return fs.readdirSync(root, { withFileTypes: true })
+            .filter(entry => !entry.name.startsWith('.'))
+            .filter(entry => entry.isDirectory() || entry.isSymbolicLink())
+            .map(entry => {
+            const dir = path.join(root, entry.name);
+            try {
+                if (!fs.statSync(dir).isDirectory())
+                    return undefined;
+            }
+            catch {
+                return undefined;
+            }
+            const metadata = readSkillMetadata(dir);
+            return metadata;
+        })
+            .filter((entry) => Boolean(entry));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/core/channel-loader.js

@@ -196,7 +196,7 @@ export function buildReloadHooks(deps) {
             if (!handoffRuntime)
                 return;
             try {
-                await handoffRuntime.recover([aid]);
+                await handoffRuntime.recover([aid], { discardExpired: false });
             }
             finally {
                 handoffRuntime.resumeAgent(aid);

package/dist/core/command/cli-intent-parser.js

@@ -33,6 +33,15 @@ export function parseCliIntent(inputArgv, source = 'menu.cli', options = {}) {
         return parseAidCommand(argv, source);
     if (cmd === 'storage')
         return parseStorageCommand(argv, source);
+    if (cmd === 'version') {
+        const parsed = parseArgs(argv.slice(1));
+        if (parsed.positionals.length > 0)
+            return raw(source, argv, 'Unexpected version positional args');
+        const unsupported = Object.keys(parsed.args).filter(key => key !== 'format' && key !== 'json');
+        if (unsupported.length > 0)
+            return raw(source, argv, `Unsupported version option: --${unsupported[0]}`);
+        return recognized('ec.version', 'relation', source, parsed.args, argv);
+    }
     if (cmd === 'status') {
         return recognized('system.status', 'process', source, parseArgs(argv.slice(1)), argv);
     }

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) {