@vellumai/assistant 0.7.2 → 0.7.3

package/src/memory/graph/retriever.ts

@@ -351,7 +351,7 @@ async function dedupCrossCategory(
 // Context load — conversation start
 // ---------------------------------------------------------------------------
 
-export interface ContextLoadOpts {
+interface ContextLoadOpts {
   /** Scope for memory isolation. */
   scopeId: string;
   /** Recent conversation summaries (used as retrieval queries). */
@@ -373,7 +373,7 @@ export interface ContextLoadOpts {
   userQuery?: string;
 }
 
-export interface ContextLoadResult {
+interface ContextLoadResult {
   nodes: ScoredNode[];
   serendipityNodes: ScoredNode[];
   triggeredNodes: TriggeredResult[];
@@ -525,7 +525,6 @@ export async function loadContextMemory(
       const results = await searchGraphNodes(
         queryVector,
         maxNodes * 3,
-        [opts.scopeId],
         sparseVector,
       );
       for (const r of results) {
@@ -548,7 +547,6 @@ export async function loadContextMemory(
       const results = await searchGraphNodes(
         userQueryVector,
         maxNodes * 3,
-        [opts.scopeId],
         undefined,
       );
       for (const r of results) {
@@ -873,7 +871,7 @@ export async function loadContextMemory(
 // Per-turn retrieval — mid-conversation injection
 // ---------------------------------------------------------------------------
 
-export interface TurnRetrievalOpts {
+interface TurnRetrievalOpts {
   /** The assistant's last message content. */
   assistantLastMessage: string;
   /** The user's last message content. */
@@ -886,7 +884,7 @@ export interface TurnRetrievalOpts {
   signal?: AbortSignal;
 }
 
-export interface TurnRetrievalResult {
+interface TurnRetrievalResult {
   /** New nodes to inject (not already in context). */
   nodes: ScoredNode[];
   /** Serendipity picks included in nodes. */
@@ -1007,9 +1005,7 @@ export async function retrieveForTurn(
           }
           const imgVector = imgResult.vectors[0];
           if (imgVector) {
-            const imgResults = await searchGraphNodes(imgVector, 40, [
-              opts.scopeId,
-            ]);
+            const imgResults = await searchGraphNodes(imgVector, 40);
             for (const r of imgResults) {
               const current = allCandidateIds.get(r.nodeId) ?? 0;
               allCandidateIds.set(r.nodeId, Math.max(current, r.score));
@@ -1097,7 +1093,7 @@ export async function retrieveForTurn(
       queryEmbeddings = embedResults.vectors;
 
       const searchPromises = queryEmbeddings.map((vec) =>
-        searchGraphNodes(vec, 40, [opts.scopeId]),
+        searchGraphNodes(vec, 40),
       );
       const searchResults = await Promise.all(searchPromises);
 

package/src/memory/indexer.ts

@@ -9,6 +9,7 @@ import { getLogger } from "../util/logger.js";
 import { enqueueAutoAnalysisIfEnabled } from "./auto-analysis-enqueue.js";
 import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
+import { isMemoryV2ReadActive } from "./context-search/sources/memory-v2.js";
 import { getDb } from "./db-connection.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
 import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
@@ -175,39 +176,9 @@ export async function indexMessageNow(
     // Summaries still run — they feed the graph retrieval pipeline and
     // are not recursion-prone.
     if (!isAutoAnalysisSource) {
-      // ── Graph extraction ────────────────────────────────────────────
-      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.
-      const extractRunAfter = graphBatchFired
-        ? Date.now()
-        : Date.now() + idleTimeoutMs;
-      upsertDebouncedJob(
-        "graph_extract",
-        {
-          conversationId: input.conversationId,
-          scopeId: input.scopeId ?? "default",
-        },
-        extractRunAfter,
-      );
-
-      // Reading config here is best-effort: feature-gated triggers below
-      // (memory v2 sweep, auto-analyze batch) skip when it fails — the
-      // idle-debounced enqueues above are unaffected.
+      // 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();
@@ -218,20 +189,58 @@ export async function indexMessageNow(
         );
       }
 
-      // Memory v2 sweep mirrors graph_extract's debounce: when the v2
-      // flag + config are 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. All three gates
-      // (feature flag, v2 master toggle, sweep_enabled) must be true.
+      const v2Config =
+        triggerConfig != null && isMemoryV2ReadActive(triggerConfig)
+          ? 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
+      // consumes. Pending-count tracking is suppressed too; otherwise a
+      // flag flip back to v1 would fire an immediate batch from counts
+      // accumulated during the v2 window.
+      let extractRunAfter: number;
+      if (v2Config == 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;
+        upsertDebouncedJob(
+          "graph_extract",
+          {
+            conversationId: input.conversationId,
+            scopeId: input.scopeId ?? "default",
+          },
+          extractRunAfter,
+        );
+      } else {
+        extractRunAfter = Date.now() + idleTimeoutMs;
+      }
+
+      // Memory v2 sweep: when v2 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 (
-        triggerConfig != null &&
-        isAssistantFeatureFlagEnabled("memory-v2-enabled", triggerConfig) &&
-        triggerConfig.memory.v2.enabled &&
-        triggerConfig.memory.v2.sweep_enabled
-      ) {
+      if (v2Config != null && v2Config.memory.v2.sweep_enabled) {
         upsertDebouncedJob(
           "memory_v2_sweep",
           { conversationId: input.conversationId },

package/src/memory/job-handlers/backfill.ts

@@ -7,10 +7,7 @@ import {
   resetMessageCursorCheckpoint,
   writeMessageCursorCheckpoint,
 } from "../checkpoints.js";
-import {
-  getConversationMemoryScopeId,
-  messageMetadataSchema,
-} from "../conversation-crud.js";
+import { messageMetadataSchema } from "../conversation-crud.js";
 import { getDb } from "../db-connection.js";
 import { indexMessageNow } from "../indexer.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
@@ -72,13 +69,7 @@ export async function backfillJob(
     .all();
 
   if (batch.length > 0) {
-    const scopeCache = new Map<string, string>();
     for (const message of batch) {
-      let scopeId = scopeCache.get(message.conversationId);
-      if (scopeId === undefined) {
-        scopeId = getConversationMemoryScopeId(message.conversationId);
-        scopeCache.set(message.conversationId, scopeId);
-      }
       const { provenanceTrustClass, automated } = parseMessageMetadata(
         message.metadata ?? null,
       );
@@ -89,7 +80,7 @@ export async function backfillJob(
           role: message.role,
           content: message.content,
           createdAt: message.createdAt,
-          scopeId,
+          scopeId: "default",
           provenanceTrustClass,
           automated,
         },

package/src/memory/job-handlers/cleanup.ts

@@ -54,6 +54,49 @@ export function pruneOldLlmRequestLogsJob(
   );
 }
 
+/**
+ * Delete trace events older than the configured retention period.
+ * Processes in batches to avoid long DB locks and excessive WAL growth.
+ * Re-enqueues itself if more rows remain.
+ */
+export function pruneOldTraceEventsJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): void {
+  const rawRetention = job.payload.retentionDays;
+  const retentionDays =
+    typeof rawRetention === "number" &&
+    Number.isFinite(rawRetention) &&
+    rawRetention >= 0
+      ? rawRetention
+      : config.memory.cleanup.traceEventRetentionDays;
+
+  // 0 means disabled
+  if (retentionDays === 0) return;
+
+  const cutoffMs = Date.now() - retentionDays * 86_400_000;
+
+  rawRun(
+    `DELETE FROM trace_events WHERE rowid IN (SELECT rowid FROM trace_events WHERE created_at < ? LIMIT ?)`,
+    cutoffMs,
+    PRUNE_LOG_BATCH_LIMIT,
+  );
+  const deleted = rawChanges();
+
+  if (deleted >= PRUNE_LOG_BATCH_LIMIT) {
+    enqueueMemoryJob("prune_old_trace_events", { retentionDays });
+  }
+
+  log.info(
+    {
+      deleted,
+      retentionDays,
+      cutoffMs,
+    },
+    "Pruned old trace events",
+  );
+}
+
 /**
  * Delete conversations that have had no activity (updatedAt) for longer than
  * the configured retention period. Processes in batches so a single job doesn't

package/src/memory/job-handlers/embedding.ts

@@ -3,7 +3,6 @@ import { readFile } from "node:fs/promises";
 import { eq } from "drizzle-orm";
 
 import type { AssistantConfig } from "../../config/types.js";
-import { getConversationMemoryScopeId } from "../conversation-crud.js";
 import { getDb } from "../db-connection.js";
 import type { EmbeddingInput } from "../embedding-types.js";
 import { asString, embedAndUpsert } from "../job-utils.js";
@@ -18,7 +17,7 @@ import {
 
 export async function embedSegmentJob(
   job: MemoryJob,
-  config: AssistantConfig
+  config: AssistantConfig,
 ): Promise<void> {
   const segmentId = asString(job.payload.segmentId);
   if (!segmentId) return;
@@ -39,7 +38,7 @@ export async function embedSegmentJob(
 
 export async function embedSummaryJob(
   job: MemoryJob,
-  config: AssistantConfig
+  config: AssistantConfig,
 ): Promise<void> {
   const summaryId = asString(job.payload.summaryId);
   if (!summaryId) return;
@@ -60,13 +59,13 @@ export async function embedSummaryJob(
       created_at: summary.startAt,
       last_seen_at: summary.endAt,
       memory_scope_id: summary.scopeId,
-    }
+    },
   );
 }
 
 export async function embedMediaJob(
   job: MemoryJob,
-  config: AssistantConfig
+  config: AssistantConfig,
 ): Promise<void> {
   const assetId = asString(job.payload.assetId);
   if (!assetId) return;
@@ -99,7 +98,7 @@ export async function embedMediaJob(
 
 export async function embedAttachmentJob(
   job: MemoryJob,
-  config: AssistantConfig
+  config: AssistantConfig,
 ): Promise<void> {
   const messageId = asString(job.payload.messageId);
   const blockIndex = job.payload.blockIndex as number;
@@ -125,11 +124,10 @@ export async function embedAttachmentJob(
 
   // Use messageId + blockIndex as targetId for uniqueness
   const targetId = `${messageId}:${blockIndex}`;
-  const memoryScopeId = getConversationMemoryScopeId(message.conversationId);
   await embedAndUpsert(config, "media", targetId, input, {
     created_at: message.createdAt,
     message_id: messageId,
     conversation_id: message.conversationId,
-    memory_scope_id: memoryScopeId,
+    memory_scope_id: "default",
   });
 }

package/src/memory/job-handlers/summarization.ts

@@ -10,7 +10,6 @@ import {
   userMessage,
 } from "../../providers/provider-send-message.js";
 import { getLogger } from "../../util/logger.js";
-import { getConversationMemoryScopeId } from "../conversation-crud.js";
 import { getDb } from "../db-connection.js";
 import { asString, truncate } from "../job-utils.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
@@ -91,10 +90,6 @@ export async function buildConversationSummaryJob(
     "conversation",
   );
 
-  // Inherit the conversation's memory scope so summaries stay aligned with
-  // the retrieval scope used by the source conversation.
-  const scopeId = getConversationMemoryScopeId(conversationId);
-
   const now = Date.now();
   const summaryId = existing?.id ?? uuid();
   const nextVersion = (existing?.version ?? 0) + 1;
@@ -108,7 +103,7 @@ export async function buildConversationSummaryJob(
       id: summaryId,
       scope: "conversation",
       scopeKey: conversationId,
-      scopeId,
+      scopeId: "default",
       summary: summaryText,
       tokenEstimate: estimateTextTokens(summaryText),
       version: nextVersion,
@@ -123,7 +118,7 @@ export async function buildConversationSummaryJob(
         summary: summaryText,
         tokenEstimate: estimateTextTokens(summaryText),
         version: sql`${memorySummaries.version} + 1`,
-        scopeId,
+        scopeId: "default",
         startAt: earliestCovered,
         endAt: latestCovered,
         updatedAt: now,

package/src/memory/jobs-store.ts

@@ -18,6 +18,7 @@ export type MemoryJobType =
   | "embed_summary"
   | "prune_old_conversations"
   | "prune_old_llm_request_logs"
+  | "prune_old_trace_events"
   | "build_conversation_summary"
   | "conversation_analyze"
   | "backfill"
@@ -366,6 +367,53 @@ export function enqueuePruneOldConversationsJob(
   return enqueueMemoryJob("prune_old_conversations", payload);
 }
 
+export function enqueuePruneOldTraceEventsJob(retentionDays?: number): string {
+  const db = getDb();
+  const existing = db
+    .select()
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "prune_old_trace_events"),
+        inArray(memoryJobs.status, ["pending", "running"]),
+      ),
+    )
+    .orderBy(asc(memoryJobs.createdAt))
+    .get();
+  if (existing) {
+    if (
+      existing.status === "pending" &&
+      typeof retentionDays === "number" &&
+      Number.isFinite(retentionDays) &&
+      retentionDays >= 0
+    ) {
+      let payload: Record<string, unknown> = {};
+      try {
+        payload = JSON.parse(existing.payload) as Record<string, unknown>;
+      } catch {
+        payload = {};
+      }
+      if (payload.retentionDays !== retentionDays) {
+        db.update(memoryJobs)
+          .set({
+            payload: JSON.stringify({ ...payload, retentionDays }),
+            updatedAt: Date.now(),
+          })
+          .where(eq(memoryJobs.id, existing.id))
+          .run();
+      }
+    }
+    return existing.id;
+  }
+  const payload =
+    typeof retentionDays === "number" &&
+    Number.isFinite(retentionDays) &&
+    retentionDays >= 0
+      ? { retentionDays }
+      : {};
+  return enqueueMemoryJob("prune_old_trace_events", payload);
+}
+
 export interface LaneBudgets {
   slowLlm: number;
   fast: number;

package/src/memory/jobs-worker.ts

@@ -1,12 +1,17 @@
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
+import {
+  checkDiskPressureBackgroundGate,
+  diskPressureBackgroundSkipLogFields,
+  shouldLogDiskPressureBackgroundSkip,
+} from "../daemon/disk-pressure-background-gate.js";
 import { getLogger } from "../util/logger.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import {
   getLastScheduledCleanupEnqueueMs,
   markScheduledCleanupEnqueued,
 } from "./cleanup-schedule-state.js";
+import { isMemoryV2ReadActive } from "./context-search/sources/memory-v2.js";
 import { conversationAnalyzeJob } from "./conversation-analyze-job.js";
 import { maybeRunDbMaintenance } from "./db-maintenance.js";
 import { bootstrapFromHistory } from "./graph/bootstrap.js";
@@ -23,6 +28,7 @@ import { backfillJob } from "./job-handlers/backfill.js";
 import {
   pruneOldConversationsJob,
   pruneOldLlmRequestLogsJob,
+  pruneOldTraceEventsJob,
 } from "./job-handlers/cleanup.js";
 import { generateConversationStartersJob } from "./job-handlers/conversation-starters.js";
 // ── Per-job-type handlers ──────────────────────────────────────────
@@ -54,6 +60,7 @@ import {
   enqueueMemoryJob,
   enqueuePruneOldConversationsJob,
   enqueuePruneOldLlmRequestLogsJob,
+  enqueuePruneOldTraceEventsJob,
   failMemoryJob,
   failStalledJobs,
   type MemoryJob,
@@ -167,6 +174,20 @@ export async function runMemoryJobsOnce(
   if (!config.memory.enabled) return 0;
   const enableScheduledCleanup = options.enableScheduledCleanup === true;
 
+  const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
+  if (diskPressureGate.action === "skip") {
+    if (shouldLogDiskPressureBackgroundSkip("memory-jobs-worker")) {
+      log.warn(
+        {
+          source: "memory",
+          ...diskPressureBackgroundSkipLogFields(diskPressureGate),
+        },
+        "Memory jobs worker skipped during disk pressure cleanup mode",
+      );
+    }
+    return 0;
+  }
+
   // Fail jobs that have been running longer than the configured timeout
   const timedOut = failStalledJobs(config.memory.jobs.stalledJobTimeoutMs);
   if (timedOut > 0) {
@@ -455,6 +476,9 @@ async function processJob(
     case "prune_old_llm_request_logs":
       pruneOldLlmRequestLogsJob(job, config);
       return;
+    case "prune_old_trace_events":
+      pruneOldTraceEventsJob(job, config);
+      return;
     case "build_conversation_summary":
       await buildConversationSummaryJob(job, config);
       return;
@@ -560,14 +584,20 @@ function maybeEnqueueScheduledCleanupJobs(
     cleanup.llmRequestLogRetentionMs !== null
       ? enqueuePruneOldLlmRequestLogsJob(cleanup.llmRequestLogRetentionMs)
       : null;
+  const pruneTraceEventsJobId =
+    cleanup.traceEventRetentionDays > 0
+      ? enqueuePruneOldTraceEventsJob(cleanup.traceEventRetentionDays)
+      : null;
   markScheduledCleanupEnqueued(nowMs);
   log.debug(
     {
       pruneConversationsJobId,
       pruneLlmRequestLogsJobId,
+      pruneTraceEventsJobId,
       enqueueIntervalMs: cleanup.enqueueIntervalMs,
       conversationRetentionDays: cleanup.conversationRetentionDays,
       llmRequestLogRetentionMs: cleanup.llmRequestLogRetentionMs,
+      traceEventRetentionDays: cleanup.traceEventRetentionDays,
     },
     "Enqueued scheduled memory cleanup jobs",
   );
@@ -590,58 +620,66 @@ export const GRAPH_MAINTENANCE_CHECKPOINTS = {
 } as const;
 
 /**
- * Enqueue periodic graph maintenance jobs (decay, consolidation, pattern scan, narrative).
- * Uses durable checkpoints so intervals survive daemon restarts — jobs only fire
- * when the actual elapsed time since last run exceeds the interval.
+ * Enqueue periodic graph maintenance jobs.
+ *
+ * Mutually exclusive between v1 and v2:
+ *   - v2 active (both `memory-v2-enabled` flag and `memory.v2.enabled`
+ *     config on) → only `memory_v2_consolidate` is scheduled.
+ *   - v2 inactive → the four v1 entries (decay, consolidate, pattern_scan,
+ *     narrative) are scheduled instead.
  *
- * The v2 consolidation entry is gated on both the `memory-v2-enabled` feature
- * flag and the `memory.v2.enabled` config — both must be true for the cron
- * to fire. Sweep is intentionally not on this schedule: it is debounced from
- * the live `graph_extract` trigger path (see `indexMessageNow` in
- * `indexer.ts`) so it runs on the same idle/message-count cadence.
+ * Read/write paths route to v2 when the flag is on, so v1 graph data goes
+ * unread; running v1 maintenance alongside v2 is wasted compute and LLM
+ * spend. The v1 code path remains live so flipping the flag back to off
+ * fully re-engages v1.
+ *
+ * Uses durable checkpoints so intervals survive daemon restarts — jobs only
+ * fire when the actual elapsed time since last run exceeds the interval.
+ * Sweep is intentionally not on this schedule: it is debounced from the
+ * live `graph_extract` trigger path (see `indexMessageNow` in `indexer.ts`)
+ * so it runs on the same idle/message-count cadence.
  */
 export function maybeEnqueueGraphMaintenanceJobs(
   config: AssistantConfig,
   nowMs = Date.now(),
 ): void {
+  const v2Active = isMemoryV2ReadActive(config);
+
   const schedule: Array<{
     key: string;
     intervalMs: number;
     jobType: MemoryJobType;
-  }> = [
-    {
-      key: GRAPH_MAINTENANCE_CHECKPOINTS.decay,
-      intervalMs: GRAPH_DECAY_INTERVAL_MS,
-      jobType: "graph_decay",
-    },
-    {
-      key: GRAPH_MAINTENANCE_CHECKPOINTS.consolidate,
-      intervalMs: GRAPH_CONSOLIDATE_INTERVAL_MS,
-      jobType: "graph_consolidate",
-    },
-    {
-      key: GRAPH_MAINTENANCE_CHECKPOINTS.patternScan,
-      intervalMs: GRAPH_PATTERN_SCAN_INTERVAL_MS,
-      jobType: "graph_pattern_scan",
-    },
-    {
-      key: GRAPH_MAINTENANCE_CHECKPOINTS.narrative,
-      intervalMs: GRAPH_NARRATIVE_INTERVAL_MS,
-      jobType: "graph_narrative_refine",
-    },
-  ];
-
-  if (
-    isAssistantFeatureFlagEnabled("memory-v2-enabled", config) &&
-    config.memory.v2.enabled
-  ) {
-    schedule.push({
-      key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
-      intervalMs:
-        config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000,
-      jobType: "memory_v2_consolidate",
-    });
-  }
+  }> = v2Active
+    ? [
+        {
+          key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
+          intervalMs:
+            config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000,
+          jobType: "memory_v2_consolidate",
+        },
+      ]
+    : [
+        {
+          key: GRAPH_MAINTENANCE_CHECKPOINTS.decay,
+          intervalMs: GRAPH_DECAY_INTERVAL_MS,
+          jobType: "graph_decay",
+        },
+        {
+          key: GRAPH_MAINTENANCE_CHECKPOINTS.consolidate,
+          intervalMs: GRAPH_CONSOLIDATE_INTERVAL_MS,
+          jobType: "graph_consolidate",
+        },
+        {
+          key: GRAPH_MAINTENANCE_CHECKPOINTS.patternScan,
+          intervalMs: GRAPH_PATTERN_SCAN_INTERVAL_MS,
+          jobType: "graph_pattern_scan",
+        },
+        {
+          key: GRAPH_MAINTENANCE_CHECKPOINTS.narrative,
+          intervalMs: GRAPH_NARRATIVE_INTERVAL_MS,
+          jobType: "graph_narrative_refine",
+        },
+      ];
 
   for (const { key, intervalMs, jobType } of schedule) {
     const lastRun = parseInt(getMemoryCheckpoint(key) ?? "0", 10);