@mycadet/assistant 0.12.9 → 0.12.10

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

@@ -1,143 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import type { AssistantConfig } from "../../config/schema.js";
-import {
-  recordConfigSettingSnapshot,
-  resetConfigSettingSnapshotForTesting,
-} from "../config-setting-snapshot.js";
-import {
-  pendingOutboxPayloads,
-  resetOutboxTable,
-  setShareAnalytics,
-} from "./outbox-test-harness.js";
-
-function makeConfig(
-  memoryEnabled: boolean,
-  v2Enabled: boolean,
-  v3Live = false,
-): AssistantConfig {
-  return {
-    memory: {
-      enabled: memoryEnabled,
-      v2: { enabled: v2Enabled },
-      v3: { live: v3Live },
-    },
-  } as AssistantConfig;
-}
-
-function recordedPairs(): Array<[string, string]> {
-  return pendingOutboxPayloads<{
-    config_key: string;
-    config_value: string;
-  }>("config_setting").map((event) => [event.config_key, event.config_value]);
-}
-
-describe("config-setting-snapshot", () => {
-  beforeEach(() => {
-    setShareAnalytics(true);
-    resetOutboxTable();
-    resetConfigSettingSnapshotForTesting();
-  });
-
-  test("records every tracked setting on the first snapshot", () => {
-    recordConfigSettingSnapshot(makeConfig(true, false));
-
-    expect(recordedPairs().sort()).toEqual([
-      ["memory.enabled", "true"],
-      ["memory.v2.enabled", "false"],
-      ["memory.v3.live", "false"],
-    ]);
-  });
-
-  test("repeated snapshots with unchanged values record nothing new", () => {
-    recordConfigSettingSnapshot(makeConfig(true, true));
-    recordConfigSettingSnapshot(makeConfig(true, true));
-    recordConfigSettingSnapshot(makeConfig(true, true));
-
-    expect(recordedPairs()).toHaveLength(3);
-  });
-
-  test("a changed value records only the changed key", () => {
-    recordConfigSettingSnapshot(makeConfig(true, true));
-    resetOutboxTable();
-
-    recordConfigSettingSnapshot(makeConfig(true, false));
-
-    expect(recordedPairs()).toEqual([["memory.v2.enabled", "false"]]);
-  });
-
-  test("memory.v3.live is tracked and its flip is captured", () => {
-    recordConfigSettingSnapshot(makeConfig(true, true, false));
-    expect(recordedPairs()).toContainEqual(["memory.v3.live", "false"]);
-    resetOutboxTable();
-
-    recordConfigSettingSnapshot(makeConfig(true, true, true));
-
-    expect(recordedPairs()).toEqual([["memory.v3.live", "true"]]);
-  });
-
-  test("unknown consent skips entirely — no rows, no memo", () => {
-    setShareAnalytics("unknown");
-    recordConfigSettingSnapshot(makeConfig(true, false));
-
-    // A snapshot is re-derivable state (unlike outbox events), so nothing is
-    // recorded while consent is unresolved...
-    expect(recordedPairs()).toHaveLength(0);
-
-    // ...and nothing was memoized: once consent resolves, the next snapshot
-    // records the complete current set.
-    setShareAnalytics(true);
-    recordConfigSettingSnapshot(makeConfig(true, false));
-    expect(recordedPairs().sort()).toEqual([
-      ["memory.enabled", "true"],
-      ["memory.v2.enabled", "false"],
-      ["memory.v3.live", "false"],
-    ]);
-  });
-
-  test("consent off drops the snapshot without poisoning the memo", () => {
-    setShareAnalytics(false);
-    recordConfigSettingSnapshot(makeConfig(true, true));
-    expect(recordedPairs()).toHaveLength(0);
-
-    // A later opted-in snapshot records the full set — the opted-out attempt
-    // must not have memoized the values (mirrors the reporter's flush retry
-    // once consent resolves).
-    setShareAnalytics(true);
-    recordConfigSettingSnapshot(makeConfig(true, true));
-    expect(recordedPairs()).toHaveLength(3);
-  });
-
-  test("re-opt-in after an opt-out re-records the full snapshot", () => {
-    // Recorded while opted in.
-    recordConfigSettingSnapshot(makeConfig(true, true));
-    expect(recordedPairs()).toHaveLength(3);
-    resetOutboxTable();
-
-    // Opt out: the reporter's opt-out flush discards any pending rows, so the
-    // memo must be cleared here too.
-    setShareAnalytics(false);
-    recordConfigSettingSnapshot(makeConfig(true, true));
-    expect(recordedPairs()).toHaveLength(0);
-
-    // Re-opt-in with the SAME config: the full snapshot re-records rather than
-    // being skipped by a stale memo.
-    setShareAnalytics(true);
-    recordConfigSettingSnapshot(makeConfig(true, true));
-    expect(recordedPairs().sort()).toEqual([
-      ["memory.enabled", "true"],
-      ["memory.v2.enabled", "true"],
-      ["memory.v3.live", "false"],
-    ]);
-  });
-
-  test("a partial config skips missing keys instead of throwing", () => {
-    recordConfigSettingSnapshot({} as AssistantConfig);
-    expect(recordedPairs()).toHaveLength(0);
-
-    recordConfigSettingSnapshot({
-      memory: { enabled: true },
-    } as AssistantConfig);
-    expect(recordedPairs()).toEqual([["memory.enabled", "true"]]);
-  });
-});

