evolcore 0.0.29 → 0.0.30

package/dist/ipc.js

@@ -1556,7 +1556,7 @@ export class IpcServer {
                     const ownerAid = taskCtx.selfAid
                         ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.owners?.[0]
                         : undefined;
-                    const { launchConsolidation } = await import('./core/memory/launch-consolidation.js');
+                    const { launchConsolidation } = await import('./core/memory/consolidation.js');
                     if (!this.consolidationLaunchExecutor) {
                         // daemon 未注入 launcher —— 无法直接创建整理会话，明确报错而不是静默失败
                         return { ok: false, code: 'NOT_CONFIGURED', error: 'daemon 未注入整理会话 launcher' };
@@ -1868,6 +1868,7 @@ export class IpcServer {
             case 'trigger.show':
             case 'trigger.history':
             case 'trigger.eventCatalog':
+            case 'trigger.authorizeLocalFiles':
             case 'trigger.create':
             case 'trigger.update':
             case 'trigger.setEnabled':

package/dist/stats/db.js

@@ -69,6 +69,30 @@ export function getDb(evolcoreHome) {
         return null;
     }
 }
+export function startDailyRollupMaintenance(evolcoreHome) {
+    const db = getDb(evolcoreHome);
+    if (!db)
+        return undefined;
+    try {
+        const daily = db.prepare('SELECT COUNT(*) AS n FROM usage_daily').get();
+        const events = db.prepare('SELECT COUNT(*) AS n FROM usage_events').get();
+        if (daily.n === 0 && events.n > 0) {
+            logger.info('[Stats] usage_daily 为空，回填历史数据…');
+            rebuildDailyRollup(evolcoreHome);
+        }
+    }
+    catch (error) {
+        logger.warn(`[Stats] usage_daily 回填检测失败（非致命）: ${error}`);
+    }
+    return setInterval(() => {
+        try {
+            rebuildDailyRollup(evolcoreHome);
+        }
+        catch (error) {
+            logger.warn(`[Stats] usage_daily 自愈失败（非致命）: ${error}`);
+        }
+    }, 24 * 60 * 60 * 1000);
+}
 /** 只读连接（CLI / ecweb 调用）。每次返回新连接，调用方负责 close()。 */
 export function openReadonlyDb(dbPath) {
     const sqlite = loadSqlite();

package/dist/stats/index.js

@@ -3,7 +3,7 @@
  */
 export { getDb, openReadonlyDb, getStatsDir, getDbPath, closeStatsDb, archiveOldData, listArchivePaths, rebuildDailyRollup } from './db.js';
 export { normalizeUsage } from './normalizer.js';
-export { insertUsageEvent, insertContextBreakdown, insertMessageEvent, insertModelCalls } from './writer.js';
+export { initializeStatsPersistence, insertUsageEvent, insertContextBreakdown, insertMessageEvent, insertModelCalls } from './writer.js';
 export { calcCost, resolvePriceRow, resolveCanonicalModel, registerBillingFn } from './billing.js';
 export { queryAggregated, queryTodaySummary, querySessionTurns, queryContextBreakdown, queryTopPeers, queryTopModels, queryMessageAggregated, queryMessageTodaySummary, queryPeerList, querySummary, queryPeerDaily, queryTaskModelCalls, querySessionModelCalls } from './query.js';
 export { getBudgetStatus } from './budget.js';

package/dist/stats/writer.js

@@ -1,7 +1,7 @@
 /**
  * writer.ts — 写入 usage_events 和 context_breakdown。
  */
-import { getDb, resetStatsDb } from './db.js';
+import { getDb, resetStatsDb, startDailyRollupMaintenance } from './db.js';
 import { resolvePrices } from './price-resolver.js';
 import { logger } from '../utils/logger.js';
 export function insertUsageEvent(evolcoreHome, event, gatewayPricing) {
@@ -105,6 +105,30 @@ export function insertContextBreakdown(evolcoreHome, bd) {
         import('../utils/logger.js').then(({ logger }) => logger.warn(`[StatsWriter] insertContextBreakdown failed: ${e}`));
     }
 }
+export function initializeStatsPersistence(evolcoreHome, collector) {
+    const previousOnMessage = collector.onMessage;
+    const onMessage = (event) => {
+        void Promise.resolve()
+            .then(() => insertMessageEvent(evolcoreHome, event))
+            .catch(() => { });
+    };
+    collector.onMessage = onMessage;
+    let stopped = false;
+    let maintenanceTimer;
+    void Promise.resolve()
+        .then(() => {
+        if (!stopped)
+            maintenanceTimer = startDailyRollupMaintenance(evolcoreHome);
+    })
+        .catch(() => { });
+    return () => {
+        stopped = true;
+        if (collector.onMessage === onMessage)
+            collector.onMessage = previousOnMessage;
+        if (maintenanceTimer)
+            clearInterval(maintenanceTimer);
+    };
+}
 export function insertMessageEvent(evolcoreHome, event) {
     const db = getDb(evolcoreHome);
     if (!db)

package/dist/trigger/application-service.js

@@ -0,0 +1,157 @@
+import { consolidationCheckCron, removeConsolidationCheckTrigger, seedConsolidationCheckTrigger } from '../core/memory/consolidation-trigger.js';
+import { tryParseChannelKey } from '../core/channel-loader.js';
+import { TriggerDefinitionManager } from './manager.js';
+import { TriggerRunStateStore } from './state.js';
+import { removeLegacyAgentUpgradeCheck, seedSessionIdleCheckTrigger, seedTaskRecoveryTrigger, seedUpgradeCheckTrigger, } from './system-definitions.js';
+import { TriggerFeedbackDispatcher } from './feedback.js';
+import { TriggerRuntimeScheduler } from './scheduler.js';
+import { logger } from '../utils/logger.js';
+export class TriggerSchedulerRegistry {
+    schedulers = new Map();
+    starts = new Map();
+    get(agentAid) {
+        return this.schedulers.get(agentAid);
+    }
+    values() {
+        return this.schedulers.values();
+    }
+    async replace(agentAid, createScheduler) {
+        await this.schedulers.get(agentAid)?.stop();
+        const scheduler = createScheduler();
+        this.schedulers.set(agentAid, scheduler);
+        try {
+            await scheduler.init();
+        }
+        catch (error) {
+            logger.error(`[Trigger] Scheduler init failed for ${agentAid}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async ensureStarted(agentAid, start) {
+        const existing = this.starts.get(agentAid);
+        if (existing)
+            return await existing;
+        const starting = start();
+        this.starts.set(agentAid, starting);
+        try {
+            await starting;
+        }
+        catch (error) {
+            if (this.starts.get(agentAid) === starting)
+                this.starts.delete(agentAid);
+            throw error;
+        }
+    }
+    async remove(agentAid) {
+        await this.schedulers.get(agentAid)?.stop();
+        this.schedulers.delete(agentAid);
+        this.starts.delete(agentAid);
+    }
+    sessionIdleTriggerIds() {
+        return [...this.schedulers.values()].flatMap(scheduler => (scheduler.list({ all: true })
+            .filter(definition => definition.source.type === 'event' && definition.source.eventPattern === 'session:idle')
+            .map(definition => definition.id)));
+    }
+    async waitForIdle(timeoutMs) {
+        await Promise.all([...this.schedulers.values()].map(scheduler => scheduler.waitForIdle(timeoutMs)));
+    }
+    async suspendForDaemonExit() {
+        await Promise.all([...this.schedulers.values()].map(scheduler => scheduler.suspendForDaemonExit()));
+    }
+}
+export function createTriggerChannelResolver({ agentRegistry, channelInstances, daemonChannel, daemonTriggerOwner, }) {
+    return (agentAid, channelKey) => {
+        if (agentAid === daemonTriggerOwner.aid && channelKey === daemonChannel.channelKey) {
+            return { adapter: daemonChannel, agentAid, agentName: daemonTriggerOwner.aid, projectPath: daemonTriggerOwner.projectPath, baseagent: daemonTriggerOwner.baseagent };
+        }
+        const agent = agentRegistry.get(agentAid);
+        if (!agent)
+            return undefined;
+        const instance = channelInstances.find(candidate => candidate.adapter.channelKey === channelKey || candidate.adapter.channelName === channelKey);
+        const parsed = instance ? tryParseChannelKey(instance.adapter.channelKey) : null;
+        if (instance && parsed?.selfAID !== agentAid)
+            return undefined;
+        if (!instance)
+            return undefined;
+        return { adapter: instance.adapter, agentAid, agentName: agent.aid, projectPath: agent.projectPath, baseagent: agent.baseagent };
+    };
+}
+export function buildTriggerScheduler(owner, dependencies, options = {}) {
+    const manager = new TriggerDefinitionManager(owner.aid);
+    if (options.seedUpgradeCheck) {
+        seedUpgradeCheckTrigger(manager, owner);
+        seedTaskRecoveryTrigger(manager, owner);
+        seedSessionIdleCheckTrigger(manager, owner);
+    }
+    else {
+        removeLegacyAgentUpgradeCheck(manager);
+    }
+    const memoryConfig = dependencies.getMemoryConfig(owner.aid);
+    if (memoryConfig?.enableRelation !== false) {
+        seedConsolidationCheckTrigger(manager, {
+            aid: owner.aid,
+            cronExpression: consolidationCheckCron(memoryConfig?.checkIntervalHours),
+        });
+    }
+    else {
+        removeConsolidationCheckTrigger(manager);
+    }
+    const state = new TriggerRunStateStore(manager);
+    const agentTriggerAudit = dependencies.triggerAudit.withHistory(manager.history);
+    const dispatcher = new TriggerFeedbackDispatcher({
+        getChannel: dependencies.getTriggerChannel,
+        sessionManager: dependencies.sessionManager,
+        messageQueue: dependencies.messageQueue,
+        recoverTask: request => dependencies.responseEngine.recoverTask(request),
+        inspectTargetExecution: (sessionId, attemptId, selfAid) => (dependencies.responseEngine.inspectTargetExecution(sessionId, attemptId, selfAid)),
+        eventBus: dependencies.eventBus,
+        tryHandoff: async (input, text, target, binding) => {
+            if (input.signal?.aborted) {
+                throw input.signal.reason instanceof Error ? input.signal.reason : new Error('trigger feedback cancelled');
+            }
+            if (tryParseChannelKey(target.channelKey)?.type !== 'aun')
+                return null;
+            const inst = dependencies.channelInstances.find(candidate => (candidate.channelType === 'aun'
+                && (candidate.adapter.channelKey === target.channelKey || candidate.adapter.channelName === target.channelKey)
+                && tryParseChannelKey(candidate.adapter.channelKey)?.selfAID === input.trigger.agentAid));
+            const channel = inst?.channel;
+            if (!channel)
+                return null;
+            const targetChatType = target.chatType;
+            if (!targetChatType)
+                return null;
+            if (targetChatType === 'group' && typeof channel.sendDaemonGroupMsg !== 'function')
+                return null;
+            if (targetChatType === 'private' && typeof channel.sendDaemonMsg !== 'function')
+                return null;
+            const originSession = await dependencies.daemonChannel.getOrCreateConversationSession(input.trigger, binding.projectPath, binding.baseagent || owner.baseagent, input.runId);
+            if (input.signal?.aborted) {
+                throw input.signal.reason instanceof Error ? input.signal.reason : new Error('trigger feedback cancelled');
+            }
+            const payload = { type: 'text', text };
+            if (target.session === 'thread' && target.threadId)
+                payload.thread_id = target.threadId;
+            const created = await dependencies.handoffRuntime.createOutbound({
+                selfAid: input.trigger.agentAid,
+                to: target.channelId,
+                originSessionId: originSession.id,
+                originMessageId: input.runId,
+                payload,
+                encrypt: typeof channel.getDefaultEncrypt === 'function' ? channel.getDefaultEncrypt() : true,
+                thread: target.session === 'thread' ? target.threadId : undefined,
+                targetChatType,
+                explicitReturnPolicy: 'none',
+                causation: input.causation,
+                signal: input.signal,
+            });
+            return created.crossSession && created.handoff
+                ? { handoffId: created.handoff.handoff_id, targetSessionId: created.targetSession.id }
+                : null;
+        },
+    });
+    return new TriggerRuntimeScheduler(manager, state, agentTriggerAudit, dependencies.triggerScriptExecutor, dispatcher, dependencies.daemonChannel, {
+        projectPath: owner.projectPath,
+        baseagent: owner.baseagent,
+        getBaseagent: () => dependencies.getBaseagent?.(owner.aid) || owner.baseagent,
+        authorizeExecution: dependencies.authorizeExecution,
+    }, dependencies.eventBus, dependencies.targetSessionLocks);
+}

package/dist/trigger/authorization.js

@@ -0,0 +1,371 @@
+import crypto from 'crypto';
+import { eventPatternIncludesInternal } from '../core/event-catalog.js';
+import { trustedExecutionIdentityInput } from '../core/auth/agent-delegation.js';
+import { authorizeOperation, buildAuthSubject } from '../core/auth/auth-gateway.js';
+import { isManagementRole } from '../config/builtin-roles.js';
+import { checkRoleAccess, resolvePeerRoleDetail, roleToSessionIdentity } from '../config/peer-role-resolver.js';
+import { validateModelSelectionForRole } from '../core/model/model-permission.js';
+import { isValidAunDeliveryForChannel } from '../core/message/outbound.js';
+import { tryParseChannelKey } from '../core/channel-loader.js';
+import { constrainRuntimePermissionMode, validateRuntimeStringFieldOverride, } from '../core/role/runtime-policy.js';
+export function originFromActorSession(session, authenticatedPeerId, authenticatedChannelKey, authenticatedChatType) {
+    const peerId = authenticatedPeerId || session.metadata?.peerId;
+    if (!peerId)
+        return undefined;
+    const sessionChannelKey = session.metadata?.channelKey || session.channel;
+    const channelKey = authenticatedChannelKey || sessionChannelKey;
+    const sameConversation = channelKey === sessionChannelKey;
+    const isGroup = authenticatedChatType === 'group' || session.chatType === 'group';
+    return {
+        channelKey,
+        channelType: session.channelType || tryParseChannelKey(channelKey)?.type || channelKey,
+        channelId: peerId,
+        session: sameConversation && !isGroup && session.threadId ? 'thread' : 'main',
+        threadId: sameConversation && !isGroup ? (session.threadId || undefined) : undefined,
+        peerId,
+        sessionKey: sameConversation && !isGroup ? session.sessionKey : undefined,
+        delivery: { chatType: 'private' },
+    };
+}
+export function daemonPrivilegedTriggerReason(definition) {
+    if (definition.origin?.channelKey === 'daemon' || definition.origin?.channelType === 'daemon') {
+        return 'daemon/control-origin 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';
+    }
+    if (definition.execution.permissionMode === 'fullaccess')
+        return 'persistent fullaccess Trigger';
+    return undefined;
+}
+export function isScopedScriptTrigger(definition) {
+    return definition.execution.type === 'script'
+        && definition.origin?.channelKey !== 'daemon'
+        && definition.origin?.channelType !== 'daemon'
+        && definition.execution.permissionMode !== 'fullaccess';
+}
+export function assertTriggerLocalFileAuthority(actor) {
+    if (actor.permissionMode === 'readonly' && !actor.fullAccess && !actor.daemonPrivileged) {
+        throw new Error('readonly tasks cannot create or update Triggers');
+    }
+    if (actor.role !== 'owner' && !actor.daemonPrivileged) {
+        throw new Error('local Trigger file inputs require the current Agent owner');
+    }
+}
+export function validateTriggerFeedbackChannels(definition, getTriggerChannel) {
+    if (definition.feedback.strategy === 'silent' || definition.feedback.strategy === 'event_session')
+        return;
+    const target = definition.feedback.strategy === 'target'
+        ? definition.feedback.target
+        : definition.origin;
+    if (target && !getTriggerChannel(definition.agentAid, target.channelKey)) {
+        throw new Error(`agent ${definition.agentAid} has no configured channel ${target.channelKey}`);
+    }
+    const channelType = tryParseChannelKey(target?.channelKey ?? '')?.type
+        ?? (target?.channelKey?.split('#', 1)[0] || undefined);
+    const validAunRoute = definition.feedback.strategy === 'target'
+        ? definition.feedback.target?.chatType === 'private' || definition.feedback.target?.chatType === 'group'
+        : !!definition.origin && isValidAunDeliveryForChannel(definition.origin.delivery, definition.origin.channelId);
+    if (target && channelType === 'aun' && !validAunRoute) {
+        throw Object.assign(new Error('AUN trigger feedback target requires a valid explicit delivery route'), { code: 'AUN_OUTBOUND_ROUTE_REQUIRED' });
+    }
+}
+export function hasDaemonTriggerAuthority(subject) {
+    return subject.isDaemonOwner || subject.processRole === 'daemon-service' || subject.dataScope === 'daemon';
+}
+export function validateTriggerDefinitionForActor(definition, actor, dependencies) {
+    if (definition.execution.permissionMode === 'fullaccess') {
+        if (!actor.daemonOwner && !actor.fullAccess) {
+            throw new Error('persistent fullaccess Trigger requires DaemonOwner or fullaccess-run');
+        }
+    }
+    const privilegedReason = daemonPrivilegedTriggerReason(definition);
+    if (privilegedReason && !actor.daemonPrivileged)
+        throw new Error(`${privilegedReason} requires DaemonOwner`);
+    if (isScopedScriptTrigger(definition) && actor.role !== 'owner' && !actor.daemonPrivileged) {
+        throw new Error('Agent-scoped script Triggers require the current Agent owner');
+    }
+    if (definition.execution.permissionMode && !actor.daemonPrivileged) {
+        const permissionDecision = constrainRuntimePermissionMode({
+            selfAid: definition.agentAid,
+            role: actor.role,
+            requestedValue: definition.execution.permissionMode,
+        });
+        if (permissionDecision.constrained) {
+            throw new Error(`trigger permissionMode ${definition.execution.permissionMode} exceeds current role ${actor.role}`);
+        }
+    }
+    if (definition.execution.model && !actor.daemonPrivileged) {
+        const agent = dependencies.getAgent(definition.agentAid);
+        const modelDecision = validateModelSelectionForRole({
+            role: actor.role,
+            baseagent: definition.execution.baseagent ?? agent?.baseagent,
+            requestedModel: definition.execution.model,
+            selfAid: definition.agentAid,
+        });
+        if (!modelDecision.ok)
+            throw new Error(modelDecision.message || 'trigger model is not allowed by current role');
+    }
+    if (definition.execution.effort && !actor.daemonPrivileged) {
+        const baseagent = definition.execution.baseagent
+            ?? dependencies.getAgent(definition.agentAid)?.baseagent;
+        if (!baseagent)
+            throw new Error('cannot determine Trigger baseagent');
+        const effortDecision = validateRuntimeStringFieldOverride({
+            selfAid: definition.agentAid,
+            role: actor.role,
+            field: `baseagents.${baseagent}.effort`,
+            value: definition.execution.effort,
+        });
+        if (!effortDecision.ok)
+            throw new Error(effortDecision.message || 'trigger effort is not allowed by current role');
+    }
+    if (!actor.management && definition.feedback.strategy === 'event_session') {
+        throw new Error('event-session feedback requires owner/admin');
+    }
+    if (!actor.management && definition.feedback.strategy === 'target') {
+        const target = definition.feedback.target;
+        const origin = actor.origin;
+        if (!target || !origin
+            || target.channelKey !== origin.channelKey
+            || target.channelId !== origin.channelId
+            || target.session !== origin.session
+            || (target.threadId ?? '') !== (origin.threadId ?? '')) {
+            throw new Error('non-management trigger target must be the creator private conversation');
+        }
+    }
+}
+export function authorizeTriggerExecution(definition, dependencies) {
+    if (definition.execution.permissionMode === 'fullaccess') {
+        if (!definition.authorizedBy) {
+            return { allowed: false, reason: 'fullaccess Trigger approval provenance is missing' };
+        }
+        const owners = new Set(dependencies.getDaemonOwners());
+        if (!owners.has(definition.authorizedBy)) {
+            return { allowed: false, reason: 'fullaccess Trigger approver is no longer a current daemon-owner' };
+        }
+    }
+    const origin = definition.origin;
+    if (!origin?.peerId)
+        return { allowed: false, reason: 'trigger origin peer is missing' };
+    if (definition.execution.permissionMode === 'fullaccess') {
+        return { allowed: true, scope: 'daemon', permissionMode: 'fullaccess' };
+    }
+    if (origin.channelKey === 'daemon') {
+        const subject = buildAuthSubject({
+            selfAid: definition.agentAid,
+            actorId: origin.peerId,
+            channel: origin.channelKey,
+            channelType: origin.channelType || 'daemon',
+            channelId: origin.channelId,
+            chatType: 'private',
+            conversationId: origin.peerId,
+            trustedProcessRole: 'daemon-service',
+            fromControlChannel: true,
+        });
+        const decision = authorizeOperation({
+            source: 'control',
+            subject,
+            intent: {
+                operation: 'trigger.run',
+                scope: 'relation',
+                source: 'control',
+                args: { self: definition.agentAid, peer: origin.peerId, peerKey: subject.peerKey, triggerId: definition.id },
+            },
+        });
+        return decision.allow
+            ? {
+                allowed: true,
+                scope: 'daemon',
+                permissionMode: definition.execution.permissionMode ?? 'bypass',
+            }
+            : { allowed: false, reason: decision.reason };
+    }
+    const channelType = origin.channelType || tryParseChannelKey(origin.channelKey)?.type;
+    if (!channelType)
+        return { allowed: false, reason: 'trigger origin channel type is missing' };
+    const roleDetail = resolvePeerRoleDetail({
+        selfAid: definition.agentAid,
+        channelKey: origin.channelKey,
+        channelType,
+        chatType: 'private',
+        actorId: origin.peerId,
+        conversationId: origin.peerId,
+    });
+    const role = roleDetail.effectiveRole;
+    if (!checkRoleAccess(role, definition.agentAid)) {
+        return { allowed: false, reason: `trigger creator no longer has access (role=${role ?? 'none'})` };
+    }
+    const subject = buildAuthSubject({
+        selfAid: definition.agentAid,
+        actorId: origin.peerId,
+        channel: origin.channelKey,
+        channelType,
+        channelId: origin.channelId,
+        chatType: 'private',
+        conversationId: origin.peerId,
+        roleDetail,
+        identity: roleToSessionIdentity(role),
+        processOwners: dependencies.getDaemonOwners(),
+        fromControlChannel: false,
+    });
+    const operationDecision = authorizeOperation({
+        source: 'agent-tool',
+        subject,
+        intent: {
+            operation: 'trigger.run',
+            scope: 'relation',
+            source: 'agent-tool',
+            args: { self: definition.agentAid, peer: origin.peerId, peerKey: subject.peerKey, triggerId: definition.id },
+        },
+    });
+    if (!operationDecision.allow)
+        return { allowed: false, reason: operationDecision.reason };
+    if (isScopedScriptTrigger(definition) && role !== 'owner' && !hasDaemonTriggerAuthority(subject)) {
+        return { allowed: false, reason: 'Agent-scoped script Trigger requires current Agent owner authority' };
+    }
+    const privilegedReason = daemonPrivilegedTriggerReason(definition);
+    const persistedFullAccessApproval = privilegedReason === 'persistent fullaccess Trigger';
+    if (privilegedReason && !persistedFullAccessApproval && !hasDaemonTriggerAuthority(subject)) {
+        return { allowed: false, reason: `${privilegedReason} requires current DaemonOwner` };
+    }
+    if (definition.feedback.strategy === 'event_session' && !isManagementRole(role)) {
+        return { allowed: false, reason: 'event-session feedback requires current owner/admin role' };
+    }
+    if (definition.feedback.strategy === 'target' && !isManagementRole(role)) {
+        const target = definition.feedback.target;
+        if (!target
+            || target.channelKey !== origin.channelKey
+            || target.channelId !== origin.channelId
+            || target.session !== origin.session
+            || (target.threadId ?? '') !== (origin.threadId ?? '')) {
+            return { allowed: false, reason: `cross-conversation target requires current owner/admin role (role=${role ?? 'none'})` };
+        }
+    }
+    const permissionDecision = constrainRuntimePermissionMode({
+        selfAid: definition.agentAid,
+        role,
+        requestedValue: definition.execution.permissionMode,
+    });
+    if (definition.execution.permissionMode && permissionDecision.constrained) {
+        return {
+            allowed: false,
+            reason: `trigger permissionMode ${definition.execution.permissionMode} exceeds current role ${role ?? 'none'}`,
+        };
+    }
+    return {
+        allowed: true,
+        scope: privilegedReason && hasDaemonTriggerAuthority(subject) ? 'daemon' : 'agent',
+        permissionMode: permissionDecision.effectiveValue,
+    };
+}
+export async function authenticatedTriggerActor(dependencies, agentAid, actorSessionId, delegationToken, delegationCommandHash, controlToken, contextOnly = false) {
+    if (typeof actorSessionId !== 'string' || !actorSessionId) {
+        const providedToken = typeof controlToken === 'string' ? Buffer.from(controlToken) : undefined;
+        const expectedToken = Buffer.from(dependencies.triggerControlToken);
+        if (!providedToken
+            || providedToken.length !== expectedToken.length
+            || !crypto.timingSafeEqual(providedToken, expectedToken)) {
+            throw new Error('valid local control token is required');
+        }
+        const origin = {
+            channelKey: 'daemon',
+            channelType: 'daemon',
+            channelId: dependencies.daemonTriggerOwner.originPeerId,
+            session: 'main',
+            peerId: dependencies.daemonTriggerOwner.originPeerId,
+            sessionKey: `daemon#${dependencies.daemonTriggerOwner.originPeerId}#__control__`,
+        };
+        const subject = buildAuthSubject({
+            selfAid: agentAid,
+            actorId: origin.peerId,
+            channel: origin.channelKey,
+            channelType: origin.channelType,
+            channelId: origin.channelId,
+            chatType: 'private',
+            conversationId: origin.peerId,
+            trustedProcessRole: 'daemon-service',
+            fromControlChannel: true,
+        });
+        return {
+            origin,
+            management: true,
+            daemonOwner: false,
+            daemonPrivileged: true,
+            fullAccess: false,
+            control: true,
+            role: 'none',
+            subject,
+        };
+    }
+    const validation = (contextOnly
+        ? dependencies.agentDelegationRegistry.validateForContext.bind(dependencies.agentDelegationRegistry)
+        : dependencies.agentDelegationRegistry.validate.bind(dependencies.agentDelegationRegistry))(typeof delegationToken === 'string' ? delegationToken : undefined, actorSessionId, typeof delegationCommandHash === 'string' ? delegationCommandHash : undefined);
+    if (!validation.ok)
+        throw new Error(validation.reason);
+    const actorSession = await dependencies.sessionManager.getSessionById(actorSessionId);
+    const actorOrigin = actorSession ? originFromActorSession(actorSession, validation.grant.actorId, validation.grant.channel, validation.grant.chatType) : undefined;
+    if (!actorSession || !actorOrigin?.peerId)
+        throw new Error('trigger actor session has no authenticated peer');
+    if (validation.grant.actorId !== actorOrigin.peerId) {
+        throw new Error('trigger delegation actor does not match session peer');
+    }
+    const roleDetail = resolvePeerRoleDetail({
+        selfAid: agentAid,
+        channelKey: validation.grant.channel,
+        channelType: validation.grant.channelType,
+        chatType: 'private',
+        actorId: validation.grant.actorId,
+        conversationId: validation.grant.actorId,
+    });
+    const currentRole = roleDetail.effectiveRole;
+    const subject = buildAuthSubject({
+        selfAid: agentAid,
+        actorId: validation.grant.actorId,
+        channel: validation.grant.channel,
+        channelType: validation.grant.channelType,
+        channelId: actorOrigin.channelId,
+        chatType: 'private',
+        conversationId: validation.grant.actorId,
+        roleDetail,
+        identity: roleToSessionIdentity(currentRole),
+        processOwners: dependencies.getDaemonOwners(),
+        fromControlChannel: false,
+        ...trustedExecutionIdentityInput(validation.grant),
+    });
+    if (validation.grant.selfAid !== agentAid && subject.dataScope !== 'daemon') {
+        throw new Error('cross-agent Trigger operations require DaemonOwner');
+    }
+    if (subject.dataScope !== 'daemon' && !checkRoleAccess(currentRole, agentAid)) {
+        throw new Error('trigger actor no longer has access to this agent');
+    }
+    const permissionDecision = subject.processRole === 'fullaccess-run'
+        ? { effectiveValue: 'fullaccess' }
+        : subject.dataScope === 'daemon'
+            ? { effectiveValue: validation.grant.permissionMode ?? subject.permissionMode ?? 'bypass' }
+            : constrainRuntimePermissionMode({
+                selfAid: agentAid,
+                role: currentRole,
+                requestedValue: validation.grant.permissionMode ?? subject.permissionMode,
+            });
+    if (subject.processRole === 'fullaccess-run'
+        && (!subject.authorizedBy || !dependencies.getDaemonOwners().includes(subject.authorizedBy))) {
+        throw new Error('fullaccess Trigger caller approval is no longer owned');
+    }
+    return {
+        origin: actorOrigin,
+        management: isManagementRole(currentRole) || subject.dataScope === 'daemon',
+        daemonOwner: subject.isDaemonOwner,
+        daemonPrivileged: subject.isDaemonOwner || subject.dataScope === 'daemon',
+        fullAccess: subject.processRole === 'fullaccess-run',
+        selfAid: validation.grant.selfAid,
+        control: false,
+        role: currentRole || 'none',
+        subject,
+        permissionMode: permissionDecision.effectiveValue,
+        sessionRuntimeDir: validation.grant.sessionRuntimeDir,
+    };
+}