@vellumai/assistant 0.6.0 → 0.6.2

package/src/memory/graph/bootstrap.ts

@@ -13,18 +13,18 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { and, asc, ne, sql } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
 
 import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
-import { getDb, rawAll } from "../db.js";
+import { getDb, rawAll, rawGet, rawRun } from "../db.js";
 import { enqueueMemoryJob, hasActiveJobOfType } from "../jobs-store.js";
 import { initQdrantClient } from "../qdrant-client.js";
 import { conversations, memoryGraphNodes, memorySegments } from "../schema.js";
 import { runGraphExtraction } from "./extraction.js";
-import { countNodes, createNode } from "./store.js";
-import type { NewNode } from "./types.js";
+import { countNodes } from "./store.js";
 
 const log = getLogger("graph-bootstrap");
 
@@ -61,7 +61,7 @@ export interface BootstrapResult {
  * if interrupted, re-run and it picks up where it left off.
  */
 export async function bootstrapFromHistory(
-  options?: BootstrapOptions
+  options?: BootstrapOptions,
 ): Promise<BootstrapResult> {
   const start = Date.now();
   const scopeId = options?.scopeId ?? "default";
@@ -106,7 +106,7 @@ export async function bootstrapFromHistory(
 
   log.info(
     { total: allConversations.length },
-    "Starting graph bootstrap from historical conversations"
+    "Starting graph bootstrap from historical conversations",
   );
 
   // Resume from checkpoint
@@ -148,7 +148,7 @@ export async function bootstrapFromHistory(
           skipQdrant: true, // Use DB query for candidates (no Qdrant dependency)
           conversationTimestamp: conv.createdAt, // Use actual conversation time
           embedInline: true, // Embed synchronously so nodes are searchable immediately
-        }
+        },
       );
 
       result.totalNodesCreated += extractionResult.nodesCreated;
@@ -171,14 +171,14 @@ export async function bootstrapFromHistory(
             nodes: nodeCount,
             elapsed: `${((Date.now() - start) / 1000).toFixed(1)}s`,
           },
-          "Bootstrap progress"
+          "Bootstrap progress",
         );
       }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       log.warn(
         { conversationId: conv.id, err: errMsg },
-        "Failed to extract conversation, continuing"
+        "Failed to extract conversation, continuing",
       );
       result.errors.push({ conversationId: conv.id, error: errMsg });
 
@@ -199,7 +199,7 @@ export async function bootstrapFromHistory(
       errors: result.errors.length,
       elapsedMs: result.elapsedMs,
     },
-    "Graph bootstrap complete"
+    "Graph bootstrap complete",
   );
 
   return result;
