@psiclawops/hypermem 0.9.0 → 0.9.1

package/dist/background-indexer.js

@@ -1,1263 +0,0 @@
-/**
- * hypermem Background Indexer
- *
- * Processes message history to extract structured knowledge:
- *   - Facts: atomic pieces of learned information
- *   - Episodes: significant events worth remembering
- *   - Topics: conversation threads and their lifecycle
- *   - Knowledge: durable structured entries (domain + key)
- *
- * Runs as a periodic background task, processing unindexed messages
- * in batches. Each batch is scored, classified, and stored in L4 (library.db).
- *
- * Design principles:
- *   - No LLM dependency: extraction uses pattern matching + heuristics
- *   - Idempotent: tracks watermarks per agent to avoid reprocessing
- *   - Bounded: processes N messages per tick to avoid blocking
- *   - Observable: logs extraction stats for monitoring
- */
-import { lintKnowledge } from './knowledge-lint.js';
-import { MessageStore } from './message-store.js';
-import { runNoiseSweep, runToolDecay } from './proactive-pass.js';
-import { TopicSynthesizer } from './topic-synthesizer.js';
-import { runDreamingPassForFleet } from './dreaming-promoter.js';
-import { FactStore } from './fact-store.js';
-import { EpisodeStore } from './episode-store.js';
-import { TopicStore } from './topic-store.js';
-import { KnowledgeStore } from './knowledge-store.js';
-import { TemporalStore } from './temporal-store.js';
-import { ContradictionDetector } from './contradiction-detector.js';
-import { ContradictionAuditStore } from './contradiction-audit-store.js';
-import { DEFAULT_CONTRADICTION_POLICY } from './contradiction-resolution-policy.js';
-import { isSafeForSharedVisibility } from './secret-scanner.js';
-// ─── Agent-to-Domain Map ────────────────────────────────────────
-// Maps well-known agent IDs to their primary domain.
-// Used to populate the `domain` column on extracted facts so that
-// domain-scoped retrieval (e.g. getActiveFacts({ domain: 'infrastructure' }))
-// returns results. New agents default to 'general'.
-//
-// ── EXAMPLE DATA ──────────────────────────────────────────────────
-// The agent names below (alice, director1, etc.) are PLACEHOLDERS.
-// Replace them with your own agent IDs and domain labels to match
-// your fleet. Single-agent installs don't need to edit this:
-// unknown agents fall through to 'general' automatically.
-// See INSTALL.md § "Configure your fleet" for details.
-// ─────────────────────────────────────────────────────────────────
-const AGENT_DOMAIN_MAP = {
-    alice: 'infrastructure',
-    director2: 'infrastructure',
-    director1: 'infrastructure',
-    director3: 'infrastructure',
-    bob: 'product',
-    director4: 'product',
-    director5: 'product',
-    director6: 'product',
-    dave: 'security',
-    director7: 'security',
-    director8: 'security',
-    agent4: 'ux',
-    carol: 'governance',
-    oscar: 'strategy',
-    specialist1: 'development',
-    specialist2: 'communications',
-    main: 'general',
-    'channel-mini': 'general',
-};
-/**
- * Derive a domain label for a fact based on agent ID.
- * Falls back to 'general' for unknown agents.
- */
-function domainForAgent(agentId) {
-    return AGENT_DOMAIN_MAP[agentId] ?? 'general';
-}
-function extractFactCandidates(content) {
-    const facts = [];
-    if (!content || content.length < 20)
-        return facts;
-    // Decision patterns: "decided to", "agreed on", "choosing", "going with" — high confidence (0.75)
-    const decisionPatterns = [
-        /(?:we |I |they )?(?:decided|agreed|chose|selected|committed) (?:to |on |that )(.{20,200})/gi,
-        /(?:going|went) with (.{10,150})/gi,
-        /decision:\s*(.{10,200})/gi,
-    ];
-    // Learned/discovered patterns — medium-high confidence (0.65)
-    const learnedPatterns = [
-        /(?:learned|discovered|found out|realized|noticed) (?:that |)(.{20,200})/gi,
-        /turns out (?:that |)(.{20,200})/gi,
-        /(?:TIL|FYI|note to self)[:\s]+(.{10,200})/gi,
-    ];
-    // Config/setting patterns — medium confidence (0.60); matches more promiscuously
-    const configPatterns = [
-        /(?:set|changed|updated|configured) (\S+ to .{5,150})/gi,
-        /(?:model|config|setting)[:\s]+(\S+\s*(?:→|->|=|is)\s*.{5,100})/gi,
-    ];
-    // Preference patterns — medium confidence (0.60)
-    const preferencePatterns = [
-        /(?:prefer|always use|never use|don't use|avoid) (.{10,150})/gi,
-        /(?:operator) (?:wants|prefers|likes|hates|dislikes) (.{10,150})/gi,
-    ];
-    // Operational patterns: deployments, incidents, fixes — high confidence (0.70)
-    const operationalPatterns = [
-        /(?:deployed|shipped|released|rolled back|reverted) (.{10,200})/gi,
-        /(?:outage|incident|failure|broke|broken|crashed)(?:: | — | - )(.{10,200})/gi,
-        /(?:fixed|resolved|patched|hotfixed) (.{10,200})/gi,
-    ];
-    const patternGroups = [
-        { patterns: decisionPatterns, confidence: 0.75 },
-        { patterns: learnedPatterns, confidence: 0.65 },
-        { patterns: configPatterns, confidence: 0.60 },
-        { patterns: preferencePatterns, confidence: 0.60 },
-        { patterns: operationalPatterns, confidence: 0.70 },
-    ];
-    for (const { patterns, confidence } of patternGroups) {
-        for (const pattern of patterns) {
-            let match;
-            // Reset lastIndex for global patterns
-            pattern.lastIndex = 0;
-            while ((match = pattern.exec(content)) !== null) {
-                const candidate = match[1].trim();
-                // Quality gate: reject noise that matched patterns but isn't a real fact
-                if (!isQualityFact(candidate))
-                    continue;
-                facts.push({ content: candidate, confidence });
-            }
-        }
-    }
-    return facts;
-}
-/**
- * TUNE-011: Quality gate for fact extraction.
- * Rejects pattern matches that are code, table fragments, questions,
- * or too short to be meaningful facts.
- */
-/**
- * Operational boilerplate phrases that appear frequently across sessions
- * but carry zero signal value. High knn similarity makes them *worse*
- * retrieval candidates — they match everything and contaminate episodes.
- */
-const OPERATIONAL_BOILERPLATE = [
-    /timed?\s*out\s*waiting/i,
-    /message\s*was\s*delivered/i,
-    /no\s*reply\s*(back\s*)?yet/i,
-    /picked?\s*it\s*up\s*on\s*(next\s*)?heartbeat/i,
-    /session\s*not\s*found/i,
-    /\bretrying\b/i,
-    /tool\s*call\s*failed/i,
-    /exec\s*completed/i,
-    /no\s*reply\s*needed/i,
-    /still\s*waiting/i,
-    /will\s*pick\s*(it\s*)?up\s*(on\s*(next|the))?/i,
-    /message\s*is\s*in\s*(his|her|their|the)\s*queue/i,
-    /sent\s+to\s+(carol|bob|agent4|dave|oscar|alice)/i,
-    /dispatched\s+(it\s+)?to/i,
-    /timed\s*out\s*after/i,
-    /\bNO_REPLY\b/,
-];
-function isQualityFact(content) {
-    // Too short — sentence fragments
-    if (content.length < 40)
-        return false;
-    // Too long — likely captured a paragraph, not a fact
-    if (content.length > 300)
-        return false;
-    // Fewer than 5 words — fragment
-    const wordCount = content.split(/\s+/).filter(w => w.length > 0).length;
-    if (wordCount < 5)
-        return false;
-    // Questions — not assertions of fact
-    if (content.trimEnd().endsWith('?'))
-        return false;
-    // Code indicators: braces, arrows, imports, variable declarations
-    if (/^[\s{}\[\]|`]/.test(content))
-        return false; // starts with structural char
-    if (/[{}].*[{}]/.test(content))
-        return false; // contains paired braces (code blocks)
-    if (/^\s*(import|export|const|let|var|function|class|interface|type|return|if|for|while|switch)\s/i.test(content))
-        return false;
-    if (/=>\s*[{(]/.test(content))
-        return false; // arrow functions
-    if (/SELECT\s|INSERT\s|UPDATE\s|DELETE\s|CREATE\s/i.test(content))
-        return false; // SQL
-    // Table cell fragments: contains pipe-delimited cells
-    if (/\|.*\|.*\|/.test(content))
-        return false;
-    // Regex patterns leaked from source
-    if (/\/[^/]+\/[gimsuvy]*[,;]/.test(content))
-        return false;
-    // Raw file paths without context (tool output, not facts)
-    if (/^\/[\w/.-]+$/.test(content.trim()))
-        return false;
-    // Markdown formatting artifacts
-    if (content.startsWith('```') || content.startsWith('---') || content.startsWith('==='))
-        return false;
-    // Git output
-    if (/^[a-f0-9]{7,40}\s/.test(content) || /^\+\+\+|^---\s[ab]\//.test(content))
-        return false;
-    if (/^\d+ files? changed/.test(content))
-        return false;
-    // Stack traces
-    if (/^\s*at\s+\S+\s+\(/.test(content) || /node:internal/.test(content))
-        return false;
-    // High non-alpha ratio indicates code/data, not natural language
-    const alphaChars = (content.match(/[a-zA-Z]/g) || []).length;
-    if (alphaChars / content.length < 0.5)
-        return false;
-    // TUNE-013: External/untrusted content markers — web search excerpts,
-    // external doc pulls, and injected context blocks should never become facts.
-    if (/<<<\s*(END_EXTERNAL|BEGIN_EXTERNAL|EXTERNAL_UNTRUSTED|UNTRUSTED_CONTENT)/i.test(content))
-        return false;
-    if (/EXTERNAL_UNTRUSTED_CONTENT\s+id=/.test(content))
-        return false;
-    // TUNE-013: Multi-paragraph content — real extracted facts are single sentences.
-    // More than 2 newlines means we captured a paragraph or structured block, not a fact.
-    const newlineCount = (content.match(/\n/g) || []).length;
-    if (newlineCount > 2)
-        return false;
-    // TUNE-013: URL-heavy content — external source snippets, not actionable facts
-    const urlMatches = content.match(/https?:\/\/\S+/g) || [];
-    if (urlMatches.length >= 2)
-        return false; // one URL in a fact is ok; multiple = source snippet
-    // TUNE-013: Content starting with a markdown heading is section text, not a fact
-    if (/^#{1,4}\s/.test(content.trim()))
-        return false;
-    // TUNE-014: Operational boilerplate — phrases common across sessions that produce
-    // high knn similarity scores but carry zero signal. They cross-contaminate episodes.
-    for (const pattern of OPERATIONAL_BOILERPLATE) {
-        if (pattern.test(content))
-            return false;
-    }
-    return true;
-}
-/**
- * Classify a message for episode significance.
- * Returns episode type and significance score, or null if not significant.
- */
-function classifyEpisode(msg) {
-    const content = msg.textContent || '';
-    if (!content || content.length < 50)
-        return null; // Raised from 30
-    // Skip heartbeats
-    if (msg.isHeartbeat)
-        return null;
-    // Skip messages that are primarily code/data output (tool results, logs)
-    const alphaRatio = (content.match(/[a-zA-Z]/g) || []).length / content.length;
-    if (alphaRatio < 0.4)
-        return null;
-    // Skip messages that start with structural output indicators
-    if (/^[\s]*[{[\d|#=+\-]/.test(content) && content.length < 200)
-        return null;
-    const lower = content.toLowerCase();
-    // ── Negation-aware incident detection ──────────────────────
-    // Only trigger on actual incidents, not "zero failures" or "no crashes"
-    const incidentTerms = ['outage', 'incident', 'failure', 'crash', 'broke', 'broken', 'emergency'];
-    const negationPrefixes = ['no ', 'zero ', 'without ', '0 ', 'never ', 'fixed ', 'resolved '];
-    const hasIncidentTerm = incidentTerms.some(term => lower.includes(term));
-    const isNegated = hasIncidentTerm && incidentTerms.some(term => {
-        const idx = lower.indexOf(term);
-        if (idx < 0)
-            return false;
-        const prefix = lower.substring(Math.max(0, idx - 15), idx).toLowerCase();
-        return negationPrefixes.some(neg => prefix.includes(neg.trimEnd()));
-    });
-    if (hasIncidentTerm && !isNegated && content.length > 100) {
-        // Genuine incident — verify it's describing a problem, not analyzing code
-        if (!/^\s*(\/\/|#|\*|\/\*|```|import|const|function)/.test(content)) {
-            const summary = content.slice(0, 200);
-            return { type: 'incident', significance: 0.9, summary };
-        }
-    }
-    // Deployment events (high significance)
-    if (/(?:deployed|shipped|released|went live|now live|go live)/i.test(content) &&
-        content.length > 60) {
-        const summary = content.slice(0, 200);
-        return { type: 'deployment', significance: 0.8, summary };
-    }
-    // Architecture decisions (high significance)
-    if (/(?:decided on|chose|committed to|architecture|design decision)/i.test(content) &&
-        content.length > 80) {
-        const summary = content.slice(0, 200);
-        return { type: 'decision', significance: 0.7, summary };
-    }
-    // Discovery/insight (medium significance)
-    if (/(?:discovered|found|realized|root cause|turns out)/i.test(content) && content.length > 80) {
-        const summary = content.slice(0, 200);
-        return { type: 'discovery', significance: 0.5, summary };
-    }
-    // Config changes (medium significance) — TUNE-004: raised to 0.5
-    if (/(?:changed|updated|migrated|switched|model.*(?:→|->|to))/i.test(content) && content.length > 60) {
-        // Skip if it's just a tool output confirmation
-        if (/^Successfully replaced|^\[main [a-f0-9]|^ok \d+ -/.test(content))
-            return null;
-        const summary = content.slice(0, 200);
-        return { type: 'config_change', significance: 0.5, summary };
-    }
-    // Milestone/completion (medium significance)
-    if (/(?:completed|finished|done|milestone|all tests pass|all green)/i.test(content) &&
-        content.length > 60) {
-        // Skip tool output that happens to contain "done"
-        if (/^Successfully|^\[main|^ok \d+/.test(content))
-            return null;
-        const summary = content.slice(0, 200);
-        return { type: 'milestone', significance: 0.5, summary };
-    }
-    return null;
-}
-/**
- * Extract knowledge candidates — structured (domain, key, value) tuples.
- */
-function extractKnowledgeCandidates(content, agentId) {
-    const results = [];
-    if (!content || content.length < 30)
-        return results;
-    // TUNE-012: Broadened path extraction.
-    // Real messages use paths inline without explicit prefixes like "located at".
-    // Match any absolute path that's at least 3 segments deep (filters /tmp, /etc noise).
-    const pathMatches = content.matchAll(/(?:`([/][\w./-]{10,})`|(?:^|[\s:=])(\/home\/[\w./-]{10,}|\/opt\/[\w./-]{10,}|\/var\/[\w./-]{10,}))/gm);
-    for (const match of pathMatches) {
-        const value = (match[1] || match[2]).replace(/[`'".,;:)]+$/, '').trim();
-        if (value.length > 10 && value.split('/').length >= 4) {
-            const segments = value.split('/').filter(s => s.length > 0);
-            const lastSeg = segments[segments.length - 1] || '';
-            // Reject truncated paths (last segment < 3 chars unless it's a known ext)
-            if (lastSeg.length < 3 && !lastSeg.includes('.'))
-                continue;
-            const key = lastSeg || segments[segments.length - 2] || 'unknown';
-            results.push({ domain: 'paths', key, value });
-        }
-    }
-    // Explicit location references (original patterns, kept for completeness)
-    const locationPatterns = [
-        /(?:path|located at|lives at|stored at|found at|repo at|running at)[:\s]+(`[^`]+`|\/\S+)/gi,
-        /(?:workspace|directory|repo|project)[:\s]+(`[^`]+`|\/\S+)/gi,
-    ];
-    for (const pattern of locationPatterns) {
-        pattern.lastIndex = 0;
-        let match;
-        while ((match = pattern.exec(content)) !== null) {
-            const value = match[1].replace(/[`'".,;:)]+/g, '').trim();
-            if (value.startsWith('/') && value.length > 10 && !results.some(r => r.value === value)) {
-                const key = value.split('/').pop() || 'unknown';
-                results.push({ domain: 'paths', key, value });
-            }
-        }
-    }
-    // Service/port patterns — broadened to catch "port NNNN" and "on :NNNN"
-    const servicePatterns = [
-        /(\S+)\s+(?:runs on|listening on|port|on port)\s+(\d{2,5})/gi,
-        /(?:service|server|daemon)\s+(\S+)\s+(?:on |at |: )(\S+)/gi,
-        /(?:localhost|127\.0\.0\.1):(\d{2,5})\b/gi,
-    ];
-    for (const pattern of servicePatterns) {
-        pattern.lastIndex = 0;
-        let match;
-        while ((match = pattern.exec(content)) !== null) {
-            if (pattern.source.includes('localhost')) {
-                // localhost:PORT pattern — key is the port, value is the URL
-                results.push({ domain: 'services', key: `port:${match[1]}`, value: match[0] });
-            }
-            else {
-                results.push({ domain: 'services', key: match[1], value: match[2] });
-            }
-        }
-    }
-    // Agent identity patterns — broadened
-    const identityPatterns = [
-        /(\w+)\s+(?:is|was)\s+(?:the\s+)?(\w+)\s+(?:seat|director|specialist|council)/gi,
-        /(\w+)\s+(?:reports to|owned by|managed by)\s+(\w+)/gi,
-        /(?:agents?|directors?|seats?)[:\s]+(\w+)(?:\s*[,/]\s*(\w+))+/gi,
-    ];
-    for (const pattern of identityPatterns) {
-        pattern.lastIndex = 0;
-        let match;
-        while ((match = pattern.exec(content)) !== null) {
-            if (match[2]) {
-                results.push({ domain: 'fleet', key: match[1].toLowerCase(), value: `${match[1]} ${match[2]}` });
-            }
-        }
-    }
-    // Dedup by domain+key
-    const seen = new Set();
-    return results.filter(r => {
-        const k = `${r.domain}:${r.key}`;
-        if (seen.has(k))
-            return false;
-        seen.add(k);
-        return true;
-    });
-}
-/**
- * Detect conversation topic from message content.
- * Returns a topic name candidate or null.
- */
-function detectTopic(content) {
-    if (!content || content.length < 50)
-        return null;
-    // Product/project name detection
-    const productMatch = content.match(/\b(HyperMem|ClawText|dashboard|canvas|council|automation|OpenClaw|dispatch)\b/i);
-    if (productMatch)
-        return productMatch[1];
-    // Infrastructure topic detection
-    if (/\b(?:redis|sqlite|database|migration|deployment|docker|nginx)\b/i.test(content)) {
-        return 'infrastructure';
-    }
-    // Security topic detection
-    if (/\b(?:security|auth|permission|access|token|credential)\b/i.test(content)) {
-        return 'security';
-    }
-    return null;
-}
-// ─── Background Indexer ─────────────────────────────────────────
-export class BackgroundIndexer {
-    getMessageDb;
-    getLibraryDb;
-    listAgents;
-    getCursor;
-    config;
-    dreamerConfig;
-    globalWritePolicy;
-    contradictionPolicy;
-    intervalHandle = null;
-    running = false;
-    vectorStore = null;
-    synthesizer = null;
-    tickCount = 0;
-    /** Circuit breaker: consecutive tick failure count. Resets on success. */
-    consecutiveFailures = 0;
-    /** True when the indexer is running in backoff mode due to repeated failures. */
-    inBackoff = false;
-    _conversationLastProcessed = new Map();
-    lastMaintenanceDiagnostics = null;
-    constructor(config, getMessageDb, getLibraryDb, listAgents, getCursor, dreamerConfig, globalWritePolicy, contradictionPolicy) {
-        this.getMessageDb = getMessageDb;
-        this.getLibraryDb = getLibraryDb;
-        this.listAgents = listAgents;
-        this.getCursor = getCursor;
-        // Initialize synthesizer if libraryDb accessor is available
-        if (getLibraryDb) {
-            const libDb = getLibraryDb();
-            if (libDb) {
-                this.synthesizer = new TopicSynthesizer(libDb, (agentId) => {
-                    if (!getMessageDb)
-                        return null;
-                    try {
-                        return getMessageDb(agentId);
-                    }
-                    catch {
-                        return null;
-                    }
-                });
-            }
-        }
-        this.config = {
-            enabled: config?.enabled ?? true,
-            factExtractionMode: config?.factExtractionMode ?? 'tiered',
-            topicDormantAfter: config?.topicDormantAfter ?? '24h',
-            topicClosedAfter: config?.topicClosedAfter ?? '7d',
-            factDecayRate: config?.factDecayRate ?? 0.01,
-            episodeSignificanceThreshold: config?.episodeSignificanceThreshold ?? 0.5,
-            periodicInterval: config?.periodicInterval ?? 60000, // 1 minute
-            batchSize: config?.batchSize ?? 128,
-            maxMessagesPerTick: config?.maxMessagesPerTick ?? 500,
-            maxActiveConversations: config?.maxActiveConversations ?? 5,
-            recentConversationCooldownMs: config?.recentConversationCooldownMs ?? 30000,
-            maxCandidatesPerPass: config?.maxCandidatesPerPass ?? 200,
-        };
-        this.dreamerConfig = dreamerConfig ?? {};
-        this.globalWritePolicy = globalWritePolicy ?? 'deny';
-        this.contradictionPolicy = contradictionPolicy ?? DEFAULT_CONTRADICTION_POLICY;
-    }
-    /**
-     * Set the vector store for embedding new facts/episodes at index time.
-     * Optional — if not set, indexer runs without embedding (FTS5-only mode).
-     */
-    setVectorStore(vs) {
-        this.vectorStore = vs;
-    }
-    /**
-     * Start periodic indexing.
-     */
-    start() {
-        if (!this.config.enabled)
-            return;
-        if (this.intervalHandle)
-            return;
-        // Startup integrity check — catch corruption before the first tick writes anything.
-        if (this.getLibraryDb) {
-            try {
-                const libDb = this.getLibraryDb();
-                if (libDb) {
-                    const row = libDb.prepare('PRAGMA quick_check').get();
-                    if (row?.integrity_check && row.integrity_check !== 'ok') {
-                        console.error('[indexer] ⚠️  library.db integrity check failed: ' + row.integrity_check + '\n' +
-                            '[indexer] Recovery: stop OpenClaw, run ' +
-                            '`sqlite3 ~/.openclaw/hypermem/library.db ".recover" | sqlite3 ~/.openclaw/hypermem/library_recovered.db`' +
-                            ', swap the files, and restart. If recovery fails, delete library.db — the indexer rebuilds from message history.');
-                        // Don't start the interval — nothing will succeed with a corrupt DB.
-                        return;
-                    }
-                }
-            }
-            catch (err) {
-                // If we can't even open the DB, log and bail — don't start the interval.
-                console.error('[indexer] Could not open library.db for integrity check:', err.message);
-                return;
-            }
-        }
-        // Run once immediately
-        this.tick().catch(err => {
-            this._handleTickError(err, 'initial');
-        });
-        // Run episode vector backfill once at startup (no-op if already done)
-        if (this.vectorStore && this.getLibraryDb) {
-            this.backfillEpisodeVectors().catch(err => {
-                console.error('[indexer] Episode backfill failed:', err);
-            });
-        }
-        // Then periodically
-        this.intervalHandle = setInterval(() => {
-            this.tick().catch(err => {
-                this._handleTickError(err, 'periodic');
-            });
-        }, this.config.periodicInterval);
-        console.log(`[indexer] Started with interval ${this.config.periodicInterval}ms, batchSize ${this.config.batchSize}, maxPerTick ${this.config.maxMessagesPerTick}`);
-    }
-    /**
-     * Circuit breaker for tick failures.
-     *
-     * - Tracks consecutive failures.
-     * - After 3 failures, logs actionable recovery guidance once, then switches
-     *   the indexer to 10× backoff interval so it stops spamming the log.
-     * - On the next successful tick, resets state and restores normal interval.
-     */
-    _handleTickError(err, phase) {
-        this.consecutiveFailures++;
-        const msg = err instanceof Error ? err.message : String(err);
-        const isSqliteCorrupt = msg.includes('database disk image is malformed') ||
-            msg.includes('SQLITE_CORRUPT') ||
-            (err instanceof Error && 'code' in err && err.code === 'ERR_SQLITE_ERROR');
-        if (this.consecutiveFailures < 3) {
-            // First 1–2 failures: log normally.
-            console.error(`[indexer] ${phase === 'initial' ? 'Initial' : 'Periodic'} tick failed (attempt ${this.consecutiveFailures}/3):`, err);
-            return;
-        }
-        if (this.consecutiveFailures === 3) {
-            // Third failure: log once with recovery instructions, then enter backoff.
-            if (isSqliteCorrupt) {
-                console.error(`[indexer] ⛔ Tick failed 3 times consecutively — library.db appears corrupted. Entering backoff mode.\n` +
-                    `[indexer] Recovery steps:\n` +
-                    `[indexer]   1. Stop OpenClaw: openclaw gateway stop\n` +
-                    `[indexer]   2. Check damage: sqlite3 ~/.openclaw/hypermem/library.db "PRAGMA integrity_check"\n` +
-                    `[indexer]   3. Attempt recovery: sqlite3 ~/.openclaw/hypermem/library.db ".recover" | sqlite3 ~/.openclaw/hypermem/library_recovered.db\n` +
-                    `[indexer]   4. Swap: mv library.db library_corrupt.bak && mv library_recovered.db library.db\n` +
-                    `[indexer]   5. If recovery fails, delete library.db — the indexer rebuilds from message history on next start.\n` +
-                    `[indexer]   6. Restart: openclaw gateway start\n` +
-                    `[indexer] Indexer will retry every ${(this.config.periodicInterval * 10) / 60000} minutes until then.`);
-            }
-            else {
-                console.error(`[indexer] ⛔ Tick failed 3 times consecutively (${msg}). Entering backoff mode. ` +
-                    `Will retry every ${(this.config.periodicInterval * 10) / 60000} minutes.`);
-            }
-            // Switch to backoff interval.
-            this.inBackoff = true;
-            if (this.intervalHandle) {
-                clearInterval(this.intervalHandle);
-            }
-            this.intervalHandle = setInterval(() => {
-                this.tick().catch(backoffErr => {
-                    this._handleTickError(backoffErr, 'periodic');
-                });
-            }, this.config.periodicInterval * 10);
-            return;
-        }
-        // Beyond 3: silent (already logged, in backoff — don't spam).
-    }
-    /**
-     * Reset the circuit breaker and restore normal interval after a successful tick.
-     * Called at the end of a successful tick().
-     */
-    _resetCircuitBreaker() {
-        if (this.consecutiveFailures === 0)
-            return;
-        const wasInBackoff = this.inBackoff;
-        this.consecutiveFailures = 0;
-        this.inBackoff = false;
-        if (wasInBackoff) {
-            // Restore normal interval.
-            if (this.intervalHandle)
-                clearInterval(this.intervalHandle);
-            this.intervalHandle = setInterval(() => {
-                this.tick().catch(err => {
-                    this._handleTickError(err, 'periodic');
-                });
-            }, this.config.periodicInterval);
-            console.log('[indexer] Circuit breaker reset — tick succeeded, restored normal interval.');
-        }
-    }
-    /**
-     * Stop periodic indexing.
-     */
-    stop() {
-        if (this.intervalHandle) {
-            clearInterval(this.intervalHandle);
-            this.intervalHandle = null;
-        }
-    }
-    /**
-     * Run one indexing pass across all agents.
-     */
-    async tick() {
-        if (this.running) {
-            console.log('[indexer] Skipping tick — previous run still active');
-            return [];
-        }
-        this.running = true;
-        const results = [];
-        let tickSucceeded = false;
-        try {
-            if (!this.listAgents || !this.getMessageDb || !this.getLibraryDb) {
-                console.warn('[indexer] Missing database accessors — skipping');
-                return [];
-            }
-            const agents = this.listAgents();
-            const libraryDb = this.getLibraryDb();
-            let tickTotal = 0;
-            for (const agentId of agents) {
-                if (tickTotal >= this.config.maxMessagesPerTick) {
-                    console.log(`[indexer] maxMessagesPerTick (${this.config.maxMessagesPerTick}) reached — deferring remaining agents`);
-                    break;
-                }
-                try {
-                    const stats = await this.processAgent(agentId, libraryDb);
-                    tickTotal += stats.messagesProcessed;
-                    if (stats.messagesProcessed > 0 || stats.tombstoned > 0) {
-                        results.push(stats);
-                    }
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`[indexer] Failed to process ${agentId}: ${msg}`);
-                }
-            }
-            if (results.length > 0) {
-                const totalMessages = results.reduce((s, r) => s + r.messagesProcessed, 0);
-                const totalFacts = results.reduce((s, r) => s + r.factsExtracted, 0);
-                const totalEpisodes = results.reduce((s, r) => s + r.episodesRecorded, 0);
-                const totalTombstoned = results.reduce((s, r) => s + r.tombstoned, 0);
-                const tombstonedPart = totalTombstoned > 0 ? `, ${totalTombstoned} tombstoned` : '';
-                console.log(`[indexer] Tick complete: ${totalMessages} messages → ${totalFacts} facts, ${totalEpisodes} episodes${tombstonedPart}`);
-            }
-            // Run decay on every tick
-            this.applyDecay(libraryDb);
-            // Topic synthesis — run for each agent after main indexer tick
-            if (this.synthesizer) {
-                for (const agentId of agents) {
-                    try {
-                        const synthResult = this.synthesizer.tick(agentId);
-                        if (synthResult.topicsSynthesized > 0) {
-                            console.log(`[indexer] Synthesized ${synthResult.topicsSynthesized} topics for ${agentId}, ${synthResult.knowledgeEntriesWritten} knowledge entries`);
-                        }
-                    }
-                    catch {
-                        // Non-fatal
-                    }
-                }
-            }
-            // Knowledge lint — every LINT_FREQUENCY ticks
-            this.tickCount++;
-            if (this.tickCount % 10 === 0 && this.getLibraryDb) {
-                try {
-                    const libDb = this.getLibraryDb();
-                    if (libDb) {
-                        const lint = lintKnowledge(libDb);
-                        if (lint.staleDecayed > 0 || lint.coverageGaps.length > 0) {
-                            console.log(`[indexer] Lint: ${lint.staleDecayed} stale decayed, ${lint.orphansFound} orphans, ${lint.coverageGaps.length} coverage gaps`);
-                        }
-                    }
-                }
-                catch {
-                    // Non-fatal
-                }
-            }
-            // Dreaming promotion pass — every tickInterval ticks (default 12 = ~1hr)
-            const dreamerEnabled = this.dreamerConfig.enabled ?? false;
-            const dreamerTickInterval = this.dreamerConfig.tickInterval ?? 12;
-            if (dreamerEnabled && this.tickCount % dreamerTickInterval === 0 && this.getLibraryDb) {
-                try {
-                    const libDb = this.getLibraryDb();
-                    if (libDb) {
-                        const dreamResults = await runDreamingPassForFleet(agents, libDb, this.dreamerConfig);
-                        const totalPromoted = dreamResults.reduce((s, r) => s + r.promoted, 0);
-                        if (totalPromoted > 0) {
-                            console.log(`[indexer] Dreaming: promoted ${totalPromoted} facts across ${dreamResults.length} agents`);
-                        }
-                    }
-                }
-                catch (err) {
-                    // Non-fatal — dreaming failures never block indexing
-                    console.warn('[indexer] Dreaming pass failed (non-fatal):', err.message);
-                }
-            }
-            // Run proactive passes on each agent's message DB
-            const maintStart = Date.now();
-            let maintConsidered = 0;
-            let maintSkipped = 0;
-            let maintScanned = 0;
-            let maintMutated = 0;
-            let maintExitReason = 'complete';
-            const maxConvs = this.config.maxActiveConversations ?? 5;
-            const cooldownMs = this.config.recentConversationCooldownMs ?? 30000;
-            const maxCandidates = this.config.maxCandidatesPerPass ?? 200;
-            const now = Date.now();
-            for (const agentId of agents) {
-                const messageDb = this.getMessageDb(agentId);
-                if (!messageDb)
-                    continue;
-                let convRows;
-                try {
-                    convRows = messageDb.prepare(`SELECT id FROM conversations WHERE agent_id = ? AND status = 'active' ORDER BY updated_at DESC LIMIT ?`).all(agentId, maxConvs);
-                }
-                catch {
-                    continue;
-                }
-                if (convRows.length === 0) {
-                    if (maintExitReason === 'complete')
-                        maintExitReason = 'no-conversations';
-                    continue;
-                }
-                for (const conv of convRows) {
-                    maintConsidered++;
-                    const lastProcessed = this._conversationLastProcessed.get(conv.id) ?? 0;
-                    if (now - lastProcessed < cooldownMs) {
-                        maintSkipped++;
-                        continue;
-                    }
-                    maintScanned++;
-                    // Any successful scan means we're in a real working state —
-                    // clear any stale 'no-conversations' marker from an earlier agent.
-                    if (maintExitReason === 'no-conversations')
-                        maintExitReason = 'complete';
-                    const noiseSweepResult = runNoiseSweep(messageDb, conv.id, 20, maxCandidates);
-                    const toolDecayResult = runToolDecay(messageDb, conv.id, 40, maxCandidates);
-                    const changed = noiseSweepResult.messagesDeleted + toolDecayResult.messagesUpdated;
-                    if (changed > 0) {
-                        maintMutated += changed;
-                        console.log(`[indexer] Proactive pass (conv ${conv.id}): swept ${noiseSweepResult.messagesDeleted} noise msgs, ` +
-                            `decayed ${toolDecayResult.messagesUpdated} tool results (${toolDecayResult.bytesFreed} bytes freed)`);
-                    }
-                    this._conversationLastProcessed.set(conv.id, now);
-                    if (maintMutated >= maxCandidates) {
-                        maintExitReason = 'cap-reached';
-                        break;
-                    }
-                }
-                if (maintExitReason === 'cap-reached')
-                    break;
-            }
-            this.lastMaintenanceDiagnostics = {
-                considered: maintConsidered,
-                skipped: maintSkipped,
-                scanned: maintScanned,
-                mutated: maintMutated,
-                durationMs: Date.now() - maintStart,
-                exitReason: maintExitReason,
-            };
-            if (maintScanned > 0) {
-                console.log(`[indexer] Maintenance: considered=${maintConsidered} skipped=${maintSkipped} scanned=${maintScanned} mutated=${maintMutated} ` +
-                    `duration=${this.lastMaintenanceDiagnostics.durationMs}ms exit=${maintExitReason}`);
-            }
-            // If we reach here, the tick completed without throwing.
-            tickSucceeded = true;
-        }
-        finally {
-            if (tickSucceeded)
-                this._resetCircuitBreaker();
-            this.running = false;
-        }
-        return results;
-    }
-    /**
-     * Process a single agent's unindexed messages.
-     *
-     * When a cursor fetcher is available, messages are split into two tiers:
-     *   - Post-cursor (id > cursor.lastSentId): "unseen" by the model, high-signal priority
-     *   - Pre-cursor (id <= cursor.lastSentId): already in the model's context window, lower priority
-     * Post-cursor messages are processed first. This ensures the indexer prioritizes
-     * content the model hasn't seen yet — decisions, incidents, and discoveries that
-     * happened between context windows.
-     */
-    async processAgent(agentId, libraryDb) {
-        const start = Date.now();
-        const messageDb = this.getMessageDb(agentId);
-        const messageStore = new MessageStore(messageDb);
-        const factStore = new FactStore(libraryDb);
-        const episodeStore = new EpisodeStore(libraryDb);
-        const topicStore = new TopicStore(libraryDb);
-        const knowledgeStore = new KnowledgeStore(libraryDb);
-        const temporalStore = new TemporalStore(libraryDb);
-        // Get watermark — last processed message ID for this agent
-        const watermark = this.getWatermark(libraryDb, agentId);
-        const lastProcessedId = watermark?.lastMessageId ?? 0;
-        // Fetch unindexed messages (batch size from config)
-        const messages = this.getUnindexedMessages(messageDb, agentId, lastProcessedId, this.config.batchSize);
-        if (messages.length === 0) {
-            // Even with no new messages, run tombstone cleanup in case supersedes
-            // were written externally (e.g. via FactStore.markSuperseded()).
-            let tombstoned = 0;
-            if (this.vectorStore) {
-                tombstoned = this.vectorStore.tombstoneSuperseded();
-            }
-            return {
-                agentId,
-                messagesProcessed: 0,
-                factsExtracted: 0,
-                episodesRecorded: 0,
-                topicsUpdated: 0,
-                knowledgeUpserted: 0,
-                tombstoned,
-                postCursorMessages: 0,
-                contradictionAuditsLogged: 0,
-                contradictionsAutoSuperseded: 0,
-                contradictionsAutoInvalidated: 0,
-                elapsedMs: Date.now() - start,
-            };
-        }
-        // ── Cursor-aware prioritization ──────────────────────────────
-        // Fetch the cursor boundary to split messages into post-cursor (unseen)
-        // and pre-cursor (already in context). Post-cursor messages are processed
-        // first — they're the highest signal for fact/episode extraction.
-        let cursorBoundary = 0;
-        if (this.getCursor) {
-            try {
-                // Get session key from the first message's conversation
-                const sessionKey = this.getSessionKeyForMessage(messageDb, messages[0].conversationId);
-                if (sessionKey) {
-                    const cursor = await this.getCursor(agentId, sessionKey);
-                    if (cursor) {
-                        cursorBoundary = cursor.lastSentId;
-                    }
-                }
-            }
-            catch {
-                // Cursor fetch is best-effort — fall through to default ordering
-            }
-        }
-        // Sort: post-cursor messages first (highest signal), then pre-cursor.
-        // Within each tier, maintain original (ascending) order.
-        const postCursor = messages.filter(m => m.id > cursorBoundary);
-        const preCursor = messages.filter(m => m.id <= cursorBoundary);
-        const ordered = [...postCursor, ...preCursor];
-        let factsExtracted = 0;
-        let episodesRecorded = 0;
-        let topicsUpdated = 0;
-        let knowledgeUpserted = 0;
-        let supersededFacts = 0;
-        let contradictionAuditsLogged = 0;
-        let contradictionsAutoSuperseded = 0;
-        let contradictionsAutoInvalidated = 0;
-        let maxMessageId = lastProcessedId;
-        const contradictionDetector = new ContradictionDetector(factStore, this.vectorStore ?? undefined, {
-            autoResolve: false,
-            maxCandidates: 6,
-            minSimilarity: 0.45,
-        });
-        const contradictionAuditStore = new ContradictionAuditStore(libraryDb);
-        for (const msg of ordered) {
-            const content = msg.textContent || '';
-            if (msg.id > maxMessageId)
-                maxMessageId = msg.id;
-            // Skip heartbeats and very short messages
-            if (msg.isHeartbeat || content.length < 30)
-                continue;
-            // 1. Extract facts (TUNE-003: confidence varies by extraction pattern type)
-            const factCandidates = extractFactCandidates(content);
-            for (const { content: factContent, confidence: factConfidence } of factCandidates) {
-                try {
-                    const factDomain = domainForAgent(agentId);
-                    // 1. Detect contradictions BEFORE addFact (operates on existing facts only)
-                    const contradictionResult = await contradictionDetector.detectOnIngest(agentId, {
-                        content: factContent,
-                        domain: factDomain,
-                    });
-                    const topContradictions = contradictionResult.contradictions.slice(0, 3);
-                    // 2. addFact first — we need fact.id for supersede linkage
-                    const fact = factStore.addFact(agentId, factContent, {
-                        scope: 'agent',
-                        domain: factDomain,
-                        confidence: factConfidence,
-                        sourceType: 'indexer',
-                        sourceSessionKey: this.getSessionKeyForMessage(messageDb, msg.conversationId),
-                        sourceRef: `msg:${msg.id}`,
-                    });
-                    factsExtracted++;
-                    // 3. Apply contradiction policy for each candidate (now we have fact.id)
-                    for (const candidate of topContradictions) {
-                        const score = candidate.contradictionScore;
-                        let auditStatus = 'pending';
-                        if (score >= this.contradictionPolicy.autoSupersedeThreshold) {
-                            const didSupersede = factStore.markSuperseded(candidate.existingFactId, fact.id);
-                            if (didSupersede) {
-                                contradictionsAutoSuperseded++;
-                                // Immediately remove stale vector so it cannot surface in KNN recall
-                                if (this.vectorStore) {
-                                    this.vectorStore.removeItem('facts', candidate.existingFactId);
-                                }
-                            }
-                            auditStatus = 'auto-superseded';
-                        }
-                        else if (score >= this.contradictionPolicy.autoInvalidateThreshold) {
-                            const didInvalidate = factStore.invalidateFact(candidate.existingFactId);
-                            if (didInvalidate) {
-                                contradictionsAutoInvalidated++;
-                            }
-                            auditStatus = 'auto-invalidated';
-                        }
-                        if (this.contradictionPolicy.alwaysAudit || auditStatus === 'pending') {
-                            contradictionAuditStore.recordFactAudit(agentId, { content: factContent, domain: factDomain }, candidate, { sourceRef: `msg:${msg.id}`, status: auditStatus });
-                            contradictionAuditsLogged++;
-                        }
-                    }
-                    // ── Supersedes detection ─────────────────────────────────
-                    // Check if the newly extracted fact supersedes an existing one.
-                    // A supersede is detected when an existing active fact shares the
-                    // same 60-char prefix (same topic, different phrasing/update).
-                    if (fact.id) {
-                        // Index into temporal store (ingest_at as proxy, confidence=0.5)
-                        temporalStore.indexFact(fact.id, agentId, fact.createdAt);
-                        const oldFactId = factStore.findSupersedableByContent(agentId, factContent);
-                        if (oldFactId !== null && oldFactId !== fact.id) {
-                            const didSupersede = factStore.markSuperseded(oldFactId, fact.id);
-                            if (didSupersede) {
-                                supersededFacts++;
-                                // Immediately remove the stale vector so it can't surface in KNN recall
-                                if (this.vectorStore) {
-                                    this.vectorStore.removeItem('facts', oldFactId);
-                                }
-                            }
-                        }
-                    }
-                    // Embed new fact for semantic recall (best-effort, non-blocking)
-                    if (this.vectorStore && fact.id) {
-                        this.vectorStore.indexItem('facts', fact.id, factContent, fact.domain || undefined)
-                            .catch(() => { });
-                    }
-                }
-                catch {
-                    // Duplicate or constraint violation — skip
-                }
-            }
-            // 2. Classify episodes
-            const episode = classifyEpisode(msg);
-            if (episode && episode.significance >= this.config.episodeSignificanceThreshold) {
-                // Secret gate: shared visibility requires clean content.
-                // Downgrade to 'private' rather than drop, so we don't lose the episode.
-                const episodeVisibility = isSafeForSharedVisibility(episode.summary) ? 'org' : 'private';
-                try {
-                    const recorded = episodeStore.record(agentId, episode.type, episode.summary, {
-                        significance: episode.significance,
-                        visibility: episodeVisibility,
-                        sessionKey: this.getSessionKeyForMessage(messageDb, msg.conversationId),
-                        sourceMessageId: msg.id,
-                    });
-                    episodesRecorded++;
-                    // Embed episodes at sig>=0.5 (lowered from 0.7 — discovery/config_change events
-                    // at sig=0.5 are real operational events, not noise).
-                    if (this.vectorStore && recorded?.id && episode.significance >= 0.5) {
-                        this.vectorStore.indexItem('episodes', recorded.id, episode.summary, episode.type)
-                            .catch(() => { });
-                    }
-                }
-                catch {
-                    // Skip duplicate episodes
-                }
-            }
-            // 3. Detect and update topics
-            const topicName = detectTopic(content);
-            if (topicName && topicName.trim().length >= 3) {
-                try {
-                    const msgSessionKey = this.getSessionKeyForMessage(messageDb, msg.conversationId) || '';
-                    // findOrCreate handles case-insensitive dedup at the schema level;
-                    // always touch afterward so message_count reflects real activity
-                    // rather than sitting at 0 forever (which made every topic an orphan).
-                    const topic = topicStore.findOrCreate(agentId, topicName, `Auto-detected from conversation`);
-                    topicStore.touch(topic.id, msgSessionKey, 1);
-                    topicsUpdated++;
-                }
-                catch {
-                    // Skip topic creation/touch errors
-                }
-            }
-            // 4. Extract knowledge candidates
-            const knowledgeCandidates = extractKnowledgeCandidates(content, agentId);
-            for (const { domain, key, value } of knowledgeCandidates) {
-                try {
-                    knowledgeStore.upsert(agentId, domain, key, value, {
-                        sourceType: 'indexer',
-                        sourceRef: `msg:${msg.id}`,
-                    });
-                    knowledgeUpserted++;
-                }
-                catch {
-                    // Skip duplicates
-                }
-            }
-        }
-        // Update watermark
-        this.setWatermark(libraryDb, agentId, maxMessageId);
-        // Run tombstone pass: remove vector entries for any facts marked superseded
-        // (covers both the supersedes detected above and external markSuperseded calls).
-        let tombstoned = 0;
-        if (this.vectorStore) {
-            tombstoned = this.vectorStore.tombstoneSuperseded();
-        }
-        return {
-            agentId,
-            messagesProcessed: messages.length,
-            factsExtracted,
-            episodesRecorded,
-            topicsUpdated,
-            knowledgeUpserted,
-            tombstoned,
-            contradictionAuditsLogged,
-            contradictionsAutoSuperseded,
-            contradictionsAutoInvalidated,
-            postCursorMessages: postCursor.length,
-            elapsedMs: Date.now() - start,
-        };
-    }
-    /**
-     * Fetch unindexed messages for an agent.
-     */
-    getUnindexedMessages(db, agentId, afterId, limit) {
-        const rows = db.prepare(`
-      SELECT m.*, c.session_key
-      FROM messages m
-      JOIN conversations c ON m.conversation_id = c.id
-      WHERE m.agent_id = ? AND m.id > ?
-      ORDER BY m.id ASC
-      LIMIT ?
-    `).all(agentId, afterId, limit);
-        return rows.map(row => ({
-            id: row.id,
-            conversationId: row.conversation_id,
-            agentId: row.agent_id,
-            role: row.role,
-            textContent: row.text_content || null,
-            toolCalls: row.tool_calls ? JSON.parse(row.tool_calls) : null,
-            toolResults: row.tool_results ? JSON.parse(row.tool_results) : null,
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-            messageIndex: row.message_index,
-            tokenCount: row.token_count || null,
-            isHeartbeat: row.is_heartbeat === 1,
-            createdAt: row.created_at,
-        }));
-    }
-    /**
-     * Get the session key for a conversation ID.
-     */
-    getSessionKeyForMessage(db, conversationId) {
-        const row = db.prepare('SELECT session_key FROM conversations WHERE id = ?').get(conversationId);
-        return row?.session_key;
-    }
-    /**
-     * Get the indexing watermark for an agent.
-     */
-    getWatermark(libraryDb, agentId) {
-        // Ensure watermarks table exists
-        libraryDb.prepare(`
-      CREATE TABLE IF NOT EXISTS indexer_watermarks (
-        agent_id TEXT PRIMARY KEY,
-        last_message_id INTEGER NOT NULL DEFAULT 0,
-        last_run_at TEXT NOT NULL
-      )
-    `).run();
-        const row = libraryDb.prepare('SELECT agent_id, last_message_id, last_run_at FROM indexer_watermarks WHERE agent_id = ?').get(agentId);
-        if (!row)
-            return null;
-        return {
-            agentId: row.agent_id,
-            lastMessageId: row.last_message_id,
-            lastRunAt: row.last_run_at,
-        };
-    }
-    /**
-     * Set the indexing watermark for an agent.
-     */
-    setWatermark(libraryDb, agentId, lastMessageId) {
-        const now = new Date().toISOString();
-        libraryDb.prepare(`
-      INSERT INTO indexer_watermarks (agent_id, last_message_id, last_run_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(agent_id) DO UPDATE SET
-        last_message_id = excluded.last_message_id,
-        last_run_at = excluded.last_run_at
-    `).run(agentId, lastMessageId, now);
-    }
-    /**
-     * Apply time-based decay to facts.
-     * Increases decay_score for older facts, making them less relevant.
-     */
-    applyDecay(libraryDb) {
-        const rate = this.config.factDecayRate;
-        // Decay facts that haven't been referenced recently
-        libraryDb.prepare(`
-      UPDATE facts
-      SET decay_score = MIN(1.0, decay_score + ?)
-      WHERE superseded_by IS NULL
-        AND decay_score < 1.0
-        AND updated_at < datetime('now', '-1 day')
-    `).run(rate);
-        // Decay episodes older than 7 days
-        libraryDb.prepare(`
-      UPDATE episodes
-      SET decay_score = MIN(1.0, decay_score + ?)
-      WHERE decay_score < 1.0
-        AND created_at < datetime('now', '-7 days')
-    `).run(rate * 0.5);
-        // Mark dormant topics
-        const dormantThreshold = this.parseDuration(this.config.topicDormantAfter);
-        if (dormantThreshold > 0) {
-            // Compute threshold timestamp in JS and pass as parameter — avoids SQL template interpolation.
-            const dormantBefore = new Date(Date.now() - dormantThreshold * 1000).toISOString();
-            libraryDb.prepare(`
-        UPDATE topics
-        SET status = 'dormant'
-        WHERE status = 'active'
-          AND updated_at < ?
-      `).run(dormantBefore);
-        }
-        // Close old dormant topics
-        const closedThreshold = this.parseDuration(this.config.topicClosedAfter);
-        if (closedThreshold > 0) {
-            const closedBefore = new Date(Date.now() - closedThreshold * 1000).toISOString();
-            libraryDb.prepare(`
-        UPDATE topics
-        SET status = 'closed'
-        WHERE status = 'dormant'
-          AND updated_at < ?
-      `).run(closedBefore);
-        }
-    }
-    /**
-     * Parse a duration string like "24h", "7d" into seconds.
-     */
-    parseDuration(dur) {
-        const match = dur.match(/^(\d+)\s*(h|d|m|s)$/);
-        if (!match)
-            return 0;
-        const val = parseInt(match[1]);
-        switch (match[2]) {
-            case 's': return val;
-            case 'm': return val * 60;
-            case 'h': return val * 3600;
-            case 'd': return val * 86400;
-            default: return 0;
-        }
-    }
-    /**
-     * One-time backfill: embed episodes with sig>=0.5 that were missed by the
-     * old >=0.7 vectorization threshold.
-     *
-     * Gated by a system_state flag 'indexer:episode_backfill_v1' so it runs
-     * exactly once even across gateway restarts. Safe to re-run manually
-     * (delete the flag row first) if re-backfill is ever needed.
-     */
-    async backfillEpisodeVectors() {
-        if (!this.vectorStore || !this.getLibraryDb)
-            return;
-        const libraryDb = this.getLibraryDb();
-        const BACKFILL_FLAG = 'episode_backfill_v1';
-        // Ensure system_state table exists (schema may not have been applied yet)
-        try {
-            libraryDb.prepare(`
-        CREATE TABLE IF NOT EXISTS system_state (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          category TEXT NOT NULL,
-          key TEXT NOT NULL,
-          value TEXT,
-          updated_at TEXT NOT NULL,
-          updated_by TEXT,
-          ttl TEXT,
-          UNIQUE(category, key)
-        )
-      `).run();
-        }
-        catch {
-            // Table already exists — safe to ignore
-        }
-        // Check if backfill already completed
-        const existing = libraryDb.prepare("SELECT value FROM system_state WHERE category = 'indexer' AND key = ?").get(BACKFILL_FLAG);
-        if (existing) {
-            // Already done
-            return;
-        }
-        console.log('[indexer] Starting episode vector backfill (sig>=0.5, not yet vectorized)...');
-        // Find episodes with sig>=0.5 that have no vec_index_map entry.
-        // We join against vec_index_map using a fallback: if the table is in a
-        // separate DB (vectors.db), we query it directly via the VectorStore.
-        let episodes;
-        try {
-            episodes = libraryDb.prepare(`
-        SELECT id, summary, event_type
-        FROM episodes
-        WHERE significance >= 0.5
-        ORDER BY created_at DESC
-      `).all();
-        }
-        catch {
-            console.warn('[indexer] Backfill: could not query episodes table');
-            return;
-        }
-        let queued = 0;
-        let skipped = 0;
-        for (const ep of episodes) {
-            // Check if already vectorized
-            if (this.vectorStore.hasItem('episodes', ep.id)) {
-                skipped++;
-                continue;
-            }
-            try {
-                await this.vectorStore.indexItem('episodes', ep.id, ep.summary, ep.event_type);
-                queued++;
-            }
-            catch {
-                // Non-fatal — keep going
-            }
-        }
-        // Mark backfill complete
-        const now = new Date().toISOString();
-        libraryDb.prepare(`
-      INSERT INTO system_state (category, key, value, updated_at, updated_by)
-      VALUES ('indexer', ?, ?, ?, 'indexer')
-      ON CONFLICT(category, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
-    `).run(BACKFILL_FLAG, JSON.stringify({ completedAt: now, queued, skipped }), now);
-        console.log(`[indexer] Episode backfill complete: ${queued} queued, ${skipped} already vectorized`);
-    }
-    /**
-     * Get current watermarks for all agents.
-     */
-    getWatermarks(libraryDb) {
-        try {
-            const rows = libraryDb.prepare('SELECT agent_id, last_message_id, last_run_at FROM indexer_watermarks ORDER BY agent_id').all();
-            return rows.map(r => ({
-                agentId: r.agent_id,
-                lastMessageId: r.last_message_id,
-                lastRunAt: r.last_run_at,
-            }));
-        }
-        catch {
-            return [];
-        }
-    }
-}
-// ─── Standalone runner ──────────────────────────────────────────
-/**
- * Create and start a background indexer connected to hypermem databases.
- * Used by the hook or a standalone daemon.
- */
-export function createIndexer(getMessageDb, getLibraryDb, listAgents, config, getCursor, vectorStore, dreamerConfig, globalWritePolicy) {
-    const indexer = new BackgroundIndexer(config, getMessageDb, getLibraryDb, listAgents, getCursor, dreamerConfig, globalWritePolicy);
-    if (vectorStore)
-        indexer.setVectorStore(vectorStore);
-    return indexer;
-}
-//# sourceMappingURL=background-indexer.js.map