@mycadet/assistant 0.12.9 → 0.12.10

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

@@ -1,102 +0,0 @@
-import { and, asc, eq, gt, isNotNull, ne, or } from "drizzle-orm";
-
-import { toolInvocations } from "../persistence/schema/index.js";
-import { getTelemetryMainDb } from "./telemetry-main-db.js";
-
-/**
- * A `tool_invocations` audit row projected for `tool_executed` telemetry
- * reporting.
- *
- * Deliberately excludes the `input` / `result` columns — raw tool
- * args/outputs are potentially PII and must never leave the device. Only the
- * payload SIZES (`argBytes` / `resultBytes`) are projected.
- */
-export interface UnreportedToolExecutedEvent {
-  id: string;
-  toolName: string;
-  /** `"allow"`-style decisions or `"error"`; never `"denied"` (filtered out). */
-  decision: string;
-  durationMs: number;
-  /** Serialized raw input size in bytes. Non-null on projected rows (the null-arg-bytes filter excludes legacy and opted-out rows). */
-  argBytes: number | null;
-  /** Raw result size in bytes, computed before truncation/redaction and sensitive-output sanitization. */
-  resultBytes: number | null;
-  provider: string | null;
-  model: string | null;
-  inferenceProfile: string | null;
-  inferenceProfileSource: string | null;
-  conversationId: string;
-  createdAt: number;
-}
-
-/**
- * Query tool invocations that haven't been reported to telemetry yet.
- * Uses a compound cursor (createdAt + id) for reliable watermarking.
- * Rows are written by the tool audit terminals (`telemetry/tool-audit.ts`) —
- * there is no record function here.
- *
- * Two row classes are excluded:
- * - Permission-denied rows: the tool never executed.
- * - Rows with null `arg_bytes`, which covers two populations:
- *   - Legacy pre-migration-278 rows: already shipped under the
- *     since-reverted `tool_execution` event type and lacking the
- *     size/attribution columns.
- *   - Rows recorded while usage data collection was opted out: the audit
- *     terminals (`telemetry/tool-audit.ts`) persist NULL telemetry columns
- *     for them at write time, making them unreportable by construction —
- *     no later opt-in or watermark race can ship them.
- *   Every opted-in post-migration writer path computes a non-null
- *   `arg_bytes` (the only other null writer, "permission_denied", is
- *   excluded by the decision filter), making `arg_bytes IS NOT NULL` a
- *   reliable discriminator. Opted-out rows recorded under builds that
- *   predate the write-time gate carry non-null columns and are guarded by
- *   the reporter's opt-out flush branch, which advances watermarks without
- *   sending (see usage-telemetry-reporter.ts).
- *
- * Reporting is best-effort: `rotateToolInvocations` purges by `created_at`
- * alone, so rows older than `auditLog.retentionDays` may rotate away before
- * they are reported.
- */
-export function queryUnreportedToolExecutedEvents(
-  afterCreatedAt: number,
-  afterId: string | undefined,
-  limit: number,
-): UnreportedToolExecutedEvent[] {
-  const db = getTelemetryMainDb();
-  const cursorPredicate = afterId
-    ? or(
-        gt(toolInvocations.createdAt, afterCreatedAt),
-        and(
-          eq(toolInvocations.createdAt, afterCreatedAt),
-          gt(toolInvocations.id, afterId),
-        ),
-      )
-    : gt(toolInvocations.createdAt, afterCreatedAt);
-  return db
-    .select({
-      id: toolInvocations.id,
-      toolName: toolInvocations.toolName,
-      decision: toolInvocations.decision,
-      durationMs: toolInvocations.durationMs,
-      argBytes: toolInvocations.argBytes,
-      resultBytes: toolInvocations.resultBytes,
-      provider: toolInvocations.provider,
-      model: toolInvocations.model,
-      inferenceProfile: toolInvocations.inferenceProfile,
-      inferenceProfileSource: toolInvocations.inferenceProfileSource,
-      conversationId: toolInvocations.conversationId,
-      createdAt: toolInvocations.createdAt,
-    })
-    .from(toolInvocations)
-    .where(
-      and(
-        ne(toolInvocations.decision, "denied"),
-        // Legacy pre-migration-278 rows — see the doc comment above.
-        isNotNull(toolInvocations.argBytes),
-        cursorPredicate,
-      ),
-    )
-    .orderBy(asc(toolInvocations.createdAt), asc(toolInvocations.id))
-    .limit(limit)
-    .all();
-}

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

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  isDiagnosticsConsentVersionEligible,
-  TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION,
-} from "./trace-collection-policy.js";
-
-describe("isDiagnosticsConsentVersionEligible", () => {
-  test("the threshold version itself is eligible (>=, inclusive boundary)", () => {
-    expect(
-      isDiagnosticsConsentVersionEligible(
-        TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION,
-      ),
-    ).toBe(true);
-  });
-
-  test("a later version is eligible", () => {
-    expect(isDiagnosticsConsentVersionEligible("2999-01-01")).toBe(true);
-  });
-
-  test("an earlier version fails closed", () => {
-    expect(isDiagnosticsConsentVersionEligible("2000-01-01")).toBe(false);
-  });
-
-  test("the empty version (never accepted / unversioned default) fails closed", () => {
-    expect(isDiagnosticsConsentVersionEligible("")).toBe(false);
-  });
-});

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

