@vellumai/assistant 0.8.6 → 0.8.7

package/src/memory/graph/consolidation.ts

@@ -279,17 +279,14 @@ async function identifyDuplicateGroups(
 
   const systemPrompt = `You are scanning a list of memory nodes for DUPLICATES — nodes that describe the exact same specific event or fact. Group duplicates together. Two nodes are duplicates ONLY if they describe the same underlying thing with substantially the same details. Be conservative — nodes about the same person or topic but with different details, timestamps, or context are NOT duplicates. Only include nodes that have at least one true duplicate.`;
 
-  const response = await provider.sendMessage(
-    [userMessage(listing)],
-    [DUPE_DETECT_TOOL],
+  const response = await provider.sendMessage([userMessage(listing)], {
+    tools: [DUPE_DETECT_TOOL],
     systemPrompt,
-    {
-      config: {
-        callSite: "memoryConsolidation" as const,
-        tool_choice: { type: "tool" as const, name: "report_duplicate_groups" },
-      },
+    config: {
+      callSite: "memoryConsolidation" as const,
+      tool_choice: { type: "tool" as const, name: "report_duplicate_groups" },
     },
-  );
+  });
 
   const toolBlock = extractToolUse(response);
   if (!toolBlock) return [];
@@ -458,9 +455,9 @@ async function consolidateChunk(
         "Consolidate this partition. Focus on merging duplicates and fading old memories.",
       ),
     ],
-    [CONSOLIDATE_TOOL_SCHEMA],
-    systemPrompt,
     {
+      tools: [CONSOLIDATE_TOOL_SCHEMA],
+      systemPrompt,
       config: {
         callSite: "memoryConsolidation" as const,
         tool_choice: { type: "tool" as const, name: "consolidate_diff" },

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

@@ -22,6 +22,7 @@ import { getWorkspaceDir } from "../../util/platform.js";
 import { getDb } from "../db-connection.js";
 import { embedWithRetry } from "../embed.js";
 import { generateSparseEmbedding } from "../embedding-backend.js";
+import { wrapMemoryBlock } from "../memory-marker.js";
 import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
@@ -895,13 +896,45 @@ export function stripExistingMemoryInjections(messages: Message[]): Message[] {
   const last = messages[messages.length - 1];
   if (!last || last.role !== "user") return messages;
 
-  const firstNonMemory = countMemoryPrefixBlocks(last.content);
-  if (firstNonMemory === 0) return messages;
+  const stripped = stripMemoryPrefixFromUserMessage(last);
+  if (stripped === last) return messages;
 
-  return [
-    ...messages.slice(0, -1),
-    { ...last, content: last.content.slice(firstNonMemory) },
-  ];
+  return [...messages.slice(0, -1), stripped];
+}
+
+/**
+ * Strip the memory-injected prefix from a single user message. Returns the
+ * same message reference unchanged when it is not a user message or carries no
+ * injected prefix, so callers can cheaply detect no-ops. Shared by
+ * `stripExistingMemoryInjections` (last message only) and
+ * `stripAllMemoryInjections` (every user message).
+ */
+function stripMemoryPrefixFromUserMessage(message: Message): Message {
+  if (message.role !== "user") return message;
+  const firstNonMemory = countMemoryPrefixBlocks(message.content);
+  if (firstNonMemory === 0) return message;
+  return { ...message, content: message.content.slice(firstNonMemory) };
+}
+
+/**
+ * Remove memory-injected blocks from EVERY user message, not just the last.
+ *
+ * memory-v3 live mode strips the injected `<memory>` block from all historical
+ * user messages each turn: it keeps the prompt lean and makes history
+ * byte-stable for prompt caching (v2 strips only the last user message — see
+ * `stripExistingMemoryInjections`). Reuses the same per-message block
+ * recognition as the last-message strip. Wired into the runtime-assembly
+ * suppression step (`conversation-runtime-assembly.ts`), which calls it when
+ * `memory-v3-live` is on and the v3 injector produced a block this turn.
+ */
+export function stripAllMemoryInjections(messages: Message[]): Message[] {
+  let changed = false;
+  const result = messages.map((message) => {
+    const stripped = stripMemoryPrefixFromUserMessage(message);
+    if (stripped !== message) changed = true;
+    return stripped;
+  });
+  return changed ? result : messages;
 }
 
 /**
@@ -933,7 +966,7 @@ function injectTextBlock(messages: Message[], text: string): Message[] {
       content: [
         {
           type: "text" as const,
-          text: `<memory>\n${text}\n</memory>`,
+          text: wrapMemoryBlock(text),
         },
         ...userTail.content,
       ],
@@ -977,7 +1010,7 @@ function injectMemoryBlock(
 
   blocks.push({
     type: "text" as const,
-    text: `<memory>\n${text}\n</memory>`,
+    text: wrapMemoryBlock(text),
   });
 
   return [

package/src/memory/graph/extraction.ts

@@ -1071,17 +1071,14 @@ export async function runGraphExtraction(
         ),
       ];
 
-  const response = await provider.sendMessage(
-    extractionMessages,
-    [EXTRACT_TOOL_SCHEMA],
+  const response = await provider.sendMessage(extractionMessages, {
+    tools: [EXTRACT_TOOL_SCHEMA],
     systemPrompt,
-    {
-      config: {
-        callSite: "memoryExtraction" as const,
-        tool_choice: { type: "tool" as const, name: "extract_graph_diff" },
-      },
+    config: {
+      callSite: "memoryExtraction" as const,
+      tool_choice: { type: "tool" as const, name: "extract_graph_diff" },
     },
-  );
+  });
 
   const toolBlock = extractToolUse(response);
   if (!toolBlock) {

package/src/memory/graph/narrative.ts

@@ -192,9 +192,9 @@ export async function runNarrativeRefinement(
         "Review and refine the narrative structure of these memories. Identify story arcs and assign roles with the benefit of hindsight.",
       ),
     ],
-    [NARRATIVE_TOOL_SCHEMA],
-    systemPrompt,
     {
+      tools: [NARRATIVE_TOOL_SCHEMA],
+      systemPrompt,
       config: {
         callSite: "narrativeRefinement" as const,
         tool_choice: { type: "tool" as const, name: "refine_narratives" },

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.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/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-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 {
@@ -84,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");
 
@@ -126,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;
@@ -607,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;
@@ -626,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;
@@ -688,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",
@@ -695,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;
 
 /**
@@ -707,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
@@ -727,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;
@@ -779,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);

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

@@ -259,36 +259,6 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     return rows.map((r) => this.toLogRow(r));
   }
 
-  async getPreviousNonCompactionCallCreatedAt(
-    conversationId: string,
-    beforeCreatedAt: number,
-  ): Promise<number | null> {
-    const aid = await this.assistantId();
-    // "Non-compactionAgent" includes empty-string `call_site`, which is
-    // what the CH mirror writes for pre-migration-264 rows whose SQLite
-    // value was NULL (CH columns are `DEFAULT ''`, not Nullable — see
-    // `toLogRow`). The local store treats NULL `callSite` the same way,
-    // so the predicate stays in sync.
-    const sql = `SELECT
-        toUnixTimestamp64Milli(created_at) AS created_at
-      FROM ${this.tableRef()}
-      WHERE assistant_id = {assistant_id:String}
-        AND conversation_id = {conversation_id:String}
-        AND created_at < fromUnixTimestamp64Milli({before_created_at:Int64})
-        AND call_site != {call_site:String}
-      ORDER BY created_at DESC, id DESC
-      LIMIT 1
-      FORMAT JSONEachRow`;
-    const rows = await this.exec(sql, {
-      assistant_id: aid,
-      conversation_id: conversationId,
-      call_site: "compactionAgent",
-      before_created_at: String(beforeCreatedAt),
-    });
-    const value = rows[0]?.created_at;
-    return value === undefined ? null : Number(value);
-  }
-
   private async selectByMessageIds(ids: string[]): Promise<LogRow[]> {
     if (ids.length === 0) return [];
     const aid = await this.assistantId();
@@ -367,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

@@ -11,7 +11,6 @@
 import type { LlmRequestLogSource } from "./llm-request-log-source.js";
 import {
   getCompactionLogsBetween,
-  getPreviousNonCompactionCallCreatedAt,
   getRequestLogById,
   getRequestLogsByConversationId,
   getRequestLogsByMessageId,
@@ -44,14 +43,4 @@ export class LocalLlmRequestLogSource implements LlmRequestLogSource {
       beforeCreatedAt,
     );
   }
-
-  async getPreviousNonCompactionCallCreatedAt(
-    conversationId: string,
-    beforeCreatedAt: number,
-  ): Promise<number | null> {
-    return getPreviousNonCompactionCallCreatedAt(
-      conversationId,
-      beforeCreatedAt,
-    );
-  }
 }