@vellumai/assistant 0.4.26 → 0.4.30

package/src/__tests__/trusted-contact-lifecycle-notifications.test.ts

@@ -89,12 +89,13 @@ mock.module("../runtime/approval-message-composer.js", () => ({
 }));
 
 import { getResolver } from "../approvals/guardian-request-resolvers.js";
+import { findContactChannel } from "../contacts/contact-store.js";
 import {
-  createApprovalRequest,
-  createBinding,
-} from "../memory/channel-guardian-store.js";
+  createGuardianBinding,
+  upsertMember,
+} from "../contacts/contacts-write.js";
+import { createApprovalRequest } from "../memory/channel-guardian-store.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import { findMember, upsertMember } from "../memory/ingress-member-store.js";
 import { createOutboundSession } from "../runtime/channel-guardian-service.js";
 import { handleChannelInbound } from "../runtime/routes/channel-routes.js";
 
@@ -119,13 +120,13 @@ const GUARDIAN_APPROVAL_TTL_MS = 5 * 60 * 1000;
 function resetState(): void {
   const db = getDb();
   db.run("DELETE FROM channel_guardian_approval_requests");
-  db.run("DELETE FROM channel_guardian_bindings");
   db.run("DELETE FROM channel_guardian_verification_challenges");
   db.run("DELETE FROM channel_guardian_rate_limits");
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM conversations");
   db.run("DELETE FROM notification_events");
-  db.run("DELETE FROM assistant_ingress_members");
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
   emitSignalCalls.length = 0;
   deliverReplyCalls.length = 0;
 }
