@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/plugins/defaults/memory/graph/in-context-tracker.ts

@@ -0,0 +1,109 @@
+// ---------------------------------------------------------------------------
+// Memory Graph — injection tracking
+//
+// `ConversationGraphMemory` keeps a tracker per conversation on every tier;
+// the v1 read engine (`../v1/graph/`) consumes it during retrieval.
+// ---------------------------------------------------------------------------
+
+import type { ScoredNode } from "./types.js";
+
+export interface InjectionLogEntry {
+  nodeId: string;
+  turn: number;
+}
+
+export interface InContextTrackerSnapshot {
+  inContext: string[];
+  log: InjectionLogEntry[];
+  currentTurn: number;
+}
+
+/**
+ * Tracks which memory graph nodes are currently in the LLM's context.
+ * Handles:
+ * - Deduplication: never re-inject a node already visible
+ * - Compaction eviction: when context compaction removes turns,
+ *   evict those nodes so they can be re-injected if relevant later
+ */
+export class InContextTracker {
+  private inContext = new Set<string>();
+  private log: InjectionLogEntry[] = [];
+  private currentTurn = 0;
+
+  /** Mark nodes as loaded into context. */
+  add(nodeIds: string[]): void {
+    for (const id of nodeIds) {
+      this.inContext.add(id);
+      this.log.push({ nodeId: id, turn: this.currentTurn });
+    }
+  }
+
+  /** Check if a node is already in context. */
+  isInContext(nodeId: string): boolean {
+    return this.inContext.has(nodeId);
+  }
+
+  /** Filter candidates to only those not already in context. */
+  filterNew(candidates: ScoredNode[]): ScoredNode[] {
+    return candidates.filter((c) => !this.inContext.has(c.node.id));
+  }
+
+  /** Advance the turn counter. Called before each retrieval step. */
+  advanceTurn(): void {
+    this.currentTurn++;
+  }
+
+  /**
+   * Evict nodes that were injected in compacted turns.
+   * Called when context compaction removes message history.
+   */
+  evictCompactedTurns(upToTurn: number): void {
+    const evicted: string[] = [];
+    this.log = this.log.filter((entry) => {
+      if (entry.turn <= upToTurn) {
+        evicted.push(entry.nodeId);
+        return false;
+      }
+      return true;
+    });
+
+    // Only evict if the node isn't also loaded in a later turn
+    const stillPresent = new Set(this.log.map((e) => e.nodeId));
+    for (const id of evicted) {
+      if (!stillPresent.has(id)) {
+        this.inContext.delete(id);
+      }
+    }
+  }
+
+  /** Get all node IDs currently in context. Useful for extraction. */
+  getActiveNodeIds(): string[] {
+    return [...this.inContext];
+  }
+
+  /** Get the injection log. Useful for debugging. */
+  getLog(): InjectionLogEntry[] {
+    return [...this.log];
+  }
+
+  /** Current turn number. */
+  getTurn(): number {
+    return this.currentTurn;
+  }
+
+  /** Serialize tracker state for persistence across eviction. */
+  toJSON(): InContextTrackerSnapshot {
+    return {
+      inContext: [...this.inContext],
+      log: [...this.log],
+      currentTurn: this.currentTurn,
+    };
+  }
+
+  /** Restore tracker state from a persisted snapshot. Replaces current state. */
+  restoreFrom(snapshot: InContextTrackerSnapshot): void {
+    this.inContext = new Set(snapshot.inContext);
+    this.log = [...snapshot.log];
+    this.currentTurn = snapshot.currentTurn;
+  }
+}

package/src/plugins/defaults/memory/graph/store.ts

