@cleocode/core 2026.4.58 → 2026.4.59

package/dist/memory/brain-lifecycle.js

@@ -0,0 +1,841 @@
+/**
+ * BRAIN lifecycle operations — temporal decay, memory consolidation, and tier promotion.
+ *
+ * Reduces confidence of stale learnings based on age, following an
+ * exponential decay model: new_confidence = confidence * (decayRate ^ daysSinceUpdate).
+ *
+ * Consolidation groups old observations by keyword overlap and merges
+ * clusters into summary observations, archiving the originals.
+ *
+ * Wave 3 additions (T549):
+ * - runTierPromotion — promotes entries through short→medium→long based on citation count,
+ *   age, and verification; soft-evicts stale short-term entries.
+ * - runConsolidation — orchestrates all consolidation steps (dedup, quality recompute,
+ *   tier promotion, contradiction detection, soft eviction, graph strengthening, summaries).
+ *
+ * @task T5394 T5395 T549
+ * @epic T5149
+ */
+import { createHash } from 'node:crypto';
+import { getBrainAccessor } from '../store/brain-accessor.js';
+import { typedAll } from '../store/typed-query.js';
+import { EDGE_TYPES } from './edge-types.js';
+/**
+ * Apply temporal decay to brain_learnings confidence values.
+ *
+ * Entries older than `olderThanDays` have their confidence reduced
+ * by an exponential decay factor based on the number of days since
+ * their last update (or creation if never updated).
+ *
+ * Formula: new_confidence = confidence * (decayRate ^ daysSinceUpdate)
+ *
+ * @param projectRoot - Project root directory for brain.db resolution
+ * @param options - Decay configuration
+ * @returns Count of updated rows and tables processed
+ */
+export async function applyTemporalDecay(projectRoot, options) {
+    const decayRate = options?.decayRate ?? 0.995;
+    const olderThanDays = options?.olderThanDays ?? 30;
+    // Ensure brain.db is initialized
+    const { getBrainDb, getBrainNativeDb } = await import('../store/brain-sqlite.js');
+    await getBrainDb(projectRoot);
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb) {
+        return { updated: 0, tablesProcessed: [] };
+    }
+    // Calculate the cutoff date
+    const cutoffDate = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .replace('T', ' ')
+        .slice(0, 19);
+    // Update learnings: reduce confidence based on age since last update (or creation).
+    // SQLite's julianday function computes the difference in days.
+    // We use COALESCE to prefer updated_at over created_at for the age calculation.
+    const stmt = nativeDb.prepare(`
+    UPDATE brain_learnings
+    SET confidence = confidence * POWER(?, julianday('now') - julianday(COALESCE(updated_at, created_at))),
+        updated_at = datetime('now')
+    WHERE COALESCE(updated_at, created_at) < ?
+      AND confidence > 0.01
+  `);
+    const result = stmt.run(decayRate, cutoffDate);
+    const updated = typeof result.changes === 'number' ? result.changes : 0;
+    return {
+        updated,
+        tablesProcessed: ['brain_learnings'],
+    };
+}
+/** Stop words excluded from keyword extraction. */
+const STOP_WORDS = new Set([
+    'the',
+    'a',
+    'an',
+    'is',
+    'are',
+    'was',
+    'were',
+    'be',
+    'been',
+    'being',
+    'have',
+    'has',
+    'had',
+    'do',
+    'does',
+    'did',
+    'will',
+    'would',
+    'could',
+    'should',
+    'may',
+    'might',
+    'shall',
+    'can',
+    'need',
+    'dare',
+    'ought',
+    'used',
+    'to',
+    'of',
+    'in',
+    'for',
+    'on',
+    'with',
+    'at',
+    'by',
+    'from',
+    'as',
+    'into',
+    'through',
+    'during',
+    'before',
+    'after',
+    'above',
+    'below',
+    'between',
+    'out',
+    'off',
+    'over',
+    'under',
+    'again',
+    'further',
+    'then',
+    'once',
+    'and',
+    'but',
+    'or',
+    'nor',
+    'not',
+    'so',
+    'yet',
+    'both',
+    'either',
+    'neither',
+    'each',
+    'every',
+    'all',
+    'any',
+    'few',
+    'more',
+    'most',
+    'other',
+    'some',
+    'such',
+    'no',
+    'only',
+    'own',
+    'same',
+    'than',
+    'too',
+    'very',
+    'just',
+    'because',
+    'until',
+    'while',
+    'about',
+    'against',
+    'this',
+    'that',
+    'these',
+    'those',
+    'it',
+    'its',
+]);
+/**
+ * Extract significant keywords from text for grouping.
+ * Filters stop words and short tokens, returns lowercase words.
+ */
+function extractKeywords(text) {
+    const words = text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .split(/\s+/);
+    const keywords = new Set();
+    for (const w of words) {
+        if (w.length >= 4 && !STOP_WORDS.has(w)) {
+            keywords.add(w);
+        }
+    }
+    return keywords;
+}
+/**
+ * Calculate keyword overlap ratio between two sets.
+ * Returns the Jaccard similarity coefficient.
+ */
+function keywordOverlap(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const w of a) {
+        if (b.has(w))
+            intersection++;
+    }
+    const union = a.size + b.size - intersection;
+    return union > 0 ? intersection / union : 0;
+}
+/**
+ * Consolidate old observations by keyword similarity.
+ *
+ * Groups observations older than `olderThanDays` by FTS5 keyword overlap.
+ * For groups with at least `minClusterSize` entries, creates one summary
+ * observation and marks originals as archived (updated_at set, narrative
+ * prefixed with [ARCHIVED]).
+ *
+ * @param projectRoot - Project root directory for brain.db resolution
+ * @param options - Consolidation configuration
+ * @returns Counts of grouped, merged, and archived observations
+ */
+export async function consolidateMemories(projectRoot, options) {
+    const olderThanDays = options?.olderThanDays ?? 90;
+    const minClusterSize = options?.minClusterSize ?? 3;
+    const { getBrainDb, getBrainNativeDb } = await import('../store/brain-sqlite.js');
+    await getBrainDb(projectRoot);
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb) {
+        return { grouped: 0, merged: 0, archived: 0 };
+    }
+    const cutoffDate = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .replace('T', ' ')
+        .slice(0, 19);
+    // Fetch old observations that are not already archived
+    const stmt = nativeDb.prepare(`
+    SELECT id, type, title, narrative, project, created_at
+    FROM brain_observations
+    WHERE created_at < ?
+      AND narrative NOT LIKE '[ARCHIVED]%'
+    ORDER BY created_at DESC
+  `);
+    const oldObservations = typedAll(stmt, cutoffDate);
+    if (oldObservations.length < minClusterSize) {
+        return { grouped: 0, merged: 0, archived: 0 };
+    }
+    // Extract keywords for each observation
+    const entries = oldObservations.map((obs) => ({
+        ...obs,
+        keywords: extractKeywords(`${obs.title} ${obs.narrative ?? ''}`),
+        clustered: false,
+    }));
+    // Greedy clustering: group by keyword overlap >= 0.3
+    const clusters = [];
+    const overlapThreshold = 0.3;
+    for (let i = 0; i < entries.length; i++) {
+        if (entries[i].clustered)
+            continue;
+        const cluster = [entries[i]];
+        entries[i].clustered = true;
+        for (let j = i + 1; j < entries.length; j++) {
+            if (entries[j].clustered)
+                continue;
+            if (entries[i].type !== entries[j].type)
+                continue;
+            const overlap = keywordOverlap(entries[i].keywords, entries[j].keywords);
+            if (overlap >= overlapThreshold) {
+                cluster.push(entries[j]);
+                entries[j].clustered = true;
+            }
+        }
+        if (cluster.length >= minClusterSize) {
+            clusters.push(cluster);
+        }
+    }
+    let grouped = 0;
+    let merged = 0;
+    let archived = 0;
+    const accessor = await getBrainAccessor(projectRoot);
+    const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    for (const cluster of clusters) {
+        grouped += cluster.length;
+        // Create summary observation from cluster
+        const titles = cluster.map((c) => c.title).join('; ');
+        const summaryTitle = `Consolidated: ${cluster[0].type} observations (${cluster.length} entries)`;
+        const summaryNarrative = `Merged from ${cluster.length} observations: ${titles.slice(0, 500)}`;
+        const contentHash = createHash('sha256')
+            .update(summaryTitle + summaryNarrative)
+            .digest('hex')
+            .slice(0, 16);
+        const id = `O-${Date.now().toString(36)}`;
+        await accessor.addObservation({
+            id,
+            type: cluster[0]
+                .type,
+            title: summaryTitle,
+            narrative: summaryNarrative,
+            contentHash,
+            project: cluster[0].project ?? null,
+            sourceType: 'agent',
+            createdAt: now,
+        });
+        merged++;
+        // Archive originals by prefixing narrative
+        for (const obs of cluster) {
+            nativeDb
+                .prepare(`
+        UPDATE brain_observations
+        SET narrative = '[ARCHIVED] ' || COALESCE(narrative, ''),
+            updated_at = ?
+        WHERE id = ?
+      `)
+                .run(now, obs.id);
+            archived++;
+        }
+    }
+    return { grouped, merged, archived };
+}
+/**
+ * Run tier promotion for all memory tables.
+ *
+ * Promotion rules (per spec §1.1–§1.3, relaxed in T614):
+ * - short → medium:
+ *     A. (citationCount >= 3 AND age > 24h) — citation-based track
+ *     B. (qualityScore >= 0.7 AND age > 24h) — quality fast-track
+ *     C. (verified = true AND age > 24h) — owner-verified track
+ *   Note: `verified` is no longer a hard gate for routes A and B.
+ *   Requiring verified=true on all paths caused all 235 short-tier observations
+ *   to be permanently stuck (T614 bug).
+ * - medium → long:
+ *     (citationCount >= 5 AND age > 7 days) OR (verified = true AND age > 7 days)
+ *   Verified entries accelerate to long-tier without citation threshold.
+ *
+ * Eviction rules:
+ * - short-term entries older than 7 days with no promotion eligibility are
+ *   soft-evicted (invalidAt = now).
+ * - long-term entries are NEVER auto-evicted.
+ *
+ * @param projectRoot - Project root directory for brain.db resolution
+ * @returns Lists of promoted and evicted entries
+ */
+export async function runTierPromotion(projectRoot) {
+    const { getBrainDb, getBrainNativeDb } = await import('../store/brain-sqlite.js');
+    await getBrainDb(projectRoot);
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb) {
+        return { promoted: [], evicted: [] };
+    }
+    const promoted = [];
+    const evicted = [];
+    const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    // Threshold timestamps
+    const age24h = new Date(Date.now() - 24 * 60 * 60 * 1000)
+        .toISOString()
+        .replace('T', ' ')
+        .slice(0, 19);
+    const age7d = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .replace('T', ' ')
+        .slice(0, 19);
+    const evictionCutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .replace('T', ' ')
+        .slice(0, 19);
+    // Tables + their date column name (mixed conventions in schema)
+    const tables = [
+        { table: 'brain_observations', dateCol: 'created_at' },
+        { table: 'brain_learnings', dateCol: 'created_at' },
+        { table: 'brain_patterns', dateCol: 'extracted_at' },
+        { table: 'brain_decisions', dateCol: 'created_at' },
+    ];
+    for (const { table, dateCol } of tables) {
+        let shortToMedium = [];
+        try {
+            shortToMedium = typedAll(nativeDb.prepare(`
+          SELECT id, citation_count, quality_score, verified
+          FROM ${table}
+          WHERE memory_tier = 'short'
+            AND invalid_at IS NULL
+            AND ${dateCol} < ?
+            AND (
+              citation_count >= 3
+              OR quality_score >= 0.7
+              OR verified = 1
+            )
+        `), age24h);
+        }
+        catch {
+            // Table may lack columns on older DB — best-effort
+            continue;
+        }
+        for (const row of shortToMedium) {
+            try {
+                nativeDb
+                    .prepare(`UPDATE ${table} SET memory_tier = 'medium', updated_at = ? WHERE id = ?`)
+                    .run(now, row.id);
+                let reason;
+                if (row.citation_count >= 3) {
+                    reason = `citationCount=${row.citation_count} >= 3, age > 24h`;
+                }
+                else if ((row.quality_score ?? 0) >= 0.7) {
+                    reason = `qualityScore=${row.quality_score?.toFixed(2)} >= 0.70, age > 24h`;
+                }
+                else {
+                    reason = `verified=true, age > 24h`;
+                }
+                promoted.push({ id: row.id, table, fromTier: 'short', toTier: 'medium', reason });
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        // --- medium → long promotion ---
+        // Two criteria (union — verified accelerates to long without citation threshold):
+        //   A. citationCount >= 5 AND age > 7d
+        //   B. verified = 1 AND age > 7d (owner-verified accelerated track)
+        let mediumToLong = [];
+        try {
+            mediumToLong = typedAll(nativeDb.prepare(`
+          SELECT id, citation_count, quality_score, verified
+          FROM ${table}
+          WHERE memory_tier = 'medium'
+            AND invalid_at IS NULL
+            AND ${dateCol} < ?
+            AND (citation_count >= 5 OR verified = 1)
+        `), age7d);
+        }
+        catch {
+            continue;
+        }
+        for (const row of mediumToLong) {
+            try {
+                nativeDb
+                    .prepare(`UPDATE ${table} SET memory_tier = 'long', updated_at = ? WHERE id = ?`)
+                    .run(now, row.id);
+                const reason = row.citation_count >= 5
+                    ? `citationCount=${row.citation_count} >= 5, age > 7d`
+                    : `verified=true, age > 7d`;
+                promoted.push({ id: row.id, table, fromTier: 'medium', toTier: 'long', reason });
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        let toEvict = [];
+        try {
+            toEvict = typedAll(nativeDb.prepare(`
+          SELECT id, quality_score
+          FROM ${table}
+          WHERE memory_tier = 'short'
+            AND invalid_at IS NULL
+            AND ${dateCol} < ?
+            AND (verified = 0 OR verified IS NULL)
+            AND (quality_score IS NULL OR quality_score < 0.5)
+        `), evictionCutoff);
+        }
+        catch {
+            continue;
+        }
+        for (const row of toEvict) {
+            try {
+                nativeDb
+                    .prepare(`UPDATE ${table} SET invalid_at = ?, updated_at = ? WHERE id = ?`)
+                    .run(now, now, row.id);
+                evicted.push({
+                    id: row.id,
+                    table,
+                    tier: 'short',
+                    reason: `age > 7d, unverified, qualityScore=${row.quality_score?.toFixed(2) ?? 'null'} < 0.5`,
+                });
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+    }
+    return { promoted, evicted };
+}
+/**
+ * Run the full sleep-time consolidation pipeline.
+ *
+ * This is the "Letta OS sleep-time compute" pattern — consolidation runs
+ * during idle time (after session end), never during active work.
+ *
+ * Steps (in order):
+ *   1. Deduplication — merge entries with >0.85 content similarity
+ *   2. Quality recompute — recalculate scores with current age/citations
+ *   3. Tier promotion — runTierPromotion()
+ *   4. Contradiction detection — from brain-consolidator
+ *   5. Soft eviction — invalidate low-quality medium-term entries
+ *   6. Graph edge strengthening — increment weight on frequently-traversed edges
+ *   7. Summary generation — existing consolidateMemories() for large clusters
+ *
+ * All steps are BEST-EFFORT — any step failure is caught and logged to console.warn.
+ *
+ * @param projectRoot - Project root directory for brain.db resolution
+ * @returns Aggregated counts from each consolidation step
+ */
+export async function runConsolidation(projectRoot) {
+    const result = {
+        deduplicated: 0,
+        qualityRecomputed: 0,
+        tierPromotions: { promoted: [], evicted: [] },
+        contradictions: 0,
+        softEvicted: 0,
+        edgesStrengthened: 0,
+        summariesGenerated: 0,
+    };
+    // Step 1: Deduplication (embedding-based when available)
+    try {
+        const deduped = await deduplicateByEmbedding(projectRoot);
+        result.deduplicated = deduped;
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 1 deduplication failed:', err);
+    }
+    // Step 2: Quality recompute (age + citation factor)
+    try {
+        const recomputed = await recomputeQualityScores(projectRoot);
+        result.qualityRecomputed = recomputed;
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 2 quality recompute failed:', err);
+    }
+    // Step 3: Tier promotion
+    try {
+        result.tierPromotions = await runTierPromotion(projectRoot);
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 3 tier promotion failed:', err);
+    }
+    // Step 4: Contradiction detection
+    try {
+        const { detectContradictions } = await import('./brain-consolidator.js');
+        const contradictions = await detectContradictions(projectRoot);
+        result.contradictions = contradictions.length;
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 4 contradiction detection failed:', err);
+    }
+    // Step 5: Soft eviction of low-quality medium-term entries
+    try {
+        const evicted = await softEvictLowQualityMedium(projectRoot);
+        result.softEvicted = evicted;
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 5 soft eviction failed:', err);
+    }
+    // Step 6: Graph edge strengthening
+    try {
+        const strengthened = await strengthenCoRetrievedEdges(projectRoot);
+        result.edgesStrengthened = strengthened;
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 6 edge strengthening failed:', err);
+    }
+    // Step 7: Summary generation from large observation clusters
+    try {
+        const summaryResult = await consolidateMemories(projectRoot, {
+            olderThanDays: 30,
+            minClusterSize: 5,
+        });
+        result.summariesGenerated = summaryResult.merged;
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 7 summary generation failed:', err);
+    }
+    // Step 8: Link memory nodes to code graph (graph-memory-bridge, T555)
+    // Scans brain entries for entity references and creates code_reference
+    // edges connecting memory to nexus-indexed symbols.
+    try {
+        const { autoLinkMemories } = await import('./graph-memory-bridge.js');
+        const bridgeResult = await autoLinkMemories(projectRoot);
+        result.graphLinksCreated = bridgeResult.linked;
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 8 graph memory bridge failed:', err);
+    }
+    // Step 9: STDP timing-dependent plasticity (T626 phase 5)
+    // Refines co_retrieved edge weights using retrieval temporal order.
+    // Runs after Hebbian strengthening (step 6) so it builds on existing edges.
+    try {
+        const { applyStdpPlasticity } = await import('./brain-stdp.js');
+        const stdpResult = await applyStdpPlasticity(projectRoot);
+        result.stdpPlasticity = stdpResult;
+    }
+    catch (err) {
+        console.warn('[consolidation] Step 9 STDP plasticity failed:', err);
+    }
+    return result;
+}
+// ============================================================================
+// Deduplication (Step 1)
+// ============================================================================
+/**
+ * Merge entries with high embedding similarity (> 0.85 cosine similarity).
+ *
+ * For each pair above the threshold: keep the higher-quality entry, transfer
+ * citationCount, and soft-evict the clone (set invalidAt). When embeddings
+ * are unavailable, falls back to exact content-hash deduplication.
+ *
+ * @param projectRoot - Project root for brain.db resolution
+ * @returns Count of merged/evicted duplicate entries
+ */
+async function deduplicateByEmbedding(projectRoot) {
+    const { getBrainDb, getBrainNativeDb } = await import('../store/brain-sqlite.js');
+    await getBrainDb(projectRoot);
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb)
+        return 0;
+    let merged = 0;
+    const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    const dupHashes = typedAll(nativeDb.prepare(`
+      SELECT content_hash, COUNT(*) as cnt
+      FROM brain_observations
+      WHERE content_hash IS NOT NULL
+        AND invalid_at IS NULL
+      GROUP BY content_hash
+      HAVING cnt > 1
+    `));
+    for (const dup of dupHashes) {
+        const dupes = typedAll(nativeDb.prepare(`
+        SELECT id, quality_score, citation_count
+        FROM brain_observations
+        WHERE content_hash = ?
+          AND invalid_at IS NULL
+        ORDER BY quality_score DESC, citation_count DESC
+      `), dup.content_hash);
+        if (dupes.length < 2)
+            continue;
+        // Keep the best entry, evict the rest and transfer their citations
+        const [keeper, ...clones] = dupes;
+        if (!keeper)
+            continue;
+        let totalCitations = keeper.citation_count;
+        for (const clone of clones) {
+            totalCitations += clone.citation_count;
+            nativeDb
+                .prepare(`UPDATE brain_observations SET invalid_at = ?, updated_at = ? WHERE id = ?`)
+                .run(now, now, clone.id);
+            merged++;
+        }
+        if (totalCitations !== keeper.citation_count) {
+            nativeDb
+                .prepare(`UPDATE brain_observations SET citation_count = ?, updated_at = ? WHERE id = ?`)
+                .run(totalCitations, now, keeper.id);
+        }
+    }
+    return merged;
+}
+// ============================================================================
+// Quality Recompute (Step 2)
+// ============================================================================
+/**
+ * Recompute quality scores factoring in current citation count and age.
+ *
+ * Applies a citation boost: +0.01 per citation, capped at +0.15.
+ * Applies age decay only on episodic entries (observations, episodic learnings).
+ *
+ * @param projectRoot - Project root for brain.db resolution
+ * @returns Count of entries updated
+ */
+async function recomputeQualityScores(projectRoot) {
+    const { getBrainDb, getBrainNativeDb } = await import('../store/brain-sqlite.js');
+    await getBrainDb(projectRoot);
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb)
+        return 0;
+    let updated = 0;
+    const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    // Update observation quality: base + citation boost, min 0.0, max 1.0
+    // Only update entries with citation_count > 0 (others unchanged)
+    try {
+        const stmt = nativeDb.prepare(`
+      UPDATE brain_observations
+      SET quality_score = MIN(1.0, COALESCE(quality_score, 0.5) + MIN(0.15, citation_count * 0.01)),
+          updated_at = ?
+      WHERE citation_count > 0
+        AND invalid_at IS NULL
+    `);
+        const r = stmt.run(now);
+        updated += typeof r.changes === 'number' ? r.changes : 0;
+    }
+    catch {
+        /* table may not have all columns — best-effort */
+    }
+    // Same for learnings
+    try {
+        const stmt = nativeDb.prepare(`
+      UPDATE brain_learnings
+      SET quality_score = MIN(1.0, COALESCE(quality_score, 0.5) + MIN(0.15, citation_count * 0.01)),
+          updated_at = ?
+      WHERE citation_count > 0
+        AND invalid_at IS NULL
+    `);
+        const r = stmt.run(now);
+        updated += typeof r.changes === 'number' ? r.changes : 0;
+    }
+    catch {
+        /* best-effort */
+    }
+    return updated;
+}
+// ============================================================================
+// Soft Eviction of Low-Quality Medium-Term Entries (Step 5)
+// ============================================================================
+/**
+ * Soft-evict medium-term entries that have decayed below quality threshold.
+ *
+ * Entries are invalidated (invalidAt = now) when:
+ * - memoryTier = 'medium'
+ * - qualityScore < 0.30 AND age > 30 days
+ * - NOT long-term (protected from auto-eviction)
+ *
+ * @param projectRoot - Project root for brain.db resolution
+ * @returns Count of entries soft-evicted
+ */
+async function softEvictLowQualityMedium(projectRoot) {
+    const { getBrainDb, getBrainNativeDb } = await import('../store/brain-sqlite.js');
+    await getBrainDb(projectRoot);
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb)
+        return 0;
+    let evicted = 0;
+    const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    const age30d = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .replace('T', ' ')
+        .slice(0, 19);
+    const tables = [
+        { table: 'brain_observations', dateCol: 'created_at' },
+        { table: 'brain_learnings', dateCol: 'created_at' },
+        { table: 'brain_patterns', dateCol: 'extracted_at' },
+        { table: 'brain_decisions', dateCol: 'created_at' },
+    ];
+    for (const { table, dateCol } of tables) {
+        try {
+            const stmt = nativeDb.prepare(`
+        UPDATE ${table}
+        SET invalid_at = ?, updated_at = ?
+        WHERE memory_tier = 'medium'
+          AND invalid_at IS NULL
+          AND quality_score IS NOT NULL
+          AND quality_score < 0.30
+          AND ${dateCol} < ?
+      `);
+            const r = stmt.run(now, now, age30d);
+            evicted += typeof r.changes === 'number' ? r.changes : 0;
+        }
+        catch {
+            /* column may not exist on older rows — best-effort */
+        }
+    }
+    return evicted;
+}
+// ============================================================================
+// Graph Edge Strengthening (Step 6)
+// ============================================================================
+/**
+ * Strengthen edges between frequently co-retrieved brain graph nodes.
+ *
+ * Queries the brain_retrieval_log table (if it exists) to find pairs of
+ * entries that were returned together frequently (>= 3 times in the last
+ * 30 days). For each qualifying pair, increments the edge weight by 0.1
+ * (capped at 1.0) in brain_page_edges.
+ *
+ * Gracefully no-ops when brain_retrieval_log does not yet exist.
+ *
+ * @param projectRoot - Project root for brain.db resolution
+ * @returns Count of edges strengthened
+ */
+async function strengthenCoRetrievedEdges(projectRoot) {
+    const { getBrainDb, getBrainNativeDb } = await import('../store/brain-sqlite.js');
+    await getBrainDb(projectRoot);
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb)
+        return 0;
+    // Check if retrieval log table exists
+    try {
+        nativeDb.prepare('SELECT 1 FROM brain_retrieval_log LIMIT 1').get();
+    }
+    catch {
+        // Table doesn't exist yet — nothing to do
+        return 0;
+    }
+    const age30d = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .replace('T', ' ')
+        .slice(0, 19);
+    const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    let logRows = [];
+    try {
+        logRows = typedAll(nativeDb.prepare(`SELECT entry_ids FROM brain_retrieval_log WHERE created_at >= ? LIMIT 1000`), age30d);
+    }
+    catch {
+        return 0;
+    }
+    // Build co-occurrence counts from JSON entry_ids arrays
+    const coOccurrence = new Map();
+    for (const row of logRows) {
+        let ids;
+        try {
+            ids = JSON.parse(row.entry_ids);
+        }
+        catch {
+            continue;
+        }
+        // Generate all pairs from the returned ID list
+        for (let i = 0; i < ids.length; i++) {
+            for (let j = i + 1; j < ids.length; j++) {
+                const a = ids[i];
+                const b = ids[j];
+                // Normalize pair key to canonical order
+                const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+                coOccurrence.set(key, (coOccurrence.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    let strengthened = 0;
+    for (const [pair, count] of coOccurrence) {
+        if (count < 3)
+            continue;
+        const [fromId, toId] = pair.split('|');
+        if (!fromId || !toId)
+            continue;
+        const nodeFrom = `observation:${fromId}`;
+        const nodeTo = `observation:${toId}`;
+        try {
+            // Try to update existing edge
+            const updateStmt = nativeDb.prepare(`
+        UPDATE brain_page_edges
+        SET weight = MIN(1.0, weight + 0.1)
+        WHERE from_id = ? AND to_id = ? AND edge_type = ?
+      `);
+            const updateResult = updateStmt.run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED);
+            const changes = typeof updateResult.changes === 'number' ? updateResult.changes : 0;
+            if (changes === 0) {
+                // Edge doesn't exist; insert it
+                nativeDb
+                    .prepare(`
+            INSERT OR IGNORE INTO brain_page_edges
+              (from_id, to_id, edge_type, weight, provenance, created_at)
+            VALUES (?, ?, ?, 0.3, 'consolidation:co-retrieval', ?)
+          `)
+                    .run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED, now);
+            }
+            strengthened++;
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    return strengthened;
+}
+//# sourceMappingURL=brain-lifecycle.js.map