@@ -209,7 +209,7 @@ export async function bootstrapFromHistory(
  * Also extract from journal files on disk.
  */
 export async function bootstrapFromJournal(
-  scopeId: string = "default"
+  scopeId: string = "default",
 ): Promise<{ extracted: number; errors: number }> {
   const config = getConfig();
   const journalDir = join(getWorkspaceDir(), "journal");
@@ -227,7 +227,7 @@ export async function bootstrapFromJournal(
         (f) =>
           f.endsWith(".md") &&
           !f.startsWith(".") &&
-          f.toLowerCase() !== "readme.md"
+          f.toLowerCase() !== "readme.md",
       );
     } catch {
       continue;
@@ -248,7 +248,7 @@ export async function bootstrapFromJournal(
       } catch (err) {
         log.warn(
           { file, slug, err: err instanceof Error ? err.message : String(err) },
-          "Failed to extract journal entry"
+          "Failed to extract journal entry",
         );
         errors++;
       }
@@ -289,8 +289,8 @@ function parseJournalDate(filename: string): number {
 
   return new Date(
     `${year}-${month}-${day}T${String(hours).padStart(2, "0")}:${String(
-      minutes
-    ).padStart(2, "0")}:00`
+      minutes,
+    ).padStart(2, "0")}:00`,
   ).getTime();
 }
 
@@ -320,8 +320,8 @@ export function maybeEnqueueGraphBootstrap(): void {
       .where(
         and(
           ne(memoryGraphNodes.type, "procedural"),
-          sql`${memoryGraphNodes.fidelity} != 'gone'`
-        )
+          sql`${memoryGraphNodes.fidelity} != 'gone'`,
+        ),
       )
       .get()?.count ?? 0;
 
@@ -343,7 +343,7 @@ export function maybeEnqueueGraphBootstrap(): void {
 
   log.info(
     { segmentCount, hasJournalFiles },
-    "Graph empty with historical data — enqueueing bootstrap"
+    "Graph empty with historical data — enqueueing bootstrap",
   );
   enqueueMemoryJob("graph_bootstrap", {});
 }
@@ -379,6 +379,11 @@ const KIND_TO_PREFIX: Record<string, string> = {
  *
  * Idempotent: uses a checkpoint to run only once. Skips items whose
  * sourceKey already exists in the graph.
+ *
+ * Uses raw SQL for the INSERT to avoid coupling to the evolving Drizzle
+ * schema. ORM-based inserts include every column in the schema definition,
+ * so adding a column in a later migration would cause this migration to
+ * fail with "table has no column named …" on upgrade paths.
  */
 export function migrateToolCreatedItems(): void {
   if (getMemoryCheckpoint(MIGRATE_ITEMS_CHECKPOINT)) return;
@@ -392,12 +397,15 @@ export function migrateToolCreatedItems(): void {
       `SELECT id, kind, subject, statement, confidence, importance, scope_id, first_seen_at
        FROM memory_items
        WHERE kind IN (${placeholders}) AND status = 'active'`,
-      ...kinds
+      ...kinds,
     );
-  } catch {
+  } catch (err) {
     // Table may not exist (fresh install) — nothing to migrate
-    setMemoryCheckpoint(MIGRATE_ITEMS_CHECKPOINT, "done");
-    return;
+    if (err instanceof Error && err.message.includes("no such table")) {
+      setMemoryCheckpoint(MIGRATE_ITEMS_CHECKPOINT, "done");
+      return;
+    }
+    throw err;
   }
 
   if (rows.length === 0) {
@@ -405,7 +413,6 @@ export function migrateToolCreatedItems(): void {
     return;
   }
 
-  const db = getDb();
   let migrated = 0;
 
   for (const row of rows) {
@@ -413,55 +420,57 @@ export function migrateToolCreatedItems(): void {
     if (!prefix) continue;
 
     // Build content in the format the new tools expect
-    const content =
-      row.kind === "playbook"
-        ? `${row.subject}\n${row.statement}`
-        : `${row.subject}: ${row.statement}`;
+    const content = `${row.subject}\n${row.statement}`;
 
     // Check if already migrated (sourceKey exists in graph)
     const sourceKey = `${prefix}${row.id}`;
-    const existing = db
-      .select({ id: memoryGraphNodes.id })
-      .from(memoryGraphNodes)
-      .where(
-        sql`${memoryGraphNodes.sourceConversations} LIKE ${
-          "%" + sourceKey + "%"
-        }`
-      )
-      .get();
+    const existing = rawGet<{ id: string }>(
+      `SELECT id FROM memory_graph_nodes WHERE source_conversations LIKE ?`,
+      `%${sourceKey}%`,
+    );
     if (existing) continue;
 
     const now = Date.now();
-    const node: NewNode = {
+    const id = uuid();
+    const emotionalCharge = JSON.stringify({
+      valence: 0,
+      intensity: 0.1,
+      decayCurve: "linear",
+      decayRate: 0.05,
+      originalIntensity: 0.1,
+    });
+
+    rawRun(
+      `INSERT INTO memory_graph_nodes (
+        id, content, type, created, last_accessed, last_consolidated,
+        event_date, emotional_charge, fidelity, confidence, significance,
+        stability, reinforcement_count, last_reinforced,
+        source_conversations, source_type, narrative_role, part_of_story,
+        image_refs, scope_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      id,
       content,
-      type: "semantic",
-      created: row.first_seen_at || now,
-      lastAccessed: now,
-      lastConsolidated: now,
-      eventDate: null,
-      emotionalCharge: {
-        valence: 0,
-        intensity: 0.1,
-        decayCurve: "linear",
-        decayRate: 0.05,
-        originalIntensity: 0.1,
-      },
-      fidelity: "vivid",
-      confidence: row.confidence,
-      significance: row.importance,
-      stability: 14,
-      reinforcementCount: 0,
-      lastReinforced: now,
-      sourceConversations: [sourceKey],
-      sourceType: "direct",
-      narrativeRole: null,
-      partOfStory: null,
-      imageRefs: null,
-      scopeId: row.scope_id || "default",
-    };
-
-    const created = createNode(node);
-    enqueueMemoryJob("embed_graph_node", { nodeId: created.id });
+      "semantic",
+      row.first_seen_at || now,
+      now,
+      now,
+      null,
+      emotionalCharge,
+      "vivid",
+      row.confidence,
+      row.importance,
+      14,
+      0,
+      now,
+      JSON.stringify([sourceKey]),
+      "direct",
+      null,
+      null,
+      null,
+      row.scope_id || "default",
+    );
+
+    enqueueMemoryJob("embed_graph_node", { nodeId: id });
     migrated++;
   }
 
