@mycadet/assistant 0.12.7 → 0.12.8

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

@@ -1,6 +1,6 @@
+import { getRawShareAnalytics } from "../cloud/consent-cache.js";
 import { getConfigReadOnly } from "../config/loader.js";
 import { memoryTier } from "../config/memory-tier.js";
-import { getRawShareAnalytics } from "../platform/consent-cache.js";
 import { getLogger } from "../util/logger.js";
 import { measureMemoryCorpusSize } from "./memory-corpus-size.js";
 import { recordWatchdogEvent } from "./watchdog-events-store.js";
@@ -10,7 +10,7 @@ const log = getLogger("memory-tier-reporter");
 /**
  * How often each assistant re-asserts its coarse memory tier as a
  * `memory_tier` watchdog event. Unlike the config-setting snapshot this emits
- * UNCONDITIONALLY every cycle (no memo): the platform-side query wants a
+ * UNCONDITIONALLY every cycle (no memo): the cloud-side query wants a
  * periodic per-assistant heartbeat of the current tier, so a gap in the series
  * is meaningful (assistant offline) rather than "value unchanged". Six-hourly
  * keeps the volume trivial while giving a same-day read on the fleet's tier
@@ -38,7 +38,7 @@ const BOOT_RETRY_INTERVAL_MS = 60_000;
  * Emit one `memory_tier` watchdog event for this assistant's current tier.
  *
  * Consent-gated like the config-setting snapshot but with NO memo: every
- * invocation emits, so the platform sees a periodic heartbeat of the current
+ * invocation emits, so the cloud sees a periodic heartbeat of the current
  * tier rather than only edges. An UNKNOWN consent state skips entirely
  * (consent resolves asynchronously after boot; the boot-retry loop re-invokes
  * once it lands) — deferring loses nothing since the tier is re-derivable

package/src/telemetry/telemetry-event-sources.test.ts

@@ -155,7 +155,7 @@ describe("onboarding_research source: flushes via the default outbox source", ()
 
   test("ships pending rows regardless of diagnostics consent, like every other outbox event", () => {
     // No flush-time diagnostics gate: the daemon rides `share_analytics`
-    // only and leaves the diagnostics decision to the platform's
+    // only and leaves the diagnostics decision to the cloud's
     // authoritative server-side ingest gate. Diagnostics off (and even a
     // stale accepted version) must not hold the row back.
     setShareDiagnostics(false, "2000-01-01");
@@ -190,7 +190,7 @@ describe("orphan-drain source", () => {
 
   test("drains rows for a type no longer in the wire contract, then self-heals on ack", () => {
     // A row whose name isn't a current outbox event type — e.g. recorded before
-    // the platform removed the type. No per-type source queries it.
+    // the cloud removed the type. No per-type source queries it.
     const orphanName = "removed_legacy_event";
     insertOutboxRow(orphanName, "orphan-row-1");
 

package/src/telemetry/telemetry-event-sources.ts

@@ -9,11 +9,11 @@
  * which sources its reporter instance is constructed with.
  */
 
-import { queryUnreportedUsageEvents } from "../persistence/llm-usage-store.js";
 import {
   getCachedShareDiagnostics,
   getCachedShareDiagnosticsVersion,
-} from "../platform/consent-cache.js";
+} from "../cloud/consent-cache.js";
+import { queryUnreportedUsageEvents } from "../persistence/llm-usage-store.js";
 import type { UsageAttributionProfileSource } from "../usage/types.js";
 import { getLogger } from "../util/logger.js";
 import { APP_VERSION } from "../version.js";
