@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/src/__tests__/slack-reaction-canonical-approval.test.ts

@@ -0,0 +1,285 @@
+/**
+ * Tests for guardian approval-by-reaction on the canonical pipeline.
+ *
+ * A Slack emoji reaction (✅ / ❌) on a delivered approval card is routed
+ * through `routeGuardianReply` exactly like a button press or text reply. The
+ * emoji maps to an action and the reacted card's message id (`reactedMessageTs`)
+ * resolves the target request via its canonical delivery record — so the
+ * decision is applied precisely even when several cards are pending in the same
+ * chat, with no clarification prompt.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (value: string) => value,
+}));
+
+const _conversationMocks = new Map<string, unknown>();
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversation: (id: string) => _conversationMocks.get(id),
+}));
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  createCanonicalGuardianDelivery,
+  createCanonicalGuardianRequest,
+  getCanonicalGuardianRequest,
+  getPendingCanonicalRequestByDestinationMessage,
+  resolveCanonicalGuardianRequest,
+} from "../memory/canonical-guardian-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+
+initializeDb();
+
+// ---------------------------------------------------------------------------
+// Constants & helpers
+// ---------------------------------------------------------------------------
+
+const GUARDIAN_USER = "U_GUARDIAN";
+const PRINCIPAL = "principal-1";
+const CHAT_ID = "D_GUARDIAN_DM";
+const TOOL_NAME = "execute_shell";
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM canonical_guardian_deliveries");
+  db.run("DELETE FROM canonical_guardian_requests");
+  db.run("DELETE FROM scoped_approval_grants");
+  pendingInteractions.clear();
+  _conversationMocks.clear();
+}
+
+/**
+ * Seed a pending tool-approval (canonical request + delivery + pending
+ * interaction with a mock conversation) and return the mocked
+ * `handleConfirmationResponse` so callers can assert it was driven.
+ */
+function seedApproval(opts: {
+  requestId: string;
+  ts: string;
+  chatId?: string;
+  principal?: string;
+}): ReturnType<typeof mock> {
+  const chatId = opts.chatId ?? CHAT_ID;
+  const principal = opts.principal ?? PRINCIPAL;
+  const conversationId = `conv-${opts.requestId}`;
+
+  createCanonicalGuardianRequest({
+    id: opts.requestId,
+    kind: "tool_approval",
+    sourceType: "channel",
+    sourceChannel: "slack",
+    conversationId,
+    requesterExternalUserId: "requester-1",
+    requesterChatId: chatId,
+    guardianExternalUserId: GUARDIAN_USER,
+    guardianPrincipalId: principal,
+    toolName: TOOL_NAME,
+    status: "pending",
+    expiresAt: Date.now() + 300_000,
+  });
+
+  createCanonicalGuardianDelivery({
+    requestId: opts.requestId,
+    destinationChannel: "slack",
+    destinationChatId: chatId,
+    destinationMessageId: opts.ts,
+  });
+
+  const handleConfirmationResponse = mock(() => {});
+  _conversationMocks.set(conversationId, {
+    handleConfirmationResponse,
+    ensureActorScopedHistory: async () => {},
+  } as unknown as Conversation);
+  pendingInteractions.register(opts.requestId, {
+    conversationId,
+    kind: "confirmation",
+    confirmationDetails: {
+      toolName: TOOL_NAME,
+      input: { command: "echo hi" },
+      riskLevel: "high",
+      allowlistOptions: [{ label: "t", description: "t", pattern: "t" }],
+      scopeOptions: [{ label: "everywhere", scope: "everywhere" }],
+    },
+  });
+  return handleConfirmationResponse;
+}
+
+function reaction(opts: {
+  emoji: string;
+  reactedMessageTs?: string;
+  chatId?: string;
+  principal?: string;
+}): Parameters<typeof routeGuardianReply>[0] {
+  return {
+    messageText: "",
+    channel: "slack",
+    actor: {
+      actorPrincipalId: opts.principal ?? PRINCIPAL,
+      actorExternalUserId: GUARDIAN_USER,
+      channel: "slack",
+      guardianPrincipalId: opts.principal ?? PRINCIPAL,
+    },
+    conversationId: "guardian-conv",
+    callbackData: `reaction:${opts.emoji}`,
+    reactedMessageTs: opts.reactedMessageTs,
+    channelDeliveryContext: {
+      replyCallbackUrl: "https://gateway.test/deliver",
+      guardianChatId: opts.chatId ?? CHAT_ID,
+      assistantId: "self",
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Store lookup
+// ---------------------------------------------------------------------------
+
+describe("getPendingCanonicalRequestByDestinationMessage", () => {
+  beforeEach(resetTables);
+
+  test("resolves the request whose delivery matches channel + chat + message id", () => {
+    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
+    const found = getPendingCanonicalRequestByDestinationMessage(
+      "slack",
+      CHAT_ID,
+      "1700000000.000001",
+    );
+    expect(found?.id).toBe("req-1");
+  });
+
+  test("returns null when no delivery matches the message id", () => {
+    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
+    expect(
+      getPendingCanonicalRequestByDestinationMessage(
+        "slack",
+        CHAT_ID,
+        "9999.0",
+      ),
+    ).toBeNull();
+  });
+
+  test("returns null once the matched request is no longer pending", () => {
+    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
+    resolveCanonicalGuardianRequest("req-1", "pending", { status: "approved" });
+    expect(
+      getPendingCanonicalRequestByDestinationMessage(
+        "slack",
+        CHAT_ID,
+        "1700000000.000001",
+      ),
+    ).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Reaction routing
+// ---------------------------------------------------------------------------
+
+describe("routeGuardianReply / reactions", () => {
+  beforeEach(resetTables);
+
+  test("✅ on a delivered card approves the matching request", async () => {
+    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "white_check_mark", reactedMessageTs: "111.1" }),
+    );
+
+    expect(result.consumed).toBe(true);
+    expect(result.decisionApplied).toBe(true);
+    expect(result.type).toBe("canonical_decision_applied");
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("approved");
+    expect(hcr).toHaveBeenCalledTimes(1);
+    expect(hcr.mock.calls[0]?.[0]).toBe("req-1");
+    expect(hcr.mock.calls[0]?.[1]).toBe("allow");
+  });
+
+  test("❌ on a delivered card rejects the matching request", async () => {
+    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "-1", reactedMessageTs: "111.1" }),
+    );
+
+    expect(result.decisionApplied).toBe(true);
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("denied");
+    expect(hcr.mock.calls[0]?.[1]).toBe("deny");
+  });
+
+  test("reacting on a specific card resolves only that card (disambiguates N>1)", async () => {
+    const hcrA = seedApproval({ requestId: "req-A", ts: "100.1" });
+    const hcrB = seedApproval({ requestId: "req-B", ts: "200.2" });
+
+    // React on card B's message — only B should resolve.
+    const result = await routeGuardianReply(
+      reaction({ emoji: "white_check_mark", reactedMessageTs: "200.2" }),
+    );
+
+    expect(result.requestId).toBe("req-B");
+    expect(getCanonicalGuardianRequest("req-B")?.status).toBe("approved");
+    expect(getCanonicalGuardianRequest("req-A")?.status).toBe("pending");
+    expect(hcrB).toHaveBeenCalledTimes(1);
+    expect(hcrA).not.toHaveBeenCalled();
+  });
+
+  test("a reaction on an unknown message is not consumed (left for transcript)", async () => {
+    seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "white_check_mark", reactedMessageTs: "no-such-ts" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(result.type).toBe("not_consumed");
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+  });
+
+  test("an unknown emoji is not consumed", async () => {
+    seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "tada", reactedMessageTs: "111.1" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+  });
+
+  test("a reaction without a reacted message id is not consumed", async () => {
+    seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "white_check_mark" }),
+    );
+
+    expect(result.consumed).toBe(false);
+  });
+
+  test("a reaction from a different principal is surfaced, not silently dropped", async () => {
+    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({
+        emoji: "white_check_mark",
+        reactedMessageTs: "111.1",
+        principal: "someone-else",
+      }),
+    );
+
+    // Consumed with a user-facing reply, request untouched, side effect not run.
+    expect(result.consumed).toBe(true);
+    expect(result.decisionApplied).toBe(false);
+    expect(result.replyText).toMatch(/permission/i);
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+    expect(hcr).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/subagent-tools.test.ts

@@ -8,6 +8,7 @@ let mockGetMessages: (
 ) => Array<{ role: string; content: string }> | null = () => null;
 const mockProfiles = {
   balanced: {},
+  "cost-optimized": {},
   disabled: { status: "disabled" },
   "quality-optimized": {},
 };
@@ -476,6 +477,155 @@ describe("Subagent spawn success and failure", () => {
     }
   });
 
