@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/__tests__/disk-pressure-guard.test.ts

@@ -38,7 +38,6 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
 
 const {
   DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT,
-  DISK_PRESSURE_MIN_FREE_FLOOR_MB,
   DISK_PRESSURE_OVERRIDE_CONFIRMATION,
   DISK_PRESSURE_THRESHOLD_PERCENT,
   DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT,
@@ -343,44 +342,4 @@ describe("disk pressure guard", () => {
     setDiskUsage(DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT - 1);
     expect(evaluateDiskPressureNow().state).toBe("ok");
   });
-
-  test("stays ok at a critical usage percentage while ample free space remains", () => {
-    // 99% used of a large volume still leaves gigabytes free — above the floor.
-    const totalMb = 1_000_000;
-    const usedMb = Math.round(totalMb * 0.99); // freeMb ~= 10_000 MiB
-    setDiskUsage(usedMb, totalMb);
-    expect(diskSample!.freeMb).toBeGreaterThanOrEqual(
-      DISK_PRESSURE_MIN_FREE_FLOOR_MB,
-    );
-
-    const status = evaluateDiskPressureNow();
-
-    expect(status.state).toBe("ok");
-    expect(status.locked).toBe(false);
-    expect(status.effectivelyLocked).toBe(false);
-  });
-
-  test("stays ok at a warning usage percentage while ample free space remains", () => {
-    const totalMb = 1_000_000;
-    const usedMb = Math.round(totalMb * 0.85); // 85% used, freeMb ~= 150_000 MiB
-    setDiskUsage(usedMb, totalMb);
-
-    const status = evaluateDiskPressureNow();
-
-    expect(status.state).toBe("ok");
-  });
-
-  test("locks at a critical usage percentage once free space drops below the floor", () => {
-    // High percentage AND little absolute headroom: floor does not apply.
-    const totalMb = 100_000;
-    const freeMb = DISK_PRESSURE_MIN_FREE_FLOOR_MB - 1;
-    setDiskUsage(totalMb - freeMb, totalMb);
-    expect(diskSample!.freeMb).toBeLessThan(DISK_PRESSURE_MIN_FREE_FLOOR_MB);
-
-    const status = evaluateDiskPressureNow();
-
-    expect(status.state).toBe("critical");
-    expect(status.locked).toBe(true);
-    expect(status.effectivelyLocked).toBe(true);
-  });
 });

package/src/__tests__/dm-persistence.test.ts

