mnueron 0.6.1 → 0.6.3

package/dist/store/local.js

@@ -1,4 +1,5 @@
 import Database from 'better-sqlite3';
+import { RECALL_EVENTS_DDL, buildRecallEvent, approximateTokens, } from '../savings/recall-event.js';
 import { randomUUID } from 'node:crypto';
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
@@ -216,44 +217,44 @@ export class LocalProvider {
         preload();
     }
     migrate() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS memories (
-        id          TEXT PRIMARY KEY,
-        namespace   TEXT NOT NULL DEFAULT 'default',
-        content     TEXT NOT NULL,
-        tags_json   TEXT NOT NULL DEFAULT '[]',
-        source      TEXT NOT NULL DEFAULT 'manual',
-        source_ref  TEXT,
-        meta_json   TEXT,
-        created_at  INTEGER NOT NULL,
-        updated_at  INTEGER NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_memories_namespace
-        ON memories(namespace);
-      CREATE INDEX IF NOT EXISTS idx_memories_created
-        ON memories(created_at DESC);
-      CREATE INDEX IF NOT EXISTS idx_memories_source
-        ON memories(source);
-      CREATE INDEX IF NOT EXISTS idx_memories_source_ref
-        ON memories(source_ref);
-
-      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts
-      USING fts5(content, tags, namespace UNINDEXED, content_id UNINDEXED);
-
-      -- Keep FTS in sync. We do this manually rather than via triggers so
-      -- the FTS row's content column holds raw text (FTS can't reach
-      -- inside JSON for tags otherwise).
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id          TEXT PRIMARY KEY,
+        namespace   TEXT NOT NULL DEFAULT 'default',
+        content     TEXT NOT NULL,
+        tags_json   TEXT NOT NULL DEFAULT '[]',
+        source      TEXT NOT NULL DEFAULT 'manual',
+        source_ref  TEXT,
+        meta_json   TEXT,
+        created_at  INTEGER NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memories_namespace
+        ON memories(namespace);
+      CREATE INDEX IF NOT EXISTS idx_memories_created
+        ON memories(created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_memories_source
+        ON memories(source);
+      CREATE INDEX IF NOT EXISTS idx_memories_source_ref
+        ON memories(source_ref);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts
+      USING fts5(content, tags, namespace UNINDEXED, content_id UNINDEXED);
+
+      -- Keep FTS in sync. We do this manually rather than via triggers so
+      -- the FTS row's content column holds raw text (FTS can't reach
+      -- inside JSON for tags otherwise).
     `);
         if (this.vecAvailable) {
             // vec0 virtual table. Each row carries the memory_id as an auxiliary
             // column so we can JOIN back to memories without managing rowids.
-            this.db.exec(`
-        CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec
-        USING vec0(
-          memory_id TEXT PRIMARY KEY,
-          embedding float[${EMBEDDING_DIM}]
-        );
+            this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec
+        USING vec0(
+          memory_id TEXT PRIMARY KEY,
+          embedding float[${EMBEDDING_DIM}]
+        );
       `);
         }
         // ── P2.3 — Entity resolution tables ──────────────────────────────────
@@ -266,73 +267,78 @@ export class LocalProvider {
         // (e.g., "Johnny" → resolved to canonical "John Doe"); `confidence`
         // ranges in [0, 1] from exact match (1.0) down through embedding
         // similarity and LLM tiebreak picks (0.65-0.85).
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS entities (
-        id              TEXT PRIMARY KEY,
-        display_name    TEXT NOT NULL,
-        entity_type     TEXT NOT NULL,
-        aliases_json    TEXT NOT NULL DEFAULT '[]',
-        mention_count   INTEGER NOT NULL DEFAULT 0,
-        first_seen_at   INTEGER NOT NULL,
-        last_seen_at    INTEGER NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_entities_type
-        ON entities(entity_type);
-      CREATE INDEX IF NOT EXISTS idx_entities_last_seen
-        ON entities(last_seen_at DESC);
-
-      CREATE TABLE IF NOT EXISTS memory_entities (
-        memory_id     TEXT NOT NULL,
-        entity_id     TEXT NOT NULL,
-        surface_form  TEXT NOT NULL,
-        confidence    REAL NOT NULL,
-        PRIMARY KEY (memory_id, entity_id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_memory_entities_entity
-        ON memory_entities(entity_id);
-
-      -- P3 — Knowledge-graph edges. Each row is a triple (from, predicate,
-      -- to) plus provenance (memory_id) + confidence. P4 forward-looking
-      -- columns (valid_from / valid_to) are added now so bi-temporal
-      -- queries don't require a schema migration later.
-      CREATE TABLE IF NOT EXISTS relations (
-        id              TEXT PRIMARY KEY,
-        from_entity_id  TEXT NOT NULL,
-        to_entity_id    TEXT NOT NULL,
-        predicate       TEXT NOT NULL,
-        memory_id       TEXT NOT NULL,
-        confidence      REAL NOT NULL,
-        valid_from      INTEGER,
-        valid_to        INTEGER,
-        recorded_at     INTEGER NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_relations_from
-        ON relations(from_entity_id);
-      CREATE INDEX IF NOT EXISTS idx_relations_to
-        ON relations(to_entity_id);
-      CREATE INDEX IF NOT EXISTS idx_relations_predicate
-        ON relations(predicate);
-      CREATE INDEX IF NOT EXISTS idx_relations_memory
-        ON relations(memory_id);
-      CREATE INDEX IF NOT EXISTS idx_relations_valid_to
-        ON relations(valid_to);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS entities (
+        id              TEXT PRIMARY KEY,
+        display_name    TEXT NOT NULL,
+        entity_type     TEXT NOT NULL,
+        aliases_json    TEXT NOT NULL DEFAULT '[]',
+        mention_count   INTEGER NOT NULL DEFAULT 0,
+        first_seen_at   INTEGER NOT NULL,
+        last_seen_at    INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_entities_type
+        ON entities(entity_type);
+      CREATE INDEX IF NOT EXISTS idx_entities_last_seen
+        ON entities(last_seen_at DESC);
+
+      CREATE TABLE IF NOT EXISTS memory_entities (
+        memory_id     TEXT NOT NULL,
+        entity_id     TEXT NOT NULL,
+        surface_form  TEXT NOT NULL,
+        confidence    REAL NOT NULL,
+        PRIMARY KEY (memory_id, entity_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_memory_entities_entity
+        ON memory_entities(entity_id);
+
+      -- P3 — Knowledge-graph edges. Each row is a triple (from, predicate,
+      -- to) plus provenance (memory_id) + confidence. P4 forward-looking
+      -- columns (valid_from / valid_to) are added now so bi-temporal
+      -- queries don't require a schema migration later.
+      CREATE TABLE IF NOT EXISTS relations (
+        id              TEXT PRIMARY KEY,
+        from_entity_id  TEXT NOT NULL,
+        to_entity_id    TEXT NOT NULL,
+        predicate       TEXT NOT NULL,
+        memory_id       TEXT NOT NULL,
+        confidence      REAL NOT NULL,
+        valid_from      INTEGER,
+        valid_to        INTEGER,
+        recorded_at     INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_relations_from
+        ON relations(from_entity_id);
+      CREATE INDEX IF NOT EXISTS idx_relations_to
+        ON relations(to_entity_id);
+      CREATE INDEX IF NOT EXISTS idx_relations_predicate
+        ON relations(predicate);
+      CREATE INDEX IF NOT EXISTS idx_relations_memory
+        ON relations(memory_id);
+      CREATE INDEX IF NOT EXISTS idx_relations_valid_to
+        ON relations(valid_to);
     `);
         if (this.vecAvailable) {
             // Embedding index for entity name+context strings. Used by the
             // resolver's vector-similarity stage when finding candidate matches
             // for a freshly extracted entity.
-            this.db.exec(`
-        CREATE VIRTUAL TABLE IF NOT EXISTS entities_vec
-        USING vec0(
-          entity_id TEXT PRIMARY KEY,
-          embedding float[${EMBEDDING_DIM}]
-        );
+            this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS entities_vec
+        USING vec0(
+          entity_id TEXT PRIMARY KEY,
+          embedding float[${EMBEDDING_DIM}]
+        );
       `);
         }
         // P5 — Consolidation proposal table (idempotent).
         ensureConsolidationSchema(this.db);
         // Procedural memory table (idempotent). Mem0 leapfrog feature.
         ensureProceduralSchema(this.db);
