@mycadet/assistant 0.12.7 → 0.12.8

package/src/skills/{managed-store.ts → cloud-store.ts}

@@ -23,13 +23,13 @@ import { getWorkspaceDir, getWorkspaceSkillsDir } from "../util/platform.js";
 import { parseFrontmatterFields } from "./frontmatter.js";
 import { writeInstallMeta } from "./install-meta.js";
 
-const log = getLogger("managed-store");
+const log = getLogger("cloud-store");
 
 // ─── Validation ──────────────────────────────────────────────────────────────
 
 const VALID_SKILL_ID = /^[a-z0-9][a-z0-9._-]*$/;
 
-export function validateManagedSkillId(id: string): string | null {
+export function validateCloudSkillId(id: string): string | null {
   if (!id || typeof id !== "string") {
     return "skill_id is required";
   }
@@ -44,8 +44,8 @@ export function validateManagedSkillId(id: string): string | null {
 
 // ─── Path helpers ────────────────────────────────────────────────────────────
 
-/** Absolute path of a managed skill's directory (whether or not it exists). */
-export function getManagedSkillDir(id: string): string {
+/** Absolute path of a cloud skill's directory (whether or not it exists). */
+export function getCloudSkillDir(id: string): string {
   return join(getWorkspaceSkillsDir(), id);
 }
 
@@ -335,12 +335,12 @@ function atomicWriteFile(filePath: string, content: string): void {
 // ─── Version metadata ─────────────────────────────────────────────────────────
 
 function getVersionMetaPath(id: string): string {
-  return join(getManagedSkillDir(id), "version.json");
+  return join(getCloudSkillDir(id), "version.json");
 }
 
 // ─── Create / Delete ─────────────────────────────────────────────────────────
 
-interface CreateManagedSkillParams {
+interface CreateCloudSkillParams {
   id: string;
   name: string;
   description: string;
@@ -363,16 +363,16 @@ interface CreateManagedSkillParams {
   files?: Array<{ path: string; content?: string; copyFrom?: string }>;
 }
 
-interface CreateManagedSkillResult {
+interface CreateCloudSkillResult {
   created: boolean;
   path: string;
   error?: string;
 }
 
-export function createManagedSkill(
-  params: CreateManagedSkillParams,
-): CreateManagedSkillResult {
-  const validationError = validateManagedSkillId(params.id);
+export function createCloudSkill(
+  params: CreateCloudSkillParams,
+): CreateCloudSkillResult {
+  const validationError = validateCloudSkillId(params.id);
   if (validationError) {
     return {
       created: false,
@@ -396,7 +396,7 @@ export function createManagedSkill(
     };
   }
 
-  const skillDir = getManagedSkillDir(params.id);
+  const skillDir = getCloudSkillDir(params.id);
   const skillFilePath = join(skillDir, "SKILL.md");
 
   const skillExists = existsSync(skillFilePath);
@@ -414,7 +414,7 @@ export function createManagedSkill(
   // rarely hold every field (the retrospective sees a skill through a
   // similarity hit; a user edit is "change step 3"), so a field they do not
   // pass is kept rather than dropped.
-  const existing = skillExists ? readStoredManagedSkill(params.id) : null;
+  const existing = skillExists ? readStoredCloudSkill(params.id) : null;
 
   // Resolve and validate every companion path before any write so an invalid
   // path leaves no partial files behind.
@@ -523,7 +523,7 @@ export function createManagedSkill(
  * it into prose. `frontmatter` is the whole block as written, for an
  * overwrite to carry keys through that the typed fields do not cover.
  */
-export interface StoredManagedSkill {
+export interface StoredCloudSkill {
   name: string;
   description: string;
   frontmatter: Record<string, unknown>;
@@ -536,14 +536,12 @@ export interface StoredManagedSkill {
 }
 
 /**
- * Read a managed skill from disk. Best-effort: a missing file or frontmatter
+ * Read a cloud skill from disk. Best-effort: a missing file or frontmatter
  * that does not parse resolves to null, so a caller enriching or patching one
  * skill never fails on a bad one.
  */
-export function readStoredManagedSkill(
-  skillId: string,
-): StoredManagedSkill | null {
-  const skillFilePath = join(getManagedSkillDir(skillId), "SKILL.md");
+export function readStoredCloudSkill(skillId: string): StoredCloudSkill | null {
+  const skillFilePath = join(getCloudSkillDir(skillId), "SKILL.md");
   try {
     const content = readFileSync(skillFilePath, "utf-8");
     const parsed = parseFrontmatter(content, skillFilePath);
@@ -568,18 +566,18 @@ export function readStoredManagedSkill(
   }
 }
 
-interface DeleteManagedSkillResult {
+interface DeleteCloudSkillResult {
   deleted: boolean;
   error?: string;
 }
 
-export function deleteManagedSkill(id: string): DeleteManagedSkillResult {
-  const validationError = validateManagedSkillId(id);
+export function deleteCloudSkill(id: string): DeleteCloudSkillResult {
+  const validationError = validateCloudSkillId(id);
   if (validationError) {
     return { deleted: false, error: validationError };
   }
 
-  const skillDir = getManagedSkillDir(id);
+  const skillDir = getCloudSkillDir(id);
   if (!existsSync(skillDir)) {
     return {
       deleted: false,

package/src/skills/inline-command-runner.ts

@@ -6,7 +6,7 @@
  *
  * - Sanitized environment variables only (no API keys, tokens, credentials)
  * - No credential proxy, no CES client, no host fallback
- * - Runs in Docker/platform-managed environments (network/filesystem isolation
+ * - Runs in Docker/cloud-managed environments (network/filesystem isolation
  *   is provided by the container, not OS-level sandboxing)
  * - Uses the conversation working directory as `cwd` so repo-local commands
  *   remain interoperable with externally authored skills that expect project

package/src/skills/install-meta.ts

@@ -38,7 +38,7 @@ export interface SkillInstallMeta {
   // breadcrumb only — `sourceConversationId` is the durable lineage.
   retrospectiveConversationId?: string;
   // Day-granularity stamp of the last time the skill was loaded (ISO 8601).
-  // Stamped by `touchSkillLastUsed` on the managed-skill activation path; the
+  // Stamped by `touchSkillLastUsed` on the cloud-skill activation path; the
   // usage-based prune reads its date portion as the last-used signal.
   lastUsedAt?: string;
 }

package/src/skills/path-classifier.ts

@@ -5,10 +5,10 @@ import { getBundledSkillsDir } from "../config/skills.js";
 import { getWorkspaceSkillsDir } from "../util/platform.js";
 
 /**
- * Returns the managed skills root directory. Managed skills are user-installed
+ * Returns the cloud skills root directory. Managed skills are user-installed
  * skills that live under $CADET_WORKSPACE_DIR/skills.
  */
-export function getManagedSkillsRoot(): string {
+export function getCloudSkillsRoot(): string {
   return normalizeDirPath(getWorkspaceSkillsDir());
 }
 
@@ -91,7 +91,7 @@ export function normalizeFilePath(filePath: string): string {
  * be passed via the `extraRoots` parameter.
  */
 export function getSkillRoots(extraRoots?: string[]): string[] {
-  const roots = [getManagedSkillsRoot(), getBundledSkillsRoot()];
+  const roots = [getCloudSkillsRoot(), getBundledSkillsRoot()];
   if (extraRoots) {
     for (const root of extraRoots) {
       roots.push(normalizeDirPath(root));
@@ -103,7 +103,7 @@ export function getSkillRoots(extraRoots?: string[]): string[] {
 /**
  * Checks whether an absolute path falls under any known skill directory.
  *
- * Returns true if the path is inside the managed skills dir, the bundled
+ * Returns true if the path is inside the cloud skills dir, the bundled
  * skills dir, or any of the provided extra roots. The check is
  * symlink-safe: both the candidate path and the skill roots are resolved
  * through realpath when the paths exist on disk.

package/src/skills/skill-history.ts

@@ -3,9 +3,9 @@
 // ---------------------------------------------------------------------------
 //
 // The workspace is a git repo with an auto-committing heartbeat, and `skills/`
-// is tracked, so every managed-skill write already has its prior content
+// is tracked, so every cloud-skill write already has its prior content
 // retained. This module reads that history rather than storing a second copy:
-// `createManagedSkill` writes through an atomic rename and keeps no version of
+// `createCloudSkill` writes through an atomic rename and keeps no version of
 // its own, but the commit underneath it does.
 //
 // A revision here is ONE UPDATE TO THE WHOLE SKILL, not a per-file log. A
@@ -43,7 +43,7 @@
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import { getWorkspaceGitService } from "../workspace/git-service.js";
-import { validateManagedSkillId } from "./managed-store.js";
+import { validateCloudSkillId } from "./cloud-store.js";
 
 const log = getLogger("skill-history");
 
@@ -128,7 +128,7 @@ export async function getSkillHistory(
   skillId: string,
   options: { limit?: number } = {},
 ): Promise<SkillHistory> {
-  const invalid = validateManagedSkillId(skillId);
+  const invalid = validateCloudSkillId(skillId);
   if (invalid) {
     throw new Error(`Invalid skill id: ${invalid}`);
   }

package/src/skills/skillssh-registry.ts

@@ -413,7 +413,7 @@ const VALID_SKILL_SLUG = /^[a-z0-9][a-z0-9._-]*$/;
 
 /**
  * Validate that a skill slug is safe for use in filesystem paths.
- * Follows the same pattern as `validateManagedSkillId` in managed-store.ts.
+ * Follows the same pattern as `validateCloudSkillId` in cloud-store.ts.
  */
 export function validateSkillSlug(slug: string): void {
   if (!slug || typeof slug !== "string") {

package/src/stt/__tests__/daemon-batch-transcriber.test.ts

@@ -611,7 +611,7 @@ describe("normalizeSttError", () => {
 });
 
 describe("cadet factory case", () => {
-  test("constructs the managed transcriber with no API key", () => {
+  test("constructs the cloud transcriber with no API key", () => {
     const transcriber = createDaemonBatchTranscriber(null, "cadet");
     expect(transcriber?.providerId).toBe("cadet");
     expect(transcriber?.boundaryId).toBe("daemon-batch");

package/src/stt/daemon-batch-transcriber.ts

@@ -206,8 +206,8 @@ export function normalizeSttError(err: unknown): SttError {
 }
 
 // ---------------------------------------------------------------------------
-// Cadet managed adapter — implements BatchTranscriber on top of the
-// platform's managed speech endpoint. No API key: the cloud connection
+// Cadet Cloud adapter — implements BatchTranscriber on top of the
+// platform's cloud speech endpoint. No API key: the cloud connection
 // is the credential.
 // ---------------------------------------------------------------------------
 
@@ -220,9 +220,9 @@ class CadetManagedBatchTranscriber implements BatchTranscriber {
   async transcribe(
     request: SttTranscribeRequest,
   ): Promise<SttTranscribeResult> {
-    const { cadetManagedTranscribe } =
-      await import("../providers/speech-to-text/cadet-managed.js");
-    return cadetManagedTranscribe(
+    const { cadetCloudTranscribe } =
+      await import("../providers/speech-to-text/cadet-cloud.js");
+    return cadetCloudTranscribe(
       request.audio,
       request.mimeType,
       request.signal,
@@ -243,7 +243,7 @@ class CadetManagedBatchTranscriber implements BatchTranscriber {
  * `language` is the spoken language, forwarded to providers whose batch API
  * accepts one: Deepgram (where `"multi"` also pins nova-3), xAI (where
  * `"multi"` is dropped because it is a Deepgram-specific value, not a
- * language code), and the Cadet managed path, whose platform proxy passes
+ * language code), and the Cadet Cloud path, whose cloud proxy passes
  * it to Deepgram server-side. Whisper and Gemini auto-detect natively and
  * take no language parameter, so it is silently ignored for them.
  *
@@ -255,7 +255,7 @@ export function createDaemonBatchTranscriber(
   providerId: SttProviderId,
   language?: string,
 ): BatchTranscriber | null {
-  // Managed speech authenticates via the cloud connection, not an API
+  // Cloud speech authenticates via the cloud connection, not an API
   // key. Callers pass canonical ids; the resolver maps legacy ones first.
   if (providerId === "cadet") {
     return new CadetManagedBatchTranscriber(language);

package/src/stt/types.ts

@@ -55,8 +55,8 @@ export type SttProviderId =
   | "xai"
   | "cadet"
   /**
-   * Managed Flux: the same conversational model as `deepgram-flux`, reached
-   * through the platform's speech relay instead of a Deepgram key. Dials the
+   * Cloud Flux: the same conversational model as `deepgram-flux`, reached
+   * through the cloud's speech relay instead of a Deepgram key. Dials the
    * relay's STT v2 endpoint asking for native Flux frames, so it keeps the
    * turn events the relay's default v1-shaped translation drops.
    */
@@ -208,7 +208,7 @@ export class SttError extends Error {
   /**
    * When true, {@link message} is already user-facing, provider-appropriate
    * copy and must be surfaced verbatim rather than rewritten by
-   * `describeSttFailure`. Set by adapters (e.g. managed speech) whose failures
+   * `describeSttFailure`. Set by adapters (e.g. cloud speech) whose failures
    * carry specific remediation — a credit top-up or platform reconnect — that
    * the generic BYOK "check your API key" copy would erase.
    */

package/src/subagent/manager.ts

@@ -361,7 +361,7 @@ export function buildSubagentTerminalMessage(opts: {
 
 // ── Manager ─────────────────────────────────────────────────────────────
 
-interface ManagedSubagent {
+interface CloudSubagent {
   /** Live conversation — null after the subagent reaches a terminal state and is released. */
   conversation: Conversation | null;
   state: SubagentState;
@@ -467,8 +467,8 @@ export class SubagentSpawnCancelledError extends Error {
 }
 
 export class SubagentManager {
-  /** subagentId → ManagedSubagent */
-  private subagents = new Map<string, ManagedSubagent>();
+  /** subagentId → CloudSubagent */
+  private subagents = new Map<string, CloudSubagent>();
   /** parentConversationId → Set<subagentId> */
   private parentToChildren = new Map<string, Set<string>>();
   /** `${parentConversationId}:${normalizedLabel}` → subagentId */
@@ -566,7 +566,7 @@ export class SubagentManager {
     config: Omit<SubagentConfig, "id">,
     parentSendToClient: (msg: AssistantEvent) => void,
     opts?: { synchronous?: boolean },
-  ): Promise<{ subagentId: string; managed: ManagedSubagent }> {
+  ): Promise<{ subagentId: string; managed: CloudSubagent }> {
     // ── Limit checks ────────────────────────────────────────────────
 
     // Depth check: prevent subagents from spawning nested subagents.
@@ -703,9 +703,9 @@ export class SubagentManager {
       usage: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     };
 
-    // Store the managed subagent early so the wrapper can read the mutable
+    // Store the cloud subagent early so the wrapper can read the mutable
     // parentSendToClient reference — this ensures reconnects are picked up.
-    const managed: ManagedSubagent = {
+    const managed: CloudSubagent = {
       // Placeholder — replaced with the real Conversation a few lines below, before
       // any code reads this field. Using null! avoids the `as unknown as` cast.
       conversation: null! as Conversation,
@@ -1195,7 +1195,7 @@ export class SubagentManager {
    * without `maxRuntimeMs` is unbounded in time, which is right for delegated
    * work whose length is the point.
    */
-  private armRuntimeBudget(managed: ManagedSubagent): void {
+  private armRuntimeBudget(managed: CloudSubagent): void {
     const maxRuntimeMs = managed.state.config.maxRuntimeMs;
     if (maxRuntimeMs === undefined || maxRuntimeMs <= 0) {
       return;
@@ -1208,7 +1208,7 @@ export class SubagentManager {
     }, maxRuntimeMs);
   }
 
-  private clearRuntimeBudget(managed: ManagedSubagent): void {
+  private clearRuntimeBudget(managed: CloudSubagent): void {
     if (managed.runtimeTimer) {
       clearTimeout(managed.runtimeTimer);
       managed.runtimeTimer = undefined;
@@ -1226,7 +1226,7 @@ export class SubagentManager {
    * hook inside the agent loop.
    */
   private countToolCallAgainstBudget(
-    managed: ManagedSubagent,
+    managed: CloudSubagent,
     msg: AssistantEvent,
   ): void {
     const maxToolCalls = managed.state.config.maxToolCalls;
@@ -1258,7 +1258,7 @@ export class SubagentManager {
    * {@link notifyParentBudgetStop} sends it from the run's `finally`, once the
    * loop has unwound.
    */
-  private stopForBudget(managed: ManagedSubagent, reason: string): void {
+  private stopForBudget(managed: CloudSubagent, reason: string): void {
     const { id } = managed.state.config;
     const stopped = this.abort(id, managed.parentSendToClient, undefined, {
       suppressNotification: true,
@@ -1289,7 +1289,7 @@ export class SubagentManager {
    * pointer is kept for the run that wrote nothing.
    */
   private notifyParentBudgetStop(
-    managed: ManagedSubagent,
+    managed: CloudSubagent,
     finalText: string,
   ): void {
     const reason = managed.pendingBudgetStopNotice;
@@ -1742,7 +1742,7 @@ export class SubagentManager {
    * nothing measured to report, and a zero taken mid-flight would read as
    * "this subagent used no tools" rather than "not measured yet".
    */
-  private refreshToolStats(managed: ManagedSubagent): void {
+  private refreshToolStats(managed: CloudSubagent): void {
     if (managed.conversation && managed.state.stats) {
       managed.state.stats = snapshotToolStats(managed.conversation);
     }
@@ -1843,7 +1843,7 @@ export class SubagentManager {
    * lightweight metadata (state, config, usage) for later queries.
    * The conversation's output is already persisted in the database.
    */
-  private releaseConversation(managed: ManagedSubagent): void {
+  private releaseConversation(managed: CloudSubagent): void {
     if (!managed.conversation) {
       return;
     }
@@ -2005,7 +2005,7 @@ export class SubagentManager {
         status: settleUnsupervisedStatus(mapped.status),
       };
 
-      const managed: ManagedSubagent = {
+      const managed: CloudSubagent = {
         conversation: null,
         state,
         parentSendToClient: () => {},
@@ -2153,7 +2153,7 @@ export class SubagentManager {
    * on the result directly rather than issuing a `subagent_read` call.
    */
   private notifyParentTerminal(
-    managed: ManagedSubagent,
+    managed: CloudSubagent,
     outcome: "completed" | "failed",
     finalText?: string,
     deniedTools?: string[],

package/src/subagent/types.ts

@@ -468,7 +468,7 @@ export function subagentOutputContractText(
  * them, so a correction lands once.
  *
  * Mirrored on the wire as `llm_usage.subagent_spawn_mode`, which is an OPEN
- * string set on the platform side: adding a value here needs no coordinated
+ * string set on the cloud side: adding a value here needs no coordinated
  * platform release.
  */
 export type SubagentSpawnMode =

package/src/telegram/__tests__/webhook-health.test.ts

@@ -13,7 +13,7 @@ const secureKeyValues = useMemorySecureKeyMap();
 // `webhooks register` actually does for platform-connected local assistants.
 let ingressConfig: Record<string, unknown> = {};
 let isPlatform = false;
-let platformContextEnabled = false;
+let cloudContextEnabled = false;
 
 type FetchOutcome =
   | { kind: "json"; status?: number; body: unknown }
@@ -65,20 +65,20 @@ mock.module("../../config/loader.js", () => ({
 const actualEnvRegistry = await import("../../config/env-registry.js");
 mock.module("../../config/env-registry.js", () => ({
   ...actualEnvRegistry,
-  getIsPlatform: () => isPlatform,
+  getIsCloud: () => isPlatform,
 }));
 
 const actualRegistration =
-  await import("../../inbound/platform-callback-registration.js");
-mock.module("../../inbound/platform-callback-registration.js", () => ({
+  await import("../../inbound/cloud-callback-registration.js");
+mock.module("../../inbound/cloud-callback-registration.js", () => ({
   ...actualRegistration,
-  resolvePlatformCallbackRegistrationContext: async () => ({
+  resolveCloudCallbackRegistrationContext: async () => ({
     isPlatform,
-    platformBaseUrl: "https://cloud.mycadet.ai",
-    assistantId: platformContextEnabled ? "assistant-123" : "",
-    hasAssistantApiKey: platformContextEnabled,
-    authHeader: platformContextEnabled ? "Api-Key secret" : null,
-    enabled: platformContextEnabled,
+    cloudBaseUrl: "https://cloud.mycadet.ai",
+    assistantId: cloudContextEnabled ? "assistant-123" : "",
+    hasAssistantApiKey: cloudContextEnabled,
+    authHeader: cloudContextEnabled ? "Api-Key secret" : null,
+    enabled: cloudContextEnabled,
   }),
 }));
 
@@ -155,7 +155,7 @@ beforeEach(() => {
   secureKeyValues.set(WEBHOOK_SECRET_KEY, "s3cret");
   ingressConfig = { publicBaseUrl: "https://example.test" };
   isPlatform = false;
-  platformContextEnabled = false;
+  cloudContextEnabled = false;
   setWebhookInfo({ url: WEBHOOK_URL, pending_update_count: 0 });
   fetchCallCount = 0;
   fetchedUrls.length = 0;
@@ -206,7 +206,7 @@ describe("gating", () => {
     // An opt-out means no inbound webhook is expected at all, so the sweep has
     // nothing to verify even though platform credentials are present.
     ingressConfig = { enabled: false };
-    platformContextEnabled = true;
+    cloudContextEnabled = true;
 
     const result = await runTelegramWebhookHealthCheck();
 
@@ -215,12 +215,12 @@ describe("gating", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
-  test("runs for a platform-connected local assistant with no ingress", async () => {
-    // LUM-2882: `webhooks register telegram` registers a platform callback
+  test("runs for a cloud-connected local assistant with no ingress", async () => {
+    // LUM-2882: `webhooks register telegram` registers a cloud callback
     // route in this exact configuration, so a broken registration is real and
     // the sweep has to verify it rather than skip.
     ingressConfig = {};
-    platformContextEnabled = true;
+    cloudContextEnabled = true;
     setWebhookInfo({
       url: WEBHOOK_URL,
       last_error_date: unixSecondsAgo(30),
@@ -238,7 +238,7 @@ describe("gating", () => {
     expect(result.detail).toContain("contact support");
   });
 
-  test("runs when platform-managed callbacks stand in for public ingress", async () => {
+  test("runs when cloud-managed callbacks stand in for public ingress", async () => {
     isPlatform = true;
     ingressConfig = {};
     setWebhookInfo({

package/src/telegram/webhook-health.ts

@@ -166,8 +166,8 @@ function telegramApiBaseUrl(): string {
  * and the assistant already maintain mirrored copies of the routing tier order
  * (`resolveExpectedTelegramWebhookUrl` and `hasWebhookRoutingConfigured`, which
  * cross-reference each other in comments after LUM-2899), and a third copy here
- * would be a third thing to keep in agreement. It also lets the managed path be
- * checked at all: resolving a platform callback URL means POSTing a route
+ * would be a third thing to keep in agreement. It also lets the cloud path be
+ * checked at all: resolving a cloud callback URL means POSTing a route
  * registration, which a read-only health check must not do.
  */
 function recordedWebhookUrl(): string | undefined {
@@ -188,12 +188,12 @@ function channelLabel(): string {
 
 /**
  * The remediation path, which differs by deployment. Self-hosted users own the
- * ingress URL; platform-managed callback routes are registered for them.
+ * ingress URL; cloud-managed callback routes are registered for them.
  */
-function fixPath(usesManagedCallbacks: boolean): string {
-  if (usesManagedCallbacks) {
+function fixPath(usesCloudCallbacks: boolean): string {
+  if (usesCloudCallbacks) {
     return (
-      "This deployment uses platform-managed callback routes, so the webhook URL is not yours to set — " +
+      "This deployment uses cloud-managed callback routes, so the webhook URL is not yours to set — " +
       "if it stays broken, contact support."
     );
   }
@@ -237,7 +237,7 @@ export async function checkTelegramWebhookHealth(): Promise<TelegramWebhookHealt
     };
   }
 
-  const { configured, usesManagedCallbacks } =
+  const { configured, usesCloudCallbacks } =
     await hasWebhookRoutingConfigured(true);
   if (!configured) {
     return {
@@ -288,7 +288,7 @@ export async function checkTelegramWebhookHealth(): Promise<TelegramWebhookHealt
       status: "not_registered",
       detail:
         `${label} has no webhook registered with Telegram, so inbound messages are not reaching ` +
-        `the assistant. ${fixPath(usesManagedCallbacks)}`,
+        `the assistant. ${fixPath(usesCloudCallbacks)}`,
       ...(pendingUpdateCount !== undefined ? { pendingUpdateCount } : {}),
     };
   }
@@ -307,7 +307,7 @@ export async function checkTelegramWebhookHealth(): Promise<TelegramWebhookHealt
       detail:
         `${label} is registered with Telegram at a different address than this assistant ` +
         `last registered, so its messages are being delivered somewhere this assistant is not ` +
-        `listening. ${fixPath(usesManagedCallbacks)}`,
+        `listening. ${fixPath(usesCloudCallbacks)}`,
       registeredUrl,
       expectedUrl,
       ...(pendingUpdateCount !== undefined ? { pendingUpdateCount } : {}),
@@ -329,7 +329,7 @@ export async function checkTelegramWebhookHealth(): Promise<TelegramWebhookHealt
       status: "delivery_failing",
       detail:
         `${label} cannot receive messages: Telegram reported "${reported}" while delivering to the ` +
-        `webhook.${queued} ${fixPath(usesManagedCallbacks)}`,
+        `webhook.${queued} ${fixPath(usesCloudCallbacks)}`,
       ...(info.last_error_message
         ? { lastErrorMessage: info.last_error_message }
         : {}),

package/src/telemetry/__tests__/config-setting-events-store.test.ts

@@ -49,7 +49,7 @@ describe("config-setting-events-store", () => {
     });
   });
 
-  test("clamps oversize key and value to the platform bounds", () => {
+  test("clamps oversize key and value to the cloud bounds", () => {
     recordConfigSettingEvent({
       configKey: "k".repeat(200),
       configValue: "v".repeat(300),

package/src/telemetry/__tests__/outbox-test-harness.ts

@@ -1,6 +1,6 @@
 import { mock, spyOn } from "bun:test";
 
-import type { ConsentState } from "../../platform/consent-cache.js";
+import type { ConsentState } from "../../cloud/consent-cache.js";
 
 let shareAnalytics: ConsentState = true;
 // Owner's `share_diagnostics` consent + accepted version — a second,
@@ -18,7 +18,7 @@ let shareDiagnosticsVersion = "2999-01-01";
 // preload — so it runs after the per-test workspace override, where src/
 // imports are as safe as in the test files themselves (AGENTS.md "Test
 // machinery isolation" scopes its no-src/ rule to preload-time machinery).
-mock.module("../../platform/consent-cache.js", () => ({
+mock.module("../../cloud/consent-cache.js", () => ({
   getRawShareAnalytics: () => shareAnalytics,
   getCachedShareDiagnostics: () => shareDiagnostics,
   getCachedShareDiagnosticsVersion: () => shareDiagnosticsVersion,

package/src/telemetry/config-setting-events-store.ts

@@ -1,7 +1,7 @@
 import { recordTelemetryEvent } from "./telemetry-events-outbox.js";
 
 /**
- * Server-side bounds from the platform `ConfigSettingTelemetryEventSerializer`.
+ * Server-side bounds from the cloud `ConfigSettingTelemetryEventSerializer`.
  * Values are clamped at record time so an oversize pair degrades to a
  * truncated event instead of a per-event ingest rejection.
  */

package/src/telemetry/config-setting-snapshot.ts

@@ -1,6 +1,6 @@
+import { getRawShareAnalytics } from "../cloud/consent-cache.js";
 import { getConfigReadOnly } from "../config/loader.js";
 import type { AssistantConfig } from "../config/schema.js";
-import { getRawShareAnalytics } from "../platform/consent-cache.js";
 import { getLogger } from "../util/logger.js";
 import { recordConfigSettingEvent } from "./config-setting-events-store.js";
 

package/src/telemetry/memory-corpus-size.ts

@@ -5,7 +5,7 @@ import { getWorkspaceDir } from "../util/platform.js";
 
 /**
  * Coarse on-disk size of the assistant's memory corpus, in the snake_case
- * shape the `memory_tier` watchdog `detail` bag carries to the platform.
+ * shape the `memory_tier` watchdog `detail` bag carries to the cloud.
  *
  * Both corpora are measured on every tier rather than branching on the tier
  * itself: an assistant part-way through a v1 -> v2 -> v3 migration has content

package/src/telemetry/memory-tier-reporter.test.ts

@@ -1,8 +1,8 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { ConsentState } from "../cloud/consent-cache.js";
 import { memoryTier } from "../config/memory-tier.js";
 import type { AssistantConfig } from "../config/schema.js";
-import type { ConsentState } from "../platform/consent-cache.js";
 import type { MemoryCorpusSize } from "./memory-corpus-size.js";
 import type { WatchdogEventRecord } from "./watchdog-events-store.js";
 
@@ -36,7 +36,7 @@ mock.module("./memory-corpus-size.js", () => ({
     return corpus;
   },
 }));
-mock.module("../platform/consent-cache.js", () => ({
+mock.module("../cloud/consent-cache.js", () => ({
   getRawShareAnalytics: () => consent,
 }));
 mock.module("../config/loader.js", () => ({