@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/runtime/runtime-environment.js

@@ -1,20 +1,45 @@
 import { createRuntimeProjectService } from "./projects/service.js";
+import { traceDebug } from "./observability/debug-logger.js";
+import { createRuntimePassiveLearning } from "./adapters/passive-learning-runtime.js";
 import { createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultModelGatewayClient, createDefaultLongTermMemoryService, createDefaultSessionStore, createDefaultToolRegistry, } from "./default-environment-adapters.js";
 import { createBoundRuntimeRequestHandler } from "./request/bound-runtime-handler.js";
 import { createModelSessionMemoryCompactor } from "./context/session-memory/index.js";
 import { createSessionLifecycleStore } from "./session/session-lifecycle-store.js";
+import { createSparkSessionClearBoundary } from "./session/spark-session-clear.js";
 import { bindManagedSessionAttachmentDeletion, deleteSessionAttachmentsIfSupported, } from "./session/session-attachment-deletion.js";
 import { SessionRequestAdmission } from "./request/session-admission.js";
 import { createRuntimeScheduler } from "./adapters/scheduler-runtime.js";
+import { createAutomationPersistence } from "./automations/persistence.js";
+import { createAutomationResultStore } from "./automations/result-store.js";
+import { createAutomationNodeTransactions } from "./automations/node-transactions.js";
+import { createAutomationService } from "./automations/service.js";
+import { createAutomationRuntimeExecutor } from "./automations/runtime-executor.js";
+import { compileAutomationGraph } from "./automations/graph-validation.js";
+import { executeAutomationGraph } from "./automations/graph-executor.js";
+import { createAutomationStepRunner } from "./automations/step-runner.js";
+import { createAutomationAgentStepExecutor } from "./automations/agent-step-executor.js";
+import { createAutomationReportService } from "./automations/run-report.js";
+import { readAutomationCatalog } from "./automations/catalog.js";
+import { fingerprintAutomationDependencies } from "./automations/dependency-fingerprint.js";
+import { validateAutomationWorkingDirectory } from "./automations/working-directory.js";
+import { createAutomationModelCapacity } from "./automations/model-capacity.js";
+import { createAutomationToolLifetimes } from "./automations/tool-lifetimes.js";
 // Composition metadata, never request state. A rebound graph retains caller
 // supplied adapters while replacing closures that belong to its old scheduler.
 const environmentCompositions = new WeakMap();
 export function createRuntimeEnvironment(config, overrides = {}) {
     const backingSessions = overrides.sessions ?? createDefaultSessionStore(config);
     const attachments = overrides.attachments ?? createDefaultAttachmentStore(config);
-    const sessionLifecycle = createSessionLifecycleStore(backingSessions, (result) => deleteSessionAttachmentsIfSupported(attachments, result.sessionId));
+    const sessionLifecycle = createSessionLifecycleStore(backingSessions, (result) => deleteSessionAttachmentsIfSupported(attachments, result.sessionId), undefined, createSparkSessionClearBoundary(backingSessions, () => admission, attachments, config.paths.runtimeDir));
     bindManagedSessionAttachmentDeletion(sessionLifecycle.store, attachments);
-    const admission = new SessionRequestAdmission(sessionLifecycle.isDeleted);
+    const admission = new SessionRequestAdmission(sessionLifecycle.isDeleted, async (sessionId) => Boolean((await sessionLifecycle.store.requestLifecycle?.listWaiting(sessionId))
+        ?.length));
+    let boundAutomationExecutor;
+    function requireAutomationExecutor() {
+        if (!boundAutomationExecutor)
+            throw new Error("automation_executor_not_ready");
+        return boundAutomationExecutor;
+    }
     const scheduling = createRuntimeScheduler({
         config,
         sessions: sessionLifecycle.store,
@@ -22,17 +47,179 @@ export function createRuntimeEnvironment(config, overrides = {}) {
         isDeleted: sessionLifecycle.isDeleted,
         handle: (ws, message, options) => rawRequests.handle(ws, message, options),
         requestOptions: overrides.scheduledRequestOptions,
+        automationExecutor: {
+            prepare: (...args) => requireAutomationExecutor().prepare(...args),
+            prepareReplay: (...args) => requireAutomationExecutor().prepareReplay(...args),
+            start: (...args) => requireAutomationExecutor().start(...args),
+            stop: (...args) => requireAutomationExecutor().stop(...args),
+            recover: (...args) => requireAutomationExecutor().recover(...args),
+            reconcileSessions: () => requireAutomationExecutor().reconcileSessions(),
+            settle: (...args) => requireAutomationExecutor().settle(...args),
+            cancelPending: (...args) => requireAutomationExecutor().cancelPending(...args),
+            maintainRetention: (...args) => requireAutomationExecutor().maintainRetention(...args),
+        },
     });
     sessionLifecycle.onDeleted(async (sessionId) => {
         await scheduling.ensureStarted();
         await scheduling.scheduler.deleteSession(sessionId);
     });
+    let automations;
+    function requireAutomations() {
+        if (!automations)
+            throw new Error("automation_service_not_ready");
+        return automations;
+    }
     const tools = overrides.tools ??
         createDefaultToolRegistry(config, {
             service: scheduling.scheduler,
             ready: scheduling.ensureStarted,
+        }, {
+            getService: requireAutomations,
+            ready: scheduling.ensureStarted,
         });
     const models = overrides.models ?? createDefaultModelGatewayClient(config);
+    const automationPersistence = createAutomationPersistence(scheduling.store);
+    const automationResults = createAutomationResultStore(config.paths.runtimeDir);
+    const automationTransactions = createAutomationNodeTransactions({
+        persistence: automationPersistence,
+    });
+    const automationModelCapacity = createAutomationModelCapacity();
+    const automationToolLifetimes = createAutomationToolLifetimes();
+    automations = createAutomationService({
+        config,
+        scheduler: scheduling.scheduler,
+        persistence: automationPersistence,
+        results: automationResults,
+        tools,
+    });
+    const automationReports = createAutomationReportService({
+        persistence: automationPersistence,
+        results: automationResults,
+    });
+    boundAutomationExecutor = createAutomationRuntimeExecutor({
+        config,
+        sessions: backingSessions,
+        persistence: automationPersistence,
+        attachments,
+        results: automationResults,
+        toolLifetimes: automationToolLifetimes,
+        async execute(_job, run, signal) {
+            const state = await automationPersistence.read();
+            const published = state.definitions.find((entry) => entry.automationId === run.target.automationId &&
+                entry.revision === run.target.definitionRevision);
+            const definition = published?.definition;
+            if (!definition)
+                return {
+                    status: "failed", error: "automation_definition_not_found",
+                    reportRef: `derived:${run.id}`,
+                };
+            const workingDirectoryIssue = validateAutomationWorkingDirectory(definition.workingDirectory);
+            if (workingDirectoryIssue)
+                return {
+                    status: "failed", error: workingDirectoryIssue.code,
+                    reportRef: `derived:${run.id}`,
+                };
+            const compiled = compileAutomationGraph(definition);
+            if (!compiled.ok)
+                return {
+                    status: "failed", error: "automation_graph_invalid",
+                    reportRef: `derived:${run.id}`,
+                };
+            if (published.dependencyFingerprint) {
+                const available = await readAutomationCatalog({
+                    automationId: run.target.automationId,
+                    environmentId: config.runtimeId,
+                    config, tools, persistence: automationPersistence,
+                });
+                if (fingerprintAutomationDependencies({
+                    definition, config, operations: available.operations,
+                }) !== published.dependencyFingerprint)
+                    return {
+                        status: "failed", error: "automation_contract_changed",
+                        reportRef: `derived:${run.id}`,
+                    };
+            }
+            const agent = createAutomationAgentStepExecutor({
+                // Agent attempts own their deletion guard; user-session tombstones are permanent.
+                config, sessions: backingSessions, attachments, models, tools,
+                modelCapacity: automationModelCapacity,
+                toolLifetimes: automationToolLifetimes,
+                persistence: automationPersistence, results: automationResults,
+                transactions: automationTransactions, grants: { get: automations.getGrant },
+                automationId: run.target.automationId, runId: run.id, definition,
+            });
+            const steps = createAutomationStepRunner({
+                runId: run.id, automationId: run.target.automationId,
+                definition, graph: compiled.graph, config, tools, attachments,
+                persistence: automationPersistence, results: automationResults,
+                transactions: automationTransactions, grants: { get: automations.getGrant },
+                toolLifetimes: automationToolLifetimes,
+                executeAgent: ({ step, inputs, sourceAttachments, signal: stepSignal }) => {
+                    if (step.node.kind !== "agent")
+                        throw new Error("automation_node_kind_invalid");
+                    return agent.execute({ node: step.node, inputs, sourceAttachments, signal: stepSignal });
+                },
+            });
+            try {
+                const outcome = await executeAutomationGraph({
+                    runId: run.id, automationId: run.target.automationId,
+                    definition, inputIds: state.executions.find((entry) => entry.id === run.id)?.inputIds ?? [],
+                    graph: compiled.graph, transactions: automationTransactions,
+                    abortSignal: signal, executeStep: steps.run,
+                });
+                const current = await automationTransactions.get(run.id);
+                if (!current || current.nodes.some((node) => node.status === "pending" || node.status === "ready" || node.status === "running"))
+                    throw new Error("automation_run_not_settled");
+                let reportRef;
+                try {
+                    const report = await automationReports.create({
+                        run,
+                        definition,
+                        outcome: outcome.status,
+                    });
+                    reportRef = report.record.id;
+                }
+                catch (error) {
+                    if (!(error instanceof Error) ||
+                        error.message !== "automation_artifact_budget_exhausted")
+                        throw error;
+                    // The durable node state can still project a compact report at capacity.
+                    reportRef = `derived:${run.id}`;
+                }
+                return {
+                    status: outcome.status,
+                    ...(outcome.errorCode ? { error: outcome.errorCode } : {}),
+                    reportRef,
+                };
+            }
+            catch (error) {
+                return {
+                    status: "failed", error: error instanceof Error ? error.message : "automation_run_failed",
+                    reportRef: `derived:${run.id}`,
+                };
+            }
+        },
+    });
+    const longTermMemory = overrides.longTermMemory ??
+        createDefaultLongTermMemoryService(config, models);
+    const passiveLearning = overrides.passiveLearning ??
+        createRuntimePassiveLearning({
+            config,
+            models,
+            memory: longTermMemory,
+            sessions: sessionLifecycle.store,
+            deliveryAdmission: admission,
+        });
+    sessionLifecycle.onDeleted(async (sessionId) => {
+        try {
+            await passiveLearning.sessionDeleted?.(sessionId);
+        }
+        catch {
+            traceDebug("runtime.passive_learning", "proposal.session_cleanup_failed", {
+                reason: "proactive_session_cleanup_failed",
+            });
+        }
+    });
     const services = Object.freeze({
         config,
         sessions: sessionLifecycle.store,
@@ -42,8 +229,9 @@ export function createRuntimeEnvironment(config, overrides = {}) {
         models,
         events: overrides.events ?? createDefaultEventSinkFactory(config),
         sessionMemoryCompactor: overrides.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
-        longTermMemory: overrides.longTermMemory ??
-            createDefaultLongTermMemoryService(config, models),
+        longTermMemory,
+        passiveLearning,
+        automations,
         scheduler: scheduling.scheduler,
         startScheduler: scheduling.start,
         stopScheduler: scheduling.stop,
@@ -67,11 +255,37 @@ export function createRuntimeEnvironment(config, overrides = {}) {
             });
         },
     });
+    let unsubscribeInjectedLearning;
     return {
         services,
         requests,
-        start: scheduling.start,
-        stop: scheduling.stop,
+        async start() {
+            await scheduling.start();
+            await longTermMemory.retention?.start();
+            const notifyInjectedLearning = overrides.passiveLearning?.notifyKnowledgeChanged;
+            if (notifyInjectedLearning) {
+                unsubscribeInjectedLearning ??= longTermMemory.subscribeChanges?.(() => {
+                    overrides.passiveLearning.notifyKnowledgeChanged();
+                });
+            }
+            try {
+                await passiveLearning.start();
+            }
+            catch (error) {
+                unsubscribeInjectedLearning?.();
+                unsubscribeInjectedLearning = undefined;
+                throw error;
+            }
+        },
+        async stop() {
+            unsubscribeInjectedLearning?.();
+            unsubscribeInjectedLearning = undefined;
+            await Promise.all([
+                passiveLearning.stop(),
+                scheduling.stop(),
+                longTermMemory.retention?.stop(),
+            ]);
+        },
         subscribeScheduledEvents: scheduling.subscribe,
     };
 }

