@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/scheduler/automation-run-records.js

@@ -0,0 +1,37 @@
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, } from "./scheduler-target.js";
+export function makeAutomationSchedulerRun(job, id, scheduledAt, trigger, idempotencyKey, admittedAt) {
+    return {
+        id,
+        jobId: job.id,
+        environmentId: job.environmentId,
+        target: { ...job.target },
+        title: job.title,
+        timeZone: job.timeZone,
+        jobRevision: job.revision,
+        scheduledAt,
+        admittedAt: admittedAt ?? scheduledAt,
+        trigger,
+        ...(idempotencyKey ? { idempotencyKey } : {}),
+        status: "pending",
+    };
+}
+export function findPendingAutomationRun(state, jobId) {
+    return state.runs.find((run) => isAutomationSchedulerRun(run) &&
+        run.jobId === jobId &&
+        run.status === "pending");
+}
+export function hasActiveAutomationRun(state, automationId) {
+    return state.runs.some((run) => {
+        if (!isAutomationSchedulerRun(run))
+            return false;
+        if (run.target.automationId !== automationId)
+            return false;
+        return ["pending", "running", "stopping"].includes(run.status);
+    });
+}
+export function requireAutomationSchedulerJob(state, jobId) {
+    const job = state.jobs.find((candidate) => isAutomationSchedulerJob(candidate) && candidate.id === jobId);
+    if (!job)
+        throw new Error("automation_job_not_found");
+    return job;
+}

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

@@ -0,0 +1,10 @@
+import type { SchedulerAutomationScheduleInput, SchedulerSchedule } from "./contracts.js";
+export declare function normalizeAutomationSchedule(input: SchedulerAutomationScheduleInput, now: number, previous?: AutomationScheduleTiming): SchedulerSchedule;
+export type AutomationScheduleTiming = Readonly<{
+    schedule: SchedulerSchedule;
+    timeZone: string;
+    authoredSchedule?: SchedulerAutomationScheduleInput;
+}>;
+export declare function hasAutomationScheduleTimingChanged(schedule: SchedulerSchedule, timeZone: string, previous?: AutomationScheduleTiming): boolean;
+/** Shared by schedule admission and draft readiness; stored runs do not reschedule. */
+export declare function requireAutomationScheduleOccurrence(schedule: SchedulerSchedule, timeZone: string, now: number): string | null;

package/dist/src/runtime/scheduler/automation-schedule.js

@@ -0,0 +1,48 @@
+import { normalizeSchedulerSchedule } from "./schedule-validation.js";
+import { requireRepresentableIntervalRecurrence } from "./interval-range.js";
+import { nextSchedulerOccurrence } from "./next-occurrence.js";
+import { SchedulerValidationError } from "./validation-error.js";
+export function normalizeAutomationSchedule(input, now, previous) {
+    if (input?.kind === "manual")
+        return { kind: "manual" };
+    if (hasUnchangedRelativeAutomationSchedule(input, previous))
+        return previous.schedule;
+    return normalizeSchedulerSchedule(input, now);
+}
+function hasUnchangedRelativeAutomationSchedule(input, previous) {
+    if (!input || !previous?.authoredSchedule)
+        return false;
+    const authored = previous.authoredSchedule;
+    const stored = previous.schedule;
+    if (input.kind === "timer")
+        return hasMatchingTimerDelay(input, authored, stored);
+    if (input.kind !== "interval")
+        return false;
+    if (authored.kind !== "interval" || stored.kind !== "interval")
+        return false;
+    if (input.anchorAt !== undefined || authored.anchorAt !== undefined)
+        return false;
+    return input.everyMs === authored.everyMs && input.everyMs === stored.everyMs;
+}
+function hasMatchingTimerDelay(input, authored, stored) {
+    if (authored.kind !== "timer" || stored.kind !== "timer")
+        return false;
+    return input.delayMs === authored.delayMs && input.delayMs === stored.delayMs;
+}
+export function hasAutomationScheduleTimingChanged(schedule, timeZone, previous) {
+    if (!previous)
+        return true;
+    if (JSON.stringify(schedule) !== JSON.stringify(previous.schedule))
+        return true;
+    if (timeZone === previous.timeZone)
+        return false;
+    return schedule.kind === "daily" || schedule.kind === "weekly" || schedule.kind === "monthly";
+}
+/** Shared by schedule admission and draft readiness; stored runs do not reschedule. */
+export function requireAutomationScheduleOccurrence(schedule, timeZone, now) {
+    requireRepresentableIntervalRecurrence(schedule, now);
+    const nextRunAt = nextSchedulerOccurrence(schedule, timeZone, now);
+    if (schedule.kind === "manual" || nextRunAt)
+        return nextRunAt;
+    throw new SchedulerValidationError("scheduler_schedule_in_past", "Choose a schedule with a future occurrence within the supported date range.");
+}

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