@@ -54,6 +54,7 @@ function memoryDb(): DrizzleDb {
 // Row ↔ Domain conversion helpers
 // ---------------------------------------------------------------------------
 
+/** Project a `memory_graph_nodes` row onto its domain node. */
 function rowToNode(row: typeof memoryGraphNodes.$inferSelect): MemoryNode {
   return {
     id: row.id,

package/src/plugins/defaults/memory/graph/tool-handlers.test.ts

@@ -44,7 +44,7 @@ mock.module("../../../../util/platform.js", () => ({
   getWorkspaceDir: () => "/tmp/test-workspace",
 }));
 
-mock.module("../jobs/embed-pkb-file.js", () => ({
+mock.module("../v1/jobs/embed-pkb-file.js", () => ({
   enqueuePkbIndexJob: () => {},
 }));
 

package/src/plugins/defaults/memory/graph/tool-handlers.ts

@@ -9,7 +9,10 @@
 import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 
-import { usesConceptPageMemory } from "../../../../config/memory-v3-gate.js";
+import {
+  isMemoryEnabled,
+  usesConceptPageMemory,
+} from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { enqueueMemoryJob } from "../../../../persistence/jobs-store.js";
 import { getWorkspaceDir } from "../paths.js";
@@ -71,7 +74,7 @@ export function handleRemember(
   if (facts.length === 0) {
     return { success: false, message: "content is required" };
   }
-  if (config.memory.enabled === false) {
+  if (!isMemoryEnabled(config)) {
     return { success: false, message: "Memory is disabled." };
   }
 

package/src/plugins/defaults/memory/graph-topology/__tests__/build-memory-graph.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 
-import type { PageIndexEntry } from "../../v3/substrate/page-index.js";
+import type { PageIndexEntry } from "../../substrate/page-index.js";
 import type { Slug } from "../../v3/types.js";
 import { assembleMemoryGraph } from "../build-memory-graph.js";
 

package/src/plugins/defaults/memory/graph-topology/build-memory-graph.ts

@@ -15,20 +15,17 @@
  * a call into `backend.getGraph()` — the contract and its route do not change.
  */
 
-import { isMemoryGraphSupported } from "../../../../config/memory-v3-gate.js";
+import { isV3TierActive } from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { getWorkspaceDir } from "../paths.js";
+import { getPageIndex, type PageIndexEntry } from "../substrate/page-index.js";
+import { readPage, renderPageContent } from "../substrate/page-store.js";
+import { isSkillSlug } from "../substrate/skill-store.js";
 import {
   isCapabilitySlug,
   renderCapabilityContent,
 } from "../v3/capabilities.js";
 import { buildEdgeGraph } from "../v3/edge.js";
-import {
-  getPageIndex,
-  type PageIndexEntry,
-} from "../v3/substrate/page-index.js";
-import { readPage, renderPageContent } from "../v3/substrate/page-store.js";
-import { isSkillSlug } from "../v3/substrate/skill-store.js";
 import type { Slug } from "../v3/types.js";
 import {
   buildPendingGraph,
@@ -235,7 +232,7 @@ export function assembleMemoryGraph(input: AssembleMemoryGraphInput): {
 export async function getMemoryGraph(
   config: AssistantConfig,
 ): Promise<MemoryGraph> {
-  if (!isMemoryGraphSupported(config)) {
+  if (!isV3TierActive(config)) {
     return { backend: null, supported: false, nodes: [], edges: [] };
   }
 
@@ -299,7 +296,7 @@ export async function getMemoryGraphNode(
   config: AssistantConfig,
   id: string,
 ): Promise<MemoryGraphNodeDetail> {
-  if (!isMemoryGraphSupported(config) || !id) {
+  if (!isV3TierActive(config) || !id) {
     return { found: false };
   }
   // Pending buffer entries: resolve the id back to its buffer fact. `found:

package/src/plugins/defaults/memory/hooks/__tests__/user-prompt-submit.test.ts

@@ -1,37 +1,51 @@
 import { describe, expect, test } from "bun:test";
 
-import { shouldRunV2Retrieval } from "../user-prompt-submit.js";
+import { shouldRunLegacyMemoryRetrieval } from "../user-prompt-submit.js";
 
 /**
- * v2 graph-memory retrieval is the deprecated path. It is gated off under
- * `memory-v3-live` — v3 owns the injected-memory layer and runtime assembly
- * strips any v2 `<memory>` block, so running v2's per-turn retrieval (embedding
- * + hybrid search + the `memoryRetrieval` LLM router) would only have its
- * result discarded. It is also skipped for untrusted actors. The
- * conversation/abort-signal presence checks stay inline at the call site (for
- * type narrowing) and are deliberately NOT part of this policy decision.
+ * Legacy (v1/v2) graph-memory retrieval is the deprecated path — the gate
+ * covers both pre-v3 engines, which `prepareMemory` dispatches between
+ * internally. It is gated off under `memory-v3-live` — v3 owns the
+ * injected-memory layer and runtime assembly strips any legacy `<memory>`
+ * block, so running the legacy per-turn retrieval (embedding + hybrid search
+ * + the `memoryRetrieval` LLM router) would only have its result discarded.
+ * It is also skipped for untrusted actors. The conversation/abort-signal
+ * presence checks stay inline at the call site (for type narrowing) and are
+ * deliberately NOT part of this policy decision.
  */
-describe("shouldRunV2Retrieval", () => {
-  test("runs for a trusted actor when memory-v3-live is off (v2/shadow path)", () => {
+describe("shouldRunLegacyMemoryRetrieval", () => {
+  test("runs for a trusted actor when memory-v3-live is off (v1/v2 path)", () => {
     expect(
-      shouldRunV2Retrieval({ isTrustedActor: true, memoryV3Live: false }),
+      shouldRunLegacyMemoryRetrieval({
+        isTrustedActor: true,
+        memoryV3Live: false,
+      }),
     ).toBe(true);
   });
 
   test("is skipped under memory-v3-live even for a trusted actor", () => {
-    // The cutover: v3 owns memory, so v2 retrieval (and its LLM router) must
-    // not fire — this is the per-turn cost the gate removes.
+    // The cutover: v3 owns memory, so legacy retrieval (and its LLM router)
+    // must not fire — this is the per-turn cost the gate removes.
     expect(
-      shouldRunV2Retrieval({ isTrustedActor: true, memoryV3Live: true }),
+      shouldRunLegacyMemoryRetrieval({
+        isTrustedActor: true,
+        memoryV3Live: true,
+      }),
     ).toBe(false);
   });
 
   test("is skipped for an untrusted actor regardless of the flag", () => {
     expect(
-      shouldRunV2Retrieval({ isTrustedActor: false, memoryV3Live: false }),
+      shouldRunLegacyMemoryRetrieval({
+        isTrustedActor: false,
+        memoryV3Live: false,
+      }),
     ).toBe(false);
     expect(
-      shouldRunV2Retrieval({ isTrustedActor: false, memoryV3Live: true }),
+      shouldRunLegacyMemoryRetrieval({
+        isTrustedActor: false,
+        memoryV3Live: true,
+      }),
     ).toBe(false);
   });
 });

package/src/plugins/defaults/memory/hooks/user-prompt-submit.ts

@@ -51,15 +51,18 @@ import { recordMemoryRecallLog } from "../memory-recall-log-store.js";
 import { MEMORY_V3_INJECTED_BLOCK_METADATA_KEY } from "../v3/ever-injected-store.js";
 
 /**
- * Whether to run v2 graph-memory retrieval this turn. v2 retrieval is the
+ * Whether to run legacy graph-memory retrieval this turn. It gates BOTH
+ * pre-v3 read paths — `prepareMemory` dispatches internally between v1
+ * retrieval and the v2 activation engine. The legacy retrieval is the
  * deprecated path: under `memory-v3-live`, v3 is the injected-memory source and
- * runtime assembly strips any v2 `<memory>` block, so running v2's retrieval
- * (embedding + hybrid search + the `memoryRetrieval` LLM router) only to
- * discard the result is pure per-turn waste. Untrusted actors never run it
- * either. The caller additionally requires the live conversation and its abort
- * signal to be present (kept inline at the call site for type narrowing).
+ * runtime assembly strips any legacy `<memory>` block, so running the legacy
+ * retrieval (embedding + hybrid search + the `memoryRetrieval` LLM router)
+ * only to discard the result is pure per-turn waste. Untrusted actors never
+ * run it either. The caller additionally requires the live conversation and
+ * its abort signal to be present (kept inline at the call site for type
+ * narrowing).
  */
-export function shouldRunV2Retrieval(params: {
+export function shouldRunLegacyMemoryRetrieval(params: {
   isTrustedActor: boolean;
   memoryV3Live: boolean;
 }): boolean {
@@ -281,16 +284,17 @@ const userPromptSubmitMemoryRetrieval: HookFunction<
     conversation?.trustContext,
   );
 
-  // v2 graph retrieval is the deprecated path: `shouldRunV2Retrieval` skips it
-  // under memory-v3-live (v3 owns the `<memory>` layer and assembly strips any
-  // v2 block) and for untrusted actors. The `conversation && abortSignal`
-  // presence checks stay inline so the block below narrows. NOTE: this removes
-  // the v2 fallback — under v3-live, a v3 empty/failed selection yields no NEW
-  // injected memory that turn (prior turns' frozen v3 cards still ride history).
+  // Legacy (v1/v2) graph retrieval is the deprecated path:
+  // `shouldRunLegacyMemoryRetrieval` skips it under memory-v3-live (v3 owns
+  // the `<memory>` layer and assembly strips any legacy block) and for
+  // untrusted actors. The `conversation && abortSignal` presence checks stay
+  // inline so the block below narrows. NOTE: under v3-live there is no legacy
+  // fallback — a v3 empty/failed selection yields no NEW injected memory that
+  // turn (prior turns' frozen v3 cards still ride history).
   const memoryV3Live = isMemoryV3Live(config);
   let v2BlockPersisted = false;
   if (
-    shouldRunV2Retrieval({ isTrustedActor, memoryV3Live }) &&
+    shouldRunLegacyMemoryRetrieval({ isTrustedActor, memoryV3Live }) &&
     conversation &&
     abortSignal
   ) {

package/src/plugins/defaults/memory/indexer.ts

@@ -7,7 +7,10 @@ import { createHash } from "crypto";
 import { eq } from "drizzle-orm";
 
 import { getConfig } from "../../../config/loader.js";
-import { usesConceptPageMemory } from "../../../config/memory-v3-gate.js";
+import {
+  isMemoryV1Active,
+  usesConceptPageMemory,
+} from "../../../config/memory-v3-gate.js";
 import type { MemoryConfig } from "../../../config/types.js";
 import {
   getMemoryCheckpoint,
@@ -27,6 +30,9 @@ import { isMemoryRetrospectiveConversation } from "./memory-retrospective-enqueu
 import { maybeEnqueueRetrospective } from "./memory-retrospective-trigger-check.js";
 import { extractMediaBlockMeta } from "./message-media.js";
 import { segmentText } from "./segmenter.js";
+// SUBSTRATE (v2+v3) — the only tier-owned import here; the v1 triggers reach
+// their work through job-type strings alone.
+import { resolveSubstrateTuning } from "./substrate/tuning.js";
 
 const log = getLogger("memory-indexer");
 
@@ -206,98 +212,55 @@ export async function indexMessageNow(
         ? 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.
-    if (!isAutoAnalysisSource) {
-      // ── Graph extraction (v1) ───────────────────────────────────────
-      // Suppressed when concept-page memory is active — it reads memory
-      // from buffer.md and concept pages, so the v1 graph would be stale
-      // data nobody consumes. Pending-count tracking is suppressed too;
-      // otherwise a later switch back to v1 would fire an immediate batch
-      // from counts accumulated in the meantime.
-      let extractRunAfter: number;
-      if (conceptConfig == null) {
-        const graphPendingKey = `graph_extract:${input.conversationId}:pending_count`;
-        const graphCurrentVal = getMemoryCheckpoint(graphPendingKey);
-        const graphPendingCount =
-          (graphCurrentVal ? parseInt(graphCurrentVal, 10) : 0) + 1;
-        setMemoryCheckpoint(graphPendingKey, String(graphPendingCount));
-
-        const graphBatchFired = graphPendingCount >= batchSize;
-        if (graphBatchFired) {
-          setMemoryCheckpoint(graphPendingKey, "0");
-        }
-
-        // Single pending `graph_extract` row per conversation. If the
-        // batch threshold just fired, pull `runAfter` back to now so the
-        // job runs immediately; otherwise debounce by the idle timeout.
-        // Routing both paths through `upsertDebouncedJob` ensures the
-        // row's `runAfter` reflects whichever trigger ran last, so a
-        // batch crossing always takes effect immediately.
-        extractRunAfter = graphBatchFired
-          ? Date.now()
-          : Date.now() + idleTimeoutMs;
-        if (isMemoryEnabled()) {
-          upsertDebouncedJob(
-            "graph_extract",
-            {
-              conversationId: input.conversationId,
-            },
-            extractRunAfter,
-          );
-        }
-      } else {
-        extractRunAfter = Date.now() + idleTimeoutMs;
-      }
-
-      // Memory sweep: when concept-page memory is on AND `sweep_enabled` is
-      // set, every extraction trigger also enqueues a sweep. The sweep
-      // itself reads recent messages globally, so the `conversationId` here
-      // is just the dedup key — one pending row per active conversation.
-      // `sweep_enabled` defaults to false because `remember()` is the
-      // primary capture path; the sweep is opt-in.
-      if (conceptConfig != null && conceptConfig.memory.v2.sweep_enabled) {
-        upsertDebouncedJob(
-          "memory_v2_sweep",
-          { conversationId: input.conversationId },
-          extractRunAfter,
+    // Per-tier trigger dispatch, three-way. Memory off enqueues nothing: no
+    // tier is live, and the pending counts the v1 arm would accumulate
+    // meanwhile fire an immediate batch on a later switch back to v1. The v1
+    // extraction/summarization triggers run when the legacy graph engine is
+    // the live tier, and the substrate sweep trigger runs under a concept-page
+    // consumer. `isAutoAnalysisSource` is the recursion guard threaded into
+    // both live arms: 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.
+    if (conceptConfig == null) {
+      // A null `conceptConfig` covers two states — v1 live and memory off — so
+      // the v1 arm asks the named predicate rather than assuming v1. A failed
+      // config load leaves `triggerConfig` null and fails open to v1: a
+      // transient read error must not silently drop indexing.
+      if (triggerConfig == null || isMemoryV1Active(triggerConfig)) {
+        // V1 — delete with v1. Dropping only the banner-marked function body
+        // below would leave this call dangling: collapse the branch to the
+        // substrate arm.
+        enqueueV1IndexTriggers(
+          input.conversationId,
+          isAutoAnalysisSource,
+          batchSize,
+          idleTimeoutMs,
         );
       }
-
-      // ── Memory retrospective triggers ─────────────────────────────────
-      // 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);
-      }
+    } else {
+      enqueueSubstrateIndexTriggers(
+        input.conversationId,
+        conceptConfig,
+        isAutoAnalysisSource,
+        idleTimeoutMs,
+      );
     }
 
-    // ── Conversation summarization (v1) ───────────────────────────────
-    // Summaries feed the v1 graph retrieval pipeline (fetchRecentSummaries,
-    // semantic search). Suppressed when concept-page memory is active — its
-    // readers (concept pages, activation pipeline, v3 lanes) do not consume
-    // `memorySummaries`, so the summarization LLM call would produce rows
-    // nothing reads. Stale v1 rows 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 (conceptConfig == null && isMemoryEnabled()) {
-      upsertDebouncedJob(
-        "build_conversation_summary",
-        { conversationId: input.conversationId },
-        Date.now() + idleTimeoutMs,
-      );
+    // ── Memory retrospective triggers (all tiers) ─────────────────────
+    // 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 guards skip auto-analysis
+    // conversations and the memory-retrospective background conversation
+    // itself.
+    if (
+      !isAutoAnalysisSource &&
+      triggerConfig != null &&
+      !isMemoryRetrospectiveConversation(input.conversationId)
+    ) {
+      maybeEnqueueRetrospective(input.conversationId, triggerConfig);
     }
   }
 
@@ -354,6 +317,100 @@ export async function indexMessageNow(
   };
 }
 
+// ── V1 index-time triggers — delete with v1 ───────────────────────
+
+/**
+ * V1 extraction/summarization triggers; run only when the legacy graph engine
+ * is the live tier (`isMemoryV1Active` — under the substrate, and with memory
+ * off, the v1 graph and `memorySummaries` would be stale data nobody consumes,
+ * and pending-count tracking is suppressed too so a later switch back to v1
+ * does not fire an immediate batch from counts accumulated in the meantime).
+ *
+ * Tracks the per-conversation pending-message count to debounce the
+ * `graph_extract` batch job, and debounces the conversation-summary build
+ * that feeds the v1 graph retrieval pipeline (fetchRecentSummaries, semantic
+ * search).
+ *
+ * `isAutoAnalysisSource` suppresses only the graph-extraction arm — summaries
+ * compress the whole conversation and build for auto-analysis conversations
+ * too.
+ */
+function enqueueV1IndexTriggers(
+  conversationId: string,
+  isAutoAnalysisSource: boolean,
+  batchSize: number,
+  idleTimeoutMs: number,
+): void {
+  if (!isAutoAnalysisSource) {
+    const graphPendingKey = `graph_extract:${conversationId}:pending_count`;
+    const graphCurrentVal = getMemoryCheckpoint(graphPendingKey);
+    const graphPendingCount =
+      (graphCurrentVal ? parseInt(graphCurrentVal, 10) : 0) + 1;
+    setMemoryCheckpoint(graphPendingKey, String(graphPendingCount));
+
+    const graphBatchFired = graphPendingCount >= batchSize;
+    if (graphBatchFired) {
+      setMemoryCheckpoint(graphPendingKey, "0");
+    }
+
+    // Single pending `graph_extract` row per conversation. If the
+    // batch threshold just fired, pull `runAfter` back to now so the
+    // job runs immediately; otherwise debounce by the idle timeout.
+    // Routing both paths through `upsertDebouncedJob` ensures the
+    // row's `runAfter` reflects whichever trigger ran last, so a
+    // batch crossing always takes effect immediately.
+    const extractRunAfter = graphBatchFired
+      ? Date.now()
+      : Date.now() + idleTimeoutMs;
+    if (isMemoryEnabled()) {
+      upsertDebouncedJob("graph_extract", { conversationId }, extractRunAfter);
+    }
+  }
+
+  // Conversation summarization. Stale v1 rows 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 (isMemoryEnabled()) {
+    upsertDebouncedJob(
+      "build_conversation_summary",
+      { conversationId },
+      Date.now() + idleTimeoutMs,
+    );
+  }
+}
+
+// ── SUBSTRATE (v2+v3) index-time triggers ─────────────────────────
+
+/**
+ * Substrate index-time trigger; runs while concept-page memory is active.
+ * When `sweep_enabled` is set, every extraction trigger debounces a
+ * `memory_v2_sweep`. The sweep itself reads recent messages globally, so the
+ * `conversationId` here is just the dedup key — one pending row per active
+ * conversation. `sweep_enabled` defaults to false because `remember()` is
+ * the primary capture path; the sweep is opt-in.
+ *
+ * `isAutoAnalysisSource` is the same recursion guard the v1 arm applies: the
+ * analysis agent writes memory directly, so its output is never swept.
+ */
+function enqueueSubstrateIndexTriggers(
+  conversationId: string,
+  conceptConfig: ReturnType<typeof getConfig>,
+  isAutoAnalysisSource: boolean,
+  idleTimeoutMs: number,
+): void {
+  if (isAutoAnalysisSource) {
+    return;
+  }
+  if (resolveSubstrateTuning(conceptConfig.memory).sweep_enabled) {
+    upsertDebouncedJob(
+      "memory_v2_sweep",
+      { conversationId },
+      Date.now() + idleTimeoutMs,
+    );
+  }
+}
+
 export function enqueueBackfillJob(force = false): string {
   if (!isMemoryEnabled()) {
     return "";