@vellumai/assistant 0.6.2 → 0.6.4

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.test.ts

@@ -179,10 +179,12 @@ describe("node CRUD", () => {
     expect(updated!.eventDate).toBeNull();
   });
 
-  test("deleteNode removes the node", () => {
+  test("deleteNode soft-deletes the node by setting fidelity to gone", () => {
     const node = createNode(makeNewNode());
     deleteNode(node.id);
-    expect(getNode(node.id)).toBeNull();
+    const deleted = getNode(node.id);
+    expect(deleted).not.toBeNull();
+    expect(deleted!.fidelity).toBe("gone");
   });
 });
 
@@ -755,7 +757,9 @@ describe("applyDiff", () => {
       reinforceNodeIds: [],
     });
     expect(result.nodesDeleted).toBe(1);
-    expect(getNode(node.id)).toBeNull();
+    const deleted = getNode(node.id);
+    expect(deleted).not.toBeNull();
+    expect(deleted!.fidelity).toBe("gone");
   });
 
   test("updates nodes", () => {

package/src/memory/graph/store.ts

@@ -2,10 +2,11 @@
 // Memory Graph — Data access layer
 // ---------------------------------------------------------------------------
 
-import { and, desc, eq, inArray, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../db.js";
+import { enqueueMemoryJob } from "../jobs-store.js";
 import {
   memoryGraphEdges,
   memoryGraphNodeEdits,
@@ -270,7 +271,14 @@ export function updateNode(
 
 export function deleteNode(id: string): void {
   const db = getDb();
-  db.delete(memoryGraphNodes).where(eq(memoryGraphNodes.id, id)).run();
+  db.update(memoryGraphNodes)
+    .set({ fidelity: "gone", lastAccessed: Date.now() })
+    .where(eq(memoryGraphNodes.id, id))
+    .run();
+  enqueueMemoryJob("delete_qdrant_vectors", {
+    targetType: "graph_node",
+    targetId: id,
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -343,7 +351,7 @@ export function queryNodes(filters: NodeQueryFilters): MemoryNode[] {
     .where(conditions.length > 0 ? and(...conditions) : undefined)
     .orderBy(sql`${memoryGraphNodes.significance} DESC`);
 
-  if (filters.limit) {
+  if (filters.limit != null) {
     query = query.limit(filters.limit) as typeof query;
   }
 
@@ -396,12 +404,19 @@ export function getEdgesForNode(
   direction?: "incoming" | "outgoing",
 ): MemoryEdge[] {
   const db = getDb();
-  const condition =
+  const dirCondition =
     direction === "outgoing"
       ? eq(memoryGraphEdges.sourceNodeId, nodeId)
       : direction === "incoming"
         ? eq(memoryGraphEdges.targetNodeId, nodeId)
-        : sql`${memoryGraphEdges.sourceNodeId} = ${nodeId} OR ${memoryGraphEdges.targetNodeId} = ${nodeId}`;
+        : or(eq(memoryGraphEdges.sourceNodeId, nodeId), eq(memoryGraphEdges.targetNodeId, nodeId));
+
+  // Exclude edges where either endpoint has fidelity='gone' (soft-deleted)
+  const condition = and(
+    dirCondition,
+    sql`NOT EXISTS (SELECT 1 FROM ${memoryGraphNodes} WHERE ${memoryGraphNodes.id} = ${memoryGraphEdges.sourceNodeId} AND ${memoryGraphNodes.fidelity} = 'gone')`,
+    sql`NOT EXISTS (SELECT 1 FROM ${memoryGraphNodes} WHERE ${memoryGraphNodes.id} = ${memoryGraphEdges.targetNodeId} AND ${memoryGraphNodes.fidelity} = 'gone')`,
+  );
 
   return db
     .select()
@@ -512,12 +527,23 @@ export function getActiveTriggersByType(
     return rows.map((r) => rowToTrigger(r.trigger));
   }
 
-  return db
-    .select()
+  const rows = db
+    .select({
+      trigger: memoryGraphTriggers,
+    })
     .from(memoryGraphTriggers)
-    .where(and(...conditions))
-    .all()
-    .map(rowToTrigger);
+    .innerJoin(
+      memoryGraphNodes,
+      eq(memoryGraphTriggers.nodeId, memoryGraphNodes.id),
+    )
+    .where(
+      and(
+        ...conditions,
+        sql`${memoryGraphNodes.fidelity} != 'gone'`,
+      ),
+    )
+    .all();
+  return rows.map((r) => rowToTrigger(r.trigger));
 }
 
 // ---------------------------------------------------------------------------
@@ -614,9 +640,18 @@ export function applyDiff(
   };
 
   db.transaction((tx) => {
-    // Delete nodes first (cascades edges + triggers)
+    // Soft-delete nodes (set fidelity='gone' and enqueue Qdrant cleanup)
     for (const id of diff.deleteNodeIds) {
-      tx.delete(memoryGraphNodes).where(eq(memoryGraphNodes.id, id)).run();
+      tx.update(memoryGraphNodes)
+        .set({ fidelity: "gone", lastAccessed: Date.now() })
+        .where(eq(memoryGraphNodes.id, id))
+        .run();
+      enqueueMemoryJob(
+        "delete_qdrant_vectors",
+        { targetType: "graph_node", targetId: id },
+        Date.now(),
+        tx,
+      );
       result.nodesDeleted++;
     }
 

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 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. 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: {

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 ─────────────────────────────────────
+      // Both triggers route through `upsertDebouncedJob` in the helper,
+      // so a single pending row is shared. Order matters: the idle
+      // upsert runs first (pushing `runAfter` into the future); the
+      // batch trigger runs last so a threshold crossing pulls
+      // `runAfter` back to "now" and overrides the idle debounce.
+      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;