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

package/src/__tests__/http-user-message-parity.test.ts

@@ -62,21 +62,6 @@ mock.module("../runtime/guardian-reply-router.js", () => ({
   routeGuardianReply: routeGuardianReplyMock,
 }));
 
-// Stub for the shared reset-drift helper. handleSendMessage only consumes its
-// result (a guardian TrustContext or null) on a first-pass-unknown actor; the
-// gate itself is covered in runtime/__tests__/guardian-vellum-migration.test.ts.
-const reResolveCalls: string[] = [];
-let mockReResolve: { trustClass: string; sourceChannel: string } | null = null;
-mock.module("../runtime/guardian-vellum-migration.js", () => ({
-  reResolveTrustOnResetDrift: async (
-    incomingPrincipalId: string,
-    _sourceChannel: string,
-  ) => {
-    reResolveCalls.push(incomingPrincipalId);
-    return mockReResolve;
-  },
-}));
-
 mock.module("../memory/canonical-guardian-store.js", () => ({
   createCanonicalGuardianRequest: () => ({
     id: "canonical-id",
@@ -109,8 +94,6 @@ mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
   addMessage: (
     conversationId: string,
     role: string,
@@ -121,70 +104,17 @@ mock.module("../memory/conversation-crud.js", () => ({
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
-  findLocalGuardianPrincipalId: async () =>
-    mockGuardians?.find(
-      (g) => g.channelType === "vellum" && g.status === "active",
-    )?.principalId as string | undefined,
-}));
-
-// Capture the sourceActorPrincipalId that handleSendMessage threads into
-// shouldAttachHostProxyForCapability / preactivateHostProxySkills, so tests
-// can assert the dev-bypass translation landed before the CU proxy gate.
-// The macOS "native_support" path short-circuits before reading the
-// principal, so only web/ios turns exercise the same-actor branch.
-const hostProxyAttachCalls: Array<{
-  capability: string;
-  sourceInterface: unknown;
-  sourceActorPrincipalId: string | undefined;
-}> = [];
-const preactivateCalls: Array<{
-  sourceInterface: unknown;
-  sourceActorPrincipalId: string | undefined;
-}> = [];
-mock.module("../daemon/host-proxy-preactivation.js", () => ({
-  shouldAttachHostProxyForCapability: (
-    capability: string,
-    sourceInterface: unknown,
-    sourceActorPrincipalId: string | undefined,
-  ) => {
-    hostProxyAttachCalls.push({
-      capability,
-      sourceInterface,
-      sourceActorPrincipalId,
-    });
-    // Return false so the route skips proxy instantiation; we only care
-    // that the translated principal reached the gate.
-    return false;
-  },
-  preactivateHostProxySkills: (
-    _conversation: unknown,
-    sourceInterface: unknown,
-    sourceActorPrincipalId: string | undefined,
-  ) => {
-    preactivateCalls.push({ sourceInterface, sourceActorPrincipalId });
-  },
-}));
-
-let mockGuardians: Array<Record<string, unknown>> | null = [
-  {
-    channelType: "vellum",
-    contactId: "guardian-contact",
-    principalId: "test-user",
-    address: "test-user",
-    status: "active",
-  },
-];
-
-mock.module("../contacts/guardian-delivery-reader.js", () => ({
-  getGuardianDelivery: async () => mockGuardians,
-  guardianForChannel: (
-    list: Array<Record<string, unknown>>,
-    channelType: string,
-  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+  resolveLocalTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  }),
 }));
 
-// handleSendMessage wraps the first-pass resolve with withSourceChannel.
 mock.module("../runtime/trust-context-resolver.js", () => ({
+  resolveTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  }),
   withSourceChannel: (sourceChannel: unknown, ctx: unknown) => ({
     ...(ctx as Record<string, unknown>),
     sourceChannel,
@@ -524,215 +454,3 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
     expect(runAgentLoop).toHaveBeenCalledTimes(1);
   });
 });
-
-// ============================================================================
-// TRUST CONTEXT — derived from the gateway guardian binding
-// ============================================================================
-describe("HTTP POST /v1/messages trust context from the gateway binding", () => {
-  beforeEach(() => {
-    mockGuardians = [
-      {
-        channelType: "vellum",
-        contactId: "guardian-contact",
-        principalId: "test-user",
-        address: "test-user",
-        status: "active",
-      },
-    ];
-    reResolveCalls.length = 0;
-    mockReResolve = null;
-  });
-
-  function requestAs(principalId: string, sourceChannel = "vellum") {
-    return new Request("http://localhost/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-vellum-actor-principal-id": principalId,
-        "x-vellum-principal-type": "actor",
-      },
-      body: JSON.stringify({
-        conversationKey: "trust-test-key",
-        content: "hi",
-        sourceChannel,
-        interface: "macos",
-      }),
-    });
-  }
-
-  async function trustContextFor(
-    principalId: string,
-    sourceChannel = "vellum",
-  ): Promise<Record<string, unknown>> {
-    let captured: Record<string, unknown> | undefined;
-    const conversation = makeConversation({
-      setTrustContext: (ctx: Record<string, unknown>) => {
-        captured = ctx;
-      },
-    });
-    const res = await callHandler(
-      (args) =>
-        handleSendMessage(args, {
-          sendMessageDeps: {
-            getOrCreateConversation: async () => conversation,
-            assistantEventHub: { publish: async () => {} } as any,
-            resolveAttachments: () => [],
-          },
-        }),
-      requestAs(principalId, sourceChannel),
-      undefined,
-      202,
-    );
-    expect(res.status).toBe(202);
-    return captured ?? {};
-  }
-
-  async function trustClassFor(principalId: string): Promise<string> {
-    return (await trustContextFor(principalId)).trustClass as string;
-  }
-
-  test("guardian principal resolves to guardian context, helper not called", async () => {
-    expect(await trustClassFor("test-user")).toBe("guardian");
-    expect(reResolveCalls).toEqual([]);
-  });
-
-  test("non-guardian principal: helper consulted, null result stays unknown", async () => {
-    mockReResolve = null;
-    expect(await trustClassFor("vellum-principal-stranger")).toBe("unknown");
-    expect(reResolveCalls).toEqual(["vellum-principal-stranger"]);
-  });
-
-  test("reset drift: helper returns guardian → route adopts it", async () => {
-    mockGuardians = [
-      {
-        channelType: "vellum",
-        contactId: "guardian-contact",
-        principalId: "vellum-principal-stale",
-        address: "vellum-principal-stale",
-        status: "active",
-      },
-    ];
-    mockReResolve = { trustClass: "guardian", sourceChannel: "vellum" };
-
-    expect(await trustClassFor("vellum-principal-healed")).toBe("guardian");
-    expect(reResolveCalls).toEqual(["vellum-principal-healed"]);
-  });
-
-  test("helper returns an unknown-class ctx → trust stays unknown (not adopted)", async () => {
-    mockGuardians = [
-      {
-        channelType: "vellum",
-        contactId: "guardian-contact",
-        principalId: "vellum-principal-stale",
-        address: "vellum-principal-stale",
-        status: "active",
-      },
-    ];
-    mockReResolve = { trustClass: "unknown", sourceChannel: "vellum" };
-
-    expect(await trustClassFor("vellum-principal-healed")).toBe("unknown");
-  });
-
-  test("dev-bypass maps the gateway guardian principal to guardian", async () => {
-    expect(await trustClassFor("dev-bypass")).toBe("guardian");
-  });
-
-  test("dev-bypass fails closed to unknown on an empty gateway", async () => {
-    // No active gateway binding: dev-bypass cannot translate to a real guardian,
-    // and the helper (null) leaves trust unknown — parity with /v1/surface-actions.
-    mockGuardians = [];
-    mockReResolve = null;
-    expect(await trustClassFor("dev-bypass")).toBe("unknown");
-  });
-
-  test("preserves the request body channel on the guardian-match happy path", async () => {
-    const ctx = await trustContextFor("test-user", "telegram");
-    expect(ctx.trustClass).toBe("guardian");
-    expect(ctx.sourceChannel).toBe("telegram");
-  });
-
-  // A web turn's "dev-bypass" principal must translate to the real guardian
-  // principal before the CU/app-control same-actor proxy-attachment gate,
-  // so it matches the macOS client's SSE-registered principal.
-  test("dev-bypass is translated to the guardian principal before the CU proxy attach gate (web turn)", async () => {
-    hostProxyAttachCalls.length = 0;
-    preactivateCalls.length = 0;
-    const conversation = makeConversation();
-    const res = await callHandler(
-      (args) =>
-        handleSendMessage(args, {
-          sendMessageDeps: {
-            getOrCreateConversation: async () => conversation,
-            assistantEventHub: { publish: async () => {} } as any,
-            resolveAttachments: () => [],
-          },
-        }),
-      new Request("http://localhost/v1/messages", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-vellum-actor-principal-id": "dev-bypass",
-          "x-vellum-principal-type": "actor",
-        },
-        body: JSON.stringify({
-          conversationKey: "cu-attach-key",
-          content: "hi",
-          sourceChannel: "vellum",
-          interface: "web",
-        }),
-      }),
-      undefined,
-      202,
-    );
-    expect(res.status).toBe(202);
-
-    // The CU attach gate receives the translated guardian principal, not
-    // the raw "dev-bypass" string.
-    const cuCall = hostProxyAttachCalls.find(
-      (c) => c.capability === "host_cu",
-    );
-    expect(cuCall).toBeDefined();
-    expect(cuCall?.sourceActorPrincipalId).toBe("test-user");
-    expect(cuCall?.sourceActorPrincipalId).not.toBe("dev-bypass");
-
-    // Preactivation receives the same translated principal.
-    const preactivateCall = preactivateCalls[0];
-    expect(preactivateCall?.sourceActorPrincipalId).toBe("test-user");
-  });
-
-  test("real (non-dev-bypass) principal passes through the CU proxy attach gate unchanged", async () => {
-    hostProxyAttachCalls.length = 0;
-    const conversation = makeConversation();
-    await callHandler(
-      (args) =>
-        handleSendMessage(args, {
-          sendMessageDeps: {
-            getOrCreateConversation: async () => conversation,
-            assistantEventHub: { publish: async () => {} } as any,
-            resolveAttachments: () => [],
-          },
-        }),
-      new Request("http://localhost/v1/messages", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-vellum-actor-principal-id": "real-jwt-principal",
-          "x-vellum-principal-type": "actor",
-        },
-        body: JSON.stringify({
-          conversationKey: "cu-attach-real-key",
-          content: "hi",
-          sourceChannel: "vellum",
-          interface: "web",
-        }),
-      }),
-      undefined,
-      202,
-    );
-
-    const cuCall = hostProxyAttachCalls.find(
-      (c) => c.capability === "host_cu",
-    );
-    expect(cuCall?.sourceActorPrincipalId).toBe("real-jwt-principal");
-  });
-});

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -64,28 +64,6 @@ mock.module("../runtime/approval-message-composer.js", () => ({
   composeApprovalMessageGenerative: async () => "mock generative message",
 }));
 
