@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/memory/conversation-title-service.ts

@@ -10,7 +10,9 @@
 import { getConfiguredProvider } from "../providers/provider-send-message.js";
 import type { Provider } from "../providers/types.js";
 import { runBtwSidechain } from "../runtime/btw-sidechain.js";
+import { publishConversationTitleChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
+import { Mutex } from "../util/mutex.js";
 import {
   getConversation,
   getMessages,
@@ -93,8 +95,6 @@ export interface GenerateTitleParams {
   userMessage?: string;
   /** Assistant response text (first turn). */
   assistantResponse?: string;
-  /** Callback to emit title update events. */
-  onTitleUpdated?: (title: string) => void;
   /** Abort signal. */
   signal?: AbortSignal;
 }
@@ -106,14 +106,8 @@ export interface GenerateTitleParams {
 export async function generateAndPersistConversationTitle(
   params: GenerateTitleParams,
 ): Promise<{ title: string; updated: boolean }> {
-  const {
-    conversationId,
-    context,
-    userMessage,
-    assistantResponse,
-    onTitleUpdated,
-    signal,
-  } = params;
+  const { conversationId, context, userMessage, assistantResponse, signal } =
+    params;
 
   // Check current title is replaceable
   const conversation = getConversation(conversationId);
@@ -127,7 +121,7 @@ export async function generateAndPersistConversationTitle(
     // No provider available — fall back to context-derived title or untitled
     const fallback = deriveFallbackTitle(context) ?? UNTITLED_FALLBACK;
     updateConversationTitle(conversationId, fallback, 1);
-    onTitleUpdated?.(fallback);
+    publishConversationTitleChanged(conversationId, fallback);
     return { title: fallback, updated: true };
   }
 
@@ -139,7 +133,7 @@ export async function generateAndPersistConversationTitle(
     tools: [],
     callSite: "conversationTitle",
     signal,
-    timeoutMs: 10_000,
+    timeoutMs: 15_000,
   });
   const title = normalizeTitle(result.text);
   if (title) {
@@ -150,7 +144,7 @@ export async function generateAndPersistConversationTitle(
     }
 
     updateConversationTitle(conversationId, title, 1);
-    onTitleUpdated?.(title);
+    publishConversationTitleChanged(conversationId, title);
     log.info({ conversationId, title }, "Auto-generated conversation title");
     return { title, updated: true };
   }
@@ -167,36 +161,61 @@ export async function generateAndPersistConversationTitle(
 
   const fallback = deriveFallbackTitle(context) ?? UNTITLED_FALLBACK;
   updateConversationTitle(conversationId, fallback, 1);
-  onTitleUpdated?.(fallback);
+  publishConversationTitleChanged(conversationId, fallback);
   return { title: fallback, updated: true };
 }
 
+// ── Serial title-generation queue ────────────────────────────────────
+
+/**
+ * Each title generation makes an LLM call. Without serialization, burst
+ * conversation creation (e.g. 5 new chats in quick succession) fires N
+ * concurrent requests that can hit provider rate limits or contend for
+ * API capacity, causing later calls to time out and fall back to
+ * "Untitled Conversation".
+ *
+ * A serial queue ensures at most one title-generation LLM call is
+ * in-flight at a time. Each call is lightweight (~1–3 s for a ≤5-word
+ * title), so the added serial latency is modest and invisible to the
+ * user (the UI shows "Generating title…" as a placeholder during the
+ * wait). Both initial generation and second-pass regeneration share
+ * this queue since they hit the same provider.
+ */
+export const titleMutex = new Mutex();
+
 /**
  * Fire-and-forget wrapper for title generation. Failures are logged
  * but do not propagate. On failure, replaces loading placeholder with
  * a stable fallback title so loading state is never permanent.
+ *
+ * Calls are serialized via {@link titleMutex} so burst conversation
+ * creation does not overwhelm the LLM provider.
  */
 export function queueGenerateConversationTitle(
   params: GenerateTitleParams,
 ): void {
-  generateAndPersistConversationTitle(params).catch((err) => {
-    log.warn(
-      { err, conversationId: params.conversationId },
-      "Failed to generate conversation title (non-fatal)",
-    );
-    // Replace loading placeholder with stable fallback
-    try {
-      const conversation = getConversation(params.conversationId);
-      if (conversation && conversation.title === GENERATING_TITLE) {
-        const fallback =
-          deriveFallbackTitle(params.context) ?? UNTITLED_FALLBACK;
-        updateConversationTitle(params.conversationId, fallback);
-        params.onTitleUpdated?.(fallback);
+  void titleMutex
+    .withLock(async () => {
+      await generateAndPersistConversationTitle(params);
+    })
+    .catch((err) => {
+      log.warn(
+        { err, conversationId: params.conversationId },
+        "Failed to generate conversation title (non-fatal)",
+      );
+      // Replace loading placeholder with stable fallback
+      try {
+        const conversation = getConversation(params.conversationId);
+        if (conversation && conversation.title === GENERATING_TITLE) {
+          const fallback =
+            deriveFallbackTitle(params.context) ?? UNTITLED_FALLBACK;
+          updateConversationTitle(params.conversationId, fallback);
+          publishConversationTitleChanged(params.conversationId, fallback);
+        }
+      } catch {
+        // Best-effort
       }
-    } catch {
-      // Best-effort
-    }
-  });
+    });
 }
 
 // ── Title regeneration (second pass) ─────────────────────────────────
@@ -204,7 +223,6 @@ export function queueGenerateConversationTitle(
 export interface RegenerateTitleParams {
   conversationId: string;
   provider?: Provider;
-  onTitleUpdated?: (title: string) => void;
   signal?: AbortSignal;
 }
 
@@ -216,7 +234,7 @@ export interface RegenerateTitleParams {
 export async function regenerateConversationTitle(
   params: RegenerateTitleParams,
 ): Promise<{ title: string; updated: boolean }> {
-  const { conversationId, onTitleUpdated, signal } = params;
+  const { conversationId, signal } = params;
 
   const conversation = getConversation(conversationId);
   if (!conversation || !conversation.isAutoTitle) {
@@ -249,7 +267,7 @@ export async function regenerateConversationTitle(
     tools: [],
     callSite: "conversationTitle",
     signal,
-    timeoutMs: 10_000,
+    timeoutMs: 15_000,
   });
   const title = normalizeTitle(result.text);
   if (title) {
@@ -260,7 +278,7 @@ export async function regenerateConversationTitle(
     }
 
     updateConversationTitle(conversationId, title, 1);
-    onTitleUpdated?.(title);
+    publishConversationTitleChanged(conversationId, title);
     log.info(
       { conversationId, title },
       "Re-generated conversation title (second pass)",
@@ -273,16 +291,22 @@ export async function regenerateConversationTitle(
 
 /**
  * Fire-and-forget wrapper for title regeneration.
+ *
+ * Serialized via the same {@link titleMutex} as initial generation.
  */
 export function queueRegenerateConversationTitle(
   params: RegenerateTitleParams,
 ): void {
-  regenerateConversationTitle(params).catch((err) => {
-    log.warn(
-      { err, conversationId: params.conversationId },
-      "Failed to regenerate conversation title (non-fatal)",
-    );
-  });
+  void titleMutex
+    .withLock(async () => {
+      await regenerateConversationTitle(params);
+    })
+    .catch((err) => {
+      log.warn(
+        { err, conversationId: params.conversationId },
+        "Failed to regenerate conversation title (non-fatal)",
+      );
+    });
 }
 
 // ── Internal helpers ─────────────────────────────────────────────────

package/src/memory/db-init.ts

@@ -18,6 +18,7 @@ import {
   addCoreColumns,
   createApprovalPromptTsTrackerTable,
   createAssistantInboxTables,
+  createAuthFallbackEventsTable,
   createCallSessionsTables,
   createCanonicalGuardianTables,
   createChannelGuardianTables,
@@ -40,6 +41,7 @@ import {
   migrate230AcpSessionHistory,
   migrate231RepairMemoryGraphEventDates,
   migrateA2ATasks,
+  migrateAcpSessionHistoryCwd,
   migrateActivationState,
   migrateActivationStateFkCascade,
   migrateAddConversationInferenceProfile,
@@ -188,6 +190,7 @@ import {
   migrateScheduleReuseConversation,
   migrateScheduleScriptColumn,
   migrateScheduleScriptTimeout,
+  migrateScheduleSourceConversation,
   migrateScheduleWakeConversationId,
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
@@ -473,7 +476,10 @@ export function initializeDb(): void {
     migrateLlmUsageEventsAddAssistantVersion,
     migrateAddMemoryV3Selections,
     migrateScheduleScriptTimeout,
+    migrateScheduleSourceConversation,
     migrateMessagesRoleCreatedAtIndex,
+    createAuthFallbackEventsTable,
+    migrateAcpSessionHistoryCwd,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/graph/__tests__/conversation-graph-memory-registry.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Tests for the live, per-conversation {@link ConversationGraphMemory} registry
+ * (`getLiveGraphMemory`). The registry lets memory-domain code that only knows
+ * a conversation id — notably the post-compaction re-injection hook — reach the
+ * same in-memory handle the turn's retrieval mutated, without the agent loop
+ * threading the handle through its generic context.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import { createMockLoggerModule } from "../../../__tests__/helpers/mock-logger.js";
+
+mock.module("../../../util/logger.js", () => createMockLoggerModule());
+
+const { ConversationGraphMemory, getLiveGraphMemory } =
+  await import("../conversation-graph-memory.js");
+
+describe("ConversationGraphMemory live registry", () => {
+  test("a constructed handle is discoverable by its conversation id", () => {
+    /**
+     * Tests that constructing a handle registers it so it can be looked up.
+     */
+
+    // GIVEN a conversation id
+    const conversationId = `conv-registry-${crypto.randomUUID()}`;
+
+    // WHEN a graph handle is constructed for it
+    const handle = new ConversationGraphMemory(conversationId);
+
+    // THEN the registry returns that exact instance
+    expect(getLiveGraphMemory(conversationId)).toBe(handle);
+  });
+
+  test("dispose removes the handle from the registry", () => {
+    /**
+     * Tests that disposing a handle unregisters it.
+     */
+
+    // GIVEN a registered graph handle
+    const conversationId = `conv-registry-${crypto.randomUUID()}`;
+    const handle = new ConversationGraphMemory(conversationId);
+
+    // WHEN it is disposed
+    handle.dispose();
+
+    // THEN the registry no longer resolves the conversation id
+    expect(getLiveGraphMemory(conversationId)).toBeUndefined();
+  });
+
+  test("missing id and undefined id both resolve to undefined", () => {
+    /**
+     * Tests the lookup's absence handling for unknown and undefined keys.
+     */
+
+    // GIVEN no handle registered for these keys
+    // WHEN the registry is queried with an unknown id and with undefined
+    // THEN both resolve to undefined (the hook treats absence as "no graph")
+    expect(
+      getLiveGraphMemory(`conv-never-${crypto.randomUUID()}`),
+    ).toBeUndefined();
+    expect(getLiveGraphMemory(undefined)).toBeUndefined();
+  });
+
+  test("recreating for the same id replaces the registered handle", () => {
+    /**
+     * Tests that the latest constructed handle wins for a conversation id.
+     */
+
+    // GIVEN a handle already registered for a conversation id
+    const conversationId = `conv-registry-${crypto.randomUUID()}`;
+    new ConversationGraphMemory(conversationId);
+
+    // WHEN a second handle is constructed for the same id
+    const recreated = new ConversationGraphMemory(conversationId);
+
+    // THEN the registry resolves to the most recent instance
+    expect(getLiveGraphMemory(conversationId)).toBe(recreated);
+  });
+
+  test("disposing a stale handle does not evict the current one", () => {
+    /**
+     * Tests the dispose guard during an eviction + recreation race: a stale
+     * handle must not delete the live entry that now points at a newer handle.
+     */
+
+    // GIVEN a superseded (stale) handle and the current handle for one id
+    const conversationId = `conv-registry-${crypto.randomUUID()}`;
+    const stale = new ConversationGraphMemory(conversationId);
+    const current = new ConversationGraphMemory(conversationId);
+
+    // WHEN the stale handle is disposed
+    stale.dispose();
+
+    // THEN the registry still resolves to the current handle
+    expect(getLiveGraphMemory(conversationId)).toBe(current);
+  });
+
+  test("records and exposes the PKB query vector pair from the registry", () => {
+    /**
+     * Tests that the dense/sparse PKB query pair recorded during retrieval is
+     * readable off the same live handle the PKB-reminder injector looks up.
+     */
+
+    // GIVEN a registered graph handle with no recorded vectors yet
+    const conversationId = `conv-registry-${crypto.randomUUID()}`;
+    const handle = new ConversationGraphMemory(conversationId);
+    expect(handle.pkbQueryVector).toBeUndefined();
+    expect(handle.pkbSparseVector).toBeUndefined();
+
+    // WHEN a retrieval records the turn's dense/sparse pair
+    const dense = [0.1, 0.2, 0.3];
+    const sparse = { indices: [0, 2], values: [0.5, 0.9] };
+    handle.recordPkbQueryVectors(dense, sparse);
+
+    // THEN a registry consumer reads back the same pair by conversation id
+    const looked = getLiveGraphMemory(conversationId);
+    expect(looked?.pkbQueryVector).toBe(dense);
+    expect(looked?.pkbSparseVector).toBe(sparse);
+  });
+});

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

@@ -62,6 +62,31 @@ const ESTIMATED_IMAGE_TOKENS = 1000;
 // Per-conversation state
 // ---------------------------------------------------------------------------
 
+/**
+ * Registry of the live, per-conversation graph handles keyed by conversation
+ * id. A handle registers itself on construction and removes itself on
+ * {@link ConversationGraphMemory.dispose}, so memory-domain code that only
+ * knows a conversation id (e.g. the post-compaction re-injection hook) can
+ * reach the same in-memory handle the turn's retrieval used — its live
+ * `tracker` / cached-node state, which a DB-reconstructed handle would not
+ * carry. Not a general service locator: it holds only the graph handle, and
+ * the daemon's `Conversation` remains the owner of the instance's lifecycle.
+ */
+const liveByConversation = new Map<string, ConversationGraphMemory>();
+
+/**
+ * Look up the live {@link ConversationGraphMemory} for a conversation, or
+ * `undefined` when none is registered (no active conversation, or a context
+ * with no conversation id). Returns the same instance the turn's retrieval
+ * mutated, so cached-node re-tracking operates on real state.
+ */
+export function getLiveGraphMemory(
+  conversationId: string | undefined,
+): ConversationGraphMemory | undefined {
+  if (!conversationId) return undefined;
+  return liveByConversation.get(conversationId);
+}
+
 /**
  * Manages memory graph state for a single conversation.
  * Create one per Conversation instance. Persists across turns.
@@ -75,9 +100,24 @@ export class ConversationGraphMemory {
   private lastInjectedBlock: string | null = null;
   private lastInjectedNodeIds: string[] = [];
   private lastInjectedImages: Map<string, ResolvedImage> = new Map();
+  private lastPkbQueryVector: number[] | undefined;
+  private lastPkbSparseVector: QdrantSparseVector | undefined;
 
   constructor(conversationId: string) {
     this.conversationId = conversationId;
+    liveByConversation.set(conversationId, this);
+  }
+
+  /**
+   * Remove this handle from the live registry. Called from
+   * `Conversation.dispose`. Guards against clobbering a newer handle for the
+   * same conversation (eviction + recreation) by only deleting the entry when
+   * it still points at this instance.
+   */
+  dispose(): void {
+    if (liveByConversation.get(this.conversationId) === this) {
+      liveByConversation.delete(this.conversationId);
+    }
   }
 
   /**
@@ -305,6 +345,31 @@ export class ConversationGraphMemory {
     this.tracker.add(this.lastInjectedNodeIds);
   }
 
+  /**
+   * Record the dense/sparse query-vector pair this turn's retrieval produced
+   * for PKB hybrid search. The PKB-reminder injector reuses the same
+   * embedding (looked up by conversation id via {@link getLiveGraphMemory})
+   * rather than receiving it threaded through the agent loop, so the vectors
+   * stay owned by the memory-retrieval domain that computes them.
+   */
+  recordPkbQueryVectors(
+    dense: number[] | undefined,
+    sparse: QdrantSparseVector | undefined,
+  ): void {
+    this.lastPkbQueryVector = dense;
+    this.lastPkbSparseVector = sparse;
+  }
+
+  /** Dense PKB query vector from this turn's retrieval, or `undefined`. */
+  get pkbQueryVector(): number[] | undefined {
+    return this.lastPkbQueryVector;
+  }
+
+  /** Sparse PKB query vector paired with {@link pkbQueryVector}. */
+  get pkbSparseVector(): QdrantSparseVector | undefined {
+    return this.lastPkbSparseVector;
+  }
+
   /**
    * Main entry point — called on every turn before the LLM sees the messages.
    *

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

@@ -22,6 +22,7 @@ import {
   checkpointKey,
   CK_BATCH,
   CK_ITEM_COUNT,
+  CK_LAST_ATTEMPT_AT,
   CK_LAST_GEN_AT,
   countActiveMemoryNodes,
   getCheckpointValue,
@@ -336,6 +337,7 @@ Bad → Good (incomplete phrase → complete):
         config: {
           callSite: "conversationStarters" as const,
           max_tokens: 2048,
+          temperature: 0.7,
           tool_choice: {
             type: "tool" as const,
             name: "store_conversation_starters",
@@ -395,18 +397,27 @@ export async function generateConversationStartersJob(
   const db = getDb();
   const now = Date.now();
 
+  // Record attempt time so the route handler's cooldown prevents rapid retries
+  // even when generation produces 0 valid starters.
+  upsertCheckpoint(
+    checkpointKey(CK_LAST_ATTEMPT_AT, scopeId),
+    String(now),
+    now,
+  );
+
   const starters = await generateStarters(scopeId);
   if (starters.length === 0) {
     log.info({ scopeId }, "No conversation starters generated");
 
-    // Sync checkpoints so both `staleByAge` and `checkpointAhead` clear.
+    // Sync the item count checkpoint so `checkpointAhead` clears, but do NOT
+    // update `CK_LAST_GEN_AT` — the stale TTL should trigger a retry on the
+    // next GET rather than blocking retries for the full TTL window.
     const totalActive = countActiveMemoryNodes(scopeId);
     upsertCheckpoint(
       checkpointKey(CK_ITEM_COUNT, scopeId),
       String(totalActive),
       now,
     );
-    upsertCheckpoint(checkpointKey(CK_LAST_GEN_AT, scopeId), String(now), now);
     return;
   }
 

package/src/memory/jobs-store.ts

@@ -79,6 +79,11 @@ export const SLOW_LLM_JOB_TYPES: MemoryJobType[] = [
   "graph_bootstrap",
 ];
 
+export const MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS = {
+  automatic: "automatic",
+  manual: "manual",
+} as const;
+
 /** Returns `false` only when `config.memory.enabled` is explicitly `false`; defaults to `true` on missing config or load errors. */
 export function isMemoryEnabled(): boolean {
   try {
@@ -337,6 +342,34 @@ export function hasActiveJobOfType(type: MemoryJobType): boolean {
   );
 }
 
+export function isAutomaticConsolidationJob(job: MemoryJob): boolean {
+  return job.payload.trigger !== MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS.manual;
+}
+
+export function cancelPendingAutomaticConsolidationJobs(): number {
+  const db = getDb();
+  db.update(memoryJobs)
+    .set({
+      status: "failed",
+      lastError: "automatic_consolidation_disabled",
+      updatedAt: Date.now(),
+    })
+    .where(
+      and(
+        eq(memoryJobs.type, "memory_v2_consolidate"),
+        eq(memoryJobs.status, "pending"),
+        or(
+          sql`json_extract(${memoryJobs.payload}, '$.trigger') = ${MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS.automatic}`,
+          // Legacy rows predate trigger markers and are indistinguishable from
+          // automatic enqueues, so disabling the schedule treats them as auto.
+          sql`json_extract(${memoryJobs.payload}, '$.trigger') IS NULL`,
+        ),
+      ),
+    )
+    .run();
+  return rawChanges();
+}
+
 export function enqueuePruneOldLlmRequestLogsJob(retentionMs?: number): string {
   const db = getDb();
   const existing = db

package/src/memory/jobs-worker.ts

@@ -8,6 +8,7 @@ import {
   diskPressureBackgroundSkipLogFields,
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
+import { maintainJob as memoryV3MaintainJob } from "../plugins/defaults/memory-v3-shadow/maintain-job.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
@@ -67,6 +68,8 @@ import {
   failMemoryJob,
   failStalledJobs,
   hasActiveJobOfType,
+  isAutomaticConsolidationJob,
+  MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS,
   type MemoryJob,
   type MemoryJobType,
   resetRunningJobsToPending,
@@ -85,10 +88,13 @@ import {
   memoryV2ConsolidateJob,
 } from "./v2/consolidation-job.js";
 import { memoryV2SweepJob } from "./v2/sweep-job.js";
-import { maintainJob as memoryV3MaintainJob } from "./v3/maintain-job.js";
 
 const log = getLogger("memory-jobs-worker");
 
+const AUTOMATIC_CONSOLIDATION_JOB_PAYLOAD = {
+  trigger: MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS.automatic,
+} as const;
+
 /**
  * V1 job types that read or write the v1 Qdrant collection via
  * `getQdrantClient()`. When `memory.v2.enabled` is true, the v1 client is
@@ -609,6 +615,16 @@ async function processJob(
       await memoryV2SweepJob(job, config);
       return;
     case "memory_v2_consolidate":
+      if (
+        isAutomaticConsolidationJob(job) &&
+        !config.memory.v2.consolidation_enabled
+      ) {
+        log.info(
+          { jobId: job.id },
+          "Skipping automatic memory v2 consolidation because scheduled consolidation is disabled",
+        );
+        return;
+      }
       await memoryV2ConsolidateJob(job, config);
       return;
     case "memory_v2_migrate":
@@ -734,6 +750,8 @@ export function maybeEnqueueGraphMaintenanceJobs(
   nowMs = Date.now(),
 ): void {
   const v2Active = config.memory.v2.enabled;
+  const v2ConsolidationAutomaticEnabled =
+    v2Active && config.memory.v2.consolidation_enabled;
 
   // The single buffer-drainer entry for the v2-active branch. Referenced again
   // below by the size-based trigger.
@@ -748,7 +766,9 @@ export function maybeEnqueueGraphMaintenanceJobs(
     intervalMs: number;
     jobType: MemoryJobType;
   }> = v2Active
-    ? [consolidateEntry]
+    ? v2ConsolidationAutomaticEnabled
+      ? [consolidateEntry]
+      : []
     : [
         {
           key: GRAPH_MAINTENANCE_CHECKPOINTS.decay,
@@ -795,7 +815,11 @@ export function maybeEnqueueGraphMaintenanceJobs(
   for (const { key, intervalMs, jobType } of schedule) {
     const lastRun = parseInt(getMemoryCheckpoint(key) ?? "0", 10);
     if (nowMs - lastRun >= intervalMs) {
-      enqueueMemoryJob(jobType, {});
+      const payload =
+        jobType === consolidateEntry.jobType
+          ? AUTOMATIC_CONSOLIDATION_JOB_PAYLOAD
+          : {};
+      enqueueMemoryJob(jobType, payload);
       setMemoryCheckpoint(key, String(nowMs));
       if (jobType === consolidateEntry.jobType) enqueuedConsolidate = true;
     }
@@ -811,14 +835,17 @@ export function maybeEnqueueGraphMaintenanceJobs(
   // buffer stays over threshold, flooding the queue with redundant LLM work.
   const maxLines = config.memory.v2.consolidation_max_buffer_lines;
   if (
-    v2Active &&
+    v2ConsolidationAutomaticEnabled &&
     !enqueuedConsolidate &&
     maxLines !== null &&
     !hasActiveJobOfType(consolidateEntry.jobType)
   ) {
     const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
     if (countBufferLines(bufferPath) >= maxLines) {
-      enqueueMemoryJob(consolidateEntry.jobType, {});
+      enqueueMemoryJob(
+        consolidateEntry.jobType,
+        AUTOMATIC_CONSOLIDATION_JOB_PAYLOAD,
+      );
       setMemoryCheckpoint(consolidateEntry.key, String(nowMs));
     }
   }