@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -214,6 +214,8 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 import { Conversation } from "../daemon/conversation.js";
+import { HostBashProxy } from "../daemon/host-bash-proxy.js";
+import { HostBrowserProxy } from "../daemon/host-browser-proxy.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -558,3 +560,291 @@ describe("sendToClient receives state signals", () => {
     });
   });
 });
+
+describe("restoreBrowserProxyAvailability", () => {
+  test("re-enables only the host browser proxy after clearProxyAvailability", () => {
+    const conversation = makeConversation();
+    const browserProxy = new HostBrowserProxy(() => {});
+    const bashProxy = new HostBashProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+    conversation.setHostBashProxy(bashProxy);
+
+    // Mark as having a connected client (interactive desktop path).
+    conversation.updateClient(() => {}, false);
+    expect(browserProxy.isAvailable()).toBe(true);
+    expect(bashProxy.isAvailable()).toBe(true);
+
+    // The drain queue clears all proxies for non-interactive turns.
+    conversation.clearProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(false);
+    expect(bashProxy.isAvailable()).toBe(false);
+
+    // restoreBrowserProxyAvailability should bring back ONLY the browser proxy.
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+    expect(bashProxy.isAvailable()).toBe(false);
+  });
+
+  test("re-enables the browser proxy even when hasNoClient is true (chrome-extension)", () => {
+    // Regression: chrome-extension is non-interactive (hasNoClient stays
+    // true so host_bash/host_file tools remain gated), but we still need
+    // to provision the hostBrowserProxy so it can service CDP commands.
+    // The helper must NOT gate on hasNoClient.
+    const conversation = makeConversation();
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // updateClient with hasNoClient=true emulates the non-interactive
+    // chrome-extension turn. Host proxies start disabled because
+    // updateClient propagates hasNoClient through to updateSender.
+    conversation.updateClient(() => {}, true);
+    expect(browserProxy.isAvailable()).toBe(false);
+    expect(conversation["hasNoClient"]).toBe(true);
+
+    // The targeted helper bypasses the hasNoClient gate so the
+    // single-capability chrome-extension turn can drive the browser
+    // via CDP without flipping hasNoClient (which would also enable
+    // host_bash/host_file gating downstream).
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+    // hasNoClient itself MUST remain true so that
+    // isToolActiveForContext keeps host_bash/host_file/host_cu gated.
+    expect(conversation["hasNoClient"]).toBe(true);
+  });
+
+  test("leaves bash/file/cu proxies disabled when called for chrome-extension", () => {
+    // Regression: the targeted helper must not accidentally re-enable
+    // proxies other than host_browser, even when called from a path that
+    // owns multiple proxies (e.g. macOS holdover state with hasNoClient
+    // forced true for an explicit non-interactive run).
+    const conversation = makeConversation();
+    const browserProxy = new HostBrowserProxy(() => {});
+    const bashProxy = new HostBashProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+    conversation.setHostBashProxy(bashProxy);
+
+    conversation.updateClient(() => {}, true);
+    expect(browserProxy.isAvailable()).toBe(false);
+    expect(bashProxy.isAvailable()).toBe(false);
+
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+    // Crucial: bash proxy stays disabled. The helper must touch ONLY the
+    // browser proxy.
+    expect(bashProxy.isAvailable()).toBe(false);
+  });
+
+  test("uses hostBrowserSenderOverride when set so drain-queue restores preserve the registry-routed sender", () => {
+    // Regression (PR #24129 cycle 2): the queue-drain path calls
+    // `restoreBrowserProxyAvailability()` on dequeue, which used to pass
+    // `this.sendToClient` (the SSE hub emitter) to the proxy, clobbering the
+    // chrome-extension registry-routed sender established by the POST
+    // /messages handler. The override field lets the HTTP handler pin the
+    // registry-routed sender so the drain path preserves it.
+    const sseHub: ServerMessage[] = [];
+    const registry: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // Simulate updateClient setting sendToClient to the SSE hub and
+    // marking the conversation as client-less (chrome-extension is
+    // non-interactive).
+    conversation.updateClient((msg) => sseHub.push(msg), true);
+    expect(browserProxy.isAvailable()).toBe(false);
+
+    // The HTTP handler stashes the registry-routed sender as the override.
+    const registrySender = (msg: ServerMessage) => registry.push(msg);
+    conversation.hostBrowserSenderOverride = registrySender;
+
+    // Drain-queue path calls restoreBrowserProxyAvailability — it must now
+    // prefer the override over sendToClient.
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+
+    // Send a frame through the proxy and verify it flows through the
+    // registry sender, not the SSE hub.
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-1",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(registry).toHaveLength(1);
+    expect(sseHub.some((m) => m === probe)).toBe(false);
+  });
+
+  test("falls back to sendToClient when hostBrowserSenderOverride is cleared", () => {
+    // When a non-chrome-extension turn takes over, the HTTP handler clears
+    // the override and restoreBrowserProxyAvailability must fall back to
+    // sendToClient (the SSE hub), otherwise macOS turns would route their
+    // host_browser frames through the stale chrome-extension registry.
+    const sseHub: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // First the chrome-extension path pins the override.
+    const registry: ServerMessage[] = [];
+    conversation.hostBrowserSenderOverride = (msg) => registry.push(msg);
+    conversation.updateClient((msg) => sseHub.push(msg), true);
+    conversation.restoreBrowserProxyAvailability();
+
+    // Then a macOS handoff clears the override.
+    conversation.hostBrowserSenderOverride = undefined;
+    conversation.updateClient((msg) => sseHub.push(msg), false);
+    conversation.restoreBrowserProxyAvailability();
+
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-2",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(sseHub).toContain(probe);
+    expect(registry).not.toContain(probe);
+  });
+});
+
+describe("hostBrowserSenderOverride is sender-mode based, not interface-string based", () => {
+  test("macOS turn with registry override routes browser frames through the registry sender", () => {
+    // When a macOS turn sets hostBrowserSenderOverride (because the
+    // guardian has an active extension connection), the browser proxy
+    // must route through the registry sender, not the SSE hub — the
+    // same behavior chrome-extension turns have always used.
+    const sseHub: ServerMessage[] = [];
+    const registry: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // macOS is interactive — hasNoClient is false.
+    conversation.updateClient((msg) => sseHub.push(msg), false);
+
+    // The POST /messages handler detected an active extension connection
+    // and set the registry-routed sender override.
+    const registrySender = (msg: ServerMessage) => registry.push(msg);
+    conversation.hostBrowserSenderOverride = registrySender;
+
+    // restoreBrowserProxyAvailability (called after updateClient in the
+    // POST handler) must prefer the override.
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+
+    // Verify frames flow through the registry, not the SSE hub.
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-macos-registry",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(registry).toHaveLength(1);
+    expect(sseHub.some((m) => m === probe)).toBe(false);
+  });
+
+  test("macOS turn without registry override clears the browser proxy on restore", () => {
+    // When a macOS turn has no active extension connection, the override
+    // is cleared and restoreBrowserProxyAvailability falls back to the
+    // SSE hub sender. The proxy should not be stuck on an unavailable
+    // registry-routed sender from a prior chrome-extension turn.
+    const sseHub: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // Interactive macOS turn without extension connectivity.
+    conversation.updateClient((msg) => sseHub.push(msg), false);
+    conversation.hostBrowserSenderOverride = undefined;
+    conversation.restoreBrowserProxyAvailability();
+
+    // The proxy should be available and routed through SSE.
+    expect(browserProxy.isAvailable()).toBe(true);
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-macos-sse",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(sseHub).toContain(probe);
+  });
+
+  test("override semantics are symmetric: chrome-extension and macOS both set override when registry-routed", () => {
+    // The override field must be set for ANY interface that uses a
+    // registry-routed sender, and cleared for any that does not.
+    // This test verifies the field is not gated on interface strings.
+    const conversation = makeConversation();
+    const registrySender = () => {};
+
+    // Simulate chrome-extension setting the override.
+    conversation.hostBrowserSenderOverride = registrySender;
+    expect(conversation.hostBrowserSenderOverride).toBe(registrySender);
+
+    // Simulate macOS-with-extension setting the same override.
+    // The field value is the same registry sender, not gated by interface.
+    const macosRegistrySender = () => {};
+    conversation.hostBrowserSenderOverride = macosRegistrySender;
+    expect(conversation.hostBrowserSenderOverride).toBe(macosRegistrySender);
+
+    // Simulate macOS-without-extension clearing the override.
+    conversation.hostBrowserSenderOverride = undefined;
+    expect(conversation.hostBrowserSenderOverride).toBeUndefined();
+  });
+
+  test("queue-drain restore path preserves registry-routed sender for macOS turns", () => {
+    // When a macOS turn with an active extension connection has its
+    // messages queued and later drained, the drain-queue path calls
+    // restoreBrowserProxyAvailability(). With the override set, the
+    // proxy must be restored with the registry sender, not the SSE hub.
+    const sseHub: ServerMessage[] = [];
+    const registry: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // macOS interactive turn with extension connectivity.
+    conversation.updateClient((msg) => sseHub.push(msg), false);
+    const registrySender = (msg: ServerMessage) => registry.push(msg);
+    conversation.hostBrowserSenderOverride = registrySender;
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+
+    // Simulate drain-queue clearing all proxies for a non-interactive
+    // queued message, then restoring for the next macOS turn.
+    conversation.clearProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(false);
+
+    // Drain restore — override is still set from the POST handler.
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+
+    // Verify the registry sender was preserved, not the SSE hub.
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-drain-macos",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(registry).toHaveLength(1);
+    expect(sseHub.some((m) => m === probe)).toBe(false);
+  });
+});

