@vellumai/assistant 0.4.16 → 0.4.17

package/src/__tests__/daemon-server-session-init.test.ts

@@ -1,8 +1,10 @@
-import type * as net from 'node:net';
+import type * as net from "node:net";
 
-import { beforeEach, describe, expect, mock, test } from 'bun:test';
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import * as pendingInteractions from '../runtime/pending-interactions.js';
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 
 interface MockMemoryPolicy {
   scopeId: string;
@@ -11,20 +13,20 @@ interface MockMemoryPolicy {
 }
 
 const MOCK_DEFAULT_MEMORY_POLICY: MockMemoryPolicy = {
-  scopeId: 'default',
+  scopeId: "default",
   includeDefaultFallback: false,
   strictSideEffects: false,
 };
 
 const conversation = {
-  id: 'conv-1',
-  title: 'Test Conversation',
+  id: "conv-1",
+  title: "Test Conversation",
   updatedAt: Date.now(),
   totalInputTokens: 0,
   totalOutputTokens: 0,
   totalEstimatedCost: 0,
-  threadType: 'standard' as string,
-  memoryScopeId: 'default' as string,
+  threadType: "standard" as string,
+  memoryScopeId: "default" as string,
 };
 
 let lastCreatedWorkingDir: string | undefined;
@@ -44,8 +46,12 @@ class MockSession {
   public updateClientCalls = 0;
   public ensureActorScopedHistoryCalls = 0;
   public lastUpdateClientHasNoClient: boolean | undefined;
-  public lastUpdateClientSender: ((msg: Record<string, unknown>) => void) | undefined;
-  public lastRunAgentLoopOptions: { skipPreMessageRollback?: boolean; isInteractive?: boolean } | undefined;
+  public lastUpdateClientSender:
+    | ((msg: Record<string, unknown>) => void)
+    | undefined;
+  public lastRunAgentLoopOptions:
+    | { skipPreMessageRollback?: boolean; isInteractive?: boolean }
+    | undefined;
   public updateClientHistory: Array<{ hasNoClient: boolean }> = [];
   public setSandboxOverrideCalls = 0;
   private stale = false;
@@ -75,7 +81,10 @@ class MockSession {
     this.ensureActorScopedHistoryCalls += 1;
   }
 
-  updateClient(sender?: (msg: Record<string, unknown>) => void, hasNoClient = false): void {
+  updateClient(
+    sender?: (msg: Record<string, unknown>) => void,
+    hasNoClient = false,
+  ): void {
     this.updateClientCalls += 1;
     this.lastUpdateClientSender = sender;
     this.lastUpdateClientHasNoClient = hasNoClient;
@@ -141,7 +150,7 @@ class MockSession {
 
   persistUserMessage(): string {
     this.processing = true;
-    return 'msg-1';
+    return "msg-1";
   }
 
   async runAgentLoop(
@@ -173,48 +182,49 @@ class MockSession {
 
 // Mock child_process to prevent getScreenDimensions() from running osascript on Linux CI
 // where AppKit/NSScreen is not available and the execSync call would fail.
-mock.module('node:child_process', () => ({
-  execSync: () => '1920x1080',
-  execFileSync: () => '',
+mock.module("node:child_process", () => ({
+  execSync: () => "1920x1080",
+  execFileSync: () => "",
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
-mock.module('../util/platform.js', () => ({
-  getSocketPath: () => '/tmp/test.sock',
-  getDataDir: () => '/tmp',
-  getSandboxWorkingDir: () => '/tmp/workspace',
+mock.module("../util/platform.js", () => ({
+  getSocketPath: () => "/tmp/test.sock",
+  getDataDir: () => "/tmp",
+  getSandboxWorkingDir: () => "/tmp/workspace",
 }));
 
-mock.module('../providers/registry.js', () => ({
-  getProvider: () => ({ name: 'mock-provider' }),
-  getFailoverProvider: () => ({ name: 'mock-provider' }),
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  getFailoverProvider: () => ({ name: "mock-provider" }),
   initializeProviders: () => {},
 }));
 
-mock.module('../providers/ratelimit.js', () => ({
+mock.module("../providers/ratelimit.js", () => ({
   RateLimitProvider: class {
     constructor(..._args: unknown[]) {}
   },
 }));
 
-mock.module('../config/loader.js', () => ({
+mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
-    provider: 'mock-provider',
-    providerOrder: ['mock-provider'],
+
+    provider: "mock-provider",
+    providerOrder: ["mock-provider"],
     maxTokens: 4096,
     thinking: false,
     contextWindow: {
       maxInputTokens: 100000,
       thresholdTokens: 80000,
       preserveRecentMessages: 6,
-      summaryModel: 'mock-model',
+      summaryModel: "mock-model",
       maxSummaryTokens: 512,
     },
     rateLimit: {
@@ -230,68 +240,82 @@ mock.module('../config/loader.js', () => ({
   invalidateConfigCache: () => {},
 }));
 
-mock.module('../config/system-prompt.js', () => ({
-  buildSystemPrompt: () => 'system prompt',
+mock.module("../config/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
 }));
 
-mock.module('../permissions/trust-store.js', () => ({
+mock.module("../permissions/trust-store.js", () => ({
   clearCache: () => {},
 }));
 
-mock.module('../security/secret-allowlist.js', () => ({
+mock.module("../security/secret-allowlist.js", () => ({
   resetAllowlist: () => {},
 }));
 
-mock.module('../memory/external-conversation-store.js', () => ({
+mock.module("../memory/external-conversation-store.js", () => ({
   getBindingsForConversations: () => new Map(),
 }));
 
-mock.module('../memory/conversation-attention-store.js', () => ({
+mock.module("../memory/conversation-attention-store.js", () => ({
   getAttentionStateByConversationIds: () => new Map(),
   recordAttentionSignal: () => {},
   recordConversationSeenSignal: () => {},
 }));
 
-mock.module('../memory/canonical-guardian-store.js', () => ({
-  generateCanonicalRequestCode: () => 'mock-code-0000',
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  generateCanonicalRequestCode: () => "mock-code-0000",
   createCanonicalGuardianRequest: (params: Record<string, unknown>) => {
     lastCanonicalGuardianCreateParams = params;
-    return { requestCode: 'mock-code-0000', status: 'pending' };
+    return { requestCode: "mock-code-0000", status: "pending" };
   },
-  submitCanonicalRequest: () => ({ requestCode: 'mock-code-0000', status: 'pending' }),
+  submitCanonicalRequest: () => ({
+    requestCode: "mock-code-0000",
+    status: "pending",
+  }),
   getCanonicalRequest: () => null,
   resolveCanonicalRequest: () => false,
   listPendingCanonicalRequests: () => [],
 }));
 
-mock.module('../memory/conversation-store.js', () => ({
+mock.module("../memory/conversation-store.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
   updateConversationTitle: () => {},
   updateConversationUsage: () => {},
-  addMessage: () => ({ id: 'mock-msg-id' }),
-  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  addMessage: () => ({ id: "mock-msg-id" }),
+  provenanceFromGuardianContext: () => ({
+    source: "user",
+    guardianContext: undefined,
+  }),
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
   getLatestConversation: () => conversation,
-  createConversation: (titleOrOpts?: string | { title?: string; threadType?: string }) => {
+  createConversation: (
+    titleOrOpts?: string | { title?: string; threadType?: string },
+  ) => {
     lastCreateConversationArgs = titleOrOpts;
     // Derive threadType and memoryScopeId from input, mirroring real implementation
-    const opts = typeof titleOrOpts === 'string' ? { title: titleOrOpts } : (titleOrOpts ?? {});
-    const threadType = opts.threadType ?? 'standard';
+    const opts =
+      typeof titleOrOpts === "string"
+        ? { title: titleOrOpts }
+        : (titleOrOpts ?? {});
+    const threadType = opts.threadType ?? "standard";
     conversation.threadType = threadType;
-    conversation.memoryScopeId = threadType === 'private' ? `private:${conversation.id}` : 'default';
+    conversation.memoryScopeId =
+      threadType === "private" ? `private:${conversation.id}` : "default";
     return conversation;
   },
-  getConversation: (id: string) => (id === conversation.id ? conversation : null),
+  getConversation: (id: string) =>
+    id === conversation.id ? conversation : null,
   getConversationThreadType: (id: string) => {
-    if (id === conversation.id) return conversation.threadType === 'private' ? 'private' : 'standard';
-    return 'standard';
+    if (id === conversation.id)
+      return conversation.threadType === "private" ? "private" : "standard";
+    return "standard";
   },
   getConversationMemoryScopeId: (id: string) => {
     if (id === conversation.id) return conversation.memoryScopeId;
-    return 'default';
+    return "default";
   },
   getMessages: () => [],
   listConversations: () => [conversation],
@@ -299,25 +323,33 @@ mock.module('../memory/conversation-store.js', () => ({
   getDisplayMetaForConversations: () => new Map(),
 }));
 
-mock.module('../runtime/confirmation-request-guardian-bridge.js', () => ({
-  bridgeConfirmationRequestToGuardian: () => ({ skipped: true, reason: 'not_trusted_contact' }),
+mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
+  bridgeConfirmationRequestToGuardian: () => ({
+    skipped: true,
+    reason: "not_trusted_contact",
+  }),
 }));
 
-mock.module('../daemon/session.js', () => ({
+mock.module("../daemon/session.js", () => ({
   Session: MockSession,
   DEFAULT_MEMORY_POLICY: MOCK_DEFAULT_MEMORY_POLICY,
 }));
 
-import { DaemonServer } from '../daemon/server.js';
+import { DaemonServer } from "../daemon/server.js";
 
 type DaemonServerTestAccess = {
   sendInitialSession: (socket: net.Socket) => Promise<void>;
-  dispatchMessage: (msg: { type: string; [key: string]: unknown }, socket: net.Socket) => void;
+  dispatchMessage: (
+    msg: { type: string; [key: string]: unknown },
+    socket: net.Socket,
+  ) => void;
   sessions: Map<string, MockSession>;
   socketToSession: Map<net.Socket, string>;
 };
 
-function asDaemonServerTestAccess(server: DaemonServer): DaemonServerTestAccess {
+function asDaemonServerTestAccess(
+  server: DaemonServer,
+): DaemonServerTestAccess {
   return server as unknown as DaemonServerTestAccess;
 }
 
@@ -337,16 +369,16 @@ function createFakeSocket() {
 
 function decodeMessages(writes: string[]): Array<Record<string, unknown>> {
   return writes
-    .flatMap((chunk) => chunk.split('\n'))
+    .flatMap((chunk) => chunk.split("\n"))
     .filter((line) => line.length > 0)
     .map((line) => JSON.parse(line) as Record<string, unknown>);
 }
 
-describe('DaemonServer initial session hydration', () => {
+describe("DaemonServer initial session hydration", () => {
   beforeEach(() => {
     conversation.updatedAt = Date.now();
-    conversation.threadType = 'standard';
-    conversation.memoryScopeId = 'default';
+    conversation.threadType = "standard";
+    conversation.memoryScopeId = "default";
     lastCreatedWorkingDir = undefined;
     lastCreatedMemoryPolicy = undefined;
     lastCreateConversationArgs = undefined;
@@ -356,25 +388,28 @@ describe('DaemonServer initial session hydration', () => {
     pendingInteractions.clear();
   });
 
-  test('hydrates latest session before session_info so undo works after reconnect', async () => {
+  test("hydrates latest session before session_info so undo works after reconnect", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket, writes } = createFakeSocket();
 
     await internal.sendInitialSession(socket);
-    internal.dispatchMessage({ type: 'undo', sessionId: conversation.id }, socket);
+    internal.dispatchMessage(
+      { type: "undo", sessionId: conversation.id },
+      socket,
+    );
 
     const messages = decodeMessages(writes);
-    const sessionInfo = messages.find((msg) => msg.type === 'session_info');
-    const undoComplete = messages.find((msg) => msg.type === 'undo_complete');
-    const error = messages.find((msg) => msg.type === 'error');
+    const sessionInfo = messages.find((msg) => msg.type === "session_info");
+    const undoComplete = messages.find((msg) => msg.type === "undo_complete");
+    const error = messages.find((msg) => msg.type === "error");
 
     expect(sessionInfo).toBeDefined();
     expect(undoComplete).toBeDefined();
     expect(error).toBeUndefined();
   });
 
-  test('does not rebind existing session client during initial handshake', async () => {
+  test("does not rebind existing session client during initial handshake", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const existingSession = new MockSession(conversation.id);
@@ -387,17 +422,17 @@ describe('DaemonServer initial session hydration', () => {
     expect(internal.socketToSession.size).toBe(0);
   });
 
-  test('creates sessions with sandbox working dir by default', async () => {
+  test("creates sessions with sandbox working dir by default", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket } = createFakeSocket();
 
     await internal.sendInitialSession(socket);
 
-    expect(lastCreatedWorkingDir).toBe('/tmp/workspace');
+    expect(lastCreatedWorkingDir).toBe("/tmp/workspace");
   });
 
-  test('ignores deprecated sandbox_set runtime override messages', async () => {
+  test("ignores deprecated sandbox_set runtime override messages", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket } = createFakeSocket();
@@ -407,13 +442,13 @@ describe('DaemonServer initial session hydration', () => {
     expect(session).toBeDefined();
     expect(session!.setSandboxOverrideCalls).toBe(0);
 
-    internal.dispatchMessage({ type: 'sandbox_set', enabled: false }, socket);
+    internal.dispatchMessage({ type: "sandbox_set", enabled: false }, socket);
 
     expect(session!.setSandboxOverrideCalls).toBe(0);
   });
 
-  test('sendInitialSession includes threadType in session_info', async () => {
-    conversation.threadType = 'private';
+  test("sendInitialSession includes threadType in session_info", async () => {
+    conversation.threadType = "private";
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket, writes } = createFakeSocket();
@@ -421,13 +456,13 @@ describe('DaemonServer initial session hydration', () => {
     await internal.sendInitialSession(socket);
 
     const messages = decodeMessages(writes);
-    const sessionInfo = messages.find((msg) => msg.type === 'session_info');
+    const sessionInfo = messages.find((msg) => msg.type === "session_info");
     expect(sessionInfo).toBeDefined();
-    expect(sessionInfo!.threadType).toBe('private');
+    expect(sessionInfo!.threadType).toBe("private");
   });
 
-  test('sendInitialSession includes standard threadType by default', async () => {
-    conversation.threadType = 'standard';
+  test("sendInitialSession includes standard threadType by default", async () => {
+    conversation.threadType = "standard";
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket, writes } = createFakeSocket();
@@ -435,13 +470,13 @@ describe('DaemonServer initial session hydration', () => {
     await internal.sendInitialSession(socket);
 
     const messages = decodeMessages(writes);
-    const sessionInfo = messages.find((msg) => msg.type === 'session_info');
+    const sessionInfo = messages.find((msg) => msg.type === "session_info");
     expect(sessionInfo).toBeDefined();
-    expect(sessionInfo!.threadType).toBe('standard');
+    expect(sessionInfo!.threadType).toBe("standard");
   });
 
-  test('session_switch includes threadType in session_info', async () => {
-    conversation.threadType = 'private';
+  test("session_switch includes threadType in session_info", async () => {
+    conversation.threadType = "private";
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket, writes } = createFakeSocket();
@@ -450,65 +485,73 @@ describe('DaemonServer initial session hydration', () => {
     await internal.sendInitialSession(socket);
     writes.length = 0;
 
-    internal.dispatchMessage({ type: 'session_switch', sessionId: conversation.id }, socket);
+    internal.dispatchMessage(
+      { type: "session_switch", sessionId: conversation.id },
+      socket,
+    );
     // Allow async handler to complete
     await new Promise((r) => setTimeout(r, 50));
 
     const messages = decodeMessages(writes);
-    const sessionInfo = messages.find((msg) => msg.type === 'session_info');
+    const sessionInfo = messages.find((msg) => msg.type === "session_info");
     expect(sessionInfo).toBeDefined();
-    expect(sessionInfo!.threadType).toBe('private');
+    expect(sessionInfo!.threadType).toBe("private");
   });
 
-  test('session_create includes threadType in session_info response', async () => {
+  test("session_create includes threadType in session_info response", async () => {
     // conversation.threadType starts as 'standard' from beforeEach — the mock
     // createConversation must derive 'private' from the IPC request input.
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket, writes } = createFakeSocket();
 
-    internal.dispatchMessage({
-      type: 'session_create',
-      title: 'Thread-type test',
-      threadType: 'private',
-    }, socket);
+    internal.dispatchMessage(
+      {
+        type: "session_create",
+        title: "Thread-type test",
+        threadType: "private",
+      },
+      socket,
+    );
     // Allow async handler to complete
     await new Promise((r) => setTimeout(r, 50));
 
     // Verify createConversation was called with the threadType from the request
     expect(lastCreateConversationArgs).toEqual({
-      title: 'Thread-type test',
-      threadType: 'private',
+      title: "Thread-type test",
+      threadType: "private",
     });
 
     const messages = decodeMessages(writes);
-    const sessionInfo = messages.find((msg) => msg.type === 'session_info');
+    const sessionInfo = messages.find((msg) => msg.type === "session_info");
     expect(sessionInfo).toBeDefined();
-    expect(sessionInfo!.threadType).toBe('private');
+    expect(sessionInfo!.threadType).toBe("private");
   });
 
-  test('session_list includes threadType on each session row', async () => {
-    conversation.threadType = 'private';
+  test("session_list includes threadType on each session row", async () => {
+    conversation.threadType = "private";
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket, writes } = createFakeSocket();
 
-    internal.dispatchMessage({ type: 'session_list' }, socket);
+    internal.dispatchMessage({ type: "session_list" }, socket);
 
     const messages = decodeMessages(writes);
-    const listResponse = messages.find((msg) => msg.type === 'session_list_response');
+    const listResponse = messages.find(
+      (msg) => msg.type === "session_list_response",
+    );
     expect(listResponse).toBeDefined();
 
     const sessions = listResponse!.sessions as Array<Record<string, unknown>>;
     expect(sessions.length).toBeGreaterThan(0);
     for (const session of sessions) {
-      expect(session.threadType).toBe('private');
+      expect(session.threadType).toBe("private");
     }
   });
 
-  test('session for private conversation derives strict memory policy', async () => {
-    conversation.threadType = 'private';
-    conversation.memoryScopeId = 'private:conv-1';
+  test("session for private conversation derives strict memory policy", async () => {
+    conversation.threadType = "private";
+    conversation.memoryScopeId = "private:conv-1";
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket } = createFakeSocket();
@@ -518,15 +561,15 @@ describe('DaemonServer initial session hydration', () => {
     const session = internal.sessions.get(conversation.id);
     expect(session).toBeDefined();
     expect(session!.memoryPolicy).toEqual({
-      scopeId: 'private:conv-1',
+      scopeId: "private:conv-1",
       includeDefaultFallback: true,
       strictSideEffects: true,
     });
   });
 
-  test('session for standard conversation uses default memory policy', async () => {
-    conversation.threadType = 'standard';
-    conversation.memoryScopeId = 'default';
+  test("session for standard conversation uses default memory policy", async () => {
+    conversation.threadType = "standard";
+    conversation.memoryScopeId = "default";
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket } = createFakeSocket();
@@ -538,10 +581,10 @@ describe('DaemonServer initial session hydration', () => {
     expect(session!.memoryPolicy).toEqual(MOCK_DEFAULT_MEMORY_POLICY);
   });
 
-  test('session_switch to private conversation derives correct policy on fresh session', async () => {
+  test("session_switch to private conversation derives correct policy on fresh session", async () => {
     // Start with standard conversation
-    conversation.threadType = 'standard';
-    conversation.memoryScopeId = 'default';
+    conversation.threadType = "standard";
+    conversation.memoryScopeId = "default";
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket } = createFakeSocket();
@@ -549,8 +592,8 @@ describe('DaemonServer initial session hydration', () => {
     await internal.sendInitialSession(socket);
 
     // Now switch the conversation metadata to private before the switch
-    conversation.threadType = 'private';
-    conversation.memoryScopeId = 'private:conv-1';
+    conversation.threadType = "private";
+    conversation.memoryScopeId = "private:conv-1";
 
     // Evict the existing session so the switch recreates it
     const existingSession = internal.sessions.get(conversation.id);
@@ -558,116 +601,134 @@ describe('DaemonServer initial session hydration', () => {
       existingSession.markStale();
     }
 
-    internal.dispatchMessage({ type: 'session_switch', sessionId: conversation.id }, socket);
+    internal.dispatchMessage(
+      { type: "session_switch", sessionId: conversation.id },
+      socket,
+    );
     await new Promise((r) => setTimeout(r, 50));
 
     // The recreated session should have the private policy
     expect(lastCreatedMemoryPolicy).toEqual({
-      scopeId: 'private:conv-1',
+      scopeId: "private:conv-1",
       includeDefaultFallback: true,
       strictSideEffects: true,
     });
   });
 
-  test('session_create normalizes unrecognized threadType to standard', async () => {
+  test("session_create normalizes unrecognized threadType to standard", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket, writes } = createFakeSocket();
 
-    internal.dispatchMessage({
-      type: 'session_create',
-      title: 'Bad threadType',
-      threadType: 'bogus' as unknown,
-    }, socket);
+    internal.dispatchMessage(
+      {
+        type: "session_create",
+        title: "Bad threadType",
+        threadType: "bogus" as unknown,
+      },
+      socket,
+    );
     await new Promise((r) => setTimeout(r, 50));
 
     // Should normalize to 'standard'
     expect(lastCreateConversationArgs).toEqual({
-      title: 'Bad threadType',
-      threadType: 'standard',
+      title: "Bad threadType",
+      threadType: "standard",
     });
 
     const messages = decodeMessages(writes);
-    const sessionInfo = messages.find((msg) => msg.type === 'session_info');
+    const sessionInfo = messages.find((msg) => msg.type === "session_info");
     expect(sessionInfo).toBeDefined();
-    expect(sessionInfo!.threadType).toBe('standard');
+    expect(sessionInfo!.threadType).toBe("standard");
   });
 
-  test('session_create defaults missing threadType to standard', async () => {
+  test("session_create defaults missing threadType to standard", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket, writes } = createFakeSocket();
 
-    internal.dispatchMessage({
-      type: 'session_create',
-      title: 'No threadType',
-    }, socket);
+    internal.dispatchMessage(
+      {
+        type: "session_create",
+        title: "No threadType",
+      },
+      socket,
+    );
     await new Promise((r) => setTimeout(r, 50));
 
     expect(lastCreateConversationArgs).toEqual({
-      title: 'No threadType',
-      threadType: 'standard',
+      title: "No threadType",
+      threadType: "standard",
     });
 
     const messages = decodeMessages(writes);
-    const sessionInfo = messages.find((msg) => msg.type === 'session_info');
+    const sessionInfo = messages.find((msg) => msg.type === "session_info");
     expect(sessionInfo).toBeDefined();
-    expect(sessionInfo!.threadType).toBe('standard');
+    expect(sessionInfo!.threadType).toBe("standard");
   });
 
-  test('session_create with private threadType derives correct policy', async () => {
+  test("session_create with private threadType derives correct policy", async () => {
     // conversation starts as 'standard' from beforeEach — the mock
     // createConversation must derive private state from the IPC request.
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
     const { socket } = createFakeSocket();
 
-    internal.dispatchMessage({
-      type: 'session_create',
-      title: 'Private Thread',
-      threadType: 'private',
-    }, socket);
+    internal.dispatchMessage(
+      {
+        type: "session_create",
+        title: "Private Thread",
+        threadType: "private",
+      },
+      socket,
+    );
     await new Promise((r) => setTimeout(r, 50));
 
     // Verify createConversation received the threadType
     expect(lastCreateConversationArgs).toEqual({
-      title: 'Private Thread',
-      threadType: 'private',
+      title: "Private Thread",
+      threadType: "private",
     });
 
     const session = internal.sessions.get(conversation.id);
     expect(session).toBeDefined();
     expect(session!.memoryPolicy).toEqual({
-      scopeId: 'private:conv-1',
+      scopeId: "private:conv-1",
       includeDefaultFallback: true,
       strictSideEffects: true,
     });
   });
 
-  test('interactive HTTP processing marks no-socket sessions interactive and registers confirmation prompts', async () => {
+  test("interactive HTTP processing marks no-socket sessions interactive and registers confirmation prompts", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
 
     // Pre-configure the mock to emit a confirmation_request during runAgentLoop,
     // simulating a tool requesting approval while the session is interactive.
     mockConfirmationToEmitDuringLoop = {
-      type: 'confirmation_request',
-      requestId: 'req-interactive-1',
-      toolName: 'notify_desktop',
-      input: { title: 'Weather' },
-      riskLevel: 'high',
-      allowlistOptions: [{ label: 'notify_desktop:*', description: 'notify_desktop:*', pattern: 'notify_desktop:*' }],
-      scopeOptions: [{ label: 'everywhere', scope: 'everywhere' }],
+      type: "confirmation_request",
+      requestId: "req-interactive-1",
+      toolName: "notify_desktop",
+      input: { title: "Weather" },
+      riskLevel: "high",
+      allowlistOptions: [
+        {
+          label: "notify_desktop:*",
+          description: "notify_desktop:*",
+          pattern: "notify_desktop:*",
+        },
+      ],
+      scopeOptions: [{ label: "everywhere", scope: "everywhere" }],
       persistentDecisionsAllowed: true,
     };
 
     await server.processMessage(
       conversation.id,
-      'send me a notification',
+      "send me a notification",
       undefined,
       { isInteractive: true },
-      'telegram',
-      'telegram',
+      "telegram",
+      "telegram",
     );
 
     mockConfirmationToEmitDuringLoop = undefined;
@@ -689,61 +750,67 @@ describe('DaemonServer initial session hydration', () => {
     expect(session!.lastUpdateClientHasNoClient).toBe(true);
 
     // The pending interaction was registered during the loop.
-    const interaction = pendingInteractions.get('req-interactive-1');
+    const interaction = pendingInteractions.get("req-interactive-1");
     expect(interaction).toBeDefined();
-    expect(interaction?.kind).toBe('confirmation');
+    expect(interaction?.kind).toBe("confirmation");
     expect(interaction?.conversationId).toBe(conversation.id);
   });
 
-  test('confirmation_request canonical records include bound guardian identity context', async () => {
+  test("confirmation_request canonical records include bound guardian identity context", async () => {
     const server = new DaemonServer();
 
     mockConfirmationToEmitDuringLoop = {
-      type: 'confirmation_request',
-      requestId: 'req-bound-1',
-      toolName: 'host_bash',
-      input: { command: 'ls' },
-      riskLevel: 'high',
-      allowlistOptions: [{ label: 'host_bash:*', description: 'host_bash:*', pattern: 'host_bash:*' }],
-      scopeOptions: [{ label: 'everywhere', scope: 'everywhere' }],
+      type: "confirmation_request",
+      requestId: "req-bound-1",
+      toolName: "host_bash",
+      input: { command: "ls" },
+      riskLevel: "high",
+      allowlistOptions: [
+        {
+          label: "host_bash:*",
+          description: "host_bash:*",
+          pattern: "host_bash:*",
+        },
+      ],
+      scopeOptions: [{ label: "everywhere", scope: "everywhere" }],
       persistentDecisionsAllowed: true,
     };
 
     await server.processMessage(
       conversation.id,
-      'run ls',
+      "run ls",
       undefined,
       {
         isInteractive: false,
         guardianContext: {
-          sourceChannel: 'telegram',
-          trustClass: 'trusted_contact',
-          guardianExternalUserId: 'guardian-123',
-          requesterExternalUserId: 'trusted-456',
-          requesterChatId: 'chat-789',
+          sourceChannel: "telegram",
+          trustClass: "trusted_contact",
+          guardianExternalUserId: "guardian-123",
+          requesterExternalUserId: "trusted-456",
+          requesterChatId: "chat-789",
         },
       },
-      'telegram',
-      'telegram',
+      "telegram",
+      "telegram",
     );
 
     expect(lastCanonicalGuardianCreateParams).toBeDefined();
     expect(lastCanonicalGuardianCreateParams).toMatchObject({
-      id: 'req-bound-1',
-      kind: 'tool_approval',
-      sourceType: 'channel',
-      sourceChannel: 'telegram',
+      id: "req-bound-1",
+      kind: "tool_approval",
+      sourceType: "channel",
+      sourceChannel: "telegram",
       conversationId: conversation.id,
-      guardianExternalUserId: 'guardian-123',
-      requesterExternalUserId: 'trusted-456',
-      requesterChatId: 'chat-789',
-      toolName: 'host_bash',
-      status: 'pending',
-      requestCode: 'mock-code-0000',
+      guardianExternalUserId: "guardian-123",
+      requesterExternalUserId: "trusted-456",
+      requesterChatId: "chat-789",
+      toolName: "host_bash",
+      status: "pending",
+      requestCode: "mock-code-0000",
     });
   });
 
-  test('finally block does not overwrite IPC client that connected during interactive agent loop (processMessage)', async () => {
+  test("finally block does not overwrite IPC client that connected during interactive agent loop (processMessage)", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
 
@@ -757,11 +824,11 @@ describe('DaemonServer initial session hydration', () => {
 
     await server.processMessage(
       conversation.id,
-      'hello',
+      "hello",
       undefined,
       { isInteractive: true },
-      'telegram',
-      'telegram',
+      "telegram",
+      "telegram",
     );
 
     mockMidLoopCallback = undefined;
@@ -776,7 +843,7 @@ describe('DaemonServer initial session hydration', () => {
     expect(session!.lastUpdateClientHasNoClient).toBe(false);
   });
 
-  test('finally block does not overwrite IPC client that connected during interactive agent loop (persistAndProcessMessage)', async () => {
+  test("finally block does not overwrite IPC client that connected during interactive agent loop (persistAndProcessMessage)", async () => {
     const server = new DaemonServer();
     const internal = asDaemonServerTestAccess(server);
 
@@ -790,13 +857,13 @@ describe('DaemonServer initial session hydration', () => {
 
     const { messageId } = await server.persistAndProcessMessage(
       conversation.id,
-      'hello',
+      "hello",
       undefined,
       { isInteractive: true },
-      'telegram',
-      'telegram',
+      "telegram",
+      "telegram",
     );
-    expect(messageId).toBe('msg-1');
+    expect(messageId).toBe("msg-1");
 
     // persistAndProcessMessage fires the loop in the background; wait for it.
     await new Promise((r) => setTimeout(r, 50));