clementine-agent 1.18.20 → 1.18.21

package/dist/memory/store.js

@@ -46,6 +46,35 @@ export class MemoryStore {
         const conf = Math.max(0, Math.min(1, confidence ?? 1));
         return conf >= 1 ? 1 : 0.5 + 0.5 * conf;
     }
+    static formatBytes(n) {
+        if (!Number.isFinite(n) || n < 0)
+            return '0 B';
+        if (n < 1024)
+            return `${n} B`;
+        if (n < 1024 * 1024)
+            return `${(n / 1024).toFixed(1)} KB`;
+        if (n < 1024 * 1024 * 1024)
+            return `${(n / 1024 / 1024).toFixed(1)} MB`;
+        return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+    }
+    static dirSizeBytes(dir) {
+        if (!existsSync(dir))
+            return 0;
+        let total = 0;
+        try {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory())
+                    total += MemoryStore.dirSizeBytes(full);
+                else if (entry.isFile())
+                    total += statSync(full).size;
+            }
+        }
+        catch {
+            return total;
+        }
+        return total;
+    }
     // ── Lifecycle ──────────────────────────────────────────────────────
     /**
      * Create the database and schema if needed.
@@ -126,6 +155,29 @@ export class MemoryStore {
       CREATE INDEX IF NOT EXISTS idx_transcripts_session ON transcripts(session_key);
       CREATE INDEX IF NOT EXISTS idx_transcripts_created ON transcripts(created_at);
 
+      CREATE VIRTUAL TABLE IF NOT EXISTS transcripts_fts USING fts5(
+        session_key, role, content, model, created_at,
+        content='transcripts', content_rowid='id',
+        tokenize='porter unicode61'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS transcripts_ai AFTER INSERT ON transcripts BEGIN
+        INSERT INTO transcripts_fts(rowid, session_key, role, content, model, created_at)
+        VALUES (new.id, new.session_key, new.role, new.content, new.model, new.created_at);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS transcripts_ad AFTER DELETE ON transcripts BEGIN
+        INSERT INTO transcripts_fts(transcripts_fts, rowid, session_key, role, content, model, created_at)
+        VALUES ('delete', old.id, old.session_key, old.role, old.content, old.model, old.created_at);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS transcripts_au AFTER UPDATE ON transcripts BEGIN
+        INSERT INTO transcripts_fts(transcripts_fts, rowid, session_key, role, content, model, created_at)
+        VALUES ('delete', old.id, old.session_key, old.role, old.content, old.model, old.created_at);
+        INSERT INTO transcripts_fts(rowid, session_key, role, content, model, created_at)
+        VALUES (new.id, new.session_key, new.role, new.content, new.model, new.created_at);
+      END;
+
       CREATE TABLE IF NOT EXISTS session_summaries (
         id INTEGER PRIMARY KEY,
         session_key TEXT NOT NULL,
@@ -136,7 +188,32 @@ export class MemoryStore {
 
       CREATE INDEX IF NOT EXISTS idx_session_summaries_key ON session_summaries(session_key);
       CREATE INDEX IF NOT EXISTS idx_session_summaries_created ON session_summaries(created_at);
+
+      CREATE TABLE IF NOT EXISTS session_lineage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_key TEXT NOT NULL,
+        parent_session_id TEXT,
+        child_session_id TEXT,
+        reason TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        exchange_count INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_session_lineage_key ON session_lineage(session_key, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_session_lineage_parent ON session_lineage(parent_session_id);
     `);
+        try {
+            this.conn.exec(`
+        INSERT INTO transcripts_fts(rowid, session_key, role, content, model, created_at)
+        SELECT id, session_key, role, content, model, created_at
+        FROM transcripts
+        WHERE id NOT IN (SELECT rowid FROM transcripts_fts)
+      `);
+        }
+        catch {
+            // FTS backfill is best-effort; triggers keep new rows indexed.
+        }
         // ── Migrations ────────────────────────────────────────────────
         // Add salience column to chunks
         try {
@@ -373,6 +450,29 @@ export class MemoryStore {
       );
       CREATE INDEX IF NOT EXISTS idx_extractions_session ON memory_extractions(session_key);
       CREATE INDEX IF NOT EXISTS idx_extractions_status ON memory_extractions(status);
+    `);
+        // Memory event ledger — compact proof that each major input stream has
+        // crossed into the memory system. This is intentionally smaller than the
+        // source payload tables; it powers health checks and lets us spot gaps
+        // like "transcripts are saved but never indexed".
+        this.conn.exec(`
+      CREATE TABLE IF NOT EXISTS memory_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_type TEXT NOT NULL,
+        source_id INTEGER,
+        session_key TEXT,
+        agent_slug TEXT,
+        content_hash TEXT NOT NULL,
+        content_preview TEXT NOT NULL,
+        indexed_at TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_memory_events_source
+        ON memory_events(source_type, source_id);
+      CREATE INDEX IF NOT EXISTS idx_memory_events_session
+        ON memory_events(session_key, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_memory_events_created
+        ON memory_events(created_at DESC);
     `);
         this.conn.exec(`
       CREATE TABLE IF NOT EXISTS memory_promotion_candidates (
@@ -714,6 +814,14 @@ export class MemoryStore {
       CREATE INDEX IF NOT EXISTS idx_ingestion_runs_source ON ingestion_runs(source_slug, started_at DESC);
       CREATE INDEX IF NOT EXISTS idx_ingestion_runs_status ON ingestion_runs(status);
     `);
+        try {
+            this.conn.exec('ALTER TABLE ingestion_runs ADD COLUMN records_unchanged INTEGER NOT NULL DEFAULT 0');
+        }
+        catch { /* already exists */ }
+        try {
+            this.conn.exec('ALTER TABLE ingestion_runs ADD COLUMN recall_check_status TEXT DEFAULT NULL');
+        }
+        catch { /* already exists */ }
         // Ingested rows — structured overlay on chunks for SQL aggregates.
         // chunk_id FK makes this an INDEX on top of chunks, not a silo.
         // Per-source dynamic columns are added via ALTER TABLE during
