@vellumai/assistant 0.10.3-staging.2 → 0.10.4-staging.1

package/src/__tests__/channel-approval-routes.test.ts

@@ -69,7 +69,6 @@ mock.module("../daemon/approval-generators.js", () => ({
   createApprovalConversationGenerator: () => _testApprovalConversationGenerator,
 }));
 
-import { upsertContact } from "../contacts/contact-store.js";
 import type { Conversation } from "../daemon/conversation.js";
 import {
   createCanonicalGuardianDelivery,
@@ -86,7 +85,10 @@ import * as gatewayClient from "../runtime/gateway-client.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { _setTestPollMaxWait } from "../runtime/routes/channel-route-shared.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
-import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
+import {
+  handleChannelInbound,
+  seedContactChannel,
+} from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 await initializeDb();
@@ -212,22 +214,19 @@ function makeInboundRequest(overrides: Record<string, unknown> = {}): Request {
 const noopProcessMessage = mock(async () => ({ messageId: "msg-1" }));
 
 function ensureTestContact(): void {
-  upsertContact({
+  seedContactChannel({
+    sourceChannel: "telegram",
+    externalUserId: "telegram-user-default",
     displayName: "Test User",
-    channels: [
-      {
-        type: "telegram",
-        address: "telegram-user-default",
-        status: "active",
-        policy: "allow",
-      },
-      {
-        type: "slack",
-        address: "slack-user-default",
-        status: "active",
-        policy: "allow",
-      },
-    ],
+    status: "active",
+    policy: "allow",
+  });
+  seedContactChannel({
+    sourceChannel: "slack",
+    externalUserId: "slack-user-default",
+    displayName: "Test User",
+    status: "active",
+    policy: "allow",
   });
 }
 
@@ -1926,16 +1925,12 @@ describe("trusted-contact self-approval blocked before guardian approval row exi
       guardianDeliveryChatId: "guardian-tc-selfapproval-chat",
       guardianPrincipalId: "guardian-tc-selfapproval",
     });
-    upsertContact({
+    seedContactChannel({
+      sourceChannel: "telegram",
+      externalUserId: "tc-selfapproval-user",
       displayName: "TC Self-Approval User",
-      channels: [
-        {
-          type: "telegram",
-          address: "tc-selfapproval-user",
-          status: "active",
-          policy: "allow",
-        },
-      ],
+      status: "active",
+      policy: "allow",
     });
   });
 

package/src/__tests__/channel-delivery-store.test.ts

@@ -493,6 +493,34 @@ describe("channel-delivery-store", () => {
     });
   });
 
+  test("conversation detail omits Slack metadata for non-Slack channels", () => {
+    const result = recordInbound("telegram", "tg-chat-1", "msg-1", {
+      sourceThreadId: "9001",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "telegram",
+      externalChatId: "tg-chat-1",
+      externalChatName: "Family",
+      externalThreadId: "9001",
+    });
+
+    const detail = buildConversationDetailResponse(result.conversationId);
+    const binding = detail?.conversation.channelBinding;
+
+    // The channel-neutral fields pass through for any source channel...
+    expect(binding).toMatchObject({
+      sourceChannel: "telegram",
+      externalChatId: "tg-chat-1",
+      externalChatName: "Family",
+      externalThreadId: "9001",
+    });
+    // ...but Slack-only deep-link metadata is not synthesized.
+    expect(binding).not.toHaveProperty("slackThread");
+    expect(binding).not.toHaveProperty("slackChannel");
+  });
+
   test("binding upsert preserves existing chat name when incoming name is missing", () => {
     const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
       sourceThreadId: "1710000000.000100",

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

@@ -65,45 +65,77 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
 
 // Gateway relay mock — the revoke path relays the ACL downgrade over IPC and
 // validates the response; return a well-formed mark_channel_revoked result.
+// The gateway owns the revoke and dual-writes the local assistant row to
+// "revoked"; mirror that dual-write here so guardian-resolution reads under
+// test observe the downgrade (the assistant-side teardown is now a no-op shim).
 mock.module("../ipc/gateway-client.js", () => ({
   ipcCallPersistent: async (
-    _method: string,
+    method: string,
     params?: Record<string, unknown>,
-  ) => ({
-    ok: true,
-    didWrite: true,
-    channel: {
-      id: (params?.contactChannelId as string) ?? "ch1",
-      contactId: "c1",
-      type: "phone",
-      address: "addr",
-      status: "revoked",
-      revokedReason: (params?.reason as string) ?? null,
-    },
-  }),
+  ) => {
+    if (method === "mark_channel_revoked") {
+      const { getDb } = await import("../memory/db-connection.js");
+      const { contactChannels } = await import("../memory/schema.js");
+      const { eq } = await import("drizzle-orm");
+      const channelId = params?.contactChannelId as string | undefined;
+      if (channelId) {
+        getDb()
+          .update(contactChannels)
+          .set({ status: "revoked" })
+          .where(eq(contactChannels.id, channelId))
+          .run();
+      }
+    }
+    return {
+      ok: true,
+      didWrite: true,
+      channel: {
+        id: (params?.contactChannelId as string) ?? "ch1",
+        contactId: "c1",
+        type: "phone",
+        address: "addr",
+        status: "revoked",
+        revokedReason: (params?.reason as string) ?? null,
+      },
+    };
+  },
 }));
 
 // Guardian-delivery reader mock — the inbound challenge guard reads guardian
 // existence from the gateway. Derive the list from the local binding state so
 // the gateway-backed presence guard mirrors the DB the rest of the test sets up.
 const resolveGuardianList = async (input?: { channelTypes?: string[] }) => {
-  const { findGuardianForChannel } = await import(
-    "../contacts/contact-store.js"
-  );
+  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 found = findGuardianForChannel(channelType);
-      if (!found) return null;
+      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: found.contact.id,
-        principalId: found.contact.principalId ?? null,
-        displayName: found.contact.displayName ?? null,
-        address: found.channel.address,
-        externalChatId: found.channel.externalChatId ?? null,
+        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: found.channel.verifiedAt ?? null,
+        verifiedAt: row.channel.verifiedAt ?? null,
       };
     })
     .filter((g) => g !== null);
