@vellumai/assistant 0.6.2 → 0.6.4

package/src/memory/embedding-local.ts

@@ -1,4 +1,10 @@
-import { existsSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  readFileSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
@@ -83,6 +89,8 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
     }
   >();
   private stdoutReaderActive = false;
+  private activeEmbeds = 0;
+  private disposeRequested = false;
 
   private readonly initGuard = new PromiseGuard<void>();
 
@@ -94,6 +102,9 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
     inputs: EmbeddingInput[],
     options?: EmbeddingRequestOptions,
   ): Promise<number[][]> {
+    if (this.disposeRequested) {
+      throw new Error("Local embedding backend is shutting down");
+    }
     if (inputs.length === 0) return [];
 
     const texts = inputs.map((i) => {
@@ -106,24 +117,30 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
     if (options?.signal?.aborted)
       throw new DOMException("Aborted", "AbortError");
 
-    await this.ensureInitialized();
-
-    const results: number[][] = [];
-    const batchSize = 32;
-    for (let i = 0; i < texts.length; i += batchSize) {
-      if (options?.signal?.aborted)
-        throw new DOMException("Aborted", "AbortError");
-      const batch = texts.slice(i, i + batchSize);
-      const response = await this.sendRequest(batch);
-      if (response.error) {
-        throw new Error(`Embedding worker error: ${response.error}`);
-      }
-      if (!response.vectors) {
-        throw new Error("Embedding worker returned no vectors");
+    this.activeEmbeds++;
+    try {
+      await this.ensureInitialized();
+
+      const results: number[][] = [];
+      const batchSize = 32;
+      for (let i = 0; i < texts.length; i += batchSize) {
+        if (options?.signal?.aborted)
+          throw new DOMException("Aborted", "AbortError");
+        const batch = texts.slice(i, i + batchSize);
+        const response = await this.sendRequest(batch);
+        if (response.error) {
+          throw new Error(`Embedding worker error: ${response.error}`);
+        }
+        if (!response.vectors) {
+          throw new Error("Embedding worker returned no vectors");
+        }
+        results.push(...response.vectors);
       }
-      results.push(...response.vectors);
+      return results;
+    } finally {
+      this.activeEmbeds--;
+      this.disposeIfIdle();
     }
-    return results;
   }
 
   private sendRequest(texts: string[]): Promise<WorkerResponse> {
@@ -148,6 +165,11 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
     await this.initGuard.run(() => this.initialize());
   }
 
+  dispose(): void {
+    this.disposeRequested = true;
+    this.disposeIfIdle();
+  }
+
   private async initialize(): Promise<void> {
     log.info({ model: this.model }, "Initializing local embedding backend");
 
@@ -199,6 +221,12 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
     const embeddingModelsDir = getEmbeddingModelsDir();
     const modelCacheDir = `${embeddingModelsDir}/model-cache`;
 
+    // Singleton guard: an orphaned embed worker from a previous daemon
+    // (e.g. one that crashed without cleanup) may still be running and
+    // holding the workspace's PID file. Detect and reclaim it before
+    // spawning so we never leave duplicate workers eating CPU/memory.
+    this.reclaimStaleWorker(workerPath);
+
     log.info(
       { bunPath, workerPath, model: this.model },
       "Spawning embedding worker process",
@@ -255,6 +283,8 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
       { pid: proc.pid, model: this.model },
       "Embedding worker process started",
     );
+
+    this.disposeIfIdle();
   }
 
   private drainStderr(stderr: ReadableStream<Uint8Array>): void {
@@ -355,6 +385,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
         if (pending) {
           this.pendingRequests.delete(msg.id);
           pending.resolve(msg);
+          this.disposeIfIdle();
         }
       }
     }
@@ -425,4 +456,132 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
       // Best-effort
     }
   }
+
+  /** Read the PID from the on-disk PID file, or null if missing/invalid. */
+  private readPidFile(): number | null {
+    const path = this.getPidFilePath();
+    if (!existsSync(path)) return null;
+    try {
+      const pid = parseInt(readFileSync(path, "utf-8").trim(), 10);
+      return Number.isFinite(pid) && pid > 0 ? pid : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Verify a PID belongs to this workspace's embed worker before sending
+   * signals — defends against PID reuse killing an unrelated process if the
+   * original worker exited and the OS recycled the PID.
+   *
+   * Matching `embed-worker` alone would also match a sibling assistant
+   * instance's worker (different VELLUM_WORKSPACE_DIR), so we match against
+   * the absolute worker script path, which lives under THIS workspace's
+   * embedding-models directory and is therefore unique per instance.
+   */
+  private isOurEmbedWorker(pid: number, workerPath: string): boolean {
+    try {
+      // `-ww` disables column-width truncation. Without it, macOS `ps` clips
+      // the command field to the terminal width, which can cut off the
+      // workerPath argument and cause this check to spuriously return false
+      // for genuine orphans. Same flag is used by daemon-control.ts:123 for
+      // exactly this reason.
+      const result = Bun.spawnSync({
+        cmd: ["ps", "-ww", "-p", String(pid), "-o", "command="],
+        stdout: "pipe",
+        stderr: "ignore",
+      });
+      if (result.exitCode !== 0) return false;
+      const cmd = new TextDecoder().decode(result.stdout).trim();
+      if (!cmd) return false;
+      return cmd.includes(workerPath);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * If a previous embed worker is still running for this workspace (orphaned
+   * by a crashed daemon, for example), terminate it before spawning a new one
+   * so we never end up with duplicate workers competing for the same workspace.
+   *
+   * Stale PID files (process no longer exists) are silently cleaned up.
+   * PIDs that have been recycled to unrelated processes — including embed
+   * workers belonging to *other* assistant instances — are left untouched.
+   */
+  private reclaimStaleWorker(workerPath: string): void {
+    const pid = this.readPidFile();
+    if (pid == null) return;
+
+    // Never signal ourselves — should not happen since the worker is a child
+    // process, but guard against logic bugs that would deadlock the daemon.
+    if (pid === process.pid) {
+      this.removePidFile();
+      return;
+    }
+
+    let isAlive = false;
+    try {
+      // Signal 0 just probes for liveness without delivering a signal.
+      process.kill(pid, 0);
+      isAlive = true;
+    } catch {
+      // ESRCH — no such process. PID file is stale.
+    }
+
+    if (!isAlive) {
+      log.info(
+        { pid, model: this.model },
+        "Removing stale embed worker PID file (process no longer exists)",
+      );
+      this.removePidFile();
+      return;
+    }
+
+    if (!this.isOurEmbedWorker(pid, workerPath)) {
+      // PID points to something that isn't this workspace's embed worker —
+      // either an unrelated process (PID reuse after the original worker
+      // exited) or another assistant instance's worker. Either way, don't
+      // signal it; just drop the stale file so the new worker can claim it.
+      log.warn(
+        { pid, model: this.model },
+        "PID file points to a process that is not this workspace's embed worker; clearing without killing",
+      );
+      this.removePidFile();
+      return;
+    }
+
+    log.warn(
+      { pid, model: this.model },
+      "Found orphaned embed worker from a previous daemon, terminating it",
+    );
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      // Race: it exited between the liveness check and the kill — fine.
+    }
+    this.removePidFile();
+  }
+
+  private disposeIfIdle(): void {
+    if (!this.disposeRequested) return;
+    if (this.activeEmbeds > 0) return;
+    if (this.pendingRequests.size > 0) return;
+    if (this.readyResolve || this.readyReject) return;
+
+    const proc = this.workerProc;
+    this.workerProc = null;
+    this.stdoutReaderActive = false;
+    this.stdoutBuffer = "";
+    this.initGuard.reset();
+    this.removePidFile();
+
+    if (!proc) return;
+
+    try {
+      proc.kill();
+    } catch {
+      // Worker may already be exiting
+    }
+  }
 }

package/src/memory/graph/consolidation.ts

@@ -4,8 +4,7 @@
 // Runs daily (or on demand). Processes nodes in partitions:
 // 1. Recency: nodes from last 7 days — merge duplicates, initial narrative
 // 2. Significance: top N by significance — update narrative arcs
-// 3. Decay: nodes at faded/gist fidelity — candidates for merging or marking gone
-// 4. Random sample: cross-pollination and pattern detection
+// 3. Random sample: cross-pollination and pattern detection
 //
 // Each partition is a separate LLM call. The LLM produces a MemoryDiff
 // (same format as extraction) that is applied to the graph.
@@ -91,25 +90,25 @@ Today is ${today}.
 
 ## Your Tasks
 
-1. **Merge duplicates**: If two or more nodes describe the same event or fact, merge them into one by:
+1. **Merge duplicates**: If two or more nodes describe the exact same specific event or fact with substantially the same details, merge them into one by:
    - Keeping the richer/more complete version (UPDATE it to incorporate details from duplicates)
    - DELETE the duplicates
    - Preserve the highest significance, reinforcement count, and stability from the merged nodes
-   - Create a "supersedes" edge from the surviving node to each deleted node (the store handles deletion, but log the relationship)
+   - Create a "supersedes" edge from the surviving node to each deleted node
+   - Two nodes about the same person or topic but with DIFFERENT details, timestamps, or context are NOT duplicates — leave them both intact.
 
-2. **Downgrade faded memories**: For nodes at "faded" or "gist" fidelity, rewrite their content to be shorter and more abstract — like how a real memory fades. A "faded" memory should be 1-2 sentences. A "gist" memory should be one sentence capturing only the essence.
+2. **Rewrite faded content**: For nodes at "faded" or "gist" fidelity, rewrite their content to be shorter and more abstract — like how a real memory fades. A "faded" memory should be 1-2 sentences. A "gist" memory should be one sentence capturing only the essence.
 
 3. **Update narrative roles**: If a node is clearly a turning point, inciting incident, or thesis in a larger story arc, set its narrativeRole and partOfStory.
 
-4. **Mark gone**: If a node is at "gist" fidelity and has very low significance (< 0.2), mark it for deletion — it's faded beyond usefulness.
-
-5. **Resolve stale prospective nodes**: If a prospective node (type=prospective) is older than 7 days and has no "resolved-by" edge, it's likely a stale commitment. Downgrade its fidelity to "gist" and rewrite it as a past observation (e.g. "Had planned to X" instead of "Need to X"). If it's already at gist with significance < 0.2, mark it for deletion. If the node has an event_date in the past, clear it by setting event_date to null.
+4. **Resolve stale prospective nodes**: If a prospective node (type=prospective) is older than 7 days and has no "resolved-by" edge, downgrade its fidelity to "gist" and rewrite it as a past observation (e.g. "Had planned to X" instead of "Need to X"). If the node has an event_date in the past, clear it by setting event_date to null.
 
 ## Constraints
 
-- Do NOT create new nodes — consolidation only merges, updates, and prunes
+- Do NOT create new nodes — consolidation only merges, updates, and rewrites
 - Do NOT change a node's type
 - Do NOT increase fidelity (memories only fade, never sharpen)
+- Do NOT delete non-duplicate nodes — only delete the non-survivor in a merge. Fading and eventual cleanup are handled by the decay engine, not consolidation.
 - Preserve first-person prose style in content rewrites
 - When merging, keep the node with higher reinforcementCount as the survivor
 
@@ -159,7 +158,7 @@ const CONSOLIDATE_TOOL_SCHEMA = {
       },
       delete_ids: {
         type: "array" as const,
-        description: "Node IDs to delete (merged duplicates, gone memories)",
+        description: "Node IDs to delete (merged duplicates only)",
         items: { type: "string" as const },
       },
       merge_edges: {
@@ -206,17 +205,6 @@ function getTopSignificanceNodes(
     .slice(0, n);
 }
 
-function getDecayedNodes(scopeId: string): MemoryNode[] {
-  const all = queryNodes({
-    scopeId,
-    limit: 10000,
-  });
-  return all.filter(
-    (n) =>
-      (n.fidelity === "faded" || n.fidelity === "gist") && !isCapabilityNode(n),
-  );
-}
-
 function getRandomSample(scopeId: string, n: number = 30): MemoryNode[] {
   const all = queryNodes({
     scopeId,
@@ -286,7 +274,7 @@ async function identifyDuplicateGroups(
     })
     .join("\n");
 
-  const systemPrompt = `You are scanning a list of memory nodes for DUPLICATES — nodes that describe the same event, fact, or topic. Group duplicates together. Two nodes are duplicates if they describe the same underlying thing, even if worded differently. Be aggressive — if in doubt, group them. Only include nodes that have at least one duplicate.`;
+  const systemPrompt = `You are scanning a list of memory nodes for DUPLICATES — nodes that describe the exact same specific event or fact. Group duplicates together. Two nodes are duplicates ONLY if they describe the same underlying thing with substantially the same details. Be conservative — nodes about the same person or topic but with different details, timestamps, or context are NOT duplicates. Only include nodes that have at least one true duplicate.`;
 
   const response = await provider.sendMessage(
     [userMessage(listing)],
@@ -657,7 +645,6 @@ export async function runConsolidation(
   const partitions: Array<{ name: string; nodes: MemoryNode[] }> = [
     { name: "recent", nodes: getRecentNodes(scopeId) },
     { name: "significant", nodes: getTopSignificanceNodes(scopeId) },
-    { name: "decayed", nodes: getDecayedNodes(scopeId) },
     { name: "random", nodes: getRandomSample(scopeId) },
   ];
 

package/src/memory/graph/conversation-graph-memory.ts

@@ -252,6 +252,21 @@ export class ConversationGraphMemory {
     };
   }
 
+  /**
+   * Re-register cached node IDs with the InContextTracker after compaction
+   * WITHOUT modifying messages. Use this at post-agent-loop compaction sites
+   * where the memory block already survives on the original user message
+   * (since `<memory __injected>` is not stripped by stripInjectionsForCompaction).
+   *
+   * Calling reinjectCachedMemory at these sites would inject a duplicate
+   * onto the last user message — which after tool calls is a tool_result,
+   * not the original user message.
+   */
+  retrackCachedNodes(): void {
+    if (this.lastInjectedNodeIds.length === 0) return;
+    this.tracker.add(this.lastInjectedNodeIds);
+  }
+
   /**
    * Main entry point — called on every turn before the LLM sees the messages.
    *

package/src/memory/graph/extraction-job.ts

@@ -9,6 +9,7 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
+import { maybeEnqueueConversationStartersJob } from "../conversation-starters-cadence.js";
 import { asString } from "../job-utils.js";
 import type { MemoryJob } from "../jobs-store.js";
 import { runGraphExtraction } from "./extraction.js";
@@ -64,6 +65,20 @@ export async function graphExtractJob(
       },
       "Graph extraction job complete",
     );
+
+    try {
+      maybeEnqueueConversationStartersJob(scopeId);
+    } catch (cadenceErr) {
+      log.warn(
+        {
+          err:
+            cadenceErr instanceof Error
+              ? cadenceErr.message
+              : String(cadenceErr),
+        },
+        "Conversation starters cadence check failed (non-fatal)",
+      );
+    }
   } catch (err) {
     log.error(
       { conversationId, err: err instanceof Error ? err.message : String(err) },

package/src/memory/graph/extraction.test.ts

@@ -111,6 +111,29 @@ describe("parseExtractionResponse — node creation", () => {
     expect(diff.createNodes[0].stability).toBe(14);
   });
 
+  test("procedural nodes get stability=60", () => {
+    const { diff } = parse({
+      create_nodes: [
+        {
+          content: "ffmpeg needs -ac 2 to force stereo output.",
+          type: "procedural",
+          emotional_charge: {
+            valence: 0,
+            intensity: 0,
+            decay_curve: "linear",
+            decay_rate: 0.05,
+          },
+          significance: 0.5,
+          confidence: 0.9,
+          source_type: "direct",
+        },
+      ],
+      reinforce_node_ids: [],
+    });
+
+    expect(diff.createNodes[0].stability).toBe(60);
+  });
+
   test("clamps significance to [0, 1]", () => {
     const { diff } = parse({
       create_nodes: [

package/src/memory/graph/extraction.ts

@@ -596,6 +596,14 @@ export function parseExtractionResponse(
       node.stability = 5;
     }
 
+    // Procedural nodes (learned skills, how-to knowledge — "ffmpeg needs -ac 2
+    // for stereo") encode facts that stay useful long after the moment they
+    // were learned. Higher initial stability slows Ebbinghaus decay so they
+    // remain retrievable months later without needing explicit reinforcement.
+    if (node.type === "procedural") {
+      node.stability = 60;
+    }
+
     diff.createNodes.push(node);
     const nodeIndex = diff.createNodes.length - 1;
 

package/src/memory/graph/retriever.ts

@@ -25,6 +25,7 @@ import {
   computeTemporalBoost,
   PER_TURN_WEIGHTS,
   scoreCandidate,
+  weightsForContextLoad,
 } from "./scoring.js";
 import { sampleSerendipity } from "./serendipity.js";
 import { getEdgesForNode, getNodesByIds, queryNodes } from "./store.js";
@@ -371,8 +372,9 @@ export async function loadContextMemory(
   opts: ContextLoadOpts,
 ): Promise<ContextLoadResult> {
   const start = Date.now();
-  const maxNodes = opts.maxNodes ?? 40;
-  const serendipitySlots = opts.serendipitySlots ?? 10;
+  const ctxLoadCfg = opts.config.memory.retrieval.injection.contextLoad;
+  const maxNodes = opts.maxNodes ?? ctxLoadCfg.maxNodes;
+  const serendipitySlots = opts.serendipitySlots ?? ctxLoadCfg.serendipitySlots;
   const now = new Date();
   const nowMs = now.getTime();
 
@@ -529,15 +531,19 @@ export async function loadContextMemory(
     const recency = computeRecencyBoost(node, nowMs);
 
     scored.push(
-      scoreCandidate(node, {
-        semanticSimilarity: semanticSim,
-        effectiveSignificance: effectiveSig,
-        emotionalIntensity: node.emotionalCharge.intensity,
-        temporalBoost: normalizedTemporal,
-        recencyBoost: recency,
-        triggerBoost,
-        activationBoost: activation,
-      }),
+      scoreCandidate(
+        node,
+        {
+          semanticSimilarity: semanticSim,
+          effectiveSignificance: effectiveSig,
+          emotionalIntensity: node.emotionalCharge.intensity,
+          temporalBoost: normalizedTemporal,
+          recencyBoost: recency,
+          triggerBoost,
+          activationBoost: activation,
+        },
+        weightsForContextLoad(node),
+      ),
     );
   }
 
@@ -547,13 +553,16 @@ export async function loadContextMemory(
   // 5b. Reserve slots for skill/CLI capabilities. Queried directly from
   // SQLite — no Qdrant vectors needed — so capabilities surface even on
   // fresh assistants whose embedding jobs haven't completed yet.
-  const CAPABILITY_RESERVE = 5;
-  const rawCapabilityNodes = queryNodes({
-    scopeId: opts.scopeId,
-    types: ["procedural"],
-    fidelityNot: ["gone"],
-    limit: CAPABILITY_RESERVE * 4,
-  });
+  const capabilityReserve = ctxLoadCfg.capabilityReserve;
+  const rawCapabilityNodes =
+    capabilityReserve > 0
+      ? queryNodes({
+          scopeId: opts.scopeId,
+          types: ["procedural"],
+          fidelityNot: ["gone"],
+          limit: capabilityReserve * 4,
+        })
+      : [];
 
   // Dedup: both seeding systems may create nodes for the same capability.
   // Extract capability ID from content and keep only the first node per ID.
@@ -574,29 +583,33 @@ export async function loadContextMemory(
 
   // Rank by semantic similarity when a query vector exists
   let selectedCapabilities: MemoryNode[];
-  if (queryVector && capabilityNodes.length > CAPABILITY_RESERVE) {
+  if (queryVector && capabilityNodes.length > capabilityReserve) {
     selectedCapabilities = capabilityNodes
       .map((node) => ({ node, sim: semanticCandidateIds.get(node.id) ?? 0 }))
       .sort((a, b) => b.sim - a.sim)
-      .slice(0, CAPABILITY_RESERVE)
+      .slice(0, capabilityReserve)
       .map((e) => e.node);
   } else {
-    selectedCapabilities = capabilityNodes.slice(0, CAPABILITY_RESERVE);
+    selectedCapabilities = capabilityNodes.slice(0, capabilityReserve);
   }
 
   const reservedCapabilities: ScoredNode[] = selectedCapabilities.map(
     (node) => {
       const existing = scored.find((s) => s.node.id === node.id);
       if (existing) return existing;
-      return scoreCandidate(node, {
-        semanticSimilarity: semanticCandidateIds.get(node.id) ?? 0,
-        effectiveSignificance: computeEffectiveSignificance(node, nowMs),
-        emotionalIntensity: node.emotionalCharge.intensity,
-        temporalBoost: (computeTemporalBoost(node, now) + 1) / 2,
-        recencyBoost: 0,
-        triggerBoost: 0,
-        activationBoost: 0,
-      });
+      return scoreCandidate(
+        node,
+        {
+          semanticSimilarity: semanticCandidateIds.get(node.id) ?? 0,
+          effectiveSignificance: computeEffectiveSignificance(node, nowMs),
+          emotionalIntensity: node.emotionalCharge.intensity,
+          temporalBoost: (computeTemporalBoost(node, now) + 1) / 2,
+          recencyBoost: 0,
+          triggerBoost: 0,
+          activationBoost: 0,
+        },
+        weightsForContextLoad(node),
+      );
     },
   );
 
@@ -987,7 +1000,8 @@ export async function retrieveForTurn(
   // 5b. Reserve slots for capability nodes (skills/CLI).
   // Sourced from vector search candidates — only semantically relevant
   // capabilities compete for reserved slots.
-  const PROCEDURAL_RESERVE = 3;
+  const perTurnCfg = opts.config.memory.retrieval.injection.perTurn;
+  const capabilityReserve = perTurnCfg.capabilityReserve;
 
   const proceduralCandidates = capabilityCandidates
     .filter(({ node }) => !opts.tracker.isInContext(node.id))
@@ -1006,7 +1020,7 @@ export async function retrieveForTurn(
       }
       return true;
     })
-    .slice(0, PROCEDURAL_RESERVE);
+    .slice(0, capabilityReserve);
 
   const proceduralScored: ScoredNode[] = rankedProcedural.map(({ node, sim }) =>
     scoreCandidate(
@@ -1033,8 +1047,14 @@ export async function retrieveForTurn(
   // Sort and apply threshold — pull a wider pool for dedup, then trim
   scored.sort((a, b) => b.score - a.score);
   const INJECTION_THRESHOLD = 0.3;
+  // Hard cap on candidates fed to the dedup LLM — effectively caps maxNodes
   const PRE_DEDUP_POOL = 20;
-  const MAX_INJECTED = 4;
+  const maxGeneralNodes = Math.max(
+    0,
+    perTurnCfg.maxNodes -
+      perTurnCfg.serendipitySlots -
+      proceduralInjected.length,
+  );
   const pool = scored
     .filter((s) => s.score >= INJECTION_THRESHOLD)
     .slice(0, PRE_DEDUP_POOL);
@@ -1042,8 +1062,12 @@ export async function retrieveForTurn(
   // Dedup + rerank with a fast model when the pool is large enough to warrant it
   let injected: ScoredNode[];
   let llmDedupApplied = false;
-  if (pool.length > MAX_INJECTED) {
-    const result = await dedupForTurn(pool, MAX_INJECTED, opts.userLastMessage);
+  if (pool.length > maxGeneralNodes) {
+    const result = await dedupForTurn(
+      pool,
+      maxGeneralNodes,
+      opts.userLastMessage,
+    );
     injected = result.nodes;
     llmDedupApplied = result.llmApplied;
   } else {
@@ -1054,17 +1078,17 @@ export async function retrieveForTurn(
   const generalInjected = injected.filter((s) => !proceduralIds.has(s.node.id));
 
   // Backfill vacated general slots from the remaining pool so we always
-  // return up to MAX_INJECTED general memories when eligible candidates exist.
+  // return up to maxGeneralNodes when eligible candidates exist.
   // Only skip backfill when LLM dedup genuinely ran — it intentionally rejected
   // items as duplicates/irrelevant. When dedupForTurn fell back to a plain
   // top-N slice (no provider, tool call failure), backfill is still appropriate.
-  if (generalInjected.length < MAX_INJECTED && !llmDedupApplied) {
+  if (generalInjected.length < maxGeneralNodes && !llmDedupApplied) {
     const usedIds = new Set([
       ...generalInjected.map((s) => s.node.id),
       ...proceduralIds,
     ]);
     const backfillCandidates = pool.filter((s) => !usedIds.has(s.node.id));
-    const needed = MAX_INJECTED - generalInjected.length;
+    const needed = maxGeneralNodes - generalInjected.length;
     for (let i = 0; i < Math.min(needed, backfillCandidates.length); i++) {
       generalInjected.push(backfillCandidates[i]);
     }
@@ -1073,11 +1097,14 @@ export async function retrieveForTurn(
   const allDeterministic = [...generalInjected, ...proceduralInjected];
   const deterministicIds = new Set(allDeterministic.map((n) => n.node.id));
 
-  // Reserve 1 serendipity slot from scored candidates not in the deterministic set
+  // Reserve serendipity slots from scored candidates not in the deterministic set
   const serendipityPool = scored.filter(
     (s) => s.score >= INJECTION_THRESHOLD && !deterministicIds.has(s.node.id),
   );
-  const serendipityPicks = sampleSerendipity(serendipityPool, 1);
+  const serendipityPicks = sampleSerendipity(
+    serendipityPool,
+    perTurnCfg.serendipitySlots,
+  );
   const allInjected = [...allDeterministic, ...serendipityPicks];
 
   const TOP_N = 20;