@@ -470,7 +479,7 @@ export function migrateToolCreatedItems(): void {
   if (migrated > 0) {
     log.info(
       { migrated, total: rows.length },
-      "Migrated tool-created items to graph nodes"
+      "Migrated tool-created items to graph nodes",
     );
   }
 }
@@ -506,7 +515,7 @@ export async function cleanupStaleItemVectors(): Promise<void> {
   } catch (err) {
     log.warn(
       { err: err instanceof Error ? err.message : String(err) },
-      "Failed to clean up stale item vectors — will retry on next startup"
+      "Failed to clean up stale item vectors — will retry on next startup",
     );
   }
 }

package/src/memory/graph/capability-seed.ts

@@ -2,17 +2,22 @@
 // Memory Graph — Capability seeding for skills and CLI commands
 //
 // Creates graph nodes for skill/CLI capabilities so they participate in
-// semantic retrieval. Mirrors the old memoryItems-based seeding in
-// skill-memory.ts and cli-memory.ts.
+// semantic retrieval.
 // ---------------------------------------------------------------------------
 
-import { and, eq, like } from "drizzle-orm";
+import { and, eq, like, sql } from "drizzle-orm";
 
 import { buildCliProgram } from "../../cli/program.js";
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { resolveSkillStates } from "../../config/skill-state.js";
 import { loadSkillCatalog } from "../../config/skills.js";
 import {
+  getCachedCatalogSync,
+  getCatalog,
+} from "../../skills/catalog-cache.js";
+import {
+  fromCatalogSkill,
   fromSkillSummary,
   type SkillCapabilityInput,
 } from "../../skills/skill-memory.js";
@@ -24,6 +29,9 @@ import { createNode } from "./store.js";
 
 const log = getLogger("graph-capability-seed");
 
+/** Default significance for capability nodes. */
+const CAPABILITY_SIGNIFICANCE = 0.6;
+
 /** Stable prefix for capability node source tracking. */
 const SKILL_SOURCE_PREFIX = "capability:skill:";
 const CLI_SOURCE_PREFIX = "capability:cli:";
@@ -107,11 +115,38 @@ export function seedSkillGraphNodes(): void {
       seenKeys.add(`${SKILL_SOURCE_PREFIX}${summary.id}`);
     }
 