package/src/telemetry/__tests__/flush-checkpoints.test.ts

@@ -1,56 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { getTelemetryDb } from "../../persistence/db-connection.js";
-import { initializeDb } from "../../persistence/db-init.js";
-import { flushCheckpoints } from "../../persistence/schema/index.js";
-import {
-  getFlushCheckpoint,
-  isFlushCheckpointStoreAvailable,
-  setFlushCheckpoint,
-} from "../flush-checkpoints.js";
-
-await initializeDb();
-
-function clearCheckpoints(): void {
-  const db = getTelemetryDb();
-  if (!db) {
-    throw new Error("telemetry DB unavailable in test");
-  }
-  db.delete(flushCheckpoints).run();
-}
-
-describe("flush-checkpoints", () => {
-  beforeEach(() => {
-    clearCheckpoints();
-  });
-
-  test("store is available once the telemetry DB is open", () => {
-    expect(isFlushCheckpointStoreAvailable()).toBe(true);
-  });
-
-  test("get returns null for an absent key", () => {
-    expect(getFlushCheckpoint("telemetry:usage:last_reported_at")).toBeNull();
-  });
-
-  test("set + get round-trips", () => {
-    setFlushCheckpoint("telemetry:usage:last_reported_at", "1700000000000");
-    expect(getFlushCheckpoint("telemetry:usage:last_reported_at")).toBe(
-      "1700000000000",
-    );
-  });
-
-  test("set overwrites an existing value", () => {
-    setFlushCheckpoint("telemetry:turns:last_reported_id", "row-1");
-    setFlushCheckpoint("telemetry:turns:last_reported_id", "row-2");
-    expect(getFlushCheckpoint("telemetry:turns:last_reported_id")).toBe(
-      "row-2",
-    );
-  });
-
-  test("keys are independent", () => {
-    setFlushCheckpoint("telemetry:usage:last_reported_at", "1");
-    setFlushCheckpoint("telemetry:turns:last_reported_at", "2");
-    expect(getFlushCheckpoint("telemetry:usage:last_reported_at")).toBe("1");
-    expect(getFlushCheckpoint("telemetry:turns:last_reported_at")).toBe("2");
-  });
-});

package/src/telemetry/__tests__/live-voice-funnel.test.ts

