@vellumai/assistant 0.4.55 → 0.4.57

package/src/daemon/server.ts

@@ -1,6 +1,11 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
+import {
+  disposeAcpSessionManager,
+  getAcpSessionManager,
+  setBroadcastToAllClients,
+} from "../acp/index.js";
 import {
   createAssistantMessage,
   createUserMessage,
@@ -13,6 +18,14 @@ import {
 } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import { onContactChange } from "../contacts/contact-events.js";
+import type { CesClient } from "../credential-execution/client.js";
+import { createCesClient } from "../credential-execution/client.js";
+import { isCesToolsEnabled } from "../credential-execution/feature-gates.js";
+import {
+  type CesProcessManager,
+  CesUnavailableError,
+  createCesProcessManager,
+} from "../credential-execution/process-manager.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
 import {
@@ -22,12 +35,14 @@ import {
 import {
   addMessage,
   getConversationMemoryScopeId,
-  getConversationThreadType,
+  getConversationType,
   provenanceFromTrustContext,
   setConversationOriginChannelIfUnset,
   setConversationOriginInterfaceIfUnset,
 } from "../memory/conversation-crud.js";
+import { getOrCreateConversation } from "../memory/conversation-key-store.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
+import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
 import {
   getFailoverProvider,
@@ -42,6 +57,8 @@ import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { checkIngressForSecrets } from "../security/secret-ingress.js";
 import { registerCancelCallback } from "../signals/cancel.js";
 import { registerConversationUndoCallback } from "../signals/conversation-undo.js";
+import { appendEventToStream } from "../signals/event-stream.js";
+import { registerUserMessageCallback } from "../signals/user-message.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { IngressBlockedError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
@@ -51,25 +68,25 @@ import {
 } from "../util/platform.js";
 import { registerDaemonCallbacks } from "../work-items/work-item-runner.js";
 import { ConfigWatcher } from "./config-watcher.js";
+import {
+  Conversation,
+  type ConversationMemoryPolicy,
+  DEFAULT_MEMORY_POLICY,
+} from "./conversation.js";
+import { ConversationEvictor } from "./conversation-evictor.js";
+import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
+import { resolveSlash } from "./conversation-slash.js";
+import { undoLastMessage } from "./handlers/conversations.js";
 import { parseIdentityFields } from "./handlers/identity.js";
-import { undoLastMessage } from "./handlers/sessions.js";
 import type {
+  ConversationCreateOptions,
   HandlerContext,
-  SessionCreateOptions,
 } from "./handlers/shared.js";
 import type { SkillOperationContext } from "./handlers/skills.js";
 import { HostBashProxy } from "./host-bash-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
 import { HostFileProxy } from "./host-file-proxy.js";
 import type { ServerMessage } from "./message-protocol.js";
-import {
-  DEFAULT_MEMORY_POLICY,
-  Session,
-  type SessionMemoryPolicy,
-} from "./session.js";
-import { SessionEvictor } from "./session-evictor.js";
-import { resolveChannelCapabilities } from "./session-runtime-assembly.js";
-import { resolveSlash } from "./session-slash.js";
 
 const log = getLogger("server");
 
@@ -137,16 +154,16 @@ function resolveCanonicalRequestSourceType(
  * Build an onEvent callback that registers pending interactions when the agent
  * loop emits confirmation_request, secret_request, host_bash_request, or
  * host_file_request events. This ensures that channel approval interception
- * can look up the session by requestId.
+ * can look up the conversation by requestId.
  */
 function makePendingInteractionRegistrar(
-  session: Session,
+  conversation: Conversation,
   conversationId: string,
 ): (msg: ServerMessage) => void {
   return (msg: ServerMessage) => {
     if (msg.type === "confirmation_request") {
       pendingInteractions.register(msg.requestId, {
-        session,
+        conversation,
         conversationId,
         kind: "confirmation",
         confirmationDetails: {
@@ -164,7 +181,7 @@ function makePendingInteractionRegistrar(
       // Create a canonical guardian request so HTTP handlers can find it
       // via applyCanonicalGuardianDecision.
       try {
-        const trustContext = session.trustContext;
+        const trustContext = conversation.trustContext;
         const sourceChannel = trustContext?.sourceChannel ?? "vellum";
         const canonicalRequest = createCanonicalGuardianRequest({
           id: msg.requestId,
@@ -179,7 +196,7 @@ function makePendingInteractionRegistrar(
           toolName: msg.toolName,
           status: "pending",
           requestCode: generateCanonicalRequestCode(),
-          expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+          expiresAt: Date.now() + 5 * 60 * 1000,
         });
 
         // For trusted-contact sessions, bridge to guardian.question so the
@@ -190,7 +207,8 @@ function makePendingInteractionRegistrar(
             trustContext,
             conversationId,
             toolName: msg.toolName,
-            assistantId: session.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
+            assistantId:
+              conversation.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
           });
         }
       } catch (err) {
@@ -201,25 +219,25 @@ function makePendingInteractionRegistrar(
       }
     } else if (msg.type === "secret_request") {
       pendingInteractions.register(msg.requestId, {
-        session,
+        conversation,
         conversationId,
         kind: "secret",
       });
     } else if (msg.type === "host_bash_request") {
       pendingInteractions.register(msg.requestId, {
-        session,
+        conversation,
         conversationId,
         kind: "host_bash",
       });
     } else if (msg.type === "host_file_request") {
       pendingInteractions.register(msg.requestId, {
-        session,
+        conversation,
         conversationId,
         kind: "host_file",
       });
     } else if (msg.type === "host_cu_request") {
       pendingInteractions.register(msg.requestId, {
-        session,
+        conversation,
         conversationId,
         kind: "host_cu",
       });
@@ -228,22 +246,38 @@ function makePendingInteractionRegistrar(
 }
 
 export class DaemonServer {
-  private sessions = new Map<string, Session>();
-  private sessionOptions = new Map<string, SessionCreateOptions>();
-  private sessionCreating = new Map<string, Promise<Session>>();
+  private conversations = new Map<string, Conversation>();
+  private conversationOptions = new Map<string, ConversationCreateOptions>();
+  private conversationCreating = new Map<string, Promise<Conversation>>();
   private sharedRequestTimestamps: number[] = [];
   private httpPort: number | undefined;
   private unsubscribeContactChange: (() => void) | null = null;
-  private evictor: SessionEvictor;
+  private evictor: ConversationEvictor;
   private _hubChain: Promise<void> = Promise.resolve();
 
   // Composed subsystems
   private configWatcher = new ConfigWatcher();
 
+  // CES (Credential Execution Service) — process-level singleton.
+  // The CES sidecar accepts exactly one bootstrap connection, so we must
+  // hold that connection at the server level rather than per-conversation.
+  private cesProcessManager?: CesProcessManager;
+  private cesClientPromise?: Promise<CesClient | undefined>;
+  private cesInitAbortController?: AbortController;
+  private cesClientRef?: CesClient;
+
   /**
    * Logical assistant identifier used when publishing to the assistant-events hub.
    */
-  assistantId: string = "default";
+  assistantId: string = DAEMON_INTERNAL_ASSISTANT_ID;
+
+  /**
+   * Return the CES client reference (if available).
+   * Used by routes that need to push updates to CES (e.g. secret-routes).
+   */
+  getCesClient(): CesClient | undefined {
+    return this.cesClientRef;
+  }
 
   /** Optional heartbeat service reference for "Run Now" from the UI. */
   private _heartbeatService?: HeartbeatService;
@@ -252,9 +286,9 @@ export class DaemonServer {
     this._heartbeatService = service;
   }
 
-  private deriveMemoryPolicy(conversationId: string): SessionMemoryPolicy {
-    const threadType = getConversationThreadType(conversationId);
-    if (threadType === "private") {
+  private deriveMemoryPolicy(conversationId: string): ConversationMemoryPolicy {
+    const conversationType = getConversationType(conversationId);
+    if (conversationType === "private") {
       return {
         scopeId: getConversationMemoryScopeId(conversationId),
         includeDefaultFallback: true,
@@ -265,8 +299,8 @@ export class DaemonServer {
   }
 
   private applyTransportMetadata(
-    _session: Session,
-    options: SessionCreateOptions | undefined,
+    _conversation: Conversation,
+    options: ConversationCreateOptions | undefined,
   ): void {
     const transport = options?.transport;
     if (!transport) return;
@@ -277,35 +311,36 @@ export class DaemonServer {
   }
 
   constructor() {
-    this.evictor = new SessionEvictor(this.sessions);
+    this.evictor = new ConversationEvictor(this.conversations);
     getSubagentManager().sharedRequestTimestamps = this.sharedRequestTimestamps;
     getSubagentManager().broadcastToAllClients = (msg) => this.broadcast(msg);
-    this.evictor.onEvict = (sessionId: string) => {
-      getSubagentManager().abortAllForParent(sessionId);
+    setBroadcastToAllClients((msg) => this.broadcast(msg));
+    this.evictor.onEvict = (conversationId: string) => {
+      getSubagentManager().abortAllForParent(conversationId);
     };
-    this.evictor.shouldProtect = (sessionId: string) => {
-      const children = getSubagentManager().getChildrenOf(sessionId);
+    this.evictor.shouldProtect = (conversationId: string) => {
+      const children = getSubagentManager().getChildrenOf(conversationId);
       return children.some(
         (c) => c.status === "running" || c.status === "pending",
       );
     };
     getSubagentManager().onSubagentFinished = async (
-      parentSessionId,
+      parentConversationId,
       message,
       sendToClient,
       notification,
     ) => {
-      const parentSession = this.sessions.get(parentSessionId);
-      if (!parentSession) {
+      const parentConversation = this.conversations.get(parentConversationId);
+      if (!parentConversation) {
         log.warn(
-          { parentSessionId },
-          "Subagent finished but parent session not found",
+          { parentConversationId },
+          "Subagent finished but parent conversation not found",
         );
         return;
       }
       const requestId = `subagent-notify-${Date.now()}`;
       const metadata = { subagentNotification: notification };
-      const enqueueResult = parentSession.enqueueMessage(
+      const enqueueResult = parentConversation.enqueueMessage(
         message,
         [],
         sendToClient,
@@ -315,22 +350,57 @@ export class DaemonServer {
         metadata,
       );
       if (!enqueueResult.queued && !enqueueResult.rejected) {
-        const messageId = await parentSession.persistUserMessage(
+        const messageId = await parentConversation.persistUserMessage(
           message,
           [],
           undefined,
           metadata,
         );
-        parentSession
+        parentConversation
           .runAgentLoop(message, messageId, sendToClient)
           .catch((err) => {
             log.error(
-              { parentSessionId, err },
+              { parentConversationId, err },
               "Failed to process subagent notification in parent",
             );
           });
       }
     };
+    getAcpSessionManager().onAcpSessionFinished = async (
+      parentConversationId,
+      message,
+      sendToClient,
+    ) => {
+      const parentConversation = this.conversations.get(parentConversationId);
+      if (!parentConversation) {
+        log.warn(
+          { parentConversationId },
+          "ACP agent finished but parent conversation not found",
+        );
+        return;
+      }
+      const requestId = `acp-notify-${Date.now()}`;
+      const enqueueResult = parentConversation.enqueueMessage(
+        message,
+        [],
+        sendToClient,
+        requestId,
+      );
+      if (!enqueueResult.queued && !enqueueResult.rejected) {
+        const messageId = await parentConversation.persistUserMessage(
+          message,
+          [],
+        );
+        parentConversation
+          .runAgentLoop(message, messageId, sendToClient)
+          .catch((err: unknown) => {
+            log.error(
+              { parentConversationId, err },
+              "Failed to process ACP notification in parent",
+            );
+          });
+      }
+    };
   }
 
   // ── Broadcast / Event publishing ──────────────────────────────────
@@ -340,9 +410,12 @@ export class DaemonServer {
    * Publications are serialized via a promise chain so subscribers
    * always observe events in send order.
    */
-  private publishAssistantEvent(msg: ServerMessage, sessionId?: string): void {
-    const id = this.assistantId ?? "default";
-    const event = buildAssistantEvent(id, msg, sessionId);
+  private publishAssistantEvent(
+    msg: ServerMessage,
+    conversationId?: string,
+  ): void {
+    const id = this.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID;
+    const event = buildAssistantEvent(id, msg, conversationId);
     this._hubChain = this._hubChain
       .then(() => assistantEventHub.publish(event))
       .catch((err: unknown) => {
@@ -351,11 +424,21 @@ export class DaemonServer {
           "assistant-events hub subscriber threw during broadcast",
         );
       });
+
+    // Dual-write to file-based stream for cross-process consumers.
+    // No-op when no subscriber files exist for this conversation.
+    if (conversationId) {
+      try {
+        appendEventToStream(conversationId, event);
+      } catch {
+        // Best-effort; file I/O failures must not block the hub chain.
+      }
+    }
   }
 
   broadcast(msg: ServerMessage): void {
-    const sessionId = extractSessionId(msg);
-    this.publishAssistantEvent(msg, sessionId);
+    const conversationId = extractConversationId(msg);
+    this.publishAssistantEvent(msg, conversationId);
   }
 
   private broadcastIdentityChanged(): void {
@@ -388,26 +471,62 @@ export class DaemonServer {
     this.evictor.start();
 
     registerDaemonCallbacks({
-      getOrCreateSession: (conversationId) =>
-        this.getOrCreateSession(conversationId),
+      getOrCreateConversation: (conversationId) =>
+        this.getOrCreateConversation(conversationId),
       broadcast: (msg) => this.broadcast(msg),
     });
 
-    registerCancelCallback((sessionId) => {
-      const session = this.sessions.get(sessionId);
-      if (!session) return false;
-      this.evictor.touch(sessionId);
-      session.abort();
-      getSubagentManager().abortAllForParent(sessionId);
+    registerCancelCallback((conversationId) => {
+      const conversation = this.conversations.get(conversationId);
+      if (!conversation) return false;
+      this.evictor.touch(conversationId);
+      conversation.abort();
+      getSubagentManager().abortAllForParent(conversationId);
       return true;
     });
 
-    registerConversationUndoCallback((sessionId) =>
-      undoLastMessage(sessionId, this.handlerContext()),
+    registerConversationUndoCallback((conversationId) =>
+      undoLastMessage(conversationId, this.handlerContext()),
     );
 
+    registerUserMessageCallback(async (params) => {
+      const { conversationId } = getOrCreateConversation(
+        params.conversationKey,
+      );
+      const conversation = await this.getOrCreateConversation(conversationId);
+      if (conversation.isProcessing()) {
+        const requestId = crypto.randomUUID();
+        const resolvedChannel = resolveTurnChannel(params.sourceChannel);
+        const resolvedInterface = resolveTurnInterface(params.sourceInterface);
+        const result = conversation.enqueueMessage(
+          params.content,
+          [],
+          () => {},
+          requestId,
+          undefined,
+          undefined,
+          {
+            userMessageChannel: resolvedChannel,
+            assistantMessageChannel: resolvedChannel,
+            userMessageInterface: resolvedInterface,
+            assistantMessageInterface: resolvedInterface,
+          },
+        );
+        return { accepted: !result.rejected };
+      }
+      await this.persistAndProcessMessage(
+        conversationId,
+        params.content,
+        undefined,
+        undefined,
+        params.sourceChannel,
+        params.sourceInterface,
+      );
+      return { accepted: true };
+    });
+
     this.configWatcher.start(
-      () => this.evictSessionsForReload(),
+      () => this.evictConversationsForReload(),
       () => this.broadcastIdentityChanged(),
     );
 
@@ -416,11 +535,79 @@ export class DaemonServer {
       this.broadcast({ type: "contacts_changed" });
     });
 
+    // CES lifecycle — start the CES process and perform the RPC handshake
+    // once at server level. The managed sidecar accepts exactly one bootstrap
+    // connection, so this must be a process-level singleton.
+    if (isCesToolsEnabled(config)) {
+      const pm = createCesProcessManager({ assistantConfig: config });
+      this.cesProcessManager = pm;
+      const abortController = new AbortController();
+      this.cesInitAbortController = abortController;
+      this.cesClientPromise = (async () => {
+        try {
+          const transport = await pm.start();
+          if (abortController.signal.aborted) {
+            throw new Error("CES initialization aborted during shutdown");
+          }
+          const client = createCesClient(transport);
+          this.cesClientRef = client;
+          // Resolve the assistant API key so CES can use it for platform
+          // credential materialisation. In managed mode the key is provisioned
+          // after hatch and stored in the credential store — CES can't read
+          // the env var, so we pass it via the handshake.
+          const proxyCtx = await resolveManagedProxyContext();
+          const { accepted, reason } = await client.handshake(
+            proxyCtx.assistantApiKey
+              ? { assistantApiKey: proxyCtx.assistantApiKey }
+              : undefined,
+          );
+          if (abortController.signal.aborted) {
+            client.close();
+            throw new Error("CES initialization aborted during shutdown");
+          }
+          if (accepted) {
+            log.info(
+              "CES client initialized and handshake accepted (server-level)",
+            );
+            return client;
+          }
+          log.warn(
+            { reason },
+            "CES handshake rejected — CES tools will be unavailable",
+          );
+          client.close();
+          this.cesClientRef = undefined;
+          await pm.stop();
+          // Reset so next session can retry initialization
+          this.cesClientPromise = undefined;
+          return undefined;
+        } catch (err) {
+          if (err instanceof CesUnavailableError) {
+            log.info(
+              { reason: err.message },
+              "CES is not available — CES tools will be unavailable",
+            );
+          } else {
+            log.warn(
+              { error: err instanceof Error ? err.message : String(err) },
+              "Failed to initialize CES client — CES tools will be unavailable",
+            );
+          }
+          await pm.stop().catch(() => {});
+          // Reset so next session can retry initialization
+          this.cesClientRef = undefined;
+          this.cesClientPromise = undefined;
+          return undefined;
+        }
+      })();
+    }
+
     log.info("DaemonServer started (HTTP-only mode)");
   }
 
   async stop(): Promise<void> {
     getSubagentManager().disposeAll();
+    disposeAcpSessionManager();
     this.evictor.stop();
     this.configWatcher.stop();
     if (this.unsubscribeContactChange) {
@@ -428,15 +615,43 @@ export class DaemonServer {
       this.unsubscribeContactChange = null;
     }
 
-    for (const session of this.sessions.values()) {
-      session.dispose();
+    for (const conversation of this.conversations.values()) {
+      conversation.dispose();
+    }
+    this.conversations.clear();
+
+    // Abort any in-flight CES initialization so it fails fast instead of
+    // blocking shutdown for up to ~15s (socket connect + handshake timeouts).
+    if (this.cesInitAbortController) {
+      this.cesInitAbortController.abort();
+      this.cesInitAbortController = undefined;
+    }
+    // Force-stop the CES process immediately — forceStop() works even if
+    // start() hasn't finished (unlike stop() which is a no-op when !running).
+    if (this.cesProcessManager) {
+      await this.cesProcessManager.forceStop().catch(() => {});
+    }
+    // Cancel in-flight handshake/RPC timers by closing the client directly.
+    // Without this, the handshake setTimeout (~10s) keeps the init promise
+    // pending even after the transport is killed.
+    if (this.cesClientRef) {
+      this.cesClientRef.close();
+      this.cesClientRef = undefined;
+    }
+    // Now await the init promise (which should settle immediately since we
+    // killed the transport and cancelled pending timers above).
+    if (this.cesClientPromise) {
+      await this.cesClientPromise.catch(() => undefined);
+      this.cesClientPromise = undefined;
+    }
+    if (this.cesProcessManager) {
+      this.cesProcessManager = undefined;
     }
-    this.sessions.clear();
 
     log.info("Daemon server stopped");
   }
 
-  // ── Session management ──────────────────────────────────────────────
+  // ── Conversation management ──────────────────────────────────────────────
 
   setHttpPort(port: number): void {
     this.httpPort = port;
@@ -448,31 +663,45 @@ export class DaemonServer {
     });
   }
 
-  clearAllSessions(): number {
-    const count = this.sessions.size;
+  clearAllConversations(): number {
+    const count = this.conversations.size;
     const subagentManager = getSubagentManager();
-    for (const id of this.sessions.keys()) {
+    for (const id of this.conversations.keys()) {
       this.evictor.remove(id);
       subagentManager.abortAllForParent(id);
     }
-    for (const session of this.sessions.values()) {
-      session.dispose();
+    for (const conversation of this.conversations.values()) {
+      conversation.dispose();
     }
-    this.sessions.clear();
-    this.sessionOptions.clear();
+    this.conversations.clear();
+    this.conversationOptions.clear();
     return count;
   }
 
-  private evictSessionsForReload(): void {
+  /**
+   * Abort and dispose a single in-memory conversation, removing it from the
+   * conversation map. No-op if no conversation exists for the given ID.
+   */
+  destroyConversation(conversationId: string): void {
+    const conversation = this.conversations.get(conversationId);
+    if (!conversation) return;
+    this.evictor.remove(conversationId);
+    getSubagentManager().abortAllForParent(conversationId);
+    conversation.dispose();
+    this.conversations.delete(conversationId);
+    this.conversationOptions.delete(conversationId);
+  }
+
+  private evictConversationsForReload(): void {
     const subagentManager = getSubagentManager();
-    for (const [id, session] of this.sessions) {
-      if (!session.isProcessing()) {
+    for (const [id, conversation] of this.conversations) {
+      if (!conversation.isProcessing()) {
         subagentManager.abortAllForParent(id);
-        session.dispose();
-        this.sessions.delete(id);
+        conversation.dispose();
+        this.conversations.delete(id);
         this.evictor.remove(id);
       } else {
-        session.markStale();
+        conversation.markStale();
       }
     }
   }
@@ -487,49 +716,49 @@ export class DaemonServer {
 
   async refreshConfigFromSources(): Promise<boolean> {
     const changed = await this.configWatcher.refreshConfigFromSources();
-    if (changed) this.evictSessionsForReload();
+    if (changed) this.evictConversationsForReload();
     return changed;
   }
 
-  private async getOrCreateSession(
+  private async getOrCreateConversation(
     conversationId: string,
-    options?: SessionCreateOptions,
-  ): Promise<Session> {
-    let session = this.sessions.get(conversationId);
+    options?: ConversationCreateOptions,
+  ): Promise<Conversation> {
+    let conversation = this.conversations.get(conversationId);
     const sendToClient = () => {};
 
     if (options && Object.values(options).some((v) => v !== undefined)) {
-      this.sessionOptions.set(conversationId, {
-        ...this.sessionOptions.get(conversationId),
+      this.conversationOptions.set(conversationId, {
+        ...this.conversationOptions.get(conversationId),
         ...options,
       });
     }
 
-    if (!session || (session.isStale() && !session.isProcessing())) {
-      if (session) {
+    if (
+      !conversation ||
+      (conversation.isStale() && !conversation.isProcessing())
+    ) {
+      if (conversation) {
         getSubagentManager().abortAllForParent(conversationId);
-        session.dispose();
+        conversation.dispose();
       }
 
-      const pending = this.sessionCreating.get(conversationId);
+      const pending = this.conversationCreating.get(conversationId);
       if (pending) {
-        session = await pending;
-        return session;
+        conversation = await pending;
+        return conversation;
       }
 
-      const storedOptions = this.sessionOptions.get(conversationId);
+      const storedOptions = this.conversationOptions.get(conversationId);
 
       const createPromise = (async () => {
         const config = getConfig();
         let provider = getFailoverProvider(
-          config.provider,
+          config.services.inference.provider,
           config.providerOrder,
         );
         const { rateLimit } = config;
-        if (
-          rateLimit.maxRequestsPerMinute > 0 ||
-          rateLimit.maxTokensPerSession > 0
-        ) {
+        if (rateLimit.maxRequestsPerMinute > 0) {
           provider = new RateLimitProvider(
             provider,
             rateLimit,
@@ -543,7 +772,11 @@ export class DaemonServer {
         const maxTokens = storedOptions?.maxResponseTokens ?? config.maxTokens;
 
         const memoryPolicy = this.deriveMemoryPolicy(conversationId);
-        const newSession = new Session(
+        // Resolve the shared CES client (may still be initializing).
+        const sharedCesClient = this.cesClientPromise
+          ? await this.cesClientPromise
+          : undefined;
+        const newConversation = new Conversation(
           conversationId,
           provider,
           systemPrompt,
@@ -552,49 +785,50 @@ export class DaemonServer {
           workingDir,
           (msg) => this.broadcast(msg),
           memoryPolicy,
+          sharedCesClient,
         );
-        newSession.updateClient(sendToClient, true);
-        await newSession.loadFromDb();
+        newConversation.updateClient(sendToClient, true);
+        await newConversation.loadFromDb();
         // Restore trust/auth context and assistant ID from stored options so
         // that evicted sessions rehydrated by undo/regenerate don't run with
         // unscoped history.  Without this, an untrusted actor could operate
         // on the full conversation after eviction.
         if (storedOptions?.assistantId) {
-          newSession.setAssistantId(storedOptions.assistantId);
+          newConversation.setAssistantId(storedOptions.assistantId);
         }
         if (storedOptions?.trustContext) {
-          newSession.setTrustContext(storedOptions.trustContext);
+          newConversation.setTrustContext(storedOptions.trustContext);
         }
         if (storedOptions?.authContext) {
-          newSession.setAuthContext(storedOptions.authContext);
+          newConversation.setAuthContext(storedOptions.authContext);
         }
         if (storedOptions?.trustContext || storedOptions?.authContext) {
-          await newSession.ensureActorScopedHistory();
+          await newConversation.ensureActorScopedHistory();
         }
-        this.applyTransportMetadata(newSession, storedOptions);
-        this.sessions.set(conversationId, newSession);
-        return newSession;
+        this.applyTransportMetadata(newConversation, storedOptions);
+        this.conversations.set(conversationId, newConversation);
+        return newConversation;
       })();
 
-      this.sessionCreating.set(conversationId, createPromise);
+      this.conversationCreating.set(conversationId, createPromise);
       try {
-        session = await createPromise;
+        conversation = await createPromise;
       } finally {
-        this.sessionCreating.delete(conversationId);
+        this.conversationCreating.delete(conversationId);
       }
       this.evictor.touch(conversationId);
     } else {
-      this.applyTransportMetadata(session, options);
+      this.applyTransportMetadata(conversation, options);
       this.evictor.touch(conversationId);
     }
-    return session;
+    return conversation;
   }
 
   // ── Handler context ────────────────────────────────────────────────
 
   private handlerContext(): HandlerContext {
     return {
-      sessions: this.sessions,
+      conversations: this.conversations,
       sharedRequestTimestamps: this.sharedRequestTimestamps,
       debounceTimers: this.configWatcher.timers,
       suppressConfigReload: this.configWatcher.suppressConfigReload,
@@ -606,10 +840,10 @@ export class DaemonServer {
       },
       send: (msg) => this.broadcast(msg),
       broadcast: (msg) => this.broadcast(msg),
-      clearAllSessions: () => this.clearAllSessions(),
-      getOrCreateSession: (id, options?) =>
-        this.getOrCreateSession(id, options),
-      touchSession: (id) => this.evictor.touch(id),
+      clearAllConversations: () => this.clearAllConversations(),
+      getOrCreateConversation: (id, options?) =>
+        this.getOrCreateConversation(id, options),
+      touchConversation: (id) => this.evictor.touch(id),
       heartbeatService: this._heartbeatService,
     };
   }
@@ -630,15 +864,15 @@ export class DaemonServer {
 
   // ── HTTP message processing ─────────────────────────────────────────
 
-  private async prepareSessionForMessage(
+  private async prepareConversationForMessage(
     conversationId: string,
     content: string,
     attachmentIds: string[] | undefined,
-    options: SessionCreateOptions | undefined,
+    options: ConversationCreateOptions | undefined,
     sourceChannel: string | undefined,
     sourceInterface: string | undefined,
   ): Promise<{
-    session: Session;
+    conversation: Conversation;
     attachments: {
       id: string;
       filename: string;
@@ -654,10 +888,13 @@ export class DaemonServer {
       );
     }
 
-    const session = await this.getOrCreateSession(conversationId, options);
+    const conversation = await this.getOrCreateConversation(
+      conversationId,
+      options,
+    );
 
-    if (session.isProcessing()) {
-      throw new Error("Session is already processing a message");
+    if (conversation.isProcessing()) {
+      throw new Error("Conversation is already processing a message");
     }
 
     const resolvedChannel = resolveTurnChannel(
@@ -665,60 +902,59 @@ export class DaemonServer {
       options?.transport?.channelId,
     );
     const resolvedInterface = resolveTurnInterface(sourceInterface);
-    session.setAssistantId(
+    conversation.setAssistantId(
       options?.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
     );
-    session.setTrustContext(options?.trustContext ?? null);
-    session.setAuthContext(options?.authContext ?? null);
-    await session.ensureActorScopedHistory();
-    session.setChannelCapabilities(
+    conversation.setTrustContext(options?.trustContext ?? null);
+    conversation.setAuthContext(options?.authContext ?? null);
+    await conversation.ensureActorScopedHistory();
+    conversation.setChannelCapabilities(
       resolveChannelCapabilities(
         sourceChannel,
         sourceInterface,
-        null,
         options?.transport?.chatType,
       ),
     );
     // Only create the host bash proxy for desktop client interfaces that can
-    // execute commands on the user's machine. Non-desktop sessions (CLI,
+    // execute commands on the user's machine. Non-desktop conversations (CLI,
     // channels, headless) fall back to local execution.
     // Guard: don't replace an active proxy during concurrent turn races —
     // another request may have started processing between the isProcessing()
     // check above and the await on ensureActorScopedHistory().
     if (resolvedInterface === "macos" || resolvedInterface === "ios") {
-      if (!session.isProcessing() || !session.hostBashProxy) {
-        session.setHostBashProxy(
-          new HostBashProxy(session.getCurrentSender(), (requestId) => {
+      if (!conversation.isProcessing() || !conversation.hostBashProxy) {
+        conversation.setHostBashProxy(
+          new HostBashProxy(conversation.getCurrentSender(), (requestId) => {
             pendingInteractions.resolve(requestId);
           }),
         );
       }
-      if (!session.isProcessing() || !session.hostFileProxy) {
-        session.setHostFileProxy(
-          new HostFileProxy(session.getCurrentSender(), (requestId) => {
+      if (!conversation.isProcessing() || !conversation.hostFileProxy) {
+        conversation.setHostFileProxy(
+          new HostFileProxy(conversation.getCurrentSender(), (requestId) => {
             pendingInteractions.resolve(requestId);
           }),
         );
       }
-      if (!session.isProcessing() || !session.hostCuProxy) {
-        session.setHostCuProxy(
-          new HostCuProxy(session.getCurrentSender(), (requestId) => {
+      if (!conversation.isProcessing() || !conversation.hostCuProxy) {
+        conversation.setHostCuProxy(
+          new HostCuProxy(conversation.getCurrentSender(), (requestId) => {
             pendingInteractions.resolve(requestId);
           }),
         );
       }
-      session.addPreactivatedSkillId("computer-use");
-    } else if (!session.isProcessing()) {
-      session.setHostBashProxy(undefined);
-      session.setHostFileProxy(undefined);
-      session.setHostCuProxy(undefined);
+      conversation.addPreactivatedSkillId("computer-use");
+    } else if (!conversation.isProcessing()) {
+      conversation.setHostBashProxy(undefined);
+      conversation.setHostFileProxy(undefined);
+      conversation.setHostCuProxy(undefined);
     }
-    session.setCommandIntent(options?.commandIntent ?? null);
-    session.setTurnChannelContext({
+    conversation.setCommandIntent(options?.commandIntent ?? null);
+    conversation.setTurnChannelContext({
       userMessageChannel: resolvedChannel,
       assistantMessageChannel: resolvedChannel,
     });
-    session.setTurnInterfaceContext({
+    conversation.setTurnInterfaceContext({
       userMessageInterface: resolvedInterface,
       assistantMessageInterface: resolvedInterface,
     });
@@ -732,36 +968,40 @@ export class DaemonServer {
         }))
       : [];
 
-    return { session, attachments };
+    return { conversation, attachments };
   }
 
   async persistAndProcessMessage(
     conversationId: string,
     content: string,
     attachmentIds?: string[],
-    options?: SessionCreateOptions,
+    options?: ConversationCreateOptions,
     sourceChannel?: string,
     sourceInterface?: string,
   ): Promise<{ messageId: string }> {
-    const { session, attachments } = await this.prepareSessionForMessage(
-      conversationId,
-      content,
-      attachmentIds,
-      options,
-      sourceChannel,
-      sourceInterface,
-    );
+    const { conversation, attachments } =
+      await this.prepareConversationForMessage(
+        conversationId,
+        content,
+        attachmentIds,
+        options,
+        sourceChannel,
+        sourceInterface,
+      );
 
     const requestId = crypto.randomUUID();
-    const messageId = await session.persistUserMessage(
+    const messageId = await conversation.persistUserMessage(
       content,
       attachments,
       requestId,
     );
 
     // Register pending interactions so channel approval interception can
-    // find the session by requestId when confirmation/secret events fire.
-    const registrar = makePendingInteractionRegistrar(session, conversationId);
+    // find the conversation by requestId when confirmation/secret events fire.
+    const registrar = makePendingInteractionRegistrar(
+      conversation,
+      conversationId,
+    );
     const onEvent = options?.onEvent
       ? (msg: ServerMessage) => {
           registrar(msg);
@@ -776,10 +1016,10 @@ export class DaemonServer {
         }
       : registrar;
     if (options?.isInteractive === true) {
-      session.updateClient(onEvent, false);
+      conversation.updateClient(onEvent, false);
     }
 
-    session
+    conversation
       .runAgentLoop(content, messageId, onEvent, {
         isInteractive: options?.isInteractive ?? false,
         isUserMessage: true,
@@ -787,9 +1027,9 @@ export class DaemonServer {
       .finally(() => {
         if (
           options?.isInteractive === true &&
-          session.getCurrentSender() === onEvent
+          conversation.getCurrentSender() === onEvent
         ) {
-          session.updateClient(() => {}, true);
+          conversation.updateClient(() => {}, true);
         }
       })
       .catch((err) => {
@@ -803,25 +1043,28 @@ export class DaemonServer {
     conversationId: string,
     content: string,
     attachmentIds?: string[],
-    options?: SessionCreateOptions,
+    options?: ConversationCreateOptions,
     sourceChannel?: string,
     sourceInterface?: string,
   ): Promise<{ messageId: string }> {
-    const { session, attachments } = await this.prepareSessionForMessage(
-      conversationId,
-      content,
-      attachmentIds,
-      options,
-      sourceChannel,
-      sourceInterface,
-    );
+    const { conversation, attachments } =
+      await this.prepareConversationForMessage(
+        conversationId,
+        content,
+        attachmentIds,
+        options,
+        sourceChannel,
+        sourceInterface,
+      );
 
     const slashResult = await resolveSlash(content);
 
     if (slashResult.kind === "unknown") {
-      const serverTurnCtx = session.getTurnChannelContext();
-      const serverInterfaceCtx = session.getTurnInterfaceContext();
-      const serverProvenance = provenanceFromTrustContext(session.trustContext);
+      const serverTurnCtx = conversation.getTurnChannelContext();
+      const serverInterfaceCtx = conversation.getTurnInterfaceContext();
+      const serverProvenance = provenanceFromTrustContext(
+        conversation.trustContext,
+      );
       const serverChannelMeta = {
         ...serverProvenance,
         ...(serverTurnCtx
@@ -845,7 +1088,7 @@ export class DaemonServer {
         JSON.stringify(userMsg.content),
         serverChannelMeta,
       );
-      session.getMessages().push(userMsg);
+      conversation.getMessages().push(userMsg);
 
       if (serverTurnCtx) {
         try {
@@ -881,32 +1124,25 @@ export class DaemonServer {
         JSON.stringify(assistantMsg.content),
         serverChannelMeta,
       );
-      session.getMessages().push(assistantMsg);
+      conversation.getMessages().push(assistantMsg);
       return { messageId: persisted.id };
     }
 
     const resolvedContent = slashResult.content;
 
-    if (slashResult.kind === "rewritten") {
-      session.setPreactivatedSkillIds([slashResult.skillId]);
-    }
-
     const requestId = crypto.randomUUID();
-    let messageId: string;
-    try {
-      messageId = await session.persistUserMessage(
-        resolvedContent,
-        attachments,
-        requestId,
-      );
-    } catch (err) {
-      session.setPreactivatedSkillIds(undefined);
-      throw err;
-    }
+    const messageId = await conversation.persistUserMessage(
+      resolvedContent,
+      attachments,
+      requestId,
+    );
 
     // Register pending interactions so channel approval interception can
-    // find the session by requestId when confirmation/secret events fire.
-    const registrar = makePendingInteractionRegistrar(session, conversationId);
+    // find the conversation by requestId when confirmation/secret events fire.
+    const registrar = makePendingInteractionRegistrar(
+      conversation,
+      conversationId,
+    );
     const onEvent = options?.onEvent
       ? (msg: ServerMessage) => {
           registrar(msg);
@@ -921,20 +1157,20 @@ export class DaemonServer {
         }
       : registrar;
     if (options?.isInteractive === true) {
-      session.updateClient(onEvent, false);
+      conversation.updateClient(onEvent, false);
     }
 
     try {
-      await session.runAgentLoop(resolvedContent, messageId, onEvent, {
+      await conversation.runAgentLoop(resolvedContent, messageId, onEvent, {
         isInteractive: options?.isInteractive ?? false,
         isUserMessage: true,
       });
     } finally {
       if (
         options?.isInteractive === true &&
-        session.getCurrentSender() === onEvent
+        conversation.getCurrentSender() === onEvent
       ) {
-        session.updateClient(() => {}, true);
+        conversation.updateClient(() => {}, true);
       }
     }
 
@@ -942,32 +1178,34 @@ export class DaemonServer {
   }
 
   /**
-   * Expose session lookup for the POST /v1/messages handler.
+   * Expose conversation lookup for the POST /v1/messages handler.
    * The handler manages busy-state checking and queueing itself.
    */
-  async getSessionForMessages(conversationId: string): Promise<Session> {
-    return this.getOrCreateSession(conversationId);
+  async getConversationForMessages(
+    conversationId: string,
+  ): Promise<Conversation> {
+    return this.getOrCreateConversation(conversationId);
   }
 
   /**
-   * Look up an active session by ID without creating one.
+   * Look up an active conversation by ID without creating one.
    */
-  findSession(sessionId: string): Session | undefined {
-    return this.sessions.get(sessionId);
+  findConversation(conversationId: string): Conversation | undefined {
+    return this.conversations.get(conversationId);
   }
 
   /**
-   * Look up an active session that owns a given surfaceId.
+   * Look up an active conversation that owns a given surfaceId.
    */
-  findSessionBySurfaceId(surfaceId: string): Session | undefined {
-    for (const s of this.sessions.values()) {
-      if (s.surfaceState.has(surfaceId)) return s;
+  findConversationBySurfaceId(surfaceId: string): Conversation | undefined {
+    for (const c of this.conversations.values()) {
+      if (c.surfaceState.has(surfaceId)) return c;
     }
     return undefined;
   }
 
   /**
-   * Expose the handler context for use by session management HTTP routes.
+   * Expose the handler context for use by conversation management HTTP routes.
    * The context is built on-the-fly so it always reflects the current server state.
    */
   getHandlerContext(): HandlerContext {
@@ -975,11 +1213,11 @@ export class DaemonServer {
   }
 }
 
-/** Extract sessionId from a ServerMessage if present. */
-function extractSessionId(msg: ServerMessage): string | undefined {
+/** Extract conversationId from a ServerMessage if present. */
+function extractConversationId(msg: ServerMessage): string | undefined {
   const record = msg as unknown as Record<string, unknown>;
-  if ("sessionId" in msg && typeof record.sessionId === "string") {
-    return record.sessionId as string;
+  if ("conversationId" in msg && typeof record.conversationId === "string") {
+    return record.conversationId as string;
   }
   return undefined;
 }