@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/schedule/__tests__/worker-control.test.ts

@@ -206,19 +206,26 @@ describe("spawnScheduleWorkerProcess", () => {
     }
   });
 
-  test("reuses an already-running worker without spawning", async () => {
+  test("spawns when the PID file names an unrelated live process", async () => {
     writeFileSync(pidPath, String(process.pid));
     let spawned = false;
     const restore = stubBunSpawn(() => {
       spawned = true;
-      return { unref: () => {}, kill: () => {}, pid: 1, exited: neverExits() };
+      writeFileSync(pidPath, "4242");
+      return {
+        unref: () => {},
+        kill: () => {},
+        pid: 4242,
+        exited: neverExits(),
+      };
     });
     try {
       const result = await spawnScheduleWorkerProcess({
-        pidWaitTimeoutMs: 100,
+        pidWaitTimeoutMs: 1_000,
+        pidPollIntervalMs: 10,
       });
-      expect(result).toEqual({ pid: process.pid, alreadyRunning: true });
-      expect(spawned).toBe(false);
+      expect(result).toEqual({ pid: 4242, alreadyRunning: false });
+      expect(spawned).toBe(true);
     } finally {
       restore();
     }
@@ -240,6 +247,11 @@ describe("probeScheduleWorker", () => {
     }
   });
 
+  test("reports not_running when the PID file names a live process that is not this worker", () => {
+    writeFileSync(pidPath, String(process.pid));
+    expect(probeScheduleWorker()).toEqual({ status: "not_running" });
+  });
+
   test("reports running (not throws) when the process exists but is not signalable (EPERM)", () => {
     writeFileSync(pidPath, "4321");
     const restore = stubProcessKill(new Set(), new Set([4321]));
@@ -256,6 +268,25 @@ describe("stopScheduleWorkerProcess", () => {
     expect(stopScheduleWorkerProcess()).toEqual({ status: "not_running" });
   });
 
+  test("does not signal a recycled PID that is not this worker", () => {
+    writeFileSync(pidPath, String(process.pid));
+    const signalled: Array<[number, string | number | undefined]> = [];
+    const original = process.kill.bind(process);
+    process.kill = ((pid: number, signal?: string | number) => {
+      if ((signal ?? 0) === 0) {
+        return original(pid, signal);
+      }
+      signalled.push([pid, signal]);
+      return true;
+    }) as typeof process.kill;
+    try {
+      expect(stopScheduleWorkerProcess()).toEqual({ status: "not_running" });
+      expect(signalled).toEqual([]);
+    } finally {
+      process.kill = original;
+    }
+  });
+
   test("signals a running worker and reports its prior state", () => {
     writeFileSync(pidPath, "4321");
     const signalled: Array<[number, string | number | undefined]> = [];

package/src/schedule/__tests__/worker-mcp-bootstrap.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Timing coverage for the schedule-worker MCP bootstrap and reload helpers.
+ *
+ * The worker entrypoint cannot be imported (it calls process.exit). These
+ * tests drive the extracted helpers with a delayed start so a due schedule
+ * cannot observe a ready surface before registration settles.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { EMPTY_MCP_STARTUP_SNAPSHOT } from "../../mcp/tool-caps.js";
+import {
+  getScheduleToolSurfaceState,
+  isScheduleToolSurfaceReady,
+  resetScheduleToolSurfaceReadinessForTests,
+} from "../tool-surface-readiness.js";
+import {
+  bootstrapScheduleWorkerMcp,
+  reloadScheduleWorkerMcp,
+} from "../worker-mcp.js";
+
+function deferred<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+} {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
+afterEach(() => {
+  resetScheduleToolSurfaceReadinessForTests();
+});
+
+describe("bootstrapScheduleWorkerMcp", () => {
+  test("stays unready past the grace period until start settles", async () => {
+    const gate = deferred<typeof EMPTY_MCP_STARTUP_SNAPSHOT>();
+    const snapshot = {
+      ...EMPTY_MCP_STARTUP_SNAPSHOT,
+      configuredServerCount: 8,
+      connectedServerCount: 8,
+      registeredToolCount: 3,
+    };
+
+    const boot = bootstrapScheduleWorkerMcp({
+      start: () => gate.promise,
+      graceMs: 20,
+    });
+    await boot;
+
+    expect(isScheduleToolSurfaceReady()).toBe(false);
+    expect(getScheduleToolSurfaceState()).toBe("starting");
+
+    gate.resolve(snapshot);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(isScheduleToolSurfaceReady()).toBe(true);
+    expect(getScheduleToolSurfaceState()).toBe("ready");
+  });
+
+  test("marks ready when start finishes before the grace deadline", async () => {
+    await bootstrapScheduleWorkerMcp({
+      start: async () => ({
+        ...EMPTY_MCP_STARTUP_SNAPSHOT,
+        registeredToolCount: 2,
+      }),
+      graceMs: 50,
+    });
+
+    expect(isScheduleToolSurfaceReady()).toBe(true);
+  });
+});
+
+describe("reloadScheduleWorkerMcp", () => {
+  test("is not ready while reload is in flight", async () => {
+    const gate = deferred<typeof EMPTY_MCP_STARTUP_SNAPSHOT>();
+    const reloading = reloadScheduleWorkerMcp({
+      restart: () => gate.promise,
+    });
+
+    expect(getScheduleToolSurfaceState()).toBe("reloading");
+    expect(isScheduleToolSurfaceReady()).toBe(false);
+
+    gate.resolve({
+      ...EMPTY_MCP_STARTUP_SNAPSHOT,
+      registeredToolCount: 4,
+    });
+    await reloading;
+
+    expect(isScheduleToolSurfaceReady()).toBe(true);
+  });
+
+  test("failed reload does not stay in reloading", async () => {
+    await expect(
+      reloadScheduleWorkerMcp({
+        restart: async () => {
+          throw new Error("reconnect failed");
+        },
+      }),
+    ).rejects.toThrow("reconnect failed");
+
+    expect(getScheduleToolSurfaceState()).toBe("ready");
+    expect(isScheduleToolSurfaceReady()).toBe(true);
+  });
+});

package/src/schedule/__tests__/worker-mcp-readiness.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Scheduler gate for tool-backed schedules while the MCP surface is not ready.
+ *
+ * A due execute schedule must not record success while worker MCP
+ * initialization is still incomplete. Once ready, the expected MCP tool
+ * has to be present in the registry the turn would use.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import { getDb } from "../../persistence/db-connection.js";
+import { initializeDb } from "../../persistence/db-init.js";
+import { RiskLevel } from "../../tools/tool-types.js";
+import { createSchedule } from "../schedule-store.js";
+import {
+  markScheduleToolSurfaceStarting,
+  resetScheduleToolSurfaceReadinessForTests,
+} from "../tool-surface-readiness.js";
+
+const processedPrompts: string[] = [];
+mock.module("../../runtime/background-job-runner.js", () => ({
+  runBackgroundJob: async (opts: { prompt: string }) => {
+    const { getMcpToolDefinitions } = await import("../../tools/registry.js");
+    capturedMcpTools = getMcpToolDefinitions().map((tool) => tool.name);
+    processedPrompts.push(opts.prompt);
+    return { conversationId: "conv-xyz", ok: true };
+  },
+}));
+
+mock.module("../../daemon/process-message.js", () => ({
+  processMessage: async () => ({ messageId: "msg-xyz" }),
+  processMessageInBackground: async () => {},
+}));
+
+mock.module("../../background-wake/publisher.js", () => ({
+  refreshBackgroundWakeIntent: () => {},
+}));
+
+mock.module("../../daemon/disk-pressure-background-gate.js", () => ({
+  checkDiskPressureBackgroundGate: () => ({
+    action: "allow",
+    status: {
+      enabled: false,
+      state: "disabled",
+      locked: false,
+      acknowledged: false,
+      overrideActive: false,
+      effectivelyLocked: false,
+      lockId: null,
+      usagePercent: null,
+      thresholdPercent: 95,
+      path: null,
+      lastCheckedAt: null,
+      blockedCapabilities: [],
+      error: null,
+    },
+  }),
+  diskPressureBackgroundSkipLogFields: () => ({}),
+  shouldLogDiskPressureBackgroundSkip: () => false,
+}));
+
+const mockEmitNotificationSignal = mock(() => Promise.resolve());
+mock.module("../../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: mockEmitNotificationSignal,
+}));
+
+const { runDueSchedulesOnce } = await import("../scheduler.js");
+const { __resetRegistryForTesting, getTool, registerMcpTools } =
+  await import("../../tools/registry.js");
+
+await initializeDb();
+
+let capturedMcpTools: string[] = [];
+
+function rawDb(): import("bun:sqlite").Database {
+  return (getDb() as unknown as { $client: import("bun:sqlite").Database })
+    .$client;
+}
+
+afterEach(() => {
+  resetScheduleToolSurfaceReadinessForTests();
+  processedPrompts.length = 0;
+  capturedMcpTools = [];
+  mockEmitNotificationSignal.mockClear();
+  __resetRegistryForTesting();
+  const db = getDb();
+  db.run("DELETE FROM cron_runs");
+  db.run("DELETE FROM cron_jobs");
+});
+
+describe("automatic schedule MCP readiness", () => {
+  test("defers a due execute schedule while MCP is still starting", async () => {
+    markScheduleToolSurfaceStarting(8);
+    const job = await createSchedule({
+      name: "Friday tagging",
+      cronExpression: "* * * * *",
+      message: "Tag new Reader documents",
+      mode: "execute",
+    });
+    rawDb().run("UPDATE cron_jobs SET next_run_at = ?", [Date.now() - 1000]);
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.claimed).toBe(1);
+    expect(result.skipped).toBe(1);
+    expect(result.completed).toBe(0);
+    expect(processedPrompts).toEqual([]);
+    const runs = rawDb()
+      .query("SELECT status FROM cron_runs WHERE job_id = ?")
+      .all(job.id) as Array<{ status: string }>;
+    expect(runs).toEqual([]);
+    const row = rawDb()
+      .query("SELECT status, enabled FROM cron_jobs WHERE id = ?")
+      .get(job.id) as { status: string; enabled: number };
+    expect(row.status).toBe("active");
+    expect(row.enabled).toBe(1);
+  });
+
+  test("still fires notify and script schedules while MCP is starting", async () => {
+    markScheduleToolSurfaceStarting(8);
+    await createSchedule({
+      name: "Ping",
+      cronExpression: "* * * * *",
+      message: "ping",
+      mode: "notify",
+    });
+    await createSchedule({
+      name: "Script",
+      cronExpression: "* * * * *",
+      message: "run script",
+      mode: "script",
+      script: "true",
+    });
+    rawDb().run("UPDATE cron_jobs SET next_run_at = ?", [Date.now() - 1000]);
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.completed).toBe(2);
+    expect(mockEmitNotificationSignal).toHaveBeenCalledTimes(1);
+  });
+
+  test("an automatic execute run sees the registered MCP tool once ready", async () => {
+    registerMcpTools("reader", [
+      {
+        name: "mcp__reader__list_documents",
+        description: "List documents",
+        defaultRiskLevel: RiskLevel.Low,
+        executionTarget: "sandbox",
+        input_schema: { type: "object", properties: {}, required: [] },
+        category: "",
+        async execute() {
+          return { content: "ok", isError: false };
+        },
+      },
+    ]);
+    resetScheduleToolSurfaceReadinessForTests();
+
+    await createSchedule({
+      name: "Saturday digest",
+      cronExpression: "* * * * *",
+      message: "Build the Reader digest",
+      mode: "execute",
+    });
+    rawDb().run("UPDATE cron_jobs SET next_run_at = ?", [Date.now() - 1000]);
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.completed).toBe(1);
+    expect(processedPrompts).toEqual(["Build the Reader digest"]);
+    expect(capturedMcpTools).toContain("mcp__reader__list_documents");
+    expect(getTool("mcp__reader__list_documents")).toBeDefined();
+  });
+});

package/src/schedule/__tests__/worker-mcp-tools.test.ts

@@ -1,38 +1,19 @@
 /**
  * Guard over the schedule worker entrypoint's MCP bootstrap.
  *
- * The tool registry is process-local and MCP tools reach it only by connecting
- * to each server and listing what it offers. `initializeTools()` does not do
- * that: it loads core built-ins and workspace tools from disk. So a worker
- * that stops connecting fails every `mcp__*` call an execute-mode schedule
- * makes as "Unknown tool", while `assistant tools list` reads the daemon's
- * registry over IPC and reports the same tool as registered. The mismatch is
- * what makes the failure hard to place, so it is worth a guard.
- *
- * The worker is also long-lived, so the set it connects at startup goes stale
- * as soon as the config moves. It watches for the daemon's reload signal to
- * rebuild, which is covered here too.
- *
- * The entrypoint installs signal handlers and calls `process.exit`, so it
- * cannot be imported into a test process; these assertions read its source the
- * way `worker-feature-flags.test.ts` does. The behavior of the steps
- * themselves is covered in `src/mcp/__tests__/startup.test.ts` and
- * `src/mcp/__tests__/reload-signal.test.ts`.
+ * Behavioral coverage lives in worker-mcp-readiness.test.ts. This file only
+ * asserts the process entrypoint still calls the extracted helpers before
+ * the first tick, because the entrypoint installs signal handlers and
+ * calls process.exit and cannot be imported into a test process.
  */
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-const MCP_CALL = "startConfiguredMcpServers(";
-
-/** The bounded wait that keeps unreachable servers off the critical path. */
-const MCP_GRACE = "MCP_STARTUP_GRACE_MS";
-
-/** The reload watcher that keeps the connected set current. */
+const MCP_BOOTSTRAP = "bootstrapScheduleWorkerMcp(";
+const MCP_RELOAD = "reloadScheduleWorkerMcp(";
 const MCP_WATCH = "watchForMcpReload(";
-
-/** The worker's first call that can execute a schedule. */
 const WORK_START = "void tick()";
 
 function readWorkerSource(): string {
@@ -40,37 +21,22 @@ function readWorkerSource(): string {
 }
 
 describe("schedule worker MCP tools", () => {
-  test("connects its own MCP servers before the first schedule tick", () => {
+  test("bootstraps its own MCP servers before the first schedule tick", () => {
     const source = readWorkerSource();
-    const mcpAt = source.indexOf(MCP_CALL);
+    const mcpAt = source.indexOf(MCP_BOOTSTRAP);
     const workAt = source.indexOf(WORK_START);
 
     expect(
       mcpAt,
-      `The schedule worker must call \`${MCP_CALL})\` at startup. This ` +
+      `The schedule worker must call \`${MCP_BOOTSTRAP})\` at startup. This ` +
         "process hosts execute-mode schedule turns, and its tool registry is " +
         "its own: without the call it has no mcp__* tools at all.",
     ).toBeGreaterThanOrEqual(0);
     expect(workAt).toBeGreaterThanOrEqual(0);
     expect(
       mcpAt < workAt,
-      "The connect starts and is waited on before the first tick, so a " +
-        "schedule that fires immediately runs with the tools it was written " +
-        "against. The wait is bounded (see below), so a server that never " +
-        "answers delays it rather than blocking it.",
-    ).toBe(true);
-  });
-
-  test("bounds the startup wait so unrelated schedules still fire", () => {
-    const source = readWorkerSource();
-
-    expect(
-      source.includes(MCP_GRACE),
-      "`McpServerManager.start()` walks servers one at a time and allows " +
-        "each 30s to connect and 30s more to list its tools. An unbounded " +
-        "wait lets a few unreachable servers hold every due schedule, " +
-        "including the notify and script ones that never touch MCP, while " +
-        "the PID file already reports this worker as running.",
+      "The connect starts and is waited on before the first tick. Tool-backed " +
+        "schedules stay deferred until that surface is marked ready.",
     ).toBe(true);
   });
 
@@ -78,11 +44,11 @@ describe("schedule worker MCP tools", () => {
     const source = readWorkerSource();
 
     expect(
-      source.includes(MCP_WATCH),
+      source.includes(MCP_WATCH) && source.includes(MCP_RELOAD),
       "This process is long-lived and holds its own connections. Without " +
         "the watcher, a server disabled or removed in the config stays " +
         "registered and callable by background schedules until the worker " +
-        "restarts.",
+        "restarts. Reload must mark the tool surface unready until it settles.",
     ).toBe(true);
   });
 });

package/src/schedule/run-script.ts

@@ -1,6 +1,7 @@
 import { buildSanitizedEnv } from "../tools/terminal/safe-env.js";
 import {
   buildShellInvocation,
+  buildShellSpawnFlags,
   terminateProcessTree,
 } from "../util/host-process.js";
 import { getLogger } from "../util/logger.js";
@@ -64,10 +65,9 @@ export async function runScript(
   const shell = buildShellInvocation(command);
   const proc = Bun.spawn([shell.command, ...shell.args], {
     cwd,
-    detached: true,
+    ...buildShellSpawnFlags(),
     stdout: "pipe",
     stderr: "pipe",
-    windowsHide: true,
     env: {
       ...buildSanitizedEnv(),
       // __SCHEDULE_ID lets a saved command find its own dir; __SCHEDULE_RUN_ID

package/src/schedule/scheduler.ts

@@ -58,6 +58,13 @@ import {
   scheduleRetry,
   setScheduleRunConversationId,
 } from "./schedule-store.js";
+import {
+  getScheduleToolSurfaceSnapshot,
+  getScheduleToolSurfaceState,
+  isScheduleToolSurfaceReady,
+  MCP_NOT_READY_DEFER_MS,
+  scheduleModeNeedsToolSurface,
+} from "./tool-surface-readiness.js";
 import { buildWakeScheduleOptions } from "./wake-schedule-options.js";
 import {
   isScheduleWorkerAdministrativelyStopped,
@@ -703,6 +710,32 @@ export async function runDueSchedulesOnce(
       continue;
     }
 
+    if (
+      scheduleModeNeedsToolSurface(job.mode) &&
+      !isScheduleToolSurfaceReady()
+    ) {
+      log.info(
+        {
+          jobId: job.id,
+          name: job.name,
+          mode: job.mode,
+          toolSurfaceState: getScheduleToolSurfaceState(),
+          ...getScheduleToolSurfaceSnapshot(),
+        },
+        "Deferring tool-backed schedule until the MCP tool surface is ready",
+      );
+      try {
+        await deferClaimedSchedule(job.id, Date.now() + MCP_NOT_READY_DEFER_MS);
+      } catch (err) {
+        log.warn(
+          { err, jobId: job.id },
+          "Failed to defer claimed schedule while MCP tool surface is not ready",
+        );
+      }
+      result.skipped += 1;
+      continue;
+    }
+
     const isOneShot = job.expression == null;
 
     // ── Notify mode (one-shot or recurring) ─────────────────────────
@@ -1149,19 +1182,22 @@ export async function runDueSchedulesOnce(
       // that before the run is called done and its one result is produced.
       await awaitDelegatedWork(conversationId, runStartedAt, log);
       await completeScheduleRun(runId, { status: "ok" });
-      // The run succeeded; make sure it was not invisible. No-ops when the run
-      // already notified or produced nothing user-facing, so a schedule whose
-      // prompt ends in an explicit `assistant notifications send` is unaffected.
+      // Automatic completion notification for successful execute-mode runs.
+      // Quiet schedules skip this fallback so a clean tick stays silent.
+      // Explicit in-run delivery (e.g. `assistant notifications send`) is
+      // unaffected because it never goes through this producer.
       // Awaited rather than fired and forgotten: the schedule worker can exit
       // once the tick's loop drains, and a detached emit would race that exit.
-      await emitScheduleResultNotification({
-        scheduleId: job.id,
-        scheduleName: job.name,
-        conversationId,
-        runId,
-        runStartedAt,
-        rlog: log,
-      });
+      if (!job.quiet) {
+        await emitScheduleResultNotification({
+          scheduleId: job.id,
+          scheduleName: job.name,
+          conversationId,
+          runId,
+          runStartedAt,
+          rlog: log,
+        });
+      }
       if (isOneShot) {
         await completeOneShot(job.id);
       }

package/src/schedule/tool-surface-readiness.ts

@@ -0,0 +1,65 @@
+/**
+ * Process-local readiness of the MCP tool surface this process hosts.
+ *
+ * MCP tools reach the registry only after every configured server has been
+ * attempted. Until that pass settles, an execute/wake/workflow schedule that
+ * fires would record success while `mcp__*` calls fail as unknown tools.
+ * Notify and script schedules do not use that surface and keep firing.
+ *
+ * Default is ready so callers that never bootstrap MCP (existing scheduler
+ * tests, the daemon's unused tick) are not blocked. The schedule worker
+ * marks starting/reloading around its own connect.
+ */
+
+import {
+  EMPTY_MCP_STARTUP_SNAPSHOT,
+  type McpStartupSnapshot,
+} from "../mcp/tool-caps.js";
+import type { ScheduleMode } from "./schedule-store.js";
+
+export type ScheduleToolSurfaceState = "ready" | "starting" | "reloading";
+
+/** How far a claimed tool-backed schedule is pushed back while MCP is not ready. */
+export const MCP_NOT_READY_DEFER_MS = 5_000;
+
+let state: ScheduleToolSurfaceState = "ready";
+let snapshot: McpStartupSnapshot = EMPTY_MCP_STARTUP_SNAPSHOT;
+
+export function scheduleModeNeedsToolSurface(mode: ScheduleMode): boolean {
+  return mode === "execute" || mode === "wake" || mode === "workflow";
+}
+
+export function isScheduleToolSurfaceReady(): boolean {
+  return state === "ready";
+}
+
+export function getScheduleToolSurfaceState(): ScheduleToolSurfaceState {
+  return state;
+}
+
+export function getScheduleToolSurfaceSnapshot(): McpStartupSnapshot {
+  return snapshot;
+}
+
+export function markScheduleToolSurfaceStarting(
+  configuredServerCount = 0,
+): void {
+  state = "starting";
+  snapshot = { ...EMPTY_MCP_STARTUP_SNAPSHOT, configuredServerCount };
+}
+
+export function markScheduleToolSurfaceReloading(): void {
+  state = "reloading";
+}
+
+export function markScheduleToolSurfaceReady(
+  next: McpStartupSnapshot = EMPTY_MCP_STARTUP_SNAPSHOT,
+): void {
+  state = "ready";
+  snapshot = next;
+}
+
+export function resetScheduleToolSurfaceReadinessForTests(): void {
+  state = "ready";
+  snapshot = EMPTY_MCP_STARTUP_SNAPSHOT;
+}

package/src/schedule/worker-control.ts

@@ -19,6 +19,8 @@ import {
   type WorkerProcessStatus,
 } from "../util/worker-process.js";
 
+const SCHEDULE_WORKER_ENTRY = new URL("./worker.ts", import.meta.url);
+
 const log = getLogger("schedule-worker-control");
 
 /**
@@ -42,11 +44,15 @@ export function setScheduleWorkerAdministrativelyStopped(value: boolean): void {
 
 /**
  * Inspect the PID file to determine whether the schedule worker process is
- * alive. A stale PID file (pointing at a dead process) is cleaned up and
- * reported as not_running.
+ * alive. A stale PID file (pointing at a dead process, or at a live process
+ * that is not this worker) is cleaned up and reported as not_running.
  */
 export function probeScheduleWorker(): WorkerProcessStatus {
-  return probeWorkerPidFile(getScheduleWorkerPidPath());
+  return probeWorkerPidFile(
+    getScheduleWorkerPidPath(),
+    SCHEDULE_WORKER_ENTRY,
+    "schedule",
+  );
 }
 
 export class ScheduleWorkerSpawnError extends WorkerProcessSpawnError {}
@@ -95,7 +101,7 @@ async function spawnScheduleWorkerProcessUncoalesced(
   try {
     return await spawnWorkerProcess({
       pidPath: getScheduleWorkerPidPath(),
-      entry: new URL("./worker.ts", import.meta.url),
+      entry: SCHEDULE_WORKER_ENTRY,
       packagedEntry: "schedule",
       workerLabel: "Schedule worker",
       options: opts,
@@ -114,7 +120,11 @@ async function spawnScheduleWorkerProcessUncoalesced(
  * `process.kill` itself fails (e.g. EPERM) — a not-running worker is a no-op.
  */
 export function stopScheduleWorkerProcess(): WorkerProcessStatus {
-  return stopWorkerProcess(getScheduleWorkerPidPath());
+  return stopWorkerProcess(
+    getScheduleWorkerPidPath(),
+    SCHEDULE_WORKER_ENTRY,
+    "schedule",
+  );
 }
 
 /**