@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

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

@@ -38,6 +38,7 @@ 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,
@@ -342,4 +343,44 @@ 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,6 +30,8 @@ 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,13 +19,18 @@ mock.module("../channels/config.js", () => ({
   getDeliverableChannels: () => ["vellum", "telegram"],
 }));
 
-mock.module("../contacts/contact-store.js", () => ({
-  findGuardianForChannel: (_channelType: string, _assistantId: string) => null,
+// 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,
 }));
 
-// 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.
+// 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,
+}));
 
 mock.module("../notifications/adapters/macos.js", () => ({
   VellumAdapter: class {

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

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

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

@@ -51,6 +51,8 @@ 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,6 +7,16 @@ 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";
@@ -21,12 +31,24 @@ 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", () => {
+  test("heals drift when both principals have vellum-principal- prefix", async () => {
     // Simulate DB reset: new guardian binding with a different UUID
     createGuardianBinding({
       channel: "vellum",
@@ -35,9 +57,10 @@ 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 = healGuardianBindingDrift("vellum-principal-old-uuid");
+    const healed = await healGuardianBindingDrift("vellum-principal-old-uuid");
     expect(healed).toBe(true);
 
     // Guardian binding now matches the old JWT
@@ -47,7 +70,31 @@ describe("healGuardianBindingDrift", () => {
     expect(guardian!.channel.address).toBe("vellum-principal-old-uuid");
   });
 
-  test("no-op when principals already match", () => {
+  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 () => {
     createGuardianBinding({
       channel: "vellum",
       guardianExternalUserId: "vellum-principal-same",
@@ -55,12 +102,13 @@ describe("healGuardianBindingDrift", () => {
       guardianPrincipalId: "vellum-principal-same",
       verifiedVia: "startup-migration",
     });
+    mockGuardians = [gatewayGuardian("vellum-principal-same")];
 
-    const healed = healGuardianBindingDrift("vellum-principal-same");
+    const healed = await healGuardianBindingDrift("vellum-principal-same");
     expect(healed).toBe(false);
   });
 
-  test("refuses to heal when incoming principal lacks vellum-principal- prefix", () => {
+  test("refuses to heal when incoming principal lacks vellum-principal- prefix", async () => {
     createGuardianBinding({
       channel: "vellum",
       guardianExternalUserId: "vellum-principal-aaa",
@@ -68,9 +116,10 @@ describe("healGuardianBindingDrift", () => {
       guardianPrincipalId: "vellum-principal-aaa",
       verifiedVia: "startup-migration",
     });
+    mockGuardians = [gatewayGuardian("vellum-principal-aaa")];
 
     // External/platform principal — should NOT be adopted
-    const healed = healGuardianBindingDrift("platform-user-12345");
+    const healed = await healGuardianBindingDrift("platform-user-12345");
     expect(healed).toBe(false);
 
     // Guardian unchanged
@@ -78,7 +127,7 @@ describe("healGuardianBindingDrift", () => {
     expect(guardian!.contact.principalId).toBe("vellum-principal-aaa");
   });
 
-  test("refuses to heal when stored principal lacks vellum-principal- prefix", () => {
+  test("refuses to heal when stored principal lacks vellum-principal- prefix", async () => {
     createGuardianBinding({
       channel: "vellum",
       guardianExternalUserId: "verified-phone-guardian",
@@ -86,17 +135,33 @@ 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 = healGuardianBindingDrift("vellum-principal-attacker");
+    const healed = await healGuardianBindingDrift("vellum-principal-attacker");
     expect(healed).toBe(false);
 
     const guardian = findGuardianForChannel("vellum");
     expect(guardian!.contact.principalId).toBe("verified-phone-guardian");
   });
 
-  test("returns false when no guardian binding exists", () => {
-    const healed = healGuardianBindingDrift("vellum-principal-orphan");
+  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");
     expect(healed).toBe(false);
   });
 });

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

@@ -24,6 +24,11 @@ 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: {
@@ -154,11 +159,18 @@ describe("guardian-dispatch", () => {
         "SELECT * FROM canonical_guardian_requests WHERE call_session_id = ?",
       )
       .get(session.id) as
-      | { id: string; status: string; question_text: string }
+      | {
+          id: string;
+          status: string;
+          question_text: string;
+          guardian_principal_id: string | null;
+        }
       | 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(
@@ -175,6 +187,88 @@ 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,6 +84,19 @@ 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,6 +70,8 @@ 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,6 +137,8 @@ const mockStoredMessages: Array<{
 }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},

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

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