@vellumai/assistant 0.10.3 → 0.10.4-dev.202607010028.1a4efcc

package/src/__tests__/schedule-routes.test.ts

@@ -17,6 +17,9 @@ mock.module("../config/loader.js", () => ({
       cronExpression: null,
       timezone: null,
     },
+    migrations: { worker: { enabled: false } },
+    llm: { pricingOverrides: {} },
+    timeouts: { scheduleTurnTimeoutSec: 600 },
   }),
   getConfigReadOnly: () => ({
     llm: {
@@ -77,11 +80,11 @@ import {
 import {
   archiveConversation,
   createConversation,
-} from "../memory/conversation-crud.js";
-import { getDb } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
-import { recordUsageEvent } from "../memory/llm-usage-store.js";
-import { rawRun } from "../memory/raw-query.js";
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { recordUsageEvent } from "../persistence/llm-usage-store.js";
+import { rawRun } from "../persistence/raw-query.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
@@ -197,7 +200,7 @@ describe("schedule run-now trust propagation", () => {
   });
 
   test("manual run-now executes plain schedules with guardian trust", async () => {
-    const schedule = createSchedule({
+    const schedule = await createSchedule({
       name: "Direct schedule",
       cronExpression: "* * * * *",
       message: "scan my inbox",
@@ -226,7 +229,7 @@ describe("schedule run-now trust propagation", () => {
       title: "Email triage",
       template: "triage inbox in background",
     });
-    const schedule = scheduleTask({
+    const schedule = await scheduleTask({
       taskId: task.id,
       name: "Scheduled task",
       cronExpression: "* * * * *",
@@ -265,7 +268,7 @@ describe("schedule run-now trust propagation", () => {
       title: "Manual Usage Task",
       template: "spend tokens manually",
     });
-    const schedule = scheduleTask({
+    const schedule = await scheduleTask({
       taskId: task.id,
       name: "Manual scheduled task",
       cronExpression: "* * * * *",
@@ -312,9 +315,9 @@ describe("schedule run-now trust propagation", () => {
     expect(runs[0].finishedAt!).toBeGreaterThanOrEqual(usageEventCreatedAt!);
 
     const summaryRoute = findRoute("schedules/usage-summary", "GET");
-    const summaryResult = summaryRoute.handler({
+    const summaryResult = (await summaryRoute.handler({
       queryParams: { from: String(from), to: String(to) },
-    }) as {
+    })) as {
       summaries: Array<{
         scheduleId: string;
         runCount: number;
@@ -340,14 +343,14 @@ describe("GET /schedules — default defer exclusion", () => {
     clearTables();
   });
 
-  test("excludes deferred wakes by default", () => {
-    createSchedule({
+  test("excludes deferred wakes by default", async () => {
+    await createSchedule({
       name: "Agent schedule",
       cronExpression: "* * * * *",
       message: "hello",
       syntax: "cron",
     });
-    const deferred = createSchedule({
+    const deferred = await createSchedule({
       name: "Deferred wake",
       cronExpression: "0 9 * * *",
       message: "wake up",
@@ -356,21 +359,21 @@ describe("GET /schedules — default defer exclusion", () => {
     });
 
     const route = findRoute("schedules", "GET");
-    const result = route.handler({}) as {
+    const result = (await route.handler({})) as {
       schedules: Array<{ id: string }>;
     };
     expect(result.schedules).toHaveLength(1);
     expect(result.schedules.every((s) => s.id !== deferred.id)).toBe(true);
   });
 
-  test("returns all schedules when include_all=true", () => {
-    createSchedule({
+  test("returns all schedules when include_all=true", async () => {
+    await createSchedule({
       name: "Agent schedule",
       cronExpression: "* * * * *",
       message: "hello",
       syntax: "cron",
     });
-    createSchedule({
+    await createSchedule({
       name: "Deferred wake",
       cronExpression: "0 9 * * *",
       message: "wake up",
@@ -379,39 +382,39 @@ describe("GET /schedules — default defer exclusion", () => {
     });
 
     const route = findRoute("schedules", "GET");
-    const result = route.handler({
+    const result = (await route.handler({
       queryParams: { include_all: "true" },
-    }) as { schedules: Array<{ id: string }> };
+    })) as { schedules: Array<{ id: string }> };
     expect(result.schedules).toHaveLength(2);
   });
 
-  test("includes source conversation availability metadata", () => {
+  test("includes source conversation availability metadata", async () => {
     const activeSource = createConversation("Active schedule source");
     const archivedSource = createConversation("Archived schedule source");
     expect(archiveConversation(archivedSource.id)).toBe(true);
 
-    createSchedule({
+    await createSchedule({
       name: "Active source schedule",
       cronExpression: "* * * * *",
       message: "active source",
       syntax: "cron",
       createdFromConversationId: activeSource.id,
     });
-    createSchedule({
+    await createSchedule({
       name: "Archived source schedule",
       cronExpression: "0 9 * * *",
       message: "archived source",
       syntax: "cron",
       createdFromConversationId: archivedSource.id,
     });
-    createSchedule({
+    await createSchedule({
       name: "Missing source schedule",
       cronExpression: "0 10 * * *",
       message: "missing source",
       syntax: "cron",
       createdFromConversationId: "conv-missing",
     });
-    createSchedule({
+    await createSchedule({
       name: "No source schedule",
       cronExpression: "0 11 * * *",
       message: "no source",
@@ -419,7 +422,7 @@ describe("GET /schedules — default defer exclusion", () => {
     });
 
     const route = findRoute("schedules", "GET");
-    const result = route.handler({}) as {
+    const result = (await route.handler({})) as {
       schedules: Array<{
         name: string;
         createdFromConversationId: string | null;
@@ -449,8 +452,8 @@ describe("GET /schedules — default defer exclusion", () => {
     expect(noSource.createdFromConversationArchivedAt).toBeNull();
   });
 
-  test("returns authored descriptions separately from cadence descriptions", () => {
-    createSchedule({
+  test("returns authored descriptions separately from cadence descriptions", async () => {
+    await createSchedule({
       name: "Described schedule",
       description: "Review the morning queue",
       cronExpression: "0 9 * * *",
@@ -459,7 +462,7 @@ describe("GET /schedules — default defer exclusion", () => {
     });
 
     const route = findRoute("schedules", "GET");
-    const result = route.handler({}) as {
+    const result = (await route.handler({})) as {
       schedules: Array<{
         name: string;
         description: string;
@@ -475,8 +478,8 @@ describe("GET /schedules — default defer exclusion", () => {
     });
   });
 
-  test("returns One-time as the cadence description for one-shot schedules", () => {
-    createSchedule({
+  test("returns One-time as the cadence description for one-shot schedules", async () => {
+    await createSchedule({
       name: "One-shot schedule",
       description: "Send a one-time reminder",
       cronExpression: null,
@@ -485,7 +488,7 @@ describe("GET /schedules — default defer exclusion", () => {
     });
 
     const route = findRoute("schedules", "GET");
-    const result = route.handler({}) as {
+    const result = (await route.handler({})) as {
       schedules: Array<{
         name: string;
         description: string;
@@ -500,14 +503,14 @@ describe("GET /schedules — default defer exclusion", () => {
     });
   });
 
-  test("humanizes rrule cadences and flags single-fire rrules as one-shot", () => {
-    createSchedule({
+  test("humanizes rrule cadences and flags single-fire rrules as one-shot", async () => {
+    await createSchedule({
       name: "RRule single fire",
       cronExpression: "DTSTART:20990612T080000\nRRULE:FREQ=DAILY;COUNT=1",
       syntax: "rrule",
       message: "brush teeth",
     });
-    createSchedule({
+    await createSchedule({
       name: "RRule weekly",
       cronExpression: "DTSTART:20990612T080000\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE",
       syntax: "rrule",
@@ -515,7 +518,7 @@ describe("GET /schedules — default defer exclusion", () => {
     });
 
     const route = findRoute("schedules", "GET");
-    const result = route.handler({}) as {
+    const result = (await route.handler({})) as {
       schedules: Array<{
         name: string;
         cadenceDescription: string;
@@ -534,14 +537,14 @@ describe("GET /schedules — default defer exclusion", () => {
     });
   });
 
-  test("mutation responses also exclude deferred wakes", () => {
-    createSchedule({
+  test("mutation responses also exclude deferred wakes", async () => {
+    await createSchedule({
       name: "Agent schedule",
       cronExpression: "* * * * *",
       message: "hello",
       syntax: "cron",
     });
-    createSchedule({
+    await createSchedule({
       name: "Deferred wake",
       cronExpression: "0 9 * * *",
       message: "wake up",
@@ -551,10 +554,10 @@ describe("GET /schedules — default defer exclusion", () => {
 
     const route = findRoute("schedules/:id/toggle", "POST");
     const agent = listSchedules().find((j) => j.createdBy === "agent")!;
-    const result = route.handler({
+    const result = (await route.handler({
       pathParams: { id: agent.id },
       body: { enabled: false },
-    }) as { schedules: Array<{ id: string }> };
+    })) as { schedules: Array<{ id: string }> };
     expect(result.schedules).toHaveLength(1);
     expect(result.schedules[0].id).toBe(agent.id);
   });
@@ -569,7 +572,7 @@ describe("GET /schedules — default defer exclusion", () => {
     });
 
     try {
-      const agent = createSchedule({
+      const agent = await createSchedule({
         name: "Agent schedule",
         cronExpression: "* * * * *",
         message: "hello",
@@ -579,7 +582,7 @@ describe("GET /schedules — default defer exclusion", () => {
       received.length = 0;
 
       const route = findRoute("schedules/:id/toggle", "POST");
-      route.handler({
+      await route.handler({
         pathParams: { id: agent.id },
         body: { enabled: false },
       });
@@ -602,9 +605,9 @@ describe("GET /schedules/:id", () => {
     clearTables();
   });
 
-  test("returns the full schedule by ID", () => {
+  test("returns the full schedule by ID", async () => {
     const source = createConversation("Schedule source");
-    const schedule = createSchedule({
+    const schedule = await createSchedule({
       name: "Single schedule",
       description: "Fetch me by ID",
       cronExpression: "0 9 * * *",
@@ -614,7 +617,9 @@ describe("GET /schedules/:id", () => {
     });
 
     const route = findRoute("schedules/:id", "GET");
-    const result = route.handler({ pathParams: { id: schedule.id } }) as {
+    const result = (await route.handler({
+      pathParams: { id: schedule.id },
+    })) as {
       schedule: Record<string, unknown>;
     };
 
@@ -633,8 +638,8 @@ describe("GET /schedules/:id", () => {
     });
   });
 
-  test("returns deferred schedules that the list hides by default", () => {
-    const deferred = createSchedule({
+  test("returns deferred schedules that the list hides by default", async () => {
+    const deferred = await createSchedule({
       name: "Deferred wake",
       cronExpression: "0 9 * * *",
       message: "wake up",
@@ -643,7 +648,9 @@ describe("GET /schedules/:id", () => {
     });
 
     const route = findRoute("schedules/:id", "GET");
-    const result = route.handler({ pathParams: { id: deferred.id } }) as {
+    const result = (await route.handler({
+      pathParams: { id: deferred.id },
+    })) as {
       schedule: { id: string };
     };
     expect(result.schedule.id).toBe(deferred.id);
@@ -667,109 +674,109 @@ describe("schedule runs list — limit handling", () => {
     clearTables();
   });
 
-  test("returns with default limit when no param is provided", () => {
-    const job = createSchedule({
+  test("returns with default limit when no param is provided", async () => {
+    const job = await createSchedule({
       name: "runs default",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
     for (let i = 0; i < 3; i += 1) {
-      createScheduleRun(job.id, `conv-${i}`);
+      await createScheduleRun(job.id, `conv-${i}`);
     }
     const route = findRoute("schedules/:id/runs", "GET");
-    const result = route.handler({ pathParams: { id: job.id } }) as {
+    const result = (await route.handler({ pathParams: { id: job.id } })) as {
       runs: unknown[];
     };
     expect(Array.isArray(result.runs)).toBe(true);
     expect(result.runs).toHaveLength(3);
   });
 
-  test("non-numeric limit falls back to default", () => {
-    const job = createSchedule({
+  test("non-numeric limit falls back to default", async () => {
+    const job = await createSchedule({
       name: "runs nan",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
-    createScheduleRun(job.id, "conv");
+    await createScheduleRun(job.id, "conv");
     const route = findRoute("schedules/:id/runs", "GET");
-    const result = route.handler({
+    const result = (await route.handler({
       pathParams: { id: job.id },
       queryParams: { limit: "abc" },
-    }) as { runs: unknown[] };
+    })) as { runs: unknown[] };
     expect(Array.isArray(result.runs)).toBe(true);
   });
 
-  test("negative limit is clamped to 1", () => {
-    const job = createSchedule({
+  test("negative limit is clamped to 1", async () => {
+    const job = await createSchedule({
       name: "runs negative",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
     for (let i = 0; i < 5; i += 1) {
-      createScheduleRun(job.id, `conv-${i}`);
+      await createScheduleRun(job.id, `conv-${i}`);
     }
     const route = findRoute("schedules/:id/runs", "GET");
-    const result = route.handler({
+    const result = (await route.handler({
       pathParams: { id: job.id },
       queryParams: { limit: "-5" },
-    }) as { runs: unknown[] };
+    })) as { runs: unknown[] };
     expect(result.runs).toHaveLength(1);
   });
 
-  test("zero limit is clamped to 1", () => {
-    const job = createSchedule({
+  test("zero limit is clamped to 1", async () => {
+    const job = await createSchedule({
       name: "runs zero",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
     for (let i = 0; i < 3; i += 1) {
-      createScheduleRun(job.id, `conv-${i}`);
+      await createScheduleRun(job.id, `conv-${i}`);
     }
     const route = findRoute("schedules/:id/runs", "GET");
-    const result = route.handler({
+    const result = (await route.handler({
       pathParams: { id: job.id },
       queryParams: { limit: "0" },
-    }) as { runs: unknown[] };
+    })) as { runs: unknown[] };
     expect(result.runs).toHaveLength(1);
   });
 
-  test("limit above 100 is capped at 100", () => {
-    const job = createSchedule({
+  test("limit above 100 is capped at 100", async () => {
+    const job = await createSchedule({
       name: "runs huge",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
     for (let i = 0; i < 5; i += 1) {
-      createScheduleRun(job.id, `conv-${i}`);
+      await createScheduleRun(job.id, `conv-${i}`);
     }
     const route = findRoute("schedules/:id/runs", "GET");
-    const result = route.handler({
+    const result = (await route.handler({
       pathParams: { id: job.id },
       queryParams: { limit: "9999" },
-    }) as { runs: unknown[] };
+    })) as { runs: unknown[] };
     expect(result.runs).toHaveLength(5);
   });
 
-  test("fractional limit is floored", () => {
-    const job = createSchedule({
+  test("fractional limit is floored", async () => {
+    const job = await createSchedule({
       name: "runs frac",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
     for (let i = 0; i < 5; i += 1) {
-      createScheduleRun(job.id, `conv-${i}`);
+      await createScheduleRun(job.id, `conv-${i}`);
     }
     const route = findRoute("schedules/:id/runs", "GET");
-    const result = route.handler({
+    const result = (await route.handler({
       pathParams: { id: job.id },
       queryParams: { limit: "2.7" },
-    }) as { runs: unknown[] };
+    })) as { runs: unknown[] };
     expect(result.runs).toHaveLength(2);
   });
 });
@@ -781,8 +788,8 @@ describe("schedule and heartbeat run metadata", () => {
     clearTables();
   });
 
-  test("schedule runs expose conversation availability and cost by run window", () => {
-    const job = createSchedule({
+  test("schedule runs expose conversation availability and cost by run window", async () => {
+    const job = await createSchedule({
       name: "windowed run",
       cronExpression: "* * * * *",
       message: "hi",
@@ -794,8 +801,8 @@ describe("schedule and heartbeat run metadata", () => {
       source: "schedule",
       scheduleJobId: job.id,
     });
-    const runId = createScheduleRun(job.id, conversation.id);
-    completeScheduleRun(runId, { status: "ok" });
+    const runId = await createScheduleRun(job.id, conversation.id);
+    await completeScheduleRun(runId, { status: "ok" });
     rawRun(
       "UPDATE cron_runs SET started_at = ?, finished_at = ?, duration_ms = ?, created_at = ? WHERE id = ?",
       1000,
@@ -812,7 +819,7 @@ describe("schedule and heartbeat run metadata", () => {
     recordUsageCostAt(conversation.id, "req-after-run", 2500, 0.75);
 
     const route = findRoute("schedules/:id/runs", "GET");
-    const result = route.handler({ pathParams: { id: job.id } }) as {
+    const result = (await route.handler({ pathParams: { id: job.id } })) as {
       runs: Array<{
         conversationId: string | null;
         conversationExists: boolean;
@@ -828,8 +835,8 @@ describe("schedule and heartbeat run metadata", () => {
     expect(result.runs[0].estimatedCostUsd).toBeCloseTo(0.06);
   });
 
-  test("schedule runs keep archived conversations distinguishable from missing ones", () => {
-    const job = createSchedule({
+  test("schedule runs keep archived conversations distinguishable from missing ones", async () => {
+    const job = await createSchedule({
       name: "archived conversation",
       cronExpression: "* * * * *",
       message: "hi",
@@ -846,11 +853,11 @@ describe("schedule and heartbeat run metadata", () => {
       archivedAt,
       conversation.id,
     );
-    const runId = createScheduleRun(job.id, conversation.id);
-    completeScheduleRun(runId, { status: "ok" });
+    const runId = await createScheduleRun(job.id, conversation.id);
+    await completeScheduleRun(runId, { status: "ok" });
 
     const route = findRoute("schedules/:id/runs", "GET");
-    const result = route.handler({ pathParams: { id: job.id } }) as {
+    const result = (await route.handler({ pathParams: { id: job.id } })) as {
       runs: Array<{
         conversationExists: boolean;
         conversationArchivedAt: number | null;
@@ -861,17 +868,17 @@ describe("schedule and heartbeat run metadata", () => {
     expect(result.runs[0].conversationArchivedAt).toBe(archivedAt);
   });
 
-  test("schedule runs keep missing and synthetic conversation ids non-clickable", () => {
-    const missingJob = createSchedule({
+  test("schedule runs keep missing and synthetic conversation ids non-clickable", async () => {
+    const missingJob = await createSchedule({
       name: "missing conversation",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
-    const missingRunId = createScheduleRun(missingJob.id, "conv-missing");
-    completeScheduleRun(missingRunId, { status: "ok" });
+    const missingRunId = await createScheduleRun(missingJob.id, "conv-missing");
+    await completeScheduleRun(missingRunId, { status: "ok" });
 
-    const scriptJob = createSchedule({
+    const scriptJob = await createSchedule({
       name: "script schedule",
       cronExpression: "* * * * *",
       message: "",
@@ -880,22 +887,22 @@ describe("schedule and heartbeat run metadata", () => {
       syntax: "cron",
     });
     const syntheticId = `script:${scriptJob.id}`;
-    const scriptRunId = createScheduleRun(scriptJob.id, syntheticId);
-    completeScheduleRun(scriptRunId, { status: "ok" });
+    const scriptRunId = await createScheduleRun(scriptJob.id, syntheticId);
+    await completeScheduleRun(scriptRunId, { status: "ok" });
 
     const route = findRoute("schedules/:id/runs", "GET");
-    const missingResult = route.handler({
+    const missingResult = (await route.handler({
       pathParams: { id: missingJob.id },
-    }) as {
+    })) as {
       runs: Array<{
         conversationId: string | null;
         conversationExists: boolean;
         conversationArchivedAt: number | null;
       }>;
     };
-    const scriptResult = route.handler({
+    const scriptResult = (await route.handler({
       pathParams: { id: scriptJob.id },
-    }) as {
+    })) as {
       runs: Array<{
         conversationId: string | null;
         conversationExists: boolean;
@@ -1002,14 +1009,14 @@ describe("GET /schedules/usage-summary", () => {
     expect(result.summaries).toEqual([]);
   });
 
-  test("includes active and inactive schedules with zero activity", () => {
-    const active = createSchedule({
+  test("includes active and inactive schedules with zero activity", async () => {
+    const active = await createSchedule({
       name: "Active summary schedule",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
-    const inactive = createSchedule({
+    const inactive = await createSchedule({
       name: "Inactive summary schedule",
       cronExpression: "0 9 * * *",
       message: "hi",
@@ -1036,18 +1043,18 @@ describe("GET /schedules/usage-summary", () => {
     });
   });
 
-  test("counts runs by started_at in the inclusive range regardless of status", () => {
-    const schedule = createSchedule({
+  test("counts runs by started_at in the inclusive range regardless of status", async () => {
+    const schedule = await createSchedule({
       name: "Run count schedule",
       cronExpression: "* * * * *",
       message: "hi",
       syntax: "cron",
     });
-    const beforeRun = createScheduleRun(schedule.id, "conv-runs");
-    const startRun = createScheduleRun(schedule.id, "conv-runs");
-    const errorRun = createScheduleRun(schedule.id, "conv-runs");
-    const runningRun = createScheduleRun(schedule.id, "conv-runs");
-    const afterRun = createScheduleRun(schedule.id, "conv-runs");
+    const beforeRun = await createScheduleRun(schedule.id, "conv-runs");
+    const startRun = await createScheduleRun(schedule.id, "conv-runs");
+    const errorRun = await createScheduleRun(schedule.id, "conv-runs");
+    const runningRun = await createScheduleRun(schedule.id, "conv-runs");
+    const afterRun = await createScheduleRun(schedule.id, "conv-runs");
 
     setScheduleRunWindow({
       runId: beforeRun,
@@ -1083,8 +1090,8 @@ describe("GET /schedules/usage-summary", () => {
     expect(result.summaries[0].runCount).toBe(3);
   });
 
-  test("sums usage by schedule run windows and excludes reused-conversation usage outside those windows", () => {
-    const schedule = createSchedule({
+  test("sums usage by schedule run windows and excludes reused-conversation usage outside those windows", async () => {
+    const schedule = await createSchedule({
       name: "Usage attribution schedule",
       cronExpression: "* * * * *",
       message: "hi",
@@ -1096,8 +1103,11 @@ describe("GET /schedules/usage-summary", () => {
       source: "schedule",
       scheduleJobId: schedule.id,
     });
-    const includedRun = createScheduleRun(schedule.id, conversation.id);
-    const outsideRangeRun = createScheduleRun(schedule.id, conversation.id);
+    const includedRun = await createScheduleRun(schedule.id, conversation.id);
+    const outsideRangeRun = await createScheduleRun(
+      schedule.id,
+      conversation.id,
+    );
 
     setScheduleRunWindow({
       runId: includedRun,
@@ -1147,15 +1157,15 @@ describe("POST /schedules — create", () => {
     clearTables();
   });
 
-  function postCreate(body: Record<string, unknown>) {
+  async function postCreate(body: Record<string, unknown>) {
     const route = findRoute("schedules", "POST");
-    return route.handler({ body }) as {
+    return (await route.handler({ body })) as {
       schedules: Array<{ id: string; inferenceProfile: string | null }>;
     };
   }
 
-  test("creates a recurring execute schedule with defaults", () => {
-    const result = postCreate({
+  test("creates a recurring execute schedule with defaults", async () => {
+    const result = await postCreate({
       name: "Morning ping",
       description: "Start the morning workflow",
       expression: "0 9 * * *",
@@ -1172,8 +1182,8 @@ describe("POST /schedules — create", () => {
     expect(job.timezone).toBeNull();
   });
 
-  test("trims whitespace and accepts an explicit timezone", () => {
-    postCreate({
+  test("trims whitespace and accepts an explicit timezone", async () => {
+    await postCreate({
       name: "  Trimmed  ",
       description: "  Trimmed description  ",
       expression: "  0 9 * * *  ",
@@ -1187,9 +1197,9 @@ describe("POST /schedules — create", () => {
     expect(job.timezone).toBe("America/New_York");
   });
 
-  test("accepts an rrule expression and detects syntax", () => {
+  test("accepts an rrule expression and detects syntax", async () => {
     const expression = "DTSTART:20260101T000000Z\nRRULE:FREQ=WEEKLY;BYDAY=MO";
-    postCreate({
+    await postCreate({
       name: "Weekly",
       description: "Weekly wake",
       expression,
@@ -1200,28 +1210,28 @@ describe("POST /schedules — create", () => {
     expect(job.expression).toBe(expression);
   });
 
-  test("rejects missing required fields", () => {
-    expect(() =>
+  test("rejects missing required fields", async () => {
+    await expect(
       postCreate({ expression: "* * * * *", message: "hi" }),
-    ).toThrow("name is required");
-    expect(() => postCreate({ name: "x", message: "hi" })).toThrow(
+    ).rejects.toThrow("name is required");
+    await expect(postCreate({ name: "x", message: "hi" })).rejects.toThrow(
       "expression is required",
     );
-    expect(() => postCreate({ name: "x", expression: "* * * * *" })).toThrow(
-      "message is required",
-    );
-    expect(() =>
+    await expect(
+      postCreate({ name: "x", expression: "* * * * *" }),
+    ).rejects.toThrow("message is required");
+    await expect(
       postCreate({
         name: "x",
         description: "   ",
         expression: "* * * * *",
         message: "hi",
       }),
-    ).toThrow("description is required");
+    ).rejects.toThrow("description is required");
   });
 
-  test("defaults omitted create descriptions for backward compatibility", () => {
-    postCreate({
+  test("defaults omitted create descriptions for backward compatibility", async () => {
+    await postCreate({
       name: "Description fallback",
       expression: "0 9 * * *",
       message: "hi",
@@ -1231,8 +1241,8 @@ describe("POST /schedules — create", () => {
     expect(job.description).toBe("Description fallback");
   });
 
-  test("rejects modes other than execute/workflow", () => {
-    expect(() =>
+  test("rejects modes other than execute/workflow/script", async () => {
+    await expect(
       postCreate({
         name: "x",
         description: "Run the thing",
@@ -1240,35 +1250,37 @@ describe("POST /schedules — create", () => {
         message: "hi",
         mode: "notify",
       }),
-    ).toThrow("Only 'execute' and 'workflow' modes are supported");
+    ).rejects.toThrow(
+      "Only 'execute', 'script', and 'workflow' modes are supported",
+    );
   });
 
-  test("rejects an unparseable expression", () => {
-    expect(() =>
+  test("rejects an unparseable expression", async () => {
+    await expect(
       postCreate({
         name: "x",
         description: "Run the thing",
         expression: "not-a-cron",
         message: "hi",
       }),
-    ).toThrow("could not be parsed");
+    ).rejects.toThrow("could not be parsed");
   });
 
-  test("surfaces invalid-cron errors from the store as 400s", () => {
-    expect(() =>
+  test("surfaces invalid-cron errors from the store as 400s", async () => {
+    await expect(
       postCreate({
         name: "x",
         description: "Run the thing",
         expression: "99 99 99 99 99",
         message: "hi",
       }),
-    ).toThrow();
+    ).rejects.toThrow();
   });
 
-  test("persists and round-trips workflowName/workflowArgs in the list response", () => {
+  test("persists and round-trips workflowName/workflowArgs in the list response", async () => {
     // Store-level round trip: the create route is flag-gated (and the mocked
     // config disables it), so exercise persistence directly via the store.
-    createSchedule({
+    await createSchedule({
       name: "Workflow schedule",
       cronExpression: "0 9 * * *",
       message: "trigger",
@@ -1279,7 +1291,7 @@ describe("POST /schedules — create", () => {
     });
 
     const route = findRoute("schedules", "GET");
-    const result = route.handler({}) as {
+    const result = (await route.handler({})) as {
       schedules: Array<{
         name: string;
         mode: string;
@@ -1297,8 +1309,8 @@ describe("POST /schedules — create", () => {
     expect(stored.workflowArgs).toEqual({ folder: "primary", limit: 10 });
   });
 
-  test("respects enabled=false", () => {
-    postCreate({
+  test("respects enabled=false", async () => {
+    await postCreate({
       name: "Off",
       description: "Disabled schedule",
       expression: "0 9 * * *",
@@ -1309,8 +1321,8 @@ describe("POST /schedules — create", () => {
     expect(job.enabled).toBe(false);
   });
 
-  test("persists a valid inferenceProfile and serializes it", () => {
-    const result = postCreate({
+  test("persists a valid inferenceProfile and serializes it", async () => {
+    const result = await postCreate({
       name: "Cheap digest",
       description: "High-frequency digest on a cheap model",
       expression: "0 * * * *",
@@ -1321,8 +1333,8 @@ describe("POST /schedules — create", () => {
     expect(listSchedules()[0].inferenceProfile).toBe("cost-optimized");
   });
 
-  test("defaults inferenceProfile to null when omitted", () => {
-    const result = postCreate({
+  test("defaults inferenceProfile to null when omitted", async () => {
+    const result = await postCreate({
       name: "Default profile",
       description: "Runs on the main-agent selection",
       expression: "0 9 * * *",
@@ -1331,8 +1343,8 @@ describe("POST /schedules — create", () => {
     expect(result.schedules[0].inferenceProfile).toBeNull();
   });
 
-  test("rejects an unknown inferenceProfile", () => {
-    expect(() =>
+  test("rejects an unknown inferenceProfile", async () => {
+    await expect(
       postCreate({
         name: "Bad profile",
         description: "Unknown profile",
@@ -1340,11 +1352,11 @@ describe("POST /schedules — create", () => {
         message: "hi",
         inferenceProfile: "does-not-exist",
       }),
-    ).toThrow('Inference profile "does-not-exist" is not defined');
+    ).rejects.toThrow('Inference profile "does-not-exist" is not defined');
   });
 
-  test("rejects a non-string inferenceProfile", () => {
-    expect(() =>
+  test("rejects a non-string inferenceProfile", async () => {
+    await expect(
       postCreate({
         name: "Bad profile type",
         description: "Wrong type",
@@ -1352,7 +1364,7 @@ describe("POST /schedules — create", () => {
         message: "hi",
         inferenceProfile: 42,
       }),
-    ).toThrow("inferenceProfile must be a string or null");
+    ).rejects.toThrow("inferenceProfile must be a string or null");
   });
 });
 
@@ -1363,8 +1375,8 @@ describe("PATCH /schedules/:id — description", () => {
     clearTables();
   });
 
-  test("updates authored descriptions", () => {
-    const schedule = createSchedule({
+  test("updates authored descriptions", async () => {
+    const schedule = await createSchedule({
       name: "Description update",
       description: "Original description",
       cronExpression: "0 9 * * *",
@@ -1373,10 +1385,10 @@ describe("PATCH /schedules/:id — description", () => {
     });
 
     const route = findRoute("schedules/:id", "PATCH");
-    const result = route.handler({
+    const result = (await route.handler({
       pathParams: { id: schedule.id },
       body: { description: "Updated description" },
-    }) as {
+    })) as {
       schedules: Array<{ id: string; description: string }>;
     };
 
@@ -1387,8 +1399,8 @@ describe("PATCH /schedules/:id — description", () => {
     expect(listSchedules()[0].description).toBe("Updated description");
   });
 
-  test("sets, validates, and clears inferenceProfile", () => {
-    const schedule = createSchedule({
+  test("sets, validates, and clears inferenceProfile", async () => {
+    const schedule = await createSchedule({
       name: "Profile pin",
       description: "Pinned profile schedule",
       cronExpression: "0 9 * * *",
@@ -1397,29 +1409,29 @@ describe("PATCH /schedules/:id — description", () => {
     });
     const route = findRoute("schedules/:id", "PATCH");
 
-    route.handler({
+    await route.handler({
       pathParams: { id: schedule.id },
       body: { inferenceProfile: "balanced" },
     });
     expect(listSchedules()[0].inferenceProfile).toBe("balanced");
 
-    expect(() =>
+    await expect(
       route.handler({
         pathParams: { id: schedule.id },
         body: { inferenceProfile: "does-not-exist" },
       }),
-    ).toThrow('Inference profile "does-not-exist" is not defined');
+    ).rejects.toThrow('Inference profile "does-not-exist" is not defined');
     expect(listSchedules()[0].inferenceProfile).toBe("balanced");
 
-    route.handler({
+    await route.handler({
       pathParams: { id: schedule.id },
       body: { inferenceProfile: null },
     });
     expect(listSchedules()[0].inferenceProfile).toBeNull();
   });
 
-  test("re-derives syntax when the expression switches cron to rrule", () => {
-    const schedule = createSchedule({
+  test("re-derives syntax when the expression switches cron to rrule", async () => {
+    const schedule = await createSchedule({
       name: "Syntax switch",
       description: "Cron schedule",
       cronExpression: "0 9 * * *",
@@ -1429,7 +1441,7 @@ describe("PATCH /schedules/:id — description", () => {
 
     const route = findRoute("schedules/:id", "PATCH");
     const rrule = "DTSTART:20260101T000000Z\nRRULE:FREQ=WEEKLY;BYDAY=MO";
-    route.handler({
+    await route.handler({
       pathParams: { id: schedule.id },
       body: { expression: rrule },
     });
@@ -1439,8 +1451,8 @@ describe("PATCH /schedules/:id — description", () => {
     expect(updated.cronExpression).toBe(rrule);
   });
 
-  test("rejects an expression that parses as neither cron nor rrule", () => {
-    const schedule = createSchedule({
+  test("rejects an expression that parses as neither cron nor rrule", async () => {
+    const schedule = await createSchedule({
       name: "Bad expression",
       description: "Cron schedule",
       cronExpression: "0 9 * * *",
@@ -1449,12 +1461,12 @@ describe("PATCH /schedules/:id — description", () => {
     });
 
     const route = findRoute("schedules/:id", "PATCH");
-    expect(() =>
+    await expect(
       route.handler({
         pathParams: { id: schedule.id },
         body: { expression: "not a schedule" },
       }),
-    ).toThrow(BadRequestError);
+    ).rejects.toThrow(BadRequestError);
   });
 });
 
@@ -1465,8 +1477,8 @@ describe("wake mode in schedule routes", () => {
     clearTables();
   });
 
-  test("PATCH accepts 'wake' as a valid mode", () => {
-    const schedule = createSchedule({
+  test("PATCH accepts 'wake' as a valid mode", async () => {
+    const schedule = await createSchedule({
       name: "Wake test",
       cronExpression: "* * * * *",
       message: "check deferred",
@@ -1474,10 +1486,10 @@ describe("wake mode in schedule routes", () => {
     });
 
     const route = findRoute("schedules/:id", "PATCH");
-    const result = route.handler({
+    const result = (await route.handler({
       pathParams: { id: schedule.id },
       body: { mode: "wake", wakeConversationId: "conv-xyz" },
-    }) as {
+    })) as {
       schedules: Array<{
         id: string;
         mode: string;
@@ -1490,8 +1502,8 @@ describe("wake mode in schedule routes", () => {
     expect(updated!.wakeConversationId).toBe("conv-xyz");
   });
 
-  test("list schedules includes wakeConversationId", () => {
-    createSchedule({
+  test("list schedules includes wakeConversationId", async () => {
+    await createSchedule({
       name: "Wake schedule",
       cronExpression: "0 9 * * *",
       message: "morning wake",
@@ -1501,7 +1513,7 @@ describe("wake mode in schedule routes", () => {
     });
 
     const route = findRoute("schedules", "GET");
-    const result = route.handler({}) as {
+    const result = (await route.handler({})) as {
       schedules: Array<{ name: string; wakeConversationId: string | null }>;
     };
     const wakeSchedule = result.schedules.find(
@@ -1525,9 +1537,9 @@ describe("PATCH /schedules/:id — timeout override", () => {
     return result.schedules[0];
   }
 
-  test("sets and clears the script timeout, exposing it in the list", () => {
+  test("sets and clears the script timeout, exposing it in the list", async () => {
     // GIVEN a script schedule with no timeout override
-    const schedule = createSchedule({
+    const schedule = await createSchedule({
       name: "Script job",
       cronExpression: "0 9 * * *",
       message: "",
@@ -1540,7 +1552,7 @@ describe("PATCH /schedules/:id — timeout override", () => {
     const patch = findRoute("schedules/:id", "PATCH");
 
     // WHEN the guardian sets a custom timeout
-    patch.handler({
+    await patch.handler({
       pathParams: { id: schedule.id },
       body: { timeoutMs: 5000 },
     });
@@ -1549,7 +1561,7 @@ describe("PATCH /schedules/:id — timeout override", () => {
     expect(listOne().timeoutMs).toBe(5000);
 
     // AND WHEN the guardian clears it
-    patch.handler({
+    await patch.handler({
       pathParams: { id: schedule.id },
       body: { timeoutMs: null },
     });
@@ -1558,9 +1570,9 @@ describe("PATCH /schedules/:id — timeout override", () => {
     expect(listOne().timeoutMs).toBeNull();
   });
 
-  test("rejects an out-of-range timeout", () => {
+  test("rejects an out-of-range timeout", async () => {
     // GIVEN a script schedule
-    const schedule = createSchedule({
+    const schedule = await createSchedule({
       name: "Guarded job",
       cronExpression: "0 9 * * *",
       message: "",
@@ -1572,12 +1584,12 @@ describe("PATCH /schedules/:id — timeout override", () => {
     const patch = findRoute("schedules/:id", "PATCH");
 
     // WHEN/THEN patching with a below-minimum timeout throws a RouteError
-    expect(() =>
+    await expect(
       patch.handler({
         pathParams: { id: schedule.id },
         body: { timeoutMs: 10 },
       }),
-    ).toThrow("timeout_ms must be between");
+    ).rejects.toThrow("timeout_ms must be between");
     expect(listOne().timeoutMs).toBeNull();
   });
 });