+  test("spawn inherits the invoking call site's default profile when no override is present", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-default-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Inherit default", objective: "Do it" },
+        makeContext("sess-inherit-default", {
+          sendToClient: () => {},
+          invokingCallSite: "mainAgent",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      // No explicit profile and no per-turn override → the child matches the
+      // invoking call site's resolved default profile (balanced for mainAgent
+      // in the test config).
+      expect(capturedConfig!.overrideProfile).toBe("balanced");
+      expect(capturedConfig!.forceOverrideProfile).toBeUndefined();
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn inherits a non-main invoker's call-site default profile", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-heartbeat-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Heartbeat child", objective: "Do it" },
+        makeContext("sess-inherit-heartbeat", {
+          sendToClient: () => {},
+          invokingCallSite: "heartbeatAgent",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      // A subagent spawned from a heartbeat turn matches heartbeatAgent's own
+      // cost-optimized default, not the mainAgent default.
+      expect(capturedConfig!.overrideProfile).toBe("cost-optimized");
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn prefers a per-turn override profile over the invoker default", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-override-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Override child", objective: "Do it" },
+        makeContext("sess-inherit-override", {
+          sendToClient: () => {},
+          invokingCallSite: "mainAgent",
+          overrideProfile: "quality-optimized",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      // The live per-turn override (per-conversation or tool-routed) wins over
+      // the call-site default, and is forwarded non-forced.
+      expect(capturedConfig!.overrideProfile).toBe("quality-optimized");
+      expect(capturedConfig!.forceOverrideProfile).toBeUndefined();
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn skips the auto profile so the child keeps its own default", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-auto-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Auto child", objective: "Do it" },
+        makeContext("sess-inherit-auto", {
+          sendToClient: () => {},
+          invokingCallSite: "mainAgent",
+          // "auto" is metadata-only; forwarding it would collapse the child to
+          // llm.default, so the inherited path drops it and the child keeps its
+          // own subagentSpawn default.
+          overrideProfile: "auto",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig!.overrideProfile).toBeUndefined();
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn still forces an explicit inference_profile over the invoker default", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-explicit-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Explicit child",
+          objective: "Do it",
+          inference_profile: "cost-optimized",
+        },
+        makeContext("sess-inherit-explicit", {
+          sendToClient: () => {},
+          invokingCallSite: "mainAgent",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig!.overrideProfile).toBe("cost-optimized");
+      expect(capturedConfig!.forceOverrideProfile).toBe(true);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
   test("spawn returns error for unknown inference_profile", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);

package/src/__tests__/task-progress-nudge-hook.test.ts

@@ -104,7 +104,7 @@ function currentResponse(toolUseId: string): ToolResultContent {
   };
 }
 
-/** A weak-model id that matches WEAK_MODEL_PATTERN (the gated population). */
+/** A weak-model id that matches WEAK_OPEN_MODEL_PATTERN (the gated population). */
 const WEAK_MODEL = "minimax/minimax-m3";
 
 function makeCtx(

package/src/__tests__/title-generate-hook.test.ts

@@ -7,8 +7,8 @@
  * - `user-prompt-submit` — first-pass generation from the submitted prompt,
  *   scheduled on a later macrotask so the main agent-loop LLM request is
  *   issued first.
- * - `stop` — second-pass regeneration once the conversation reaches its third
- *   user turn (turn count derived from the user prompts in history).
+ * - `stop` — fallback retry for replaceable titles and second-pass
+ *   regeneration once the conversation reaches its third user turn.
  *
  * Both let the title service resolve the provider, persist the title, and
  * broadcast the resulting `conversation_title_updated` / `sync_changed`
@@ -31,13 +31,42 @@ const queueGenerateConversationTitleMock = mock(
   }): void => undefined,
 );
 const queueRegenerateConversationTitleMock = mock(
-  (_params: { conversationId: string; provider?: unknown }): void => undefined,
+  (_params: {
+    conversationId: string;
+    provider?: unknown;
+    onlyIfReplaceable?: boolean;
+  }): void => undefined,
 );
 mock.module("../memory/conversation-title-service.js", () => ({
+  AUTO_TITLE_DETERMINISTIC: 2,
+  isReplaceableTitle: (title: string | null) =>
+    title == null ||
+    title === "" ||
+    title === "Generating title..." ||
+    title === "New Conversation" ||
+    title === "Untitled" ||
+    title === "Untitled Conversation" ||
+    title.startsWith("Runtime: "),
   queueGenerateConversationTitle: queueGenerateConversationTitleMock,
   queueRegenerateConversationTitle: queueRegenerateConversationTitleMock,
 }));
 
+const mockGetConversation = mock(
+  (_conversationId: string) =>
+    ({
+      title: "Existing Title",
+      isAutoTitle: 1,
+      conversationType: "standard",
+    }) as {
+      title: string;
+      isAutoTitle: number;
+      conversationType: string;
+    },
+);
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversation: mockGetConversation,
+}));
+
 // The `stop` hook reads `conversations.skipAutoRetitling`; stub the loader so
 // the opt-out is controllable per test.
 let skipAutoRetitling = false;
@@ -192,6 +221,19 @@ describe("title-generate stop hook", () => {
     resetPluginRegistryForTests();
     queueRegenerateConversationTitleMock.mockReset();
     queueRegenerateConversationTitleMock.mockImplementation(() => undefined);
+    mockGetConversation.mockReset();
+    mockGetConversation.mockImplementation(
+      (_conversationId: string) =>
+        ({
+          title: "Existing Title",
+          isAutoTitle: 1,
+          conversationType: "standard",
+        }) as {
+          title: string;
+          isAutoTitle: number;
+          conversationType: string;
+        },
+    );
     skipAutoRetitling = false;
   });
 
@@ -210,6 +252,61 @@ describe("title-generate stop hook", () => {
     expect(call?.conversationId).toBe("conv-1");
     expect(call).not.toHaveProperty("provider");
     expect(call).not.toHaveProperty("signal");
+    expect(call).not.toHaveProperty("onlyIfReplaceable");
+  });
+
+  test("retries a replaceable fallback title after a successful turn", async () => {
+    mockGetConversation.mockReturnValueOnce({
+      title: "Untitled Conversation",
+      isAutoTitle: 2,
+      conversationType: "standard",
+    });
+    const ctx = makeStopCtx({ messages: historyWithUserTurns(1) });
+
+    await stop(ctx);
+    await flushMacrotasks();
+
+    expect(queueRegenerateConversationTitleMock).toHaveBeenCalledTimes(1);
+    expect(queueRegenerateConversationTitleMock).toHaveBeenCalledWith({
+      conversationId: "conv-1",
+      onlyIfReplaceable: true,
+    });
+  });
+
+  test("preserves the third-turn retitle when the title is still replaceable", async () => {
+    mockGetConversation.mockReturnValueOnce({
+      title: "Untitled Conversation",
+      isAutoTitle: 2,
+      conversationType: "standard",
+    });
+    const ctx = makeStopCtx({ messages: historyWithUserTurns(3) });
+
+    await stop(ctx);
+    await flushMacrotasks();
+
+    expect(queueRegenerateConversationTitleMock).toHaveBeenCalledTimes(1);
+    const call = queueRegenerateConversationTitleMock.mock.calls[0]?.[0];
+    expect(call?.conversationId).toBe("conv-1");
+    expect(call).not.toHaveProperty("onlyIfReplaceable");
+  });
+
+  test("fallback title retry is not blocked by the retitling opt-out", async () => {
+    skipAutoRetitling = true;
+    mockGetConversation.mockReturnValueOnce({
+      title: "Generating title...",
+      isAutoTitle: 1,
+      conversationType: "standard",
+    });
+    const ctx = makeStopCtx({ messages: historyWithUserTurns(1) });
+
+    await stop(ctx);
+    await flushMacrotasks();
+
+    expect(queueRegenerateConversationTitleMock).toHaveBeenCalledTimes(1);
+    expect(queueRegenerateConversationTitleMock).toHaveBeenCalledWith({
+      conversationId: "conv-1",
+      onlyIfReplaceable: true,
+    });
   });
 
   test("defers the regeneration so the completed turn is persisted first", async () => {

package/src/__tests__/tool-approval-seed-content-blocks.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { buildToolApprovalSeedContentBlocks } from "../notifications/tool-approval-copy.js";
+import { buildToolApprovalSeedContentBlocks } from "../notifications/approval-card-data.js";
 
 describe("buildToolApprovalSeedContentBlocks", () => {
   const toolApprovalPayload: Record<string, unknown> = {

package/src/__tests__/tool-audit-listener.test.ts

@@ -1,11 +1,11 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// Toggle for the collectUsageData opt-out gate the listener consults when
+// Toggle for the share_analytics opt-out gate the listener consults when
 // populating the telemetry columns.
-let collectUsageData = true;
+let shareAnalytics = true;
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ collectUsageData }),
+mock.module("../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => shareAnalytics,
 }));
 
 import { createToolAuditListener } from "../events/tool-audit-listener.js";
@@ -17,7 +17,7 @@ import {
 
 describe("tool audit listener", () => {
   beforeEach(() => {
-    collectUsageData = true;
+    shareAnalytics = true;
   });
 
   test("records executed events with truncated output", () => {
@@ -361,8 +361,8 @@ describe("tool audit listener", () => {
     );
   });
 
-  test("persists NULL telemetry columns when usage data collection is opted out", () => {
-    collectUsageData = false;
+  test("persists NULL telemetry columns when share_analytics is opted out", () => {
+    shareAnalytics = false;
     const records: ToolInvocationRecord[] = [];
     const listener = createToolAuditListener((record) => records.push(record));
 

package/src/__tests__/tool-executor-lifecycle-events.test.ts

@@ -34,9 +34,6 @@ const mockConfig = {
   permissions: {
     mode: "workspace" as const,
   },
-  // The audit listener nulls the telemetry columns when this is false; the
-  // end-to-end listener tests below assert the opted-in sizing behavior.
-  collectUsageData: true,
 };
 
 let checkerDecision: "allow" | "prompt" | "deny" = "allow";
@@ -56,6 +53,12 @@ mock.module("../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
+// Analytics consent is granted so the audit listener populates the telemetry
+// columns; the end-to-end listener tests below assert the opted-in sizing.
+mock.module("../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => true,
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {

package/src/__tests__/trusted-contact-approval-notifier.test.ts

@@ -169,8 +169,10 @@ async function simulateNotifierPoll(params: {
     notifiedRequestIds,
   } = params;
 
-  // Gate check: only trusted contacts with guardian route
-  if (trustClass !== "trusted_contact" || !guardianExternalUserId) {
+  // Gate check: only identity-known non-guardian contacts with guardian route
+  const isIdentityKnownNonGuardian =
+    trustClass === "trusted_contact" || trustClass === "unverified_contact";
+  if (!isIdentityKnownNonGuardian || !guardianExternalUserId) {
     return false;
   }