@vellumai/assistant 0.8.4 → 0.8.6

package/src/runtime/routes/surface-conversation-resolver.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared helper for resolving the conversation that owns a surface.
+ *
+ * Used by both `surface-action-routes` (POST /v1/surface-actions) and
+ * `surface-content-routes` (GET /v1/surfaces/:surfaceId) so the
+ * in-memory-miss → DB-scan → rehydrate flow stays in one place.
+ *
+ * Why this exists: surfaces live on the in-memory `Conversation` object
+ * (`surfaceState` is rebuilt from `ui_surface` blocks in message
+ * history by `restoreSurfaceStateFromHistory()` whenever a Conversation
+ * is constructed). A bare `findConversation` lookup 404s after daemon
+ * restart or LRU eviction even though the surface data is still in the
+ * SQLite `messages` table. The DB scan below uses the surfaceId itself
+ * as the existence check so `getOrCreateConversation` can't be tricked
+ * into materializing a phantom conversation for any caller-supplied id.
+ */
+import type { Conversation } from "../../daemon/conversation.js";
+import {
+  findConversation,
+  findConversationBySurfaceId,
+  getOrCreateConversation,
+} from "../../daemon/conversation-store.js";
+import { rawGet } from "../../memory/raw-query.js";
+
+/**
+ * Resolve the {@link Conversation} that owns the given surface.
+ *
+ * Lookup order:
+ * 1. In-memory map keyed by `conversationId` (or by `surfaceId` when no
+ *    id is supplied).
+ * 2. SQLite `messages` table — find the conversation whose history
+ *    contains a `ui_surface` block with this `surfaceId`. The result is
+ *    validated against the caller's `conversationId` (when supplied) so
+ *    a mismatched pair returns `undefined` rather than silently
+ *    re-routing to a different conversation.
+ * 3. `getOrCreateConversation` rehydrates the row, which triggers
+ *    `restoreSurfaceStateFromHistory()` and repopulates `surfaceState`.
+ *
+ * Returns `undefined` when neither lookup nor DB scan turns up a
+ * matching conversation. Callers are expected to translate that into
+ * the route-appropriate 404.
+ */
+export async function resolveSurfaceConversation(
+  conversationId: string | null | undefined,
+  surfaceId: string,
+): Promise<Conversation | undefined> {
+  const found = conversationId
+    ? findConversation(conversationId)
+    : findConversationBySurfaceId(surfaceId);
+  if (found) return found;
+
+  // Escape LIKE wildcards so a `surfaceId` like "%" or "_" can't match
+  // unrelated rows.
+  const escaped = surfaceId.replace(/[\\%_]/g, "\\$&");
+  const row = rawGet<{ conversation_id: string }>(
+    `SELECT conversation_id FROM messages
+     WHERE content LIKE ? ESCAPE '\\'
+     ORDER BY created_at DESC
+     LIMIT 1`,
+    `%"surfaceId":"${escaped}"%`,
+  );
+  if (!row) return undefined;
+  if (conversationId && conversationId !== row.conversation_id) return undefined;
+  return await getOrCreateConversation(row.conversation_id);
+}

package/src/runtime/routes/wipe-conversation-routes.ts

@@ -5,6 +5,7 @@
 import { z } from "zod";
 
 import { destroyActiveConversation } from "../../daemon/conversation-store.js";
+import { stripConversationIds } from "../../home/feed-writer.js";
 import {
   countConversationsByScheduleJobId,
   getConversation,
@@ -54,6 +55,8 @@ async function handleWipeConversation({ body = {} }: RouteHandlerArgs) {
     });
   }
 
+  void stripConversationIds(conversationId);
+
   return {
     wiped: true,
     unsupersededItems: 0,

package/src/runtime/routes/workspace-routes.ts

@@ -59,9 +59,12 @@ function isSoundsWorkspacePath(path: string): boolean {
   );
 }
 
