@vellumai/assistant 0.8.0 → 0.8.2

package/src/memory/indexer.ts

@@ -12,6 +12,8 @@ import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import { getDb } from "./db-connection.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
 import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
+import { isMemoryRetrospectiveConversation } from "./memory-retrospective-enqueue.js";
+import { maybeEnqueueRetrospective } from "./memory-retrospective-trigger-check.js";
 import {
   extractMediaBlockMeta,
   extractTextFromStoredMessageContent,
@@ -167,32 +169,30 @@ export async function indexMessageNow(
     const batchSize = config.extraction.batchSize ?? 10;
     const idleTimeoutMs = config.extraction.idleTimeoutMs ?? 300_000;
 
+    // Reading config here is best-effort: when it fails we treat v2 as
+    // inactive (failing-open to v1) so a config error never silently
+    // drops the extraction or summarization paths.
+    let triggerConfig: ReturnType<typeof getConfig> | null = null;
+    try {
+      triggerConfig = getConfig();
+    } catch (err) {
+      log.debug(
+        { err, conversationId: input.conversationId },
+        "Skipping feature-gated extraction triggers: failed to load config",
+      );
+    }
+
+    const v2Config =
+      triggerConfig != null && triggerConfig.memory.v2.enabled
+        ? triggerConfig
+        : null;
+
     // Recursion guard: skip graph extraction + auto-analysis enqueues
     // when the source conversation is itself an auto-analysis
     // conversation. The analysis agent writes memory directly via tools,
     // so extracting from its reflective musings would double-count and
     // analyzing its own output would loop indefinitely.
-    // Summaries still run — they feed the graph retrieval pipeline and
-    // are not recursion-prone.
     if (!isAutoAnalysisSource) {
-      // Reading config here is best-effort: when it fails we treat v2 as
-      // inactive (failing-open to v1) so a config error never silently
-      // drops both extraction paths.
-      let triggerConfig: ReturnType<typeof getConfig> | null = null;
-      try {
-        triggerConfig = getConfig();
-      } catch (err) {
-        log.debug(
-          { err, conversationId: input.conversationId },
-          "Skipping feature-gated extraction triggers: failed to load config",
-        );
-      }
-
-      const v2Config =
-        triggerConfig != null && triggerConfig.memory.v2.enabled
-          ? triggerConfig
-          : null;
-
       // ── Graph extraction (v1) ───────────────────────────────────────
       // Suppressed when v2 is active — v2 reads memory from buffer.md
       // and concept pages, so the v1 graph would be stale data nobody
@@ -283,17 +283,39 @@ export async function indexMessageNow(
           });
         }
       }
+
+      // ── Memory retrospective triggers ─────────────────────────────────
+      // Independent of auto-analyze: the retrospective is a focused,
+      // memory-only pass that re-reads messages since its last successful
+      // run and saves what the in-conversation `remember` calls didn't
+      // capture. Triggers (interval / message_count) are evaluated by
+      // `maybeEnqueueRetrospective`, which also enforces the per-conversation
+      // cooldown gate against retry storms. Recursion guard skips the
+      // memory-retrospective background conversation itself.
+      if (
+        triggerConfig != null &&
+        !isMemoryRetrospectiveConversation(input.conversationId)
+      ) {
+        maybeEnqueueRetrospective(input.conversationId, triggerConfig);
+      }
     }
 
