@vellumai/assistant 0.4.43 → 0.4.45

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

@@ -14,15 +14,33 @@ import {
   parseChannelId,
   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 { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
+import {
+  buildModelInfoEvent,
+  isModelSlashCommand,
+} from "../../daemon/session-process.js";
+import {
+  isProviderShortcut,
+  resolveSlash,
+  type SlashContext,
+} from "../../daemon/session-slash.js";
 import * as attachmentsStore from "../../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
   generateCanonicalRequestCode,
   listPendingRequestsByConversationScope,
 } from "../../memory/canonical-guardian-store.js";
-import { addMessage, getMessages } from "../../memory/conversation-crud.js";
+import {
+  addMessage,
+  getMessages,
+  provenanceFromTrustContext,
+  setConversationOriginChannelIfUnset,
+  setConversationOriginInterfaceIfUnset,
+} from "../../memory/conversation-crud.js";
 import {
   getConversationByKey,
   getOrCreateConversation,
@@ -30,6 +48,7 @@ import {
 import { searchConversations } from "../../memory/conversation-queries.js";
 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 { buildAssistantEvent } from "../assistant-event.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
@@ -331,6 +350,9 @@ export function handleListMessages(
       attachments: msgAttachments,
       ...(m.toolCalls.length > 0 ? { toolCalls: m.toolCalls } : {}),
       ...(interfaces ? { interfaces } : {}),
+      ...(m.surfaces.length > 0 ? { surfaces: m.surfaces } : {}),
+      ...(m.textSegments.length > 0 ? { textSegments: m.textSegments } : {}),
+      ...(m.contentOrder.length > 0 ? { contentOrder: m.contentOrder } : {}),
     };
   });
 
@@ -341,9 +363,10 @@ export function handleListMessages(
  * Build an `onEvent` callback that publishes every outbound event to the
  * assistant event hub, maintaining ordered delivery through a serial chain.
  *
- * Also registers pending interactions when confirmation_request or
- * secret_request events flow through, so standalone approval endpoints
- * can look up the session by requestId.
+ * 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
+ * by requestId.
  */
 function makeHubPublisher(
   deps: SendMessageDeps,
@@ -370,7 +393,7 @@ function makeHubPublisher(
         },
       });
 
-      // Create a canonical guardian request so IPC/HTTP handlers can find it
+      // Create a canonical guardian request so HTTP handlers can find it
       // via applyCanonicalGuardianDecision.
       try {
         const trustContext = session.trustContext;
@@ -414,6 +437,18 @@ function makeHubPublisher(
         conversationId,
         kind: "secret",
       });
+    } else if (msg.type === "host_bash_request") {
+      pendingInteractions.register(msg.requestId, {
+        session,
+        conversationId,
+        kind: "host_bash",
+      });
+    } else if (msg.type === "host_file_request") {
+      pendingInteractions.register(msg.requestId, {
+        session,
+        conversationId,
+        kind: "host_file",
+      });
     }
 
     // ServerMessage is a large union; sessionId exists on most but not all variants.
@@ -523,6 +558,29 @@ export async function handleSendMessage(
     }
   }
 
