@mycadet/assistant 0.12.7 → 0.12.8

package/src/plugins/defaults/memory/substrate/boot-maintenance.ts

@@ -58,10 +58,10 @@ export function maybeSeedCliCommandCards(config: AssistantConfig): void {
 
 /**
  * Default upper bound on how long
- * {@link maybeReseedCapabilitiesAfterManagedCredential} waits for the capability
+ * {@link maybeReseedCapabilitiesAfterCloudCredential} waits for the capability
  * reseeds before enqueuing the v3 maintain pass. The reseeds keep running
  * detached past this bound — it only stops the barrier from waiting on a wedged
- * catalog (a stalled `getCatalog()` or a managed-proxy embed that never
+ * catalog (a stalled `getCatalog()` or a cloud-proxy embed that never
  * returns). A straggler that finishes later re-enqueues maintain.
  */
 const RESEED_BARRIER_TIMEOUT_MS = 120_000;
@@ -89,13 +89,13 @@ async function settledWithin(
 }
 
 /**
- * Re-seed the v2 skill and CLI-command capability entries once a managed-proxy
+ * Re-seed the v2 skill and CLI-command capability entries once a cloud-proxy
  * credential lands, closing the first-boot race where the daemon's startup seed
- * runs before the platform has provisioned the managed embedding credential.
+ * runs before the cloud has provisioned the cloud embedding credential.
  *
- * On a brand-new managed assistant the memory worker fires the startup seed
+ * On a brand-new cloud assistant the memory worker fires the startup seed
  * (`maybeSeedCapabilitySkills` / `maybeSeedCliCommandCards`) seconds after
- * boot, but the platform pushes `cadet:assistant_api_key` (the credential the
+ * boot, but the cloud pushes `cadet:assistant_api_key` (the credential the
  * managed Gemini embedding backend needs) tens of seconds later. The seed's
  * `embedWithBackend` call throws `EmbeddingBackendUnavailableError` before the
  * skill/CLI `entries` cache is replaced, so `listSkillEntries()` /
@@ -105,7 +105,7 @@ async function settledWithin(
  * the next daemon restart. Re-running the seed when the credential arrives
  * restores the capability pages without a restart.
  *
- * Gated on the managed-proxy prerequisites now being satisfied (both the
+ * Gated on the cloud-proxy prerequisites now being satisfied (both the
  * platform base URL and the assistant API key present) so a non-managed
  * credential write — or a partial update that has not yet completed the pair —
  * does not kick a doomed embed. Idempotent: `seedV2SkillEntries` /
@@ -125,7 +125,7 @@ async function settledWithin(
  *
  * The maintain enqueue must NOT be gated on both catalogs settling. The two
  * embeds are independent, and a single wedged catalog (a stalled `getCatalog()`
- * or a managed-proxy embed that never returns) would otherwise block the v3 lane
+ * or a cloud-proxy embed that never returns) would otherwise block the v3 lane
  * rebuild indefinitely, so the catalog that DID seed never reaches the selector.
  * The barrier is therefore bounded by `reseedTimeoutMs`: maintain is enqueued
  * once the barrier resolves (the pass is idempotent and reconciles whatever the
@@ -136,7 +136,7 @@ async function settledWithin(
  * `reseedTimeoutMs` is injectable for tests; production uses
  * {@link RESEED_BARRIER_TIMEOUT_MS}.
  */
-export async function maybeReseedCapabilitiesAfterManagedCredential(
+export async function maybeReseedCapabilitiesAfterCloudCredential(
   config: AssistantConfig,
   opts: { reseedTimeoutMs?: number } = {},
 ): Promise<void> {
@@ -144,13 +144,13 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
     return;
   }
 
-  const { hasManagedProxyPrereqs } =
-    await import("../../../../providers/platform-proxy/context.js");
-  if (!(await hasManagedProxyPrereqs())) {
+  const { hasCloudProxyPrereqs } =
+    await import("../../../../providers/cloud-proxy/context.js");
+  if (!(await hasCloudProxyPrereqs())) {
     return;
   }
 
-  // The managed credential has just landed, so the embedding backend is now
+  // The cloud credential has just landed, so the embedding backend is now
   // reachable. Retry the embedding-identity reconcile to close the
   // fresh-platform-install-booted-with-Gemini-down case: the first boot defers
   // (degraded) because the backend probe returns null, and this credential-
@@ -168,7 +168,7 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
   } catch (err) {
     log.warn(
       { err },
-      "Embedding-identity reconcile after managed proxy credential update threw — continuing",
+      "Embedding-identity reconcile after cloud proxy credential update threw — continuing",
     );
   }
 
@@ -200,12 +200,12 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
     seed().then(
       () =>
         log.info(
-          `Memory v2 ${label} entries seeded after managed proxy credential update`,
+          `Memory v2 ${label} entries seeded after cloud proxy credential update`,
         ),
       (err: unknown) =>
         log.warn(
           { err },
-          `Failed to seed v2 ${label} entries after managed proxy credential update`,
+          `Failed to seed v2 ${label} entries after cloud proxy credential update`,
         ),
     ),
   );
@@ -229,7 +229,7 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
     } catch (err) {
       log.warn(
         { err },
-        "Failed to enqueue memory_v3_maintain after managed proxy credential update",
+        "Failed to enqueue memory_v3_maintain after cloud proxy credential update",
       );
     }
   };