@@ -0,0 +1,4 @@
+import type { SchedulerAutomationRun } from "./contracts.js";
+import { type SchedulerContext } from "./service-context.js";
+export declare function enqueueDueAutomationOccurrences(context: SchedulerContext, now: number): Promise<void>;
+export declare function dispatchPendingAutomationRun(context: SchedulerContext, pending: SchedulerAutomationRun): Promise<void>;

package/dist/src/runtime/scheduler/automation-scheduler-engine.js

@@ -0,0 +1,188 @@
+import { randomUUID } from "node:crypto";
+import { hasActiveAutomationRun, makeAutomationSchedulerRun, } from "./automation-run-records.js";
+import { requireCommittedAutomationExecution } from "./automation-job-management.js";
+import { hasReachedAutomationDailyRunLimit } from "./automation-run-budget.js";
+import { settleAutomationSchedulerRun } from "./automation-run-completion.js";
+import { nextSchedulerOccurrence } from "./next-occurrence.js";
+import { canBeginSchedulerRun, jobEpoch, } from "./service-context.js";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, } from "./scheduler-target.js";
+export async function enqueueDueAutomationOccurrences(context, now) {
+    if (!context.automationExecutor)
+        return;
+    const snapshot = await context.store.read();
+    for (const candidate of snapshot.jobs) {
+        if (!isDueAutomationJob(candidate, now))
+            continue;
+        if (hasActiveAutomationRun(snapshot, candidate.target.automationId))
+            continue;
+        await prepareDueAutomationOccurrence(context, candidate, now);
+    }
+}
+function isDueAutomationJob(job, now) {
+    if (!isAutomationSchedulerJob(job))
+        return false;
+    if (job.state !== "active" || !job.nextRunAt)
+        return false;
+    return Date.parse(job.nextRunAt) <= now;
+}
+async function prepareDueAutomationOccurrence(context, job, now) {
+    const executor = context.automationExecutor;
+    if (!executor)
+        throw new Error("automation_executor_unavailable");
+    const epoch = jobEpoch(context, job.id);
+    const candidateRunId = randomUUID();
+    const prepared = await executor.prepare(job, candidateRunId, "schedule");
+    if (prepared.kind === "no_input") {
+        const update = context.store.updateWithAutomations;
+        if (!update)
+            throw new Error("automation_store_unavailable");
+        await update((state, automations) => {
+            const live = matchingDueAutomationJob(context, state, job, epoch, now);
+            if (!live)
+                return;
+            prepared.commit?.(automations);
+            advanceAutomationOccurrence(live, now);
+        });
+        return;
+    }
+    let claimed = false;
+    try {
+        if (await hasReachedAutomationDailyRunLimit(context, job, now)) {
+            await context.store.update((state) => {
+                const live = matchingDueAutomationJob(context, state, job, epoch, now);
+                if (live)
+                    advanceAutomationOccurrence(live, now);
+            });
+            return;
+        }
+        const update = context.store.updateWithAutomations;
+        if (!update)
+            throw new Error("automation_store_unavailable");
+        const committed = await update((state, automations) => {
+            const live = matchingDueAutomationJob(context, state, job, epoch, now);
+            if (!live)
+                return;
+            if (hasActiveAutomationRun(state, live.target.automationId))
+                return;
+            const run = makeAutomationSchedulerRun(live, candidateRunId, live.nextRunAt, "schedule", undefined, new Date(now).toISOString());
+            prepared.commit(automations, run.id);
+            const execution = requireCommittedAutomationExecution(automations, run.id);
+            if (prepared.kind === "failed") {
+                requireFailedOccurrenceReport(prepared, execution.reportRef);
+                run.status = "failed";
+                run.error = prepared.error;
+                run.reportRef = execution.reportRef;
+                run.finishedAt = new Date(now).toISOString();
+                live.state = "paused";
+                live.updatedAt = run.finishedAt;
+                live.revision += 1;
+            }
+            else {
+                advanceAutomationOccurrence(live, now);
+            }
+            state.runs.push(run);
+            return true;
+        });
+        claimed = committed === true;
+    }
+    finally {
+        if (!claimed && prepared.kind === "ready")
+            await prepared.discard?.();
+    }
+}
+function requireFailedOccurrenceReport(prepared, reportRef) {
+    if (!prepared.error || !reportRef)
+        throw new Error("automation_report_missing");
+}
+function matchingDueAutomationJob(context, state, prepared, epoch, now) {
+    if (!canBeginSchedulerRun(context, prepared.id, epoch))
+        return null;
+    const live = state.jobs.find((candidate) => candidate.id === prepared.id);
+    if (!live || !isDueAutomationJob(live, now))
+        return null;
+    if (live.revision !== prepared.revision)
+        return null;
+    if (live.nextRunAt !== prepared.nextRunAt)
+        return null;
+    return live;
+}
+function advanceAutomationOccurrence(job, now) {
+    job.nextRunAt = nextSchedulerOccurrence(job.schedule, job.timeZone, now);
+    if (!job.nextRunAt)
+        job.state = "completed";
+}
+export async function dispatchPendingAutomationRun(context, pending) {
+    const executor = context.automationExecutor;
+    if (!executor)
+        throw new Error("automation_executor_unavailable");
+    const epoch = jobEpoch(context, pending.jobId);
+    if (!canBeginSchedulerRun(context, pending.jobId, epoch))
+        return;
+    const release = await executor.tryReserve(pending.target.automationId);
+    if (!release)
+        return;
+    let delegated = false;
+    try {
+        const claimed = await claimPendingAutomationRun(context, pending, epoch);
+        if (!claimed)
+            return;
+        // The durable pending -> running claim is the admission boundary. Once it
+        // succeeds, a later Job edit may affect future runs but not this snapshot.
+        const execution = startCapturedAutomationRun(context, claimed.job, claimed.run);
+        delegated = true;
+        void settleAutomationSchedulerRun(context, claimed.run, context.generation, execution, release);
+    }
+    finally {
+        if (!delegated)
+            release();
+    }
+}
+async function claimPendingAutomationRun(context, pending, epoch) {
+    return context.store.update((state) => {
+        if (!canBeginSchedulerRun(context, pending.jobId, epoch))
+            return null;
+        const job = state.jobs.find((item) => item.id === pending.jobId);
+        if (!job || !isAutomationSchedulerJob(job))
+            return null;
+        if (job.state === "cancelled")
+            return null;
+        const run = state.runs.find((item) => item.id === pending.id);
+        if (!run || !isAutomationSchedulerRun(run))
+            return null;
+        if (run.status !== "pending")
+            return null;
+        if (job.state === "paused" && run.trigger !== "manual")
+            return null;
+        if (hasRunningAutomationRun(state, run))
+            return null;
+        run.status = "running";
+        run.startedAt = new Date(context.now()).toISOString();
+        return { job, run };
+    });
+}
+function hasRunningAutomationRun(state, candidate) {
+    return state.runs.some((run) => {
+        if (!isAutomationSchedulerRun(run) || run.id === candidate.id)
+            return false;
+        if (run.target.automationId !== candidate.target.automationId)
+            return false;
+        return run.status === "running" || run.status === "stopping";
+    });
+}
+function startCapturedAutomationRun(context, job, run) {
+    try {
+        return context.automationExecutor.start({
+            ...job,
+            target: { ...run.target },
+            title: run.title,
+            timeZone: run.timeZone,
+            revision: run.jobRevision,
+        }, run);
+    }
+    catch (error) {
+        return {
+            outcome: Promise.reject(error),
+            resourcesSettled: Promise.resolve(),
+        };
+    }
+}