@@ -167,12 +168,13 @@ describe("trusted contact lifecycle notification signals", () => {
 
   test("guardian deny emits guardian_decision and denied signals", async () => {
     // Set up guardian binding and member record (guardians must pass ACL)
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
       guardianDeliveryChatId: "guardian-chat-789",
       guardianPrincipalId: "guardian-user-789",
+      verifiedVia: "test",
     });
     upsertMember({
       assistantId: "self",
@@ -248,12 +250,13 @@ describe("trusted contact lifecycle notification signals", () => {
 
   test("guardian approve emits guardian_decision and verification_sent signals", async () => {
     // Set up guardian binding and member record (guardians must pass ACL)
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
       guardianDeliveryChatId: "guardian-chat-789",
       guardianPrincipalId: "guardian-user-789",
+      verifiedVia: "test",
     });
     upsertMember({
       assistantId: "self",
@@ -325,12 +328,13 @@ describe("trusted contact lifecycle notification signals", () => {
 
   test("deduplication keys prevent duplicate signals", async () => {
     // Set up guardian binding and member record (guardians must pass ACL)
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
       guardianDeliveryChatId: "guardian-chat-789",
       guardianPrincipalId: "guardian-user-789",
+      verifiedVia: "test",
     });
     upsertMember({
       assistantId: "self",
@@ -391,12 +395,13 @@ describe("trusted contact activated notification signal", () => {
 
   test("successful trusted contact verification emits activated signal", async () => {
     // Set up a guardian binding so the verification path allows bypass
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
       guardianDeliveryChatId: "guardian-chat-789",
       guardianPrincipalId: "guardian-user-789",
+      verifiedVia: "test",
     });
 
     // Create an identity-bound outbound session (simulates M3 approval flow)
@@ -447,12 +452,13 @@ describe("trusted contact activated notification signal", () => {
   });
 
   test("re-verification preserves an existing guardian-managed member display name", async () => {
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
       guardianDeliveryChatId: "guardian-chat-789",
       guardianPrincipalId: "guardian-user-789",
+      verifiedVia: "test",
     });
 
     upsertMember({
@@ -484,15 +490,13 @@ describe("trusted contact activated notification signal", () => {
 
     await handleChannelInbound(verifyReq, undefined, TEST_BEARER_TOKEN);
 
-    const member = findMember({
-      assistantId: "self",
-      sourceChannel: "telegram",
+    const result = findContactChannel({
+      channelType: "telegram",
       externalUserId: "requester-user-456",
-      externalChatId: "chat-123",
     });
-    expect(member).not.toBeNull();
-    expect(member!.status).toBe("active");
-    expect(member!.displayName).toBe("Jeff");
+    expect(result).not.toBeNull();
+    expect(result!.channel.status).toBe("active");
+    expect(result!.contact.displayName).toBe("Jeff");
   });
 
   test("guardian verification does NOT emit activated signal", async () => {
@@ -529,12 +533,13 @@ describe("trusted contact activated notification signal", () => {
 
   test("member is persisted BEFORE activated signal is emitted", async () => {
     // Set up a guardian binding
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
       guardianDeliveryChatId: "guardian-chat-789",
       guardianPrincipalId: "guardian-user-789",
+      verifiedVia: "test",
     });
 
     const session = createOutboundSession({
@@ -562,13 +567,12 @@ describe("trusted contact activated notification signal", () => {
     expect(activatedSignals.length).toBe(1);
 
     // Verify the member was already persisted (the signal fires after upsertMember)
-    const member = findMember({
-      assistantId: "self",
-      sourceChannel: "telegram",
+    const result = findContactChannel({
+      channelType: "telegram",
       externalUserId: "requester-user-456",
     });
-    expect(member).not.toBeNull();
-    expect(member!.status).toBe("active");
-    expect(member!.policy).toBe("allow");
+    expect(result).not.toBeNull();
+    expect(result!.channel.status).toBe("active");
+    expect(result!.channel.policy).toBe("allow");
   });
 });

package/src/__tests__/trusted-contact-multichannel.test.ts

@@ -96,9 +96,12 @@ mock.module("../runtime/approval-message-composer.js", () => ({
   composeApprovalMessageGenerative: async () => "mock generative message",
 }));
 
-import { createBinding } from "../memory/channel-guardian-store.js";
+import { findContactChannel } from "../contacts/contact-store.js";
+import {
+  createGuardianBinding,
+  upsertMember,
+} from "../contacts/contacts-write.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import { findMember, upsertMember } from "../memory/ingress-member-store.js";
 import {
   createOutboundSession,
   validateAndConsumeChallenge,
@@ -125,13 +128,13 @@ const TEST_BEARER_TOKEN = "test-token";
 function resetState(): void {
   const db = getDb();
   db.run("DELETE FROM channel_guardian_approval_requests");
-  db.run("DELETE FROM channel_guardian_bindings");
   db.run("DELETE FROM channel_guardian_verification_challenges");
   db.run("DELETE FROM channel_guardian_rate_limits");
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM conversations");
   db.run("DELETE FROM notification_events");
-  db.run("DELETE FROM assistant_ingress_members");
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
   emitSignalCalls.length = 0;
   notifyGuardianCalls.length = 0;
   deliverReplyCalls.length = 0;
@@ -227,12 +230,13 @@ for (const config of CHANNEL_CONFIGS) {
     });
 
     test("guardian is notified when a non-member messages", async () => {
-      createBinding({
+      createGuardianBinding({
         assistantId: "self",
         channel: config.channel,
         guardianExternalUserId: config.guardianExternalUserId,
         guardianDeliveryChatId: config.guardianChatId,
         guardianPrincipalId: config.guardianExternalUserId,
+        verifiedVia: "test",
       });
 
       const req = buildInboundRequest(config);
@@ -264,7 +268,7 @@ for (const config of CHANNEL_CONFIGS) {
         verificationPurpose: "trusted_contact",
       });
 
-      const result = validateAndConsumeChallenge(
+      const challengeResult = validateAndConsumeChallenge(
         "self",
         config.channel,
         session.secret,
@@ -274,9 +278,9 @@ for (const config of CHANNEL_CONFIGS) {
         "Test Requester",
       );
 
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.verificationType).toBe("trusted_contact");
+      expect(challengeResult.success).toBe(true);
+      if (challengeResult.success) {
+        expect(challengeResult.verificationType).toBe("trusted_contact");
       }
 
       upsertMember({
@@ -290,16 +294,15 @@ for (const config of CHANNEL_CONFIGS) {
         username: "test_requester",
       });
 
-      const member = findMember({
-        assistantId: "self",
-        sourceChannel: config.channel,
+      const contactResult = findContactChannel({
+        channelType: config.channel,
         externalUserId: config.senderExternalUserId,
       });
 
-      expect(member).not.toBeNull();
-      expect(member!.status).toBe("active");
-      expect(member!.policy).toBe("allow");
-      expect(member!.sourceChannel).toBe(config.channel);
+      expect(contactResult).not.toBeNull();
+      expect(contactResult!.channel.status).toBe("active");
+      expect(contactResult!.channel.policy).toBe("allow");
+      expect(contactResult!.channel.type).toBe(config.channel);
     });
 
     test("no cross-channel leakage between member records", () => {
@@ -314,21 +317,19 @@ for (const config of CHANNEL_CONFIGS) {
       });
 
       // Should be found on this channel
-      const sameChanMember = findMember({
-        assistantId: "self",
-        sourceChannel: config.channel,
+      const sameChanResult = findContactChannel({
+        channelType: config.channel,
         externalUserId: config.senderExternalUserId,
       });
-      expect(sameChanMember).not.toBeNull();
+      expect(sameChanResult).not.toBeNull();
 
       // Should NOT be found on a different channel
       const otherChannel = config.channel === "telegram" ? "sms" : "telegram";
-      const crossChanMember = findMember({
-        assistantId: "self",
-        sourceChannel: otherChannel,
+      const crossChanResult = findContactChannel({
+        channelType: otherChannel,
         externalUserId: config.senderExternalUserId,
       });
-      expect(crossChanMember).toBeNull();
+      expect(crossChanResult).toBeNull();
     });
   });
 }

package/src/__tests__/trusted-contact-verification.test.ts

@@ -3,7 +3,7 @@
  *
  * When a requester successfully verifies their identity (enters the correct
  * 6-digit code from an identity-bound outbound session), the system should:
- * 1. Upsert an active member record in assistant_ingress_members
+ * 1. Upsert an active member record (contact + contact_channel)
  * 2. Allow subsequent messages through the ACL check
  * 3. Scope the member correctly (no cross-assistant leakage)
  * 4. Reactivate previously revoked members on re-verification
@@ -42,15 +42,15 @@ mock.module("../util/logger.js", () => ({
 }));
 
 import {
-  createBinding,
-  getActiveBinding,
-} from "../memory/channel-guardian-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+  findContactChannel,
+  findGuardianForChannel,
+} from "../contacts/contact-store.js";
 import {
-  findMember,
+  createGuardianBinding,
   revokeMember,
   upsertMember,
-} from "../memory/ingress-member-store.js";
+} from "../contacts/contacts-write.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
 import {
   createOutboundSession,
@@ -75,9 +75,9 @@ afterAll(() => {
 function resetTables(): void {
   const db = getDb();
   db.run("DELETE FROM channel_guardian_verification_challenges");
-  db.run("DELETE FROM channel_guardian_bindings");
   db.run("DELETE FROM channel_guardian_rate_limits");
-  db.run("DELETE FROM assistant_ingress_members");
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
 }
 
 // ---------------------------------------------------------------------------
@@ -119,7 +119,6 @@ describe("trusted contact verification → member activation", () => {
 
     // Simulate the member upsert that inbound-message-handler performs on success
     upsertMember({
-      assistantId: "self",
       sourceChannel: "telegram",
       externalUserId: "requester-user-123",
       externalChatId: "requester-chat-123",
@@ -130,26 +129,22 @@ describe("trusted contact verification → member activation", () => {
     });
 
     // Verify: active member record exists
-    const member = findMember({
-      assistantId: "self",
-      sourceChannel: "telegram",
+    const contactResult = findContactChannel({
+      channelType: "telegram",
       externalUserId: "requester-user-123",
     });
 
-    expect(member).not.toBeNull();
-    expect(member!.status).toBe("active");
-    expect(member!.policy).toBe("allow");
-    expect(member!.externalUserId).toBe("requester-user-123");
-    expect(member!.externalChatId).toBe("requester-chat-123");
-    expect(member!.displayName).toBe("Requester Name");
-    expect(member!.username).toBe("requester_username");
-    expect(member!.assistantId).toBe("self");
-    expect(member!.sourceChannel).toBe("telegram");
+    expect(contactResult).not.toBeNull();
+    expect(contactResult!.channel.status).toBe("active");
+    expect(contactResult!.channel.policy).toBe("allow");
+    expect(contactResult!.channel.externalUserId).toBe("requester-user-123");
+    expect(contactResult!.channel.externalChatId).toBe("requester-chat-123");
+    expect(contactResult!.contact.displayName).toBe("Requester Name");
+    expect(contactResult!.channel.type).toBe("telegram");
   });
 
   test("resolveActorTrust surfaces member displayName when sender displayName is missing", () => {
     upsertMember({
-      assistantId: "self",
       sourceChannel: "telegram",
       externalUserId: "requester-user-jeff",
       externalChatId: "requester-chat-jeff",
@@ -170,12 +165,14 @@ describe("trusted contact verification → member activation", () => {
     expect(trust.actorMetadata.displayName).toBe("Jeff");
     expect(trust.actorMetadata.senderDisplayName).toBeUndefined();
     expect(trust.actorMetadata.memberDisplayName).toBe("Jeff");
-    expect(trust.actorMetadata.identifier).toBe("@jeff_handle");
+    // Contacts-first path does not carry username from the contact channel,
+    // so identifier falls back to canonicalSenderId when no actorUsername
+    // is provided.
+    expect(trust.actorMetadata.identifier).toBe("requester-user-jeff");
   });
 
   test("resolveActorTrust prioritizes member displayName over sender displayName", () => {
     upsertMember({
-      assistantId: "self",
       sourceChannel: "telegram",
       externalUserId: "requester-user-jeff-priority",
       externalChatId: "requester-chat-jeff-priority",
@@ -198,15 +195,16 @@ describe("trusted contact verification → member activation", () => {
     expect(trust.actorMetadata.displayName).toBe("Jeff");
     expect(trust.actorMetadata.senderDisplayName).toBe("Jeffrey");
     expect(trust.actorMetadata.memberDisplayName).toBe("Jeff");
-    expect(trust.actorMetadata.username).toBe("jeff_handle");
-    expect(trust.actorMetadata.identifier).toBe("@jeff_handle");
+    // Contacts-first path does not carry username from the contact channel,
+    // so the sender's username takes precedence via the fallback chain.
+    expect(trust.actorMetadata.username).toBe("jeffrey_telegram");
+    expect(trust.actorMetadata.identifier).toBe("@jeffrey_telegram");
   });
 
   test("resolveActorTrust falls back to sender metadata when member record matches chat but not sender (group chat)", () => {
     // Simulate a group chat: member record exists for a different user who
     // shares the same externalChatId (e.g., Telegram group).
     upsertMember({
-      assistantId: "self",
       sourceChannel: "telegram",
       externalUserId: "other-user-in-group",
       externalChatId: "shared-group-chat",
@@ -259,7 +257,6 @@ describe("trusted contact verification → member activation", () => {
 
     // Simulate member upsert on verification success
     upsertMember({
-      assistantId: "self",
       sourceChannel: "telegram",
       externalUserId: "requester-user-456",
       externalChatId: "requester-chat-456",
@@ -268,21 +265,19 @@ describe("trusted contact verification → member activation", () => {
     });
 
     // Simulate the ACL check that inbound-message-handler performs
-    const member = findMember({
-      assistantId: "self",
-      sourceChannel: "telegram",
+    const contactResult = findContactChannel({
+      channelType: "telegram",
       externalUserId: "requester-user-456",
-      externalChatId: "requester-chat-456",
     });
 
-    expect(member).not.toBeNull();
-    expect(member!.status).toBe("active");
-    expect(member!.policy).toBe("allow");
+    expect(contactResult).not.toBeNull();
+    expect(contactResult!.channel.status).toBe("active");
+    expect(contactResult!.channel.policy).toBe("allow");
     // ACL check passes: member exists, is active, and has allow policy
   });
 
-  test("no cross-assistant leakage (member scoped correctly)", () => {
-    // Create member for assistant 'self'
+  test("member lookup is scoped by channel type", () => {
+    // Create member on the telegram channel
     const session = createOutboundSession({
       assistantId: "self",
       channel: "telegram",
@@ -302,7 +297,6 @@ describe("trusted contact verification → member activation", () => {
     );
 
     upsertMember({
-      assistantId: "self",
       sourceChannel: "telegram",
       externalUserId: "user-cross-test",
       externalChatId: "chat-cross-test",
@@ -310,28 +304,25 @@ describe("trusted contact verification → member activation", () => {
       policy: "allow",
     });
 
-    // Member should be found for 'self'
-    const selfMember = findMember({
-      assistantId: "self",
-      sourceChannel: "telegram",
+    // Member should be found via contacts
+    const contactResult = findContactChannel({
+      channelType: "telegram",
       externalUserId: "user-cross-test",
     });
-    expect(selfMember).not.toBeNull();
-    expect(selfMember!.status).toBe("active");
+    expect(contactResult).not.toBeNull();
+    expect(contactResult!.channel.status).toBe("active");
 
-    // Member should NOT be found for a different assistant
-    const otherMember = findMember({
-      assistantId: "other-assistant",
-      sourceChannel: "telegram",
+    // Member should NOT be found for a different channel type
+    const otherChannel = findContactChannel({
+      channelType: "slack",
       externalUserId: "user-cross-test",
     });
-    expect(otherMember).toBeNull();
+    expect(otherChannel).toBeNull();
   });
 
   test("re-verification of previously revoked member reactivates them", () => {
     // Create and activate a member
     const member = upsertMember({
-      assistantId: "self",
       sourceChannel: "telegram",
       externalUserId: "user-revoked",
       externalChatId: "chat-revoked",
@@ -341,18 +332,17 @@ describe("trusted contact verification → member activation", () => {
     });
 
     // Revoke the member
-    const revoked = revokeMember(member.id, "testing revocation");
+    const revoked = revokeMember(member!.channel.id, "testing revocation");
     expect(revoked).not.toBeNull();
-    expect(revoked!.status).toBe("revoked");
+    expect(revoked!.channel.status).toBe("revoked");
 
     // Verify the member is indeed revoked (ACL would reject)
-    const revokedMember = findMember({
-      assistantId: "self",
-      sourceChannel: "telegram",
+    const revokedResult = findContactChannel({
+      channelType: "telegram",
       externalUserId: "user-revoked",
     });
-    expect(revokedMember).not.toBeNull();
-    expect(revokedMember!.status).toBe("revoked");
+    expect(revokedResult).not.toBeNull();
+    expect(revokedResult!.channel.status).toBe("revoked");
 
     // Guardian re-approves, new outbound session created
     const session = createOutboundSession({
@@ -380,7 +370,6 @@ describe("trusted contact verification → member activation", () => {
 
     // upsertMember reactivates the existing record
     upsertMember({
-      assistantId: "self",
       sourceChannel: "telegram",
       externalUserId: "user-revoked",
       externalChatId: "chat-revoked",
@@ -389,19 +378,18 @@ describe("trusted contact verification → member activation", () => {
     });
 
     // Verify: member is now active again
-    const reactivated = findMember({
-      assistantId: "self",
-      sourceChannel: "telegram",
+    const reactivatedResult = findContactChannel({
+      channelType: "telegram",
       externalUserId: "user-revoked",
     });
-    expect(reactivated).not.toBeNull();
-    expect(reactivated!.status).toBe("active");
-    expect(reactivated!.policy).toBe("allow");
+    expect(reactivatedResult).not.toBeNull();
+    expect(reactivatedResult!.channel.status).toBe("active");
+    expect(reactivatedResult!.channel.policy).toBe("allow");
   });
 
   test("trusted contact verification does NOT create a guardian binding", () => {
     // Ensure there's an existing guardian binding we want to preserve
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "guardian-user-original",
@@ -438,12 +426,14 @@ describe("trusted contact verification → member activation", () => {
     }
 
     // The original guardian binding should remain intact
-    const binding = getActiveBinding("self", "telegram");
-    expect(binding).not.toBeNull();
-    expect(binding!.guardianExternalUserId).toBe("guardian-user-original");
+    const guardianResult = findGuardianForChannel("telegram", "self");
+    expect(guardianResult).not.toBeNull();
+    expect(guardianResult!.channel.externalUserId).toBe(
+      "guardian-user-original",
+    );
   });
 
-  test("guardian inbound verification still creates binding (backward compat)", async () => {
+  test("guardian inbound verification succeeds but does not create binding", async () => {
     // Create an inbound challenge (no expected identity — guardian flow)
 
     const { createVerificationChallenge } =
@@ -459,13 +449,11 @@ describe("trusted contact verification → member activation", () => {
     );
 
     expect(result.success).toBe(true);
-    if (result.success && result.verificationType === "guardian") {
-      expect(result.bindingId).toBeDefined();
+    if (result.success) {
+      expect(result.verificationType).toBe("guardian");
     }
 
-    // Guardian binding should be created
-    const binding = getActiveBinding("self", "telegram");
-    expect(binding).not.toBeNull();
-    expect(binding!.guardianExternalUserId).toBe("guardian-user");
+    const guardianResult = findGuardianForChannel("telegram", "self");
+    expect(guardianResult).toBeNull();
   });
 });