@@ -772,6 +880,22 @@ export class MemoryStore {
             this.conn.exec('ALTER TABLE recall_traces ADD COLUMN match_types TEXT DEFAULT NULL');
         }
         catch { /* column already exists */ }
+        try {
+            this.conn.exec('ALTER TABLE recall_traces ADD COLUMN backend_counts TEXT DEFAULT NULL');
+        }
+        catch { /* column already exists */ }
+        try {
+            this.conn.exec('ALTER TABLE recall_traces ADD COLUMN evidence_json TEXT DEFAULT NULL');
+        }
+        catch { /* column already exists */ }
+        try {
+            this.conn.exec('ALTER TABLE recall_traces ADD COLUMN confidence REAL DEFAULT NULL');
+        }
+        catch { /* column already exists */ }
+        try {
+            this.conn.exec('ALTER TABLE recall_traces ADD COLUMN empty_reason TEXT DEFAULT NULL');
+        }
+        catch { /* column already exists */ }
         // Dense neural embeddings (transformers.js — arctic-embed-m by default).
         // Parallel to the existing chunks.embedding (TF-IDF, 512-dim) so we can
         // backfill incrementally and fall back gracefully if the dense model
@@ -1809,7 +1933,24 @@ export class MemoryStore {
         const finalResults = mmrRerank(deduplicateResults(merged), 0.7, limit + recencyLimit);
         // 5. Log recall trace if session context provided. Skipped for internal
         // calls (e.g. consolidation, dedup checks) by passing skipTrace=true.
-        if (sessionKey && !skipTrace && finalResults.length > 0) {
+        if (sessionKey && !skipTrace) {
+            const backendCounts = {
+                fts: ftsResults.length,
+                vector: vectorResults.length,
+                graph: graphResults.length,
+                recency: recentResults.length,
+            };
+            const evidence = finalResults.slice(0, 8).map((r) => ({
+                chunkId: r.chunkId,
+                matchType: r.matchType,
+                score: r.score,
+                sourceFile: r.sourceFile,
+                section: r.section,
+            }));
+            const topScore = finalResults[0]?.score ?? 0;
+            const confidence = finalResults.length > 0
+                ? Math.max(0.1, Math.min(1, topScore / (Math.abs(topScore) + 1)))
+                : 0;
             this.logRecallTrace({
                 sessionKey,
                 messageId: messageId ?? null,
@@ -1818,6 +1959,11 @@ export class MemoryStore {
                 scores: finalResults.map(r => r.score),
                 agentSlug: agentSlug ?? null,
                 matchTypes: finalResults.map(r => r.matchType),
+                backendCounts,
+                evidence,
+                confidence,
+                emptyReason: finalResults.length === 0 ? 'no_backend_matches' : null,
+                allowEmpty: finalResults.length === 0,
             });
         }
         return finalResults;
@@ -1851,7 +1997,7 @@ export class MemoryStore {
      * Non-fatal: errors are swallowed so retrieval never fails on logging issues.
      */
     logRecallTrace(opts) {
-        if (opts.chunkIds.length === 0)
+        if (opts.chunkIds.length === 0 && !opts.allowEmpty)
             return;
         if (this.writeQueue) {
             this.writeQueue.enqueue({
@@ -1863,6 +2009,11 @@ export class MemoryStore {
                 scores: [...opts.scores],
                 agentSlug: opts.agentSlug ?? null,
                 matchTypes: opts.matchTypes ? [...opts.matchTypes] : undefined,
+                backendCounts: opts.backendCounts ?? undefined,
+                evidence: opts.evidence ? [...opts.evidence] : undefined,
+                confidence: opts.confidence ?? undefined,
+                emptyReason: opts.emptyReason ?? undefined,
+                allowEmpty: opts.allowEmpty,
             });
             return;
         }
@@ -1870,11 +2021,13 @@ export class MemoryStore {
     }
     /** Internal sync recall_trace insert. Called by the WriteQueue. */
     _logRecallTraceSync(opts) {
-        if (opts.chunkIds.length === 0)
+        if (opts.chunkIds.length === 0 && !opts.allowEmpty)
             return;
         try {
-            this.conn.prepare(`INSERT INTO recall_traces (session_key, message_id, query, chunk_ids, scores, agent_slug, match_types)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`).run(opts.sessionKey, opts.messageId ?? null, opts.query, JSON.stringify(opts.chunkIds), JSON.stringify(opts.scores), opts.agentSlug ?? null, opts.matchTypes ? JSON.stringify(opts.matchTypes) : null);
+            this.conn.prepare(`INSERT INTO recall_traces
+         (session_key, message_id, query, chunk_ids, scores, agent_slug, match_types,
+          backend_counts, evidence_json, confidence, empty_reason)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(opts.sessionKey, opts.messageId ?? null, opts.query, JSON.stringify(opts.chunkIds), JSON.stringify(opts.scores), opts.agentSlug ?? null, opts.matchTypes ? JSON.stringify(opts.matchTypes) : null, opts.backendCounts ? JSON.stringify(opts.backendCounts) : null, opts.evidence ? JSON.stringify(opts.evidence) : null, opts.confidence ?? null, opts.emptyReason ?? null);
         }
         catch {
             // Non-fatal — recall trace logging never breaks retrieval
@@ -1885,7 +2038,8 @@ export class MemoryStore {
      * Used by the dashboard chat panel to show "what memory powered this answer".
      */
     getRecentRecallTraces(sessionKey, limit = 50) {
-        const rows = this.conn.prepare(`SELECT id, message_id, query, chunk_ids, scores, retrieved_at
+        const rows = this.conn.prepare(`SELECT id, message_id, query, chunk_ids, scores, backend_counts,
+              evidence_json, confidence, empty_reason, retrieved_at
        FROM recall_traces
        WHERE session_key = ?
        ORDER BY retrieved_at DESC, id DESC
@@ -1896,6 +2050,10 @@ export class MemoryStore {
             query: r.query,
             chunkIds: this._parseJsonArray(r.chunk_ids),
             scores: this._parseJsonArray(r.scores),
+            backendCounts: this._parseJsonObject(r.backend_counts),
+            evidence: this._parseJsonArray(r.evidence_json ?? '[]'),
+            confidence: r.confidence,
+            emptyReason: r.empty_reason,
             retrievedAt: r.retrieved_at,
         }));
     }
@@ -1904,7 +2062,8 @@ export class MemoryStore {
      * Used for the dashboard "view sources" expansion on a single message.
      */
     getRecallTrace(traceId) {
-        const trace = this.conn.prepare(`SELECT id, session_key, message_id, query, chunk_ids, scores, retrieved_at
+        const trace = this.conn.prepare(`SELECT id, session_key, message_id, query, chunk_ids, scores,
+              backend_counts, evidence_json, confidence, empty_reason, retrieved_at
        FROM recall_traces WHERE id = ?`).get(traceId);
         if (!trace)
             return null;
@@ -1925,6 +2084,10 @@ export class MemoryStore {
             messageId: trace.message_id,
             query: trace.query,
             retrievedAt: trace.retrieved_at,
+            backendCounts: this._parseJsonObject(trace.backend_counts),
+            evidence: this._parseJsonArray(trace.evidence_json ?? '[]'),
+            confidence: trace.confidence,
+            emptyReason: trace.empty_reason,
             chunks: ordered,
         };
     }
@@ -2014,6 +2177,17 @@ export class MemoryStore {
             return [];
         }
     }
+    _parseJsonObject(json) {
+        if (!json)
+            return null;
+        try {
+            const parsed = JSON.parse(json);
+            return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
     // ── User Mental Model ──────────────────────────────────────────────
     //
     // MemGPT-style core memory: a small, always-in-context surface for
@@ -2446,7 +2620,15 @@ export class MemoryStore {
         if (!this._stmtInsertTranscript) {
             this._stmtInsertTranscript = this.conn.prepare('INSERT INTO transcripts (session_key, role, content, model) VALUES (?, ?, ?, ?)');
         }
-        this._stmtInsertTranscript.run(sessionKey, role, content, model);
+        const info = this._stmtInsertTranscript.run(sessionKey, role, content, model);
+        this.recordMemoryEvent({
+            sourceType: 'transcript',
+            sourceId: info.lastInsertRowid,
+            sessionKey,
+            agentSlug: null,
+            content: `${role}: ${content}`,
+            indexed: true,
+        });
     }
     /**
      * Get all turns for a given session, ordered chronologically.
@@ -2511,8 +2693,35 @@ export class MemoryStore {
      * Search transcripts by keyword. Returns matching turns with context.
      */
     searchTranscripts(query, limit = 20, sessionKey = '') {
-        const queryLower = `%${query.toLowerCase()}%`;
+        const sanitized = MemoryStore.sanitizeFtsQuery(query);
         let rows;
+        if (sanitized) {
+            try {
+                const params = [sanitized];
+                let sql = `SELECT t.session_key, t.role, t.content, t.model, t.created_at
+           FROM transcripts_fts f
+           JOIN transcripts t ON t.id = f.rowid
+           WHERE transcripts_fts MATCH ?`;
+                if (sessionKey) {
+                    sql += ' AND t.session_key = ?';
+                    params.push(sessionKey);
+                }
+                sql += ' ORDER BY t.created_at DESC, t.id DESC LIMIT ?';
+                params.push(limit);
+                rows = this.conn.prepare(sql).all(...params);
+                return rows.map((row) => ({
+                    sessionKey: row.session_key,
+                    role: row.role,
+                    content: row.content.slice(0, 2000),
+                    model: row.model,
+                    createdAt: row.created_at,
+                }));
+            }
+            catch {
+                // Fall back to LIKE for malformed FTS queries or legacy SQLite builds.
+            }
+        }
+        const queryLower = `%${query.toLowerCase()}%`;
         if (sessionKey) {
             rows = this.conn
                 .prepare(`SELECT session_key, role, content, model, created_at
@@ -2561,6 +2770,49 @@ export class MemoryStore {
             createdAt: row.created_at,
         }));
     }
+    /**
+     * Get recent session summaries scoped to one conversation.
+     */
+    getRecentSummariesForSession(sessionKey, limit = 3) {
+        const rows = this.conn
+            .prepare(`SELECT session_key, summary, exchange_count, created_at
+         FROM session_summaries
+         WHERE session_key = ?
+         ORDER BY created_at DESC
+         LIMIT ?`)
+            .all(sessionKey, limit);
+        return rows.map((row) => ({
+            sessionKey: row.session_key,
+            summary: row.summary,
+            exchangeCount: row.exchange_count,
+            createdAt: row.created_at,
+        }));
+    }
+    recordSessionLineage(input) {
+        this.conn
+            .prepare(`INSERT INTO session_lineage
+           (session_key, parent_session_id, child_session_id, reason, summary, exchange_count)
+         VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(input.sessionKey, input.parentSessionId ?? null, input.childSessionId ?? null, input.reason, input.summary, input.exchangeCount ?? 0);
+    }
+    getSessionLineage(sessionKey, limit = 5) {
+        const rows = this.conn
+            .prepare(`SELECT session_key, parent_session_id, child_session_id, reason, summary, exchange_count, created_at
+         FROM session_lineage
+         WHERE session_key = ?
+         ORDER BY created_at DESC
+         LIMIT ?`)
+            .all(sessionKey, limit);
+        return rows.map((row) => ({
+            sessionKey: row.session_key,
+            parentSessionId: row.parent_session_id,
+            childSessionId: row.child_session_id,
+            reason: row.reason,
+            summary: row.summary,
+            exchangeCount: row.exchange_count,
+            createdAt: row.created_at,
+        }));
+    }
     // ── Salience Tracking ─────────────────────────────────────────────
     /**
      * Record that chunks were accessed (retrieved/displayed). Routes through
@@ -2800,7 +3052,38 @@ export class MemoryStore {
         const stmt = this.conn.prepare(`INSERT INTO tool_artifacts (session_key, agent_slug, tool_name, summary, content, tags)
        VALUES (?, ?, ?, ?, ?, ?)`);
         const info = stmt.run(input.sessionKey ?? null, input.agentSlug ?? null, input.toolName, input.summary, input.content, input.tags ?? '');
-        return info.lastInsertRowid;
+        const id = info.lastInsertRowid;
+        this.recordMemoryEvent({
+            sourceType: 'artifact',
+            sourceId: id,
+            sessionKey: input.sessionKey ?? null,
+            agentSlug: input.agentSlug ?? null,
+            content: `${input.toolName}\n${input.summary}\n${input.content}`,
+            indexed: true,
+        });
+        return id;
+    }
+    recordMemoryEvent(input) {
+        try {
+            const content = String(input.content ?? '');
+            const contentHash = createHash('sha256').update(content).digest('hex').slice(0, 16);
+            const preview = content.replace(/\s+/g, ' ').trim().slice(0, 500);
+            this.conn.prepare(`INSERT INTO memory_events
+         (source_type, source_id, session_key, agent_slug, content_hash, content_preview, indexed_at)
+         VALUES (?, ?, ?, ?, ?, ?, ${input.indexed === false ? 'NULL' : "datetime('now')"})`).run(input.sourceType, input.sourceId ?? null, input.sessionKey ?? null, input.agentSlug ?? null, contentHash, preview);
+        }
+        catch {
+            // Ledger writes are observability only; never fail the source write.
+        }
+    }
+    getMemoryEventStats() {
+        const total = this.conn.prepare('SELECT COUNT(*) AS c FROM memory_events').get().c;
+        const indexed = this.conn.prepare('SELECT COUNT(*) AS c FROM memory_events WHERE indexed_at IS NOT NULL').get().c;
+        const bySourceType = this.conn
+            .prepare(`SELECT source_type AS sourceType, COUNT(*) AS count
+                FROM memory_events GROUP BY source_type ORDER BY count DESC`)
+            .all();
+        return { total, indexed, bySourceType };
     }
     /**
      * Search artifacts via FTS over summary + content + tool_name + tags.
@@ -2985,6 +3268,14 @@ export class MemoryStore {
             sets.push('records_failed = ?');
             params.push(patch.recordsFailed);
         }
+        if (patch.recordsUnchanged !== undefined) {
+            sets.push('records_unchanged = ?');
+            params.push(patch.recordsUnchanged);
+        }
+        if (patch.recallCheckStatus !== undefined) {
+            sets.push('recall_check_status = ?');
+            params.push(patch.recallCheckStatus);
+        }
         if (patch.overviewNotePath !== undefined) {
             sets.push('overview_note_path = ?');
             params.push(patch.overviewNotePath);
@@ -3007,20 +3298,22 @@ export class MemoryStore {
     }
     listIngestionRuns(sourceSlug, limit = 50) {
         let sql = `SELECT id, source_slug, started_at, finished_at, records_in, records_written,
-                      records_skipped, records_failed, overview_note_path, errors_json, status
+                      records_skipped, records_failed, records_unchanged, recall_check_status,
+                      overview_note_path, errors_json, status
                FROM ingestion_runs`;
         const params = [];
         if (sourceSlug) {
             sql += ` WHERE source_slug = ?`;
             params.push(sourceSlug);
         }
-        sql += ` ORDER BY started_at DESC LIMIT ?`;
+        sql += ` ORDER BY started_at DESC, id DESC LIMIT ?`;
         params.push(limit);
         const rows = this.conn.prepare(sql).all(...params);
         return rows.map((r) => ({
             id: r.id, sourceSlug: r.source_slug, startedAt: r.started_at, finishedAt: r.finished_at,
             recordsIn: r.records_in, recordsWritten: r.records_written,
             recordsSkipped: r.records_skipped, recordsFailed: r.records_failed,
+            recordsUnchanged: r.records_unchanged ?? 0, recallCheckStatus: r.recall_check_status ?? null,
             overviewNotePath: r.overview_note_path, errorsJson: r.errors_json, status: r.status,
         }));
     }
@@ -3165,6 +3458,7 @@ export class MemoryStore {
         // 90-day window is enough to debug "why did the agent answer that way last
         // week" without letting the table grow unbounded.
         const recallRetention = opts.recallTraceRetentionDays ?? 90;
+        const memoryEventRetention = opts.memoryEventRetentionDays ?? 180;
         // Prune stale episodic chunks (not vault-sourced content)
         const episodicResult = this.conn
             .prepare(`DELETE FROM chunks
@@ -3211,6 +3505,16 @@ export class MemoryStore {
         catch {
             // Table may not exist on first boot before initialize() runs the new schema
         }
+        let memoryEventsPruned = 0;
+        try {
+            const memoryEventsResult = this.conn
+                .prepare(`DELETE FROM memory_events WHERE created_at < datetime('now', ?)`)
+                .run(`-${memoryEventRetention} days`);
+            memoryEventsPruned = memoryEventsResult.changes;
+        }
+        catch {
+            // Table may not exist on first boot before initialize() runs the new schema
+        }
         return {
             episodicPruned: episodicResult.changes,
             accessLogPruned: accessResult.changes,
@@ -3220,6 +3524,7 @@ export class MemoryStore {
             reflectionsPruned: reflectionsResult.changes,
             usageLogPruned: usageResult.changes,
             recallTracesPruned,
+            memoryEventsPruned,
         };
     }
     // ── Staleness detection ─────────────────────────────────────────
@@ -4517,12 +4822,16 @@ export class MemoryStore {
     markConsolidated(chunkIds) {
         if (chunkIds.length === 0)
             return;
-        const placeholders = chunkIds.map(() => '?').join(',');
-        this.conn
-            .prepare(`UPDATE chunks
-         SET consolidated = 1, salience = MAX(salience - 0.3, 0.0)
-         WHERE id IN (${placeholders})`)
-            .run(...chunkIds);
+        const batchSize = 500;
+        for (let i = 0; i < chunkIds.length; i += batchSize) {
+            const batch = chunkIds.slice(i, i + batchSize);
+            const placeholders = batch.map(() => '?').join(',');
+            this.conn
+                .prepare(`UPDATE chunks
+           SET consolidated = 1, salience = MAX(salience - 0.3, 0.0)
+           WHERE id IN (${placeholders})`)
+                .run(...batch);
+        }
     }
     // ── Autonomy log ───────────────────────────────────────────────────
     _stmtLogAutonomy = null;
@@ -4634,6 +4943,7 @@ export class MemoryStore {
             'transcripts',
             'session_summaries',
             'memory_extractions',
+            'memory_events',
             'chunk_soft_deletes',
             'chunk_history',
             'sdk_session_entries',
@@ -4660,6 +4970,18 @@ export class MemoryStore {
                 .prepare(`SELECT COUNT(*) AS c FROM memory_extractions WHERE status LIKE 'skipped:%' AND extracted_at >= datetime('now', '-30 days')`)
                 .get().c,
         };
+        const retrievalProof = {
+            tracesLast7d: recentActivity.recallTracesLast7d,
+            emptyTracesLast7d: this.conn
+                .prepare(`SELECT COUNT(*) AS c FROM recall_traces
+                  WHERE retrieved_at >= datetime('now', '-7 days')
+                    AND json_array_length(chunk_ids) = 0`)
+                .get().c,
+            tracedChunksLast7d: this.conn
+                .prepare(`SELECT COALESCE(SUM(json_array_length(chunk_ids)), 0) AS c
+                  FROM recall_traces WHERE retrieved_at >= datetime('now', '-7 days')`)
+                .get().c,
+        };
         const userModelSlots = this.conn
             .prepare(`SELECT
            COUNT(*) AS total,
@@ -4718,6 +5040,8 @@ export class MemoryStore {
             chunksByCategory: byCategory,
             tableRowCounts,
             recentActivity,
+            retrievalProof,
+            memoryEvents: this.getMemoryEventStats(),
             topCitedLast30d: topCited.map((r) => ({
                 chunkId: r.chunk_id,
                 sourceFile: r.source_file,
@@ -4752,12 +5076,19 @@ export class MemoryStore {
                     FROM chunks WHERE embedding_dense IS NOT NULL
                     GROUP BY embedding_dense_model ORDER BY count DESC`)
                     .all();
+                const cacheDir = embeddingsModule.denseModelCacheDir();
+                const cacheBytes = MemoryStore.dirSizeBytes(cacheDir);
                 return {
                     withDense,
                     total: chunkAgg.total,
                     models,
                     currentModel: embeddingsModule.currentDenseModel(),
                     ready: embeddingsModule.isDenseReady(),
+                    cacheDir,
+                    cacheExists: existsSync(cacheDir),
+                    cacheBytes,
+                    cacheSize: MemoryStore.formatBytes(cacheBytes),
+                    installed: cacheBytes >= 1024 * 1024,
                 };
             })(),
         };

package/dist/memory/write-queue.d.ts

@@ -33,6 +33,22 @@ export type QueueOp = {
     scores: number[];
     agentSlug: string | null;
     matchTypes?: string[];
+    backendCounts?: {
+        fts: number;
+        vector: number;
+        graph: number;
+        recency: number;
+    } | null;
+    evidence?: Array<{
+        chunkId: number;
+        matchType: string;
+        score: number;
+        sourceFile?: string;
+        section?: string;
+    }>;
+    confidence?: number | null;
+    emptyReason?: string | null;
+    allowEmpty?: boolean;
 } | {
     kind: 'outcome';
     outcomes: Array<{

package/dist/memory/write-queue.js

@@ -137,6 +137,11 @@ export class WriteQueue {
                     scores: op.scores,
                     agentSlug: op.agentSlug,
                     matchTypes: op.matchTypes,
+                    backendCounts: op.backendCounts,
+                    evidence: op.evidence,
+                    confidence: op.confidence,
+                    emptyReason: op.emptyReason,
+                    allowEmpty: op.allowEmpty,
                 });
                 break;
             case 'outcome':