@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -21,7 +21,10 @@ import {
   isValidConversationStarterText,
 } from "../../memory/conversation-starter-validation.js";
 import { getDb } from "../../memory/db-connection.js";
-import { enqueueMemoryJob } from "../../memory/jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+} from "../../memory/jobs-store.js";
 import { conversationStarters, memoryJobs } from "../../memory/schema.js";
 import { NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -203,7 +206,7 @@ function handleListConversationStarters({
       checkpointAhead ||
       (invalidItemCount > 0 && totalActive > 0 && !withinCooldown);
 
-    if (shouldRefresh && !hasActiveJob) {
+    if (shouldRefresh && !hasActiveJob && isMemoryEnabled()) {
       enqueueMemoryJob("generate_conversation_starters", { scopeId });
       hasActiveJob = true;
     }
@@ -225,7 +228,7 @@ function handleListConversationStarters({
 
   const existing = hasActiveConversationStarterJob(db, scopeId);
 
-  if (!existing) {
+  if (!existing && isMemoryEnabled()) {
     enqueueMemoryJob("generate_conversation_starters", { scopeId });
   }
 

package/src/runtime/routes/conversations-import-routes.ts

@@ -2,7 +2,11 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getConfig } from "../../config/loader.js";
-import { addMessage, createConversation } from "../../memory/conversation-crud.js";
+import {
+  addMessage,
+  createConversation,
+  type MessageRole,
+} from "../../memory/conversation-crud.js";
 import {
   getConversationByKey,
   setConversationKey,
@@ -22,7 +26,7 @@ const log = getLogger("conversations-import-routes");
 // -- Types --
 
 interface ImportMessage {
-  role: string;
+  role: MessageRole;
   content: string | Array<{ type: string; text: string }>;
   createdAt?: number;
 }
@@ -59,7 +63,10 @@ function resolveTimestamps(conv: ImportConversation): {
 // -- Handler --
 
 async function handleConversationsImport({ body }: RouteHandlerArgs) {
-  if (!body || !Array.isArray((body as Record<string, unknown>).conversations)) {
+  if (
+    !body ||
+    !Array.isArray((body as Record<string, unknown>).conversations)
+  ) {
     throw new BadRequestError("conversations array required");
   }
 
@@ -70,7 +77,8 @@ async function handleConversationsImport({ body }: RouteHandlerArgs) {
   let imported = 0;
   let skipped = 0;
   let totalMessages = 0;
-  const errors: Array<{ index: number; sourceKey?: string; error: string }> = [];
+  const errors: Array<{ index: number; sourceKey?: string; error: string }> =
+    [];
 
   for (let idx = 0; idx < payload.conversations.length; idx++) {
     const conv = payload.conversations[idx];
@@ -90,7 +98,8 @@ async function handleConversationsImport({ body }: RouteHandlerArgs) {
         }
       }
 
-      const { convCreatedAt, convUpdatedAt, messageTimestamps } = resolveTimestamps(conv);
+      const { convCreatedAt, convUpdatedAt, messageTimestamps } =
+        resolveTimestamps(conv);
 
       const conversation = createConversation(conv.title);
 
@@ -122,7 +131,11 @@ async function handleConversationsImport({ body }: RouteHandlerArgs) {
         .orderBy(messagesTable.createdAt)
         .all();
 
-      for (let i = 0; i < dbMessages.length && i < messageTimestamps.length; i++) {
+      for (
+        let i = 0;
+        i < dbMessages.length && i < messageTimestamps.length;
+        i++
+      ) {
         db.update(messagesTable)
           .set({ createdAt: messageTimestamps[i] })
           .where(eq(messagesTable.id, dbMessages[i].id))

package/src/runtime/routes/disk-pressure-routes.ts

@@ -11,7 +11,7 @@ import type { RouteDefinition } from "./types.js";
 
 const DiskPressureStatusSchema = z.object({
   enabled: z.boolean(),
-  state: z.enum(["disabled", "ok", "critical", "unknown"]),
+  state: z.enum(["disabled", "ok", "warning", "critical", "unknown"]),
   locked: z.boolean(),
   acknowledged: z.boolean(),
   overrideActive: z.boolean(),

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

@@ -82,7 +82,16 @@ export const ROUTES: RouteDefinition[] = [
       },
     ],
     responseBody: z.object({
-      documents: z.array(z.unknown()).describe("Document summary objects"),
+      documents: z.array(
+        z.object({
+          surfaceId: z.string(),
+          conversationId: z.string(),
+          title: z.string(),
+          wordCount: z.number(),
+          createdAt: z.number(),
+          updatedAt: z.number(),
+        }),
+      ),
     }),
     handler: ({ queryParams }) => {
       const conversationId = queryParams?.conversationId ?? undefined;

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

@@ -35,7 +35,10 @@ async function requireClient(): Promise<VellumPlatformClient> {
 // ── Handlers ──────────────────────────────────────────────────────────
 
 async function handleDomainRegister({ body = {} }: RouteHandlerArgs) {
-  const { subdomain } = body as { subdomain?: string };
+  const { subdomain, email_username } = body as {
+    subdomain?: string;
+    email_username?: string;
+  };
   const client = await requireClient();
   const apexDomain = getApexDomain();
 
@@ -43,6 +46,9 @@ async function handleDomainRegister({ body = {} }: RouteHandlerArgs) {
   if (subdomain) {
     reqBody.subdomain = subdomain;
   }
+  if (email_username) {
+    reqBody.email_username = email_username;
+  }
 
   const response = await client.fetch(
     `/v1/assistants/${client.platformAssistantId}/domains/`,
@@ -58,12 +64,18 @@ async function handleDomainRegister({ body = {} }: RouteHandlerArgs) {
       string,
       unknown
     >;
+    const firstFieldError = ["subdomain", "email_username"].reduce<
+      string | undefined
+    >(
+      (found, field) =>
+        found ??
+        (Array.isArray(respBody[field])
+          ? (respBody[field][0] as string)
+          : undefined),
+      undefined,
+    );
     const detail =
-      respBody.detail ??
-      (Array.isArray(respBody.subdomain)
-        ? respBody.subdomain[0]
-        : undefined) ??
-      `HTTP ${response.status}`;
+      respBody.detail ?? firstFieldError ?? `HTTP ${response.status}`;
     throw new BadRequestError(String(detail));
   }
 
@@ -71,10 +83,9 @@ async function handleDomainRegister({ body = {} }: RouteHandlerArgs) {
     id: string;
     subdomain?: string;
     domain?: string;
-    status?: string;
-    verified?: boolean;
     created_at?: string;
     created?: string;
+    email_error?: { detail: string; code: string };
   };
 
   // Persist the subdomain to config so getAssistantDomain() can use it
@@ -117,8 +128,6 @@ async function handleDomainStatus(_args: RouteHandlerArgs) {
       id: string;
       subdomain?: string;
       domain?: string;
-      status?: string;
-      verified?: boolean;
       created_at?: string;
       created?: string;
     }[];
@@ -145,6 +154,39 @@ async function handleDomainStatus(_args: RouteHandlerArgs) {
   return data;
 }
 
+async function handleDomainVerificationStatus({
+  body = {},
+}: RouteHandlerArgs) {
+  const { domain_id } = body as { domain_id?: string };
+  if (!domain_id) {
+    throw new BadRequestError("domain_id is required");
+  }
+  const client = await requireClient();
+
+  const response = await client.fetch(
+    `/v1/assistants/${client.platformAssistantId}/domains/${domain_id}/verification-status/`,
+  );
+
+  if (!response.ok) {
+    const respBody = (await response.json().catch(() => ({}))) as Record<
+      string,
+      unknown
+    >;
+    const detail = respBody.detail ?? `HTTP ${response.status}`;
+    throw new RouteError(
+      String(detail),
+      "VERIFICATION_STATUS_FAILED",
+      response.status,
+    );
+  }
+
+  return (await response.json()) as {
+    domain: string;
+    status: string;
+    message: string;
+  };
+}
+
 // ── Route definitions ─────────────────────────────────────────────────
 
 export const ROUTES: RouteDefinition[] = [
@@ -164,4 +206,12 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Show domain registration and health",
     tags: ["domain"],
   },
+  {
+    operationId: "domain_verification_status",
+    endpoint: "domain/verification-status",
+    method: "POST",
+    handler: handleDomainVerificationStatus,
+    summary: "Get live DNS verification status for a domain",
+    tags: ["domain"],
+  },
 ];

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

@@ -277,13 +277,16 @@ async function handleEmailSend({ body = {} }: RouteHandlerArgs) {
 
   const fromAddress = addresses[0].address;
 
+  // LLMs often produce literal "\n" escape sequences instead of real newlines.
+  const normalizedText = text?.replace(/\\n/g, "\n") ?? "";
+
   // Auto-generate HTML from text if not provided
-  const resolvedHtml = html ?? markdownToEmailHtml(text);
+  const resolvedHtml = html ?? markdownToEmailHtml(normalizedText);
 
   const payload: Record<string, unknown> = {
     to,
     from_address: fromAddress,
-    text,
+    text: normalizedText,
   };
   if (subject) payload.subject = subject;
   if (resolvedHtml) payload.html = resolvedHtml;

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

@@ -26,6 +26,7 @@ import { z } from "zod";
 import type { HostProxyCapability } from "../../channels/types.js";
 import { parseInterfaceId, supportsHostProxy } from "../../channels/types.js";
 import { emitContactChange } from "../../contacts/contact-events.js";
+import { getConversation } from "../../memory/conversation-crud.js";
 import { getOrCreateConversation } from "../../memory/conversation-key-store.js";
 import { getLogger } from "../../util/logger.js";
 import { formatSseFrame, formatSseHeartbeat } from "../assistant-event.js";
@@ -39,7 +40,11 @@ import {
   assistantEventHub,
 } from "../assistant-event-hub.js";
 import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
-import { BadRequestError, ServiceUnavailableError } from "./errors.js";
+import {
+  BadRequestError,
+  NotFoundError,
+  ServiceUnavailableError,
+} from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("events-routes");
@@ -220,9 +225,17 @@ const defaultSseShedReporter: SseShedReporter = (reason, inst) => {
  * Stream assistant events as Server-Sent Events.
  *
  * Query params:
- *   conversationKey -- optional; when provided, scopes the stream to one
- *                      conversation. When omitted, the stream delivers events
- *                      from ALL conversations for this assistant.
+ *   conversationId  -- optional; assistant-minted internal conversation id.
+ *                      When provided, the stream is scoped to that one
+ *                      conversation; the daemon 404s if no such conversation
+ *                      exists (clients must obtain the id from a prior
+ *                      response).
+ *   conversationKey -- optional; external key (non-vellum channels) or the
+ *                      web idempotency key. Resolved via the conversation
+ *                      keys table; materializes a row on first use.
+ *                      Ignored when `conversationId` is also provided.
+ *   When both are omitted, the stream delivers events from ALL
+ *   conversations for this assistant.
  *
  * Headers (optional):
  *   X-Vellum-Client-Id    -- stable per-install UUID identifying this client.
@@ -248,8 +261,18 @@ export function handleSubscribeAssistantEvents(
 ): ReadableStream<Uint8Array> {
   const { queryParams, headers, abortSignal } = args;
 
-  const conversationKey = queryParams?.conversationKey;
-  if ("conversationKey" in (queryParams ?? {}) && !conversationKey?.trim()) {
+  const rawConversationId = queryParams?.conversationId;
+  const rawConversationKey = queryParams?.conversationKey;
+  if (
+    "conversationId" in (queryParams ?? {}) &&
+    !rawConversationId?.trim()
+  ) {
+    throw new BadRequestError("conversationId must not be empty");
+  }
+  if (
+    "conversationKey" in (queryParams ?? {}) &&
+    !rawConversationKey?.trim()
+  ) {
     throw new BadRequestError("conversationKey must not be empty");
   }
 
@@ -293,10 +316,25 @@ export function handleSubscribeAssistantEvents(
     "host_browser",
   ];
 
+  // Resolve the scope. `conversationId` (when supplied) is the
+  // assistant-minted internal id — looked up directly; 404 if absent.
+  // Otherwise fall through to `conversationKey`, which is treated as an
+  // external key and resolved via the conversation_keys table
+  // (materialized on first use, preserving the existing subscribe-time
+  // create behavior for the web idempotency flow).
   const filter: AssistantEventFilter = {};
-  if (conversationKey) {
-    const mapping = getOrCreateConversation(conversationKey);
+  let scopeConversationKey: string | null = null;
+  if (rawConversationId) {
+    const existing = getConversation(rawConversationId);
+    if (!existing) {
+      throw new NotFoundError(`Conversation ${rawConversationId} not found`);
+    }
+    filter.conversationId = existing.id;
+    scopeConversationKey = existing.id;
+  } else if (rawConversationKey) {
+    const mapping = getOrCreateConversation(rawConversationKey);
     filter.conversationId = mapping.conversationId;
+    scopeConversationKey = rawConversationKey;
   }
 
   const encoder = new TextEncoder();
@@ -316,7 +354,7 @@ export function handleSubscribeAssistantEvents(
     heartbeatsSent: 0,
     clientId,
     interfaceId,
-    conversationKey: conversationKey ?? null,
+    conversationKey: scopeConversationKey,
   };
 
   ensureEventLoopDelayMonitorStarted();
@@ -470,9 +508,15 @@ export const ROUTES: RouteDefinition[] = [
     description: "Stream assistant events as Server-Sent Events (SSE).",
     tags: ["events"],
     queryParams: [
+      {
+        name: "conversationId",
+        description:
+          "Scope to a single conversation by its assistant-minted internal id. 404s if no such conversation exists.",
+      },
       {
         name: "conversationKey",
-        description: "Scope to a single conversation",
+        description:
+          "Scope to a single conversation by an external key (non-vellum channels) or the web idempotency key. Materializes a row on first use. Ignored when conversationId is also provided.",
       },
     ],
     responseHeaders: {

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

@@ -22,6 +22,13 @@ import { publishConversationListChanged } from "../sync/resource-sync-events.js"
 import { BadRequestError, ForbiddenError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
+const groupSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  sortPosition: z.number(),
+  isSystemGroup: z.boolean(),
+});
+
 function serializeGroup(group: ReturnType<typeof getGroup>) {
   if (!group) return null;
   return {
@@ -41,14 +48,17 @@ function handleListGroups() {
   return { groups: groups.map(serializeGroup) };
 }
 
-function handleCreateGroup({ body = {} }: RouteHandlerArgs) {
+function handleCreateGroup({ body = {}, headers }: RouteHandlerArgs) {
   const name = body.name;
   if (!name || typeof name !== "string") {
     throw new BadRequestError("Missing or invalid name");
   }
   try {
     const group = createGroup(name);
-    publishConversationListChanged("created");
+    publishConversationListChanged(
+      "created",
+      headers?.["x-vellum-client-id"]?.trim() || undefined,
+    );
     return serializeGroup(group);
   } catch (err) {
     if (
@@ -63,7 +73,11 @@ function handleCreateGroup({ body = {} }: RouteHandlerArgs) {
   }
 }
 
-function handleUpdateGroup({ pathParams = {}, body = {} }: RouteHandlerArgs) {
+function handleUpdateGroup({
+  pathParams = {},
+  body = {},
+  headers,
+}: RouteHandlerArgs) {
   const groupId = pathParams.groupId;
   const existing = getGroup(groupId);
   if (!existing) {
@@ -92,11 +106,14 @@ function handleUpdateGroup({ pathParams = {}, body = {} }: RouteHandlerArgs) {
   if (!updated) {
     throw new NotFoundError("Group not found");
   }
-  publishConversationListChanged("reordered");
+  publishConversationListChanged(
+    "reordered",
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return serializeGroup(updated);
 }
 
-function handleDeleteGroup({ pathParams = {} }: RouteHandlerArgs) {
+function handleDeleteGroup({ pathParams = {}, headers }: RouteHandlerArgs) {
   const groupId = pathParams.groupId;
   const existing = getGroup(groupId);
   if (!existing) {
@@ -106,10 +123,13 @@ function handleDeleteGroup({ pathParams = {} }: RouteHandlerArgs) {
     throw new ForbiddenError("System groups cannot be deleted");
   }
   deleteGroup(groupId);
-  publishConversationListChanged("reordered");
+  publishConversationListChanged(
+    "reordered",
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
 }
 
-function handleReorderGroups({ body = {} }: RouteHandlerArgs) {
+function handleReorderGroups({ body = {}, headers }: RouteHandlerArgs) {
   const updates = body.updates as
     | Array<{ groupId: string; sortPosition: number }>
     | undefined;
@@ -135,7 +155,10 @@ function handleReorderGroups({ body = {} }: RouteHandlerArgs) {
     }
   }
   reorderGroups(updates);
-  publishConversationListChanged("reordered");
+  publishConversationListChanged(
+    "reordered",
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { ok: true };
 }
 
@@ -153,6 +176,7 @@ export const ROUTES: RouteDefinition[] = [
     summary: "List groups",
     description: "Return all conversation groups.",
     tags: ["groups"],
+    responseBody: z.object({ groups: z.array(groupSchema) }),
   },
   {
     operationId: "groups_create",
@@ -168,6 +192,7 @@ export const ROUTES: RouteDefinition[] = [
     requestBody: z.object({
       name: z.string().describe("Group name"),
     }),
+    responseBody: groupSchema,
     additionalResponses: {
       "400": {
         description:
@@ -188,6 +213,7 @@ export const ROUTES: RouteDefinition[] = [
       name: z.string().optional(),
       sortPosition: z.number().optional(),
     }),
+    responseBody: groupSchema,
     additionalResponses: {
       "403": {
         description: "System group sort position cannot be changed",
@@ -235,6 +261,7 @@ export const ROUTES: RouteDefinition[] = [
         )
         .describe("Array of { groupId, sortPosition } objects"),
     }),
+    responseBody: z.object({ ok: z.boolean() }),
     additionalResponses: {
       "403": {
         description: "Cannot reorder system groups",

package/src/runtime/routes/home-feed-routes.ts

@@ -62,6 +62,32 @@ const patchFeedItemRequestSchema = z.object({
   status: z.enum(["new", "seen", "acted_on", "dismissed"]),
 });
 
+const listHomeFeedRequestSchema = z.object({
+  includeDismissed: z.boolean().optional(),
+  statuses: z
+    .array(z.enum(["new", "seen", "acted_on", "dismissed"]))
+    .optional(),
+  before: z.string().optional(),
+  after: z.string().optional(),
+  urgencies: z.array(z.enum(["low", "medium", "high", "critical"])).optional(),
+  categories: z
+    .array(z.enum(["security", "scheduling", "background", "email", "system"]))
+    .optional(),
+  conversationId: z.string().optional(),
+  fromAssistant: z.boolean().optional(),
+  noteworthy: z.boolean().optional(),
+  limit: z.number().int().positive().max(200).optional(),
+  offset: z.number().int().nonnegative().optional(),
+});
+
+const listHomeFeedResponseSchema = z.object({
+  items: z.array(feedItemSchema),
+  total: z.number().int().nonnegative(),
+  returned: z.number().int().nonnegative(),
+  hasMore: z.boolean(),
+  updatedAt: z.string(),
+});
+
 // ---------------------------------------------------------------------------
 // Pure helpers (exported for direct testing)
 // ---------------------------------------------------------------------------
@@ -183,6 +209,97 @@ export async function handlePatchFeedItem({
   return updated as unknown as Record<string, unknown>;
 }
 
+export function handleListHomeFeed({
+  body = {},
+}: RouteHandlerArgs): Record<string, unknown> {
+  const parsed = listHomeFeedRequestSchema.safeParse(body);
+  if (!parsed.success) {
+    throw new BadRequestError(
+      `Invalid list request: ${parsed.error.issues
+        .map((i) => `${i.path.join(".")} ${i.message}`)
+        .join("; ")}`,
+    );
+  }
+  const params = parsed.data;
+
+  const beforeMs =
+    params.before !== undefined ? Date.parse(params.before) : undefined;
+  if (beforeMs !== undefined && Number.isNaN(beforeMs)) {
+    throw new BadRequestError(
+      `Invalid 'before' timestamp; expected ISO-8601 (got "${params.before}")`,
+    );
+  }
+  const afterMs =
+    params.after !== undefined ? Date.parse(params.after) : undefined;
+  if (afterMs !== undefined && Number.isNaN(afterMs)) {
+    throw new BadRequestError(
+      `Invalid 'after' timestamp; expected ISO-8601 (got "${params.after}")`,
+    );
+  }
+
+  // `statuses` is the explicit override. Otherwise default to excluding
+  // dismissed unless includeDismissed=true — the assistant's primary use
+  // case is "what's still outstanding", so dismissed items are noise
+  // unless explicitly requested.
+  const statusFilter: Set<FeedItemStatus> | null = params.statuses
+    ? new Set(params.statuses)
+    : params.includeDismissed
+      ? null
+      : new Set<FeedItemStatus>(["new", "seen", "acted_on"]);
+
+  const urgencySet = params.urgencies ? new Set(params.urgencies) : null;
+  const categorySet = params.categories ? new Set(params.categories) : null;
+
+  const feed = readHomeFeed();
+
+  const filtered = feed.items.filter((item) => {
+    if (statusFilter && !statusFilter.has(item.status)) return false;
+    if (urgencySet) {
+      if (!item.urgency || !urgencySet.has(item.urgency)) return false;
+    }
+    if (categorySet) {
+      if (!item.category || !categorySet.has(item.category)) return false;
+    }
+    if (
+      params.conversationId !== undefined &&
+      item.conversationId !== params.conversationId
+    )
+      return false;
+    if (
+      params.fromAssistant !== undefined &&
+      (item.fromAssistant ?? false) !== params.fromAssistant
+    )
+      return false;
+    if (
+      params.noteworthy !== undefined &&
+      (item.noteworthy ?? false) !== params.noteworthy
+    )
+      return false;
+
+    if (beforeMs !== undefined || afterMs !== undefined) {
+      const createdMs = Date.parse(item.createdAt);
+      if (Number.isNaN(createdMs)) return false;
+      if (beforeMs !== undefined && createdMs >= beforeMs) return false;
+      if (afterMs !== undefined && createdMs <= afterMs) return false;
+    }
+
+    return true;
+  });
+
+  const total = filtered.length;
+  const offset = params.offset ?? 0;
+  const limit = params.limit ?? 20;
+  const items = filtered.slice(offset, offset + limit);
+
+  return {
+    items,
+    total,
+    returned: items.length,
+    hasMore: total > offset + items.length,
+    updatedAt: feed.updatedAt,
+  };
+}
+
 export async function handlePostFeedAction({
   pathParams = {},
 }: RouteHandlerArgs): Promise<Record<string, unknown>> {
@@ -261,6 +378,18 @@ export const ROUTES: RouteDefinition[] = [
       "500": { description: "Failed to persist feed item status" },
     },
   },
+  {
+    operationId: "list_home_feed",
+    endpoint: "home/feed/query",
+    method: "POST",
+    handler: handleListHomeFeed,
+    summary: "List home feed items with filters",
+    description:
+      "Return home feed items filtered by status, urgency, category, conversation, and date range. Defaults to excluding dismissed items. Used by the assistant CLI to inspect what notifications have been surfaced to the user.",
+    tags: ["home"],
+    requestBody: listHomeFeedRequestSchema,
+    responseBody: listHomeFeedResponseSchema,
+  },
   {
     operationId: "trigger_home_feed_action",
     endpoint: "home/feed/:id/actions/:actionId",

package/src/runtime/routes/host-browser-routes.ts

@@ -223,8 +223,9 @@ export type HostBrowserSessionInvalidatedResolution =
 export function resolveHostBrowserSessionInvalidated(frame: {
   targetId?: unknown;
   reason?: unknown;
+  clientId?: unknown;
 }): HostBrowserSessionInvalidatedResolution {
-  const { targetId, reason } = frame;
+  const { targetId, reason, clientId } = frame;
 
   if (targetId !== undefined && typeof targetId !== "string") {
     return {
@@ -235,6 +236,9 @@ export function resolveHostBrowserSessionInvalidated(frame: {
     };
   }
 
+  const resolvedClientId =
+    typeof clientId === "string" && clientId.length > 0 ? clientId : undefined;
+
   if (typeof targetId === "string" && targetId.length > 0) {
     markTargetInvalidated(
       targetId,
@@ -245,7 +249,7 @@ export function resolveHostBrowserSessionInvalidated(frame: {
     // Without this, a user closing the pinned tab manually would see
     // their next browser command fail with a `cdp_session_not_found`
     // until the daemon process restarts.
-    clearPinnedTabByTabId(targetId);
+    clearPinnedTabByTabId(targetId, resolvedClientId);
   }
 
   return { ok: true };
@@ -387,6 +391,10 @@ export const ROUTES: RouteDefinition[] = [
         .optional()
         .describe("CDP target that was detached"),
       reason: z.string().optional().describe("Detach reason"),
+      clientId: z
+        .string()
+        .optional()
+        .describe("Extension client ID that reported the invalidation"),
     }),
     responseBody: z.object({
       accepted: z.boolean(),