@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/persistence/job-handlers/message-lexical.ts

@@ -0,0 +1,251 @@
+import { eq } from "drizzle-orm";
+
+import type { AssistantConfig } from "../../config/types.js";
+import { getLogger } from "../../util/logger.js";
+import { getDb } from "../db-connection.js";
+import { generateSparseEmbedding } from "../embeddings/embedding-backend.js";
+import {
+  getMessagesLexicalIndex,
+  initMessagesLexicalIndex,
+  MESSAGES_LEXICAL_COLLECTION,
+  type MessagesLexicalIndex,
+} from "../embeddings/messages-lexical-index.js";
+import { withQdrantBreaker } from "../embeddings/qdrant-circuit-breaker.js";
+import { resolveQdrantUrl } from "../embeddings/qdrant-client.js";
+import { asString } from "../job-utils.js";
+import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import { messages } from "../schema/index.js";
+
+const log = getLogger("messages-lexical-enqueue");
+
+/**
+ * Resolve the messages lexical index singleton, lazily initializing it from
+ * `config` when it has not been set up in this process. The eager init in
+ * `runMemoryStartup` (startup.ts) only runs in the daemon process; the memory
+ * job worker can run as a separate OS process (`jobs/worker.ts`) that never
+ * calls `runMemoryStartup`, so without this fallback every lexical job claimed
+ * there would throw. `initMessagesLexicalIndex` is idempotent — it just
+ * (re)points the singleton at an equivalent client — so re-initializing from
+ * the same config is safe.
+ */
+export function resolveLexicalIndex(
+  config: AssistantConfig,
+): MessagesLexicalIndex {
+  try {
+    return getMessagesLexicalIndex();
+  } catch {
+    return initMessagesLexicalIndex({
+      url: resolveQdrantUrl(config),
+      collection: MESSAGES_LEXICAL_COLLECTION,
+      onDisk: config.memory.qdrant.onDisk,
+    });
+  }
+}
+
+/**
+ * Encode `message.content` with the local sparse encoder and upsert it into the
+ * messages lexical (Qdrant) index. The single shared indexing primitive — the
+ * `index_message_lexical` job and the backfill path both route through here so
+ * the encode + upsert sequence lives in one place.
+ *
+ * The upsert is wrapped in the Qdrant circuit breaker so a transient Qdrant
+ * outage trips the breaker and surfaces as a deferrable error rather than an
+ * unhandled throw; the job worker's retry/defer logic then drains the backlog
+ * once Qdrant recovers.
+ */
+export async function indexMessageToLexical(
+  message: {
+    id: string;
+    conversationId: string;
+    content: string;
+    createdAt: number;
+  },
+  config: AssistantConfig,
+): Promise<void> {
+  const index = resolveLexicalIndex(config);
+  const sparse = generateSparseEmbedding(message.content);
+  await withQdrantBreaker(() =>
+    index.upsertMessage(message.id, sparse, {
+      conversationId: message.conversationId,
+      createdAt: message.createdAt,
+    }),
+  );
+}
+
+export async function indexMessageLexicalJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const messageId = asString(job.payload.messageId);
+  if (!messageId) {
+    return;
+  }
+
+  const db = getDb();
+  const row = db
+    .select({
+      id: messages.id,
+      conversationId: messages.conversationId,
+      content: messages.content,
+      createdAt: messages.createdAt,
+    })
+    .from(messages)
+    .where(eq(messages.id, messageId))
+    .get();
+
+  // The message may have been deleted between enqueue and dispatch — no-op.
+  if (!row) {
+    return;
+  }
+
+  await indexMessageToLexical(row, config);
+}
+
+/**
+ * Delete a conversation's points from the lexical index (the
+ * `purge_conversation_lexical` job body).
+ */
+async function purgeConversationLexical(
+  conversationId: string,
+  config: AssistantConfig,
+): Promise<void> {
+  const index = resolveLexicalIndex(config);
+  await withQdrantBreaker(() => index.deleteByConversation(conversationId));
+}
+
+/**
+ * Delete a single message's point from the lexical index (the
+ * `delete_message_lexical` job body).
+ */
+async function deleteMessageLexical(
+  messageId: string,
+  config: AssistantConfig,
+): Promise<void> {
+  const index = resolveLexicalIndex(config);
+  await withQdrantBreaker(() => index.deleteByMessageId(messageId));
+}
+
+export async function purgeConversationLexicalJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const conversationId = asString(job.payload.conversationId);
+  if (!conversationId) {
+    return;
+  }
+  await purgeConversationLexical(conversationId, config);
+}
+
+export async function deleteMessageLexicalJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const messageId = asString(job.payload.messageId);
+  if (!messageId) {
+    return;
+  }
+  await deleteMessageLexical(messageId, config);
+}
+
+/**
+ * Enqueue an `index_message_lexical` job for a single message so its content is
+ * (re)indexed into the lexical (Qdrant) index off the SQLite write path. Called
+ * wherever a message's content becomes durable — on persist and on the
+ * streaming/import finalize seams that mirror the segment indexer
+ * (`indexMessageNow`).
+ *
+ * One job per message (not a debounced per-conversation coalesce): the payload
+ * carries a specific `messageId`, so coalescing bursts by conversation would
+ * drop every message but the last from the index. The upsert into Qdrant is
+ * idempotent, so re-enqueuing the same message id is harmless.
+ *
+ * Unconditional: message-content search is host infrastructure, so indexing
+ * runs regardless of the memory feature's or memory plugin's state (the job
+ * worker drains the lexical types even while memory is disabled).
+ *
+ * Best-effort: the enqueue is a search side effect off the message write path,
+ * so a failure (e.g. the jobs database is unavailable) is swallowed and logged
+ * rather than propagated — an indexing hiccup must not escalate a successful
+ * message persist into a throw, mirroring the `indexMessageNow` call sites
+ * this runs beside.
+ */
+export function enqueueLexicalIndexForMessage(messageId: string): void {
+  if (!messageId) {
+    return;
+  }
+  try {
+    enqueueMemoryJob("index_message_lexical", { messageId });
+  } catch (err) {
+    log.warn(
+      { err, messageId },
+      "Failed to enqueue lexical index job for message (non-fatal)",
+    );
+  }
+}
+
+/**
+ * Purge a deleted/wiped conversation's points from the lexical index, as a
+ * `purge_conversation_lexical` job processed off the write path (the worker
+ * drains the lexical types regardless of the memory feature's state).
+ *
+ * The purge targets Qdrant by `conversationId`, so it is correct even after the
+ * conversation's message rows have been deleted. Callers on the wipe path must
+ * invoke this AFTER `cancelPendingJobsForConversation`, which fails every
+ * pending `conversationId`-keyed job — otherwise an enqueued purge is swept by
+ * that same cancellation.
+ *
+ * Best-effort: a failed enqueue is swallowed and logged rather than
+ * propagated, so conversation deletion never fails on an indexing hiccup.
+ */
+export function enqueuePurgeConversationLexical(conversationId: string): void {
+  if (!conversationId) {
+    return;
+  }
+  try {
+    enqueueMemoryJob("purge_conversation_lexical", { conversationId });
+  } catch (err) {
+    log.warn(
+      { err, conversationId },
+      "Failed to schedule lexical purge for conversation (non-fatal)",
+    );
+  }
+}
+
+/**
+ * Remove a deleted message's point from the lexical index, as a
+ * `delete_message_lexical` job. Used by single-message delete paths
+ * (consolidation, undo) that remove a row without wiping the whole
+ * conversation. Best-effort so message deletion never fails on an indexing
+ * hiccup.
+ */
+export function enqueueDeleteMessageLexical(messageId: string): void {
+  if (!messageId) {
+    return;
+  }
+  try {
+    enqueueMemoryJob("delete_message_lexical", { messageId });
+  } catch (err) {
+    log.warn(
+      { err, messageId },
+      "Failed to schedule lexical delete for message (non-fatal)",
+    );
+  }
+}
+
+/**
+ * Drop every point from the messages lexical index. Called inline (not via a
+ * job) by "clear all conversations": that path deletes all rows and the
+ * `memory_jobs` table itself, so there is nothing left to key a per-conversation
+ * purge job on. Best-effort — a Qdrant failure is swallowed, matching the other
+ * `clearAll` cleanup steps that tolerate failures.
+ */
+export async function clearMessagesLexicalIndex(
+  config: AssistantConfig,
+): Promise<void> {
+  try {
+    const index = resolveLexicalIndex(config);
+    await withQdrantBreaker(() => index.clear());
+  } catch (err) {
+    log.warn({ err }, "Failed to clear messages lexical index (non-fatal)");
+  }
+}

