@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/provider-catalog-visibility.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../config/schema.js";
+import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
+import { getVisibleProviderCatalog } from "../providers/provider-catalog-visibility.js";
+
+beforeEach(() => {
+  _setOverridesForTesting({});
+});
+
+afterEach(() => {
+  _setOverridesForTesting({});
+});
+
+/** Minimal AssistantConfig stub for feature-flag resolution. */
+function makeConfig(): AssistantConfig {
+  return {} as AssistantConfig;
+}
+
+describe("getVisibleProviderCatalog", () => {
+  test("hides openai-compatible endpoints by default", () => {
+    _setOverridesForTesting({});
+
+    const visible = getVisibleProviderCatalog(makeConfig());
+
+    expect(visible.find((p) => p.id === "openai-compatible")).toBeUndefined();
+  });
+
+  test("shows openai-compatible endpoints when its flag is enabled", () => {
+    _setOverridesForTesting({ "openai-compatible-endpoints": true });
+
+    const visible = getVisibleProviderCatalog(makeConfig());
+
+    expect(visible.find((p) => p.id === "openai-compatible")).toBeDefined();
+  });
+
+  test("returns the full catalog when all feature flags are enabled", () => {
+    const allFlags: Record<string, boolean> = {};
+    for (const entry of PROVIDER_CATALOG) {
+      if (entry.featureFlag) allFlags[entry.featureFlag] = true;
+      for (const model of entry.models) {
+        if (model.featureFlag) allFlags[model.featureFlag] = true;
+      }
+    }
+    _setOverridesForTesting(allFlags);
+
+    const visible = getVisibleProviderCatalog(makeConfig());
+    expect(visible.length).toBe(PROVIDER_CATALOG.length);
+    expect(visible.map((p) => p.id)).toEqual(PROVIDER_CATALOG.map((p) => p.id));
+  });
+
+  test("hides a provider whose featureFlag is disabled", () => {
+    const allFlags: Record<string, boolean> = {};
+    for (const entry of PROVIDER_CATALOG) {
+      if (entry.featureFlag) allFlags[entry.featureFlag] = true;
+      for (const model of entry.models) {
+        if (model.featureFlag) allFlags[model.featureFlag] = true;
+      }
+    }
+    _setOverridesForTesting({ ...allFlags, "test-provider-flag": false });
+
+    const original = [...PROVIDER_CATALOG];
+    PROVIDER_CATALOG.push({
+      id: "__test_flagged_provider__",
+      displayName: "Test Flagged Provider",
+      models: [
+        {
+          id: "test-model",
+          displayName: "Test Model",
+        },
+      ],
+      defaultModel: "test-model",
+      featureFlag: "test-provider-flag",
+    });
+
+    try {
+      const visible = getVisibleProviderCatalog(makeConfig());
+      expect(
+        visible.find((p) => p.id === "__test_flagged_provider__"),
+      ).toBeUndefined();
+      expect(visible.length).toBe(original.length);
+    } finally {
+      PROVIDER_CATALOG.length = 0;
+      PROVIDER_CATALOG.push(...original);
+    }
+  });
+
+  test("hides a model whose featureFlag is disabled but keeps the provider", () => {
+    _setOverridesForTesting({ "test-model-flag": false });
+
+    const original = [...PROVIDER_CATALOG];
+    PROVIDER_CATALOG.push({
+      id: "__test_provider_with_flagged_model__",
+      displayName: "Test Provider",
+      models: [
+        {
+          id: "visible-model",
+          displayName: "Visible Model",
+        },
+        {
+          id: "flagged-model",
+          displayName: "Flagged Model",
+          featureFlag: "test-model-flag",
+        },
+      ],
+      defaultModel: "visible-model",
+    });
+
+    try {
+      const visible = getVisibleProviderCatalog(makeConfig());
+      const provider = visible.find(
+        (p) => p.id === "__test_provider_with_flagged_model__",
+      );
+      expect(provider).toBeDefined();
+      expect(provider!.models.map((m) => m.id)).toEqual(["visible-model"]);
+    } finally {
+      PROVIDER_CATALOG.length = 0;
+      PROVIDER_CATALOG.push(...original);
+    }
+  });
+
+  test("hides a provider entirely when all its models are flagged off", () => {
+    _setOverridesForTesting({
+      "flag-a": false,
+      "flag-b": false,
+    });
+
+    const original = [...PROVIDER_CATALOG];
+    PROVIDER_CATALOG.push({
+      id: "__test_all_models_flagged__",
+      displayName: "All Flagged",
+      models: [
+        {
+          id: "model-a",
+          displayName: "Model A",
+          featureFlag: "flag-a",
+        },
+        {
+          id: "model-b",
+          displayName: "Model B",
+          featureFlag: "flag-b",
+        },
+      ],
+      defaultModel: "model-a",
+    });
+
+    try {
+      const visible = getVisibleProviderCatalog(makeConfig());
+      expect(
+        visible.find((p) => p.id === "__test_all_models_flagged__"),
+      ).toBeUndefined();
+    } finally {
+      PROVIDER_CATALOG.length = 0;
+      PROVIDER_CATALOG.push(...original);
+    }
+  });
+});