-    // Always prune stale capability nodes — this cleans up nodes from
-    // previously-seeded uninstalled skills that are no longer refreshed.
-    // seenKeys already contains all locally-installed-and-enabled skills
-    // which is sufficient to identify what should be kept.
-    pruneStaleCapabilities(SKILL_SOURCE_PREFIX, seenKeys);
+    // Protect uninstalled catalog skills from pruning — they are seeded
+    // asynchronously by seedUninstalledCatalogSkillMemories() and should
+    // not be marked as "gone" just because they aren't locally installed.
+    // When the catalog cache is cold (empty before the async fetch
+    // completes), we can only prune locally managed skills; full
+    // catalog-based pruning waits until the cache is populated.
+    const cachedCatalog = getCachedCatalogSync();
+    if (cachedCatalog.length === 0) {
+      // Catalog cache is cold — we can't enumerate remote catalog skills, so
+      // skip catalog-based pruning to avoid incorrectly marking valid
+      // uninstalled catalog nodes as gone. But still prune locally disabled
+      // skills so stale capability nodes don't linger after cold start.
+      log.info("Catalog cache is cold — pruning only locally disabled skills");
+      const disabled = resolved.filter((r) => r.state !== "enabled");
+      for (const { summary } of disabled) {
+        deleteSkillCapabilityNode(summary.id);
+      }
+    } else {
+      for (const entry of cachedCatalog) {
+        const flagKey = entry.metadata?.vellum?.["feature-flag"];
+        if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config))
+          continue;
+        seenKeys.add(`${SKILL_SOURCE_PREFIX}${entry.id}`);
+      }
+      pruneStaleCapabilities(SKILL_SOURCE_PREFIX, seenKeys);
+    }
+
+    // Clean up old-format capability nodes (skill:* and cli:*) that use the
+    // legacy "{prefix}:{id}\n..." content format. Mark them as gone so they
+    // stop appearing as duplicates. Idempotent — once cleaned, subsequent
+    // runs find nothing.
+    cleanupOldFormatCapabilityNodes();
   } catch (err) {
     log.warn({ err }, "Failed to seed skill graph nodes");
   }
