@vellumai/assistant 0.4.26 → 0.4.30

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

@@ -37,46 +37,18 @@ mock.module("../security/secret-ingress.js", () => ({
   checkIngressForSecrets: () => ({ blocked: false }),
 }));
 
-// Mock ingress member store with a configurable member lookup.
-// By default returns an active member so ACL passes.
-let mockFindMember: (() => unknown) | null = null;
-mock.module("../memory/ingress-member-store.js", () => ({
-  findMember: (..._args: unknown[]) => {
-    if (mockFindMember) return mockFindMember();
-    return {
-      id: "member-test-default",
-      assistantId: "self",
-      sourceChannel: "telegram",
-      externalUserId: "telegram-user-default",
-      externalChatId: null,
-      displayName: null,
-      username: null,
-      status: "active",
-      policy: "allow",
-      inviteId: null,
-      createdBySessionId: null,
-      revokedReason: null,
-      blockedReason: null,
-      lastSeenAt: null,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    };
-  },
-  updateLastSeen: () => {},
-  upsertMember: () => {},
-}));
-
+import { upsertContact } from "../contacts/contact-store.js";
+import { createGuardianBinding } from "../contacts/contacts-write.js";
+import type { TrustContext } from "../daemon/session-runtime-assembly.js";
 import * as channelDeliveryStore from "../memory/channel-delivery-store.js";
-import { createBinding } from "../memory/channel-guardian-store.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { channelInboundEvents, messages } from "../memory/schema.js";
 import { sweepFailedEvents } from "../runtime/channel-retry-sweep.js";
+import { handleChannelInbound } from "../runtime/routes/channel-routes.js";
 import {
-  type GuardianContext,
   resolveRoutingState,
   resolveRoutingStateFromRuntime,
-} from "../runtime/guardian-context-resolver.js";
-import { handleChannelInbound } from "../runtime/routes/channel-routes.js";
+} from "../runtime/trust-context-resolver.js";
 
 initializeDb();
 