-    // ── Conversation summarization (independent of extraction) ────────
-    // Summaries feed the graph retrieval pipeline via fetchRecentSummaries().
-    // Debounced on the same idle timeout — no threshold trigger needed since
-    // summaries compress the whole conversation, not incremental batches.
-    upsertDebouncedJob(
-      "build_conversation_summary",
-      { conversationId: input.conversationId },
-      Date.now() + idleTimeoutMs,
-    );
+    // ── Conversation summarization (v1) ───────────────────────────────
+    // Summaries feed the v1 graph retrieval pipeline (fetchRecentSummaries,
+    // semantic search). Suppressed when v2 is active — v2 readers (concept
+    // pages, activation pipeline) do not consume `memorySummaries`, so the
+    // summarization LLM call would produce rows nothing reads. Stale rows
+    // from before v2 was enabled are short-circuited at dispatch in
+    // jobs-worker.ts. Debounced on the same idle timeout — no threshold
+    // trigger needed since summaries compress the whole conversation, not
+    // incremental batches.
+    if (v2Config == null) {
+      upsertDebouncedJob(
+        "build_conversation_summary",
+        { conversationId: input.conversationId },
+        Date.now() + idleTimeoutMs,
+      );
+    }
   }
 
   if (skippedShortSegments > 0) {

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

@@ -151,6 +151,8 @@ type MemoryJob = ReturnType<MemoryJobMod["claimMemoryJobs"]>[number];
 const { embedConceptPageJob, enqueueEmbedConceptPageJob } =
   await import("../embed-concept-page.js");
 const { writePage } = await import("../../v2/page-store.js");
+const { _resetQdrantBreaker, isQdrantBreakerOpen, withQdrantBreaker } =
+  await import("../../qdrant-circuit-breaker.js");
 
 // Use a tiny vectorSize so the cache-dim check matches our stub vector.
 const TEST_CONFIG = {
@@ -186,6 +188,7 @@ beforeEach(() => {
   embedWithBackendCalls.length = 0;
   upsertCalls.length = 0;
   deleteCalls.length = 0;
+  _resetQdrantBreaker();
 });
 
 afterEach(() => {
@@ -203,7 +206,7 @@ describe("embedConceptPageJob — happy path", () => {
   test("reads the page, embeds it, and upserts to the v2 collection", async () => {
     await writePage(tmpWorkspace, {
       slug: "alice-prefers-vs-code",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Alice prefers VS Code over Vim.\nShe ships at end of day.\n",
     });
 
@@ -231,7 +234,7 @@ describe("embedConceptPageJob — happy path", () => {
   test("populates the SQLite embedding cache row keyed on (concept_page, slug)", async () => {
     await writePage(tmpWorkspace, {
       slug: "bob-uses-zsh",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Bob uses zsh.\n",
     });
 
@@ -257,6 +260,7 @@ describe("embedConceptPageJob — summary embedding", () => {
       frontmatter: {
         edges: [],
         ref_files: [],
+        ref_urls: [],
         summary: "A short prose summary that retrieval indexes separately.",
       },
       body: "Long-form body content.\n",
@@ -282,7 +286,7 @@ describe("embedConceptPageJob — summary embedding", () => {
   test("skips summary embedding when the page has no summary in frontmatter", async () => {
     await writePage(tmpWorkspace, {
       slug: "legacy-page",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Body only — no summary in frontmatter.\n",
     });
 
@@ -303,6 +307,7 @@ describe("embedConceptPageJob — summary embedding", () => {
       frontmatter: {
         edges: [],
         ref_files: [],
+        ref_urls: [],
         summary: "   ",
       },
       body: "Body content.\n",
@@ -324,14 +329,12 @@ describe("embedConceptPageJob — summary embedding", () => {
       frontmatter: {
         edges: [],
         ref_files: [],
+        ref_urls: [],
         summary: "First version of the summary.",
       },
       body: "Stable body that never changes.\n",
     });
-    await embedConceptPageJob(
-      makeJob({ slug: "cached-summary" }),
-      TEST_CONFIG,
-    );
+    await embedConceptPageJob(makeJob({ slug: "cached-summary" }), TEST_CONFIG);
     // Body + summary batched into a single backend call on first run.
     expect(embedWithBackendCalls).toHaveLength(1);
     expect(embedWithBackendCalls[0].inputs).toHaveLength(2);
@@ -344,14 +347,12 @@ describe("embedConceptPageJob — summary embedding", () => {
       frontmatter: {
         edges: [],
         ref_files: [],
+        ref_urls: [],
         summary: "Second version of the summary, different wording.",
       },
       body: "Stable body that never changes.\n",
     });
-    await embedConceptPageJob(
-      makeJob({ slug: "cached-summary" }),
-      TEST_CONFIG,
-    );
+    await embedConceptPageJob(makeJob({ slug: "cached-summary" }), TEST_CONFIG);
     // One additional backend call with only the summary text — body hit the cache.
     expect(embedWithBackendCalls).toHaveLength(2);
     expect(embedWithBackendCalls[1].inputs).toHaveLength(1);
@@ -362,7 +363,7 @@ describe("embedConceptPageJob — cache hit", () => {
   test("reuses the cached dense vector when content hash matches", async () => {
     await writePage(tmpWorkspace, {
       slug: "alice-prefers-vs-code",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Stable content.\n",
     });
 
@@ -387,7 +388,7 @@ describe("embedConceptPageJob — cache hit", () => {
   test("re-embeds when the body changes (content hash mismatch)", async () => {
     await writePage(tmpWorkspace, {
       slug: "alice-prefers-vs-code",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "First content.\n",
     });
     await embedConceptPageJob(
@@ -398,7 +399,7 @@ describe("embedConceptPageJob — cache hit", () => {
     // Rewrite with different body.
     await writePage(tmpWorkspace, {
       slug: "alice-prefers-vs-code",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Second content (different).\n",
     });
     await embedConceptPageJob(
@@ -438,6 +439,76 @@ describe("embedConceptPageJob — defensive", () => {
   });
 });
 
+describe("embedConceptPageJob — Qdrant breaker integration", () => {
+  test("half-open probe success closes the breaker so embed catch-up unthrottles", async () => {
+    // Trip the breaker by recording 5 consecutive Qdrant failures. Without
+    // this fix, `embed_concept_page` bypassed the breaker entirely — winning
+    // the half-open probe slot did not transition state back to closed and
+    // the embed lane stayed throttled at one job per tick indefinitely.
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+    expect(isQdrantBreakerOpen()).toBe(true);
+
+    // Advance time past the 30s cooldown so the next breaker call transitions
+    // open → half-open and allows the probe through.
+    const originalNow = Date.now;
+    Date.now = () => originalNow() + 60_000;
+    try {
+      await writePage(tmpWorkspace, {
+        slug: "probe-success",
+        frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+        body: "Probe body.\n",
+      });
+
+      await embedConceptPageJob(
+        makeJob({ slug: "probe-success" }),
+        TEST_CONFIG,
+      );
+    } finally {
+      Date.now = originalNow;
+    }
+
+    expect(upsertCalls).toHaveLength(1);
+    // Probe succeeded → breaker should now be closed (not open, not
+    // half-open), restoring full embed-lane concurrency.
+    expect(isQdrantBreakerOpen()).toBe(false);
+  });
+
+  test("half-open probe success on the delete path also closes the breaker", async () => {
+    // Same flow as above but exercising the missing-page branch — both v2
+    // Qdrant calls (`upsert` and `delete`) must close the breaker on success.
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+    expect(isQdrantBreakerOpen()).toBe(true);
+
+    const originalNow = Date.now;
+    Date.now = () => originalNow() + 60_000;
+    try {
+      // No `writePage` — the handler takes the delete branch.
+      await embedConceptPageJob(makeJob({ slug: "missing-slug" }), TEST_CONFIG);
+    } finally {
+      Date.now = originalNow;
+    }
+
+    expect(deleteCalls).toEqual(["missing-slug"]);
+    expect(isQdrantBreakerOpen()).toBe(false);
+  });
+});
+
 describe("enqueueEmbedConceptPageJob", () => {
   test("enqueues a pending embed_concept_page job with the slug payload", () => {
     const id = enqueueEmbedConceptPageJob({ slug: "alice-prefers-vs-code" });
@@ -453,7 +524,7 @@ describe("enqueueEmbedConceptPageJob", () => {
   test("round-trip: enqueued job dispatches through embedConceptPageJob", async () => {
     await writePage(tmpWorkspace, {
       slug: "round-trip-slug",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Round-trip body.\n",
     });
 

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

@@ -34,6 +34,7 @@ import {
 import { embeddingInputContentHash } from "../embedding-types.js";
 import { asString, blobToVector, vectorToBlob } from "../job-utils.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import { memoryEmbeddings } from "../schema.js";
 import { readPage } from "../v2/page-store.js";
 import {
@@ -81,7 +82,10 @@ export async function embedConceptPageJob(
   if (!page) {
     // Page was deleted out from under us — clean up the prior embedding so
     // retrieval no longer surfaces a slug whose disk-side prose is gone.
-    await deleteConceptPageEmbedding(slug);
+    // Route through the Qdrant breaker so success on the half-open probe
+    // slot transitions the breaker back to closed and unthrottles embed
+    // catch-up.
+    await withQdrantBreaker(() => deleteConceptPageEmbedding(slug));
     return;
   }
 
@@ -163,21 +167,54 @@ export async function embedConceptPageJob(
     slots.push("summary");
   }
 
-  let bodyDense: number[] | undefined = bodyCacheHit ? bodyCache!.dense : undefined;
+  let bodyDense: number[] | undefined = bodyCacheHit
+    ? bodyCache!.dense
+    : undefined;
   let summaryDense: number[] | undefined = summaryCacheHit
     ? summaryCache!.dense
     : undefined;
   let writeProvider = cacheProvider;
   let writeModel = cacheModel;
+  let bodyFresh = false;
+  let summaryFresh = false;
   if (toEmbed.length > 0) {
-    const embedded = await embedWithBackend(config, toEmbed);
+    let embedded = await embedWithBackend(config, toEmbed);
+    let appliedSlots = slots;
+    // Backend rotation between `getMemoryBackendStatus()` and
+    // `embedWithBackend()` would tag the cached half with the old
+    // provider/model and the fresh half with the new — writing both into
+    // one Qdrant point mixes embedding spaces. Re-embed every slot fresh
+    // when we detect the rotation so the point's named vectors share one
+    // identity.
+    const rotated =
+      (bodyCacheHit || summaryCacheHit) &&
+      (embedded.provider !== cacheProvider || embedded.model !== cacheModel);
+    if (rotated) {
+      const allTexts: Array<{ type: "text"; text: string }> = [
+        { type: "text", text },
+      ];
+      const allSlots: Slot[] = ["body"];
+      if (hasSummary) {
+        allTexts.push({ type: "text", text: summaryText });
+        allSlots.push("summary");
+      }
+      embedded = await embedWithBackend(config, allTexts);
+      appliedSlots = allSlots;
+      bodyDense = undefined;
+      summaryDense = undefined;
+    }
     writeProvider = embedded.provider;
     writeModel = embedded.model;
-    for (let i = 0; i < slots.length; i++) {
+    for (let i = 0; i < appliedSlots.length; i++) {
       const vector = embedded.vectors[i];
       if (!vector) continue;
-      if (slots[i] === "body") bodyDense = vector;
-      else summaryDense = vector;
+      if (appliedSlots[i] === "body") {
+        bodyDense = vector;
+        bodyFresh = true;
+      } else {
+        summaryDense = vector;
+        summaryFresh = true;
+      }
     }
   }
   // Body embedding is the ground truth — without it the page can't surface.
@@ -205,9 +242,12 @@ export async function embedConceptPageJob(
   const now = Date.now();
   // Persist freshly embedded vectors for cross-restart reuse. On cache hit
   // the existing row already has identical content + hash, so the write
-  // would be a no-op — skip it. Best-effort: write failure is not fatal,
-  // we still want the Qdrant upsert below to fire.
-  if (!bodyCacheHit) {
+  // would be a no-op — skip it. Backend rotation flips a cache hit into a
+  // fresh embed (see `rotated` above); the `*Fresh` flags capture that so
+  // the new vector overwrites the now-stale cache row under the new
+  // provider/model identity. Best-effort: write failure is not fatal, we
+  // still want the Qdrant upsert below to fire.
+  if (bodyFresh) {
     writeEmbeddingCache(db, {
       slug,
       cacheId: slug,
@@ -218,7 +258,7 @@ export async function embedConceptPageJob(
       now,
     });
   }
-  if (hasSummary && !summaryCacheHit && summaryDense && summaryContentHash) {
+  if (hasSummary && summaryFresh && summaryDense && summaryContentHash) {
     writeEmbeddingCache(db, {
       slug,
       cacheId: summaryCacheId,
@@ -244,16 +284,21 @@ export async function embedConceptPageJob(
     ? await applyCorrectionIfCalibrated(summaryDense, writeProvider, writeModel)
     : undefined;
 
-  await upsertConceptPageEmbedding({
-    slug,
-    dense: correctedDense,
-    sparse,
-    summary:
-      correctedSummaryDense && summarySparse
-        ? { dense: correctedSummaryDense, sparse: summarySparse }
-        : undefined,
-    updatedAt: now,
-  });
+  // Route through the Qdrant breaker so a probe-slot success transitions the
+  // breaker back to closed; without this wrapper the embed lane stays
+  // throttled at one job per tick indefinitely after a half-open success.
+  await withQdrantBreaker(() =>
+    upsertConceptPageEmbedding({
+      slug,
+      dense: correctedDense,
+      sparse,
+      summary:
+        correctedSummaryDense && summarySparse
+          ? { dense: correctedSummaryDense, sparse: summarySparse }
+          : undefined,
+      updatedAt: now,
+    }),
+  );
 }
 
 /** SQLite cache row shape returned by `readEmbeddingCache`. */

package/src/memory/jobs-store.ts

@@ -42,7 +42,8 @@ export type MemoryJobType =
   | "memory_v2_consolidate"
   | "memory_v2_migrate"
   | "memory_v2_reembed"
-  | "memory_v2_activation_recompute";
+  | "memory_v2_activation_recompute"
+  | "memory_retrospective";
 
 export const EMBED_JOB_TYPES: MemoryJobType[] = [
   "embed_segment",
@@ -52,6 +53,7 @@ export const EMBED_JOB_TYPES: MemoryJobType[] = [
   "embed_graph_node",
   "embed_pkb_file",
   "graph_trigger_embed",
+  "embed_concept_page",
 ];
 
 export const SLOW_LLM_JOB_TYPES: MemoryJobType[] = [
@@ -65,6 +67,7 @@ export const SLOW_LLM_JOB_TYPES: MemoryJobType[] = [
   "memory_v2_sweep",
   "memory_v2_consolidate",
   "memory_v2_migrate",
+  "memory_retrospective",
   "backfill",
   "graph_bootstrap",
 ];
@@ -251,6 +254,53 @@ export function upsertAutoAnalysisJob(
   }
 }
 
+/**
+ * Upsert a pending `memory_retrospective` job keyed by `conversationId`. All
+ * four retrospective triggers (interval, message_count, compaction,
+ * lifecycle) collapse into a single pending row per conversation — rapid
+ * triggers coalesce instead of double-firing. The `runAfter` parameter on a
+ * follow-up enqueue overwrites the existing row's `runAfter` so a sooner
+ * trigger can pull a later-scheduled job earlier; a later-scheduled trigger
+ * does NOT push a sooner-scheduled row further out (consumer takes the
+ * minimum). The trigger metadata is intentionally not retained — it is only
+ * useful for observability at enqueue time.
+ */
+export function upsertMemoryRetrospectiveJob(
+  payload: { conversationId: string },
+  runAfter: number = Date.now(),
+  dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
+    tx: infer T,
+  ) => unknown
+    ? T
+    : never,
+): void {
+  const db = dbOverride ?? getDb();
+  const existing = db
+    .select()
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "memory_retrospective"),
+        eq(memoryJobs.status, "pending"),
+        sql`json_extract(${memoryJobs.payload}, '$.conversationId') = ${payload.conversationId}`,
+      ),
+    )
+    .get();
+  if (existing) {
+    // Take the minimum of the existing and incoming runAfter so the earliest
+    // trigger always wins. A later trigger never pushes work further out.
+    const nextRunAfter = Math.min(existing.runAfter, runAfter);
+    if (nextRunAfter !== existing.runAfter) {
+      db.update(memoryJobs)
+        .set({ runAfter: nextRunAfter, updatedAt: Date.now() })
+        .where(eq(memoryJobs.id, existing.id))
+        .run();
+    }
+    return;
+  }
+  enqueueMemoryJob("memory_retrospective", payload, runAfter, dbOverride);
+}
+
 /**
  * Check whether a pending or running job of the given type already exists.
  * Used to prevent duplicate enqueues for long-running maintenance jobs.

package/src/memory/jobs-worker.ts

@@ -67,6 +67,8 @@ import {
   resetRunningJobsToPending,
   SLOW_LLM_JOB_TYPES,
 } from "./jobs-store.js";
+import { memoryRetrospectiveJob } from "./memory-retrospective-job.js";
+import { sweepOrphanMemoryRetrospectiveConversations } from "./memory-retrospective-startup-cleanup.js";
 import { QdrantCircuitOpenError } from "./qdrant-circuit-breaker.js";
 import {
   memoryV2ActivationRecomputeJob,
@@ -78,6 +80,25 @@ import { memoryV2SweepJob } from "./v2/sweep-job.js";
 
 const log = getLogger("memory-jobs-worker");
 
+/**
+ * V1 job types that read or write the v1 Qdrant collection via
+ * `getQdrantClient()`. When `memory.v2.enabled` is true, the v1 client is
+ * intentionally left uninitialized in `lifecycle.ts`, so these handlers would
+ * throw `BackendUnavailableError` and accumulate as a deferred backlog. Stale
+ * rows from indexer.ts and other unguarded enqueue sites must short-circuit
+ * here for the same reason `graph_extract` does below.
+ */
+const V1_QDRANT_JOB_TYPES = new Set<MemoryJobType>([
+  "embed_segment",
+  "embed_summary",
+  "embed_media",
+  "embed_attachment",
+  "embed_graph_node",
+  "embed_pkb_file",
+  "rebuild_index",
+  "delete_qdrant_vectors",
+]);
+
 /**
  * Job types whose handlers have been removed. Existing rows may still sit in
  * the database — the worker completes them silently instead of throwing.
@@ -111,6 +132,19 @@ export function startMemoryJobsWorker(): MemoryJobsWorker {
     log.info({ recovered }, "Recovered stale running memory jobs");
   }
 
+  // After running-job recovery (so legitimate in-flight retries aren't
+  // swept), clean up orphan memory-retrospective background conversations
+  // left behind by daemon crashes mid-job. Best-effort — never block worker
+  // startup on cleanup failures.
+  try {
+    sweepOrphanMemoryRetrospectiveConversations();
+  } catch (err) {
+    log.warn(
+      { err },
+      "Memory-retrospective startup cleanup failed; continuing worker startup",
+    );
+  }
+
   let stopped = false;
   let tickRunning = false;
   let timer: ReturnType<typeof setTimeout>;
@@ -124,16 +158,24 @@ export function startMemoryJobsWorker(): MemoryJobsWorker {
         enableScheduledCleanup: true,
       });
       if (processed > 0) {
-        currentIntervalMs = POLL_INTERVAL_MIN_MS;
+        // Per-tick claim budget equals the lane caps, so when a tick
+        // processed work the next tick must run immediately to drain any
+        // remaining backlog. Holding the 1.5s floor between ticks would cap
+        // sustained throughput at lane-cap jobs per 1.5s and starve large
+        // backlogs of short jobs.
+        currentIntervalMs = 0;
       } else {
         currentIntervalMs = Math.min(
-          currentIntervalMs * 2,
+          Math.max(currentIntervalMs * 2, POLL_INTERVAL_MIN_MS),
           POLL_INTERVAL_MAX_MS,
         );
       }
     } catch (err) {
       log.error({ err }, "Memory worker tick failed");
-      currentIntervalMs = Math.min(currentIntervalMs * 2, POLL_INTERVAL_MAX_MS);
+      currentIntervalMs = Math.min(
+        Math.max(currentIntervalMs * 2, POLL_INTERVAL_MIN_MS),
+        POLL_INTERVAL_MAX_MS,
+      );
     } finally {
       tickRunning = false;
     }
@@ -462,6 +504,9 @@ async function processJob(
   job: MemoryJob,
   config: AssistantConfig,
 ): Promise<void> {
+  if (config.memory.v2.enabled && V1_QDRANT_JOB_TYPES.has(job.type)) {
+    return;
+  }
   switch (job.type) {
     case "embed_segment":
       await embedSegmentJob(job, config);
@@ -479,6 +524,12 @@ async function processJob(
       pruneOldTraceEventsJob(job, config);
       return;
     case "build_conversation_summary":
+      // Stale rows enqueued before v2 was enabled must not consume the
+      // `conversationSummarization` LLM budget — v2 readers do not consume
+      // `memorySummaries`, mirroring the `graph_extract` gate below.
+      if (config.memory.v2.enabled) {
+        return;
+      }
       await buildConversationSummaryJob(job, config);
       return;
     case "backfill":
@@ -555,6 +606,9 @@ async function processJob(
     case "memory_v2_activation_recompute":
       await memoryV2ActivationRecomputeJob(job, config);
       return;
+    case "memory_retrospective":
+      await memoryRetrospectiveJob(job, config);
+      return;
 
     default: {
       const rawType = (job as { type: string }).type;