@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

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

@@ -65,22 +65,90 @@ 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 { 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);
+};
+
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: resolveGuardianList,
+  getGuardianDeliveryFresh: resolveGuardianList,
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
 }));
 
 import { handleChannelVerificationSession } from "../daemon/handlers/config-channels.js";
@@ -111,6 +179,7 @@ import {
 } from "../memory/guardian-rate-limits.js";
 import {
   channelVerificationSessions,
+  contactChannels,
   conversations,
 } from "../memory/schema.js";
 import {
@@ -156,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)
 // ═══════════════════════════════════════════════════════════════════════════
@@ -319,12 +401,12 @@ describe("guardian service challenge validation", () => {
     }
   });
 
-  test("validateAndConsumeVerification does not create a guardian binding (caller responsibility)", () => {
+  test("validateAndConsumeVerification does not create a guardian binding (caller responsibility)", async () => {
     const { secret } = createInboundVerificationSession("telegram");
 
     validateAndConsumeVerification("telegram", secret, "user-42", "chat-42");
 
-    const binding = getGuardianBinding("asst-1", "telegram");
+    const binding = await getGuardianBinding("asst-1", "telegram");
     expect(binding).toBeNull();
   });
 
@@ -396,7 +478,7 @@ describe("guardian service challenge validation", () => {
     expect(result2.success).toBe(false);
   });
 
-  test("validateAndConsumeVerification succeeds with voice channel", () => {
+  test("validateAndConsumeVerification succeeds with voice channel", async () => {
     const { secret } = createInboundVerificationSession("phone");
 
     const result = validateAndConsumeVerification(
@@ -413,7 +495,7 @@ describe("guardian service challenge validation", () => {
 
     // validateAndConsumeVerification no longer creates bindings — that is
     // now handled by the gateway's verification intercepts.
-    const binding = getGuardianBinding("asst-1", "phone");
+    const binding = await getGuardianBinding("asst-1", "phone");
     expect(binding).toBeNull();
   });
 
@@ -449,7 +531,7 @@ describe("guardian service challenge validation", () => {
     expect(telegramResult.success).toBe(true);
   });
 
-  test("validateAndConsumeVerification succeeds even with existing binding (conflict check is caller responsibility)", () => {
+  test("validateAndConsumeVerification succeeds even with existing binding (conflict check is caller responsibility)", async () => {
     // Create initial guardian binding
     createGuardianBinding({
       channel: "telegram",
@@ -458,7 +540,7 @@ describe("guardian service challenge validation", () => {
       guardianDeliveryChatId: "old-chat",
     });
 
-    const oldBinding = getGuardianBinding("asst-1", "telegram");
+    const oldBinding = await getGuardianBinding("asst-1", "telegram");
     expect(oldBinding).not.toBeNull();
     expect(oldBinding!.guardianExternalUserId).toBe("old-user");
 
@@ -473,7 +555,7 @@ describe("guardian service challenge validation", () => {
     // Challenge validation succeeds — the caller decides how to handle binding conflicts
     expect(result.success).toBe(true);
 
-    const binding = getGuardianBinding("asst-1", "telegram");
+    const binding = await getGuardianBinding("asst-1", "telegram");
     expect(binding).not.toBeNull();
     expect(binding!.guardianExternalUserId).toBe("old-user");
   });
@@ -488,7 +570,7 @@ describe("guardian identity check", () => {
     resetTables();
   });
 
-  test("isGuardian returns true for matching user", () => {
+  test("isGuardian returns true for matching user", async () => {
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "user-42",
@@ -496,10 +578,10 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "chat-42",
     });
 
-    expect(isGuardian("asst-1", "telegram", "user-42")).toBe(true);
+    expect(await isGuardian("asst-1", "telegram", "user-42")).toBe(true);
   });
 
-  test("isGuardian returns false for non-matching user", () => {
+  test("isGuardian returns false for non-matching user", async () => {
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "user-42",
@@ -507,14 +589,14 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "chat-42",
     });
 
-    expect(isGuardian("asst-1", "telegram", "user-99")).toBe(false);
+    expect(await isGuardian("asst-1", "telegram", "user-99")).toBe(false);
   });
 
-  test("isGuardian returns false when no binding exists", () => {
-    expect(isGuardian("asst-1", "telegram", "user-42")).toBe(false);
+  test("isGuardian returns false when no binding exists", async () => {
+    expect(await isGuardian("asst-1", "telegram", "user-42")).toBe(false);
   });
 
-  test("isGuardian returns false after binding is revoked", () => {
+  test("isGuardian returns false after binding is revoked", async () => {
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "user-42",
@@ -522,12 +604,12 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "chat-42",
     });
 
-    serviceRevokeBinding("asst-1", "telegram");
+    revokeGuardianChannelLocally("telegram");
 
-    expect(isGuardian("asst-1", "telegram", "user-42")).toBe(false);
+    expect(await isGuardian("asst-1", "telegram", "user-42")).toBe(false);
   });
 
-  test("getGuardianBinding returns the active binding", () => {
+  test("getGuardianBinding returns the active binding", async () => {
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "user-42",
@@ -535,17 +617,17 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "chat-42",
     });
 
-    const binding = getGuardianBinding("asst-1", "telegram");
+    const binding = await getGuardianBinding("asst-1", "telegram");
     expect(binding).not.toBeNull();
     expect(binding!.guardianExternalUserId).toBe("user-42");
   });
 
-  test("getGuardianBinding returns null when no binding exists", () => {
-    const binding = getGuardianBinding("asst-1", "telegram");
+  test("getGuardianBinding returns null when no binding exists", async () => {
+    const binding = await getGuardianBinding("asst-1", "telegram");
     expect(binding).toBeNull();
   });
 
-  test("isGuardian works for voice channel", () => {
+  test("isGuardian works for voice channel", async () => {
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "phone-user-1",
@@ -553,13 +635,13 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "voice-chat-1",
     });
 
-    expect(isGuardian("asst-1", "phone", "phone-user-1")).toBe(true);
-    expect(isGuardian("asst-1", "phone", "phone-user-2")).toBe(false);
+    expect(await isGuardian("asst-1", "phone", "phone-user-1")).toBe(true);
+    expect(await isGuardian("asst-1", "phone", "phone-user-2")).toBe(false);
     // Telegram guardian should not match voice channel
-    expect(isGuardian("asst-1", "telegram", "phone-user-1")).toBe(false);
+    expect(await isGuardian("asst-1", "telegram", "phone-user-1")).toBe(false);
   });
 
-  test("serviceRevokeBinding revokes the active binding", () => {
+  test("guardian binding read reflects a gateway-owned revoke", async () => {
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "user-42",
@@ -567,9 +649,11 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "chat-42",
     });
 
-    const result = serviceRevokeBinding("asst-1", "telegram");
-    expect(result).toBe(true);
-    expect(getGuardianBinding("asst-1", "telegram")).toBeNull();
+    // 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();
   });
 });
 
@@ -860,7 +944,7 @@ describe("channel-scoped guardian resolution", () => {
     resetTables();
   });
 
-  test("isGuardian resolves independently per channel", () => {
+  test("isGuardian resolves independently per channel", async () => {
     // Create guardian binding on telegram
     createGuardianBinding({
       channel: "telegram",
@@ -877,15 +961,15 @@ describe("channel-scoped guardian resolution", () => {
     });
 
     // user-alpha is guardian for telegram but not voice
-    expect(isGuardian("self", "telegram", "user-alpha")).toBe(true);
-    expect(isGuardian("self", "phone", "user-alpha")).toBe(false);
+    expect(await isGuardian("self", "telegram", "user-alpha")).toBe(true);
+    expect(await isGuardian("self", "phone", "user-alpha")).toBe(false);
 
     // user-beta is guardian for voice but not telegram
-    expect(isGuardian("self", "phone", "user-beta")).toBe(true);
-    expect(isGuardian("self", "telegram", "user-beta")).toBe(false);
+    expect(await isGuardian("self", "phone", "user-beta")).toBe(true);
+    expect(await isGuardian("self", "telegram", "user-beta")).toBe(false);
   });
 
-  test("getGuardianBinding returns different bindings for different channels", () => {
+  test("getGuardianBinding returns different bindings for different channels", async () => {
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "user-alpha",
@@ -899,8 +983,8 @@ describe("channel-scoped guardian resolution", () => {
       guardianDeliveryChatId: "chat-beta",
     });
 
-    const bindingTelegram = getGuardianBinding("self", "telegram");
-    const bindingVoice = getGuardianBinding("self", "phone");
+    const bindingTelegram = await getGuardianBinding("self", "telegram");
+    const bindingVoice = await getGuardianBinding("self", "phone");
 
     expect(bindingTelegram).not.toBeNull();
     expect(bindingVoice).not.toBeNull();
@@ -908,7 +992,7 @@ describe("channel-scoped guardian resolution", () => {
     expect(bindingVoice!.guardianExternalUserId).toBe("user-beta");
   });
 
-  test("revoking binding for one channel does not affect another", () => {
+  test("revoking binding for one channel does not affect another", async () => {
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "user-alpha",
@@ -922,13 +1006,13 @@ describe("channel-scoped guardian resolution", () => {
       guardianDeliveryChatId: "chat-beta",
     });
 
-    serviceRevokeBinding("self", "telegram");
+    revokeGuardianChannelLocally("telegram");
 
-    expect(getGuardianBinding("self", "telegram")).toBeNull();
-    expect(getGuardianBinding("self", "phone")).not.toBeNull();
+    expect(await getGuardianBinding("self", "telegram")).toBeNull();
+    expect(await getGuardianBinding("self", "phone")).not.toBeNull();
   });
 
-  test("validateAndConsumeVerification scoped to channel", () => {
+  test("validateAndConsumeVerification scoped to channel", async () => {
     // Create challenge on telegram
     const { secret: secretTelegram } =
       createInboundVerificationSession("telegram");
@@ -961,8 +1045,8 @@ describe("channel-scoped guardian resolution", () => {
     );
     expect(resultVoice.success).toBe(true);
 
-    const bindingTelegram = getGuardianBinding("self", "telegram");
-    const bindingVoice = getGuardianBinding("self", "phone");
+    const bindingTelegram = await getGuardianBinding("self", "telegram");
+    const bindingVoice = await getGuardianBinding("self", "phone");
     expect(bindingTelegram).toBeNull();
     expect(bindingVoice).toBeNull();
   });
@@ -1277,7 +1361,7 @@ describe("voice guardian challenge validation", () => {
     }
   });
 
-  test("validateAndConsumeVerification does not create a guardian binding for voice (caller responsibility)", () => {
+  test("validateAndConsumeVerification does not create a guardian binding for voice (caller responsibility)", async () => {
     const { secret } = createInboundVerificationSession("phone");
 
     validateAndConsumeVerification(
@@ -1287,7 +1371,7 @@ describe("voice guardian challenge validation", () => {
       "voice-chat-1",
     );
 
-    const binding = getGuardianBinding("asst-1", "phone");
+    const binding = await getGuardianBinding("asst-1", "phone");
     expect(binding).toBeNull();
   });
 
@@ -1361,7 +1445,7 @@ describe("voice guardian challenge validation", () => {
     expect(result2.success).toBe(false);
   });
 
-  test("validateAndConsumeVerification succeeds even with existing voice binding (conflict check is caller responsibility)", () => {
+  test("validateAndConsumeVerification succeeds even with existing voice binding (conflict check is caller responsibility)", async () => {
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "old-voice-user",
@@ -1369,7 +1453,7 @@ describe("voice guardian challenge validation", () => {
       guardianDeliveryChatId: "old-voice-chat",
     });
 
-    const oldBinding = getGuardianBinding("asst-1", "phone");
+    const oldBinding = await getGuardianBinding("asst-1", "phone");
     expect(oldBinding).not.toBeNull();
     expect(oldBinding!.guardianExternalUserId).toBe("old-voice-user");
 
@@ -1385,7 +1469,7 @@ describe("voice guardian challenge validation", () => {
     expect(result.success).toBe(true);
 
     // The original binding is untouched (no side effects)
-    const binding = getGuardianBinding("asst-1", "phone");
+    const binding = await getGuardianBinding("asst-1", "phone");
     expect(binding).not.toBeNull();
     expect(binding!.guardianExternalUserId).toBe("old-voice-user");
   });
@@ -1400,7 +1484,7 @@ describe("voice guardian identity and revocation", () => {
     resetTables();
   });
 
-  test("isGuardian works for voice channel", () => {
+  test("isGuardian works for voice channel", async () => {
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "voice-user-1",
@@ -1408,13 +1492,13 @@ describe("voice guardian identity and revocation", () => {
       guardianDeliveryChatId: "voice-chat-1",
     });
 
-    expect(isGuardian("asst-1", "phone", "voice-user-1")).toBe(true);
-    expect(isGuardian("asst-1", "phone", "voice-user-2")).toBe(false);
+    expect(await isGuardian("asst-1", "phone", "voice-user-1")).toBe(true);
+    expect(await isGuardian("asst-1", "phone", "voice-user-2")).toBe(false);
     // Voice guardian should not match telegram channel
-    expect(isGuardian("asst-1", "telegram", "voice-user-1")).toBe(false);
+    expect(await isGuardian("asst-1", "telegram", "voice-user-1")).toBe(false);
   });
 
-  test("getGuardianBinding returns voice binding", () => {
+  test("getGuardianBinding returns voice binding", async () => {
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "voice-user-1",
@@ -1422,13 +1506,13 @@ describe("voice guardian identity and revocation", () => {
       guardianDeliveryChatId: "voice-chat-1",
     });
 
-    const binding = getGuardianBinding("asst-1", "phone");
+    const binding = await getGuardianBinding("asst-1", "phone");
     expect(binding).not.toBeNull();
     expect(binding!.channel).toBe("phone");
     expect(binding!.guardianExternalUserId).toBe("voice-user-1");
   });
 
-  test("revokeBinding clears active voice guardian binding", () => {
+  test("revokeBinding clears active voice guardian binding", async () => {
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "voice-user-1",
@@ -1436,12 +1520,14 @@ describe("voice guardian identity and revocation", () => {
       guardianDeliveryChatId: "voice-chat-1",
     });
 
-    const result = serviceRevokeBinding("asst-1", "phone");
-    expect(result).toBe(true);
-    expect(getGuardianBinding("asst-1", "phone")).toBeNull();
+    // 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();
   });
 
-  test("revokeBinding for voice does not affect telegram binding", () => {
+  test("revokeBinding for voice does not affect telegram binding", async () => {
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "voice-user-1",
@@ -1455,10 +1541,10 @@ describe("voice guardian identity and revocation", () => {
       guardianDeliveryChatId: "tg-chat-1",
     });
 
-    serviceRevokeBinding("asst-1", "phone");
+    revokeGuardianChannelLocally("phone");
 
-    expect(getGuardianBinding("asst-1", "phone")).toBeNull();
-    expect(getGuardianBinding("asst-1", "telegram")).not.toBeNull();
+    expect(await getGuardianBinding("asst-1", "phone")).toBeNull();
+    expect(await getGuardianBinding("asst-1", "telegram")).not.toBeNull();
   });
 });
 
@@ -1716,7 +1802,7 @@ describe("HTTP handler voice guardian verification", () => {
     expect(resp!.bound).toBe(false);
 
     // Verify binding is actually revoked
-    expect(getGuardianBinding("self", "phone")).toBeNull();
+    expect(await getGuardianBinding("self", "phone")).toBeNull();
   });
 
   test("revoke for voice does not affect telegram binding", async () => {
@@ -1742,8 +1828,8 @@ describe("HTTP handler voice guardian verification", () => {
 
     await handleChannelVerificationSession(msg);
 
-    expect(getGuardianBinding("self", "phone")).toBeNull();
-    expect(getGuardianBinding("self", "telegram")).not.toBeNull();
+    expect(await getGuardianBinding("self", "phone")).toBeNull();
+    expect(await getGuardianBinding("self", "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,6 +81,8 @@ mock.module("../runtime/gateway-client.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},