+  // Block inbound messages containing secrets before they reach the model.
+  // This mirrors the legacy handleUserMessage behavior: secrets are
+  // detected and the message is rejected with a safe notice. The client
+  // should prompt the user to use the secure credential flow instead.
+  if (trimmedContent.length > 0) {
+    const ingressCheck = checkIngressForSecrets(trimmedContent);
+    if (ingressCheck.blocked) {
+      log.warn(
+        { detectedTypes: ingressCheck.detectedTypes },
+        "Blocked user message containing secrets (POST /v1/messages)",
+      );
+      return Response.json(
+        {
+          accepted: false,
+          error: "secret_blocked",
+          message: ingressCheck.userNotice,
+          detectedTypes: ingressCheck.detectedTypes,
+        },
+        { status: 422 },
+      );
+    }
+  }
+
   if (!deps.sendMessageDeps) {
     return httpError(
       "SERVICE_UNAVAILABLE",
@@ -554,11 +612,49 @@ export async function handleSendMessage(
   }
 
   const onEvent = makeHubPublisher(smDeps, mapping.conversationId, session);
-  // Route server-authoritative state signals (confirmation_state_changed,
-  // assistant_activity_state) to the SSE hub. Without this, these signals
-  // only travel through session.sendToClient, which is a no-op for
-  // socketless HTTP sessions.
-  session.setStateSignalListener(onEvent);
+  // Desktop, CLI, and web interfaces have an SSE client that can display
+  // permission prompts. Channel interfaces (telegram, slack, etc.) route
+  // approvals through the guardian system and have no interactive prompter UI.
+  const isInteractiveInterface =
+    sourceInterface === "macos" ||
+    sourceInterface === "ios" ||
+    sourceInterface === "cli" ||
+    sourceInterface === "vellum";
+  // Only create the host bash proxy for desktop client interfaces that can
+  // execute commands on the user's machine. Non-desktop sessions (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
+    // host bash request to avoid orphaning in-flight requests.
+    if (!session.isProcessing() || !session.hostBashProxy) {
+      const proxy = new HostBashProxy(onEvent, (requestId) => {
+        pendingInteractions.resolve(requestId);
+      });
+      session.setHostBashProxy(proxy);
+    }
+    if (!session.isProcessing() || !session.hostFileProxy) {
+      const fileProxy = new HostFileProxy(onEvent, (requestId) => {
+        pendingInteractions.resolve(requestId);
+      });
+      session.setHostFileProxy(fileProxy);
+    }
+  } else if (!session.isProcessing()) {
+    session.setHostBashProxy(undefined);
+    session.setHostFileProxy(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() &&
+    sourceInterface !== "macos" &&
+    sourceInterface !== "ios";
+  session.updateClient(onEvent, !isInteractiveInterface, {
+    skipProxySenderUpdate: preservingProxies,
+  });
 
   const attachments = hasAttachments
     ? smDeps.resolveAttachments(attachmentIds)
@@ -573,7 +669,7 @@ export async function handleSendMessage(
 
   // Try to consume the message as a canonical guardian approval/rejection reply.
   // On failure, degrade to the existing queue/auto-deny path rather than
-  // surfacing a 500 — mirrors the IPC handler's catch-and-fallback.
+  // surfacing a 500 — mirrors the handler's catch-and-fallback.
   try {
     const inlineReplyResult = await tryConsumeCanonicalGuardianReply({
       conversationId: mapping.conversationId,
@@ -606,11 +702,36 @@ export async function handleSendMessage(
   }
 
   if (session.isProcessing()) {
-    // If a tool confirmation is pending, auto-deny it so the agent
-    // can finish the current turn and process this queued message.
+    // Queue the message so it's processed when the current turn completes
+    const requestId = crypto.randomUUID();
+    const enqueueResult = session.enqueueMessage(
+      content ?? "",
+      attachments,
+      onEvent,
+      requestId,
+      undefined, // activeSurfaceId
+      undefined, // currentPage
+      {
+        userMessageChannel: sourceChannel,
+        assistantMessageChannel: sourceChannel,
+        userMessageInterface: sourceInterface,
+        assistantMessageInterface: sourceInterface,
+      },
+      { isInteractive: isInteractiveInterface },
+    );
+    if (enqueueResult.rejected) {
+      return Response.json(
+        { accepted: false, error: "queue_full" },
+        { status: 429 },
+      );
+    }
+
+    // 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()) {
       // Emit authoritative denial state for each pending request.
-      // The onStateSignal listener routes these to the SSE hub automatically.
+      // sendToClient (wired to the SSE hub) delivers these to the client.
       for (const interaction of pendingInteractions.getByConversation(
         mapping.conversationId,
       )) {
@@ -630,30 +751,6 @@ export async function handleSendMessage(
       pendingInteractions.removeBySession(session);
     }
 
-    // Queue the message so it's processed when the current turn completes
-    const requestId = crypto.randomUUID();
-    const result = session.enqueueMessage(
-      content ?? "",
-      attachments,
-      onEvent,
-      requestId,
-      undefined, // activeSurfaceId
-      undefined, // currentPage
-      {
-        userMessageChannel: sourceChannel,
-        assistantMessageChannel: sourceChannel,
-        userMessageInterface: sourceInterface,
-        assistantMessageInterface: sourceInterface,
-      },
-      { isInteractive: false },
-    );
-    if (result.rejected) {
-      return httpError(
-        "RATE_LIMITED",
-        "Message queue is full. Please retry later.",
-        429,
-      );
-    }
     return Response.json({ accepted: true, queued: true }, { status: 202 });
   }
 
@@ -666,18 +763,108 @@ export async function handleSendMessage(
     userMessageInterface: sourceInterface,
     assistantMessageInterface: sourceInterface,
   });
-  const requestId = crypto.randomUUID();
-  const messageId = await session.persistUserMessage(
-    content ?? "",
-    attachments,
-    requestId,
-  );
+
+  await session.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,
+    maxInputTokens: config.contextWindow.maxInputTokens,
+    model: config.model,
+    provider: config.provider,
+    estimatedCost: session.usageStats.estimatedCost,
+  };
+  const slashResult = resolveSlash(rawContent, slashContext);
+
+  if (slashResult.kind === "unknown") {
+    session.processing = true;
+    try {
+      const provenance = provenanceFromTrustContext(session.trustContext);
+      const channelMeta = {
+        ...provenance,
+        userMessageChannel: sourceChannel,
+        assistantMessageChannel: sourceChannel,
+        userMessageInterface: sourceInterface,
+        assistantMessageInterface: sourceInterface,
+      };
+      const userMsg = createUserMessage(rawContent, attachments);
+      const persisted = await addMessage(
+        mapping.conversationId,
+        "user",
+        JSON.stringify(userMsg.content),
+        channelMeta,
+      );
+      session.getMessages().push(userMsg);
+
+      const assistantMsg = createAssistantMessage(slashResult.message);
+      await addMessage(
+        mapping.conversationId,
+        "assistant",
+        JSON.stringify(assistantMsg.content),
+        channelMeta,
+      );
+      session.getMessages().push(assistantMsg);
+
+      setConversationOriginChannelIfUnset(
+        mapping.conversationId,
+        sourceChannel,
+      );
+      setConversationOriginInterfaceIfUnset(
+        mapping.conversationId,
+        sourceInterface,
+      );
+
+      // Emit fresh model info before the text delta so the client has
+      // up-to-date configuredProviders when rendering /model, /models,
+      // and provider shortcut commands (/gpt4, /opus, etc.).
+      if (isModelSlashCommand(rawContent) || isProviderShortcut(rawContent)) {
+        onEvent(buildModelInfoEvent());
+      }
+
+      onEvent({ type: "assistant_text_delta", text: slashResult.message });
+      onEvent({
+        type: "message_complete",
+        sessionId: mapping.conversationId,
+      });
+
+      return Response.json(
+        { accepted: true, messageId: persisted.id },
+        { status: 202 },
+      );
+    } finally {
+      session.processing = false;
+      session.drainQueue().catch(() => {});
+    }
+  }
+
+  const resolvedContent = slashResult.content;
+  if (slashResult.kind === "rewritten") {
+    session.setPreactivatedSkillIds([slashResult.skillId]);
+  }
+
+  let messageId: string;
+  try {
+    const requestId = crypto.randomUUID();
+    messageId = await session.persistUserMessage(
+      resolvedContent,
+      attachments,
+      requestId,
+    );
+  } 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.
-  // Mark non-interactive so conflict clarification doesn't block the turn.
   session
-    .runAgentLoop(content ?? "", messageId, onEvent, {
-      isInteractive: false,
+    .runAgentLoop(resolvedContent, messageId, onEvent, {
+      isInteractive: isInteractiveInterface,
       isUserMessage: true,
     })
     .catch((err) => {

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

@@ -1,15 +1,21 @@
 /**
  * HTTP route handlers for diagnostics export and dictation processing.
  *
- * Migrated from IPC handlers:
- *   - handlers/diagnostics.ts (diagnostics_export_request)
- *   - handlers/dictation.ts (dictation_request)
+ * Handles diagnostics export and dictation processing requests.
  */
 
 import { randomBytes } from "node:crypto";
-import { createWriteStream, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import {
+  createWriteStream,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 
 import archiver from "archiver";
 import { and, desc, eq, gte, lte } from "drizzle-orm";
@@ -45,7 +51,7 @@ import type { RouteDefinition } from "../http-router.js";
 const log = getLogger("diagnostics-routes");
 
 // ---------------------------------------------------------------------------
-// Diagnostics export — redaction helpers (shared with IPC handler)
+// Diagnostics export — redaction helpers
 // ---------------------------------------------------------------------------
 
 const MAX_CONTENT_LENGTH = 500;
@@ -104,6 +110,58 @@ function redactDeep(value: unknown): unknown {
   return value;
 }
 
+// ---------------------------------------------------------------------------
+// Crash report discovery
+// ---------------------------------------------------------------------------
+
+const CRASH_REPORT_EXTENSIONS = new Set([".crash", ".ips", ".diag"]);
+const CRASH_REPORT_TAR_GZ = ".tar.gz";
+const CRASH_REPORT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+function findRecentCrashReports(): string[] {
+  const diagnosticReportsDir = join(
+    homedir(),
+    "Library",
+    "Logs",
+    "DiagnosticReports",
+  );
+
+  try {
+    const entries = readdirSync(diagnosticReportsDir);
+    const now = Date.now();
+    const results: string[] = [];
+
+    for (const entry of entries) {
+      // Case-insensitive prefix match for "vellum-assistant"
+      if (!entry.toLowerCase().startsWith("vellum-assistant")) continue;
+
+      // Check extension
+      const lowerEntry = entry.toLowerCase();
+      const hasValidExt =
+        CRASH_REPORT_EXTENSIONS.has(
+          lowerEntry.slice(lowerEntry.lastIndexOf(".")),
+        ) || lowerEntry.endsWith(CRASH_REPORT_TAR_GZ);
+
+      if (!hasValidExt) continue;
+
+      const filePath = join(diagnosticReportsDir, entry);
+      try {
+        const stat = statSync(filePath);
+        if (!stat.isFile()) continue;
+        if (now - stat.mtimeMs > CRASH_REPORT_MAX_AGE_MS) continue;
+        results.push(filePath);
+      } catch {
+        // Skip files we can't stat
+      }
+    }
+
+    return results;
+  } catch {
+    // Directory doesn't exist or can't be read — not an error
+    return [];
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Diagnostics export handler
 // ---------------------------------------------------------------------------
@@ -121,7 +179,12 @@ async function handleDiagnosticsExport(body: {
   try {
     const db = getDb();
 
-    // 1. Find the anchor message
+    // 1. Find the anchor message.
+    // Try in order: specific ID → most recent assistant message → any message.
+    // The final fallback handles the race condition where the user clicks
+    // "export" before message_complete fires and the assistant message has
+    // been persisted — the user message and in-flight tool/usage data are
+    // still captured.
     let anchorMessage;
     if (anchorMessageId) {
       anchorMessage = db
@@ -134,7 +197,8 @@ async function handleDiagnosticsExport(body: {
           ),
         )
         .get();
-    } else {
+    }
+    if (!anchorMessage) {
       anchorMessage = db
         .select()
         .from(messages)
@@ -148,30 +212,60 @@ async function handleDiagnosticsExport(body: {
         .limit(1)
         .get();
     }
-
     if (!anchorMessage) {
-      return httpError("NOT_FOUND", "Anchor message not found", 404);
+      anchorMessage = db
+        .select()
+        .from(messages)
+        .where(eq(messages.conversationId, conversationId))
+        .orderBy(desc(messages.createdAt))
+        .limit(1)
+        .get();
     }
 
-    // 2. Find the preceding user message
-    const precedingUserMessage = db
-      .select()
-      .from(messages)
-      .where(
-        and(
-          eq(messages.conversationId, conversationId),
-          eq(messages.role, "user"),
-          lte(messages.createdAt, anchorMessage.createdAt),
-        ),
-      )
-      .orderBy(desc(messages.createdAt))
-      .limit(1)
-      .get();
+    // 2. Compute the export time range.
+    // When an anchor message exists, scope to the preceding user message
+    // through the anchor. When no messages exist at all (empty conversation
+    // or race condition), use the current timestamp so the export still
+    // captures any in-flight usage/tool data.
+    const now = Date.now();
+    let rangeEnd: number;
+    let rangeStart: number;
+    let usageRangeEnd: number;
+
+    if (anchorMessage) {
+      const precedingUserMessage = db
+        .select()
+        .from(messages)
+        .where(
+          and(
+            eq(messages.conversationId, conversationId),
+            eq(messages.role, "user"),
+            lte(messages.createdAt, anchorMessage.createdAt),
+          ),
+        )
+        .orderBy(desc(messages.createdAt))
+        .limit(1)
+        .get();
 
-    const rangeStart =
-      precedingUserMessage?.createdAt ?? anchorMessage.createdAt - 2000;
-    const rangeEnd = anchorMessage.createdAt;
-    const usageRangeEnd = anchorMessage.createdAt + 5000;
+      rangeStart =
+        precedingUserMessage?.createdAt ?? anchorMessage.createdAt - 2000;
+
+      // When the anchor is not an assistant message (e.g. the fallback "any
+      // message" path hit because the assistant reply hasn't been persisted
+      // yet), extend the range to the current time so in-flight tool
+      // invocations and usage recorded after the user message are captured.
+      const anchorIsAssistant = anchorMessage.role === "assistant";
+      rangeEnd = anchorIsAssistant ? anchorMessage.createdAt : now;
+      usageRangeEnd = anchorIsAssistant
+        ? anchorMessage.createdAt + 5000
+        : now + 5000;
+    } else {
+      // No messages at all — use the current time so we capture any
+      // in-flight LLM usage or tool invocations.
+      rangeStart = now - 60_000;
+      rangeEnd = now;
+      usageRangeEnd = now + 5000;
+    }
 
     // 3. Query all messages in the range
     const rangeMessages = db
@@ -239,7 +333,7 @@ async function handleDiagnosticsExport(body: {
         version: "1.1",
         exportedAt: new Date().toISOString(),
         conversationId,
-        messageId: anchorMessage.id,
+        messageId: anchorMessage?.id ?? null,
       };
       writeFileSync(
         join(tempDir, "manifest.json"),
@@ -344,6 +438,28 @@ async function handleDiagnosticsExport(body: {
 
         archive.pipe(output);
         archive.directory(tempDir, false);
+
+        // Add recent crash report files under crash-reports/.
+        // Text-based crash files (.crash, .ips, .diag) are redacted using the
+        // same patterns as conversation data. Binary archives (.tar.gz) are
+        // added as-is since they can't be meaningfully text-redacted.
+        const crashReportFiles = findRecentCrashReports();
+        for (const filePath of crashReportFiles) {
+          try {
+            const fileName = basename(filePath);
+            if (fileName.toLowerCase().endsWith(CRASH_REPORT_TAR_GZ)) {
+              archive.file(filePath, { name: "crash-reports/" + fileName });
+            } else {
+              const content = readFileSync(filePath, "utf-8");
+              archive.append(redact(content), {
+                name: "crash-reports/" + fileName,
+              });
+            }
+          } catch {
+            // Skip files that can't be read
+          }
+        }
+
         archive.finalize();
       });
 
@@ -352,7 +468,7 @@ async function handleDiagnosticsExport(body: {
         "Diagnostics export completed via HTTP",
       );
 
-      return Response.json({ ok: true, filePath: zipPath });
+      return Response.json({ success: true, filePath: zipPath });
     } finally {
       try {
         rmSync(tempDir, { recursive: true, force: true });
@@ -382,9 +498,7 @@ const MAX_WINDOW_TITLE_LENGTH = 100;
 
 function sanitizeWindowTitle(title: string | undefined): string {
   if (!title) return "";
-  return title
-    .replace(/[<>]/g, "")
-    .slice(0, MAX_WINDOW_TITLE_LENGTH);
+  return title.replace(/[<>]/g, "").slice(0, MAX_WINDOW_TITLE_LENGTH);
 }
 
 interface DictationBody {
@@ -469,10 +583,7 @@ function buildCombinedDictationPrompt(
   return sections.join("\n");
 }
 
-function buildCommandPrompt(
-  body: DictationBody,
-  stylePrompt?: string,
-): string {
+function buildCommandPrompt(body: DictationBody, stylePrompt?: string): string {
   const sections = [
     "You are a text transformation assistant. The user has selected text and given a voice command to transform it.",
     "",
@@ -559,7 +670,10 @@ async function handleDictation(body: DictationBody): Promise<Response> {
   const stylePrompt = profile.stylePrompt || undefined;
 
   // Command mode: selected text present
-  if (body.context.selectedText && body.context.selectedText.trim().length > 0) {
+  if (
+    body.context.selectedText &&
+    body.context.selectedText.trim().length > 0
+  ) {
     log.info({ mode: "command" }, "Command mode (selected text present)");
     return handleCommandMode(body, profile, profileMeta, stylePrompt);
   }
@@ -573,7 +687,7 @@ async function handleDictation(body: DictationBody): Promise<Response> {
       log.warn(
         "Dictation: no provider available, using heuristic + raw transcription",
       );
-      // Build an IPC-compatible msg for the heuristic
+      // Build a compatible msg for the heuristic
       const mode = detectDictationModeHeuristic({
         type: "dictation_request",
         transcription: body.transcription,
@@ -669,10 +783,7 @@ async function handleDictation(body: DictationBody): Promise<Response> {
           });
         }
         const cleanedText = input.text?.trim() || transcription;
-        const normalizedText = applyDictionary(
-          cleanedText,
-          profile.dictionary,
-        );
+        const normalizedText = applyDictionary(cleanedText, profile.dictionary);
         return Response.json({
           text: normalizedText,
           mode: "dictation",

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

@@ -2,7 +2,7 @@
  * Route handlers for document persistence operations.
  *
  * Exposes document CRUD over HTTP, sharing business logic with the
- * IPC handlers in `daemon/handlers/documents.ts`.
+ * handlers in `daemon/handlers/documents.ts`.
  */
 import { rawAll, rawGet, rawRun } from "../../memory/db.js";
 import { getLogger } from "../../util/logger.js";
@@ -24,7 +24,7 @@ interface DocumentRow {
 type DocumentListRow = Omit<DocumentRow, "content">;
 
 // ---------------------------------------------------------------------------
-// Shared business logic (used by both IPC handlers and HTTP routes)
+// Shared business logic (used by both message handlers and HTTP routes)
 // ---------------------------------------------------------------------------
 
 export function saveDocument(params: {