@vellumai/assistant 0.12.2 → 0.12.3-staging.1

package/src/runtime/routes/schedule-routes.ts

@@ -213,6 +213,7 @@ const scheduleSchema = z.object({
   mode: z.enum(["notify", "execute", "script", "wake", "workflow"]),
   status: z.enum(["active", "firing", "fired", "cancelled"]),
   routingIntent: z.enum(["single_channel", "multi_channel", "all_channels"]),
+  quiet: z.boolean(),
   reuseConversation: z.boolean(),
   wakeConversationId: z.string().nullable(),
   workflowName: z.string().nullable(),
@@ -381,6 +382,7 @@ function serializeSchedule(
     mode: j.mode,
     status: j.status,
     routingIntent: j.routingIntent,
+    quiet: j.quiet,
     reuseConversation: j.reuseConversation,
     wakeConversationId: j.wakeConversationId,
     workflowName: j.workflowName,

package/src/runtime/routes/secret-routes.ts

@@ -16,10 +16,7 @@ import {
 } from "../../acp/acp-credentials.js";
 import {
   getPlatformAssistantId,
-  setPlatformAssistantId,
   setPlatformBaseUrl,
-  setPlatformOrganizationId,
-  setPlatformUserId,
 } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
 import { maybeDefaultSpeechToManaged } from "../../config/managed-speech-defaults.js";
@@ -41,6 +38,7 @@ import {
   refreshProvidersAfterSecretChange,
   refreshProvidersForRotatedCredential,
 } from "../../providers/inference/credential-rotation.js";
+import { validateJevApiKey } from "../../providers/jev/client.js";
 import { validateMinimaxApiKey } from "../../providers/minimax/client.js";
 import { validateOpenAIApiKey } from "../../providers/openai/client.js";
 import { validatePoolsideApiKey } from "../../providers/poolside/client.js";
@@ -79,6 +77,48 @@ const log = getLogger("runtime-http");
 const CES_READY_POLL_INTERVAL_MS = 500;
 const CES_READY_POLL_TIMEOUT_MS = 30_000;
 
+const WRITABLE_VELLUM_CREDENTIAL_FIELDS = [
+  "assistant_api_key",
+  "webhook_secret",
+  "platform_base_url",
+] as const;
+
+function isWritableVellumCredentialField(field: string): boolean {
+  return (WRITABLE_VELLUM_CREDENTIAL_FIELDS as readonly string[]).includes(
+    field,
+  );
+}
+
+async function persistCredential(
+  service: string,
+  field: string,
+  value: string,
+): Promise<void> {
+  const key = credentialKey(service, field);
+  const stored = await setSecureKeyAsync(key, value);
+  if (!stored) {
+    throw new InternalError(
+      `Failed to store credential in secure storage (backend: ${getActiveBackendName()})`,
+    );
+  }
+  if (!isNonSecretPlatformField(service, field)) {
+    try {
+      const scrubbed = await scrubStoredCredentialFromTranscripts(value);
+      log.info(
+        { service, field, ...scrubbed },
+        "Credential stored; scrubbed value from recent transcripts",
+      );
+    } catch (err) {
+      log.warn(
+        { err, service, field },
+        "Credential stored, but transcript scrub failed",
+      );
+    }
+  }
+  upsertCredentialMetadata(service, field, {});
+  await syncManualTokenConnection(service);
+}
+
 let apiKeyGeneration = 0;
 
 async function queueApiKeyPropagation(
@@ -263,6 +303,15 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           );
           return { success: false, error: validation.reason };
         }
+      } else if (name === "jev") {
+        const validation = await validateJevApiKey(value);
+        if (!validation.valid) {
+          log.warn(
+            { provider: name, reason: validation.reason },
+            "API key validation failed",
+          );
+          return { success: false, error: validation.reason };
+        }
       }
 
       const stored = await setSecureKeyAsync(
@@ -307,10 +356,50 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           'For credential type, name must be in "service:field" format (e.g. "github:api_token")',
         );
       }
-      assertMetadataWritable();
       const service = name.slice(0, colonIdx);
       const field = name.slice(colonIdx + 1);
 
