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

package/src/ipc/__tests__/contacts-info-ipc.test.ts

@@ -0,0 +1,285 @@
+/**
+ * Unit tests for the daemon-side contact INFO-READ IPC handlers
+ * (ipc/routes/contacts-info-ipc-routes.ts). Each handler reads the real
+ * (isolated) assistant DB, so we seed rows via getSqlite() and invoke the
+ * handler with `{ body }` exactly as the IPC server would.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { getSqlite } from "../../persistence/db-connection.js";
+import { initializeDb } from "../../persistence/db-init.js";
+import {
+  handleContactChannelIdentityLookup,
+  handleContactMirrorProbe,
+  handleContactsInfoBatch,
+  handleContactUserFileSlugs,
+} from "../routes/contacts-info-ipc-routes.js";
+
+await initializeDb();
+
+function resetTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM assistant_contact_metadata");
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function insertContact(params: {
+  id: string;
+  displayName?: string;
+  notes?: string | null;
+  userFile?: string | null;
+  contactType?: "human" | "assistant";
+}): void {
+  const now = Date.now();
+  getSqlite().run(
+    "INSERT INTO contacts (id, display_name, notes, user_file, contact_type, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+    [
+      params.id,
+      params.displayName ?? `name-${params.id}`,
+      params.notes ?? null,
+      params.userFile ?? null,
+      params.contactType ?? "human",
+      now,
+      now,
+    ],
+  );
+}
+
+function insertChannel(params: {
+  id: string;
+  contactId: string;
+  type?: string;
+  address: string;
+  externalChatId?: string | null;
+}): void {
+  const now = Date.now();
+  getSqlite().run(
+    "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, external_chat_id, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?, ?)",
+    [
+      params.id,
+      params.contactId,
+      params.type ?? "telegram",
+      params.address,
+      params.externalChatId ?? null,
+      now,
+      now,
+    ],
+  );
+}
+
+function insertMetadata(params: {
+  contactId: string;
+  species: string;
+  metadata?: Record<string, unknown> | null;
+}): void {
+  getSqlite().run(
+    "INSERT INTO assistant_contact_metadata (contact_id, species, metadata) VALUES (?, ?, ?)",
+    [
+      params.contactId,
+      params.species,
+      params.metadata != null ? JSON.stringify(params.metadata) : null,
+    ],
+  );
+}
+
+beforeEach(() => {
+  resetTables();
+});
+
+// ── contacts_info_batch ──────────────────────────────────────────────────────
+
+describe("handleContactsInfoBatch", () => {
+  test("empty contactIds returns empty infos", () => {
+    const result = handleContactsInfoBatch({ body: { contactIds: [] } });
+    expect(result).toEqual({ infos: [] });
+  });
+
+  test("returns info fields and gates assistant metadata on contactType", () => {
+    insertContact({ id: "c1", notes: "friend", contactType: "human" });
+    insertContact({ id: "c2", contactType: "assistant" });
+    insertMetadata({ contactId: "c2", species: "vellum", metadata: { model: "opus" } });
+
+    const result = handleContactsInfoBatch({
+      body: { contactIds: ["c1", "c2", "missing"] },
+    }) as { infos: Array<Record<string, unknown>> };
+
+    expect(result.infos).toHaveLength(2);
+    const c1 = result.infos.find((i) => i.contactId === "c1")!;
+    expect(c1.notes).toBe("friend");
+    expect(c1.contactType).toBe("human");
+    expect(c1.assistantMetadata).toBeNull();
+
+    const c2 = result.infos.find((i) => i.contactId === "c2")!;
+    expect(c2.contactType).toBe("assistant");
+    expect(c2.assistantMetadata).toEqual({
+      species: "vellum",
+      metadata: { model: "opus" },
+    });
+  });
+
+  test("does not emit metadata for human contact with stale species row", () => {
+    insertContact({ id: "c1", contactType: "human" });
+    insertMetadata({ contactId: "c1", species: "vellum", metadata: { x: 1 } });
+
+    const result = handleContactsInfoBatch({
+      body: { contactIds: ["c1"] },
+    }) as { infos: Array<Record<string, unknown>> };
+    expect(result.infos[0].assistantMetadata).toBeNull();
+  });
+
+  test("malformed metadata JSON degrades to null metadata", () => {
+    insertContact({ id: "c1", contactType: "assistant" });
+    getSqlite().run(
+      "INSERT INTO assistant_contact_metadata (contact_id, species, metadata) VALUES (?, ?, ?)",
+      ["c1", "vellum", "{not valid json"],
+    );
+
+    const result = handleContactsInfoBatch({
+      body: { contactIds: ["c1"] },
+    }) as { infos: Array<Record<string, unknown>> };
+    expect(result.infos[0].assistantMetadata).toEqual({
+      species: "vellum",
+      metadata: null,
+    });
+  });
+
+  test("rejects a malformed body (non-array contactIds)", () => {
+    expect(() =>
+      handleContactsInfoBatch({ body: { contactIds: "nope" } as never }),
+    ).toThrow();
+  });
+});
+
+// ── contact_channel_identity_lookup ──────────────────────────────────────────
+
+describe("handleContactChannelIdentityLookup", () => {
+  test("resolves by (type, address) case-insensitively", () => {
+    insertContact({ id: "c1", displayName: "Alice" });
+    insertChannel({
+      id: "ch1",
+      contactId: "c1",
+      type: "email",
+      address: "Alice@Example.com",
+      externalChatId: "chat-1",
+    });
+
+    const result = handleContactChannelIdentityLookup({
+      body: { type: "email", address: "alice@example.com" },
+    }) as { channel: Record<string, unknown> | null };
+
+    expect(result.channel).toEqual({
+      id: "ch1",
+      contactId: "c1",
+      type: "email",
+      address: "Alice@Example.com",
+      externalChatId: "chat-1",
+      displayName: "Alice",
+    });
+  });
+
+  test("resolves by channelId", () => {
+    insertContact({ id: "c1", displayName: "Bob" });
+    insertChannel({ id: "ch1", contactId: "c1", type: "slack", address: "U123" });
+
+    const result = handleContactChannelIdentityLookup({
+      body: { channelId: "ch1" },
+    }) as { channel: Record<string, unknown> | null };
+    expect(result.channel?.type).toBe("slack");
+    expect(result.channel?.address).toBe("U123");
+    expect(result.channel?.displayName).toBe("Bob");
+  });
+
+  test("returns null when no channel matches", () => {
+    const result = handleContactChannelIdentityLookup({
+      body: { channelId: "nope" },
+    });
+    expect(result).toEqual({ channel: null });
+  });
+
+  test("rejects a selector with neither channelId nor (type,address)", () => {
+    expect(() =>
+      handleContactChannelIdentityLookup({ body: { type: "email" } }),
+    ).toThrow();
+  });
+});
+
+// ── contact_mirror_probe ─────────────────────────────────────────────────────
+
+describe("handleContactMirrorProbe", () => {
+  test("reports absence when the contact is not mirrored", () => {
+    const result = handleContactMirrorProbe({ body: { contactId: "gone" } });
+    expect(result).toEqual({
+      exists: false,
+      hasChannels: false,
+      notes: null,
+      userFile: null,
+      contactType: null,
+      hasMetadata: false,
+    });
+  });
+
+  test("reports info fields, channels, and metadata presence", () => {
+    insertContact({
+      id: "c1",
+      notes: "note",
+      userFile: "alice.md",
+      contactType: "assistant",
+    });
+    insertChannel({ id: "ch1", contactId: "c1", address: "addr" });
+    insertMetadata({ contactId: "c1", species: "vellum" });
+
+    const result = handleContactMirrorProbe({
+      body: { contactId: "c1" },
+    }) as Record<string, unknown>;
+    expect(result).toEqual({
+      exists: true,
+      hasChannels: true,
+      notes: "note",
+      userFile: "alice.md",
+      contactType: "assistant",
+      hasMetadata: true,
+    });
+  });
+
+  test("row present with no channels or metadata (bare seed contact)", () => {
+    insertContact({ id: "c1", contactType: "human" });
+    const result = handleContactMirrorProbe({
+      body: { contactId: "c1" },
+    }) as Record<string, unknown>;
+    expect(result.exists).toBe(true);
+    expect(result.hasChannels).toBe(false);
+    expect(result.hasMetadata).toBe(false);
+    expect(result.contactType).toBe("human");
+  });
+});
+
+// ── contact_user_file_slugs ──────────────────────────────────────────────────
+
+describe("handleContactUserFileSlugs", () => {
+  test("lists user_file slugs matching the prefix", () => {
+    insertContact({ id: "c1", userFile: "alice.md" });
+    insertContact({ id: "c2", userFile: "alice-2.md" });
+    insertContact({ id: "c3", userFile: "bob.md" });
+    insertContact({ id: "c4", userFile: null });
+
+    const result = handleContactUserFileSlugs({
+      body: { prefix: "alice" },
+    }) as { userFiles: string[] };
+    expect(result.userFiles.sort()).toEqual(["alice-2.md", "alice.md"]);
+  });
+
+  test("returns empty list when nothing matches", () => {
+    insertContact({ id: "c1", userFile: "zed.md" });
+    const result = handleContactUserFileSlugs({ body: { prefix: "alice" } });
+    expect(result).toEqual({ userFiles: [] });
+  });
+});

package/src/ipc/assistant-server.ts

@@ -51,6 +51,8 @@ import {
   writeStreamChunk,
   writeStreamEnd,
 } from "./ipc-framing.js";
+import { CONTACTS_INFO_IPC_METHODS } from "./routes/contacts-info-ipc-routes.js";
+import { CONTACTS_MIRROR_IPC_METHODS } from "./routes/contacts-mirror-ipc-routes.js";
 import { type DbProxyParams, handleDbProxy } from "./routes/db-proxy.js";
 import {
   type DbProxyTransactionParams,
@@ -205,15 +207,34 @@ export class AssistantIpcServer {
     );
 
     // IPC-only invite methods (see ipc/routes/invite-ipc-routes.ts). The
-    // gateway calls these back over IPC to mint tokens / redeem voice + token
-    // invites (assistant-owned secrets). No HTTP surface; never in ROUTES.
+    // gateway calls these back over IPC to mirror redeemed-invite contact
+    // info locally. No HTTP surface; never in ROUTES.
     for (const [operationId, handler] of Object.entries(INVITE_IPC_METHODS)) {
       this.methods.set(operationId, handler);
     }
 
+    // IPC-only contact INFO-READ methods (see ipc/routes/contacts-info-ipc-routes.ts).
+    // The gateway calls these to read assistant-owned info fields + channel
+    // identity, replacing raw db_proxy SELECTs. No HTTP surface; never in ROUTES.
+    for (const [operationId, handler] of Object.entries(
+      CONTACTS_INFO_IPC_METHODS,
+    )) {
+      this.methods.set(operationId, handler);
+    }
+
+    // IPC-only contact identity-mirror methods (see
+    // ipc/routes/contacts-mirror-ipc-routes.ts). The gateway calls these back
+    // over IPC to mirror single-row contact/channel identity locally after a
+    // gateway-owned ACL write. No HTTP surface; never in ROUTES.
+    for (const [operationId, handler] of Object.entries(
+      CONTACTS_MIRROR_IPC_METHODS,
+    )) {
+      this.methods.set(operationId, handler);
+    }
+
     this.methods.set("$cancel", (params) => {
       const targetId = (params as { targetId?: string }).targetId;
-      if (targetId) this.abortControllers.get(targetId)?.abort();
+      if (targetId) {this.abortControllers.get(targetId)?.abort();}
       return null;
     });
 
@@ -255,11 +276,11 @@ export class AssistantIpcServer {
   stop(): void {
     this.watchdog.stop();
 
-    for (const ctrl of this.abortControllers.values()) ctrl.abort();
+    for (const ctrl of this.abortControllers.values()) {ctrl.abort();}
     this.abortControllers.clear();
 
     for (const client of this.clients) {
-      if (!client.destroyed) client.destroy();
+      if (!client.destroyed) {client.destroy();}
     }
     this.clients.clear();
 
@@ -595,7 +616,7 @@ export class AssistantIpcServer {
     response: IpcResponse,
     binary?: Uint8Array,
   ): void {
-    if (socket.destroyed) return;
+    if (socket.destroyed) {return;}
     if (reader.isLegacy) {
       writeLegacyMessage(socket, response);
     } else {
@@ -643,7 +664,7 @@ export function injectLocalActorHeader(
   if (!headers["x-vellum-actor-principal-id"]) {
     try {
       const localActor = findLocalGuardianPrincipalIdFromStore();
-      if (localActor) headers["x-vellum-actor-principal-id"] = localActor;
+      if (localActor) {headers["x-vellum-actor-principal-id"] = localActor;}
     } catch (err) {
       log.debug(
         { err },

package/src/ipc/routes/__tests__/contacts-mirror-apply-atomicity.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Atomicity of the transactional identity-mirror IPC (`contacts_mirror_apply`)
+ * against the REAL assistant DB. A mid-batch op failure must roll back the
+ * ENTIRE daemon-side transaction so the mirror is never left partially applied.
+ *
+ * The per-op primitives are defensive and don't throw on well-formed input, so
+ * the failure is injected: `deleteContact` is mocked to throw, and an earlier
+ * real `upsert_contact` op's write must NOT survive.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { getSqlite } from "../../../persistence/db-connection.js";
+import { initializeDb } from "../../../persistence/db-init.js";
+
+// Spread the real module so upsert_contact/upsert_channel run against the real
+// DB; only deleteContact throws, simulating a mid-batch failure.
+const realContactStore = await import("../../../contacts/contact-store.js");
+mock.module("../../../contacts/contact-store.js", () => ({
+  ...realContactStore,
+  deleteContact: () => {
+    throw new Error("injected mid-batch failure");
+  },
+}));
+
+const { handleContactsMirrorApply } = await import(
+  "../contacts-mirror-ipc-routes.js"
+);
+
+await initializeDb();
+
+function contactExists(id: string): boolean {
+  return (
+    getSqlite().prepare("SELECT 1 FROM contacts WHERE id = ?").get(id) != null
+  );
+}
+
+describe("contacts_mirror_apply atomicity", () => {
+  beforeEach(() => {
+    const sqlite = getSqlite();
+    sqlite.exec("DELETE FROM contact_channels");
+    sqlite.exec("DELETE FROM contacts");
+  });
+
+  test("rolls back the ENTIRE batch when a later op throws mid-transaction", () => {
+    expect(() =>
+      handleContactsMirrorApply({
+        body: {
+          ops: [
+            // op1: a real contact write that MUST NOT survive the rollback.
+            { op: "upsert_contact", contactId: "rollback-co", displayName: "RB" },
+            // op2: throws mid-transaction, aborting the whole batch.
+            { op: "delete_contact", contactId: "anything" },
+          ],
+        },
+      }),
+    ).toThrow("injected mid-batch failure");
+
+    // op1 rolled back: no partial mirror.
+    expect(contactExists("rollback-co")).toBe(false);
+  });
+});

package/src/ipc/routes/__tests__/contacts-mirror-apply.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Transactional identity-mirror IPC (`contacts_mirror_apply`) against the REAL
+ * assistant DB (via `initializeDb()`; the test preload points
+ * VELLUM_WORKSPACE_DIR at a per-file temp dir).
+ *
+ * Covers the guardian-bootstrap-shaped upsert end to end, a multi-op batch
+ * committing together, and the re-auth rebind (an existing channel id rebound
+ * to a new address updates in place instead of colliding). Mid-batch rollback
+ * lives in contacts-mirror-apply-atomicity.test.ts (needs an injected throw).
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getSqlite } from "../../../persistence/db-connection.js";
+import { initializeDb } from "../../../persistence/db-init.js";
+import {
+  handleContactsMirrorApply,
+  handleContactsMirrorUpsertChannel,
+} from "../contacts-mirror-ipc-routes.js";
+
+await initializeDb();
+
+function resetContacts(): void {
+  const sqlite = getSqlite();
+  sqlite.exec("DELETE FROM contact_channels");
+  sqlite.exec("DELETE FROM contacts");
+}
+
+function contactExists(id: string): boolean {
+  return (
+    getSqlite().prepare("SELECT 1 FROM contacts WHERE id = ?").get(id) != null
+  );
+}
+
+function channelRow(
+  id: string,
+): { contact_id: string; is_primary: number; external_chat_id: string | null } | null {
+  return (
+    (getSqlite()
+      .prepare(
+        "SELECT contact_id, is_primary, external_chat_id FROM contact_channels WHERE id = ?",
+      )
+      .get(id) as
+      | { contact_id: string; is_primary: number; external_chat_id: string | null }
+      | undefined) ?? null
+  );
+}
+
+describe("contacts_mirror_apply", () => {
+  beforeEach(() => {
+    resetContacts();
+  });
+
+  test("applies a guardian-bootstrap-shaped upsert (contact + primary channel) end to end", () => {
+    const result = handleContactsMirrorApply({
+      body: {
+        ops: [
+          {
+            op: "upsert_channel",
+            contactId: "guardian-co",
+            channelId: "guardian-ch",
+            type: "vellum",
+            address: "vellum-principal-abc",
+            externalChatId: "local",
+            displayName: "Owner",
+            isPrimary: true,
+            refreshDisplayName: true,
+            reassignConflictingChannels: true,
+          },
+        ],
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(contactExists("guardian-co")).toBe(true);
+    const ch = channelRow("guardian-ch");
+    expect(ch?.contact_id).toBe("guardian-co");
+    // The guardian channel keeps its primary flag and delivery chat id.
+    expect(ch?.is_primary).toBe(1);
+    expect(ch?.external_chat_id).toBe("local");
+  });
+
+  test("commits a multi-op batch atomically", () => {
+    handleContactsMirrorApply({
+      body: {
+        ops: [
+          { op: "upsert_contact", contactId: "co-a", displayName: "A" },
+          {
+            op: "upsert_channel",
+            contactId: "co-a",
+            channelId: "ch-a",
+            type: "telegram",
+            address: "tg-a",
+            displayName: "A",
+          },
+        ],
+      },
+    });
+
+    expect(contactExists("co-a")).toBe(true);
+    expect(channelRow("ch-a")?.contact_id).toBe("co-a");
+  });
+
+  test("re-auth rebind: updates an existing channel's address in place by id", () => {
+    // A guardian channel already mirrored at the OLD actor address.
+    const sqlite = getSqlite();
+    sqlite
+      .prepare(
+        "INSERT INTO contacts (id, display_name, created_at, updated_at) VALUES (?, ?, ?, ?)",
+      )
+      .run("g-co", "Owner", 1, 1);
+    sqlite
+      .prepare(
+        "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, created_at) VALUES (?, ?, ?, ?, 1, ?)",
+      )
+      .run("g-ch", "g-co", "vellum", "OLD-principal", 1);
+
+    // The gateway rebinds the SAME channel id to a NEW address (re-auth). The op
+    // must update row g-ch in place, not collide on its id and silently keep the
+    // stale address.
+    const result = handleContactsMirrorApply({
+      body: {
+        ops: [
+          {
+            op: "upsert_channel",
+            contactId: "g-co",
+            channelId: "g-ch",
+            type: "vellum",
+            address: "NEW-principal",
+            externalChatId: "local",
+            displayName: "Owner",
+            isPrimary: true,
+            refreshDisplayName: true,
+            reassignConflictingChannels: true,
+          },
+        ],
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const row = getSqlite()
+      .prepare(
+        "SELECT contact_id, address, is_primary, external_chat_id FROM contact_channels WHERE id = ?",
+      )
+      .get("g-ch");
+    expect(row).toEqual({
+      contact_id: "g-co",
+      address: "NEW-principal",
+      is_primary: 1,
+      external_chat_id: "local",
+    });
+    // Exactly one row — no duplicate from a collided insert, no stale sibling.
+    const count = getSqlite()
+      .prepare("SELECT COUNT(*) AS n FROM contact_channels")
+      .get() as { n: number };
+    expect(count.n).toBe(1);
+  });
+
+  test("re-auth rebind also works through the single-row upsert_channel handler", () => {
+    const sqlite = getSqlite();
+    sqlite
+      .prepare(
+        "INSERT INTO contacts (id, display_name, created_at, updated_at) VALUES (?, ?, ?, ?)",
+      )
+      .run("g2-co", "Owner", 1, 1);
+    sqlite
+      .prepare(
+        "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, created_at) VALUES (?, ?, ?, ?, 1, ?)",
+      )
+      .run("g2-ch", "g2-co", "vellum", "OLD-2", 1);
+
+    // The single-row handler shares the same applier/primitive as the apply op.
+    handleContactsMirrorUpsertChannel({
+      body: {
+        contactId: "g2-co",
+        channelId: "g2-ch",
+        type: "vellum",
+        address: "NEW-2",
+        displayName: "Owner",
+        isPrimary: true,
+        refreshDisplayName: true,
+        reassignConflictingChannels: true,
+      },
+    });
+
+    const row = getSqlite()
+      .prepare("SELECT address FROM contact_channels WHERE id = ?")
+      .get("g2-ch") as { address: string };
+    expect(row.address).toBe("NEW-2");
+    const count = getSqlite()
+      .prepare("SELECT COUNT(*) AS n FROM contact_channels")
+      .get() as { n: number };
+    expect(count.n).toBe(1);
+  });
+
+  test("re-auth rebind adopts a (type,address) held by another row instead of colliding on the unique index", () => {
+    const sqlite = getSqlite();
+    // Guardian channel at the OLD address.
+    sqlite
+      .prepare(
+        "INSERT INTO contacts (id, display_name, created_at, updated_at) VALUES (?, ?, ?, ?)",
+      )
+      .run("g3-co", "Owner", 1, 1);
+    sqlite
+      .prepare(
+        "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, created_at) VALUES (?, ?, ?, ?, 1, ?)",
+      )
+      .run("g3-ch", "g3-co", "vellum", "OLD-3", 1);
+    // A DIFFERENT row (different contact) already holds (vellum, NEW-3) — the
+    // address the guardian is about to rebind to. idx_contact_channels_type_address
+    // would reject a naive address move.
+    sqlite
+      .prepare(
+        "INSERT INTO contacts (id, display_name, created_at, updated_at) VALUES (?, ?, ?, ?)",
+      )
+      .run("stale-co", "Stale", 1, 1);
+    sqlite
+      .prepare(
+        "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, created_at) VALUES (?, ?, ?, ?, 0, ?)",
+      )
+      .run("stale-ch", "stale-co", "vellum", "NEW-3", 1);
+
+    // reassignConflictingChannels:true (guardian) → adopt the identity onto the
+    // gateway-keyed row: remove the stale duplicate, land g3-ch on NEW-3, no throw.
+    const result = handleContactsMirrorApply({
+      body: {
+        ops: [
+          {
+            op: "upsert_channel",
+            contactId: "g3-co",
+            channelId: "g3-ch",
+            type: "vellum",
+            address: "NEW-3",
+            displayName: "Owner",
+            isPrimary: true,
+            refreshDisplayName: true,
+            reassignConflictingChannels: true,
+          },
+        ],
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    // The gateway-keyed row survived and moved to the new address.
+    const g3 = getSqlite()
+      .prepare("SELECT contact_id, address, is_primary FROM contact_channels WHERE id = ?")
+      .get("g3-ch");
+    expect(g3).toEqual({ contact_id: "g3-co", address: "NEW-3", is_primary: 1 });
+    // The stale duplicate is gone — exactly one channel row remains.
+    expect(
+      getSqlite().prepare("SELECT 1 FROM contact_channels WHERE id = ?").get("stale-ch"),
+    ).toBeNull();
+    const count = getSqlite()
+      .prepare("SELECT COUNT(*) AS n FROM contact_channels")
+      .get() as { n: number };
+    expect(count.n).toBe(1);
+  });
+
+  test("rejects an unknown op discriminator", () => {
+    expect(() =>
+      handleContactsMirrorApply({
+        body: { ops: [{ op: "wipe_everything", contactId: "x" }] },
+      }),
+    ).toThrow();
+  });
+
+  test("rejects an empty ops array", () => {
+    expect(() =>
+      handleContactsMirrorApply({ body: { ops: [] } }),
+    ).toThrow();
+  });
+});