@vellumai/assistant 0.8.5 → 0.8.7

package/src/memory/graph/pattern-scan.ts

@@ -161,9 +161,9 @@ export async function runPatternScan(
         "Analyze this memory sample for recurring patterns. Only report patterns you're confident about.",
       ),
     ],
-    [PATTERN_TOOL_SCHEMA],
-    systemPrompt,
     {
+      tools: [PATTERN_TOOL_SCHEMA],
+      systemPrompt,
       config: {
         callSite: "patternScan" as const,
         tool_choice: { type: "tool" as const, name: "detect_patterns" },

package/src/memory/graph/retriever.test.ts

@@ -71,9 +71,9 @@ mock.module("../../providers/provider-send-message.js", () => ({
   extractToolUse: () => null,
 }));
 
+import { resetDbForTesting } from "../../__tests__/db-test-helpers.js";
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
-import { resetDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
 import { resetTestTables } from "../raw-query.js";
 import { InContextTracker } from "./injection.js";
@@ -134,7 +134,7 @@ describe("loadContextMemory — query/sparse vector surfacing", () => {
     embedCallCount = 0;
     embedRouter = null;
     searchRouter = null;
-    resetDb();
+    resetDbForTesting();
     initializeDb();
   });
 
@@ -190,7 +190,7 @@ describe("retrieveForTurn — query/sparse vector surfacing", () => {
     embedCallCount = 0;
     embedRouter = null;
     searchRouter = null;
-    resetDb();
+    resetDbForTesting();
     initializeDb();
   });
 

package/src/memory/graph/retriever.ts

@@ -113,10 +113,9 @@ async function rerankAndDedup(
       })
       .join("\n");
 
-    const response = await provider.sendMessage(
-      [userMessage(listing)],
-      [RERANK_TOOL],
-      `You are selecting memories for an AI assistant's context at conversation start. You see ${candidates.length} candidate memories ranked by algorithmic score.
+    const response = await provider.sendMessage([userMessage(listing)], {
+      tools: [RERANK_TOOL],
+      systemPrompt: `You are selecting memories for an AI assistant's context at conversation start. You see ${candidates.length} candidate memories ranked by algorithmic score.
 
 Your job:
 1. REMOVE DUPLICATES: If multiple entries describe the same event/fact/topic, keep ONLY the most complete version. Be aggressive — even partial overlaps should be deduplicated.
@@ -125,15 +124,13 @@ Your job:
    - Diversity (don't load 5 memories about the same topic)
    - Importance (key relationship moments, active commitments, identity-defining events)
 3. Return the IDs in order of importance (most important first).`,
-      {
-        config: {
-          callSite: "memoryRetrieval" as const,
-          tool_choice: { type: "tool" as const, name: "select_memories" },
-          thinking: { type: "disabled" },
-          temperature: 0,
-        },
+      config: {
+        callSite: "memoryRetrieval" as const,
+        tool_choice: { type: "tool" as const, name: "select_memories" },
+        thinking: { type: "disabled" },
+        temperature: 0,
       },
-    );
+    });
 
     const toolBlock = extractToolUse(response);
     if (!toolBlock) return candidates.slice(0, maxNodes);
@@ -214,9 +211,9 @@ async function dedupForTurn(
 
     const response = await provider.sendMessage(
       [userMessage(`query:\n${query}\n\nitems:\n\n${listing}`)],
-      [SELECT_ITEMS_TOOL],
-      `Dedupe + rerank the following numbered items. Pick the most relevant items to the query. Call the select_items tool.\n\nBe aggressive on dedup — when multiple items describe the same event, fact, or status, keep ONLY the richest version. But be generous on relevance — only cut items that are completely irrelevant to the query. If it's even tangentially related, keep it.`,
       {
+        tools: [SELECT_ITEMS_TOOL],
+        systemPrompt: `Dedupe + rerank the following numbered items. Pick the most relevant items to the query. Call the select_items tool.\n\nBe aggressive on dedup — when multiple items describe the same event, fact, or status, keep ONLY the richest version. But be generous on relevance — only cut items that are completely irrelevant to the query. If it's even tangentially related, keep it.`,
         config: {
           callSite: "memoryRetrieval" as const,
           tool_choice: { type: "tool" as const, name: "select_items" },
@@ -304,19 +301,16 @@ async function dedupCrossCategory(
       })
       .join("\n");
 
-    const response = await provider.sendMessage(
-      [userMessage(listing)],
-      [DEDUP_ITEMS_TOOL],
-      `Deduplicate the following numbered items. When multiple items describe the same event, fact, or status, keep ONLY the richest version. Keep ALL items that are not duplicates — do not filter by relevance or topic. Call the select_items tool with every item that survives dedup.`,
-      {
-        config: {
-          callSite: "memoryRetrieval" as const,
-          tool_choice: { type: "tool" as const, name: "select_items" },
-          thinking: { type: "disabled" },
-          temperature: 0,
-        },
+    const response = await provider.sendMessage([userMessage(listing)], {
+      tools: [DEDUP_ITEMS_TOOL],
+      systemPrompt: `Deduplicate the following numbered items. When multiple items describe the same event, fact, or status, keep ONLY the richest version. Keep ALL items that are not duplicates — do not filter by relevance or topic. Call the select_items tool with every item that survives dedup.`,
+      config: {
+        callSite: "memoryRetrieval" as const,
+        tool_choice: { type: "tool" as const, name: "select_items" },
+        thinking: { type: "disabled" },
+        temperature: 0,
       },
-    );
+    });
 
     const toolBlock = extractToolUse(response);
     if (!toolBlock) return candidates.slice(0, maxNodes);

package/src/memory/graph/tools.ts

@@ -15,7 +15,7 @@ const RECALL_DEPTHS = ["fast", "standard", "deep"] as const;
  * Explicit local information search across memory, conversations, and
  * workspace files.
  */
-export const graphRecallDefinition: ToolDefinition = {
+export const graphRecallDefinition = {
   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 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.',
@@ -51,7 +51,7 @@ export const graphRecallDefinition: ToolDefinition = {
     },
     required: ["query"],
   },
-};
+} satisfies ToolDefinition;
 
 /**
  * `remember` tool description. The retrospective pass catches what isn't
@@ -70,7 +70,7 @@ const REMEMBER_DESCRIPTION =
  * of the buffer into longer-form storage runs as a separate periodic job in
  * both modes.
  */
-export const graphRememberDefinition: ToolDefinition = {
+export const graphRememberDefinition = {
   name: "remember",
   description: REMEMBER_DESCRIPTION,
   input_schema: {
@@ -89,4 +89,4 @@ export const graphRememberDefinition: ToolDefinition = {
     },
     required: ["content"],
   },
-};
+} satisfies ToolDefinition;

package/src/memory/job-handlers/conversation-starters.ts

@@ -295,44 +295,44 @@ Bad → Good (incomplete phrase → complete):
           "Generate personalized conversation starters based on my context.",
         ),
       ],
-      [
-        {
-          name: "store_conversation_starters",
-          description: "Store generated conversation starter suggestions",
-          input_schema: {
-            type: "object" as const,
-            properties: {
-              starters: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    label: {
-                      type: "string",
-                      description:
-                        "User-voice chip label (2-7 words, max 40 chars, verb-first)",
-                    },
-                    prompt: {
-                      type: "string",
-                      description:
-                        "Full message sent on click (1-2 natural sentences, as the user would say it)",
-                    },
-                    category: {
-                      type: "string",
-                      enum: [...CONVERSATION_STARTER_CATEGORIES],
-                      description: "Capability category for grouping",
+      {
+        tools: [
+          {
+            name: "store_conversation_starters",
+            description: "Store generated conversation starter suggestions",
+            input_schema: {
+              type: "object" as const,
+              properties: {
+                starters: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      label: {
+                        type: "string",
+                        description:
+                          "User-voice chip label (2-7 words, max 40 chars, verb-first)",
+                      },
+                      prompt: {
+                        type: "string",
+                        description:
+                          "Full message sent on click (1-2 natural sentences, as the user would say it)",
+                      },
+                      category: {
+                        type: "string",
+                        enum: [...CONVERSATION_STARTER_CATEGORIES],
+                        description: "Capability category for grouping",
+                      },
                     },
+                    required: ["label", "prompt", "category"],
                   },
-                  required: ["label", "prompt", "category"],
                 },
               },
+              required: ["starters"],
             },
-            required: ["starters"],
           },
-        },
-      ],
-      systemPrompt,
-      {
+        ],
+        systemPrompt,
         config: {
           callSite: "conversationStarters" as const,
           max_tokens: 2048,

package/src/memory/job-handlers/embedding.test.ts

@@ -40,9 +40,10 @@ mock.module("../job-utils.js", () => ({
   },
 }));
 
+import { resetDbForTesting } from "../../__tests__/db-test-helpers.js";
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
-import { getDb, resetDb } from "../db-connection.js";
+import { getDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
 import type { MemoryJob } from "../jobs-store.js";
 import { mediaAssets } from "../schema.js";
@@ -66,7 +67,7 @@ describe("embedMediaJob", () => {
 
   beforeEach(() => {
     embedAndUpsertCalls.length = 0;
-    resetDb();
+    resetDbForTesting();
     initializeDb();
   });
 

package/src/memory/job-handlers/summarization.ts

@@ -180,9 +180,8 @@ async function summarizeWithLLM(
     try {
       const response = await provider.sendMessage(
         [userMessage(userParts.join("\n"))],
-        undefined,
-        systemPrompt,
         {
+          systemPrompt,
           config: {
             callSite: "conversationSummarization" as const,
             max_tokens: SUMMARY_MAX_TOKENS,

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

@@ -142,7 +142,10 @@ afterAll(() => {
 // Imports are deferred to after the env var is set so any internal use of
 // `getWorkspaceDir()` resolves to the tmpdir.
 const { DEFAULT_CONFIG } = await import("../../../config/defaults.js");
-const { getDb, resetDb } = await import("../../db-connection.js");
+const { getDb } = await import("../../db-connection.js");
+const { resetDbForTesting } = await import(
+  "../../../__tests__/db-test-helpers.js"
+);
 const { initializeDb } = await import("../../db-init.js");
 const { memoryEmbeddings, memoryJobs } = await import("../../schema.js");
 const { claimMemoryJobs } = await import("../../jobs-store.js");
@@ -183,7 +186,7 @@ function makeJob(payload: Record<string, unknown>): MemoryJob {
 }
 
 beforeEach(() => {
-  resetDb();
+  resetDbForTesting();
   initializeDb();
   embedWithBackendCalls.length = 0;
   upsertCalls.length = 0;

package/src/memory/jobs-store.ts

@@ -44,6 +44,8 @@ export type MemoryJobType =
   | "memory_v2_migrate"
   | "memory_v2_reembed"
   | "memory_v2_activation_recompute"
+  | "memory_v3_maintain"
+  // Retired/legacy — no live handler; persisted rows drop via LEGACY_JOB_TYPES.
   | "memory_v3_consolidate"
   | "memory_v3_index_maintenance"
   | "memory_v3_edge_learning"
@@ -70,7 +72,7 @@ export const SLOW_LLM_JOB_TYPES: MemoryJobType[] = [
   "generate_conversation_starters",
   "memory_v2_sweep",
   "memory_v2_consolidate",
-  "memory_v3_consolidate",
+  "memory_v3_maintain",
   "memory_v2_migrate",
   "memory_retrospective",
   "backfill",

package/src/memory/jobs-worker.ts

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
 import {
@@ -65,6 +66,7 @@ import {
   enqueuePruneOldTraceEventsJob,
   failMemoryJob,
   failStalledJobs,
+  hasActiveJobOfType,
   type MemoryJob,
   type MemoryJobType,
   resetRunningJobsToPending,
@@ -83,9 +85,7 @@ import {
   memoryV2ConsolidateJob,
 } from "./v2/consolidation-job.js";
 import { memoryV2SweepJob } from "./v2/sweep-job.js";
-import { memoryV3ConsolidateJob } from "./v3/consolidation-job.js";
-import { memoryV3EdgeLearningJob } from "./v3/edge-learning-job.js";
-import { memoryV3IndexMaintenanceJob } from "./v3/maintenance.js";
+import { maintainJob as memoryV3MaintainJob } from "./v3/maintain-job.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -125,6 +125,11 @@ const LEGACY_JOB_TYPES = new Set([
   "generate_capability_cards",
   "generate_thread_starters",
   "memory_v2_rebuild_edges",
+  // Retired memory-v3 job types — handlers were removed in the v3 rip. Kept
+  // here so pre-upgrade rows enqueued by the old write path drop gracefully.
+  "memory_v3_consolidate",
+  "memory_v3_index_maintenance",
+  "memory_v3_edge_learning",
 ]);
 
 export const POLL_INTERVAL_MIN_MS = 1_500;
@@ -606,16 +611,6 @@ async function processJob(
     case "memory_v2_consolidate":
       await memoryV2ConsolidateJob(job, config);
       return;
-    case "memory_v3_consolidate":
-      await memoryV3ConsolidateJob(job, config);
-      return;
-    case "memory_v3_index_maintenance":
-      await memoryV3IndexMaintenanceJob(job);
-      return;
-    case "memory_v3_edge_learning":
-      // Fast lane: bounded DB work (decay + reinforce + read), no LLM.
-      memoryV3EdgeLearningJob(job);
-      return;
     case "memory_v2_migrate":
       await memoryV2MigrateJob(job, config);
       return;
@@ -625,6 +620,9 @@ async function processJob(
     case "memory_v2_activation_recompute":
       await memoryV2ActivationRecomputeJob(job, config);
       return;
+    case "memory_v3_maintain":
+      await memoryV3MaintainJob(job, config);
+      return;
     case "memory_retrospective":
       await memoryRetrospectiveJob(job, config);
       return;
@@ -687,6 +685,12 @@ const GRAPH_DECAY_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
 const GRAPH_CONSOLIDATE_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
 const GRAPH_PATTERN_SCAN_INTERVAL_MS = 24 * 60 * 60 * 1000; // 1 day
 const GRAPH_NARRATIVE_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000; // 1 week
+// Backstop cadence for v3 self-maintenance. The primary trigger is the
+// post-consolidation follow-up (see `consolidation-job.ts`); this interval only
+// covers the case where that follow-up is missed (enqueue failure, or a v3-on
+// install with v2 consolidation disabled). A conservative cadence is fine since
+// the maintenance pass is idempotent and cheap when there's nothing to do.
+const GRAPH_V3_MAINTAIN_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
 
 export const GRAPH_MAINTENANCE_CHECKPOINTS = {
   decay: "graph_maintenance:decay:last_run",
@@ -694,7 +698,7 @@ export const GRAPH_MAINTENANCE_CHECKPOINTS = {
   patternScan: "graph_maintenance:pattern_scan:last_run",
   narrative: "graph_maintenance:narrative:last_run",
   memoryV2Consolidate: "memory_v2_consolidate_last_run",
-  memoryV3Consolidate: "memory_v3_consolidate_last_run",
+  memoryV3Maintain: "memory_v3_maintain_last_run",
 } as const;
 
 /**
@@ -706,15 +710,9 @@ export const GRAPH_MAINTENANCE_CHECKPOINTS = {
  *   - v2 inactive → the four v1 entries (decay, consolidate, pattern_scan,
  *     narrative) are scheduled instead.
  *
- * **Buffer-drainer retarget (v2 vs v3).** The `memory/buffer.md` is shared, so
- * exactly one consolidator may own the drain at a time. When
- * `memory.v3.write.enabled` is on, the v3 consolidator (`memory_v3_consolidate`)
- * is scheduled INSTEAD of `memory_v2_consolidate` — same shared buffer +
- * standing-context files, additionally authored into the v3 tree. When the v3
- * write flag is off (default) the v2 consolidator stays the sole drainer,
- * unchanged. The retarget is a clean conditional, fully reversible via the flag.
- * Concept pages stay the shared canonical store, so the v2 router keeps working
- * off pages v3 writes regardless of which consolidator ran.
+ * The `memory/buffer.md` is shared, so exactly one consolidator owns the drain
+ * at a time. When v2 is active, the v2 consolidator (`memory_v2_consolidate`)
+ * is the sole buffer-drainer.
  *
  * Read/write paths route to v2 when the flag is on, so v1 graph data goes
  * unread; running v1 maintenance alongside v2 is wasted compute and LLM
@@ -726,28 +724,24 @@ export const GRAPH_MAINTENANCE_CHECKPOINTS = {
  * Sweep is intentionally not on this schedule: it is debounced from the
  * live `graph_extract` trigger path (see `indexMessageNow` in `indexer.ts`)
  * so it runs on the same idle/message-count cadence.
+ *
+ * Independently of the v1/v2 split, a flag-gated `memory_v3_maintain` backstop
+ * is appended when a v3 path is active so the topic tree self-heals even if the
+ * primary post-consolidation follow-up enqueue is missed.
  */
 export function maybeEnqueueGraphMaintenanceJobs(
   config: AssistantConfig,
   nowMs = Date.now(),
 ): void {
   const v2Active = config.memory.v2.enabled;
-  const v3WriteActive = config.memory.v3.write.enabled;
-
-  // The single buffer-drainer entry for the v2-active branch: v3 when the v3
-  // write flag owns the drain, v2 otherwise. Same shared buffer either way.
-  const consolidateEntry = v3WriteActive
-    ? {
-        key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV3Consolidate,
-        intervalMs: config.memory.v3.write.consolidateIntervalMs,
-        jobType: "memory_v3_consolidate" as MemoryJobType,
-      }
-    : {
-        key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
-        intervalMs:
-          config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000,
-        jobType: "memory_v2_consolidate" as MemoryJobType,
-      };
+
+  // The single buffer-drainer entry for the v2-active branch. Referenced again
+  // below by the size-based trigger.
+  const consolidateEntry = {
+    key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
+    intervalMs: config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000,
+    jobType: "memory_v2_consolidate" as MemoryJobType,
+  };
 
   const schedule: Array<{
     key: string;
@@ -778,6 +772,25 @@ export function maybeEnqueueGraphMaintenanceJobs(
         },
       ];
 
+  // v3 self-maintenance backstop. Orthogonal to the v1/v2 mutual exclusion
+  // above: it owns its own checkpoint and operates on the v3 topic tree, so it
+  // runs under either branch. Gated on the same flags that gate the v3 plugin
+  // so it stays inert when v3 is off. The post-consolidation follow-up in
+  // `consolidation-job.ts` remains the primary trigger; this interval only
+  // self-heals when that follow-up is missed (failed enqueue, or v3-on with v2
+  // consolidation disabled). The job handler itself no-ops when v3 is off, so
+  // this guard is belt-and-suspenders that also avoids a wasted enqueue.
+  if (
+    isAssistantFeatureFlagEnabled("memory-v3-shadow", config) ||
+    isAssistantFeatureFlagEnabled("memory-v3-live", config)
+  ) {
+    schedule.push({
+      key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV3Maintain,
+      intervalMs: GRAPH_V3_MAINTAIN_INTERVAL_MS,
+      jobType: "memory_v3_maintain",
+    });
+  }
+
   let enqueuedConsolidate = false;
   for (const { key, intervalMs, jobType } of schedule) {
     const lastRun = parseInt(getMemoryCheckpoint(key) ?? "0", 10);
@@ -791,8 +804,18 @@ export function maybeEnqueueGraphMaintenanceJobs(
   // Size-based trigger: when the shared buffer crosses the configured line
   // count, drain it now rather than waiting out the interval. Retargets to the
   // same consolidator the interval branch above selected.
+  //
+  // The size branch is checkpoint-blind by design (it must fire before the
+  // interval elapses), so it dedupes against an already-active consolidate job
+  // instead — otherwise it would re-enqueue on every worker tick while the
+  // buffer stays over threshold, flooding the queue with redundant LLM work.
   const maxLines = config.memory.v2.consolidation_max_buffer_lines;
-  if (v2Active && !enqueuedConsolidate && maxLines !== null) {
+  if (
+    v2Active &&
+    !enqueuedConsolidate &&
+    maxLines !== null &&
+    !hasActiveJobOfType(consolidateEntry.jobType)
+  ) {
     const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
     if (countBufferLines(bufferPath) >= maxLines) {
       enqueueMemoryJob(consolidateEntry.jobType, {});

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

@@ -209,6 +209,56 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     return rows.map((r) => this.toLogRow(r));
   }
 
+  async getCompactionLogsBetween(
+    conversationId: string,
+    afterCreatedAt: number | null,
+    beforeCreatedAt: number,
+  ): Promise<LogRow[]> {
+    const aid = await this.assistantId();
+    // `call_site` is bound as a literal via type-bound parameter (not
+    // string interpolation) for parity with the rest of this class —
+    // even though "compactionAgent" is a hard-coded identifier today,
+    // future call sites should plug into the same parameter slot
+    // without re-templating the query string.
+    //
+    // The `afterCreatedAt` lower bound is appended dynamically because
+    // type-bound parameter slots that are referenced in the SQL but
+    // unbound at exec time return a server error — so we only template
+    // the predicate in when the caller actually has a floor to enforce.
+    const params: Record<string, string> = {
+      assistant_id: aid,
+      conversation_id: conversationId,
+      call_site: "compactionAgent",
+      before_created_at: String(beforeCreatedAt),
+    };
+    let afterPredicate = "";
+    if (afterCreatedAt !== null) {
+      params.after_created_at = String(afterCreatedAt);
+      afterPredicate =
+        " AND created_at > fromUnixTimestamp64Milli({after_created_at:Int64})";
+    }
+    const sql = `SELECT
+        id,
+        conversation_id,
+        message_id,
+        provider,
+        request_payload,
+        response_payload,
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason,
+        call_site
+      FROM ${this.tableRef()}
+      WHERE assistant_id = {assistant_id:String}
+        AND conversation_id = {conversation_id:String}
+        AND call_site = {call_site:String}
+        AND created_at < fromUnixTimestamp64Milli({before_created_at:Int64})${afterPredicate}
+      ORDER BY created_at ASC, id ASC
+      LIMIT 1 BY id
+      FORMAT JSONEachRow`;
+    const rows = await this.exec(sql, params);
+    return rows.map((r) => this.toLogRow(r));
+  }
+
   private async selectByMessageIds(ids: string[]): Promise<LogRow[]> {
     if (ids.length === 0) return [];
     const aid = await this.assistantId();
@@ -287,7 +337,11 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     if (!res.ok) {
       const body = await res.text().catch(() => "");
       log.error(
-        { status: res.status, table: this.config.table, bodySnippet: body.slice(0, 200) },
+        {
+          status: res.status,
+          table: this.config.table,
+          bodySnippet: body.slice(0, 200),
+        },
         "ClickHouse query failed",
       );
       throw new Error(

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

@@ -10,6 +10,7 @@
  */
 import type { LlmRequestLogSource } from "./llm-request-log-source.js";
 import {
+  getCompactionLogsBetween,
   getRequestLogById,
   getRequestLogsByConversationId,
   getRequestLogsByMessageId,
@@ -30,4 +31,16 @@ export class LocalLlmRequestLogSource implements LlmRequestLogSource {
   ): Promise<LogRow[]> {
     return getRequestLogsByConversationId(conversationId);
   }
+
+  async getCompactionLogsBetween(
+    conversationId: string,
+    afterCreatedAt: number | null,
+    beforeCreatedAt: number,
+  ): Promise<LogRow[]> {
+    return getCompactionLogsBetween(
+      conversationId,
+      afterCreatedAt,
+      beforeCreatedAt,
+    );
+  }
 }

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

@@ -38,6 +38,23 @@ export interface LlmRequestLogSource {
    * and orphaned logs are all included because they share conversation_id.
    */
   getRequestLogsByConversationId(conversationId: string): Promise<LogRow[]>;
+
+  /**
+   * Fetch every `callSite = "compactionAgent"` log row in the conversation
+   * whose `createdAt` falls in the **open window**
+   * `(afterCreatedAt, beforeCreatedAt)`, ordered chronologically.
+   *
+   * Drives the Inspector's Compaction tab. The route handler computes
+   * the window from the turn the selected call belongs to via
+   * `getTurnTimeBounds` in `memory/conversation-crud.ts`; this source
+   * method is bound-agnostic. See `getCompactionLogsBetween` in
+   * `llm-request-log-store.ts` for the SQL.
+   */
+  getCompactionLogsBetween(
+    conversationId: string,
+    afterCreatedAt: number | null,
+    beforeCreatedAt: number,
+  ): Promise<LogRow[]>;
 }
 
 /**
@@ -58,14 +75,12 @@ export async function getLlmRequestLogSource(): Promise<LlmRequestLogSource> {
   const cfg = config.llmRequestLogs ?? { readSource: "local" as const };
 
   if (cfg.readSource === "clickhouse") {
-    const { ClickHouseLlmRequestLogSource } = await import(
-      "./llm-request-log-source-clickhouse.js"
-    );
+    const { ClickHouseLlmRequestLogSource } =
+      await import("./llm-request-log-source-clickhouse.js");
     return new ClickHouseLlmRequestLogSource(cfg.clickhouse);
   }
 
-  const { LocalLlmRequestLogSource } = await import(
-    "./llm-request-log-source-local.js"
-  );
+  const { LocalLlmRequestLogSource } =
+    await import("./llm-request-log-source-local.js");
   return new LocalLlmRequestLogSource();
 }