@vellumai/assistant 0.10.3 → 0.10.4-staging.1

package/src/__tests__/db-compaction-events-migration.test.ts

@@ -0,0 +1,129 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { migrateCreateCompactionEvents } from "../memory/migrations/302-create-compaction-events.js";
+import * as schema from "../memory/schema.js";
+
+interface EventRow {
+  conversation_id: string;
+  compacted_at: number;
+  summary: string;
+  compacted_message_count: number;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrapCheckpointsTable(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function bootstrapConversations(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      context_summary TEXT,
+      context_compacted_message_count INTEGER NOT NULL DEFAULT 0,
+      context_compacted_at INTEGER
+    )
+  `);
+}
+
+function insertConversation(
+  raw: Database,
+  id: string,
+  summary: string | null,
+  count: number,
+  compactedAt: number | null,
+): void {
+  raw
+    .query(
+      /*sql*/ `
+        INSERT INTO conversations (
+          id, title, created_at, updated_at,
+          context_summary, context_compacted_message_count, context_compacted_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `,
+    )
+    .run(id, id, 1000, 2000, summary, count, compactedAt);
+}
+
+function getEvents(raw: Database): EventRow[] {
+  return raw
+    .query(
+      /*sql*/ `
+        SELECT conversation_id, compacted_at, summary, compacted_message_count
+        FROM conversation_compaction_events
+        ORDER BY conversation_id
+      `,
+    )
+    .all() as EventRow[];
+}
+
+describe("migrateCreateCompactionEvents", () => {
+  test("creates the ledger and backfills one event per compacted conversation", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapConversations(raw);
+
+    insertConversation(raw, "compacted", "Summary text", 5, 3000);
+    insertConversation(raw, "uncompacted", null, 0, null);
+    // count>0 but never actually compacted (no timestamp) — must be skipped.
+    insertConversation(raw, "count-without-at", "Orphan summary", 4, null);
+
+    migrateCreateCompactionEvents(db);
+
+    expect(getEvents(raw)).toEqual([
+      {
+        conversation_id: "compacted",
+        compacted_at: 3000,
+        summary: "Summary text",
+        compacted_message_count: 5,
+      },
+    ]);
+  });
+
+  test("is idempotent — re-running does not duplicate backfilled events", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapConversations(raw);
+    insertConversation(raw, "compacted", "Summary text", 5, 3000);
+
+    migrateCreateCompactionEvents(db);
+    migrateCreateCompactionEvents(db);
+
+    expect(getEvents(raw)).toHaveLength(1);
+  });
+
+  test("the NOT EXISTS guard prevents duplicates even if the checkpoint is lost", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapConversations(raw);
+    insertConversation(raw, "compacted", "Summary text", 5, 3000);
+
+    migrateCreateCompactionEvents(db);
+    raw.exec(`DELETE FROM memory_checkpoints`);
+    migrateCreateCompactionEvents(db);
+
+    expect(getEvents(raw)).toHaveLength(1);
+  });
+});

package/src/__tests__/delete-propagation.test.ts

@@ -23,7 +23,6 @@ mock.module("../config/env.js", () => ({
 
 import { eq } from "drizzle-orm";
 
-import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { linkMessage, recordInbound } from "../memory/delivery-crud.js";
@@ -33,7 +32,10 @@ import {
   writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
 import { _setDeleteLookupConfigForTests } from "../runtime/routes/inbound-message-handler.js";
-import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
+import {
+  handleChannelInbound,
+  seedContactChannel,
+} from "./helpers/channel-test-adapter.js";
 
 await initializeDb();
 
@@ -56,7 +58,7 @@ function resetState(): void {
 }
 
 function seedActiveDeleteActor(externalChatId: string): void {
-  upsertContactChannel({
+  seedContactChannel({
     sourceChannel: "slack",
     externalUserId: SLACK_DELETE_ACTOR_ID,
     externalChatId,

package/src/__tests__/dm-backfill.test.ts

@@ -78,7 +78,6 @@ import {
   saveRawConfig,
   setNestedValue,
 } from "../config/loader.js";
-import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { messages } from "../memory/schema/conversations.js";
@@ -86,7 +85,10 @@ import {
   readSlackMetadata,
   type SlackMessageMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
-import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
+import {
+  handleChannelInbound,
+  seedContactChannel,
+} from "./helpers/channel-test-adapter.js";
 
 await initializeDb();
 
@@ -117,7 +119,7 @@ function setConfiguredSlackBotUserId(botUserId: string): void {
 }
 
 function seedActiveMember(): void {
-  upsertContactChannel({
+  seedContactChannel({
     sourceChannel: "slack",
     externalUserId: SLACK_DM_USER_ID,
     externalChatId: SLACK_DM_CHANNEL_ID,
@@ -128,7 +130,7 @@ function seedActiveMember(): void {
 }
 
 function seedSlackGuardian(): void {
-  upsertContactChannel({
+  seedContactChannel({
     sourceChannel: "slack",
     externalUserId: SLACK_DM_USER_ID,
     externalChatId: SLACK_DM_CHANNEL_ID,

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -21,17 +21,13 @@ mock.module("../channels/config.js", () => ({
 
 // Guardian connectivity is resolved from the gateway pull. No active guardian
 // binding ⇒ binding-based channels (telegram) are not reported connected.
+// Guardian connectivity resolves solely from the gateway delivery; an empty
+// list ⇒ telegram stays disconnected.
 mock.module("../contacts/guardian-delivery-reader.js", () => ({
   getGuardianDelivery: async () => [],
   guardianForChannel: () => undefined,
 }));
 
-// connectivity falls back to the local contacts read on a per-channel gateway
-// no-match; no local binding ⇒ telegram stays disconnected.
-mock.module("../contacts/contact-store.js", () => ({
-  findGuardianForChannel: () => null,
-}));
-
 mock.module("../notifications/adapters/macos.js", () => ({
   VellumAdapter: class {
     constructor(_broadcastFn: unknown) {}

package/src/__tests__/guardian-binding-drift-heal.test.ts

@@ -17,7 +17,7 @@ mock.module("../contacts/guardian-delivery-reader.js", () => ({
     list.find((g) => g.channelType === channelType && g.status === "active"),
 }));
 
-import { findGuardianForChannel } from "../contacts/contact-store.js";
+import { findContactByAddress } from "../contacts/contact-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { healGuardianBindingDrift } from "../runtime/guardian-vellum-migration.js";
@@ -31,17 +31,31 @@ function resetTables(): void {
   db.run("DELETE FROM contacts");
 }
 
-/** Gateway delivery mirroring the local guardian binding's principal. */
-function gatewayGuardian(principalId: string): GuardianDelivery {
+/**
+ * Gateway delivery for the vellum guardian. `principalId` is the gateway-owned
+ * binding principal; `address` is the local channel address the heal resolves
+ * its write target by (defaults to the principal for same-principal bindings).
+ */
+function gatewayGuardian(
+  principalId: string,
+  address: string = principalId,
+): GuardianDelivery {
   return {
     channelType: "vellum",
     contactId: "guardian-contact",
     principalId,
-    address: principalId,
+    address,
     status: "active",
   };
 }
 
+/** Read the local vellum guardian channel/contact by its channel address. */
+function localVellumGuardian(address: string) {
+  const contact = findContactByAddress("vellum", address);
+  const channel = contact?.channels.find((c) => c.type === "vellum");
+  return contact && channel ? { contact, channel } : null;
+}
+
 describe("healGuardianBindingDrift", () => {
   beforeEach(() => {
     resetTables();
@@ -63,18 +77,17 @@ describe("healGuardianBindingDrift", () => {
     const healed = await healGuardianBindingDrift("vellum-principal-old-uuid");
     expect(healed).toBe(true);
 
-    // Guardian binding now matches the old JWT
-    const guardian = findGuardianForChannel("vellum");
+    // The heal repairs the channel identity address to match the JWT. The
+    // principalId column is gateway-owned and no longer written locally.
+    const guardian = localVellumGuardian("vellum-principal-old-uuid");
     expect(guardian).not.toBeNull();
-    expect(guardian!.contact.principalId).toBe("vellum-principal-old-uuid");
     expect(guardian!.channel.address).toBe("vellum-principal-old-uuid");
   });
 
-  test("repairs the stale local mirror even when the gateway already matches the JWT", async () => {
-    // Gateway binding already matches the incoming JWT principal, but the
-    // local mirror is stale — the gateway-source-of-truth drift mode. The
-    // /v1/messages trust path still reads the local mirror in this plan, so
-    // a stale row must be repaired or the actor stays classified `unknown`.
+  test("repairs the local mirror toward the JWT when the gateway diverges", async () => {
+    // Gateway principal diverges from the incoming JWT — the drift signal. The
+    // /v1/messages trust path still reads the local mirror in this plan, so the
+    // mirror is repaired toward the JWT or the actor stays `unknown`.
     createGuardianBinding({
       channel: "vellum",
       guardianExternalUserId: "vellum-principal-stale-local",
@@ -82,15 +95,19 @@ describe("healGuardianBindingDrift", () => {
       guardianPrincipalId: "vellum-principal-stale-local",
       verifiedVia: "startup-migration",
     });
-    mockGuardians = [gatewayGuardian("vellum-principal-jwt")];
+    // Gateway address matches the local channel address so the heal can resolve
+    // its local write target; only the gateway principal has drifted.
+    mockGuardians = [
+      gatewayGuardian("vellum-principal-gateway", "vellum-principal-stale-local"),
+    ];
 
     const healed = await healGuardianBindingDrift("vellum-principal-jwt");
     expect(healed).toBe(true);
 
-    // Local mirror now matches the JWT, so a subsequent local trust
-    // resolution classifies the actor as guardian rather than unknown.
-    const guardian = findGuardianForChannel("vellum");
-    expect(guardian!.contact.principalId).toBe("vellum-principal-jwt");
+    // The local mirror's identity address now matches the JWT, so a subsequent
+    // local trust resolution classifies the actor as guardian rather than
+    // unknown. The principalId column is gateway-owned and not written locally.
+    const guardian = localVellumGuardian("vellum-principal-jwt");
     expect(guardian!.channel.address).toBe("vellum-principal-jwt");
   });
 
@@ -122,12 +139,13 @@ describe("healGuardianBindingDrift", () => {
     const healed = await healGuardianBindingDrift("platform-user-12345");
     expect(healed).toBe(false);
 
-    // Guardian unchanged
-    const guardian = findGuardianForChannel("vellum");
-    expect(guardian!.contact.principalId).toBe("vellum-principal-aaa");
+    // Guardian unchanged: the local channel identity address still resolves to
+    // the original binding (principalId is gateway-owned, no longer local).
+    const guardian = localVellumGuardian("vellum-principal-aaa");
+    expect(guardian!.channel.address).toBe("vellum-principal-aaa");
   });
 
-  test("refuses to heal when stored principal lacks vellum-principal- prefix", async () => {
+  test("refuses to heal when the gateway principal lacks vellum-principal- prefix", async () => {
     createGuardianBinding({
       channel: "vellum",
       guardianExternalUserId: "verified-phone-guardian",
@@ -141,8 +159,10 @@ describe("healGuardianBindingDrift", () => {
     const healed = await healGuardianBindingDrift("vellum-principal-attacker");
     expect(healed).toBe(false);
 
-    const guardian = findGuardianForChannel("vellum");
-    expect(guardian!.contact.principalId).toBe("verified-phone-guardian");
+    // Guardian unchanged: the local channel identity address still resolves to
+    // the original binding (principalId is gateway-owned, no longer local).
+    const guardian = localVellumGuardian("verified-phone-guardian");
+    expect(guardian!.channel.address).toBe("verified-phone-guardian");
   });
 
   test("returns false when gateway reports no guardian binding", async () => {

package/src/__tests__/guardian-dispatch.test.ts

@@ -24,11 +24,56 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
-// The pending_question request principal is resolved via the SAME local source
-// the Vellum actor uses — findGuardianForChannel("vellum")?.contact.principalId
-// — so the stamped principal always equals the submitting actor principal. The
-// real contacts DB is seeded in resetTables(); tests model drift / missing
-// guardian by reseeding or clearing that local binding directly.
+// The pending_question request principal is resolved via the gateway guardian
+// delivery for the vellum channel — the SAME source the Vellum actor uses — so
+// the stamped principal always equals the submitting actor principal. The real
+// contacts DB is seeded in resetTables(); the reader mock below derives the
+// gateway delivery from that DB binding so tests model drift / missing guardian
+// by reseeding or clearing the local binding directly.
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async (input?: { channelTypes?: string[] }) => {
+    const { getDb } = await import("../memory/db-connection.js");
+    const { contacts, contactChannels } = await import("../memory/schema.js");
+    const { and, eq } = await import("drizzle-orm");
+    const channels = input?.channelTypes ?? [];
+    return channels
+      .map((channelType) => {
+        const row = getDb()
+          .select({ contact: contacts, channel: contactChannels })
+          .from(contacts)
+          .innerJoin(
+            contactChannels,
+            eq(contacts.id, contactChannels.contactId),
+          )
+          .where(
+            and(
+              eq(contacts.role, "guardian"),
+              eq(contactChannels.type, channelType),
+              eq(contactChannels.status, "active"),
+            ),
+          )
+          .get();
+        if (!row) return null;
+        return {
+          channelType,
+          contactId: row.contact.id,
+          principalId: row.contact.principalId ?? null,
+          displayName: row.contact.displayName ?? null,
+          address: row.channel.address,
+          externalChatId: row.channel.externalChatId ?? null,
+          status: "active",
+          verifiedAt: row.channel.verifiedAt ?? null,
+        };
+      })
+      .filter((g) => g !== null);
+  },
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
+}));
+
 const emitCalls: unknown[] = [];
 let conversationCreatedFromMock: ConversationCreatedInfo | null = null;
 let mockEmitResult: {

package/src/__tests__/guardian-routing-state.test.ts

@@ -14,7 +14,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { upsertContact } from "../contacts/contact-store.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -27,6 +26,7 @@ import {
 } from "../runtime/trust-context-resolver.js";
 import {
   handleChannelInbound,
+  seedContactChannel,
   setAdapterProcessMessage,
 } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
@@ -155,16 +155,12 @@ describe("inbound-message-handler trusted-contact interactivity", () => {
     resetTables();
     setAdapterProcessMessage(undefined);
     // Insert a test contact so the contacts-based ACL lookup passes
-    upsertContact({
+    seedContactChannel({
+      sourceChannel: "telegram",
+      externalUserId: "telegram-user-default",
       displayName: "Test User",
-      channels: [
-        {
-          type: "telegram",
-          address: "telegram-user-default",
-          status: "active",
-          policy: "allow",
-        },
-      ],
+      status: "active",
+      policy: "allow",
     });
   });
 

package/src/__tests__/helpers/channel-test-adapter.ts

@@ -62,11 +62,11 @@ mock.module("../../daemon/approval-generators.js", () => ({
 }));
 
 import type { TrustClass, TrustVerdict } from "@vellumai/gateway-client";
+import { and, desc, eq } from "drizzle-orm";
 
-import {
-  findContactChannel,
-  findGuardianForChannel,
-} from "../../contacts/contact-store.js";
+import { findContactChannel } from "../../contacts/contact-store.js";
+import { getDb } from "../../memory/db-connection.js";
+import { contactChannels, contacts } from "../../memory/schema.js";
 import type {
   ApprovalConversationGenerator,
   ApprovalCopyGenerator,
@@ -147,6 +147,27 @@ function stampTrustVerdict(body: Record<string, unknown>): void {
   body.sourceMetadata = { ...(meta ?? {}), trustVerdict: verdict };
 }
 
+/**
+ * Local mirror of the gateway's active-guardian-channel resolution, querying
+ * the contact store directly (the production query now lives in the gateway).
+ */
+function localGuardianForChannel(channelType: string) {
+  const row = getDb()
+    .select({ contact: contacts, channel: contactChannels })
+    .from(contacts)
+    .innerJoin(contactChannels, eq(contacts.id, contactChannels.contactId))
+    .where(
+      and(
+        eq(contacts.role, "guardian"),
+        eq(contactChannels.type, channelType),
+        eq(contactChannels.status, "active"),
+      ),
+    )
+    .orderBy(desc(contactChannels.verifiedAt))
+    .get();
+  return row ? { contact: row.contact, channel: row.channel } : null;
+}
+
 /** Local mirror of the gateway resolver, reading the daemon contact store. */
 export function resolveLocalTrustVerdict(input: {
   channelType: string;
@@ -161,18 +182,28 @@ export function resolveLocalTrustVerdict(input: {
         address: input.actorExternalId,
       })
     : null;
-  const guardian = findGuardianForChannel(input.channelType);
+  const guardian = localGuardianForChannel(input.channelType);
 
   const isGuardian =
     !!guardian &&
     !!canonicalSenderId &&
     guardian.channel.address.toLowerCase() === canonicalSenderId.toLowerCase();
 
+  // ACL columns are no longer on the slimmed ContactChannel type; read the raw
+  // row (columns still exist) so this local mirror sees status/policy/verified.
+  const memberRow = member
+    ? (getDb()
+        .select()
+        .from(contactChannels)
+        .where(eq(contactChannels.id, member.channel.id))
+        .get() ?? null)
+    : null;
+
   let trustClass: TrustClass;
   if (isGuardian) {
     trustClass = "guardian";
-  } else if (member) {
-    const status = member.channel.status;
+  } else if (memberRow) {
+    const status = memberRow.status;
     if (status === "active") trustClass = "trusted_contact";
     else if (status === "unverified" || status === "pending")
       trustClass = "unverified_contact";
@@ -191,22 +222,24 @@ export function resolveLocalTrustVerdict(input: {
     verdict.guardianDisplayName = guardian.contact.displayName;
   }
 
-  if (member) {
+  if (member && memberRow) {
     verdict.contactId = member.channel.contactId;
     verdict.channelId = member.channel.id;
     verdict.type = member.channel.type;
     verdict.address = member.channel.address;
     verdict.externalChatId = member.channel.externalChatId;
-    verdict.status = member.channel.status;
-    verdict.policy = member.channel.policy;
-    verdict.verifiedAt = member.channel.verifiedAt;
-    verdict.verifiedVia = member.channel.verifiedVia;
+    verdict.status = memberRow.status;
+    verdict.policy = memberRow.policy;
+    verdict.verifiedAt = memberRow.verifiedAt;
+    verdict.verifiedVia = memberRow.verifiedVia;
     verdict.memberDisplayName = member.contact.displayName;
   }
 
   return verdict;
 }
 
+export { seedContactChannel } from "./seed-contact-channel.js";
+
 // ---------------------------------------------------------------------------
 // handleDeleteConversation adapter
 // ---------------------------------------------------------------------------

package/src/__tests__/helpers/create-guardian-binding.ts

@@ -4,11 +4,10 @@
  * path was moved to the gateway.
  */
 
-import type { ChannelId } from "../../channels/types.js";
-import { upsertContact } from "../../contacts/contact-store.js";
+import { getContact } from "../../contacts/contact-store.js";
 import type { GuardianBinding } from "../../memory/channel-verification-sessions.js";
 import { ensureGuardianPersonaFile } from "../../prompts/persona-resolver.js";
-import { canonicalizeInboundIdentity } from "../../util/canonicalize-identity.js";
+import { seedContactChannel } from "./seed-contact-channel.js";
 
 function parseDisplayNameFromMetadata(
   metadataJson: string | null | undefined,
@@ -36,37 +35,30 @@ export function createGuardianBinding(params: {
   verifiedVia?: string;
   metadataJson?: string | null;
 }): GuardianBinding {
-  const canonicalId =
-    canonicalizeInboundIdentity(
-      params.channel as ChannelId,
-      params.guardianExternalUserId,
-    ) ?? params.guardianExternalUserId;
-
   const displayName =
     parseDisplayNameFromMetadata(params.metadataJson) ??
     params.guardianExternalUserId;
 
-  const contact = upsertContact({
+  // The production identity upsert no longer writes ACL columns (gateway-owned);
+  // seedContactChannel stamps the guardian ACL state directly so the local
+  // guardian-resolution reads still under test resolve this binding.
+  const { contactId } = seedContactChannel({
+    sourceChannel: params.channel,
+    externalUserId: params.guardianExternalUserId,
+    externalChatId: params.guardianDeliveryChatId,
     displayName,
     role: "guardian",
-    notes: "guardian",
     principalId: params.guardianPrincipalId,
-    channels: [
-      {
-        type: params.channel,
-        address: canonicalId,
-        externalChatId: params.guardianDeliveryChatId,
-        status: "active",
-        verifiedAt: Date.now(),
-        verifiedVia: params.verifiedVia ?? "challenge",
-      },
-    ],
+    status: "active",
+    verifiedAt: Date.now(),
+    verifiedVia: params.verifiedVia ?? "challenge",
   });
 
   // Seed persona file (mirrors gateway's production behavior)
-  if (contact.userFile) {
+  const userFile = getContact(contactId)?.userFile;
+  if (userFile) {
     try {
-      ensureGuardianPersonaFile(contact.userFile);
+      ensureGuardianPersonaFile(userFile);
     } catch {
       // Tolerate filesystem failures in tests
     }

package/src/__tests__/helpers/mock-logger.ts

@@ -56,6 +56,7 @@ export function createMockLoggerModule(
     initLogger: () => {},
     truncateForLog: (value: string) => value,
     pruneOldLogFiles: () => 0,
+    getCurrentLogFilePath: () => "/tmp/assistant-test-mock.log",
     LOG_FILE_PATTERN: /^assistant-(\d{4}-\d{2}-\d{2})\.log$/,
     ...overrides,
   };