@@ -92,14 +64,14 @@ afterAll(() => {
 function resetTables(): void {
   const db = getDb();
   db.run("DELETE FROM channel_inbound_events");
-  db.run("DELETE FROM channel_guardian_bindings");
   db.run("DELETE FROM channel_guardian_approval_requests");
   db.run("DELETE FROM canonical_guardian_requests");
   db.run("DELETE FROM conversation_keys");
   db.run("DELETE FROM messages");
   db.run("DELETE FROM conversations");
-  db.run("DELETE FROM assistant_ingress_members");
   db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -108,7 +80,7 @@ function resetTables(): void {
 
 describe("resolveRoutingState", () => {
   test("guardian actors are always interactive and route-resolvable", () => {
-    const ctx: GuardianContext = {
+    const ctx: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "guardian",
       guardianExternalUserId: "guardian-123",
@@ -124,7 +96,7 @@ describe("resolveRoutingState", () => {
 
   test("guardian actors are interactive even without guardianExternalUserId", () => {
     // Edge case: guardian is chatting in their own chat, no separate binding needed
-    const ctx: GuardianContext = {
+    const ctx: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "guardian",
     };
@@ -134,7 +106,7 @@ describe("resolveRoutingState", () => {
   });
 
   test("trusted contact with resolvable guardian route is interactive", () => {
-    const ctx: GuardianContext = {
+    const ctx: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "trusted_contact",
       guardianExternalUserId: "guardian-456",
@@ -149,7 +121,7 @@ describe("resolveRoutingState", () => {
   });
 
   test("trusted contact without guardian route is NOT interactive (fail-fast)", () => {
-    const ctx: GuardianContext = {
+    const ctx: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "trusted_contact",
       // No guardianExternalUserId — no guardian binding for this channel
@@ -163,12 +135,12 @@ describe("resolveRoutingState", () => {
   });
 
   test("unknown actors are never interactive regardless of guardian route", () => {
-    const withRoute: GuardianContext = {
+    const withRoute: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "unknown",
       guardianExternalUserId: "guardian-789",
     };
-    const withoutRoute: GuardianContext = {
+    const withoutRoute: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "unknown",
     };
@@ -210,7 +182,20 @@ describe("resolveRoutingStateFromRuntime", () => {
 describe("inbound-message-handler trusted-contact interactivity", () => {
   beforeEach(() => {
     resetTables();
-    mockFindMember = null;
+    // Insert a test contact so the contacts-based ACL lookup passes
+    upsertContact({
+      displayName: "Test User",
+      assistantId: "self",
+      channels: [
+        {
+          type: "telegram",
+          address: "telegram-user-default",
+          externalUserId: "telegram-user-default",
+          status: "active",
+          policy: "allow",
+        },
+      ],
+    });
   });
 
   function makeInboundRequest(
@@ -226,7 +211,9 @@ describe("inbound-message-handler trusted-contact interactivity", () => {
         sourceChannel: "telegram",
         interface: "telegram",
         conversationExternalId: "chat-123",
-        externalMessageId: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        externalMessageId: `msg-${Date.now()}-${Math.random()
+          .toString(36)
+          .slice(2, 8)}`,
         content: "hello",
         actorExternalId: "telegram-user-default",
         replyCallbackUrl: "https://gateway.test/deliver/telegram",
@@ -236,8 +223,8 @@ describe("inbound-message-handler trusted-contact interactivity", () => {
   }
 
   test("trusted contact with guardian binding gets interactive turn", async () => {
-    // Create guardian binding so the trusted contact has a resolvable route
-    createBinding({
+    // Create guardian binding in contacts table so the trust resolver finds it
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "guardian-user-for-tc",
@@ -337,8 +324,8 @@ describe("inbound-message-handler trusted-contact interactivity", () => {
   });
 
   test("guardian actors remain interactive regardless", async () => {
-    // Guardian binding matches the sender
-    createBinding({
+    // Guardian binding matches the sender — use contacts-first so trust resolver finds it
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "telegram-user-default",
@@ -389,10 +376,8 @@ describe("inbound-message-handler trusted-contact interactivity", () => {
   });
 
   test("unknown actors remain non-interactive (denied at gate)", async () => {
-    // No member record => non-member denied at the ACL gate,
+    // No contact record => non-member denied at the ACL gate,
     // which is the strongest form of "not interactive".
-    mockFindMember = () => null;
-
     const req = makeInboundRequest({
       externalMessageId: `msg-unknown-${Date.now()}`,
       actorExternalId: "unknown-user-no-member",
@@ -414,7 +399,6 @@ describe("inbound-message-handler trusted-contact interactivity", () => {
 describe("channel-retry-sweep routing state", () => {
   beforeEach(() => {
     resetTables();
-    mockFindMember = null;
   });
 
   function seedFailedEvent(
@@ -430,7 +414,7 @@ describe("channel-retry-sweep routing state", () => {
       content: "retry me",
       sourceChannel: "telegram",
       interface: "telegram",
-      guardianCtx: {
+      trustCtx: {
         trustClass,
         sourceChannel: "telegram",
         requesterExternalUserId: "test-user",

package/src/__tests__/guardian-verification-intent-routing.test.ts

@@ -13,7 +13,6 @@ describe("direct guardian setup phrases trigger forced routing", () => {
     "verify me as your guardian",
     "confirm me as guardian",
     "confirm me as your guardian",
-    "set me as guardian for SMS",
     "set me as guardian for voice",
     "set me as guardian for telegram",
     "set me up as guardian",
@@ -25,10 +24,8 @@ describe("direct guardian setup phrases trigger forced routing", () => {
     "can you verify me as guardian",
     "I want to become your guardian",
     "register me as your guardian",
-    "help me set myself up as your guardian via sms",
     "I need to set myself as guardian",
     "guardian verify",
-    "set me up as guardian for text message",
   ];
 
   for (const phrase of directSetupPhrases) {
@@ -142,14 +139,15 @@ describe("slash commands are never intercepted", () => {
 // =====================================================================
 
 describe("channel hint extraction", () => {
-  test("detects SMS channel hint", () => {
+  test("SMS phrases still trigger setup but without SMS channel hint", () => {
     const result = resolveGuardianVerificationIntent(
       "set me as guardian for SMS",
     );
     expect(result.kind).toBe("direct_setup");
     if (result.kind === "direct_setup") {
-      expect(result.channelHint).toBe("sms");
-      expect(result.rewrittenContent).toContain("sms channel");
+      // SMS is no longer a supported channel; the intent still matches on
+      // the guardian setup pattern but no channel hint is extracted.
+      expect(result.channelHint).toBeUndefined();
     }
   });
 

package/src/__tests__/guardian-verify-setup-skill-regression.test.ts

@@ -49,13 +49,13 @@ describe("guardian-verify-setup skill — voice auto-followup", () => {
     expect(skillContent).toContain("## Voice Auto-Check Polling");
   });
 
-  test("polling section specifies the correct status endpoint for voice", () => {
+  test("polling section specifies the correct status command for voice", () => {
     const pollingSection =
       skillContent
         .split("## Voice Auto-Check Polling")[1]
         ?.split("## Step 6")[0] ?? "";
     expect(pollingSection).toContain(
-      "/v1/integrations/guardian/status?channel=voice",
+      "vellum integrations guardian status --channel voice --json",
     );
   });
 
@@ -107,14 +107,12 @@ describe("guardian-verify-setup skill — voice auto-followup", () => {
         ?.split("## Step 6")[0] ?? "";
     // Must mention rebind guard concept
     expect(pollingSection).toContain("Rebind guard");
-    // Must instruct not to trust the first bound: true in a rebind flow
+    // Must instruct not to trust bound: true alone in a rebind flow
     expect(pollingSection).toContain(
-      "do NOT treat the first `bound: true` poll result as success",
+      "do NOT treat `bound: true` alone as success",
     );
-    // Must reference bound_at timestamp comparison as the primary mechanism
-    expect(pollingSection).toContain("bound_at");
-    // Must have a fallback for when bound_at is unavailable
-    expect(pollingSection).toContain("second poll onward");
+    // Must reference verificationSessionId as the mechanism to detect fresh binding
+    expect(pollingSection).toContain("verificationSessionId");
     // Must clarify non-rebind flows are unaffected
     expect(pollingSection).toContain("Non-rebind flows");
   });

package/src/__tests__/handle-user-message-secret-resume.test.ts

@@ -8,6 +8,42 @@ mock.module("../config/env.js", () => ({
   isMonitoringEnabled: () => false,
 }));
 
+mock.module("../runtime/local-actor-identity.js", () => ({
+  resolveLocalIpcTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+    guardianPrincipalId: "local-principal",
+  }),
+  resolveLocalIpcAuthContext: () => ({
+    scope: "ipc_v1",
+    actorPrincipalId: "local-principal",
+  }),
+}));
+
+mock.module("../config/loader.js", () => {
+  const config = {
+    daemon: { standaloneRecording: false },
+    secretDetection: {
+      enabled: true,
+      blockIngress: true,
+      customPatterns: [],
+      entropyThreshold: 3.5,
+    },
+  };
+  return {
+    getConfig: () => config,
+    loadConfig: () => config,
+    loadRawConfig: () => ({}),
+    saveConfig: () => {},
+    saveRawConfig: () => {},
+    invalidateConfigCache: () => {},
+    applyNestedDefaults: (c: unknown) => c,
+    getNestedValue: () => undefined,
+    setNestedValue: () => {},
+    API_KEY_PROVIDERS: [],
+  };
+});
+
 const { handleUserMessage } = await import("../daemon/handlers/sessions.js");
 
 describe("handleUserMessage secret redirect continuation", () => {
@@ -51,11 +87,13 @@ describe("handleUserMessage secret redirect continuation", () => {
       setTurnInterfaceContext: () => {},
       setAssistantId: () => {},
       setChannelCapabilities: () => {},
-      setGuardianContext: () => {},
+      setTrustContext: () => {},
       setAuthContext: () => {},
       setCommandIntent: () => {},
       updateClient: () => {},
       emitActivityState: () => {},
+      hasAnyPendingConfirmation: () => false,
+      hasPendingConfirmation: () => false,
       processMessage: (
         content: string,
         _attachments: unknown[],

package/src/__tests__/handlers-cu-observation-blob.test.ts

@@ -57,6 +57,17 @@ import type {
 } from "../daemon/ipc-contract.js";
 import { DebouncerMap } from "../util/debounce.js";
 
+/** Poll until a predicate is true or timeout (default 2s). */
+async function waitFor(
+  predicate: () => boolean,
+  timeoutMs = 2000,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!predicate() && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 10));
+  }
+}
+
 /** Write a blob file to the test blob directory and return the IpcBlobRef. */
 function writeBlobFile(
   content: Buffer,
@@ -143,8 +154,8 @@ describe("handleCuObservation blob hydration", () => {
 
     handleMessage(msg, fakeSocket, ctx);
 
-    // handleCuObservation is async; wait for it to settle
-    await new Promise((r) => setTimeout(r, 50));
+    // handleCuObservation is async (fire-and-forget); poll until it completes
+    await waitFor(() => observations.length > 0);
 
     expect(observations).toHaveLength(1);
     expect(observations[0].axTree).toBe(axTreeContent);
@@ -171,7 +182,7 @@ describe("handleCuObservation blob hydration", () => {
     const fakeSocket = {} as net.Socket;
 
     handleMessage(msg, fakeSocket, ctx);
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(() => observations.length > 0);
 
     expect(observations).toHaveLength(1);
     // Screenshot should be base64-encoded for the provider path
@@ -202,7 +213,7 @@ describe("handleCuObservation blob hydration", () => {
     const fakeSocket = {} as net.Socket;
 
     handleMessage(msg, fakeSocket, ctx);
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(() => observations.length > 0);
 
     expect(observations).toHaveLength(1);
     // Blob takes precedence when both are present and blob succeeds
@@ -231,7 +242,7 @@ describe("handleCuObservation blob hydration", () => {
     const fakeSocket = {} as net.Socket;
 
     handleMessage(msg, fakeSocket, ctx);
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(() => observations.length > 0);
 
     expect(observations).toHaveLength(1);
     // Inline value should be preserved as fallback when blob fails
@@ -258,7 +269,7 @@ describe("handleCuObservation blob hydration", () => {
     const fakeSocket = {} as net.Socket;
 
     handleMessage(msg, fakeSocket, ctx);
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(() => observations.length > 0);
 
     // Should still forward to session with partial data (no axTree)
     expect(observations).toHaveLength(1);
@@ -284,7 +295,7 @@ describe("handleCuObservation blob hydration", () => {
     const fakeSocket = {} as net.Socket;
 
     handleMessage(msg, fakeSocket, ctx);
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(() => observations.length > 0);
 
     expect(observations).toHaveLength(1);
     // Should fall back to inline because kind validation failed
@@ -309,7 +320,7 @@ describe("handleCuObservation blob hydration", () => {
     const fakeSocket = {} as net.Socket;
 
     handleMessage(msg, fakeSocket, ctx);
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(() => observations.length > 0);
 
     // Should still forward to session with partial data (no screenshot)
     expect(observations).toHaveLength(1);
@@ -337,7 +348,7 @@ describe("handleCuObservation blob hydration", () => {
     const fakeSocket = {} as net.Socket;
 
     handleMessage(msg, fakeSocket, ctx);
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(() => observations.length > 0);
 
     expect(observations).toHaveLength(1);
     expect(observations[0].axTree).toBe(inlineAxTree);
@@ -371,7 +382,7 @@ describe("handleCuObservation blob hydration", () => {
     const fakeSocket = {} as net.Socket;
 
     handleMessage(msg, fakeSocket, ctx);
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(() => observations.length > 0);
 
     expect(observations).toHaveLength(1);
     expect(observations[0].axTree).toBe(axTreeContent);

package/src/__tests__/handlers-telegram-config.test.ts

@@ -279,7 +279,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -340,7 +340,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -404,7 +404,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -529,7 +529,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -581,7 +581,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -629,7 +629,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -707,7 +707,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -813,7 +813,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -882,7 +882,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -946,7 +946,7 @@ describe("Telegram config handler", () => {
         });
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const { ctx, sent } = createTestContext();
     await handleTelegramConfig(
@@ -1040,7 +1040,7 @@ describe("Telegram config handler", () => {
         });
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -1096,7 +1096,7 @@ describe("Telegram config handler", () => {
         });
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -1159,7 +1159,7 @@ describe("Telegram config handler", () => {
         );
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     const msg: TelegramConfigRequest = {
       type: "telegram_config",
@@ -1198,7 +1198,7 @@ describe("Telegram config handler", () => {
         });
       }
       return originalFetch(url);
-    }) as typeof fetch;
+    }) as unknown as typeof fetch;
 
     // Call set_commands WITHOUT explicit commands to use defaults
     const msg: TelegramConfigRequest = {

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -68,6 +68,15 @@ mock.module("../memory/conversation-store.js", () => ({
 
 mock.module("../config/loader.js", () => ({
   getConfig: getConfigMock,
+  loadConfig: getConfigMock,
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  applyNestedDefaults: (c: unknown) => c,
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  API_KEY_PROVIDERS: [],
 }));
 
 mock.module("../daemon/approval-generators.js", () => ({
@@ -77,6 +86,18 @@ mock.module("../daemon/approval-generators.js", () => ({
   }),
 }));
 
+mock.module("../runtime/local-actor-identity.js", () => ({
+  resolveLocalIpcTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+    guardianPrincipalId: "local-principal",
+  }),
+  resolveLocalIpcAuthContext: () => ({
+    scope: "ipc_v1",
+    actorPrincipalId: "local-principal",
+  }),
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -115,7 +136,7 @@ interface TestSession {
   setTurnChannelContext: (ctx: unknown) => void;
   setTurnInterfaceContext: (ctx: unknown) => void;
   setAssistantId: (assistantId: string) => void;
-  setGuardianContext: (ctx: unknown) => void;
+  setTrustContext: (ctx: unknown) => void;
   setAuthContext: (ctx: unknown) => void;
   setCommandIntent: (intent: unknown) => void;
   updateClient: (
@@ -180,7 +201,7 @@ function makeSession(overrides: Partial<TestSession> = {}): TestSession {
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
     setAssistantId: () => {},
-    setGuardianContext: () => {},
+    setTrustContext: () => {},
     setAuthContext: () => {},
     setCommandIntent: () => {},
     updateClient: () => {},

package/src/__tests__/headless-browser-interactions.test.ts

@@ -84,7 +84,7 @@ const ctx: ToolContext = {
   sessionId: "test-session",
   conversationId: "test-conversation",
   workingDir: "/tmp",
-  guardianTrustClass: "guardian",
+  trustClass: "guardian",
 };
 
 function resetMockPage() {

package/src/__tests__/headless-browser-navigate.test.ts

@@ -59,7 +59,7 @@ const ctx: ToolContext = {
   sessionId: "test-session",
   conversationId: "test-conversation",
   workingDir: "/tmp",
-  guardianTrustClass: "guardian",
+  trustClass: "guardian",
 };
 
 function resetMockPage() {

package/src/__tests__/headless-browser-read-tools.test.ts

@@ -68,7 +68,7 @@ const ctx: ToolContext = {
   sessionId: "test-session",
   conversationId: "test-conversation",
   workingDir: "/tmp",
-  guardianTrustClass: "guardian",
+  trustClass: "guardian",
 };
 
 function resetMockPage() {

package/src/__tests__/headless-browser-snapshot.test.ts

@@ -67,7 +67,7 @@ const ctx: ToolContext = {
   sessionId: "test-session",
   conversationId: "test-conversation",
   workingDir: "/tmp",
-  guardianTrustClass: "guardian",
+  trustClass: "guardian",
 };
 
 function resetMockPage() {