package/dist/src/runtime/scheduler/automation-snapshot-validation.d.ts

@@ -0,0 +1,3 @@
+import type { SchedulerAutomationJob, SchedulerAutomationRun } from "./contracts.js";
+export declare function parseStoredAutomationJob(value: Record<string, unknown>): SchedulerAutomationJob;
+export declare function parseStoredAutomationRun(value: Record<string, unknown>): SchedulerAutomationRun;

package/dist/src/runtime/scheduler/automation-snapshot-validation.js

@@ -0,0 +1,106 @@
+import { normalizeStoredSchedulerSchedule, validateTimeZone } from "./schedule-validation.js";
+function corruptAutomationSchedulerRecord() {
+    throw new Error("scheduler_store_corrupt");
+}
+function hasText(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function hasInstant(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function hasOptionalInstant(value) {
+    return value === undefined || hasInstant(value);
+}
+function hasPositiveRevision(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0;
+}
+export function parseStoredAutomationJob(value) {
+    const target = value.target;
+    if (!target || typeof target !== "object" || Array.isArray(target))
+        corruptAutomationSchedulerRecord();
+    const identity = target;
+    if (identity.kind !== "automation")
+        corruptAutomationSchedulerRecord();
+    if (!hasText(identity.automationId))
+        corruptAutomationSchedulerRecord();
+    if (!hasPositiveRevision(identity.definitionRevision))
+        corruptAutomationSchedulerRecord();
+    if (!hasText(value.id) || !hasText(value.environmentId))
+        corruptAutomationSchedulerRecord();
+    if (!hasText(value.title))
+        corruptAutomationSchedulerRecord();
+    if (typeof value.timeZone !== "string")
+        corruptAutomationSchedulerRecord();
+    validateTimeZone(value.timeZone);
+    if (!hasPositiveRevision(value.revision))
+        corruptAutomationSchedulerRecord();
+    if (!hasInstant(value.createdAt) || !hasInstant(value.updatedAt))
+        corruptAutomationSchedulerRecord();
+    if (value.nextRunAt !== null && !hasInstant(value.nextRunAt))
+        corruptAutomationSchedulerRecord();
+    if (!["active", "paused", "cancelled", "completed"].includes(String(value.state)))
+        corruptAutomationSchedulerRecord();
+    const schedule = normalizeStoredSchedulerSchedule(value.schedule);
+    if (schedule.kind === "manual" && value.nextRunAt !== null)
+        corruptAutomationSchedulerRecord();
+    return { ...value, target: identity, schedule };
+}
+export function parseStoredAutomationRun(value) {
+    const target = value.target;
+    if (!target || typeof target !== "object" || Array.isArray(target))
+        corruptAutomationSchedulerRecord();
+    const identity = target;
+    if (identity.kind !== "automation")
+        corruptAutomationSchedulerRecord();
+    if (!hasText(identity.automationId))
+        corruptAutomationSchedulerRecord();
+    if (!hasPositiveRevision(identity.definitionRevision))
+        corruptAutomationSchedulerRecord();
+    if (!hasText(value.id) || !hasText(value.jobId))
+        corruptAutomationSchedulerRecord();
+    if (!hasText(value.environmentId) || !hasText(value.title))
+        corruptAutomationSchedulerRecord();
+    if (typeof value.timeZone !== "string")
+        corruptAutomationSchedulerRecord();
+    validateTimeZone(value.timeZone);
+    if (!hasPositiveRevision(value.jobRevision))
+        corruptAutomationSchedulerRecord();
+    if (!hasInstant(value.scheduledAt))
+        corruptAutomationSchedulerRecord();
+    if (!hasOptionalInstant(value.admittedAt))
+        corruptAutomationSchedulerRecord();
+    if (!hasOptionalInstant(value.startedAt) || !hasOptionalInstant(value.finishedAt))
+        corruptAutomationSchedulerRecord();
+    if (value.trigger !== "manual" && value.trigger !== "schedule")
+        corruptAutomationSchedulerRecord();
+    if (value.idempotencyKey !== undefined) {
+        if (value.trigger !== "manual")
+            corruptAutomationSchedulerRecord();
+        if (typeof value.idempotencyKey !== "string")
+            corruptAutomationSchedulerRecord();
+        if (!value.idempotencyKey || value.idempotencyKey.length > 128)
+            corruptAutomationSchedulerRecord();
+    }
+    if (value.replayOf !== undefined) {
+        if (value.trigger !== "manual" || !hasText(value.replayOf) ||
+            value.replayOf === value.id)
+            corruptAutomationSchedulerRecord();
+    }
+    if (![
+        "pending",
+        "running",
+        "stopping",
+        "succeeded",
+        "completed_with_skips",
+        "failed",
+        "cancelled",
+        "interrupted",
+        "missed",
+    ].includes(String(value.status)))
+        corruptAutomationSchedulerRecord();
+    if (value.error !== undefined && typeof value.error !== "string")
+        corruptAutomationSchedulerRecord();
+    if (value.reportRef !== undefined && !hasText(value.reportRef))
+        corruptAutomationSchedulerRecord();
+    return value;
+}

package/dist/src/runtime/scheduler/contracts.d.ts

@@ -1,4 +1,5 @@
 import type { AgentMode } from "../../shared/types.js";
+import type { AutomationJournalState } from "../automations/storage-records.js";
 import type { SchedulerToolPermissionMode } from "./tool-permission-mode.js";
 export type SchedulerScheduleInput = {
     kind: "timer";
@@ -22,7 +23,12 @@ export type SchedulerScheduleInput = {
     at: string;
     dayOfMonth: number;
 };
+export type SchedulerAutomationScheduleInput = SchedulerScheduleInput | {
+    kind: "manual";
+};
 export type SchedulerSchedule = {
+    kind: "manual";
+} | {
     kind: "timer";
     delayMs: number;
     at: string;
@@ -45,8 +51,15 @@ export type SchedulerSchedule = {
     at: string;
     dayOfMonth: number;
 };
+export type SchedulerTimedSchedule = Exclude<SchedulerSchedule, {
+    kind: "manual";
+}>;
 export type SchedulerJobState = "active" | "paused" | "cancelled" | "completed";
 export interface SchedulerJob {
+    /** Legacy records omit this discriminator and are normalized when loaded. */
+    target?: Readonly<{
+        kind: "request";
+    }>;
     id: string;
     environmentId: string;
     sessionId: string;
@@ -56,6 +69,23 @@ export interface SchedulerJob {
     agentMode: AgentMode;
     toolPermissionMode: SchedulerToolPermissionMode;
     timeZone: string;
+    schedule: SchedulerTimedSchedule;
+    state: SchedulerJobState;
+    createdAt: string;
+    updatedAt: string;
+    nextRunAt: string | null;
+    revision: number;
+}
+export interface SchedulerAutomationJob {
+    id: string;
+    environmentId: string;
+    target: Readonly<{
+        kind: "automation";
+        automationId: string;
+        definitionRevision: number;
+    }>;
+    title: string;
+    timeZone: string;
     schedule: SchedulerSchedule;
     state: SchedulerJobState;
     createdAt: string;
@@ -63,6 +93,15 @@ export interface SchedulerJob {
     nextRunAt: string | null;
     revision: number;
 }
+export type SchedulerStoredJob = SchedulerJob | SchedulerAutomationJob;
+export interface CreateAutomationSchedulerJobInput {
+    automationId: string;
+    definitionRevision: number;
+    title: string;
+    timeZone: string;
+    schedule: SchedulerAutomationScheduleInput;
+}
+export type UpdateAutomationSchedulerJobInput = Partial<Omit<CreateAutomationSchedulerJobInput, "automationId">>;
 export interface CreateSchedulerJobInput {
     toolPermissionMode?: SchedulerToolPermissionMode;
     sessionId: string;
@@ -76,6 +115,10 @@ export interface CreateSchedulerJobInput {
 export type UpdateSchedulerJobInput = Partial<Omit<CreateSchedulerJobInput, "sessionId">>;
 export type SchedulerRunStatus = "pending" | "running" | "succeeded" | "failed" | "cancelled" | "interrupted" | "missed";
 export interface SchedulerRun {
+    /** Legacy records omit this discriminator and are normalized when loaded. */
+    target?: Readonly<{
+        kind: "request";
+    }>;
     /** Omitted by historical runs, which always used Full. */
     toolPermissionMode?: SchedulerToolPermissionMode;
     id: string;
@@ -98,6 +141,77 @@ export interface SchedulerRun {
     resultMessageId?: string;
     error?: string;
 }
+export interface SchedulerAutomationRun {
+    id: string;
+    jobId: string;
+    environmentId: string;
+    target: Readonly<{
+        kind: "automation";
+        automationId: string;
+        definitionRevision: number;
+    }>;
+    title: string;
+    timeZone: string;
+    jobRevision: number;
+    scheduledAt: string;
+    /** Durable actual admission instant; old automation records fall back to scheduledAt. */
+    admittedAt?: string;
+    startedAt?: string;
+    finishedAt?: string;
+    trigger: "schedule" | "manual";
+    idempotencyKey?: string;
+    replayOf?: string;
+    status: SchedulerRunStatus | "stopping" | "completed_with_skips";
+    error?: string;
+    reportRef?: string;
+}
+export type SchedulerStoredRun = SchedulerRun | SchedulerAutomationRun;
+export interface SchedulerAutomationRunOutcome {
+    status: "succeeded" | "completed_with_skips" | "failed" | "cancelled";
+    error?: string;
+    reportRef?: string;
+}
+export interface SchedulerAutomationStartedRun {
+    /** May resolve at the stop-report deadline before underlying effects settle. */
+    outcome: Promise<SchedulerAutomationRunOutcome>;
+    /** Admission remains reserved until every started effect actually settles. */
+    resourcesSettled: Promise<void>;
+}
+export type PreparedAutomationOccurrence = Readonly<{
+    kind: "no_input";
+    /** Commit source-baseline/observation metadata without creating a Run. */
+    commit?(state: AutomationJournalState): void;
+}> | Readonly<{
+    kind: "ready";
+    inputIds: readonly string[];
+    /** Pure durable-state mutation within the scheduler Run claim transaction. */
+    commit(state: AutomationJournalState, runId: string): void;
+    /** Dispose snapshots when a stale preparation never reaches the claim. */
+    discard?(): Promise<void>;
+}> | Readonly<{
+    kind: "failed";
+    error: string;
+    commit(state: AutomationJournalState, runId: string): void;
+}>;
+export interface SchedulerAutomationExecutor {
+    /** Recover internal transcripts under the journal lease before any dispatch. */
+    reconcileSessions?(): Promise<void>;
+    /** Existing scheduler tick drives bounded payload retention without a new timer. */
+    maintainRetention?(now: number): Promise<void>;
+    tryReserve(automationId: string): (() => void) | null | Promise<(() => void) | null>;
+    prepare(job: SchedulerAutomationJob, candidateRunId: string, trigger: SchedulerAutomationRun["trigger"]): Promise<PreparedAutomationOccurrence>;
+    /** Reuse exact retained input versions without mutating the previous claim. */
+    prepareReplay?(job: SchedulerAutomationJob, previousRun: SchedulerAutomationRun, candidateRunId: string): Promise<PreparedAutomationOccurrence>;
+    start(job: SchedulerAutomationJob, run: SchedulerAutomationRun): SchedulerAutomationStartedRun;
+    /** Signal a durable stop intent; remember it if start has not begun yet. */
+    stop(runId: string): void;
+    /** Synchronous state updates, committed atomically with scheduler recovery. */
+    recover(scheduler: SchedulerSnapshot, automations: AutomationJournalState, recoveredRunIds: readonly string[]): void;
+    /** Synchronous report/reference update in the root terminal commit. */
+    settle(run: SchedulerAutomationRun, automations: AutomationJournalState, outcome: SchedulerAutomationRunOutcome): void;
+    /** Release never-dispatched claims and attach a derived report in one commit. */
+    cancelPending(run: SchedulerAutomationRun, automations: AutomationJournalState, reason: "paused" | "republished" | "stopped"): void;
+}
 export interface SchedulerRunOutcome {
     status: "succeeded" | "failed";
     resultText?: string;
@@ -111,14 +225,22 @@ export interface SchedulerExecutor {
 }
 export interface SchedulerSnapshot {
     schemaVersion: 1;
-    jobs: SchedulerJob[];
-    runs: SchedulerRun[];
+    jobs: SchedulerStoredJob[];
+    runs: SchedulerStoredRun[];
 }
 export interface SchedulerStore {
     acquire(): Promise<() => Promise<void>>;
     read(view?: "active"): Promise<SchedulerSnapshot>;
     update<T>(mutate: (state: SchedulerSnapshot) => T, view?: "active"): Promise<T>;
-    readRuns?(jobId?: string, query?: SchedulerRunListQuery): Promise<SchedulerRun[]>;
+    readRuns?(jobId?: string, query?: SchedulerRunListQuery, target?: "request" | "automation"): Promise<SchedulerStoredRun[]>;
+    readRun?(runId: string): Promise<SchedulerStoredRun | null>;
+    readAutomationRunByKey?(automationId: string, idempotencyKey: string): Promise<SchedulerAutomationRun | null>;
+    /** Compact journal-index count; no retained Run payload hydration. */
+    countAutomationRunsOnDay?(automationId: string, timeZone: string, at: number): Promise<number>;
+    /** The automation facet shares this store's owner lease and journal. */
+    readAutomations?(): Promise<AutomationJournalState>;
+    updateAutomations?<T>(mutate: (state: AutomationJournalState) => T): Promise<T>;
+    updateWithAutomations?<T>(mutate: (scheduler: SchedulerSnapshot, automations: AutomationJournalState) => T, view?: "active"): Promise<T>;
 }
 export interface SchedulerListFilter {
     sessionId?: string;
@@ -144,4 +266,22 @@ export interface SchedulerService {
     runNow(jobId: string): Promise<SchedulerRun>;
     deleteSession(sessionId: string): Promise<void>;
     listRuns(jobId?: string, query?: SchedulerRunListQuery): Promise<SchedulerRun[]>;
+    createAutomationJob(input: CreateAutomationSchedulerJobInput, commitPublication?: (state: AutomationJournalState, candidate: SchedulerAutomationJob) => void): Promise<SchedulerAutomationJob>;
+    getAutomationJob(automationId: string): Promise<SchedulerAutomationJob | null>;
+    listAutomationJobs(): Promise<SchedulerAutomationJob[]>;
+    updateAutomationJob(jobId: string, patch: UpdateAutomationSchedulerJobInput, commitPublication?: (state: AutomationJournalState, candidate: SchedulerAutomationJob) => void): Promise<SchedulerAutomationJob>;
+    pauseAutomationJob(jobId: string): Promise<SchedulerAutomationJob>;
+    resumeAutomationJob(jobId: string): Promise<SchedulerAutomationJob>;
+    runNowAutomation(jobId: string, options?: {
+        idempotencyKey?: string;
+    }): Promise<SchedulerAutomationRun>;
+    rerunAutomationRun(previousRunId: string, options: {
+        idempotencyKey: string;
+        confirmed: true;
+        preflight?(job: SchedulerAutomationJob, previousRun: SchedulerAutomationRun): Promise<void>;
+        validateAdmission(state: AutomationJournalState, job: SchedulerAutomationJob, previousRun: SchedulerAutomationRun): void;
+    }): Promise<SchedulerAutomationRun>;
+    stopAutomationRun(runId: string): Promise<SchedulerAutomationRun>;
+    listAutomationRuns(automationId: string, query?: SchedulerRunListQuery): Promise<SchedulerAutomationRun[]>;
+    getAutomationRun(runId: string): Promise<SchedulerAutomationRun | null>;
 }

package/dist/src/runtime/scheduler/file-store.js

@@ -62,12 +62,26 @@ export function createFileSchedulerStore(directory, onCommittedChange) {
             };
         },
         read: (view) => enqueue(() => readJournal((store) => store.snapshot(view))),
-        readRuns: (jobId, query) => enqueue(() => readJournal((store) => store.readRuns(jobId, query))),
+        readRuns: (jobId, query, target) => enqueue(() => readJournal((store) => store.readRuns(jobId, query, target))),
+        readRun: (runId) => enqueue(() => readJournal((store) => store.readRun(runId))),
+        readAutomationRunByKey: (automationId, idempotencyKey) => enqueue(() => readJournal((store) => store.readAutomationRunByKey(automationId, idempotencyKey))),
+        countAutomationRunsOnDay: (automationId, timeZone, at) => enqueue(() => readJournal((store) => store.countAutomationRunsOnDay(automationId, timeZone, at))),
+        readAutomations: () => enqueue(() => readJournal((store) => store.readAutomations())),
         update: (mutate, view) => enqueue(async () => {
             if (!releaseOwner || !journal)
                 throw new Error("scheduler_store_not_owned");
             return journal.update(mutate, view);
         }),
+        updateAutomations: (mutate) => enqueue(async () => {
+            if (!releaseOwner || !journal)
+                throw new Error("scheduler_store_not_owned");
+            return journal.updateAutomations(mutate);
+        }),
+        updateWithAutomations: (mutate, view) => enqueue(async () => {
+            if (!releaseOwner || !journal)
+                throw new Error("scheduler_store_not_owned");
+            return journal.updateWithAutomations(mutate, view);
+        }),
     };
 }
 function isOwnerContention(error) {

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

@@ -6,6 +6,7 @@ import { requireRepresentableIntervalRecurrence } from "./interval-range.js";
 import { cancelPendingRuns, findPendingRun, makeSchedulerRun, requireSchedulerJob, } from "./run-records.js";
 import { normalizeSchedulerSchedule, validateSchedulerJobInput, } from "./schedule-validation.js";
 import { invalidateJob, requireRunningScheduler, } from "./service-context.js";
+import { isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export function createSchedulerJob(context, input) {
     return context.enqueue(async () => {
         requireRunningScheduler(context);
@@ -188,8 +189,8 @@ export function deleteSchedulerSession(context, sessionId) {
         requireRunningScheduler(context);
         context.deletedSessions.add(sessionId);
         await context.store.update((state) => {
-            state.jobs = state.jobs.filter((job) => job.sessionId !== sessionId);
-            state.runs = state.runs.filter((run) => run.sessionId !== sessionId);
+            state.jobs = state.jobs.filter((job) => !isRequestSchedulerJob(job) || job.sessionId !== sessionId);
+            state.runs = state.runs.filter((run) => !isRequestSchedulerRun(run) || run.sessionId !== sessionId);
         });
     })
         .finally(releaseIntent);