@vellumai/assistant 0.6.2 → 0.6.4

package/src/runtime/routes/user-route-dispatcher.ts

@@ -6,6 +6,11 @@
  * exports named functions for HTTP methods (GET, POST, PUT, etc.) using
  * the standard Web API Request/Response signature.
  *
+ * Handlers receive a second `context` argument with runtime singletons
+ * (event hub, assistant ID, etc.) that would otherwise be unreachable
+ * from dynamically imported modules because Bun's cache-busting import
+ * creates separate module instances.
+ *
  * Modules are lazily loaded on first request and cached by file path +
  * mtime. When a file changes on disk, the next request reloads it via
  * Bun's dynamic `import()` with a cache-busting query parameter.
@@ -16,10 +21,35 @@ import { join, resolve } from "node:path";
 
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceRoutesDir } from "../../util/platform.js";
+import type { AssistantEventHub } from "../assistant-event-hub.js";
 import { httpError } from "../http-errors.js";
 
 const log = getLogger("user-routes");
 
+// ---------------------------------------------------------------------------
+// User route context — injected into every handler as the second argument
+// ---------------------------------------------------------------------------
+
+/**
+ * Runtime context passed to user-defined route handlers.
+ *
+ * Because user route modules are loaded via dynamic `import()` with
+ * cache-busting query parameters, they get isolated module instances
+ * and cannot import process-level singletons like the event hub
+ * directly. This context bridges the gap by carrying references to
+ * the daemon's real singletons.
+ */
+export interface UserRouteContext {
+  /** The daemon's event hub singleton — use this to publish events to connected SSE clients. */
+  readonly assistantEventHub: AssistantEventHub;
+  /** The logical assistant ID used by the daemon (typically "self"). */
+  readonly assistantId: string;
+}
+
+// ---------------------------------------------------------------------------
+// Route handler types
+// ---------------------------------------------------------------------------
+
 /** HTTP methods that can be exported from a handler module. */
 const HTTP_METHODS = [
   "GET",
@@ -33,8 +63,18 @@ const HTTP_METHODS = [
 
 type HttpMethod = (typeof HTTP_METHODS)[number];
 
-/** The function signature that user-defined route handlers must follow. */
-type RouteHandler = (request: Request) => Response | Promise<Response>;
+/**
+ * The function signature that user-defined route handlers must follow.
+ *
+ * Handlers may accept an optional second `context` argument with runtime
+ * singletons (event hub, assistant ID). Legacy handlers that only accept
+ * `request` continue to work — the context is passed positionally but
+ * ignored if the handler doesn't declare the parameter.
+ */
+type RouteHandler = (
+  request: Request,
+  context: UserRouteContext,
+) => Response | Promise<Response>;
 
 /** A loaded handler module with its cached metadata. */
 interface CachedModule {
@@ -55,10 +95,15 @@ const HANDLER_EXTENSIONS = [".ts", ".js"] as const;
 export class UserRouteDispatcher {
   private moduleCache = new Map<string, CachedModule>();
   private handlerTimeoutMs: number;
+  private context: UserRouteContext;
 
-  constructor(options?: { handlerTimeoutMs?: number }) {
+  constructor(options: {
+    handlerTimeoutMs?: number;
+    context: UserRouteContext;
+  }) {
     this.handlerTimeoutMs =
-      options?.handlerTimeoutMs ?? DEFAULT_HANDLER_TIMEOUT_MS;
+      options.handlerTimeoutMs ?? DEFAULT_HANDLER_TIMEOUT_MS;
+    this.context = Object.freeze({ ...options.context });
   }
 
   /**
@@ -192,7 +237,7 @@ export class UserRouteDispatcher {
   ): Promise<Response> {
     try {
       const result = await Promise.race([
-        Promise.resolve(handler(request)),
+        Promise.resolve(handler(request, this.context)),
         new Promise<never>((_, reject) =>
           setTimeout(
             () => reject(new Error("Handler timed out")),

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

@@ -4,12 +4,24 @@
  * Registers a single catch-all route that delegates to the
  * UserRouteDispatcher for file-based dispatch from
  * `$VELLUM_WORKSPACE_DIR/routes/`.
+ *
+ * The dispatcher injects a `UserRouteContext` into every handler so
+ * that dynamically imported route modules can access daemon singletons
+ * (event hub, assistant ID) without relying on module-level imports
+ * that would resolve to separate instances due to cache-busting.
  */
 
+import { assistantEventHub } from "../assistant-event-hub.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import type { RouteDefinition } from "../http-router.js";
 import { UserRouteDispatcher } from "./user-route-dispatcher.js";
 
-const dispatcher = new UserRouteDispatcher();
+const dispatcher = new UserRouteDispatcher({
+  context: {
+    assistantEventHub,
+    assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
+  },
+});
 
 /**
  * HTTP methods supported by user-defined route handlers.

package/src/runtime/routes/work-items-routes.ts

@@ -19,6 +19,7 @@ import {
   getToolDescription,
   sanitizeToolList,
 } from "../../tasks/tool-sanitizer.js";
+import { createAbortReason } from "../../util/abort-reasons.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
 import { resolveRequiredTools } from "../../work-items/resolve-required-tools.js";
@@ -587,7 +588,13 @@ export function workItemRouteDefinitions(
           const conversation = deps.findConversation(conversationId);
           if (conversation) {
             conversation.headlessLock = false;
-            conversation.abort();
+            conversation.abort(
+              createAbortReason(
+                "work_item_aborted",
+                "work-items-routes.cancel",
+                conversationId,
+              ),
+            );
             getSubagentManager().abortAllForParent(conversationId);
           }
         }

package/src/runtime/routes/workspace-routes.test.ts

@@ -190,6 +190,28 @@ describe("isTextMimeType", () => {
     // A binary plist has a specific MIME type — extension should not override it
     expect(isTextMimeType("application/x-plist", "Info.plist")).toBe(false);
   });
+
+  test("application/octet-stream with .jsonl filename is text", () => {
+    expect(isTextMimeType("application/octet-stream", "messages.jsonl")).toBe(
+      true,
+    );
+  });
+
+  test("application/octet-stream with .ndjson filename is text", () => {
+    expect(isTextMimeType("application/octet-stream", "events.ndjson")).toBe(
+      true,
+    );
+  });
+
+  test("application/octet-stream with .JSONL uppercase is text", () => {
+    expect(isTextMimeType("application/octet-stream", "DATA.JSONL")).toBe(true);
+  });
+
+  test("application/octet-stream with .NDJSON uppercase is text", () => {
+    expect(isTextMimeType("application/octet-stream", "DATA.NDJSON")).toBe(
+      true,
+    );
+  });
 });
 
 // ===========================================================================

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

@@ -120,7 +120,14 @@ function handleWorkspaceFile(ctx: RouteContext): Response {
   }
 
   const mimeType = Bun.file(resolved).type;
-  const isText = isTextMimeType(mimeType, basename(resolved));
+  // Empty files with unknown MIME type default to text — there is no binary
+  // content to protect, and files created via the UI "New File" action are
+  // always 0 bytes. Without this override, extensionless files (e.g. "Test")
+  // would be classified as binary and rendered in a non-editable fallback view.
+  const isText =
+    stat.size === 0 && mimeType === "application/octet-stream"
+      ? true
+      : isTextMimeType(mimeType, basename(resolved));
   const isBinary = !isText;
 
   let content: string | undefined = undefined;

package/src/runtime/routes/workspace-utils.ts

@@ -159,6 +159,8 @@ const TEXT_FILE_EXTENSIONS = new Set([
   "patch",
   "log",
   "lock",
+  "jsonl",
+  "ndjson",
 ]);
 
 export function isTextMimeType(mimeType: string, fileName?: string): boolean {

package/src/runtime/runtime-mode.ts

@@ -0,0 +1,33 @@
+/**
+ * Daemon runtime-mode detection.
+ *
+ * Exposes a single well-named helper `getDaemonRuntimeMode()` that returns
+ * `"docker"` when the daemon is running inside a container and
+ * `"bare-metal"` otherwise.
+ *
+ * Under the hood this delegates to `getIsContainerized()` from the env
+ * registry, which accepts the standard truthy values for `IS_CONTAINERIZED`
+ * (`"true"` or `"1"`). Keeping the check in the registry avoids duplicating
+ * the env-parsing semantics across modules.
+ *
+ * The mode-named API (rather than a boolean) exists to make downstream
+ * switch/branch code read naturally — e.g. `if (mode === "docker") { ... }`
+ * is clearer than `if (isContainerized) { ... }` when the behavior depends
+ * on the specific deployment shape, and it leaves room for additional
+ * runtime modes in the future without renaming every callsite.
+ */
+
+import { getIsContainerized } from "../config/env-registry.js";
+
+export type DaemonRuntimeMode = "bare-metal" | "docker";
+
+/**
+ * Returns the deployment mode the daemon is currently running under.
+ *
+ * - `"docker"` when `IS_CONTAINERIZED` is set to a truthy value
+ *   (`"true"` or `"1"`).
+ * - `"bare-metal"` otherwise.
+ */
+export function getDaemonRuntimeMode(): DaemonRuntimeMode {
+  return getIsContainerized() ? "docker" : "bare-metal";
+}

package/src/runtime/services/__tests__/analyze-conversation.test.ts

@@ -0,0 +1,444 @@
+/**
+ * Unit tests for the analyzeConversation service.
+ *
+ * The service is driven directly (no HTTP routing) so tests exercise the
+ * validation + setup logic against mocked memory/CRUD + transcript helpers.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+const mockResolveConversationId = mock((id: string) => id as string | null);
+const mockGetConversation = mock(
+  () =>
+    ({
+      id: "conv-1",
+      title: "Source",
+      conversationType: "normal",
+    }) as Record<string, unknown> | null,
+);
+const mockGetMessages = mock(() => [{ id: "m-source" }] as Array<{ id: string }>);
+const mockCreateConversation = mock(
+  (_opts?: Record<string, unknown>) => ({ id: "analysis-new" }),
+);
+const mockAddMessage = mock(async () => ({ id: "msg-1" }));
+const mockFindAnalysisConversationFor = mock(
+  (_parent: string) => null as { id: string } | null,
+);
+const mockGetConversationSource = mock((_id: string) => null as string | null);
+
+mock.module("../../../memory/conversation-key-store.js", () => ({
+  resolveConversationId: mockResolveConversationId,
+}));
+
+mock.module("../../../memory/conversation-crud.js", () => ({
+  getConversation: mockGetConversation,
+  getMessages: mockGetMessages,
+  createConversation: mockCreateConversation,
+  addMessage: mockAddMessage,
+  findAnalysisConversationFor: mockFindAnalysisConversationFor,
+  getConversationSource: mockGetConversationSource,
+}));
+
+mock.module("../../../export/transcript-formatter.js", () => ({
+  buildAnalysisTranscript: () => "user: hi",
+}));
+
+// Default config stub — individual tests can override via mockGetConfig.
+interface AnalysisConfigStub {
+  analysis: {
+    modelIntent?: string;
+    modelOverride?: string;
+  };
+}
+const mockGetConfig = mock(
+  (): AnalysisConfigStub => ({
+    analysis: {},
+  }),
+);
+
+mock.module("../../../config/loader.js", () => ({
+  getConfig: mockGetConfig,
+}));
+
+import { AssistantEventHub } from "../../assistant-event-hub.js";
+import type { SendMessageDeps } from "../../http-types.js";
+import { analyzeConversation } from "../analyze-conversation.js";
+
+beforeEach(() => {
+  mockResolveConversationId.mockReset();
+  mockResolveConversationId.mockImplementation((id: string) => id);
+  mockGetConversation.mockReset();
+  mockGetConversation.mockImplementation(() => ({
+    id: "conv-1",
+    title: "Source",
+    conversationType: "normal",
+  }));
+  mockGetMessages.mockReset();
+  mockGetMessages.mockImplementation(() => [{ id: "m-source" }]);
+  mockCreateConversation.mockReset();
+  mockCreateConversation.mockImplementation(() => ({ id: "analysis-new" }));
+  mockAddMessage.mockReset();
+  mockAddMessage.mockImplementation(async () => ({ id: "msg-1" }));
+  mockFindAnalysisConversationFor.mockReset();
+  mockFindAnalysisConversationFor.mockImplementation(() => null);
+  mockGetConversationSource.mockReset();
+  mockGetConversationSource.mockImplementation(() => null);
+  mockGetConfig.mockReset();
+  mockGetConfig.mockImplementation(() => ({ analysis: {} }));
+});
+
+function makeConversation() {
+  return {
+    setTrustContext: mock(() => {}),
+    ensureActorScopedHistory: mock(() => Promise.resolve()),
+    setSubagentAllowedTools: mock(() => {}),
+    updateClient: mock(() => {}),
+    processing: false,
+    abortController: null as AbortController | null,
+    currentRequestId: null as string | null,
+    loadedHistoryTrustClass: undefined as string | undefined,
+    runAgentLoop: mock(() => Promise.resolve()),
+  };
+}
+
+function makeDeps(conversation: ReturnType<typeof makeConversation>) {
+  const assistantEventHub = new AssistantEventHub();
+  const getOrCreateConversation = mock(async () => conversation);
+  const sendMessageDeps = {
+    getOrCreateConversation,
+    assistantEventHub,
+    resolveAttachments: () => [],
+  } as unknown as SendMessageDeps;
+  return {
+    sendMessageDeps,
+    buildConversationDetailResponse: (id: string) => ({ id }),
+    getOrCreateConversation,
+  };
+}
+
+describe("analyzeConversation", () => {
+  test("returns NOT_FOUND when the source ID does not resolve", async () => {
+    mockResolveConversationId.mockImplementation(() => null);
+    const deps = makeDeps(makeConversation());
+
+    const result = await analyzeConversation("missing", deps, {
+      trigger: "manual",
+    });
+
+    expect("error" in result).toBe(true);
+    if (!("error" in result)) throw new Error("expected error");
+    expect(result.error.kind).toBe("NOT_FOUND");
+    expect(result.error.status).toBe(404);
+    expect(mockGetConversation).not.toHaveBeenCalled();
+  });
+
+  test("returns NOT_FOUND when the conversation record is missing", async () => {
+    mockGetConversation.mockImplementation(() => null);
+    const deps = makeDeps(makeConversation());
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "manual",
+    });
+
+    expect("error" in result).toBe(true);
+    if (!("error" in result)) throw new Error("expected error");
+    expect(result.error.kind).toBe("NOT_FOUND");
+    expect(result.error.status).toBe(404);
+  });
+
+  test("returns FORBIDDEN when the source conversation is private", async () => {
+    mockGetConversation.mockImplementation(() => ({
+      id: "conv-1",
+      title: "Private",
+      conversationType: "private",
+    }));
+    const deps = makeDeps(makeConversation());
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "manual",
+    });
+
+    expect("error" in result).toBe(true);
+    if (!("error" in result)) throw new Error("expected error");
+    expect(result.error.kind).toBe("FORBIDDEN");
+    expect(result.error.status).toBe(403);
+  });
+
+  test("returns BAD_REQUEST when the source conversation has no messages", async () => {
+    mockGetMessages.mockImplementation(() => []);
+    const deps = makeDeps(makeConversation());
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "manual",
+    });
+
+    expect("error" in result).toBe(true);
+    if (!("error" in result)) throw new Error("expected error");
+    expect(result.error.kind).toBe("BAD_REQUEST");
+    expect(result.error.status).toBe(400);
+  });
+
+  test("creates an analysis conversation with unknown trust, no tools, and returns the new ID", async () => {
+    const conversation = makeConversation();
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "manual",
+    });
+
+    expect("error" in result).toBe(false);
+    if ("error" in result) throw new Error("expected success");
+    expect(result.analysisConversationId).toBe("analysis-new");
+
+    // Persists the prompt as a user message with unknown trust.
+    expect(mockAddMessage).toHaveBeenCalledWith(
+      "analysis-new",
+      "user",
+      expect.any(String),
+      { provenanceTrustClass: "unknown" },
+    );
+
+    // Sets trust context to unknown.
+    expect(conversation.setTrustContext).toHaveBeenCalledWith({
+      trustClass: "unknown",
+      sourceChannel: "vellum",
+    });
+
+    // Strips all tools.
+    expect(conversation.setSubagentAllowedTools).toHaveBeenCalledTimes(1);
+    const allowedTools = (
+      conversation.setSubagentAllowedTools.mock.calls as unknown as Array<
+        [Set<string> | undefined]
+      >
+    )[0]?.[0];
+    expect(allowedTools).toBeInstanceOf(Set);
+    expect(allowedTools?.size).toBe(0);
+
+    // Fires the agent loop.
+    expect(conversation.runAgentLoop).toHaveBeenCalledWith(
+      expect.any(String),
+      "msg-1",
+      expect.any(Function),
+      expect.objectContaining({ isInteractive: false, isUserMessage: true }),
+    );
+  });
+
+  // ── Auto trigger ──────────────────────────────────────────────────
+
+  test("auto: creates a new analysis conversation when none exists, with source=auto-analysis, dedicated groupId, and forkParentConversationId", async () => {
+    mockFindAnalysisConversationFor.mockImplementation(() => null);
+    const conversation = makeConversation();
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "auto",
+    });
+
+    expect("error" in result).toBe(false);
+    if ("error" in result) throw new Error("expected success");
+    expect(result.analysisConversationId).toBe("analysis-new");
+
+    // Verifies the rolling-analysis lookup was consulted against the source ID.
+    expect(mockFindAnalysisConversationFor).toHaveBeenCalledWith("conv-1");
+
+    expect(mockCreateConversation).toHaveBeenCalledTimes(1);
+    expect(mockCreateConversation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Analysis: Source",
+        source: "auto-analysis",
+        groupId: "system:background",
+        forkParentConversationId: "conv-1",
+      }),
+    );
+  });
+
+  test("auto: skips the run (no agent loop, no message persisted) when the rolling analysis conversation is already processing", async () => {
+    const conversation = makeConversation();
+    conversation.processing = true;
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "auto",
+    });
+
+    // Returns a successful no-op result tagged with `skipped: true`.
+    expect("error" in result).toBe(false);
+    if ("error" in result) throw new Error("expected success");
+    expect(result.analysisConversationId).toBe("analysis-new");
+    expect(result.skipped).toBe(true);
+
+    // Critically, none of the mutating side effects should have run: no
+    // message persisted, no trust context overwritten, no agent loop fired.
+    expect(mockAddMessage).not.toHaveBeenCalled();
+    expect(conversation.setTrustContext).not.toHaveBeenCalled();
+    expect(conversation.runAgentLoop).not.toHaveBeenCalled();
+    expect(conversation.abortController).toBeNull();
+  });
+
+  test("manual: does NOT skip when the conversation reports processing (guard is auto-only)", async () => {
+    const conversation = makeConversation();
+    conversation.processing = true;
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "manual",
+    });
+
+    expect("error" in result).toBe(false);
+    if ("error" in result) throw new Error("expected success");
+    expect(result.skipped).toBeUndefined();
+
+    // Manual trigger always proceeds — it creates a fresh conversation per
+    // invocation, so there is no shared-state concurrency hazard.
+    expect(mockAddMessage).toHaveBeenCalled();
+    expect(conversation.runAgentLoop).toHaveBeenCalled();
+  });
+
+  test("auto: reuses an existing rolling analysis conversation (no new row)", async () => {
+    mockFindAnalysisConversationFor.mockImplementation(() => ({
+      id: "analysis-existing",
+    }));
+    const conversation = makeConversation();
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "auto",
+    });
+
+    expect("error" in result).toBe(false);
+    if ("error" in result) throw new Error("expected success");
+    expect(result.analysisConversationId).toBe("analysis-existing");
+
+    // No new conversation row is created on reuse.
+    expect(mockCreateConversation).not.toHaveBeenCalled();
+
+    // The new user message is appended to the existing analysis conversation.
+    expect(mockAddMessage).toHaveBeenCalledWith(
+      "analysis-existing",
+      "user",
+      expect.any(String),
+      { provenanceTrustClass: "guardian" },
+    );
+  });
+
+  test("auto: invalidates loadedHistoryTrustClass before ensureActorScopedHistory on reuse so stale ctx.messages is reloaded", async () => {
+    // Simulate a reused rolling conversation whose prior run already cached
+    // a guardian-class history load. Without explicit invalidation,
+    // ensureActorScopedHistory would short-circuit and runAgentLoopImpl
+    // would execute against ctx.messages missing the newly-enqueued prompt.
+    mockFindAnalysisConversationFor.mockImplementation(() => ({
+      id: "analysis-existing",
+    }));
+    const conversation = makeConversation();
+    conversation.loadedHistoryTrustClass = "guardian";
+    let trustClassWhenEnsured: string | undefined = "sentinel";
+    conversation.ensureActorScopedHistory.mockImplementation(() => {
+      trustClassWhenEnsured = conversation.loadedHistoryTrustClass;
+      return Promise.resolve();
+    });
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "auto",
+    });
+
+    expect("error" in result).toBe(false);
+    // The invalidation must land before ensureActorScopedHistory runs so
+    // the reload inside it pulls the freshly-persisted user prompt.
+    expect(trustClassWhenEnsured).toBeUndefined();
+    expect(conversation.ensureActorScopedHistory).toHaveBeenCalledTimes(1);
+  });
+
+  test("auto: sets trustClass to guardian", async () => {
+    const conversation = makeConversation();
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "auto",
+    });
+    expect("error" in result).toBe(false);
+
+    expect(conversation.setTrustContext).toHaveBeenCalledWith({
+      trustClass: "guardian",
+      sourceChannel: "vellum",
+    });
+  });
+
+  test("auto: does NOT strip the tool surface", async () => {
+    const conversation = makeConversation();
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "auto",
+    });
+    expect("error" in result).toBe(false);
+
+    // Manual mode calls this with an empty Set; auto mode must leave the
+    // conversation's default tool surface intact.
+    expect(conversation.setSubagentAllowedTools).not.toHaveBeenCalled();
+  });
+
+  test("auto: rejects when the source conversation is itself an auto-analysis conversation", async () => {
+    mockGetConversationSource.mockImplementation(() => "auto-analysis");
+    const conversation = makeConversation();
+    const deps = makeDeps(conversation);
+
+    const result = await analyzeConversation("conv-1", deps, {
+      trigger: "auto",
+    });
+
+    expect("error" in result).toBe(true);
+    if (!("error" in result)) throw new Error("expected error");
+    expect(result.error.kind).toBe("BAD_REQUEST");
+    expect(result.error.status).toBe(400);
+
+    // Nothing downstream of the guard should have fired.
+    expect(mockFindAnalysisConversationFor).not.toHaveBeenCalled();
+    expect(mockCreateConversation).not.toHaveBeenCalled();
+    expect(mockAddMessage).not.toHaveBeenCalled();
+  });
+
+  test("auto: passes modelOverride through to getOrCreateConversation when set in config", async () => {
+    mockGetConfig.mockImplementation(() => ({
+      analysis: {
+        modelIntent: "quality-optimized",
+        modelOverride: "claude-opus-4-6",
+      },
+    }));
+    const conversation = makeConversation();
+    const deps = makeDeps(conversation);
+
+    await analyzeConversation("conv-1", deps, { trigger: "auto" });
+
+    expect(deps.getOrCreateConversation).toHaveBeenCalledWith(
+      "analysis-new",
+      expect.objectContaining({
+        modelIntent: "quality-optimized",
+        modelOverride: "claude-opus-4-6",
+      }),
+    );
+  });
+
+  test("auto: does not pass modelOverride/modelIntent keys when config leaves them unset", async () => {
+    const conversation = makeConversation();
+    const deps = makeDeps(conversation);
+
+    await analyzeConversation("conv-1", deps, { trigger: "auto" });
+
+    const [, passedOpts] = (
+      deps.getOrCreateConversation.mock.calls as unknown as Array<
+        [string, Record<string, unknown>]
+      >
+    )[0] ?? ["", {}];
+    expect(passedOpts).toBeDefined();
+    expect("modelIntent" in (passedOpts ?? {})).toBe(false);
+    expect("modelOverride" in (passedOpts ?? {})).toBe(false);
+  });
+});