+      if (service === "vellum") {
+        if (!isWritableVellumCredentialField(field)) {
+          throw new BadRequestError(
+            `Unknown vellum credential: ${field}. Allowed fields: ${WRITABLE_VELLUM_CREDENTIAL_FIELDS.join(", ")}`,
+          );
+        }
+        assertMetadataWritable();
+        await persistCredential(service, field, value);
+        if (field === "platform_base_url") {
+          setPlatformBaseUrl(value);
+        }
+        if (isPlatformManagedCredential(service, field)) {
+          await refreshProvidersAfterSecretChange();
+          // Close the first-boot race where the startup capability seed ran before
+          // the managed embedding credential was provisioned, leaving skill/CLI
+          // pages unseeded until restart. Detached, must not block the response.
+          void maybeReseedCapabilitiesAfterManagedCredential(getConfig());
+          if (field === "assistant_api_key") {
+            await notifyCesOfAssistantApiKeyUpdate(value, getCesClient());
+          }
+        } else {
+          await refreshProvidersForRotatedCredential(service, field);
+        }
+        if (field === "assistant_api_key" || field === "platform_base_url") {
+          // Managed-speech availability needs the API key, the assistant ID,
+          // and the base URL. Fire on each write that completes a piece of
+          // that set; the hook no-ops until the connection is complete.
+          // Detached, must not block the response.
+          void maybeDefaultSpeechToManaged();
+          // Same last-write-wins shape: the startup syncs no-op before live
+          // registration, so re-enqueue them here. Both dedup and no-op until
+          // the client and assistant id exist.
+          syncWorkspaceIdentityToPlatform();
+          syncAvatarToPlatform();
+        }
+        log.info({ service, field }, "Credential added via HTTP");
+        return { success: true, type, name };
+      }
+
+      assertMetadataWritable();
+
       // Reject an Anthropic API key pasted into the ACP OAuth-token field (a 401
       // footgun) as a 400 rather than letting it persist and fail at runtime.
       if (service === ACP_SERVICE) {
@@ -324,104 +413,8 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
         }
       }
 
