@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/__tests__/scheduler-recurrence.test.ts

@@ -1,20 +1,4 @@
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // Mock the shared `runBackgroundJob` runner so the scheduler's fresh-bootstrap
 // talk-mode path stays observable in unit tests. Each invocation creates a new
@@ -77,7 +61,7 @@ import {
   getSchedule,
   getScheduleRuns,
 } from "../schedule/schedule-store.js";
-import { startScheduler } from "../schedule/scheduler.js";
+import { runScheduleDueWorkOnce } from "../schedule/scheduler.js";
 import { createTask } from "../tasks/task-store.js";
 
 await initializeDb();
@@ -131,30 +115,7 @@ function buildEndedRrule(): string {
 
 // ── RRULE schedule fires through the scheduler ──────────────────────
 
-// Replace setTimeout with a zero-delay version so the 500ms scheduler
-// wait calls fire instantly instead of waiting real time.
-let origSetTimeout: typeof globalThis.setTimeout;
-
 describe("scheduler RRULE execution", () => {
-  beforeAll(() => {
-    origSetTimeout = globalThis.setTimeout;
-    globalThis.setTimeout = ((
-      fn: TimerHandler,
-      _ms?: number,
-      ...args: unknown[]
-    ) => {
-      // Use a small real delay so fire-and-forget async ticks have time to
-      // settle, while still cutting the 500ms waits down dramatically.
-      // 200ms gives headroom for the run_task path which does a dynamic
-      // import of task-runner.js on first invocation.
-      return origSetTimeout(fn, 200, ...args);
-    }) as typeof setTimeout;
-  });
-
-  afterAll(() => {
-    globalThis.setTimeout = origSetTimeout;
-  });
-
   beforeEach(() => {
     const db = getDb();
     db.run("DELETE FROM cron_runs");
@@ -192,9 +153,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     // The runner should have been invoked with the RRULE message
     expect(
@@ -225,26 +184,14 @@ describe("scheduler RRULE execution", () => {
     forceScheduleDue(schedule.id);
 
     const directCalls: { conversationId: string; message: string }[] = [];
-    let onMessage: (() => void) | undefined;
-    const messageReceived = new Promise<void>((r) => (onMessage = r));
     processMessageImpl = async (conversationId, message) => {
       directCalls.push({ conversationId, message });
-      onMessage?.();
     };
 
-    const scheduler = startScheduler();
-    // The run_task path involves a dynamic import which can take >50ms in CI,
-    // exceeding the patched setTimeout delay. Await the actual callback instead
-    // of relying on a fixed timeout.
-    await Promise.race([
-      messageReceived,
-      new Promise((r) => origSetTimeout(r, 2000)),
-    ]);
-    // Yield to the macrotask queue so all pending microtasks settle —
-    // the scheduler tick still needs to create the schedule run after
-    // processMessage returns.
-    await new Promise((r) => origSetTimeout(r, 0));
-    scheduler.stop();
+    // runScheduleDueWorkOnce() awaits the full tick — including the run_task
+    // dynamic import and processMessage — so the schedule run is recorded by the
+    // time it resolves. No fixed timeout / callback race needed.
+    await runScheduleDueWorkOnce();
 
     // runTask renders the template, so processMessage gets the template text
     const runTaskCalls = directCalls.filter(
@@ -297,9 +244,7 @@ describe("scheduler RRULE execution", () => {
     };
 
     // First tick: the expired schedule should fire its final due run
-    const scheduler1 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler1.stop();
+    await runScheduleDueWorkOnce();
 
     // The message IS delivered once
     expect(processedMessages).toContain("Final expired run");
@@ -317,9 +262,7 @@ describe("scheduler RRULE execution", () => {
 
     // Second tick: the disabled schedule must NOT fire again
     processedMessages.length = 0;
-    const scheduler2 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler2.stop();
+    await runScheduleDueWorkOnce();
 
     expect(processedMessages).not.toContain("Final expired run");
     // No additional runs
@@ -347,9 +290,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     // The runner should have been invoked with the cron message
     expect(processedMessages.some((m) => m.message === "Cron message")).toBe(
@@ -402,9 +343,7 @@ describe("scheduler RRULE execution", () => {
     // Force the schedule to be due
     forceScheduleDue(schedule.id);
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     // The schedule should have been claimed and nextRunAt advanced
     const after = getSchedule(schedule.id);
@@ -451,9 +390,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push(prompt);
     };
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     expect(processedMessages).toContain("Set fire test");
 
@@ -527,9 +464,7 @@ describe("scheduler RRULE execution", () => {
         processedMessages.push(prompt);
       };
 
-      const scheduler = startScheduler();
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      scheduler.stop();
+      await runScheduleDueWorkOnce();
 
       // The schedule should have fired
       expect(processedMessages).toContain("EXRULE scheduler fire");
@@ -565,9 +500,7 @@ describe("scheduler RRULE execution", () => {
     forceScheduleDue(schedule.id);
     const forcedDueAt = getSchedule(schedule.id)!.nextRunAt;
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     const after = getSchedule(schedule.id);
     expect(after).not.toBeNull();
@@ -596,9 +529,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     expect(
       processedMessages.some((m) => m.message === "Execute this once"),
@@ -627,9 +558,7 @@ describe("scheduler RRULE execution", () => {
 
     expect(getSchedule(schedule.id)!.status).toBe("active");
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     expect(notifySignalCalls).toHaveLength(1);
     expect(notifySignalCalls[0]).toMatchObject({
@@ -662,9 +591,7 @@ describe("scheduler RRULE execution", () => {
 
     runBackgroundJobShouldFail = true;
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     const after = getSchedule(schedule.id);
     expect(after).not.toBeNull();
@@ -687,9 +614,7 @@ describe("scheduler RRULE execution", () => {
 
     forceScheduleDue(schedule.id);
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     expect(notifySignalCalls).toHaveLength(1);
     expect(notifySignalCalls[0]).toMatchObject({
@@ -727,9 +652,7 @@ describe("scheduler RRULE execution", () => {
       },
     });
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     expect(notifySignalCalls).toHaveLength(1);
     expect(notifySignalCalls[0].routingIntent).toBe("all_channels");

package/src/__tests__/scheduler-reuse-conversation.test.ts

@@ -1,20 +1,4 @@
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // Mock the shared `runBackgroundJob` runner so the scheduler's fresh-bootstrap
 // talk-mode path stays observable in unit tests. Each invocation creates a new
@@ -88,17 +72,24 @@ mock.module("../runtime/background-job-runner.js", () => ({
 
 // The scheduler's reuse path dispatches into the existing conversation through
 // `processMessage`; capture those calls into the same shared log as the
-// fresh-bootstrap runner so assertions don't need to know which path ran.
+// fresh-bootstrap runner so assertions don't need to know which path ran. The
+// real `processMessage` resolves to `{ messageId, turnFailure? }`, so the mock
+// mirrors that shape — the scheduler destructures `turnFailure` off it.
+type ProcessMessageResult = {
+  messageId: string;
+  turnFailure?: { failureCode?: string };
+};
 const captureProcessedMessage = async (
   conversationId: string,
   message: string,
-): Promise<void> => {
+): Promise<ProcessMessageResult> => {
   processedMessages.push({ conversationId, message });
+  return { messageId: "test-message-id" };
 };
 let processMessageImpl: (
   conversationId: string,
   message: string,
-) => Promise<void> = captureProcessedMessage;
+) => Promise<ProcessMessageResult> = captureProcessedMessage;
 mock.module("../daemon/process-message.js", () => ({
   processMessage: (conversationId: string, message: string) =>
     processMessageImpl(conversationId, message),
@@ -110,7 +101,7 @@ import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { createSchedule, getScheduleRuns } from "../schedule/schedule-store.js";
-import { startScheduler } from "../schedule/scheduler.js";
+import { runScheduleDueWorkOnce } from "../schedule/scheduler.js";
 
 await initializeDb();
 
@@ -146,26 +137,7 @@ function buildEveryMinuteRrule(dtstart: Date = new Date()): string {
   return `DTSTART:${ds}\nRRULE:FREQ=MINUTELY;INTERVAL=1`;
 }
 
-// Replace setTimeout with a zero-delay version so the 500ms scheduler
-// wait calls fire instantly instead of waiting real time.
-let origSetTimeout: typeof globalThis.setTimeout;
-
 describe("scheduler conversation reuse", () => {
-  beforeAll(() => {
-    origSetTimeout = globalThis.setTimeout;
-    globalThis.setTimeout = ((
-      fn: TimerHandler,
-      _ms?: number,
-      ...args: unknown[]
-    ) => {
-      return origSetTimeout(fn, 200, ...args);
-    }) as typeof setTimeout;
-  });
-
-  afterAll(() => {
-    globalThis.setTimeout = origSetTimeout;
-  });
-
   beforeEach(() => {
     const db = getDb();
     db.run("DELETE FROM cron_runs");
@@ -201,9 +173,7 @@ describe("scheduler conversation reuse", () => {
     // WHEN the schedule fires for the first time
     forceScheduleDue(schedule.id);
 
-    const scheduler1 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler1.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN a conversation is created and recorded
     expect(processedMessages).toHaveLength(1);
@@ -220,9 +190,7 @@ describe("scheduler conversation reuse", () => {
     forceScheduleDue(schedule.id);
     processedMessages.length = 0;
 
-    const scheduler2 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler2.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN the same conversation is reused
     expect(processedMessages).toHaveLength(1);
@@ -257,9 +225,7 @@ describe("scheduler conversation reuse", () => {
     // WHEN the schedule fires for the first time
     forceScheduleDue(schedule.id);
 
-    const scheduler1 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler1.stop();
+    await runScheduleDueWorkOnce();
 
     expect(processedMessages).toHaveLength(1);
     const firstConversationId = processedMessages[0].conversationId;
@@ -269,9 +235,7 @@ describe("scheduler conversation reuse", () => {
     forceScheduleDue(schedule.id);
     processedMessages.length = 0;
 
-    const scheduler2 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler2.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN a fresh conversation is created instead of reusing the first
     expect(processedMessages).toHaveLength(1);
@@ -297,9 +261,7 @@ describe("scheduler conversation reuse", () => {
     // WHEN the schedule fires for the first time
     forceScheduleDue(schedule.id);
 
-    const scheduler1 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler1.stop();
+    await runScheduleDueWorkOnce();
 
     expect(processedMessages).toHaveLength(1);
     const firstConversationId = processedMessages[0].conversationId;
@@ -308,9 +270,7 @@ describe("scheduler conversation reuse", () => {
     forceScheduleDue(schedule.id);
     processedMessages.length = 0;
 
-    const scheduler2 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler2.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN a different conversation is created
     expect(processedMessages).toHaveLength(1);
@@ -336,9 +296,7 @@ describe("scheduler conversation reuse", () => {
 
     forceScheduleDue(schedule.id);
 
-    const scheduler1 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler1.stop();
+    await runScheduleDueWorkOnce();
 
     expect(processedMessages).toHaveLength(1);
     const firstConversationId = processedMessages[0].conversationId;
@@ -350,9 +308,7 @@ describe("scheduler conversation reuse", () => {
     forceScheduleDue(schedule.id);
     processedMessages.length = 0;
 
-    const scheduler2 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler2.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN a new conversation is created (not the deleted one)
     expect(processedMessages).toHaveLength(1);
@@ -376,9 +332,7 @@ describe("scheduler conversation reuse", () => {
     });
 
     // WHEN the schedule fires
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN the message is processed with a new conversation
     expect(processedMessages).toHaveLength(1);
@@ -414,11 +368,10 @@ describe("scheduler conversation reuse", () => {
     processMessageImpl = async (conversationId, message) => {
       processedMessages.push({ conversationId, message });
       if (shouldFail) throw new Error("Simulated failure");
+      return { messageId: "test-message-id" };
     };
 
-    const scheduler1 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler1.stop();
+    await runScheduleDueWorkOnce();
 
     expect(processedMessages).toHaveLength(1);
     const successConversationId = processedMessages[0].conversationId;
@@ -428,9 +381,7 @@ describe("scheduler conversation reuse", () => {
     processedMessages.length = 0;
     shouldFail = true;
 
-    const scheduler2 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler2.stop();
+    await runScheduleDueWorkOnce();
 
     // The failed run created a different conversation (since it failed
     // before the run could reuse — actually it does reuse the same one
@@ -442,15 +393,59 @@ describe("scheduler conversation reuse", () => {
     processedMessages.length = 0;
     shouldFail = false;
 
-    const scheduler3 = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler3.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN the third run reuses the conversation from the first successful run
     // (the lookup queries for status="ok", so it picks the first run's conversation)
     expect(processedMessages).toHaveLength(1);
     expect(processedMessages[0].conversationId).toBe(successConversationId);
   });
+
+  test("reuse path records an error when the turn fails without throwing", async () => {
+    /**
+     * Regression: an execute-mode LLM call that fails (e.g. an invalid
+     * provider) ends the turn without throwing — `processMessage` resolves
+     * normally and reports the failure via `turnFailure`. The scheduler must
+     * record the run as an error, not "ok".
+     */
+
+    // GIVEN a recurring reuse schedule whose first run succeeds
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = await createSchedule({
+      name: "Turn Failure Reuse",
+      cronExpression: rruleExpr,
+      message: "Do the thing",
+      syntax: "rrule",
+      expression: rruleExpr,
+      reuseConversation: true,
+    });
+
+    forceScheduleDue(schedule.id);
+    await runScheduleDueWorkOnce();
+
+    const runs1 = getScheduleRuns(schedule.id);
+    expect(runs1[0].status).toBe("ok");
+
+    // WHEN the next run's turn fails at the LLM call (reported via turnFailure,
+    // no exception thrown)
+    forceScheduleDue(schedule.id);
+    processedMessages.length = 0;
+    processMessageImpl = async (conversationId, message) => {
+      processedMessages.push({ conversationId, message });
+      return {
+        messageId: "test-message-id",
+        turnFailure: { failureCode: "provider_error" },
+      };
+    };
+
+    await runScheduleDueWorkOnce();
+
+    // THEN the run is recorded as an error (not "ok") and carries the code
+    const runs2 = getScheduleRuns(schedule.id);
+    expect(runs2.length).toBe(2);
+    expect(runs2[0].status).toBe("error");
+    expect(runs2[0].error).toContain("provider_error");
+  });
 });
 
 describe("scheduler talk-mode runner option propagation", () => {
@@ -479,9 +474,7 @@ describe("scheduler talk-mode runner option propagation", () => {
     });
     forceScheduleDue(schedule.id);
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     expect(runBackgroundJobOptions).toHaveLength(1);
     const opts = runBackgroundJobOptions[0]!;
@@ -503,9 +496,7 @@ describe("scheduler talk-mode runner option propagation", () => {
     });
     forceScheduleDue(schedule.id);
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     expect(runBackgroundJobOptions).toHaveLength(1);
     expect(runBackgroundJobOptions[0]!.suppressFailureNotifications).toBe(
@@ -531,9 +522,7 @@ describe("scheduler talk-mode runner option propagation", () => {
     forceScheduleDue(schedule.id);
     runBackgroundJobBootstrapFails = true;
 
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     const runs = getScheduleRuns(schedule.id);
     expect(runs.length).toBe(1);
@@ -572,9 +561,7 @@ describe("scheduler talk-mode runner option propagation", () => {
         }
       },
     });
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
     subscription.dispose();
 
     expect(sseCalls).toHaveLength(1);

package/src/__tests__/scheduler-wake.test.ts

@@ -1,20 +1,4 @@
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const mockWakeAgentForOpportunity = mock(
   (): Promise<{
@@ -36,7 +20,7 @@ import { loadRawConfig, saveRawConfig } from "../config/loader.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { createSchedule } from "../schedule/schedule-store.js";
-import { startScheduler } from "../schedule/scheduler.js";
+import { runScheduleDueWorkOnce } from "../schedule/scheduler.js";
 
 await initializeDb();
 
@@ -61,26 +45,7 @@ function forceScheduleDue(scheduleId: string): void {
   ]);
 }
 
-// Replace setTimeout with a fast-forward version so the scheduler
-// wait calls fire quickly instead of waiting real time.
-let origSetTimeout: typeof globalThis.setTimeout;
-
 describe("scheduler wake mode", () => {
-  beforeAll(() => {
-    origSetTimeout = globalThis.setTimeout;
-    globalThis.setTimeout = ((
-      fn: TimerHandler,
-      _ms?: number,
-      ...args: unknown[]
-    ) => {
-      return origSetTimeout(fn, 200, ...args);
-    }) as typeof setTimeout;
-  });
-
-  afterAll(() => {
-    globalThis.setTimeout = origSetTimeout;
-  });
-
   beforeEach(() => {
     const db = getDb();
     db.run("DELETE FROM cron_runs");
@@ -105,9 +70,7 @@ describe("scheduler wake mode", () => {
     forceScheduleDue(schedule.id);
 
     // WHEN the scheduler fires
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN wakeAgentForOpportunity is called with the correct arguments
     expect(mockWakeAgentForOpportunity).toHaveBeenCalledTimes(1);
@@ -140,9 +103,7 @@ describe("scheduler wake mode", () => {
     forceScheduleDue(schedule.id);
 
     // WHEN the scheduler fires
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN wakeAgentForOpportunity is NOT called
     expect(mockWakeAgentForOpportunity).not.toHaveBeenCalled();
@@ -171,9 +132,7 @@ describe("scheduler wake mode", () => {
     forceScheduleDue(schedule.id);
 
     // WHEN the scheduler fires
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN the one-shot is marked as completed (status = 'fired')
     const row = getRawDb()
@@ -196,9 +155,7 @@ describe("scheduler wake mode", () => {
     forceScheduleDue(schedule.id);
 
     // WHEN the scheduler fires
-    const scheduler = startScheduler();
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
+    await runScheduleDueWorkOnce();
 
     // THEN the one-shot is reverted to 'active' for retry (failOneShot behavior)
     const row = getRawDb()
@@ -229,10 +186,8 @@ describe("scheduler wake mode", () => {
     });
     forceScheduleDue(schedule.id);
 
-    const scheduler = startScheduler();
-
-    // WHEN the first tick runs (fires immediately from startScheduler)
-    await new Promise((resolve) => origSetTimeout(resolve, 600));
+    // WHEN the first tick runs
+    await runScheduleDueWorkOnce();
 
     // THEN the job is NOT completed — it's reverted to 'active' for retry
     const rowAfterFirst = getRawDb()
@@ -241,9 +196,8 @@ describe("scheduler wake mode", () => {
     expect(rowAfterFirst?.status).toBe("active");
     expect(rowAfterFirst?.retry_count).toBe(1);
 
-    // WHEN the second tick fires (call runOnce directly to avoid waiting for setInterval)
-    await scheduler.runOnce();
-    scheduler.stop();
+    // WHEN the second tick fires
+    await runScheduleDueWorkOnce();
 
     // THEN the job IS completed (status = 'fired')
     const rowAfterSecond = getRawDb()
@@ -277,10 +231,8 @@ describe("scheduler wake mode", () => {
       schedule.id,
     ]);
 
-    // WHEN the scheduler fires (first tick runs immediately from startScheduler)
-    const scheduler = startScheduler();
-    await new Promise((resolve) => origSetTimeout(resolve, 600));
-    scheduler.stop();
+    // WHEN the scheduler fires
+    await runScheduleDueWorkOnce();
 
     // THEN the job is permanently failed (status = 'cancelled', enabled = false)
     const row = getRawDb()

package/src/__tests__/scheduler-worker-standdown.test.ts

@@ -7,14 +7,6 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 mock.module("../background-wake/publisher.js", () => ({
   refreshBackgroundWakeIntent: () => {},
 }));