package/dist/src/runtime/runtime-host-scheduler-ownership.js

@@ -17,7 +17,11 @@ export function acquireHostScheduler(services) {
         }
         if (owner.started) {
             owner.stopping = (async () => {
-                await services?.stopScheduler?.();
+                await Promise.all([
+                    services?.stopScheduler?.(),
+                    services?.passiveLearning?.stop(),
+                    services?.longTermMemory?.retention?.stop(),
+                ]);
             })();
         }
         owner.stopping ??= Promise.resolve();
@@ -61,6 +65,13 @@ function retainSchedulerOwner(key, services) {
             return;
         owner.started = true;
         await services.startScheduler?.();
+        if (!hasSchedulerHostReferences(owner))
+            return;
+        await services.longTermMemory?.retention?.start();
+        if (!hasSchedulerHostReferences(owner))
+            return;
+        // The compatibility host owns the environment's background learning too.
+        await services.passiveLearning?.start();
     };
     owner.ready = previous?.stopping ? previous.stopping.then(start) : start();
     return owner;

package/dist/src/runtime/scheduler/automation-job-management.d.ts

@@ -0,0 +1,12 @@
+import type { AutomationExecutionRecord, AutomationJournalState } from "../automations/storage-records.js";
+import type { CreateAutomationSchedulerJobInput, SchedulerAutomationJob, SchedulerAutomationRun, UpdateAutomationSchedulerJobInput } from "./contracts.js";
+import { type SchedulerContext } from "./service-context.js";
+type PublicationCommit = (state: AutomationJournalState, candidate: SchedulerAutomationJob) => void;
+export declare function createAutomationSchedulerJob(context: SchedulerContext, input: CreateAutomationSchedulerJobInput, commitPublication?: PublicationCommit): Promise<SchedulerAutomationJob>;
+export declare function updateAutomationSchedulerJob(context: SchedulerContext, jobId: string, patch: UpdateAutomationSchedulerJobInput, commitPublication?: PublicationCommit): Promise<SchedulerAutomationJob>;
+export declare function changeAutomationSchedulerJobState(context: SchedulerContext, jobId: string, target: "active" | "paused"): Promise<SchedulerAutomationJob>;
+export declare function requestAutomationSchedulerRunNow(context: SchedulerContext, jobId: string, options?: {
+    idempotencyKey?: string;
+}): Promise<SchedulerAutomationRun>;
+export declare function requireCommittedAutomationExecution(state: AutomationJournalState, runId: string): AutomationExecutionRecord;
+export {};

