@vellumai/assistant 0.11.10 → 0.11.11-staging.1

package/src/runtime/routes/integrations/vercel.ts

@@ -16,6 +16,7 @@ import {
   getVercelConfig,
   setVercelConfig,
 } from "../../../daemon/handlers/config-vercel.js";
+import { ACTOR_PRINCIPALS } from "../../auth/route-policy.js";
 import { BadRequestError } from "../errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
 
@@ -70,7 +71,10 @@ export const ROUTES: RouteDefinition[] = [
     operationId: "integrations_vercel_config_get",
     endpoint: "integrations/vercel/config",
     method: "GET",
-    policy: null,
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
     summary: "Get Vercel config",
     description: "Check if a Vercel API token is stored.",
     tags: ["integrations"],
@@ -81,7 +85,10 @@ export const ROUTES: RouteDefinition[] = [
     operationId: "integrations_vercel_config_post",
     endpoint: "integrations/vercel/config",
     method: "POST",
-    policy: null,
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
     summary: "Set or delete Vercel config",
     description:
       "Set or delete the Vercel API token. Action is determined by the body action field.",
@@ -97,7 +104,10 @@ export const ROUTES: RouteDefinition[] = [
     operationId: "integrations_vercel_config_delete",
     endpoint: "integrations/vercel/config",
     method: "DELETE",
-    policy: null,
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
     summary: "Delete Vercel config",
     description: "Delete the stored Vercel API token.",
     tags: ["integrations"],

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

@@ -15,8 +15,9 @@
  *   - platform_callback_routes_list (GET platform/callback-routes): lists
  *     registered callback routes for this assistant.
  *   - platform_credits (GET platform/credits): fetches the org's remaining
- *     credit balance, today's spend, and daily-limit / low-balance state from
- *     the platform billing summary.
+ *     credit balance, plan-included credit usage, extra credit, upcoming
+ *     expiry, today's spend, and daily-limit / low-balance state from the
+ *     platform billing summary.
  *   - platform_subscription (GET platform/subscription): fetches the org's
  *     current plan, subscription status, and entitlements.
  *   - platform_plans (GET platform/plans): fetches the plan catalog with pricing.
@@ -26,6 +27,11 @@
  *     invoice list and returns a single invoice by Stripe invoice ID.
  */
 
+import {
+  type BillingPlanId,
+  extraCreditUsd,
+  planCreditUsedFraction,
+} from "@vellumai/service-contracts/plan-credit";
 import {
   type PlatformCredentialVerificationStatus,
   type PlatformVerifyCredentialResponse,
@@ -172,6 +178,48 @@ const PlatformCreditsResponseSchema = z.object({
     .describe(
       "True when the balance is above zero but below the low-balance threshold and auto top-up is not enabled.",
     ),
+  plan_credit_remaining: z
+    .number()
+    .nullable()
+    .describe(
+      "Unused credit (USD) remaining on the unexpired plan-included grants (initial credit, Pro credit bundle). Null when the platform did not report grant figures.",
+    ),
+  plan_credit_total: z
+    .number()
+    .nullable()
+    .describe(
+      "Total credit (USD) those plan-included grants were worth, net of refunds. Null when the platform did not report grant figures.",
+    ),
+  plan_credit_used_fraction: z
+    .number()
+    .nullable()
+    .describe(
+      "Share of the plan-included credit already used, from 0 to 1: the same reading as the in-app usage meter. A Pro subscription whose unexpired grants total nothing reads as 1 (everything granted is used or expired). Null when there is no usable reading: grant figures missing, or a zero total on a base or unknown plan.",
+    ),
+  plan_credits_spent: z
+    .boolean()
+    .nullable()
+    .describe(
+      "True when the plan-included credit is used up or expired. Whether further managed usage is funded is extra_credit_remaining (zero means the organization is out of credit). Null when there is no plan-credit reading.",
+    ),
+  extra_credit_remaining: z
+    .number()
+    .nullable()
+    .describe(
+      "Credit (USD) bought or earned on top of the plan-included grants: remaining minus plan_credit_remaining, floored at zero. Null when grant figures are missing.",
+    ),
+  credits_expiring_soon: z
+    .number()
+    .nullable()
+    .describe(
+      "Unexpired credit (USD) on grants that expire within the next 30 days. Null when the platform did not report it.",
+    ),
+  next_credit_expiry_at: z
+    .string()
+    .nullable()
+    .describe(
+      "Earliest upcoming expiry (ISO 8601) across grants that still hold credit, or null when none is scheduled.",
+    ),
 });
 type PlatformCreditsResponse = z.infer<typeof PlatformCreditsResponseSchema>;
 
@@ -513,10 +561,40 @@ async function handlePlatformCredits(
     daily_limit_snoozed?: boolean;
     low_balance_threshold_usd?: string;
     low_balance_warning?: boolean;
+    available_usage_balance?: string;
+    total_usage_balance?: string;
+    credits_expiring_soon_usd?: string;
+    next_credit_expiry_at?: string | null;
   };
 
+  const remaining = Number(summary.effective_balance_usd);
+  const planCreditRemaining = parseUsd(summary.available_usage_balance);
+  const planCreditTotal = parseUsd(summary.total_usage_balance);
+  let usedFraction = planCreditUsedFraction(
+    planCreditTotal,
+    planCreditRemaining,
+    null,
+  );
+  if (
+    usedFraction === null &&
+    planCreditTotal !== null &&
+    planCreditTotal <= 0
+  ) {
+    // Only the zero-grant reading depends on the plan, so the subscription is
+    // read lazily and best-effort: a slow or failed read degrades that one
+    // reading to null instead of delaying or failing the balance.
+    const planId = await fetchBillingSubscription()
+      .then((subscription) => subscription.plan_id)
+      .catch((): BillingPlanId | null => null);
+    usedFraction = planCreditUsedFraction(
+      planCreditTotal,
+      planCreditRemaining,
+      planId,
+    );
+  }
+
   return {
-    remaining: Number(summary.effective_balance_usd),
+    remaining,
     settled: Number(summary.settled_balance_usd),
     pending: Number(summary.pending_compute_usd),
     unit: "USD",
@@ -530,6 +608,19 @@ async function handlePlatformCredits(
     daily_limit_snoozed: summary.daily_limit_snoozed === true,
     low_balance_threshold: parseUsd(summary.low_balance_threshold_usd),
     low_balance_warning: summary.low_balance_warning === true,
+    plan_credit_remaining: planCreditRemaining,
+    plan_credit_total: planCreditTotal,
+    plan_credit_used_fraction: usedFraction,
+    plan_credits_spent: usedFraction === null ? null : usedFraction >= 1,
+    extra_credit_remaining:
+      planCreditRemaining === null
+        ? null
+        : extraCreditUsd(remaining, planCreditRemaining),
+    credits_expiring_soon: parseUsd(summary.credits_expiring_soon_usd),
+    next_credit_expiry_at:
+      typeof summary.next_credit_expiry_at === "string"
+        ? summary.next_credit_expiry_at
+        : null,
   };
 }
 
@@ -624,28 +715,34 @@ async function fetchPlatformJson(
   return response.json();
 }
 
+interface BillingSubscriptionData {
+  plan_id: BillingPlanId;
+  status: string | null;
+  renewal_date: string | null;
+  current_period_end: string | null;
+  cancel_at_period_end: boolean;
+  cancel_at: string | null;
+  selected_credit_tier: string | null;
+  package: {
+    key: string;
+    name: string;
+    version: number;
+    customized: boolean;
+  } | null;
+  entitlements: { managed_email: boolean; phone_number: boolean };
+}
+
+function fetchBillingSubscription(): Promise<BillingSubscriptionData> {
+  return fetchPlatformJson(
+    "/v1/organizations/billing/subscription/",
+    "subscription",
+  ) as Promise<BillingSubscriptionData>;
+}
+
 async function handlePlatformSubscription(
   _args: RouteHandlerArgs,
 ): Promise<PlatformSubscriptionResponse> {
-  const data = (await fetchPlatformJson(
-    "/v1/organizations/billing/subscription/",
-    "subscription",
-  )) as {
-    plan_id: "base" | "pro";
-    status: string | null;
-    renewal_date: string | null;
-    current_period_end: string | null;
-    cancel_at_period_end: boolean;
-    cancel_at: string | null;
-    selected_credit_tier: string | null;
-    package: {
-      key: string;
-      name: string;
-      version: number;
-      customized: boolean;
-    } | null;
-    entitlements: { managed_email: boolean; phone_number: boolean };
-  };
+  const data = await fetchBillingSubscription();
 
   return {
     planId: data.plan_id,
@@ -914,9 +1011,9 @@ export const ROUTES: RouteDefinition[] = [
       allowedPrincipalTypes: ACTOR_PRINCIPALS,
     },
     summary:
-      "Get the organization's remaining credit balance and daily-limit state",
+      "Get the organization's credit balance, plan-credit usage, and daily-limit state",
     description:
-      "Fetches the org's settled, pending, and effective (remaining) credit balance in USD from the platform billing summary, plus the daily-limit state: today's spend counted against the daily credit limit (which excludes spend covered by plan-included credits, so it is not total spend), the limit itself, and the low-balance warning state.",
+      "Fetches the org's settled, pending, and effective (remaining) credit balance in USD from the platform billing summary, plus plan-included credit usage (remaining, total, and the used fraction shown by the in-app usage meter), extra credit bought or earned on top, credit expiring within 30 days, and the daily-limit state: today's spend counted against the daily credit limit (which excludes spend covered by plan-included credits, so it is not total spend), the limit itself, and the low-balance warning state.",
     tags: ["platform"],
     handler: handlePlatformCredits,
     responseBody: PlatformCreditsResponseSchema,

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

@@ -14,6 +14,7 @@ import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { INTERNAL_GUARDIAN_TRUST_CONTEXT } from "../../daemon/trust-context.js";
 import { bootstrapConversation } from "../../persistence/conversation-bootstrap.js";
 import { getConversation } from "../../persistence/conversation-crud.js";
+import { isLifecycleQuiesced } from "../../persistence/lifecycle-quiesce.js";
 import {
   getUsageCostForRun,
   listRunConversationIds,
@@ -62,6 +63,7 @@ import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { parseEpochMillisRange } from "./epoch-millis-range.js";
 import {
   BadRequestError,
+  ConflictError,
   ForbiddenError,
   InternalError,
   NotFoundError,
@@ -1302,11 +1304,17 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Run schedule now",
     description:
-      "Trigger an immediate execution of a schedule. A plugin-sourced schedule is rejected with a 400 when its plugin is disabled or no longer declares it.",
+      "Trigger an immediate execution of a schedule. A plugin-sourced schedule is rejected with a 400 when its plugin is disabled or no longer declares it. Returns 409 while a drain quiesce lease is active so run-now cannot start work the shutdown snapshot would miss.",
     tags: ["schedules"],
     responseBody: z.object({
       schedules: z.array(scheduleSchema).describe("Updated schedule list"),
     }),
+    additionalResponses: {
+      "409": {
+        description:
+          "A drain quiesce lease is active, so run-now is not starting new work.",
+      },
+    },
     handler: ({ pathParams, headers }: RouteHandlerArgs) =>
       handleRunScheduleNow(pathParams!.id, headers),
   },
@@ -1321,6 +1329,12 @@ async function handleRunScheduleNow(
     throw new NotFoundError("Schedule not found");
   }
 
+  if (isLifecycleQuiesced()) {
+    throw new ConflictError(
+      "The assistant is shutting down and is not starting new schedule runs.",
+    );
+  }
+
   // A plugin-sourced row runs the plugin's own script or prompt, so run-now is
   // only offered while that plugin is something the runtime would activate.
   // `pluginScheduleSourceAvailable` covers a plugin the daemon never

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

@@ -9,8 +9,11 @@ mock.module("../../config/loader.js", () => ({
   getConfigReadOnly: () => ({ ui: mockUi }),
 }));
 
-const { resolveScheduleTimezone, expressionCarriesOwnTimezone } =
-  await import("../schedule-timezone.js");
+const {
+  resolveScheduleTimezone,
+  expressionCarriesOwnTimezone,
+  hourInTimeZone,
+} = await import("../schedule-timezone.js");
 
 afterEach(() => {
   mockUi = {};
@@ -42,12 +45,27 @@ describe("resolveScheduleTimezone", () => {
     expect(resolveScheduleTimezone(null)).toBeNull();
   });
 
-  test("ignores an invalid explicit value and falls back", () => {
+  test("an invalid explicit value is ignored and falls back", () => {
     mockUi = { userTimezone: "America/New_York" };
     expect(resolveScheduleTimezone("Not/AZone")).toBe("America/New_York");
   });
 });
 
+describe("hourInTimeZone", () => {
+  test("returns the wall-clock hour in the given zone", () => {
+    // 23:00 UTC on a Pacific Daylight date is 16:00 in America/Los_Angeles.
+    const now = new Date("2026-09-08T23:00:00Z");
+    expect(hourInTimeZone("UTC", now)).toBe(23);
+    expect(hourInTimeZone("America/Los_Angeles", now)).toBe(16);
+    expect(hourInTimeZone("America/New_York", now)).toBe(19);
+  });
+
+  test("normalizes a 24-hour midnight encoding to 0", () => {
+    const midnightUtc = new Date("2026-09-08T00:00:00Z");
+    expect(hourInTimeZone("UTC", midnightUtc)).toBe(0);
+  });
+});
+
 describe("expressionCarriesOwnTimezone", () => {
   test("cron never carries its own zone", () => {
     expect(expressionCarriesOwnTimezone("cron", "30 8 * * *")).toBe(false);

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

@@ -0,0 +1,88 @@
+/**
+ * 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`.
+ */
+
+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_WATCH = "watchForMcpReload(";
+
+/** The worker's first call that can execute a schedule. */
+const WORK_START = "void tick()";
+
+function readWorkerSource(): string {
+  return readFileSync(join(process.cwd(), "src/schedule/worker.ts"), "utf8");
+}
+
+describe("schedule worker MCP tools", () => {
+  test("connects its own MCP servers before the first schedule tick", () => {
+    const source = readWorkerSource();
+    const mcpAt = source.indexOf(MCP_CALL);
+    const workAt = source.indexOf(WORK_START);
+
+    expect(
+      mcpAt,
+      `The schedule worker must call \`${MCP_CALL})\` 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.",
+    ).toBe(true);
+  });
+
+  test("rebuilds its MCP set when the daemon reports a reload", () => {
+    const source = readWorkerSource();
+
+    expect(
+      source.includes(MCP_WATCH),
+      "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.",
+    ).toBe(true);
+  });
+});

package/src/schedule/schedule-timezone.ts

@@ -61,3 +61,28 @@ export function resolveScheduleTimezone(
     null
   );
 }
+
+/**
+ * Wall-clock hour (0-23) of `now` in `timeZone`.
+ *
+ * Heartbeat active hours are stored as 0-23 integers. Evaluating them against
+ * the host clock (UTC on a managed container) shifts the window by the user's
+ * offset, so 8:00-22:00 becomes 1am-3pm Pacific. This reads the hour in the
+ * same zone `resolveScheduleTimezone` selected.
+ */
+export function hourInTimeZone(
+  timeZone: string,
+  now: Date = new Date(),
+): number {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hourCycle: "h23",
+    hour: "numeric",
+  }).formatToParts(now);
+  const raw = Number(parts.find((part) => part.type === "hour")?.value);
+  if (!Number.isFinite(raw)) {
+    return now.getHours();
+  }
+  // Some runtimes emit "24" for midnight under hourCycle h23.
+  return raw === 24 ? 0 : raw;
+}

package/src/schedule/scheduler.ts

@@ -10,6 +10,7 @@ import { processMessage } from "../daemon/process-message.js";
 import { INTERNAL_GUARDIAN_TRUST_CONTEXT } from "../daemon/trust-context.js";
 import { emitBackgroundFailureSignal } from "../notifications/background-failure-signal.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
+import { emitScheduleResultNotification } from "../notifications/schedule-result-producer.js";
 import { getConversation } from "../persistence/conversation-crud.js";
 import { isLifecycleQuiesced } from "../persistence/lifecycle-quiesce.js";
 import { invalidateAssistantInferredItemsForConversation } from "../plugins/defaults/memory/task-memory-cleanup.js";
@@ -963,6 +964,11 @@ export async function runDueSchedulesOnce(
     let failedTurn: TurnFailure | undefined;
     const conversationReused = reusedConversationId != null;
     let runConversationId = reusedConversationId;
+    // Captured before the run so the post-run "did this run notify?" probe has
+    // a lower bound. A reused conversation carries every prior run's
+    // notifications, and without this bound the first run to notify would
+    // silence the fallback for every run after it.
+    const runStartedAt = Date.now();
     const runId = await createScheduleRun(job.id, reusedConversationId);
 
     if (reusedConversationId) {
@@ -1067,6 +1073,19 @@ export async function runDueSchedulesOnce(
 
     if (ok) {
       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.
+      // 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 (isOneShot) {
         await completeOneShot(job.id);
       }

package/src/schedule/worker.ts

@@ -11,7 +11,7 @@
  * user-facing traffic, and keep running during a main-thread freeze in the
  * daemon.
  */
-import { writeFileSync } from "node:fs";
+import { watch, writeFileSync } from "node:fs";
 
 import {
   initFeatureFlagOverrides,
@@ -20,12 +20,18 @@ import {
 import { getConfig } from "../config/loader.js";
 import { rehydratePlatformCredentials } from "../config/platform-rehydration.js";
 import { startConversationEvictor } from "../daemon/conversation-evictor.js";
+import { stopMcpServerManager } from "../mcp/manager.js";
+import { MCP_RELOAD_SIGNAL_FILE } from "../mcp/reload-signal.js";
+import {
+  restartConfiguredMcpServers,
+  startConfiguredMcpServers,
+} from "../mcp/startup.js";
 import { resetDb } from "../persistence/db-connection.js";
 import { registerWorkerPluginSurface } from "../plugins/worker-plugin-surface.js";
 import { disableStreamSeqStamping } from "../runtime/assistant-stream-state.js";
 import { initializeTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
-import { getScheduleWorkerPidPath } from "../util/platform.js";
+import { getScheduleWorkerPidPath, getSignalsDir } from "../util/platform.js";
 import {
   cleanupWorkerPidFile,
   startWorkerPidFileGuard,
@@ -40,6 +46,80 @@ const TICK_INTERVAL_MS = 15_000;
 /** How often this process re-reads flag overrides from the gateway. */
 const FLAG_REFRESH_INTERVAL_MS = 60_000;
 
+/**
+ * How long startup waits for MCP servers before arming the tick.
+ *
+ * Connecting is worth waiting for: a schedule that fires first would fail its
+ * `mcp__*` calls as unknown tools. It is not worth waiting for without limit.
+ * `McpServerManager.start()` walks servers one at a time and allows each 30s to
+ * connect and 30s more to list its tools, so a handful of unreachable ones can
+ * hold the first tick for minutes, including the notify and script schedules
+ * that never touch MCP. Past this deadline the connect continues in the
+ * background and the tick starts without it.
+ */
+const MCP_STARTUP_GRACE_MS = 20_000;
+
+/**
+ * Rebuild this process's MCP connections whenever the daemon reports a reload.
+ *
+ * Watches the signals directory rather than config.json: a reload also follows
+ * an OAuth reauthentication and a plugin install, neither of which edits that
+ * file, and the daemon already funnels all of them through one reload that
+ * writes this signal. Restarts are serialized and coalesced, so a burst of
+ * writes (an editor saving config.json, several servers reauthenticating)
+ * rebuilds once rather than once per event.
+ *
+ * Never throws: a signals directory that cannot be watched leaves this process
+ * on the servers it connected at startup, which is where it already was.
+ */
+function watchForMcpReload(): void {
+  const signalsDir = getSignalsDir();
+  let restarting: Promise<unknown> | null = null;
+  let restartQueued = false;
+
+  const restart = (): void => {
+    if (restarting) {
+      // A reload landed mid-rebuild, so the rebuild in flight may have read
+      // the config as it stood before. Run once more after it, not once per
+      // event that arrived while it ran.
+      restartQueued = true;
+      return;
+    }
+    restarting = restartConfiguredMcpServers()
+      .then((toolCount) => {
+        log.info({ toolCount }, "MCP servers reloaded in schedule worker");
+      })
+      .catch((err: unknown) => {
+        log.warn({ err }, "MCP reload failed in schedule worker");
+      })
+      .finally(() => {
+        restarting = null;
+        if (restartQueued) {
+          restartQueued = false;
+          restart();
+        }
+      });
+  };
+
+  try {
+    const watcher = watch(signalsDir, (_eventType, filename) => {
+      if (String(filename ?? "") === MCP_RELOAD_SIGNAL_FILE) {
+        restart();
+      }
+    });
+    watcher.on("error", (err) => {
+      log.warn({ err, signalsDir }, "MCP reload watcher failed");
+    });
+    watcher.unref();
+    log.info({ dir: signalsDir }, "Watching for MCP reload signals");
+  } catch (err) {
+    log.warn(
+      { err, signalsDir },
+      "Failed to watch for MCP reload signals; MCP servers stay as connected at startup",
+    );
+  }
+}
+
 async function main(): Promise<void> {
   // Only the daemon stamps SSE seqs and writes the shared reservation file.
   disableStreamSeqStamping();
@@ -102,6 +182,36 @@ async function main(): Promise<void> {
     );
   }
 
+  // Connect this process's own MCP servers. The tool registry is per-process
+  // and MCP tools reach it only by connecting to each server and listing what
+  // it offers, so `initializeTools()` above leaves them out: it loads core
+  // built-ins and workspace tools from disk and nothing else. Without this an
+  // execute-mode schedule fails every `mcp__*` call as "Unknown tool" while the
+  // daemon, which does connect at boot, lists the same tool as registered.
+  //
+  // Connecting here rather than borrowing the daemon's connections is what
+  // keeps this process independent of the daemon's event loop, which is the
+  // reason it is a separate process at all.
+  //
+  // Bounded by MCP_STARTUP_GRACE_MS: unreachable servers must not hold the
+  // schedules that do not use them. The connect runs on past the deadline.
+  const mcpStartup = startConfiguredMcpServers(getConfig().mcp);
+  await Promise.race([
+    mcpStartup,
+    // Unref'd so a connect that beats the deadline leaves nothing pending.
+    new Promise((resolve) => {
+      setTimeout(resolve, MCP_STARTUP_GRACE_MS).unref();
+    }),
+  ]);
+
+  // React to an MCP reload in the daemon. The server set belongs to the config
+  // and the daemon owns the watcher that notices it change; this process holds
+  // its own connections to the same servers, so without this it keeps serving
+  // whatever was configured when it started, including servers since disabled
+  // or removed. Best-effort: a signals directory that cannot be watched leaves
+  // this process on its startup connections until it restarts.
+  watchForMcpReload();
+
   // Sweep idle conversations out of the in-memory pool. The daemon starts
   // this at startup; this process hosts conversations too, so without it
   // every scheduled run's conversation is retained for the process lifetime.
@@ -122,6 +232,13 @@ async function main(): Promise<void> {
       clearInterval(flagRefreshTimer);
     }
     disposePidGuard?.();
+    // Best-effort, deliberately not awaited: this process exits immediately on
+    // a signal by design, and the exit is what everything else here relies on.
+    // Starting the close still lets a stdio server see its stdin shut rather
+    // than only noticing when the pipe breaks.
+    void stopMcpServerManager().catch((err) => {
+      log.warn({ err }, "MCP server shutdown failed (non-fatal)");
+    });
     cleanupWorkerPidFile(pidPath);
     process.exit(0);
   };