@vellumai/assistant 0.8.1 → 0.8.2

package/src/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -107,18 +107,20 @@ mock.module("@qdrant/js-client-rest", () => ({
   QdrantClient: MockQdrantClient,
 }));
 
+const embedWithBackendMock = mock(async (_config, texts: string[]) => ({
+  provider: "local",
+  model: "test-model",
+  vectors: texts.map(() => [0.1, 0.2, 0.3]) as number[][],
+}));
+const generateSparseEmbeddingMock = mock((_text: string) => ({
+  indices: [1, 2, 3],
+  values: [0.5, 0.5, 0.5] as number[],
+}));
 const realEmbeddingBackend = await import("../../embedding-backend.js");
 mock.module("../../embedding-backend.js", () => ({
   ...realEmbeddingBackend,
-  embedWithBackend: async () => ({
-    provider: "local",
-    model: "test-model",
-    vectors: [[0.1, 0.2, 0.3]] as number[][],
-  }),
-  generateSparseEmbedding: () => ({
-    indices: [1, 2, 3],
-    values: [0.5, 0.5, 0.5] as number[],
-  }),
+  embedWithBackend: embedWithBackendMock,
+  generateSparseEmbedding: generateSparseEmbeddingMock,
 }));
 
 const realQdrantClient = await import("../../qdrant-client.js");
@@ -293,6 +295,8 @@ beforeEach(() => {
   qdrantState.queryResponses.sparse.length = 0;
   loadContextMemoryMock.mockClear();
   retrieveForTurnMock.mockClear();
+  embedWithBackendMock.mockClear();
+  generateSparseEmbeddingMock.mockClear();
   _resetMemoryV2QdrantForTests();
 });
 
@@ -390,6 +394,59 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(firstBlock.text).toContain("# memory/concepts/alice-vscode.md");
   });
 