@@ -30,8 +30,6 @@ const addMessageCalls: Array<{
 }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
   addMessage: async (
     conversationId: string,
     role: string,

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -19,19 +19,14 @@ mock.module("../channels/config.js", () => ({
   getDeliverableChannels: () => ["vellum", "telegram"],
 }));
 
-// Guardian connectivity is resolved from the gateway pull. No active guardian
-// binding ⇒ binding-based channels (telegram) are not reported connected.
-mock.module("../contacts/guardian-delivery-reader.js", () => ({
-  getGuardianDelivery: async () => [],
-  guardianForChannel: () => undefined,
-}));
-
-// connectivity falls back to the local contacts read on a per-channel gateway
-// no-match; no local binding ⇒ telegram stays disconnected.
 mock.module("../contacts/contact-store.js", () => ({
-  findGuardianForChannel: () => null,
+  findGuardianForChannel: (_channelType: string, _assistantId: string) => null,
 }));
 
+// Note: stale mock for channel-guardian-store.js removed — the barrel was
+// deleted and none of the functions it mocked (getActiveBinding) existed in
+// the barrel.
+
 mock.module("../notifications/adapters/macos.js", () => ({
   VellumAdapter: class {
     constructor(_broadcastFn: unknown) {}

package/src/__tests__/events-dev-bypass-actor.test.ts

@@ -29,13 +29,7 @@ mock.module("../config/env.js", () => ({
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
-  findLocalGuardianPrincipalIdFromStore: () => fakeGuardianPrincipalId,
-  resolveActorPrincipalIdForLocalGuardianSync: (
-    rawHeader: string | undefined,
-  ) => {
-    if (rawHeader !== "dev-bypass" || !fakeHttpAuthDisabled) return rawHeader;
-    return fakeGuardianPrincipalId;
-  },
+  findLocalGuardianPrincipalId: () => fakeGuardianPrincipalId,
 }));
 
 mock.module("../util/logger.js", () => ({

package/src/__tests__/exploration-drift-hook.test.ts

@@ -225,11 +225,10 @@ describe("exploration-drift post-tool-use hook — long-dig trigger", () => {
     expect(ctx.toolResponse.content).toBe(BASE_CONTENT);
   });
 
-  test("counts code_search, file_read, and file_list as exploration tools", async () => {
-    const explorationNames = ["code_search", "file_read", "file_list"];
+  test("counts file_read and file_list as exploration tools", async () => {
     const messages: Message[] = [];
     for (let i = 0; i < EXPLORATION_NUDGE_THRESHOLD - 1; i++) {
-      const name = explorationNames[i % explorationNames.length];
+      const name = i % 2 === 0 ? "file_read" : "file_list";
       const id = `${name}-${i}`;
       messages.push(toolUseTurn(id, name, { path: `/tmp/file-${i}` }));
       messages.push(toolResultTurn(id));

package/src/__tests__/filing-service.test.ts

@@ -51,8 +51,6 @@ const createdConversations: Array<{
 let conversationIdCounter = 0;
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},

package/src/__tests__/guardian-binding-drift-heal.test.ts

@@ -7,16 +7,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import type { GuardianDelivery } from "@vellumai/gateway-client";
-
-let mockGuardians: GuardianDelivery[] | null = [];
-
-mock.module("../contacts/guardian-delivery-reader.js", () => ({
-  getGuardianDelivery: async () => mockGuardians,
-  guardianForChannel: (list: GuardianDelivery[], channelType: string) =>
-    list.find((g) => g.channelType === channelType && g.status === "active"),
-}));
-
 import { findGuardianForChannel } from "../contacts/contact-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -31,24 +21,12 @@ function resetTables(): void {
   db.run("DELETE FROM contacts");
 }
 
-/** Gateway delivery mirroring the local guardian binding's principal. */
-function gatewayGuardian(principalId: string): GuardianDelivery {
-  return {
-    channelType: "vellum",
-    contactId: "guardian-contact",
-    principalId,
-    address: principalId,
-    status: "active",
-  };
-}
-
 describe("healGuardianBindingDrift", () => {
   beforeEach(() => {
     resetTables();
-    mockGuardians = [];
   });
 
-  test("heals drift when both principals have vellum-principal- prefix", async () => {
+  test("heals drift when both principals have vellum-principal- prefix", () => {
     // Simulate DB reset: new guardian binding with a different UUID
     createGuardianBinding({
       channel: "vellum",
@@ -57,10 +35,9 @@ describe("healGuardianBindingDrift", () => {
       guardianPrincipalId: "vellum-principal-new-uuid",
       verifiedVia: "startup-migration",
     });
-    mockGuardians = [gatewayGuardian("vellum-principal-new-uuid")];
 
     // Client arrives with the old JWT principal
-    const healed = await healGuardianBindingDrift("vellum-principal-old-uuid");
+    const healed = healGuardianBindingDrift("vellum-principal-old-uuid");
     expect(healed).toBe(true);
 
     // Guardian binding now matches the old JWT
@@ -70,31 +47,7 @@ describe("healGuardianBindingDrift", () => {
     expect(guardian!.channel.address).toBe("vellum-principal-old-uuid");
   });
 
-  test("repairs the stale local mirror even when the gateway already matches the JWT", async () => {
-    // Gateway binding already matches the incoming JWT principal, but the
-    // local mirror is stale — the gateway-source-of-truth drift mode. The
-    // /v1/messages trust path still reads the local mirror in this plan, so
-    // a stale row must be repaired or the actor stays classified `unknown`.
-    createGuardianBinding({
-      channel: "vellum",
-      guardianExternalUserId: "vellum-principal-stale-local",
-      guardianDeliveryChatId: "local",
-      guardianPrincipalId: "vellum-principal-stale-local",
-      verifiedVia: "startup-migration",
-    });
-    mockGuardians = [gatewayGuardian("vellum-principal-jwt")];
-
-    const healed = await healGuardianBindingDrift("vellum-principal-jwt");
-    expect(healed).toBe(true);
-
-    // Local mirror now matches the JWT, so a subsequent local trust
-    // resolution classifies the actor as guardian rather than unknown.
-    const guardian = findGuardianForChannel("vellum");
-    expect(guardian!.contact.principalId).toBe("vellum-principal-jwt");
-    expect(guardian!.channel.address).toBe("vellum-principal-jwt");
-  });
-
-  test("no-op when principals already match", async () => {
+  test("no-op when principals already match", () => {
     createGuardianBinding({
       channel: "vellum",
       guardianExternalUserId: "vellum-principal-same",
@@ -102,13 +55,12 @@ describe("healGuardianBindingDrift", () => {
       guardianPrincipalId: "vellum-principal-same",
       verifiedVia: "startup-migration",
     });
-    mockGuardians = [gatewayGuardian("vellum-principal-same")];
 
-    const healed = await healGuardianBindingDrift("vellum-principal-same");
+    const healed = healGuardianBindingDrift("vellum-principal-same");
     expect(healed).toBe(false);
   });
 
-  test("refuses to heal when incoming principal lacks vellum-principal- prefix", async () => {
+  test("refuses to heal when incoming principal lacks vellum-principal- prefix", () => {
     createGuardianBinding({
       channel: "vellum",
       guardianExternalUserId: "vellum-principal-aaa",
@@ -116,10 +68,9 @@ describe("healGuardianBindingDrift", () => {
       guardianPrincipalId: "vellum-principal-aaa",
       verifiedVia: "startup-migration",
     });
-    mockGuardians = [gatewayGuardian("vellum-principal-aaa")];
 
     // External/platform principal — should NOT be adopted
-    const healed = await healGuardianBindingDrift("platform-user-12345");
+    const healed = healGuardianBindingDrift("platform-user-12345");
     expect(healed).toBe(false);
 
     // Guardian unchanged
@@ -127,7 +78,7 @@ describe("healGuardianBindingDrift", () => {
     expect(guardian!.contact.principalId).toBe("vellum-principal-aaa");
   });
 
-  test("refuses to heal when stored principal lacks vellum-principal- prefix", async () => {
+  test("refuses to heal when stored principal lacks vellum-principal- prefix", () => {
     createGuardianBinding({
       channel: "vellum",
       guardianExternalUserId: "verified-phone-guardian",
@@ -135,33 +86,17 @@ describe("healGuardianBindingDrift", () => {
       guardianPrincipalId: "verified-phone-guardian",
       verifiedVia: "challenge",
     });
-    mockGuardians = [gatewayGuardian("verified-phone-guardian")];
 
     // Even with a vellum-principal- incoming, don't overwrite a real binding
-    const healed = await healGuardianBindingDrift("vellum-principal-attacker");
+    const healed = healGuardianBindingDrift("vellum-principal-attacker");
     expect(healed).toBe(false);
 
     const guardian = findGuardianForChannel("vellum");
     expect(guardian!.contact.principalId).toBe("verified-phone-guardian");
   });
 
-  test("returns false when gateway reports no guardian binding", async () => {
-    mockGuardians = [];
-    const healed = await healGuardianBindingDrift("vellum-principal-orphan");
-    expect(healed).toBe(false);
-  });
-
-  test("returns false when the gateway is unreachable (null list)", async () => {
-    createGuardianBinding({
-      channel: "vellum",
-      guardianExternalUserId: "vellum-principal-aaa",
-      guardianDeliveryChatId: "local",
-      guardianPrincipalId: "vellum-principal-aaa",
-      verifiedVia: "startup-migration",
-    });
-    mockGuardians = null;
-
-    const healed = await healGuardianBindingDrift("vellum-principal-old-uuid");
+  test("returns false when no guardian binding exists", () => {
+    const healed = healGuardianBindingDrift("vellum-principal-orphan");
     expect(healed).toBe(false);
   });
 });

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

@@ -24,11 +24,6 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
-// The pending_question request principal is resolved via the SAME local source
-// the Vellum actor uses — findGuardianForChannel("vellum")?.contact.principalId
-// — so the stamped principal always equals the submitting actor principal. The
-// real contacts DB is seeded in resetTables(); tests model drift / missing
-// guardian by reseeding or clearing that local binding directly.
 const emitCalls: unknown[] = [];
 let conversationCreatedFromMock: ConversationCreatedInfo | null = null;
 let mockEmitResult: {
@@ -159,18 +154,11 @@ describe("guardian-dispatch", () => {
         "SELECT * FROM canonical_guardian_requests WHERE call_session_id = ?",
       )
       .get(session.id) as
-      | {
-          id: string;
-          status: string;
-          question_text: string;
-          guardian_principal_id: string | null;
-        }
+      | { id: string; status: string; question_text: string }
       | undefined;
     expect(request).toBeDefined();
     expect(request!.status).toBe("pending");
     expect(request!.question_text).toBe("What is the gate code?");
-    // principalId comes from the local guardian binding (same source the actor submits)
-    expect(request!.guardian_principal_id).toBe("test-principal-id");
 
     const vellumDelivery = raw
       .query(
@@ -187,88 +175,6 @@ describe("guardian-dispatch", () => {
     expect(typeof signalParams.onConversationCreated).toBe("function");
   });
 
-  test("stamps the request principal from the local source the actor submits, not the (possibly drifted) gateway binding", async () => {
-    // Simulate gateway/local binding drift: the local guardian binding (the
-    // source the actor submit path reads) carries a different principal than
-    // the gateway would. The request must be stamped with that local value so
-    // a later actor submission matches (no identity_mismatch under drift).
-    const db = getDb();
-    db.run("DELETE FROM contact_channels");
-    db.run("DELETE FROM contacts");
-    createGuardianBinding({
-      channel: "vellum",
-      guardianExternalUserId: "local-actor-principal",
-      guardianDeliveryChatId: "local",
-      guardianPrincipalId: "local-actor-principal",
-      verifiedVia: "bootstrap",
-    });
-
-    const convId = "conv-dispatch-drift";
-    ensureConversation(convId);
-
-    const session = createCallSession({
-      conversationId: convId,
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, "Drifted bindings?");
-
-    await dispatchGuardianQuestion({
-      callSessionId: session.id,
-      conversationId: convId,
-      assistantId: "self",
-      pendingQuestion: pq,
-    });
-
-    const raw = (db as unknown as { $client: import("bun:sqlite").Database })
-      .$client;
-    const request = raw
-      .query(
-        "SELECT * FROM canonical_guardian_requests WHERE call_session_id = ?",
-      )
-      .get(session.id) as
-      | { guardian_principal_id: string | null }
-      | undefined;
-    expect(request).toBeDefined();
-    expect(request!.guardian_principal_id).toBe("local-actor-principal");
-  });
-
-  test("skips dispatch when no local guardian binding exists (no principal to stamp)", async () => {
-    const db = getDb();
-    db.run("DELETE FROM contact_channels");
-    db.run("DELETE FROM contacts");
-
-    const convId = "conv-dispatch-no-principal";
-    ensureConversation(convId);
-
-    const session = createCallSession({
-      conversationId: convId,
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, "No principal available");
-
-    await dispatchGuardianQuestion({
-      callSessionId: session.id,
-      conversationId: convId,
-      assistantId: "self",
-      pendingQuestion: pq,
-    });
-
-    // No request is created and the pipeline is never invoked.
-    const raw = (db as unknown as { $client: import("bun:sqlite").Database })
-      .$client;
-    const request = raw
-      .query(
-        "SELECT * FROM canonical_guardian_requests WHERE call_session_id = ?",
-      )
-      .get(session.id) as { id: string } | null;
-    expect(request).toBeNull();
-    expect(emitCalls).toHaveLength(0);
-  });
-
   test("creates a telegram guardian delivery with binding metadata when pipeline sends telegram", async () => {
     const convId = "conv-dispatch-2";
     ensureConversation(convId);

package/src/__tests__/guardian-outbound-http.test.ts

@@ -84,19 +84,6 @@ globalThis.fetch = (async (
   return originalFetch(input, init as never);
 }) as unknown as typeof fetch;
 
-// Guardian-delivery reader mock — the inbound challenge guard reads guardian
-// existence from the gateway. These tests seed no binding, so report an empty
-// list (not bound) rather than a null that would fail closed as already-bound.
-mock.module("../contacts/guardian-delivery-reader.js", () => ({
-  getGuardianDelivery: async () => [],
-  getGuardianDeliveryFresh: async () => [],
-  guardianForChannel: (
-    list: Array<{ channelType: string; status: string }>,
-    channelType: string,
-  ) =>
-    list.find((g) => g.channelType === channelType && g.status === "active"),
-}));
-
 // ---------------------------------------------------------------------------
 // Now import modules under test (after mocks are in place)
 // ---------------------------------------------------------------------------

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -70,8 +70,6 @@ mock.module("../schedule/recurrence-engine.js", () => ({
 
 const createdConversations: Array<{ conversationType: string }> = [];
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
   getConversation: () => null,
   getMessages: () => [],
   createConversation: (opts: { conversationType: string }) => {

package/src/__tests__/heartbeat-service.test.ts

@@ -137,8 +137,6 @@ const mockStoredMessages: Array<{
 }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},

package/src/__tests__/helpers/channel-test-adapter.ts

@@ -138,11 +138,16 @@ function stampTrustVerdict(body: Record<string, unknown>): void {
   const channelType = String(body.sourceChannel ?? "");
   const actorExternalId =
     typeof body.actorExternalId === "string" ? body.actorExternalId : undefined;
+  const externalChatId =
+    typeof body.conversationExternalId === "string"
+      ? body.conversationExternalId
+      : undefined;
   if (!channelType) return;
 
   const verdict = resolveLocalTrustVerdict({
     channelType,
     actorExternalId,
+    externalChatId,
   });
   body.sourceMetadata = { ...(meta ?? {}), trustVerdict: verdict };
 }
@@ -151,14 +156,15 @@ function stampTrustVerdict(body: Record<string, unknown>): void {
 export function resolveLocalTrustVerdict(input: {
   channelType: string;
   actorExternalId?: string;
+  externalChatId?: string;
 }): TrustVerdict {
   const canonicalSenderId = input.actorExternalId ?? null;
 
-  // Match the gateway's address-only member resolution (no externalChatId).
   const member = input.actorExternalId
     ? findContactChannel({
         channelType: input.channelType,
         address: input.actorExternalId,
+        externalChatId: input.externalChatId,
       })
     : null;
   const guardian = findGuardianForChannel(input.channelType);

package/src/__tests__/host-app-control-routes.test.ts

@@ -62,7 +62,7 @@ afterAll(() => {
 
 const handleHostAppControlResult = ROUTES.find(
   (r) => r.endpoint === "host-app-control-result",
-)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
+)!.handler;
 
 // ── Tests ────────────────────────────────────────────────────────────
 
@@ -395,7 +395,7 @@ describe("handleHostAppControlResult — same-actor guard", () => {
     ).toThrow(BadRequestError);
   });
 
-  test("targeted + missing header: interaction is NOT consumed (still pending)", async () => {
+  test("targeted + missing header: interaction is NOT consumed (still pending)", () => {
     const requestId = "ac-req-targeted-no-header-stays";
     pending.set(requestId, {
       conversationId: "conv-1",
@@ -404,11 +404,13 @@ describe("handleHostAppControlResult — same-actor guard", () => {
       targetActorPrincipalId: "user-1",
     });
 
-    await handleHostAppControlResult({
-      body: { requestId, state: "running" },
-    }).catch(() => {
+    try {
+      handleHostAppControlResult({
+        body: { requestId, state: "running" },
+      });
+    } catch {
       // expected
-    });
+    }
 
     expect(pending.has(requestId)).toBe(true);
   });
@@ -435,7 +437,7 @@ describe("handleHostAppControlResult — same-actor guard", () => {
     ).toThrow(ForbiddenError);
   });
 
-  test("targeted + wrong client id: interaction is NOT consumed", async () => {
+  test("targeted + wrong client id: interaction is NOT consumed", () => {
     const requestId = "ac-req-targeted-wrong-client-stays";
     pending.set(requestId, {
       conversationId: "conv-1",
@@ -444,15 +446,17 @@ describe("handleHostAppControlResult — same-actor guard", () => {
       targetActorPrincipalId: "user-1",
     });
 
-    await handleHostAppControlResult({
-      body: { requestId, state: "running" },
-      headers: {
-        "x-vellum-client-id": "client-B",
-        "x-vellum-actor-principal-id": "user-1",
-      },
-    }).catch(() => {
+    try {
+      handleHostAppControlResult({
+        body: { requestId, state: "running" },
+        headers: {
+          "x-vellum-client-id": "client-B",
+          "x-vellum-actor-principal-id": "user-1",
+        },
+      });
+    } catch {
       // expected
-    });
+    }
 
     expect(pending.has(requestId)).toBe(true);
   });
@@ -479,7 +483,7 @@ describe("handleHostAppControlResult — same-actor guard", () => {
     ).toThrow(ForbiddenError);
   });
 
-  test("targeted + wrong actor principal: interaction is NOT consumed", async () => {
+  test("targeted + wrong actor principal: interaction is NOT consumed", () => {
     const requestId = "ac-req-targeted-wrong-actor-stays";
     pending.set(requestId, {
       conversationId: "conv-1",
@@ -488,15 +492,17 @@ describe("handleHostAppControlResult — same-actor guard", () => {
       targetActorPrincipalId: "user-1",
     });
 
-    await handleHostAppControlResult({
-      body: { requestId, state: "running" },
-      headers: {
-        "x-vellum-client-id": "client-A",
-        "x-vellum-actor-principal-id": "user-2",
-      },
-    }).catch(() => {
+    try {
+      handleHostAppControlResult({
+        body: { requestId, state: "running" },
+        headers: {
+          "x-vellum-client-id": "client-A",
+          "x-vellum-actor-principal-id": "user-2",
+        },
+      });
+    } catch {
       // expected
-    });
+    }
 
     expect(pending.has(requestId)).toBe(true);
   });