@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/channel-setup-panel-ack.test.ts

@@ -0,0 +1,184 @@
+/**
+ * `ui_show channel_setup` acknowledgment flow.
+ *
+ * `open_panel` is a side-effect-only command that is never persisted to the
+ * transcript, so a dropped event is unrecoverable. The tool result must
+ * therefore be gated on a client acknowledgment: "displayed" means a client
+ * actually rendered the drawer; every other outcome (nack, timeout, no
+ * client, aborted turn) is a tool error the model can act on instead of
+ * announcing a panel the user cannot see.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { OpenPanelEvent } from "../api/events/open-panel.js";
+import {
+  createSurfaceMutex,
+  handleSurfaceAction,
+  openChannelSetupPanel,
+  type SurfaceConversationContext,
+  surfaceProxyResolver,
+} from "../daemon/conversation-surfaces.js";
+import type {
+  ServerMessage,
+  SurfaceData,
+  SurfaceType,
+} from "../daemon/message-protocol.js";
+
+function makeContext(
+  sent: ServerMessage[] = [],
+  overrides: Partial<SurfaceConversationContext> = {},
+): SurfaceConversationContext {
+  return {
+    conversationId: "session-1",
+    traceEmitter: { emit: () => {} },
+    sendToClient: (msg) => sent.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map<
+      string,
+      { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    >(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
+    surfaceActionRequestIds: new Set<string>(),
+    pendingStandaloneSurfaces: new Map(),
+    recentlyCompletedStandaloneSurfaces: new Map(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "ok",
+    withSurface: createSurfaceMutex(),
+    ...overrides,
+  };
+}
+
+function findOpenPanel(sent: ServerMessage[]): OpenPanelEvent | undefined {
+  return sent.find((msg): msg is OpenPanelEvent => msg.type === "open_panel");
+}
+
+async function waitForOpenPanel(
+  sent: ServerMessage[],
+): Promise<OpenPanelEvent> {
+  for (let i = 0; i < 20 && !findOpenPanel(sent); i++) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  const event = findOpenPanel(sent);
+  expect(event).toBeDefined();
+  return event!;
+}
+
+describe("ui_show channel_setup acknowledgment", () => {
+  test("emits open_panel with a surfaceId and succeeds once the client acks", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const resultPromise = surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "channel_setup",
+      data: { channel: "slack" },
+    });
+
+    const event = await waitForOpenPanel(sent);
+    expect(event.panelType).toBe("channel_setup");
+    expect(event.conversationId).toBe("session-1");
+    expect(event.data).toEqual({ channel: "slack" });
+    expect(typeof event.surfaceId).toBe("string");
+
+    const surfaceId = event.surfaceId!;
+    expect(ctx.pendingStandaloneSurfaces!.has(surfaceId)).toBe(true);
+    // Registered so the surface-action route can resolve the conversation
+    // by surfaceId when the ack arrives.
+    expect(ctx.surfaceState.get(surfaceId)?.surfaceType).toBe("channel_setup");
+
+    await handleSurfaceAction(ctx, surfaceId, "ack");
+
+    const result = await resultPromise;
+    expect(result.isError).toBe(false);
+    expect(JSON.parse(result.content as string)).toEqual({
+      surfaceId,
+      status: "displayed",
+    });
+
+    // Ack consumed the pending entry without leaking surface state.
+    expect(ctx.pendingStandaloneSurfaces!.size).toBe(0);
+    expect(ctx.surfaceState.has(surfaceId)).toBe(false);
+  });
+
+  test("returns a tool error when the client nacks", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const resultPromise = surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "channel_setup",
+      data: { channel: "slack" },
+    });
+
+    const event = await waitForOpenPanel(sent);
+    await handleSurfaceAction(ctx, event.surfaceId!, "nack", {
+      reason: "no_active_assistant",
+    });
+
+    const result = await resultPromise;
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("no_active_assistant");
+    expect(result.content).toContain("Do NOT tell the user the panel is open");
+  });
+
+  test("fails closed without emitting when no interactive client is connected", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, { hasNoClient: true });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "channel_setup",
+      data: { channel: "slack" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("no connected client");
+    expect(findOpenPanel(sent)).toBeUndefined();
+  });
+
+  test("times out into a tool error when no client acknowledges", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const ack = await openChannelSetupPanel(
+      ctx,
+      "surface-timeout",
+      { channel: "slack" },
+      { timeoutMs: 10 },
+    );
+
+    expect(ack.status).toBe("timed_out");
+    // Timed-out entries are fully cleaned up and tombstoned so a late ack
+    // cannot fall through to the LLM-turn path.
+    expect(ctx.pendingStandaloneSurfaces!.size).toBe(0);
+    expect(ctx.surfaceState.has("surface-timeout")).toBe(false);
+    expect(
+      ctx.recentlyCompletedStandaloneSurfaces!.has("surface-timeout"),
+    ).toBe(true);
+  });
+
+  test("resolves cancelled when the turn is aborted mid-wait", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+    const controller = new AbortController();
+
+    const ackPromise = openChannelSetupPanel(
+      ctx,
+      "surface-abort",
+      { channel: "slack" },
+      { signal: controller.signal, timeoutMs: 5_000 },
+    );
+    controller.abort();
+
+    const ack = await ackPromise;
+    expect(ack.status).toBe("cancelled");
+    expect(ack.cancellationReason).toBe("resolver_unavailable");
+    expect(ctx.pendingStandaloneSurfaces!.size).toBe(0);
+    expect(ctx.surfaceState.has("surface-abort")).toBe(false);
+  });
+});

package/src/__tests__/clear-all-lexical.test.ts

@@ -0,0 +1,90 @@
+// clearAll() must drop the memory feature's bulk per-message index (the whole
+// lexical Qdrant collection) — a "delete all" leaves no conversation ids to key
+// per-conversation purges on, so the points would otherwise survive a
+// "permanently delete everything" action. clearAll routes this through the
+// `MemoryPersistenceHooks.onAllConversationsCleared` seam (persistence stays
+// decoupled from the plugin); the memory plugin's impl calls
+// `clearMessagesLexicalIndex`. This asserts the full chain fires.
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+// Spy on `clearMessagesLexicalIndex` (the plugin's `onAllConversationsCleared`
+// impl calls it) while keeping the rest of the module REAL. `mock.module` is
+// process-global and not undone by `mock.restore()`, so a partial mock that
+// drops the other exports would leak into any later test file in the same
+// process that imports them (e.g. the handler tests importing
+// `indexMessageLexicalJob`). Spread the real module so only this one export is
+// replaced. Importing the real module here is safe: its deps
+// (`@qdrant/js-client-rest`, `uuid`, the local TF-IDF encoder) resolve in the
+// worktree.
+const actualLexical =
+  await import("../persistence/job-handlers/message-lexical.js");
+let clearCalls = 0;
+mock.module("../persistence/job-handlers/message-lexical.js", () => ({
+  ...actualLexical,
+  clearMessagesLexicalIndex: async () => {
+    clearCalls += 1;
+  },
+}));
+
+import { clearAll } from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  getMemoryPersistenceHooks,
+  registerMemoryPersistenceHooks,
+  resetMemoryPersistenceHooksForTests,
+} from "../persistence/memory-lifecycle-hooks.js";
+import { registerDefaultPluginPersistenceHooks } from "../plugins/defaults/index.js";
+
+await initializeDb();
+
+describe("clearAll bulk lexical index cleanup", () => {
+  beforeEach(() => {
+    clearCalls = 0;
+    // Register the real memory persistence hooks so `onAllConversationsCleared`
+    // routes to the plugin impl (which calls the spied clear helper).
+    registerDefaultPluginPersistenceHooks();
+  });
+
+  test("clearAll fires onAllConversationsCleared, which clears the lexical index", async () => {
+    await clearAll();
+    expect(clearCalls).toBe(1);
+  });
+
+  test("clearAll AWAITS the collection drop before returning", async () => {
+    // The drop must complete before clearAll resolves — otherwise a write right
+    // after clear-all could land in a collection that is about to be dropped.
+    // Register a hook whose drop yields to the microtask queue before finishing;
+    // if clearAll did not await, `dropCompleted` would still be false here.
+    let dropCompleted = false;
+    registerMemoryPersistenceHooks({
+      ...getMemoryPersistenceHooks(),
+      async onAllConversationsCleared() {
+        await new Promise((r) => setTimeout(r, 10));
+        dropCompleted = true;
+      },
+    });
+
+    await clearAll();
+    expect(dropCompleted).toBe(true);
+
+    registerDefaultPluginPersistenceHooks();
+  });
+
+  test("clearAll is a safe no-op when the memory hooks are not registered", async () => {
+    // Persistence must work with no memory present — the seam falls through to
+    // its no-op and clearAll does not touch the lexical index.
+    resetMemoryPersistenceHooksForTests();
+    clearCalls = 0;
+    await clearAll();
+    expect(clearCalls).toBe(0);
+    // Restore for any later test in the same process.
+    registerDefaultPluginPersistenceHooks();
+  });
+});

package/src/__tests__/compactor-media-strip.test.ts

@@ -0,0 +1,177 @@
+import { describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  getMessages: () => [],
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../persistence/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+import { runAssistantDrivenCompaction } from "../context/compactor.js";
+import type { Message, Provider } from "../providers/types.js";
+
+const TAIL_TIMESTAMP =
+  "2026-05-21 (Thursday) 10:00:00 -05:00 (America/Chicago)";
+
+const compactionResponse = `
+<compaction_result>
+<summary>
+Earlier turns summarized here.
+</summary>
+
+<key_state>
+- Nothing critical pending.
+</key_state>
+
+<tail_start timestamp="${TAIL_TIMESTAMP}" preview="tail anchor message" />
+</compaction_result>
+`;
+
+const OLD_SCREENSHOT_DATA = "b64-old-screenshot-bytes";
+const LATEST_SCREENSHOT_DATA = "b64-latest-screenshot-bytes";
+const USER_ATTACHED_IMAGE_DATA = "b64-user-attached-bytes";
+
+const userTextWithTurnContext = (text: string, timestamp: string): Message => ({
+  role: "user",
+  content: [
+    {
+      type: "text",
+      text: `<turn_context>\ncurrent_time: ${timestamp}\n</turn_context>\n${text}`,
+    },
+  ],
+});
+
+const assistantToolUse = (id: string): Message => ({
+  role: "assistant",
+  content: [{ type: "tool_use", id, name: "screenshot", input: {} }],
+});
+
+const toolResultWithImage = (id: string, data: string): Message => ({
+  role: "user",
+  content: [
+    {
+      type: "tool_result",
+      tool_use_id: id,
+      content: "captured",
+      contentBlocks: [
+        {
+          type: "image",
+          source: { type: "base64", media_type: "image/png", data },
+        },
+      ],
+    },
+  ],
+});
+
+const userWithAttachedImage = (): Message => ({
+  role: "user",
+  content: [
+    { type: "text", text: "here is a mockup" },
+    {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: "image/png",
+        data: USER_ATTACHED_IMAGE_DATA,
+      },
+    },
+  ],
+});
+
+function serializeBlocks(messages: Message[]): string {
+  return JSON.stringify(messages);
+}
+
+// Records the exact message list the provider is asked to summarize.
+function recordingProvider(sink: { sent: Message[] }): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async (msgs: Message[]) => {
+      sink.sent = msgs;
+      return {
+        content: [{ type: "text", text: compactionResponse }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+// The summary request must carry the same media-stripped projection the agent
+// loop sends on its own model calls. An unsanitized history resends every
+// screenshot in the conversation; enough of them cross Anthropic's many-image
+// threshold, where a stricter per-image dimension cap rejects the whole
+// summary call (and trips the compaction circuit breaker).
+describe("compaction summary calls — old tool-result media stripping", () => {
+  test("runAssistantDrivenCompaction strips images from older tool results, keeps the latest turn's image and user-attached images, and leaves durable history untouched", async () => {
+    // GIVEN a screenshot-heavy history: older tool results with images, a
+    // user-attached image, and a most-recent tool result with an image
+    const messages: Message[] = [
+      userWithAttachedImage(),
+      assistantToolUse("tu_old_1"),
+      toolResultWithImage("tu_old_1", OLD_SCREENSHOT_DATA),
+      userTextWithTurnContext("tail anchor message", TAIL_TIMESTAMP),
+      assistantToolUse("tu_latest"),
+      toolResultWithImage("tu_latest", LATEST_SCREENSHOT_DATA),
+    ];
+
+    // AND a snapshot of the caller's array so we can assert it is not mutated
+    const inputSnapshot = serializeBlocks(messages);
+    const sink = { sent: [] as Message[] };
+
+    // WHEN compaction runs over that history
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-media-strip",
+      messages,
+      provider: recordingProvider(sink),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      // Large budget so the request is not front-truncated — this test
+      // exercises the media-strip sanitizer, not the truncation fallback.
+      maxInputTokens: 100000,
+      previousEstimatedInputTokens: 90000,
+    });
+
+    // THEN older tool-result screenshots are replaced with a text marker
+    const sentSerialized = serializeBlocks(sink.sent);
+    expect(sentSerialized).not.toContain(OLD_SCREENSHOT_DATA);
+    expect(sentSerialized).toContain("binary data removed to save context");
+
+    // AND the most recent tool-result turn keeps its image (the model may
+    // still need it), as do images the user attached directly
+    expect(sentSerialized).toContain(LATEST_SCREENSHOT_DATA);
+    expect(sentSerialized).toContain(USER_ATTACHED_IMAGE_DATA);
+
+    // AND the caller's durable history array is left byte-for-byte untouched,
+    // so persisted messages keep the original rich blocks
+    expect(serializeBlocks(messages)).toBe(inputSnapshot);
+    expect(result.compacted).toBe(true);
+  });
+});

package/src/__tests__/config-loader-backfill.test.ts

@@ -856,9 +856,9 @@ describe("loadConfig startup behavior", () => {
     );
     expect(raw.llm.profiles.balanced.effort).toBe("high");
     expect(raw.llm.profiles.balanced.source).toBe("managed");
-    // Quality serves Anthropic Opus, the most capable managed profile.
+    // Quality serves Anthropic Fable, the most capable managed profile.
     expect(raw.llm.profiles["quality-optimized"].provider).toBe("anthropic");
-    expect(raw.llm.profiles["quality-optimized"].model).toBe("claude-opus-4-8");
+    expect(raw.llm.profiles["quality-optimized"].model).toBe("claude-fable-5");
     // Speed is served by DeepSeek V4 Flash on Fireworks.
     expect(raw.llm.profiles["cost-optimized"].provider).toBe("fireworks");
     expect(raw.llm.profiles["cost-optimized"].model).toBe(
@@ -899,7 +899,7 @@ describe("loadConfig startup behavior", () => {
   test("reseed updates a source-less legacy canonical managed profile", () => {
     // Migration 052 seeded canonical profiles without a `source`. Such a
     // source-less `quality-optimized` is legacy managed, not user-owned, so it
-    // must still reseed to the latest template (Opus) and be tagged managed.
+    // must still reseed to the latest template (Fable) and be tagged managed.
     writeConfig({
       llm: {
         profiles: {
@@ -915,7 +915,7 @@ describe("loadConfig startup behavior", () => {
     mergeDefaultConfigAndSeedInferenceProfiles();
     const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
 
-    expect(raw.llm.profiles["quality-optimized"].model).toBe("claude-opus-4-8");
+    expect(raw.llm.profiles["quality-optimized"].model).toBe("claude-fable-5");
     expect(raw.llm.profiles["quality-optimized"].source).toBe("managed");
   });
 
@@ -1574,7 +1574,7 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
 
     expect(raw.llm.activeProfile).toBe("balanced");
-    // Balanced lives on `fireworks-managed`; `quality-optimized` (Opus on
+    // Balanced lives on `fireworks-managed`; `quality-optimized` (Fable on
     // `anthropic-managed`) is on a different connection, so selecting balanced at
     // hatch disables it. The default advisor falls to the only active managed
     // profile, `balanced`.

package/src/__tests__/config-schema.test.ts

@@ -890,6 +890,7 @@ describe("AssistantConfigSchema", () => {
         language: "en-US",
         hints: [],
         interruptSensitivity: "low",
+        telephonyStreaming: true,
       },
       callerIdentity: {
         allowPerCallOverride: true,
@@ -997,6 +998,7 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.voice.language).toBe("en-US");
     expect(result.calls.voice.hints).toEqual([]);
     expect(result.calls.voice.interruptSensitivity).toBe("low");
+    expect(result.calls.voice.telephonyStreaming).toBe(true);
   });
 
   test("accepts valid calls.voice overrides", () => {
@@ -1004,10 +1006,25 @@ describe("AssistantConfigSchema", () => {
       calls: {
         voice: {
           language: "es-ES",
+          telephonyStreaming: false,
         },
       },
     });
     expect(result.calls.voice.language).toBe("es-ES");
+    expect(result.calls.voice.telephonyStreaming).toBe(false);
+  });
+
+  test("rejects non-boolean calls.voice.telephonyStreaming", () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { telephonyStreaming: "yes" } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(
+        msgs.some((m) => m.includes("calls.voice.telephonyStreaming")),
+      ).toBe(true);
+    }
   });
 
   test("transcriptionProvider is no longer part of the voice config schema", () => {

package/src/__tests__/contact-store-interaction-info.test.ts

@@ -1,8 +1,9 @@
 /**
- * INFO telemetry (interactionCount/lastInteraction/lastSeenAt) is local, not
- * ACL: the gateway's handle-inbound mirror writes it to the assistant DB, and
- * model-facing turn context reads it back. These tests assert the daemon-native
- * read paths (getContact / searchContacts) re-hydrate and aggregate it.
+ * Interaction telemetry (interactionCount/lastInteraction/lastSeenAt) is
+ * gateway-owned: reads source it from the stamped trust verdict and the gateway
+ * rich-read relay, and the assistant DB no longer carries the columns. These
+ * tests assert the daemon-native read paths (getContact / searchContacts /
+ * findContactInfoById) surface no telemetry.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -43,114 +44,70 @@ function insertChannel(params: {
   contactId: string;
   type: string;
   address: string;
-  interactionCount: number;
-  lastInteraction: number | null;
-  lastSeenAt?: number | null;
 }): void {
   const now = Date.now();
   getSqlite().run(
-    "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, interaction_count, last_interaction, last_seen_at, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?)",
-    [
-      params.id,
-      params.contactId,
-      params.type,
-      params.address,
-      params.interactionCount,
-      params.lastInteraction,
-      params.lastSeenAt ?? null,
-      now,
-      now,
-    ],
+    "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?)",
+    [params.id, params.contactId, params.type, params.address, now, now],
   );
 }
 
-describe("contact interaction INFO aggregation", () => {
+const TELEMETRY_KEYS = ["interactionCount", "lastInteraction", "lastSeenAt"];
+
+describe("contact-store surfaces no interaction telemetry", () => {
   beforeEach(() => {
     resetContactTables();
   });
 
-  test("getContact sums interaction_count and takes the latest last_interaction across channels", () => {
+  test("getContact returns no telemetry fields on the contact or its channels", () => {
     insertContact("ct_1", "Alice");
     insertChannel({
       id: "ch_a",
       contactId: "ct_1",
       type: "phone",
       address: "+15550100",
-      interactionCount: 3,
-      lastInteraction: 1900,
-      lastSeenAt: 1850,
-    });
-    insertChannel({
-      id: "ch_b",
-      contactId: "ct_1",
-      type: "email",
-      address: "alice@example.com",
-      interactionCount: 4,
-      lastInteraction: 2100,
-      lastSeenAt: 2050,
     });
 
     const contact = getContact("ct_1");
     expect(contact).not.toBeNull();
-    expect(contact!.interactionCount).toBe(7);
-    expect(contact!.lastInteraction).toBe(2100);
-
-    // Per-channel INFO is hydrated too.
-    const phone = contact!.channels.find((c) => c.type === "phone");
-    expect(phone?.interactionCount).toBe(3);
-    expect(phone?.lastInteraction).toBe(1900);
-    expect(phone?.lastSeenAt).toBe(1850);
+    for (const key of TELEMETRY_KEYS) {
+      expect(key in contact!).toBe(false);
+    }
+    const phone = contact!.channels.find((c) => c.type === "phone")!;
+    for (const key of TELEMETRY_KEYS) {
+      expect(key in phone).toBe(false);
+    }
   });
 
-  test("findContactInfoById surfaces the real interaction count", () => {
+  test("findContactInfoById returns the notes-only INFO shape (telemetry is gateway-owned)", () => {
     insertContact("ct_2", "Bob");
     insertChannel({
       id: "ch_c",
       contactId: "ct_2",
       type: "phone",
       address: "+15550200",
-      interactionCount: 5,
-      lastInteraction: 1000,
     });
 
     const info = findContactInfoById("ct_2");
-    expect(info?.interactionCount).toBe(5);
-  });
-
-  test("lastInteraction is null when no channel has interacted", () => {
-    insertContact("ct_3", "Carol");
-    insertChannel({
-      id: "ch_d",
-      contactId: "ct_3",
-      type: "phone",
-      address: "+15550300",
-      interactionCount: 0,
-      lastInteraction: null,
-    });
-
-    const contact = getContact("ct_3");
-    expect(contact!.interactionCount).toBe(0);
-    expect(contact!.lastInteraction).toBeNull();
+    expect(info).not.toBeNull();
+    expect(Object.keys(info!)).toEqual(["notes"]);
+    expect(info!.notes).toBeNull();
   });
 
-  test("filtered searchContacts carries channel INFO fields", () => {
+  test("filtered searchContacts carries no telemetry fields", () => {
     insertContact("ct_4", "Dana");
     insertChannel({
       id: "ch_e",
       contactId: "ct_4",
       type: "phone",
       address: "+15550400",
-      interactionCount: 9,
-      lastInteraction: 3000,
-      lastSeenAt: 2900,
     });
 
     const results = searchContacts({ query: "Dana", limit: 10 });
     expect(results).toHaveLength(1);
-    expect(results[0].interactionCount).toBe(9);
-    expect(results[0].lastInteraction).toBe(3000);
-    const ch = results[0].channels[0];
-    expect(ch.interactionCount).toBe(9);
-    expect(ch.lastSeenAt).toBe(2900);
+    for (const key of TELEMETRY_KEYS) {
+      expect(key in results[0]).toBe(false);
+      expect(key in results[0].channels[0]).toBe(false);
+    }
   });
 });