@vellumai/assistant 0.4.54 → 0.4.56

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

@@ -16,20 +16,20 @@ import {
   parseInterfaceId,
 } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
-import { renderHistoryContent } from "../../daemon/handlers/shared.js";
-import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
-import { HostCuProxy } from "../../daemon/host-cu-proxy.js";
-import { HostFileProxy } from "../../daemon/host-file-proxy.js";
-import type { ServerMessage } from "../../daemon/message-protocol.js";
 import {
   buildModelInfoEvent,
   isModelSlashCommand,
-} from "../../daemon/session-process.js";
+} from "../../daemon/conversation-process.js";
 import {
   isProviderShortcut,
   resolveSlash,
   type SlashContext,
-} from "../../daemon/session-slash.js";
+} from "../../daemon/conversation-slash.js";
+import { renderHistoryContent } from "../../daemon/handlers/shared.js";
+import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
+import { HostCuProxy } from "../../daemon/host-cu-proxy.js";
+import { HostFileProxy } from "../../daemon/host-file-proxy.js";
+import type { ServerMessage } from "../../daemon/message-protocol.js";
 import * as attachmentsStore from "../../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
@@ -52,6 +52,7 @@ import { getConfiguredProvider } from "../../providers/provider-send-message.js"
 import type { Provider } from "../../providers/types.js";
 import { checkIngressForSecrets } from "../../security/secret-ingress.js";
 import { getLogger } from "../../util/logger.js";
+import { silentlyWithLog } from "../../util/silently.js";
 import { buildAssistantEvent } from "../assistant-event.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import type { AuthContext } from "../auth/types.js";
