@mycadet/assistant 0.12.10 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/assistant",
-  "version": "0.12.10",
+  "version": "0.13.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -20,7 +20,7 @@
     "probe:skill-retrieval": "bun run scripts/probe-skill-retrieval.ts",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "lint": "bun run lint:skills && bun run lint:openapi && eslint --max-warnings 2863",
+    "lint": "bun run lint:skills && bun run lint:openapi && eslint --max-warnings 2829",
     "lint:unused": "knip --include files,dependencies,unlisted",
     "lint:circular": "bun run scripts/check-circular-deps.ts",
     "lint:unused:production": "knip --production --include exports",
@@ -79,7 +79,6 @@
     "semver": "7.8.0",
     "sharp": "0.35.4",
     "stemmer": "2.0.1",
-    "tar-stream": "3.1.7",
     "tldts": "7.0.25",
     "unified": "11.0.5",
     "uuid": "11.1.0",

package/scripts/sync-web-search-catalog.ts

@@ -39,7 +39,7 @@ const OUTPUT_PATHS = [
  * downstream consumers must opt into. Adding optional fields that older
  * consumers can ignore does NOT require a bump.
  */
-const CLIENT_CATALOG_VERSION = 1;
+const CLIENT_CATALOG_VERSION = 2;
 
 function projectProvider(
   entry: SearchProviderCatalogEntry,
@@ -51,7 +51,6 @@ function projectProvider(
   if (entry.displayNameLong !== undefined) {
     projected.displayNameLong = entry.displayNameLong;
   }
-  projected.kind = entry.kind;
   if (entry.apiKeyPrefix !== undefined) {
     projected.apiKeyPrefix = entry.apiKeyPrefix;
   }

package/src/__tests__/cloud-profile-guard.test.ts

@@ -138,6 +138,42 @@ function savedProfile(name: string): Record<string, unknown> {
   >;
 }
 
+describe("partial default-provider config", () => {
+  for (const provider of ["cadet", "chatgpt"]) {
+    test(`timezone PATCH accepts a model-less ${provider} default`, async () => {
+      seedRawConfig({ llm: { default: { provider } } });
+      await patchRoute.handler({
+        body: { ui: { userTimezone: "America/New_York" } },
+      });
+      const saved = committedRaw() as {
+        ui: { userTimezone: string };
+        llm: { default: { provider: string; model?: string } };
+      };
+      expect(saved.ui.userTimezone).toBe("America/New_York");
+      expect(saved.llm.default).toEqual({ provider });
+      expectOneCommitCycle();
+    });
+    test(`PATCH can select ${provider} as default without a model`, async () => {
+      seedRawConfig({});
+      await patchRoute.handler({ body: { llm: { default: { provider } } } });
+      expect(
+        (committedRaw() as { llm: { default: { provider: string } } }).llm
+          .default,
+      ).toEqual({ provider });
+    });
+  }
+  test("Zod rejects a default model with the wrong type", async () => {
+    await expect(
+      patchRoute.handler({
+        body: {
+          llm: { default: { provider: "cadet", model: 42 } },
+        },
+      }),
+    ).rejects.toThrow(/model|expected string/i);
+    expectNothingCommitted();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // PUT /v1/config/llm/profiles/:name — replace inference profile
 // ---------------------------------------------------------------------------
@@ -210,13 +246,13 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
     ).toBeUndefined();
   });
 
-  test("rejects a routing identity with an unroutable model at the write choke point", async () => {
+  test("Zod rejects invalid fields in a replacement profile", async () => {
     await expect(
       replaceRoute.handler({
         pathParams: { name: "my-custom" },
-        body: { provider: "cadet", model: "not-a-real-model" },
+        body: { provider: "cadet", model: "claude-opus-4-8", maxTokens: 0 },
       }),
-    ).rejects.toThrow(/not served by the Cadet Cloud route/);
+    ).rejects.toThrow(/expected number to be >0/);
     expect(committedRaw()).toBeNull();
   });
 
@@ -1061,7 +1097,7 @@ describe("PATCH /v1/config — provider-only services scrub legacy mode", () =>
       body: {
         services: {
           "image-generation": { provider: "cadet", mode: "managed" },
-          "web-search": { provider: "cadet", mode: "managed" },
+          "web-search": { provider: "brave", mode: "managed" },
         },
       },
     } as never);
@@ -1075,6 +1111,6 @@ describe("PATCH /v1/config — provider-only services scrub legacy mode", () =>
     expect("mode" in raw.services["image-generation"]!).toBe(false);
     expect(raw.services["image-generation"]!.provider).toBe("cadet");
     expect("mode" in raw.services["web-search"]!).toBe(false);
-    expect(raw.services["web-search"]!.provider).toBe("cadet");
+    expect(raw.services["web-search"]!.provider).toBe("brave");
   });
 });

package/src/__tests__/config-schema.test.ts

@@ -1532,9 +1532,6 @@ describe("AssistantConfigSchema", () => {
     expect(result.services.tts.providers.deepgram.languageVoices).toEqual({
       hi: "aura-2-hi-voice",
     });
-    expect(result.services.tts.providers.cadet.languageVoices).toEqual({
-      hi: "aura-2-hi-voice",
-    });
   });
 
   test("normalizes user-entered languageVoices keys to lowercase base subtags", () => {
@@ -1586,7 +1583,7 @@ describe("AssistantConfigSchema", () => {
       services: {
         tts: {
           providers: {
-            cadet: {
+            deepgram: {
               languageVoices: {
                 "": "voice-empty",
                 "  ": "voice-blank",
@@ -1598,7 +1595,7 @@ describe("AssistantConfigSchema", () => {
         },
       },
     });
-    expect(result.services.tts.providers.cadet.languageVoices).toEqual({
+    expect(result.services.tts.providers.deepgram.languageVoices).toEqual({
       hi: "voice-hindi",
     });
   });
@@ -1611,11 +1608,10 @@ describe("AssistantConfigSchema", () => {
     expect(
       result.services.tts.providers.deepgram.languageVoices,
     ).toBeUndefined();
-    expect(result.services.tts.providers.cadet.languageVoices).toBeUndefined();
   });
 
   test("rejects non-string services.tts.providers languageVoices values", () => {
-    for (const provider of ["elevenlabs", "deepgram", "cadet"]) {
+    for (const provider of ["elevenlabs", "deepgram"]) {
       const result = AssistantConfigSchema.safeParse({
         services: {
           tts: {
@@ -1647,13 +1643,6 @@ describe("AssistantConfigSchema", () => {
     expect(result.services.tts.provider).toBe("elevenlabs");
   });
 
-  test("accepts tts provider cadet as an ordinary choice", () => {
-    const result = AssistantConfigSchema.safeParse({
-      services: { tts: { provider: "cadet" } },
-    });
-    expect(result.success).toBe(true);
-  });
-
   // ── hostBrowser.cdpInspect.desktopAuto config ───────────────────────
 
   test("applies hostBrowser.cdpInspect.desktopAuto defaults", () => {
@@ -1719,9 +1708,6 @@ describe("AssistantConfigSchema", () => {
       expect(defaulted.data.provider).toBe("elevenlabs");
     }
 
-    expect(TtsServiceSchema.safeParse({ provider: "cadet" }).success).toBe(
-      true,
-    );
     expect(
       TtsServiceSchema.safeParse({ provider: "self-hosted" }).success,
     ).toBe(false);
@@ -1809,13 +1795,6 @@ describe("AssistantConfigSchema", () => {
     expect(result.services.stt.provider).toBe("deepgram");
   });
 
-  test("accepts stt provider cadet as an ordinary choice", () => {
-    const result = AssistantConfigSchema.safeParse({
-      services: { stt: { provider: "cadet" } },
-    });
-    expect(result.success).toBe(true);
-  });
-
   test("rejects invalid services.stt.provider", () => {
     const result = AssistantConfigSchema.safeParse({
       services: { stt: { provider: "azure-speech" } },
@@ -1892,9 +1871,6 @@ describe("AssistantConfigSchema", () => {
     expect(
       SttServiceSchema.safeParse({ provider: "openai-whisper" }).success,
     ).toBe(true);
-    expect(SttServiceSchema.safeParse({ provider: "cadet" }).success).toBe(
-      true,
-    );
     expect(
       SttServiceSchema.safeParse({ provider: "self-hosted" }).success,
     ).toBe(false);
@@ -2090,21 +2066,13 @@ describe("TTS provider catalog integration", () => {
 
   test("resolveTtsConfig returns correct defaults for each catalog provider", () => {
     for (const providerId of listCatalogProviderIds()) {
-      // cadet is connection-based and only valid under managed mode.
-      const mode = providerId === "cadet" ? "managed" : "your-own";
       const config = AssistantConfigSchema.parse({
-        services: { tts: { mode, provider: providerId } },
+        services: { tts: { provider: providerId } },
       });
       const resolved = resolveTtsConfig(config);
       expect(resolved.provider).toBe(providerId);
-      if (providerId === "cadet") {
-        // The cadet config block is intentionally empty — the cloud
-        // pins the voice and model.
-        expect(resolved.providerConfig).toEqual({});
-      } else {
-        // Every BYOK provider resolves to a non-empty config object.
-        expect(Object.keys(resolved.providerConfig).length).toBeGreaterThan(0);
-      }
+      // Every provider resolves to a non-empty config object.
+      expect(Object.keys(resolved.providerConfig).length).toBeGreaterThan(0);
     }
   });
 

package/src/__tests__/conversation-queue.test.ts

@@ -372,6 +372,11 @@ type ConversationWithWorkspaceDeps = Conversation & {
     provider?: unknown,
     deadlineMs?: number,
   ) => Promise<void>;
+  turnCommitLog?: Array<{
+    workspaceDir: string;
+    conversationId: string;
+    turnNumber: number;
+  }>;
 };
 
 function makeConversation(
@@ -401,12 +406,24 @@ function makeConversation(
   conversationWithWorkspaceDeps.getWorkspaceGitService = () => ({
     ensureInitialized: async () => {},
   });
+  // Per-instance commit log: the shared turnCommitCalls counter also catches
+  // commits from stale turns of EARLIER tests (an abort watchdog that fired
+  // late under CI worker starvation drives the dead conversation's turn into
+  // commitTurnChanges). Assertions scoped to this log stay race-free.
+  const turnCommitLog: Array<{
+    workspaceDir: string;
+    conversationId: string;
+    turnNumber: number;
+  }> = [];
+  conversationWithWorkspaceDeps.turnCommitLog = turnCommitLog;
   conversationWithWorkspaceDeps.commitTurnChanges = async (
     workspaceDir: string,
     conversationId: string,
     turnNumber: number,
   ) => {
-    turnCommitCalls.push({ workspaceDir, conversationId, turnNumber });
+    const entry = { workspaceDir, conversationId, turnNumber };
+    turnCommitCalls.push(entry);
+    turnCommitLog.push(entry);
     if (turnCommitHangForever) {
       // Simulate a commit that never resolves within the timeout budget
       await new Promise<void>(() => {});
@@ -2717,6 +2734,15 @@ describe("Batched drain correctness fixes", () => {
     expect(events4.filter((e) => e.type === "message_dequeued")).toHaveLength(
       0,
     );
+    // Settle any run the aborted drain started (run 0 was resolved mid-test)
+    // so its abort watchdog clears the real-time timer it armed. A leaked
+    // ~5s timer otherwise fires during a later test and drives this stale
+    // turn into commitTurnChanges, inflating the shared turnCommitCalls
+    // counter that other tests assert against.
+    for (let i = 1; i < pendingRuns.length; i++) {
+      await resolveRun(i);
+    }
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("failed tail persist uses last-successful requestId", async () => {
@@ -3926,9 +3952,16 @@ describe("Regression: cancel semantics and error channel split", () => {
     await run.onEvent({ type: "message_complete", message: assistantMsg });
     run.resolve([...run.messages, assistantMsg]);
     await p1;
-
-    expect(turnCommitCalls).toHaveLength(1);
-    expect(turnCommitCalls[0]).toEqual({
+    // The turn commit should have been called — scoped to this test's
+    // conversation instance (see the turnCommitLog note in makeConversation:
+    // the shared counter also catches stale turns whose abort watchdog fired
+    // late under CI worker starvation).
+    expect(
+      (conversation as ConversationWithWorkspaceDeps).turnCommitLog,
+    ).toHaveLength(1);
+    expect(
+      (conversation as ConversationWithWorkspaceDeps).turnCommitLog?.[0],
+    ).toEqual({
       workspaceDir: "/tmp",
       conversationId: "conv-1",
       turnNumber: 1,
@@ -4062,8 +4095,14 @@ describe("Regression: cancel semantics and error channel split", () => {
       const dequeued = events2.find((e) => e.type === "message_dequeued");
       expect(dequeued).toBeDefined();
 
-      // The turn commit should have been called
-      expect(turnCommitCalls).toHaveLength(1);
+      // The turn commit should have been called — scoped to this test's
+      // conversation instance (see the turnCommitLog note in
+      // makeConversation: the shared counter also catches stale turns from
+      // earlier tests whose abort watchdog fired late under CI worker
+      // starvation).
+      expect(
+        (conversation as ConversationWithWorkspaceDeps).turnCommitLog,
+      ).toHaveLength(1);
 
       // Complete the second run so the test can clean up
       turnCommitHangForever = false;

package/src/__tests__/db-readiness-http-gate.test.ts

@@ -100,12 +100,6 @@ describe("DB migration readiness HTTP gate", () => {
     body = (await response.json().catch(() => ({}))) as Record<string, unknown>;
     expect(body.reason).not.toBe("db_migrations_failed");
 
-    // The parameterized job-status route (GCS import polling) passes the
-    // gate by prefix in the failed state.
-    response = await fetch(url("/migrations/jobs/some-job-id"));
-    body = (await response.json().catch(() => ({}))) as Record<string, unknown>;
-    expect(body.reason).not.toBe("db_migrations_failed");
-
     // Non-repair routes stay gated in the failed state.
     response = await fetch(url("/conversations"));
     expect(response.status).toBe(503);

package/src/__tests__/persist-onboarding-artifacts.test.ts

@@ -41,7 +41,6 @@ mock.module("../prompts/persona-resolver.js", () => ({
   }),
   resolveUserSlug: () => null,
   ensureGuardianPersonaFile: () => {},
-  isGuardianPersonaCustomized: () => false,
   GUARDIAN_PERSONA_TEMPLATE: "",
 }));
 

package/src/__tests__/persona-resolver.test.ts

@@ -98,7 +98,6 @@ import { resolveUserName } from "../daemon/identity-helpers.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import {
   ensureGuardianPersonaFile,
-  isGuardianPersonaCustomized,
   resolveGuardianPersona,
   resolveGuardianPersonaPath,
   resolveGuardianPersonaStrict,
@@ -242,56 +241,6 @@ describe("resolveGuardianPersonaStrict", () => {
   });
 });
 
-// ── isGuardianPersonaCustomized ────────────────────────────────────
-
-describe("isGuardianPersonaCustomized", () => {
-  test("returns false when the file does not exist", () => {
-    const filePath = join(mockWorkspaceDir, "users", "nobody.md");
-    expect(isGuardianPersonaCustomized(filePath)).toBe(false);
-  });
-
-  test("returns false for the bare scaffold template (no user edits)", () => {
-    const userFile = "alice.md";
-    const filePath = join(mockWorkspaceDir, "users", userFile);
-
-    // ensureGuardianPersonaFile writes the canonical template — the
-    // exact bytes that "not customized" accepts.
-    ensureGuardianPersonaFile(userFile);
-
-    expect(isGuardianPersonaCustomized(filePath)).toBe(false);
-  });
-
-  test("returns false when the file contains only comment lines", () => {
-    const userFile = "alice.md";
-    const dir = join(mockWorkspaceDir, "users");
-    const filePath = join(dir, userFile);
-
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(
-      filePath,
-      "_ only comments here\n_ nothing meaningful\n",
-      "utf-8",
-    );
-
-    expect(isGuardianPersonaCustomized(filePath)).toBe(false);
-  });
-
-  test("returns true when the file has user-authored content", () => {
-    const userFile = "alice.md";
-    const dir = join(mockWorkspaceDir, "users");
-    const filePath = join(dir, userFile);
-
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(
-      filePath,
-      "# My profile\n\n- Preferred name/reference: Real User\n",
-      "utf-8",
-    );
-
-    expect(isGuardianPersonaCustomized(filePath)).toBe(true);
-  });
-});
-
 // ── resolveUserSlug — background/scheduled guardian turns ──────────
 //
 // Background and scheduled turns carry a guardian trust context with no

package/src/__tests__/provider-cloud-proxy-integration.test.ts

@@ -43,7 +43,6 @@ mock.module("@google/genai", () => ({
 // Mock OpenAI SDK to capture OpenAI/Fireworks tool definitions and preserve
 // constructor baseURL assertions. Must be before importing the registry.
 // ---------------------------------------------------------------------------
-let lastOpenAIChatParams: Record<string, unknown> | null = null;
 
 mock.module("openai", () => {
   class FakeAPIError extends Error {
@@ -69,8 +68,7 @@ mock.module("openai", () => {
 
     chat = {
       completions: {
-        create: (params: Record<string, unknown>) => {
-          lastOpenAIChatParams = JSON.parse(JSON.stringify(params));
+        create: (_params: Record<string, unknown>) => {
           return (async function* () {
             yield {
               choices: [
@@ -119,7 +117,7 @@ import {
   initializeProviders,
   listProviders,
 } from "../providers/registry.js";
-import type { Message, ToolDefinition } from "../providers/types.js";
+import type { Message } from "../providers/types.js";
 import { setConfig } from "./helpers/set-config.js";
 
 function makeProvidersConfig(
@@ -152,10 +150,6 @@ const PLATFORM_BASE = "https://test-cloud.mycadet.ai";
 const MANAGED_API_KEY = "ast-managed-key-123";
 const PLATFORM_ASSISTANT_ID = "assistant-abc123";
 
-const MANAGED_NATIVE_WEB_SEARCH: Services["web-search"] = {
-  provider: "inference-provider-native",
-};
-
 const DIRECT_OR_MANAGED_PROVIDER_KEYS: string[] = [
   "openai",
   "anthropic",
@@ -226,22 +220,6 @@ function userMsg(text: string): Message {
   return { role: "user", content: [{ type: "text", text }] };
 }
 
-const sampleTools: ToolDefinition[] = [
-  {
-    name: "file_read",
-    description: "Read a file",
-    input_schema: { type: "object", properties: { path: { type: "string" } } },
-  },
-  {
-    name: "web_search",
-    description: "Search the web",
-    input_schema: {
-      type: "object",
-      properties: { query: { type: "string" } },
-    },
-  },
-];
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -251,7 +229,6 @@ beforeEach(() => {
   clearUserKeys();
   lastGeminiConstructorOpts = null;
   lastGeminiGenerateContentStreamParams = null;
-  lastOpenAIChatParams = null;
   // Reset the workspace config to pure schema defaults (the default
   // web-search service — your-own / inference-provider-native — IS the
   // schema default, so only divergent tests seed `services`).
@@ -541,91 +518,6 @@ describe("cloud proxy integration — credential precedence", () => {
   });
 });
 
-describe("cloud proxy integration — managed web search routing", () => {
-  test("managed Fireworks/Kimi tool call completes through the cloud Brave proxy", async () => {
-    enableCloudProxy();
-    clearUserKeys();
-    setConfig("services", { "web-search": MANAGED_NATIVE_WEB_SEARCH });
-
-    const originalFetch = globalThis.fetch;
-    const fetchUrls: string[] = [];
-    globalThis.fetch = (async (url: URL | RequestInfo) => {
-      fetchUrls.push(String(url));
-      return new Response(
-        JSON.stringify({
-          status: 200,
-          headers: { "content-type": "application/json" },
-          body: {
-            web: {
-              results: [
-                {
-                  title: "Cloud Result",
-                  url: "https://example.com/platform-result",
-                  description: "Returned by the cloud Brave proxy.",
-                  age: "1 day ago",
-                },
-              ],
-            },
-          },
-        }),
-        {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        },
-      );
-    }) as unknown as typeof fetch;
-
-    try {
-      await initializeProviders(
-        makeProvidersConfig(
-          "fireworks",
-          "accounts/fireworks/models/kimi-k2p6",
-          MANAGED_NATIVE_WEB_SEARCH,
-        ),
-      );
-
-      const provider = getProvider("fireworks");
-      await provider.sendMessage([userMsg("Search using managed Brave")], {
-        tools: sampleTools,
-      });
-
-      const tools = lastOpenAIChatParams!.tools as Array<{
-        type: string;
-        function?: { name: string; description?: string };
-      }>;
-      expect(tools).toHaveLength(2);
-      expect(tools[1]).toMatchObject({
-        type: "function",
-        function: {
-          name: "web_search",
-          description: "Search the web",
-        },
-      });
-
-      const { webSearchTool } = await import("../tools/network/web-search.js");
-      const result = await webSearchTool.execute(
-        { query: "managed kimi query", count: 1, offset: 2, freshness: "pw" },
-        {
-          conversationId: "conv-123",
-          workingDir: "/tmp",
-          trustClass: "guardian",
-        },
-      );
-
-      expect(result.isError).toBe(false);
-      expect(result.content).toContain("Cloud Result");
-      expect(result.activityMetadata?.webSearch?.provider).toBe("brave");
-      expect(result.activityMetadata?.webSearch?.resultCount).toBe(1);
-
-      expect(fetchUrls).toEqual([
-        `${PLATFORM_BASE}/v1/assistants/${PLATFORM_ASSISTANT_ID}/cloud-search-proxy/brave/`,
-      ]);
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-});
-
 describe("cloud proxy integration — ollama exclusion", () => {
   test("ollama is never registered via cloud proxy fallback", async () => {
     enableCloudProxy();

package/src/__tests__/run-due-schedules.test.ts

@@ -9,10 +9,6 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../background-wake/publisher.js", () => ({
-  refreshBackgroundWakeIntent: () => {},
-}));
-
 mock.module("../daemon/disk-pressure-background-gate.js", () => ({
   checkDiskPressureBackgroundGate: () => ({
     action: "allow",

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

@@ -1,18 +1,6 @@
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
-import { mock } from "bun:test";
-
-// Stub the background-wake publisher so these store-level unit tests stay
-// hermetic. `notifySchedulesChanged()` fires a debounced background-wake
-// refresh on every mutation; left real, that 250ms timer performs a
-// synchronous DB read plus a cloud-client lookup which compete with the
-// serialized async event delivery and can push a `sync_changed` past the
-// wait deadline on loaded runners. Background-wake behavior is covered by the
-// background-wake tests.
-mock.module("../background-wake/publisher.js", () => ({
-  refreshBackgroundWakeIntent: () => {},
-}));
 
 import type { AssistantEventEnvelope } from "../api/index.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";

package/src/__tests__/stt-stream-session.test.ts

@@ -140,11 +140,11 @@ class FailingTranscriber implements StreamingTranscriber {
 }
 
 /**
- * Mock managed transcriber whose start() throws a userFacing SttError,
- * mirroring the cloud relay's mapped dial rejection.
+ * Mock transcriber whose start() throws a userFacing SttError, mirroring
+ * an adapter's mapped upstream rejection.
  */
 class ManagedFailingTranscriber implements StreamingTranscriber {
-  readonly providerId = "cadet" as const;
+  readonly providerId = "deepgram" as const;
   readonly boundaryId = "daemon-streaming" as const;
 
   constructor(private readonly message: string) {}
@@ -357,7 +357,7 @@ describe("SttStreamSession", () => {
     });
 
     test("managed start failure surfaces its remediation verbatim", async () => {
-      const { ws, session } = createSession("cadet");
+      const { ws, session } = createSession("deepgram");
       const managedMessage =
         "Cloud speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.";