@@ -209,12 +209,12 @@ export const ORPHAN_OUTBOX_DRAIN_SOURCE_ID = "__orphan_outbox_drain";
 
 /**
  * Synthetic ack-mode source that drains outbox rows whose `name` is no longer a
- * current outbox event type — e.g. rows recorded before the platform removed or
+ * current outbox event type — e.g. rows recorded before the cloud removed or
  * renamed a type, still pending on a client that has since upgraded. The
  * derived per-type sources ({@link OUTBOX_TELEMETRY_EVENT_NAMES}) never query
  * those names, so without this the rows would sit in the outbox forever.
  *
- * Draining is send-then-ack: the platform skips an unknown event type but still
+ * Draining is send-then-ack: the cloud skips an unknown event type but still
  * returns 2xx, after which the row is deleted. This is safe against a stale
  * local wire copy — a name merely missing from a lagging wire still ships and
  * lands rather than being purged and lost — and rides `share_analytics` like
@@ -304,7 +304,7 @@ const usageSource = simpleSource(
     // Record-time version when present; otherwise the running
     // binary's `APP_VERSION` (a legacy row from before
     // migration 267 ran). We deliberately don't emit explicit
-    // `null` — under the platform contract a present-but-null
+    // `null` — under the cloud contract a present-but-null
     // per-event value would override the envelope, and we'd
     // rather have a concrete version than no version.
     assistant_version: e.assistantVersion ?? APP_VERSION,
@@ -345,12 +345,12 @@ const turnSource: TelemetryEventSource = {
     // deferred turn (and everything after it) is picked up on a later flush
     // once its response settles.
     //
-    // Trace eligibility is composed daemon-side to mirror the platform's
+    // Trace eligibility is composed daemon-side to mirror the cloud's
     // authoritative owner-based ingest gate, so traces for ineligible owners
     // never leave the device. Two parts, fail-closed (both must be true):
     //   1. the owner's cached `share_diagnostics` consent, and
     //   2. the owner's cached `share_diagnostics_accepted_version` being at or
-    //      past the disclosing version — the platform applies the identical
+    //      past the disclosing version — the cloud applies the identical
     //      check, so an old consent never yields a trace here or there.
     const traceEligible =
       getCachedShareDiagnostics() &&
@@ -467,7 +467,7 @@ const turnSource: TelemetryEventSource = {
         // to `messages` is a separate (larger) migration; until
         // then we stamp the running binary's `APP_VERSION` so the
         // wire value is concrete (matches what the envelope would
-        // have provided, but per-event so it survives the platform
+        // have provided, but per-event so it survives the cloud
         // contract that treats present per-event values as winning
         // over the envelope).
         assistant_version: APP_VERSION,
@@ -517,7 +517,7 @@ const toolExecutedSource = simpleSource(
     // `tool_invocations` has no record-time version column — stamp
     // the running binary's `APP_VERSION` so the wire value is
     // concrete rather than an explicit null that would override the
-    // envelope under the platform's per-event-wins contract.
+    // envelope under the cloud's per-event-wins contract.
     assistant_version: APP_VERSION,
   }),
 );

package/src/telemetry/telemetry-events-outbox.ts

@@ -9,9 +9,9 @@
 import { asc, eq, inArray } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { getRawShareAnalytics } from "../cloud/consent-cache.js";
 import { getSqliteFrom, getTelemetryDb } from "../persistence/db-connection.js";
 import { telemetryEvents } from "../persistence/schema/index.js";
-import { getRawShareAnalytics } from "../platform/consent-cache.js";
 import { APP_VERSION } from "../version.js";
 import type {
   OutboxTelemetryEventName,
@@ -221,7 +221,7 @@ export function discardPendingTelemetryOutboxEvents(name: string): void {
 /**
  * Distinct event names with at least one pending row in the outbox. Used by the
  * orphan-drain source to find rows whose type is no longer in the wire contract
- * (e.g. recorded before the platform removed/renamed a type) so they can be
+ * (e.g. recorded before the cloud removed/renamed a type) so they can be
  * flushed instead of stranded. Empty when the telemetry DB is unavailable.
  */
 export function queryDistinctOutboxEventNames(): string[] {

package/src/telemetry/telemetry-wire-validation.test.ts

@@ -131,7 +131,7 @@ describe("validateWireEvents", () => {
   });
 
   test("unknown event types are reported and warned once per process per type", () => {
-    // A type the platform ingest endpoint has no serializer for: the server
+    // A type the cloud ingest endpoint has no serializer for: the server
     // silently skips it. Uses a synthetic never-shipped discriminant so the
     // test stays valid as real event types graduate into the wire contract.
     const unknownEvent = {

package/src/telemetry/telemetry-wire-validation.ts

@@ -2,7 +2,7 @@
  * Pre-flush validation of outgoing telemetry events against the
  * platform-generated wire schemas (`telemetry-wire.generated.ts`).
  *
- * The platform ingest endpoint rejects individual events that violate its
+ * The cloud ingest endpoint rejects individual events that violate its
  * serializer bounds and skips event types it has no serializer for — both
  * silently from the daemon's point of view (the batch still 2xxes). This
  * module surfaces those would-be-silent drops as structured warnings at the
@@ -73,7 +73,7 @@ export function getWireSchemaForType(type: string): z.ZodObject | undefined {
  * the refined wire schemas; this drops the claims/suggestions byte-bound
  * superRefines, which aren't expressible in the request type anyway — the
  * handler still validates the assembled event against the full wire schema
- * ({@link getWireSchemaForType}) for those bounds. Undefined when the platform
+ * ({@link getWireSchemaForType}) for those bounds. Undefined when the cloud
  * contract has no serializer for `type`.
  */
 export function getWireFieldsSchema(type: string): z.ZodObject | undefined {
@@ -113,7 +113,7 @@ interface WireValidationResult {
 }
 
 /**
- * Validate a batch of outgoing telemetry events against the platform wire
+ * Validate a batch of outgoing telemetry events against the cloud wire
  * schemas, logging a structured warning for each event the server would
  * silently drop. Warn payloads carry the event `type` and issue
  * `{ path, code }` shapes only — never field values, and never dynamic key

package/src/telemetry/telemetry-wire.generated.ts

@@ -442,7 +442,7 @@ export const telemetryEventSchema = z.discriminatedUnion("type", [
 ]);
 export type TelemetryEvent = z.infer<typeof telemetryEventSchema>;
 
-// Event types recorded SERVER-SIDE by the platform. A daemon-sent
+// Event types recorded SERVER-SIDE by the cloud. A daemon-sent
 // event of one of these types is rejected (dropped) by ingest.
 export const PLATFORM_MANAGED_EVENT_TYPES = [
   "credit_balance_depleted",

package/src/telemetry/tool-audit.ts

@@ -26,11 +26,11 @@
  * are unaffected — `tool_invocations` is a local always-on audit log.
  */
 
+import { getRawShareAnalytics } from "../cloud/consent-cache.js";
 import {
   type LifecycleEventAttributes,
   recordLifecycleEvent,
 } from "../persistence/lifecycle-events-store.js";
-import { getRawShareAnalytics } from "../platform/consent-cache.js";
 import { redactJsonStringLeaves } from "../security/redact-json.js";
 import { redactSensitiveFields } from "../security/redaction.js";
 import { redactSecrets } from "../security/secret-scanner.js";

package/src/telemetry/tool-executed-events-store.test.ts

@@ -4,7 +4,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // when populating the telemetry columns.
 let shareAnalytics = true;
 
-mock.module("../platform/consent-cache.js", () => ({
+mock.module("../cloud/consent-cache.js", () => ({
   getRawShareAnalytics: () => shareAnalytics,
 }));
 

package/src/telemetry/trace-collection-policy.ts

@@ -5,17 +5,17 @@
  * collected from owners who accepted the diagnostics-sharing consent copy that
  * *discloses* trace collection — identified by its accepted version.
  *
- * This mirrors the platform's authoritative ingest gate in
+ * This mirrors the cloud's authoritative ingest gate in
  * `mycadet-platform`:
  *   - `django/app/core/trace_collection.py` (`is_trace_collection_enabled`)
  *   - `config.settings.TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION`
  *
  * The daemon applies the same `share_diagnostics_accepted_version >= threshold`
- * check the platform does, so traces for ineligible owners never leave the
- * device. (The platform would drop them anyway, but checking here keeps the PII
+ * check the cloud does, so traces for ineligible owners never leave the
+ * device. (The cloud would drop them anyway, but checking here keeps the PII
  * local — data minimization.)
  *
- * Keep this constant in lockstep with the platform setting. Versions are
+ * Keep this constant in lockstep with the cloud setting. Versions are
  * "YYYY-MM-DD" strings, so the lexicographic compare is chronological; ""
  * (never accepted) and older versions fail closed.
  */

package/src/telemetry/turn-events-store.ts

@@ -179,7 +179,7 @@ export function queryUnreportedTurnEvents(
       // sqlite's `json_extract` yields 1/0 for JSON booleans, not true/false,
       // and SQL NULL when the path is absent (rows predating the field). Kept
       // numeric here and converted below. A raw pass-through would put `1`
-      // on the wire, which the platform's BooleanField would reject.
+      // on the wire, which the cloud's BooleanField would reject.
       scripted: sql<
         number | null
       >`json_extract(${messages.metadata}, '$.scripted')`.as("scripted"),

package/src/telemetry/turn-outcome.ts

@@ -71,7 +71,7 @@ export function stampTurnOutcome(
   try {
     // The failure* keys are read back by `readTurnFailure` only; the turn
     // telemetry projection (`queryUnreportedTurnEvents`) extracts none of
-    // them, so nothing here changes the platform wire contract.
+    // them, so nothing here changes the cloud wire contract.
     updateMessageMetadata(userMessageId, {
       turnOutcome: outcome,
       ...(extras.batchedInto ? { turnBatchedInto: extras.batchedInto } : {}),

package/src/telemetry/turn-trace-store.ts

@@ -345,9 +345,9 @@ export function assembleTurnTrace(boundary: TurnTraceBoundary): TurnTrace {
 }
 
 /**
- * Maximum serialized size of a trace the platform will accept (it drops traces
+ * Maximum serialized size of a trace the cloud will accept (it drops traces
  * whose JSON exceeds ~256 KiB). Keep the daemon-side cap a touch under that so
- * we never ship a trace the platform will silently drop. A trace over the cap
+ * we never ship a trace the cloud will silently drop. A trace over the cap
  * is omitted entirely (the trace-free turn row still flushes).
  */
 export const MAX_TRACE_SERIALIZED_BYTES = 256 * 1024;

package/src/telemetry/types.test.ts

@@ -9,7 +9,7 @@ import type { TurnTelemetryEvent } from "./types.js";
 
 // Runtime contract test: events constructed with the daemon's types (the
 // shared fixtures are annotated with them) must parse against the generated
-// wire schemas — the same validation the platform's ingest serializers
+// wire schemas — the same validation the cloud's ingest serializers
 // apply. A daemon type whose values can't round-trip through
 // `telemetryEventSchema` produces events the server silently drops.
 

package/src/telemetry/types.ts

@@ -16,7 +16,7 @@ export interface TelemetryEventBase {
    * back-compat with platforms that haven't deployed the per-event
    * handling.
    *
-   * The platform's `TelemetryIngestView` prefers per-event over
+   * The cloud's `TelemetryIngestView` prefers per-event over
    * envelope: when a per-event value is present (including explicit
    * `null`) it wins. When the field is omitted on the event entirely
    * (old assistant), the envelope value is the back-compat fallback.
@@ -30,7 +30,7 @@ export interface TelemetryEventBase {
    * stamp the flushing binary's `APP_VERSION`. Stamping `APP_VERSION`
    * instead of emitting explicit `null` preserves envelope-equivalent
    * behavior under the per-event-wins contract. The type allows
-   * `null` for parity with the platform contract; in practice the
+   * `null` for parity with the cloud contract; in practice the
    * daemon never sends it.
    */
   assistant_version: string | null;
@@ -44,7 +44,7 @@ export interface TelemetryEventBase {
  *
  * `provider`/`model` are nullable on the wire because rows persisted before
  * the attribution columns existed, and rows whose attribution resolution
- * failed, must still ship; the platform serializer accepts null.
+ * failed, must still ship; the cloud serializer accepts null.
  */
 export interface ModelTelemetryEventBase extends TelemetryEventBase {
   /** Provider serving the call, e.g. "anthropic", "fireworks". */
@@ -61,7 +61,7 @@ export interface ModelTelemetryEventBase extends TelemetryEventBase {
  * Applies the daemon's record-time guarantee to a wire-derived event type.
  *
  * The wire contract marks `assistant_version` optional for back-compat with
- * old daemons; under the platform's per-event-wins contract a present
+ * old daemons; under the cloud's per-event-wins contract a present
  * per-event value (including explicit `null`) beats the envelope fallback.
  * This daemon always stamps the field at record time (see
  * {@link TelemetryEventBase.assistant_version} for the full contract), so
@@ -204,7 +204,7 @@ export interface TurnTelemetryClientInfo {
  * role `"user"` keep that role here so the transcript is faithful to what was
  * sent to the model. `content` is the parsed `messages.content` — either the
  * modern `ContentBlock[]` (text / tool_use / tool_result / thinking / image /
- * file blocks) or a legacy plain string. Stored verbatim by the platform as an
+ * file blocks) or a legacy plain string. Stored verbatim by the cloud as an
  * opaque JSON column, so the shape is self-describing rather than normalized.
  */
 export interface TurnTraceMessage {
@@ -259,7 +259,7 @@ export interface TurnTraceToolCall {
  * turn and the next real user turn. Attached to the turn telemetry event's
  * `trace` field ONLY when trace collection is enabled — the owner's
  * `share_diagnostics` consent at an eligible accepted version.
- * The platform stores this verbatim as an opaque JSON column, so the daemon
+ * The cloud stores this verbatim as an opaque JSON column, so the daemon
  * owns the shape.
  *
  * Each turn's trace is its natural window. A turn whose window holds no
@@ -278,7 +278,7 @@ export interface TurnTraceToolDefinition {
 }
 
 export interface TurnTrace {
-  /** Shape version so the platform/dbt can evolve parsing without ambiguity. */
+  /** Shape version so the cloud/dbt can evolve parsing without ambiguity. */
   schema_version: 3;
   /**
    * Ordered message rows for the turn (the user message first, then assistant
@@ -424,7 +424,7 @@ export interface TurnTelemetryEvent extends TelemetryEventBase {
    * composes the gate itself from the owner's cached `share_diagnostics`
    * consent AND the accepted consent version being at or past the disclosing
    * version. Fail-closed: when either is off (or unknown) no trace
-   * is attached. The platform dual-writes consented traces into a separate PII
+   * is attached. The cloud dual-writes consented traces into a separate PII
    * table and keeps the trace-free turn row; downstream consumers that don't
    * read traces ignore this field. Null / absent when the gate is off or the
    * serialized trace exceeded the size cap.
@@ -479,7 +479,7 @@ export interface SkillLoadedTelemetryEvent extends ModelTelemetryEventBase {
  * watchdog observes liveness/health signals (event-loop block, stream-idle
  * stalls, restarts, ...) and emits one event per check firing.
  *
- * Deliberately minimal and forward-compatible, mirroring the platform
+ * Deliberately minimal and forward-compatible, mirroring the cloud
  * `WatchdogTelemetryEventSerializer`:
  *
  *   - `check_name` — which watchdog check fired. Open string set (not a
@@ -488,7 +488,7 @@ export interface SkillLoadedTelemetryEvent extends ModelTelemetryEventBase {
  *     downstream. The infrastructure admin chart filters this to
  *     `event_loop_blocked`.
  *   - `value` — the single measured magnitude for the check (block ms, idle
- *     ms, ...). Nullable: not every check carries a scalar. The platform
+ *     ms, ...). Nullable: not every check carries a scalar. The cloud
  *     coerces ints to float, so the daemon need not distinguish.
  *   - `detail` — open JSON bag for any extra fields the daemon attaches
  *     (reason codes, secondary numbers, a human message) without a
@@ -576,13 +576,13 @@ type Overrides = {
 };
 
 /**
- * Daemon-only event types not (yet) in the platform wire contract — i.e. types
+ * Daemon-only event types not (yet) in the cloud wire contract — i.e. types
  * the daemon emits but `POST /v1/telemetry/ingest/` would silently skip because
- * they have no serializer in the platform's `TELEMETRY_EVENT_SERIALIZERS`.
+ * they have no serializer in the cloud's `TELEMETRY_EVENT_SERIALIZERS`.
  *
  * Currently EMPTY: every emitted type is in the wire contract. When the daemon
- * needs to emit a type before the platform accepts it, add it here (keyed by
- * its wire `type`). Once the platform adds the serializer and the wire sync
+ * needs to emit a type before the cloud accepts it, add it here (keyed by
+ * its wire `type`). Once the cloud adds the serializer and the wire sync
  * lands, the key must leave `Extensions` — into `Overrides` if the daemon type
  * stays narrower than the wire, or plain wire flow-through otherwise. The
  * `_extensionsDontCollide` guard below turns red until that move is made.
@@ -596,7 +596,7 @@ export type TelemetryEvent = EventMap[keyof EventMap];
 
 /**
  * Lifecycle event — app_open, hatch, etc. 1:1 with the wire contract:
- * `telemetry-wire.generated.ts` (from the platform's
+ * `telemetry-wire.generated.ts` (from the cloud's
  * `LifecycleTelemetryEventSerializer`) is the source of truth.
  */
 export type LifecycleTelemetryEvent = EventMap["lifecycle"];
@@ -604,7 +604,7 @@ export type LifecycleTelemetryEvent = EventMap["lifecycle"];
 /**
  * Onboarding event — pre-chat selections, Google connect status, and
  * activation-funnel steps. 1:1 with the wire contract
- * (`OnboardingTelemetryEventSerializer`); the platform accepts either the
+ * (`OnboardingTelemetryEventSerializer`); the cloud accepts either the
  * legacy `screen` shape or the complete funnel step field set — see the wire
  * schema's superRefine.
  */
@@ -634,7 +634,7 @@ export type AvatarChangedTelemetryEvent = EventMap["avatar_changed"];
 
 // ---- Compile-time drift guards ----
 // Each `Overrides` entry is pinned to its wire type in BOTH directions, so a
-// wire sync PR that moves the platform contract turns red here instead of
+// wire sync PR that moves the cloud contract turns red here instead of
 // drifting silently:
 //
 //   - `_*Narrows` — the daemon type stays assignable to the wire type, i.e.
@@ -689,7 +689,7 @@ type _watchdogNarrows = AssertNarrows<
 // opaque-JSON fields are NOT excluded here: opacity is about a field's
 // SHAPE (the daemon's richer types aren't assignable to `JsonValue`), but
 // key PRESENCE is part of the typed contract — the generated wire types
-// declare `raw_usage`/`trace`/`client`/`detail`, and a platform sync that
+// declare `raw_usage`/`trace`/`client`/`detail`, and a cloud sync that
 // removed or renamed one of them would otherwise leave every guard green
 // while the daemon kept emitting a field the server discards.
 type _llmUsageKeysExist = AssertNarrows<
@@ -757,7 +757,7 @@ export type WatermarkTelemetryEventName =
 /**
  * Event names backed by the `telemetry_events` outbox: every wire event type
  * that is not watermark-flushed. Derived from the generated wire contract, so a
- * new event type added on the platform side flows onto the outbox — and gets a
+ * new event type added on the cloud side flows onto the outbox — and gets a
  * flush source (`telemetry-event-sources.ts`) and a fully-typed
  * `recordTelemetryEvent` call — with NO edit here. Each name doubles as the
  * wire `type` discriminant and the flush-group key.