@@ -121,9 +156,9 @@ export function seedSkillGraphNodes(): void {
  * Seed graph nodes for all CLI commands.
  * Prunes stale nodes whose commands are no longer registered.
  */
-export function seedCliGraphNodes(): void {
+export async function seedCliGraphNodes(): Promise<void> {
   try {
-    const program = buildCliProgram();
+    const program = await buildCliProgram();
 
     const seenKeys = new Set<string>();
     for (const cmd of program.commands) {
@@ -137,6 +172,34 @@ export function seedCliGraphNodes(): void {
   }
 }
 
+/**
+ * Seed capability graph nodes for catalog skills that are not yet installed.
+ * This makes uninstalled skills discoverable via memory injection so the LLM
+ * can auto-install them via skill_load when relevant.
+ * Best-effort: errors are logged but never thrown.
+ */
+export async function seedUninstalledCatalogSkillMemories(): Promise<void> {
+  try {
+    const fullCatalog = await getCatalog();
+    if (fullCatalog.length === 0) return;
+
+    const installedCatalog = loadSkillCatalog();
+    const installedIds = new Set(installedCatalog.map((s) => s.id));
+
+    const config = getConfig();
+    for (const entry of fullCatalog) {
+      if (installedIds.has(entry.id)) continue;
+
+      const flagKey = entry.metadata?.vellum?.["feature-flag"];
+      if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config)) continue;
+
+      upsertSkillCapabilityNode(entry.id, fromCatalogSkill(entry));
+    }
+  } catch (err) {
+    log.warn({ err }, "Failed to seed uninstalled catalog skill memories");
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -172,7 +235,7 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
     .where(
       and(
         eq(memoryGraphNodes.scopeId, "default"),
-        like(memoryGraphNodes.sourceConversations, `%${sourceKey}%`),
+        eq(memoryGraphNodes.sourceConversations, JSON.stringify([sourceKey])),
       ),
     )
     .get();
@@ -181,9 +244,15 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
 
   if (existing) {
     if (existing.content === content && existing.fidelity !== "gone") {
-      // Same content — just touch lastAccessed
+      // Same content — just touch lastAccessed (and backfill lastConsolidated
+      // for nodes created before the fix so they don't decay immediately,
+      // and backfill significance for nodes created before the raise to 0.6)
+      const updates: Record<string, number> = { lastAccessed: now };
+      if (existing.lastConsolidated === 0) updates.lastConsolidated = now;
+      if (existing.significance < CAPABILITY_SIGNIFICANCE)
+        updates.significance = CAPABILITY_SIGNIFICANCE;
       db.update(memoryGraphNodes)
-        .set({ lastAccessed: now })
+        .set(updates)
         .where(eq(memoryGraphNodes.id, existing.id))
         .run();
       return;
@@ -195,6 +264,7 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
         content,
         fidelity: "vivid",
         lastAccessed: now,
+        ...(existing.lastConsolidated === 0 ? { lastConsolidated: now } : {}),
       })
       .where(eq(memoryGraphNodes.id, existing.id))
       .run();
@@ -208,7 +278,7 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
     type: "procedural" as const,
     created: now,
     lastAccessed: now,
-    lastConsolidated: 0,
+    lastConsolidated: now,
     eventDate: null,
     emotionalCharge: {
       valence: 0,
@@ -219,7 +289,7 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
     },
     fidelity: "vivid" as const,
     confidence: 1.0,
-    significance: 0.3,
+    significance: CAPABILITY_SIGNIFICANCE,
     stability: 1000, // Effectively permanent — never decays
     reinforcementCount: 0,
     lastReinforced: now,
@@ -246,7 +316,7 @@ function deleteCapabilityNode(sourceKey: string): void {
     .where(
       and(
         eq(memoryGraphNodes.scopeId, "default"),
-        like(memoryGraphNodes.sourceConversations, `%${sourceKey}%`),
+        eq(memoryGraphNodes.sourceConversations, JSON.stringify([sourceKey])),
       ),
     )
     .get();
@@ -256,6 +326,79 @@ function deleteCapabilityNode(sourceKey: string): void {
       .set({ fidelity: "gone", lastAccessed: Date.now() })
       .where(eq(memoryGraphNodes.id, existing.id))
       .run();
+    enqueueMemoryJob("delete_qdrant_vectors", {
+      targetType: "graph_node",
+      targetId: existing.id,
+    });
+  }
+}
+
+/**
+ * Find and soft-delete old-format capability memory nodes (skill:* and cli:*).
+ *
+ * The legacy system stored content as "skill:{id}\n{statement}" or
+ * "cli:{command}\n{statement}". The current system uses prose format.
+ * This marks any remaining old-format nodes as gone so they no longer
+ * surface in retrieval.
+ */
+function cleanupOldFormatCapabilityNodes(): void {
+  const db = getDb();
+  const now = Date.now();
+
+  // --- skill:* old-format nodes ---
+  const oldFormatNodes = db
+    .select()
+    .from(memoryGraphNodes)
+    .where(
+      and(
+        eq(memoryGraphNodes.type, "procedural"),
+        eq(memoryGraphNodes.scopeId, "default"),
+        sql`${memoryGraphNodes.fidelity} != 'gone'`,
+        sql`${memoryGraphNodes.content} LIKE 'skill:%'`,
+      ),
+    )
+    .all();
+
+  for (const node of oldFormatNodes) {
+    // Verify this is truly old-format: "skill:{id}\n..."
+    if (!/^skill:\S+\n/.test(node.content)) continue;
+
+    db.update(memoryGraphNodes)
+      .set({ fidelity: "gone", lastAccessed: now })
+      .where(eq(memoryGraphNodes.id, node.id))
+      .run();
+    enqueueMemoryJob("delete_qdrant_vectors", {
+      targetType: "graph_node",
+      targetId: node.id,
+    });
+    log.info({ nodeId: node.id }, "Cleaned up old-format skill memory node");
+  }
+
+  // --- cli:* old-format nodes ---
+  const oldCliNodes = db
+    .select()
+    .from(memoryGraphNodes)
+    .where(
+      and(
+        eq(memoryGraphNodes.type, "procedural"),
+        eq(memoryGraphNodes.scopeId, "default"),
+        sql`${memoryGraphNodes.fidelity} != 'gone'`,
+        sql`${memoryGraphNodes.content} LIKE 'cli:%'`,
+      ),
+    )
+    .all();
+
+  for (const node of oldCliNodes) {
+    if (!/^cli:\S+\n/.test(node.content)) continue;
+    db.update(memoryGraphNodes)
+      .set({ fidelity: "gone", lastAccessed: now })
+      .where(eq(memoryGraphNodes.id, node.id))
+      .run();
+    enqueueMemoryJob("delete_qdrant_vectors", {
+      targetType: "graph_node",
+      targetId: node.id,
+    });
+    log.info({ nodeId: node.id }, "Cleaned up old-format CLI memory node");
   }
 }
 
@@ -284,11 +427,18 @@ function pruneStaleCapabilities(prefix: string, activeKeys: Set<string>): void {
       const sources = JSON.parse(row.sourceConversations as string);
       const key = Array.isArray(sources) ? sources[0] : null;
       if (key && typeof key === "string" && !activeKeys.has(key)) {
-        log.info({ sourceKey: key, nodeId: row.id }, "Pruning stale capability graph node");
+        log.info(
+          { sourceKey: key, nodeId: row.id },
+          "Pruning stale capability graph node",
+        );
         db.update(memoryGraphNodes)
           .set({ fidelity: "gone", lastAccessed: now })
           .where(eq(memoryGraphNodes.id, row.id))
           .run();
+        enqueueMemoryJob("delete_qdrant_vectors", {
+          targetType: "graph_node",
+          targetId: row.id,
+        });
       }
     } catch {
       // Skip malformed JSON

package/src/memory/graph/consolidation.ts

@@ -19,13 +19,16 @@ import {
 } from "../../providers/provider-send-message.js";
 import { BackendUnavailableError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
+import { getDb } from "../db.js";
 import { parseEpochMs } from "./extraction.js";
 import {
   createTrigger,
+  deduplicateParagraphs,
   deleteNode,
   getEdgesForNode,
   getTriggersForNode,
   queryNodes,
+  recordNodeEdit,
   updateNode,
 } from "./store.js";
 import type { MemoryNode } from "./types.js";
@@ -60,7 +63,11 @@ function buildConsolidationPrompt(
           ? ` eventDate=${new Date(n.eventDate).toISOString().split("T")[0]}`
           : "";
       const imageStr = n.hasImage ? " [has_image]" : "";
-      return `  [${n.id}] type=${n.type} sig=${n.significance.toFixed(2)} fidelity=${n.fidelity} reinforced=${n.reinforcementCount}x age=${age}d${eventStr}${imageStr}\n    ${n.content}`;
+      return `  [${n.id}] type=${n.type} sig=${n.significance.toFixed(
+        2,
+      )} fidelity=${n.fidelity} reinforced=${
+        n.reinforcementCount
+      }x age=${age}d${eventStr}${imageStr}\n    ${n.content}`;
     })
     .join("\n\n");
 
@@ -194,7 +201,9 @@ function getTopSignificanceNodes(
     scopeId,
     fidelityNot: ["gone"],
     minSignificance: 0.6,
-  }).filter((n) => !isCapabilityNode(n)).slice(0, n);
+  })
+    .filter((n) => !isCapabilityNode(n))
+    .slice(0, n);
 }
 
 function getDecayedNodes(scopeId: string): MemoryNode[] {
@@ -202,7 +211,10 @@ function getDecayedNodes(scopeId: string): MemoryNode[] {
     scopeId,
     limit: 10000,
   });
-  return all.filter((n) => (n.fidelity === "faded" || n.fidelity === "gist") && !isCapabilityNode(n));
+  return all.filter(
+    (n) =>
+      (n.fidelity === "faded" || n.fidelity === "gist") && !isCapabilityNode(n),
+  );
 }
 
 function getRandomSample(scopeId: string, n: number = 30): MemoryNode[] {
@@ -506,8 +518,30 @@ async function consolidateChunk(
 
     if (Object.keys(changes).length > 1) {
       // more than just lastConsolidated
-      updateNode(update.id, changes);
+
+      // Wrap edit recording + node update in a transaction so they are atomic:
+      // if updateNode fails, the edit record is rolled back.
+      getDb().transaction(() => {
+        if (changes.content) {
+          const cleanContent = deduplicateParagraphs(changes.content);
+          const node = nodeMap.get(update.id);
+          if (node && node.content !== cleanContent) {
+            recordNodeEdit({
+              nodeId: update.id,
+              previousContent: node.content,
+              newContent: cleanContent,
+              source: "consolidation",
+            });
+          }
+        }
+
+        updateNode(update.id, changes);
+      });
       result.nodesUpdated++;
+      // Sync in-memory state with what updateNode actually wrote to the DB
+      // (updateNode deduplicates content before persisting)
+      if (changes.content)
+        changes.content = deduplicateParagraphs(changes.content);
       const node = nodeMap.get(update.id);
       if (node) Object.assign(node, changes);
     }