@@ -147,6 +179,7 @@ import {
 } from "../memory/guardian-rate-limits.js";
 import {
   channelVerificationSessions,
+  contactChannels,
   conversations,
 } from "../memory/schema.js";
 import {
@@ -192,6 +225,19 @@ function resetTables(): void {
   mockBotUsername = "test_bot";
 }
 
+/**
+ * Revoke a guardian channel's local ACL state directly. The production revoke
+ * is gateway-owned (relayed via mark_channel_revoked); this stamps the local
+ * mirror so the guardian-resolution reads still under test see the downgrade.
+ */
+function revokeGuardianChannelLocally(channelType: string): void {
+  getDb()
+    .update(contactChannels)
+    .set({ status: "revoked" })
+    .where(eq(contactChannels.type, channelType))
+    .run();
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // 2. Verification Challenge Lifecycle (Store)
 // ═══════════════════════════════════════════════════════════════════════════
@@ -558,7 +604,7 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "chat-42",
     });
 
-    serviceRevokeBinding("asst-1", "telegram");
+    revokeGuardianChannelLocally("telegram");
 
     expect(await isGuardian("asst-1", "telegram", "user-42")).toBe(false);
   });
@@ -595,7 +641,7 @@ describe("guardian identity check", () => {
     expect(await isGuardian("asst-1", "telegram", "phone-user-1")).toBe(false);
   });
 
-  test("serviceRevokeBinding revokes the active binding", async () => {
+  test("guardian binding read reflects a gateway-owned revoke", async () => {
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "user-42",
@@ -603,8 +649,10 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "chat-42",
     });
 
-    const result = serviceRevokeBinding("asst-1", "telegram");
-    expect(result).toBe(true);
+    // The revoke is gateway-owned; serviceRevokeBinding's local teardown is a
+    // no-op shim. Stamp the local downgrade and assert the read reflects it.
+    serviceRevokeBinding("asst-1", "telegram");
+    revokeGuardianChannelLocally("telegram");
     expect(await getGuardianBinding("asst-1", "telegram")).toBeNull();
   });
 });
