evolcore 0.0.17 → 0.0.19

package/dist/index.js

@@ -42,7 +42,7 @@ import { buildEnvelope, isDeliveryTargetForChannel, replyContextFromSession } fr
 import { ResponseEngine } from './core/message/response-engine.js';
 import { MessageQueue } from './core/message/message-queue.js';
 import { MessageBridge } from './core/message/message-bridge.js';
-import { evaluateEvolMenuVersionGate, evolMenuResponseTransportMetadata, MenuRequestDeduper, hasValidMenuId, menuFailure, menuPayloadFingerprint, parseMenuControl, validateMenuRequest } from './core/command/menu-protocol.js';
+import { evaluateEvolMenuVersionGate, evolMenuResponseTransportMetadata, MenuRequestDeduper, hasValidMenuId, menuFailure, menuPayloadFingerprint, normalizeMenuResponseTiming, parseMenuControl, validateMenuRequest, withMenuProcessingTime, logMenuRequestCompleted, logMenuRequestReceived } from './core/command/menu-protocol.js';
 import { readInstalledEvolcoreVersion } from './utils/evolcore-version.js';
 import { recoverAllRoleMutationsSync } from './core/command/role-menu.js';
 import { HandoffRuntime } from './core/handoff/runtime.js';
@@ -51,13 +51,14 @@ import { postBootstrapWelcomeOperationId } from './core/bootstrap-messages.js';
 import { MessageCache } from './core/message/message-cache.js';
 import { CommandHandler, isProcessLevelOwner } from './core/command/command-handler.js';
 import { EventBus } from './core/event-bus.js';
-import { getEventCatalog } from './core/event-catalog.js';
+import { eventPatternIncludesInternal, getEventCatalog } from './core/event-catalog.js';
 import { StatsCollector } from './utils/stats.js';
 import { AidStatsCollector } from './utils/stats.js';
 import { PermissionGateway } from './core/permission/approval-gateway.js';
 import { InteractionRouter, registerAdapterInteractions } from './core/interaction-router.js';
 import { AgentDelegationRegistry, authorizeDelegatedAunMsgSend } from './core/auth/agent-delegation.js';
-import { authorizeOperation, buildAuthSubject, isCrossAgentTriggerOperationAllowed, isCrossAgentTriggerReadOperation, } from './core/auth/auth-gateway.js';
+import { authorizeOperation, buildAuthSubject, isCrossAgentTriggerOperationAllowed, } from './core/auth/auth-gateway.js';
+import { authorizationDenialData, formatAuthorizationDenial } from './core/auth/authorization-denial.js';
 import { parsePeerKey } from './core/relation/peer-identity.js';
 import { isHClassPath } from './core/protected-paths.js';
 import { ChannelLoader, tryParseChannelKey } from './core/channel-loader.js';
@@ -481,6 +482,9 @@ async function runBindBootstrapDaemon(daemonCfg) {
     });
     bindService.startCleanup();
     let controlChannel;
+    let shutdown;
+    let pendingShutdownReason;
+    let shutdownInProgress = false;
     controlChannel = new AUNChannel({
         aid: daemonCfg.aid,
         agentName: daemonCfg.aid,
@@ -535,12 +539,21 @@ async function runBindBootstrapDaemon(daemonCfg) {
                     gatewayUrl: aidState.gatewayUrl,
                     reconnectCount: aidState.reconnectCount,
                     lastConnectedAt: aidState.lastConnectedAt,
+                    lastTransportEventAt: aidState.lastTransportEventAt,
+                    lastInboundAt: aidState.lastInboundAt,
                     lastError: aidState.lastError,
                 } : {}),
             };
         })(),
     }));
     ipcServer.setControlToken(controlToken);
