@vellumai/assistant 0.8.7 → 0.8.8

package/src/memory/__tests__/jobs-worker-v2-schedule.test.ts

@@ -72,6 +72,7 @@ const CONSOLIDATE_CHECKPOINT_KEY = "memory_v2_consolidate_last_run";
 
 function buildConfig(overrides: {
   v2Enabled?: boolean;
+  consolidationEnabled?: boolean;
   intervalHours?: number;
   maxBufferLines?: number | null;
 }) {
@@ -79,6 +80,13 @@ function buildConfig(overrides: {
   if (overrides.v2Enabled !== undefined) {
     partial.memory.v2.enabled = overrides.v2Enabled;
   }
+  if (overrides.consolidationEnabled !== undefined) {
+    (
+      partial.memory.v2 as typeof partial.memory.v2 & {
+        consolidation_enabled?: boolean;
+      }
+    ).consolidation_enabled = overrides.consolidationEnabled;
+  }
   if (overrides.intervalHours !== undefined) {
     partial.memory.v2.consolidation_interval_hours = overrides.intervalHours;
   }
@@ -110,6 +118,15 @@ function countPendingJobs(type: string): number {
     .all().length;
 }
 
+function consolidationJobPayloads(): Record<string, unknown>[] {
+  return getDb()
+    .select({ payload: memoryJobs.payload })
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, "memory_v2_consolidate"))
+    .all()
+    .map((row) => JSON.parse(row.payload) as Record<string, unknown>);
+}
+
 // Initialize the DB once for the file; clear per-test tables in beforeEach
 // rather than tearing down the singleton, which is slow because it re-runs
 // every migration on the next access.
@@ -138,6 +155,7 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    expect(consolidationJobPayloads()).toEqual([{ trigger: "automatic" }]);
     // v1 entries are suppressed when v2 is active.
     expect(countPendingJobs("graph_decay")).toBe(0);
     expect(countPendingJobs("graph_consolidate")).toBe(0);
@@ -170,6 +188,7 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     maybeEnqueueGraphMaintenanceJobs(config, now);
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    expect(consolidationJobPayloads()).toEqual([{ trigger: "automatic" }]);
   });
 
   test("respects a custom consolidation_interval_hours value", () => {
@@ -231,6 +250,28 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("graph_narrative_refine")).toBe(1);
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
+
+  test("automatic consolidation off suppresses the v2 schedule without re-enabling v1 maintenance", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      consolidationEnabled: false,
+      intervalHours: 1,
+    });
+
+    deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:narrative:last_run");
+    deleteMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY);
+
+    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_decay")).toBe(0);
+    expect(countPendingJobs("graph_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(0);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(0);
+  });
 });
 
 describe("maybeEnqueueGraphMaintenanceJobs — buffer-size trigger", () => {
@@ -369,4 +410,19 @@ describe("maybeEnqueueGraphMaintenanceJobs — buffer-size trigger", () => {
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
+
+  test("size trigger inert when automatic consolidation is disabled", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      consolidationEnabled: false,
+      intervalHours: 1,
+      maxBufferLines: 1,
+    });
+
+    writeBuffer(100);
+
+    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
+  });
 });

package/src/memory/auth-fallback-events-store.ts

@@ -0,0 +1,94 @@
+import { and, asc, eq, gt, or } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import { getConfig } from "../config/loader.js";
+import { getDb } from "./db-connection.js";
+import { authFallbackEvents } from "./schema.js";
+
+/** A single aggregated auth-fallback count for one (guard, path, failure_kind). */
+export interface AuthFallbackCount {
+  guard: string;
+  path: string;
+  failureKind: string;
+  count: number;
+}
+
+/** A persisted auth-fallback event row. */
+export interface AuthFallbackEvent {
+  id: string;
+  createdAt: number;
+  guard: string;
+  path: string;
+  failureKind: string;
+  count: number;
+  windowStart: number;
+  windowEnd: number;
+}
+
+/**
+ * Record a batch of aggregated auth-fallback counts forwarded by the gateway —
+ * one row per count entry, all sharing the same flush window. Returns the
+ * number of rows recorded, or 0 when usage data collection is disabled (the
+ * counts are dropped to honor the opt-out, matching the rest of telemetry).
+ */
+export function recordAuthFallbackCounts(
+  windowStart: number,
+  windowEnd: number,
+  counts: AuthFallbackCount[],
+): number {
+  if (!getConfig().collectUsageData) return 0;
+  if (counts.length === 0) return 0;
+  const db = getDb();
+  const createdAt = Date.now();
+  const rows = counts.map((c) => ({
+    id: uuid(),
+    createdAt,
+    guard: c.guard,
+    path: c.path,
+    failureKind: c.failureKind,
+    count: c.count,
+    windowStart,
+    windowEnd,
+  }));
+  db.insert(authFallbackEvents).values(rows).run();
+  return rows.length;
+}
+
+/**
+ * Query auth-fallback events that haven't been reported to telemetry yet.
+ * Uses a compound cursor (createdAt + id) for reliable watermarking.
+ */
+export function queryUnreportedAuthFallbackEvents(
+  afterCreatedAt: number,
+  afterId: string | undefined,
+  limit: number,
+): AuthFallbackEvent[] {
+  const db = getDb();
+  const rows = db
+    .select({
+      id: authFallbackEvents.id,
+      createdAt: authFallbackEvents.createdAt,
+      guard: authFallbackEvents.guard,
+      path: authFallbackEvents.path,
+      failureKind: authFallbackEvents.failureKind,
+      count: authFallbackEvents.count,
+      windowStart: authFallbackEvents.windowStart,
+      windowEnd: authFallbackEvents.windowEnd,
+    })
+    .from(authFallbackEvents)
+    .where(
+      afterId
+        ? or(
+            gt(authFallbackEvents.createdAt, afterCreatedAt),
+            and(
+              eq(authFallbackEvents.createdAt, afterCreatedAt),
+              gt(authFallbackEvents.id, afterId),
+            ),
+          )
+        : gt(authFallbackEvents.createdAt, afterCreatedAt),
+    )
+    .orderBy(asc(authFallbackEvents.createdAt), asc(authFallbackEvents.id))
+    .limit(limit)
+    .all();
+  return rows;
+}

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,
@@ -188,6 +189,7 @@ import {
   migrateScheduleReuseConversation,
   migrateScheduleScriptColumn,
   migrateScheduleScriptTimeout,
+  migrateScheduleSourceConversation,
   migrateScheduleWakeConversationId,
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
@@ -473,7 +475,9 @@ export function initializeDb(): void {
     migrateLlmUsageEventsAddAssistantVersion,
     migrateAddMemoryV3Selections,
     migrateScheduleScriptTimeout,
+    migrateScheduleSourceConversation,
     migrateMessagesRoleCreatedAtIndex,
+    createAuthFallbackEventsTable,
   ];
 
   // 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/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