@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/plugins/defaults/memory/memory-retrospective-job.ts

@@ -54,7 +54,7 @@ import {
   isInteractiveInterface,
   parseInterfaceId,
 } from "../../../channels/types.js";
-import { isProcToSkillsActive } from "../../../config/memory-v3-gate.js";
+import { isV3TierActive } from "../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../config/types.js";
 import { getGuardianDelivery } from "../../../contacts/guardian-delivery-reader.js";
 import { extractTurnContextTimestamp } from "../../../context/compactor.js";
@@ -97,6 +97,7 @@ import {
   getRetrospectiveState,
   upsertRetrospectiveState,
 } from "./memory-retrospective-state.js";
+import { effectiveSweepLookbackMs } from "./memory-retrospective-sweep.js";
 
 const log = getLogger("memory-retrospective-job");
 
@@ -124,6 +125,7 @@ const MEMORY_RETROSPECTIVE_RUN_CHECK_NAME = "memory_retrospective_run";
 export type MemoryRetrospectiveOutcome =
   | { kind: "disabled" }
   | { kind: "no_new_messages" }
+  | { kind: "source_dormant" }
   | { kind: "source_processing" }
   | { kind: "wake_failed"; reason?: string; conversationId?: string }
   | {
@@ -170,7 +172,9 @@ export async function memoryRetrospectiveJob(
 
   let outcome: MemoryRetrospectiveOutcome;
   try {
-    outcome = await runForkBasedRetrospective(sourceConversationId, config);
+    outcome = await runForkBasedRetrospective(sourceConversationId, config, {
+      enforceSweepLookback: true,
+    });
   } catch (err) {
     emitRunOutcome("error", err instanceof Error ? err.message : String(err));
     throw err;
@@ -196,6 +200,16 @@ export async function memoryRetrospectiveJob(
 export async function runForkBasedRetrospective(
   sourceConversationId: string,
   config: AssistantConfig,
+  opts?: {
+    /**
+     * Skip the run when the source's last message is older than
+     * `memory.retrospective.sweepLookbackMs`. The queue handler passes this so
+     * a stale pending backlog is completed as no-ops instead of run; the CLI's
+     * manual command omits it — an operator's explicit request overrides the
+     * window.
+     */
+    enforceSweepLookback?: boolean;
+  },
 ): Promise<MemoryRetrospectiveOutcome> {
   // Start stamp for the retrospective's end-to-end wall time, surfaced as
   // `durationMs` on the "invoked" log (start → invoked).
@@ -209,6 +223,29 @@ export async function runForkBasedRetrospective(
     return { kind: "no_new_messages" };
   }
 
+  // Execution-time twin of the sweep's lookback window (see
+  // memory-retrospective-sweep.ts). Event triggers enqueue in response to a
+  // just-persisted message, so a legitimately-enqueued job's source sits
+  // inside the window when the job runs; a numeric stamp older than the
+  // window means the row is stale backlog, and running it would burn an
+  // inference pass on a conversation the sweep no longer considers stalled.
+  // A missing stamp is NOT dormancy here — the enqueue itself evidences
+  // activity, unlike the sweep's scan where the stamp is the only signal.
+  // Both state pointers stay untouched.
+  if (opts?.enforceSweepLookback === true) {
+    const lastMessageAt = sourceConversation.lastMessageAt;
+    if (
+      typeof lastMessageAt === "number" &&
+      startedAtMs - lastMessageAt > effectiveSweepLookbackMs(config)
+    ) {
+      log.info(
+        { sourceConversationId, lastMessageAt },
+        "memory-retrospective (fork): source dormant beyond the sweep lookback; skipping",
+      );
+      return { kind: "source_dormant" };
+    }
+  }
+
   // Forking mid-turn would capture a half-finished display turn — incremental
   // checkpoint persistence writes complete tool turns to the DB while the
   // agent loop is still running. Check the persisted `processing_started_at`
@@ -335,7 +372,7 @@ export async function runForkBasedRetrospective(
   }
   const forkId = forkConversationRow.id;
 
-  const procToSkillsActive = isProcToSkillsActive(config);
+  const procToSkillsActive = isV3TierActive(config);
   const instruction = buildForkInstruction({
     windowStartTimestamp,
     windowAnchorKind: turnContextTimestamp ? "turn_context" : "created_at",

package/src/plugins/defaults/memory/memory-retrospective-sweep.ts

@@ -27,6 +27,14 @@
 // (filtered in `EXCLUDED_SOURCES`).
 //
 // Cost discipline:
+//   - The scan is bounded to conversations whose last message falls inside
+//     `memory.retrospective.sweepLookbackMs`. A crash-orphaned turn is by
+//     definition recent, so a conversation dormant beyond the window is not
+//     stalled work — its unprocessed tail is an ordinary end-of-conversation
+//     remainder. Without this bound, the scan degenerates into a full-history
+//     backfill: nearly every conversation ever carries a tail past its final
+//     retrospective cursor, so a cold start would enqueue an inference pass
+//     per conversation across the entire history.
 //   - The per-conversation gate skips any conversation whose last retrospective
 //     attempt is newer than the sweep interval, so the sweep never competes
 //     with the responsive event triggers on active conversations — it only
@@ -35,11 +43,22 @@
 //     `upsertMemoryRetrospectiveJob` coalesces against any already-pending job,
 //     so a conversation already queued by an event trigger is never
 //     double-processed.
+//   - Enqueues are capped at `SWEEP_MAX_ENQUEUES_PER_PASS` per pass. Inside
+//     the lookback window, organic stalled work is a handful of conversations;
+//     a pass wanting more signals an anomalous backlog. Each pass re-scans
+//     from the start, so the deferred remainder is picked up by later passes.
+//     Sources with an already-pending retrospective job are skipped before
+//     the cap, so coalescing no-ops never consume it; a running job does not
+//     suppress the sweep (its cursor is a pre-run snapshot — a mid-run
+//     arrival needs a follow-up row behind it).
 //   - The scan is keyset-paginated in bounded batches with a yield between
 //     pages (mirrors `conversation-memory-orphan-sweep.ts`), so a large history
-//     never materializes all ids at once or holds the event loop. Every
-//     eligible conversation is examined each pass — there is no front-of-list
-//     limit that could starve later conversations.
+//     never materializes all ids at once or holds the event loop.
+//
+// The retrospective job re-applies the lookback window at execution time
+// (`runForkBasedRetrospective`'s `enforceSweepLookback` gate), so pending rows
+// that outlive the window — e.g. a backlog drained long after enqueue — are
+// completed as no-ops instead of run.
 
 import { and, asc, gt, ne, notInArray } from "drizzle-orm";
 
@@ -48,20 +67,32 @@ import { AUTO_ANALYSIS_SOURCE } from "../../../persistence/auto-analysis-constan
 import { getConversationRecentProvenanceTrustClass } from "../../../persistence/conversation-crud.js";
 import { getDb } from "../../../persistence/db-connection.js";
 import type { MemoryJob } from "../../../persistence/jobs-store.js";
-import { isMemoryEnabled } from "../../../persistence/jobs-store.js";
+import {
+  isMemoryEnabled,
+  listPendingMemoryRetrospectiveSourceConversationIds,
+} from "../../../persistence/jobs-store.js";
 import { conversations } from "../../../persistence/schema/index.js";
 import { getLogger } from "./logging.js";
 import { countRetrospectiveMessagesAfter } from "./memory-retrospective-accounting.js";
 import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 import { enqueueMemoryRetrospectiveIfEnabled } from "./memory-retrospective-enqueue.js";
 import { getRetrospectiveState } from "./memory-retrospective-state.js";
-import { MEMORY_V2_CONSOLIDATION_SOURCE } from "./v3/substrate/constants.js";
+import { MEMORY_V2_CONSOLIDATION_SOURCE } from "./substrate/constants.js";
 
 const log = getLogger("memory-retrospective-sweep");
 
 /** Rows per keyset-paginated page — bounds each statement and the id set held. */
 const SWEEP_BATCH = 200;
 
+/**
+ * Hard ceiling on retrospectives enqueued by a single sweep pass. Each
+ * enqueue fans out an LLM inference pass, so a pass that wants more than this
+ * many is anomalous (organic in-window stalled work is a handful of
+ * conversations at most) and gets clamped with a warning. Safe to defer: every
+ * pass re-scans from the start, so the remainder is enqueued by later passes.
+ */
+export const SWEEP_MAX_ENQUEUES_PER_PASS = 50;
+
 /**
  * Conversation `source` values excluded from the sweep up front:
  *   - retrospective background conversations — recursion guard (never run a
@@ -107,15 +138,44 @@ function breathe(): Promise<void> {
   return Bun.sleep(0);
 }
 
+/**
+ * The lookback window the sweep actually applies: never smaller than TWICE
+ * `sweepIntervalMs`. One interval is not enough — the pass checkpoint is
+ * stamped at enqueue but the cutoff is computed at execution, so tick, queue,
+ * and runtime delay stretch the gap between consecutive executions past the
+ * nominal cadence, and a message landing in that skew right after a pass
+ * would sit permanently outside an exact-interval window. The doubled floor
+ * absorbs the skew while staying BOUNDED: deriving the window from elapsed
+ * time since the previous pass would cover arbitrary gaps, but after
+ * extended downtime it would recreate the cold-start backfill this window
+ * exists to prevent. Outages longer than a full interval can therefore still
+ * leave tails outside the window — accepted by design, like the cold start.
+ * Shared by the sweep scan and the retrospective job's execution-time gate;
+ * the two must agree or the gate would kill jobs the scan legitimately
+ * enqueued.
+ */
+export function effectiveSweepLookbackMs(config: AssistantConfig): number {
+  return Math.max(
+    config.memory.retrospective.sweepLookbackMs,
+    2 * config.memory.retrospective.sweepIntervalMs,
+  );
+}
+
 /**
  * One keyset page of sweep-eligible conversation ids past `cursor`. The empty
  * string sorts before any real id, so the first page starts at the beginning.
  * `scheduled`-type conversations are filtered here (low-yield, matching the
  * enqueue guard); other low-yield cases are caught by the enqueue itself.
+ *
+ * `lastMessageAtCutoff` bounds the scan to the sweep's lookback window
+ * (indexed via `idx_conversations_last_message_at`). `gt` NULL semantics
+ * exclude rows with no recorded message stamp: absent any evidence of recent
+ * activity, a conversation is not sweepable.
  */
 export function listSweepCandidateConversationIds(
   cursor: string,
   limit: number,
+  lastMessageAtCutoff: number,
 ): string[] {
   return getDb()
     .select({ id: conversations.id })
@@ -123,6 +183,7 @@ export function listSweepCandidateConversationIds(
     .where(
       and(
         gt(conversations.id, cursor),
+        gt(conversations.lastMessageAt, lastMessageAtCutoff),
         notInArray(conversations.source, EXCLUDED_SOURCES),
         ne(conversations.conversationType, "scheduled"),
       ),
@@ -141,11 +202,12 @@ export interface RetrospectiveSweepResult {
 }
 
 /**
- * Scan all sweep-eligible conversations and enqueue a `sweep`-triggered
- * retrospective for any with unprocessed messages whose last attempt is older
- * than `sweepIntervalMs`. Idempotent and best-effort: enqueue coalescing
- * prevents duplicates, and the scan degrades to a no-op when memory is
- * disabled.
+ * Scan sweep-eligible conversations with activity inside the lookback window
+ * and enqueue a `sweep`-triggered retrospective for any with unprocessed
+ * messages whose last attempt is older than `sweepIntervalMs`, up to
+ * {@link SWEEP_MAX_ENQUEUES_PER_PASS} per pass. Idempotent and best-effort:
+ * enqueue coalescing prevents duplicates, and the scan degrades to a no-op
+ * when memory is disabled.
  */
 export async function runRetrospectiveSweep(
   config: AssistantConfig,
@@ -155,12 +217,20 @@ export async function runRetrospectiveSweep(
     return { scanned: 0, enqueued: 0 };
   }
   const sweepIntervalMs = config.memory.retrospective.sweepIntervalMs;
+  const lookbackCutoff = now - effectiveSweepLookbackMs(config);
+  const pendingSourceIds = new Set(
+    listPendingMemoryRetrospectiveSourceConversationIds(),
+  );
 
   let scanned = 0;
   let enqueued = 0;
   let cursor = "";
   for (;;) {
-    const page = listSweepCandidateConversationIds(cursor, SWEEP_BATCH);
+    const page = listSweepCandidateConversationIds(
+      cursor,
+      SWEEP_BATCH,
+      lookbackCutoff,
+    );
     if (page.length === 0) {
       break;
     }
@@ -169,6 +239,17 @@ export async function runRetrospectiveSweep(
     for (const conversationId of page) {
       scanned += 1;
 
+      // A source with a pending row has nothing for the sweep to add — the
+      // row runs on its own. Skipping it up front keeps coalescing upserts
+      // from consuming the per-pass enqueue cap: counted no-ops would starve
+      // conversations later in id order across passes (every pass restarts
+      // from the lowest id). A RUNNING job does not suppress the sweep — its
+      // cursor is a pre-run snapshot, so a mid-run arrival needs a follow-up
+      // row, and the upsert's pending-only coalescing creates exactly that.
+      if (pendingSourceIds.has(conversationId)) {
+        continue;
+      }
+
       // Memory trust boundary: never enqueue a retrospective (which runs under
       // guardian trust with `remember`) for a conversation whose actor isn't
       // memory-trusted. This is the sweep's equivalent of the per-message
@@ -198,6 +279,13 @@ export async function runRetrospectiveSweep(
 
       enqueueMemoryRetrospectiveIfEnabled({ conversationId, trigger: "sweep" });
       enqueued += 1;
+      if (enqueued >= SWEEP_MAX_ENQUEUES_PER_PASS) {
+        log.warn(
+          { scanned, enqueued },
+          "Memory retrospective sweep hit the per-pass enqueue cap; deferring the remainder to the next pass",
+        );
+        return { scanned, enqueued };
+      }
     }
 
     await breathe();

package/src/plugins/defaults/memory/src/__tests__/memory-v2-routes.test.ts

@@ -14,8 +14,8 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import type { RouteDefinition } from "../../../../../runtime/routes/types.js";
-import { writePage } from "../../v3/substrate/page-store.js";
-import type { ConceptPage } from "../../v3/substrate/types.js";
+import { writePage } from "../../substrate/page-store.js";
+import type { ConceptPage } from "../../substrate/types.js";
 import type { MemoryV2ListConceptPagesResult } from "../memory-v2-routes.js";
 import { ROUTES } from "../memory-v2-routes.js";
 
@@ -26,7 +26,9 @@ let origWorkspaceDir: string | undefined;
 
 function findHandler(operationId: string): RouteDefinition["handler"] {
   const route = ROUTES.find((r) => r.operationId === operationId);
-  if (!route) throw new Error(`Route ${operationId} not found`);
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
   return route.handler;
 }
 

package/src/plugins/defaults/memory/src/__tests__/memory-v2-simulate-route.test.ts

@@ -32,7 +32,7 @@ import type { ToolDefinition } from "../../llm-helpers.js";
 // ---------------------------------------------------------------------------
 
 // Skill store: empty by default so the page index only contains test pages.
-mock.module("../../v3/substrate/skill-store.js", () => ({
+mock.module("../../substrate/skill-store.js", () => ({
   SKILL_SLUG_PREFIX: "skills/",
   listSkillEntries: () => [],
   seedV2SkillEntries: async () => undefined,
@@ -118,9 +118,8 @@ mock.module("../../../../../util/platform.js", () => ({
 // ---------------------------------------------------------------------------
 
 const { handleSimulateRouter } = await import("../memory-v2-routes.js");
-const { writePage } = await import("../../v3/substrate/page-store.js");
-const { invalidatePageIndex } =
-  await import("../../v3/substrate/page-index.js");
+const { writePage } = await import("../../substrate/page-store.js");
+const { invalidatePageIndex } = await import("../../substrate/page-index.js");
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/plugins/defaults/memory/src/memory-graph-routes.ts

@@ -61,7 +61,8 @@ export const ROUTES: RouteDefinition[] = [
       {
         name: "id",
         schema: { type: "string" },
-        description: "Node id from the graph payload (memory-v3: the concept-page slug).",
+        description:
+          "Node id from the graph payload (memory-v3: the concept-page slug).",
       },
     ],
     responseBody: MemoryGraphNodeDetailSchema,

package/src/plugins/defaults/memory/src/memory-item-routes.test.ts

@@ -68,7 +68,7 @@ mock.module(
 // stats test seed synthetic (modifiedAt: 0) rows and assert they're excluded.
 let mockSkillEntries: Array<{ id: string; content: string }> = [];
 
-mock.module("../v3/substrate/skill-store.js", () => ({
+mock.module("../substrate/skill-store.js", () => ({
   SKILL_SLUG_PREFIX: "skills/",
   listSkillEntries: () => mockSkillEntries,
 }));
@@ -92,9 +92,9 @@ import {
 } from "../../../../runtime/routes/errors.js";
 import type { RouteDefinition } from "../../../../runtime/routes/types.js";
 import { readPendingBufferEntries } from "../graph-topology/pending-buffer.js";
-import { invalidatePageIndex } from "../v3/substrate/page-index.js";
-import { writePage } from "../v3/substrate/page-store.js";
-import type { ConceptPage } from "../v3/substrate/types.js";
+import { invalidatePageIndex } from "../substrate/page-index.js";
+import { writePage } from "../substrate/page-store.js";
+import type { ConceptPage } from "../substrate/types.js";
 import { ROUTES } from "./memory-item-routes.js";
 
 // ---------------------------------------------------------------------------
@@ -105,7 +105,9 @@ function getRoute(endpoint: string, method: string): RouteDefinition {
   const route = ROUTES.find(
     (r: RouteDefinition) => r.endpoint === endpoint && r.method === method,
   );
-  if (!route) throw new Error(`No route: ${method} ${endpoint}`);
+  if (!route) {
+    throw new Error(`No route: ${method} ${endpoint}`);
+  }
   return route;
 }
 

package/src/plugins/defaults/memory/src/memory-item-routes.ts

@@ -33,7 +33,7 @@ import { z } from "zod";
 
 import { getConfig } from "../../../../config/loader.js";
 import {
-  isMemoryGraphSupported,
+  isV3TierActive,
   usesConceptPageMemory,
 } from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
@@ -81,7 +81,8 @@ import { consolidationBackoffRemainingMs } from "../jobs-worker.js";
 import { getLogger } from "../logging.js";
 import { memoryDbOrNull } from "../memory-db.js";
 import { getWorkspaceDir } from "../paths.js";
-import { getPageIndex } from "../v3/substrate/page-index.js";
+import { getPageIndex } from "../substrate/page-index.js";
+import { resolveSubstrateTuning } from "../substrate/tuning.js";
 
 const log = getLogger("memory-item-routes");
 
@@ -211,13 +212,19 @@ async function searchNodesSemantic(
     // search (the caller's `null` branch) instead of querying the v1
     // collection, which is in active retirement and a corrupted sparse
     // segment can OOM-crash the shared Qdrant process.
-    if (usesConceptPageMemory(config.memory)) return null;
+    if (usesConceptPageMemory(config.memory)) {
+      return null;
+    }
     const backendStatus = await getMemoryBackendStatus(config);
-    if (!backendStatus.provider) return null;
+    if (!backendStatus.provider) {
+      return null;
+    }
 
     const embedded = await embedWithBackend(config, [query]);
     const queryVector = embedded.vectors[0];
-    if (!queryVector) return null;
+    if (!queryVector) {
+      return null;
+    }
 
     const sparse = generateSparseEmbedding(query);
     const sparseVector = { indices: sparse.indices, values: sparse.values };
@@ -320,7 +327,9 @@ async function handleListMemoryItems(queryParams: Record<string, string>) {
   }
 
   const db = memoryDbOrNull("listMemoryItems");
-  if (!db) throw new Error("memory database unavailable");
+  if (!db) {
+    throw new Error("memory database unavailable");
+  }
 
   // Build fidelity filter based on status param
   const fidelityFilter =
@@ -343,7 +352,9 @@ async function handleListMemoryItems(queryParams: Record<string, string>) {
       const kindCountConditions = [
         inArray(memoryGraphNodes.id, semanticResult.ids),
       ];
-      if (fidelityFilter) kindCountConditions.push(fidelityFilter);
+      if (fidelityFilter) {
+        kindCountConditions.push(fidelityFilter);
+      }
 
       const kindCountRows = db
         .select({ kind: memoryGraphNodes.type, count: count() })
@@ -365,7 +376,9 @@ async function handleListMemoryItems(queryParams: Record<string, string>) {
         if (kindParam) {
           filterConditions.push(eq(memoryGraphNodes.type, kindParam));
         }
-        if (fidelityFilter) filterConditions.push(fidelityFilter);
+        if (fidelityFilter) {
+          filterConditions.push(fidelityFilter);
+        }
 
         if (filterConditions.length > 1) {
           const validIdSet = new Set(
@@ -393,9 +406,12 @@ async function handleListMemoryItems(queryParams: Record<string, string>) {
 
       // Hydrate nodes from DB
       const hydrationConditions = [inArray(memoryGraphNodes.id, pageIds)];
-      if (fidelityFilter) hydrationConditions.push(fidelityFilter);
-      if (kindParam)
+      if (fidelityFilter) {
+        hydrationConditions.push(fidelityFilter);
+      }
+      if (kindParam) {
         hydrationConditions.push(eq(memoryGraphNodes.type, kindParam));
+      }
 
       const rows = db
         .select()
@@ -419,7 +435,9 @@ async function handleListMemoryItems(queryParams: Record<string, string>) {
 
   // ── Kind counts for SQL path ───────────────────────────────────────
   const kindCountConditions = [];
-  if (fidelityFilter) kindCountConditions.push(fidelityFilter);
+  if (fidelityFilter) {
+    kindCountConditions.push(fidelityFilter);
+  }
   if (searchParam) {
     kindCountConditions.push(
       like(memoryGraphNodes.content, `%${searchParam}%`),
@@ -441,8 +459,12 @@ async function handleListMemoryItems(queryParams: Record<string, string>) {
 
   // ── SQL path (default or fallback) ──────────────────────────────────
   const conditions = [];
-  if (fidelityFilter) conditions.push(fidelityFilter);
-  if (kindParam) conditions.push(eq(memoryGraphNodes.type, kindParam));
+  if (fidelityFilter) {
+    conditions.push(fidelityFilter);
+  }
+  if (kindParam) {
+    conditions.push(eq(memoryGraphNodes.type, kindParam));
+  }
   if (searchParam) {
     conditions.push(like(memoryGraphNodes.content, `%${searchParam}%`));
   }
@@ -497,7 +519,7 @@ function handleGetMemoryItem(id: string) {
  * concept graph is deliberately kept off identity-page load.
  *
  * `graph_supported` reports whether the memory-concept graph is available for
- * this assistant — the same `isMemoryGraphSupported` condition under which
+ * this assistant — the same `isV3TierActive` condition under which
  * `GET /memory-graph` returns `supported: true` (memory enabled + v3 live). It
  * is a cheap config read (no page I/O), so glanceable surfaces can gate the
  * graph entry point on real availability without triggering the graph build.
@@ -507,7 +529,7 @@ async function handleGetMemoryStats(
 ): Promise<{ concepts: number; graph_supported: boolean }> {
   const pageIndex = await getPageIndex(getWorkspaceDir());
   const concepts = pageIndex.entries.filter((e) => e.modifiedAt > 0).length;
-  return { concepts, graph_supported: isMemoryGraphSupported(config) };
+  return { concepts, graph_supported: isV3TierActive(config) };
 }
 
 async function handleCreateMemoryItem(body: Record<string, unknown>) {
@@ -538,7 +560,9 @@ async function handleCreateMemoryItem(body: Record<string, unknown>) {
 
   // Check for duplicate content
   const db = memoryDbOrNull("createMemoryItem");
-  if (!db) throw new Error("memory database unavailable");
+  if (!db) {
+    throw new Error("memory database unavailable");
+  }
   const existing = db
     .select({ id: memoryGraphNodes.id })
     .from(memoryGraphNodes)
@@ -658,7 +682,9 @@ async function handleUpdateMemoryItem(
   if (contentChanged || reactivating) {
     const contentToCheck = changes.content ?? existing.content;
     const db = memoryDbOrNull("updateMemoryItem");
-    if (!db) throw new Error("memory database unavailable");
+    if (!db) {
+      throw new Error("memory database unavailable");
+    }
     const collision = db
       .select({ id: memoryGraphNodes.id })
       .from(memoryGraphNodes)
@@ -705,14 +731,20 @@ async function handleUpdateMemoryItem(
  */
 function maybeEnqueueConsolidationForCreate(config: AssistantConfig): void {
   try {
-    if (!usesConceptPageMemory(config.memory) || !isMemoryEnabled()) {
+    // `usesConceptPageMemory` already covers the memory-off case (an explicit
+    // `memory.enabled === false` makes it false), so a second
+    // `isMemoryEnabled()` clause would be unreachable.
+    if (!usesConceptPageMemory(config.memory)) {
       return;
     }
     if (hasActiveJobOfType("memory_v2_consolidate")) {
       return;
     }
     const intervalMs =
-      config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000;
+      resolveSubstrateTuning(config.memory).consolidation_interval_hours *
+      60 *
+      60 *
+      1000;
     if (consolidationBackoffRemainingMs(intervalMs, Date.now()) > 0) {
       return;
     }

package/src/plugins/defaults/memory/src/memory-v2-routes.ts

@@ -21,11 +21,25 @@ import { RouteError } from "../../../../runtime/routes/errors.js";
 import type { RouteDefinition } from "../../../../runtime/routes/types.js";
 import type { RouteHandlerArgs } from "../../../../runtime/routes/types.js";
 import { getLogger } from "../logging.js";
+import { getWorkspaceDir } from "../paths.js";
+import {
+  getEdgeIndex,
+  totalEdgeCount,
+  validateEdgeTargets,
+} from "../substrate/edge-index.js";
+import { getPageIndex } from "../substrate/page-index.js";
+import {
+  getConceptsDir,
+  listPages,
+  readPage,
+  renderPageContent,
+} from "../substrate/page-store.js";
+import { seedV2SkillEntries } from "../substrate/skill-store.js";
+import { resolveSubstrateTuning } from "../substrate/tuning.js";
 import {
   type ConceptFrequencyResponse,
   getConceptFrequencySummary,
-} from "../memory-v2-concept-frequency.js";
-import { getWorkspaceDir } from "../paths.js";
+} from "../v2/concept-frequency.js";
 import { runComparisonOverHistory } from "../v2/harness/compare.js";
 import type { Retriever } from "../v2/harness/retriever.js";
 import { createRouterRetriever } from "../v2/harness/router-retriever.js";
@@ -34,19 +48,6 @@ import { computeInjectionScores } from "../v2/injection-events.js";
 import { loadNowText } from "../v2/now-text.js";
 import { ROUTER_PROMPT } from "../v2/prompts/router.js";
 import { type RouterSource, runRouter } from "../v2/router.js";
-import {
-  getEdgeIndex,
-  totalEdgeCount,
-  validateEdgeTargets,
-} from "../v3/substrate/edge-index.js";
-import { getPageIndex } from "../v3/substrate/page-index.js";
-import {
-  getConceptsDir,
-  listPages,
-  readPage,
-  renderPageContent,
-} from "../v3/substrate/page-store.js";
-import { seedV2SkillEntries } from "../v3/substrate/skill-store.js";
 
 const log = getLogger("memory-v2-routes");
 
@@ -133,7 +134,9 @@ async function handleValidate({
   MemoryV2ValidateParams.parse(body);
 
   const workspaceDir = getWorkspaceDir();
-  const maxPageChars = loadConfig().memory.v2.max_page_chars;
+  const maxPageChars = resolveSubstrateTuning(
+    loadConfig().memory,
+  ).max_page_chars;
 
   const slugs = await listPages(workspaceDir);
   const knownSlugs = new Set<string>();
@@ -143,7 +146,9 @@ async function handleValidate({
   for (const slug of slugs) {
     try {
       const page = await readPage(workspaceDir, slug);
-      if (!page) continue;
+      if (!page) {
+        continue;
+      }
       knownSlugs.add(slug);
       const chars = page.body.length;
       if (chars > maxPageChars) {
@@ -242,7 +247,9 @@ async function handleListConceptPages({
     slugs.map(async (slug) => {
       try {
         const page = await readPage(workspaceDir, slug);
-        if (!page) return null;
+        if (!page) {
+          return null;
+        }
         const stats = await stat(join(conceptsDir, `${slug}.md`));
         return {
           slug,
@@ -346,7 +353,9 @@ async function handleEmaScores({
     modifiedAt: entry.modifiedAt,
   }));
   entries.sort((a, b) => {
-    if (a.score !== b.score) return b.score - a.score;
+    if (a.score !== b.score) {
+      return b.score - a.score;
+    }
     return a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0;
   });
   return { entries };
@@ -455,7 +464,9 @@ function applySimulateOverrides(
   live: AssistantConfig,
   overrides: z.infer<typeof SimulateRouterOverridesSchema> | undefined,
 ): AssistantConfig {
-  if (!overrides) return live;
+  if (!overrides) {
+    return live;
+  }
   const liveRouter = live.memory.v2.router;
   const mergedRouter = {
     ...liveRouter,