+  test("per-turn dense embedding is computed from combined assistant+user text", async () => {
+    // Short referential follow-ups ("do that one") carry no semantic signal
+    // on their own — the dense PKB query embedding must mirror v1's
+    // `retrieveForTurn` and combine the prior assistant turn so hint search
+    // still resolves what "that one" refers to. The sparse vector matches
+    // v1 by using the user message alone so lexical signal isn't diluted.
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const assistantText =
+      "Alice prefers VS Code as her editor — she finds the extension ecosystem unmatched.";
+    const userText = "do that one";
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text" as const, text: "what editors did we cover?" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text" as const, text: assistantText }],
+      },
+      { role: "user", content: [{ type: "text" as const, text: userText }] },
+    ];
+
+    await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    // v1's `retrieveForTurn` joins assistantLast + userLast with "\n\n" and
+    // embeds the combined string as the dense query vector. Assert the v2
+    // path makes the exact same embed call somewhere during this turn.
+    const expectedCombined = `${assistantText}\n\n${userText}`;
+    const matchingCall = embedWithBackendMock.mock.calls.find((call) => {
+      const texts = call[1] as string[];
+      return texts.length === 1 && texts[0] === expectedCombined;
+    });
+    expect(matchingCall).toBeDefined();
+
+    // Sparse embedding for the per-turn query uses userLast only.
+    expect(generateSparseEmbeddingMock.mock.calls).toContainEqual([userText]);
+    expect(
+      generateSparseEmbeddingMock.mock.calls.some((call) =>
+        (call[0] as string).includes(assistantText),
+      ),
+    ).toBe(false);
+  });
+
   test("config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
     // No `stageTurn` call — every channel returns `{ points: [] }` so the
     // candidate set is empty and `injectMemoryV2Block` returns block=null.

package/src/memory/graph/conversation-graph-memory.ts

@@ -438,8 +438,10 @@ export class ConversationGraphMemory {
       // turns. v1's `loadContextMemory` produced these as a side effect of
       // hybrid retrieval; the v2 path skips that retrieval, so embed
       // explicitly here.
+      const userQueryText = rawUserText ?? userQuery ?? "";
       const userQueryEmbed = await this.computeQueryVectors(
-        rawUserText ?? userQuery ?? "",
+        userQueryText,
+        userQueryText,
         config,
         signal,
       );
@@ -598,8 +600,16 @@ export class ConversationGraphMemory {
     if (v2.routed) {
       // Surface a per-turn query embedding so PKB hint search still runs
       // on v2 turns. v1's `retrieveForTurn` produced these as a side effect;
-      // the v2 path skips that retrieval, so embed explicitly here.
+      // the v2 path skips that retrieval, so embed explicitly here. Match
+      // v1's split: dense embeds the combined assistant+user text (short
+      // referential follow-ups like "do that one" need the assistant turn
+      // for semantic grounding), while sparse uses the user message alone
+      // to keep lexical signal focused on what the user actually said.
+      const denseQueryText = [assistantLast, userLast]
+        .filter((m) => m.length > 0)
+        .join("\n\n");
       const perTurnEmbed = await this.computeQueryVectors(
+        denseQueryText,
         userLast,
         config,
         signal,
@@ -697,24 +707,30 @@ export class ConversationGraphMemory {
    * static fallback rather than blocking the turn.
    */
   private async computeQueryVectors(
-    text: string,
+    denseText: string,
+    sparseText: string,
     config: AssistantConfig,
     signal: AbortSignal,
   ): Promise<{ dense?: number[]; sparse?: QdrantSparseVector }> {
-    const trimmed = text.trim();
-    if (trimmed.length === 0) return {};
+    const trimmedDense = denseText.trim();
+    const trimmedSparse = sparseText.trim();
     let dense: number[] | undefined;
-    try {
-      const result = await embedWithRetry(config, [trimmed], { signal });
-      dense = result.vectors[0];
-    } catch (err) {
-      log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
-        "Failed to embed query for PKB hints on v2 path",
-      );
+    if (trimmedDense.length > 0) {
+      try {
+        const result = await embedWithRetry(config, [trimmedDense], { signal });
+        dense = result.vectors[0];
+      } catch (err) {
+        log.warn(
+          { err: err instanceof Error ? err.message : String(err) },
+          "Failed to embed query for PKB hints on v2 path",
+        );
+      }
+    }
+    let sparse: QdrantSparseVector | undefined;
+    if (trimmedSparse.length > 0) {
+      const sparseRaw = generateSparseEmbedding(trimmedSparse);
+      sparse = sparseRaw.indices.length > 0 ? sparseRaw : undefined;
     }
-    const sparseRaw = generateSparseEmbedding(trimmed);
-    const sparse = sparseRaw.indices.length > 0 ? sparseRaw : undefined;
     return { dense, sparse };
   }
 

package/src/memory/graph/tools.ts

@@ -20,7 +20,7 @@ const RECALL_DEPTHS = ["fast", "standard", "deep"] as const;
 export const graphRecallDefinition: ToolDefinition = {
   name: "recall",
   description:
-    'Search local information the moment you feel uncertain. Use recall for memory, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If the user references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
+    'Search local information the moment you feel uncertain. Use recall for memory, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If a turn references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
   input_schema: {
     type: "object",
     properties: {
@@ -72,7 +72,7 @@ const REMEMBER_DESCRIPTION_DEFAULT =
  * something feels worth marking, not because the volume is required.
  */
 const REMEMBER_DESCRIPTION_RELAXED =
-  "Remember anything concrete the user shared: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
+  "Remember anything concrete shared in conversation: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
 
 /**
  * Return the description that should appear in the `remember` tool
@@ -115,7 +115,7 @@ export const graphRememberDefinition: ToolDefinition = {
       finish_turn: {
         type: "boolean",
         description:
-          "When you have nothing else to say and want to hand control back to the user you MUST set this to true. When true, your turn ends after this tool call. It's critical that you do this in order to avoid unnecessary LLM calls.",
+          "When you have nothing else to say and want to yield the turn you MUST set this to true. When true, your turn ends after this tool call. It's critical that you do this in order to avoid unnecessary LLM calls.",
       },
     },
     required: ["content"],

package/src/memory/indexer.ts

@@ -169,32 +169,30 @@ export async function indexMessageNow(
     const batchSize = config.extraction.batchSize ?? 10;
     const idleTimeoutMs = config.extraction.idleTimeoutMs ?? 300_000;
 
+    // Reading config here is best-effort: when it fails we treat v2 as
+    // inactive (failing-open to v1) so a config error never silently
+    // drops the extraction or summarization paths.
+    let triggerConfig: ReturnType<typeof getConfig> | null = null;
+    try {
+      triggerConfig = getConfig();
+    } catch (err) {
+      log.debug(
+        { err, conversationId: input.conversationId },
+        "Skipping feature-gated extraction triggers: failed to load config",
+      );
+    }
+
+    const v2Config =
+      triggerConfig != null && triggerConfig.memory.v2.enabled
+        ? triggerConfig
+        : null;
+
     // Recursion guard: skip graph extraction + auto-analysis enqueues
     // when the source conversation is itself an auto-analysis
     // conversation. The analysis agent writes memory directly via tools,
     // so extracting from its reflective musings would double-count and
     // analyzing its own output would loop indefinitely.
-    // Summaries still run — they feed the graph retrieval pipeline and
-    // are not recursion-prone.
     if (!isAutoAnalysisSource) {
-      // Reading config here is best-effort: when it fails we treat v2 as
-      // inactive (failing-open to v1) so a config error never silently
-      // drops both extraction paths.
-      let triggerConfig: ReturnType<typeof getConfig> | null = null;
-      try {
-        triggerConfig = getConfig();
-      } catch (err) {
-        log.debug(
-          { err, conversationId: input.conversationId },
-          "Skipping feature-gated extraction triggers: failed to load config",
-        );
-      }
-
-      const v2Config =
-        triggerConfig != null && triggerConfig.memory.v2.enabled
-          ? triggerConfig
-          : null;
-
       // ── Graph extraction (v1) ───────────────────────────────────────
       // Suppressed when v2 is active — v2 reads memory from buffer.md
       // and concept pages, so the v1 graph would be stale data nobody
@@ -302,15 +300,22 @@ export async function indexMessageNow(
       }
     }
 
-    // ── Conversation summarization (independent of extraction) ────────
-    // Summaries feed the graph retrieval pipeline via fetchRecentSummaries().
-    // Debounced on the same idle timeout — no threshold trigger needed since
-    // summaries compress the whole conversation, not incremental batches.
-    upsertDebouncedJob(
-      "build_conversation_summary",
-      { conversationId: input.conversationId },
-      Date.now() + idleTimeoutMs,
-    );
+    // ── Conversation summarization (v1) ───────────────────────────────
+    // Summaries feed the v1 graph retrieval pipeline (fetchRecentSummaries,
+    // semantic search). Suppressed when v2 is active — v2 readers (concept
+    // pages, activation pipeline) do not consume `memorySummaries`, so the
+    // summarization LLM call would produce rows nothing reads. Stale rows
+    // from before v2 was enabled are short-circuited at dispatch in
+    // jobs-worker.ts. Debounced on the same idle timeout — no threshold
+    // trigger needed since summaries compress the whole conversation, not
+    // incremental batches.
+    if (v2Config == null) {
+      upsertDebouncedJob(
+        "build_conversation_summary",
+        { conversationId: input.conversationId },
+        Date.now() + idleTimeoutMs,
+      );
+    }
   }
 
   if (skippedShortSegments > 0) {

package/src/memory/jobs/__tests__/embed-concept-page.test.ts

@@ -151,6 +151,8 @@ type MemoryJob = ReturnType<MemoryJobMod["claimMemoryJobs"]>[number];
 const { embedConceptPageJob, enqueueEmbedConceptPageJob } =
   await import("../embed-concept-page.js");
 const { writePage } = await import("../../v2/page-store.js");
+const { _resetQdrantBreaker, isQdrantBreakerOpen, withQdrantBreaker } =
+  await import("../../qdrant-circuit-breaker.js");
 
 // Use a tiny vectorSize so the cache-dim check matches our stub vector.
 const TEST_CONFIG = {
@@ -186,6 +188,7 @@ beforeEach(() => {
   embedWithBackendCalls.length = 0;
   upsertCalls.length = 0;
   deleteCalls.length = 0;
+  _resetQdrantBreaker();
 });
 
 afterEach(() => {
@@ -436,6 +439,76 @@ describe("embedConceptPageJob — defensive", () => {
   });
 });
 
+describe("embedConceptPageJob — Qdrant breaker integration", () => {
+  test("half-open probe success closes the breaker so embed catch-up unthrottles", async () => {
+    // Trip the breaker by recording 5 consecutive Qdrant failures. Without
+    // this fix, `embed_concept_page` bypassed the breaker entirely — winning
+    // the half-open probe slot did not transition state back to closed and
+    // the embed lane stayed throttled at one job per tick indefinitely.
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+    expect(isQdrantBreakerOpen()).toBe(true);
+
+    // Advance time past the 30s cooldown so the next breaker call transitions
+    // open → half-open and allows the probe through.
+    const originalNow = Date.now;
+    Date.now = () => originalNow() + 60_000;
+    try {
+      await writePage(tmpWorkspace, {
+        slug: "probe-success",
+        frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+        body: "Probe body.\n",
+      });
+
+      await embedConceptPageJob(
+        makeJob({ slug: "probe-success" }),
+        TEST_CONFIG,
+      );
+    } finally {
+      Date.now = originalNow;
+    }
+
+    expect(upsertCalls).toHaveLength(1);
+    // Probe succeeded → breaker should now be closed (not open, not
+    // half-open), restoring full embed-lane concurrency.
+    expect(isQdrantBreakerOpen()).toBe(false);
+  });
+
+  test("half-open probe success on the delete path also closes the breaker", async () => {
+    // Same flow as above but exercising the missing-page branch — both v2
+    // Qdrant calls (`upsert` and `delete`) must close the breaker on success.
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+    expect(isQdrantBreakerOpen()).toBe(true);
+
+    const originalNow = Date.now;
+    Date.now = () => originalNow() + 60_000;
+    try {
+      // No `writePage` — the handler takes the delete branch.
+      await embedConceptPageJob(makeJob({ slug: "missing-slug" }), TEST_CONFIG);
+    } finally {
+      Date.now = originalNow;
+    }
+
+    expect(deleteCalls).toEqual(["missing-slug"]);
+    expect(isQdrantBreakerOpen()).toBe(false);
+  });
+});
+
 describe("enqueueEmbedConceptPageJob", () => {
   test("enqueues a pending embed_concept_page job with the slug payload", () => {
     const id = enqueueEmbedConceptPageJob({ slug: "alice-prefers-vs-code" });

package/src/memory/jobs/embed-concept-page.ts

@@ -34,6 +34,7 @@ import {
 import { embeddingInputContentHash } from "../embedding-types.js";
 import { asString, blobToVector, vectorToBlob } from "../job-utils.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import { memoryEmbeddings } from "../schema.js";
 import { readPage } from "../v2/page-store.js";
 import {
@@ -81,7 +82,10 @@ export async function embedConceptPageJob(
   if (!page) {
     // Page was deleted out from under us — clean up the prior embedding so
     // retrieval no longer surfaces a slug whose disk-side prose is gone.
-    await deleteConceptPageEmbedding(slug);
+    // Route through the Qdrant breaker so success on the half-open probe
+    // slot transitions the breaker back to closed and unthrottles embed
+    // catch-up.
+    await withQdrantBreaker(() => deleteConceptPageEmbedding(slug));
     return;
   }
 
@@ -280,16 +284,21 @@ export async function embedConceptPageJob(
     ? await applyCorrectionIfCalibrated(summaryDense, writeProvider, writeModel)
     : undefined;
 
-  await upsertConceptPageEmbedding({
-    slug,
-    dense: correctedDense,
-    sparse,
-    summary:
-      correctedSummaryDense && summarySparse
-        ? { dense: correctedSummaryDense, sparse: summarySparse }
-        : undefined,
-    updatedAt: now,
-  });
+  // Route through the Qdrant breaker so a probe-slot success transitions the
+  // breaker back to closed; without this wrapper the embed lane stays
+  // throttled at one job per tick indefinitely after a half-open success.
+  await withQdrantBreaker(() =>
+    upsertConceptPageEmbedding({
+      slug,
+      dense: correctedDense,
+      sparse,
+      summary:
+        correctedSummaryDense && summarySparse
+          ? { dense: correctedSummaryDense, sparse: summarySparse }
+          : undefined,
+      updatedAt: now,
+    }),
+  );
 }
 
 /** SQLite cache row shape returned by `readEmbeddingCache`. */

package/src/memory/jobs-worker.ts

@@ -95,7 +95,6 @@ const V1_QDRANT_JOB_TYPES = new Set<MemoryJobType>([
   "embed_attachment",
   "embed_graph_node",
   "embed_pkb_file",
-  "graph_trigger_embed",
   "rebuild_index",
   "delete_qdrant_vectors",
 ]);
@@ -525,6 +524,12 @@ async function processJob(
       pruneOldTraceEventsJob(job, config);
       return;
     case "build_conversation_summary":
+      // Stale rows enqueued before v2 was enabled must not consume the
+      // `conversationSummarization` LLM budget — v2 readers do not consume
+      // `memorySummaries`, mirroring the `graph_extract` gate below.
+      if (config.memory.v2.enabled) {
+        return;
+      }
       await buildConversationSummaryJob(job, config);
       return;
     case "backfill":

package/src/memory/llm-request-log-source-clickhouse.ts

@@ -172,14 +172,21 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
   private async selectByMessageIds(ids: string[]): Promise<LogRow[]> {
     if (ids.length === 0) return [];
     const aid = await this.assistantId();
-    // ClickHouse Array(String) URL encoding is fiddly; the message IDs are
-    // server-generated UUIDs (or safe internal strings), so inline the
-    // literal after escaping single quotes. No SQL-injection surface — the
-    // values originate from our own SQLite messages table.
-    const idLiteral =
-      "[" +
-      ids.map((id) => `'${id.replace(/'/g, "''")}'`).join(",") +
-      "]";
+    // Bind each id as its own {id_N:String} placeholder. The IDs ultimately
+    // come from a caller-supplied path parameter — `getAssistantMessageIdsInTurn`
+    // passes the input straight through when the message lookup misses — so
+    // inline literal building (even with quote-doubling) is unsafe: ClickHouse
+    // honors `\'` as an escaped quote inside string literals, letting a
+    // backslash-suffixed id break out of the IN clause and bypass the
+    // `assistant_id` scope filter. Type-bound parameters carry value, not
+    // syntax, regardless of content.
+    const params: Record<string, string> = { assistant_id: aid };
+    const placeholders: string[] = [];
+    for (let i = 0; i < ids.length; i++) {
+      const key = `id_${i}`;
+      params[key] = ids[i]!;
+      placeholders.push(`{${key}:String}`);
+    }
     const sql = `SELECT
         id,
         conversation_id,
@@ -190,11 +197,11 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         toUnixTimestamp64Milli(created_at) AS created_at
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
-        AND message_id IN ${idLiteral}
+        AND message_id IN (${placeholders.join(",")})
       ORDER BY created_at ASC, id ASC
       LIMIT 1 BY id
       FORMAT JSONEachRow`;
-    const rows = await this.exec(sql, { assistant_id: aid });
+    const rows = await this.exec(sql, params);
     return rows.map((r) => this.toLogRow(r));
   }
 

package/src/memory/llm-request-log-source.ts

@@ -12,16 +12,13 @@
  *   only sees rows the mirror cron has flushed). See
  *   `llm-request-log-source-clickhouse.ts`.
  *
- * The active source is cached at module level and invalidated on config
- * change (see `daemon/config-watcher.ts`) so a config edit takes effect
- * without restarting the daemon.
+ * Implementations are cheap to instantiate, so there's no module-level
+ * cache — each call resolves config fresh and constructs a new instance.
+ * Config edits take effect on the next request without an invalidation hook.
  */
 import { getConfig } from "../config/loader.js";
-import { getLogger } from "../util/logger.js";
 import type { LogRow } from "./llm-request-log-store.js";
 
-const log = getLogger("llm-request-log-source");
-
 export interface LlmRequestLogSource {
   /** Fetch a single log row by its primary key. Returns null if not found. */
   getRequestLogById(logId: string): Promise<LogRow | null>;
@@ -36,62 +33,32 @@ export interface LlmRequestLogSource {
   getRequestLogsByMessageId(messageId: string): Promise<LogRow[]>;
 }
 
-let cached: LlmRequestLogSource | null = null;
-let cachedKind: "local" | "clickhouse" | null = null;
-
 /**
- * Return the currently configured LLM request log source.
+ * Return the configured LLM request log source.
  *
- * The result is cached for the lifetime of the process. Callers should
- * never hang on to the instance across config reloads — always re-resolve
- * through this function. The factory is async because BOTH implementations
- * are loaded via dynamic `import()` on first use. This is deliberate: it
- * keeps the static module graph for `llm-request-log-source.ts` (and for
- * everything that transitively imports it, including `config-watcher`)
- * free of `llm-request-log-store → conversation-crud → indexer → embedding-backend`,
+ * The factory is async because both implementations are loaded via
+ * dynamic `import()` on first use. This is deliberate: it keeps the
+ * static module graph for `llm-request-log-source.ts` (and for
+ * everything that transitively imports it) free of
+ * `llm-request-log-store → conversation-crud → indexer → embedding-backend`,
  * which would otherwise force test files that stub `embedding-backend.js`
- * to also stub every export `indexer.ts` reaches for. Callers MUST `await`
- * the source methods because the active source may swap to one with real
- * I/O at any time.
+ * to also stub every export `indexer.ts` reaches for.
+ *
+ * Callers must `await` both the factory and the source methods.
  */
 export async function getLlmRequestLogSource(): Promise<LlmRequestLogSource> {
-  if (cached) return cached;
-
   const config = getConfig();
-  const kind = config.llmRequestLogs?.readSource ?? "local";
+  const cfg = config.llmRequestLogs ?? { readSource: "local" as const };
 
-  if (kind === "clickhouse") {
+  if (cfg.readSource === "clickhouse") {
     const { ClickHouseLlmRequestLogSource } = await import(
       "./llm-request-log-source-clickhouse.js"
     );
-    cached = new ClickHouseLlmRequestLogSource(config.llmRequestLogs.clickhouse);
-    cachedKind = "clickhouse";
-    log.info(
-      { table: config.llmRequestLogs.clickhouse.table },
-      "Using ClickHouse for LLM request log reads",
-    );
-  } else {
-    const { LocalLlmRequestLogSource } = await import(
-      "./llm-request-log-source-local.js"
-    );
-    cached = new LocalLlmRequestLogSource();
-    cachedKind = "local";
+    return new ClickHouseLlmRequestLogSource(cfg.clickhouse);
   }
 
-  return cached;
-}
-
-/**
- * Drop the cached source so the next `getLlmRequestLogSource()` call
- * resolves fresh from config. Called on workspace config reload.
- */
-export function invalidateLlmRequestLogSourceCache(): void {
-  if (cached !== null) {
-    log.debug(
-      { previousKind: cachedKind },
-      "Invalidating LLM request log source cache",
-    );
-  }
-  cached = null;
-  cachedKind = null;
+  const { LocalLlmRequestLogSource } = await import(
+    "./llm-request-log-source-local.js"
+  );
+  return new LocalLlmRequestLogSource();
 }