package/src/persistence/jobs-store.ts

@@ -36,6 +36,7 @@ export type MemoryJobType =
   | "prune_old_conversations"
   | "prune_old_llm_request_logs"
   | "prune_old_trace_events"
+  | "prune_old_tool_invocations"
   | "build_conversation_summary"
   | "conversation_analyze"
   | "backfill"
@@ -61,6 +62,10 @@ export type MemoryJobType =
   | "memory_v2_reembed"
   | "memory_v2_activation_recompute"
   | "memory_v3_maintain"
+  | "index_message_lexical"
+  | "purge_conversation_lexical"
+  | "delete_message_lexical"
+  | "backfill_lexical_index"
   // Retired/legacy — no live handler; persisted rows drop via LEGACY_JOB_TYPES.
   | "memory_v3_consolidate"
   | "memory_v3_index_maintenance"
@@ -78,6 +83,19 @@ export const EMBED_JOB_TYPES: MemoryJobType[] = [
   "embed_concept_page",
 ];
 
+/**
+ * Job types that power message-content lexical search — host infrastructure
+ * that shares the background job queue but is not a memory feature. The worker
+ * keeps draining exactly these types while memory is disabled, so message
+ * search stays indexed regardless of the memory feature's state.
+ */
+export const MESSAGE_LEXICAL_JOB_TYPES: MemoryJobType[] = [
+  "index_message_lexical",
+  "purge_conversation_lexical",
+  "delete_message_lexical",
+  "backfill_lexical_index",
+];
+
 export const SLOW_LLM_JOB_TYPES: MemoryJobType[] = [
   "graph_consolidate",
   "graph_pattern_scan",
@@ -501,20 +519,84 @@ export function enqueuePruneOldTraceEventsJob(retentionDays?: number): string {
   return enqueueMemoryJob("prune_old_trace_events", payload);
 }
 
+export function enqueuePruneOldToolInvocationsJob(
+  retentionDays?: number,
+): string {
+  const db = memoryDb();
+  const existing = db
+    .select()
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "prune_old_tool_invocations"),
+        inArray(memoryJobs.status, ["pending", "running"]),
+      ),
+    )
+    .orderBy(asc(memoryJobs.createdAt))
+    .get();
+  if (existing) {
+    if (
+      existing.status === "pending" &&
+      typeof retentionDays === "number" &&
+      Number.isFinite(retentionDays) &&
+      retentionDays >= 0
+    ) {
+      let payload: Record<string, unknown> = {};
+      try {
+        payload = JSON.parse(existing.payload) as Record<string, unknown>;
+      } catch {
+        payload = {};
+      }
+      if (payload.retentionDays !== retentionDays) {
+        db.update(memoryJobs)
+          .set({
+            payload: JSON.stringify({ ...payload, retentionDays }),
+            updatedAt: Date.now(),
+          })
+          .where(eq(memoryJobs.id, existing.id))
+          .run();
+      }
+    }
+    return existing.id;
+  }
+  const payload =
+    typeof retentionDays === "number" &&
+    Number.isFinite(retentionDays) &&
+    retentionDays >= 0
+      ? { retentionDays }
+      : {};
+  return enqueueMemoryJob("prune_old_tool_invocations", payload);
+}
+
 export interface LaneBudgets {
   slowLlm: number;
   fast: number;
   embed: number;
 }
 
