@vellumai/assistant 0.4.55 → 0.4.56

package/src/daemon/conversation-evictor.ts

@@ -0,0 +1,204 @@
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("conversation-evictor");
+
+/** Minimal interface a conversation must satisfy to be evictable. */
+export interface EvictableConversation {
+  isProcessing(): boolean;
+  dispose(): void;
+}
+
+export interface EvictorOptions {
+  /** Max idle time before a conversation is eligible for eviction (ms). Default: 30 min. */
+  ttlMs?: number;
+  /** Max number of in-memory conversations before LRU eviction kicks in. Default: 100. */
+  maxConversations?: number;
+  /** RSS threshold (bytes) above which idle conversations are aggressively evicted. Default: 3 GB. */
+  memoryThresholdBytes?: number;
+  /** Interval between periodic sweeps (ms). Default: 60 s. */
+  sweepIntervalMs?: number;
+}
+
+export interface EvictionResult {
+  /** Conversations evicted because they exceeded TTL. */
+  ttlEvicted: number;
+  /** Conversations evicted because pool exceeded maxConversations (LRU order). */
+  lruEvicted: number;
+  /** Conversations evicted due to memory pressure. */
+  memoryEvicted: number;
+  /** Conversations skipped because they were actively processing. */
+  skipped: number;
+}
+
+const DEFAULT_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const DEFAULT_MAX_CONVERSATIONS = 100;
+const DEFAULT_MEMORY_THRESHOLD_BYTES = 3072 * 1024 * 1024; // 3 GB
+const DEFAULT_SWEEP_INTERVAL_MS = 60 * 1000; // 60 seconds
+
+export class ConversationEvictor {
+  private readonly ttlMs: number;
+  private readonly maxConversations: number;
+  private readonly memoryThresholdBytes: number;
+  private readonly sweepIntervalMs: number;
+
+  /** Tracks last access time per conversation ID. */
+  private lastAccess = new Map<string, number>();
+
+  private sweepTimer: ReturnType<typeof setInterval> | null = null;
+  private conversations: Map<string, EvictableConversation>;
+
+  /** Optional hook called for each evicted conversation (for cleanup in DaemonServer). */
+  onEvict?: (conversationId: string) => void;
+
+  /** Optional guard: if this returns true, the conversation is protected from eviction. */
+  shouldProtect?: (conversationId: string) => boolean;
+
+  constructor(
+    conversations: Map<string, EvictableConversation>,
+    options?: EvictorOptions,
+  ) {
+    this.conversations = conversations;
+    this.ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+    this.maxConversations =
+      options?.maxConversations ?? DEFAULT_MAX_CONVERSATIONS;
+    this.memoryThresholdBytes =
+      options?.memoryThresholdBytes ?? DEFAULT_MEMORY_THRESHOLD_BYTES;
+    this.sweepIntervalMs =
+      options?.sweepIntervalMs ?? DEFAULT_SWEEP_INTERVAL_MS;
+  }
+
+  /** Record an access for the given conversation (resets its idle clock). */
+  touch(conversationId: string): void {
+    this.lastAccess.set(conversationId, Date.now());
+  }
+
+  /** Remove tracking state for a conversation that was externally removed. */
+  remove(conversationId: string): void {
+    this.lastAccess.delete(conversationId);
+  }
+
+  /** Start the periodic sweep timer. */
+  start(): void {
+    if (this.sweepTimer) return;
+    this.sweepTimer = setInterval(() => {
+      try {
+        const result = this.sweep();
+        const total =
+          result.ttlEvicted + result.lruEvicted + result.memoryEvicted;
+        if (total > 0) {
+          log.info(result, "Conversation eviction sweep completed");
+        }
+      } catch (err) {
+        log.error({ err }, "Conversation eviction sweep failed");
+      }
+    }, this.sweepIntervalMs);
+  }
+
+  /** Stop the periodic sweep timer. */
+  stop(): void {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+    this.lastAccess.clear();
+  }
+
+  /**
+   * Run a single eviction sweep. Safe to call manually (e.g. from tests)
+   * in addition to the periodic timer.
+   */
+  sweep(): EvictionResult {
+    const now = Date.now();
+    const result: EvictionResult = {
+      ttlEvicted: 0,
+      lruEvicted: 0,
+      memoryEvicted: 0,
+      skipped: 0,
+    };
+
+    // Phase 1: TTL eviction — remove conversations idle longer than ttlMs.
+    for (const [id, conversation] of this.conversations) {
+      const lastAccessTime = this.lastAccess.get(id) ?? 0;
+      if (now - lastAccessTime < this.ttlMs) continue;
+      if (conversation.isProcessing() || this.shouldProtect?.(id)) {
+        result.skipped++;
+        continue;
+      }
+      this.evict(id, conversation);
+      result.ttlEvicted++;
+    }
+
+    // Phase 2: LRU eviction — if still over capacity, evict least-recently-used.
+    if (this.conversations.size > this.maxConversations) {
+      const sorted = this.idleConversationsByLru();
+      for (const [id, conversation] of sorted) {
+        if (this.conversations.size <= this.maxConversations) break;
+        this.evict(id, conversation);
+        result.lruEvicted++;
+      }
+    }
+
+    // Phase 3: Memory pressure — if RSS exceeds threshold, evict idle conversations
+    // starting from least-recently-used until we're under the threshold or
+    // no more idle conversations remain.
+    const rss = process.memoryUsage.rss();
+    if (rss > this.memoryThresholdBytes) {
+      const sorted = this.idleConversationsByLru();
+      if (sorted.length > 0) {
+        log.warn(
+          {
+            rssBytes: rss,
+            thresholdBytes: this.memoryThresholdBytes,
+            conversationCount: this.conversations.size,
+          },
+          "Memory pressure detected, evicting idle conversations",
+        );
+        for (const [id, conversation] of sorted) {
+          if (process.memoryUsage.rss() <= this.memoryThresholdBytes) break;
+          this.evict(id, conversation);
+          result.memoryEvicted++;
+        }
+      }
+    }
+
+    // Clean up stale lastAccess entries for conversations that no longer exist
+    // (e.g. removed by clearAllConversations or evictConversationsForReload).
+    for (const id of this.lastAccess.keys()) {
+      if (!this.conversations.has(id)) {
+        this.lastAccess.delete(id);
+      }
+    }
+
+    return result;
+  }
+
+  /** Current number of tracked conversations (for diagnostics). */
+  get trackedCount(): number {
+    return this.lastAccess.size;
+  }
+
+  // ── Internals ──────────────────────────────────────────────────────
+
+  private evict(id: string, conversation: EvictableConversation): void {
+    conversation.dispose();
+    this.conversations.delete(id);
+    this.lastAccess.delete(id);
+    this.onEvict?.(id);
+    log.debug({ conversationId: id }, "Evicted idle conversation");
+  }
+
+  /**
+   * Return idle (non-processing) conversations sorted by last access time
+   * ascending (least recently used first).
+   */
+  private idleConversationsByLru(): Array<[string, EvictableConversation]> {
+    const idle: Array<[string, EvictableConversation, number]> = [];
+    for (const [id, conversation] of this.conversations) {
+      if (conversation.isProcessing()) continue;
+      if (this.shouldProtect?.(id)) continue;
+      idle.push([id, conversation, this.lastAccess.get(id) ?? 0]);
+    }
+    idle.sort((a, b) => a[2] - b[2]);
+    return idle.map(([id, conversation]) => [id, conversation]);
+  }
+}