-// Stub the gateway IPC so redemption claims + activation relays resolve
-// deterministically without a running gateway socket.
-const gatewayIpcCalls: Array<{
-  method: string;
-  params?: Record<string, unknown>;
-}> = [];
-mock.module("../ipc/gateway-client.js", () => ({
-  ipcCallPersistent: async (
-    method: string,
-    params?: Record<string, unknown>,
-  ) => {
-    gatewayIpcCalls.push({ method, params });
-    if (method === "record_invite_redemption") {
-      return { ok: true, updated: true, mirrored: true };
-    }
-    if (method === "upsert_verified_channel") {
-      return { ok: true, verified: true };
-    }
-    return undefined;
-  },
-}));
-
 import {
   findContactChannel,
   upsertContact,
@@ -120,7 +98,6 @@ function resetState(): void {
   db.run("DELETE FROM contacts");
   emitSignalCalls.length = 0;
   deliverReplyCalls.length = 0;
-  gatewayIpcCalls.length = 0;
   msgCounter = 0;
 }
 
@@ -200,11 +177,6 @@ describe("inbound invite redemption intercept", () => {
     expect(result).not.toBeNull();
     expect(result!.channel.status).toBe("active");
 
-    // The activation is written to the gateway via upsert_verified_channel.
-    expect(
-      gatewayIpcCalls.some((c) => c.method === "upsert_verified_channel"),
-    ).toBe(true);
-
     // Verify a welcome reply was delivered
     expect(deliverReplyCalls.length).toBe(1);
     const replyText = (deliverReplyCalls[0].payload as Record<string, unknown>)

package/src/__tests__/inbound-slack-persistence.test.ts

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

package/src/__tests__/invite-redemption-service.test.ts

@@ -7,26 +7,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-// Wrap the real contacts-write so a test can force the best-effort local mirror
-// to fail (simulating a gateway-verified activation whose local DB row failed),
-// while normal setup keeps the real implementation. Capture the concrete real
-// function BEFORE registering the mock so the wrapper never recurses into
-// itself via the (now live) module namespace.
-const contactsWriteState = { mirrorThrows: false };
-const realContactsWrite = await import("../contacts/contacts-write.js");
-const realUpsertContactChannel = realContactsWrite.upsertContactChannel;
-mock.module("../contacts/contacts-write.js", () => ({
-  ...realContactsWrite,
-  upsertContactChannel: (
-    params: Parameters<typeof realUpsertContactChannel>[0],
-  ) => {
-    if (contactsWriteState.mirrorThrows) {
-      throw new Error("local mirror exploded");
-    }
-    return realUpsertContactChannel(params);
-  },
-}));
-
 // Mock the gateway IPC bridge used by the redemption service for the
 // authoritative pre-mutation claim (record_invite_redemption). Tests drive the
 // claim result via `gatewayIpc`.
@@ -37,12 +17,6 @@ const gatewayIpc = {
     mirrored: boolean;
   },
   claimThrows: false,
-  // Drives the upsert_verified_channel relay verdict. When false the gateway
-  // refuses the actor (blocked/revoked) and the activation is refused.
-  activationVerified: true,
-  // Gateway channel returned on a verified activation, surfaced as the memberId
-  // when the local mirror produces no row.
-  activationChannelId: "gw-channel-id" as string | undefined,
   calls: [] as { method: string; params?: Record<string, unknown> }[],
 };
 
@@ -54,49 +28,18 @@ mock.module("../ipc/gateway-client.js", () => ({
     gatewayIpc.calls.push({ method, params });
     if (method === "record_invite_redemption") {
       if (gatewayIpc.claimThrows) throw new Error("gateway unreachable");
-      onGatewayClaim?.();
       return gatewayIpc.claim;
     }
-    if (method === "upsert_verified_channel") {
-      if (!gatewayIpc.activationVerified) {
-        return { ok: true, verified: false };
-      }
-      return {
-        ok: true,
-        verified: true,
-        channel: gatewayIpc.activationChannelId
-          ? {
-              id: gatewayIpc.activationChannelId,
-              contactId: (params?.contactId as string) ?? "gw-contact",
-              type: (params?.type as string) ?? "telegram",
-              address: (params?.address as string) ?? "gw-addr",
-              status: "active",
-              verifiedAt: 1,
-              verifiedVia: (params?.verifiedVia as string) ?? "invite",
-            }
-          : undefined,
-      };
-    }
     return undefined;
   },
 }));
 
-// Lets a test inject a side-effect into the gateway claim — runs after the
-// service's pre-validation but before the assistant use-bump, so it can race a
-// revoke into the window that makes `recordInviteUse` return false.
-let onGatewayClaim: (() => void) | null = null;
-
 function resetGatewayIpc() {
   gatewayIpc.claim = { ok: true, updated: true, mirrored: true };
   gatewayIpc.claimThrows = false;
-  gatewayIpc.activationVerified = true;
-  gatewayIpc.activationChannelId = "gw-channel-id";
   gatewayIpc.calls = [];
-  onGatewayClaim = null;
 }
 
-import type { TrustVerdict } from "@vellumai/gateway-client";
-
 import {
   findContactChannel,
   getContact,
@@ -113,7 +56,6 @@ import {
   type InviteRedemptionOutcome,
   redeemInvite,
   redeemInviteByCode,
-  resolveMemberGateStatus,
 } from "../runtime/invite-redemption-service.js";
 import { hashVoiceCode } from "../util/voice-code.js";
 
@@ -134,7 +76,6 @@ describe("invite-redemption-service", () => {
   beforeEach(() => {
     resetTables();
     resetGatewayIpc();
-    contactsWriteState.mirrorThrows = false;
   });
 
   test("redeems a valid invite and returns typed outcome", async () => {
@@ -158,11 +99,6 @@ describe("invite-redemption-service", () => {
       memberId: expect.any(String),
       inviteId: invite.id,
     });
-
-    // The activation is written to the gateway via upsert_verified_channel.
-    expect(
-      gatewayIpc.calls.some((c) => c.method === "upsert_verified_channel"),
-    ).toBe(true);
   });
 
   test("marks channel as verified via invite on redemption", async () => {
@@ -421,18 +357,6 @@ describe("invite-redemption-service", () => {
     expect(outcome.ok).toBe(true);
     expect((outcome as { type: string }).type).toBe("redeemed");
 
-    // Gateway-first: the activation relays the target contactId so the gateway
-    // binds the channel to Mom (not the guardian) — the binding is not lost.
-    const upsert = gatewayIpc.calls.find(
-      (c) => c.method === "upsert_verified_channel",
-    );
-    expect(upsert).toBeDefined();
-    expect(upsert!.params).toMatchObject({
-      type: "telegram",
-      address: "guardian-tg-id",
-      contactId: momContact.id,
-    });
-
     // Verify the redeemer's Telegram ID is now bound to Mom's contact
     const result = findContactChannel({
       channelType: "telegram",
@@ -704,39 +628,6 @@ describe("invite-redemption-service", () => {
     ).toBeNull();
   });
 
-  test("does not activate the member when recordInviteUse loses the race (returns false)", async () => {
-    const targetContactId = createTargetContact();
-    const { rawToken, invite } = createInvite({
-      sourceChannel: "telegram",
-      contactId: targetContactId,
-      maxUses: 1,
-    });
-
-    // Legacy gateway row so the claim proceeds past the gateway gate. Revoke
-    // the assistant invite during the claim — after pre-validation, before the
-    // use-bump — so `recordInviteUse` sees a non-active row and returns false.
-    gatewayIpc.claim = { ok: true, updated: false, mirrored: false };
-    onGatewayClaim = () => {
-      revokeStoreFn(invite.id);
-    };
-
-    const outcome = await redeemInvite({
-      rawToken,
-      sourceChannel: "telegram",
-      externalUserId: "raced-user",
-    });
-
-    expect(outcome).toEqual({ ok: false, reason: "invalid_token" });
-
-    // The member was NOT activated: no gateway upsert and no active channel.
-    expect(
-      gatewayIpc.calls.some((c) => c.method === "upsert_verified_channel"),
-    ).toBe(false);
-    expect(
-      findContactChannel({ channelType: "telegram", address: "raced-user" }),
-    ).toBeNull();
-  });
-
   test("proceeds and mutates when the gateway claim is consumed (updated:true)", async () => {
     const targetContactId = createTargetContact();
     const { rawToken, invite } = createInvite({
@@ -871,93 +762,4 @@ describe("invite-redemption-service", () => {
       }),
     ).toBeNull();
   });
-
-  test("returns invalid_token (no throw) when the gateway refuses the activation", async () => {
-    const targetContactId = createTargetContact();
-    const { rawToken } = createInvite({
-      sourceChannel: "telegram",
-      contactId: targetContactId,
-      maxUses: 1,
-    });
-
-    // Gateway claim consumes the row, then refuses the channel activation
-    // (blocked/revoked actor). The committed use is acceptable for this rare
-    // blocked-backstop path; the outcome must be the branch failure, not a 500.
-    gatewayIpc.activationVerified = false;
-
-    const outcome = await redeemInvite({
-      rawToken,
-      sourceChannel: "telegram",
-      externalUserId: "refused-user",
-    });
-
-    expect(outcome).toEqual({ ok: false, reason: "invalid_token" });
-  });
-
-  test("redeems with the gateway channel id when the gateway verifies but the local mirror fails", async () => {
-    const targetContactId = createTargetContact();
-    const { rawToken, invite } = createInvite({
-      sourceChannel: "telegram",
-      contactId: targetContactId,
-      maxUses: 1,
-    });
-
-    // Gateway verifies and returns its channel; the best-effort local mirror
-    // throws. The activation must still stand using the gateway channel id.
-    gatewayIpc.activationChannelId = "gw-verified-channel";
-    contactsWriteState.mirrorThrows = true;
-
-    const outcome = await redeemInvite({
-      rawToken,
-      sourceChannel: "telegram",
-      externalUserId: "mirrorless-user",
-    });
-
-    expect(outcome).toEqual({
-      ok: true,
-      type: "redeemed",
-      memberId: "gw-verified-channel",
-      inviteId: invite.id,
-    });
-  });
-});
-
-describe("resolveMemberGateStatus", () => {
-  const memberlessVerdict: TrustVerdict = {
-    trustClass: "unverified_contact",
-    canonicalSenderId: "telegram:blocked-user",
-  };
-  const memberVerdict: TrustVerdict = {
-    trustClass: "trusted_contact",
-    canonicalSenderId: "telegram:active-user",
-    contactId: "contact-1",
-    channelId: "channel-1",
-    type: "telegram",
-    address: "active-user",
-    status: "active",
-    policy: "allow",
-  };
-
-  test("uses the verdict member status when the verdict resolves a member", async () => {
-    expect(await resolveMemberGateStatus(memberVerdict, "blocked")).toBe(
-      "active",
-    );
-  });
-
-  test("falls back to local status when a non-null verdict carries no member", async () => {
-    // A previously blocked contact with a valid invite must stay blocked even
-    // when the verdict is non-null but memberless (externalChatId-only match /
-    // resolutionFailed), so it can't bypass the gate.
-    expect(await resolveMemberGateStatus(memberlessVerdict, "blocked")).toBe(
-      "blocked",
-    );
-  });
-
-  test("falls back to local status when the verdict is null", async () => {
-    expect(await resolveMemberGateStatus(null, "blocked")).toBe("blocked");
-  });
-
-  test("returns null when neither verdict member nor local status is present", async () => {
-    expect(await resolveMemberGateStatus(memberlessVerdict, null)).toBeNull();
-  });
 });