@vellumai/assistant 0.6.3 → 0.6.5

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

@@ -5,9 +5,12 @@ import {
   computeEffectiveSignificance,
   computeRecencyBoost,
   computeTemporalBoost,
+  DEFAULT_WEIGHTS,
   PER_TURN_WEIGHTS,
+  PROCEDURAL_WEIGHTS,
   scoreCandidate,
   type ScoringWeights,
+  weightsForContextLoad,
 } from "./scoring.js";
 import type { MemoryNode } from "./types.js";
 
@@ -546,3 +549,186 @@ describe("scoreCandidate", () => {
     expect(result.scoreBreakdown.effectiveSignificance).toBe(0.7);
   });
 });
+
+// ---------------------------------------------------------------------------
+// weightsForContextLoad + PROCEDURAL_WEIGHTS
+// ---------------------------------------------------------------------------
+
+describe("weightsForContextLoad", () => {
+  test("returns PROCEDURAL_WEIGHTS for procedural nodes", () => {
+    const node = makeNode({ type: "procedural" });
+    expect(weightsForContextLoad(node)).toBe(PROCEDURAL_WEIGHTS);
+  });
+
+  test("returns DEFAULT_WEIGHTS for episodic nodes", () => {
+    const node = makeNode({ type: "episodic" });
+    expect(weightsForContextLoad(node)).toBe(DEFAULT_WEIGHTS);
+  });
+
+  test("returns DEFAULT_WEIGHTS for semantic/emotional/prospective/behavioral/narrative/shared nodes", () => {
+    for (const type of [
+      "semantic",
+      "emotional",
+      "prospective",
+      "behavioral",
+      "narrative",
+      "shared",
+    ] as const) {
+      const node = makeNode({ type });
+      expect(weightsForContextLoad(node)).toBe(DEFAULT_WEIGHTS);
+    }
+  });
+});
+
+describe("PROCEDURAL_WEIGHTS", () => {
+  test("weights sum to 1.0", () => {
+    const sum =
+      PROCEDURAL_WEIGHTS.semanticSimilarity +
+      PROCEDURAL_WEIGHTS.effectiveSignificance +
+      PROCEDURAL_WEIGHTS.emotionalIntensity +
+      PROCEDURAL_WEIGHTS.temporalBoost +
+      PROCEDURAL_WEIGHTS.recencyBoost +
+      PROCEDURAL_WEIGHTS.triggerBoost +
+      PROCEDURAL_WEIGHTS.activationBoost;
+    expect(sum).toBeCloseTo(1.0, 5);
+  });
+
+  test("zeroes out emotionalIntensity and temporalBoost", () => {
+    // Procedural memories have no emotional charge and no time-of-day pattern
+    // by nature — grading on these signals is just dead weight.
+    expect(PROCEDURAL_WEIGHTS.emotionalIntensity).toBe(0);
+    expect(PROCEDURAL_WEIGHTS.temporalBoost).toBe(0);
+  });
+
+  test("weights semanticSimilarity and effectiveSignificance more heavily than DEFAULT_WEIGHTS", () => {
+    expect(PROCEDURAL_WEIGHTS.semanticSimilarity).toBeGreaterThan(
+      DEFAULT_WEIGHTS.semanticSimilarity,
+    );
+    expect(PROCEDURAL_WEIGHTS.effectiveSignificance).toBeGreaterThan(
+      DEFAULT_WEIGHTS.effectiveSignificance,
+    );
+  });
+
+  test("procedural node outscores otherwise-identical episodic node under type-aware weights", () => {
+    // A procedural memory with zero emotional charge, zero recency, zero
+    // trigger — all dead signals — should still surface under PROCEDURAL_WEIGHTS
+    // thanks to semantic relevance and significance. Under DEFAULT_WEIGHTS the
+    // same signals would leave ~45% of the budget dead.
+    const proceduralNode = makeNode({ type: "procedural" });
+    const episodicNode = makeNode({ id: "node-2", type: "episodic" });
+
+    // Components a procedural memory typically carries: semantic hit + stable
+    // significance, but no emotional charge, no recency, no trigger.
+    const proceduralComponents = {
+      semanticSimilarity: 0.8,
+      effectiveSignificance: 0.7,
+      emotionalIntensity: 0,
+      temporalBoost: 0.5, // neutral
+      recencyBoost: 0,
+      triggerBoost: 0,
+      activationBoost: 0,
+    };
+
+    const proceduralScore = scoreCandidate(
+      proceduralNode,
+      proceduralComponents,
+      weightsForContextLoad(proceduralNode),
+    ).score;
+    const episodicScore = scoreCandidate(
+      episodicNode,
+      proceduralComponents,
+      weightsForContextLoad(episodicNode),
+    ).score;
+
+    expect(proceduralScore).toBeGreaterThan(episodicScore);
+  });
+
+  test("episodic node with full signal still outscores procedural with only semantic signal", () => {
+    // The change must NOT break episodic retrieval: an episodic memory with
+    // emotional charge + recency + moderate significance should still outrank
+    // a procedural memory that only has semantic relevance.
+    const episodicNode = makeNode({ type: "episodic" });
+    const proceduralNode = makeNode({ id: "node-2", type: "procedural" });
+
+    const episodicComponents = {
+      semanticSimilarity: 0.5,
+      effectiveSignificance: 0.6,
+      emotionalIntensity: 0.7,
+      temporalBoost: 0.6,
+      recencyBoost: 0.9,
+      triggerBoost: 0.4,
+      activationBoost: 0.3,
+    };
+
+    const proceduralComponents = {
+      semanticSimilarity: 0.5,
+      effectiveSignificance: 0.3,
+      emotionalIntensity: 0,
+      temporalBoost: 0.5,
+      recencyBoost: 0,
+      triggerBoost: 0,
+      activationBoost: 0,
+    };
+
+    const episodicScore = scoreCandidate(
+      episodicNode,
+      episodicComponents,
+      weightsForContextLoad(episodicNode),
+    ).score;
+    const proceduralScore = scoreCandidate(
+      proceduralNode,
+      proceduralComponents,
+      weightsForContextLoad(proceduralNode),
+    ).score;
+
+    expect(episodicScore).toBeGreaterThan(proceduralScore);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Regression: DEFAULT_WEIGHTS behavior unchanged
+// ---------------------------------------------------------------------------
+
+describe("DEFAULT_WEIGHTS (regression)", () => {
+  test("weights sum to 1.0", () => {
+    const sum =
+      DEFAULT_WEIGHTS.semanticSimilarity +
+      DEFAULT_WEIGHTS.effectiveSignificance +
+      DEFAULT_WEIGHTS.emotionalIntensity +
+      DEFAULT_WEIGHTS.temporalBoost +
+      DEFAULT_WEIGHTS.recencyBoost +
+      DEFAULT_WEIGHTS.triggerBoost +
+      DEFAULT_WEIGHTS.activationBoost;
+    expect(sum).toBeCloseTo(1.0, 5);
+  });
+
+  test("preserves exact weight values", () => {
+    expect(DEFAULT_WEIGHTS).toEqual({
+      semanticSimilarity: 0.25,
+      effectiveSignificance: 0.15,
+      emotionalIntensity: 0.15,
+      temporalBoost: 0.05,
+      recencyBoost: 0.15,
+      triggerBoost: 0.15,
+      activationBoost: 0.1,
+    });
+  });
+
+  test("scoreCandidate without weights argument uses DEFAULT_WEIGHTS", () => {
+    // Backwards-compat: existing callers that pass no weights argument should
+    // continue to get DEFAULT_WEIGHTS scoring.
+    const node = makeNode({ type: "episodic" });
+    const components = {
+      semanticSimilarity: 1.0,
+      effectiveSignificance: 1.0,
+      emotionalIntensity: 1.0,
+      temporalBoost: 1.0,
+      recencyBoost: 1.0,
+      triggerBoost: 1.0,
+      activationBoost: 1.0,
+    };
+    const implicit = scoreCandidate(node, components).score;
+    const explicit = scoreCandidate(node, components, DEFAULT_WEIGHTS).score;
+    expect(implicit).toBe(explicit);
+  });
+});

package/src/memory/graph/scoring.ts

@@ -166,7 +166,7 @@ export interface ScoringWeights {
 }
 
 /** Weights for context-load (conversation start): balanced across all signals. */
-const DEFAULT_WEIGHTS: ScoringWeights = {
+export const DEFAULT_WEIGHTS: ScoringWeights = {
   semanticSimilarity: 0.25,
   effectiveSignificance: 0.15,
   emotionalIntensity: 0.15,
@@ -176,6 +176,28 @@ const DEFAULT_WEIGHTS: ScoringWeights = {
   activationBoost: 0.1,
 };
 
+/**
+ * Weights for context-load of procedural memories (learned skills, how-to).
+ * Procedural memories have no emotional charge, no time-of-day pattern, and
+ * are often old-but-stable (a workaround learned months ago stays useful).
+ * Grading them on DEFAULT_WEIGHTS wastes ~45% of the budget on signals that
+ * are structurally ~0 for procedurals, causing them to lose out to episodic
+ * and emotional memories that simply have more signals lit up.
+ *
+ * This redistributes the dead weight onto semantic similarity and
+ * significance — the signals that actually differentiate useful procedurals
+ * from stale ones.
+ */
+export const PROCEDURAL_WEIGHTS: ScoringWeights = {
+  semanticSimilarity: 0.45,
+  effectiveSignificance: 0.25,
+  emotionalIntensity: 0.0,
+  temporalBoost: 0.0,
+  recencyBoost: 0.05,
+  triggerBoost: 0.1,
+  activationBoost: 0.15,
+};
+
 /**
  * Weights for per-turn injection: heavily biased toward semantic similarity.
  * Per-turn injections should only surface memories directly relevant to
@@ -191,6 +213,14 @@ export const PER_TURN_WEIGHTS: ScoringWeights = {
   activationBoost: 0.05,
 };
 
+/**
+ * Pick the appropriate context-load weights for a node based on its type.
+ * Procedural nodes use PROCEDURAL_WEIGHTS; everything else uses DEFAULT_WEIGHTS.
+ */
+export function weightsForContextLoad(node: MemoryNode): ScoringWeights {
+  return node.type === "procedural" ? PROCEDURAL_WEIGHTS : DEFAULT_WEIGHTS;
+}
+
 /**
  * Compute the final retrieval score for a candidate node.
  * All components should be in [0, 1] range before weighting.

package/src/memory/graph/store.ts

@@ -358,6 +358,47 @@ export function queryNodes(filters: NodeQueryFilters): MemoryNode[] {
   return query.all().map(rowToNode);
 }
 
+/**
+ * Pull capability (skill / CLI) nodes directly from SQLite, ordered by
+ * significance DESC. Matches the content shapes produced by both the
+ * legacy (`skill:{id}\n`, `cli:{name}\n`) and current
+ * (`The "..." skill (id) is available.`, `The "assistant ..." CLI command`)
+ * seeding systems — keeping the SQL filter in sync with `isCapabilityNode`.
+ *
+ * Used as a cold-start fallback for context-load capability injection when
+ * no semantic-search candidates are capability nodes (e.g. fresh assistants
+ * whose embedding jobs haven't completed yet). The content-pattern filter
+ * prevents organic procedural memories from crowding out real capabilities.
+ */
+export function queryCapabilityNodes(
+  scopeId: string,
+  limit: number,
+): MemoryNode[] {
+  const db = getDb();
+  const rows = db
+    .select()
+    .from(memoryGraphNodes)
+    .where(
+      and(
+        eq(memoryGraphNodes.scopeId, scopeId),
+        eq(memoryGraphNodes.type, "procedural"),
+        sql`${memoryGraphNodes.fidelity} != 'gone'`,
+        or(
+          sql`${memoryGraphNodes.content} LIKE 'skill:%'`,
+          sql`${memoryGraphNodes.content} LIKE 'cli:%'`,
+          and(
+            sql`${memoryGraphNodes.content} LIKE 'The "%'`,
+            sql`${memoryGraphNodes.content} LIKE '% is available.%'`,
+          ),
+        ),
+      ),
+    )
+    .orderBy(sql`${memoryGraphNodes.significance} DESC`)
+    .limit(limit)
+    .all();
+  return rows.map(rowToNode);
+}
+
 /** Count all non-gone nodes in a scope. */
 export function countNodes(scopeId: string): number {
   const db = getDb();

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

@@ -14,6 +14,8 @@ import { getWorkspaceDir } from "../../util/platform.js";
 import { buildExcerpt, buildFtsMatchQuery } from "../conversation-queries.js";
 import { embedWithRetry } from "../embed.js";
 import { generateSparseEmbedding } from "../embedding-backend.js";
+import { enqueuePkbIndexJob } from "../jobs/embed-pkb-file.js";
+import { PKB_WORKSPACE_SCOPE } from "../pkb/types.js";
 import { searchGraphNodes } from "./graph-search.js";
 import { getNodesByIds } from "./store.js";
 
@@ -249,6 +251,7 @@ async function handleArchiveRecall(
 
 export interface RememberInput {
   content: string;
+  finish_turn?: boolean;
 }
 
 export interface RememberResult {
@@ -286,6 +289,7 @@ export function handleRemember(
   // Append to buffer.md
   const bufferPath = join(pkbDir, "buffer.md");
   appendFileSync(bufferPath, entry, "utf-8");
+  enqueuePkbReindex(pkbDir, bufferPath);
 
   // Append to daily archive
   const yyyy = now.getFullYear();
@@ -296,6 +300,29 @@ export function handleRemember(
     appendFileSync(archivePath, `# ${month} ${day}, ${yyyy}\n\n`, "utf-8");
   }
   appendFileSync(archivePath, entry, "utf-8");
+  enqueuePkbReindex(pkbDir, archivePath);
 
   return { success: true, message: "Saved to knowledge base." };
 }
+
+/**
+ * Fire-and-forget enqueue of a PKB re-index job for a file we just wrote.
+ *
+ * Always indexes under {@link PKB_WORKSPACE_SCOPE}. See the comment on that
+ * constant for why PKB points are not per-conversation-scoped.
+ *
+ * Wrapped in try/catch so an enqueue failure (e.g. DB hiccup) cannot break
+ * the remember call — the write has already succeeded and the user's fact
+ * is safe on disk.
+ */
+function enqueuePkbReindex(pkbRoot: string, absPath: string): void {
+  try {
+    enqueuePkbIndexJob({
+      pkbRoot,
+      absPath,
+      memoryScopeId: PKB_WORKSPACE_SCOPE,
+    });
+  } catch (err) {
+    log.warn({ err, absPath }, "Failed to enqueue PKB re-index job");
+  }
+}

package/src/memory/graph/tools.ts

@@ -82,7 +82,7 @@ export const graphRecallDefinition: ToolDefinition = {
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",
   description:
-    "Save a fact to your knowledge base. Call this AGGRESSIVELY — every preference, location, name, date, habit, opinion, health detail, plan, relationship fact, routine, or commitment. The bar is: if you wouldn't want to ask about it again, remember it. Examples: 'Prefers UberEats over DoorDash', 'Lives in NYC, from Texas', 'Takes 45mg nicotine daily, tapering', 'Girlfriend Yen is in Texas', 'Watches vampire show Saturday nights', 'NYU Summit April 10-11'. Call this multiple times per conversation — it's cheap (one line appended to a file). Don't wait until the end. Don't batch. Every new fact, immediately. Remembering too much is infinitely better than forgetting something that mattered.",
+    "Save a fact to your knowledge base. Call this AGGRESSIVELY — capture anything concrete about their life: preferences, locations, names, dates, habits, opinions, health details, plans, relationship facts, routines, commitments. Default to remembering; only skip obvious noise (small talk, hypotheticals, things they're just musing about). Don't judge importance — filing decides that later. Examples: 'Prefers UberEats over DoorDash', 'Lives in NYC, from Texas', 'Takes daily medication, tapering dose', 'Partner Alex lives in Austin', 'Watches a weekly show on Saturday nights', 'Conference in May'. Call this multiple times per conversation — it's cheap (one line appended to a file). Don't wait until the end. Don't batch. Every new fact, immediately. Remembering too much is infinitely better than forgetting something that mattered. CORRECTIONS are the highest priority — when the user corrects a fact you had wrong, `remember` the correction immediately. The wrong version is already propagated in your prior turns and memory graph; skipping a correction means future-you keeps operating on the old value. Never skip a correction even if you'd skip the equivalent fresh fact.",
   input_schema: {
     type: "object",
     properties: {
@@ -91,6 +91,11 @@ export const graphRememberDefinition: ToolDefinition = {
         description:
           "The fact to remember. Write naturally — a preference, a detail, a commitment, a plan. No need to categorize.",
       },
+      finish_turn: {
+        type: "boolean",
+        description:
+          "Set to true ONLY on the final `remember` call when you have nothing else to say and want to hand control back to the user. When true, the assistant turn ends after this tool call and no further LLM call is made. Do NOT set true on intermediate `remember` calls. Default: false.",
+      },
     },
     required: ["content"],
   },

package/src/memory/group-crud.ts

@@ -25,6 +25,11 @@ export interface ConversationGroupRow {
 
 export function listGroups(): ConversationGroupRow[] {
   ensureGroupMigration();
+  // Migration markers are stored as rows in conversation_groups with a leading
+  // underscore (e.g. `_backfill_complete`). System groups use the `system:`
+  // prefix and custom groups use UUIDs, so no legitimate group id starts with
+  // `_`. GLOB treats `_` as literal (unlike LIKE), so `_*` matches any id
+  // whose first character is an underscore.
   const rows = rawAll<{
     id: string;
     name: string;
@@ -33,7 +38,7 @@ export function listGroups(): ConversationGroupRow[] {
     created_at: number;
     updated_at: number;
   }>(
-    "SELECT id, name, sort_position, is_system_group, created_at, updated_at FROM conversation_groups WHERE id NOT IN ('_backfill_complete', '_backfill_all_complete', '_sort_shift_complete') ORDER BY sort_position ASC",
+    "SELECT id, name, sort_position, is_system_group, created_at, updated_at FROM conversation_groups WHERE id NOT GLOB '_*' ORDER BY sort_position ASC",
   );
   return rows.map((r) => ({
     id: r.id,

package/src/memory/indexer.ts

@@ -1,10 +1,13 @@
 import { createHash } from "crypto";
 import { desc, eq } from "drizzle-orm";
 
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
 import type { MemoryConfig } from "../config/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 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 { getDb } from "./db.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
@@ -154,6 +157,7 @@ export async function indexMessageNow(
   // ── Batch extraction tracking ──────────────────────────────────────
   // Instead of per-message extraction, track pending unextracted messages
   // and trigger batch extraction when the threshold is reached or after idle.
+  const isAutoAnalysisSource = isAutoAnalysisConversation(input.conversationId);
   if (
     shouldExtract &&
     isTrustedActor &&
@@ -163,26 +167,89 @@ export async function indexMessageNow(
     const batchSize = config.extraction.batchSize ?? 10;
     const idleTimeoutMs = config.extraction.idleTimeoutMs ?? 300_000;
 
-    // ── 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));
+    // Recursion guard: skip graph extraction + auto-analysis enqueues
+    // when the source conversation is itself an auto-analysis
+    // conversation. The analysis agent writes memory directly via tools,
+    // so extracting from its reflective musings would double-count and
+    // analyzing its own output would loop indefinitely.
+    // Summaries still run — they feed the graph retrieval pipeline and
+    // are not recursion-prone.
+    if (!isAutoAnalysisSource) {
+      // ── 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));
 
-    if (graphPendingCount >= batchSize) {
-      enqueueMemoryJob("graph_extract", {
+      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.
+      upsertDebouncedJob(
+        "graph_extract",
+        {
+          conversationId: input.conversationId,
+          scopeId: input.scopeId ?? "default",
+        },
+        graphBatchFired ? Date.now() : Date.now() + idleTimeoutMs,
+      );
+
+      // ── Auto-analysis triggers ─────────────────────────────────────
+      // Immediate triggers (batch, compaction) and debounced triggers
+      // (idle, lifecycle) write to separate rows keyed by triggerGroup
+      // via `upsertAutoAnalysisJob`. When an immediate trigger fires,
+      // it cancels any pending debounced row for the same conversation
+      // to avoid redundant analysis runs.
+      enqueueAutoAnalysisIfEnabled({
         conversationId: input.conversationId,
-        scopeId: input.scopeId ?? "default",
+        trigger: "idle",
       });
-      setMemoryCheckpoint(graphPendingKey, "0");
-    }
 
-    upsertDebouncedJob(
-      "graph_extract",
-      { conversationId: input.conversationId },
-      Date.now() + idleTimeoutMs,
-    );
+      // Auto-analysis cadence is tracked by its own pending-count
+      // checkpoint so it fires at `analysis.batchSize` (default 30).
+      // Gated behind the `auto-analyze` feature flag so the counter
+      // does not accumulate stale counts while the flag is off — if it
+      // did, flipping the flag on would trigger an immediate batch from
+      // messages buffered during the disabled period. Reading config
+      // here is best-effort: if it fails we skip the batch trigger
+      // (the idle-debounced enqueue above still runs).
+      let analysisConfig: ReturnType<typeof getConfig> | null = null;
+      try {
+        analysisConfig = getConfig();
+      } catch (err) {
+        log.debug(
+          { err, conversationId: input.conversationId },
+          "Skipping auto-analysis batch trigger: failed to load config",
+        );
+      }
+      if (
+        analysisConfig != null &&
+        isAssistantFeatureFlagEnabled("auto-analyze", analysisConfig)
+      ) {
+        const analysisBatchSize = analysisConfig.analysis.batchSize;
+        const analysisPendingKey = `conversation_analyze:${input.conversationId}:pending_count`;
+        const analysisCurrentVal = getMemoryCheckpoint(analysisPendingKey);
+        const analysisPendingCount =
+          (analysisCurrentVal ? parseInt(analysisCurrentVal, 10) : 0) + 1;
+        setMemoryCheckpoint(analysisPendingKey, String(analysisPendingCount));
+
+        if (analysisPendingCount >= analysisBatchSize) {
+          setMemoryCheckpoint(analysisPendingKey, "0");
+          enqueueAutoAnalysisIfEnabled({
+            conversationId: input.conversationId,
+            trigger: "batch",
+          });
+        }
+      }
+    }
 
     // ── Conversation summarization (independent of extraction) ────────
     // Summaries feed the graph retrieval pipeline via fetchRecentSummaries().
@@ -228,6 +295,18 @@ export async function indexMessageNow(
     );
   }
 
+  if (
+    isAutoAnalysisSource &&
+    shouldExtract &&
+    isTrustedActor &&
+    !input.automated &&
+    config.extraction.useLLM
+  ) {
+    log.debug(
+      "Skipping graph_extract + auto-analysis enqueues: source is an auto-analysis conversation",
+    );
+  }
+
   const storedSegments = segments.length - skippedShortSegments;
   const enqueuedJobs = storedSegments - skippedEmbedJobs + mediaBlocks.length;
   return {

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

@@ -17,15 +17,18 @@ export function pruneOldLlmRequestLogsJob(
   job: MemoryJob,
   config: AssistantConfig,
 ): void {
+  const rawRetention = job.payload.retentionMs;
   const retentionMs =
-    typeof job.payload.retentionMs === "number" &&
-    Number.isFinite(job.payload.retentionMs) &&
-    job.payload.retentionMs >= 0
-      ? job.payload.retentionMs
-      : config.memory.cleanup.llmRequestLogRetentionMs;
-
-  // 0 means disabled
-  if (retentionMs === 0) return;
+    rawRetention === null
+      ? null
+      : typeof rawRetention === "number" &&
+          Number.isFinite(rawRetention) &&
+          rawRetention >= 0
+        ? rawRetention
+        : config.memory.cleanup.llmRequestLogRetentionMs;
+
+  // null means "keep forever" — skip pruning entirely
+  if (retentionMs === null || retentionMs === undefined) return;
 
   const cutoffMs = Date.now() - retentionMs;