package/src/daemon/{session-history.ts → conversation-history.ts}

@@ -17,7 +17,7 @@ import { getLogger } from "../util/logger.js";
 import type { ServerMessage } from "./message-protocol.js";
 import type { TraceEmitter } from "./trace-emitter.js";
 
-const log = getLogger("session-history");
+const log = getLogger("conversation-history");
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
@@ -344,9 +344,9 @@ export function consolidateAssistantMessages(
 // ── Undo ─────────────────────────────────────────────────────────────
 
 /**
- * Subset of Session state that undo/regenerate need access to.
+ * Subset of Conversation state that undo/regenerate need access to.
  */
-export interface HistorySessionContext {
+export interface HistoryConversationContext {
   readonly conversationId: string;
   readonly traceEmitter: TraceEmitter;
   messages: Message[];
@@ -369,14 +369,14 @@ export interface HistorySessionContext {
  * Remove the last user+assistant exchange from memory and DB.
  * Returns the number of messages removed.
  */
-export function undo(session: HistorySessionContext): number {
-  if (session.processing) return 0;
+export function undo(conversation: HistoryConversationContext): number {
+  if (conversation.processing) return 0;
 
-  const lastUserIdx = findLastUndoableUserMessageIndex(session.messages);
+  const lastUserIdx = findLastUndoableUserMessageIndex(conversation.messages);
   if (lastUserIdx === -1) return 0;
 
-  const removed = session.messages.length - lastUserIdx;
-  session.messages = session.messages.slice(0, lastUserIdx);
+  const removed = conversation.messages.length - lastUserIdx;
+  conversation.messages = conversation.messages.slice(0, lastUserIdx);
 
   // Also remove from DB. We may need to call deleteLastExchange multiple
   // times because the DB stores tool_result user messages as separate rows.
@@ -391,15 +391,15 @@ export function undo(session: HistorySessionContext): number {
   // deleteLastExchange when the loop peeled back tool_result messages.
   let hadToolResult = false;
   do {
-    deleteLastExchange(session.conversationId);
-    if (isLastUserMessageToolResult(session.conversationId)) {
+    deleteLastExchange(conversation.conversationId);
+    if (isLastUserMessageToolResult(conversation.conversationId)) {
       hadToolResult = true;
     } else {
       break;
     }
   } while (true);
   if (hadToolResult) {
-    deleteLastExchange(session.conversationId);
+    deleteLastExchange(conversation.conversationId);
   }
 
   return removed;
@@ -413,14 +413,14 @@ export function undo(session: HistorySessionContext): number {
  * Qdrant, then re-run the agent loop with the same user message.
  */
 export async function regenerate(
-  session: HistorySessionContext,
+  conversation: HistoryConversationContext,
   onEvent: (msg: ServerMessage) => void,
   requestId?: string,
 ): Promise<void> {
-  if (session.processing) {
+  if (conversation.processing) {
     onEvent({ type: "error", message: "Cannot regenerate while processing" });
     if (requestId) {
-      session.traceEmitter.emit(
+      conversation.traceEmitter.emit(
         "request_error",
         "Cannot regenerate while processing",
         {
@@ -435,24 +435,28 @@ export async function regenerate(
 
   // Find the last undoable user message — everything after it is the
   // assistant's exchange that we want to regenerate.
-  const lastUserIdx = findLastUndoableUserMessageIndex(session.messages);
+  const lastUserIdx = findLastUndoableUserMessageIndex(conversation.messages);
   if (lastUserIdx === -1) {
     onEvent({ type: "error", message: "No messages to regenerate" });
     if (requestId) {
-      session.traceEmitter.emit("request_error", "No messages to regenerate", {
-        requestId,
-        status: "error",
-        attributes: { reason: "no_messages" },
-      });
+      conversation.traceEmitter.emit(
+        "request_error",
+        "No messages to regenerate",
+        {
+          requestId,
+          status: "error",
+          attributes: { reason: "no_messages" },
+        },
+      );
     }
     return;
   }
 
   // There must be at least one message after the user message (the assistant reply).
-  if (lastUserIdx >= session.messages.length - 1) {
+  if (lastUserIdx >= conversation.messages.length - 1) {
     onEvent({ type: "error", message: "No assistant response to regenerate" });
     if (requestId) {
-      session.traceEmitter.emit(
+      conversation.traceEmitter.emit(
         "request_error",
         "No assistant response to regenerate",
         {
@@ -466,11 +470,11 @@ export async function regenerate(
   }
 
   // Remove the assistant's exchange from in-memory history (keep the user message).
-  session.messages = session.messages.slice(0, lastUserIdx + 1);
+  conversation.messages = conversation.messages.slice(0, lastUserIdx + 1);
 
   // Find DB message IDs to delete: get all messages from the DB, then
   // identify the ones that come after the last user message.
-  const dbMessages = getMessages(session.conversationId);
+  const dbMessages = getMessages(conversation.conversationId);
 
   // Walk backwards to find the last real (non-tool_result) user message in the DB.
   let dbUserMsgIdx = -1;
@@ -495,7 +499,7 @@ export async function regenerate(
   if (dbUserMsgIdx === -1) {
     onEvent({ type: "error", message: "No user message found in DB" });
     if (requestId) {
-      session.traceEmitter.emit(
+      conversation.traceEmitter.emit(
         "request_error",
         "No user message found in DB",
         {
@@ -526,12 +530,12 @@ export async function regenerate(
 
   // Clean up Qdrant vectors (fire-and-forget).
   cleanupQdrantVectors(
-    session.conversationId,
+    conversation.conversationId,
     allSegmentIds,
     allOrphanedItemIds,
   ).catch((err) => {
     log.warn(
-      { err, conversationId: session.conversationId },
+      { err, conversationId: conversation.conversationId },
       "Qdrant cleanup after regenerate failed (non-fatal)",
     );
   });
@@ -539,7 +543,7 @@ export async function regenerate(
   // Re-extract the user message content for the agent loop.
   // Use all content blocks (text, image, file) so attachments are
   // preserved — not just text blocks.
-  const userMessage = session.messages[lastUserIdx];
+  const userMessage = conversation.messages[lastUserIdx];
   const textBlocks = userMessage.content.filter((b) => b.type === "text");
   const content = textBlocks
     .map((b) => (b as { type: "text"; text: string }).text)
@@ -549,17 +553,17 @@ export async function regenerate(
   onEvent({
     type: "undo_complete",
     removedCount: messagesToDelete.length,
-    sessionId: session.conversationId,
+    conversationId: conversation.conversationId,
   });
 
   // Set up processing state manually and call runAgentLoop directly,
   // bypassing processMessage to avoid duplicating the user message
   // in both this.messages and the DB.
-  session.processing = true;
-  session.abortController = new AbortController();
-  session.currentRequestId = requestId ?? uuid();
+  conversation.processing = true;
+  conversation.abortController = new AbortController();
+  conversation.currentRequestId = requestId ?? uuid();
 
-  await session.runAgentLoop(content, existingUserMessageId, onEvent, {
+  await conversation.runAgentLoop(content, existingUserMessageId, onEvent, {
     skipPreMessageRollback: true,
     isUserMessage: true,
   });

package/src/daemon/{session-lifecycle.ts → conversation-lifecycle.ts}

@@ -1,6 +1,6 @@
 /**
- * Session lifecycle methods extracted from Session: loadFromDb, abort,
- * and dispose. Each operates on a context interface so the Session class
+ * Conversation lifecycle methods extracted from Conversation: loadFromDb, abort,
+ * and dispose. Each operates on a context interface so the Conversation class
  * can delegate without exposing its full surface.
  */
 
@@ -21,22 +21,22 @@ import {
   isUntrustedTrustClass,
   type TrustClass,
 } from "../runtime/actor-trust-resolver.js";
-import { unregisterSessionSender } from "../tools/browser/browser-screencast.js";
+import { unregisterConversationSender } from "../tools/browser/browser-screencast.js";
 import { getLogger } from "../util/logger.js";
+import {
+  unregisterCallNotifiers,
+  unregisterWatchNotifiers,
+} from "./conversation-notifiers.js";
+import type { MessageQueue } from "./conversation-queue-manager.js";
+import { resetSkillToolProjection } from "./conversation-skill-tools.js";
 import { repairHistory } from "./history-repair.js";
 import type {
   SurfaceData,
   SurfaceType,
   UsageStats,
 } from "./message-protocol.js";
-import {
-  unregisterCallNotifiers,
-  unregisterWatchNotifiers,
-} from "./session-notifiers.js";
-import type { MessageQueue } from "./session-queue-manager.js";
-import { resetSkillToolProjection } from "./session-skill-tools.js";
 
-const log = getLogger("session-lifecycle");
+const log = getLogger("conversation-lifecycle");
 
 function parseProvenanceTrustClass(
   metadata: string | null,
@@ -204,7 +204,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
 // ── abort ─────────────────────────────────────────────────────────────
 
-export function abortSession(ctx: AbortContext): void {
+export function abortConversation(ctx: AbortContext): void {
   if (ctx.processing) {
     log.info(
       { conversationId: ctx.conversationId },
@@ -220,7 +220,7 @@ export function abortSession(ctx: AbortContext): void {
     for (const queued of ctx.queue) {
       queued.onEvent({
         type: "generation_cancelled",
-        sessionId: ctx.conversationId,
+        conversationId: ctx.conversationId,
       });
     }
     ctx.queue.clear();
@@ -229,13 +229,13 @@ export function abortSession(ctx: AbortContext): void {
 
 // ── dispose ──────────────────────────────────────────────────────────
 
-export function disposeSession(ctx: DisposeContext): void {
-  void getHookManager().trigger("session-end", {
-    sessionId: ctx.conversationId,
+export function disposeConversation(ctx: DisposeContext): void {
+  void getHookManager().trigger("conversation-end", {
+    conversationId: ctx.conversationId,
   });
   ctx.abort();
   unregisterCallNotifiers(ctx.conversationId);
-  unregisterSessionSender(ctx.conversationId);
+  unregisterConversationSender(ctx.conversationId);
   resetSkillToolProjection(ctx.skillProjectionState);
   ctx.eventBus.dispose();
 

package/src/daemon/{session-memory.ts → conversation-memory.ts}

@@ -131,7 +131,7 @@ export async function prepareMemoryContext(
       })
     : undefined;
   // Build scope policy override for non-default scopes so retrieval
-  // honours the session's memory policy regardless of the global config.
+  // honours the conversation's memory policy regardless of the global config.
   const scopePolicyOverride: ScopePolicyOverride | undefined =
     ctx.scopeId !== "default"
       ? { scopeId: ctx.scopeId, fallbackToDefault: ctx.includeDefaultFallback }

package/src/daemon/{session-messaging.ts → conversation-messaging.ts}

@@ -1,8 +1,8 @@
 /**
- * Session messaging methods: enqueue, persistUserMessage,
+ * Conversation messaging methods: enqueue, persistUserMessage,
  * redirectToSecurePrompt, and queue/confirmation helpers.
  *
- * Extracted from Session to keep the class focused on coordination.
+ * Extracted from Conversation to keep the class focused on coordination.
  */
 
 import { v4 as uuid } from "uuid";
@@ -28,14 +28,14 @@ import {
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
+import type { MessageQueue } from "./conversation-queue-manager.js";
+import type { TrustContext } from "./conversation-runtime-assembly.js";
 import type {
   ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
-import type { MessageQueue } from "./session-queue-manager.js";
-import type { TrustContext } from "./session-runtime-assembly.js";
 
-const log = getLogger("session-messaging");
+const log = getLogger("conversation-messaging");
 
 interface IngressSecretTarget {
   service: string;
@@ -166,7 +166,7 @@ function resolveIngressSecretTarget(
 
 // ── Context Interface ────────────────────────────────────────────────
 
-export interface MessagingSessionContext {
+export interface MessagingConversationContext {
   readonly conversationId: string;
   messages: Message[];
   processing: boolean;
@@ -205,7 +205,7 @@ function extractTurnInterfaceContext(
 // ── enqueueMessage ───────────────────────────────────────────────────
 
 export function enqueueMessage(
-  ctx: MessagingSessionContext,
+  ctx: MessagingConversationContext,
   content: string,
   attachments: UserMessageAttachment[],
   onEvent: (msg: ServerMessage) => void,
@@ -256,7 +256,7 @@ export function enqueueMessage(
 // ── persistUserMessage ───────────────────────────────────────────────
 
 export async function persistUserMessage(
-  ctx: MessagingSessionContext,
+  ctx: MessagingConversationContext,
   content: string,
   attachments: UserMessageAttachment[],
   requestId?: string,
@@ -264,7 +264,7 @@ export async function persistUserMessage(
   displayContent?: string,
 ): Promise<string> {
   if (ctx.processing) {
-    throw new Error("Session is already processing a message");
+    throw new Error("Conversation is already processing a message");
   }
 
   if (!content.trim() && attachments.length === 0) {

package/src/daemon/{session-notifiers.ts → conversation-notifiers.ts}

@@ -1,6 +1,6 @@
 /**
  * Watch and call notifier registration/unregistration, extracted from
- * the Session constructor and dispose/abort methods.
+ * the Conversation constructor and dispose/abort methods.
  *
  * Notifier callbacks read from the provided context object at invocation
  * time (not registration time), so they always see the latest sendToClient
@@ -33,36 +33,36 @@ import {
   unregisterWatchCompletionNotifier,
   unregisterWatchStartNotifier,
 } from "../tools/watch/watch-state.js";
+import type { TrustContext } from "./conversation-runtime-assembly.js";
 import type { ServerMessage } from "./message-protocol.js";
-import type { TrustContext } from "./session-runtime-assembly.js";
 import {
-  lastCommentaryBySession,
-  lastSummaryBySession,
+  lastCommentaryByConversation,
+  lastSummaryByConversation,
 } from "./watch-handler.js";
 
 /**
- * Subset of Session state that notifier callbacks need to read at
+ * Subset of Conversation state that notifier callbacks need to read at
  * invocation time. Properties are read lazily from this reference.
  */
-export interface NotifierSessionContext {
+export interface NotifierConversationContext {
   sendToClient: (msg: ServerMessage) => void;
   messages: Message[];
   trustContext?: TrustContext;
 }
 
 /**
- * Register watch and call notifiers for a session. Call once during
+ * Register watch and call notifiers for a conversation. Call once during
  * construction; the notifier callbacks close over `ctx` so they see
  * live sendToClient/messages values.
  */
-export function registerSessionNotifiers(
+export function registerConversationNotifiers(
   conversationId: string,
-  ctx: NotifierSessionContext,
+  ctx: NotifierConversationContext,
 ): void {
   registerWatchStartNotifier(conversationId, (session: WatchSession) => {
     ctx.sendToClient({
       type: "watch_started",
-      sessionId: conversationId,
+      conversationId: conversationId,
       watchId: session.watchId,
       durationSeconds: session.durationSeconds,
       intervalSeconds: session.intervalSeconds,
@@ -70,33 +70,33 @@ export function registerSessionNotifiers(
   });
 
   registerWatchCommentaryNotifier(conversationId, (_session: WatchSession) => {
-    const commentary = lastCommentaryBySession.get(conversationId);
+    const commentary = lastCommentaryByConversation.get(conversationId);
     if (commentary) {
-      lastCommentaryBySession.delete(conversationId);
+      lastCommentaryByConversation.delete(conversationId);
       ctx.sendToClient({
         type: "assistant_text_delta",
         text: commentary,
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
       ctx.sendToClient({
         type: "message_complete",
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
     }
   });
 
   registerWatchCompletionNotifier(conversationId, (_session: WatchSession) => {
-    const summary = lastSummaryBySession.get(conversationId);
+    const summary = lastSummaryByConversation.get(conversationId);
     if (summary) {
-      lastSummaryBySession.delete(conversationId);
+      lastSummaryByConversation.delete(conversationId);
       ctx.sendToClient({
         type: "assistant_text_delta",
         text: summary,
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
       ctx.sendToClient({
         type: "message_complete",
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
     }
   });
@@ -126,11 +126,11 @@ export function registerSessionNotifiers(
       ctx.sendToClient({
         type: "assistant_text_delta",
         text: questionText,
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
       ctx.sendToClient({
         type: "message_complete",
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
     },
   );
@@ -144,11 +144,11 @@ export function registerSessionNotifiers(
       ctx.sendToClient({
         type: "assistant_text_delta",
         text: transcriptText,
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
       ctx.sendToClient({
         type: "message_complete",
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
     },
   );
@@ -159,18 +159,18 @@ export function registerSessionNotifiers(
     ctx.sendToClient({
       type: "assistant_text_delta",
       text: summaryText,
-      sessionId: conversationId,
+      conversationId: conversationId,
     });
     ctx.sendToClient({
       type: "message_complete",
-      sessionId: conversationId,
+      conversationId: conversationId,
     });
   });
 }
 
 /**
  * Unregister watch notifiers and prune watch sessions. Called during
- * abort when the session is actively processing.
+ * abort when the conversation is actively processing.
  */
 export function unregisterWatchNotifiers(conversationId: string): void {
   unregisterWatchStartNotifier(conversationId);