@@ -1,174 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  liveVoiceEndScreen,
-  liveVoiceSilenceReason,
-  liveVoiceStartScreen,
-} from "../live-voice-funnel.js";
-
-describe("liveVoiceStartScreen", () => {
-  it("stamps the client and the entry point", () => {
-    expect(liveVoiceStartScreen("macos", "companion")).toBe(
-      "started_macos:companion",
-    );
-  });
-
-  it("keeps both halves present when a client sends neither", () => {
-    // A query splits the stamp on its colon; a stand-in for a missing half
-    // keeps that split from needing a null branch per side.
-    expect(liveVoiceStartScreen(undefined, undefined)).toBe(
-      "started_unknown:unknown",
-    );
-    expect(liveVoiceStartScreen(null, null)).toBe("started_unknown:unknown");
-  });
-
-  it("stands in for whichever half is missing on its own", () => {
-    expect(liveVoiceStartScreen("ios")).toBe("started_ios:unknown");
-    expect(liveVoiceStartScreen(undefined, "deep_link")).toBe(
-      "started_unknown:deep_link",
-    );
-  });
-
-  it("keeps the longest stamp inside the wire field's 64-char bound", () => {
-    // The parser caps `entry` at 32 characters and the longest `ClientOs` is
-    // `windows`; the stamp built from both must still fit the ingest cap.
-    const longest = liveVoiceStartScreen("windows", "a".repeat(32));
-    expect(longest.length).toBeLessThanOrEqual(64);
-  });
-});
-
-describe("liveVoiceSilenceReason", () => {
-  it("blames the transport when the session never went active", () => {
-    // Nothing after `ready` can be held against a session that never got
-    // there: the user had no chance to speak.
-    expect(
-      liveVoiceSilenceReason({
-        reachedActive: false,
-        audioInput: true,
-        receivedAudio: false,
-        detectedSpeech: false,
-      }),
-    ).toBe("no_ready");
-  });
-
-  it("blames the transport even if stray audio arrived first", () => {
-    // Audio can land before the preflight resolves. The session still never
-    // became usable, and reporting that as a microphone problem would send
-    // someone looking in the wrong layer.
-    expect(
-      liveVoiceSilenceReason({
-        reachedActive: false,
-        audioInput: true,
-        receivedAudio: true,
-        detectedSpeech: true,
-      }),
-    ).toBe("no_ready");
-  });
-
-  it("reports a microphone that never opened", () => {
-    expect(
-      liveVoiceSilenceReason({
-        reachedActive: true,
-        audioInput: true,
-        receivedAudio: false,
-        detectedSpeech: false,
-      }),
-    ).toBe("no_audio");
-  });
-
-  it("separates a mic that opened but carried no speech", () => {
-    // The distinction that makes this taxonomy worth having: a denied
-    // permission and a muted mic both produce a silent session, and only this
-    // pair of flags tells them apart.
-    expect(
-      liveVoiceSilenceReason({
-        reachedActive: true,
-        audioInput: true,
-        receivedAudio: true,
-        detectedSpeech: false,
-      }),
-    ).toBe("no_speech");
-  });
-
-  it("does not blame the microphone on a session that never had one", () => {
-    // A text-only session opened because speech-to-text was unavailable and
-    // the client could type. Scoring the absent microphone as `no_audio` would
-    // file it under a failure it does not have, and inflate the very rate this
-    // taxonomy exists to explain.
-    expect(
-      liveVoiceSilenceReason({
-        reachedActive: true,
-        audioInput: false,
-        receivedAudio: false,
-        detectedSpeech: false,
-      }),
-    ).toBe("text_only");
-  });
-
-  it("still reports text_only when a text-only session streamed stray audio", () => {
-    // A client that has not caught up with `audioInput: false` may keep
-    // sending chunks. Nothing transcribes them, so they say nothing about why
-    // the session was silent, and the reason must not flip on their account.
-    expect(
-      liveVoiceSilenceReason({
-        reachedActive: true,
-        audioInput: false,
-        receivedAudio: true,
-        detectedSpeech: true,
-      }),
-    ).toBe("text_only");
-  });
-
-  it("reports speech that never became a turn", () => {
-    expect(
-      liveVoiceSilenceReason({
-        reachedActive: true,
-        audioInput: true,
-        receivedAudio: true,
-        detectedSpeech: true,
-      }),
-    ).toBe("no_turn");
-  });
-});
-
-describe("liveVoiceEndScreen", () => {
-  it("carries the close reason alone when nothing else applies", () => {
-    expect(liveVoiceEndScreen("client_end")).toBe("ended_client_end");
-  });
-
-  it("carries a failure code in the detail slot", () => {
-    expect(liveVoiceEndScreen("error", "invalid_field")).toBe(
-      "ended_error:invalid_field",
-    );
-  });
-
-  it("carries a silence reason when the session merely produced nothing", () => {
-    expect(liveVoiceEndScreen("client_end", null, "no_audio")).toBe(
-      "ended_client_end:silent_no_audio",
-    );
-  });
-
-  it("prefers the failure code when a session both failed and was silent", () => {
-    // A session that died on an error is explained by the error; its silence
-    // is a consequence, not a second finding.
-    expect(liveVoiceEndScreen("error", "invalid_field", "no_audio")).toBe(
-      "ended_error:invalid_field",
-    );
-  });
-
-  it("keeps every combination inside the wire field's 64-char bound", () => {
-    // `screen` is capped at 64 chars by the ingest serializer and an over-long
-    // value is dropped silently, taking the whole row with it.
-    const longest = liveVoiceEndScreen("transport_closed", null, "no_speech");
-    expect(longest.length).toBeLessThanOrEqual(64);
-  });
-
-  it("prefixes the silence value so it reads correctly in a mislabelled column", () => {
-    // It shares the detail slot with failure codes, and the admin dashboard
-    // renders that slot under a "failure code" header until it learns the
-    // difference. The prefix keeps the value honest meanwhile.
-    expect(liveVoiceEndScreen("client_end", null, "no_turn")).toContain(
-      "silent_",
-    );
-  });
-});

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

