@vellumai/assistant 0.7.0 → 0.7.1

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

@@ -8,18 +8,21 @@
 import { and, desc, eq, inArray, sql } from "drizzle-orm";
 import { z } from "zod";
 
+import {
+  checkpointKey,
+  CK_ITEM_COUNT,
+  CK_LAST_GEN_AT,
+  countActiveMemoryNodes,
+  getCheckpointValue,
+  parseCheckpointInt,
+} from "../../memory/conversation-starter-checkpoints.js";
 import {
   buildConversationStarterValidationContext,
   isValidConversationStarterText,
 } from "../../memory/conversation-starter-validation.js";
 import { getDb } from "../../memory/db-connection.js";
 import { enqueueMemoryJob } from "../../memory/jobs-store.js";
-import { rawGet } from "../../memory/raw-query.js";
-import {
-  conversationStarters,
-  memoryCheckpoints,
-  memoryJobs,
-} from "../../memory/schema.js";
+import { conversationStarters, memoryJobs } from "../../memory/schema.js";
 import { NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -36,19 +39,10 @@ interface StarterItem {
   batch: number;
 }
 
-const CK_ITEM_COUNT = "conversation_starters:item_count_at_last_gen";
-const CK_LAST_GEN_AT = "conversation_starters:last_gen_at";
 export const CONVERSATION_STARTERS_STALE_TTL_MS = 24 * 60 * 60 * 1000;
 
-function checkpointKey(base: string, scopeId: string): string {
-  return `${base}:${scopeId}`;
-}
-
-function parseCheckpointInt(value: string | undefined): number | null {
-  if (!value) return null;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : null;
-}
+/** Minimum interval between re-enqueue attempts triggered by invalid items. */
+const REFRESH_COOLDOWN_MS = 60_000;
 
 function hasActiveConversationStarterJob(
   db: ReturnType<typeof getDb>,
@@ -190,36 +184,24 @@ function handleListConversationStarters({
   const total = validItems.length;
 
   if (allItems.length > 0) {
-    const totalActive =
-      rawGet<{ c: number }>(
-        `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
-        scopeId,
-      )?.c ?? 0;
+    const totalActive = countActiveMemoryNodes(scopeId);
     const lastCount = parseCheckpointInt(
-      db
-        .select({ value: memoryCheckpoints.value })
-        .from(memoryCheckpoints)
-        .where(eq(memoryCheckpoints.key, checkpointKey(CK_ITEM_COUNT, scopeId)))
-        .get()?.value,
+      getCheckpointValue(checkpointKey(CK_ITEM_COUNT, scopeId)),
     );
     const lastGenAt = parseCheckpointInt(
-      db
-        .select({ value: memoryCheckpoints.value })
-        .from(memoryCheckpoints)
-        .where(
-          eq(memoryCheckpoints.key, checkpointKey(CK_LAST_GEN_AT, scopeId)),
-        )
-        .get()?.value,
+      getCheckpointValue(checkpointKey(CK_LAST_GEN_AT, scopeId)),
     );
     const staleByAge =
       lastGenAt == null ||
       Date.now() - lastGenAt >= CONVERSATION_STARTERS_STALE_TTL_MS;
     const checkpointAhead = lastCount != null && totalActive < lastCount;
     let hasActiveJob = hasActiveConversationStarterJob(db, scopeId);
+    const withinCooldown =
+      lastGenAt != null && Date.now() - lastGenAt < REFRESH_COOLDOWN_MS;
     const shouldRefresh =
       staleByAge ||
       checkpointAhead ||
-      (invalidItemCount > 0 && totalActive > 0);
+      (invalidItemCount > 0 && totalActive > 0 && !withinCooldown);
 
     if (shouldRefresh && !hasActiveJob) {
       enqueueMemoryJob("generate_conversation_starters", { scopeId });
@@ -235,12 +217,9 @@ function handleListConversationStarters({
     };
   }
 
-  const memoryCount = rawGet<{ c: number }>(
-    `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
-    scopeId,
-  );
+  const memoryCount = countActiveMemoryNodes(scopeId);
 
-  if (!memoryCount || memoryCount.c === 0) {
+  if (memoryCount === 0) {
     return { starters: [], total: 0, status: "empty" };
   }
 

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

@@ -25,6 +25,23 @@ interface DocumentRow {
 
 type DocumentListRow = Omit<DocumentRow, "content">;
 
+// ---------------------------------------------------------------------------
+// Junction table helper
+// ---------------------------------------------------------------------------
+
+/** Insert a document–conversation association (idempotent via INSERT OR IGNORE). */
+function addDocumentConversation(
+  surfaceId: string,
+  conversationId: string,
+): void {
+  rawRun(
+    /*sql*/ `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
+    surfaceId,
+    conversationId,
+    Date.now(),
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Shared business logic (used by both message handlers and HTTP routes)
 // ---------------------------------------------------------------------------
@@ -58,6 +75,20 @@ function saveDocument(params: {
       { surfaceId: params.surfaceId, title: params.title },
       "Saved document",
     );
+
+    // Best-effort: associate the document with the conversation.
+    // Failures (e.g. migration not yet applied, table missing) must not
+    // cause the save response to report failure — the document itself is
+    // already persisted at this point.
+    try {
+      addDocumentConversation(params.surfaceId, params.conversationId);
+    } catch (err) {
+      log.warn(
+        { err, surfaceId: params.surfaceId },
+        "Failed to record document–conversation association",
+      );
+    }
+
     return { success: true, surfaceId: params.surfaceId };
   } catch (error) {
     log.error({ err: error, surfaceId: params.surfaceId }, "Save error");
@@ -123,21 +154,30 @@ function listDocuments(conversationId?: string): Array<{
   updatedAt: number;
 }> {
   try {
-    let query = /*sql*/ `
-      SELECT surface_id, conversation_id, title, word_count, created_at, updated_at
-      FROM documents
-    `;
-    const params: string[] = [];
+    let results: DocumentListRow[];
 
     if (conversationId) {
-      query += " WHERE conversation_id = ?";
-      params.push(conversationId);
+      // Query via junction table so we return the *matched* conversation_id
+      // (not the origin conversation_id from the documents table).
+      results = rawAll<DocumentListRow>(
+        /*sql*/ `
+        SELECT d.surface_id, dc.conversation_id AS conversation_id,
+               d.title, d.word_count, d.created_at, d.updated_at
+        FROM documents d
+        INNER JOIN document_conversations dc ON d.surface_id = dc.surface_id
+        WHERE dc.conversation_id = ?
+        ORDER BY d.updated_at DESC
+        `,
+        conversationId,
+      );
+    } else {
+      results = rawAll<DocumentListRow>(/*sql*/ `
+        SELECT surface_id, conversation_id, title, word_count, created_at, updated_at
+        FROM documents
+        ORDER BY updated_at DESC
+        `);
     }
 
-    query += " ORDER BY updated_at DESC";
-
-    const results = rawAll<DocumentListRow>(query, ...params);
-
     log.info({ count: results.length }, "Listed documents");
     return results.map((row) => ({
       surfaceId: row.surface_id,
@@ -233,13 +273,8 @@ export const ROUTES: RouteDefinition[] = [
       surfaceId: z.string(),
     }),
     handler: ({ body }) => {
-      const {
-        surfaceId,
-        conversationId,
-        title,
-        content,
-        wordCount,
-      } = (body ?? {}) as {
+      const { surfaceId, conversationId, title, content, wordCount } = (body ??
+        {}) as {
         surfaceId?: string;
         conversationId?: string;
         title?: string;

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

@@ -11,30 +11,20 @@
  * that conversation. When omitted, subscribers receive events from ALL
  * conversations for this assistant (unfiltered).
  *
- * If the conversationKey has no server-side mapping yet (e.g. a client-
- * generated draft UUID that has not been sent a first message), this
- * handler eagerly materialises the conversation so the subscriber's
- * `filter.conversationId` matches the id under which the first turn's
- * scoped events (text deltas, tool calls, message_complete) will be
- * published by `handleSendMessage`. The `conversation_list_invalidated`
- * notification for other clients is driven by `handleSendMessage`'s
- * first-message check, so eager materialisation here is safe and does
- * not hide the first-message notification from other clients.
- *
  * Client registration:
  *   Clients may send `X-Vellum-Client-Id` and `X-Vellum-Interface-Id`
- *   request headers to register in the ClientRegistry on connect and
- *   automatically unregister on disconnect. When both headers are present,
- *   the client is registered immediately, touched on each heartbeat, and
- *   unregistered when the stream closes. When either header is missing,
- *   registration is skipped (backwards compat).
+ *   request headers. When both are present, the subscriber is registered
+ *   as a client in the event hub with derived capabilities. The hub
+ *   handles registration, touch (heartbeat), and unregistration (dispose).
  */
 
-import { parseInterfaceId } from "../../channels/types.js";
+import type { HostProxyCapability } from "../../channels/types.js";
+import { parseInterfaceId, supportsHostProxy } from "../../channels/types.js";
 import { getOrCreateConversation } from "../../memory/conversation-key-store.js";
 import { getLogger } from "../../util/logger.js";
 import { formatSseFrame, formatSseHeartbeat } from "../assistant-event.js";
 import type {
+  AssistantEventCallback,
   AssistantEventFilter,
   AssistantEventSubscription,
 } from "../assistant-event-hub.js";
@@ -42,15 +32,13 @@ import {
   AssistantEventHub,
   assistantEventHub,
 } from "../assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
-import { getClientRegistry } from "../client-registry.js";
 import { BadRequestError, ServiceUnavailableError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("events-routes");
 
-/** Keep-alive comment sent to idle clients every 30 s by default. */
-const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
+/** Keep-alive comment sent to idle clients every 7 s by default. */
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 7_000;
 
 /**
  * Stream assistant events as Server-Sent Events.
@@ -64,12 +52,13 @@ const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
  *   X-Vellum-Client-Id    -- stable per-install UUID identifying this client.
  *   X-Vellum-Interface-Id -- interface type (e.g. "macos", "ios", "web").
  *
- *   When both are present the client is registered in the ClientRegistry on
- *   connect and unregistered on disconnect.
+ *   When both are present, the subscriber is registered as a client in the
+ *   event hub with metadata (interfaceId, capabilities). The hub handles
+ *   lifecycle — dispose() unregisters the client automatically.
  *
  * Options (for testing):
  *   hub               -- override the event hub (defaults to process singleton).
- *   heartbeatIntervalMs -- how often to emit keep-alive comments (default 30 s).
+ *   heartbeatIntervalMs -- how often to emit keep-alive comments (default 7 s).
  */
 export function handleSubscribeAssistantEvents(
   args: RouteHandlerArgs,
@@ -85,7 +74,7 @@ export function handleSubscribeAssistantEvents(
     throw new BadRequestError("conversationKey must not be empty");
   }
 
-  // ── Client registration from headers ──────────────────────────────────
+  // ── Client identity from headers ──────────────────────────────────────
   const rawClientId = headers?.["x-vellum-client-id"];
   const rawInterfaceId = headers?.["x-vellum-interface-id"];
   const clientId = rawClientId?.trim() || null;
@@ -103,32 +92,23 @@ export function handleSubscribeAssistantEvents(
     );
   }
 
-  const registry = getClientRegistry();
-  if (clientId && interfaceId) {
-    registry.register({ clientId, interfaceId });
-    log.info(
-      { clientId, interfaceId },
-      "client registered via /events SSE connect",
-    );
-  }
-
   const hub = options?.hub ?? assistantEventHub;
   const heartbeatIntervalMs =
     options?.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
 
-  const filter: AssistantEventFilter = {
-    assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
-  };
+  const ALL_CAPABILITIES: HostProxyCapability[] = [
+    "host_bash",
+    "host_file",
+    "host_cu",
+    "host_browser",
+  ];
+
+  const filter: AssistantEventFilter = {};
   if (conversationKey) {
-    // Eagerly resolve (and if necessary create) the conversation so the
-    // subscriber's filter matches the id under which first-turn scoped
-    // events will be published. The `conversation_list_invalidated`
-    // publish is driven by `handleSendMessage`'s first-message check,
-    // so eager materialisation here is safe and does not suppress the
-    // cross-client notification.
     const mapping = getOrCreateConversation(conversationKey);
     filter.conversationId = mapping.conversationId;
   }
+
   const encoder = new TextEncoder();
 
   // -- Eager subscribe --------------------------------------------------------
@@ -145,9 +125,6 @@ export function handleSubscribeAssistantEvents(
       clearInterval(heartbeatTimer);
       heartbeatTimer = null;
     }
-    if (clientId) {
-      registry.unregister(clientId);
-    }
     try {
       controllerRef?.close();
     } catch {
@@ -155,85 +132,76 @@ export function handleSubscribeAssistantEvents(
     }
   }
 
+  const callback: AssistantEventCallback = (event) => {
+    const controller = controllerRef;
+    if (!controller) return;
+    try {
+      if (controller.desiredSize != null && controller.desiredSize <= 0) {
+        sub.dispose();
+        cleanup();
+        return;
+      }
+      controller.enqueue(encoder.encode(formatSseFrame(event)));
+    } catch {
+      sub.dispose();
+      cleanup();
+    }
+  };
+
   try {
-    sub = hub.subscribe(
+    const subscriberBase = {
       filter,
-      (event) => {
-        const controller = controllerRef;
-        if (!controller) return;
-        try {
-          // Shed stalled consumers: desiredSize <= 0 means the 16-event buffer
-          // is full and the client isn't draining it.
-          if (controller.desiredSize != null && controller.desiredSize <= 0) {
-            sub.dispose();
-            cleanup();
-            return;
-          }
-          controller.enqueue(encoder.encode(formatSseFrame(event)));
-        } catch {
-          sub.dispose();
-          cleanup();
-        }
-      },
-      {
-        // Called by the hub when a newer connection evicts this one (capacity
-        // management: oldest subscriber out, newest in).
-        onEvict: cleanup,
-      },
-    );
+      callback,
+      onEvict: cleanup,
+    };
+
+    sub =
+      clientId && interfaceId
+        ? hub.subscribe({
+            ...subscriberBase,
+            type: "client" as const,
+            clientId,
+            interfaceId,
+            capabilities: ALL_CAPABILITIES.filter((cap) =>
+              supportsHostProxy(interfaceId, cap),
+            ),
+          })
+        : hub.subscribe({
+            ...subscriberBase,
+            type: "process" as const,
+          });
   } catch (err) {
     if (err instanceof RangeError) {
-      if (clientId) {
-        registry.unregister(clientId);
-      }
       throw new ServiceUnavailableError("Too many concurrent connections");
     }
     throw err;
   }
 
-  // Allow up to 16 queued frames before treating the consumer as stalled.
-  // This absorbs normal token-stream bursts without prematurely closing the
-  // connection, while still shedding genuinely slow clients.
   const stream = new ReadableStream<Uint8Array>(
     {
       start(controller) {
         controllerRef = controller;
 
-        // If the client already disconnected before start() ran, clean up
-        // immediately -- the abort event fires once and won't be re-dispatched.
         if (abortSignal?.aborted) {
           sub.dispose();
           cleanup();
           return;
         }
 
-        // Immediately enqueue a heartbeat comment so the HTTP status line and
-        // headers are flushed to the client without waiting for a real event.
-        // Without this, Bun may buffer the headers until the first data chunk
-        // arrives, causing clients (e.g. Python `requests`) to hang until the
-        // periodic heartbeat fires or an event is published.
         controller.enqueue(encoder.encode(formatSseHeartbeat()));
 
-        // Send a keep-alive comment on each interval to prevent proxies and
-        // load-balancers from treating idle connections as timed out.
         heartbeatTimer = setInterval(() => {
           try {
-            // Apply the same slow-consumer guard as the event path: stop
-            // feeding heartbeats into a queue the client is not draining.
             if (controller.desiredSize != null && controller.desiredSize <= 0) {
               sub.dispose();
               cleanup();
               return;
             }
-            // Touch the client on each heartbeat to keep it fresh in the
-            // registry. Without this, long-idle SSE connections would be
-            // evicted by the staleness sweep despite being connected.
             if (clientId) {
-              registry.touch(clientId);
+              hub.touchClient(clientId);
             }
             controller.enqueue(encoder.encode(formatSseHeartbeat()));
           } catch {
-            // Controller already closed (e.g. client disconnected).
             sub.dispose();
             cleanup();
           }

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

@@ -1,17 +1,27 @@
 /**
  * Route handlers for filing management.
+ *
+ * `available` reflects whether the filing service is the active background
+ * memory job for this instance. When the `memory-v2-enabled` flag is on,
+ * filing yields to the consolidation job (see consolidation-routes.ts) and
+ * returns `available: false` so the UI can hide the row.
  */
 
 import { z } from "zod";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { FilingService } from "../../filing/filing-service.js";
 import { getLogger } from "../../util/logger.js";
-import { InternalError } from "./errors.js";
+import { BadRequestError, InternalError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("filing-routes");
 
+function isFilingAvailable(): boolean {
+  return !isAssistantFeatureFlagEnabled("memory-v2-enabled", getConfig());
+}
+
 // ---------------------------------------------------------------------------
 // Shared ROUTES
 // ---------------------------------------------------------------------------
@@ -27,6 +37,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Return the current filing schedule configuration.",
     tags: ["filing"],
     responseBody: z.object({
+      available: z.boolean(),
       enabled: z.boolean(),
       intervalMs: z.number(),
       activeHoursStart: z.number().nullable(),
@@ -39,6 +50,7 @@ export const ROUTES: RouteDefinition[] = [
       const config = getConfig().filing;
       const svc = FilingService.getInstance();
       return {
+        available: isFilingAvailable(),
         enabled: config.enabled,
         intervalMs: config.intervalMs,
         activeHoursStart: config.activeHoursStart ?? null,
@@ -63,6 +75,11 @@ export const ROUTES: RouteDefinition[] = [
       ran: z.boolean().describe("Whether the filing actually ran"),
     }),
     handler: async (_args: RouteHandlerArgs) => {
+      if (!isFilingAvailable()) {
+        throw new BadRequestError(
+          "Filing is not the active background memory job (memory v2 is enabled)",
+        );
+      }
       const svc = FilingService.getInstance();
       if (!svc) {
         throw new InternalError("Filing service not available");

package/src/runtime/routes/guardian-action-routes.ts

@@ -29,15 +29,11 @@ import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 // GET /v1/guardian-actions/pending?conversationId=...
 // ---------------------------------------------------------------------------
 
-function handleGuardianActionsPending({
-  queryParams = {},
-}: RouteHandlerArgs) {
+function handleGuardianActionsPending({ queryParams = {} }: RouteHandlerArgs) {
   const conversationId = queryParams.conversationId;
 
   if (!conversationId) {
-    throw new BadRequestError(
-      "conversationId query parameter is required",
-    );
+    throw new BadRequestError("conversationId query parameter is required");
   }
 
   const prompts = listGuardianDecisionPrompts({
@@ -51,7 +47,7 @@ function handleGuardianActionsPending({
 // POST /v1/guardian-actions/decision
 // ---------------------------------------------------------------------------
 
-export async function handleGuardianActionDecision({
+async function handleGuardianActionDecision({
   body,
   headers = {},
 }: RouteHandlerArgs) {
@@ -231,8 +227,7 @@ export const ROUTES: RouteDefinition[] = [
     endpoint: "guardian-actions/pending",
     method: "GET",
     summary: "List pending guardian actions",
-    description:
-      "Return pending guardian decision prompts for a conversation.",
+    description: "Return pending guardian decision prompts for a conversation.",
     tags: ["guardian"],
     queryParams: [
       {

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

@@ -6,6 +6,7 @@
  */
 import { z } from "zod";
 
+import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
 import * as pendingInteractions from "../pending-interactions.js";
 import {
   BadRequestError,
@@ -48,9 +49,9 @@ function handleHostBashResult({ body }: RouteHandlerArgs) {
     );
   }
 
-  const interaction = pendingInteractions.resolve(requestId)!;
+  pendingInteractions.resolve(requestId);
 
-  interaction.conversation!.resolveHostBash(requestId, {
+  HostBashProxy.instance.resolve(requestId, {
     stdout: stdout ?? "",
     stderr: stderr ?? "",
     exitCode: exitCode ?? null,

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

@@ -10,8 +10,8 @@ import {
   markTargetInvalidated,
   publishCdpEvent,
 } from "../../browser-session/events.js";
-import * as pendingInteractions from "../pending-interactions.js";
-import { BadRequestError, ConflictError, NotFoundError } from "./errors.js";
+import { HostBrowserProxy } from "../../daemon/host-browser-proxy.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 /**
@@ -29,8 +29,8 @@ export type HostBrowserResultResolution =
   | { ok: true }
   | {
       ok: false;
-      code: "BAD_REQUEST" | "NOT_FOUND" | "CONFLICT";
-      status: 400 | 404 | 409;
+      code: "BAD_REQUEST" | "NOT_FOUND";
+      status: 400 | 404;
       message: string;
     };
 
@@ -61,10 +61,8 @@ export function resolveHostBrowserResultByRequestId(frame: {
     };
   }
 
-  // Peek first (non-destructive) so we can validate the interaction kind
-  // without accidentally consuming a confirmation or secret interaction.
-  const peeked = pendingInteractions.get(requestId);
-  if (!peeked) {
+  const proxy = HostBrowserProxy.instance;
+  if (!proxy.hasPendingRequest(requestId)) {
     return {
       ok: false,
       code: "NOT_FOUND",
@@ -73,32 +71,10 @@ export function resolveHostBrowserResultByRequestId(frame: {
     };
   }
 
-  if (peeked.kind !== "host_browser") {
-    return {
-      ok: false,
-      code: "CONFLICT",
-      status: 409,
-      message: `Pending interaction is of kind "${peeked.kind}", expected "host_browser"`,
-    };
-  }
-
-  // Validation passed — consume the pending interaction.
-  const interaction = pendingInteractions.resolve(requestId)!;
-
   const normalizedContent = typeof content === "string" ? content : "";
   const normalizedIsError = typeof isError === "boolean" ? isError : false;
 
-  if (!interaction.conversation) {
-    return {
-      ok: false,
-      code: "BAD_REQUEST",
-      status: 400,
-      message:
-        "host_browser pending interaction has no associated conversation",
-    };
-  }
-
-  interaction.conversation.resolveHostBrowser(requestId, {
+  proxy.resolve(requestId, {
     content: normalizedContent,
     isError: normalizedIsError,
   });
@@ -203,8 +179,8 @@ function handleHostBrowserResult({ body }: RouteHandlerArgs) {
 
   const resolution = resolveHostBrowserResultByRequestId(body);
   if (!resolution.ok) {
-    if (resolution.code === "NOT_FOUND") throw new NotFoundError(resolution.message);
-    if (resolution.code === "CONFLICT") throw new ConflictError(resolution.message);
+    if (resolution.code === "NOT_FOUND")
+      throw new NotFoundError(resolution.message);
     throw new BadRequestError(resolution.message);
   }
 

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

@@ -6,6 +6,7 @@
  */
 import { z } from "zod";
 
+import { findConversation } from "../../daemon/conversation-store.js";
 import * as pendingInteractions from "../pending-interactions.js";
 import {
   BadRequestError,
@@ -69,8 +70,12 @@ function handleHostCuResult({ body }: RouteHandlerArgs) {
   }
 
   const interaction = pendingInteractions.resolve(requestId)!;
+  const conversation = findConversation(interaction.conversationId);
+  if (!conversation) {
+    throw new NotFoundError("Conversation not found for host CU result");
+  }
 
-  interaction.conversation!.resolveHostCu(requestId, {
+  conversation.hostCuProxy?.resolve(requestId, {
     axTree,
     axDiff,
     screenshot,