-function publishSoundsConfigUpdatedForPaths(paths: string[]): void {
+function publishSoundsConfigUpdatedForPaths(
+  paths: string[],
+  originClientId?: string,
+): void {
   if (paths.some(isSoundsWorkspacePath)) {
-    publishSoundsConfigUpdated();
+    publishSoundsConfigUpdated(originClientId);
   }
 }
 
@@ -263,7 +266,7 @@ function handleWorkspaceFileContent({
 // POST /v1/workspace/write — create or overwrite a file
 // ---------------------------------------------------------------------------
 
-function handleWorkspaceWrite({ body }: RouteHandlerArgs) {
+function handleWorkspaceWrite({ body, headers }: RouteHandlerArgs) {
   const path = body?.path as string | undefined;
   const content = body?.content as string | undefined;
   const encoding = body?.encoding as string | undefined;
@@ -292,7 +295,10 @@ function handleWorkspaceWrite({ body }: RouteHandlerArgs) {
 
   mkdirSync(dirname(resolved), { recursive: true });
   writeFileSync(resolved, buffer);
-  publishSoundsConfigUpdatedForPaths([path]);
+  publishSoundsConfigUpdatedForPaths(
+    [path],
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
 
   return { path, size: buffer.byteLength };
 }
@@ -301,7 +307,7 @@ function handleWorkspaceWrite({ body }: RouteHandlerArgs) {
 // POST /v1/workspace/mkdir — create directories
 // ---------------------------------------------------------------------------
 
-function handleWorkspaceMkdir({ body }: RouteHandlerArgs) {
+function handleWorkspaceMkdir({ body, headers }: RouteHandlerArgs) {
   const path = body?.path as string | undefined;
   if (!path) {
     throw new BadRequestError("path is required");
@@ -320,7 +326,10 @@ function handleWorkspaceMkdir({ body }: RouteHandlerArgs) {
   }
 
   mkdirSync(resolved, { recursive: true });
-  publishSoundsConfigUpdatedForPaths([path]);
+  publishSoundsConfigUpdatedForPaths(
+    [path],
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { path };
 }
 
@@ -328,7 +337,7 @@ function handleWorkspaceMkdir({ body }: RouteHandlerArgs) {
 // POST /v1/workspace/rename — rename/move files and directories
 // ---------------------------------------------------------------------------
 
-function handleWorkspaceRename({ body }: RouteHandlerArgs) {
+function handleWorkspaceRename({ body, headers }: RouteHandlerArgs) {
   const oldPath = body?.oldPath as string | undefined;
   const newPath = body?.newPath as string | undefined;
   if (!oldPath || !newPath) {
@@ -360,7 +369,10 @@ function handleWorkspaceRename({ body }: RouteHandlerArgs) {
 
   mkdirSync(dirname(resolvedNew), { recursive: true });
   renameSync(resolvedOld, resolvedNew);
-  publishSoundsConfigUpdatedForPaths([oldPath, newPath]);
+  publishSoundsConfigUpdatedForPaths(
+    [oldPath, newPath],
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { oldPath, newPath };
 }
 
@@ -368,7 +380,7 @@ function handleWorkspaceRename({ body }: RouteHandlerArgs) {
 // POST /v1/workspace/delete — delete files and directories
 // ---------------------------------------------------------------------------
 
-function handleWorkspaceDelete({ body }: RouteHandlerArgs) {
+function handleWorkspaceDelete({ body, headers }: RouteHandlerArgs) {
   const path = body?.path as string | undefined;
   if (!path) {
     throw new BadRequestError("path is required");
@@ -388,7 +400,10 @@ function handleWorkspaceDelete({ body }: RouteHandlerArgs) {
   }
 
   rmSync(resolved, { recursive: true, force: true });
-  publishSoundsConfigUpdatedForPaths([path]);
+  publishSoundsConfigUpdatedForPaths(
+    [path],
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { success: true };
 }
 

package/src/runtime/services/__tests__/analyze-conversation.test.ts

@@ -46,6 +46,7 @@ mock.module("../../../memory/conversation-crud.js", () => ({
   addMessage: mockAddMessage,
   findAnalysisConversationFor: mockFindAnalysisConversationFor,
   getConversationSource: mockGetConversationSource,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../../../export/transcript-formatter.js", () => ({
@@ -80,6 +81,7 @@ const testHub = new AssistantEventHub();
 mock.module("../../assistant-event-hub.js", () => ({
   AssistantEventHub,
   assistantEventHub: testHub,
+  broadcastMessage: async () => {},
 }));
 
 import { analyzeConversation } from "../analyze-conversation.js";

package/src/runtime/slack-dm-text-delivery.ts

@@ -0,0 +1,177 @@
+import type { ChannelId } from "../channels/types.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import { getLogger } from "../util/logger.js";
+import { deliverChannelReply } from "./gateway-client.js";
+
+const log = getLogger("runtime-http");
+
+const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/gi;
+
+export function isSlackDeliveryCallbackUrl(replyCallbackUrl?: string): boolean {
+  if (!replyCallbackUrl) return false;
+  try {
+    return new URL(replyCallbackUrl).pathname.endsWith("/deliver/slack");
+  } catch {
+    return replyCallbackUrl.endsWith("/deliver/slack");
+  }
+}
+
+export function shouldDeliverSlackDmTextResponses(params: {
+  sourceChannel: ChannelId;
+  chatType?: string;
+  replyCallbackUrl?: string;
+}): boolean {
+  return (
+    params.sourceChannel === "slack" &&
+    params.chatType === "im" &&
+    isSlackDeliveryCallbackUrl(params.replyCallbackUrl)
+  );
+}
+
+export type SlackDmTextDeliveryController = {
+  observeEvent: (msg: ServerMessage) => void;
+  waitForPendingDeliveries: () => Promise<void>;
+  getFinalDeliveryResumeOptions: (
+    messageId: string | undefined,
+  ) => { startFromSegment: number; messageTs?: string } | undefined;
+};
+
+export function createSlackDmTextDeliveryController(params: {
+  sourceChannel: ChannelId;
+  chatType?: string;
+  replyCallbackUrl?: string;
+  chatId: string;
+  assistantId?: string;
+  deliveredTextResponseIndexes?: readonly number[];
+  onTextResponseDelivered?: (
+    responseIndex: number,
+    reason: "before_tool" | "message_complete",
+  ) => void;
+}): SlackDmTextDeliveryController | undefined {
+  const { replyCallbackUrl } = params;
+  if (!shouldDeliverSlackDmTextResponses(params) || !replyCallbackUrl) {
+    return undefined;
+  }
+
+  const deliveredTextResponseIndexes = new Set(
+    params.deliveredTextResponseIndexes ?? [],
+  );
+  const messageIdToResponseIndexes = new Map<string, number[]>();
+  const responseIndexToMessageTs = new Map<number, string>();
+  let textResponseIndex = 0;
+  let pendingText = "";
+  let currentMessageResponseIndexes: number[] = [];
+  let deliveryChain = Promise.resolve();
+
+  const associateCurrentMessageResponses = (
+    messageId: string | undefined,
+  ): void => {
+    if (!messageId || currentMessageResponseIndexes.length === 0) return;
+    const responseIndexes = messageIdToResponseIndexes.get(messageId) ?? [];
+    for (const responseIndex of currentMessageResponseIndexes) {
+      if (!responseIndexes.includes(responseIndex)) {
+        responseIndexes.push(responseIndex);
+      }
+    }
+    messageIdToResponseIndexes.set(messageId, responseIndexes);
+    currentMessageResponseIndexes = [];
+  };
+
+  const flushPendingText = (
+    reason: "before_tool" | "message_complete",
+  ): void => {
+    const text = pendingText;
+    pendingText = "";
+
+    const deliverableText = text.replace(NO_RESPONSE_INLINE_RE, "").trim();
+    if (deliverableText.length === 0) return;
+
+    textResponseIndex += 1;
+    const currentResponseIndex = textResponseIndex;
+    currentMessageResponseIndexes.push(currentResponseIndex);
+    if (deliveredTextResponseIndexes.has(currentResponseIndex)) return;
+
+    deliveryChain = deliveryChain
+      .catch(() => undefined)
+      .then(async () => {
+        let result: Awaited<ReturnType<typeof deliverChannelReply>>;
+        try {
+          result = await deliverChannelReply(replyCallbackUrl, {
+            chatId: params.chatId,
+            text: deliverableText,
+            assistantId: params.assistantId,
+            useBlocks: true,
+          });
+        } catch (err) {
+          log.warn(
+            { err, chatId: params.chatId },
+            "Failed to deliver intermediate Slack DM assistant text",
+          );
+          return;
+        }
+
+        if (result.ts) {
+          responseIndexToMessageTs.set(currentResponseIndex, result.ts);
+        }
+        deliveredTextResponseIndexes.add(currentResponseIndex);
+        try {
+          params.onTextResponseDelivered?.(currentResponseIndex, reason);
+        } catch (err) {
+          log.warn(
+            { err, chatId: params.chatId, responseIndex: currentResponseIndex },
+            "Failed to persist intermediate Slack DM assistant text progress",
+          );
+        }
+      });
+  };
+
+  return {
+    observeEvent(msg) {
+      if (msg.type === "assistant_text_delta") {
+        pendingText += msg.text;
+        return;
+      }
+
+      if (msg.type === "message_complete") {
+        flushPendingText("message_complete");
+        if (typeof msg.messageId === "string") {
+          associateCurrentMessageResponses(msg.messageId);
+        }
+        currentMessageResponseIndexes = [];
+        return;
+      }
+
+      if (msg.type === "tool_use_start") {
+        flushPendingText("before_tool");
+      }
+    },
+    waitForPendingDeliveries: () => deliveryChain,
+    getFinalDeliveryResumeOptions: (messageId) => {
+      if (typeof messageId !== "string") {
+        return undefined;
+      }
+      const responseIndexes = messageIdToResponseIndexes.get(messageId) ?? [];
+      let deliveredPrefixCount = 0;
+      for (const responseIndex of responseIndexes) {
+        if (!deliveredTextResponseIndexes.has(responseIndex)) break;
+        deliveredPrefixCount += 1;
+      }
+      if (deliveredPrefixCount === 0) return undefined;
+
+      const firstLiveResponseIndex = responseIndexes[0];
+      const allTextResponsesDelivered =
+        responseIndexes.length > 0 &&
+        responseIndexes.every((responseIndex) =>
+          deliveredTextResponseIndexes.has(responseIndex),
+        );
+      const messageTs =
+        allTextResponsesDelivered && firstLiveResponseIndex !== undefined
+          ? responseIndexToMessageTs.get(firstLiveResponseIndex)
+          : undefined;
+      return {
+        startFromSegment: deliveredPrefixCount,
+        ...(messageTs ? { messageTs } : {}),
+      };
+    },
+  };
+}

package/src/runtime/sync/resource-sync-events.ts

@@ -9,15 +9,18 @@ import { getAvatarImagePath } from "../../util/platform.js";
 import { broadcastMessage } from "../assistant-event-hub.js";
 import { publishSyncInvalidation } from "./sync-publisher.js";
 
-export function publishAvatarChanged(): void {
+export function publishAvatarChanged(originClientId?: string): void {
   broadcastMessage({
     type: "avatar_updated",
     avatarPath: getAvatarImagePath(),
   });
-  void publishSyncInvalidation([SYNC_TAGS.assistantAvatar]);
+  void publishSyncInvalidation([SYNC_TAGS.assistantAvatar], originClientId);
 }
 
-export function publishIdentityChanged(fields: IdentityFields): void {
+export function publishIdentityChanged(
+  fields: IdentityFields,
+  originClientId?: string,
+): void {
   broadcastMessage({
     type: "identity_changed",
     name: fields.name,
@@ -26,59 +29,112 @@ export function publishIdentityChanged(fields: IdentityFields): void {
     emoji: fields.emoji,
     home: fields.home,
   });
-  void publishSyncInvalidation([SYNC_TAGS.assistantIdentity]);
+  void publishSyncInvalidation([SYNC_TAGS.assistantIdentity], originClientId);
 }
 
-export function publishConfigChanged(): void {
+export function publishConfigChanged(originClientId?: string): void {
   broadcastMessage({ type: "config_changed" });
-  void publishSyncInvalidation([SYNC_TAGS.assistantConfig]);
+  void publishSyncInvalidation([SYNC_TAGS.assistantConfig], originClientId);
 }
 
-export function publishSoundsConfigUpdated(): void {
+export function publishSoundsConfigUpdated(originClientId?: string): void {
   broadcastMessage({ type: "sounds_config_updated" });
-  void publishSyncInvalidation([SYNC_TAGS.assistantSounds]);
+  void publishSyncInvalidation([SYNC_TAGS.assistantSounds], originClientId);
 }
 
-export function publishSchedulesChanged(): void {
-  void publishSyncInvalidation([SYNC_TAGS.assistantSchedules]);
+export function publishSchedulesChanged(originClientId?: string): void {
+  void publishSyncInvalidation([SYNC_TAGS.assistantSchedules], originClientId);
+}
+
+/**
+ * Reasons that change the *shape* of the conversation list — a row is
+ * added, removed, or its position changes. These require web clients to
+ * refetch the paginated list because the row patch path (`refreshConversationRow`)
+ * only handles a single known id. Reasons not in this set are *content-only*
+ * changes to an existing row (e.g. `seen_changed`, `renamed`) and are
+ * delivered exclusively via the per-conversation `sync_changed` tag, which
+ * web consumes by GET-and-patching the single row.
+ */
+const SHAPE_CHANGING_REASONS: ReadonlySet<ConversationListInvalidatedReason> =
+  new Set(["created", "deleted", "reordered"]);
+
+/**
+ * Publish the legacy `conversation_list_invalidated` broadcast to macOS
+ * subscribers only.
+ *
+ * Web consumes `sync_changed` (`conversationsList` for shape changes,
+ * `conversation:<id>:metadata` for content changes) directly and patches
+ * the cached list in place — see `useConversationSync` for the consumer
+ * side. macOS (`ConversationRestorer.swift`) still listens for the typed
+ * broadcast.
+ *
+ * TODO(electron-cutover): remove this helper and all callers once macOS
+ * migrates to the Electron client and consumes `sync_changed` directly.
+ * At that point the `conversation_list_invalidated` message type can be
+ * retired entirely.
+ */
+function broadcastConversationListInvalidatedToMacos(
+  reason: ConversationListInvalidatedReason,
+): void {
+  broadcastMessage(
+    {
+      type: "conversation_list_invalidated",
+      reason,
+    },
+    undefined,
+    { targetInterfaceId: "macos" },
+  );
 }
 
 export function publishConversationListChanged(
   reason: ConversationListInvalidatedReason,
+  originClientId?: string,
 ): void {
-  broadcastMessage({
-    type: "conversation_list_invalidated",
-    reason,
-  });
-  void publishSyncInvalidation([SYNC_TAGS.conversationsList]);
+  broadcastConversationListInvalidatedToMacos(reason);
+  void publishSyncInvalidation([SYNC_TAGS.conversationsList], originClientId);
 }
 
 export function publishConversationMessagesChanged(
   conversationId: string,
+  originClientId?: string,
 ): void {
-  void publishSyncInvalidation([conversationMessagesSyncTag(conversationId)]);
+  void publishSyncInvalidation(
+    [conversationMessagesSyncTag(conversationId)],
+    originClientId,
+  );
 }
 
 export function publishConversationListAndMetadataChanged(
   reason: ConversationListInvalidatedReason,
   conversationIds: string | string[],
+  originClientId?: string,
 ): void {
   const ids = Array.isArray(conversationIds)
     ? conversationIds
     : [conversationIds];
-  broadcastMessage({
-    type: "conversation_list_invalidated",
-    reason,
-  });
-  void publishSyncInvalidation([
-    SYNC_TAGS.conversationsList,
-    ...ids.map((conversationId) => conversationMetadataSyncTag(conversationId)),
-  ]);
+  broadcastConversationListInvalidatedToMacos(reason);
+
+  // Shape-changing reasons (`created`, `deleted`, `reordered`) add or
+  // remove rows or change the order of the paginated window — web must
+  // refetch the list, so include the `conversationsList` umbrella tag.
+  // Content-only reasons (`renamed`, `seen_changed`) modify an existing
+  // row; web consumes the per-conversation metadata tag and GET-and-
+  // patches the single row, avoiding the full paginated list drain
+  // (`limit=50&offset=0..N` × foreground + background — ~14 requests
+  // per write at a few hundred conversations).
+  const tags: string[] = ids.map((conversationId) =>
+    conversationMetadataSyncTag(conversationId),
+  );
+  if (SHAPE_CHANGING_REASONS.has(reason)) {
+    tags.unshift(SYNC_TAGS.conversationsList);
+  }
+  void publishSyncInvalidation(tags, originClientId);
 }
 
 export function publishConversationTitleChanged(
   conversationId: string,
   title: string,
+  originClientId?: string,
 ): void {
   broadcastMessage(
     {
@@ -88,18 +144,27 @@ export function publishConversationTitleChanged(
     },
     conversationId,
   );
-  void publishSyncInvalidation([
-    SYNC_TAGS.conversationsList,
-    conversationMetadataSyncTag(conversationId),
-  ]);
+  // Renames are content-only — the paired typed `conversation_title_updated`
+  // event already carries the new title and patches the row in place on
+  // web; macOS receives the per-interface `conversation_list_invalidated`
+  // emitted from `broadcastMessage` (see `assistant-event-hub.ts`). The
+  // `sync_changed` metadata tag is included as a belt-and-suspenders signal
+  // for any sibling-tab consumer that missed the typed event.
+  void publishSyncInvalidation(
+    [conversationMetadataSyncTag(conversationId)],
+    originClientId,
+  );
 }
 
-export function publishConversationInferenceProfileChanged(params: {
-  conversationId: string;
-  profile: string | null;
-  sessionId?: string | null;
-  expiresAt?: number | null;
-}): void {
+export function publishConversationInferenceProfileChanged(
+  params: {
+    conversationId: string;
+    profile: string | null;
+    sessionId?: string | null;
+    expiresAt?: number | null;
+  },
+  originClientId?: string,
+): void {
   broadcastMessage(
     {
       type: "conversation_inference_profile_updated",
@@ -110,8 +175,11 @@ export function publishConversationInferenceProfileChanged(params: {
     },
     params.conversationId,
   );
-  void publishSyncInvalidation([
-    SYNC_TAGS.conversationsList,
-    conversationMetadataSyncTag(params.conversationId),
-  ]);
+  void publishSyncInvalidation(
+    [
+      SYNC_TAGS.conversationsList,
+      conversationMetadataSyncTag(params.conversationId),
+    ],
+    originClientId,
+  );
 }

package/src/runtime/sync/sync-publisher.test.ts

@@ -102,4 +102,53 @@ describe("sync publisher", () => {
       subscription.dispose();
     }
   });
+
+  test("forwards originClientId when provided", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const message = await publishSyncInvalidation(
+        [SYNC_TAGS.assistantAvatar],
+        "client-abc",
+      );
+
+      await waitFor(() => received.length === 1);
+
+      expect(message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantAvatar],
+        originClientId: "client-abc",
+      });
+      expect(received[0].message).toEqual(message);
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("omits originClientId when not provided", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const message = await publishSyncInvalidation([SYNC_TAGS.assistantAvatar]);
+
+      await waitFor(() => received.length === 1);
+
+      expect("originClientId" in message).toBe(false);
+      expect(received[0].message).toEqual(message);
+    } finally {
+      subscription.dispose();
+    }
+  });
 });

package/src/runtime/sync/sync-publisher.ts

@@ -10,8 +10,9 @@ const log = getLogger("sync-publisher");
 
 export async function publishSyncInvalidation(
   tags: SyncInvalidationTag[],
+  originClientId?: string,
 ): Promise<SyncChangedMessage> {
-  const message = buildSyncChangedMessage(tags);
+  const message = buildSyncChangedMessage(tags, originClientId);
   try {
     broadcastMessage(message);
   } catch (err) {

package/src/runtime/tool-grant-request-helper.ts

@@ -147,6 +147,7 @@ export function createOrReuseToolGrantRequest(
     sourceEventName: "guardian.question",
     sourceChannel: sourceChannel as NotificationSourceChannel,
     sourceContextId: conversationId,
+    requiresConversation: true,
     attentionHints: {
       requiresAction: true,
       urgency: "high",