@@ -1,85 +0,0 @@
-import { mock, spyOn } from "bun:test";
-
-import type { ConsentState } from "../../cloud/consent-cache.js";
-
-let shareAnalytics: ConsentState = true;
-// Owner's `share_diagnostics` consent + accepted version — a second,
-// independent gate some outbox event types layer on top of
-// `share_analytics` (their payload carries content richer than metadata).
-// Default permissive/far-future so tests that only care about the analytics
-// gate are unaffected; the diagnostics-specific cases override via
-// `setShareDiagnostics`.
-let shareDiagnostics = true;
-let shareDiagnosticsVersion = "2999-01-01";
-
-// Installed when this harness is imported. bun's mock.module patches
-// retroactively (live bindings), so importers need no special import order.
-// This harness is imported by *.test.ts files only — never by the test
-// 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("../../cloud/consent-cache.js", () => ({
-  getRawShareAnalytics: () => shareAnalytics,
-  getCachedShareDiagnostics: () => shareDiagnostics,
-  getCachedShareDiagnosticsVersion: () => shareDiagnosticsVersion,
-}));
-
-import * as dbConnection from "../../persistence/db-connection.js";
-import { getTelemetryDb } from "../../persistence/db-connection.js";
-import { initializeDb } from "../../persistence/db-init.js";
-import { telemetryEvents } from "../../persistence/schema/index.js";
-import { queryTelemetryOutboxBatch } from "../telemetry-events-outbox.js";
-
-await initializeDb();
-
-/** Flip the mocked share_analytics consent; call with true in beforeEach. */
-export function setShareAnalytics(value: ConsentState): void {
-  shareAnalytics = value;
-}
-
-/**
- * Flip the mocked share_diagnostics consent and, optionally, its accepted
- * version (defaults far-future/unconditionally eligible). Call with `true`
- * in `beforeEach` for stores that gate on it.
- */
-export function setShareDiagnostics(
-  value: boolean,
-  version = "2999-01-01",
-): void {
-  shareDiagnostics = value;
-  shareDiagnosticsVersion = version;
-}
-
-/** Delete every telemetry_events row. */
-export function resetOutboxTable(): void {
-  const db = getTelemetryDb();
-  if (!db) {
-    throw new Error("telemetry DB unavailable in test");
-  }
-  db.delete(telemetryEvents).run();
-}
-
-/** Pending rows for one event name in (created_at, id) order. */
-export function pendingOutboxRows(name: string, limit = 100) {
-  return queryTelemetryOutboxBatch(name, limit);
-}
-
-/** Pending payloads for one event name, JSON-parsed, in flush order. */
-export function pendingOutboxPayloads<T = Record<string, unknown>>(
-  name: string,
-  limit = 100,
-): T[] {
-  return pendingOutboxRows(name, limit).map(
-    (row) => JSON.parse(row.payload) as T,
-  );
-}
-
-/** Run `fn` with the telemetry connection reported as unavailable. */
-export function withTelemetryDbUnavailable(fn: () => void): void {
-  const spy = spyOn(dbConnection, "getTelemetryDb").mockReturnValue(null);
-  try {
-    fn();
-  } finally {
-    spy.mockRestore();
-  }
-}