package/dist/src/runtime/scheduler/automation-job-management.js

@@ -0,0 +1,288 @@
+import { randomUUID } from "node:crypto";
+import { requireUnarchivedAutomation } from "../automations/archive-management.js";
+import { publishedAutomationScheduleTiming } from "../automations/trigger-schedule.js";
+import { normalizeAutomationSchedule, requireAutomationScheduleOccurrence, hasAutomationScheduleTimingChanged } from "./automation-schedule.js";
+import { hasReachedAutomationDailyRunLimit } from "./automation-run-budget.js";
+import { findPendingAutomationRun, hasActiveAutomationRun, makeAutomationSchedulerRun, requireAutomationSchedulerJob, } from "./automation-run-records.js";
+import { nextSchedulerOccurrence } from "./next-occurrence.js";
+import { canBeginSchedulerRun, invalidateJob, jobEpoch, requireRunningScheduler, } from "./service-context.js";
+import { validateTimeZone } from "./schedule-validation.js";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, } from "./scheduler-target.js";
+function requireAutomationJournalUpdate(context) {
+    const update = context.store.updateWithAutomations;
+    if (!update)
+        throw new Error("automation_store_unavailable");
+    return update;
+}
+function requireAutomationExecutor(context) {
+    const executor = context.automationExecutor;
+    if (!executor)
+        throw new Error("automation_executor_unavailable");
+    return executor;
+}
+function requireAutomationJobInput(input) {
+    if (!input.automationId?.trim())
+        throw new Error("automation_invalid_job");
+    if (!input.title?.trim())
+        throw new Error("automation_invalid_job");
+    if (!Number.isSafeInteger(input.definitionRevision))
+        throw new Error("automation_invalid_job");
+    if (input.definitionRevision < 1)
+        throw new Error("automation_invalid_job");
+    validateTimeZone(input.timeZone);
+}
+export function createAutomationSchedulerJob(context, input, commitPublication) {
+    return context.enqueue(async () => {
+        requireRunningScheduler(context);
+        requireAutomationJobInput(input);
+        const now = context.now();
+        const schedule = normalizeAutomationSchedule(input.schedule, now);
+        const nextRunAt = requireAutomationScheduleOccurrence(schedule, input.timeZone, now);
+        const job = {
+            id: randomUUID(),
+            environmentId: context.environmentId,
+            target: {
+                kind: "automation",
+                automationId: input.automationId,
+                definitionRevision: input.definitionRevision,
+            },
+            title: input.title.trim(),
+            timeZone: input.timeZone,
+            schedule,
+            state: "paused",
+            createdAt: new Date(now).toISOString(),
+            updatedAt: new Date(now).toISOString(),
+            nextRunAt,
+            revision: 1,
+        };
+        const update = requireAutomationJournalUpdate(context);
+        return update((scheduler, automations) => {
+            requireUnarchivedAutomation(automations, input.automationId);
+            if (hasAutomationJob(scheduler, input.automationId))
+                throw new Error("automation_job_exists");
+            commitPublication?.(automations, job);
+            scheduler.jobs.push(job);
+            return job;
+        });
+    });
+}
+function hasAutomationJob(scheduler, automationId) {
+    return scheduler.jobs.some((job) => isAutomationSchedulerJob(job) &&
+        job.target.automationId === automationId);
+}
+export function updateAutomationSchedulerJob(context, jobId, patch, commitPublication) {
+    const settleInvalidation = invalidateJob(context, jobId);
+    return context
+        .enqueue(async () => {
+        requireRunningScheduler(context);
+        const update = requireAutomationJournalUpdate(context);
+        return update((scheduler, automations) => {
+            const job = requireAutomationSchedulerJob(scheduler, jobId);
+            requireUnarchivedAutomation(automations, job.target.automationId);
+            if (job.state === "cancelled")
+                throw new Error("scheduler_job_cancelled");
+            const now = context.now();
+            const draft = automations.drafts.find((item) => item.automationId === job.target.automationId &&
+                item.revision === patch.definitionRevision);
+            const previousTiming = commitPublication
+                ? publishedAutomationScheduleTiming(automations, job, draft?.definition.trigger) : undefined;
+            const candidate = updatedAutomationJob(job, patch, now, previousTiming);
+            commitPublication?.(automations, candidate);
+            if (JSON.stringify(candidate) === JSON.stringify(job))
+                return job;
+            cancelPendingAutomationRuns(context, scheduler, automations, jobId, now, "republished");
+            Object.assign(job, candidate);
+            return job;
+        });
+    })
+        .finally(settleInvalidation);
+}
+function updatedAutomationJob(job, patch, now, previousTiming) {
+    const title = patch.title ?? job.title;
+    const timeZone = patch.timeZone ?? job.timeZone;
+    const definitionRevision = patch.definitionRevision ?? job.target.definitionRevision;
+    requireAutomationJobInput({
+        automationId: job.target.automationId,
+        title,
+        timeZone,
+        definitionRevision,
+        schedule: patch.schedule ?? job.schedule,
+    });
+    if (definitionRevision < job.target.definitionRevision)
+        throw new Error("automation_definition_revision_regressed");
+    const schedule = patch.schedule
+        ? normalizeAutomationSchedule(patch.schedule, now, previousTiming)
+        : job.schedule;
+    const timingChanged = hasAutomationScheduleTimingChanged(schedule, timeZone, job);
+    const nextRunAt = timingChanged
+        ? requireAutomationScheduleOccurrence(schedule, timeZone, now)
+        : job.nextRunAt;
+    const changed = title !== job.title ||
+        timeZone !== job.timeZone ||
+        definitionRevision !== job.target.definitionRevision ||
+        timingChanged;
+    if (!changed)
+        return job;
+    return {
+        ...job,
+        target: { ...job.target, definitionRevision },
+        title: title.trim(),
+        timeZone,
+        schedule,
+        nextRunAt,
+        updatedAt: new Date(now).toISOString(),
+        revision: job.revision + 1,
+        state: job.state === "completed" && timingChanged ? "active" : job.state,
+    };
+}
+function cancelPendingAutomationRuns(context, scheduler, automations, jobId, now, reason) {
+    const at = new Date(now).toISOString();
+    for (const run of scheduler.runs) {
+        if (run.jobId !== jobId || run.status !== "pending")
+            continue;
+        if (!isAutomationSchedulerRun(run))
+            continue;
+        requireAutomationExecutor(context).cancelPending(run, automations, reason);
+        const execution = requireCommittedAutomationExecution(automations, run.id);
+        if (!execution.reportRef)
+            throw new Error("automation_report_missing");
+        run.status = "cancelled";
+        run.reportRef = execution.reportRef;
+        run.finishedAt = at;
+    }
+}
+export function changeAutomationSchedulerJobState(context, jobId, target) {
+    const settleInvalidation = invalidateJob(context, jobId);
+    return context
+        .enqueue(async () => {
+        requireRunningScheduler(context);
+        const update = requireAutomationJournalUpdate(context);
+        return update((scheduler, automations) => {
+            const job = requireAutomationSchedulerJob(scheduler, jobId);
+            if (job.state === "cancelled")
+                throw new Error("scheduler_job_cancelled");
+            const now = context.now();
+            if (target === "active")
+                requireUnarchivedAutomation(automations, job.target.automationId);
+            if (target === "paused") {
+                cancelPendingAutomationRuns(context, scheduler, automations, jobId, now, "paused");
+            }
+            if (job.state === target)
+                return job;
+            job.state = target;
+            job.updatedAt = new Date(now).toISOString();
+            job.revision += 1;
+            if (target !== "active")
+                return job;
+            job.nextRunAt = nextSchedulerOccurrence(job.schedule, job.timeZone, now);
+            if (hasExhaustedAutomationSchedule(job))
+                job.state = "completed";
+            return job;
+        });
+    })
+        .finally(settleInvalidation);
+}
+function hasExhaustedAutomationSchedule(job) {
+    if (job.schedule.kind === "manual")
+        return false;
+    return job.nextRunAt === null;
+}
+export function requestAutomationSchedulerRunNow(context, jobId, options) {
+    return context.enqueue(async () => {
+        requireRunningScheduler(context);
+        const idempotencyKey = options?.idempotencyKey;
+        if (idempotencyKey !== undefined &&
+            (!idempotencyKey || idempotencyKey.length > 128))
+            throw new Error("automation_idempotency_key_invalid");
+        const scheduler = await context.store.read();
+        const job = requireAutomationSchedulerJob(scheduler, jobId);
+        if (job.state === "cancelled")
+            throw new Error("scheduler_job_cancelled");
+        if (!context.store.readAutomations)
+            throw new Error("automation_store_unavailable");
+        requireUnarchivedAutomation(await context.store.readAutomations(), job.target.automationId);
+        if (idempotencyKey) {
+            const readByKey = context.store.readAutomationRunByKey;
+            if (!readByKey)
+                throw new Error("automation_idempotency_unavailable");
+            const previous = await readByKey(job.target.automationId, idempotencyKey);
+            if (previous) {
+                if (previous.replayOf || previous.jobId !== job.id ||
+                    previous.target.definitionRevision !== job.target.definitionRevision)
+                    throw new Error("automation_idempotency_conflict");
+                return previous;
+            }
+        }
+        const pending = findPendingAutomationRun(scheduler, jobId);
+        if (pending) {
+            if (idempotencyKey)
+                throw new Error("automation_run_active");
+            return pending;
+        }
+        if (hasActiveAutomationRun(scheduler, job.target.automationId))
+            throw new Error("automation_run_active");
+        const executor = requireAutomationExecutor(context);
+        const candidateId = randomUUID();
+        const epoch = jobEpoch(context, jobId);
+        const prepared = await executor.prepare(job, candidateId, "manual");
+        if (prepared.kind === "no_input") {
+            if (prepared.commit) {
+                const update = requireAutomationJournalUpdate(context);
+                await update((current, automations) => {
+                    if (!canBeginSchedulerRun(context, jobId, epoch))
+                        throw new Error("automation_job_changed");
+                    const live = requireAutomationSchedulerJob(current, jobId);
+                    requireUnarchivedAutomation(automations, live.target.automationId);
+                    if (live.revision !== job.revision)
+                        throw new Error("automation_job_changed");
+                    prepared.commit?.(automations);
+                });
+            }
+            throw new Error("automation_no_eligible_input");
+        }
+        let claimed = false;
+        try {
+            const update = requireAutomationJournalUpdate(context);
+            if (await hasReachedAutomationDailyRunLimit(context, job, context.now()))
+                throw new Error("automation_budget_exhausted");
+            const run = await update((current, automations) => {
+                if (!canBeginSchedulerRun(context, jobId, epoch))
+                    throw new Error("automation_job_changed");
+                const live = requireAutomationSchedulerJob(current, jobId);
+                requireUnarchivedAutomation(automations, live.target.automationId);
+                if (live.revision !== job.revision)
+                    throw new Error("automation_job_changed");
+                if (hasActiveAutomationRun(current, live.target.automationId))
+                    throw new Error("automation_run_active");
+                const run = makeAutomationSchedulerRun(live, candidateId, new Date(context.now()).toISOString(), "manual", idempotencyKey);
+                prepared.commit(automations, run.id);
+                const execution = requireCommittedAutomationExecution(automations, run.id);
+                if (prepared.kind === "failed") {
+                    if (!execution.reportRef)
+                        throw new Error("automation_report_missing");
+                    run.status = "failed";
+                    run.error = prepared.error;
+                    run.reportRef = execution.reportRef;
+                    run.finishedAt = new Date(context.now()).toISOString();
+                    live.state = "paused";
+                    live.updatedAt = run.finishedAt;
+                    live.revision += 1;
+                }
+                current.runs.push(run);
+                return run;
+            });
+            claimed = true;
+            return run;
+        }
+        finally {
+            if (!claimed && prepared.kind === "ready")
+                await prepared.discard?.();
+        }
+    });
+}
+export function requireCommittedAutomationExecution(state, runId) {
+    const execution = state.executions.find((item) => item.id === runId);
+    if (!execution)
+        throw new Error("automation_execution_checkpoint_missing");
+    return execution;
+}

package/dist/src/runtime/scheduler/automation-rerun.d.ts

@@ -0,0 +1,6 @@
+import type { SchedulerAutomationRun } from "./contracts.js";
+import { type SchedulerContext } from "./service-context.js";
+import type { SchedulerService } from "./contracts.js";
+type RerunOptions = Parameters<SchedulerService["rerunAutomationRun"]>[1];
+export declare function requestAutomationSchedulerRerun(context: SchedulerContext, previousRunId: string, options: RerunOptions): Promise<SchedulerAutomationRun>;
+export {};