@@ -958,7 +1006,7 @@ describe("channel-scoped guardian resolution", () => {
       guardianDeliveryChatId: "chat-beta",
     });
 
-    serviceRevokeBinding("self", "telegram");
+    revokeGuardianChannelLocally("telegram");
 
     expect(await getGuardianBinding("self", "telegram")).toBeNull();
     expect(await getGuardianBinding("self", "phone")).not.toBeNull();
@@ -1472,8 +1520,10 @@ describe("voice guardian identity and revocation", () => {
       guardianDeliveryChatId: "voice-chat-1",
     });
 
-    const result = serviceRevokeBinding("asst-1", "phone");
-    expect(result).toBe(true);
+    // The revoke is gateway-owned; serviceRevokeBinding's local teardown is a
+    // no-op shim. Stamp the local downgrade and assert the read reflects it.
+    serviceRevokeBinding("asst-1", "phone");
+    revokeGuardianChannelLocally("phone");
     expect(await getGuardianBinding("asst-1", "phone")).toBeNull();
   });
 
@@ -1491,7 +1541,7 @@ describe("voice guardian identity and revocation", () => {
       guardianDeliveryChatId: "tg-chat-1",
     });
 
-    serviceRevokeBinding("asst-1", "phone");
+    revokeGuardianChannelLocally("phone");
 
     expect(await getGuardianBinding("asst-1", "phone")).toBeNull();
     expect(await getGuardianBinding("asst-1", "telegram")).not.toBeNull();

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -59,7 +59,6 @@ mock.module("../daemon/disk-pressure-guard.js", () => ({
     diskPressureStatusSequence?.shift() ?? diskPressureStatus,
 }));
 