package/src/telemetry/__tests__/phone-call-funnel.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  PHONE_CALL_STEPS,
-  phoneCallEndScreen,
-  phoneCallSilenceReason,
-  phoneCallStartScreen,
-} from "../phone-call-funnel.js";
-
-describe("phoneCallStartScreen", () => {
-  it("stamps the direction and the call mode", () => {
-    expect(phoneCallStartScreen("inbound", "normal")).toBe(
-      "started_inbound:normal",
-    );
-    expect(phoneCallStartScreen("outbound", "verification")).toBe(
-      "started_outbound:verification",
-    );
-  });
-
-  it("reads an unwritten mode as the ordinary call it is", () => {
-    // Only verification and invite calls write a mode, so a null there is a
-    // normal conversation rather than a dimension nobody filled in.
-    expect(phoneCallStartScreen("inbound", null)).toBe(
-      "started_inbound:normal",
-    );
-    expect(phoneCallStartScreen("inbound")).toBe("started_inbound:normal");
-  });
-
-  it("keeps the longest stamp inside the wire field's 64-char bound", () => {
-    const longest = phoneCallStartScreen("outbound", "verification");
-    expect(longest.length).toBeLessThanOrEqual(64);
-  });
-});
-
-describe("phoneCallSilenceReason", () => {
-  it("blames the connection when the call never reached the caller", () => {
-    // Nothing that happens on a live call can be held against one that never
-    // connected: nobody was there to speak.
-    expect(phoneCallSilenceReason({ connected: false })).toBe("no_connect");
-  });
-
-  it("reports a connected call that took no turn as silence on the line", () => {
-    expect(phoneCallSilenceReason({ connected: true })).toBe("no_turn");
-  });
-});
-
-describe("phoneCallEndScreen", () => {
-  it("stamps the terminal status on a call that took a turn", () => {
-    expect(phoneCallEndScreen("completed")).toBe("ended_completed");
-    expect(phoneCallEndScreen("failed", null)).toBe("ended_failed");
-  });
-
-  it("carries the silence classification when no turn was taken", () => {
-    expect(phoneCallEndScreen("failed", "no_connect")).toBe(
-      "ended_failed:silent_no_connect",
-    );
-    expect(phoneCallEndScreen("completed", "no_turn")).toBe(
-      "ended_completed:silent_no_turn",
-    );
-  });
-});
-
-describe("PHONE_CALL_STEPS", () => {
-  it("orders the pair the warehouse subtracts", () => {
-    // Duration is the gap between these two rows, so their order is part of
-    // the contract rather than a label.
-    expect(PHONE_CALL_STEPS.callStarted.stepIndex).toBe(0);
-    expect(PHONE_CALL_STEPS.callEnded.stepIndex).toBe(1);
-    expect(PHONE_CALL_STEPS.callStarted.stepName).toBe("phone_call_started");
-    expect(PHONE_CALL_STEPS.callEnded.stepName).toBe("phone_call_ended");
-  });
-});