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

package/src/__tests__/actor-trust-resolver-address-fallback.test.ts

@@ -7,12 +7,18 @@
  * and are discovered through the same path as every other channel.
  *
  * This suite verifies that address-based lookup returns the correct
- * `memberRecord` with the right channel/status so relay-setup-router
+ * `memberRecord` with the right ACL status so relay-setup-router
  * can emit the appropriate outcome (e.g. `unverified_caller`).
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type {
+  ChannelPolicy,
+  ChannelStatus,
+  ContactRole,
+} from "../contacts/types.js";
+
 // ── Logger mock (suppress output) ───────────────────────────────────────────
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -23,18 +29,45 @@ mock.module("../util/logger.js", () => ({
 let _byAddress: ReturnType<
   (typeof import("../contacts/contact-store.js"))["findContactByAddress"]
 > = null;
-let _guardian: ReturnType<
-  (typeof import("../contacts/contact-store.js"))["findGuardianForChannel"]
-> = null;
+// ACL view is carried on memberRecord, sourced from the member-verdict cache.
+// Seed it per test instead of seeding the DB.
+let _acl: { status: ChannelStatus; policy: ChannelPolicy; role: ContactRole } =
+  { status: "unverified", policy: "allow", role: "contact" };
 
 mock.module("../contacts/contact-store.js", () => ({
   findContactByAddress: (_type: string, _addr: string) => _byAddress,
-  findGuardianForChannel: (_channel: string) => _guardian,
+}));
+
+// Guardian resolution reads the gateway delivery cache; these suites only
+// exercise the member/address path, so the cache peek stays empty.
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  peekCachedGuardianDelivery: () => undefined,
+  guardianForChannel: () => undefined,
 }));
 
 // ── Real import after mocks ───────────────────────────────────────────────────
 import type { ContactWithChannels } from "../contacts/types.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