+        // ── Recall savings (v0.6) ────────────────────────────────────────
+        // Logs every search() for the savings dashboard widget.
+        // DDL lives in src/savings/recall-event.ts so the savings module
+        // owns its own schema.
+        this.db.exec(RECALL_EVENTS_DDL);
     }
     // ─── write path ──────────────────────────────────────────────────────────
     async save(input) {
@@ -391,17 +397,17 @@ export class LocalProvider {
         // Failure here is non-fatal — we just skip the vec insert.
         const vector = this.vecAvailable ? await embed(input.content) : null;
         const tx = this.db.transaction(() => {
-            this.db.prepare(`
-        INSERT INTO memories (id, namespace, content, tags_json, source, source_ref, meta_json, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            this.db.prepare(`
+        INSERT INTO memories (id, namespace, content, tags_json, source, source_ref, meta_json, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(id, ns, input.content, JSON.stringify(tags), input.source ?? 'manual', input.source_ref ?? null, input.metadata ? JSON.stringify(input.metadata) : null, now, now);
-            this.db.prepare(`
-        INSERT INTO memories_fts (content, tags, namespace, content_id)
-        VALUES (?, ?, ?, ?)
+            this.db.prepare(`
+        INSERT INTO memories_fts (content, tags, namespace, content_id)
+        VALUES (?, ?, ?, ?)
       `).run(input.content, tags.join(' '), ns, id);
             if (vector && this.vecAvailable) {
-                this.db.prepare(`
-          INSERT INTO memories_vec (memory_id, embedding) VALUES (?, ?)
+                this.db.prepare(`
+          INSERT INTO memories_vec (memory_id, embedding) VALUES (?, ?)
         `).run(id, Buffer.from(vector.buffer));
             }
         });
@@ -457,9 +463,9 @@ export class LocalProvider {
                             ? meta.byok_anthropic_key : undefined;
                         const relations = await extractRelations(input.content, resolvedForRelations, { anthropicKey: byokAnthropic });
                         if (relations.length > 0) {
-                            const insertRel = this.db.prepare(`INSERT INTO relations
-                   (id, from_entity_id, to_entity_id, predicate, memory_id,
-                    confidence, valid_from, valid_to, recorded_at)
+                            const insertRel = this.db.prepare(`INSERT INTO relations
+                   (id, from_entity_id, to_entity_id, predicate, memory_id,
+                    confidence, valid_from, valid_to, recorded_at)
                  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
                             const tx2 = this.db.transaction(() => {
                                 for (const r of relations) {
@@ -528,13 +534,13 @@ export class LocalProvider {
     async bulkSaveOne(inputs) {
         const vectors = this.vecAvailable ? await embedBatch(inputs.map(i => i.content)) : inputs.map(() => null);
         const out = [];
-        const insertMem = this.db.prepare(`
-      INSERT INTO memories (id, namespace, content, tags_json, source, source_ref, meta_json, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        const insertMem = this.db.prepare(`
+      INSERT INTO memories (id, namespace, content, tags_json, source, source_ref, meta_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        const insertFts = this.db.prepare(`
-      INSERT INTO memories_fts (content, tags, namespace, content_id)
-      VALUES (?, ?, ?, ?)
+        const insertFts = this.db.prepare(`
+      INSERT INTO memories_fts (content, tags, namespace, content_id)
+      VALUES (?, ?, ?, ?)
     `);
         const insertVec = this.vecAvailable
             ? this.db.prepare(`INSERT INTO memories_vec (memory_id, embedding) VALUES (?, ?)`)
@@ -567,7 +573,7 @@ export class LocalProvider {
         return out;
     }
     async bulkSave(inputs) {
-        let saved = 0, errors = 0;
+        let saved = 0, errors = 0, skipped = 0;
         // 1. Redact secrets up front, same as save().
         const redactedInputs = inputs.map(preSaveTransform);
         // 2. Expand long inputs into per-chunk memories before we save. A backfill
@@ -603,46 +609,102 @@ export class LocalProvider {
             }
             expanded.push(input);
         }
-        // Pre-compute embeddings for the whole (expanded) batch in one go —
-        // much faster than calling embed() N times because Transformers.js
-        // batches the forward pass.
-        const vectors = this.vecAvailable
-            ? await embedBatch(expanded.map(i => i.content))
-            : expanded.map(() => null);
-        const insertMem = this.db.prepare(`
-      INSERT INTO memories (id, namespace, content, tags_json, source, source_ref, meta_json, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        // Persist in per-source_ref groups so progress is durable and re-runs are
+        // idempotent. The previous implementation embedded the ENTIRE expanded set
+        // in one forward pass and committed a single transaction at the very end.
+        // For large imports (e.g. many big Cowork transcripts → thousands of
+        // chunks) that one embedding pass exceeded the caller's request timeout,
+        // and because the only DB write was the final transaction, a timed-out
+        // call committed nothing — so every retry restarted from zero and could
+        // never make progress. We now (a) embed in bounded sub-batches, (b) commit
+        // each source group in its own transaction, and (c) skip groups whose
+        // source_ref is already present (the upsert-by-source_ref the import path
+        // always advertised but never actually performed here).
+        const insertMem = this.db.prepare(`
+      INSERT INTO memories (id, namespace, content, tags_json, source, source_ref, meta_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        const insertFts = this.db.prepare(`
-      INSERT INTO memories_fts (content, tags, namespace, content_id)
-      VALUES (?, ?, ?, ?)
+        const insertFts = this.db.prepare(`
+      INSERT INTO memories_fts (content, tags, namespace, content_id)
+      VALUES (?, ?, ?, ?)
     `);
         const insertVec = this.vecAvailable
             ? this.db.prepare(`INSERT INTO memories_vec (memory_id, embedding) VALUES (?, ?)`)
             : null;
-        const tx = this.db.transaction((items) => {
-            for (let i = 0; i < items.length; i++) {
-                const input = items[i];
-                try {
-                    const id = randomUUID();
-                    const now = Date.now();
-                    const ns = input.namespace ?? 'default';
-                    const tags = input.tags ?? [];
-                    insertMem.run(id, ns, input.content, JSON.stringify(tags), input.source ?? 'manual', input.source_ref ?? null, input.metadata ? JSON.stringify(input.metadata) : null, now, now);
-                    insertFts.run(input.content, tags.join(' '), ns, id);
-                    const vec = vectors[i];
-                    if (vec && insertVec) {
-                        insertVec.run(id, Buffer.from(vec.buffer));
-                    }
-                    saved++;
-                }
-                catch (e) {
-                    errors++;
+        const existsByRef = this.db.prepare(`SELECT 1 FROM memories WHERE source_ref = ? LIMIT 1`);
+        // Group expanded chunks by source_ref. All chunks of one source (e.g. a
+        // single Cowork session) share parent_ref == source_ref, so a group maps
+        // 1:1 to an importable unit that we can dedup and commit atomically.
+        const groups = new Map();
+        const ungrouped = [];
+        for (const item of expanded) {
+            const ref = item.source_ref ?? null;
+            if (ref) {
+                const g = groups.get(ref);
+                if (g)
+                    g.push(item);
+                else
+                    groups.set(ref, [item]);
+            }
+            else {
+                ungrouped.push(item);
+            }
+        }
+        // Keep each embedding forward-pass small and bounded regardless of how
+        // large a single source is.
+        const EMBED_BATCH = 32;
+        const persistGroup = async (items, dedupRef) => {
+            // Idempotency: a present source_ref means this source already imported.
+            // Groups commit atomically, so there are never partial sources to repair.
+            if (dedupRef && existsByRef.get(dedupRef)) {
+                skipped += items.length;
+                return;
+            }
+            const vectors = [];
+            if (this.vecAvailable) {
+                for (let i = 0; i < items.length; i += EMBED_BATCH) {
+                    const slice = items.slice(i, i + EMBED_BATCH);
+                    const vs = await embedBatch(slice.map(s => s.content));
+                    for (const v of vs)
+                        vectors.push(v);
                 }
             }
-        });
-        tx(expanded);
-        return { saved, errors };
+            else {
+                for (let i = 0; i < items.length; i++)
+                    vectors.push(null);
+            }
+            const tx = this.db.transaction((rows) => {
+                for (let i = 0; i < rows.length; i++) {
+                    const input = rows[i];
+                    try {
+                        const id = randomUUID();
+                        const now = Date.now();
+                        const ns = input.namespace ?? 'default';
+                        const tags = input.tags ?? [];
+                        insertMem.run(id, ns, input.content, JSON.stringify(tags), input.source ?? 'manual', input.source_ref ?? null, input.metadata ? JSON.stringify(input.metadata) : null, now, now);
+                        insertFts.run(input.content, tags.join(' '), ns, id);
+                        const vec = vectors[i];
+                        if (vec && insertVec) {
+                            insertVec.run(id, Buffer.from(vec.buffer));
+                        }
+                        saved++;
+                    }
+                    catch (e) {
+                        errors++;
+                    }
+                }
+            });
+            tx(items);
+        };
+        for (const [ref, items] of groups) {
+            await persistGroup(items, ref);
+        }
+        // Items without a source_ref can't be deduped; still persist them in
+        // bounded batches so one giant pass can't blow the timeout.
+        for (let i = 0; i < ungrouped.length; i += EMBED_BATCH) {
+            await persistGroup(ungrouped.slice(i, i + EMBED_BATCH), null);
+        }
+        return { saved, errors, skipped };
     }
     // ─── read path: hybrid keyword + vector with RRF ─────────────────────────
     async search(input) {
@@ -653,12 +715,12 @@ export class LocalProvider {
         const ftsRanks = new Map(); // id → 1-based rank
         if (safeQuery) {
             const filter = buildFilterFragment(input, 'm');
-            let sql = `
-        SELECT m.id
-        FROM memories_fts f
-        JOIN memories m ON m.id = f.content_id
-        WHERE memories_fts MATCH ?
-          AND ${filter.sql}
+            let sql = `
+        SELECT m.id
+        FROM memories_fts f
+        JOIN memories m ON m.id = f.content_id
+        WHERE memories_fts MATCH ?
+          AND ${filter.sql}
       `;
             const params = [safeQuery, ...filter.params];
             sql += ` ORDER BY bm25(memories_fts) LIMIT ?`;
@@ -677,12 +739,12 @@ export class LocalProvider {
             const qvec = await embed(input.query);
             if (qvec) {
                 try {
-                    const rows = this.db.prepare(`
-            SELECT memory_id AS id, distance
-            FROM memories_vec
-            WHERE embedding MATCH ?
-              AND k = ?
-            ORDER BY distance
+                    const rows = this.db.prepare(`
+            SELECT memory_id AS id, distance
+            FROM memories_vec
+            WHERE embedding MATCH ?
+              AND k = ?
+            ORDER BY distance
           `).all(Buffer.from(qvec.buffer), candidateLimit);
                     let candidates = rows.map(r => r.id);
                     // Namespace filter (after the KNN — sqlite-vec doesn't let us
@@ -727,8 +789,59 @@ export class LocalProvider {
             const wanted = new Set(input.tags);
             memories = memories.filter(m => m.tags.some(t => wanted.has(t)));
         }
+        // Recall-event capture moved to the MCP-server tool handler
+        // (src/index.ts) so it's provider-agnostic — fires for both local and
+        // hosted modes. recordRecallEvent() below is kept for any direct
+        // LocalProvider callers (e.g. the benchmark adapter) that still want
+        // the inline capture, but it's no longer invoked from search().
         return memories;
     }
+    /**
+     * Logs one row to recall_events for the savings dashboard. Sums every
+     * memory in the namespace once to get the baseline 'what would I have
+     * had to send' figure (cheap — LENGTH() over content text). Fail-open.
+     */
+    recordRecallEvent(input, returned) {
+        try {
+            const tokens_returned = returned.reduce((sum, m) => sum + approximateTokens(m.content), 0);
+            const ns = input.namespace ?? null;
+            let baseline_chars = 0;
+            if (ns) {
+                const row = this.db
+                    .prepare(`SELECT COALESCE(SUM(LENGTH(content)), 0) AS chars
+               FROM memories
+              WHERE namespace = ?`)
+                    .get(ns);
+                baseline_chars = row?.chars ?? 0;
+            }
+            else {
+                const row = this.db
+                    .prepare(`SELECT COALESCE(SUM(LENGTH(content)), 0) AS chars FROM memories`)
+                    .get();
+                baseline_chars = row?.chars ?? 0;
+            }
+            const tokens_baseline_namespace = Math.ceil(baseline_chars / 4);
+            const ev = buildRecallEvent({
+                namespace: ns,
+                query: input.query,
+                tokens_returned,
+                tokens_baseline_namespace,
+                model_id: input.model_id ?? null,
+                client: input.client ?? null,
+            });
+            this.db
+                .prepare(`INSERT INTO recall_events
+             (id, created_at, namespace, query_hash, tokens_returned,
+              tokens_baseline_namespace, tokens_baseline_capped, model_id,
+              context_limit, client)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(ev.id, ev.created_at, ev.namespace, ev.query_hash, ev.tokens_returned, ev.tokens_baseline_namespace, ev.tokens_baseline_capped, ev.model_id, ev.context_limit, ev.client);
+        }
+        catch (e) {
+            // Fail-open by design — never let recall observability break recall.
+            console.warn('[mnueron/savings] recall-event capture failed:', e instanceof Error ? e.message : e);
+        }
+    }
     async list(input) {
         // v0.2.1 + v0.2.4: full filter support via shared helper.
         // Note: 'm' alias is omitted here because list() doesn't join other
@@ -822,12 +935,12 @@ export class LocalProvider {
         const nextTags = patch.tags
             ?? JSON.parse((existing.tags_json ?? existing.tags) ?? '[]');
         const now = Date.now();
-        this.db.prepare(`UPDATE memories
-          SET content    = ?,
-              namespace  = ?,
-              tags_json  = ?,
-              meta_json  = ?,
-              updated_at = ?
+        this.db.prepare(`UPDATE memories
+          SET content    = ?,
+              namespace  = ?,
+              tags_json  = ?,
+              meta_json  = ?,
+              updated_at = ?
         WHERE id = ?`).run(nextContent, nextNs, JSON.stringify(nextTags), JSON.stringify(merged), now, id);
         // If content changed, re-index FTS + (optionally) re-embed.
         if (contentChanged) {
@@ -865,13 +978,13 @@ export class LocalProvider {
         return tx();
     }
     async namespaces() {
-        const rows = this.db.prepare(`
-      SELECT namespace AS name,
-             COUNT(*) AS count,
-             MAX(updated_at) AS last_updated
-      FROM memories
-      GROUP BY namespace
-      ORDER BY last_updated DESC
+        const rows = this.db.prepare(`
+      SELECT namespace AS name,
+             COUNT(*) AS count,
+             MAX(updated_at) AS last_updated
+      FROM memories
+      GROUP BY namespace
+      ORDER BY last_updated DESC
     `).all();
         return rows.map(r => ({
             name: r.name,
@@ -895,12 +1008,12 @@ export class LocalProvider {
         }
         if (input.q && input.q.trim()) {
             // Match display_name OR any alias (case-insensitive substring).
-            parts.push(`(
-        lower(display_name) LIKE lower('%' || ? || '%')
-        OR EXISTS (
-          SELECT 1 FROM json_each(aliases_json) AS a
-           WHERE lower(a.value) LIKE lower('%' || ? || '%')
-        )
+            parts.push(`(
+        lower(display_name) LIKE lower('%' || ? || '%')
+        OR EXISTS (
+          SELECT 1 FROM json_each(aliases_json) AS a
+           WHERE lower(a.value) LIKE lower('%' || ? || '%')
+        )
       )`);
             params.push(input.q.trim(), input.q.trim());
         }
@@ -932,13 +1045,13 @@ export class LocalProvider {
     async getEntityMemories(id, limit = 100) {
         const cap = clampLimit(limit, 500);
         const rows = this.db
-            .prepare(`SELECT m.id, m.namespace, m.content, m.tags_json, m.source, m.source_ref,
-                m.meta_json, m.created_at, m.updated_at,
-                me.surface_form, me.confidence
-           FROM memory_entities me
-           JOIN memories m ON m.id = me.memory_id
-          WHERE me.entity_id = ?
-          ORDER BY m.created_at DESC
+            .prepare(`SELECT m.id, m.namespace, m.content, m.tags_json, m.source, m.source_ref,
+                m.meta_json, m.created_at, m.updated_at,
+                me.surface_form, me.confidence
+           FROM memory_entities me
+           JOIN memories m ON m.id = me.memory_id
+          WHERE me.entity_id = ?
+          ORDER BY m.created_at DESC
           LIMIT ?`)
             .all(id, cap);
         return rows.map((r) => ({
@@ -983,18 +1096,18 @@ export class LocalProvider {
             // Repoint edges. INSERT-OR-IGNORE then DELETE-old, with confidence MAX
             // fold to preserve the strongest edge if both winner and loser shared
             // a memory.
-            this.db.prepare(`INSERT INTO memory_entities (memory_id, entity_id, surface_form, confidence)
-         SELECT memory_id, ?, surface_form, confidence
-           FROM memory_entities WHERE entity_id = ?
-         ON CONFLICT(memory_id, entity_id) DO UPDATE SET
+            this.db.prepare(`INSERT INTO memory_entities (memory_id, entity_id, surface_form, confidence)
+         SELECT memory_id, ?, surface_form, confidence
+           FROM memory_entities WHERE entity_id = ?
+         ON CONFLICT(memory_id, entity_id) DO UPDATE SET
            confidence = MAX(memory_entities.confidence, excluded.confidence)`).run(winnerId, loserId);
             this.db.prepare(`DELETE FROM memory_entities WHERE entity_id = ?`).run(loserId);
             // Update winner aggregate.
-            this.db.prepare(`UPDATE entities SET
-           aliases_json   = ?,
-           mention_count  = mention_count + ?,
-           first_seen_at  = MIN(first_seen_at, ?),
-           last_seen_at   = MAX(last_seen_at,  ?)
+            this.db.prepare(`UPDATE entities SET
+           aliases_json   = ?,
+           mention_count  = mention_count + ?,
+           first_seen_at  = MIN(first_seen_at, ?),
+           last_seen_at   = MAX(last_seen_at,  ?)
          WHERE id = ?`).run(JSON.stringify(mergedAliases), loser.mention_count, loser.first_seen_at, loser.last_seen_at, winnerId);
             // Delete loser everywhere.
             if (this.vecAvailable) {
@@ -1056,11 +1169,11 @@ export class LocalProvider {
         }
         const limit = clampLimit(input.limit ?? 200, 1000);
         const rows = this.db
-            .prepare(`SELECT id, from_entity_id, to_entity_id, predicate, memory_id,
-                confidence, valid_from, valid_to, recorded_at
-           FROM relations
-          WHERE ${parts.join(' AND ')}
-          ORDER BY recorded_at DESC
+            .prepare(`SELECT id, from_entity_id, to_entity_id, predicate, memory_id,
+                confidence, valid_from, valid_to, recorded_at
+           FROM relations
+          WHERE ${parts.join(' AND ')}
+          ORDER BY recorded_at DESC
           LIMIT ?`)
             .all(...params, limit);
         return rows;
@@ -1168,10 +1281,10 @@ export class LocalProvider {
     countMissingEmbeddings() {
         if (!this.vecAvailable)
             return 0;
-        const r = this.db.prepare(`
-      SELECT COUNT(*) AS c
-      FROM memories
-      WHERE id NOT IN (SELECT memory_id FROM memories_vec)
+        const r = this.db.prepare(`
+      SELECT COUNT(*) AS c
+      FROM memories
+      WHERE id NOT IN (SELECT memory_id FROM memories_vec)
     `).get();
         return r?.c ?? 0;
     }
@@ -1183,18 +1296,18 @@ export class LocalProvider {
     async rebuildEmbeddings(onProgress) {
         if (!this.vecAvailable)
             return { updated: 0, skipped: 0, errors: 0 };
-        const rows = this.db.prepare(`
-      SELECT id, content
-      FROM memories
-      WHERE id NOT IN (SELECT memory_id FROM memories_vec)
-      ORDER BY created_at ASC
+        const rows = this.db.prepare(`
+      SELECT id, content
+      FROM memories
+      WHERE id NOT IN (SELECT memory_id FROM memories_vec)
+      ORDER BY created_at ASC
     `).all();
         const total = rows.length;
         let updated = 0, skipped = 0, errors = 0;
         // Embed in batches of 16 for throughput without spiking memory.
         const BATCH = 16;
-        const insertVec = this.db.prepare(`
-      INSERT OR REPLACE INTO memories_vec (memory_id, embedding) VALUES (?, ?)
+        const insertVec = this.db.prepare(`
+      INSERT OR REPLACE INTO memories_vec (memory_id, embedding) VALUES (?, ?)
     `);
         for (let i = 0; i < rows.length; i += BATCH) {
             const chunk = rows.slice(i, i + BATCH);
@@ -1258,20 +1371,20 @@ export class LocalProvider {
         }
         // Now fetch every memory whose metadata.parent_ref equals ref.
         // JSON field path syntax: json_extract(meta_json, '$.parent_ref')
-        const rows = this.db.prepare(`
-      SELECT *
-      FROM memories
-      WHERE json_extract(meta_json, '$.parent_ref') = ?
-      ORDER BY COALESCE(json_extract(meta_json, '$.chunk_index'), 0) ASC, created_at ASC
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM memories
+      WHERE json_extract(meta_json, '$.parent_ref') = ?
+      ORDER BY COALESCE(json_extract(meta_json, '$.chunk_index'), 0) ASC, created_at ASC
     `).all(ref);
         // Also try a fallback against source_ref for memories chunked via
         // source_ref-as-parent_ref (this is the common case for backfills).
         if (rows.length === 0) {
-            const alt = this.db.prepare(`
-        SELECT *
-        FROM memories
-        WHERE source_ref = ?
-        ORDER BY COALESCE(json_extract(meta_json, '$.chunk_index'), 0) ASC, created_at ASC
+            const alt = this.db.prepare(`
+        SELECT *
+        FROM memories
+        WHERE source_ref = ?
+        ORDER BY COALESCE(json_extract(meta_json, '$.chunk_index'), 0) ASC, created_at ASC
       `).all(ref);
             return alt.map(r => this.rowToMemory(r));
         }
@@ -1292,37 +1405,37 @@ export class LocalProvider {
         const offset = opts.offset ?? 0;
         // We use COALESCE(parent_ref-from-metadata, id) as the bucket key so
         // standalone (non-chunked) memories show up as single-row threads too.
-        const sql = `
-      WITH grouped AS (
-        SELECT
-          COALESCE(json_extract(meta_json, '$.parent_ref'), id) AS pref,
-          namespace,
-          COUNT(*)                  AS cnt,
-          MIN(created_at)           AS first_at,
-          MAX(updated_at)           AS last_at,
-          SUM(CASE WHEN json_extract(meta_json, '$.chunk_index') IS NOT NULL THEN 1 ELSE 0 END) AS chunked_n
-        FROM memories
-        ${opts.namespace ? 'WHERE namespace = ?' : ''}
-        GROUP BY pref, namespace
-      )
-      SELECT
-        g.pref AS parent_ref,
-        g.namespace,
-        g.cnt   AS count,
-        g.first_at,
-        g.last_at,
-        g.chunked_n > 0 AS has_chunks,
-        (
-          SELECT m.content
-          FROM memories m
-          WHERE COALESCE(json_extract(m.meta_json, '$.parent_ref'), m.id) = g.pref
-            AND m.namespace = g.namespace
-          ORDER BY COALESCE(json_extract(m.meta_json, '$.chunk_index'), 0) ASC, m.created_at ASC
-          LIMIT 1
-        ) AS title_source
-      FROM grouped g
-      ORDER BY g.last_at DESC
-      LIMIT ? OFFSET ?
+        const sql = `
+      WITH grouped AS (
+        SELECT
+          COALESCE(json_extract(meta_json, '$.parent_ref'), id) AS pref,
+          namespace,
+          COUNT(*)                  AS cnt,
+          MIN(created_at)           AS first_at,
+          MAX(updated_at)           AS last_at,
+          SUM(CASE WHEN json_extract(meta_json, '$.chunk_index') IS NOT NULL THEN 1 ELSE 0 END) AS chunked_n
+        FROM memories
+        ${opts.namespace ? 'WHERE namespace = ?' : ''}
+        GROUP BY pref, namespace
+      )
+      SELECT
+        g.pref AS parent_ref,
+        g.namespace,
+        g.cnt   AS count,
+        g.first_at,
+        g.last_at,
+        g.chunked_n > 0 AS has_chunks,
+        (
+          SELECT m.content
+          FROM memories m
+          WHERE COALESCE(json_extract(m.meta_json, '$.parent_ref'), m.id) = g.pref
+            AND m.namespace = g.namespace
+          ORDER BY COALESCE(json_extract(m.meta_json, '$.chunk_index'), 0) ASC, m.created_at ASC
+          LIMIT 1
+        ) AS title_source
+      FROM grouped g
+      ORDER BY g.last_at DESC
+      LIMIT ? OFFSET ?
     `;
         const params = opts.namespace ? [opts.namespace, limit, offset] : [limit, offset];
         const rows = this.db.prepare(sql).all(...params);
@@ -1341,15 +1454,15 @@ export class LocalProvider {
      * predate chunking. Used by `mnueron rechunk` to backfill the new shape.
      */
     findOversizedMemories(threshold = DEFAULT_CHUNK_THRESHOLD) {
-        return this.db.prepare(`
-      SELECT id, content, namespace, tags_json, source, source_ref, meta_json, created_at
-      FROM memories
-      WHERE LENGTH(content) > ?
-        AND (
-          meta_json IS NULL
-          OR json_extract(meta_json, '$.chunk_index') IS NULL
-        )
-      ORDER BY LENGTH(content) DESC
+        return this.db.prepare(`
+      SELECT id, content, namespace, tags_json, source, source_ref, meta_json, created_at
+      FROM memories
+      WHERE LENGTH(content) > ?
+        AND (
+          meta_json IS NULL
+          OR json_extract(meta_json, '$.chunk_index') IS NULL
+        )
+      ORDER BY LENGTH(content) DESC
     `).all(threshold);
     }
     rowToMemory(row, score) {