evolcore 0.0.1 → 0.0.2

package/dist/trigger/scheduler.js

@@ -0,0 +1,1600 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import { CronExpressionParser } from 'cron-parser';
+import { logger } from '../utils/logger.js';
+import { matchTriggerEvent, TriggerEventSource } from './event-source.js';
+import { definitionRevision, parseDurationMs, previewText, renderTemplate, resolveScriptPath, sha256, } from './validation.js';
+import { enterTrigger, formatTriggerPath } from '../core/causation/context.js';
+import { createRootCausation } from '../core/causation/context.js';
+import { recordCausationSpan } from '../core/causation/audit.js';
+import { accumulateTriggerExecutionAnomalies, drainTriggerExecutionAnomalies, mergeTriggerExecutionAnomalies, } from './anomaly-store.js';
+const MAX_TIMER_MS = 2_147_483_647;
+const RUN_ABORT_SETTLE_GRACE_MS = 1_000;
+const RUN_COMPLETION_BARRIER_MS = 1_500;
+export class TriggerRuntimeScheduler {
+    manager;
+    state;
+    audit;
+    scriptExecutor;
+    feedback;
+    daemonChannel;
+    runtime;
+    eventBus;
+    timers = new Map();
+    running = new Map();
+    runStartLocks = new Map();
+    eventSource;
+    initialized = false;
+    stopping = false;
+    constructor(manager, state, audit, scriptExecutor, feedback, daemonChannel, runtime, eventBus) {
+        this.manager = manager;
+        this.state = state;
+        this.audit = audit;
+        this.scriptExecutor = scriptExecutor;
+        this.feedback = feedback;
+        this.daemonChannel = daemonChannel;
+        this.runtime = runtime;
+        this.eventBus = eventBus;
+        if (eventBus) {
+            this.eventSource = new TriggerEventSource(eventBus, (triggerId, event) => {
+                void this.fireEventTrigger(triggerId, event);
+            });
+        }
+    }
+    async init() {
+        await this.stop();
+        this.stopping = false;
+        await this.recoverOpenRuns();
+        for (const definition of this.manager.list()) {
+            this.schedule(definition);
+        }
+        this.initialized = true;
+        logger.info(`[Trigger] scheduler initialized for ${this.manager.agentAid}`);
+    }
+    async stop() {
+        this.stopping = true;
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+        this.eventSource?.stop();
+        const settlements = [];
+        for (const runs of Array.from(this.running.values())) {
+            for (const [runId, runtime] of Array.from(runs.entries())) {
+                settlements.push(this.terminateRun(runId, runtime, {
+                    reason: 'stopped',
+                    message: 'trigger scheduler stopped',
+                }));
+            }
+        }
+        settlements.push(...this.runStartLocks.values());
+        this.initialized = false;
+        await Promise.all(settlements);
+    }
+    async waitForIdle(timeoutMs = 5_000) {
+        const deadline = Date.now() + timeoutMs;
+        while ((this.running.size > 0 || this.runStartLocks.size > 0) && Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        return this.running.size === 0 && this.runStartLocks.size === 0;
+    }
+    list(opts = {}) {
+        return this.manager.list(opts);
+    }
+    listItems(definitions) {
+        const latestRuns = this.audit.latest(definitions.map(definition => definition.id));
+        return definitions.map(definition => this.buildListItem(definition, latestRuns.get(definition.id)));
+    }
+    listItem(definition) {
+        return this.buildListItem(definition, this.audit.recent(definition.id, 1)[0]);
+    }
+    buildListItem(definition, lastRun) {
+        const schedule = this.state.readSchedule(definition.id);
+        return {
+            id: definition.id,
+            name: definition.name,
+            enabled: definition.enabled,
+            ...(definition.description ? { description: definition.description } : {}),
+            source: summarizeListSource(definition.source),
+            execution: { type: definition.execution.type },
+            feedback: {
+                strategy: definition.feedback.strategy,
+                ...(definition.feedback.target ? { target: definition.feedback.target } : {}),
+            },
+            ...(schedule ? { nextFireAt: schedule.nextFireAt } : {}),
+            ...(lastRun ? { lastStatus: lastRun.status, lastFinishedAt: lastRun.finishedAt } : {}),
+            updatedAt: definition.updatedAt,
+        };
+    }
+    show(triggerId, opts = {}) {
+        const definition = this.manager.require(triggerId);
+        const schedule = this.state.readSchedule(triggerId);
+        return {
+            definition,
+            revision: definitionRevision(definition),
+            active: this.state.list(triggerId).map(run => ({
+                phase: run.phase,
+                triggerId: run.triggerId,
+                runId: run.runId,
+                startedAt: run.startedAt,
+                ...(run.deadlineAt !== undefined ? { deadlineAt: run.deadlineAt } : {}),
+                eventCount: run.events.length,
+            })),
+            ...(schedule ? {
+                schedule: {
+                    nextFireAt: schedule.nextFireAt,
+                    updatedAt: schedule.updatedAt,
+                    ...(schedule.lastScheduledAt !== undefined ? { lastScheduledAt: schedule.lastScheduledAt } : {}),
+                    ...(schedule.lastFiredAt !== undefined ? { lastFiredAt: schedule.lastFiredAt } : {}),
+                },
+            } : {}),
+            limitState: this.state.readLimitState(triggerId),
+            recentRuns: this.audit.recent(triggerId, 10).map(run => ({
+                runId: run.runId,
+                status: run.status,
+                ...(run.reason ? { reason: run.reason } : {}),
+                startedAt: run.startedAt,
+                finishedAt: run.finishedAt,
+                durationMs: Math.max(0, run.finishedAt - run.startedAt),
+                ...(run.error?.code ? { errorCode: run.error.code } : {}),
+            })),
+            ...(opts.includeScriptPreview === false ? {} : { scriptPreview: this.scriptPreview(definition) }),
+            subscription: this.subscriptionInfo(definition),
+        };
+    }
+    history(triggerId, limit = 100) {
+        return this.manager.history.events(triggerId, limit);
+    }
+    scriptPreview(definition) {
+        if (definition.execution.type !== 'script' || !definition.execution.script)
+            return undefined;
+        const script = definition.execution.script;
+        const preview = {
+            path: script.path,
+            runtime: script.runtime,
+        };
+        try {
+            const stat = fs.statSync(resolveScriptPath(this.manager.triggerDir(definition.id), script.path));
+            if (!stat.isFile())
+                return { ...preview, error: 'script path is not a file' };
+            return { ...preview, sizeBytes: stat.size, mtime: stat.mtimeMs };
+        }
+        catch (err) {
+            return { ...preview, error: err?.message || String(err) };
+        }
+    }
+    stats(triggerId) {
+        const historyStats = this.audit.stats(triggerId);
+        const merged = this.manager.history.hasLegacyArchive(triggerId)
+            ? historyStats
+            : mergeStats(this.manager.legacyStats(triggerId), historyStats);
+        const schedule = this.state.readSchedule(triggerId);
+        return accountScheduleMarker(merged, schedule, skipped => this.audit.hasSkippedSchedule(triggerId, skipped));
+    }
+    create(input, files = [], opts = {}) {
+        const definition = this.manager.create(input, files, opts);
+        this.state.clearSchedule(definition.id);
+        if (!definition.limits)
+            this.state.clearLimitState(definition.id);
+        if (definition.enabled && this.initialized)
+            this.schedule(definition);
+        this.publishTriggerDefinitionEvent('trigger:registered', definition);
+        return definition;
+    }
+    update(triggerId, input, files = []) {
+        const previous = this.manager.get(triggerId);
+        const definition = this.manager.update(triggerId, input, files);
+        this.clearTimer(triggerId);
+        this.unregisterEvent(triggerId);
+        this.state.clearSchedule(triggerId);
+        if (!definition.limits) {
+            this.state.clearLimitState(triggerId);
+        }
+        else if (definition.enabled && limitsSignature(previous?.limits) !== limitsSignature(definition.limits)) {
+            this.state.resetLimitState(triggerId);
+        }
+        else if (definition.enabled) {
+            this.state.ensureLimitState(triggerId);
+        }
+        if (definition.enabled && this.initialized)
+            this.schedule(definition);
+        this.publishTriggerDefinitionEvent('trigger:updated', definition);
+        return definition;
+    }
+    setEnabled(triggerId, enabled) {
+        const definition = this.manager.setEnabled(triggerId, enabled);
+        this.clearTimer(triggerId);
+        this.unregisterEvent(triggerId);
+        this.state.clearSchedule(triggerId);
+        if (enabled && definition.limits)
+            this.state.resetLimitState(triggerId);
+        if (!definition.limits)
+            this.state.clearLimitState(triggerId);
+        if (definition.enabled && this.initialized)
+            this.schedule(definition);
+        return definition;
+    }
+    cancel(triggerId) {
+        return this.setEnabled(triggerId, false);
+    }
+    delete(triggerId) {
+        const definition = this.manager.require(triggerId);
+        this.clearTimer(triggerId);
+        this.unregisterEvent(triggerId);
+        this.state.clearSchedule(triggerId);
+        this.state.clearLimitState(triggerId);
+        return this.manager.delete(triggerId);
+    }
+    async run(triggerId, opts = {}) {
+        const definition = this.manager.require(triggerId);
+        const firedAt = Date.now();
+        let sourcePayload = this.sourcePayload(definition.source);
+        if (opts.eventPayload !== undefined) {
+            if (definition.source.type !== 'event') {
+                throw new Error('simulated event payload is only supported for Event Triggers');
+            }
+            if (!isRecord(opts.eventPayload)) {
+                throw new Error('simulated event payload must be a JSON object');
+            }
+            const match = matchTriggerEvent(definition.source, opts.eventPayload);
+            if (!match.matched) {
+                throw new Error(eventTestMatchError(match.reason, definition.source.eventPattern));
+            }
+            sourcePayload = opts.eventPayload;
+        }
+        if (!opts.dryRun) {
+            const disabledReason = this.limitDisabledReason(definition, firedAt);
+            if (disabledReason) {
+                const audit = this.disableForLimit(definition, undefined, firedAt, disabledReason);
+                return {
+                    ok: true,
+                    runId: audit.runId,
+                    triggerId: definition.id,
+                    status: 'skipped',
+                    reason: audit.reason,
+                    audit,
+                };
+            }
+        }
+        return await this.startRun(definition, {
+            firedAt,
+            payload: sourcePayload,
+            dryRun: opts.dryRun,
+        });
+    }
+    schedule(definition) {
+        this.clearTimer(definition.id);
+        this.unregisterEvent(definition.id);
+        if (definition.limits)
+            this.state.ensureLimitState(definition.id);
+        else
+            this.state.clearLimitState(definition.id);
+        if (definition.source.type === 'event') {
+            this.registerEvent(definition);
+            return;
+        }
+        const scheduledAt = this.resolveScheduledAt(definition);
+        if (scheduledAt === null) {
+            if (this.isOneShot(definition.source) && definition.reliability.missedPolicy === 'skip') {
+                this.writeSkippedAudit(definition, undefined, Date.now(), 'missed_skip');
+                this.setEnabled(definition.id, false);
+            }
+            return;
+        }
+        const now = Date.now();
+        if (this.isPeriodic(definition.source) && scheduledAt < now - 1000 && definition.reliability.missedPolicy === 'skip') {
+            this.writeSkippedAudit(definition, scheduledAt, now, 'missed_skip');
+            this.advancePeriodicSchedule(definition, scheduledAt, now);
+            this.schedule(definition);
+            return;
+        }
+        const rawDelay = Math.max(0, scheduledAt - Date.now());
+        const timer = setTimeout(() => {
+            this.timers.delete(definition.id);
+            if (scheduledAt - Date.now() > 1000) {
+                this.schedule(definition);
+                return;
+            }
+            void this.handleScheduledFire(definition.id, scheduledAt);
+        }, Math.min(MAX_TIMER_MS, rawDelay));
+        timer.unref?.();
+        this.timers.set(definition.id, timer);
+    }
+    async handleScheduledFire(triggerId, scheduledAt) {
+        const definition = this.manager.get(triggerId);
+        if (!definition?.enabled)
+            return;
+        const firedRevision = definitionRevision(definition);
+        const firedAt = Date.now();
+        if (this.isOneShot(definition.source) && scheduledAt < firedAt - 1000 && definition.reliability.missedPolicy === 'skip') {
+            this.writeSkippedAudit(definition, scheduledAt, firedAt, 'missed_skip');
+            this.setEnabled(definition.id, false);
+            return;
+        }
+        if (this.isPeriodic(definition.source)) {
+            if (scheduledAt < firedAt - 1000 && definition.reliability.missedPolicy === 'skip') {
+                this.writeSkippedAudit(definition, scheduledAt, firedAt, 'missed_skip');
+                this.advancePeriodicSchedule(definition, scheduledAt, firedAt);
+                this.schedule(definition);
+                return;
+            }
+            const disabledReason = this.limitDisabledReason(definition, firedAt);
+            if (disabledReason) {
+                this.disableForLimit(definition, scheduledAt, firedAt, disabledReason);
+                return;
+            }
+        }
+        else {
+            const disabledReason = this.limitDisabledReason(definition, firedAt);
+            if (disabledReason) {
+                this.disableForLimit(definition, scheduledAt, firedAt, disabledReason);
+                return;
+            }
+        }
+        const runPromise = this.startRun(definition, {
+            scheduledAt,
+            firedAt,
+            payload: this.sourcePayload(definition.source),
+        });
+        if (this.isPeriodic(definition.source)) {
+            this.advancePeriodicSchedule(definition, scheduledAt, firedAt);
+            this.schedule(definition);
+            await runPromise;
+            return;
+        }
+        await runPromise;
+        const fresh = this.manager.get(triggerId);
+        if (fresh?.enabled && definitionRevision(fresh) === firedRevision) {
+            this.setEnabled(triggerId, false);
+        }
+    }
+    async startRun(definition, payload) {
+        const firedAt = payload.firedAt;
+        const runId = `run_${firedAt}_${crypto.randomBytes(3).toString('hex')}`;
+        if (this.stopping) {
+            return { ok: false, runId, triggerId: definition.id, status: 'failed', reason: 'stopped' };
+        }
+        const source = this.buildSourceInfo(definition.source, firedAt, payload.scheduledAt, payload.payload);
+        const executionAuthorization = this.runtime.authorizeExecution?.(definition);
+        if (executionAuthorization && !executionAuthorization.allowed) {
+            const reason = executionAuthorization.reason || 'execution_authorization_denied';
+            const audit = this.buildAudit({
+                definition,
+                runId,
+                startedAt: firedAt,
+                status: 'failed',
+                reason: 'authorization_denied',
+                source,
+                script: null,
+                reply: null,
+                feedback: null,
+                effects: [],
+                error: { code: 'authorization_denied', message: reason },
+                causation: payload.causation,
+            });
+            if (!payload.dryRun) {
+                this.audit.write(audit);
+                this.publishTriggerRunOutcome(definition, audit);
+            }
+            logger.warn(`[Trigger] execution authorization denied: trigger=${definition.id} reason=${reason}`);
+            return { ok: false, runId, triggerId: definition.id, status: 'failed', reason: 'authorization_denied', audit, error: reason };
+        }
+        const entered = enterTrigger(payload.causation, definition.id, runId);
+        if (!entered.ok) {
+            const audit = this.buildAudit({
+                definition,
+                runId,
+                startedAt: firedAt,
+                status: 'skipped',
+                reason: entered.reason,
+                source,
+                script: null,
+                reply: null,
+                feedback: null,
+                effects: [],
+                error: null,
+                causation: payload.causation,
+            });
+            if (!payload.dryRun)
+                this.audit.write(audit);
+            logger.warn(`[Trigger] causation blocked: reason=${entered.reason} trace=${payload.causation?.traceId ?? '<none>'} chain=${formatTriggerPath(payload.causation, definition.id)}`);
+            return { ok: true, runId, triggerId: definition.id, status: 'skipped', reason: entered.reason, audit };
+        }
+        const causation = entered.causation;
+        const startedAt = Date.now();
+        const controller = new AbortController();
+        let script = null;
+        let processing = null;
+        let reply = null;
+        let executionAnomalies = [];
+        let runningRuntime;
+        let incomplete;
+        let settleCompletion;
+        const completion = new Promise(resolve => { settleCompletion = resolve; });
+        const activeRun = {
+            phase: 'running',
+            triggerId: definition.id,
+            runId,
+            startedAt,
+            events: [{ seq: 0, event: 'run.started', ts: startedAt }],
+        };
+        if (!payload.dryRun) {
+            const releaseStartLock = await this.acquireRunStartLock(definition.id);
+            try {
+                if (this.stopping) {
+                    return { ok: false, runId, triggerId: definition.id, status: 'failed', reason: 'stopped' };
+                }
+                if (definition.limits) {
+                    const disabledReason = this.limitDisabledReason(definition, firedAt);
+                    if (disabledReason) {
+                        const audit = this.disableForLimit(definition, payload.scheduledAt, firedAt, disabledReason);
+                        return {
+                            ok: true,
+                            runId: audit.runId,
+                            triggerId: definition.id,
+                            status: 'skipped',
+                            reason: audit.reason,
+                            audit,
+                        };
+                    }
+                }
+                const conflict = await this.checkConcurrency(definition, runId, source);
+                if (conflict)
+                    return conflict;
+                if (this.stopping) {
+                    return { ok: false, runId, triggerId: definition.id, status: 'failed', reason: 'stopped' };
+                }
+                recordCausationSpan(causation, 'trigger.run', { status: 'started', refs: { triggerId: definition.id, runId } });
+                runningRuntime = {
+                    run: activeRun,
+                    definition,
+                    source,
+                    causation,
+                    controller,
+                    completion,
+                    anomalies: executionAnomalies,
+                };
+                this.addRunning(definition.id, runId, runningRuntime);
+                this.state.upsert(definition.id, activeRun);
+                if (definition.limits)
+                    this.state.incrementLimitRunCount(definition.id);
+                this.publishTriggerFired(definition, runId, firedAt, causation);
+            }
+            finally {
+                releaseStartLock();
+            }
+        }
+        try {
+            const execution = await awaitWithAbortSettleGrace(this.runExecution(definition, runId, firedAt, source.payload, controller.signal, payload.dryRun === true, causation, anomalies => {
+                executionAnomalies = anomalies;
+                if (runningRuntime)
+                    runningRuntime.anomalies = anomalies;
+            }), controller.signal, RUN_ABORT_SETTLE_GRACE_MS, 'execution');
+            script = execution.script;
+            processing = execution.processing;
+            reply = execution.reply ?? null;
+            executionAnomalies = execution.anomalies ?? [];
+            if (runningRuntime)
+                runningRuntime.anomalies = executionAnomalies;
+            if (!payload.dryRun && controller.signal.aborted) {
+                const reason = triggerCancellationReason(controller.signal);
+                if (this.isRunning(definition.id, runId))
+                    this.finishRun(definition.id, runId);
+                return {
+                    ok: false,
+                    runId,
+                    triggerId: definition.id,
+                    status: 'failed',
+                    reason,
+                };
+            }
+            if (!payload.dryRun) {
+                const executionFailed = execution.reply
+                    ? shouldRetryExecution(execution.reply)
+                    : execution.feedbackResult?.status === 'failed';
+                this.state.appendEvent(definition.id, runId, {
+                    event: executionFailed ? 'execution.failed' : 'execution.completed',
+                    ts: Date.now(),
+                    mode: definition.execution.type,
+                    outcome: execution.reply?.outcome ?? execution.feedbackResult?.status,
+                    ...(executionAnomalies.length
+                        ? { anomalyCount: executionAnomalies.length }
+                        : {}),
+                    ...(script ? { exitCode: script.exitCode } : {}),
+                });
+                if (!execution.feedbackResult) {
+                    this.state.setPhase(definition.id, runId, 'feedback-pending', {
+                        deadlineAt: Date.now() + 30_000,
+                    });
+                    this.state.appendEvent(definition.id, runId, {
+                        event: 'feedback.pending',
+                        ts: Date.now(),
+                        branch: execution.branch,
+                    });
+                }
+            }
+            const feedbackResult = execution.feedbackResult ?? await awaitWithAbortSettleGrace(this.feedback.dispatch({
+                trigger: definition,
+                runId,
+                firedAt,
+                branch: execution.branch,
+                reply: execution.reply,
+                sourcePayload: source.payload,
+                dryRun: payload.dryRun,
+                causation,
+                signal: controller.signal,
+            }), controller.signal, RUN_ABORT_SETTLE_GRACE_MS, 'feedback');
+            if (!payload.dryRun && controller.signal.aborted) {
+                const reason = triggerCancellationReason(controller.signal);
+                if (this.isRunning(definition.id, runId))
+                    this.finishRun(definition.id, runId);
+                return {
+                    ok: false,
+                    runId,
+                    triggerId: definition.id,
+                    status: 'failed',
+                    reason,
+                };
+            }
+            const audit = this.buildAudit({
+                definition,
+                runId,
+                startedAt,
+                status: payload.dryRun
+                    ? 'dry-run'
+                    : statusWithExecutionAnomalies(feedbackResult.status, executionAnomalies),
+                reason: feedbackResult.reason,
+                source,
+                processing,
+                script,
+                reply,
+                feedback: feedbackResult.feedback,
+                anomalies: executionAnomalies,
+                effects: feedbackResult.effects,
+                error: feedbackResult.error,
+                causation,
+            });
+            if (!payload.dryRun) {
+                this.audit.write(audit);
+                this.publishTriggerRunOutcome(definition, audit);
+                this.finishRun(definition.id, runId);
+                recordCausationSpan(causation, 'trigger.run', { status: audit.status === 'failed' ? 'failed' : 'completed', refs: { triggerId: definition.id, runId }, reason: audit.reason });
+            }
+            return {
+                ok: feedbackResult.status !== 'failed',
+                runId,
+                triggerId: definition.id,
+                status: audit.status,
+                reason: audit.reason,
+                audit,
+                error: audit.error?.message,
+            };
+        }
+        catch (err) {
+            if (err instanceof AbortSettleGraceError) {
+                incomplete = {
+                    reason: 'abort_settle_grace_exceeded',
+                    phase: err.phase,
+                    timeoutMs: err.graceMs,
+                    anomalyCapture: 'truncated',
+                };
+            }
+            executionAnomalies = mergeTriggerExecutionAnomalies(executionAnomalies, executionAnomaliesFromError(err));
+            const message = err?.message || String(err);
+            if (!payload.dryRun && controller.signal.aborted) {
+                const reason = triggerCancellationReason(controller.signal);
+                if (this.isRunning(definition.id, runId))
+                    this.finishRun(definition.id, runId);
+                return {
+                    ok: false,
+                    runId,
+                    triggerId: definition.id,
+                    status: 'failed',
+                    reason,
+                    error: message,
+                };
+            }
+            executionAnomalies = accumulateTriggerExecutionAnomalies(executionAnomalies, drainTriggerExecutionAnomalies(runId));
+            const audit = this.buildAudit({
+                definition,
+                runId,
+                startedAt,
+                status: 'failed',
+                reason: 'daemon_error',
+                source,
+                processing,
+                script,
+                reply,
+                feedback: null,
+                anomalies: executionAnomalies,
+                effects: [],
+                error: { code: 'daemon_error', message },
+                causation,
+            });
+            if (!payload.dryRun) {
+                this.audit.write(audit);
+                this.publishTriggerRunOutcome(definition, audit);
+                this.finishRun(definition.id, runId);
+                recordCausationSpan(causation, 'trigger.run', { status: 'failed', refs: { triggerId: definition.id, runId }, reason: 'daemon_error' });
+            }
+            return { ok: false, runId, triggerId: definition.id, status: 'failed', reason: 'daemon_error', audit, error: message };
+        }
+        finally {
+            if (runningRuntime)
+                runningRuntime.anomalies = executionAnomalies;
+            settleCompletion?.({ anomalies: executionAnomalies, ...(incomplete ? { incomplete } : {}) });
+        }
+    }
+    async runExecution(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, onAnomalies) {
+        const maxAttempts = !dryRun && definition.execution.onError === 'retry'
+            ? definition.reliability.retry.maxAttempts
+            : 0;
+        let attempt = 1;
+        let anomalies = [];
+        try {
+            let execution = await this.runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt);
+            anomalies = accumulateTriggerExecutionAnomalies(anomalies, mergeTriggerExecutionAnomalies(execution.reply?.anomalies, drainTriggerExecutionAnomalies(runId)));
+            onAnomalies?.(anomalies);
+            for (let retryCount = 0; shouldRetryExecutionResult(execution) && retryCount < maxAttempts && !signal.aborted; retryCount++) {
+                const backoffCompleted = await sleep(definition.reliability.retry.backoffMs, signal);
+                if (!backoffCompleted || signal.aborted)
+                    break;
+                attempt += 1;
+                execution = await this.runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt);
+                anomalies = accumulateTriggerExecutionAnomalies(anomalies, mergeTriggerExecutionAnomalies(execution.reply?.anomalies, drainTriggerExecutionAnomalies(runId)));
+                onAnomalies?.(anomalies);
+            }
+            if (execution.reply && anomalies.length) {
+                execution = { ...execution, reply: { ...execution.reply, anomalies } };
+            }
+            return anomalies.length ? { ...execution, anomalies } : execution;
+        }
+        catch (error) {
+            anomalies = accumulateTriggerExecutionAnomalies(anomalies, drainTriggerExecutionAnomalies(runId));
+            onAnomalies?.(anomalies);
+            throw new TriggerExecutionFailure(error, anomalies);
+        }
+    }
+    async runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt = 1) {
+        if (signal.aborted) {
+            return {
+                script: null,
+                processing: { mode: definition.execution.type },
+                reply: errorReply(runId, 0, 'cancelled', 'trigger execution cancelled'),
+            };
+        }
+        if (definition.execution.type === 'script') {
+            const script = await this.runScriptOnce(definition, runId, firedAt, sourcePayload, signal);
+            const processing = {
+                mode: 'script',
+                scriptPath: definition.execution.script?.path,
+                scriptArgs: definition.execution.script?.args ?? [],
+            };
+            if (script.error || script.exitCode !== 0) {
+                const reply = errorReply(runId, script.durationMs, script.error?.code || 'script_error', script.error?.message || 'script failed');
+                return {
+                    branch: 'onFailure',
+                    script,
+                    processing,
+                    reply,
+                };
+            }
+            const reply = replyFromScriptResult(script, runId);
+            return {
+                branch: branchFromReply(reply),
+                script,
+                processing,
+                reply,
+            };
+        }
+        const prompt = renderTemplate(definition.execution.prompt ?? '', {
+            trigger: definition,
+            timestamp: firedAt,
+            event: sourcePayload,
+            source: { type: definition.source.type, payload: sourcePayload },
+        });
+        const processing = {
+            mode: definition.execution.type,
+            renderedTextHash: sha256(prompt),
+            renderedTextPreview: previewText(prompt),
+        };
+        if (definition.execution.type === 'target_session') {
+            const feedbackResult = await this.feedback.dispatchTargetSession({
+                trigger: definition,
+                runId,
+                attemptId: `${runId}:attempt:${attempt}`,
+                firedAt,
+                prompt,
+                dryRun,
+                causation,
+                signal,
+            });
+            return {
+                script: null,
+                processing,
+                reply: null,
+                feedbackResult,
+            };
+        }
+        if (dryRun) {
+            const reply = {
+                outcome: prompt.trim() ? 'success' : 'noop',
+                text: prompt,
+                files: [],
+                meta: {
+                    runId,
+                    durationMs: 0,
+                    toolCallCount: 0,
+                },
+            };
+            return { branch: branchFromReply(reply), script: null, processing, reply };
+        }
+        try {
+            const runtimeBaseagent = this.runtime.getBaseagent?.() || this.runtime.baseagent;
+            const originPath = causation.trigger?.path ?? [];
+            logger.info(`[Trigger] execution context triggerId=${definition.id}`
+                + ` triggerRunId=${runId}`
+                + ` originRunId=${originPath[0]?.runId ?? '<none>'}`
+                + ` selfAID=${definition.agentAid}`
+                + ` baseagent=${runtimeBaseagent}`
+                + ` model=${definition.execution.model ?? '<agent-default>'}`
+                + ` effort=${definition.execution.effort ?? '<agent-default>'}`);
+            const executionSession = await this.daemonChannel.getOrCreateConversationSession(definition, this.runtime.projectPath, runtimeBaseagent, runId, `${runId}:attempt:${attempt}`);
+            const daemonReply = await this.daemonChannel.converse(prompt, {
+                trigger: definition,
+                runId,
+                attemptId: `${runId}:attempt:${attempt}`,
+                firedAt,
+                projectPath: this.runtime.projectPath,
+                baseagent: runtimeBaseagent,
+                session: executionSession,
+                causation,
+                signal,
+                onStateChange: (state, metadata) => {
+                    if (state === 'requires_action') {
+                        this.state.setPhase(definition.id, runId, 'requires-action');
+                        this.state.appendEvent(definition.id, runId, {
+                            event: 'execution.requires_action',
+                            ts: Date.now(),
+                            requestId: metadata?.requestId,
+                            expiresAt: metadata?.expiresAt,
+                        });
+                    }
+                    else {
+                        this.state.setPhase(definition.id, runId, 'running');
+                        this.state.appendEvent(definition.id, runId, {
+                            event: 'execution.resumed',
+                            ts: Date.now(),
+                            requestId: metadata?.requestId,
+                        });
+                    }
+                },
+            });
+            const sentinel = definition.execution.noopSentinel ?? '[[NOOP]]';
+            const reply = {
+                ...daemonReply,
+                outcome: daemonReply.outcome === 'success' && daemonReply.text.trim() === sentinel ? 'noop' : daemonReply.outcome,
+                text: daemonReply.text.trim() === sentinel ? '' : daemonReply.text,
+            };
+            return {
+                branch: branchFromReply(reply),
+                script: null,
+                processing,
+                reply,
+            };
+        }
+        catch (err) {
+            const reply = errorReply(runId, 0, 'agent_execution_error', err?.message || String(err));
+            return {
+                branch: 'onFailure',
+                script: null,
+                processing,
+                reply,
+            };
+        }
+    }
+    async runScriptOnce(definition, runId, firedAt, sourcePayload, signal) {
+        return await this.scriptExecutor.execute({
+            trigger: definition,
+            triggerDir: this.manager.triggerDir(definition.id),
+            runId,
+            firedAt,
+            sourcePayload,
+            signal,
+        });
+    }
+    async checkConcurrency(definition, nextRunId, source) {
+        const runs = this.running.get(definition.id);
+        if (!runs || runs.size === 0 || definition.reliability.concurrency === 'allow')
+            return undefined;
+        const first = runs.values().next().value;
+        const conflictRunId = first?.run.runId;
+        if (definition.reliability.concurrency === 'forbid') {
+            const audit = this.writeSkippedAudit(definition, source.scheduledAt, source.firedAt, 'concurrency_forbid', conflictRunId, nextRunId);
+            return {
+                ok: true,
+                runId: nextRunId,
+                triggerId: definition.id,
+                status: 'skipped',
+                reason: 'concurrency_forbid',
+                audit,
+                ...(conflictRunId ? { conflictRunId } : {}),
+            };
+        }
+        await Promise.all(Array.from(runs.entries()).map(([runId, runtime]) => this.terminateRun(runId, runtime, {
+            reason: 'replaced',
+            message: `trigger run replaced by ${nextRunId}`,
+        })));
+        return await this.checkConcurrency(definition, nextRunId, source);
+    }
+    async recoverOpenRuns() {
+        for (const definition of this.manager.list({ all: true })) {
+            const activeRuns = this.state.list(definition.id);
+            if (activeRuns.length === 0)
+                continue;
+            for (const run of activeRuns) {
+                const status = run.phase === 'feedback-pending' ? 'skipped' : 'failed';
+                const audit = this.buildAudit({
+                    definition,
+                    runId: run.runId,
+                    startedAt: run.startedAt,
+                    status,
+                    reason: 'daemon_restart',
+                    source: this.buildSourceInfo(definition.source, run.startedAt, run.startedAt, this.sourcePayload(definition.source)),
+                    script: null,
+                    reply: null,
+                    feedback: null,
+                    effects: [],
+                    error: status === 'failed' ? { code: 'daemon_restart', message: 'daemon restarted while run was open' } : null,
+                });
+                this.audit.write(audit);
+                if (status === 'failed') {
+                    const reply = errorReply(run.runId, Math.max(0, Date.now() - run.startedAt), 'daemon_restart', 'daemon restarted while run was waiting or executing');
+                    try {
+                        await this.feedback.dispatch({
+                            trigger: definition,
+                            runId: run.runId,
+                            firedAt: run.startedAt,
+                            branch: 'onFailure',
+                            reply,
+                            sourcePayload: this.sourcePayload(definition.source),
+                            causation: createRootCausation(),
+                        });
+                    }
+                    catch (error) {
+                        logger.warn(`[Trigger] daemon restart feedback failed: trigger=${definition.id} run=${run.runId} error=${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            this.state.clear(definition.id);
+        }
+    }
+    resolveScheduledAt(definition) {
+        const now = Date.now();
+        switch (definition.source.type) {
+            case 'once':
+                return now;
+            case 'delay': {
+                const at = definition.createdAt + definition.source.afterMs;
+                return at <= now && definition.reliability.missedPolicy === 'skip' ? null : Math.max(at, now);
+            }
+            case 'at': {
+                const at = new Date(definition.source.at).getTime();
+                return at <= now && definition.reliability.missedPolicy === 'skip' ? null : Math.max(at, now);
+            }
+            case 'interval':
+            case 'cron': {
+                const signature = this.sourceSignature(definition.source);
+                const state = this.state.readSchedule(definition.id);
+                if (state?.sourceSignature === signature) {
+                    return this.ensureScheduleRunMarker(definition, state).nextFireAt;
+                }
+                const nextFireAt = this.nextPeriodicFireAt(definition.source, now);
+                this.writeScheduleCursor(definition, nextFireAt, signature);
+                return nextFireAt;
+            }
+            case 'event':
+                return null;
+        }
+    }
+    advancePeriodicSchedule(definition, scheduledAt, firedAt) {
+        if (!this.isPeriodic(definition.source))
+            return;
+        const missed = scheduledAt < firedAt - 1000;
+        const ref = missed ? firedAt : scheduledAt;
+        let nextFireAt = this.nextPeriodicFireAt(definition.source, ref);
+        const now = Date.now();
+        if (nextFireAt <= now && missed) {
+            nextFireAt = this.nextPeriodicFireAt(definition.source, now);
+        }
+        this.writeScheduleCursor(definition, nextFireAt, undefined, { lastScheduledAt: scheduledAt, lastFiredAt: firedAt });
+    }
+    nextPeriodicFireAt(source, ref) {
+        if (source.type === 'interval')
+            return ref + source.everyMs;
+        return this.nextCronFireAt(source, ref);
+    }
+    nextCronFireAt(source, ref) {
+        const interval = CronExpressionParser.parse(source.expression, {
+            currentDate: new Date(ref),
+            tz: source.timezone,
+        });
+        return interval.next().getTime();
+    }
+    writeScheduleCursor(definition, nextFireAt, signature = this.sourceSignature(definition.source), patch = {}) {
+        const previous = this.state.readSchedule(definition.id);
+        this.state.writeSchedule(definition.id, {
+            nextFireAt,
+            updatedAt: Date.now(),
+            sourceSignature: signature,
+            ...(previous?.sourceSignature === signature && previous.lastScheduledAt !== undefined
+                ? { lastScheduledAt: previous.lastScheduledAt }
+                : {}),
+            ...(previous?.sourceSignature === signature && previous.lastFiredAt !== undefined
+                ? { lastFiredAt: previous.lastFiredAt }
+                : {}),
+            ...patch,
+        });
+    }
+    ensureScheduleRunMarker(definition, schedule) {
+        if (schedule.lastScheduledAt !== undefined || !this.isPeriodic(definition.source))
+            return schedule;
+        const inferred = this.previousPeriodicFireAt(definition.source, schedule.nextFireAt);
+        if (inferred === undefined)
+            return schedule;
+        if (Math.abs(schedule.updatedAt - inferred) > 300_000)
+            return schedule;
+        const patched = {
+            ...schedule,
+            lastScheduledAt: inferred,
+            lastFiredAt: schedule.updatedAt,
+        };
+        this.state.writeSchedule(definition.id, patched);
+        return patched;
+    }
+    previousPeriodicFireAt(source, ref) {
+        if (source.type === 'interval')
+            return ref - source.everyMs;
+        try {
+            const interval = CronExpressionParser.parse(source.expression, {
+                currentDate: new Date(ref),
+                tz: source.timezone,
+            });
+            return interval.prev().getTime();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    sourceSignature(source) {
+        return JSON.stringify(source);
+    }
+    sourcePayload(source) {
+        switch (source.type) {
+            case 'once': return {};
+            case 'delay': return { afterMs: source.afterMs };
+            case 'at': return { at: source.at };
+            case 'cron': return {
+                expression: source.expression,
+                timezone: source.timezone ?? runtimeTimezone(),
+            };
+            case 'interval': return { everyMs: source.everyMs };
+            case 'event': return { eventPattern: source.eventPattern };
+        }
+    }
+    buildSourceInfo(source, firedAt, scheduledAt, payload) {
+        return {
+            type: source.type,
+            eventName: source.type === 'event' ? (typeof payload?.type === 'string' ? payload.type : source.eventPattern) : undefined,
+            scheduledAt,
+            firedAt,
+            payload: payload ?? this.sourcePayload(source),
+        };
+    }
+    buildAudit(input) {
+        const reply = summarizeReply(input.reply, { omitText: input.script?.result !== undefined });
+        return {
+            runId: input.runId,
+            triggerId: input.definition.id,
+            agentAid: input.definition.agentAid,
+            startedAt: input.startedAt,
+            finishedAt: Date.now(),
+            status: input.status,
+            reason: input.reason,
+            conflictRunId: input.conflictRunId,
+            definition: {
+                schemaVersion: input.definition.$schema_version,
+                revision: definitionRevision(input.definition),
+                name: input.definition.name,
+            },
+            source: input.source,
+            processing: input.processing ?? null,
+            script: summarizeScript(input.script),
+            reply,
+            feedback: summarizeFeedback(input.feedback, input.reply),
+            ...(input.anomalies?.length ? { anomalies: input.anomalies } : {}),
+            ...(input.incomplete ? { incomplete: input.incomplete } : {}),
+            effects: input.effects,
+            error: input.error,
+            causation: input.causation,
+        };
+    }
+    writeSkippedAudit(definition, scheduledAt, firedAt, reason, conflictRunId, runId = `run_${firedAt}_${crypto.randomBytes(3).toString('hex')}`) {
+        const audit = this.buildAudit({
+            definition,
+            runId,
+            startedAt: firedAt,
+            status: 'skipped',
+            reason,
+            source: this.buildSourceInfo(definition.source, firedAt, scheduledAt, this.sourcePayload(definition.source)),
+            script: null,
+            reply: null,
+            feedback: null,
+            effects: [],
+            error: null,
+            conflictRunId,
+        });
+        this.audit.write(audit);
+        this.publishTriggerRunOutcome(definition, audit);
+        return audit;
+    }
+    limitDisabledReason(definition, firedAt) {
+        if (!definition.limits)
+            return undefined;
+        const limitState = this.state.ensureLimitState(definition.id);
+        if (definition.limits.maxRuns !== undefined && limitState.runCount >= definition.limits.maxRuns) {
+            return 'max_runs';
+        }
+        if (definition.limits.maxDuration !== undefined) {
+            const durationMs = parseDurationMs(definition.limits.maxDuration);
+            if (firedAt - limitState.startedAt >= durationMs)
+                return 'max_duration';
+        }
+        return undefined;
+    }
+    disableForLimit(definition, scheduledAt, firedAt, reason) {
+        this.state.markLimitDisabled(definition.id, reason);
+        this.setEnabled(definition.id, false);
+        return this.writeSkippedAudit(definition, scheduledAt, firedAt, reason === 'max_runs' ? 'max_runs_reached' : 'max_duration_reached');
+    }
+    isOneShot(source) {
+        return source.type === 'once' || source.type === 'delay' || source.type === 'at';
+    }
+    isPeriodic(source) {
+        return source.type === 'cron' || source.type === 'interval';
+    }
+    addRunning(triggerId, runId, runtime) {
+        let runs = this.running.get(triggerId);
+        if (!runs) {
+            runs = new Map();
+            this.running.set(triggerId, runs);
+        }
+        runs.set(runId, runtime);
+    }
+    async acquireRunStartLock(triggerId) {
+        const previous = this.runStartLocks.get(triggerId) ?? Promise.resolve();
+        let releaseCurrent;
+        const current = new Promise(resolve => { releaseCurrent = resolve; });
+        const tail = previous.then(() => current);
+        this.runStartLocks.set(triggerId, tail);
+        await previous;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            releaseCurrent();
+            if (this.runStartLocks.get(triggerId) === tail) {
+                this.runStartLocks.delete(triggerId);
+            }
+        };
+    }
+    terminateRun(runId, runtime, termination) {
+        if (runtime.terminationSettlement)
+            return runtime.terminationSettlement;
+        runtime.termination = termination;
+        if (!runtime.controller.signal.aborted) {
+            runtime.controller.abort(new Error(termination.message));
+        }
+        runtime.terminationSettlement = this.settleTerminatedRun(runId, runtime, termination);
+        return runtime.terminationSettlement;
+    }
+    async settleTerminatedRun(runId, runtime, termination) {
+        const completion = await settleWithin(runtime.completion, RUN_COMPLETION_BARRIER_MS);
+        const completedAnomalies = mergeTriggerExecutionAnomalies(runtime.anomalies, completion.settled ? completion.value.anomalies : undefined);
+        const anomalies = accumulateTriggerExecutionAnomalies(completedAnomalies, drainTriggerExecutionAnomalies(runId));
+        if (!completion.settled) {
+            logger.warn(`[Trigger] run completion barrier timed out: trigger=${runtime.definition.id} run=${runId} reason=${termination.reason} timeoutMs=${RUN_COMPLETION_BARRIER_MS}`);
+        }
+        if (!runtime.terminalAuditWritten) {
+            runtime.terminalAuditWritten = true;
+            const incomplete = completion.settled
+                ? completion.value.incomplete
+                : {
+                    reason: 'completion_barrier_timeout',
+                    phase: 'run',
+                    timeoutMs: RUN_COMPLETION_BARRIER_MS,
+                    anomalyCapture: 'truncated',
+                };
+            const message = incomplete?.reason === 'completion_barrier_timeout'
+                ? `${termination.message}; completion barrier timed out after ${incomplete.timeoutMs}ms; anomaly capture is truncated`
+                : incomplete
+                    ? `${termination.message}; ${incomplete.phase} operation did not settle within ${incomplete.timeoutMs}ms abort grace; anomaly capture is truncated`
+                    : termination.message;
+            const audit = this.buildAudit({
+                definition: runtime.definition,
+                runId,
+                startedAt: runtime.run.startedAt,
+                status: 'failed',
+                reason: termination.reason,
+                source: runtime.source,
+                script: null,
+                reply: null,
+                feedback: null,
+                anomalies,
+                incomplete,
+                effects: [],
+                error: { code: termination.reason, message },
+                causation: runtime.causation,
+            });
+            this.audit.write(audit);
+            this.publishTriggerRunOutcome(runtime.definition, audit);
+            recordCausationSpan(runtime.causation, 'trigger.run', {
+                status: 'failed',
+                refs: { triggerId: runtime.definition.id, runId },
+                reason: termination.reason,
+            });
+        }
+        this.finishRun(runtime.definition.id, runId);
+    }
+    finishRun(triggerId, runId) {
+        const runs = this.running.get(triggerId);
+        runs?.delete(runId);
+        if (runs && runs.size === 0)
+            this.running.delete(triggerId);
+        this.state.remove(triggerId, runId);
+    }
+    isRunning(triggerId, runId) {
+        return this.running.get(triggerId)?.has(runId) === true;
+    }
+    clearTimer(triggerId) {
+        const timer = this.timers.get(triggerId);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(triggerId);
+    }
+    registerEvent(definition) {
+        if (!this.eventSource) {
+            logger.warn(`[Trigger] event source disabled; skip ${definition.id}`);
+            return;
+        }
+        this.eventSource.register(definition);
+    }
+    unregisterEvent(triggerId) {
+        this.eventSource?.unregister(triggerId);
+    }
+    subscriptionInfo(definition) {
+        if (definition.source.type !== 'event')
+            return { status: 'not-event' };
+        if (!definition.enabled)
+            return { status: 'inactive', warning: 'trigger is disabled' };
+        if (!this.eventSource)
+            return { status: 'event-bus-unavailable', warning: 'event bus is not attached to this scheduler' };
+        if (this.eventSource.has(definition.id))
+            return { status: 'active' };
+        return { status: 'inactive', warning: 'event subscription is not registered' };
+    }
+    async fireEventTrigger(triggerId, event) {
+        const definition = this.manager.get(triggerId);
+        if (!definition?.enabled || definition.source.type !== 'event')
+            return;
+        const disabledReason = this.limitDisabledReason(definition, event.firedAt);
+        if (disabledReason) {
+            this.disableForLimit(definition, undefined, event.firedAt, disabledReason);
+            return;
+        }
+        await this.startRun(definition, {
+            firedAt: event.firedAt,
+            payload: event.payload,
+            causation: event.causation,
+        });
+    }
+    publishTriggerDefinitionEvent(type, definition) {
+        const target = primaryTarget(definition);
+        this.eventBus?.publish({
+            type,
+            triggerId: definition.id,
+            name: definition.name,
+            peerId: definition.origin?.peerId,
+            targetChannel: target?.channelKey,
+            targetChannelId: target?.channelId,
+            scheduleType: definition.source.type,
+            scheduleValue: this.sourceScheduleValue(definition.source),
+            timestamp: Date.now(),
+        });
+    }
+    publishTriggerFired(definition, runId, firedAt, causation) {
+        const target = primaryTarget(definition);
+        this.eventBus?.publish({
+            type: 'trigger:fired',
+            triggerId: definition.id,
+            name: definition.name,
+            runId,
+            originTriggerId: definition.id,
+            fireTime: firedAt,
+            targetChannel: target?.channelKey,
+            targetChannelId: target?.channelId,
+            scheduleType: definition.source.type,
+            timestamp: Date.now(),
+            causation,
+        });
+    }
+    publishTriggerRunOutcome(definition, audit) {
+        if (!this.eventBus || audit.status === 'dry-run')
+            return;
+        const target = primaryTarget(definition);
+        const targetChannel = target?.channelKey ?? 'daemon';
+        const targetChannelId = target?.channelId ?? definition.agentAid;
+        const base = {
+            triggerId: definition.id,
+            name: definition.name,
+            runId: audit.runId,
+            originTriggerId: definition.id,
+            targetChannel,
+            targetChannelId,
+            fireTime: audit.source.firedAt,
+            causation: audit.causation,
+        };
+        if (audit.status === 'completed' || audit.status === 'degraded' || audit.status === 'noop') {
+            this.eventBus.publish({
+                type: 'trigger:completed',
+                ...base,
+                messageId: this.triggerOutcomeMessageId(audit),
+                durationMs: Math.max(0, audit.finishedAt - audit.startedAt),
+            });
+            return;
+        }
+        if (audit.status === 'failed') {
+            this.eventBus.publish({
+                type: 'trigger:failed',
+                ...base,
+                messageId: this.triggerOutcomeMessageId(audit),
+                error: audit.error?.message ?? audit.reason ?? 'trigger failed',
+                phase: 'execute',
+            });
+            return;
+        }
+        if (audit.status === 'skipped') {
+            this.eventBus.publish({
+                type: 'trigger:skipped',
+                ...base,
+                reason: audit.reason ?? 'skipped',
+            });
+        }
+    }
+    triggerOutcomeMessageId(audit) {
+        return audit.effects.find(effect => effect.messageId)?.messageId ?? audit.runId;
+    }
+    sourceScheduleValue(source) {
+        switch (source.type) {
+            case 'cron': return source.expression;
+            case 'interval': return `${source.everyMs}ms`;
+            case 'delay': return `${source.afterMs}ms`;
+            case 'at': return String(source.at);
+            case 'once': return 'once';
+            case 'event': return source.eventPattern;
+        }
+    }
+}
+function replyFromScriptResult(script, runId) {
+    const result = script.result ?? {};
+    const outcomeRaw = typeof result.outcome === 'string' ? result.outcome : undefined;
+    const outcome = normalizeReplyOutcome(outcomeRaw);
+    const text = result.text === undefined || result.text === null ? '' : String(result.text);
+    if (!outcome) {
+        return invalidScriptReply(script, runId, 'script_reply_invalid', 'script stdout must be a TriggerReply object with outcome: success | noop | error | interrupted | timeout');
+    }
+    const files = Array.isArray(result.files)
+        ? result.files
+            .filter((file) => isRecord(file) && typeof file.path === 'string')
+            .map(file => ({
+            path: String(file.path),
+            name: typeof file.name === 'string' ? file.name : undefined,
+        }))
+        : [];
+    const error = isRecord(result.error)
+        ? {
+            reason: typeof result.error.reason === 'string' ? result.error.reason : undefined,
+            text: typeof result.error.text === 'string' ? result.error.text : text || 'script returned error',
+        }
+        : outcome === 'error'
+            ? { text: text || 'script returned error' }
+            : undefined;
+    return {
+        outcome,
+        text,
+        files,
+        error,
+        meta: {
+            runId,
+            durationMs: script.durationMs,
+            toolCallCount: 0,
+        },
+    };
+}
+function normalizeReplyOutcome(value) {
+    if (value === 'success' || value === 'noop' || value === 'error' || value === 'interrupted' || value === 'timeout') {
+        return value;
+    }
+    return undefined;
+}
+function invalidScriptReply(script, runId, reason, text) {
+    return {
+        outcome: 'error',
+        text: '',
+        files: [],
+        error: { reason, text },
+        meta: {
+            runId,
+            durationMs: script.durationMs,
+            toolCallCount: 0,
+        },
+    };
+}
+function branchFromReply(reply) {
+    if (reply.outcome === 'success')
+        return 'onReply';
+    if (reply.outcome === 'noop')
+        return 'onNoop';
+    return 'onFailure';
+}
+function shouldRetryExecution(reply) {
+    return reply.outcome === 'error' || reply.outcome === 'timeout' || reply.outcome === 'interrupted';
+}
+function triggerCancellationReason(signal) {
+    const reason = signal.reason instanceof Error
+        ? signal.reason.message
+        : typeof signal.reason === 'string'
+            ? signal.reason
+            : '';
+    if (reason.includes('replaced'))
+        return 'replaced';
+    if (reason.includes('stopped'))
+        return 'stopped';
+    return 'cancelled';
+}
+function shouldRetryExecutionResult(execution) {
+    if (execution.reply)
+        return shouldRetryExecution(execution.reply);
+    return execution.feedbackResult?.status === 'failed';
+}
+function statusWithExecutionAnomalies(status, anomalies) {
+    return status === 'completed' && anomalies.length ? 'degraded' : status;
+}
+function errorReply(runId, durationMs, reason, text) {
+    return {
+        outcome: 'error',
+        text: '',
+        files: [],
+        error: { reason, text },
+        meta: {
+            runId,
+            durationMs,
+            toolCallCount: 0,
+        },
+    };
+}
+function summarizeScript(script) {
+    if (!script)
+        return null;
+    const { stdoutPreview, error, ...summary } = script;
+    const summarizedError = error
+        ? {
+            code: error.code,
+            message: error.message,
+            ...(error.stdoutPreview && error.stdoutPreview !== stdoutPreview
+                ? { stdoutPreview: error.stdoutPreview }
+                : {}),
+            ...(error.stderrPreview && error.stderrPreview !== script.stderrPreview
+                ? { stderrPreview: error.stderrPreview }
+                : {}),
+        }
+        : undefined;
+    return {
+        ...summary,
+        ...(script.result === undefined && stdoutPreview ? { stdoutPreview } : {}),
+        ...(summarizedError ? { error: summarizedError } : {}),
+    };
+}
+function summarizeFeedback(feedback, reply) {
+    if (!feedback)
+        return feedback;
+    const duplicateReply = !!reply?.text
+        && feedback.renderedTextHash === sha256(reply.text);
+    const emptyOrSilent = feedback.strategy === 'silent'
+        || !feedback.renderedTextPreview;
+    if (!duplicateReply && !emptyOrSilent)
+        return feedback;
+    const { renderedTextHash: _hash, renderedTextPreview: _preview, ...summary } = feedback;
+    return summary;
+}
+function summarizeReply(reply, opts = {}) {
+    if (!reply)
+        return null;
+    return {
+        outcome: reply.outcome,
+        ...(!opts.omitText && reply.text
+            ? { textHash: sha256(reply.text), textPreview: previewText(reply.text) }
+            : {}),
+        fileCount: reply.files.length,
+        durationMs: reply.meta.durationMs,
+        numTurns: reply.meta.numTurns,
+        tokenUsage: reply.meta.tokenUsage,
+        toolCallCount: reply.meta.toolCallCount,
+    };
+}
+function primaryTarget(definition) {
+    if (definition.feedback.strategy === 'target')
+        return definition.feedback.target;
+    if (!definition.origin)
+        return undefined;
+    return {
+        channelKey: definition.origin.channelKey,
+        channelId: definition.origin.channelId,
+        session: definition.origin.session,
+        threadId: definition.origin.threadId,
+    };
+}
+function eventTestMatchError(reason, eventPattern) {
+    switch (reason) {
+        case 'missing_event_type':
+            return 'simulated event payload.type must be a non-empty string';
+        case 'event_pattern_mismatch':
+            return `simulated event payload.type does not match Event Pattern "${eventPattern}"`;
+        case 'event_filter_mismatch':
+            return 'simulated event payload does not satisfy the Event Trigger filter';
+    }
+}
+function runtimeTimezone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    }
+    catch {
+        return 'UTC';
+    }
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function summarizeListSource(source) {
+    switch (source.type) {
+        case 'once': return { type: 'once' };
+        case 'delay': return { type: 'delay', afterMs: source.afterMs };
+        case 'at': return { type: 'at', at: source.at };
+        case 'cron': return {
+            type: 'cron',
+            expression: source.expression,
+            ...(source.timezone ? { timezone: source.timezone } : {}),
+        };
+        case 'interval': return { type: 'interval', everyMs: source.everyMs };
+        case 'event': return { type: 'event', eventPattern: source.eventPattern };
+    }
+}
+function sleep(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve(false);
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (completed) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            resolve(completed);
+        };
+        const onAbort = () => finish(false);
+        const timer = setTimeout(() => finish(true), Math.max(0, ms));
+        timer.unref?.();
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function awaitWithAbortSettleGrace(operation, signal, graceMs, phase) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let graceTimer;
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            signal.removeEventListener('abort', onAbort);
+            callback();
+        };
+        const onAbort = () => {
+            if (settled || graceTimer)
+                return;
+            graceTimer = setTimeout(() => {
+                const reason = signal.reason instanceof Error
+                    ? signal.reason.message
+                    : typeof signal.reason === 'string'
+                        ? signal.reason
+                        : 'trigger run aborted';
+                finish(() => reject(new AbortSettleGraceError(reason, phase, graceMs)));
+            }, Math.max(0, graceMs));
+            graceTimer.unref?.();
+        };
+        operation.then(value => finish(() => resolve(value)), error => finish(() => reject(error)));
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
+class AbortSettleGraceError extends Error {
+    phase;
+    graceMs;
+    constructor(reason, phase, graceMs) {
+        super(`${reason}; ${phase} operation did not settle within ${graceMs}ms abort grace`);
+        this.phase = phase;
+        this.graceMs = graceMs;
+        this.name = 'AbortSettleGraceError';
+    }
+}
+function settleWithin(promise, timeoutMs) {
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish({ settled: false }), Math.max(0, timeoutMs));
+        timer.unref?.();
+        promise.then(value => finish({ settled: true, value }), () => finish({ settled: false }));
+    });
+}
+class TriggerExecutionFailure extends Error {
+    anomalies;
+    constructor(error, anomalies) {
+        super(error instanceof Error ? error.message : String(error), { cause: error });
+        this.anomalies = anomalies;
+        this.name = 'TriggerExecutionFailure';
+    }
+}
+function executionAnomaliesFromError(error) {
+    return error instanceof TriggerExecutionFailure ? error.anomalies : undefined;
+}
+function limitsSignature(limits) {
+    return JSON.stringify(limits ?? null);
+}
+function mergeStats(legacy, current) {
+    if (!legacy)
+        return current;
+    const out = {
+        fireCount: legacy.fireCount + current.fireCount,
+        failCount: legacy.failCount + current.failCount,
+    };
+    const legacyAt = legacy.lastFiredAt ?? -1;
+    const currentAt = current.lastFiredAt ?? -1;
+    if (legacyAt >= currentAt && legacy.lastFiredAt !== undefined) {
+        out.lastFiredAt = legacy.lastFiredAt;
+        out.lastResult = legacy.lastResult;
+    }
+    else if (current.lastFiredAt !== undefined) {
+        out.lastFiredAt = current.lastFiredAt;
+        out.lastResult = current.lastResult;
+    }
+    return out;
+}
+function accountScheduleMarker(stats, schedule, hasSkippedSchedule) {
+    if (stats.fireCount > 0 || schedule?.lastScheduledAt === undefined)
+        return stats;
+    if (hasSkippedSchedule(schedule.lastScheduledAt))
+        return stats;
+    return {
+        ...stats,
+        fireCount: 1,
+    };
+}