@mycadet/assistant 0.12.11 → 0.13.0

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 {

package/src/live-voice/live-voice-session.ts

@@ -8262,14 +8262,18 @@ export async function defaultSpawnBackgroundContinuation(args: {
 async function defaultResolveStreamingTranscriber(
   options: ResolveStreamingTranscriberOptions,
 ): Promise<StreamingTranscriber | null> {
-  const { resolveEffectiveSpeechProviders } =
-    await import("../config/cloud-speech-defaults.js");
   const { resolveStreamingTranscriber } =
     await import("../providers/speech-to-text/resolve.js");
-  const { stt } = await resolveEffectiveSpeechProviders(undefined, {
-    role: "liveVoice",
-  });
-  return resolveStreamingTranscriber({ ...options, providerId: stt });
+  const { sttCatalogKeyForRole } = await import("../stt/roles.js");
+  const { getConfig } = await import("../config/loader.js");
+  // The live-voice role's configured provider is the one that gets dialed —
+  // the session resolves it here (rather than trusting a caller's override)
+  // so readiness and transcription agree.
+  const providerId = sttCatalogKeyForRole(
+    getConfig().services.stt,
+    "liveVoice",
+  );
+  return resolveStreamingTranscriber({ ...options, providerId });
 }
 
 async function defaultResolveLiveVoiceCredentialReadiness(): Promise<LiveVoiceCredentialReadiness> {

package/src/live-voice/live-voice-tts.ts

@@ -220,14 +220,7 @@ async function resolveLiveVoiceStreamingTtsProvider(
   configOverride?: LiveVoiceTtsConfig,
 ): Promise<ResolvedStreamingTtsProvider> {
   const config = configOverride ?? (await loadAssistantConfig());
-  const { resolveEffectiveSpeechProviders } =
-    await import("../config/cloud-speech-defaults.js");
-  const { tts: effectiveProviderId } =
-    await resolveEffectiveSpeechProviders(config);
-  const { provider: providerId, providerConfig } = resolveTtsConfig(
-    config,
-    effectiveProviderId,
-  );
+  const { provider: providerId, providerConfig } = resolveTtsConfig(config);
 
   let provider: TtsProvider;
   try {

package/src/plugins/defaults/memory/worker.ts

@@ -60,9 +60,9 @@ async function main(): Promise<void> {
   // standalone process must do it itself so getCloudBaseUrl() resolves to
   // the persisted platform environment instead of the CADET_ENVIRONMENT
   // default. Retrospective and consolidation passes wake real agent
-  // conversations whose inference and background-wake requests go through the
-  // cloud proxy — without rehydration those requests hit the wrong platform
-  // and are rejected.
+  // conversations whose inference requests go through the cloud proxy —
+  // without rehydration those requests hit the wrong platform and are
+  // rejected.
   await ensureCloudIdentityIds();
 
   // Jobs in this process wake real agent conversations, so it registers the

package/src/prompts/persona-resolver.ts

@@ -385,41 +385,6 @@ export function ensureGuardianPersonaFile(userFile: string): void {
   log.debug({ path: filePath }, "Wrote guardian persona scaffold");
 }
 
-/**
- * Return `true` when the persona file at `filePath` has been edited by
- * the user (its stripped content differs from the bare scaffold
- * template). Returns `false` when the file is missing, unreadable,
- * empty after stripping, or byte-identical to the template after
- * stripping comment lines.
- *
- * Used by the vbundle importer to decide whether a legacy
- * `prompts/USER.md` entry may safely overwrite `users/<slug>.md`.
- */
-export function isGuardianPersonaCustomized(filePath: string): boolean {
-  if (!existsSync(filePath)) {
-    return false;
-  }
-
-  let content: string;
-  try {
-    content = readFileSync(filePath, "utf-8");
-  } catch (err) {
-    log.warn(
-      { err, path: filePath },
-      "Failed to read persona file while checking customization",
-    );
-    return false;
-  }
-
-  const stripped = stripCommentLines(content);
-  if (stripped.length === 0) {
-    return false;
-  }
-
-  const templateStripped = stripCommentLines(GUARDIAN_PERSONA_TEMPLATE);
-  return stripped !== templateStripped;
-}
-
 // ── Onboarding section writer ────────────────────────────────────
 
 const ONBOARDING_HEADING = "## Onboarding Context";