@mycadet/assistant 0.12.10 → 0.13.0

package/src/config/schemas/__tests__/stt.test.ts

@@ -69,9 +69,9 @@ describe("SttServiceSchema", () => {
   test("language defaults to multilingual rather than staying absent", () => {
     // Every config carries a real language, so nothing downstream has to
     // infer one from an absent key. Omitting the param entirely is not a
-    // neutral state on Deepgram and the cloud relay: it decodes as
-    // English, which is what this default exists to stop.
-    const parsed = SttServiceSchema.parse({ provider: "cadet" });
+    // neutral state on Deepgram: it decodes as English, which is what this
+    // default exists to stop.
+    const parsed = SttServiceSchema.parse({ provider: "deepgram" });
     expect(parsed.language).toBe("multi");
   });
 
@@ -86,7 +86,8 @@ describe("SttServiceSchema", () => {
 
   test("language round-trips a code and the multi code-switching mode", () => {
     expect(
-      SttServiceSchema.parse({ provider: "cadet", language: "multi" }).language,
+      SttServiceSchema.parse({ provider: "deepgram", language: "multi" })
+        .language,
     ).toBe("multi");
     expect(
       SttServiceSchema.parse({ provider: "deepgram", language: "hi" }).language,
@@ -95,30 +96,25 @@ describe("SttServiceSchema", () => {
 
   test("language is trimmed and rejects blank strings", () => {
     expect(
-      SttServiceSchema.parse({ provider: "cadet", language: "  multi  " })
+      SttServiceSchema.parse({ provider: "deepgram", language: "  multi  " })
         .language,
     ).toBe("multi");
     expect(() =>
-      SttServiceSchema.parse({ provider: "cadet", language: "   " }),
+      SttServiceSchema.parse({ provider: "deepgram", language: "   " }),
     ).toThrow(/must not be empty/);
   });
 });
 
-describe("cloud provider", () => {
-  test("accepts cadet as an ordinary provider choice", () => {
-    const parsed = SttServiceSchema.parse({ provider: "cadet" });
-    expect(parsed.provider).toBe("cadet");
-  });
-
+describe("provider parsing", () => {
   // Migration 130 folds mode into provider; a stale key must not resurrect
   // the second axis or fail the parse.
   test("ignores a legacy mode key", () => {
     const parsed = SttServiceSchema.parse({
       mode: "managed",
-      provider: "cadet",
+      provider: "deepgram",
     });
     expect(parsed).toEqual({
-      provider: "cadet",
+      provider: "deepgram",
       language: "multi",
       providers: {},
       roles: {},

package/src/config/schemas/llm.ts

@@ -54,9 +54,8 @@ const ALWAYS_RESOLVING_MANAGED_ONLY_PROFILE_KEYS =
  * an open string so a stored provider outside this list parses instead of
  * stripping its profile; dispatch resolves such a label as a connection
  * entry name and fails with an explainable resolution error when no row
- * carries it. Write-time membership is enforced at the profiles route and
- * the `commitConfigWrite` choke point (`unknownLlmProviderIssue`), which
- * is where entry names unlock when the entries model enables them.
+ * carries it. The generic config routes follow this open-string schema;
+ * dedicated profile routes apply their own provider selection rules.
  */
 export const KNOWN_LLM_PROVIDERS = [
   "anthropic",
@@ -153,8 +152,7 @@ export function isByokDefaultProviderChoice(
  * on that profile/call site deterministically — a call-site fragment naming
  * an identity without a model would inherit whatever model the winning
  * profile carries, which the identity may not serve. Enforced at parse time
- * (LLMSchema.superRefine), at the config write choke point
- * (commitConfigWrite), and by the profile write route.
+ * (LLMSchema.superRefine) and by the profile creation route.
  */
 export function routingIdentityModelIssue(
   provider: string,

package/src/config/schemas/services.ts

@@ -71,12 +71,11 @@ const ImageGenerationServiceSchema = z.object({
 });
 
 /**
- * Web-search carries no `mode`: `provider` is the only axis. `"cadet"`
- * searches through the Cadet Cloud search proxy, billed to Cadet
- * credits; `"inference-provider-native"` prefers the inference model's own
- * hosted search, falling back to the user's keys and then the cloud
- * proxy; any other provider uses the user's own API key. A `mode` key sent
- * by an older client is stripped at parse.
+ * Web-search carries no `mode`: `provider` is the only axis.
+ * `"inference-provider-native"` prefers the inference model's own hosted
+ * search, falling back to the user's own keys; any other provider uses the
+ * user's own API key. A `mode` key sent by an older client is stripped at
+ * parse.
  */
 const WebSearchServiceSchema = z.object({
   provider: z

package/src/config/schemas/stt.ts

@@ -18,7 +18,6 @@ export const VALID_STT_PROVIDERS = [
   "google-gemini",
   "openai-whisper",
   "xai",
-  "cadet",
 ] as const;
 
 /**
@@ -183,8 +182,7 @@ export { STT_ROLE_REQUIREMENTS, STT_ROLES, type SttRole };
 /**
  * Canonical STT service configuration.
  *
- * `provider` is the only axis: `"cadet"` transcribes through the cloud,
- * billed to Cadet credits; any other provider uses the user's own API key.
+ * `provider` is the only axis: every provider uses the user's own API key.
  */
 export const SttServiceSchema = z
   .object({

package/src/config/schemas/tts.ts

@@ -271,31 +271,6 @@ export const TtsXaiProviderConfigSchema = z
 
 export type TtsXaiProviderConfig = z.infer<typeof TtsXaiProviderConfigSchema>;
 
-/**
- * Cadet Cloud provider configuration under `services.tts.providers`.
- */
-const TtsCadetProviderConfigSchema = z
-  .object({
-    model: z
-      .string()
-      .optional()
-      .describe(
-        "Managed TTS voice model (e.g. aura-2-thalia-en). Unset means the cloud's default voice. The cloud rejects voices it does not offer.",
-      ),
-    languageVoices: languageVoicesSchema(
-      "cadet",
-      "values are managed TTS voice models (e.g. aura-2-thalia-en) and must " +
-        "be voices offered by the cloud rate card: an unpriced model is " +
-        "rejected by the relay (missing_price), the same contract as " +
-        "services.tts.providers.cadet.model.",
-    ),
-  })
-  .describe("Cadet Cloud provider configuration under services.tts");
-
-export type TtsCadetProviderConfig = z.infer<
-  typeof TtsCadetProviderConfigSchema
->;
-
 const TtsProvidersSchema = z.object({
   elevenlabs: TtsElevenLabsProviderConfigSchema.default(
     TtsElevenLabsProviderConfigSchema.parse({}),
@@ -307,9 +282,6 @@ const TtsProvidersSchema = z.object({
     TtsDeepgramProviderConfigSchema.parse({}),
   ),
   xai: TtsXaiProviderConfigSchema.default(TtsXaiProviderConfigSchema.parse({})),
-  cadet: TtsCadetProviderConfigSchema.default(
-    TtsCadetProviderConfigSchema.parse({}),
-  ),
 });
 export type TtsProviders = z.infer<typeof TtsProvidersSchema>;
 
@@ -344,8 +316,7 @@ for (const id of schemaKeys) {
 /**
  * Canonical TTS service configuration.
  *
- * `provider` is the only axis: `"cadet"` synthesizes through the cloud,
- * billed to Cadet credits; any other provider uses the user's own API key.
+ * `provider` is the only axis: every provider uses the user's own API key.
  */
 export const TtsServiceSchema = z
   .object({

package/src/daemon/daemon-readiness.ts

@@ -64,32 +64,13 @@ export const DB_MIGRATION_READINESS_EXEMPT_OPERATIONS: ReadonlySet<string> =
 /**
  * The migration-repair surface: operations additionally allowed while DB
  * migrations are in the terminal FAILED state — and only then, never while
- * they are still running. Rolling back migrations and importing a backup are
- * exactly the remedies for a failed migration (the upgrade CLI's
- * rollback/restore path), so gating them in that state would make recovery
- * impossible. Contains both the HTTP endpoint form and the IPC operationId
+ * they are still running. Rollback repairs a failed migration without racing
+ * an active migration runner. Contains both the HTTP endpoint form and the IPC operationId
  * form of each route. Bypasses only the migration gate — route policies
  * (gateway-principal scopes, guardian auth) still apply.
  */
 export const DB_MIGRATION_FAILED_STATE_EXEMPT_OPERATIONS: ReadonlySet<string> =
-  new Set([
-    "admin/rollback-migrations",
-    "admin_rollbackmigrations_post",
-    "migrations/import",
-    "migrations_import_post",
-    // Restore has three transports; all must stay repair-capable. The
-    // preflights are read-only analysis; the GCS import is the cloud
-    // platform's restore path and is job-based, so its job-status GET (a
-    // parameterized route, matched by prefix in isDbMigrationGateBypassed)
-    // must answer too.
-    "migrations/import-preflight",
-    "migrations_importpreflight_post",
-    "migrations/import-from-gcs",
-    "migrations_importfromgcs_post",
-    "migrations/preflight-from-gcs",
-    "migrations_preflightfromgcs_post",
-    "migrations_jobs_by_job_id_get",
-  ]);
+  new Set(["admin/rollback-migrations", "admin_rollbackmigrations_post"]);
 
 /**
  * Whether an operation may proceed despite unready DB migrations: always for
@@ -103,13 +84,7 @@ export function isDbMigrationGateBypassed(operation: string): boolean {
   if (dbMigrationReadiness.state !== "failed") {
     return false;
   }
-  // The HTTP gate passes the raw path after /v1/, so the parameterized
-  // job-status route (migrations/jobs/:job_id) is matched by prefix; the
-  // IPC form is the exact operationId in the set above.
-  return (
-    DB_MIGRATION_FAILED_STATE_EXEMPT_OPERATIONS.has(operation) ||
-    operation.startsWith("migrations/jobs/")
-  );
+  return DB_MIGRATION_FAILED_STATE_EXEMPT_OPERATIONS.has(operation);
 }
 
 export function setDbReady(v: boolean): void {

package/src/daemon/lifecycle.ts

@@ -49,7 +49,6 @@ import {
   startRuntimeHttpServerBackgroundSweeps,
 } from "../runtime/http-server.js";
 import { warmLocalGuardianPrincipalCache } from "../runtime/local-actor-identity.js";
-import { recoverInterruptedImport } from "../runtime/migrations/vbundle-streaming-importer.js";
 import { markCurrentProcessAsMainDaemon } from "../runtime/process-role.js";
 import { publishConfigChanged } from "../runtime/sync/resource-sync-events.js";
 import { reconcilePluginSchedules } from "../schedule/plugin-schedule-reconciler.js";
@@ -148,36 +147,6 @@ export async function runDaemon(): Promise<void> {
   // after it.
   recordDaemonBootTime(startupStartedAt);
 
-  // Recover from any streaming `.vbundle` import that was interrupted by a
-  // crash or SIGKILL. If the previous process died between
-  // `carryOverPreservedPaths` and the atomic workspace swap, the live
-  // workspace may be missing `data/db` / `data/qdrant` / etc. The marker
-  // at `<workspaceDir>.import-marker.json` (persisted before any rename
-  // runs) tells us where the orphaned preserved paths landed; the
-  // recovery helper moves them back into the live workspace and cleans
-  // up the temp tree. Running this BEFORE `initializeDb()` ensures the
-  // DB singleton opens against the fully-restored `assistant.db`.
-  try {
-    const recoveryResult = await recoverInterruptedImport(getWorkspaceDir());
-    if (!recoveryResult.ok) {
-      // Rollback is intentionally unresolved — backup/temp/marker are
-      // preserved on disk so an operator (or a later retry) can finish
-      // the recovery. Log loudly so ops sees it, but don't block start-up:
-      // the daemon still needs to come up for diagnostics. The next
-      // `streamCommitImport` will refuse to start a new import until the
-      // marker is resolved.
-      log.error(
-        { failedCount: recoveryResult.failedCount },
-        "Interrupted-import recovery is INCOMPLETE; leftover .pre-import-* / .import-* scratch dirs remain in the workspace. Manual intervention may be required before the next import can run.",
-      );
-    }
-  } catch (err) {
-    log.warn(
-      { err },
-      "recoverInterruptedImport threw during daemon startup; continuing",
-    );
-  }
-
   // Load (or generate + persist) the auth signing key so tokens survive
   // daemon restarts.
   const signingKey = resolveSigningKey();

package/src/daemon/providers-setup.ts

@@ -1,5 +1,4 @@
 import { ensureCloudIdentityIds } from "../config/cloud-identity.js";
-import { maybeDefaultSpeechToCloud } from "../config/cloud-speech-defaults.js";
 import type { AssistantConfig } from "../config/types.js";
 import { getMcpServerManager } from "../mcp/manager.js";
 import { startConfiguredMcpServers } from "../mcp/startup.js";
@@ -34,13 +33,6 @@ export async function initializeProvidersAndTools(
   // overrides are normally only set by the secret-routes handlers at runtime.
   await ensureCloudIdentityIds();
 
-  // Speech defaulting normally fires when the cloud credentials land
-  // (secret-routes); evaluating it once per boot also covers assistants whose
-  // connection predates that trigger, so voice works for every connected
-  // assistant with no configured speech credentials. Idempotent, and detached
-  // per the startup philosophy — must not block boot.
-  void maybeDefaultSpeechToCloud();
-
   await initializeProviders(config);
   // initializeTools() also loads workspace tool overrides from
   // `<workspaceDir>/tools/` once core tools have settled, so they own

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -58,7 +58,6 @@ mock.module("../../prompts/persona-resolver.js", () => ({
   resolveGuardianPersona: () => null,
   resolveGuardianPersonaPath: () => null,
   resolveGuardianPersonaStrict: () => null,
-  isGuardianPersonaCustomized: () => false,
   resolveUserSlug: () => null,
   resolveUserPersona: () => null,
   resolveChannelPersona: () => null,

package/src/heartbeat/heartbeat-service.ts

@@ -124,16 +124,6 @@ function recordReengagementTimestamp(): void {
   }
 }
 
-function refreshBackgroundWakeIntentSoon(reason: string): void {
-  void import("../background-wake/publisher.js")
-    .then(({ refreshBackgroundWakeIntent }) =>
-      refreshBackgroundWakeIntent(reason),
-    )
-    .catch((err) =>
-      log.warn({ err, reason }, "Failed to queue background wake refresh"),
-    );
-}
-
 export interface HeartbeatDeps {
   /** Override for current hour (0-23), for testing. Used when no timezone is resolved. */
   getCurrentHour?: () => number;
@@ -141,19 +131,6 @@ export interface HeartbeatDeps {
   now?: () => Date;
 }
 
-export interface ManagedWakeHeartbeatRunOptions {
-  now?: number;
-  toleranceMs?: number;
-  assumeDue?: boolean;
-  scheduledFor?: number;
-}
-
-export interface ManagedWakeHeartbeatRunResult {
-  due: boolean;
-  completed: number;
-  skipped: number;
-}
-
 export class HeartbeatService {
   private static instance?: HeartbeatService;
 
@@ -236,47 +213,12 @@ export class HeartbeatService {
     return countCompletedRunsToday() >= config.maxDailyRuns;
   }
 
-  async runCloudWakeIfDue(
-    options: ManagedWakeHeartbeatRunOptions = {},
-  ): Promise<ManagedWakeHeartbeatRunResult> {
-    const now = options.now ?? Date.now();
-    const toleranceMs = options.toleranceMs ?? 0;
-    const dueByLocalTimer =
-      this._nextRunAt != null && this._nextRunAt <= now + toleranceMs;
-
-    if (!dueByLocalTimer && options.assumeDue !== true) {
-      return { due: false, completed: 0, skipped: 0 };
-    }
-
-    if (!dueByLocalTimer) {
-      if (this._pendingRunId) {
-        supersedePendingRun(this._pendingRunId);
-        this._pendingRunId = null;
-      }
-      this._nextRunAt = options.scheduledFor ?? now;
-      this._pendingRunId = insertPendingHeartbeatRun(this._nextRunAt);
-    }
-
-    const completed = await this.runOnce({ force: false });
-
-    if (this.cronMode && !this.stopped) {
-      this.scheduleNextCronRun(getConfig().heartbeat);
-    }
-
-    return {
-      due: true,
-      completed: completed ? 1 : 0,
-      skipped: completed ? 0 : 1,
-    };
-  }
-
   start(): void {
     this.stopped = false;
     const config = getConfig().heartbeat;
     if (!config.enabled) {
       log.info("Heartbeat disabled by config");
       this._nextRunAt = null;
-      refreshBackgroundWakeIntentSoon("heartbeat-disabled");
       return;
     }
     if (this.timer) {
@@ -405,7 +347,6 @@ export class HeartbeatService {
         { nextRunAt: new Date(nextRunAt).toISOString(), delayMs },
         "Heartbeat cron run scheduled",
       );
-      refreshBackgroundWakeIntentSoon("heartbeat-cron-scheduled");
     } catch (err) {
       log.warn(
         { err },
@@ -432,7 +373,6 @@ export class HeartbeatService {
     this._nextRunAt = null;
     this.cronMode = false;
     this.start();
-    refreshBackgroundWakeIntentSoon("heartbeat-reconfigured");
   }
 
   /**
@@ -449,7 +389,6 @@ export class HeartbeatService {
       supersedePendingRun(this._pendingRunId);
       this._pendingRunId = null;
     }
-    refreshBackgroundWakeIntentSoon("heartbeat-counter-reset");
     if (!this.timer) {
       return;
     }
@@ -519,7 +458,6 @@ export class HeartbeatService {
       if (runId) {
         skipHeartbeatRun(runId, "disabled");
       }
-      refreshBackgroundWakeIntentSoon("heartbeat-disabled");
       return false;
     }
 
@@ -680,7 +618,6 @@ export class HeartbeatService {
       if (!this.cronMode) {
         this.scheduleNextRun(getConfig().heartbeat.intervalMs);
       }
-      refreshBackgroundWakeIntentSoon("heartbeat-run-complete");
     }
     return true;
   }
@@ -691,7 +628,6 @@ export class HeartbeatService {
     }
     this._nextRunAt = Date.now() + intervalMs;
     this._pendingRunId = insertPendingHeartbeatRun(this._nextRunAt);
-    refreshBackgroundWakeIntentSoon("heartbeat-interval-scheduled");
   }
 
   /**
@@ -964,8 +900,7 @@ This is one of your first heartbeats. Your user hasn't heard from you yet and ma
 }
 
 /**
- * Construct and start the heartbeat service singleton, returning it so callers
- * can wire it into the background-wake runtime. start() self-gates on
+ * Construct and start the heartbeat service singleton. start() self-gates on
  * `heartbeat.enabled` and logs its own status.
  */
 export function startHeartbeatService(): HeartbeatService {

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

@@ -97,23 +97,15 @@ describe("AssistantIpcServer DB migration readiness gate", () => {
   });
 
   test("migration-repair surface is allowed only in the failed state", () => {
-    // Rollback/import are the remedies for failed migrations — gating them in
+    // Rollback is the remedy for failed migrations — gating them in
     // that state would make recovery impossible (the upgrade CLI's
     // rollback/restore path). While migrations are merely RUNNING they stay
     // gated: a rollback would race the in-flight migration runner.
     setDbMigrating();
     expect(gate("admin_rollbackmigrations_post")?.statusCode).toBe(503);
-    expect(gate("migrations_import_post")?.statusCode).toBe(503);
 
     setDbMigrationFailed(new Error("boom"));
     expect(gate("admin_rollbackmigrations_post")).toBeNull();
-    expect(gate("migrations_import_post")).toBeNull();
-    // All restore transports are repair-capable: preflights, the cloud
-    // platform's GCS path, and its job-status polling.
-    expect(gate("migrations_importpreflight_post")).toBeNull();
-    expect(gate("migrations_importfromgcs_post")).toBeNull();
-    expect(gate("migrations_preflightfromgcs_post")).toBeNull();
-    expect(gate("migrations_jobs_by_job_id_get")).toBeNull();
     // Everything else stays gated in the failed state.
     expect(gate("db_proxy")?.statusCode).toBe(503);
   });

package/src/live-voice/__tests__/live-voice-credential-preflight.test.ts

@@ -40,10 +40,6 @@ const realSttResolveModule = {
 const realSecureKeysModule = {
   ...(await import("../../security/secure-keys.js")),
 };
-const realCloudSpeechModule = {
-  ...(await import("../../cloud/cloud-speech.js")),
-};
-
 // -- Mutable stub state --------------------------------------------------------
 
 import type { StreamingTranscriber } from "../../stt/types.js";
@@ -74,16 +70,6 @@ mock.module("../../security/secure-keys.js", () => ({
       : realSecureKeysModule.getSecureKeyAsync(account),
 }));
 
-let managedAvailable = false;
-
-mock.module("../../cloud/cloud-speech.js", () => ({
-  ...realCloudSpeechModule,
-  managedSpeechAvailable: async () =>
-    preflightMocksActive
-      ? managedAvailable
-      : realCloudSpeechModule.managedSpeechAvailable(),
-}));
-
 import { setConfig } from "../../__tests__/helpers/set-config.js";
 import { getConfig } from "../../config/loader.js";
 import {
@@ -135,7 +121,6 @@ beforeEach(() => {
   sttProvider = "deepgram";
   ttsProvider = "fish-audio";
   ttsProviders = { "fish-audio": { referenceId: "ref-123" } };
-  managedAvailable = false;
 });
 
 function expectNotReady(
@@ -284,32 +269,3 @@ describe("resolveLiveVoiceCredentialReadiness", () => {
     expect(readiness.userMessage.endsWith(".")).toBe(true);
   });
 });
-
-describe("resolveLiveVoiceCredentialReadiness — managed (cadet) TTS", () => {
-  test("cadet TTS with a full platform connection → ready", async () => {
-    ttsProvider = "cadet";
-    ttsProviders = {};
-    managedAvailable = true;
-
-    const readiness = await runReadiness();
-    expect(readiness).toEqual({ status: "ready" });
-  });
-
-  test("cadet TTS without a cloud connection → connection copy, not API-key copy", async () => {
-    ttsProvider = "cadet";
-    ttsProviders = {};
-    managedAvailable = false;
-
-    const readiness = expectNotReady(await runReadiness());
-    expect(readiness.missing).toEqual([
-      {
-        kind: "tts",
-        providerId: "cadet",
-        reason:
-          'TTS provider "cadet" needs a Cadet Cloud connection for cloud speech',
-      },
-    ]);
-    expect(readiness.userMessage).toContain("assistant cloud connect");
-    expect(readiness.userMessage).not.toContain("API key");
-  });
-});

package/src/live-voice/__tests__/live-voice-flux-turn-end.test.ts

@@ -1170,8 +1170,6 @@ describe("LiveVoiceSession Flux end-of-turn", () => {
   test.each([
     { providerId: "deepgram-flux" as const, flagOn: true },
     { providerId: "deepgram-flux" as const, flagOn: false },
-    { providerId: "cadet-flux" as const, flagOn: true },
-    { providerId: "cadet-flux" as const, flagOn: false },
   ])(
     "only provider speech starts interrupt playback: %j",
     async ({ providerId, flagOn }) => {
@@ -1518,7 +1516,7 @@ describe("LiveVoiceSession Flux end-of-turn during the STT dial", () => {
     async (flagOn) => {
       const gate = createDialGate();
       const { frames, session } = createHarness({
-        providerId: "cadet",
+        providerId: "deepgram",
         fluxConfig: flagOn ? FLUX_ON : FLUX_OFF,
         silenceThresholdMs: 10_000,
         resolveGate: gate.promise,
@@ -1539,9 +1537,9 @@ describe("LiveVoiceSession Flux end-of-turn during the STT dial", () => {
   );
 
   test.each([
-    { providerId: "cadet" as const, audio: LOUD_CHUNK, interrupts: false },
+    { providerId: "deepgram" as const, audio: LOUD_CHUNK, interrupts: false },
     {
-      providerId: "cadet" as const,
+      providerId: "deepgram" as const,
       audio: SUSTAINED_LOUD_CHUNK,
       interrupts: true,
     },
@@ -1616,7 +1614,7 @@ describe("LiveVoiceSession Flux end-of-turn during the STT dial", () => {
       // The first input is released but cannot dispatch until its final arrives.
       await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
       await sleep(PAST_SILENCE_BOUNDARY_MS);
-      options.providerId = "cadet";
+      options.providerId = "deepgram";
       first.flushStopEvents();
       await waitFor(() => countFrames(frames, "thinking") === 1);
       expect(countFrames(frames, "turn_cancelled")).toBe(0);

package/src/live-voice/__tests__/live-voice-stt.test.ts

@@ -1609,7 +1609,7 @@ describe("LiveVoiceSession STT", () => {
         },
       },
     });
-    const transcriber = new MockStreamingTranscriber("cadet");
+    const transcriber = new MockStreamingTranscriber("deepgram");
     const startVoiceTurn = speakingVoiceTurnStarter();
     const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
     const { context } = createContext();

package/src/live-voice/live-voice-credential-preflight.ts

@@ -11,24 +11,22 @@
  * Mirrors `calls/telephony-credential-preflight.ts` for the phone-call
  * transport.
  *
- * Both legs are checked against the effective providers
- * (`resolveEffectiveSpeechProviders`), which is what the transcriber and
- * synthesis paths resolve too — so a `ready` verdict earned on managed
- * speech is a verdict the runtime can honour.
+ * Both legs are checked against the providers the transcriber and synthesis
+ * paths resolve, so a `ready` verdict is one the runtime can honour.
  */
 
 import {
   fishAudioReferenceIdConfigured,
   ttsSecretResolves,
 } from "../calls/telephony-tts-capability.js";
-import { managedSpeechAvailable } from "../cloud/cloud-speech.js";
-import { resolveEffectiveSpeechProviders } from "../config/cloud-speech-defaults.js";
+import { getConfig } from "../config/loader.js";
 import { getProviderEntry } from "../providers/speech-to-text/provider-catalog.js";
 import {
   resolveStreamingTranscriber,
   sttCredentialGapReason,
   sttProviderKeyResolves,
 } from "../providers/speech-to-text/resolve.js";
+import { sttCatalogKeyForRole } from "../stt/roles.js";
 import type { SttProviderId } from "../stt/types.js";
 import type { TtsProviderCatalogEntry } from "../tts/provider-catalog.js";
 import { getCatalogProvider, getTtsProvider } from "../tts/provider-catalog.js";
@@ -78,13 +76,12 @@ export type LiveVoiceCredentialReadiness =
 export async function resolveLiveVoiceCredentialReadiness(): Promise<LiveVoiceCredentialReadiness> {
   // Readiness must ask about the same provider the session will dial, so it
   // reads the live-voice role rather than the global setting.
-  const effective = await resolveEffectiveSpeechProviders(undefined, {
-    role: "liveVoice",
-  });
+  const config = getConfig();
+  const effectiveStt = sttCatalogKeyForRole(config.services.stt, "liveVoice");
   const gaps = (
     await Promise.all([
-      resolveSttGap(effective.stt),
-      resolveTtsGap(effective.tts),
+      resolveSttGap(effectiveStt),
+      resolveTtsGap(config.services.tts.provider),
     ])
   ).filter((gap) => gap !== null);
 
@@ -142,10 +139,7 @@ async function resolveSttGap(
         providerId: entry.id,
         reason: sttCredentialGapReason(entry.credentialProvider),
       },
-      clause:
-        entry.credentialProvider === "cadet"
-          ? `a Cadet Cloud connection for cloud speech (run 'assistant cloud connect')`
-          : `an API key for the speech-to-text provider "${entry.id}"`,
+      clause: `an API key for the speech-to-text provider "${entry.id}"`,
     };
   }
 
@@ -197,24 +191,6 @@ async function resolveTtsGap(
     };
   }
 
-  // Cloud speech authenticates via the cloud connection — full
-  // availability (API key + assistant ID) is the credential, so the
-  // stored-secret loop below would pass half-connected states that
-  // synthesis rejects.
-  if (entry.id === "cadet") {
-    if (!(await managedSpeechAvailable())) {
-      return {
-        gap: {
-          kind: "tts",
-          providerId: entry.id,
-          reason: `TTS provider "${entry.id}" needs a Cadet Cloud connection for cloud speech`,
-        },
-        clause: `a Cadet Cloud connection for cloud speech (run 'assistant cloud connect')`,
-      };
-    }
-    return null;
-  }
-
   for (const secret of entry.secretRequirements) {
     if (!(await ttsSecretResolves(secret.credentialStoreKey))) {
       return {