-      const key = credentialKey(service, field);
-
-      const TRIMMED_IDENTITY_FIELDS = new Set([
-        "platform_assistant_id",
-        "platform_organization_id",
-        "platform_user_id",
-      ]);
-      const isTrimmedIdentity =
-        service === "vellum" && TRIMMED_IDENTITY_FIELDS.has(field);
-      const effectiveValue = isTrimmedIdentity ? value.trim() : value;
-
-      if (isTrimmedIdentity && effectiveValue === "") {
-        const deleteResult = await deleteSecureKeyAsync(key);
-        if (deleteResult === "error") {
-          throw new InternalError(
-            `Failed to delete stale credential from secure storage: ${service}:${field}`,
-          );
-        }
-        if (field === "platform_assistant_id") {
-          setPlatformAssistantId(undefined);
-        } else if (field === "platform_organization_id") {
-          setPlatformOrganizationId(undefined);
-        } else if (field === "platform_user_id") {
-          setPlatformUserId(undefined);
-        }
-        deleteCredentialMetadata(service, field);
-      } else {
-        const stored = await setSecureKeyAsync(key, effectiveValue);
-        if (!stored) {
-          throw new InternalError(
-            `Failed to store credential in secure storage (backend: ${getActiveBackendName()})`,
-          );
-        }
-        if (!isNonSecretPlatformField(service, field)) {
-          // Same seam as the api_key branch: the scrub runs immediately after
-          // the secure-store write, before side effects that can throw. The
-          // value IS stored at this point; the scrub is best-effort hygiene
-          // and must stay invisible to the caller. Counts only — never the
-          // value.
-          try {
-            const scrubbed =
-              await scrubStoredCredentialFromTranscripts(effectiveValue);
-            log.info(
-              { service, field, ...scrubbed },
-              "Credential stored; scrubbed value from recent transcripts",
-            );
-          } catch (err) {
-            log.warn(
-              { err, service, field },
-              "Credential stored, but transcript scrub failed",
-            );
-          }
-        }
-        upsertCredentialMetadata(service, field, {});
-        await syncManualTokenConnection(service);
-        if (service === "vellum" && field === "platform_base_url") {
-          setPlatformBaseUrl(effectiveValue);
-        }
-        if (service === "vellum" && field === "platform_assistant_id") {
-          setPlatformAssistantId(effectiveValue || undefined);
-        }
-        if (service === "vellum" && field === "platform_organization_id") {
-          setPlatformOrganizationId(effectiveValue || undefined);
-        }
-        if (service === "vellum" && field === "platform_user_id") {
-          setPlatformUserId(effectiveValue || undefined);
-        }
-      }
-      if (isPlatformManagedCredential(service, field)) {
-        await refreshProvidersAfterSecretChange();
-        // Close the first-boot race where the startup capability seed ran before
-        // the managed embedding credential was provisioned, leaving skill/CLI
-        // pages unseeded until restart. Detached — must not block the response.
-        void maybeReseedCapabilitiesAfterManagedCredential(getConfig());
-        if (service === "vellum" && field === "assistant_api_key") {
-          await notifyCesOfAssistantApiKeyUpdate(value, getCesClient());
-        }
-      } else if (!isTrimmedIdentity) {
-        await refreshProvidersForRotatedCredential(service, field);
-      }
-      if (
-        service === "vellum" &&
-        (field === "assistant_api_key" ||
-          field === "platform_assistant_id" ||
-          field === "platform_base_url")
-      ) {
-        // Managed-speech availability needs the API key, the assistant ID,
-        // and the base URL, and the CLI connect path stores all three
-        // concurrently — fire on each so the last write to land triggers the
-        // defaulting; the hook no-ops until the connection is complete.
-        // Detached — must not block the response.
-        void maybeDefaultSpeechToManaged();
-        // Same last-write-wins shape: the startup syncs no-op before live
-        // registration, so re-enqueue them here. Both dedup and no-op until
-        // the client and assistant id exist.
-        syncWorkspaceIdentityToPlatform();
-        syncAvatarToPlatform();
-      }
+      await persistCredential(service, field, value);
+      await refreshProvidersForRotatedCredential(service, field);
       log.info({ service, field }, "Credential added via HTTP");
       return { success: true, type, name };
     }
@@ -464,8 +457,7 @@ async function handleReadSecret({ body }: RouteHandlerArgs) {
   try {
     let accountKey: string;
     let prefetchedResult:
-      | Awaited<ReturnType<typeof getSecureKeyResultAsync>>
-      | undefined;
+      Awaited<ReturnType<typeof getSecureKeyResultAsync>> | undefined;
 
     if (type === "api_key") {
       if (
@@ -609,6 +601,9 @@ async function handleDeleteSecret({ body }: RouteHandlerArgs) {
         );
       }
       const service = name.slice(0, colonIdx);
+      if (service === "vellum") {
+        throw new BadRequestError("Vellum credentials cannot be deleted");
+      }
       const field = name.slice(colonIdx + 1);
       assertMetadataWritable();
       const key = credentialKey(service, field);
@@ -624,21 +619,6 @@ async function handleDeleteSecret({ body }: RouteHandlerArgs) {
         );
       }
       deleteCredentialMetadata(service, field);
-      if (service === "vellum" && field === "platform_base_url") {
-        setPlatformBaseUrl(undefined);
-      }
-      if (service === "vellum" && field === "platform_assistant_id") {
-        setPlatformAssistantId(undefined);
-      }
-      if (service === "vellum" && field === "platform_organization_id") {
-        setPlatformOrganizationId(undefined);
-      }
-      if (service === "vellum" && field === "platform_user_id") {
-        setPlatformUserId(undefined);
-      }
-      if (isPlatformManagedCredential(service, field)) {
-        await refreshProvidersAfterSecretChange();
-      }
       invalidateConnectionsAfterCredentialDelete(affectedConnections);
       log.info({ service, field }, "Credential deleted via HTTP");
       return { success: true, type, name };

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);
   });
 });