-import { upsertContact } from "../contacts/contact-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import * as deliveryCrud from "../memory/delivery-crud.js";
@@ -71,6 +70,7 @@ import {
 import { sweepFailedEvents } from "../runtime/channel-retry-sweep.js";
 import {
   handleChannelInbound,
+  seedContactChannel,
   setAdapterProcessMessage,
 } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
@@ -90,16 +90,12 @@ function resetTables(): void {
 }
 
 function seedTrustedContact(policy: "allow" | "escalate" = "allow"): void {
-  upsertContact({
+  seedContactChannel({
+    sourceChannel: "telegram",
+    externalUserId: "telegram-user-1",
     displayName: "Example User",
-    channels: [
-      {
-        type: "telegram",
-        address: "telegram-user-1",
-        status: "active",
-        policy,
-      },
-    ],
+    status: "active",
+    policy,
   });
 }
 
@@ -236,16 +232,12 @@ describe("channel inbound disk pressure gate", () => {
   });
 
   test("blocks non-guardian Slack reactions silently (no reply) before persistence while locked", async () => {
-    upsertContact({
+    seedContactChannel({
+      sourceChannel: "slack",
+      externalUserId: "slack-user-1",
       displayName: "Example Slack User",
-      channels: [
-        {
-          type: "slack",
-          address: "slack-user-1",
-          status: "active",
-          policy: "allow",
-        },
-      ],
+      status: "active",
+      policy: "allow",
     });
     const processMessage = mock(async () => {
       throw new Error("processMessage should not run");

package/src/__tests__/channel-reply-delivery.test.ts

@@ -81,8 +81,8 @@ mock.module("../runtime/gateway-client.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
@@ -240,6 +240,7 @@ describe("channel-reply-delivery", () => {
       payload: {
         chatId: "chat-1",
         text: "Before tool.",
+        useBlocks: true,
         attachments: undefined,
         assistantId: "assistant-1",
       },
@@ -249,6 +250,7 @@ describe("channel-reply-delivery", () => {
       payload: {
         chatId: "chat-1",
         text: "After tool.",
+        useBlocks: true,
         attachments,
         assistantId: "assistant-1",
       },
@@ -307,12 +309,14 @@ describe("channel-reply-delivery", () => {
     expect(deliveryCalls[0].payload).toEqual({
       chatId: "chat-3",
       text: "Before tool.",
+      useBlocks: true,
       attachments: undefined,
       assistantId: "assistant-2",
     });
     expect(deliveryCalls[1].payload).toEqual({
       chatId: "chat-3",
       text: "After tool.",
+      useBlocks: true,
       attachments: [
         {
           id: "att-2",

package/src/__tests__/compaction-ledger-store.test.ts

@@ -0,0 +1,128 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+import {
+  appendCompactionEvent,
+  forkCompactionLedger,
+  getLatestCompactionEventAtOrBefore,
+} from "../memory/compaction-ledger-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import {
+  conversationCompactionEvents,
+  conversations,
+} from "../memory/schema.js";
+
+await initializeDb();
+
+function reset(): void {
+  const db = getDb();
+  db.delete(conversationCompactionEvents).run();
+  db.delete(conversations).run();
+}
+
+function makeConversation(id: string): void {
+  const now = Date.now();
+  getDb()
+    .insert(conversations)
+    .values({ id, title: id, createdAt: now, updatedAt: now })
+    .run();
+}
+
+function forkEventsFor(conversationId: string) {
+  return getDb()
+    .select()
+    .from(conversationCompactionEvents)
+    .where(eq(conversationCompactionEvents.conversationId, conversationId))
+    .all();
+}
+
+describe("compaction-ledger-store", () => {
+  beforeEach(reset);
+
+  test("getLatestCompactionEventAtOrBefore returns the newest event at-or-before the cutoff", () => {
+    makeConversation("conv");
+    appendCompactionEvent("conv", {
+      compactedAt: 100,
+      summary: "s100",
+      compactedMessageCount: 1,
+    });
+    appendCompactionEvent("conv", {
+      compactedAt: 200,
+      summary: "s200",
+      compactedMessageCount: 3,
+    });
+    appendCompactionEvent("conv", {
+      compactedAt: 300,
+      summary: "s300",
+      compactedMessageCount: 5,
+    });
+
+    expect(getLatestCompactionEventAtOrBefore("conv", 50)).toBeNull();
+    expect(
+      getLatestCompactionEventAtOrBefore("conv", 100)?.compactedMessageCount,
+    ).toBe(1);
+    expect(
+      getLatestCompactionEventAtOrBefore("conv", 250)?.compactedMessageCount,
+    ).toBe(3);
+    expect(
+      getLatestCompactionEventAtOrBefore("conv", 999)?.compactedMessageCount,
+    ).toBe(5);
+    expect(getLatestCompactionEventAtOrBefore("conv", null)).toBeNull();
+  });
+
+  test("getLatestCompactionEventAtOrBefore is scoped per conversation", () => {
+    makeConversation("a");
+    makeConversation("b");
+    appendCompactionEvent("a", {
+      compactedAt: 100,
+      summary: "a",
+      compactedMessageCount: 1,
+    });
+
+    expect(getLatestCompactionEventAtOrBefore("b", 999)).toBeNull();
+  });
+
+  test("forkCompactionLedger copies only events at-or-before the boundary", () => {
+    makeConversation("src");
+    makeConversation("fork");
+    appendCompactionEvent("src", {
+      compactedAt: 100,
+      summary: "s100",
+      compactedMessageCount: 1,
+    });
+    appendCompactionEvent("src", {
+      compactedAt: 300,
+      summary: "s300",
+      compactedMessageCount: 5,
+    });
+
+    forkCompactionLedger(getDb(), "src", "fork", 200);
+
+    const copied = forkEventsFor("fork");
+    expect(copied).toHaveLength(1);
+    expect(copied[0]?.compactedAt).toBe(100);
+    expect(copied[0]?.summary).toBe("s100");
+  });
+
+  test("forkCompactionLedger with a null boundary copies nothing", () => {
+    makeConversation("src");
+    makeConversation("fork");
+    appendCompactionEvent("src", {
+      compactedAt: 100,
+      summary: "s100",
+      compactedMessageCount: 1,
+    });
+
+    forkCompactionLedger(getDb(), "src", "fork", null);
+
+    expect(forkEventsFor("fork")).toHaveLength(0);
+  });
+});