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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.8",
+  "version": "0.10.9-dev.202607152225.ec6fdbf",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -30,7 +30,7 @@
     "test:stable": "EXCLUDE_EXPERIMENTAL=true bun run scripts/test.ts",
     "test:bench": "find src -type f -name '*.benchmark.test.ts' -print0 | xargs -0 -P 1 -I {} bun test {}",
     "test:filesystem-tools": "bash scripts/test-filesystem-tools.sh",
-    "postinstall": "cd .. && (git config core.hooksPath || git config core.hooksPath .githooks 2>/dev/null || true) && ([ -f meta/feature-flags/sync-bundled-copies.ts ] && bun run meta/feature-flags/sync-bundled-copies.ts 2>/dev/null || true)"
+    "postinstall": "cd .. && (git config core.hooksPath || git config core.hooksPath .githooks 2>/dev/null || true) && ([ -f meta/sync-bundled-copies.ts ] && bun run meta/sync-bundled-copies.ts 2>/dev/null || true)"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "0.25.0",

package/scripts/build-test-fixtures.ts

@@ -69,8 +69,9 @@ async function buildMigratedFixture(outWorkspaceDir: string): Promise<void> {
   mkdirSync(destDbDir, { recursive: true });
 
   // The four DBs are captured together: the migrated state spans them (e.g.
-  // llm_request_logs in `logs`, memory_jobs in `memory`, watchdog_events in
-  // `telemetry`), so a partial capture would leave a test with missing tables.
+  // llm_request_logs in `logs`, memory_jobs in `memory`, telemetry_events +
+  // flush_checkpoints in `telemetry`), so a partial capture would leave a test
+  // with missing tables.
   const captures = [
     [getSqlite(), getDbPath()],
     [getLogsSqlite(), getLogsDbPath()],

package/scripts/test.ts

@@ -73,16 +73,11 @@ const KNOWN_BROKEN_FILES = new Set<string>([]);
 // and feature-flag-registry-bundled.test.ts fails. Running the sync here is
 // idempotent and cheap (two file copies).
 function syncFeatureFlagRegistry(): void {
-  const syncScript = join(
-    "..",
-    "meta",
-    "feature-flags",
-    "sync-bundled-copies.ts",
-  );
+  const syncScript = join("..", "meta", "sync-bundled-copies.ts");
   if (!existsSync(syncScript)) {
     return;
   }
-  Bun.spawnSync(["bun", "run", "meta/feature-flags/sync-bundled-copies.ts"], {
+  Bun.spawnSync(["bun", "run", "meta/sync-bundled-copies.ts"], {
     cwd: join(process.cwd(), ".."),
     stdout: "ignore",
     stderr: "ignore",

package/src/__tests__/activation-early-marking.test.ts

@@ -16,17 +16,10 @@
 
 import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 const { applyBootstrapTemplate } = await import("../prompts/system-prompt.js");
 const { isActivationSession } =
   await import("../plugins/defaults/memory/activation-session-store.js");

package/src/__tests__/actor-token-service.test.ts

@@ -13,13 +13,6 @@
  */
 import { 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: () => false,
   getInternalGatewayTarget: () => "http://localhost:7822",

package/src/__tests__/add-message-preassigned-id.test.ts

@@ -40,7 +40,7 @@ describe("addMessage pre-assigned id", () => {
     const msgs = getMessages("conv-preassigned-id");
     const found = msgs.find((m) => m.id === customId);
     expect(found).toBeDefined();
-    expect(found?.content).toBe("hello");
+    expect(found?.content).toEqual([{ type: "text", text: "hello" }]);
   });
 
   test("generates a uuid when no id is provided", async () => {

package/src/__tests__/add-message-skip-indexing.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Indexing side effects of `addMessage({ skipIndexing })`.
+ *
+ * A message saved with `skipIndexing: true` must persist (visible in the
+ * transcript) while producing NO indexing artifacts: no `memory_segments`
+ * rows, no `embed_segment` tickets, no `index_message_lexical` ticket. A
+ * message saved without the flag must produce all of them — the default is
+ * unchanged. This is the contract the consolidation kickoff prompt relies on
+ * (threaded via `runBackgroundJob({ skipPromptIndexing })` →
+ * `processMessage({ skipUserMessageIndexing })`).
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+mock.module("../persistence/embeddings/qdrant-client.js", () => ({
+  getQdrantClient: () => ({
+    searchWithFilter: async () => [],
+    hybridSearch: async () => [],
+    upsertPoints: async () => {},
+    deletePoints: async () => {},
+  }),
+  initQdrantClient: () => {},
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
+}));
+
+import { addMessage } from "../persistence/conversation-crud.js";
+import { getDb, getMemoryDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  conversations,
+  memoryJobs,
+  memorySegments,
+  messages,
+} from "../persistence/schema/index.js";
+import { setConfig } from "./helpers/set-config.js";
+
+// Deterministic extraction: keep the LLM out of the indexer path. Everything
+// else (including `memory.enabled: true`) is the schema default.
+setConfig("memory", { extraction: { useLLM: false } });
+
+await initializeDb();
+
+// Open the memory connection before any test mutates state so the jobs table
+// is reachable through the same path the enqueue helpers use.
+getMemoryDb();
+
+const CONVERSATION_ID = "conv-skip-indexing";
+
+const LONG_TEXT =
+  "You are running memory consolidation. Read the buffer, route each entry " +
+  "into the matching concept page, rewrite the recent file, and trim the " +
+  "buffer down to entries that arrived after the cutoff. Alice prefers " +
+  "VS Code over Vim for large projects and ships at the end of the day.";
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM memory_segments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  getMemoryDb()!.run("DELETE FROM memory_jobs");
+
+  const now = Date.now();
+  db.insert(conversations)
+    .values({
+      id: CONVERSATION_ID,
+      title: null,
+      createdAt: now,
+      updatedAt: now,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      contextCompactedAt: null,
+    })
+    .run();
+}
+
+function messageRow(messageId: string) {
+  return getDb()
+    .select()
+    .from(messages)
+    .where(eq(messages.id, messageId))
+    .get();
+}
+
+function segmentCountFor(messageId: string): number {
+  return getDb()
+    .select()
+    .from(memorySegments)
+    .where(eq(memorySegments.messageId, messageId))
+    .all().length;
+}
+
+/** Memory-jobs of `type` whose payload references `messageId` (embed_segment
+ *  payloads carry segment metadata, so those are matched by conversation-wide
+ *  count instead — callers reset the table between saves). */
+function jobCount(type: string): number {
+  return getMemoryDb()!
+    .select()
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, type))
+    .all().length;
+}
+
+function blocks(text: string): string {
+  return JSON.stringify([{ type: "text", text }]);
+}
+
+beforeEach(() => {
+  resetTables();
+});
+
+describe("addMessage skipIndexing contract", () => {
+  test("skipIndexing: true persists the row but produces zero segments and zero tickets", async () => {
+    const saved = await addMessage(CONVERSATION_ID, "user", blocks(LONG_TEXT), {
+      skipIndexing: true,
+    });
+
+    // The row exists — the message is part of the transcript.
+    expect(messageRow(saved.id)).toBeDefined();
+
+    // No indexing artifacts of any kind.
+    expect(segmentCountFor(saved.id)).toBe(0);
+    expect(jobCount("embed_segment")).toBe(0);
+    expect(jobCount("index_message_lexical")).toBe(0);
+  });
+
+  test("default save indexes: segments, embed tickets, and a lexical ticket", async () => {
+    const saved = await addMessage(CONVERSATION_ID, "user", blocks(LONG_TEXT));
+
+    expect(messageRow(saved.id)).toBeDefined();
+    expect(segmentCountFor(saved.id)).toBeGreaterThan(0);
+    expect(jobCount("embed_segment")).toBeGreaterThan(0);
+
+    const lexicalPayloads = getMemoryDb()!
+      .select({ payload: memoryJobs.payload })
+      .from(memoryJobs)
+      .where(eq(memoryJobs.type, "index_message_lexical"))
+      .all()
+      .map((row) => JSON.parse(row.payload) as { messageId?: string });
+    expect(lexicalPayloads).toEqual([{ messageId: saved.id }]);
+  });
+
+  test("a default-path save after a skipped save still indexes (per-message flag)", async () => {
+    const skipped = await addMessage(
+      CONVERSATION_ID,
+      "user",
+      blocks(LONG_TEXT),
+      { skipIndexing: true },
+    );
+    const reply = await addMessage(
+      CONVERSATION_ID,
+      "assistant",
+      blocks(LONG_TEXT),
+    );
+
+    expect(segmentCountFor(skipped.id)).toBe(0);
+    expect(segmentCountFor(reply.id)).toBeGreaterThan(0);
+    expect(jobCount("index_message_lexical")).toBe(1);
+  });
+});

package/src/__tests__/agent-image-optimize.test.ts

@@ -1,6 +1,36 @@
 import { describe, expect, it } from "bun:test";
 
-import { shouldRescaleImage } from "../agent/image-optimize.js";
+import {
+  isBelowMinDimension,
+  MIN_IMAGE_DIMENSION,
+  optimizeImageForTransport,
+  shouldRescaleImage,
+  upscaleImageToMinimum,
+  upscaleTargetDimensions,
+} from "../agent/image-optimize.js";
+
+/**
+ * Minimal PNG whose IHDR declares the given dimensions — enough for
+ * `parseImageDimensions` to read them; the payload is not decodable.
+ */
+function makePngBase64(width: number, height: number): string {
+  return Buffer.from(
+    Uint8Array.from([
+      ...[0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], // PNG signature
+      ...[0x00, 0x00, 0x00, 0x0d], // IHDR length (13)
+      ...[0x49, 0x48, 0x44, 0x52], // "IHDR"
+      (width >>> 24) & 0xff,
+      (width >>> 16) & 0xff,
+      (width >>> 8) & 0xff,
+      width & 0xff,
+      (height >>> 24) & 0xff,
+      (height >>> 16) & 0xff,
+      (height >>> 8) & 0xff,
+      height & 0xff,
+      ...[0x08, 0x06, 0x00, 0x00, 0x00], // bit depth / color type / etc.
+    ]),
+  ).toString("base64");
+}
 
 describe("shouldRescaleImage", () => {
   it("rescales when any side exceeds the max dimension, regardless of file size", () => {
@@ -34,3 +64,76 @@ describe("shouldRescaleImage", () => {
     expect(shouldRescaleImage(null, 5_000_000)).toBe(true);
   });
 });
+
+describe("isBelowMinDimension", () => {
+  it("flags an image with any side under the minimum floor", () => {
+    // Regression: Anthropic rejects tiny images with a 400 "Could not
+    // process image" (observed with a 16×14 px upload).
+    expect(isBelowMinDimension({ width: 16, height: 14 })).toBe(true);
+    expect(isBelowMinDimension({ width: 1024, height: 20 })).toBe(true);
+  });
+
+  it("leaves images at or above the floor alone", () => {
+    expect(
+      isBelowMinDimension({
+        width: MIN_IMAGE_DIMENSION,
+        height: MIN_IMAGE_DIMENSION,
+      }),
+    ).toBe(false);
+    expect(isBelowMinDimension({ width: 1200, height: 800 })).toBe(false);
+  });
+
+  it("never flags unparseable dimensions — byte size cannot prove smallness", () => {
+    expect(isBelowMinDimension(null)).toBe(false);
+  });
+});
+
+describe("upscaleTargetDimensions", () => {
+  it("lifts the short side to the minimum floor, preserving aspect ratio", () => {
+    const target = upscaleTargetDimensions({ width: 16, height: 14 });
+    expect(target).not.toBeNull();
+    expect(Math.min(target!.width, target!.height)).toBe(MIN_IMAGE_DIMENSION);
+    // 16:14 aspect carried through the upscale (±1 px rounding).
+    expect(target!.width / target!.height).toBeCloseTo(16 / 14, 1);
+  });
+
+  it("returns null for an image already at the floor", () => {
+    expect(
+      upscaleTargetDimensions({
+        width: MIN_IMAGE_DIMENSION,
+        height: MIN_IMAGE_DIMENSION,
+      }),
+    ).toBeNull();
+  });
+
+  it("caps the long side at the transport max for extreme aspect ratios", () => {
+    // A 4×2000 sliver cannot reach a 64 px short side without blowing the
+    // 1568 px long-side cap; the scale is clamped to the cap instead.
+    const target = upscaleTargetDimensions({ width: 4, height: 2000 });
+    expect(target).toBeNull();
+  });
+});
+
+describe("upscaleImageToMinimum", () => {
+  it("returns null when dimensions are unparseable", () => {
+    expect(
+      upscaleImageToMinimum(
+        Buffer.from("not an image").toString("base64"),
+        "image/png",
+      ),
+    ).toBeNull();
+  });
+});
+
+describe("optimizeImageForTransport", () => {
+  it("passes an undersized image through unchanged — the minimum floor is rejection-path only", () => {
+    // The floor is undocumented provider behavior, so pre-send transport
+    // never enforces it; only the image-recovery plugin reacts to an actual
+    // "Could not process image" rejection.
+    const tiny = makePngBase64(16, 14);
+    expect(optimizeImageForTransport(tiny, "image/png")).toEqual({
+      data: tiny,
+      mediaType: "image/png",
+    });
+  });
+});

package/src/__tests__/agent-loop-callsite-precedence.test.ts

@@ -19,21 +19,9 @@
  * clients consume.
  */
 
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
-let mockLlmConfig: Record<string, unknown> = {};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ llm: mockLlmConfig }),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { AgentLoop } from "../agent/loop.js";
-import { LLMSchema } from "../config/schemas/llm.js";
 import { RetryProvider } from "../providers/retry.js";
 import type {
   Message,
@@ -41,18 +29,20 @@ import type {
   ProviderResponse,
   SendMessageOptions,
 } from "../providers/types.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const userMessage: Message = {
   role: "user",
   content: [{ type: "text", text: "hi" }],
 };
 
+/** Seed the workspace `llm` config block for real; the loader schema-merges it. */
 function setLlmConfig(raw: unknown): void {
-  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+  setConfig("llm", raw);
 }
 
 beforeEach(() => {
-  mockLlmConfig = LLMSchema.parse({}) as Record<string, unknown>;
+  setLlmConfig({});
 });
 
 /**

package/src/__tests__/agent-loop-mutable-latest-user-message.test.ts

@@ -13,12 +13,6 @@
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "./helpers/mock-logger.js";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 // AgentLoop reads the v3-live gate (`config.memory.v3.live`) via
 // `isMemoryV3Live` to decide the cache-anchor signal; drive it per-test.
 let memoryV3LiveSlot = false;

package/src/__tests__/agent-loop-override-profile.test.ts

@@ -13,25 +13,13 @@
  * field is omitted from `providerConfig` rather than carrying `undefined`.
  */
 
-import { beforeAll, describe, expect, mock, test } from "bun:test";
-
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
+import { describe, expect, mock, test } from "bun:test";
 
 // These suites exercise override-profile PLUMBING through legacy-shaped
 // fixtures (llm.default-centric, no defaultProvider). Pinned to the
 // flag-off cascade; override-or-default resolution semantics are pinned by
 // llm-resolver-override-or-default.test.ts and the inference-profile loop
 // suite.
-beforeAll(() => {
-  setOverridesForTesting({ "override-or-default-resolution": false });
-});
-
-import { makeMockLogger } from "./helpers/mock-logger.js";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 import { AgentLoop } from "../agent/loop.js";
 import type {
   Message,
@@ -40,6 +28,7 @@ import type {
   SendMessageOptions,
   ToolDefinition,
 } from "../providers/types.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const userMessage: Message = {
   role: "user",
@@ -282,14 +271,20 @@ mock.module("../providers/registry.js", () => ({
   resolveProviderFromConnection: async () => anthropicStub,
 }));
 
+import { VELLUM_MANAGED_CONNECTION_NAME } from "../providers/vellum-model-routing.js";
+
 // Connection-aware resolver path: satisfy
 // `tryResolveProviderForConnectionName` lookups so resolveDefaultProvider
-// returns a usable provider for the inline `anthropic-conn` fixture.
+// returns a usable provider for any connection name the winning profile
+// references. The managed connection must carry the provider the catalog
+// `balanced` default declares (fireworks) or resolution rejects the row as a
+// provider mismatch; other names behave as personal anthropic connections.
 mock.module("../providers/inference/connections.js", () => ({
   getConnection: (_db: unknown, name: string) => ({
     id: 1,
     name,
-    provider: "anthropic",
+    provider:
+      name === VELLUM_MANAGED_CONNECTION_NAME ? "fireworks" : "anthropic",
     auth_strategy: "user_managed_credential",
     credential_alias: null,
     metadata_json: null,
@@ -298,32 +293,32 @@ mock.module("../providers/inference/connections.js", () => ({
   }),
 }));
 
-let mockActiveProfile: string | undefined;
-let mockCallSites: Record<string, unknown> = {};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    llm: {
-      default: {
+/**
+ * Seed the workspace `llm` config block for real. `activeProfile` and
+ * `callSites` vary per test.
+ */
+function seedLlmConfig(options?: {
+  activeProfile?: string;
+  callSites?: Record<string, unknown>;
+}): void {
+  setConfig("llm", {
+    profiles: {
+      // Complete (provider + model) so the profile is a usable winner at
+      // every rung of the single-winner selection chain.
+      fast: {
+        source: "user",
         provider: "anthropic",
-        model: "claude-opus-4-7",
-        provider_connection: "anthropic-conn",
-      },
-      profiles: {
-        // Disable the catalog default so resolution lands on llm.default.
-        balanced: { source: "managed", status: "disabled" },
-        fast: {
-          source: "user",
-          provider: "anthropic",
-          model: "claude-haiku-4-5-20251001",
-        },
+        model: "claude-haiku-4-5-20251001",
       },
-      activeProfile: mockActiveProfile,
-      callSites: mockCallSites,
     },
-    rateLimit: { maxRequestsPerMinute: 0 },
-  }),
-}));
+    ...(options?.activeProfile === undefined
+      ? {}
+      : { activeProfile: options.activeProfile }),
+    callSites: options?.callSites ?? {},
+  });
+}
+
+seedLlmConfig();
 
 import { SubagentManager } from "../subagent/manager.js";
 
@@ -457,7 +452,7 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
     }
   });
 
-  test("omits overrideProfile when neither context nor row carries it", async () => {
+  test("forwards the invoker's resolved default profile when neither context nor row carries an override", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -479,10 +474,11 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
       );
 
       expect(capturedConfig).toBeDefined();
-      // Field must be absent rather than carrying `undefined` so the
-      // SubagentConfig respects the same "field omitted when unset"
-      // contract the agent loop uses.
-      expect("overrideProfile" in capturedConfig!).toBe(false);
+      // With no explicit override anywhere, the invoker-default tier forwards
+      // the invoking call site's resolved default profile — here `mainAgent`
+      // with no active profile or pin, which resolves the catalog `balanced`
+      // default — so the subagent matches its invoker's model selection.
+      expect(capturedConfig!.overrideProfile).toBe("balanced");
     } finally {
       manager.spawn = originalSpawn;
     }
@@ -491,8 +487,9 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
   test("an explicit subagentSpawn call-site pin suppresses the invoker-default inheritance", async () => {
     // With an active profile the invoker-default tier resolves ("fast"), so
     // absent a pin it is forwarded as the inherited override; with an
-    // explicit llm.callSites.subagentSpawn profile the heuristic must yield
-    // so the pin can win under override-or-default resolution.
+    // explicit llm.callSites.subagentSpawn profile the heuristic must yield —
+    // a forwarded override would outrank the pin under single-winner
+    // resolution, overriding the user's explicit call-site choice.
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -500,7 +497,7 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
       capturedConfig = config;
       return "nested-subagent-id-3";
     };
-    mockActiveProfile = "fast";
+    seedLlmConfig({ activeProfile: "fast" });
     try {
       const baseContext = {
         workingDir: "/tmp",
@@ -509,14 +506,16 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
         sendToClient: () => {},
       } as import("../tools/types.js").ToolContext;
 
-      mockCallSites = {};
       await executeSubagentSpawn(
         { label: "nested", objective: "do nested work" },
         baseContext,
       );
       expect(capturedConfig!.overrideProfile).toBe("fast");
 
-      mockCallSites = { subagentSpawn: { profile: "fast" } };
+      seedLlmConfig({
+        activeProfile: "fast",
+        callSites: { subagentSpawn: { profile: "fast" } },
+      });
       capturedConfig = undefined;
       await executeSubagentSpawn(
         { label: "nested", objective: "do nested work" },
@@ -525,8 +524,7 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
       expect("overrideProfile" in capturedConfig!).toBe(false);
     } finally {
       manager.spawn = originalSpawn;
-      mockActiveProfile = undefined;
-      mockCallSites = {};
+      seedLlmConfig();
     }
   });
 });

package/src/__tests__/agent-loop-pushes-post-hook-prompt.test.ts

@@ -9,14 +9,6 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// ── Stub pipes ──────────────────────────────────────────────────────
-// Same logger-stub shape as the rest of the test suite — pino pulls are
-// agent-loop-time too, but we silence them so the test stays deterministic.
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 // Mock plugin pipeline. Two modes:
 //  - return mode (default): returns `hookResponse` as the hook result.
 //  - in-place mode: mutates ctx.systemPrompt directly and returns the same
@@ -54,15 +46,8 @@ mock.module("../plugins/pipeline.js", () => ({
   },
 }));
 
-// Minimal `getConfig` so the loop's defaults/loader path doesn't trip.
-let mockLlmConfig: Record<string, unknown> = {};
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ llm: mockLlmConfig }),
-}));
-
 import type { AgentEvent } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
-import { LLMSchema } from "../config/schemas/llm.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import type {
   Message,
@@ -70,6 +55,7 @@ import type {
   ProviderResponse,
   SendMessageOptions,
 } from "../providers/types.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const userMessage: Message = {
   role: "user",
@@ -81,12 +67,13 @@ const trust: TrustContext = {
   trustClass: "guardian",
 };
 
+/** Seed the workspace `llm` config block for real; the loader schema-merges it. */
 function setLlmConfig(raw: unknown): void {
-  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+  setConfig("llm", raw);
 }
 
 beforeEach(() => {
-  mockLlmConfig = LLMSchema.parse({}) as Record<string, unknown>;
+  setLlmConfig({});
   hookMutatesInPlace = false;
   hookResponse = {
     conversationId: "test-conv",