package/src/__tests__/conversation-error.test.ts

@@ -6,6 +6,10 @@ import {
   classifyConversationError,
   isUserCancellation,
 } from "../daemon/conversation-error.js";
+import {
+  type AbortReasonKind,
+  createAbortReason,
+} from "../util/abort-reasons.js";
 import { ProviderError, ProviderNotConfiguredError } from "../util/errors.js";
 
 describe("isUserCancellation", () => {
@@ -563,6 +567,72 @@ describe("classifyConversationError", () => {
       expect(isUserCancellation(err, aborted)).toBe(true);
     });
   });
+
+  describe("wrapped ProviderError carrying tagged abort reason", () => {
+    const abortedCtx: ErrorContext = { phase: "agent_loop", aborted: true };
+    const taggedKinds: AbortReasonKind[] = [
+      "user_cancel",
+      "preempted_by_new_message",
+      "conversation_disposed",
+      "subagent_aborted",
+      "signal_cancel",
+      "voice_session_aborted",
+      "work_item_aborted",
+    ];
+
+    for (const kind of taggedKinds) {
+      it(`treats ProviderError with abortReason kind="${kind}" as user cancellation`, () => {
+        const wrapped = new ProviderError(
+          "Anthropic API error (undefined): Request was aborted.",
+          "anthropic",
+          undefined,
+          { abortReason: createAbortReason(kind, `test:${kind}`) },
+        );
+        expect(isUserCancellation(wrapped, abortedCtx)).toBe(true);
+      });
+    }
+
+    it("does NOT treat tagged ProviderError as cancellation when ctx.aborted is false", () => {
+      const wrapped = new ProviderError(
+        "Anthropic API error (undefined): Request was aborted.",
+        "anthropic",
+        undefined,
+        { abortReason: createAbortReason("user_cancel", "test") },
+      );
+      const notAborted: ErrorContext = { phase: "agent_loop", aborted: false };
+      expect(isUserCancellation(wrapped, notAborted)).toBe(false);
+    });
+
+    it("does NOT treat ProviderError without abortReason as cancellation", () => {
+      const wrapped = new ProviderError(
+        "Anthropic API error (undefined): Request was aborted.",
+        "anthropic",
+        undefined,
+      );
+      expect(isUserCancellation(wrapped, abortedCtx)).toBe(false);
+    });
+
+    it("does NOT treat ProviderError with foreign reason as cancellation", () => {
+      const wrapped = new ProviderError(
+        "Anthropic API error (undefined): Request was aborted.",
+        "anthropic",
+        undefined,
+        { abortReason: { kind: "user_cancel", source: "spoofed" } },
+      );
+      expect(isUserCancellation(wrapped, abortedCtx)).toBe(false);
+    });
+
+    it("falls through to CONVERSATION_ABORTED when wrapped ProviderError has no tagged reason", () => {
+      const wrapped = new ProviderError(
+        "Anthropic API error (undefined): Request was aborted.",
+        "anthropic",
+        undefined,
+      );
+      const result = classifyConversationError(wrapped, abortedCtx);
+      expect(result.code).toBe("CONVERSATION_ABORTED");
+      expect(result.errorCategory).toBe("session_aborted");
+    });
+  });
 });
 
 describe("buildConversationErrorMessage", () => {

package/src/__tests__/conversation-fork-crud.test.ts

@@ -35,6 +35,7 @@ import {
   addMessage,
   createConversation,
   forkConversation,
+  getConversationHostAccess,
   getMessages,
   PRIVATE_CONVERSATION_FORK_ERROR,
 } from "../memory/conversation-crud.js";
@@ -138,6 +139,22 @@ describe("forkConversation", () => {
     ).toBe(true);
   });
 
+  test("forked conversations start with host access disabled", async () => {
+    const source = createConversation({
+      title: "Computer-enabled thread",
+      hostAccess: true,
+    });
+    await addMessage(source.id, "user", "Use the computer", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(getConversationHostAccess(source.id)).toBe(true);
+    expect(getConversationHostAccess(fork.id)).toBe(false);
+    expect(fork.hostAccess).toBe(0);
+  });
+
   test("preserves source order when source messages share a timestamp", () => {
     const source = createConversation("Equal timestamp thread");
     const db = getDb();

package/src/__tests__/conversation-history-web-search.test.ts

@@ -747,15 +747,23 @@ describe("web_search_tool_result structural guard", () => {
     // web_search_tool_result has a structurally different content format
     // (array of web_search_result objects) and is not truncated this way.
     "context/tool-result-truncation.ts",
+    "context/post-turn-tool-result-truncation.ts",
 
     // Anthropic provider type guards define API-specific discriminants.
     // It has a separate isWebSearchToolResultBlock for the other type.
     "providers/anthropic/client.ts",
 
-    // OpenAI provider converts Anthropic-style messages to OpenAI format.
-    // OpenAI API does not support web_search_tool_result natively; those
-    // blocks are handled upstream before reaching the OpenAI client.
-    "providers/openai/client.ts",
+    // Chat-completions transport used by OpenAI-compatible providers
+    // (OpenRouter, Fireworks, Ollama). These APIs do not support
+    // web_search_tool_result natively; those blocks are handled upstream
+    // before reaching the chat-completions provider.
+    "providers/openai/chat-completions-provider.ts",
+
+    // OpenAI Responses API transport (used for direct OpenAI inference).
+    // Converts Anthropic-style messages to Responses API input format.
+    // web_search_tool_result blocks are handled upstream before reaching
+    // the responses provider.
+    "providers/openai/responses-provider.ts",
 
     // Renders tool_result blocks for client display. web_search_tool_result
     // blocks are rendered by the client via their own display path.

package/src/__tests__/conversation-host-access-routes.test.ts

@@ -0,0 +1,229 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+let authDisabled = true;
+let boundGuardianPrincipalId: string | null = null;
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => authDisabled,
+  hasUngatedHttpAuthDisabled: () => false,
+  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
+  getGatewayPort: () => 7830,
+  getRuntimeHttpPort: () => 7821,
+  getRuntimeHttpHost: () => "127.0.0.1",
+  getRuntimeGatewayOriginSecret: () => undefined,
+  getIngressPublicBaseUrl: () => undefined,
+  setIngressPublicBaseUrl: () => {},
+}));
+
+mock.module("../contacts/contact-store.js", () => ({
+  findGuardianForChannel: () =>
+    boundGuardianPrincipalId
+      ? {
+          channel: { externalUserId: undefined },
+          contact: { principalId: boundGuardianPrincipalId },
+        }
+      : null,
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import {
+  createConversation,
+  updateConversationHostAccess,
+} from "../memory/conversation-crud.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { conversationManagementRouteDefinitions } from "../runtime/routes/conversation-management-routes.js";
+
+initializeDb();
+
+const routes = conversationManagementRouteDefinitions({
+  switchConversation: async (conversationId) => {
+    const conversation = {
+      conversationId,
+      title: "Switched conversation",
+      conversationType: "standard",
+      hostAccess: false,
+    };
+    return conversation;
+  },
+  renameConversation: () => true,
+  clearAllConversations: () => 0,
+  cancelGeneration: () => true,
+  destroyConversation: () => {},
+  undoLastMessage: async () => null,
+  regenerateResponse: async () => null,
+});
+
+function findRoute(method: string, endpoint: string) {
+  const route = routes.find(
+    (routeDef) => routeDef.method === method && routeDef.endpoint === endpoint,
+  );
+  if (!route) {
+    throw new Error(`Route not found: ${method} ${endpoint}`);
+  }
+  return route;
+}
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM conversation_assistant_attention_state");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+describe("conversation host-access transport", () => {
+  let server: RuntimeHttpServer | null = null;
+
+  beforeEach(async () => {
+    await server?.stop();
+    server = null;
+    authDisabled = true;
+    boundGuardianPrincipalId = null;
+    clearTables();
+  });
+
+  afterAll(async () => {
+    await server?.stop();
+    resetDb();
+    mock.restore();
+  });
+
+  test("GET and PATCH /v1/conversations/:id/host-access use the conversation store", async () => {
+    const conversation = createConversation("Host access test");
+
+    const getRoute = findRoute("GET", "conversations/:id/host-access");
+    const getResponse = await getRoute.handler({
+      req: new Request("http://localhost/v1/conversations/test/host-access"),
+      url: new URL("http://localhost/v1/conversations/test/host-access"),
+      server: null as never,
+      authContext: {} as never,
+      params: { id: conversation.id },
+    });
+
+    expect(getResponse.status).toBe(200);
+    expect(await getResponse.json()).toEqual({
+      conversationId: conversation.id,
+      hostAccess: false,
+    });
+
+    const received: Array<{
+      assistantId: string;
+      type: string;
+      conversationId?: string;
+      hostAccess?: boolean;
+    }> = [];
+    const subscription = assistantEventHub.subscribe(
+      { assistantId: DAEMON_INTERNAL_ASSISTANT_ID },
+      (event) => {
+        received.push({
+          assistantId: event.assistantId,
+          type: event.message.type,
+          conversationId: event.conversationId,
+          hostAccess:
+            event.message.type === "conversation_host_access_updated"
+              ? event.message.hostAccess
+              : undefined,
+        });
+      },
+    );
+
+    const patchRoute = findRoute("PATCH", "conversations/:id/host-access");
+    const patchResponse = await patchRoute.handler({
+      req: new Request("http://localhost/v1/conversations/test/host-access", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ hostAccess: true }),
+      }),
+      url: new URL("http://localhost/v1/conversations/test/host-access"),
+      server: null as never,
+      authContext: {} as never,
+      params: { id: conversation.id },
+    });
+
+    await Promise.resolve();
+
+    expect(patchResponse.status).toBe(200);
+    expect(await patchResponse.json()).toEqual({
+      conversationId: conversation.id,
+      hostAccess: true,
+    });
+    expect(received).toHaveLength(1);
+    expect(received[0]).toEqual({
+      assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
+      type: "conversation_host_access_updated",
+      conversationId: conversation.id,
+      hostAccess: true,
+    });
+    subscription.dispose();
+  });
+
+  test("conversation summaries include hostAccess", async () => {
+    const conversation = createConversation("Summary host access");
+    updateConversationHostAccess(conversation.id, true);
+
+    server = new RuntimeHttpServer({
+      port: 0,
+      bearerToken: "test-bearer-token",
+    });
+    await server.start();
+
+    const response = await fetch(
+      `http://127.0.0.1:${server.actualPort}/v1/conversations/${conversation.id}`,
+    );
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      conversation: {
+        id: string;
+        hostAccess: boolean;
+      };
+    };
+
+    expect(body.conversation.id).toBe(conversation.id);
+    expect(body.conversation.hostAccess).toBe(true);
+  });
+
+  test("PATCH /v1/conversations/:id/host-access rejects non-guardian actors when auth is enforced", async () => {
+    authDisabled = false;
+    boundGuardianPrincipalId = "guardian-principal";
+    const conversation = createConversation("Guarded host access");
+
+    const patchRoute = findRoute("PATCH", "conversations/:id/host-access");
+    const patchResponse = await patchRoute.handler({
+      req: new Request("http://localhost/v1/conversations/test/host-access", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ hostAccess: true }),
+      }),
+      url: new URL("http://localhost/v1/conversations/test/host-access"),
+      server: null as never,
+      authContext: {
+        actorPrincipalId: "trusted-contact-principal",
+      } as never,
+      params: { id: conversation.id },
+    });
+
+    expect(patchResponse.status).toBe(403);
+  });
+});