@hachej/boring-automation 0.1.71 → 0.1.79

package/dist/server/index.js

@@ -10,12 +10,110 @@ var BORING_AUTOMATION_ROUTE_PREFIX = "/api/v1/boring-automation";
 // src/shared/error-codes.ts
 var BORING_AUTOMATION_ERROR_CODES = {
   INVALID_BODY: "BORING_AUTOMATION_INVALID_BODY",
+  INVALID_CRON: "BORING_AUTOMATION_INVALID_CRON",
+  INVALID_TIMEZONE: "BORING_AUTOMATION_INVALID_TIMEZONE",
+  INVALID_MODEL: "BORING_AUTOMATION_INVALID_MODEL",
   AUTOMATION_NOT_FOUND: "BORING_AUTOMATION_NOT_FOUND",
-  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND"
+  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND",
+  RUN_ALREADY_ACTIVE: "BORING_AUTOMATION_RUN_ALREADY_ACTIVE",
+  RUN_ALREADY_RECORDED: "BORING_AUTOMATION_RUN_ALREADY_RECORDED",
+  RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE",
+  TRIGGER_FORBIDDEN: "BORING_AUTOMATION_TRIGGER_FORBIDDEN",
+  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED"
 };
 
 // src/shared/schema.ts
 import { z } from "zod";
+
+// src/shared/schedule.ts
+import { Cron } from "croner";
+var AUTOMATION_SCHEDULE_ERRORS = {
+  INVALID_CRON: "Invalid cron schedule. Use exactly five fields, for example 0 9 * * *.",
+  INVALID_TIMEZONE: "Invalid timezone. Use a valid IANA timezone, for example UTC or America/New_York."
+};
+function validateAutomationSchedule(cron, timezone) {
+  const errors = {};
+  if (!isValidFiveFieldCron(cron)) errors.cron = AUTOMATION_SCHEDULE_ERRORS.INVALID_CRON;
+  if (!isValidIanaTimeZone(timezone)) errors.timezone = AUTOMATION_SCHEDULE_ERRORS.INVALID_TIMEZONE;
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function isValidFiveFieldCron(cron) {
+  const normalized = normalizeSpace(cron);
+  if (!normalized || normalized.split(" ").length !== 5) return false;
+  try {
+    new Cron(normalized);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidIanaTimeZone(timezone) {
+  const normalized = timezone.trim();
+  if (!normalized) return false;
+  try {
+    const resolved = new Intl.DateTimeFormat("en-US", { timeZone: normalized }).resolvedOptions().timeZone;
+    return resolved === "UTC" || resolved.includes("/");
+  } catch {
+    return false;
+  }
+}
+function evaluateAutomationSchedule(input) {
+  const now = new Date(input.now);
+  const scheduledFor = floorToMinute(now).toISOString();
+  const runs = [...input.runs];
+  const decisions = input.automations.map((automation) => {
+    const validation = validateAutomationSchedule(automation.cron, automation.timezone);
+    if (validation.errors.cron) return skip(automation, null, "invalid-cron", validation.errors.cron);
+    if (validation.errors.timezone) return skip(automation, null, "invalid-timezone", validation.errors.timezone);
+    if (!automation.enabled) return skip(automation, null, "disabled", "Automation is disabled.");
+    const cron = new Cron(normalizeSpace(automation.cron), { timezone: automation.timezone.trim() });
+    if (!cron.match(new Date(scheduledFor))) {
+      return skip(automation, null, "not-current-minute", "Automation is not scheduled for the current minute.");
+    }
+    if (hasDuplicateScheduledRun(runs, automation.id, scheduledFor)) {
+      return skip(automation, scheduledFor, "duplicate-scheduled-run", "A run already exists for this scheduled minute.");
+    }
+    if (hasActiveRun(runs, automation.id)) {
+      return skip(automation, scheduledFor, "active-run", "Automation already has a queued or running run.");
+    }
+    return {
+      kind: "due",
+      automation,
+      automationId: automation.id,
+      scheduledFor,
+      reason: "current-minute-matched"
+    };
+  }).sort(compareScheduleDecisions);
+  return { decisions, due: decisions.filter((decision) => decision.kind === "due") };
+}
+function skip(automation, scheduledFor, reason, message) {
+  return { kind: "skip", automation, automationId: automation.id, scheduledFor, reason, message };
+}
+function hasDuplicateScheduledRun(runs, automationId, scheduledFor) {
+  return runs.some((run) => run.automationId === automationId && run.trigger === "scheduled" && run.scheduledFor === scheduledFor);
+}
+function hasActiveRun(runs, automationId) {
+  return runs.some((run) => run.automationId === automationId && (run.status === "queued" || run.status === "running"));
+}
+function floorToMinute(date) {
+  const next = new Date(date);
+  next.setUTCSeconds(0, 0);
+  return next;
+}
+function normalizeSpace(value) {
+  return value.trim().replace(/\s+/g, " ");
+}
+function compareScheduleDecisions(a, b) {
+  return compareNullableString(a.scheduledFor, b.scheduledFor) || a.automationId.localeCompare(b.automationId);
+}
+function compareNullableString(a, b) {
+  if (a === b) return 0;
+  if (a === null) return 1;
+  if (b === null) return -1;
+  return a.localeCompare(b);
+}
+
+// src/shared/schema.ts
 var nonEmptyString = z.string().trim().min(1);
 var isoString = z.string().datetime({ offset: true });
 var nonNegativeInteger = z.number().int().nonnegative();
@@ -28,37 +126,32 @@ var AutomationCreateSchema = z.object({
   timezone: nonEmptyString,
   model: nonEmptyString,
   prompt: z.string().optional()
-}).strict();
+}).strict().superRefine((value, ctx) => {
+  addScheduleIssues(ctx, value);
+});
 var AutomationPatchSchema = z.object({
   title: nonEmptyString.optional(),
   enabled: z.boolean().optional(),
   cron: nonEmptyString.optional(),
   timezone: nonEmptyString.optional(),
   model: nonEmptyString.optional()
-}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided").superRefine((value, ctx) => {
+  addScheduleIssues(ctx, value);
+});
 var PromptUpdateSchema = z.object({
   prompt: z.string()
 }).strict();