@@ -1,30 +0,0 @@
-/**
- * Per-turn trace-collection disclosure gate (daemon side).
- *
- * A "trace" is the full transcript of one assistant turn. Traces are only
- * collected from owners who accepted the diagnostics-sharing consent copy that
- * *discloses* trace collection — identified by its accepted version.
- *
- * 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 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 cloud setting. Versions are
- * "YYYY-MM-DD" strings, so the lexicographic compare is chronological; ""
- * (never accepted) and older versions fail closed.
- */
-export const TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION = "2026-06-18";
-
-/**
- * True iff `version` (the owner's `share_diagnostics_accepted_version`) is at or
- * past the disclosing version. Fails closed for "" / older versions.
- */
-export function isDiagnosticsConsentVersionEligible(version: string): boolean {
-  return version >= TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION;
-}

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

@@ -1,216 +0,0 @@
-import { and, asc, eq, gt, or, sql } from "drizzle-orm";
-
-import { getDb } from "../persistence/db-connection.js";
-import { realUserTurnContentFilter } from "../persistence/real-user-turn-filter.js";
-import { conversations, messages } from "../persistence/schema/index.js";
-
-export interface TurnEvent {
-  id: string;
-  createdAt: number;
-  /**
-   * Parent conversation id. Lets downstream analytics group turns by
-   * conversation (e.g. avg turns per conversation).
-   */
-  conversationId: string;
-  /**
-   * Conversation type of the parent conversation. Used downstream to
-   * distinguish user-initiated turns (`"standard"`) from system-generated
-   * prompts in `"background"` / `"scheduled"` conversations so analytics
-   * (e.g. DAU) can exclude the latter.
-   */
-  conversationType: string;
-  /**
-   * 1-indexed position of this user turn within the parent conversation,
-   * counting only real user turns (tool-result rows persisted with
-   * role="user" are excluded — same filter as the eligibility predicate
-   * below). The first user turn in a conversation is `1`.
-   *
-   * Computed via correlated subquery on the same filtered set used for
-   * eligibility; this scales with batch size (≤ BATCH_SIZE turns per
-   * flush) and uses the `idx_messages_conversation_id` index for the
-   * partition lookup.
-   */
-  turnIndex: number;
-  /**
-   * Canonical `InterfaceId` enum value identifying the UI surface the user
-   * was interacting from at message-creation time (`"macos"`, `"ios"`,
-   * `"cli"`, `"web"`, `"chrome-extension"`, `"slack"`, `"telegram"`,
-   * `"whatsapp"`, `"email"`, `"phone"`). Sourced from
-   * `messages.metadata.userMessageInterface` (stamped on insert by every
-   * `persistUserMessage` path that flows through `TurnChannelContext`).
-   *
-   * Null when the metadata didn't carry the field — historical rows
-   * predating the threading, or system-initiated turns with no inbound
-   * client context. Downstream analytics should treat null as
-   * `"unknown"`.
-   */
-  interfaceId: string | null;
-  /**
-   * Canonical `ChannelId` enum value identifying the messaging fabric the
-   * user message arrived on (`"cadet"` for in-app messaging from
-   * macos/ios/web/cli; `"slack"`/`"telegram"`/`"whatsapp"`/`"email"`/
-   * `"phone"` for channel-based interfaces). Sourced from
-   * `messages.metadata.userMessageChannel`.
-   *
-   * The 7th `ChannelId` value (`"platform"`) is APNs-push outbound-only
-   * and should never appear on a user-message row.
-   */
-  channelId: string | null;
-  /**
-   * Flexible client metadata stashed under `messages.metadata.client` by
-   * the HTTP header middleware. Carries optional `browserFamily`,
-   * `browserVersion`, `os`, `interfaceVersion` (and is extensible without
-   * a migration since it lives inside the JSON column). Null when no
-   * client headers were attached.
-   *
-   * Returned as raw JSON text — the reporter parses + re-shapes for the
-   * wire format.
-   */
-  clientMetadata: string | null;
-  /**
-   * Abnormal turn outcome stamped onto `messages.metadata.turnOutcome` at
-   * turn end: `"batched"` (coalesced into a later turn's shared response),
-   * `"failed"` (loop ended in a non-cancellation error), or `"cancelled"`
-   * (user stop / barge-in). Null when the turn replied normally, when the
-   * row predates outcome stamping, or when the process died mid-turn
-   * before a stamp could land.
-   */
-  outcome: string | null;
-  /**
-   * For `"batched"` turns: `messages.id` of the batch-final turn whose
-   * window carries the shared response. Null otherwise.
-   */
-  batchedInto: string | null;
-  /**
-   * For `"failed"` turns: the stable classified error code
-   * (`classifyConversationError(...).code`). Null otherwise or when the
-   * failure had no classification.
-   */
-  failureCode: string | null;
-  /**
-   * True when this turn was auto-sent on the user's behalf rather than typed
-   * by the user (onboarding research prompt, personality `<system-message>`,
-   * research corrections, kickoff greetings, legacy pre-chat bootstrap,
-   * `[User action on ...]` surface synthetics). Sourced from
-   * `messages.metadata.scripted`, stamped by `persistQueuedMessageBody`.
-   *
-   * Null ONLY for rows persisted before the field existed: scriptedness is
-   * unknown for those, which downstream must not conflate with `false`.
-   * Activation metrics exclude `true` and let `null` fall back to the legacy
-   * trace-text classifier; treating `null` as `false` is the bug this field
-   * exists to fix (ANT-10).
-   */
-  scripted: boolean | null;
-}
-
-/**
- * Query user messages (turns) that haven't been reported to telemetry yet.
- * Uses a compound cursor (createdAt + id) for reliable watermarking.
- *
- * Joins to `conversations` so each turn carries its `conversationType`.
- * The inner join is safe because `messages.conversationId` has a
- * not-null FK to `conversations.id` (cascade on delete): every message
- * row has a matching conversation row.
- *
- * `turnIndex` is computed via a correlated subquery counting the real
- * user turns in the same conversation up to and including this row.
- */
-export function queryUnreportedTurnEvents(
-  afterCreatedAt: number,
-  afterId: string | undefined,
-  limit: number,
-): TurnEvent[] {
-  const db = getDb();
-  const rows = db
-    .select({
-      id: messages.id,
-      createdAt: messages.createdAt,
-      conversationId: messages.conversationId,
-      conversationType: conversations.conversationType,
-      // 1-indexed turn position within the parent conversation. Counts
-      // only real user turns (same filter applied to the outer query).
-      // `(created_at, id)` lex-comparison matches the watermark cursor
-      // ordering so ties on `created_at` are broken deterministically.
-      turnIndex: sql<number>`(
-        SELECT COUNT(*) FROM messages AS m2
-        WHERE m2.conversation_id = ${messages.conversationId}
-          AND m2.role = 'user'
-          AND ${realUserTurnContentFilter("m2")}
-          AND (m2.created_at < ${messages.createdAt}
-               OR (m2.created_at = ${messages.createdAt}
-                   AND m2.id <= ${messages.id}))
-      )`.as("turn_index"),
-      // Client attribution: extract from `messages.metadata` JSON.
-      // `userMessageInterface` and `userMessageChannel` are stamped on
-      // insert by every `persistUserMessage` path that flows through
-      // `TurnChannelContext`. `client` is the flexible namespace for
-      // browser/os/version metadata attached by HTTP header middleware.
-      // `json_extract` returns SQL NULL when the JSON path is absent —
-      // exactly the null semantics we want on the wire.
-      interfaceId: sql<
-        string | null
-      >`json_extract(${messages.metadata}, '$.userMessageInterface')`.as(
-        "interface_id",
-      ),
-      channelId: sql<
-        string | null
-      >`json_extract(${messages.metadata}, '$.userMessageChannel')`.as(
-        "channel_id",
-      ),
-      clientMetadata: sql<
-        string | null
-      >`json_extract(${messages.metadata}, '$.client')`.as("client_metadata"),
-      // Turn-outcome stamps written at turn end (`stampTurnOutcome`).
-      // `json_extract` returns SQL NULL when the path is absent — rows
-      // predating outcome stamping and normally-replied turns project null.
-      outcome: sql<
-        string | null
-      >`json_extract(${messages.metadata}, '$.turnOutcome')`.as("outcome"),
-      batchedInto: sql<
-        string | null
-      >`json_extract(${messages.metadata}, '$.turnBatchedInto')`.as(
-        "batched_into",
-      ),
-      failureCode: sql<
-        string | null
-      >`json_extract(${messages.metadata}, '$.turnFailureCode')`.as(
-        "failure_code",
-      ),
-      // 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 cloud's BooleanField would reject.
-      scripted: sql<
-        number | null
-      >`json_extract(${messages.metadata}, '$.scripted')`.as("scripted"),
-    })
-    .from(messages)
-    .innerJoin(conversations, eq(messages.conversationId, conversations.id))
-    .where(
-      and(
-        eq(messages.role, "user"),
-        realUserTurnContentFilter("messages"),
-        afterId
-          ? or(
-              gt(messages.createdAt, afterCreatedAt),
-              and(
-                eq(messages.createdAt, afterCreatedAt),
-                gt(messages.id, afterId),
-              ),
-            )
-          : gt(messages.createdAt, afterCreatedAt),
-      ),
-    )
-    .orderBy(asc(messages.createdAt), asc(messages.id))
-    .limit(limit)
-    .all();
-  // Narrow sqlite's 1/0/NULL to boolean/null. Only a literal 1 or 0 is a real
-  // stamp; anything else (SQL NULL from a missing key, or a junk value on a
-  // row written by some other path) reports UNKNOWN rather than being coerced.
-  // Coercing to `false` would assert "the user typed this" on no evidence,
-  // which downstream trusts and cannot fall back from.
-  return rows.map((row) => ({
-    ...row,
-    scripted: row.scripted === 1 ? true : row.scripted === 0 ? false : null,
-  }));
-}