@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/__tests__/conversation-surfaces-activation-emit.test.ts

@@ -2,14 +2,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { ServerMessage } from "../daemon/message-protocol.js";
 
-// Silence the logger.
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // Analytics consent is granted so recordActivationEvent writes rows.
 let shareAnalytics = true;
 
@@ -35,20 +27,28 @@ const { createSurfaceMutex, handleSurfaceAction, surfaceProxyResolver } =
 
 import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
 import type { SurfaceType, UiSurfaceShow } from "../daemon/message-protocol.js";
-import { queryUnreportedOnboardingEvents } from "../onboarding/onboarding-events-store.js";
-import { getDb } from "../persistence/db-connection.js";
+import { getDb, getTelemetryDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import {
   activationSessions,
-  onboardingEvents,
+  telemetryEvents,
 } from "../persistence/schema/index.js";
 import {
   isActivationSession,
   markActivationSession,
 } from "../plugins/defaults/memory/activation-session-store.js";
+import { queryTelemetryOutboxBatch } from "../telemetry/telemetry-events-outbox.js";
+import type { OnboardingTelemetryEvent } from "../telemetry/types.js";
 
 await initializeDb();
 
+/** Pending onboarding outbox payloads, parsed, in `(created_at, id)` order. */
+function pendingOnboardingPayloads(): OnboardingTelemetryEvent[] {
+  return queryTelemetryOutboxBatch("onboarding", 10).map(
+    (row) => JSON.parse(row.payload) as OnboardingTelemetryEvent,
+  );
+}
+
 interface ProcessMessageCall {
   content: string;
   activeSurfaceId?: string;
@@ -92,7 +92,7 @@ function makeContext(
 }
 
 function resetTables(): void {
-  getDb().delete(onboardingEvents).run();
+  getTelemetryDb()!.delete(telemetryEvents).run();
   getDb().delete(activationSessions).run();
 }
 
@@ -139,11 +139,11 @@ describe("activation moment emission from ui_show surface commits", () => {
       selectedIds: ["inbox"],
     });
 
-    const rows = queryUnreportedOnboardingEvents(0, undefined, 10);
+    const rows = pendingOnboardingPayloads();
     expect(rows).toHaveLength(1);
-    expect(rows[0]!.stepName).toBe("activation_moment_2_complete");
-    expect(rows[0]!.stepIndex).toBe(2);
-    expect(rows[0]!.sessionId).toBe("conv-marked");
+    expect(rows[0]!.step_name).toBe("activation_moment_2_complete");
+    expect(rows[0]!.step_index).toBe(2);
+    expect(rows[0]!.session_id).toBe("conv-marked");
   });
 
   test("a queue-rejected commit does NOT emit; the tag survives for the retry", async () => {
@@ -164,7 +164,7 @@ describe("activation moment emission from ui_show surface commits", () => {
       choiceId: "inbox",
       selectedIds: ["inbox"],
     });
-    expect(queryUnreportedOnboardingEvents(0, undefined, 10)).toHaveLength(0);
+    expect(pendingOnboardingPayloads()).toHaveLength(0);
 
     // Retry is accepted → records exactly one row.
     ctx.enqueueMessage = () => ({ queued: false, requestId: "req-ok" });
@@ -172,9 +172,9 @@ describe("activation moment emission from ui_show surface commits", () => {
       choiceId: "inbox",
       selectedIds: ["inbox"],
     });
-    const rows = queryUnreportedOnboardingEvents(0, undefined, 10);
+    const rows = pendingOnboardingPayloads();
     expect(rows).toHaveLength(1);
-    expect(rows[0]!.stepName).toBe("activation_moment_2_complete");
+    expect(rows[0]!.step_name).toBe("activation_moment_2_complete");
   });
 
   test("first_wow_executed records at SHOW time (no commit) and never double-emits", async () => {
@@ -191,10 +191,10 @@ describe("activation moment emission from ui_show surface commits", () => {
     });
 
     // Recorded immediately on render — no handleSurfaceAction commit needed.
-    let rows = queryUnreportedOnboardingEvents(0, undefined, 10);
+    let rows = pendingOnboardingPayloads();
     expect(rows).toHaveLength(1);
-    expect(rows[0]!.stepName).toBe("activation_first_wow_executed");
-    expect(rows[0]!.stepIndex).toBe(4);
+    expect(rows[0]!.step_name).toBe("activation_first_wow_executed");
+    expect(rows[0]!.step_index).toBe(4);
 
     // If the card later receives a commit (e.g. it carried an action), it must
     // NOT double-emit — a show-timing tag is never stored for the commit path.
@@ -202,7 +202,7 @@ describe("activation moment emission from ui_show surface commits", () => {
       (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
     ) as UiSurfaceShow;
     await handleSurfaceAction(ctx, showMessage.surfaceId, "expand", {});
-    rows = queryUnreportedOnboardingEvents(0, undefined, 10);
+    rows = pendingOnboardingPayloads();
     expect(rows).toHaveLength(1);
   });
 
@@ -215,7 +215,7 @@ describe("activation moment emission from ui_show surface commits", () => {
       data: { body: "x" },
       activation_moment: "first_wow_executed",
     });
-    expect(queryUnreportedOnboardingEvents(0, undefined, 10)).toHaveLength(0);
+    expect(pendingOnboardingPayloads()).toHaveLength(0);
   });
 
   test("does not forward the daemon-only tag to the client", async () => {
@@ -244,7 +244,7 @@ describe("activation moment emission from ui_show surface commits", () => {
       selectedIds: ["inbox"],
     });
 
-    expect(queryUnreportedOnboardingEvents(0, undefined, 10)).toHaveLength(0);
+    expect(pendingOnboardingPayloads()).toHaveLength(0);
   });
 
   test("tagged surface in an UNMARKED session writes no row", async () => {
@@ -257,7 +257,7 @@ describe("activation moment emission from ui_show surface commits", () => {
       selectedIds: ["inbox"],
     });
 
-    expect(queryUnreportedOnboardingEvents(0, undefined, 10)).toHaveLength(0);
+    expect(pendingOnboardingPayloads()).toHaveLength(0);
   });
 
   test("an invalid activation_moment token is ignored (no row)", async () => {
@@ -271,7 +271,7 @@ describe("activation moment emission from ui_show surface commits", () => {
       selectedIds: ["inbox"],
     });
 
-    expect(queryUnreportedOnboardingEvents(0, undefined, 10)).toHaveLength(0);
+    expect(pendingOnboardingPayloads()).toHaveLength(0);
   });
 
   test("FIX 1: launch_conversation commit on a tagged surface records exactly one row", async () => {
@@ -300,10 +300,10 @@ describe("activation moment emission from ui_show surface commits", () => {
       seedPrompt: "Write a draft",
     });
 
-    const rows = queryUnreportedOnboardingEvents(0, undefined, 10);
+    const rows = pendingOnboardingPayloads();
     expect(rows).toHaveLength(1);
-    expect(rows[0]!.stepName).toBe("activation_moment_1_complete");
-    expect(rows[0]!.sessionId).toBe("conv-launch");
+    expect(rows[0]!.step_name).toBe("activation_moment_1_complete");
+    expect(rows[0]!.session_id).toBe("conv-launch");
   });
 
   test("FIX 2: commit-timing tag survives a surfaceState restore from history", async () => {
@@ -354,10 +354,10 @@ describe("activation moment emission from ui_show surface commits", () => {
       selectedIds: ["inbox"],
     });
 
-    const rows = queryUnreportedOnboardingEvents(0, undefined, 10);
+    const rows = pendingOnboardingPayloads();
     expect(rows).toHaveLength(1);
-    expect(rows[0]!.stepName).toBe("activation_moment_2_complete");
-    expect(rows[0]!.sessionId).toBe("conv-restore");
+    expect(rows[0]!.step_name).toBe("activation_moment_2_complete");
+    expect(rows[0]!.session_id).toBe("conv-restore");
   });
 
   test("intermediate selection_changed does NOT emit; the terminal commit does", async () => {
@@ -389,12 +389,12 @@ describe("activation moment emission from ui_show surface commits", () => {
     await handleSurfaceAction(ctx, surfaceId, "selection_changed", {
       selectedIds: ["r1"],
     });
-    expect(queryUnreportedOnboardingEvents(0, undefined, 10)).toHaveLength(0);
+    expect(pendingOnboardingPayloads()).toHaveLength(0);
 
     // Terminal commit — emits exactly once.
     await handleSurfaceAction(ctx, surfaceId, "run", { selectedIds: ["r1"] });
-    const rows = queryUnreportedOnboardingEvents(0, undefined, 10);
+    const rows = pendingOnboardingPayloads();
     expect(rows).toHaveLength(1);
-    expect(rows[0]!.stepName).toBe("activation_moment_3_complete");
+    expect(rows[0]!.step_name).toBe("activation_moment_3_complete");
   });
 });