+    ipcServer.setShutdownExecutor(async (reason) => {
+        if (!shutdown) {
+            pendingShutdownReason = reason;
+            return;
+        }
+        await shutdown(reason);
+    });
     ipcServer.setBindExecutor({
         begin: (cmd) => bindService.begin(cmd),
         status: (taskId) => bindService.status(taskId),
@@ -549,9 +562,16 @@ async function runBindBootstrapDaemon(daemonCfg) {
     await ipcServer.start();
     fs.writeFileSync(resolvePaths().readySignal, String(Date.now()));
     logger.info(`✓ Bind bootstrap ready signal written: ${resolvePaths().readySignal}`);
-    const shutdown = async (signal) => {
+    shutdown = async (signal) => {
+        if (shutdownInProgress)
+            return;
+        shutdownInProgress = true;
         logger.info(`[bind-bootstrap] shutting down${signal ? ` (${signal})` : ''}`);
         ipcServer.stop();
+        try {
+            fs.unlinkSync(resolvePaths().readySignal);
+        }
+        catch { }
         bindService.stopCleanup();
         if (controlChannel) {
             try {
@@ -562,6 +582,10 @@ async function runBindBootstrapDaemon(daemonCfg) {
         removeAll();
         process.exit(0);
     };
+    if (pendingShutdownReason) {
+        const reason = pendingShutdownReason;
+        setImmediate(() => { void shutdown?.(reason); });
+    }
     process.on('SIGINT', () => shutdown('SIGINT'));
     process.on('SIGTERM', () => shutdown('SIGTERM'));
     process.on('exit', () => removeAll());
@@ -1390,11 +1414,29 @@ async function main() {
             throw Object.assign(new Error('AUN trigger feedback target requires a valid explicit delivery route'), { code: 'AUN_OUTBOUND_ROUTE_REQUIRED' });
         }
     };
-    const validateTriggerDefinitionForActor = (definition, actor) => {
-        if (definition.execution.type === 'script' && !actor.management) {
-            throw new Error('only owner/admin may create or update a script trigger');
+    const daemonPrivilegedTriggerReason = (definition) => {
+        if (definition.origin?.channelKey === 'daemon' || definition.origin?.channelType === 'daemon') {
+            return 'daemon/control-origin Trigger';
         }
-        if (definition.execution.permissionMode) {
+        if (definition.execution.type === 'script')
+            return 'script Trigger';
+        if (definition.execution.permissionMode === 'bypass')
+            return 'persistent bypass Trigger';
+        if (definition.source.type === 'event' && eventPatternIncludesInternal(definition.source.eventPattern)) {
+            return 'internal-event Trigger';
+        }
+        if (definition.feedback.strategy === 'target'
+            && definition.feedback.target?.channelKey === 'daemon') {
+            return 'daemon-control feedback';
+        }
+        return undefined;
+    };
+    const hasDaemonTriggerAuthority = (subject) => (subject.isDaemonOwner || subject.processRole === 'daemon-service');
+    const validateTriggerDefinitionForActor = (definition, actor) => {
+        const privilegedReason = daemonPrivilegedTriggerReason(definition);
+        if (privilegedReason && !actor.daemonPrivileged)
+            throw new Error(`${privilegedReason} requires DaemonOwner`);
+        if (definition.execution.permissionMode && !actor.daemonPrivileged) {
             const permissionDecision = constrainRuntimePermissionMode({
                 selfAid: definition.agentAid,
                 role: actor.role,
@@ -1404,7 +1446,7 @@ async function main() {
                 throw new Error(`trigger permissionMode ${definition.execution.permissionMode} exceeds current role ${actor.role}`);
             }
         }
-        if (definition.execution.model) {
+        if (definition.execution.model && !actor.daemonPrivileged) {
             const agent = agentRegistry.get(definition.agentAid);
             const modelDecision = validateModelSelectionForRole({
                 role: actor.role,
@@ -1415,7 +1457,7 @@ async function main() {
             if (!modelDecision.ok)
                 throw new Error(modelDecision.message || 'trigger model is not allowed by current role');
         }
-        if (definition.execution.effort) {
+        if (definition.execution.effort && !actor.daemonPrivileged) {
             const baseagent = definition.execution.baseagent
                 ?? agentRegistry.get(definition.agentAid)?.baseagent
                 ?? 'claude';
@@ -1453,7 +1495,7 @@ async function main() {
                 channelId: origin.channelId,
                 chatType: 'private',
                 conversationId: origin.peerId,
-                identity: roleToSessionIdentity('owner'),
+                trustedProcessRole: 'daemon-service',
                 fromControlChannel: true,
             });
             const decision = authorizeOperation({
@@ -1493,6 +1535,7 @@ async function main() {
             conversationId: origin.peerId,
             roleDetail,
             identity: roleToSessionIdentity(role),
+            processOwners: loadDaemonConfig().owners ?? [],
             fromControlChannel: false,
         });
         const operationDecision = authorizeOperation({
@@ -1508,8 +1551,9 @@ async function main() {
         if (!operationDecision.allow) {
             return { allowed: false, reason: operationDecision.reason };
         }
-        if (definition.execution.type === 'script' && !isManagementRole(role)) {
-            return { allowed: false, reason: `script trigger requires current owner/admin role (role=${role ?? 'none'})` };
+        const privilegedReason = daemonPrivilegedTriggerReason(definition);
+        if (privilegedReason && !hasDaemonTriggerAuthority(subject)) {
+            return { allowed: false, reason: `${privilegedReason} requires current DaemonOwner` };
         }
         if (definition.feedback.strategy === 'target' && !isManagementRole(role)) {
             const target = definition.feedback.target;
@@ -1548,14 +1592,16 @@ async function main() {
                 channelId: origin.channelId,
                 chatType: 'private',
                 conversationId: origin.peerId,
-                identity: roleToSessionIdentity('owner'),
+                trustedProcessRole: 'daemon-service',
                 fromControlChannel: true,
             });
             return {
                 origin,
                 management: true,
+                daemonOwner: false,
+                daemonPrivileged: true,
                 control: true,
-                role: 'owner',
+                role: 'none',
                 subject,
             };
         }
@@ -1580,9 +1626,6 @@ async function main() {
             conversationId: validation.grant.actorId,
         });
         const currentRole = roleDetail.effectiveRole;
-        if (!checkRoleAccess(currentRole, agentAid)) {
-            throw new Error('trigger actor no longer has access to this agent');
-        }
         const subject = buildAuthSubject({
             selfAid: agentAid,
             actorId: validation.grant.actorId,
@@ -1593,11 +1636,20 @@ async function main() {
             conversationId: validation.grant.actorId,
             roleDetail,
             identity: roleToSessionIdentity(currentRole),
+            processOwners: loadDaemonConfig().owners ?? [],
             fromControlChannel: false,
         });
+        if (validation.grant.selfAid !== agentAid && !subject.isDaemonOwner) {
+            throw new Error('cross-agent Trigger operations require DaemonOwner');
+        }
+        if (!subject.isDaemonOwner && !checkRoleAccess(currentRole, agentAid)) {
+            throw new Error('trigger actor no longer has access to this agent');
+        }
         return {
             origin: actorOrigin,
-            management: isManagementRole(currentRole),
+            management: isManagementRole(currentRole) || subject.isDaemonOwner,
+            daemonOwner: subject.isDaemonOwner,
+            daemonPrivileged: subject.isDaemonOwner,
             selfAid: validation.grant.selfAid,
             control: false,
             role: currentRole || 'none',
@@ -2124,6 +2176,8 @@ async function main() {
     // A failed bind (for example, a stale Windows named pipe) must abort startup
     // without creating a second AUN session that can kick the old daemon.
     let controlChannel;
+    let shutdown;
+    let pendingShutdownReason;
     const ipcServer = new IpcServer(resolvePaths().socket, () => {
         const channels = {};
         const channelsByType = {};
@@ -2176,6 +2230,8 @@ async function main() {
                         gatewayUrl: aidState.gatewayUrl,
                         reconnectCount: aidState.reconnectCount,
                         lastConnectedAt: aidState.lastConnectedAt,
+                        lastTransportEventAt: aidState.lastTransportEventAt,
+                        lastInboundAt: aidState.lastInboundAt,
                         lastError: aidState.lastError,
                     } : {}),
                 };
@@ -2259,7 +2315,15 @@ async function main() {
         // 2. menu.* JSON — 路由到 cmdHandler.execMenuForControl（进程级 + 全量权限）
         // 发送方身份由 AUN X.509 证书链验证，非 owner 完全静默。
         controlChannel.onMessage(async (opts) => {
+            let activeMenuRequest;
+            let menuCompletionLogged = false;
+            const menuFlowContext = {
+                source: 'control-aun',
+                selfAid: daemonCfg.aid,
+                messageId: opts.messageId,
+            };
             try {
+                const menuTiming = normalizeMenuResponseTiming(opts);
                 const text = (opts.content || '').trim();
                 let parsed;
                 try {
@@ -2269,6 +2333,28 @@ async function main() {
                     parsed = null;
                 }
                 const menuResponseContext = () => controlReplyContext(opts, evolMenuResponseTransportMetadata());
+                const sendControlMenuResponse = async (response) => {
+                    const timedResponse = withMenuProcessingTime(response, menuTiming);
+                    const request = activeMenuRequest ?? {
+                        type: 'menu.unknown',
+                        id: response.id,
+                        ...(response.name ? { name: response.name } : {}),
+                    };
+                    try {
+                        await controlChannel.sendStructured(opts.channelId, timedResponse, menuResponseContext());
+                        logMenuRequestCompleted(request, timedResponse, menuFlowContext, { delivery: 'sent' });
+                        menuCompletionLogged = true;
+                    }
+                    catch (error) {
+                        logMenuRequestCompleted(request, timedResponse, menuFlowContext, {
+                            delivery: 'failed',
+                            reason: 'transport-error',
+                            transportError: error,
+                        });
+                        menuCompletionLogged = true;
+                        throw error;
+                    }
+                };
                 if (bindService && parsed?.type === 'bind.request') {
                     const response = await bindService.handleRequest(parsed, opts.peerId);
                     if (response) {
@@ -2280,18 +2366,32 @@ async function main() {
                     return;
                 }
                 const menuControl = parseMenuControl(text);
+                if (menuControl.isMenu) {
+                    activeMenuRequest = menuControl.request;
+                    logMenuRequestReceived(menuControl.request, menuFlowContext);
+                }
                 const isRoleMenu = menuControl.isMenu
                     && (menuControl.name === 'role' || menuControl.request.cmd === '/role');
+                const currentProcessOwners = loadDaemonConfig().owners ?? [];
                 if (menuControl.isMenu && !hasValidMenuId(menuControl)) {
                     logger.warn(`[ControlMenu] dropped malformed request without id type=${menuControl.type}`);
+                    logMenuRequestCompleted(menuControl.request, undefined, menuFlowContext, {
+                        delivery: 'dropped',
+                        reason: 'missing-id',
+                    });
+                    menuCompletionLogged = true;
                     return;
                 }
-                if (menuControl.isMenu && !isRoleMenu && !isProcessLevelOwner(opts.peerId, processLevelOwners)) {
-                    const response = menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, { code: 'ROLE_ACCESS_DENIED', message: 'Current identity cannot access the control channel' });
-                    await controlChannel.sendStructured(opts.channelId, response, menuResponseContext());
+                if (menuControl.isMenu && !isRoleMenu && !isProcessLevelOwner(opts.peerId, currentProcessOwners)) {
+                    const response = menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, {
+                        code: 'NOT_ALLOWED',
+                        message: formatAuthorizationDenial('Control-channel process operations require DaemonOwner.', 'DAEMON_OWNER_REQUIRED'),
+                        data: authorizationDenialData('DAEMON_OWNER_REQUIRED'),
+                    });
+                    await sendControlMenuResponse(response);
                     return;
                 }
-                if (!isRoleMenu && !isProcessLevelOwner(opts.peerId, processLevelOwners)) {
+                if (!isRoleMenu && !isProcessLevelOwner(opts.peerId, currentProcessOwners)) {
                     logger.debug(`控制 AID 收到非 owner 消息，忽略: from=${opts.peerId}`);
                     return;
                 }
@@ -2316,12 +2416,12 @@ async function main() {
                         protectedHeaders: opts.protectedHeaders,
                     });
                     if (versionError) {
-                        await controlChannel.sendStructured(opts.channelId, menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, versionError), menuResponseContext());
+                        await sendControlMenuResponse(menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, versionError));
                         return;
                     }
                     const validationError = validateMenuRequest(menuControl.request);
                     if (validationError) {
-                        await controlChannel.sendStructured(opts.channelId, menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, validationError), menuResponseContext());
+                        await sendControlMenuResponse(menuFailure({ id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) }, validationError));
                         return;
                     }
                     const deduped = await controlMenuDeduper.execute([opts.channelId, opts.peerId, menuControl.id].join('\u001f'), menuPayloadFingerprint(menuControl.raw), () => cmdHandler.execMenuForControl(parsed, opts.peerId));
@@ -2340,13 +2440,20 @@ async function main() {
                         : deduped.value;
                     // 同 bind.response：sendStructured 直发 typed payload（payload.type='menu.response'），
                     // 不能用 sendMessage（会包成 {type:'text',...}）；encrypted 跟随入站请求保持对称。
-                    await controlChannel.sendStructured(opts.channelId, response, menuResponseContext());
+                    await sendControlMenuResponse(response);
                     return;
                 }
                 // owner 发的其他内容：提示可用指令
                 await controlChannel.sendMessage(opts.channelId, '可用指令：/pair（获取 ECWeb 登录配对码）', controlReplyContext(opts));
             }
             catch (e) {
+                if (activeMenuRequest && !menuCompletionLogged) {
+                    logMenuRequestCompleted(activeMenuRequest, undefined, menuFlowContext, {
+                        delivery: 'failed',
+                        reason: 'handler-error',
+                        transportError: e,
+                    });
+                }
                 logger.warn(`控制 AID 消息处理失败: ${e?.message || e}`);
             }
         });
@@ -2502,6 +2609,13 @@ async function main() {
         }
     }
     function configureIpc() {
+        ipcServer.setShutdownExecutor(async (reason) => {
+            if (!shutdown) {
+                pendingShutdownReason = reason;
+                return;
+            }
+            await shutdown(reason);
+        });
         // M3: direct call (not cast) — wire EvolAgentRegistry into IPC for evolagent.* handlers
         ipcServer.setAgentRegistry(agentRegistry);
         ipcServer.setControlToken(triggerControlToken);
@@ -2657,7 +2771,7 @@ async function main() {
             for (const runner of new Set(agentMap.values())) {
                 if (typeof runner?.evaluatePreToolUse !== 'function')
                     continue;
-                const result = await runner.evaluatePreToolUse(params.threadId, params.toolName, params.toolInput);
+                const result = await runner.evaluatePreToolUse(params.threadId, params.toolName, params.toolInput, params.signal);
                 if (result.applicable)
                     return result;
             }
@@ -2699,7 +2813,7 @@ async function main() {
                 channelId: conversationId,
                 chatType: delegation.grant.chatType,
                 conversationId,
-                processOwners: daemonCfg.owners ?? [],
+                processOwners: loadDaemonConfig().owners ?? [],
             });
             const managementRole = isManagementRole(subject.role);
             const decision = authorizeOperation({
@@ -3317,9 +3431,6 @@ async function main() {
             if (!session || session.selfAID !== delegation.grant.selfAid) {
                 return { ok: false, code: 'INVALID_DELEGATION', error: 'delegation does not match the current session' };
             }
-            if (params.targetAid && params.targetAid !== delegation.grant.selfAid) {
-                return { ok: false, code: 'SCOPE_MISMATCH', error: 'only the current Agent can be targeted' };
-            }
             let conversationId;
             try {
                 conversationId = parsePeerKey(delegation.grant.peerKey).channelId;
@@ -3335,10 +3446,10 @@ async function main() {
                 channelId: conversationId,
                 chatType: delegation.grant.chatType,
                 conversationId,
-                processOwners: daemonCfg.owners ?? [],
+                processOwners: loadDaemonConfig().owners ?? [],
             });
-            if (!isManagementRole(subject.role)) {
-                return { ok: false, code: 'ROLE_ACCESS_DENIED', error: `${operation} requires Agent admin permission` };
+            if (params.targetAid && params.targetAid !== delegation.grant.selfAid && !subject.isDaemonOwner) {
+                return { ok: false, code: 'SCOPE_MISMATCH', error: 'only the current Agent can be targeted' };
             }
             const decision = authorizeOperation({
                 source: 'agent-tool',
@@ -3355,6 +3466,180 @@ async function main() {
                 ? { ok: true, aid: delegation.grant.selfAid }
                 : { ok: false, code: decision.code, error: decision.reason };
         }
+        ipcServer.setAgentOperationExecutor(async (argv, sessionId, delegationToken, delegationCommandHash) => {
+            const fail = (code, error, reasonCode) => ({
+                ok: false,
+                code,
+                error,
+                ...(reasonCode ? { data: authorizationDenialData(reasonCode) } : {}),
+            });
+            if (!Array.isArray(argv) || argv[0] !== 'agent')
+                return fail('INVALID_REQUEST', 'agent.op requires an agent command');
+            const sub = argv[1];
+            if (!sub)
+                return fail('INVALID_ARGS', 'missing agent subcommand');
+            const value = (flag) => {
+                const index = argv.indexOf(flag);
+                return index >= 0 && index + 1 < argv.length && !argv[index + 1].startsWith('--') ? argv[index + 1] : undefined;
+            };
+            const taskSession = await sessionManager.getSessionById(sessionId);
+            const delegation = agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash);
+            if (!delegation.ok)
+                return fail(delegation.code, delegation.reason);
+            if (!taskSession || taskSession.selfAID !== delegation.grant.selfAid) {
+                return fail('INVALID_DELEGATION', 'delegation does not match the current session');
+            }
+            const taskAid = delegation.grant.selfAid;
+            const targetAid = sub === 'list'
+                ? undefined
+                : sub === 'show'
+                    ? (argv[2] && !argv[2].startsWith('--') ? argv[2] : taskAid)
+                    : sub === 'reload'
+                        ? (argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined)
+                        : (argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined);
+            const operation = sub === 'list' ? 'agent.list'
+                : sub === 'show' ? 'agent.show'
+                    : sub === 'new' ? 'agent.create'
+                        : sub === 'enable' ? 'agent.enable'
+                            : sub === 'disable' ? 'agent.disable'
+                                : sub === 'reload' ? 'agent.reload'
+                                    : sub === 'delete' ? 'agent.delete' : undefined;
+            if (!operation)
+                return fail('INVALID_ARGS', `unsupported managed agent command: ${sub}`);
+            if (sub === 'new' && !argv.includes('--non-interactive')) {
+                return fail('MANAGED_NON_INTERACTIVE_REQUIRED', 'interactive Agent creation is unavailable in a managed task', 'MANAGED_NON_INTERACTIVE_REQUIRED');
+            }
+            if (sub === 'delete' && argv.includes('--purge') && !argv.includes('--confirm-purge')) {
+                return fail('PURGE_CONFIRMATION_REQUIRED', 'agent delete --purge requires explicit --confirm-purge', 'PURGE_CONFIRMATION_REQUIRED');
+            }
+            let conversationId;
+            try {
+                conversationId = parsePeerKey(delegation.grant.peerKey).channelId;
+            }
+            catch {
+                return fail('INVALID_DELEGATION', 'delegation contains an invalid relation key');
+            }
+            const subject = buildAuthSubject({
+                selfAid: taskAid,
+                actorId: delegation.grant.actorId,
+                channel: delegation.grant.channel,
+                channelType: delegation.grant.channelType,
+                channelId: conversationId,
+                chatType: delegation.grant.chatType,
+                conversationId,
+                processOwners: loadDaemonConfig().owners ?? [],
+            });
+            const decision = authorizeOperation({
+                source: 'agent-tool',
+                subject,
+                intent: {
+                    operation,
+                    scope: operation === 'agent.show'
+                        ? 'agent'
+                        : operation === 'agent.reload' && targetAid
+                            ? 'agent'
+                            : 'control',
+                    source: 'agent-tool',
+                    args: {
+                        self: taskAid,
+                        aid: targetAid ?? taskAid,
+                        taskAgentAid: taskAid,
+                        targetAgentAid: targetAid ?? taskAid,
+                    },
+                },
+                auditMetadata: { taskId: delegation.grant.taskId, messageId: delegation.grant.messageId },
+            });
+            if (!decision.allow) {
+                const reasonCode = decision.command?.reasonCode;
+                return fail(decision.code, decision.reason, reasonCode);
+            }
+            const { execAgentAction, execAgentOptions, execAgentQuery } = await import('./core/command/agent-control.js');
+            if (operation === 'agent.list') {
+                const result = await execAgentOptions({ options: 'all' });
+                if ('error' in result)
+                    return fail(result.code, result.error);
+                const agents = Array.isArray(result.data?.agents) ? result.data.agents.map((agent) => ({
+                    aid: agent.aid,
+                    name: agent.name,
+                    personalName: agent.personalName ?? null,
+                    status: agent.status,
+                    channels: Array.isArray(agent.channels) ? agent.channels : [],
+                    projectPath: null,
+                    baseagent: agent.baseagent ?? null,
+                    model: agent.model ?? null,
+                    lastActivity: agent.lastActivity ?? null,
+                })) : [];
+                return { ok: true, result: { ok: true, agents, redacted: true } };
+            }
+            if (operation === 'agent.show') {
+                const result = await execAgentQuery({ aid: targetAid });
+                if ('error' in result)
+                    return fail(result.code, result.error);
+                const agent = result.data ?? {};
+                return { ok: true, result: {
+                        ok: true,
+                        aid: agent.aid,
+                        status: agent.status,
+                        identity: agent.identity ?? { name: null, description: null },
+                        config: {
+                            baseagent: agent.config?.baseagent ?? null,
+                            model: agent.config?.model ?? null,
+                            effort: agent.config?.effort ?? null,
+                            chatmode: agent.config?.chatmode ?? null,
+                            channels: Array.isArray(agent.config?.channels) ? agent.config.channels : [],
+                        },
+                        connection: agent.connection ?? null,
+                        sessions: agent.sessions ?? { active: 0, last_activity: null },
+                        paths: { config: null, agent_md: null, project: null, data: null },
+                        redacted: true,
+                        ...(agent.createProgress ? { createProgress: agent.createProgress } : {}),
+                    } };
+            }
+            if (operation === 'agent.create') {
+                const aid = argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined;
+                if (!aid)
+                    return fail('INVALID_ARGS', 'ec agent new requires an AID');
+                const { agentCreateNonInteractive, resolveAgentCreatePlan, validateAgentCreatePlan } = await import('./cli/agent.js');
+                const plan = resolveAgentCreatePlan({
+                    aid,
+                    project: value('--project'),
+                    baseagent: value('--baseagent'),
+                    owner: value('--owner'),
+                    name: value('--name'),
+                    description: value('--description'),
+                    force: argv.includes('--force'),
+                });
+                const validationError = validateAgentCreatePlan(plan);
+                if (validationError)
+                    return fail('INVALID_ARGS', validationError);
+                if (argv.includes('--dry-run'))
+                    return { ok: true, result: { ok: true, dryRun: true, plan } };
+                const result = await agentCreateNonInteractive({
+                    aid: plan.aid,
+                    project: plan.project,
+                    baseagent: plan.baseagent,
+                    owner: plan.owner,
+                    name: plan.name,
+                    description: plan.description,
+                    force: argv.includes('--force'),
+                });
+                return !result.ok
+                    ? fail(result.code ?? 'INTERNAL', result.error)
+                    : { ok: true, result: { ...result, configPath: '[redacted]' } };
+            }
+            if (operation === 'agent.delete') {
+                const { agentDelete } = await import('./cli/agent.js');
+                const result = await agentDelete(targetAid ?? '', argv.includes('--purge'));
+                return 'error' in result ? fail(result.code ?? 'INTERNAL', result.error) : { ok: true, result };
+            }
+            if (operation === 'agent.reload' && !targetAid) {
+                const { agentReload } = await import('./cli/agent.js');
+                const result = await agentReload();
+                return !result.ok ? fail(result.code ?? 'INTERNAL', result.error) : { ok: true, result };
+            }
+            const result = await execAgentAction(sub, { aid: targetAid ?? taskAid, force: argv.includes('--force') }, delegation.grant.actorId, eventBus);
+            return 'error' in result ? fail(result.code, result.error) : { ok: true, result: { ok: true, ...(result.data ?? {}) } };
+        });
         ipcServer.setQueueOperationExecutor(async (params) => {
             const operation = `ec.queue.${params.action ?? 'read'}`;
             const authorization = await authorizeManagedAgentOperation(params, operation);
@@ -3416,17 +3701,14 @@ async function main() {
                 const isCrossAgent = !actor.control && actor.selfAid !== agentAid;
                 if (!isCrossAgentTriggerOperationAllowed({
                     control: actor.control,
+                    daemonOwner: actor.daemonOwner,
                     taskAgentAid: actor.selfAid,
                     targetAgentAid: agentAid,
                     targetManagement: actor.management,
                     operation,
                 })) {
-                    if (isCrossAgent && !actor.management) {
-                        throw new Error('cross-agent trigger audit requires owner/admin access on the target agent');
-                    }
-                    if (isCrossAgent && !isCrossAgentTriggerReadOperation(operation)) {
-                        throw new Error('cross-agent trigger operations are limited to list, show, and history');
-                    }
+                    if (isCrossAgent)
+                        throw new Error('cross-agent Trigger operations require DaemonOwner');
                     throw new Error('trigger agent does not match authenticated task agent');
                 }
                 const operationDecision = authorizeOperation({
@@ -3438,6 +3720,8 @@ async function main() {
                         source: actor.control ? 'control' : 'agent-tool',
                         args: {
                             self: agentAid,
+                            taskAgentAid: actor.selfAid,
+                            targetAgentAid: agentAid,
                             peer: actor.origin.peerId,
                             peerKey: actor.subject.peerKey,
                             ...(triggerId ? { triggerId } : {}),
@@ -3446,11 +3730,15 @@ async function main() {
                 });
                 if (!operationDecision.allow)
                     throw new Error(operationDecision.reason);
-                if (actor.management)
-                    return actor;
                 if (!triggerId)
                     return actor;
                 const definition = schedulerFor(agentAid).list({ all: true }).find(trigger => trigger.id === triggerId);
+                const privilegedReason = definition ? daemonPrivilegedTriggerReason(definition) : undefined;
+                if (privilegedReason && !actor.daemonPrivileged) {
+                    throw new Error(`${privilegedReason} requires DaemonOwner`);
+                }
+                if (actor.management)
+                    return actor;
                 if (!definition
                     || definition.origin?.peerId !== actor.origin?.peerId
                     || definition.origin?.channelKey !== actor.origin?.channelKey) {
@@ -3463,8 +3751,9 @@ async function main() {
                     const agentAid = requireAgent(cmd.agentAid);
                     const actor = await authorizeTrigger(agentAid, 'trigger.list');
                     const scheduler = schedulerFor(agentAid);
-                    const definitions = scheduler.list({ all: cmd.all === true }).filter(trigger => actor.management
-                        || (trigger.origin?.peerId === actor.origin?.peerId && trigger.origin?.channelKey === actor.origin?.channelKey));
+                    const definitions = scheduler.list({ all: cmd.all === true }).filter(trigger => ((actor.daemonPrivileged || !daemonPrivilegedTriggerReason(trigger))
+                        && (actor.management
+                            || (trigger.origin?.peerId === actor.origin?.peerId && trigger.origin?.channelKey === actor.origin?.channelKey))));
                     return { ok: true, triggers: scheduler.listItems(definitions) };
                 }
                 case 'trigger.show': {
@@ -3487,16 +3776,28 @@ async function main() {
                     if (cmd.triggerId !== undefined && (typeof cmd.triggerId !== 'string' || !cmd.triggerId)) {
                         throw new Error('invalid triggerId');
                     }
+                    let actor;
                     if (cmd.triggerId)
                         await authorizeTrigger(agentAid, 'trigger.history', cmd.triggerId);
-                    else if (!(await authorizeTrigger(agentAid, 'trigger.history')).management) {
+                    else
+                        actor = await authorizeTrigger(agentAid, 'trigger.history');
+                    if (!cmd.triggerId && !actor?.management) {
                         throw new Error('triggerId is required for non-management history access');
                     }
-                    return { ok: true, events: schedulerFor(agentAid).history(cmd.triggerId, limit) };
+                    const events = schedulerFor(agentAid).history(cmd.triggerId, limit);
+                    if (cmd.triggerId || actor?.daemonPrivileged)
+                        return { ok: true, events };
+                    const privilegedIds = new Set(schedulerFor(agentAid).list({ all: true })
+                        .filter(trigger => !!daemonPrivilegedTriggerReason(trigger))
+                        .map(trigger => trigger.id));
+                    return { ok: true, events: events.filter((event) => !privilegedIds.has(String(event.triggerId ?? ''))) };
                 }
                 case 'trigger.eventCatalog': {
                     const agentAid = requireAgent(cmd.agentAid);
-                    await authorizeTrigger(agentAid, 'trigger.eventCatalog');
+                    const actor = await authorizeTrigger(agentAid, 'trigger.eventCatalog');
+                    if (cmd.includeInternal === true && !actor.daemonPrivileged) {
+                        throw new Error('internal Trigger event catalog requires DaemonOwner');
+                    }
                     return { ok: true, ...getEventCatalog({ includeInternal: cmd.includeInternal === true }) };
                 }
                 case 'trigger.create': {
@@ -3597,7 +3898,7 @@ async function main() {
     // 优雅关闭
     let shutdownSignal = 'unknown';
     let shutdownInProgress = false;
-    const shutdown = async (signal) => {
+    shutdown = async (signal) => {
         if (shutdownInProgress)
             return;
         shutdownInProgress = true;
@@ -3608,6 +3909,10 @@ async function main() {
         logger.info(`\n\nShutting down gracefully... (signal=${shutdownSignal}, pid=${pid}, ppid=${ppid})`);
         ipcServer.stopCpuTracking();
         ipcServer.stop();
+        try {
+            fs.unlinkSync(readySignalPath);
+        }
+        catch { }
         bindService?.stopCleanup();
         // 必须在第一个 await 之前同步冻结 active batch、发布 task:interrupted，
         // 否则 handler continuation 可能先提交完成并清掉待恢复的主消息。
@@ -3664,6 +3969,10 @@ async function main() {
             process.exit(0);
         }
     };
+    if (pendingShutdownReason) {
+        const reason = pendingShutdownReason;
+        setImmediate(() => { void shutdown?.(reason); });
+    }
     process.on('SIGINT', () => shutdown('SIGINT'));
     process.on('SIGTERM', () => shutdown('SIGTERM'));
     // 全局错误处理：防止未捕获的 WebSocket 错误导致进程崩溃