@@ -78,7 +79,7 @@ const SUGGESTION_CACHE_MAX = 100;
 function collectCanonicalGuardianRequestHintIds(
   conversationId: string,
   sourceChannel: string,
-  session: import("../../daemon/session.js").Session,
+  conversation: import("../../daemon/conversation.js").Conversation,
 ): string[] {
   const requests = listPendingRequestsByConversationScope(
     conversationId,
@@ -88,7 +89,8 @@ function collectCanonicalGuardianRequestHintIds(
   return requests
     .filter(
       (req) =>
-        req.kind !== "tool_approval" || session.hasPendingConfirmation(req.id),
+        req.kind !== "tool_approval" ||
+        conversation.hasPendingConfirmation(req.id),
     )
     .map((req) => req.id);
 }
@@ -104,7 +106,7 @@ async function tryConsumeCanonicalGuardianReply(params: {
     mimeType: string;
     data: string;
   }>;
-  session: import("../../daemon/session.js").Session;
+  conversation: import("../../daemon/conversation.js").Conversation;
   onEvent: (msg: ServerMessage) => void;
   approvalConversationGenerator?: ApprovalConversationGenerator;
   /** Verified actor identity from actor-token middleware. */
@@ -118,7 +120,7 @@ async function tryConsumeCanonicalGuardianReply(params: {
     sourceInterface,
     content,
     attachments,
-    session,
+    conversation,
     onEvent,
     approvalConversationGenerator,
     verifiedActorExternalUserId,
@@ -133,7 +135,7 @@ async function tryConsumeCanonicalGuardianReply(params: {
   const pendingRequestHintIds = collectCanonicalGuardianRequestHintIds(
     conversationId,
     sourceChannel,
-    session,
+    conversation,
   );
   const pendingRequestIds =
     pendingRequestHintIds.length > 0 ? pendingRequestHintIds : undefined;
@@ -165,8 +167,8 @@ async function tryConsumeCanonicalGuardianReply(params: {
   // However, stale/failed paths never reach handleConfirmationResponse,
   // so we emit resolved_stale here for those cases.
   if (routerResult.requestId && !routerResult.decisionApplied) {
-    session.emitConfirmationStateChanged({
-      sessionId: conversationId,
+    conversation.emitConfirmationStateChanged({
+      conversationId: conversationId,
       requestId: routerResult.requestId,
       state: "resolved_stale",
       source: "inline_nl",
@@ -210,14 +212,14 @@ async function tryConsumeCanonicalGuardianReply(params: {
     );
 
     // Avoid mutating in-memory history / emitting stream deltas while a run is active.
-    if (!session.isProcessing()) {
-      session.getMessages().push(userMessage, assistantMessage);
+    if (!conversation.isProcessing()) {
+      conversation.getMessages().push(userMessage, assistantMessage);
       onEvent({
         type: "assistant_text_delta",
         text: replyText,
-        sessionId: conversationId,
+        conversationId: conversationId,
       });
-      onEvent({ type: "message_complete", sessionId: conversationId });
+      onEvent({ type: "message_complete", conversationId: conversationId });
     }
   } catch (err) {
     log.warn(
@@ -317,73 +319,44 @@ export function handleListMessages(
   const messages: RuntimeMessagePayload[] = parsed.map((m) => {
     let msgAttachments: RuntimeAttachmentMetadata[] = [];
     if (m.id) {
-      if (m.role === "user") {
-        // Use metadata-only query first to avoid loading large base64
-        // blobs for non-image attachments (documents, audio). Then
-        // selectively fetch full data only for images so the client can
-        // generate thumbnails for inline display on history restore.
-        const linked = attachmentsStore.getAttachmentMetadataForMessage(m.id);
-        if (linked.length > 0) {
-          msgAttachments = linked.map((a) => {
-            if (a.mimeType.startsWith("image/")) {
-              const full = attachmentsStore.getAttachmentById(a.id);
-              return {
-                id: a.id,
-                filename: a.originalFilename,
-                mimeType: a.mimeType,
-                sizeBytes: a.sizeBytes,
-                kind: a.kind,
-                ...(full?.dataBase64 ? { data: full.dataBase64 } : {}),
-                ...(a.thumbnailBase64
-                  ? { thumbnailData: a.thumbnailBase64 }
-                  : {}),
-              };
-            }
-            return {
-              id: a.id,
-              filename: a.originalFilename,
-              mimeType: a.mimeType,
-              sizeBytes: a.sizeBytes,
-              kind: a.kind,
-              ...(a.thumbnailBase64
-                ? { thumbnailData: a.thumbnailBase64 }
-                : {}),
-            };
-          });
-        }
-      } else {
-        const linked =
-          attachmentsStore.getAttachmentMetadataForMessage(m.id);
-        if (linked.length > 0) {
-          msgAttachments = linked.map((a) => {
-            if (a.mimeType.startsWith("image/")) {
-              const full = attachmentsStore.getAttachmentById(a.id);
-              return {
-                id: a.id,
-                filename: a.originalFilename,
-                mimeType: a.mimeType,
-                sizeBytes: a.sizeBytes,
-                kind: a.kind,
-                ...(full?.dataBase64
-                  ? { data: full.dataBase64 }
-                  : {}),
-                ...(a.thumbnailBase64
-                  ? { thumbnailData: a.thumbnailBase64 }
-                  : {}),
-              };
-            }
+      // Use metadata-only query first to avoid loading large base64
+      // blobs for non-image attachments (documents, audio). Then
+      // selectively fetch full data only for images so the client can
+      // generate thumbnails for inline display on history restore.
+      const linked = attachmentsStore.getAttachmentMetadataForMessage(m.id);
+      if (linked.length > 0) {
+        // Batch-fetch file-backed status for all attachments in one query
+        // instead of issuing a separate query per attachment.
+        const fileBackedIds = attachmentsStore.getFileBackedAttachmentIds(
+          linked.map((a) => a.id),
+        );
+        msgAttachments = linked.map((a) => {
+          const isFileBacked = fileBackedIds.has(a.id);
+          if (a.mimeType.startsWith("image/")) {
+            const full = attachmentsStore.getAttachmentById(a.id);
             return {
               id: a.id,
               filename: a.originalFilename,
               mimeType: a.mimeType,
               sizeBytes: a.sizeBytes,
               kind: a.kind,
+              ...(full?.dataBase64 ? { data: full.dataBase64 } : {}),
               ...(a.thumbnailBase64
                 ? { thumbnailData: a.thumbnailBase64 }
                 : {}),
+              ...(isFileBacked ? { fileBacked: true } : {}),
             };
-          });
-        }
+          }
+          return {
+            id: a.id,
+            filename: a.originalFilename,
+            mimeType: a.mimeType,
+            sizeBytes: a.sizeBytes,
+            kind: a.kind,
+            ...(a.thumbnailBase64 ? { thumbnailData: a.thumbnailBase64 } : {}),
+            ...(isFileBacked ? { fileBacked: true } : {}),
+          };
+        });
       }
     }
 
@@ -425,20 +398,20 @@ export function handleListMessages(
  *
  * Also registers pending interactions when confirmation_request,
  * secret_request, host_bash_request, or host_file_request events flow
- * through, so standalone approval/result endpoints can look up the session
+ * through, so standalone approval/result endpoints can look up the conversation
  * by requestId.
  */
 function makeHubPublisher(
   deps: SendMessageDeps,
   conversationId: string,
-  session: import("../../daemon/session.js").Session,
+  conversation: import("../../daemon/conversation.js").Conversation,
 ): (msg: ServerMessage) => void {
   let hubChain: Promise<void> = Promise.resolve();
   return (msg: ServerMessage) => {
     // Register pending interactions for approval events
     if (msg.type === "confirmation_request") {
       pendingInteractions.register(msg.requestId, {
-        session,
+        conversation,
         conversationId,
         kind: "confirmation",
         confirmationDetails: {
@@ -456,7 +429,7 @@ function makeHubPublisher(
       // 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,
@@ -471,10 +444,10 @@ function makeHubPublisher(
           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
+        // For trusted-contact conversations, bridge to guardian.question so the
         // guardian gets notified and can approve via callback/request-code.
         if (trustContext) {
           bridgeConfirmationRequestToGuardian({
@@ -482,7 +455,8 @@ function makeHubPublisher(
             trustContext,
             conversationId,
             toolName: msg.toolName,
-            assistantId: session.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
+            assistantId:
+              conversation.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
           });
         }
       } catch (err) {
@@ -493,35 +467,35 @@ function makeHubPublisher(
       }
     } 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",
       });
     }
 
-    // ServerMessage is a large union; sessionId exists on most but not all variants.
+    // ServerMessage is a large union; conversationId exists on most but not all variants.
     const msgSessionId =
-      "sessionId" in msg &&
-      typeof (msg as { sessionId?: unknown }).sessionId === "string"
-        ? (msg as { sessionId: string }).sessionId
+      "conversationId" in msg &&
+      typeof (msg as { conversationId?: unknown }).conversationId === "string"
+        ? (msg as { conversationId: string }).conversationId
         : undefined;
     const resolvedSessionId = msgSessionId ?? conversationId;
     const event = buildAssistantEvent(
@@ -557,6 +531,8 @@ export async function handleSendMessage(
     attachmentIds?: string[];
     sourceChannel?: string;
     interface?: string;
+    conversationType?: string;
+    automated?: boolean;
   };
 
   const { conversationKey, content, attachmentIds } = body;
@@ -655,9 +631,15 @@ export async function handleSendMessage(
     );
   }
 
-  const mapping = getOrCreateConversation(conversationKey);
+  const conversationType =
+    body.conversationType === "private" ? ("private" as const) : undefined;
+  const mapping = getOrCreateConversation(conversationKey, {
+    conversationType,
+  });
   const smDeps = deps.sendMessageDeps;
-  const session = await smDeps.getOrCreateSession(mapping.conversationId);
+  const conversation = await smDeps.getOrCreateConversation(
+    mapping.conversationId,
+  );
 
   // Resolve guardian context from the AuthContext's actorPrincipalId.
   // The JWT-verified principal is used as the sender identity through
@@ -670,61 +652,65 @@ export async function handleSendMessage(
       conversationExternalId: "local",
       actorExternalId: authContext.actorPrincipalId,
     });
-    session.setTrustContext(withSourceChannel(sourceChannel, trustCtx));
+    conversation.setTrustContext(withSourceChannel(sourceChannel, trustCtx));
   } else {
     // Service principals (svc_gateway) or tokens without an actor ID
     // get a minimal guardian context so downstream code has something.
-    session.setTrustContext({ trustClass: "guardian", sourceChannel });
+    conversation.setTrustContext({ trustClass: "guardian", sourceChannel });
   }
 
-  const onEvent = makeHubPublisher(smDeps, mapping.conversationId, session);
+  const onEvent = makeHubPublisher(
+    smDeps,
+    mapping.conversationId,
+    conversation,
+  );
   const isInteractive = isInteractiveInterface(sourceInterface);
   // 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.
   // Set the proxy BEFORE updateClient so updateClient's call to
   // hostBashProxy.updateSender targets the correct (new) proxy.
   if (sourceInterface === "macos" || sourceInterface === "ios") {
-    // Reuse the existing proxy if the session is actively processing a
+    // Reuse the existing proxy if the conversation is actively processing a
     // host bash request to avoid orphaning in-flight requests.
-    if (!session.isProcessing() || !session.hostBashProxy) {
+    if (!conversation.isProcessing() || !conversation.hostBashProxy) {
       const proxy = new HostBashProxy(onEvent, (requestId) => {
         pendingInteractions.resolve(requestId);
       });
-      session.setHostBashProxy(proxy);
+      conversation.setHostBashProxy(proxy);
     }
-    if (!session.isProcessing() || !session.hostFileProxy) {
+    if (!conversation.isProcessing() || !conversation.hostFileProxy) {
       const fileProxy = new HostFileProxy(onEvent, (requestId) => {
         pendingInteractions.resolve(requestId);
       });
-      session.setHostFileProxy(fileProxy);
+      conversation.setHostFileProxy(fileProxy);
     }
-    if (!session.isProcessing() || !session.hostCuProxy) {
+    if (!conversation.isProcessing() || !conversation.hostCuProxy) {
       const cuProxy = new HostCuProxy(onEvent, (requestId) => {
         pendingInteractions.resolve(requestId);
       });
-      session.setHostCuProxy(cuProxy);
+      conversation.setHostCuProxy(cuProxy);
     }
-    // Only preactivate CU when the session is idle — if the session is
+    // Only preactivate CU when the conversation is idle — if the conversation is
     // processing, this message will be queued and preactivation is deferred
     // to dequeue time in drainQueueImpl to avoid mutating in-flight turn state.
-    if (!session.isProcessing()) {
-      session.addPreactivatedSkillId("computer-use");
+    if (!conversation.isProcessing()) {
+      conversation.addPreactivatedSkillId("computer-use");
     }
-  } else if (!session.isProcessing()) {
-    session.setHostBashProxy(undefined);
-    session.setHostFileProxy(undefined);
-    session.setHostCuProxy(undefined);
+  } else if (!conversation.isProcessing()) {
+    conversation.setHostBashProxy(undefined);
+    conversation.setHostFileProxy(undefined);
+    conversation.setHostCuProxy(undefined);
   }
   // Wire sendToClient to the SSE hub so all subsystems can reach the HTTP client.
   // Called after setHostBashProxy so updateSender targets the current proxy.
   // When proxies are preserved during an active turn (non-desktop request while
   // processing), skip updating proxy senders to avoid degrading them.
   const preservingProxies =
-    session.isProcessing() &&
+    conversation.isProcessing() &&
     sourceInterface !== "macos" &&
     sourceInterface !== "ios";
-  session.updateClient(onEvent, !isInteractive, {
+  conversation.updateClient(onEvent, !isInteractive, {
     skipProxySenderUpdate: preservingProxies,
   });
 
@@ -733,11 +719,11 @@ export async function handleSendMessage(
     : [];
 
   // Resolve the verified actor's external user ID and principal for inline
-  // approval routing from the session's guardian context.
+  // approval routing from the conversation's guardian context.
   const verifiedActorExternalUserId =
-    session.trustContext?.guardianExternalUserId;
+    conversation.trustContext?.guardianExternalUserId;
   const verifiedActorPrincipalId =
-    session.trustContext?.guardianPrincipalId ?? undefined;
+    conversation.trustContext?.guardianPrincipalId ?? undefined;
 
   // Try to consume the message as a canonical guardian approval/rejection reply.
   // On failure, degrade to the existing queue/auto-deny path rather than
@@ -749,11 +735,11 @@ export async function handleSendMessage(
       sourceInterface,
       content: content ?? "",
       attachments,
-      session,
+      conversation,
       onEvent,
       // Desktop path: disable NL classification to avoid consuming non-decision
       // messages while a tool confirmation is pending. Deterministic code-prefix
-      // and callback parsing remain active. Mirrors session-process.ts behavior.
+      // and callback parsing remain active. Mirrors conversation-process.ts behavior.
       approvalConversationGenerator:
         sourceChannel === "vellum"
           ? undefined
@@ -780,10 +766,10 @@ export async function handleSendMessage(
     );
   }
 
-  if (session.isProcessing()) {
+  if (conversation.isProcessing()) {
     // Queue the message so it's processed when the current turn completes
     const requestId = crypto.randomUUID();
-    const enqueueResult = session.enqueueMessage(
+    const enqueueResult = conversation.enqueueMessage(
       content ?? "",
       attachments,
       onEvent,
@@ -795,6 +781,7 @@ export async function handleSendMessage(
         assistantMessageChannel: sourceChannel,
         userMessageInterface: sourceInterface,
         assistantMessageInterface: sourceInterface,
+        ...(body.automated === true ? { automated: true } : {}),
       },
       { isInteractive },
     );
@@ -808,26 +795,26 @@ export async function handleSendMessage(
     // Auto-deny pending confirmations only after enqueue succeeds, so we
     // don't cancel approval-gated workflows when the replacement message
     // is itself rejected by the queue budget.
-    if (session.hasAnyPendingConfirmation()) {
+    if (conversation.hasAnyPendingConfirmation()) {
       // Emit authoritative denial state for each pending request.
       // sendToClient (wired to the SSE hub) delivers these to the client.
       for (const interaction of pendingInteractions.getByConversation(
         mapping.conversationId,
       )) {
         if (
-          interaction.session === session &&
+          interaction.conversation === conversation &&
           interaction.kind === "confirmation"
         ) {
-          session.emitConfirmationStateChanged({
-            sessionId: mapping.conversationId,
+          conversation.emitConfirmationStateChanged({
+            conversationId: mapping.conversationId,
             requestId: interaction.requestId,
             state: "denied" as const,
             source: "auto_deny" as const,
           });
         }
       }
-      session.denyAllPendingConfirmations();
-      pendingInteractions.removeBySession(session);
+      conversation.denyAllPendingConfirmations();
+      pendingInteractions.removeByConversation(conversation);
     }
 
     return Response.json(
@@ -836,68 +823,69 @@ export async function handleSendMessage(
     );
   }
 
-  // Auto-deny pending confirmations for idle sessions. The legacy
+  // Auto-deny pending confirmations for idle conversations. The legacy
   // handleUserMessage called autoDenyPendingConfirmations unconditionally
-  // before dispatching, so an idle session with lingering confirmations
+  // before dispatching, so an idle conversation with lingering confirmations
   // (e.g. the user never responded to a tool-approval prompt) must deny
   // them before starting the new turn.
-  if (session.hasAnyPendingConfirmation()) {
+  if (conversation.hasAnyPendingConfirmation()) {
     for (const interaction of pendingInteractions.getByConversation(
       mapping.conversationId,
     )) {
       if (
-        interaction.session === session &&
+        interaction.conversation === conversation &&
         interaction.kind === "confirmation"
       ) {
-        session.emitConfirmationStateChanged({
-          sessionId: mapping.conversationId,
+        conversation.emitConfirmationStateChanged({
+          conversationId: mapping.conversationId,
           requestId: interaction.requestId,
           state: "denied" as const,
           source: "auto_deny" as const,
         });
       }
     }
-    session.denyAllPendingConfirmations();
-    pendingInteractions.removeBySession(session);
+    conversation.denyAllPendingConfirmations();
+    pendingInteractions.removeByConversation(conversation);
   }
 
-  // Session is idle — persist and fire agent loop immediately
-  session.setTurnChannelContext({
+  // Conversation is idle — persist and fire agent loop immediately
+  conversation.setTurnChannelContext({
     userMessageChannel: sourceChannel,
     assistantMessageChannel: sourceChannel,
   });
-  session.setTurnInterfaceContext({
+  conversation.setTurnInterfaceContext({
     userMessageInterface: sourceInterface,
     assistantMessageInterface: sourceInterface,
   });
 
-  await session.ensureActorScopedHistory();
+  await conversation.ensureActorScopedHistory();
 
   // Resolve slash commands before persisting or running the agent loop.
   const rawContent = content ?? "";
   const config = getConfig();
   const slashContext: SlashContext = {
-    messageCount: session.getMessages().length,
-    inputTokens: session.usageStats.inputTokens,
-    outputTokens: session.usageStats.outputTokens,
+    messageCount: conversation.getMessages().length,
+    inputTokens: conversation.usageStats.inputTokens,
+    outputTokens: conversation.usageStats.outputTokens,
     maxInputTokens: config.contextWindow.maxInputTokens,
-    model: config.model,
-    provider: config.provider,
-    estimatedCost: session.usageStats.estimatedCost,
+    model: config.services.inference.model,
+    provider: config.services.inference.provider,
+    estimatedCost: conversation.usageStats.estimatedCost,
   };
   const slashResult = await resolveSlash(rawContent, slashContext);
 
   if (slashResult.kind === "unknown") {
-    session.processing = true;
+    conversation.processing = true;
     let cleanupDeferred = false;
     try {
-      const provenance = provenanceFromTrustContext(session.trustContext);
+      const provenance = provenanceFromTrustContext(conversation.trustContext);
       const channelMeta = {
         ...provenance,
         userMessageChannel: sourceChannel,
         assistantMessageChannel: sourceChannel,
         userMessageInterface: sourceInterface,
         assistantMessageInterface: sourceInterface,
+        ...(body.automated === true ? { automated: true } : {}),
       };
       const userMsg = createUserMessage(rawContent, attachments);
       const persisted = await addMessage(
@@ -906,7 +894,7 @@ export async function handleSendMessage(
         JSON.stringify(userMsg.content),
         channelMeta,
       );
-      session.getMessages().push(userMsg);
+      conversation.getMessages().push(userMsg);
 
       const assistantMsg = createAssistantMessage(slashResult.message);
       await addMessage(
@@ -915,7 +903,7 @@ export async function handleSendMessage(
         JSON.stringify(assistantMsg.content),
         channelMeta,
       );
-      session.getMessages().push(assistantMsg);
+      conversation.getMessages().push(assistantMsg);
 
       setConversationOriginChannelIfUnset(
         mapping.conversationId,
@@ -945,9 +933,9 @@ export async function handleSendMessage(
       // Defer event publishing to next tick so the HTTP response reaches the
       // client first. This ensures the client's serverToLocalSessionMap is
       // populated before SSE events arrive, preventing dropped events in new
-      // desktop threads.
+      // desktop conversations.
       //
-      // session.processing and drainQueue are also deferred so the current
+      // conversation.processing and drainQueue are also deferred so the current
       // slash command's events are emitted before the next queued message
       // starts processing.
       const conversationId = mapping.conversationId;
@@ -959,10 +947,10 @@ export async function handleSendMessage(
         onEvent({ type: "assistant_text_delta", text: message });
         onEvent({
           type: "message_complete",
-          sessionId: conversationId,
+          conversationId: conversationId,
         });
-        session.processing = false;
-        session.drainQueue().catch(() => {});
+        conversation.processing = false;
+        silentlyWithLog(conversation.drainQueue(), "slash-command queue drain");
       }, 0);
 
       cleanupDeferred = true;
@@ -970,35 +958,30 @@ export async function handleSendMessage(
     } finally {
       // No-op for the slash-command early-return path (handled inside
       // setTimeout above), but still needed for error paths.
-      if (!cleanupDeferred && session.processing) {
-        session.processing = false;
-        session.drainQueue().catch(() => {});
+      if (!cleanupDeferred && conversation.processing) {
+        conversation.processing = false;
+        silentlyWithLog(conversation.drainQueue(), "error-path queue drain");
       }
     }
   }
 
   const resolvedContent = slashResult.content;
-  if (slashResult.kind === "rewritten") {
-    session.setPreactivatedSkillIds([slashResult.skillId]);
-  }
 
   let messageId: string;
   try {
     const requestId = crypto.randomUUID();
-    messageId = await session.persistUserMessage(
+    messageId = await conversation.persistUserMessage(
       resolvedContent,
       attachments,
       requestId,
+      body.automated === true ? { automated: true } : undefined,
     );
   } catch (err) {
-    // Reset preactivated skill IDs so a stale activation doesn't leak
-    // into the next message if persistence fails.
-    session.setPreactivatedSkillIds(undefined);
     throw err;
   }
 
   // Fire-and-forget the agent loop; events flow to the hub via onEvent.
-  session
+  conversation
     .runAgentLoop(resolvedContent, messageId, onEvent, {
       isInteractive,
       isUserMessage: true,
@@ -1187,7 +1170,7 @@ export async function handleGetSuggestion(
 /**
  * GET /search?q=<query>[&limit=<n>][&maxMessagesPerConversation=<n>]
  *
- * Full-text search across all conversation threads (message content + titles).
+ * Full-text search across all conversations (message content + titles).
  * Returns ranked results grouped by conversation, each with matching message excerpts.
  */
 function handleSearchConversations(url: URL): Response {