@mycadet/assistant 0.12.10 → 0.13.0

package/src/providers/speech-to-text/resolve.ts

@@ -13,7 +13,6 @@ import {
   batchBoundaryGapReason,
   getCredentialProvider,
   getProviderEntry,
-  isCloudSttProvider,
   resolveSttCatalogKey,
   supportsBoundary,
   supportsDiarization,
@@ -37,11 +36,6 @@ const log = getLogger("stt-resolver");
  */
 const MULTILINGUAL_DEFAULT_PROVIDERS: ReadonlySet<SttProviderId> = new Set([
   "deepgram",
-  "cadet",
-  // Cloud Flux resolves an absent language to `flux-general-en` relay-side,
-  // so unset is an English pin here too. With "multi" the relay selects
-  // `flux-general-multi` and lets Flux detect and code-switch.
-  "cadet-flux",
 ] as SttProviderId[]);
 
 /**
@@ -156,16 +150,6 @@ export async function resolveBatchTranscriber(
     throw new SttError("provider-error", reason, { userFacing: true });
   }
 
-  if (provider === "cadet") {
-    // Managed batch rides the cloud's speech proxy, which forwards the
-    // language to Deepgram server-side. A platform build predating that
-    // field ignores it rather than failing, so the daemon can send one
-    // before the cloud side deploys.
-    return (await sttProviderKeyResolves("cadet"))
-      ? createDaemonBatchTranscriber(null, "cadet", language)
-      : null;
-  }
-
   const apiKey = await getProviderKeyAsync(credentialProviderName);
   return createDaemonBatchTranscriber(
     apiKey,
@@ -515,18 +499,8 @@ export async function resolveStreamingTranscriber(
     (diarizePreference === "preferred" || diarizePreference === "required") &&
     providerSupportsDiarization;
 
-  // Both managed entries authenticate with the cloud connection, not a
-  // stored API key: there is no key to fetch, and readiness is whether the
-  // connection resolves.
-  const managed = isCloudSttProvider(provider);
-  const apiKey = managed
-    ? null
-    : await getProviderKeyAsync(credentialProviderName);
-  if (managed) {
-    if (!(await sttProviderKeyResolves("cadet"))) {
-      return null;
-    }
-  } else if (!apiKey) {
+  const apiKey = await getProviderKeyAsync(credentialProviderName);
+  if (!apiKey) {
     return null;
   }
 
@@ -656,82 +630,6 @@ async function createStreamingTranscriber(
         ...(options.diarize ? { diarize: true } : {}),
       });
     }
-    case "cadet": {
-      // Cloud speech dials the GATEWAY's speech relay (tunnel contact is
-      // gateway-only); the apiKey argument is unused. Diarization is
-      // unsupported (not in the relay's param allowlist) and silently
-      // ignored, matching Gemini/Whisper — as is utteranceEndMs (the relay
-      // allowlist has no utterance_end_ms; boundary finals ride on
-      // endpointing alone).
-      // The gateway is the credential authority, but the cloud
-      // connection (API key + assistant ID) is checkable locally — gate
-      // here so preflight reports "connect your account" instead of
-      // resolving a transcriber whose dial is doomed.
-      const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
-      if (!(await cadetCloudSpeechAvailable())) {
-        return null;
-      }
-      const { resolveSpeechRelayConnection } =
-        await import("./cadet-speech-relay-connection.js");
-      const connection = await resolveSpeechRelayConnection();
-      if (!connection) {
-        return null;
-      }
-      const { CadetManagedRealtimeTranscriber } =
-        await import("./cadet-cloud-realtime.js");
-      return new CadetManagedRealtimeTranscriber(connection, {
-        sampleRate: options.sampleRate,
-        // `language` IS in the relay's param allowlist, and the relay pins
-        // the STT model to nova-3 server-side, so "multi" code-switching
-        // needs nothing from the cloud, only this forward. Source:
-        // mycadet-platform: tunnel/internal/tunnel/deepgram.go
-        // (deepgramSTTParams allowlist; deepgramSTTModel pin).
-        ...(options.language ? { language: options.language } : {}),
-        ...(options.utteranceBoundaryFinals
-          ? { utteranceBoundaryFinals: true }
-          : {}),
-      });
-    }
-    case "cadet-flux": {
-      // Cloud Flux: same relay as `cadet`, but the STT v2 endpoint with
-      // `contract=flux` so the turn events arrive intact instead of being
-      // translated into the released v1 Deepgram dialect. Gated on the local
-      // cloud connection for the same reason as `cadet` above.
-      const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
-      if (!(await cadetCloudSpeechAvailable())) {
-        return null;
-      }
-      // The relay maps the language onto a Flux model and refuses the dial
-      // when there is none, so a language outside Flux's roster fails as a
-      // relay param error the caller cannot explain. Refuse here instead, on
-      // the same rule the BYOK twin above applies, so the reason is named
-      // where it can be read.
-      const { fluxModelForLanguage: managedFluxModelForLanguage } =
-        await import("./deepgram-flux-frames.js");
-      if (managedFluxModelForLanguage(options.language) === null) {
-        log.warn(
-          { providerId, language: options.language },
-          "Cloud Flux has no model for the configured language; refusing rather than transcribing it as another",
-        );
-        return null;
-      }
-      const { resolveSpeechRelayConnection } =
-        await import("./cadet-speech-relay-connection.js");
-      const connection = await resolveSpeechRelayConnection();
-      if (!connection) {
-        return null;
-      }
-      const { CadetManagedFluxRealtimeTranscriber } =
-        await import("./cadet-cloud-flux-realtime.js");
-      return new CadetManagedFluxRealtimeTranscriber(connection, {
-        sampleRate: options.sampleRate,
-        // The relay picks `flux-general-en` or `flux-general-multi` from
-        // this, so it is the only lever over the Flux model from here.
-        // `utteranceBoundaryFinals` is a nova-3 concept and the catalog
-        // keeps this provider off telephony, so it never arrives.
-        ...(options.language ? { language: options.language } : {}),
-      });
-    }
     case "deepgram-flux": {
       // Flux is streaming-only and dials Deepgram's /v2/listen conversational
       // endpoint. Turn-detection tuning comes from `liveVoice.flux`, which the
@@ -775,29 +673,14 @@ async function createStreamingTranscriber(
  * need a key-existence check don't import secure-keys directly.
  */
 /**
- * Human-readable reason for a credential gap, aware that connection-based
- * providers (cadet) are fixed by connecting the cloud account, not by
- * entering an API key.
+ * Human-readable reason for a credential gap.
  */
 export function sttCredentialGapReason(credentialProviderName: string): string {
-  // Called with either the catalog id ("cadet") or its credential-service
-  // key ("cadet", the persisted identity family) — both mean cloud speech.
-  if (
-    credentialProviderName === "cadet" ||
-    credentialProviderName === "cadet"
-  ) {
-    return "No Cadet Cloud connection for cloud speech — run 'assistant cloud connect'";
-  }
   return `No API key configured for credential provider "${credentialProviderName}"`;
 }
 
 export async function sttProviderKeyResolves(
   credentialProviderName: string,
 ): Promise<boolean> {
-  // cadet has no stored API key — the cloud connection is the credential.
-  if (credentialProviderName === "cadet") {
-    const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
-    return cadetCloudSpeechAvailable();
-  }
   return (await getProviderKeyAsync(credentialProviderName)) !== undefined;
 }

package/src/runtime/http-router-types.ts

@@ -45,9 +45,7 @@ export type RouteBodySchema = z.ZodType;
 
 /**
  * Description for a non-200 response variant. Used when an endpoint has
- * meaningful alternate response shapes that clients should handle (e.g.
- * 502 `fetch_failed` on POST /v1/migrations/import when the URL body path
- * can't reach the upstream bundle host).
+ * meaningful alternate response shapes that clients should handle.
  */
 export interface RouteAdditionalResponse {
   description: string;

package/src/runtime/http-server.ts

@@ -122,7 +122,7 @@ const log = getLogger("runtime-http");
 const DEFAULT_PORT = 7821;
 const DEFAULT_HOSTNAME = "127.0.0.1";
 
-/** Global hard cap on request body size (512 MB — accommodates large .vbundle backup imports). */
+/** Global hard cap on request body size (512 MB, accommodates app package uploads). */
 const MAX_REQUEST_BODY_BYTES = 512 * 1024 * 1024;
 
 function dbMigrationUnavailableForEndpoint(endpoint: string): Response | null {

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -1625,7 +1625,7 @@ describe("config GET serves profiles verbatim", () => {
   });
 });
 
-describe("provider membership at the write choke point", () => {
+describe("provider labels follow the open-string Zod schema", () => {
   const configPatchRoute = ROUTES.find(
     (r) => r.operationId === "config_patch",
   )!;
@@ -1659,21 +1659,23 @@ describe("provider membership at the write choke point", () => {
     expect(llm.profiles?.work?.provider).toBe("anthropic-work");
   });
 
-  test("introducing an unknown provider is rejected", async () => {
+  test("a new provider label is accepted by the schema", async () => {
     rawConfigFixture = { llm: {} };
     seedRawConfig();
-
-    await expect(
-      configPatchRoute.handler({
-        body: {
-          llm: {
-            profiles: {
-              rogue: { source: "user", provider: "not-a-provider", model: "m" },
+    await configPatchRoute.handler({
+      body: {
+        llm: {
+          profiles: {
+            work: {
+              source: "user",
+              provider: "anthropic-work",
+              model: "claude-opus-4-8",
             },
           },
         },
-      }),
-    ).rejects.toThrow(/Invalid provider/);
+      },
+    });
+    expect(persistedProfile("work").provider).toBe("anthropic-work");
   });
 });
 

package/src/runtime/routes/__tests__/tts-routes.test.ts

@@ -127,17 +127,13 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("tts-routes", () => {
-  test("exports route definitions for tts/providers, tts/managed-voices, tts/synthesize, and tts/synthesize-cli", () => {
-    expect(ROUTES).toHaveLength(4);
+  test("exports route definitions for tts/providers, tts/synthesize, and tts/synthesize-cli", () => {
+    expect(ROUTES).toHaveLength(3);
 
     const providers = getRoute("tts/providers");
     expect(providers.method).toBe("GET");
     expect(providers.policy?.requiredScopes).toContain("settings.read");
 
-    const managedVoices = getRoute("tts/managed-voices");
-    expect(managedVoices.method).toBe("GET");
-    expect(managedVoices.policy?.requiredScopes).toContain("settings.read");
-
     const synthesize = getRoute("tts/synthesize");
     expect(synthesize.method).toBe("POST");
     expect(synthesize.policy?.requiredScopes).toContain("chat.read");

package/src/runtime/routes/conversation-query-routes.ts

@@ -53,8 +53,6 @@ import {
   LLMDefaultConfigSchema,
   LLMSchema,
   ProfileEntry,
-  routingIdentityModelIssue,
-  unknownLlmProviderIssue,
 } from "../../config/schemas/llm.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
 import { ServiceModeSchema } from "../../config/schemas/services.js";
@@ -106,7 +104,6 @@ import { getMemoryRecallLogByMessageIds } from "../../plugins/defaults/memory/me
 import { getMemoryV2ActivationLogByMessageIds } from "../../plugins/defaults/memory/v2/activation-log-store.js";
 import { getMemoryV3SelectionForInspectorByMessageIds } from "../../plugins/defaults/memory/v3/selection-log-store.js";
 import { CLOUD_ROUTABLE_PROVIDERS } from "../../providers/cadet-model-routing.js";
-import { writableProfileProviderIssue } from "../../providers/connection-resolution.js";
 import { ROUTING_IDENTITY_PROVIDERS } from "../../providers/inference/auth.js";
 import { PROVIDERS_REQUIRING_BASE_URL_AND_MODELS } from "../../providers/inference/auth.js";
 import {
@@ -684,98 +681,6 @@ function handleGetConfigSchema({ queryParams = {} }: RouteHandlerArgs) {
   };
 }
 
-/**
- * Reject writes that would store a routing-identity provider with a missing
- * or unroutable model (see `routingIdentityModelIssue`). saveRawConfig
- * persists without schema validation, so the parse-time rejection alone
- * would let the pair reach disk and be stripped on the next read — a silent
- * no-op where the user expects a saved override.
- */
-function collectProviderEntries(
-  raw: Record<string, unknown>,
-): [string, { provider?: unknown; model?: unknown }][] {
-  const llm = raw.llm as
-    | {
-        default?: { provider?: unknown; model?: unknown } | null;
-        profiles?: Record<
-          string,
-          { provider?: unknown; model?: unknown } | null | undefined
-        >;
-        callSites?: Record<
-          string,
-          { provider?: unknown; model?: unknown } | null | undefined
-        >;
-      }
-    | undefined;
-  const entries: [string, { provider?: unknown; model?: unknown }][] = [];
-  // llm.default is a raw compatibility field outside the parsed schema;
-  // profile materialization uses the on-disk blob as its fill base, so it is
-  // checked like the schema-carried sections.
-  if (llm?.default) {
-    entries.push(["llm.default", llm.default]);
-  }
-  for (const section of ["profiles", "callSites"] as const) {
-    for (const [name, entry] of Object.entries(llm?.[section] ?? {})) {
-      if (entry) {
-        entries.push([`llm.${section}.${name}`, entry]);
-      }
-    }
-  }
-  return entries;
-}
-
-function assertRoutableIdentityEntries(
-  preWrite: Record<string, unknown>,
-  raw: Record<string, unknown>,
-): void {
-  const entries = collectProviderEntries(raw);
-  const priorProviders = new Map(
-    collectProviderEntries(preWrite).flatMap(([label, entry]) =>
-      typeof entry.provider === "string" ? [[label, entry.provider]] : [],
-    ),
-  );
-  for (const [label, entry] of entries) {
-    if (typeof entry.provider !== "string") {
-      continue;
-    }
-    // The provider schema is an open string (a stored value outside the
-    // known set parses instead of stripping its profile), so write-time
-    // membership is enforced here and at the profiles route. Scoped to
-    // providers this write introduces or changes: a stored value outside
-    // the known set is readable and dispatchable by design, and
-    // re-validating it on every write would make all later settings saves
-    // fail with no in-product repair path. Profiles accept entry names;
-    // call-site fragments and the legacy default blob stay vendor-only
-    // (overrides become model-only with the entries demolition).
-    if (entry.provider !== priorProviders.get(label)) {
-      const providerIssue = label.startsWith("llm.profiles.")
-        ? writableProfileProviderIssue(entry.provider)
-        : unknownLlmProviderIssue(entry.provider);
-      if (providerIssue) {
-        throw new BadRequestError(`${providerIssue} (${label})`);
-      }
-    }
-    // A model-less entry under a code-defined default name is the thin
-    // managed stub — its content is code-owned, so the routing-identity
-    // model check applies only to entries carrying their own body.
-    const profileName = label.startsWith("llm.profiles.")
-      ? label.slice("llm.profiles.".length)
-      : undefined;
-    const isManagedName =
-      profileName != null && MANAGED_PROFILE_NAMES.has(profileName);
-    if (entry.model == null && isManagedName) {
-      continue;
-    }
-    const issue = routingIdentityModelIssue(
-      entry.provider,
-      typeof entry.model === "string" ? entry.model : undefined,
-    );
-    if (issue) {
-      throw new BadRequestError(`${issue} (${label})`);
-    }
-  }
-}
-
 export async function commitConfigWrite(
   raw: Record<string, unknown>,
   opLabel: string,
@@ -792,7 +697,6 @@ export async function commitConfigWrite(
   if (!chatSettings.success) {
     throw new BadRequestError(chatSettings.error.message);
   }
-  assertRoutableIdentityEntries(preWrite, raw);
 
   // Suppress the file-watcher callback for the duration of the debounce
   // window. Without this, the ConfigWatcher detects the config.json write

package/src/runtime/routes/inbound-stages/transcribe-audio.test.ts

@@ -200,17 +200,17 @@ describe("tryTranscribeAudioAttachments", () => {
     expect(reason).toContain("Deepgram");
   });
 
-  test("managed auth failure surfaces its remediation, not the BYOK API-key rewrite", async () => {
+  test("a userFacing auth failure surfaces its remediation, not the BYOK API-key rewrite", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
     const managedMessage =
       "Cloud speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.";
     mockTranscriber = {
-      providerId: "cadet",
+      providerId: "deepgram",
       boundaryId: "daemon-batch",
       transcribe: async () => {
-        // Managed adapters flag their SttError userFacing so the friendly
-        // copy layer passes the message through verbatim.
+        // Adapters flag their SttError userFacing so the friendly copy
+        // layer passes the message through verbatim.
         throw new SttError("auth", managedMessage, { userFacing: true });
       },
     };
@@ -220,18 +220,18 @@ describe("tryTranscribeAudioAttachments", () => {
     expect(result.status).toBe("error");
     const reason = (result as { reason: string }).reason;
     expect(reason).toBe(managedMessage);
-    // Managed users have no STT key — the BYOK rewrite must not appear.
+    // The BYOK rewrite must not appear over a userFacing message.
     expect(reason).not.toContain("API key");
     expect(reason).not.toContain("Settings → Voice");
   });
 
-  test("managed credits-exhausted failure is not hidden behind generic copy", async () => {
+  test("a credits-exhausted userFacing failure is not hidden behind generic copy", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
     const creditsMessage =
       "Cadet credits are exhausted — add funds to your Cadet account to continue using managed transcription.";
     mockTranscriber = {
-      providerId: "cadet",
+      providerId: "deepgram",
       boundaryId: "daemon-batch",
       transcribe: async () => {
         throw new SttError("provider-error", creditsMessage, {

package/src/runtime/routes/index.ts

@@ -27,7 +27,6 @@ import { ROUTES as AUDIT_ROUTES } from "./audit-routes.js";
 import { ROUTES as AUTH_ROUTES } from "./auth-routes.js";
 import { ROUTES as AVATAR_ROUTES } from "./avatar-routes.js";
 import { ROUTES as BACKGROUND_TOOL_ROUTES } from "./background-tool-routes.js";
-import { ROUTES as BACKGROUND_WAKE_ROUTES } from "./background-wake-routes.js";
 import { ROUTES as BOOKMARK_ROUTES } from "./bookmark-routes.js";
 import { ROUTES as BRAIN_GRAPH_ROUTES } from "./brain-graph-routes.js";
 import { ROUTES as BROWSER_ROUTES } from "./browser-routes.js";
@@ -114,7 +113,6 @@ import { ROUTES as LOG_EXPORT_ROUTES } from "./log-export-routes.js";
 import { ROUTES as MCP_AUTH_ROUTES } from "./mcp-auth-routes.js";
 import { ROUTES as MESSAGES_LEXICAL_ROUTES } from "./messages-lexical-routes.js";
 import { ROUTES as MIGRATION_ROLLBACK_ROUTES } from "./migration-rollback-routes.js";
-import { ROUTES as MIGRATION_ROUTES } from "./migration-routes.js";
 import { ROUTES as MONITORING_ROUTES } from "./monitoring-routes.js";
 import { ROUTES as NOTIFICATION_ROUTES } from "./notification-routes.js";
 import { ROUTES as OAUTH_APPS_ROUTES } from "./oauth-apps.js";
@@ -179,7 +177,6 @@ export const ROUTES: RouteDefinition[] = [
   ...AUDIT_ROUTES,
   ...AUTH_ROUTES,
   ...AVATAR_ROUTES,
-  ...BACKGROUND_WAKE_ROUTES,
   ...BACKGROUND_TOOL_ROUTES,
   ...BOOKMARK_ROUTES,
   ...CACHE_ROUTES,
@@ -267,7 +264,6 @@ export const ROUTES: RouteDefinition[] = [
   ...MEMORY_WORKER_ROUTES,
   ...MESSAGES_LEXICAL_ROUTES,
   ...MIGRATION_ROLLBACK_ROUTES,
-  ...MIGRATION_ROUTES,
   ...NOTIFICATION_ROUTES,
   ...OAUTH_APPS_ROUTES,
   ...OAUTH_LIFECYCLE_ROUTES,

package/src/runtime/routes/live-voice-routes.test.ts

@@ -1,11 +1,10 @@
 /**
  * Tests for the live-voice preflight and session-end routes.
  *
- * The handler must run cloud-speech defaulting first, then return the
- * live-voice credential readiness verdict verbatim:
+ * The preflight handler returns the live-voice credential readiness verdict
+ * verbatim:
  * - ready → { status: "ready" }
  * - not-ready → passes through the missing gaps + userMessage
- * - defaulting is invoked BEFORE readiness is resolved
  *
  * The session-end route is the out-of-band recovery path (LUM-3440): it
  * reports whether it actually reclaimed the daemon's single live-voice slot.
@@ -23,12 +22,6 @@ const calls: string[] = [];
 let readiness: LiveVoiceCredentialReadiness = { status: "ready" };
 let releaseResult: LiveVoiceSessionReleaseResult = { released: false };
 
-mock.module("../../config/cloud-speech-defaults.js", () => ({
-  maybeDefaultSpeechToCloud: async () => {
-    calls.push("default");
-  },
-}));
-
 mock.module("../../live-voice/live-voice-credential-preflight.js", () => ({
   resolveLiveVoiceCredentialReadiness: async () => {
     calls.push("resolve");
@@ -80,13 +73,13 @@ describe("live_voice_preflight_post", () => {
     expect(result).toEqual(readiness);
   });
 
-  test("runs cloud-speech defaulting before resolving readiness", async () => {
+  test("resolves readiness without touching persisted config", async () => {
     calls.length = 0;
     readiness = { status: "ready" };
 
     await preflightRoute.handler({});
 
-    expect(calls).toEqual(["default", "resolve"]);
+    expect(calls).toEqual(["resolve"]);
   });
 });
 

package/src/runtime/routes/live-voice-routes.ts

@@ -1,9 +1,9 @@
 /**
  * Transport-agnostic route definitions for live-voice preflight.
  *
- * POST /v1/live-voice/preflight — ensure cloud-speech defaulting has run,
- * then report whether the daemon can run both audio legs of a live voice
- * session. Lets the web client verify voice is configured BEFORE opening the
+ * POST /v1/live-voice/preflight — report whether the daemon can run both
+ * audio legs of a live voice session. Lets the web client verify voice is
+ * configured BEFORE opening the
  * voice-room WebSocket, instead of opening it and reacting to an error frame.
  *
  * POST /v1/live-voice/session/end releases whatever session holds the
@@ -22,12 +22,9 @@ import type { RouteDefinition } from "./types.js";
 // ---------------------------------------------------------------------------
 
 async function handleLiveVoicePreflight() {
-  const { maybeDefaultSpeechToCloud } =
-    await import("../../config/cloud-speech-defaults.js");
   const { resolveLiveVoiceCredentialReadiness } =
     await import("../../live-voice/live-voice-credential-preflight.js");
 
-  await maybeDefaultSpeechToCloud();
   return resolveLiveVoiceCredentialReadiness();
 }
 
@@ -51,17 +48,17 @@ export const ROUTES: RouteDefinition[] = [
     operationId: "live_voice_preflight_post",
     endpoint: "live-voice/preflight",
     method: "POST",
-    // Requires settings.write, not a read scope: the handler runs
-    // maybeDefaultSpeechToCloud(), which can persist config changes
-    // (switching services.stt/tts.provider to "cadet"). This matches the
-    // secret/settings config writers, which all require settings.write.
+    // Requires settings.write, not a read scope: preflight reports the
+    // assistant's speech credential state, which the caller may act on to
+    // rewrite speech config. This matches the secret/settings config
+    // writers, which all require settings.write.
     policy: {
       requiredScopes: ["settings.write"],
       allowedPrincipalTypes: ACTOR_PRINCIPALS,
     },
     summary: "Live voice preflight",
     description:
-      "Ensure cloud speech defaulting has run, then report whether live voice can start.",
+      "Report whether live voice can start with the current speech credentials.",
     tags: ["live-voice"],
     responseBody: z.object({
       status: z.enum(["ready", "not-ready"]),

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

@@ -16,7 +16,6 @@ import {
 } from "../../acp/acp-credentials.js";
 import { syncAvatarToCloud } from "../../avatar/sync-avatar.js";
 import { syncWorkspaceIdentityToPlatform } from "../../cloud/sync-identity.js";
-import { maybeDefaultSpeechToCloud } from "../../config/cloud-speech-defaults.js";
 import { getCloudAssistantId } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
 import { getCesClient } from "../../credential-execution/ces-runtime.js";
@@ -342,11 +341,6 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           await refreshProvidersForRotatedCredential(service, field);
         }
         if (field === "assistant_api_key") {
-          // Managed-speech availability needs the API key and the assistant
-          // ID. Fire on each write that completes a piece of that set; the
-          // hook no-ops until the connection is complete.
-          // Detached, must not block the response.
-          void maybeDefaultSpeechToCloud();
           // Same last-write-wins shape: the startup syncs no-op before live
           // registration, so re-enqueue them here. Both dedup and no-op until
           // the client and assistant id exist.

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

@@ -8,7 +8,6 @@
 import { z } from "zod";
 
 import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
-import { managedSpeechVoices } from "../../cloud/cloud-speech.js";
 import { getConfig } from "../../config/loader.js";
 import { listCatalogProvidersForDisplay } from "../../tts/provider-catalog.js";
 import {
@@ -132,17 +131,6 @@ function handleListTtsProviders() {
   return { providers: listCatalogProvidersForDisplay() };
 }
 
-async function handleListCloudVoices() {
-  const result = await managedSpeechVoices();
-  if (!result.ok) {
-    if (result.kind === "unavailable") {
-      throw new ServiceUnavailableError(result.message);
-    }
-    throw new BadGatewayError(result.message);
-  }
-  return result.value;
-}
-
 async function handleSynthesizeTts({ body }: RouteHandlerArgs) {
   if (!body?.text || typeof body.text !== "string") {
     throw new BadRequestError("text is required");
@@ -234,32 +222,6 @@ export const ROUTES: RouteDefinition[] = [
     }),
     handler: handleListTtsProviders,
   },
-  {
-    operationId: "tts_managed_voices",
-    endpoint: "tts/managed-voices",
-    method: "GET",
-    policy: {
-      requiredScopes: ["settings.read"],
-      allowedPrincipalTypes: ACTOR_PRINCIPALS,
-    },
-    summary: "List managed TTS voices",
-    description:
-      "Return the voices offered by Cadet Cloud TTS, fetched live from the cloud. Only currently-usable voices are returned; defaultModel is always one of them (null when none are offered).",
-    tags: ["tts"],
-    responseBody: z.object({
-      voices: z.array(
-        z.object({
-          model: z.string(),
-          label: z.string(),
-          description: z.string(),
-          sampleUrl: z.string(),
-          source: z.string(),
-        }),
-      ),
-      defaultModel: z.string().nullable(),
-    }),
-    handler: handleListCloudVoices,
-  },
   {
     operationId: "tts_synthesize",
     endpoint: "tts/synthesize",

package/src/schedule/__tests__/plugin-schedule-reconciler.test.ts

@@ -3,19 +3,13 @@
  *
  * Fixture plugin directories are written under the (per-test-process)
  * workspace plugins dir and converged against the real schedule store; the
- * only stubs are the notification emitter (recorded for assertions) and the
- * background-wake publisher (kept out for hermeticity, mirroring
- * schedule-store.test.ts).
+ * only stub is the notification emitter (recorded for assertions).
  */
 
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../../background-wake/publisher.js", () => ({
-  refreshBackgroundWakeIntent: () => {},
-}));
-
 const emittedSignals: Array<Record<string, unknown>> = [];
 
 /** When set, merged into the next emit results (e.g. a failure reason). */

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

@@ -32,10 +32,6 @@ mock.module("../../daemon/process-message.js", () => ({
   processMessageInBackground: async () => {},
 }));
 
-mock.module("../../background-wake/publisher.js", () => ({
-  refreshBackgroundWakeIntent: () => {},
-}));
-
 mock.module("../../daemon/disk-pressure-background-gate.js", () => ({
   checkDiskPressureBackgroundGate: () => ({
     action: "allow",