@mycadet/assistant 0.12.7 → 0.12.9

package/src/config/schemas/llm.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 import {
-  getManagedUpstream,
+  getCloudUpstream,
   parseCadetModel,
 } from "../../providers/cadet-model-routing.js";
 import {
@@ -18,9 +18,9 @@ import {
   DEFAULT_PROFILE_KEYS,
   DEFAULT_PROFILE_PROVIDERS,
   FALLBACK_PROFILE_BY_KEY,
+  isCloudOnlyProfileKey,
   isDefaultProfileKey,
   isFlagGatedProfileKey,
-  isManagedOnlyProfileKey,
   JEV_MANAGED_PROFILE_CALL_SITES,
   JEV_MANAGED_PROFILE_KEY,
   MANAGED_ONLY_PROFILE_KEYS,
@@ -28,7 +28,7 @@ import {
 import { InputModalitiesSchema } from "../input-modalities.js";
 
 /**
- * Managed-only keys that are valid reference targets on the managed column
+ * Managed-only keys that are valid reference targets on the cloud column
  * whether or not a workspace stub exists. The flag-gated ones (`os-beta`,
  * `auto`) are excluded: they resolve only while their reconciled stub is
  * present, so they enter the reference set through `llm.profiles` alone.
@@ -77,7 +77,7 @@ export const KNOWN_LLM_PROVIDERS = [
   "ionet",
   "poolside",
   "typesafe",
-  // Routing identities: "cadet" = the platform-managed route (upstream
+  // Routing identities: "cadet" = the cloud route (upstream
   // derived from the model at dispatch) and the catalog owner of
   // Cadet-hosted GPU models; "chatgpt" = the subscription route to OpenAI.
   // Dispatch substitutes a concrete upstream before adapter lookup.
@@ -173,8 +173,8 @@ export function routingIdentityModelIssue(
     if (routed) {
       return `Model "${model}" is an encoded routing string; store the native model id "${routed.model}".`;
     }
-    return getManagedUpstream(model) === null
-      ? `Model "${model}" is not served by the Cadet managed route.`
+    return getCloudUpstream(model) === null
+      ? `Model "${model}" is not served by the Cadet Cloud route.`
       : null;
   }
   if (provider === "chatgpt") {
@@ -506,7 +506,7 @@ const OpenRouterDeepPartialSchema = z.object({
 // ---------------------------------------------------------------------------
 
 /**
- * Distinguishes daemon-managed profiles (overwritten on every startup) from
+ * Distinguishes daemon-cloud profiles (overwritten on every startup) from
  * user-created ones (never touched by the daemon).
  */
 const ProfileSource = z.enum(["managed", "user"]);
@@ -617,7 +617,7 @@ export type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
  * (`LLMConfigBase` is the all-defaulted VIEW for resolution, never the
  * storage shape). `provider` stays the loose provider set and is clamped at
  * read time via `isDefaultProviderChoice`: a value with no matrix column
- * (keyless ollama, user-endpoint openai-compatible) resolves to the managed
+ * (keyless ollama, user-endpoint openai-compatible) resolves to the cloud
  * column rather than failing the whole blob.
  */
 export const LLMDefaultConfigSchema = LLMConfigFragment.extend({
@@ -630,7 +630,7 @@ export type LLMDefaultConfig = z.infer<typeof LLMDefaultConfigSchema>;
  * config carries them, for readers that see config.json before the loader's
  * schema parse (boot seed, ensure passes, wire overlays). Each field fails
  * independently so a valid provider survives a bad pin, and a malformed blob
- * reads as empty — both clamp to the managed column downstream via
+ * reads as empty — both clamp to the cloud column downstream via
  * `isDefaultProviderChoice`.
  */
 export const RawDefaultSelectionSchema = z
@@ -710,9 +710,9 @@ export const ProfileEntry = LLMConfigFragment.extend({
   inputModalities: InputModalitiesSchema.nullable().optional(),
   /**
    * Absent means active. `.nullable()` matches `label` so the PUT route's
-   * "send `null` to clear" sentinel works for status too — a managed
+   * "send `null` to clear" sentinel works for status too — a cloud
    * re-enable body of `{status: null}` clears back to active-by-absence
-   * (see `applyManagedProfileReenable`).
+   * (see `applyCloudProfileReenable`).
    */
   status: ProfileStatusSchema.nullable().optional(),
   /**
@@ -727,13 +727,13 @@ export const ProfileEntry = LLMConfigFragment.extend({
    */
   mix: MixSchema.optional(),
   /**
-   * Code-owned backup profile for a Cadet-managed default profile. This is
+   * Code-owned backup profile for a Cadet Cloud default profile. This is
    * read-only metadata from the default-profile catalog. Config write paths
    * reject user-authored values because custom and BYOK fallback routes are
    * not supported.
    */
   fallbackProfile: z.string().min(1).optional().meta({ readOnly: true }),
-});
+}).meta({ id: "ProfileEntry" });
 export type ProfileEntry = z.infer<typeof ProfileEntry>;
 
 /**
@@ -771,10 +771,10 @@ export type DefaultProviderConfig = {
 };
 
 /**
- * Whether the managed backup profiles (`BACKUP_PROFILE_KEYS`) resolve under a
+ * Whether the cloud backup profiles (`BACKUP_PROFILE_KEYS`) resolve under a
  * given `llm.default` blob.
  *
- * Backups are companions of the managed (`cadet`) column only: on a BYOK or
+ * Backups are companions of the cloud (`cadet`) column only: on a BYOK or
  * ChatGPT default provider `defaultProfileBodyForProvider` returns `undefined`
  * for them, because the install may hold no credential for the backup's
  * upstream. So a reference to one is a target that can never resolve there,
@@ -782,7 +782,7 @@ export type DefaultProviderConfig = {
  * cannot show.
  *
  * A missing blob or a `provider` with no matrix column (keyless ollama,
- * user-endpoint openai-compatible) clamps to the managed column via
+ * user-endpoint openai-compatible) clamps to the cloud column via
  * `isDefaultProviderChoice`, so backups resolve there too.
  */
 export function backupProfilesResolveUnderDefaultProvider(
@@ -799,35 +799,35 @@ export function backupProfilesResolveUnderDefaultProvider(
  * Why a referenced profile name does not resolve, for the reference error
  * messages. A backup key under a non-managed default provider gets its own
  * reason: the name is real and code-defined, it just has no body outside the
- * managed column, and "not defined in llm.profiles" would send the reader
+ * cloud column, and "not defined in llm.profiles" would send the reader
  * looking for a missing entry that was never supposed to exist.
  */
 function unresolvableProfileReason(
   name: string,
   backupsResolve: boolean,
 ): string {
-  if (backupsResolve || !isManagedOnlyProfileKey(name)) {
+  if (backupsResolve || !isCloudOnlyProfileKey(name)) {
     return "is not defined in llm.profiles";
   }
   if (name === JEV_MANAGED_PROFILE_KEY) {
-    return "is the managed Jev profile, which resolves only while llm.default is the managed provider";
+    return "is the cloud Jev profile, which resolves only while llm.default is the cloud provider";
   }
   if (name === AUTO_PROFILE_KEY) {
-    return "is the managed Auto profile, which resolves only while llm.default is the managed provider";
+    return "is the cloud Auto profile, which resolves only while llm.default is the cloud provider";
   }
-  return "is a managed backup profile, which resolves only while llm.default is the managed provider";
+  return "is a cloud backup profile, which resolves only while llm.default is the cloud provider";
 }
 
 /**
  * The `llm.profiles` keys that are reference targets in their own right,
- * given whether the managed backups resolve under the current
+ * given whether the cloud backups resolve under the current
  * `llm.default`.
  *
  * Every on-disk key qualifies but one: a reserved backup name whose entry is
  * a thin `source: "managed"` stub. The stub is not a profile, it is the
- * workspace's slot for a code-owned one, and it can reach disk on a managed
+ * workspace's slot for a code-owned one, and it can reach disk on a cloud
  * install through nothing more than a `config get` -> `config set` round-trip
- * of the effective profile list (`normalizeManagedProfileWrites` reduces the
+ * of the effective profile list (`normalizeCloudProfileWrites` reduces the
  * echoed body to exactly that stub). Counting it as an ordinary raw key would
  * let it launder a backup reference past the provider gate: after a switch to
  * a BYOK or ChatGPT default provider the reference would keep validating
@@ -846,7 +846,7 @@ function referenceableProfileKeys(
 ): string[] {
   return Object.entries(profiles ?? {})
     .filter(([name, value]) => {
-      if (backupsResolve || !isManagedOnlyProfileKey(name)) {
+      if (backupsResolve || !isCloudOnlyProfileKey(name)) {
         return true;
       }
       const entry =
@@ -874,8 +874,8 @@ function referenceableProfileKeys(
  * are read defensively so the raw on-disk shape is safe to pass.
  *
  * `llmDefault` is the sibling `llm.default` value (raw or parsed): it
- * decides whether the managed backups are valid targets, since they resolve
- * on the managed column alone.
+ * decides whether the cloud backups are valid targets, since they resolve
+ * on the cloud column alone.
  */
 export function collectFallbackProfileIssues(
   profiles: Record<string, unknown> | undefined,
@@ -891,8 +891,8 @@ export function collectFallbackProfileIssues(
   // (`default-profile-catalog.ts`) and resolve whether or not they are
   // materialized in `llm.profiles`, so their names are always valid
   // fallback targets (same rule as call-site `profile` references). The
-  // managed backups resolve the same way, but on the managed column only,
-  // so they are valid targets only under a managed `llm.default`.
+  // managed backups resolve the same way, but on the cloud column only,
+  // so they are valid targets only under a cloud `llm.default`.
   // A persisted managed stub for a backup name does not change that, see
   // `referenceableProfileKeys`.
   const backupsResolve = backupProfilesResolveUnderDefaultProvider(
@@ -930,7 +930,7 @@ export function collectFallbackProfileIssues(
     if (entry?.source !== "managed" || fallback !== expectedFallback) {
       issues.push({
         profileName: name,
-        message: `Profile "${name}" cannot configure fallbackProfile. Automatic fallbacks are code-owned for Cadet-managed default profiles.`,
+        message: `Profile "${name}" cannot configure fallbackProfile. Automatic fallbacks are code-owned for Cadet Cloud default profiles.`,
       });
       continue;
     }
@@ -1049,20 +1049,20 @@ export const LLMSchema = z
     // The always-available default profiles are code-defined
     // (`default-profile-catalog.ts`) and resolve whether or not they are
     // materialized in `llm.profiles`, so their names are always valid
-    // reference targets. The managed backups (`BACKUP_PROFILE_KEYS`) are
+    // reference targets. The cloud backups (`BACKUP_PROFILE_KEYS`) are
     // code-defined on the same terms and are listed in the effective
     // catalog, so a selection naming one (`activeProfile`, `advisorProfile`,
     // a call-site pin) must survive the next load rather than being stripped
-    // back to a default. Backups are scoped to the managed column though, so
-    // they join the set only under a managed `llm.default`: on a BYOK
+    // back to a default. Backups are scoped to the cloud column though, so
+    // they join the set only under a cloud `llm.default`: on a BYOK
     // or ChatGPT default provider they have no body to resolve to, and
     // keeping the reference would strand a selection the picker cannot show.
-    // The managed Jev profile (`JEV_MANAGED_PROFILE_KEY`) is scoped the same
+    // The cloud Jev profile (`JEV_MANAGED_PROFILE_KEY`) is scoped the same
     // way, as a pin target for the judge call sites.
     // The flag-gated `os-beta` is excluded: it resolves only while a
     // workspace entry exists, so a reference to it is valid only when that
     // entry is present in `config.profiles`. A backup name materialized as a
-    // thin managed stub does not re-enter the set on a non-managed column
+    // thin managed stub does not re-enter the set on a non-cloud column
     // either, see `referenceableProfileKeys`.
     const backupsResolve = backupProfilesResolveUnderDefaultProvider(
       config.default,
@@ -1121,7 +1121,7 @@ export const LLMSchema = z
         message: `Profile "${config.advisorProfile}" referenced by llm.advisorProfile ${unresolvableProfileReason(config.advisorProfile, backupsResolve)}`,
       });
     }
-    // The managed Jev profile is a valid reference target for call-site pins
+    // The cloud Jev profile is a valid reference target for call-site pins
     // only. Its model returns structured verdicts rather than chat text, so
     // the conversation positions reject it here as well as at the write
     // routes, which keeps a raw config write from handing the main agent or

package/src/config/schemas/memory-lifecycle.ts

@@ -41,6 +41,14 @@ const MemoryJobsConfigInputSchema = z.object({
     ),
 });
 
+const MemoryJobsConfigOutputSchema = z.object({
+  workerConcurrency: positiveInt("workerConcurrency"),
+  stalledJobTimeoutMs: positiveInt("stalledJobTimeoutMs"),
+  slowLlmConcurrency: positiveInt("slowLlmConcurrency"),
+  fastConcurrency: positiveInt("fastConcurrency"),
+  embedConcurrency: positiveInt("embedConcurrency"),
+});
+
 export const MemoryJobsConfigSchema = MemoryJobsConfigInputSchema.transform(
   (input) => {
     // When `workerConcurrency` is explicitly set but lane caps are not,
@@ -76,7 +84,9 @@ export const MemoryJobsConfigSchema = MemoryJobsConfigInputSchema.transform(
       embedConcurrency,
     };
   },
-).describe("Memory background job processing configuration");
+)
+  .pipe(MemoryJobsConfigOutputSchema)
+  .describe("Memory background job processing configuration");
 
 export const MemoryRetentionConfigSchema = z
   .object({

package/src/config/schemas/services.ts

@@ -20,7 +20,7 @@ export const VALID_INFERENCE_PROVIDERS = [
   "openrouter",
 ] as const;
 
-// `cadet` generates through the platform runtime proxy; the backend
+// `cadet` generates through the cloud runtime proxy; the backend
 // (gemini/openai) derives from the selected model's prefix at request time.
 const VALID_IMAGE_GEN_PROVIDERS = [
   "cadet",
@@ -60,7 +60,7 @@ const InferenceServiceSchema = z.object({});
 
 /**
  * Image generation carries no `mode`: `provider` is the only axis. `"cadet"`
- * generates through the platform runtime proxy for the model-appropriate
+ * generates through the cloud runtime proxy for the model-appropriate
  * backend, billed to Cadet credits; `"gemini"`/`"openai"`/`"openrouter"`
  * use the user's key. A `mode` key sent by an older client is stripped at
  * parse.
@@ -74,7 +74,7 @@ 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 platform
+ * 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.
  */
@@ -90,7 +90,7 @@ const WebSearchServiceSchema = z.object({
 });
 
 /**
- * Web-fetch carries no `mode`: there is no managed proxy for it, so the only
+ * Web-fetch carries no `mode`: there is no cloud proxy for it, so the only
  * axis is which provider backs the tool.
  */
 const WebFetchServiceSchema = z.object({

package/src/config/schemas/stt.ts

@@ -183,7 +183,7 @@ export { STT_ROLE_REQUIREMENTS, STT_ROLES, type SttRole };
 /**
  * Canonical STT service configuration.
  *
- * `provider` is the only axis: `"cadet"` transcribes through the platform,
+ * `provider` is the only axis: `"cadet"` transcribes through the cloud,
  * billed to Cadet credits; any other provider uses the user's own API key.
  */
 export const SttServiceSchema = z
@@ -204,7 +204,7 @@ export const SttServiceSchema = z
       .describe("Active STT provider used for speech-to-text transcription"),
     /**
      * Spoken-language selection, forwarded to providers whose adapters accept
-     * a language (Deepgram, xAI, and the managed relay).
+     * a language (Deepgram, xAI, and the cloud relay).
      *
      * `"multi"` selects Deepgram's nova-3 code-switching mode, which follows
      * a speaker moving between languages inside a single utterance (e.g.
@@ -220,7 +220,7 @@ export const SttServiceSchema = z
      * The default applies on load, not just at creation, so an existing
      * config that never set a language materializes `"multi"` on its next
      * start. That changes no behavior: `effectiveSttLanguage` already
-     * resolved unset to `"multi"` on Deepgram and the managed relay, and the
+     * resolved unset to `"multi"` on Deepgram and the cloud relay, and the
      * providers that detect natively ignore the field either way. It only
      * makes the value explicit. An assistant that has chosen a language
      * keeps it, since a default fills nothing that is already set.

package/src/config/schemas/tts.ts

@@ -52,6 +52,7 @@ function languageVoicesSchema(providerId: string, valuesDescription: string) {
       }
       return Object.fromEntries(normalized);
     })
+    .pipe(z.record(z.string(), z.string()))
     .optional()
     .describe(
       "Per-language voice overrides for live voice. Keys are normalized on " +
@@ -70,6 +71,7 @@ export const TtsElevenLabsProviderConfigSchema = z
       })
       .transform((v) => v || DEFAULT_ELEVENLABS_VOICE_ID)
       .default(DEFAULT_ELEVENLABS_VOICE_ID)
+      .pipe(z.string())
       .describe("ElevenLabs voice ID for text-to-speech"),
     voiceModelId: z
       .string({
@@ -194,6 +196,7 @@ export const TtsDeepgramProviderConfigSchema = z
       })
       .transform((v) => v || "aura-asteria-en")
       .default("aura-asteria-en")
+      .pipe(z.string())
       .describe("Deepgram TTS model identifier"),
     format: z
       .enum(["mp3", "wav", "opus"], {
@@ -221,6 +224,7 @@ export const TtsXaiProviderConfigSchema = z
       })
       .transform((v) => v || "eve")
       .default("eve")
+      .pipe(z.string())
       .describe(
         "xAI voice ID — one of: eve, ara, rex, sal, leo (case-insensitive)",
       ),
@@ -230,6 +234,7 @@ export const TtsXaiProviderConfigSchema = z
       })
       .transform((v) => v || "auto")
       .default("auto")
+      .pipe(z.string())
       .describe(
         "BCP-47 language code (e.g. 'en-US') or 'auto' for auto-detection",
       ),
@@ -267,7 +272,7 @@ export const TtsXaiProviderConfigSchema = z
 export type TtsXaiProviderConfig = z.infer<typeof TtsXaiProviderConfigSchema>;
 
 /**
- * Cadet managed provider configuration under `services.tts.providers`.
+ * Cadet Cloud provider configuration under `services.tts.providers`.
  */
 const TtsCadetProviderConfigSchema = z
   .object({
@@ -275,17 +280,17 @@ const TtsCadetProviderConfigSchema = z
       .string()
       .optional()
       .describe(
-        "Managed TTS voice model (e.g. aura-2-thalia-en). Unset means the platform's default voice. The platform rejects voices it does not offer.",
+        "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 platform rate card: an unpriced model is " +
+        "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 managed provider configuration under services.tts");
+  .describe("Cadet Cloud provider configuration under services.tts");
 
 export type TtsCadetProviderConfig = z.infer<
   typeof TtsCadetProviderConfigSchema
@@ -339,7 +344,7 @@ for (const id of schemaKeys) {
 /**
  * Canonical TTS service configuration.
  *
- * `provider` is the only axis: `"cadet"` synthesizes through the platform,
+ * `provider` is the only axis: `"cadet"` synthesizes through the cloud,
  * billed to Cadet credits; any other provider uses the user's own API key.
  */
 export const TtsServiceSchema = z

package/src/config/schemas/voice.ts

@@ -103,7 +103,7 @@ export const VoiceFrontModelConfigSchema = z
       )
       .default(1200)
       .describe(
-        "Hard budget (ms) for the endpoint decision LLM call. This adds to end-of-turn latency when semantic endpointing is on, so keep it as tight as the decider model's real roundtrip allows. Measured Haiku roundtrips through the managed proxy run ~670-1130ms (dev), so tighter budgets turn the feature into a fail-open no-op.",
+        "Hard budget (ms) for the endpoint decision LLM call. This adds to end-of-turn latency when semantic endpointing is on, so keep it as tight as the decider model's real roundtrip allows. Measured Haiku roundtrips through the cloud proxy run ~670-1130ms (dev), so tighter budgets turn the feature into a fail-open no-op.",
       ),
     endpointExtensionMs: z
       .number({

package/src/config/seed-inference-profiles.ts

@@ -1,5 +1,5 @@
 import type { DrizzleDb } from "../persistence/db-connection.js";
-import { CADET_MANAGED_PROVIDER } from "../providers/cadet-model-routing.js";
+import { CADET_CLOUD_PROVIDER } from "../providers/cadet-model-routing.js";
 import { PROVIDERS_REQUIRING_BASE_URL_AND_MODELS } from "../providers/inference/auth.js";
 import {
   createConnection,
@@ -14,6 +14,7 @@ import {
   MANAGED_PROFILE_NAMES,
   MANAGED_PROFILE_TEMPLATES,
 } from "./default-profile-catalog.js";
+import { getIsCloud } from "./env-registry.js";
 import { loadConfig, loadRawConfig, saveRawConfig } from "./loader.js";
 import { isDispatchableProfile } from "./profile-dispatchability.js";
 import {
@@ -48,12 +49,12 @@ export type SeedInferenceProfilesOptions = {
  *    `<provider>-personal` connection backed by the user's API key in CES.
  *    The BYOK columns of the intent × provider matrix stamp exactly that
  *    connection name (via `resolveDefaultConnectionName`), so the default
- *    profiles dispatch through it. Skipped for the managed provider — the
+ *    profiles dispatch through it. Skipped for the cloud provider — the
  *    `cadet` column routes through the canonical platform-backed row, never
  *    a user key, so no `cadet-personal` connection exists or is needed.
  *
  * 2. **`llm.default`**: the base blob's `provider` field is written once at
- *    hatch time, mirroring the platform/managed/BYOK decision, and never
+ *    hatch time, mirroring the cloud/managed/BYOK decision, and never
  *    overwritten afterward. The default profiles resolve through this
  *    provider's matrix column.
  *
@@ -67,10 +68,9 @@ export function seedInferenceProfiles(
   const llm = config.llm;
   const profiles = llm.profiles;
 
-  const isPlatform =
-    process.env.IS_PLATFORM === "true" || process.env.IS_PLATFORM === "1";
+  const isCloud = getIsCloud();
 
-  // A hatch overlay that explicitly selected a managed connection routes the
+  // A hatch overlay that explicitly selected a cloud connection routes the
   // default provider through cadet rather than the entered BYOK key.
   const hatchSelectedManagedConnection = didHatchSelectManagedConnection(
     llm,
@@ -78,18 +78,18 @@ export function seedInferenceProfiles(
     options,
   );
 
-  // 1. Personal provider connection: only at hatch time for off-platform
+  // 1. Personal provider connection: only at hatch time for off-cloud
   //    installations, backed by the user's API key in CES. The BYOK columns
   //    of the intent × provider matrix stamp `<provider>-personal` (via
   //    `resolveDefaultConnectionName`), so the connection must exist for the
   //    default profiles to dispatch.
   let usableHatchProvider: string | undefined;
-  if (options.isHatch && !isPlatform) {
+  if (options.isHatch && !isCloud) {
     // The hatch overlay writes `llm.default.provider` directly.
     const hatchProvider = llm.default?.provider;
     if (
       hatchProvider &&
-      hatchProvider !== CADET_MANAGED_PROVIDER &&
+      hatchProvider !== CADET_CLOUD_PROVIDER &&
       hatchProvider !== "ollama" &&
       !PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(hatchProvider)
     ) {
@@ -138,7 +138,7 @@ export function seedInferenceProfiles(
     llm.default = {
       ...blob,
       provider: resolveHatchDefaultProvider(
-        isPlatform,
+        isCloud,
         hatchSelectedManagedConnection,
         usableHatchProvider,
       ),
@@ -150,8 +150,8 @@ export function seedInferenceProfiles(
   // Profile lookups below go through the effective view: a default profile
   // resolves from the code catalog whether or not the workspace carries a
   // stub for it, and a stub contributes only its status/label overlays.
-  // Resolved against `llm.default` so the managed backups count as
-  // available only on the managed column, matching what the schema accepts
+  // Resolved against `llm.default` so the cloud backups count as
+  // available only on the cloud column, matching what the schema accepts
   // as a reference: an `activeProfile` naming a backup on a BYOK install
   // fails the typed load's leaf recovery, reads here as no selection, and
   // is repaired to `balanced` below.
@@ -186,7 +186,7 @@ export function seedInferenceProfiles(
     requestedAdvisorProfile === undefined ||
     requestedAdvisorIsDisabledManaged
   ) {
-    const defaultAdvisorProfile = firstActiveManagedProfile(effectiveProfiles, [
+    const defaultAdvisorProfile = firstActiveCloudProfile(effectiveProfiles, [
       "quality-optimized",
       "balanced",
       "cost-optimized",
@@ -201,7 +201,7 @@ export function seedInferenceProfiles(
   // Profile ordering: ensure all seeded profiles appear in the order array.
   // A managed key absent from a workspace's order is placed next to the
   // sibling that precedes it in the catalog rather than appended, so the
-  // managed profiles stay grouped in catalog order even on a workspace whose
+  // cloud profiles stay grouped in catalog order even on a workspace whose
   // order already lists custom profiles. Entries already in the order keep
   // their relative positions, so a user arrangement survives.
   const profileOrder = [...llm.profileOrder];
@@ -246,13 +246,13 @@ export function readObject(value: unknown): Record<string, unknown> | null {
 }
 
 function resolveHatchDefaultProvider(
-  isPlatform: boolean,
+  isCloud: boolean,
   selectedManagedConnection: boolean,
   hatchProvider: string | undefined,
 ): string {
   // Platform mode and an explicit managed-connection selection both route
   // through cadet.
-  if (isPlatform || selectedManagedConnection) {
+  if (isCloud || selectedManagedConnection) {
     return "cadet";
   }
   if (hatchProvider !== undefined && isDefaultProviderChoice(hatchProvider)) {
@@ -331,7 +331,7 @@ function pruneRemovedProfileReferences(
   }
 }
 
-function firstActiveManagedProfile(
+function firstActiveCloudProfile(
   profiles: Record<string, ProfileEntry>,
   names: string[],
 ): string | undefined {
@@ -363,8 +363,8 @@ function didHatchSelectManagedConnection(
     return MANAGED_CONNECTION_NAMES.has(explicitConnection);
   }
 
-  // A default-profile name with no explicit connection selects the managed
-  // route: the cadet column IS the managed column, and its profiles route
+  // A default-profile name with no explicit connection selects the cloud
+  // route: the cadet column IS the cloud column, and its profiles route
   // through the canonical cadet row.
   return MANAGED_PROFILE_TEMPLATES[activeProfile] !== undefined;
 }

package/src/config/skill-state.ts

@@ -1,4 +1,4 @@
-import { isSkillCompatibleWithPlatform } from "../skills/platform-compatibility.js";
+import { isSkillCompatibleWithCloud } from "../skills/cloud-compatibility.js";
 import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
 import type { AssistantConfig, SkillEntryConfig } from "./schema.js";
 import type { SkillSummary } from "./skills.js";
@@ -32,7 +32,7 @@ export function resolveSkillStates(
   };
 
   for (const skill of catalog) {
-    if (!isSkillCompatibleWithPlatform(skill)) {
+    if (!isSkillCompatibleWithCloud(skill)) {
       continue;
     }
 

package/src/config/skills.ts

@@ -21,14 +21,14 @@ import { z } from "zod";
 import type { ClientOs } from "../channels/types.js";
 import { getDefaultPluginSkillRoots } from "../plugins/defaults/main.js";
 import { isPluginDisabled } from "../plugins/disabled-state.js";
-import { parseFrontmatterFields } from "../skills/frontmatter.js";
-import type { InlineCommandExpansion } from "../skills/inline-command-expansions.js";
-import { parseInlineCommandExpansions } from "../skills/inline-command-expansions.js";
 import {
   normalizeSkillPlatforms,
   SKILL_PLATFORM_VALUES,
   type SkillPlatform,
-} from "../skills/platform-compatibility.js";
+} from "../skills/cloud-compatibility.js";
+import { parseFrontmatterFields } from "../skills/frontmatter.js";
+import type { InlineCommandExpansion } from "../skills/inline-command-expansions.js";
+import { parseInlineCommandExpansions } from "../skills/inline-command-expansions.js";
 import { parseToolManifestFile } from "../skills/tool-manifest.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
 import type { OwnerInfo } from "../tools/types.js";

package/src/config/substrate-twin-shadowing.ts

@@ -2,6 +2,8 @@
 // Memory substrate — twin-namespace shadowing detection
 // ---------------------------------------------------------------------------
 
+import { getConfig } from "./loader.js";
+
 /** One `memory.v2` tunable's `memory.substrate` twin. */
 interface SubstrateTwin {
   /** The twin's `memory.substrate` key, e.g. `spread_k` for `k`. */
@@ -93,29 +95,22 @@ export type SubstrateShadowing = {
   alsoReadByV2Engine: boolean;
 };
 
-function readPlainObject(value: unknown): Record<string, unknown> | undefined {
-  return value != null && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : undefined;
-}
-
 /**
  * The `memory.substrate` twin covering `path`, or `undefined` when `path` is
  * not a shadowable `memory.v2` tunable or its twin is unset.
  *
  * `memory.substrate` is override-only and wins for substrate recall whenever
- * its key is present — including when it holds an explicit `null`, which
- * `resolveSubstrateTuning` treats as present. Detection therefore keys on
- * presence, not truthiness. What that means for the `memory.v2` key depends on
- * `alsoReadByV2Engine`: for a substrate-only twin the `memory.v2` value has no
- * remaining consumer, while for the three engine-read twins it still tunes v2
- * injection.
+ * its key is set. Detection keys on presence in the RUNNING config — the same
+ * typed view `resolveSubstrateTuning` consults, so the check can never
+ * disagree with runtime precedence: a key absent from the parsed config is
+ * absent for the resolver too.
  *
- * `raw` is the unparsed config object (`loadRawConfig()` / the `config_get`
- * payload), so the check sees exactly what is persisted.
+ * What a set twin means for the `memory.v2` key depends on
+ * {@link SubstrateTwin.alsoReadByV2Engine}: for a substrate-only twin the
+ * `memory.v2` value has no remaining consumer, while for the three
+ * engine-read twins it still tunes v2 injection.
  */
 export function findSubstrateShadowing(
-  raw: Record<string, unknown>,
   path: string,
 ): SubstrateShadowing | undefined {
   const segments = path.split(".");
@@ -130,8 +125,8 @@ export function findSubstrateShadowing(
   if (twin === undefined) {
     return undefined;
   }
-  const substrate = readPlainObject(readPlainObject(raw.memory)?.substrate);
-  if (!substrate || !(twin.substrateKey in substrate)) {
+  const substrate: Record<string, unknown> = getConfig().memory.substrate;
+  if (!(twin.substrateKey in substrate)) {
     return undefined;
   }
   return {