@assemblyline-agents/runtime 0.1.0

package/dist/schedule-execution.js

@@ -0,0 +1,951 @@
+import { isTriggerHandlerDefinition, normalizeRoutineRunRecord, normalizeTriggerPrepareResult, triggerPrepareContext } from "./channel-http-util.js";
+import { RunCapacityError } from "./concurrency.js";
+import { dueTimeForSchedule, dynamicScheduleMessage, stringValue, timestamp } from "./runtime-util.js";
+import { buildDefaultContextBundle } from "./sandbox-fs.js";
+import { isJsonObject, safeJson } from "./json-util.js";
+import { failRun } from "./run-outcome.js";
+import { isRuntimeSettingsStore } from "./state.js";
+import { memoryBodyText, memoryDocumentSummary, positiveLimit } from "./storage.js";
+export async function registerManifestSchedulesImpl(host) {
+    const records = [];
+    for (const schedule of manifestScheduleRegistrations(host)) {
+        records.push(await host.state.registerSchedule({
+            id: schedule.schedule,
+            name: `schedule:${schedule.schedule}`,
+            cron: schedule.cron,
+            ...(schedule.timezone ? { timezone: schedule.timezone } : {}),
+            metadata: {
+                agentRevision: host.manifest.agentRevision,
+                message: schedule.message ?? compiledSchedule(host, schedule.schedule)?.message ?? null,
+                trigger: schedule.trigger ? safeJson(schedule.trigger) : null
+            }
+        }));
+    }
+    return records;
+}
+export async function runDueSchedulesImpl(host, options = {}) {
+    host.boot();
+    if (!(await host.agentEnabled()))
+        return [];
+    await registerManifestSchedulesImpl(host);
+    const now = options.now ?? host.now();
+    const lookbackMs = options.lookbackMs ?? host.schedulerTickMs;
+    const results = [];
+    for (const schedule of manifestScheduleRegistrations(host)) {
+        const dueAt = dueTimeForSchedule(schedule, now, lookbackMs);
+        if (!dueAt)
+            continue;
+        const dueAtIso = dueAt.toISOString();
+        const idempotencyKey = `${schedule.idempotencyKey}:${dueAtIso}`;
+        // Message schedules run through the bounded semaphore; claim capacity
+        // BEFORE reserving the idempotency key so a saturated runtime skips the
+        // tick without burning the key (the next sweep retries). Triggered
+        // schedules use an existingRun and bypass admission (enter()).
+        let admission;
+        if (!schedule.trigger) {
+            const admitted = host.admitRunOrReject();
+            if (admitted instanceof RunCapacityError) {
+                results.push({ schedule: schedule.schedule, dueAt: dueAtIso, idempotencyKey, status: "skipped", error: "run capacity saturated" });
+                continue;
+            }
+            admission = admitted;
+        }
+        const reserved = await host.state.reserveIdempotencyKey("schedule", idempotencyKey, host.manifest.agentRevision).catch((error) => {
+            admission?.release();
+            throw error;
+        });
+        if (!reserved) {
+            admission?.release();
+            results.push({ schedule: schedule.schedule, dueAt: dueAtIso, idempotencyKey, status: "skipped" });
+            continue;
+        }
+        // Durable claim evidence, written immediately after the key burn: a crash
+        // before the run exists leaves a "preparing" record instead of a silently
+        // lost occurrence. (The residual window is the single adjacent statement.)
+        await host.state.recordScheduleRun({
+            scheduleId: schedule.schedule,
+            runAt: dueAtIso,
+            idempotencyKey,
+            status: "preparing"
+        }).catch((error) => {
+            admission?.release();
+            throw error;
+        });
+        const job = manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKey);
+        try {
+            results.push(await runScheduleExecution(host, job, admission));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await host.state.recordScheduleRun({
+                scheduleId: schedule.schedule,
+                runAt: dueAtIso,
+                idempotencyKey,
+                status: "failed"
+            });
+            results.push({ schedule: schedule.schedule, dueAt: dueAtIso, idempotencyKey, status: "failed", error: message });
+        }
+    }
+    results.push(...(await runDueDynamicSchedules(host, now)));
+    return results;
+}
+export async function dispatchAutomationEventImpl(host, event) {
+    host.boot();
+    if (!(await host.agentEnabled()))
+        return [];
+    if (!event.source.trim() || !event.event.trim() || !event.eventId.trim()) {
+        throw new Error("Automation events require non-empty source, event, and eventId values.");
+    }
+    if (event.occurredAt && Number.isNaN(new Date(event.occurredAt).getTime())) {
+        throw new Error("Automation event occurredAt must be a valid ISO timestamp.");
+    }
+    const results = [];
+    for (const automation of host.manifest.automationRegistrations ?? []) {
+        if (automation.trigger.type !== "event")
+            continue;
+        if (automation.trigger.source !== event.source || automation.trigger.event !== event.event)
+            continue;
+        if (automation.trigger.filter && !jsonSubsetMatches(automation.trigger.filter, event.payload))
+            continue;
+        const idempotencyKey = `${automation.idempotencyKey}:${event.eventId}`;
+        let admission;
+        if (!automation.lifecycle) {
+            const admitted = host.admitRunOrReject();
+            if (admitted instanceof RunCapacityError) {
+                results.push({
+                    automation: automation.automation,
+                    eventId: event.eventId,
+                    idempotencyKey,
+                    status: "skipped",
+                    error: "run capacity saturated"
+                });
+                continue;
+            }
+            admission = admitted;
+        }
+        const reserved = await host.state.reserveIdempotencyKey(`automation:${automation.automation}:event`, idempotencyKey, host.manifest.agentRevision).catch((error) => {
+            admission?.release();
+            throw error;
+        });
+        if (!reserved) {
+            admission?.release();
+            results.push({
+                automation: automation.automation,
+                eventId: event.eventId,
+                idempotencyKey,
+                status: "skipped"
+            });
+            continue;
+        }
+        const execution = eventAutomationExecution(host, automation, event, idempotencyKey);
+        try {
+            const result = await runScheduleExecution(host, execution, admission);
+            results.push({
+                automation: automation.automation,
+                eventId: event.eventId,
+                idempotencyKey,
+                status: result.status,
+                ...(result.runId ? { runId: result.runId } : {}),
+                ...(result.error ? { error: result.error } : {})
+            });
+        }
+        catch (error) {
+            results.push({
+                automation: automation.automation,
+                eventId: event.eventId,
+                idempotencyKey,
+                status: "failed",
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    return results;
+}
+function eventAutomationExecution(host, automation, event, idempotencyKey) {
+    const eventAt = event.occurredAt ?? timestamp();
+    const compiled = host.manifest.automations?.find((candidate) => candidate.name === automation.automation);
+    const trigger = automation.lifecycle
+        ? {
+            handler: automation.lifecycle.handler,
+            ...(automation.target ? { target: automation.target } : {}),
+            ...(automation.metadata ? { metadata: automation.metadata } : {})
+        }
+        : undefined;
+    return {
+        source: "manifest",
+        scheduleId: automation.automation,
+        resultSchedule: automation.automation,
+        dueAtIso: eventAt,
+        idempotencyKey,
+        message: automation.message ?? `Handle ${event.event} from ${event.source}.`,
+        channel: "automation",
+        ...(trigger ? { trigger } : {}),
+        ...(automation.target ? { target: automation.target } : {}),
+        automationEvent: event,
+        metadata: {
+            automation: automation.automation,
+            event: safeJson(event),
+            ...(automation.metadata ?? {})
+        },
+        definition: safeJson(compiled ?? automation),
+        ...(event.userId ? { userId: event.userId } : {}),
+        ...(event.conversationId ? { conversationId: event.conversationId } : {}),
+        ...(event.projectId ? { projectId: event.projectId } : {}),
+        ...(event.delivery ? { delivery: event.delivery } : {}),
+        turnMetadata: {
+            automation: automation.automation,
+            source: event.source,
+            event: event.event,
+            payload: event.payload,
+            ...(event.metadata ?? {})
+        }
+    };
+}
+function jsonSubsetMatches(expected, actual) {
+    return Object.entries(expected).every(([key, expectedValue]) => {
+        if (!Object.prototype.hasOwnProperty.call(actual, key))
+            return false;
+        const actualValue = actual[key];
+        if (isJsonObject(expectedValue)) {
+            return isJsonObject(actualValue) && jsonSubsetMatches(expectedValue, actualValue);
+        }
+        return JSON.stringify(expectedValue) === JSON.stringify(actualValue);
+    });
+}
+function manifestScheduleExecution(host, schedule, dueAtIso, idempotencyKey) {
+    return {
+        source: "manifest",
+        scheduleId: schedule.schedule,
+        resultSchedule: schedule.schedule,
+        dueAtIso,
+        idempotencyKey,
+        message: scheduleMessage(host, schedule.schedule),
+        channel: "schedule",
+        ...(schedule.trigger ? { trigger: schedule.trigger } : {}),
+        ...(schedule.target ? { target: schedule.target } : {}),
+        metadata: {
+            schedule: schedule.schedule,
+            dueAt: dueAtIso,
+            idempotencyKey
+        },
+        definition: safeJson(compiledSchedule(host, schedule.schedule) ?? schedule)
+    };
+}
+async function runScheduleExecution(host, schedule, admission) {
+    return schedule.trigger ? runTriggeredSchedule(host, schedule) : runMessageSchedule(host, schedule, admission);
+}
+async function runMessageSchedule(host, schedule, admission) {
+    const overrides = admission ? { admission } : {};
+    if (schedule.target)
+        overrides.target = schedule.target;
+    const result = await host.run(scheduleRunOptions(host, schedule, schedule.message, schedule.metadata, overrides));
+    await host.state.recordScheduleRun({
+        scheduleId: schedule.resultSchedule,
+        runId: result.run.id,
+        runAt: schedule.dueAtIso,
+        idempotencyKey: schedule.idempotencyKey,
+        status: result.run.status
+    });
+    return {
+        schedule: schedule.resultSchedule,
+        dueAt: schedule.dueAtIso,
+        idempotencyKey: schedule.idempotencyKey,
+        status: result.run.status === "failed" ? "failed" : "completed",
+        runId: result.run.id
+    };
+}
+function scheduleRunOptions(host, schedule, message, metadata, overrides = {}) {
+    const options = {
+        message,
+        channel: schedule.channel,
+        eventId: schedule.idempotencyKey,
+        metadata,
+        ...overrides
+    };
+    if (schedule.userId)
+        options.userId = schedule.userId;
+    if (schedule.conversationId)
+        options.conversationId = schedule.conversationId;
+    if (schedule.projectId)
+        options.projectId = schedule.projectId;
+    if (schedule.delivery)
+        options.delivery = schedule.delivery;
+    if (schedule.conversationId) {
+        options.turn = {
+            eventId: schedule.idempotencyKey,
+            channel: schedule.channel,
+            conversationId: schedule.conversationId,
+            message,
+            ...(schedule.userId ? { userId: schedule.userId } : {}),
+            ...(schedule.delivery ? { delivery: schedule.delivery } : {}),
+            ...(schedule.turnMetadata ? { metadata: schedule.turnMetadata } : {})
+        };
+    }
+    return options;
+}
+async function runTriggeredSchedule(host, schedule) {
+    const trigger = schedule.trigger;
+    if (!trigger)
+        throw new Error(`Schedule ${schedule.resultSchedule} has no trigger definition.`);
+    const handler = automationHandlers(host).find((candidate) => candidate.name === trigger.handler);
+    if (!handler)
+        throw new Error(`Trigger handler not found: ${trigger.handler}`);
+    const invocation = {
+        kind: schedule.automationEvent ? "event" : "schedule",
+        source: schedule.source,
+        ...(schedule.automationEvent
+            ? { automation: schedule.resultSchedule, event: schedule.automationEvent }
+            : { schedule: schedule.resultSchedule, dueAt: schedule.dueAtIso }),
+        handler: handler.name,
+        idempotencyKey: schedule.idempotencyKey
+    };
+    if (trigger.metadata)
+        invocation.metadata = trigger.metadata;
+    let run = await host.state.createRun({
+        agentRevision: host.manifest.agentRevision,
+        status: "created",
+        input: {
+            message: schedule.message,
+            model: host.manifest.agent.model,
+            channel: schedule.channel,
+            eventId: schedule.idempotencyKey,
+            conversationId: schedule.conversationId ?? null,
+            userId: schedule.userId ?? null,
+            projectId: schedule.projectId ?? null,
+            delivery: schedule.delivery ?? null,
+            metadata: {
+                ...schedule.metadata,
+                trigger: safeJson(invocation)
+            }
+        }
+    });
+    await host.state.recordScheduleRun({
+        scheduleId: schedule.resultSchedule,
+        runId: run.id,
+        runAt: schedule.dueAtIso,
+        idempotencyKey: schedule.idempotencyKey,
+        status: "preparing"
+    });
+    const definition = await loadTriggerHandler(host, handler);
+    const prepareStartedAt = timestamp();
+    let prepareResult = {};
+    let prepareContext = { runId: run.id };
+    try {
+        await host.state.appendEvent(run.id, "trigger.prepare_started", {
+            handler: handler.name,
+            schedule: schedule.resultSchedule,
+            source: schedule.source,
+            dueAt: schedule.dueAtIso,
+            idempotencyKey: schedule.idempotencyKey
+        });
+        const prepared = await definition.prepare?.(createTriggerHandlerContext(host, run, schedule, invocation, {}));
+        prepareResult = normalizeTriggerPrepareResult(prepared);
+        prepareContext = triggerPrepareContext(run.id, prepareResult);
+        await host.state.appendEvent(run.id, "trigger.prepare_completed", {
+            handler: handler.name,
+            target: safeJson(prepareResult.target ?? trigger.target ?? null),
+            promptContext: safeJson(prepareResult.promptContext ?? {})
+        });
+        await host.emitSpan("ai.assembly-line.trigger.prepare", prepareStartedAt, host.runSpanAttributes(run, {
+            triggerHandler: handler.name,
+            schedule: schedule.resultSchedule,
+            scheduleSource: schedule.source,
+            status: "completed"
+        }), {
+            parentSpanId: host.turnSpanId(run.id),
+            status: "ok"
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await host.state.appendEvent(run.id, "trigger.prepare_failed", { handler: handler.name, error: message });
+        run = await failRun({ state: host.state }, run.id, { reason: "trigger.prepare_failed", error: message });
+        await host.state.recordScheduleRun({
+            scheduleId: schedule.resultSchedule,
+            runId: run.id,
+            runAt: schedule.dueAtIso,
+            idempotencyKey: schedule.idempotencyKey,
+            status: "failed"
+        });
+        await host.emitSpan("ai.assembly-line.trigger.prepare", prepareStartedAt, host.runSpanAttributes(run, {
+            triggerHandler: handler.name,
+            schedule: schedule.resultSchedule,
+            scheduleSource: schedule.source,
+            status: "failed",
+            error: message
+        }), {
+            parentSpanId: host.turnSpanId(run.id),
+            status: "error"
+        });
+        return { schedule: schedule.resultSchedule, dueAt: schedule.dueAtIso, idempotencyKey: schedule.idempotencyKey, status: "failed", runId: run.id, error: message };
+    }
+    const target = prepareResult.target ?? trigger.target ?? schedule.target;
+    const promptContext = {
+        triggerKind: invocation.kind,
+        triggerSource: invocation.source ?? "manifest",
+        triggerKey: invocation.idempotencyKey,
+        ...(schedule.automationEvent
+            ? {
+                automation: schedule.resultSchedule,
+                event: safeJson(schedule.automationEvent)
+            }
+            : {
+                schedule: schedule.resultSchedule,
+                dueAt: schedule.dueAtIso
+            }),
+        runId: run.id,
+        ...(prepareResult.promptContext ?? {})
+    };
+    const metadata = {
+        ...schedule.metadata,
+        trigger: safeJson(invocation),
+        promptContext,
+        ...(prepareResult.metadata ?? {})
+    };
+    const message = prepareResult.message ?? prepareResult.prompt ?? schedule.message ?? `Run scheduled trigger ${handler.name}.`;
+    let runResult;
+    let finalizeResult;
+    try {
+        await host.state.recordScheduleRun({
+            scheduleId: schedule.resultSchedule,
+            runId: run.id,
+            runAt: schedule.dueAtIso,
+            idempotencyKey: schedule.idempotencyKey,
+            status: "running"
+        });
+        const runOptions = scheduleRunOptions(host, schedule, message, metadata, {
+            existingRun: run,
+            promptContext
+        });
+        if (target)
+            runOptions.target = target;
+        runResult = await host.run(runOptions);
+        run = runResult.run;
+        const failureMessage = run.status === "failed" ? await host.latestRunFailureMessage(run.id) : undefined;
+        finalizeResult = {
+            ok: run.status !== "failed",
+            runId: run.id,
+            status: run.status,
+            summary: runResult.response ?? "",
+            response: runResult.response ?? "",
+            metadata: {
+                eventCount: runResult.events.length,
+                toolCallCount: runResult.toolCalls.length
+            }
+        };
+        if (failureMessage)
+            finalizeResult.error = failureMessage;
+    }
+    catch (error) {
+        const messageText = error instanceof Error ? error.message : String(error);
+        await host.state.appendEvent(run.id, "trigger.model_failed", { handler: handler.name, error: messageText });
+        run = await failRun({ state: host.state }, run.id, { reason: "trigger.model_failed", error: messageText });
+        finalizeResult = {
+            ok: false,
+            runId: run.id,
+            status: "failed",
+            summary: messageText,
+            error: messageText
+        };
+    }
+    const finalizeStartedAt = timestamp();
+    try {
+        await host.state.appendEvent(run.id, "trigger.finalize_started", {
+            handler: handler.name,
+            ok: finalizeResult.ok,
+            status: finalizeResult.status ?? null
+        });
+        await definition.finalize?.(createTriggerHandlerContext(host, run, schedule, invocation, prepareContext), finalizeResult);
+        await host.state.appendEvent(run.id, "trigger.finalize_completed", {
+            handler: handler.name,
+            ok: finalizeResult.ok,
+            status: finalizeResult.status ?? null
+        });
+        await host.emitSpan("ai.assembly-line.trigger.finalize", finalizeStartedAt, host.runSpanAttributes(run, {
+            triggerHandler: handler.name,
+            schedule: schedule.resultSchedule,
+            scheduleSource: schedule.source,
+            status: "completed",
+            resultOk: finalizeResult.ok
+        }), {
+            parentSpanId: host.turnSpanId(run.id),
+            status: "ok"
+        });
+    }
+    catch (error) {
+        const messageText = error instanceof Error ? error.message : String(error);
+        await host.state.appendEvent(run.id, "trigger.finalize_failed", { handler: handler.name, error: messageText });
+        run = await failRun({ state: host.state }, run.id, { reason: "trigger.finalize_failed", error: messageText });
+        await host.emitSpan("ai.assembly-line.trigger.finalize", finalizeStartedAt, host.runSpanAttributes(run, {
+            triggerHandler: handler.name,
+            schedule: schedule.resultSchedule,
+            scheduleSource: schedule.source,
+            status: "failed",
+            error: messageText
+        }), {
+            parentSpanId: host.turnSpanId(run.id),
+            status: "error"
+        });
+        finalizeResult = {
+            ...finalizeResult,
+            ok: false,
+            status: "failed",
+            error: messageText,
+            summary: messageText
+        };
+    }
+    const finalRun = await host.state.getRun(run.id) ?? run;
+    await host.state.recordScheduleRun({
+        scheduleId: schedule.resultSchedule,
+        runId: finalRun.id,
+        runAt: schedule.dueAtIso,
+        idempotencyKey: schedule.idempotencyKey,
+        status: finalRun.status
+    });
+    return {
+        schedule: schedule.resultSchedule,
+        dueAt: schedule.dueAtIso,
+        idempotencyKey: schedule.idempotencyKey,
+        status: finalRun.status === "failed" || !finalizeResult.ok ? "failed" : "completed",
+        runId: finalRun.id,
+        ...(finalizeResult.error ? { error: finalizeResult.error } : {})
+    };
+}
+async function loadTriggerHandler(host, handler) {
+    const module = await host.sourceLoader.load(handler.source);
+    const candidates = [module.default, module[handler.name], ...Object.values(module)];
+    const definition = candidates.find(isTriggerHandlerDefinition);
+    if (!definition)
+        throw new Error(`Trigger handler ${handler.name} did not export a trigger handler definition.`);
+    return definition;
+}
+export function normalizeScheduleTriggerDefinitionImpl(host, value) {
+    if (!isJsonObject(value))
+        throw new Error("Schedule trigger must be an object.");
+    const handler = stringValue(value.handler);
+    if (!handler)
+        throw new Error("Schedule trigger requires handler.");
+    if (!automationHandlers(host).some((candidate) => candidate.name === handler)) {
+        throw new Error(`Unknown trigger handler: ${handler}`);
+    }
+    const trigger = { handler };
+    if (value.target !== undefined && value.target !== null) {
+        trigger.target = normalizeTriggerTarget(value.target);
+    }
+    if (value.metadata !== undefined) {
+        if (!isJsonObject(value.metadata))
+            throw new Error("Schedule trigger metadata must be an object.");
+        trigger.metadata = value.metadata;
+    }
+    return trigger;
+}
+function normalizeTriggerTarget(value) {
+    if (!isJsonObject(value))
+        throw new Error("Schedule trigger target must be an object.");
+    const type = stringValue(value.type);
+    if (type === "skill") {
+        const name = stringValue(value.name);
+        if (!name)
+            throw new Error("Skill trigger targets require name.");
+        return { type, name, ...(isJsonObject(value.metadata) ? { metadata: value.metadata } : {}) };
+    }
+    if (type === "agent") {
+        const name = stringValue(value.name);
+        const model = stringValue(value.model);
+        const target = { type };
+        if (name)
+            target.name = name;
+        if (model)
+            target.model = model;
+        if (isJsonObject(value.metadata))
+            target.metadata = value.metadata;
+        return target;
+    }
+    if (type === "playbook") {
+        const name = stringValue(value.name);
+        if (!name)
+            throw new Error("Playbook trigger targets require name.");
+        return { type, name, ...(isJsonObject(value.metadata) ? { metadata: value.metadata } : {}) };
+    }
+    throw new Error(`Unsupported schedule trigger target type: ${type || "missing"}`);
+}
+function createTriggerHandlerContext(host, run, schedule, trigger, prepare) {
+    const sandboxHandle = host.createSandboxHandle(() => run, () => undefined, () => buildDefaultContextBundle(host.manifest, {
+        message: typeof run.input.message === "string" ? run.input.message : schedule.message,
+        channel: schedule.channel
+    }));
+    return {
+        runId: run.id,
+        agentRevision: host.manifest.agentRevision,
+        trigger,
+        state: createTriggerStateApi(host, run),
+        memory: host.createMemoryToolApi(run),
+        resources: createTriggerResourceApi(host, run, sandboxHandle),
+        blob: {
+            put: async (key, value, contentTypeOrOptions) => host.blob.put(key, value, contentTypeOrOptions),
+            get: async (key) => host.blob.get(key)
+        },
+        schedule: {
+            definition: schedule.definition,
+            run: {
+                scheduleId: schedule.resultSchedule,
+                runId: run.id,
+                runAt: trigger.dueAt ?? trigger.event?.occurredAt ?? schedule.dueAtIso,
+                idempotencyKey: trigger.idempotencyKey
+            }
+        },
+        env: host.env,
+        fetch: host.fetch,
+        prepare,
+        emit: async (eventType, data = {}) => {
+            await host.state.appendEvent(run.id, eventType, data);
+        },
+        idempotencyKey: (scope) => `${trigger.idempotencyKey}:${scope}`,
+        step: (key, fn, options) => host.durableStep(run.id, key, fn, options)
+    };
+}
+function createTriggerStateApi(host, run) {
+    const runtime = host;
+    return {
+        async upsertRoutineRun(input) {
+            const current = await runtime.state.getRun(run.id) ?? run;
+            const metadata = isJsonObject(current.input.metadata) ? current.input.metadata : {};
+            const existing = isJsonObject(metadata.routineRun) ? metadata.routineRun : {};
+            const record = normalizeRoutineRunRecord({
+                existing,
+                runId: run.id,
+                kind: input.kind,
+                triggerKey: input.triggerKey,
+                status: input.status ?? (stringValue(existing.status) || current.status),
+                metadata: input.metadata ?? (isJsonObject(existing.metadata) ? existing.metadata : {})
+            });
+            await runtime.state.updateRun(run.id, {
+                input: {
+                    ...current.input,
+                    metadata: {
+                        ...metadata,
+                        routineRun: safeJson(record)
+                    }
+                }
+            });
+            await runtime.state.appendEvent(run.id, "routine.run_upserted", safeJson(record));
+            return record;
+        },
+        async completeRoutineRun(input) {
+            const current = await runtime.state.getRun(run.id) ?? run;
+            const metadata = isJsonObject(current.input.metadata) ? current.input.metadata : {};
+            const existing = isJsonObject(metadata.routineRun) ? metadata.routineRun : {};
+            const completeInput = {
+                existing,
+                runId: input.runId || run.id,
+                kind: stringValue(existing.kind) || "routine",
+                triggerKey: stringValue(existing.triggerKey) || "",
+                status: input.status,
+                metadata: input.metadata ?? (isJsonObject(existing.metadata) ? existing.metadata : {})
+            };
+            if (input.summary)
+                completeInput.summary = input.summary;
+            const record = normalizeRoutineRunRecord(completeInput);
+            await runtime.state.updateRun(run.id, {
+                input: {
+                    ...current.input,
+                    metadata: {
+                        ...metadata,
+                        routineRun: safeJson(record)
+                    }
+                }
+            });
+            await runtime.state.appendEvent(run.id, "routine.run_completed", safeJson(record));
+            return record;
+        }
+    };
+}
+function createTriggerResourceApi(host, run, sandboxHandle) {
+    const base = host.createResourceToolApi(run, sandboxHandle);
+    return {
+        ...base,
+        collect: async (input = {}) => collectTriggerResources(host, run, input)
+    };
+}
+async function collectTriggerResources(host, run, input = {}) {
+    const requested = new Set(input.sources ?? ["memory", "history", "connections"]);
+    const limit = positiveLimit(input.limit, 50);
+    const resources = [];
+    const sections = [];
+    if (requested.has("memory")) {
+        const documents = await host.memoryStore.list(host.memoryScopeForRun(run), { limit });
+        resources.push(...documents.map((document) => memoryDocumentSummary(document)));
+        if (documents.length > 0) {
+            sections.push([
+                "# Memory",
+                ...documents.map((document) => [
+                    `## ${document.path}`,
+                    memoryBodyText(document)
+                ].join("\n"))
+            ].join("\n\n"));
+        }
+    }
+    if (requested.has("history")) {
+        const conversationId = typeof run.input.conversationId === "string" ? run.input.conversationId : undefined;
+        const messages = conversationId ? await host.state.listRecentMessages(conversationId, limit) : [];
+        resources.push(...messages.map((message) => ({
+            kind: "history",
+            role: message.role,
+            createdAt: message.createdAt,
+            runId: message.runId ?? null
+        })));
+        if (messages.length > 0) {
+            sections.push([
+                "# History",
+                ...messages.map((message) => {
+                    const text = typeof message.content.text === "string" ? message.content.text : JSON.stringify(message.content);
+                    return `- ${message.role}: ${text}`;
+                })
+            ].join("\n"));
+        }
+    }
+    if (requested.has("connections")) {
+        const connections = host.mergedConnections().slice(0, limit);
+        resources.push(...connections.map((connection) => ({
+            kind: "connection",
+            name: connection.name,
+            protocol: connection.protocol,
+            provider: connection.provider,
+            required: connection.required
+        })));
+        if (connections.length > 0) {
+            sections.push([
+                "# Connections",
+                ...connections.map((connection) => `- ${connection.name} (${connection.protocol}, ${connection.provider})`)
+            ].join("\n"));
+        }
+    }
+    if (requested.has("skills")) {
+        const skills = (await host.skillStore.list(host.skillScope())).filter((skill) => !skill.pending).slice(0, limit);
+        resources.push(...skills.map((skill) => ({
+            kind: "skill",
+            name: skill.name,
+            origin: skill.origin,
+            updatedAt: skill.updatedAt
+        })));
+        if (skills.length > 0) {
+            sections.push([
+                "# Skills",
+                ...skills.map((skill) => `- ${skill.name} (${skill.origin})`)
+            ].join("\n"));
+        }
+    }
+    await host.state.appendEvent(run.id, "trigger.resources_collected", {
+        sources: [...requested],
+        count: resources.length,
+        since: input.since ?? null
+    });
+    return {
+        markdown: sections.join("\n\n").trim(),
+        resources
+    };
+}
+/**
+ * Dispatch application-managed dynamic schedules: atomically lease due rows
+ * and start one durable run per row. At-least-once; tasks should be idempotent.
+ */
+async function runDueDynamicSchedules(host, now) {
+    if (!host.schedulesConfig.dynamic)
+        return [];
+    const results = [];
+    const due = await host.scheduleStore.claimDue({ now, limit: 25, leaseForMs: 5 * 60_000 });
+    for (const job of due) {
+        const dueAtIso = job.nextRunAt;
+        const idempotencyKey = `dynamic:${job.id}:${dueAtIso}`;
+        const leaseToken = job.leaseToken ?? "";
+        try {
+            // openeve_schedule_runs rows reference openeve_schedules; dynamic jobs
+            // live in the schedule store, so upsert a parent row before recording runs.
+            await host.state.registerSchedule({
+                id: `dynamic:${job.id}`,
+                name: `dynamic:${job.id}`,
+                cron: job.cron ?? (job.everyMinutes ? `@every ${job.everyMinutes}m` : `@at ${dueAtIso}`),
+                ...(job.timezone ? { timezone: job.timezone } : {}),
+                metadata: { source: "dynamic", scope: job.scope }
+            });
+            const schedule = dynamicScheduleExecution(host, job, dueAtIso, idempotencyKey);
+            const result = await runScheduleExecution(host, schedule);
+            await host.scheduleStore.complete(job.id, leaseToken, { ranAt: dueAtIso });
+            if (result.runId) {
+                await host.state.appendEvent(result.runId, "schedule.dynamic_dispatched", {
+                    dynamicScheduleId: job.id,
+                    dueAt: dueAtIso,
+                    trigger: job.trigger ? safeJson(job.trigger) : null
+                });
+            }
+            results.push(result);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            try {
+                await host.state.recordScheduleRun({
+                    scheduleId: `dynamic:${job.id}`,
+                    runAt: dueAtIso,
+                    idempotencyKey,
+                    status: "failed"
+                });
+            }
+            catch (recordError) {
+                host.logger.warn("dynamic schedule failure bookkeeping failed", {
+                    dynamicScheduleId: job.id,
+                    error: recordError instanceof Error ? recordError.message : String(recordError)
+                });
+            }
+            // Escalating backoff on the failure streak (5min base, 2x, capped 6h);
+            // the store disables the schedule atomically once the streak hits the
+            // cap so a poison schedule cannot burn a model run every cycle forever.
+            const failureStreak = (job.consecutiveFailures ?? 0) + 1;
+            const retryDelayMs = Math.min(300_000 * 2 ** (failureStreak - 1), 6 * 3_600_000);
+            const disabled = failureStreak >= host.scheduleMaxConsecutiveFailures;
+            await host.scheduleStore.release(job.id, leaseToken, new Date(now.getTime() + retryDelayMs), {
+                maxConsecutiveFailures: host.scheduleMaxConsecutiveFailures
+            });
+            if (disabled) {
+                host.logger.warn("dynamic schedule disabled after consecutive failures", {
+                    dynamicScheduleId: job.id,
+                    scope: job.scope,
+                    consecutiveFailures: failureStreak,
+                    error: message
+                });
+                if (isRuntimeSettingsStore(host.state)) {
+                    await host.state.appendRuntimeControlEvent(job.scope, "schedule.disabled_after_failures", {
+                        dynamicScheduleId: job.id,
+                        consecutiveFailures: failureStreak,
+                        error: message
+                    }).catch(() => undefined);
+                }
+            }
+            results.push({ schedule: `dynamic:${job.id}`, dueAt: dueAtIso, idempotencyKey, status: "failed", error: message });
+        }
+    }
+    return results;
+}
+function dynamicScheduleExecution(host, job, dueAtIso, idempotencyKey) {
+    const target = isJsonObject(job.target) ? job.target : {};
+    const targetConversation = typeof target.conversationId === "string" ? target.conversationId : undefined;
+    const targetProject = typeof target.projectId === "string" ? target.projectId : undefined;
+    const conversationId = job.conversationId ?? targetConversation;
+    const projectId = job.projectId ?? targetProject;
+    const delivery = isJsonObject(job.target) ? job.target : undefined;
+    const message = dynamicScheduleMessage(job);
+    const trigger = job.trigger ? normalizeScheduleTriggerDefinitionImpl(host, job.trigger) : undefined;
+    const metadata = {
+        ...(job.metadata ?? {}),
+        dynamicScheduleId: job.id,
+        scope: job.scope,
+        source: "dynamic",
+        schedule: `dynamic:${job.id}`,
+        dueAt: dueAtIso,
+        idempotencyKey
+    };
+    if (job.target)
+        metadata.target = safeJson(job.target);
+    const definition = { ...job };
+    if (trigger)
+        definition.trigger = trigger;
+    return {
+        source: "dynamic",
+        scheduleId: job.id,
+        resultSchedule: `dynamic:${job.id}`,
+        dueAtIso,
+        idempotencyKey,
+        message,
+        channel: job.channel,
+        ...(trigger ? { trigger } : {}),
+        metadata,
+        definition: safeJson(definition),
+        ...(job.userId ? { userId: job.userId } : {}),
+        ...(conversationId ? { conversationId } : {}),
+        ...(projectId ? { projectId } : {}),
+        ...(delivery ? { delivery } : {})
+    };
+}
+export async function startSchedulerPollingLoopImpl(host) {
+    if (!hasScheduledWork(host))
+        return undefined;
+    await registerManifestSchedulesImpl(host);
+    let inFlight = false;
+    const tick = async () => {
+        if (inFlight)
+            return [];
+        inFlight = true;
+        try {
+            return await runDueSchedulesImpl(host, { now: host.now(), lookbackMs: host.schedulerTickMs });
+        }
+        catch (error) {
+            // The interval invokes tick as a floating promise; a throw here would
+            // become an unhandled rejection and take down the whole process.
+            host.logger.error("scheduler tick failed", {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return [];
+        }
+        finally {
+            inFlight = false;
+        }
+    };
+    const timer = setInterval(() => {
+        void tick();
+    }, host.schedulerTickMs);
+    timer.unref?.();
+    void tick();
+    return {
+        stop() {
+            clearInterval(timer);
+        },
+        tick
+    };
+}
+function hasScheduledWork(host) {
+    if (host.schedulesConfig.dynamic)
+        return true;
+    return manifestScheduleRegistrations(host).length > 0;
+}
+function compiledSchedule(host, name) {
+    return host.manifest.automations?.find((automation) => automation.name === name)
+        ?? host.manifest.schedules.find((schedule) => schedule.name === name);
+}
+function scheduleMessage(host, name) {
+    const registration = manifestScheduleRegistrations(host).find((schedule) => schedule.schedule === name);
+    const compiled = compiledSchedule(host, name);
+    return registration?.message ?? compiled?.message ?? compiled?.description ?? `Run schedule ${name}.`;
+}
+function automationHandlers(host) {
+    return host.manifest.automationHandlers?.length
+        ? host.manifest.automationHandlers
+        : host.manifest.triggerHandlers ?? [];
+}
+function manifestScheduleRegistrations(host) {
+    if (Array.isArray(host.manifest.automationRegistrations)) {
+        return host.manifest.automationRegistrations.flatMap((automation) => {
+            if (automation.trigger.type !== "schedule")
+                return [];
+            const registration = {
+                schedule: automation.automation,
+                cron: automation.trigger.cron,
+                idempotencyKey: automation.idempotencyKey
+            };
+            if (automation.trigger.timezone)
+                registration.timezone = automation.trigger.timezone;
+            if (automation.message)
+                registration.message = automation.message;
+            if (automation.target)
+                registration.target = automation.target;
+            if (automation.lifecycle) {
+                registration.trigger = {
+                    handler: automation.lifecycle.handler,
+                    ...(automation.target ? { target: automation.target } : {}),
+                    ...(automation.metadata ? { metadata: automation.metadata } : {})
+                };
+            }
+            return [registration];
+        });
+    }
+    return host.manifest.scheduleRegistrations ?? [];
+}
+//# sourceMappingURL=schedule-execution.js.map