package/src/__tests__/provider-error-scenarios.test.ts

@@ -753,6 +753,117 @@ describe("RetryProvider — streaming response handling", () => {
     expect(callCount).toBe(2);
   });
 
+  test("retries transport-aborted stream (Anthropic 'Request was aborted' with no abortReason)", async () => {
+    let callCount = 0;
+    const inner: Provider = {
+      name: "retry-transport-abort",
+      async sendMessage() {
+        callCount++;
+        if (callCount <= 1) {
+          // Mirrors the ProviderError shape produced by the catch-site in
+          // providers/anthropic/client.ts when the SDK reports
+          // ``Anthropic.APIError(status === undefined, message: "Request
+          // was aborted.")`` and the daemon's AbortController was NOT the
+          // cause (i.e. abortReason is undefined). Empirically the #1
+          // daemon error by a factor of 5x — 1,344 events in 4d on the
+          // SSE chat path, all of which used to surface as a 45s blank
+          // screen on the web client via LUM-1431.
+          throw new ProviderError(
+            "Anthropic API error: Request was aborted.",
+            "anthropic",
+            undefined,
+          );
+        }
+        return successResponse();
+      },
+    };
+    const provider = new RetryProvider(inner);
+    await provider.sendMessage(MESSAGES);
+    expect(callCount).toBe(2);
+  });
+
+  test("does NOT retry caller-aborted stream (abortReason set short-circuits retry)", async () => {
+    let callCount = 0;
+    const abortError = new ProviderError(
+      "Anthropic API error: Request was aborted.",
+      "anthropic",
+      undefined,
+      // Tagging abortReason exactly matches what the catch-site does when
+      // signal.aborted was true at the moment of failure — i.e. the
+      // daemon (or the user) cancelled the request, not the transport.
+      // The retry layer must respect this and surface the error
+      // immediately without consuming retry budget.
+      { abortReason: "user-cancelled" },
+    );
+    const inner: Provider = {
+      name: "caller-abort",
+      async sendMessage() {
+        callCount++;
+        throw abortError;
+      },
+    };
+    const provider = new RetryProvider(inner);
+    await expect(provider.sendMessage(MESSAGES)).rejects.toBe(abortError);
+    expect(callCount).toBe(1);
+  });
+
+  test("does NOT retry inner-timeout stream (deterministic 30min deadline failure)", async () => {
+    let callCount = 0;
+    // When the inner streamTimeoutMs fires, the catch-site rewrites the
+    // message to "Anthropic stream timed out after Xs (inner
+    // streamTimeoutMs)" instead of "Request was aborted." That rewrite is
+    // what allows this branch to bypass the transport-abort retry —
+    // retrying a 30min-deadline failure would almost certainly hit the
+    // same deadline on the next attempt and waste retry budget.
+    const innerTimeoutError = new ProviderError(
+      "Anthropic API error: Anthropic stream timed out after 1800s (inner streamTimeoutMs)",
+      "anthropic",
+      undefined,
+    );
+    const inner: Provider = {
+      name: "inner-timeout",
+      async sendMessage() {
+        callCount++;
+        throw innerTimeoutError;
+      },
+    };
+    const provider = new RetryProvider(inner);
+    await expect(provider.sendMessage(MESSAGES)).rejects.toBe(
+      innerTimeoutError,
+    );
+    expect(callCount).toBe(1);
+  });
+
+  test("does NOT retry OpenAI/Gemini-shaped 'Request was aborted' (no inner-timeout rewrite at those catch-sites)", async () => {
+    // The OpenAI chat-completions, OpenAI responses, and Gemini catch-sites
+    // format their errors as `"<Provider> API error (undefined): Request
+    // was aborted."` (note the `(undefined)` parenthetical that the
+    // Anthropic catch-site intentionally omits) and — unlike the Anthropic
+    // catch-site — they do NOT rewrite their inner-streamTimeoutMs
+    // deadline failures. A provider-agnostic transport-abort predicate
+    // would burn three retries on what is by construction a deterministic
+    // 30-minute deadline failure that will fire again on every attempt.
+    // Scoping the predicate to the Anthropic message prefix avoids that
+    // wasted retry budget for non-Anthropic providers until their
+    // catch-sites grow the same `innerTimeoutFired` distinction.
+    const openaiAbortError = new ProviderError(
+      "OpenAI API error (undefined): Request was aborted.",
+      "openai",
+      undefined,
+    );
+    let callCount = 0;
+    const inner: Provider = {
+      name: "openai-aborted-stream",
+      async sendMessage() {
+        callCount++;
+        throw openaiAbortError;
+      },
+    };
+    const provider = new RetryProvider(inner);
+    await expect(provider.sendMessage(MESSAGES)).rejects.toBe(openaiAbortError);
+    expect(callCount).toBe(1);
+  });
+
   test("events accumulate across retries (each attempt delivers events independently)", async () => {
     let callCount = 0;
     const inner: Provider = {

package/src/__tests__/{provider-managed-proxy-integration.test.ts → provider-platform-proxy-integration.test.ts}

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
+import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
 import { credentialKey } from "../security/credential-key.js";
 
 // ---------------------------------------------------------------------------
@@ -113,7 +113,7 @@ const DIRECT_OR_MANAGED_PROVIDER_KEYS: string[] = [
   "fireworks",
   "openrouter",
 ];
-const MANAGED_FALLBACK_PROVIDERS: string[] = ["anthropic", "gemini", "openai"];
+const MANAGED_FALLBACK_PROVIDERS: string[] = ["anthropic", "gemini", "openai", "fireworks"];
 
 function enableManagedProxy() {
   mockPlatformBaseUrl = PLATFORM_BASE;
@@ -209,20 +209,19 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("managed bootstrap registers anthropic, openai, and gemini", async () => {
+    test("managed bootstrap registers anthropic, openai, gemini, and fireworks", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       expect(listProviders()).toEqual(
-        expect.arrayContaining(["anthropic", "openai", "gemini"]),
+        expect.arrayContaining(["anthropic", "openai", "gemini", "fireworks"]),
       );
-      expect(listProviders()).toHaveLength(3);
+      expect(listProviders()).toHaveLength(4);
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
       expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      for (const p of ["fireworks", "openrouter"]) {
-        expect(getProviderRoutingSource(p)).toBeUndefined();
-      }
+      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
     test("managed anthropic uses anthropic proxy path", async () => {
@@ -376,7 +375,7 @@ describe("managed proxy integration — credential precedence", () => {
   });
 
   describe("mixed: some user keys + managed fallback fills gaps", () => {
-    test("user key for anthropic routes direct and managed fallback fills openai and gemini", async () => {
+    test("user key for anthropic routes direct and managed fallback fills openai, gemini, and fireworks", async () => {
       enableManagedProxy();
       setUserKeysFor("anthropic");
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
@@ -387,13 +386,13 @@ describe("managed proxy integration — credential precedence", () => {
       expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
       expect(registered).toContain("gemini");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      for (const p of ["fireworks", "openrouter"]) {
-        expect(registered).not.toContain(p);
-        expect(getProviderRoutingSource(p)).toBeUndefined();
-      }
+      expect(registered).toContain("fireworks");
+      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(registered).not.toContain("openrouter");
+      expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
-    test("user key for openai routes direct while anthropic and gemini still bootstrap via managed proxy", async () => {
+    test("user key for openai routes direct while anthropic, gemini, and fireworks still bootstrap via managed proxy", async () => {
       enableManagedProxy();
       setUserKeysFor("openai");
       await initializeProviders(makeProvidersConfig("openai", "test-model"));
@@ -404,11 +403,10 @@ describe("managed proxy integration — credential precedence", () => {
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
       expect(registered).toContain("gemini");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      // OpenAI has a user key so it's user-key, not managed-proxy
-      for (const p of ["fireworks", "openrouter"]) {
-        expect(registered).not.toContain(p);
-        expect(getProviderRoutingSource(p)).toBeUndefined();
-      }
+      expect(registered).toContain("fireworks");
+      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(registered).not.toContain("openrouter");
+      expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
   });
 });
@@ -436,7 +434,7 @@ describe("managed proxy integration — ollama exclusion", () => {
   });
 
   test("ollama metadata is marked as non-managed", () => {
-    const meta = MANAGED_PROVIDER_META.ollama;
+    const meta = PLATFORM_PROVIDER_META.ollama;
     expect(meta).toBeDefined();
     expect(meta.managed).toBe(false);
     expect(meta.proxyPath).toBeUndefined();
@@ -476,9 +474,9 @@ describe("config mode flip → provider reinit", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("anthropic, openai, and gemini have metadata with managed=true and a proxyPath", () => {
-    for (const provider of ["anthropic", "openai", "gemini"]) {
-      const meta = MANAGED_PROVIDER_META[provider];
+  test("anthropic, openai, gemini, and fireworks have metadata with managed=true and a proxyPath", () => {
+    for (const provider of ["anthropic", "openai", "gemini", "fireworks"]) {
+      const meta = PLATFORM_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
       expect(meta.proxyPath).toBeTruthy();
@@ -487,27 +485,31 @@ describe("managed proxy integration — constants integrity", () => {
   });
 
   test("anthropic routes through anthropic proxy path", () => {
-    expect(MANAGED_PROVIDER_META.anthropic.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.anthropic.proxyPath).toBe(
       "/v1/runtime-proxy/anthropic",
     );
   });
 
   test("gemini routes through gemini proxy path", () => {
-    expect(MANAGED_PROVIDER_META.gemini.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.gemini.proxyPath).toBe(
       "/v1/runtime-proxy/gemini",
     );
   });
 
   test("openai routes through openai proxy path", () => {
-    expect(MANAGED_PROVIDER_META.openai.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.openai.proxyPath).toBe(
       "/v1/runtime-proxy/openai",
     );
   });
 
-  test("fireworks and openrouter are not managed proxy capable", () => {
-    for (const provider of ["fireworks", "openrouter"]) {
-      expect(MANAGED_PROVIDER_META[provider].managed).toBe(false);
-      expect(MANAGED_PROVIDER_META[provider].proxyPath).toBeUndefined();
-    }
+  test("fireworks routes through fireworks proxy path", () => {
+    expect(PLATFORM_PROVIDER_META.fireworks.proxyPath).toBe(
+      "/v1/runtime-proxy/fireworks",
+    );
+  });
+
+  test("openrouter is not managed proxy capable", () => {
+    expect(PLATFORM_PROVIDER_META.openrouter.managed).toBe(false);
+    expect(PLATFORM_PROVIDER_META.openrouter.proxyPath).toBeUndefined();
   });
 });

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const mockRefreshSkillCapabilityMemories = mock(() => {});
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -11,6 +12,11 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../daemon/skill-memory-refresh.js", () => ({
+  refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
+}));
+
+import { loadSkillCatalog } from "../config/skills.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
@@ -24,6 +30,7 @@ function makeContext(): ToolContext {
 
 beforeEach(() => {
   mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+  mockRefreshSkillCapabilityMemories.mockClear();
 });
 
 afterEach(() => {
@@ -31,7 +38,29 @@ afterEach(() => {
 });
 
 describe("scaffold_managed_skill tool", () => {
-  test("creates a valid skill and index entry", async () => {
+  test("keeps legacy index control as a deprecated no-op schema field", () => {
+    const tools = JSON.parse(
+      readFileSync(
+        join(
+          import.meta.dirname,
+          "../config/bundled-skills/skill-management/TOOLS.json",
+        ),
+        "utf-8",
+      ),
+    );
+    const scaffoldTool = tools.tools.find(
+      (tool: { name: string }) => tool.name === "scaffold_managed_skill",
+    );
+
+    expect(scaffoldTool).toBeDefined();
+    expect(scaffoldTool.input_schema.properties.add_to_index).toEqual({
+      type: "boolean",
+      description:
+        "Deprecated no-op compatibility field. Skills are discovered from top-level SKILL.md files.",
+    });
+  });
+
+  test("creates a valid skill discovered from its SKILL.md directory", async () => {
     const result = await executeScaffoldManagedSkill(
       {
         skill_id: "test-skill",
@@ -46,18 +75,40 @@ describe("scaffold_managed_skill tool", () => {
     const parsed = JSON.parse(result.content);
     expect(parsed.created).toBe(true);
     expect(parsed.skill_id).toBe("test-skill");
-    expect(parsed.index_updated).toBe(true);
+    expect(parsed).not.toHaveProperty("index_updated");
 
     const skillFile = join(TEST_DIR, "skills", "test-skill", "SKILL.md");
     expect(existsSync(skillFile)).toBe(true);
     const content = readFileSync(skillFile, "utf-8");
     expect(content).toContain('name: "Test Skill"');
 
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+
+    const catalog = loadSkillCatalog();
+    const skill = catalog.find((s) => s.id === "test-skill");
+    expect(skill).toBeDefined();
+    expect(skill!.name).toBe("Test Skill");
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+  });
+
+  test("accepts legacy add_to_index input without returning index metadata", async () => {
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "legacy-input",
+        name: "Legacy Input",
+        description: "A test skill",
+        body_markdown: "Do the thing.",
+        add_to_index: true,
+      },
+      makeContext(),
     );
-    expect(indexContent).toContain("- test-skill");
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.created).toBe(true);
+    expect(parsed).not.toHaveProperty("index_updated");
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
   });
 
   test("rejects duplicate unless overwrite=true", async () => {
@@ -258,7 +309,7 @@ describe("scaffold_managed_skill tool", () => {
     expect(result.content).toContain("traversal");
   });
 
-  test("e2e: scaffold child then parent with includes, verify files and index", async () => {
+  test("e2e: scaffold child then parent with includes, verify file discovery", async () => {
     const childResult = await executeScaffoldManagedSkill(
       {
         skill_id: "e2e-child",
@@ -288,11 +339,12 @@ describe("scaffold_managed_skill tool", () => {
     expect(parentContent).toContain("    includes:");
     expect(parentContent).toContain("      - e2e-child");
 
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(indexContent).toContain("- e2e-child");
-    expect(indexContent).toContain("- e2e-parent");
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+
+    const catalog = loadSkillCatalog();
+    expect(catalog.find((s) => s.id === "e2e-child")).toBeDefined();
+    const parent = catalog.find((s) => s.id === "e2e-parent");
+    expect(parent).toBeDefined();
+    expect(parent!.includes).toEqual(["e2e-child"]);
   });
 });

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

@@ -39,8 +39,11 @@ mock.module("../daemon/conversation-store.js", () => ({
   },
 }));
 
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/schedule-routes.js";
 import type { RouteDefinition } from "../runtime/routes/types.js";
 import {
@@ -71,6 +74,15 @@ function findRoute(endpoint: string, method: string): RouteDefinition {
   return route;
 }
 
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for schedule route event");
+}
+
 describe("schedule run-now trust propagation", () => {
   beforeEach(() => {
     clearTables();
@@ -218,6 +230,41 @@ describe("GET /schedules — default defer exclusion", () => {
     expect(result.schedules).toHaveLength(1);
     expect(result.schedules[0].id).toBe(agent.id);
   });
+
+  test("mutation routes emit schedule sync invalidation", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const agent = createSchedule({
+        name: "Agent schedule",
+        cronExpression: "* * * * *",
+        message: "hello",
+        syntax: "cron",
+      });
+      await waitFor(() => received.length >= 1);
+      received.length = 0;
+
+      const route = findRoute("schedules/:id/toggle", "POST");
+      route.handler({
+        pathParams: { id: agent.id },
+        body: { enabled: false },
+      });
+
+      await waitFor(() => received.length >= 1);
+      expect(received[0].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantSchedules],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
 });
 
 // ── schedules/:id/runs limit handling ─────────────────────────────────────
@@ -388,9 +435,9 @@ describe("POST /schedules — create", () => {
   });
 
   test("rejects missing required fields", () => {
-    expect(() => postCreate({ expression: "* * * * *", message: "hi" })).toThrow(
-      "name is required",
-    );
+    expect(() =>
+      postCreate({ expression: "* * * * *", message: "hi" }),
+    ).toThrow("name is required");
     expect(() => postCreate({ name: "x", message: "hi" })).toThrow(
       "expression is required",
     );