@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

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

@@ -7,13 +7,23 @@ 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";
 import { healGuardianBindingDrift } from "../runtime/guardian-vellum-migration.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();
@@ -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-card-withdrawal.test.ts

@@ -35,7 +35,7 @@ import {
   recordGuardianRequestDeliveries,
 } from "../notifications/canonical-delivery-recorder.js";
 
-initializeDb();
+await initializeDb();
 
 const PRINCIPAL_ID = "withdrawal-test-principal";
 

package/src/__tests__/guardian-decision-primitive-canonical.test.ts

@@ -26,7 +26,7 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { scopedApprovalGrants } from "../memory/schema.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

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: {
@@ -68,7 +73,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { conversations } from "../memory/schema.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 function ensureConversation(id: string): void {
   const db = getDb();
@@ -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)
 // ---------------------------------------------------------------------------
@@ -105,7 +118,7 @@ import {
 import { resetDbForTesting } from "./db-test-helpers.js";
 
 // Initialize the database (creates all tables)
-initializeDb();
+await initializeDb();
 
 afterAll(() => {
   globalThis.fetch = originalFetch;
@@ -115,11 +128,6 @@ afterAll(() => {
 function resetTables(): void {
   const db = getDb();
   db.run("DELETE FROM channel_verification_sessions");
-  try {
-    db.run("DELETE FROM channel_guardian_approval_requests");
-  } catch {
-    /* table may not exist */
-  }
   try {
     db.run("DELETE FROM channel_guardian_rate_limits");
   } catch {
@@ -442,9 +450,9 @@ describe("HTTP route: handleCreateVerificationSession (guardian path)", () => {
 
 describe("HTTP route: handleResendVerificationSession (guardian path)", () => {
   test("throws BadRequestError when channel is missing", async () => {
-    await expect(
-      handleResendVerificationSession({ body: {} }),
-    ).rejects.toThrow(BadRequestError);
+    await expect(handleResendVerificationSession({ body: {} })).rejects.toThrow(
+      BadRequestError,
+    );
   });
 
   test("throws BadRequestError for no_active_session", async () => {
@@ -483,9 +491,9 @@ describe("HTTP route: handleResendVerificationSession (guardian path)", () => {
 
 describe("HTTP route: handleCancelVerificationSession (guardian path)", () => {
   test("throws BadRequestError when channel is missing", async () => {
-    await expect(
-      handleCancelVerificationSession({ body: {} }),
-    ).rejects.toThrow(BadRequestError);
+    await expect(handleCancelVerificationSession({ body: {} })).rejects.toThrow(
+      BadRequestError,
+    );
   });
 
   test("returns success even when no active session exists", async () => {

package/src/__tests__/guardian-principal-id-roundtrip.test.ts

@@ -15,7 +15,7 @@ import {
 } from "../memory/canonical-guardian-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

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

@@ -55,7 +55,7 @@ import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { parseCallbackData } from "../runtime/routes/channel-route-shared.js";
 import { listGuardianDecisionPrompts } from "../runtime/routes/guardian-action-routes.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();
@@ -226,10 +226,8 @@ describe("routing invariant: all decision paths reference applyCanonicalGuardian
   test("guardian-reply-router routes all decisions through applyCanonicalGuardianDecision", () => {
     const fullPath = join(srcRoot, "runtime/guardian-reply-router.ts");
     const source = readFileSync(fullPath, "utf-8");
-    // The router must import and call the canonical primitive, not applyGuardianDecision
+    // The router must import and call the canonical decision primitive.
     expect(source).toContain("applyCanonicalGuardianDecision");
-    // The router must NOT directly call the legacy applyGuardianDecision
-    expect(source).not.toContain("applyGuardianDecision(");
   });
 });
 

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

@@ -31,12 +31,11 @@ import {
 } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();
   db.run("DELETE FROM channel_inbound_events");
-  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");

package/src/__tests__/guardian-verification-voice-binding.test.ts

@@ -90,7 +90,7 @@ import { getOrCreateConversation } from "../memory/conversation-key-store.js";
 import { initializeDb } from "../memory/db-init.js";
 import { getBindingByConversation } from "../memory/external-conversation-store.js";
 
-initializeDb();
+await initializeDb();
 
 describe("startVerificationCall — voice binding", () => {
   beforeEach(() => {

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

@@ -482,9 +482,9 @@ describe("browser_mode wiring through tool execution", () => {
     expect(result.isError).toBe(false);
   });
 
-  // ── Auto mode still works without browser_mode ────────────────
+  // ── Default browser selection works without browser_mode ──────
 
-  test("auto mode works when browser_mode is not specified", async () => {
+  test("default browser selection works when browser_mode is not specified", async () => {
     const result = await executeBrowserSnapshot({}, ctx);
     expect(result.isError).toBe(false);
   });

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

@@ -26,6 +26,10 @@ mock.module("../config/loader.js", () => ({
       activeHoursStart: undefined,
       activeHoursEnd: undefined,
     },
+    timeouts: {
+      backgroundTurnTimeoutSec: 1800,
+      scheduleTurnTimeoutSec: 1800,
+    },
   }),
   loadConfig: () => ({}),
   loadRawConfig: () => ({}),

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

@@ -47,6 +47,9 @@ let mockConfig = {
     activeHoursEnd: undefined as number | undefined,
     disposition: "Default disposition text mentioning notifications skill.",
   },
+  timeouts: {
+    backgroundTurnTimeoutSec: 1800,
+  },
 };
 
 mock.module("../config/loader.js", () => ({
@@ -399,6 +402,9 @@ describe("HeartbeatService", () => {
         activeHoursEnd: undefined,
         disposition: "Default disposition text mentioning notifications skill.",
       },
+      timeouts: {
+        backgroundTurnTimeoutSec: 1800,
+      },
     };
   });
 

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

@@ -61,6 +61,12 @@ mock.module("../../daemon/approval-generators.js", () => ({
   createApprovalConversationGenerator: () => undefined,
 }));
 
+import type { TrustClass, TrustVerdict } from "@vellumai/gateway-client";
+
+import {
+  findContactChannel,
+  findGuardianForChannel,
+} from "../../contacts/contact-store.js";
 import type {
   ApprovalConversationGenerator,
   ApprovalCopyGenerator,
@@ -112,9 +118,95 @@ export async function handleChannelInbound(
   _approvalConversationGenerator?: ApprovalConversationGenerator,
 ): Promise<Response> {
   const body = await req.json();
+  stampTrustVerdict(body);
   return wrapHandler(() => _handleChannelInbound({ body }));
 }
 
+/**
+ * Mirror the gateway: stamp a per-actor {@link TrustVerdict} onto inbound
+ * `sourceMetadata` from the local contact store, so the daemon's ACL stage
+ * (which now reads the verdict and fail-closed-denies when it is absent) sees
+ * the same verdict the gateway would resolve in production.
+ *
+ * Skipped when a test already supplies `trustVerdict` (or sets `sourceMetadata`
+ * to null) so absent-verdict / explicit-verdict tests keep their setup.
+ */
+function stampTrustVerdict(body: Record<string, unknown>): void {
+  const meta = body.sourceMetadata as Record<string, unknown> | undefined;
+  if (meta && "trustVerdict" in meta) return;
+
+  const channelType = String(body.sourceChannel ?? "");
+  const actorExternalId =
+    typeof body.actorExternalId === "string" ? body.actorExternalId : undefined;
+  if (!channelType) return;
+
+  const verdict = resolveLocalTrustVerdict({
+    channelType,
+    actorExternalId,
+  });
+  body.sourceMetadata = { ...(meta ?? {}), trustVerdict: verdict };
+}
+
+/** Local mirror of the gateway resolver, reading the daemon contact store. */
+export function resolveLocalTrustVerdict(input: {
+  channelType: string;
+  actorExternalId?: 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,
+      })
+    : null;
+  const guardian = findGuardianForChannel(input.channelType);
+
+  const isGuardian =
+    !!guardian &&
+    !!canonicalSenderId &&
+    guardian.channel.address.toLowerCase() === canonicalSenderId.toLowerCase();
+
+  let trustClass: TrustClass;
+  if (isGuardian) {
+    trustClass = "guardian";
+  } else if (member) {
+    const status = member.channel.status;
+    if (status === "active") trustClass = "trusted_contact";
+    else if (status === "unverified" || status === "pending")
+      trustClass = "unverified_contact";
+    else trustClass = "unknown";
+  } else {
+    trustClass = "unknown";
+  }
+
+  const verdict: TrustVerdict = { trustClass, canonicalSenderId };
+
+  if (guardian) {
+    verdict.guardianExternalUserId = guardian.channel.address;
+    verdict.guardianDeliveryChatId = guardian.channel.externalChatId;
+    if (guardian.contact.principalId)
+      verdict.guardianPrincipalId = guardian.contact.principalId;
+    verdict.guardianDisplayName = guardian.contact.displayName;
+  }
+
+  if (member) {
+    verdict.contactId = member.channel.contactId;
+    verdict.channelId = member.channel.id;
+    verdict.type = member.channel.type;
+    verdict.address = member.channel.address;
+    verdict.externalChatId = member.channel.externalChatId;
+    verdict.status = member.channel.status;
+    verdict.policy = member.channel.policy;
+    verdict.verifiedAt = member.channel.verifiedAt;
+    verdict.verifiedVia = member.channel.verifiedVia;
+    verdict.memberDisplayName = member.contact.displayName;
+  }
+
+  return verdict;
+}
+
 // ---------------------------------------------------------------------------
 // handleDeleteConversation adapter
 // ---------------------------------------------------------------------------