-export function claimMemoryJobs(limits: LaneBudgets): MemoryJob[] {
-  if (limits.slowLlm <= 0 && limits.fast <= 0 && limits.embed <= 0) return [];
+/**
+ * Claim up to the per-lane budgets of pending jobs. When `restrictToTypes` is
+ * provided, only jobs of those types are eligible in every lane — the worker
+ * uses this to drain exclusively the message-lexical types while memory is
+ * disabled.
+ */
+export function claimMemoryJobs(
+  limits: LaneBudgets,
+  restrictToTypes?: readonly MemoryJobType[],
+): MemoryJob[] {
+  if (limits.slowLlm <= 0 && limits.fast <= 0 && limits.embed <= 0) {
+    return [];
+  }
 
   const db = memoryDb();
   const now = Date.now();
+  const restrictFilter = restrictToTypes
+    ? inArray(memoryJobs.type, [...restrictToTypes])
+    : undefined;
   const pendingFilter = and(
     eq(memoryJobs.status, "pending"),
     lte(memoryJobs.runAfter, now),
+    restrictFilter,
   );
 
   // Slow lane: long-running LLM jobs (graph extract/consolidate, analysis, etc.).
@@ -596,7 +678,9 @@ export function claimMemoryJobs(limits: LaneBudgets): MemoryJob[] {
       .set({ status: "running", startedAt: now, updatedAt: now })
       .where(and(eq(memoryJobs.id, row.id), eq(memoryJobs.status, "pending")))
       .run();
-    if (rawMemoryChanges() === 0) continue;
+    if (rawMemoryChanges() === 0) {
+      continue;
+    }
     claimed.push(
       parseRow({
         ...row,
@@ -640,7 +724,9 @@ const DEFER_MAX_DELAY_MS = 5 * 60 * 1000;
 export function deferMemoryJob(id: string): "deferred" | "failed" {
   const db = memoryDb();
   const row = db.select().from(memoryJobs).where(eq(memoryJobs.id, id)).get();
-  if (!row) return "failed";
+  if (!row) {
+    return "failed";
+  }
 
   const deferrals = row.deferrals + 1;
   const now = Date.now();
@@ -697,7 +783,9 @@ export function failMemoryJob(
   const maxAttempts = options?.maxAttempts ?? 5;
   const db = memoryDb();
   const row = db.select().from(memoryJobs).where(eq(memoryJobs.id, id)).get();
-  if (!row) return;
+  if (!row) {
+    return;
+  }
   const attempts = row.attempts + 1;
   const now = Date.now();
   if (attempts >= maxAttempts) {
@@ -741,6 +829,7 @@ export function failStalledJobs(timeoutMs: number): number {
   const now = Date.now();
   const cutoff = now - timeoutMs;
   const stalled = rawMemoryAll<{ id: string; type: string }>(
+    "jobs:failStalledJobs:select",
     `
     SELECT id, type
     FROM memory_jobs
@@ -750,7 +839,9 @@ export function failStalledJobs(timeoutMs: number): number {
   `,
     cutoff,
   );
-  if (stalled.length === 0) return 0;
+  if (stalled.length === 0) {
+    return 0;
+  }
 
   const db = memoryDb();
   for (const row of stalled) {
@@ -773,11 +864,14 @@ export function failStalledJobs(timeoutMs: number): number {
 }
 
 export function getMemoryJobCounts(): Record<string, number> {
-  const rows = rawMemoryAll<{ status: string; c: number }>(`
+  const rows = rawMemoryAll<{ status: string; c: number }>(
+    "jobs:getMemoryJobCounts",
+    `
     SELECT status, COUNT(*) AS c
     FROM memory_jobs
     GROUP BY status
-  `);
+  `,
+  );
   const counts: Record<string, number> = {
     pending: 0,
     running: 0,

package/src/persistence/jobs-worker.ts

@@ -1,5 +1,3 @@
-import { join } from "node:path";
-
 import { getConfig } from "../config/loader.js";
 import { isMemoryV3Live } from "../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../config/types.js";
@@ -8,9 +6,7 @@ import {
   diskPressureBackgroundSkipLogFields,
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
-import { countBufferLines } from "../plugins/defaults/memory/v2/consolidation-job.js";
 import { getLogger } from "../util/logger.js";
-import { getWorkspaceDir } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import {
   getLastScheduledCleanupEnqueueMs,
@@ -37,6 +33,7 @@ import {
   enqueueMemoryJob,
   enqueuePruneOldConversationsJob,
   enqueuePruneOldLlmRequestLogsJob,
+  enqueuePruneOldToolInvocationsJob,
   enqueuePruneOldTraceEventsJob,
   failMemoryJob,
   failStalledJobs,
@@ -44,6 +41,7 @@ import {
   MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS,
   type MemoryJob,
   type MemoryJobType,
+  MESSAGE_LEXICAL_JOB_TYPES,
   resetRunningJobsToPending,
   SLOW_LLM_JOB_TYPES,
 } from "./jobs-store.js";
@@ -206,7 +204,9 @@ export function startMemoryJobsWorker(): MemoryJobsWorker {
  * stopMemoryWorkerProcess() in worker-control.ts.
  */
 export function stopMemoryJobsWorker(): void {
-  if (!instance) return;
+  if (!instance) {
+    return;
+  }
   instance.stop();
   instance = null;
 }
@@ -251,7 +251,9 @@ export function startInProcessMemoryJobsWorker(
   let currentIntervalMs = POLL_INTERVAL_MIN_MS;
 
   const tick = async () => {
-    if (stopped || tickRunning) return;
+    if (stopped || tickRunning) {
+      return;
+    }
     tickRunning = true;
     try {
       if (
@@ -296,17 +298,23 @@ export function startInProcessMemoryJobsWorker(
   };
 
   const scheduleTick = () => {
-    if (stopped) return;
+    if (stopped) {
+      return;
+    }
     timer = setTimeout(() => {
       void tick().then(() => {
-        if (!stopped) scheduleTick();
+        if (!stopped) {
+          scheduleTick();
+        }
       });
     }, currentIntervalMs);
     (timer as NodeJS.Timeout).unref?.();
   };
 
   void tick().then(() => {
-    if (!stopped) scheduleTick();
+    if (!stopped) {
+      scheduleTick();
+    }
   });
 
   return {
@@ -326,8 +334,13 @@ export async function runMemoryJobsOnce(
   options: { enableScheduledCleanup?: boolean } = {},
 ): Promise<number> {
   const config = getConfig();
-  if (config.memory.enabled === false) return 0;
-  const enableScheduledCleanup = options.enableScheduledCleanup === true;
+  // While memory is disabled the queue still drains the MESSAGE-LEXICAL job
+  // types — host-owned message-search indexing that shares this queue but is
+  // not a memory feature. Every memory lane and every maintenance enqueue
+  // stays idle in that state; only the lexical types are claimable.
+  const memoryEnabled = config.memory.enabled !== false;
+  const enableScheduledCleanup =
+    options.enableScheduledCleanup === true && memoryEnabled;
 
   const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
   if (diskPressureGate.action === "skip") {
@@ -355,19 +368,26 @@ export async function runMemoryJobsOnce(
 
   // Claim per-lane budgets so a backlog of slow LLM jobs cannot starve fast
   // jobs (and vice versa). The Qdrant circuit breaker still gates only the
-  // embed lane inside `claimMemoryJobs`.
-  const claimed = claimMemoryJobs({
-    slowLlm: cfgSlow,
-    fast: cfgFast,
-    embed: cfgEmbed,
-  });
+  // embed lane inside `claimMemoryJobs`. With memory disabled, the slow and
+  // embed lanes get no budget and the fast lane is restricted to the
+  // message-lexical types (they ride the fast lane).
+  const claimed = claimMemoryJobs(
+    {
+      slowLlm: memoryEnabled ? cfgSlow : 0,
+      fast: cfgFast,
+      embed: memoryEnabled ? cfgEmbed : 0,
+    },
+    memoryEnabled ? undefined : MESSAGE_LEXICAL_JOB_TYPES,
+  );
 
   if (claimed.length === 0) {
     if (enableScheduledCleanup) {
       maybeEnqueueScheduledCleanupJobs(config);
     }
     maybeEnqueueGraphMaintenanceJobs(config);
-    await maybeRunDbMaintenance();
+    if (memoryEnabled) {
+      await maybeRunDbMaintenance();
+    }
     return 0;
   }
 
@@ -451,7 +471,9 @@ async function runLanePool(
   concurrency: number,
   processGroup: ProcessGroup,
 ): Promise<number> {
-  if (jobs.length === 0) return 0;
+  if (jobs.length === 0) {
+    return 0;
+  }
 
   const groups = new Map<string, MemoryJob[]>();
   for (const job of jobs) {
@@ -490,7 +512,9 @@ async function runLanePool(
   // starts the instant any slot frees up.
   let nextIdx = 0;
   const startNext = (): Promise<void> | undefined => {
-    if (nextIdx >= typeGroups.length) return undefined;
+    if (nextIdx >= typeGroups.length) {
+      return undefined;
+    }
     const group = typeGroups[nextIdx++]!;
     return processGroup(group)
       .then(
@@ -634,9 +658,12 @@ function maybeEnqueueScheduledCleanupJobs(
   nowMs = Date.now(),
 ): boolean {
   const cleanup = config.memory.cleanup;
-  if (!cleanup.enabled) return false;
-  if (nowMs - getLastScheduledCleanupEnqueueMs() < cleanup.enqueueIntervalMs)
+  if (!cleanup.enabled) {
     return false;
+  }
+  if (nowMs - getLastScheduledCleanupEnqueueMs() < cleanup.enqueueIntervalMs) {
+    return false;
+  }
 
   const pruneConversationsJobId =
     cleanup.conversationRetentionDays > 0
@@ -650,16 +677,24 @@ function maybeEnqueueScheduledCleanupJobs(
     cleanup.traceEventRetentionDays > 0
       ? enqueuePruneOldTraceEventsJob(cleanup.traceEventRetentionDays)
       : null;
+  // Audit-log (tool_invocations) retention is configured separately under
+  // `auditLog.retentionDays`, but rides this same cleanup cadence for now.
+  const pruneToolInvocationsJobId =
+    config.auditLog.retentionDays > 0
+      ? enqueuePruneOldToolInvocationsJob(config.auditLog.retentionDays)
+      : null;
   markScheduledCleanupEnqueued(nowMs);
   log.debug(
     {
       pruneConversationsJobId,
       pruneLlmRequestLogsJobId,
       pruneTraceEventsJobId,
+      pruneToolInvocationsJobId,
       enqueueIntervalMs: cleanup.enqueueIntervalMs,
       conversationRetentionDays: cleanup.conversationRetentionDays,
       llmRequestLogRetentionMs: cleanup.llmRequestLogRetentionMs,
       traceEventRetentionDays: cleanup.traceEventRetentionDays,
+      auditLogRetentionDays: config.auditLog.retentionDays,
     },
     "Enqueued scheduled memory cleanup jobs",
   );
@@ -721,7 +756,9 @@ export function maybeEnqueueGraphMaintenanceJobs(
   nowMs = Date.now(),
 ): void {
   const memoryEnabled = config.memory.enabled !== false;
-  if (!memoryEnabled) return;
+  if (!memoryEnabled) {
+    return;
+  }
 
   const v2Active = config.memory.v2.enabled;
 
@@ -787,8 +824,10 @@ export function maybeEnqueueGraphMaintenanceJobs(
       // The checkpoint advances so the next check fires after the regular
       // interval. Manual "Run now" is unaffected (routes layer, not schedule).
       if (jobType === consolidateEntry.jobType) {
-        const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
-        if (countBufferLines(bufferPath) < MIN_BUFFER_LINES_FOR_CONSOLIDATION) {
+        if (
+          getMemoryPersistenceHooks().countMemoryBufferLines() <
+          MIN_BUFFER_LINES_FOR_CONSOLIDATION
+        ) {
           log.debug(
             "Scheduled consolidation skipped: buffer under minimum line threshold",
           );
@@ -802,7 +841,9 @@ export function maybeEnqueueGraphMaintenanceJobs(
           : {};
       enqueueMemoryJob(jobType, payload);
       setMemoryCheckpoint(key, String(nowMs));
-      if (jobType === consolidateEntry.jobType) enqueuedConsolidate = true;
+      if (jobType === consolidateEntry.jobType) {
+        enqueuedConsolidate = true;
+      }
     }
   }
 
@@ -821,8 +862,7 @@ export function maybeEnqueueGraphMaintenanceJobs(
     maxLines !== null &&
     !hasActiveJobOfType(consolidateEntry.jobType)
   ) {
-    const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
-    if (countBufferLines(bufferPath) >= maxLines) {
+    if (getMemoryPersistenceHooks().countMemoryBufferLines() >= maxLines) {
       enqueueMemoryJob(
         consolidateEntry.jobType,
         AUTOMATIC_CONSOLIDATION_JOB_PAYLOAD,