-var AutomationRunCreateSchema = z.object({
+var AutomationRunBeginSchema = z.object({
   automationId: nonEmptyString,
-  sessionId: nonEmptyString.nullable().optional(),
-  status: AutomationRunStatusSchema.optional(),
   trigger: AutomationRunTriggerSchema,
   scheduledFor: isoString.nullable().optional(),
-  startedAt: isoString.nullable().optional(),
-  completedAt: isoString.nullable().optional(),
-  durationMs: nonNegativeInteger.nullable().optional(),
-  inputTokens: nonNegativeInteger.nullable().optional(),
-  outputTokens: nonNegativeInteger.nullable().optional(),
-  totalTokens: nonNegativeInteger.nullable().optional(),
   promptSnapshot: z.string(),
   modelSnapshot: nonEmptyString,
-  error: z.string().nullable().optional()
+  createdAt: isoString.optional()
 }).strict();
-var AutomationRunPatchSchema = z.object({
+var AutomationRunLifecyclePatchSchema = z.object({
   sessionId: nonEmptyString.nullable().optional(),
   status: AutomationRunStatusSchema.optional(),
-  scheduledFor: isoString.nullable().optional(),
   startedAt: isoString.nullable().optional(),
   completedAt: isoString.nullable().optional(),
   durationMs: nonNegativeInteger.nullable().optional(),
@@ -68,11 +161,14 @@ var AutomationRunPatchSchema = z.object({
   error: z.string().nullable().optional()
 }).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
 var IdParamsSchema = z.object({ id: nonEmptyString });
-
-// src/server/fileStore.ts
-import { randomUUID } from "crypto";
-import { mkdir, readFile, rename, writeFile } from "fs/promises";
-import { dirname, join } from "path";
+function addScheduleIssues(ctx, value) {
+  if (value.cron !== void 0 && !isValidFiveFieldCron(value.cron)) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["cron"], message: AUTOMATION_SCHEDULE_ERRORS.INVALID_CRON });
+  }
+  if (value.timezone !== void 0 && !isValidIanaTimeZone(value.timezone)) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["timezone"], message: AUTOMATION_SCHEDULE_ERRORS.INVALID_TIMEZONE });
+  }
+}
 
 // src/server/store.ts
 var AutomationStoreError = class extends Error {
@@ -88,8 +184,98 @@ function automationNotFound(id) {
 function runNotFound(id) {
   return new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.RUN_NOT_FOUND, `automation run ${id} not found`);
 }
+function runAlreadyActive(automationId) {
+  return new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE, `automation ${automationId} already has an active run`);
+}
+function runAlreadyRecorded(automationId, scheduledFor) {
+  return new AutomationStoreError(
+    BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_RECORDED,
+    `automation ${automationId} already has a run for ${scheduledFor}`
+  );
+}
+
+// src/server/dueRunService.ts
+var DueRunService = class {
+  constructor(options) {
+    this.options = options;
+    this.clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+  }
+  options;
+  clock;
+  async runDue(request) {
+    const now = this.clock();
+    const automations = await this.options.store.listAutomations();
+    const runs = (await Promise.all(automations.map(async (automation) => {
+      await this.options.store.reconcileOrphanedRuns(automation.id);
+      return await this.options.store.listRuns(automation.id);
+    }))).flat();
+    const evaluated = evaluateAutomationSchedule({ automations, runs, now });
+    const outcomes = evaluated.decisions.filter((decision) => decision.kind === "skip").map((decision) => ({
+      kind: "skipped",
+      automationId: decision.automationId,
+      scheduledFor: decision.scheduledFor,
+      reason: decision.reason,
+      message: decision.message
+    }));
+    for (const decision of evaluated.due) {
+      try {
+        const run = await this.options.executor.run({
+          automationId: decision.automationId,
+          request,
+          trigger: "scheduled",
+          scheduledFor: decision.scheduledFor
+        });
+        outcomes.push({ kind: "started", automationId: decision.automationId, scheduledFor: decision.scheduledFor, run: toDueRunSummary(run) });
+      } catch (error) {
+        if (error instanceof AutomationStoreError && (error.code === BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE || error.code === BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_RECORDED)) {
+          outcomes.push({
+            kind: "skipped",
+            automationId: decision.automationId,
+            scheduledFor: decision.scheduledFor,
+            reason: error.code === BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE ? "active-run" : "duplicate-scheduled-run",
+            message: error.message
+          });
+          continue;
+        }
+        outcomes.push({
+          kind: "failed",
+          automationId: decision.automationId,
+          scheduledFor: decision.scheduledFor,
+          code: error instanceof AutomationStoreError ? error.code : BORING_AUTOMATION_ERROR_CODES.RUN_FAILED,
+          message: safeErrorMessage(error)
+        });
+      }
+    }
+    outcomes.sort((a, b) => a.automationId.localeCompare(b.automationId) || (a.scheduledFor ?? "").localeCompare(b.scheduledFor ?? ""));
+    return { now: now.toISOString(), decisions: evaluated.decisions, outcomes };
+  }
+};
+function toDueRunSummary(run) {
+  return {
+    id: run.id,
+    automationId: run.automationId,
+    sessionId: run.sessionId,
+    status: run.status,
+    trigger: run.trigger,
+    scheduledFor: run.scheduledFor,
+    startedAt: run.startedAt,
+    completedAt: run.completedAt,
+    durationMs: run.durationMs,
+    inputTokens: run.inputTokens,
+    outputTokens: run.outputTokens,
+    totalTokens: run.totalTokens
+  };
+}
+function safeErrorMessage(error) {
+  const message = error instanceof Error ? error.message : "Automation run failed";
+  const firstLine = message.split(/\r?\n/u)[0]?.trim() || "Automation run failed";
+  return firstLine.length > 300 ? `${firstLine.slice(0, 297)}...` : firstLine;
+}
 
 // src/server/fileStore.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname, join } from "path";
 var EMPTY_STATE = {
   automations: {},
   runs: {}
@@ -100,12 +286,16 @@ var FileAutomationStore = class {
   constructor(rootDir, options = {}) {
     this.rootDir = rootDir;
     this.writer = options.writer ?? writeAtomic;
+    this.clock = options.clock ?? (() => /* @__PURE__ */ new Date());
   }
   rootDir;
   state = null;
   loadInFlight = null;
   writeChain = Promise.resolve();
+  /** Active runs owned by this store process; persisted active runs are orphaned after restart. */
+  activeRunIds = /* @__PURE__ */ new Set();
   writer;
+  clock;
   async listAutomations() {
     const state = await this.load();
     return Object.values(state.automations).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).map(clone);
@@ -116,7 +306,7 @@ var FileAutomationStore = class {
     return automation ? clone(automation) : null;
   }
   async createAutomation(input) {
-    const now = nowIso();
+    const now = this.nowIso();
     const id = randomUUID();
     const automation = {
       id,
@@ -146,7 +336,7 @@ var FileAutomationStore = class {
         id: automation.id,
         promptRef: automation.promptRef,
         createdAt: automation.createdAt,
-        updatedAt: nowIso()
+        updatedAt: this.nowIso()
       };
       state.automations[id] = updated;
     });
@@ -175,45 +365,61 @@ var FileAutomationStore = class {
     await this.mutate((state) => {
       const current = state.automations[automationId];
       if (!current) throw automationNotFound(automationId);
-      current.updatedAt = nowIso();
+      current.updatedAt = this.nowIso();
     });
   }
-  async createRun(input) {
-    const now = nowIso();
+  async reconcileOrphanedRuns(automationId) {
+    const now = this.nowIso();
+    await this.mutate((state) => {
+      if (!state.automations[automationId]) throw automationNotFound(automationId);
+      reconcileOrphanedRuns(state, automationId, this.activeRunIds, now);
+    });
+  }
+  async beginRun(input) {
+    const now = input.createdAt ?? this.nowIso();
     let run;
     await this.mutate((state) => {
       if (!state.automations[input.automationId]) throw automationNotFound(input.automationId);
+      reconcileOrphanedRuns(state, input.automationId, this.activeRunIds, now);
+      if (input.trigger === "scheduled" && input.scheduledFor) {
+        const duplicate = Object.values(state.runs).some((candidate) => candidate.automationId === input.automationId && candidate.trigger === "scheduled" && candidate.scheduledFor === input.scheduledFor);
+        if (duplicate) throw runAlreadyRecorded(input.automationId, input.scheduledFor);
+      }
+      const active = Object.values(state.runs).find((candidate) => candidate.automationId === input.automationId && (candidate.status === "queued" || candidate.status === "running"));
+      if (active) throw runAlreadyActive(input.automationId);
       run = {
         id: randomUUID(),
         automationId: input.automationId,
-        sessionId: input.sessionId ?? null,
-        status: input.status ?? "queued",
+        sessionId: null,
+        status: "queued",
         trigger: input.trigger,
         scheduledFor: input.scheduledFor ?? null,
-        startedAt: input.startedAt ?? null,
-        completedAt: input.completedAt ?? null,
-        durationMs: input.durationMs ?? null,
-        inputTokens: input.inputTokens ?? null,
-        outputTokens: input.outputTokens ?? null,
-        totalTokens: input.totalTokens ?? null,
+        startedAt: null,
+        completedAt: null,
+        durationMs: null,
+        inputTokens: null,
+        outputTokens: null,
+        totalTokens: null,
         promptSnapshot: input.promptSnapshot,
         modelSnapshot: input.modelSnapshot,
-        error: input.error ?? null,
+        error: null,
         createdAt: now,
         updatedAt: now
       };
       state.runs[run.id] = clone(run);
+      this.activeRunIds.add(run.id);
     });
     return clone(requireValue(run));
   }
-  async updateRun(runId, patch) {
+  async updateRunLifecycle(runId, patch) {
     let updated;
     await this.mutate((state) => {
       const run = state.runs[runId];
       if (!run) throw runNotFound(runId);
-      updated = applyRunPatch(run, patch);
+      updated = applyRunPatch(run, patch, this.nowIso());
       state.runs[runId] = updated;
     });
+    if (updated && isTerminalRunStatus(updated.status)) this.activeRunIds.delete(runId);
     return clone(requireValue(updated));
   }
   async listRuns(automationId) {
@@ -222,10 +428,6 @@ var FileAutomationStore = class {
     const state = await this.load();
     return Object.values(state.runs).filter((run) => run.automationId === automationId).sort((a, b) => runSortTimestamp(b).localeCompare(runSortTimestamp(a))).map(clone);
   }
-  async findRunningRun(automationId) {
-    const runs = await this.listRuns(automationId);
-    return runs.find((run) => run.status === "running") ?? null;
-  }
   statePath() {
     return join(this.rootDir, "store.json");
   }
@@ -247,6 +449,9 @@ var FileAutomationStore = class {
     this.writeChain = run.catch(() => void 0);
     return run;
   }
+  nowIso() {
+    return this.clock().toISOString();
+  }
   async load() {
     if (this.state) return this.state;
     if (!this.loadInFlight) {
@@ -273,8 +478,21 @@ var FileAutomationStore = class {
 function promptRefForId(id) {
   return `prompts/${id}.md`;
 }
-function applyRunPatch(run, patch) {
-  const next = { ...run, updatedAt: nowIso() };
+function reconcileOrphanedRuns(state, automationId, activeRunIds, completedAt) {
+  for (const run of Object.values(state.runs)) {
+    if (run.automationId !== automationId || isTerminalRunStatus(run.status) || activeRunIds.has(run.id)) continue;
+    run.status = "failed";
+    run.completedAt = completedAt;
+    run.durationMs = Math.max(0, new Date(completedAt).getTime() - new Date(run.startedAt ?? run.createdAt).getTime());
+    run.error = "Automation host restarted before the run completed";
+    run.updatedAt = completedAt;
+  }
+}
+function isTerminalRunStatus(status) {
+  return status === "succeeded" || status === "failed" || status === "cancelled";
+}
+function applyRunPatch(run, patch, updatedAt) {
+  const next = { ...run, updatedAt };
   for (const [key, value] of Object.entries(patch)) {
     if (value !== void 0) next[key] = value;
   }
@@ -289,9 +507,6 @@ async function writeAtomic(path, content) {
   await writeFile(tmp, content, "utf8");
   await rename(tmp, path);
 }
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
 function requireValue(value) {
   if (value === void 0) throw new Error("expected automation store mutation to produce a value");
   return value;
@@ -300,19 +515,209 @@ function clone(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
+// src/server/manualRunExecutor.ts
+var ManualRunExecutor = class {
+  constructor(options) {
+    this.options = options;
+    this.clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+  }
+  options;
+  clock;
+  async run(input) {
+    const actor = await this.options.actorResolver(input.request);
+    const store = await this.options.storeForRequest?.(input.request, actor) ?? this.options.store;
+    const automation = await store.getAutomation(input.automationId);
+    if (!automation) {
+      throw new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.AUTOMATION_NOT_FOUND, `automation ${input.automationId} not found`);
+    }
+    const promptSnapshot = await store.getPrompt(input.automationId);
+    const modelSnapshot = automation.model;
+    const model = parseAutomationModel(modelSnapshot);
+    const createdAt = this.nowIso();
+    const trigger = input.trigger ?? "manual";
+    const scheduledFor = trigger === "scheduled" ? input.scheduledFor ?? null : null;
+    if (trigger === "scheduled" && !scheduledFor) {
+      throw new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.INVALID_BODY, "scheduled runs require scheduledFor");
+    }
+    const run = await store.beginRun({
+      automationId: automation.id,
+      trigger,
+      scheduledFor,
+      promptSnapshot,
+      modelSnapshot,
+      createdAt
+    });
+    const usage = { input: null, output: null };
+    let current = run;
+    let sessionId = null;
+    let terminalStatus = null;
+    let terminalError = null;
+    let startedAt = null;
+    try {
+      const dispatcher = await this.options.dispatcherResolver.resolve(actor, { request: input.request });
+      startedAt = this.nowIso();
+      current = await store.updateRunLifecycle(run.id, {
+        status: "running",
+        startedAt,
+        sessionId: null
+      });
+      for await (const event of dispatcher.send({
+        content: promptSnapshot,
+        model,
+        actor: { id: actor.userId },
+        originSurface: "boring-automation"
+      })) {
+        const eventSessionId = sessionIdFromEvent(event);
+        if (!sessionId && eventSessionId) {
+          sessionId = eventSessionId;
+          current = await store.updateRunLifecycle(run.id, { sessionId });
+        }
+        aggregateUsage(usage, event);
+        const outcome = terminalOutcomeFromEvent(event);
+        if (outcome && !terminalStatus) {
+          terminalStatus = outcome.status;
+          terminalError = outcome.error;
+        }
+      }
+      const completedAt = this.nowIso();
+      return await this.finalizeRun(store, run.id, {
+        current,
+        sessionId,
+        startedAt,
+        completedAt,
+        status: terminalStatus ?? "succeeded",
+        error: terminalStatus === "failed" ? terminalError ?? "Automation run failed" : null,
+        usage
+      });
+    } catch (error) {
+      const completedAt = this.nowIso();
+      const cancelled = isCancellationError(error);
+      const status = terminalStatus ?? (cancelled ? "cancelled" : "failed");
+      return await this.finalizeRun(store, run.id, {
+        current,
+        sessionId,
+        startedAt,
+        completedAt,
+        status,
+        error: status === "failed" ? terminalError ?? safeErrorMessage2(error) : null,
+        usage
+      });
+    }
+  }
+  async finalizeRun(store, runId, input) {
+    return await store.updateRunLifecycle(runId, {
+      status: input.status,
+      completedAt: input.completedAt,
+      durationMs: durationMs(input.startedAt ?? input.current.createdAt, input.completedAt),
+      sessionId: input.sessionId,
+      ...finalizeUsage(input.usage),
+      error: input.error
+    });
+  }
+  nowIso() {
+    return this.clock().toISOString();
+  }
+};
+function parseAutomationModel(value) {
+  const index = value.indexOf(":");
+  if (index <= 0 || index === value.length - 1) {
+    throw new AutomationStoreError(
+      BORING_AUTOMATION_ERROR_CODES.INVALID_MODEL,
+      "automation model must use explicit provider:model-id syntax"
+    );
+  }
+  const provider = value.slice(0, index).trim();
+  const id = value.slice(index + 1).trim();
+  if (!provider || !id) {
+    throw new AutomationStoreError(
+      BORING_AUTOMATION_ERROR_CODES.INVALID_MODEL,
+      "automation model must use explicit provider:model-id syntax"
+    );
+  }
+  return { provider, id };
+}
+function sessionIdFromEvent(event) {
+  if (!event || typeof event !== "object") return null;
+  const sessionId = event.sessionId;
+  return typeof sessionId === "string" && sessionId.trim() ? sessionId : null;
+}
+function chunkFromEvent(event) {
+  if (!event || typeof event !== "object") return null;
+  const chunk = event.chunk;
+  if (!chunk || typeof chunk !== "object") return null;
+  return chunk;
+}
+function aggregateUsage(accumulator, event) {
+  const chunk = chunkFromEvent(event);
+  if (!chunk || chunk.type !== "usage") return;
+  const usage = chunk.usage;
+  if (!usage || typeof usage !== "object") return;
+  const record = usage;
+  const input = sumObservedNumbers(record.input, record.inputTokens, record.cacheRead, record.cacheReadTokens, record.cacheWrite, record.cacheWriteTokens);
+  const output = sumObservedNumbers(record.output, record.outputTokens);
+  if (input !== null) accumulator.input = (accumulator.input ?? 0) + input;
+  if (output !== null) accumulator.output = (accumulator.output ?? 0) + output;
+}
+function sumObservedNumbers(...values) {
+  let observed = false;
+  let total = 0;
+  for (const value of values) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) continue;
+    observed = true;
+    total += Math.trunc(value);
+  }
+  return observed ? total : null;
+}
+function finalizeUsage(usage) {
+  if (usage.input === null && usage.output === null) {
+    return { inputTokens: null, outputTokens: null, totalTokens: null };
+  }
+  return {
+    inputTokens: usage.input,
+    outputTokens: usage.output,
+    totalTokens: (usage.input ?? 0) + (usage.output ?? 0)
+  };
+}
+function terminalOutcomeFromEvent(event) {
+  const chunk = chunkFromEvent(event);
+  if (!chunk) return null;
+  if (chunk.type === "agent-end" && !chunk.willRetry) {
+    if (chunk.status === "ok") return { status: "succeeded", error: null };
+    if (chunk.status === "aborted") return { status: "cancelled", error: null };
+    return { status: "failed", error: "Automation run failed" };
+  }
+  if (chunk.type === "error") {
+    return { status: "failed", error: safeErrorMessage2(chunk.error) };
+  }
+  return null;
+}
+function isCancellationError(error) {
+  if (!error || typeof error !== "object") return false;
+  const record = error;
+  return record.name === "AbortError" || record.code === "ABORT_ERR";
+}
+function safeErrorMessage2(error) {
+  const raw = error instanceof Error ? error.message : typeof error === "string" ? error : error && typeof error === "object" && typeof error.message === "string" ? error.message : "Automation run failed";
+  const firstLine = raw.split(/\r?\n/u)[0]?.trim() || "Automation run failed";
+  return firstLine.length > 300 ? `${firstLine.slice(0, 297)}...` : firstLine;
+}
+function durationMs(startedAt, completedAt) {
+  return Math.max(0, new Date(completedAt).getTime() - new Date(startedAt).getTime());
+}
+
 // src/server/routes.ts
 import { ZodError } from "zod";
 async function automationRoutes(app, opts) {
   app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations`, async (_request, reply) => {
     try {
-      return { ok: true, automations: await opts.store.listAutomations() };
+      return { ok: true, automations: await (await resolveStore(opts, _request)).listAutomations() };
     } catch (cause) {
       return sendError(reply, cause);
     }
   });
   app.post(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations`, async (request, reply) => {
     try {
-      const automation = await opts.store.createAutomation(parseBody(AutomationCreateSchema, request.body));
+      const automation = await (await resolveStore(opts, request)).createAutomation(parseBody(AutomationCreateSchema, request.body));
       return reply.status(201).send({ ok: true, automation });
     } catch (cause) {
       return sendError(reply, cause);
@@ -321,7 +726,7 @@ async function automationRoutes(app, opts) {
   app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id`, async (request, reply) => {
     try {
       const { id } = parseParams(IdParamsSchema, request.params);
-      const automation = await opts.store.getAutomation(id);
+      const automation = await (await resolveStore(opts, request)).getAutomation(id);
       if (!automation) throw automationNotFound(id);
       return { ok: true, automation };
     } catch (cause) {
@@ -331,7 +736,7 @@ async function automationRoutes(app, opts) {
   app.patch(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id`, async (request, reply) => {
     try {
       const { id } = parseParams(IdParamsSchema, request.params);
-      const automation = await opts.store.updateAutomation(id, parseBody(AutomationPatchSchema, request.body));
+      const automation = await (await resolveStore(opts, request)).updateAutomation(id, parseBody(AutomationPatchSchema, request.body));
       return { ok: true, automation };
     } catch (cause) {
       return sendError(reply, cause);
@@ -340,7 +745,7 @@ async function automationRoutes(app, opts) {
   app.delete(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id`, async (request, reply) => {
     try {
       const { id } = parseParams(IdParamsSchema, request.params);
-      await opts.store.deleteAutomation(id);
+      await (await resolveStore(opts, request)).deleteAutomation(id);
       return reply.status(204).send();
     } catch (cause) {
       return sendError(reply, cause);
@@ -349,7 +754,7 @@ async function automationRoutes(app, opts) {
   app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id/prompt`, async (request, reply) => {
     try {
       const { id } = parseParams(IdParamsSchema, request.params);
-      return { ok: true, prompt: await opts.store.getPrompt(id) };
+      return { ok: true, prompt: await (await resolveStore(opts, request)).getPrompt(id) };
     } catch (cause) {
       return sendError(reply, cause);
     }
@@ -358,21 +763,58 @@ async function automationRoutes(app, opts) {
     try {
       const { id } = parseParams(IdParamsSchema, request.params);
       const { prompt } = parseBody(PromptUpdateSchema, request.body);
-      await opts.store.updatePrompt(id, prompt);
+      await (await resolveStore(opts, request)).updatePrompt(id, prompt);
       return { ok: true };
     } catch (cause) {
       return sendError(reply, cause);
     }
   });
+  app.post(`${BORING_AUTOMATION_ROUTE_PREFIX}/due`, async (request, reply) => {
+    try {
+      if (!isLoopbackAddress(request.ip)) {
+        throw new AutomationStoreError(
+          BORING_AUTOMATION_ERROR_CODES.TRIGGER_FORBIDDEN,
+          "automation due trigger is limited to loopback callers"
+        );
+      }
+      if (!opts.dueRunService) {
+        throw new AutomationStoreError(
+          BORING_AUTOMATION_ERROR_CODES.RUN_EXECUTOR_UNAVAILABLE,
+          "automation due executor is unavailable"
+        );
+      }
+      return { ok: true, ...await opts.dueRunService.runDue(request) };
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+  app.post(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id/run`, async (request, reply) => {
+    try {
+      const { id } = parseParams(IdParamsSchema, request.params);
+      if (!opts.manualRunExecutor) {
+        throw new AutomationStoreError(
+          BORING_AUTOMATION_ERROR_CODES.RUN_EXECUTOR_UNAVAILABLE,
+          "automation run executor is unavailable"
+        );
+      }
+      const run = await opts.manualRunExecutor.run({ automationId: id, request });
+      return reply.status(201).send({ ok: true, run });
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
   app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id/runs`, async (request, reply) => {
     try {
       const { id } = parseParams(IdParamsSchema, request.params);
-      return { ok: true, runs: await opts.store.listRuns(id) };
+      return { ok: true, runs: await (await resolveStore(opts, request)).listRuns(id) };
     } catch (cause) {
       return sendError(reply, cause);
     }
   });
 }
+async function resolveStore(opts, request) {
+  return await opts.storeForRequest?.(request) ?? opts.store;
+}
 function parseBody(schema, body) {
   return parse(schema, body);
 }
@@ -386,10 +828,11 @@ function parse(schema, value) {
 }
 function sendError(reply, cause) {
   if (cause instanceof ZodError) {
+    const issue = cause.issues[0];
     return reply.status(400).send({
       ok: false,
-      code: BORING_AUTOMATION_ERROR_CODES.INVALID_BODY,
-      error: cause.issues[0]?.message ?? "invalid request"
+      code: zodIssueErrorCode(issue),
+      error: issue?.message ?? "invalid request"
     });
   }
   if (cause instanceof AutomationStoreError) {
@@ -397,24 +840,266 @@ function sendError(reply, cause) {
   }
   throw cause;
 }
+function zodIssueErrorCode(issue) {
+  const field = issue?.path[0];
+  if (field === "cron") return BORING_AUTOMATION_ERROR_CODES.INVALID_CRON;
+  if (field === "timezone") return BORING_AUTOMATION_ERROR_CODES.INVALID_TIMEZONE;
+  return BORING_AUTOMATION_ERROR_CODES.INVALID_BODY;
+}
+function isLoopbackAddress(address) {
+  const normalized = address.trim().toLowerCase();
+  return normalized === "127.0.0.1" || normalized === "::1" || normalized.startsWith("::ffff:127.");
+}
 function httpStatusForStoreError(error) {
   switch (error.code) {
     case BORING_AUTOMATION_ERROR_CODES.INVALID_BODY:
+    case BORING_AUTOMATION_ERROR_CODES.INVALID_CRON:
+    case BORING_AUTOMATION_ERROR_CODES.INVALID_TIMEZONE:
+    case BORING_AUTOMATION_ERROR_CODES.INVALID_MODEL:
       return 400;
     case BORING_AUTOMATION_ERROR_CODES.AUTOMATION_NOT_FOUND:
     case BORING_AUTOMATION_ERROR_CODES.RUN_NOT_FOUND:
       return 404;
+    case BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE:
+    case BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_RECORDED:
+      return 409;
+    case BORING_AUTOMATION_ERROR_CODES.TRIGGER_FORBIDDEN:
+      return 403;
+    case BORING_AUTOMATION_ERROR_CODES.RUN_EXECUTOR_UNAVAILABLE:
+      return 503;
+    case BORING_AUTOMATION_ERROR_CODES.RUN_FAILED:
+      return 500;
   }
 }
 
+// src/server/migrations.ts
+async function runBoringAutomationMigrations(sql) {
+  await sql.unsafe(`
+    CREATE TABLE IF NOT EXISTS boring_automation_automations (
+      id uuid PRIMARY KEY,
+      workspace_id text NOT NULL,
+      owner_user_id text NOT NULL,
+      title text NOT NULL,
+      enabled boolean NOT NULL DEFAULT true,
+      cron text NOT NULL,
+      timezone text NOT NULL,
+      model text NOT NULL,
+      prompt text NOT NULL DEFAULT '',
+      created_at timestamptz NOT NULL,
+      updated_at timestamptz NOT NULL
+    )
+  `);
+  await sql.unsafe(`
+    CREATE INDEX IF NOT EXISTS boring_automation_automations_owner_idx
+      ON boring_automation_automations (workspace_id, owner_user_id)
+  `);
+  await sql.unsafe(`
+    CREATE TABLE IF NOT EXISTS boring_automation_runs (
+      id uuid PRIMARY KEY,
+      automation_id uuid NOT NULL REFERENCES boring_automation_automations(id) ON DELETE CASCADE,
+      workspace_id text NOT NULL,
+      owner_user_id text NOT NULL,
+      session_id text,
+      status text NOT NULL,
+      trigger text NOT NULL,
+      scheduled_for timestamptz,
+      started_at timestamptz,
+      completed_at timestamptz,
+      duration_ms integer,
+      input_tokens integer,
+      output_tokens integer,
+      total_tokens integer,
+      prompt_snapshot text NOT NULL,
+      model_snapshot text NOT NULL,
+      error text,
+      created_at timestamptz NOT NULL,
+      updated_at timestamptz NOT NULL,
+      CONSTRAINT boring_automation_runs_status_check CHECK (status IN ('queued', 'running', 'succeeded', 'failed', 'cancelled')),
+      CONSTRAINT boring_automation_runs_trigger_check CHECK (trigger IN ('manual', 'scheduled'))
+    )
+  `);
+  await sql.unsafe(`
+    CREATE INDEX IF NOT EXISTS boring_automation_runs_automation_idx
+      ON boring_automation_runs (automation_id, created_at DESC)
+  `);
+  await sql.unsafe(`
+    CREATE UNIQUE INDEX IF NOT EXISTS boring_automation_runs_active_once_idx
+      ON boring_automation_runs (automation_id)
+      WHERE status IN ('queued', 'running')
+  `);
+  await sql.unsafe(`
+    CREATE UNIQUE INDEX IF NOT EXISTS boring_automation_runs_scheduled_once_idx
+      ON boring_automation_runs (automation_id, scheduled_for)
+      WHERE trigger = 'scheduled' AND scheduled_for IS NOT NULL
+  `);
+}
+
+// src/server/postgresStore.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var PostgresAutomationStore = class {
+  constructor(sql, actor, clock = () => /* @__PURE__ */ new Date()) {
+    this.sql = sql;
+    this.actor = actor;
+    this.clock = clock;
+  }
+  sql;
+  actor;
+  clock;
+  async listAutomations() {
+    const rows = await this.sql`
+      SELECT id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+      FROM boring_automation_automations
+      WHERE workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+      ORDER BY created_at, id
+    `;
+    return rows.map(toAutomation);
+  }
+  async getAutomation(id) {
+    const rows = await this.sql`
+      SELECT id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+      FROM boring_automation_automations
+      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    return rows[0] ? toAutomation(rows[0]) : null;
+  }
+  async createAutomation(input) {
+    const now = this.clock().toISOString();
+    const id = randomUUID2();
+    const prompt = input.prompt ?? "";
+    const rows = await this.sql`
+      INSERT INTO boring_automation_automations (id, workspace_id, owner_user_id, title, enabled, cron, timezone, model, prompt, created_at, updated_at)
+      VALUES (${id}, ${this.actor.workspaceId}, ${this.actor.userId}, ${input.title}, ${input.enabled ?? true}, ${input.cron}, ${input.timezone}, ${input.model}, ${prompt}, ${now}, ${now})
+      RETURNING id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+    `;
+    return toAutomation(rows[0]);
+  }
+  async updateAutomation(id, patch) {
+    const current = await this.getAutomation(id);
+    if (!current) throw automationNotFound(id);
+    const next = { ...current, ...patch, updatedAt: this.clock().toISOString() };
+    const rows = await this.sql`
+      UPDATE boring_automation_automations
+      SET title = ${next.title}, enabled = ${next.enabled}, cron = ${next.cron}, timezone = ${next.timezone}, model = ${next.model}, updated_at = ${next.updatedAt}
+      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+      RETURNING id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+    `;
+    if (!rows[0]) throw automationNotFound(id);
+    return toAutomation(rows[0]);
+  }
+  async deleteAutomation(id) {
+    const result = await this.sql`
+      DELETE FROM boring_automation_automations
+      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    if (result.count === 0) throw automationNotFound(id);
+  }
+  async getPrompt(automationId) {
+    const automation = await this.getAutomation(automationId);
+    if (!automation) throw automationNotFound(automationId);
+    const rows = await this.sql`
+      SELECT prompt FROM boring_automation_automations
+      WHERE id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    return rows[0]?.prompt ?? "";
+  }
+  async updatePrompt(automationId, body) {
+    const result = await this.sql`
+      UPDATE boring_automation_automations SET prompt = ${body}, updated_at = ${this.clock().toISOString()}
+      WHERE id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    if (result.count === 0) throw automationNotFound(automationId);
+  }
+  async reconcileOrphanedRuns(automationId) {
+    await this.sql`
+      UPDATE boring_automation_runs
+      SET status = 'failed', completed_at = ${this.clock().toISOString()}, error = 'Automation host restarted before the run completed', updated_at = ${this.clock().toISOString()}
+      WHERE automation_id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId} AND status IN ('queued', 'running')
+    `;
+  }
+  async beginRun(input) {
+    const automation = await this.getAutomation(input.automationId);
+    if (!automation) throw automationNotFound(input.automationId);
+    const active = await this.sql`
+      SELECT id FROM boring_automation_runs
+      WHERE automation_id = ${input.automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId} AND status IN ('queued', 'running')
+      LIMIT 1
+    `;
+    if (active[0]) throw runAlreadyActive(input.automationId);
+    try {
+      const now = input.createdAt ?? this.clock().toISOString();
+      const id = randomUUID2();
+      const rows = await this.sql`
+        INSERT INTO boring_automation_runs (id, automation_id, workspace_id, owner_user_id, session_id, status, trigger, scheduled_for, started_at, completed_at, duration_ms, input_tokens, output_tokens, total_tokens, prompt_snapshot, model_snapshot, error, created_at, updated_at)
+        VALUES (${id}, ${input.automationId}, ${this.actor.workspaceId}, ${this.actor.userId}, NULL, 'queued', ${input.trigger}, ${input.scheduledFor ?? null}, NULL, NULL, NULL, NULL, NULL, NULL, ${input.promptSnapshot}, ${input.modelSnapshot}, NULL, ${now}, ${now})
+        RETURNING *
+      `;
+      return toRun(rows[0]);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        if (constraintName(error) === "boring_automation_runs_active_once_idx") throw runAlreadyActive(input.automationId);
+        if (input.trigger === "scheduled" && input.scheduledFor) throw runAlreadyRecorded(input.automationId, input.scheduledFor);
+      }
+      throw error;
+    }
+  }
+  async updateRunLifecycle(runId, patch) {
+    const current = await this.findRun(runId);
+    if (!current) throw runNotFound(runId);
+    const next = { ...current, ...patch, updatedAt: this.clock().toISOString() };
+    const rows = await this.sql`
+      UPDATE boring_automation_runs
+      SET session_id = ${next.sessionId}, status = ${next.status}, started_at = ${next.startedAt}, completed_at = ${next.completedAt}, duration_ms = ${next.durationMs}, input_tokens = ${next.inputTokens}, output_tokens = ${next.outputTokens}, total_tokens = ${next.totalTokens}, error = ${next.error}, updated_at = ${next.updatedAt}
+      WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+      RETURNING *
+    `;
+    if (!rows[0]) throw runNotFound(runId);
+    return toRun(rows[0]);
+  }
+  async listRuns(automationId) {
+    const rows = await this.sql`
+      SELECT * FROM boring_automation_runs
+      WHERE automation_id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+      ORDER BY created_at DESC, id DESC
+    `;
+    return rows.map(toRun);
+  }
+  async findRun(runId) {
+    const rows = await this.sql`
+      SELECT * FROM boring_automation_runs
+      WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    return rows[0] ? toRun(rows[0]) : null;
+  }
+};
+function toAutomation(row) {
+  return { id: row.id, title: row.title, enabled: row.enabled, cron: row.cron, timezone: row.timezone, model: row.model, promptRef: `hosted:${row.id}`, createdAt: iso(row.created_at), updatedAt: iso(row.updated_at) };
+}
+function toRun(row) {
+  return { id: row.id, automationId: row.automation_id, sessionId: row.session_id, status: row.status, trigger: row.trigger, scheduledFor: nullableIso(row.scheduled_for), startedAt: nullableIso(row.started_at), completedAt: nullableIso(row.completed_at), durationMs: row.duration_ms, inputTokens: row.input_tokens, outputTokens: row.output_tokens, totalTokens: row.total_tokens, promptSnapshot: row.prompt_snapshot, modelSnapshot: row.model_snapshot, error: row.error, createdAt: iso(row.created_at), updatedAt: iso(row.updated_at) };
+}
+function iso(value) {
+  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+function nullableIso(value) {
+  return value === null ? null : iso(value);
+}
+function isUniqueViolation(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "23505");
+}
+function constraintName(error) {
+  return error && typeof error === "object" && "constraint_name" in error ? String(error.constraint_name) : void 0;
+}
+
 // src/server/index.ts
 function createBoringAutomationServerPlugin(options = {}) {
   const store = options.store ?? createDefaultStore(options.workspaceRoot);
+  const manualRunExecutor = options.dispatcherResolver && options.actorResolver ? new ManualRunExecutor({ store, dispatcherResolver: options.dispatcherResolver, actorResolver: options.actorResolver }) : void 0;
+  const dueRunService = manualRunExecutor ? new DueRunService({ store, executor: manualRunExecutor }) : void 0;
   return defineServerPlugin({
     id: BORING_AUTOMATION_PLUGIN_ID,
     label: BORING_AUTOMATION_PLUGIN_LABEL,
     routes: async (app) => {
-      await automationRoutes(app, { store });
+      await automationRoutes(app, { store, manualRunExecutor, dueRunService });
     }
   });
 }
@@ -423,16 +1108,20 @@ function createDefaultStore(workspaceRoot) {
   return new FileAutomationStore(join2(workspaceRoot, ".pi", "automation"));
 }
 function defaultBoringAutomationServerPlugin(options, ctx) {
+  const trusted = ctx?.trusted;
   return createBoringAutomationServerPlugin({
     ...options,
-    workspaceRoot: options?.workspaceRoot ?? ctx?.workspaceRoot
+    workspaceRoot: options?.workspaceRoot ?? ctx?.workspaceRoot,
+    dispatcherResolver: options?.dispatcherResolver ?? trusted?.workspaceAgentDispatcherResolver,
+    actorResolver: options?.actorResolver ?? trusted?.actorResolver
   });
 }
 export {
+  AUTOMATION_SCHEDULE_ERRORS,
   AutomationCreateSchema,
   AutomationPatchSchema,
-  AutomationRunCreateSchema,
-  AutomationRunPatchSchema,
+  AutomationRunBeginSchema,
+  AutomationRunLifecyclePatchSchema,
   AutomationRunStatusSchema,
   AutomationRunTriggerSchema,
   AutomationStoreError,
@@ -440,12 +1129,23 @@ export {
   BORING_AUTOMATION_PLUGIN_ID,
   BORING_AUTOMATION_PLUGIN_LABEL,
   BORING_AUTOMATION_ROUTE_PREFIX,
+  DueRunService,
   FileAutomationStore,
   IdParamsSchema,
+  ManualRunExecutor,
+  PostgresAutomationStore,
   PromptUpdateSchema,
   automationNotFound,
   automationRoutes,
   createBoringAutomationServerPlugin,
   defaultBoringAutomationServerPlugin as default,
-  runNotFound
+  evaluateAutomationSchedule,
+  isValidFiveFieldCron,
+  isValidIanaTimeZone,
+  parseAutomationModel,
+  runAlreadyActive,
+  runAlreadyRecorded,
+  runBoringAutomationMigrations,
+  runNotFound,
+  validateAutomationSchedule
 };