stitchkit 0.96.1 → 0.97.0

package/dist/entrypoints/agent-runtime.js

@@ -1902,10 +1902,67 @@ function defineAgentProtocol(config) {
     }
   };
 }
-// src/agent-runtime/schedule-tools.ts
+// src/agent-runtime/schedule-contract.ts
 import { z as z8 } from "zod";
-var ScheduledOutputSchema = z8.object({ scheduleId: z8.string(), nextAt: z8.string() }).strict();
-var ConversationInputSchema = z8.object({ conversationId: z8.string().min(1) }).strict();
+var AgentScheduleSchema = z8.object({
+  id: z8.string().min(1),
+  conversationId: z8.string().min(1),
+  kind: z8.enum(["at", "after", "every"]),
+  nextAt: z8.iso.datetime({ offset: true }),
+  intervalMs: z8.int().positive().optional(),
+  timeZone: z8.string().min(1).optional(),
+  input: z8.json(),
+  state: z8.enum(["scheduled", "cancelled", "completed", "failed"]),
+  occurrence: z8.int().nonnegative(),
+  attempts: z8.int().nonnegative().optional(),
+  retryAt: z8.iso.datetime({ offset: true }).optional(),
+  lastError: z8.string().optional(),
+  createdAt: z8.iso.datetime({ offset: true }),
+  updatedAt: z8.iso.datetime({ offset: true })
+}).strict();
+var ScheduleRowSchema = z8.object({
+  id: z8.string(),
+  conversation_id: z8.string(),
+  kind: z8.enum(["at", "after", "every"]),
+  next_at: z8.string(),
+  interval_ms: z8.number().int().positive().nullable(),
+  time_zone: z8.string().nullable(),
+  input_payload: z8.string(),
+  state: z8.enum(["scheduled", "cancelled", "completed", "failed"]),
+  occurrence: z8.int().nonnegative(),
+  attempts: z8.int().nonnegative(),
+  retry_at: z8.string().nullable(),
+  last_error: z8.string().nullable(),
+  created_at: z8.string(),
+  updated_at: z8.string()
+});
+function parseSchedule(raw) {
+  const row = ScheduleRowSchema.parse(raw);
+  return AgentScheduleSchema.parse({
+    id: row.id,
+    conversationId: row.conversation_id,
+    kind: row.kind,
+    nextAt: row.next_at,
+    ...row.interval_ms !== null && { intervalMs: row.interval_ms },
+    ...row.time_zone !== null && { timeZone: row.time_zone },
+    input: JSON.parse(row.input_payload),
+    state: row.state,
+    occurrence: row.occurrence,
+    attempts: row.attempts,
+    ...row.retry_at !== null && { retryAt: row.retry_at },
+    ...row.last_error !== null && { lastError: row.last_error },
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  });
+}
+var AgentScheduleDeliveryOutcomeSchema = z8.discriminatedUnion("status", [
+  z8.object({ status: z8.literal("retry"), reason: z8.string().min(1) }).strict(),
+  z8.object({ status: z8.literal("terminal"), reason: z8.string().min(1) }).strict()
+]);
+// src/agent-runtime/schedule-tools.ts
+import { z as z9 } from "zod";
+var ScheduledOutputSchema = z9.object({ scheduleId: z9.string(), nextAt: z9.string() }).strict();
+var ConversationInputSchema = z9.object({ conversationId: z9.string().min(1) }).strict();
 function createAgentScheduleTools(service) {
   const schedule = async (request) => {
     const result = await service.scheduleInput(request);
@@ -1916,10 +1973,10 @@ function createAgentScheduleTools(service) {
       name: "schedule_after",
       description: "Schedule durable input after a relative delay.",
       identity: { serviceName: "agent-schedules", action: "after", method: "POST" },
-      input: z8.object({
-        conversationId: z8.string().min(1),
-        input: z8.json(),
-        afterMs: z8.int().positive()
+      input: z9.object({
+        conversationId: z9.string().min(1),
+        input: z9.json(),
+        afterMs: z9.int().positive()
       }).strict(),
       output: ScheduledOutputSchema,
       transports: ["AGENT"],
@@ -1929,7 +1986,7 @@ function createAgentScheduleTools(service) {
       name: "schedule_at",
       description: "Schedule durable input at an absolute timestamp with an explicit offset.",
       identity: { serviceName: "agent-schedules", action: "at", method: "POST" },
-      input: z8.object({ conversationId: z8.string().min(1), input: z8.json(), at: z8.string().min(1) }).strict(),
+      input: z9.object({ conversationId: z9.string().min(1), input: z9.json(), at: z9.string().min(1) }).strict(),
       output: ScheduledOutputSchema,
       transports: ["AGENT"],
       handler: ({ input }) => schedule(input)
@@ -1938,11 +1995,11 @@ function createAgentScheduleTools(service) {
       name: "schedule_every",
       description: "Schedule recurring durable input in an explicit conversation timezone.",
       identity: { serviceName: "agent-schedules", action: "every", method: "POST" },
-      input: z8.object({
-        conversationId: z8.string().min(1),
-        input: z8.json(),
-        everyMs: z8.int().positive(),
-        timeZone: z8.string().min(1)
+      input: z9.object({
+        conversationId: z9.string().min(1),
+        input: z9.json(),
+        everyMs: z9.int().positive(),
+        timeZone: z9.string().min(1)
       }).strict(),
       output: ScheduledOutputSchema,
       transports: ["AGENT"],
@@ -1953,7 +2010,7 @@ function createAgentScheduleTools(service) {
       description: "List durable schedules for one conversation.",
       identity: { serviceName: "agent-schedules", action: "list", method: "GET" },
       input: ConversationInputSchema,
-      output: z8.object({ schedules: z8.array(z8.json()) }).strict(),
+      output: z9.object({ schedules: z9.array(z9.json()) }).strict(),
       transports: ["AGENT"],
       handler: ({ input }) => ({
         schedules: [...service.listSchedules(input.conversationId)]
@@ -1963,8 +2020,8 @@ function createAgentScheduleTools(service) {
       name: "schedule_cancel",
       description: "Cancel one durable deferred-input schedule.",
       identity: { serviceName: "agent-schedules", action: "cancel", method: "POST" },
-      input: z8.object({ conversationId: z8.string().min(1), scheduleId: z8.string().min(1) }).strict(),
-      output: z8.object({ cancelled: z8.boolean() }).strict(),
+      input: z9.object({ conversationId: z9.string().min(1), scheduleId: z9.string().min(1) }).strict(),
+      output: z9.object({ cancelled: z9.boolean() }).strict(),
       transports: ["AGENT"],
       handler: async ({ input }) => ({
         cancelled: await service.cancelSchedule(input.conversationId, input.scheduleId)
@@ -1973,12 +2030,14 @@ function createAgentScheduleTools(service) {
   ];
 }
 // src/agent-runtime/schedules.ts
+import { z as z11 } from "zod";
+
+// src/agent-runtime/schedule-dispatch.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { z as z10 } from "zod";
 
 // src/agent-runtime/schedule-records.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function newSchedule(request, observedAt) {
   const modes = [
     request.at !== undefined,
@@ -2003,7 +2062,7 @@ function newSchedule(request, observedAt) {
   if (delay !== undefined && (!Number.isSafeInteger(delay) || delay < 1)) {
     throw new TypeError("Schedule delay must be a positive safe integer");
   }
-  const nextAt = request.at ? new Date(z9.iso.datetime({ offset: true }).parse(request.at)).toISOString() : new Date(observedAt.getTime() + (delay ?? 0)).toISOString();
+  const nextAt = request.at ? new Date(z10.iso.datetime({ offset: true }).parse(request.at)).toISOString() : new Date(observedAt.getTime() + (delay ?? 0)).toISOString();
   const schedule = AgentScheduleSchema.parse({
     id: randomUUID2(),
     conversationId: request.conversationId,
@@ -2011,7 +2070,7 @@ function newSchedule(request, observedAt) {
     nextAt,
     ...intervalMs !== undefined && { intervalMs },
     ...request.timeZone && { timeZone: request.timeZone },
-    input: z9.json().parse(request.input),
+    input: z10.json().parse(request.input),
     state: "scheduled",
     occurrence: 0,
     createdAt: observedAt.toISOString(),
@@ -2035,50 +2094,67 @@ async function insertSchedule(sqlite, schedule) {
     });
   });
 }
-async function recordDispatchFailure(sqlite, { schedule, occurrence, at, owner }, error) {
+function holdsClaim(raw, firing, at) {
+  if (raw === null || raw === undefined)
+    return false;
+  const row = z10.object({
+    state: z10.string(),
+    claim_owner: z10.string().nullable(),
+    claim_until: z10.string().nullable(),
+    occurrence: z10.int(),
+    next_at: z10.string()
+  }).parse(raw);
+  return row.state === "scheduled" && row.claim_owner === firing.owner && row.claim_until !== null && row.claim_until > at && row.occurrence === firing.schedule.occurrence && row.next_at === firing.schedule.nextAt;
+}
+async function recordDispatchFailure(sqlite, firing, reason, terminal = false) {
+  const { schedule, occurrence } = firing;
   await sqlite.transaction(async (scope) => {
+    const at = firing.now().toISOString();
+    const raw = scope.database.prepare(`
+      SELECT state, claim_owner, claim_until, occurrence, next_at
+      FROM stitchkit_agent_runtime_schedules WHERE id = ?
+    `).get(schedule.id);
+    if (!holdsClaim(raw, firing, at))
+      return;
+    const attempts = Math.min((schedule.attempts ?? 0) + 1, Number.MAX_SAFE_INTEGER);
+    const retryAt = terminal ? null : new Date(new Date(at).getTime() + Math.min(60000, 1000 * 2 ** Math.min(attempts - 1, 6))).toISOString();
     scope.database.prepare(`
-        UPDATE stitchkit_agent_runtime_schedules
-        SET claim_owner = NULL, claim_until = NULL, updated_at = ?
-        WHERE id = ? AND claim_owner = ?
-      `).run(at, schedule.id, owner);
+      UPDATE stitchkit_agent_runtime_schedules
+      SET state = ?, retry_at = ?, attempts = ?, last_error = ?,
+        claim_owner = NULL, claim_until = NULL, updated_at = ? WHERE id = ?
+    `).run(terminal ? "failed" : "scheduled", retryAt, attempts, reason, at, schedule.id);
     await scope.appendEvent({
       conversationId: schedule.conversationId,
       kind: "schedule/failed",
       occurredAt: at,
-      payload: {
-        id: schedule.id,
-        occurrence,
-        message: error instanceof Error ? error.message : String(error)
-      }
+      payload: { id: schedule.id, occurrence, message: reason, attempts, retryAt, terminal }
     });
   });
 }
-async function settleFiring(sqlite, { schedule, occurrence, at, owner }, observedAt, lateByMs) {
-  let nextAt = schedule.nextAt;
-  if (schedule.kind === "every" && schedule.intervalMs) {
-    let next = new Date(schedule.nextAt).getTime() + schedule.intervalMs;
-    while (next <= observedAt.getTime())
-      next += schedule.intervalMs;
-    nextAt = new Date(next).toISOString();
-  }
+async function settleFiring(sqlite, firing, lateByMs) {
+  const { schedule, occurrence } = firing;
   const state = schedule.kind === "every" ? "scheduled" : "completed";
   await sqlite.transaction(async (scope) => {
-    const held = scope.database.prepare(`
-        SELECT state, claim_owner FROM stitchkit_agent_runtime_schedules WHERE id = ?
-      `).get(schedule.id);
-    const settled = held !== null && held !== undefined && (() => {
-      const row = FinalizeRowSchema.parse(held);
-      return row.state === "scheduled" && row.claim_owner === owner;
-    })();
-    if (settled) {
-      scope.database.prepare(`
-          UPDATE stitchkit_agent_runtime_schedules
-          SET state = ?, occurrence = ?, next_at = ?, updated_at = ?,
-            claim_owner = NULL, claim_until = NULL
-          WHERE id = ?
-        `).run(state, occurrence, nextAt, at, schedule.id);
+    const observedAt = firing.now();
+    const at = observedAt.toISOString();
+    let nextAt = schedule.nextAt;
+    if (schedule.kind === "every" && schedule.intervalMs) {
+      const due = new Date(schedule.nextAt).getTime();
+      const slots = Math.max(1, Math.floor((observedAt.getTime() - due) / schedule.intervalMs) + 1);
+      nextAt = new Date(due + slots * schedule.intervalMs).toISOString();
     }
+    const raw = scope.database.prepare(`
+      SELECT state, claim_owner, claim_until, occurrence, next_at
+      FROM stitchkit_agent_runtime_schedules WHERE id = ?
+    `).get(schedule.id);
+    if (!holdsClaim(raw, firing, at))
+      return;
+    scope.database.prepare(`
+      UPDATE stitchkit_agent_runtime_schedules
+      SET state = ?, occurrence = ?, next_at = ?, updated_at = ?,
+        claim_owner = NULL, claim_until = NULL, retry_at = NULL, attempts = 0, last_error = NULL
+      WHERE id = ?
+    `).run(state, occurrence, nextAt, at, schedule.id);
     if (lateByMs > 0) {
       await scope.appendEvent({
         conversationId: schedule.conversationId,
@@ -2091,168 +2167,165 @@ async function settleFiring(sqlite, { schedule, occurrence, at, owner }, observe
       conversationId: schedule.conversationId,
       kind: "schedule/fired",
       occurredAt: at,
-      payload: {
-        id: schedule.id,
-        occurrence,
-        lateByMs,
-        nextAt,
-        state: settled ? state : "cancelled"
-      }
+      payload: { id: schedule.id, occurrence, lateByMs, nextAt, state }
     });
   });
 }
-function claimSchedule(sqlite, owner, id, until, at) {
+function claimSchedule(sqlite, owner, schedule, now) {
   return sqlite.transaction(async (scope) => {
+    const observedAt = now();
+    const at = observedAt.toISOString();
+    const until = new Date(observedAt.getTime() + 60000).toISOString();
     const raw = scope.database.prepare(`
-        SELECT state, claim_until FROM stitchkit_agent_runtime_schedules WHERE id = ?
-      `).get(id);
+      SELECT occurrence, next_at, attempts FROM stitchkit_agent_runtime_schedules
+      WHERE id = ? AND state = 'scheduled' AND eligible_at <= ?
+    `).get(schedule.id, at);
     if (raw === null || raw === undefined)
       return false;
-    const row = ClaimRowSchema.parse(raw);
-    if (row.state !== "scheduled")
+    const row = z10.object({ occurrence: z10.int(), next_at: z10.string(), attempts: z10.int() }).parse(raw);
+    if (row.attempts !== (schedule.attempts ?? 0))
       return false;
-    if (row.claim_until !== null && row.claim_until >= at)
+    if (row.occurrence !== schedule.occurrence || row.next_at !== schedule.nextAt)
       return false;
     scope.database.prepare(`
-        UPDATE stitchkit_agent_runtime_schedules
-        SET claim_owner = ?, claim_until = ?, updated_at = ?
-        WHERE id = ?
-      `).run(owner, until, at, id);
+      UPDATE stitchkit_agent_runtime_schedules
+      SET claim_owner = ?, claim_until = ?, updated_at = ? WHERE id = ?
+    `).run(owner, until, at, schedule.id);
     return true;
   });
 }
 
-// src/agent-runtime/schedules.ts
-var AgentScheduleSchema = z10.object({
-  id: z10.string().min(1),
-  conversationId: z10.string().min(1),
-  kind: z10.enum(["at", "after", "every"]),
-  nextAt: z10.iso.datetime({ offset: true }),
-  intervalMs: z10.int().positive().optional(),
-  timeZone: z10.string().min(1).optional(),
-  input: z10.json(),
-  state: z10.enum(["scheduled", "cancelled", "completed"]),
-  occurrence: z10.int().nonnegative(),
-  createdAt: z10.iso.datetime({ offset: true }),
-  updatedAt: z10.iso.datetime({ offset: true })
-}).strict();
-var ScheduleRowSchema = z10.object({
-  id: z10.string(),
-  conversation_id: z10.string(),
-  kind: z10.enum(["at", "after", "every"]),
-  next_at: z10.string(),
-  interval_ms: z10.number().int().positive().nullable(),
-  time_zone: z10.string().nullable(),
-  input_payload: z10.string(),
-  state: z10.enum(["scheduled", "cancelled", "completed"]),
-  occurrence: z10.int().nonnegative(),
-  created_at: z10.string(),
-  updated_at: z10.string()
-});
-var ClaimRowSchema = z10.object({
-  state: z10.enum(["scheduled", "cancelled", "completed"]),
-  claim_until: z10.string().nullable()
-});
-var FinalizeRowSchema = z10.object({
-  state: z10.enum(["scheduled", "cancelled", "completed"]),
-  claim_owner: z10.string().nullable()
-});
-var StateRowSchema = z10.object({
-  state: z10.enum(["scheduled", "cancelled", "completed"])
-});
-function parseSchedule(raw) {
-  const row = ScheduleRowSchema.parse(raw);
-  return AgentScheduleSchema.parse({
-    id: row.id,
-    conversationId: row.conversation_id,
-    kind: row.kind,
-    nextAt: row.next_at,
-    ...row.interval_ms !== null && { intervalMs: row.interval_ms },
-    ...row.time_zone !== null && { timeZone: row.time_zone },
-    input: JSON.parse(row.input_payload),
-    state: row.state,
-    occurrence: row.occurrence,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  });
+// src/agent-runtime/schedule-dispatch.ts
+async function dispatchSchedule(context, schedule) {
+  if (context.signal.aborted)
+    return;
+  const owner = randomUUID3();
+  if (!await claimSchedule(context.sqlite, owner, schedule, context.now))
+    return;
+  const observedAt = context.now();
+  const occurrence = schedule.occurrence + 1;
+  const lateByMs = Math.max(0, observedAt.getTime() - new Date(schedule.nextAt).getTime());
+  const controller = new AbortController;
+  const aborted = Promise.withResolvers();
+  const abort = () => {
+    const error = new Error("Schedule dispatch aborted");
+    controller.abort(error);
+    aborted.reject(error);
+  };
+  context.signal.addEventListener("abort", abort, { once: true });
+  const timer = context.setTimer(abort, 30000);
+  try {
+    if (context.signal.aborted)
+      abort();
+    const outcome = await Promise.race([
+      aborted.promise,
+      Promise.resolve().then(() => {
+        controller.signal.throwIfAborted();
+        return context.dispatch({
+          conversationId: schedule.conversationId,
+          idempotencyKey: `schedule:${schedule.id}:${occurrence}`,
+          input: schedule.input,
+          schedule: { id: schedule.id, occurrence, lateByMs },
+          signal: controller.signal
+        });
+      })
+    ]);
+    const firing = { schedule, occurrence, now: context.now, owner };
+    if (outcome === undefined) {
+      await settleFiring(context.sqlite, firing, lateByMs);
+    } else {
+      const failure = AgentScheduleDeliveryOutcomeSchema.parse(outcome);
+      await recordDispatchFailure(context.sqlite, firing, failure.reason, failure.status === "terminal");
+    }
+  } catch (error) {
+    if (!context.signal.aborted) {
+      await recordDispatchFailure(context.sqlite, { schedule, occurrence, now: context.now, owner }, error instanceof Error ? error.message : String(error));
+    }
+  } finally {
+    context.clearTimer(timer);
+    context.signal.removeEventListener("abort", abort);
+  }
 }
+
+// src/agent-runtime/schedules.ts
 function createAgentScheduleService(input) {
-  const onError = input.onError ?? ((error) => {
-    console.error("[stitchkit] agent schedule tick failed", error);
-  });
   const now = input.now ?? (() => new Date);
   const database = input.sqlite.database;
   const setTimer = input.setTimer ?? ((callback, delay) => setTimeout(callback, delay));
   const clearTimer = input.clearTimer ?? clearTimeout;
+  const onError = input.onError ?? ((error) => {
+    console.error("[stitchkit] agent schedule tick failed", error);
+  });
+  const lifecycle = new AbortController;
   let timer;
-  let closed = false;
+  let ticking;
+  let recoveryAt = 0;
+  let storageFailures = 0;
+  const reportStorageFailure = (error) => {
+    storageFailures += 1;
+    recoveryAt = now().getTime() + Math.min(60000, 1000 * 2 ** Math.min(storageFailures - 1, 6));
+    onError(error);
+  };
   const listSchedules = (conversationId) => database.prepare(`
-        SELECT id, conversation_id, kind, next_at, interval_ms, time_zone,
-          input_payload, state, occurrence, created_at, updated_at
-        FROM stitchkit_agent_runtime_schedules
-        WHERE conversation_id = ? ORDER BY created_at, id
-      `).all(conversationId).map(parseSchedule);
+    SELECT * FROM stitchkit_agent_runtime_schedules
+    WHERE conversation_id = ? ORDER BY created_at, id
+  `).all(conversationId).map(parseSchedule);
   const arm = () => {
-    if (timer)
+    if (timer !== undefined)
       clearTimer(timer);
-    if (closed)
+    timer = undefined;
+    if (lifecycle.signal.aborted || ticking)
       return;
-    try {
-      armNext();
-    } catch (error) {
-      onError(error);
+    let dueAt;
+    if (recoveryAt > now().getTime()) {
+      dueAt = recoveryAt;
+    } else {
+      try {
+        const raw = database.prepare(`
+          SELECT eligible_at FROM stitchkit_agent_runtime_schedules
+          WHERE state = 'scheduled' ORDER BY eligible_at, id LIMIT 1
+        `).get();
+        if (raw === null || raw === undefined)
+          return;
+        dueAt = new Date(z11.object({ eligible_at: z11.string() }).parse(raw).eligible_at).getTime();
+      } catch (error) {
+        reportStorageFailure(error);
+        dueAt = recoveryAt;
+      }
     }
+    timer = setTimer(() => {
+      timer = undefined;
+      tick();
+    }, Math.min(Math.max(0, dueAt - now().getTime()), 2147483647));
   };
-  const armNext = () => {
-    const raw = database.prepare(`
-        SELECT MAX(next_at, COALESCE(claim_until, next_at)) AS due_at
-        FROM stitchkit_agent_runtime_schedules
-        WHERE state = 'scheduled' ORDER BY due_at, id LIMIT 1
-      `).get();
-    if (raw === null || raw === undefined || typeof raw.due_at !== "string")
-      return;
-    const delay = Math.max(0, new Date(raw.due_at).getTime() - now().getTime());
-    timer = setTimer(() => void tick(), Math.min(delay, 2147483647));
-  };
-  const owner = randomUUID3();
-  const CLAIM_MS = 60000;
-  let ticking;
-  const claim = (id, until, at) => claimSchedule(input.sqlite, owner, id, until, at);
   const runTick = async () => {
-    if (closed)
+    if (lifecycle.signal.aborted || now().getTime() < recoveryAt)
       return;
-    const observedAt = now();
     const due = database.prepare(`
-        SELECT id, conversation_id, kind, next_at, interval_ms, time_zone,
-          input_payload, state, occurrence, created_at, updated_at
-        FROM stitchkit_agent_runtime_schedules
-        WHERE state = 'scheduled' AND next_at <= ? ORDER BY next_at, id
-      `).all(observedAt.toISOString()).map(parseSchedule);
-    for (const schedule of due) {
-      const at = observedAt.toISOString();
-      if (!await claim(schedule.id, new Date(observedAt.getTime() + CLAIM_MS).toISOString(), at)) {
-        continue;
-      }
-      const occurrence = schedule.occurrence + 1;
-      const lateByMs = Math.max(0, observedAt.getTime() - new Date(schedule.nextAt).getTime());
-      try {
-        await input.dispatch({
-          conversationId: schedule.conversationId,
-          idempotencyKey: `schedule:${schedule.id}:${occurrence}`,
-          input: schedule.input,
-          schedule: { id: schedule.id, occurrence, lateByMs }
-        });
-      } catch (error) {
-        await recordDispatchFailure(input.sqlite, { schedule, occurrence, at, owner }, error);
-        continue;
-      }
-      await settleFiring(input.sqlite, { schedule, occurrence, at, owner }, observedAt, lateByMs);
-    }
+      SELECT * FROM stitchkit_agent_runtime_schedules
+      WHERE state = 'scheduled' AND eligible_at <= ? ORDER BY eligible_at, id LIMIT 32
+    `).all(now().toISOString()).map(parseSchedule);
+    const results = await Promise.allSettled(due.map((schedule) => dispatchSchedule({
+      sqlite: input.sqlite,
+      dispatch: input.dispatch,
+      now,
+      setTimer,
+      clearTimer,
+      signal: lifecycle.signal
+    }, schedule)));
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed?.status === "rejected")
+      throw failed.reason;
+    recoveryAt = 0;
+    storageFailures = 0;
   };
   const tick = () => {
     if (ticking)
       return ticking;
-    ticking = runTick().catch(onError).finally(() => {
+    if (timer !== undefined)
+      clearTimer(timer);
+    timer = undefined;
+    ticking = runTick().catch(reportStorageFailure).finally(() => {
       ticking = undefined;
       arm();
     });
@@ -2268,17 +2341,17 @@ function createAgentScheduleService(input) {
     const observedAt = now().toISOString();
     const changed = await input.sqlite.transaction(async (scope) => {
       const raw = scope.database.prepare(`
-          SELECT state FROM stitchkit_agent_runtime_schedules
-          WHERE id = ? AND conversation_id = ?
-        `).get(id, conversationId);
+        SELECT state FROM stitchkit_agent_runtime_schedules WHERE id = ? AND conversation_id = ?
+      `).get(id, conversationId);
       if (raw === null || raw === undefined)
         return false;
-      if (StateRowSchema.parse(raw).state !== "scheduled")
+      if (z11.object({ state: z11.string() }).parse(raw).state !== "scheduled")
         return false;
       scope.database.prepare(`
-          UPDATE stitchkit_agent_runtime_schedules SET state = 'cancelled', updated_at = ?
-          WHERE id = ? AND conversation_id = ?
-        `).run(observedAt, id, conversationId);
+        UPDATE stitchkit_agent_runtime_schedules
+        SET state = 'cancelled', updated_at = ?, claim_owner = NULL, claim_until = NULL
+        WHERE id = ? AND conversation_id = ?
+      `).run(observedAt, id, conversationId);
       await scope.appendEvent({
         conversationId,
         kind: "schedule/cancelled",
@@ -2298,24 +2371,25 @@ function createAgentScheduleService(input) {
     tick,
     start: arm,
     close() {
-      closed = true;
-      if (timer)
+      lifecycle.abort();
+      if (timer !== undefined)
         clearTimer(timer);
+      timer = undefined;
     }
   };
 }
 // src/agent-runtime/spill.ts
 import { createHash, randomUUID as randomUUID4 } from "node:crypto";
-import { z as z11 } from "zod";
-var SpillRowSchema = z11.object({
-  payload: z11.instanceof(Uint8Array),
-  bytes: z11.int().nonnegative(),
-  authorization_payload: z11.string().nullable()
+import { z as z12 } from "zod";
+var SpillRowSchema = z12.object({
+  payload: z12.instanceof(Uint8Array),
+  bytes: z12.int().nonnegative(),
+  authorization_payload: z12.string().nullable()
 });
-var SpillMetadataRowSchema = z11.object({
-  reference_id: z11.string(),
-  bytes: z11.int().nonnegative(),
-  created_at: z11.string()
+var SpillMetadataRowSchema = z12.object({
+  reference_id: z12.string(),
+  bytes: z12.int().nonnegative(),
+  created_at: z12.string()
 });
 function decodeAuthorization(value) {
   if (value === null)
@@ -2402,14 +2476,14 @@ function createSqliteAgentSpillStore(input) {
   return { authorization, write, read, search, cleanup };
 }
 // src/agent-runtime/state-tools.ts
-import { z as z12 } from "zod";
-var GoalSchema = z12.object({
-  objective: z12.string().min(1),
-  status: z12.enum(["active", "complete", "blocked"])
+import { z as z13 } from "zod";
+var GoalSchema = z13.object({
+  objective: z13.string().min(1),
+  status: z13.enum(["active", "complete", "blocked"])
 }).strict();
-var TodoItemSchema = z12.object({
-  step: z12.string().min(1),
-  status: z12.enum(["pending", "in_progress", "completed"])
+var TodoItemSchema = z13.object({
+  step: z13.string().min(1),
+  status: z13.enum(["pending", "in_progress", "completed"])
 }).strict();
 function createAgentStateTools(input) {
   const writeGoal = async (value) => {
@@ -2426,7 +2500,7 @@ function createAgentStateTools(input) {
       name: "create_goal",
       description: "Create the durable objective for this conversation.",
       identity: { serviceName: "agent-state", action: "create-goal", method: "POST" },
-      input: z12.object({ objective: z12.string().min(1) }).strict(),
+      input: z13.object({ objective: z13.string().min(1) }).strict(),
       output: GoalSchema,
       transports: ["AGENT"],
       handler: async ({ input: request }) => {
@@ -2440,9 +2514,9 @@ function createAgentStateTools(input) {
       name: "update_goal",
       description: "Update the durable objective or lifecycle status.",
       identity: { serviceName: "agent-state", action: "update-goal", method: "POST" },
-      input: z12.object({
-        objective: z12.string().min(1).optional(),
-        status: z12.enum(["active", "complete", "blocked"]).optional()
+      input: z13.object({
+        objective: z13.string().min(1).optional(),
+        status: z13.enum(["active", "complete", "blocked"]).optional()
       }).strict().refine((request) => request.objective !== undefined || request.status !== undefined, {
         message: "At least one goal field must be supplied"
       }),
@@ -2460,8 +2534,8 @@ function createAgentStateTools(input) {
       name: "get_goal",
       description: "Read the durable objective for this conversation.",
       identity: { serviceName: "agent-state", action: "get-goal", method: "GET" },
-      input: z12.object({}).strict(),
-      output: z12.object({ goal: GoalSchema.optional() }).strict(),
+      input: z13.object({}).strict(),
+      output: z13.object({ goal: GoalSchema.optional() }).strict(),
       transports: ["AGENT"],
       handler: async () => {
         const current = await input.state.get(input.conversationId, "goal");
@@ -2472,8 +2546,8 @@ function createAgentStateTools(input) {
       name: "todo_write",
       description: "Replace the durable ordered work plan for this conversation.",
       identity: { serviceName: "agent-state", action: "write-todo", method: "POST" },
-      input: z12.object({ items: z12.array(TodoItemSchema) }).strict(),
-      output: z12.object({ items: z12.array(TodoItemSchema) }).strict(),
+      input: z13.object({ items: z13.array(TodoItemSchema) }).strict(),
+      output: z13.object({ items: z13.array(TodoItemSchema) }).strict(),
       transports: ["AGENT"],
       handler: async ({ input: request }) => {
         const stored = await input.state.set({
@@ -2482,7 +2556,7 @@ function createAgentStateTools(input) {
           value: request,
           actor: "agent"
         });
-        return z12.object({ items: z12.array(TodoItemSchema) }).strict().parse(stored.value);
+        return z13.object({ items: z13.array(TodoItemSchema) }).strict().parse(stored.value);
       }
     })
   ];
@@ -2592,6 +2666,7 @@ export {
   AgentSnapshotSchema,
   AgentSeedReceiptSchema,
   AgentScheduleSchema,
+  AgentScheduleDeliveryOutcomeSchema,
   AgentSandboxRestrictionSchema,
   AgentSandboxGradeSchema,
   AgentRuntimeHeadSchema,