package/src/plugins/defaults/memory/substrate/cli-command-store.ts

@@ -159,12 +159,12 @@ async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
 
     // Sparse (BM25/TF) encoding is computed locally; only the dense vectors
     // require `embedWithBackend`, which is unconfigured during the cold-start
-    // window before a managed-proxy embedding credential is provisioned. A
+    // window before a cloud-proxy embedding credential is provisioned. A
     // dense-embed failure is non-fatal to the in-memory cache: the v3 needle
     // finder lane reads CLI capabilities from `entries` / the page index, NOT
     // from Qdrant, so the cache is populated from the local Commander tree
     // regardless of backend state and commands stay discoverable from first
-    // boot. Only the dense Qdrant upsert is skipped; the managed-credential
+    // boot. Only the dense Qdrant upsert is skipped; the cloud-credential
     // reseed and the v3 maintain pass backfill the dense vectors on recovery.
     const nextEntries = new Map<string, CliCommandEntry>();
     let denseVectors: number[][] = [];

package/src/plugins/defaults/memory/substrate/prompts/consolidation.ts

@@ -1182,7 +1182,7 @@ export function renderConsolidationPrompt(
  * page index's reports, `{{OVERLONG_SECTIONS_SECTION}}` from the v3 section
  * scan, and the legacy `{{PROC_TO_SKILLS_SECTION}}` always
  * stripped to empty, so a prompt copied from any past bundled source never
- * leaks a raw placeholder, and a customized prompt can opt into the managed
+ * leaks a raw placeholder, and a customized prompt can opt into the cloud
  * sections.
  *
  * The buffer entries and the repair sections do not wait for opt-in: an

package/src/plugins/defaults/memory/substrate/skill-store.ts

@@ -323,14 +323,14 @@ async function runSeedV2SkillEntries(generation: number): Promise<void> {
     // Build the dense + sparse vectors for the Qdrant write. Sparse (BM25/TF)
     // encoding is computed locally and needs no backend; only the dense vectors
     // require `embedWithBackend`, which is unconfigured during the cold-start
-    // window before a managed-proxy embedding credential is provisioned.
+    // window before a cloud-proxy embedding credential is provisioned.
     //
     // A dense-embed failure is non-fatal to the in-memory cache: the v3 needle
     // finder lane and always-candidate skill pinning read skills from `entries`
     // / the page index, NOT from Qdrant, so the cache is populated from the
     // local catalog regardless of backend state and skills stay discoverable
-    // from first boot. Only the dense Qdrant upsert is skipped; the managed-
-    // credential reseed (`maybeReseedCapabilitiesAfterManagedCredential`) and
+    // from first boot. Only the dense Qdrant upsert is skipped; the cloud-
+    // credential reseed (`maybeReseedCapabilitiesAfterCloudCredential`) and
     // the v3 maintain pass backfill the dense vectors once the backend recovers.
     const nextEntries = new Map<string, SkillEntry>();
     let denseVectors: number[][] = [];
@@ -461,7 +461,7 @@ async function runSeedV2SkillEntries(generation: number): Promise<void> {
     fallbackAlwaysCandidateIds = new Set<string>();
     invalidatePageIndex();
 
-    // Surface a dense-embed failure to `throwOnError` callers (the managed-
+    // Surface a dense-embed failure to `throwOnError` callers (the cloud-
     // credential reseed and the operator reembed route) so the existing retry +
     // maintain machinery backfills the dense lane. The in-memory cache is
     // already updated above, so the needle lane is fixed regardless.

package/src/plugins/defaults/memory/v3/__tests__/maintain-job.test.ts

@@ -125,7 +125,7 @@ describe("maintainJob", () => {
       },
       // Skill usage-prune stage off by default: no managed skills ⇒ nothing to
       // report or delete. The dedicated usage-prune tests below override these.
-      listManagedSkills: () => [],
+      listCloudSkills: () => [],
       deleteSkill: async () => {},
       nowMs: () => Date.now(),
     };
@@ -1202,7 +1202,7 @@ describe("maintainJob skill usage-prune", () => {
       listIndexedSlugs: async () => [],
       loadCoreSet: () => [],
       invalidateLanes: () => {},
-      listManagedSkills: () =>
+      listCloudSkills: () =>
         skills.map((s) => ({ ...s, installMeta: metas[s.id] ?? null })),
       deleteSkill: async (id) => {
         deletedSkills.push(id);
@@ -1259,7 +1259,7 @@ describe("maintainJob skill usage-prune", () => {
     });
   });
 
-  describe("enabled (skillPruneDays: 30) — deletes via executeDeleteManagedSkill", () => {
+  describe("enabled (skillPruneDays: 30) — deletes via executeDeleteCloudSkill", () => {
     test("prunes a stale assistant skill via deleteSkill", async () => {
       memoryV3LiveSlot = true;
       const {

package/src/plugins/defaults/memory/v3/__tests__/pool-select.test.ts

@@ -89,7 +89,7 @@ mock.module("@mycadet/plugin-api", () => ({
 mock.module("../../../../../providers/registry.js", () => ({
   ...registryReal,
   getProviderRoutingSource: (providerName: string) =>
-    providerName === "managed" ? "managed-proxy" : "user-key",
+    providerName === "managed" ? "cloud-proxy" : "user-key",
 }));
 
 mock.module("../../../../../util/logger.js", () => ({
@@ -536,7 +536,7 @@ describe("selectPool — infrastructure failures throw", () => {
     expect(failure.turn?.recentContext).toBe("");
   });
 
-  test("managed provider 402 attaches a non-terminal credits notice", async () => {
+  test("cloud provider 402 attaches a non-terminal credits notice", async () => {
     providerStub = {
       name: "managed",
       sendMessage: async (messages, options) => {

package/src/plugins/defaults/memory/v3/maintain-job.ts

@@ -57,7 +57,7 @@
  *   5. **Skill usage-prune (observe-first, default-off)** — REPORT
  *      assistant-authored managed skills unused for at least
  *      {@link SKILL_OBSERVE_WINDOW_DAYS} days (in `prunableSkills`) on every
- *      pass for observability, and DELETE them (via `executeDeleteManagedSkill`)
+ *      pass for observability, and DELETE them (via `executeDeleteCloudSkill`)
  *      only when `memory.maintenance.skillPruneDays` is a positive integer
  *      (default `null` = never prune). `author:"user"` and untagged skills are
  *      always protected. See {@link pruneStaleSkills}.
@@ -89,7 +89,7 @@ import { getMemoryCheckpoint } from "../../../../persistence/checkpoints.js";
 import { EmbeddingBackendUnavailableError } from "../../../../persistence/embeddings/embedding-backend.js";
 import { EmbeddingBillingBlockError } from "../../../../persistence/embeddings/embedding-billing-breaker.js";
 import type { MemoryJob } from "../../../../persistence/jobs-store.js";
-import { executeDeleteManagedSkill } from "../../../../tools/skills/delete-managed.js";
+import { executeDeleteCloudSkill } from "../../../../tools/skills/delete-cloud.js";
 import { embedWithBackend } from "../embeddings.js";
 import { getLogger } from "../logging.js";
 import { getWorkspaceDir } from "../paths.js";
@@ -208,14 +208,14 @@ export interface MaintainJobDeps {
   /** Drop the memoized v3 lanes so the next turn rebuilds them. */
   invalidateLanes: () => void;
   /**
-   * The managed (assistant-installed) skills in the catalog, each carrying its
+   * The cloud (assistant-installed) skills in the catalog, each carrying its
    * `installMeta`. The usage-prune stage reads the meta's `author`,
    * `lastUsedAt`, and `installedAt` to find stale assistant-authored skills.
    */
-  listManagedSkills: () => ResolvedSkillEntry[] | Promise<ResolvedSkillEntry[]>;
+  listCloudSkills: () => ResolvedSkillEntry[] | Promise<ResolvedSkillEntry[]>;
   /**
-   * Delete a managed skill by id (dir + companion files + graph node + v2
-   * page/vectors + v3 sections reconcile), as the `delete_managed_skill` tool
+   * Delete a cloud skill by id (dir + companion files + graph node + v2
+   * page/vectors + v3 sections reconcile), as the `delete_cloud_skill` tool
    * does. Called only when deletion is enabled and a skill is stale.
    */
   deleteSkill: (skillId: string) => Promise<void>;
@@ -455,10 +455,10 @@ function defaultDeps(config: AssistantConfig): MaintainJobDeps {
     listIndexedSlugs: () => selectAllPagesFromWorkspace(workspaceDir),
     loadCoreSet: () => realLoadCoreSet(workspaceDir),
     invalidateLanes: realInvalidateLanes,
-    listManagedSkills: async () =>
+    listCloudSkills: async () =>
       (await listInstalledSkills()).filter((s) => s.source === "managed"),
     deleteSkill: async (skillId) => {
-      const result = await executeDeleteManagedSkill(
+      const result = await executeDeleteCloudSkill(
         { skill_id: skillId },
         {
           conversationId: "memory-v3-maintain",
@@ -722,7 +722,7 @@ async function pruneStaleSkills(deps: MaintainJobDeps): Promise<{
   const deleteEnabled =
     typeof skillPruneDays === "number" && skillPruneDays > 0;
 
-  const managed = await deps.listManagedSkills();
+  const managed = await deps.listCloudSkills();
   const prunableSkills: string[] = [];
   const prunedSkills: string[] = [];
   const skillPruneFailures: Array<{ skillId: string; error: string }> = [];
@@ -1167,7 +1167,7 @@ export async function maintainJob(
   // Stage 5: usage-prune assistant-authored skills. OBSERVE-FIRST and
   // DEFAULT-OFF: it always REPORTS assistant-authored managed skills unused for
   // at least SKILL_OBSERVE_WINDOW_DAYS days (prunableSkills) so accumulation is
-  // visible, and only DELETES — via executeDeleteManagedSkill — when
+  // visible, and only DELETES — via executeDeleteCloudSkill — when
   // memory.maintenance.skillPruneDays is a positive integer (default null = never
   // prune). User-authored and untagged skills are always protected. Contained: a
   // failure is logged + recorded without aborting invalidation.

package/src/plugins/defaults/memory/v3/orchestrate.ts

@@ -118,7 +118,7 @@ import {
 const log = getLogger("memory-v3-injection-gate");
 
 /** `check_name` of the `watchdog` telemetry event recorded once per
- *  injection-gate run. The platform's memory admin analytics count and filter
+ *  injection-gate run. The cloud's memory admin analytics count and filter
  *  on this exact string — keep it stable. */
 export const MEMORY_V3_INJECTION_GATE_CHECK_NAME = "memory_v3_injection_gate";
 
@@ -133,7 +133,7 @@ export const MEMORY_V3_INJECTION_GATE_CHECK_NAME = "memory_v3_injection_gate";
  *  gate threw). Pass rate is only meaningful over scored runs — the shortcuts are
  *  all unconditional passes and would otherwise inflate it. It is derivable from
  *  `reason`, but the daemon owns the reason set and adds to it freely, so it is
- *  reported explicitly rather than left for the platform to re-derive from a
+ *  reported explicitly rather than left for the cloud to re-derive from a
  *  hardcoded list that would silently miscount the next reason we add. */
 function recordGateRun(detail: Record<string, unknown>): void {
   try {
@@ -149,7 +149,7 @@ function recordGateRun(detail: Record<string, unknown>): void {
 }
 
 /** `check_name` of the `watchdog` telemetry event recorded once per orchestrated
- *  turn, carrying what the SELECTOR did. Keep this string stable — the platform's
+ *  turn, carrying what the SELECTOR did. Keep this string stable — the cloud's
  *  memory admin analytics filter on it. */
 export const MEMORY_V3_SELECTION_CHECK_NAME = "memory_v3_selection";
 

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

@@ -12,9 +12,9 @@
 
 import { writeFileSync } from "node:fs";
 
+import { rehydrateCloudCredentials } from "../../../config/cloud-rehydration.js";
 import { getConfig } from "../../../config/loader.js";
 import { isMemoryEnabled } from "../../../config/memory-v3-gate.js";
-import { rehydratePlatformCredentials } from "../../../config/platform-rehydration.js";
 import { startConversationEvictor } from "../../../daemon/conversation-evictor.js";
 import {
   startWorkspaceSkillMdMtimePoll,
@@ -55,15 +55,15 @@ async function main(): Promise<void> {
   writeFileSync(pidPath, String(process.pid), { flag: "w" });
   log.info({ pid: process.pid, pidPath }, "Memory worker process started");
 
-  // Rehydrate the platform base URL and IDs from the credential store before
+  // Rehydrate the cloud base URL and IDs from the credential store before
   // any job runs. The daemon does this in initializeProvidersAndTools(); this
-  // standalone process must do it itself so getPlatformBaseUrl() resolves to
+  // 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
-  // platform proxy — without rehydration those requests hit the wrong platform
+  // cloud proxy — without rehydration those requests hit the wrong platform
   // and are rejected.
-  await rehydratePlatformCredentials();
+  await rehydrateCloudCredentials();
 
   // Jobs in this process wake real agent conversations, so it registers the
   // default plugin hook surface (hooks and injectors, no init hooks) the same

package/src/plugins/defaults/workspace/injectors.ts

@@ -292,7 +292,7 @@ function readConfigValidationResetNotice(): ConfigValidationResetNotice | null {
  * the loader recovers along a ladder (see `config/loader.ts`
  * `recoverFromInvalidConfig`) and records a sentinel. Whichever rung it lands
  * on, the saved config is not fully in effect: a section — or the whole config —
- * may have reverted to schema defaults, flipping a managed email/OAuth service
+ * may have reverted to schema defaults, flipping a cloud email/OAuth service
  * mode back to `your-own`, or the user's most recent edit may simply never have
  * applied. That is otherwise invisible (log-only). This injector reads the
  * sentinel and, when it is younger than
@@ -340,7 +340,7 @@ const configValidationResetNoticeInjector: Injector = {
       `The user's config.json failed schema validation at ${notice.resetAt} ` +
       `and did not fully take effect. Settings the user did not change may ` +
       `have silently reverted to defaults — including managed email/OAuth ` +
-      `service modes (a managed connection can flip back to "your-own" and ` +
+      `service modes (a cloud connection can flip back to "your-own" and ` +
       `break), model choices, and other customizations — and a recent edit may ` +
       `never have applied. The on-disk config.json is intact; the invalid ` +
       `entries just need fixing for the saved values to take effect again. ` +

package/src/plugins/mtime-cache.ts

@@ -1018,7 +1018,7 @@ export function registerDeclaredCredentialKeyPatterns(
  *
  * `disable` and `reload` keep the directory present, so {@link runShutdownHook}
  * resolves and runs the on-disk `shutdown` (via the same resolution the dispatch
- * path uses). `uninstall` runs nothing here: a managed uninstall runs `shutdown`
+ * path uses). `uninstall` runs nothing here: a cloud uninstall runs `shutdown`
  * *before* removing the directory (see `cli/lib/uninstall-plugin.ts`), and an
  * out-of-band `rm` leaves nothing to resolve.
  */

package/src/plugins/source-versions.ts

@@ -68,7 +68,7 @@ export interface SourceVersionsDocument {
   /** ISO timestamp of the last rewrite, for staleness logging. */
   readonly writtenAt: string;
   /**
-   * Keyed by the absolute directory path as the platform helpers construct
+   * Keyed by the absolute directory path as the cloud helpers construct
    * it (`getWorkspacePluginsDir()`-derived plugin dirs, plus
    * `getWorkspaceHooksDir()` for standalone workspace hooks), so readers
    * can key their own state the same way without any name resolution.

package/src/plugins/types.ts

@@ -148,7 +148,7 @@ export interface TurnContext {
   readonly interfaceName?: string;
   /**
    * Client OS surface, reported independently of the transport interface.
-   * Rendered as the `client_os:` line so the model knows the platform even
+   * Rendered as the `client_os:` line so the model knows the cloud even
    * though browser, mobile, and desktop apps share one `"web"`
    * transport interface.
    */

package/src/prompts/__tests__/system-prompt.test.ts

@@ -178,7 +178,7 @@ describe("buildSystemPrompt — default persona trust-class guardrail", () => {
   test("gates off for an unresolved local build when HTTP auth is disabled", () => {
     // Initial-prompt warming, home generation, and btw sidechains build
     // prompts with NO trustContext on behalf of the owner. In an auth-disabled
-    // (local / platform-managed) deployment that unresolved actor is the
+    // (local / cloud-managed) deployment that unresolved actor is the
     // guardian, so the guardrail must not render into those guardian-facing
     // prompts (fail-stranger would stonewall the owner about their own data).
     process.env.DISABLE_HTTP_AUTH = "true";

package/src/prompts/normalize-onboarding.ts

@@ -138,7 +138,7 @@ export function normalizeOnboardingContext(
     // Findings are model-extracted from arbitrary web content and get written
     // into persisted persona markdown as single bullets. Collapse ALL runs of
     // whitespace (incl. newlines) so one finding can never mint extra lines —
-    // injected bullets, headings, or a `## ` that would corrupt the managed
+    // injected bullets, headings, or a `## ` that would corrupt the cloud
     // section boundary on later rewrites.
     researchFindings: ctx.researchFindings?.length
       ? ctx.researchFindings

package/src/prompts/persona-resolver.ts

@@ -475,7 +475,7 @@ function resolveOnboardingWriteTarget(): string {
 }
 
 /**
- * Write a managed `## Onboarding Context` section to the guardian persona
+ * Write a cloud `## Onboarding Context` section to the guardian persona
  * file (or fallback target). Idempotent: replaces the section in-place if
  * it already exists, appends if not, and creates the file when missing.
  *

package/src/prompts/templates/system-sections.ts

@@ -27,7 +27,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { getCachedManagedConnections } from "../../credential-execution/managed-catalog.js";
+import { getCachedManagedConnections } from "../../credential-execution/cloud-catalog.js";
 import { listConnections } from "../../oauth/oauth-store.js";
 import type { OnboardingContext } from "../../types/onboarding-context.js";
 import { stripCommentLines } from "../../util/strip-comment-lines.js";
@@ -136,7 +136,7 @@ function renderFirstRunUserContext(onboarding: OnboardingContext): string {
 /**
  * Builds the `# Connected Services` block from the live OAuth caches.
  * Reads local (BYO) connections from the SQLite store via
- * `listConnections()` and platform-managed connections from the
+ * `listConnections()` and cloud connections from the
  * in-memory cache populated at daemon startup.  Provider-level dedup
  * is intentional: this block is a summary for the model, not an
  * exhaustive account list, so multiple accounts on the same provider
@@ -569,7 +569,7 @@ You can still be genuinely helpful — answer general questions, do research, an
     // because the content is derived from live caches rather than a
     // workspace file — the transform pulls from `listConnections()`
     // (SQLite OAuth store) and `getCachedManagedConnections()`
-    // (in-memory cache populated by the managed-catalog refresh job).
+    // (in-memory cache populated by the cloud-catalog refresh job).
     // Returns null when no active connections exist so the renderer's
     // empty-body gate omits the section entirely.
     id: "14-connected-services",

package/src/providers/__tests__/cadet-connection-routing.test.ts

@@ -8,7 +8,7 @@ import { migrateCreateProviderConnections } from "../../persistence/migrations/2
 import { migrateProviderConnectionStatusLabel } from "../../persistence/migrations/244-provider-connection-status-label.js";
 import { migrateProviderConnectionBaseUrlAndModels } from "../../persistence/migrations/250-provider-connection-base-url-and-models.js";
 import * as schema from "../../persistence/schema/index.js";
-import { isCadetManagedConnection } from "../cadet-model-routing.js";
+import { isCadetCloudConnection } from "../cadet-model-routing.js";
 import { createAdapterFromConnection } from "../inference/adapter-factory.js";
 import type { Auth, ProviderConnection } from "../inference/auth.js";
 import type { ResolvedAuth } from "../inference/auth.js";
@@ -43,13 +43,13 @@ const resolvedAuth: ResolvedAuth = {
 };
 
 describe("cadet connection routing", () => {
-  test("isCadetManagedConnection identifies the sentinel connection", () => {
-    expect(isCadetManagedConnection(cadetConnection)).toBe(true);
+  test("isCadetCloudConnection identifies the sentinel connection", () => {
+    expect(isCadetCloudConnection(cadetConnection)).toBe(true);
     // The provider column alone decides: a concrete provider is never the
-    // managed route (platform auth always pairs with provider "cadet";
+    // cloud route (platform auth always pairs with provider "cadet";
     // DB migration 361 reconciles stored rows).
-    expect(isCadetManagedConnection({ provider: "fireworks" })).toBe(false);
-    expect(isCadetManagedConnection({ provider: "cadet" })).toBe(true);
+    expect(isCadetCloudConnection({ provider: "fireworks" })).toBe(false);
+    expect(isCadetCloudConnection({ provider: "cadet" })).toBe(true);
   });
 
   test("the cadet sentinel does not dispatch without an override", () => {
@@ -149,7 +149,7 @@ describe("cadet connection persistence (DB round-trip)", () => {
     const loaded = getConnection(db, "cadet");
     expect(loaded).not.toBeNull();
     expect(loaded?.provider).toBe("cadet");
-    expect(isCadetManagedConnection(loaded!)).toBe(true);
+    expect(isCadetCloudConnection(loaded!)).toBe(true);
   });
 
   test("listConnections includes a persisted cadet row", () => {

package/src/providers/__tests__/cadet-mismatch-routing.test.ts

@@ -1,7 +1,7 @@
 /**
  * Guards that a `cadet` provider_connection only takes the provider-agnostic
- * routing path when the resolving profile declares a managed-routable upstream.
- * A `cadet` connection paired with a non-managed provider (openrouter/ollama/…)
+ * routing path when the resolving profile declares a cloud-routable upstream.
+ * A `cadet` connection paired with a non-cloud provider (openrouter/ollama/…)
  * is a misconfiguration and must use the normal mismatch recovery/error path,
  * not route as platform auth and silently fall back.
  */
@@ -88,14 +88,14 @@ describe("cadet connection mismatch handling", () => {
     expect(provider).not.toBeNull();
     expect(provider?.routeAttribution).toEqual({
       connectionName: "cadet",
-      isManagedRoute: true,
+      isCloudRoute: true,
     });
     expect(resolveCalls).toHaveLength(1);
     expect(resolveCalls[0].connection.name).toBe("cadet");
     expect(resolveCalls[0].opts.providerOverride).toBe("fireworks");
   });
 
-  test("non-managed provider with no recovery throws provider_mismatch", async () => {
+  test("non-cloud provider with no recovery throws provider_mismatch", async () => {
     fakeConnections.set("cadet", cadetConn);
     listResult = []; // no openrouter connection to recover to
     let caught: unknown;
@@ -113,11 +113,11 @@ describe("cadet connection mismatch handling", () => {
     expect((caught as ConnectionResolutionError).reason).toBe(
       "provider_mismatch",
     );
-    // Never routed as a cadet platform-auth request.
+    // Never routed as a cadet cloud-auth request.
     expect(resolveCalls).toHaveLength(0);
   });
 
-  test("non-managed provider auto-recovers to a real connection (no override)", async () => {
+  test("non-cloud provider auto-recovers to a real connection (no override)", async () => {
     fakeConnections.set("cadet", cadetConn);
     listResult = [
       {
@@ -135,7 +135,7 @@ describe("cadet connection mismatch handling", () => {
     expect(provider).not.toBeNull();
     expect(provider?.routeAttribution).toEqual({
       connectionName: "openrouter-personal",
-      isManagedRoute: false,
+      isCloudRoute: false,
     });
     expect(resolveCalls).toHaveLength(1);
     expect(resolveCalls[0].connection.name).toBe("openrouter-personal");
@@ -145,8 +145,8 @@ describe("cadet connection mismatch handling", () => {
 
 /**
  * Boot seeding leaves a user-owned row claiming the `cadet` name in place, so
- * an install can have no canonical row at all. A managed profile only resolves
- * on a platform install, so its route is platform auth, never the credentials
+ * an install can have no canonical row at all. A cloud profile only resolves
+ * on a cloud install, so its route is platform auth, never the credentials
  * that row happens to carry, and never an error over the name collision.
  */
 describe("user-owned connection claiming the cadet name", () => {
@@ -199,7 +199,7 @@ describe("user-owned connection claiming the cadet name", () => {
 
   test("an unavailable platform is a soft miss, not a fall-through", async () => {
     fakeConnections.set("cadet", userOwnedOpenai);
-    resolveResult = null; // not signed in to the platform
+    resolveResult = null; // not signed in to the cloud
     const provider = await tryResolveProviderForConnectionName(
       "cadet",
       config,
@@ -213,8 +213,8 @@ describe("user-owned connection claiming the cadet name", () => {
 
   test("a concrete provider over the canonical name is still platform-billed", async () => {
     // The shape `resolveCallSiteConfig` produces when a call-site tweak pins a
-    // concrete upstream over a managed profile: provider is the upstream, the
-    // managed connection survives. The legacy config of the same shape (a BYOK
+    // concrete upstream over a cloud profile: provider is the upstream, the
+    // cloud connection survives. The legacy config of the same shape (a BYOK
     // profile pointing at a row named `cadet`) resolves the same way.
     fakeConnections.set("cadet", userOwnedOpenai);
     const provider = await tryResolveProviderForConnectionName(

package/src/providers/__tests__/connection-model-compat.test.ts

@@ -26,7 +26,7 @@ import type { Auth } from "../inference/auth.js";
 // ---------------------------------------------------------------------------
 
 const apiKeyAuth: Auth = { type: "api_key", credential: "credential/x" };
-const platformAuth: Auth = { type: "platform" };
+const cloudAuth: Auth = { type: "platform" };
 const oauthAuth: Auth = {
   type: "oauth_subscription",
   credential: "credential/x",
@@ -40,7 +40,7 @@ describe("isConnectionCompatibleWithModel", () => {
   });
 
   test("platform connection is compatible with any model", () => {
-    const conn = { auth: platformAuth };
+    const conn = { auth: cloudAuth };
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-nano")).toBe(true);
   });