package/src/__tests__/conversation-surfaces-data-persist.test.ts

@@ -16,7 +16,7 @@ let getMessagesImpl: (conversationId: string) => Array<{
   id: string;
   conversationId: string;
   role: string;
-  content: string;
+  content: unknown;
   createdAt: number;
   metadata: string | null;
 }> = () => [];
@@ -87,7 +87,9 @@ function seedRows(rows: Array<{ id: string; content: unknown }>): void {
       conversationId: "conv-persist-1",
       role: "assistant",
       content:
-        typeof r.content === "string" ? r.content : JSON.stringify(r.content),
+        typeof r.content === "string"
+          ? [{ type: "text", text: r.content }]
+          : r.content,
       createdAt: 0,
       metadata: null,
     }));

package/src/__tests__/conversation-title-service.test.ts

@@ -90,13 +90,6 @@ mock.module("../providers/provider-send-message.js", () => ({
       .join(" "),
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 const mockPublishConversationTitleChanged = mock(
   (_conversationId: string, _title: string) => {},
 );

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -56,7 +56,6 @@ mock.module("../tools/browser/browser-screencast.js", () => ({
 mock.module("../apps/app-store.js", () => ({
   getApp: mock(() => null),
   getAppDirPath: mock(() => "/tmp/test-apps/dummy"),
-  isMultifileApp: mock(() => false),
   getAppsDir: mock(() => "/tmp/test-apps"),
   resolveAppIdByDirName: mock(() => null),
   resolveAppIdFromPath: mock(() => null),

package/src/__tests__/conversation-tool-setup-attribution.test.ts

@@ -7,7 +7,7 @@
  * attribution resolution failures must never break tool execution.
  */
 
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
 import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
 import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
@@ -20,40 +20,6 @@ import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
 // Module mocks (must precede the import of the module under test)
 // ---------------------------------------------------------------------------
 
-let mockLlmConfig: Record<string, unknown> = {};
-let configThrows = false;
-
-// Non-llm fields used by other conversation-tool-setup consumers (e.g.
-// createResolveToolsCallback reads `tools.exclude`), so test files sharing
-// this process keep working against the mocked loader.
-const baseConfig = {
-  tools: { exclude: [] as string[] },
-  timeouts: {
-    shellDefaultTimeoutSec: 120,
-    shellMaxTimeoutSec: 600,
-    permissionTimeoutSec: 300,
-    toolExecutionTimeoutSec: 600,
-  },
-  services: {},
-};
-
-function mockGetConfig() {
-  if (configThrows) {
-    throw new Error("config unavailable");
-  }
-  return { ...baseConfig, llm: mockLlmConfig };
-}
-
-mock.module("../config/loader.js", () => ({
-  getConfig: mockGetConfig,
-  loadConfig: mockGetConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
 mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: mock(() => {}),
 }));
@@ -76,7 +42,6 @@ mock.module("../tools/browser/browser-screencast.js", () => ({
 mock.module("../apps/app-store.js", () => ({
   getApp: mock(() => null),
   getAppDirPath: mock(() => "/tmp/test-apps/dummy"),
-  isMultifileApp: mock(() => false),
   getAppsDir: mock(() => "/tmp/test-apps"),
   resolveAppIdByDirName: mock(() => null),
   resolveAppIdFromPath: mock(() => null),
@@ -100,18 +65,31 @@ mock.module("../persistence/external-conversation-store.js", () => ({
 // Imports after mocks are in place
 // ---------------------------------------------------------------------------
 
-import { LLMSchema } from "../config/schemas/llm.js";
+import * as configLoader from "../config/loader.js";
 import {
   createToolExecutor,
   resolveConversationAttribution,
 } from "../daemon/conversation-tool-setup.js";
+import { setConfig } from "./helpers/set-config.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
 function setLlmConfig(raw: unknown): void {
-  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+  setConfig("llm", raw);
+}
+
+/**
+ * Make the config loader throw for the failure-path tests: attribution
+ * resolution must degrade to `null` on any error. The real loader never
+ * throws on its own (it falls back to defaults), so this injects the fault
+ * at the read site.
+ */
+function makeGetConfigThrow(): ReturnType<typeof spyOn> {
+  return spyOn(configLoader, "getConfig").mockImplementation(() => {
+    throw new Error("config unavailable");
+  });
 }
 
 /** Build a minimal ToolSetupContext stub. */
@@ -168,14 +146,7 @@ function makeToolFn(executor: ToolExecutor, ctx: ToolSetupContext) {
   return createToolExecutor(executor, noopPrompter, noopSecretPrompter, ctx);
 }
 
-// The module mock outlives this file when multiple test files share a
-// process, so leave the config in a working (non-throwing) state.
-afterEach(() => {
-  configThrows = false;
-});
-
 beforeEach(() => {
-  configThrows = false;
   setLlmConfig({
     default: { provider: "anthropic", model: "model-default" },
     profiles: {
@@ -240,11 +211,14 @@ describe("resolveConversationAttribution", () => {
   });
 
   test("returns null instead of throwing when resolution fails", () => {
-    configThrows = true;
-
-    expect(
-      resolveConversationAttribution({ conversationId: "conv-test" }),
-    ).toBeNull();
+    const getConfigSpy = makeGetConfigThrow();
+    try {
+      expect(
+        resolveConversationAttribution({ conversationId: "conv-test" }),
+      ).toBeNull();
+    } finally {
+      getConfigSpy.mockRestore();
+    }
   });
 });
 
@@ -318,16 +292,19 @@ describe("createToolExecutor attribution threading", () => {
   });
 
   test("attribution resolution failure yields null and does not break tool execution", async () => {
-    configThrows = true;
-
-    const { executor, calls } = makeCapturingExecutor();
-    const toolFn = makeToolFn(executor, makeCtx());
-
-    const result = await toolFn("file_read", { path: "/tmp/a" });
-
-    expect(result).toMatchObject({ content: "ok", isError: false });
-    expect(calls).toHaveLength(1);
-    expect(calls[0].context.attribution).toBeNull();
+    const getConfigSpy = makeGetConfigThrow();
+    try {
+      const { executor, calls } = makeCapturingExecutor();
+      const toolFn = makeToolFn(executor, makeCtx());
+
+      const result = await toolFn("file_read", { path: "/tmp/a" });
+
+      expect(result).toMatchObject({ content: "ok", isError: false });
+      expect(calls).toHaveLength(1);
+      expect(calls[0].context.attribution).toBeNull();
+    } finally {
+      getConfigSpy.mockRestore();
+    }
   });
 });
 

package/src/__tests__/conversation-tool-setup-tools-disabled.test.ts

@@ -28,10 +28,8 @@ mock.module("../daemon/conversation-skill-tools.js", () => ({
 // Import after mocks
 // ---------------------------------------------------------------------------
 
-import {
-  createResolveToolsCallback,
-  type SkillProjectionContext,
-} from "../daemon/conversation-tool-setup.js";
+import type { Conversation } from "../daemon/conversation.js";
+import { createResolveToolsCallback } from "../daemon/conversation-tool-setup.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -41,16 +39,13 @@ function makeToolDef(name: string): ToolDefinition {
   return { name, description: `${name} tool`, input_schema: {} };
 }
 
-function makeCtx(
-  overrides: Partial<SkillProjectionContext> = {},
-): SkillProjectionContext {
+function makeCtx(overrides: Partial<Conversation> = {}): Conversation {
   return {
     skillProjectionState: new Map(),
     skillProjectionCache: {} as SkillProjectionCache,
-    coreToolNames: new Set(["tool_a", "tool_b"]),
     toolsDisabledDepth: 0,
     ...overrides,
-  };
+  } as unknown as Conversation;
 }
 
 const EMPTY_HISTORY: Message[] = [];
@@ -155,7 +150,7 @@ describe("createResolveToolsCallback — toolsDisabledDepth", () => {
     expect(ctx.allowedToolNames).toEqual(new Set());
   });
 
-  test("records the resolved set on lastResolvedToolNames for inventory queries", () => {
+  test("records the resolved set on registeredToolDefinitions for inventory queries", () => {
     // GIVEN a normal resolver call
     const toolDefs = [makeToolDef("tool_a"), makeToolDef("tool_b")];
     const ctx = makeCtx();
@@ -165,18 +160,21 @@ describe("createResolveToolsCallback — toolsDisabledDepth", () => {
     resolve(EMPTY_HISTORY);
 
     // THEN the durable snapshot mirrors the per-turn gate
-    expect(ctx.lastResolvedToolNames).toEqual(ctx.allowedToolNames!);
-    expect(ctx.lastResolvedToolNames?.has("tool_a")).toBe(true);
-    expect(ctx.lastResolvedToolNames?.has("tool_b")).toBe(true);
+    const resolvedNames = new Set(
+      ctx.registeredToolDefinitions?.map((d) => d.name),
+    );
+    expect(resolvedNames).toEqual(ctx.allowedToolNames!);
+    expect(resolvedNames.has("tool_a")).toBe(true);
+    expect(resolvedNames.has("tool_b")).toBe(true);
   });
 
-  test("preserves lastResolvedToolNames when a later call disables tools", () => {
+  test("preserves registeredToolDefinitions when a later call disables tools", () => {
     // GIVEN a conversation that resolved tools on a normal turn
     const toolDefs = [makeToolDef("tool_a"), makeToolDef("tool_b")];
     const ctx = makeCtx();
     const resolve = createResolveToolsCallback(toolDefs, ctx)!;
     resolve(EMPTY_HISTORY);
-    const snapshot = ctx.lastResolvedToolNames;
+    const snapshot = ctx.registeredToolDefinitions;
 
     // WHEN a subsequent call disables tools (e.g. pointer generation, or the
     // turn-teardown that clears the per-turn gate)
@@ -185,7 +183,9 @@ describe("createResolveToolsCallback — toolsDisabledDepth", () => {
 
     // THEN the per-turn gate is empty but the inventory snapshot survives
     expect(ctx.allowedToolNames).toEqual(new Set());
-    expect(ctx.lastResolvedToolNames).toBe(snapshot);
-    expect(ctx.lastResolvedToolNames?.has("tool_a")).toBe(true);
+    expect(ctx.registeredToolDefinitions).toBe(snapshot);
+    expect(
+      ctx.registeredToolDefinitions?.some((d) => d.name === "tool_a"),
+    ).toBe(true);
   });
 });

package/src/__tests__/conversation-unread-route.test.ts

@@ -1,12 +1,5 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   hasUngatedHttpAuthDisabled: () => false,

package/src/__tests__/conversation-usage.test.ts

@@ -1,13 +1,4 @@
-import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
-
-// Legacy-shaped fixtures (llm.default-centric resolution): pinned to the
-// flag-off cascade. Override-or-default (flag-on) semantics are pinned by
-// llm-resolver-override-or-default.test.ts and its companion suites.
-beforeAll(() => {
-  setOverridesForTesting({ "override-or-default-resolution": false });
-});
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const updateConversationUsageCalls: Array<{
   conversationId: string;
@@ -16,21 +7,6 @@ const updateConversationUsageCalls: Array<{
   estimatedCost: number;
 }> = [];
 
-let mockLlmConfig = createMockLlmConfig();
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    llm: mockLlmConfig,
-  }),
-}));
-
 mock.module("../persistence/conversation-crud.js", () => ({
   setConversationProcessingStartedAt: () => {},
   isConversationProcessing: () => false,
@@ -58,63 +34,35 @@ import type { Provider, ProviderResponse } from "../providers/types.js";
 import { UsageTrackingProvider } from "../providers/usage-tracking.js";
 import type { PricingUsage } from "../usage/types.js";
 import { resolvePricingForUsageWithOverrides } from "../util/pricing.js";
+import { setConfig } from "./helpers/set-config.js";
 
 await initializeDb();
 
-function createMockLlmConfig() {
-  return {
-    default: {
-      provider: "anthropic" as const,
-      model: "claude-opus-4-6",
-      maxTokens: 64_000,
-      effort: "max" as const,
-      speed: "standard" as const,
-      verbosity: "medium" as const,
-      temperature: null,
-      thinking: { enabled: true, streamThinking: true },
-      contextWindow: {
-        enabled: true,
-        maxInputTokens: 200_000,
-        targetBudgetRatio: 0.3,
-        compactThreshold: 0.8,
-        summaryBudgetRatio: 0.05,
-        overflowRecovery: {
-          enabled: true,
-          safetyMarginRatio: 0.05,
-          maxAttempts: 3,
-          interactiveLatestTurnCompression: "summarize" as const,
-          nonInteractiveLatestTurnCompression: "truncate" as const,
-        },
-      },
-      openrouter: { only: [] },
+// The attribution assertions resolve profiles/call sites through the real
+// workspace config, so seed the fixtures the tests reference.
+setConfig("llm", {
+  profiles: {
+    conversationProfile: {
+      provider: "openai",
+      model: "gpt-4o",
     },
-    profiles: {
-      conversationProfile: {
-        provider: "openai" as const,
-        model: "gpt-4o",
-      },
-      summaryProfile: {
-        provider: "anthropic" as const,
-        model: "claude-haiku-3",
-      },
+    summaryProfile: {
+      provider: "anthropic",
+      model: "claude-haiku-3",
     },
-    profileOrder: [],
-    callSites: {
-      conversationSummarization: {
-        profile: "summaryProfile",
-      },
+  },
+  callSites: {
+    conversationSummarization: {
+      profile: "summaryProfile",
     },
-    activeProfile: undefined,
-    pricingOverrides: [],
-  };
-}
+  },
+});
 
 describe("recordUsage", () => {
   beforeEach(() => {
     const db = getDb();
     db.run(`DELETE FROM llm_usage_events`);
     updateConversationUsageCalls.length = 0;
-    mockLlmConfig = createMockLlmConfig();
   });
 
   test("applies fast mode pricing when any response has speed: fast", () => {
@@ -409,9 +357,11 @@ describe("recordUsage", () => {
       undefined,
       1,
       undefined,
+      // No override profile: an override wins selection at every call site
+      // (covered by the main-agent test above), so attribution lands on the
+      // call-site rung only when the turn carries no override.
       {
         callSite: "conversationSummarization",
-        overrideProfile: "conversationProfile",
       },
     );