+import {
+  __resetMemberVerdictCacheForTest,
+  setMemberVerdict,
+} from "../runtime/member-verdict-cache.js";
+
+const CHANNEL_ID = "ch-test";
+const CONTACT_ID = "contact-test";
+
+// Seed the member-verdict cache so the sync fallback resolves the member with
+// the configured ACL view (mirrors a warmed gateway verdict).
+function seedAcl(): void {
+  setMemberVerdict("phone", PHONE, {
+    trustClass: _acl.role === "guardian" ? "guardian" : "unknown",
+    canonicalSenderId: PHONE,
+    contactId: CONTACT_ID,
+    channelId: CHANNEL_ID,
+    status: _acl.status,
+    policy: _acl.policy,
+  });
+}
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -44,13 +77,14 @@ function makeContact(
   role: "guardian" | "contact" = "contact",
   status: "unverified" | "active" = "unverified",
 ): ContactWithChannels {
-  const channelId = "ch-test";
+  // ACL lives on memberRecord (carrier), sourced from the member-verdict cache —
+  // record the intended view so seedAcl() warms it before resolution.
+  _acl = { status, policy: "allow", role };
   return {
-    id: "contact-test",
+    id: CONTACT_ID,
     displayName: "Patrick Test",
-    role,
-    principalId: null,
     notes: null,
+    role,
     lastInteraction: null,
     interactionCount: 0,
     contactType: "human" as const,
@@ -59,22 +93,16 @@ function makeContact(
     updatedAt: 0,
     channels: [
       {
-        id: channelId,
-        contactId: "contact-test",
+        id: CHANNEL_ID,
+        contactId: CONTACT_ID,
         type: "phone",
         address: PHONE,
         externalChatId: null,
         isPrimary: true,
-        status,
-        policy: "allow",
-        verifiedAt: null,
-        verifiedVia: null,
-        revokedReason: null,
-        blockedReason: null,
+        inviteId: null,
+        lastSeenAt: null,
         interactionCount: 0,
         lastInteraction: null,
-        lastSeenAt: null,
-        inviteId: null,
         createdAt: 0,
         updatedAt: 0,
       },
@@ -87,12 +115,14 @@ function makeContact(
 describe("resolveActorTrust — address fallback", () => {
   beforeEach(() => {
     _byAddress = null;
-    _guardian = null;
+    _acl = { status: "unverified", policy: "allow", role: "contact" };
+    __resetMemberVerdictCacheForTest();
   });
 
   test("finds unverified channel via address when externalUserId is null", () => {
     // Simulate a contact registered by name-capture: address set, externalUserId null.
     _byAddress = makeContact("contact", "unverified");
+    seedAcl();
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -103,7 +133,7 @@ describe("resolveActorTrust — address fallback", () => {
 
     expect(result.memberRecord).not.toBeNull();
     expect(result.memberRecord?.contact.displayName).toBe("Patrick Test");
-    expect(result.memberRecord?.channel.status).toBe("unverified");
+    expect(result.memberRecord?.status).toBe("unverified");
     // trustClass is 'unverified_contact' for a member whose channel is
     // pending or unverified — known to the guardian but not yet verified.
     expect(result.trustClass).toBe("unverified_contact");
@@ -111,6 +141,7 @@ describe("resolveActorTrust — address fallback", () => {
 
   test("address lookup is the sole member resolution path", () => {
     _byAddress = makeContact("contact", "active");
+    seedAcl();
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -119,7 +150,7 @@ describe("resolveActorTrust — address fallback", () => {
       actorExternalId: PHONE,
     });
 
-    expect(result.memberRecord?.channel.status).toBe("active");
+    expect(result.memberRecord?.status).toBe("active");
     expect(result.memberRecord?.channel.address).toBe(PHONE);
   });
 
@@ -137,10 +168,28 @@ describe("resolveActorTrust — address fallback", () => {
     expect(result.trustClass).toBe("unknown");
   });
 
+  test("fail-closed: contact found but verdict cache miss → unknown", () => {
+    // The sync fallback runs only when there is no live verdict; with no cached
+    // verdict either, the member stays unresolved and trust is fail-closed.
+    _byAddress = makeContact("contact", "active");
+    // No seedAcl() — the cache is a miss for this sender.
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord).toBeNull();
+    expect(result.trustClass).toBe("unknown");
+  });
+
   test("address-found active channel elevates trust to trusted_contact", () => {
     // An active channel found via address (e.g. after manual verify without externalUserId set)
     // should still yield trusted_contact trust class.
     _byAddress = makeContact("contact", "active");
+    seedAcl();
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -150,7 +199,7 @@ describe("resolveActorTrust — address fallback", () => {
     });
 
     expect(result.memberRecord).not.toBeNull();
-    expect(result.memberRecord?.channel.status).toBe("active");
+    expect(result.memberRecord?.status).toBe("active");
     expect(result.trustClass).toBe("trusted_contact");
   });
 
@@ -158,9 +207,10 @@ describe("resolveActorTrust — address fallback", () => {
     // Mirrors the unverified branch but for `pending` status (e.g. a phone
     // contact registered by name-capture awaiting the DTMF challenge).
     const contact = makeContact("contact", "unverified");
-    // Override status to "pending" — makeContact only accepts unverified/active
-    contact.channels[0]!.status = "pending";
+    // Override ACL status to "pending" — makeContact only accepts unverified/active.
+    _acl = { ..._acl, status: "pending" };
     _byAddress = contact;
+    seedAcl();
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -169,16 +219,17 @@ describe("resolveActorTrust — address fallback", () => {
       actorExternalId: PHONE,
     });
 
-    expect(result.memberRecord?.channel.status).toBe("pending");
+    expect(result.memberRecord?.status).toBe("pending");
     expect(result.trustClass).toBe("unverified_contact");
   });
 
   test("blocked-status member is classified as unknown (not unverified_contact)", () => {
     // Hard-deny statuses (blocked, revoked) stay `unknown` — admission-layer
-    // re-checks channel.status and emits the hard-deny reasons.
+    // re-checks channel status and emits the hard-deny reasons.
     const contact = makeContact("contact", "unverified");
-    contact.channels[0]!.status = "blocked";
+    _acl = { ..._acl, status: "blocked" };
     _byAddress = contact;
+    seedAcl();
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -187,14 +238,15 @@ describe("resolveActorTrust — address fallback", () => {
       actorExternalId: PHONE,
     });
 
-    expect(result.memberRecord?.channel.status).toBe("blocked");
+    expect(result.memberRecord?.status).toBe("blocked");
     expect(result.trustClass).toBe("unknown");
   });
 
   test("revoked-status member is classified as unknown", () => {
     const contact = makeContact("contact", "unverified");
-    contact.channels[0]!.status = "revoked";
+    _acl = { ..._acl, status: "revoked" };
     _byAddress = contact;
+    seedAcl();
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -203,7 +255,7 @@ describe("resolveActorTrust — address fallback", () => {
       actorExternalId: PHONE,
     });
 
-    expect(result.memberRecord?.channel.status).toBe("revoked");
+    expect(result.memberRecord?.status).toBe("revoked");
     expect(result.trustClass).toBe("unknown");
   });
 });

package/src/__tests__/agent-loop-override-profile.test.ts

@@ -384,6 +384,7 @@ describe("SubagentManager.spawn — overrideProfile inheritance", () => {
 // inheritance chain breaks at the second nesting level.
 
 mock.module("../memory/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
   // Always return undefined for the row read so the test fails fast unless
   // executeSubagentSpawn reads from context.overrideProfile first.
   getConversationOverrideProfile: () => undefined,

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -21,6 +21,8 @@ import type {
 import type { Message } from "../providers/types.js";
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getConversationOverrideProfile: () => undefined,
 }));
 

package/src/__tests__/agent-wake-override-profile.test.ts

@@ -31,6 +31,8 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 let mockOverrideProfile: string | undefined = undefined;
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getConversationOverrideProfile: (_id: string) => mockOverrideProfile,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));

package/src/__tests__/annotate-activity-metadata.test.ts

@@ -55,6 +55,8 @@ let mockedRowContent = "";
 const updates: Array<{ id: string; content: string }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: () => ({ id: "mock-msg-id" }),
   getMessageById: (id: string) =>
     mockedRowContent ? { id, content: mockedRowContent } : null,

package/src/__tests__/annotate-risk-options.test.ts

@@ -50,6 +50,8 @@ let mockedRowContent = "";
 const updates: Array<{ id: string; content: string }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: () => ({ id: "mock-msg-id" }),
   getMessageById: (id: string) =>
     mockedRowContent ? { id, content: mockedRowContent } : null,

package/src/__tests__/approval-cascade.test.ts

@@ -121,6 +121,8 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},

package/src/__tests__/assistant-attachments.test.ts

@@ -373,6 +373,48 @@ describe("extractVellumLinks", () => {
     expect(result.directiveRequests[1].path).toBe("/tmp/b.pdf");
   });
 
+  test("decodes URL-encoded spaces in workspace paths", () => {
+    const text =
+      "[file with spaces.txt](vellum://workspace/scratch/file%20with%20spaces.txt)";
+    const result = extractVellumLinks(text);
+
+    expect(result.directiveRequests).toHaveLength(1);
+    expect(result.directiveRequests[0].source).toBe("sandbox");
+    expect(result.directiveRequests[0].path).toBe(
+      "scratch/file with spaces.txt",
+    );
+  });
+
+  test("decodes URL-encoded spaces in host paths", () => {
+    const text =
+      "[my file.pdf](vellum://host/Users/me/my%20file.pdf)";
+    const result = extractVellumLinks(text);
+
+    expect(result.directiveRequests).toHaveLength(1);
+    expect(result.directiveRequests[0].source).toBe("host");
+    expect(result.directiveRequests[0].path).toBe("/Users/me/my file.pdf");
+  });
+
+  test("warns on malformed percent-encoding instead of throwing", () => {
+    const text =
+      "[100% complete.txt](vellum://workspace/scratch/100%25complete.txt)";
+    const result = extractVellumLinks(text);
+
+    // %25 decodes to %, so this should succeed
+    expect(result.directiveRequests).toHaveLength(1);
+    expect(result.directiveRequests[0].path).toBe("scratch/100%complete.txt");
+  });
+
+  test("warns on malformed percent-encoding and skips the link", () => {
+    const text =
+      "[bad file](vellum://workspace/scratch/100%complete.txt)";
+    const result = extractVellumLinks(text);
+
+    expect(result.directiveRequests).toHaveLength(0);
+    expect(result.parseWarnings).toHaveLength(1);
+    expect(result.parseWarnings[0]).toContain("malformed percent-encoding");
+  });
+
   test("warns on empty workspace path", () => {
     const text = "[file](vellum://workspace/)";
     const result = extractVellumLinks(text);

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -100,6 +100,8 @@ mock.module("../daemon/process-message.js", () => ({
 
 const createdConversations: Array<{ conversationType: string }> = [];
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: mock(() => ({ id: "msg-1" })),
   archiveConversation: mock(() => true),
   batchSetDisplayOrders: mock(() => {}),

package/src/__tests__/btw-routes.test.ts

@@ -43,6 +43,8 @@ mock.module("../memory/conversation-key-store.js", () => ({
 const mockAddMessage = mock(() => {});
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: mockAddMessage,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));

package/src/__tests__/build-persisted-content.test.ts

@@ -41,6 +41,8 @@ mock.module("../config/loader.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: () => ({ id: "mock-msg-id" }),
   getMessageById: () => null,
   updateMessageContent: () => {},

package/src/__tests__/call-controller.test.ts

@@ -168,6 +168,25 @@ mock.module("../notifications/emit-signal.js", () => ({
   }),
 }));
 
+// Guardian principalId is resolved from the gateway binding reader. Mirror the
+// vellum binding seeded by resetTables so guardian dispatch can resolve it.
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [
+    {
+      channelType: "vellum",
+      contactId: "guardian-vellum",
+      principalId: "test-principal-id",
+      address: "local",
+      status: "active",
+    },
+  ],
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: unknown[]) => list[0],
+}));
+
 mock.module("../calls/voice-session-bridge.js", () => {
   mockStartVoiceTurn = mock(createMockVoiceTurn(["Hello", " there"]));
   return {

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",