@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/exploration-cost.js

@@ -1,204 +0,0 @@
-/**
- * Exploration Cost Estimator — counterfactual token cost analysis.
- *
- * Estimates what an AI agent WOULD have spent in tokens to gather the same
- * information without the graph intelligence layer. This quantifies the
- * value of graph-backed tools vs naive file exploration.
- *
- * Counterfactual baselines (tokens the agent would consume without graph):
- *   - blast_radius: 500 tokens/file × caller count (read each caller file)
- *   - find_callers: grep output (~200 tokens) + read each file (~500 tokens)
- *   - show_community: ls (~50 tokens) + read 15 files (~500 tokens each)
- *   - search_entities: grep output (~200 tokens) + read 10 files (~500 tokens)
- *   - get_entity: read file (~500 tokens) + parse mentally (~100 tokens)
- *   - health_grade: read 20 files + compute manually
- *
- * All estimates are conservative (lower bound of actual cost).
- */
-import { createModuleLogger } from "../utils/logger.js";
-const log = createModuleLogger("exploration-cost");
-const COUNTERFACTUAL_RULES = {
-    blast_radius: {
-        tokensPerFile: 500,
-        baseTokens: 100,
-        fileMultiplier: (resultSize) => Math.max(resultSize, 1),
-        method: "read each caller file + parse for references",
-        explain: (resultSize) => `Without graph: grep for symbol → read ${resultSize} caller files (~500 tok each) + parse references`,
-    },
-    find_callers: {
-        tokensPerFile: 500,
-        baseTokens: 200,
-        fileMultiplier: (resultSize) => Math.max(resultSize, 1),
-        method: "grep + read each matching file",
-        explain: (resultSize) => `Without graph: grep across codebase (~200 tok) → read ${resultSize} matching files (~500 tok each)`,
-    },
-    show_community: {
-        tokensPerFile: 500,
-        baseTokens: 50,
-        fileMultiplier: (_resultSize, entityCount) => Math.max(entityCount ?? 15, 5),
-        method: "ls directory + read community files",
-        explain: (_resultSize, entityCount) => `Without graph: ls directory (~50 tok) → read ${entityCount ?? 15} related files (~500 tok each)`,
-    },
-    search_entities: {
-        tokensPerFile: 500,
-        baseTokens: 200,
-        fileMultiplier: (resultSize) => Math.min(Math.max(resultSize, 1), 20),
-        method: "grep + read matching files",
-        explain: (resultSize) => `Without graph: grep codebase (~200 tok) → read ${Math.min(resultSize, 20)} result files (~500 tok each)`,
-    },
-    get_entity: {
-        tokensPerFile: 500,
-        baseTokens: 100,
-        fileMultiplier: () => 1,
-        method: "find file + read + parse",
-        explain: () => "Without graph: find file location (~100 tok) → read entire file (~500 tok)",
-    },
-    health_grade: {
-        tokensPerFile: 400,
-        baseTokens: 300,
-        fileMultiplier: (_resultSize, entityCount) => Math.max(entityCount ?? 20, 5),
-        method: "read multiple files + manual analysis",
-        explain: (_resultSize, entityCount) => `Without graph: read ${entityCount ?? 20} files (~400 tok each) + manual complexity analysis (~300 tok)`,
-    },
-    show_conventions: {
-        tokensPerFile: 300,
-        baseTokens: 500,
-        fileMultiplier: (_resultSize, entityCount) => Math.max(entityCount ?? 10, 3),
-        method: "read sample files + infer patterns",
-        explain: (_resultSize, entityCount) => `Without graph: read ${entityCount ?? 10} sample files (~300 tok each) + infer conventions (~500 tok)`,
-    },
-    risk_assessment: {
-        tokensPerFile: 500,
-        baseTokens: 200,
-        fileMultiplier: (resultSize) => Math.max(resultSize, 3),
-        method: "read callers + analyze dependencies manually",
-        explain: (resultSize) => `Without graph: read ${Math.max(resultSize, 3)} dependency files (~500 tok each) + manual risk analysis`,
-    },
-};
-const DEFAULT_RULE = {
-    tokensPerFile: 400,
-    baseTokens: 150,
-    fileMultiplier: (resultSize) => Math.max(Math.ceil(resultSize / 2), 1),
-    method: "generic file exploration",
-    explain: (resultSize) => `Without graph: explore ~${Math.max(Math.ceil(resultSize / 2), 1)} files (~400 tok each)`,
-};
-/**
- * Maps actual MCP tool names to the underlying counterfactual rule key.
- * Without this layer, every modern tool name (`get_references`, `search_code`,
- * etc.) falls through to DEFAULT_RULE and the specialized cost models above
- * become dead code.
- */
-const TOOL_ALIAS = {
-    // Reference tools — same profile as find_callers (grep + read each match)
-    get_references: "find_callers",
-    get_callers: "find_callers",
-    get_callees: "find_callers",
-    get_imports: "find_callers",
-    get_test_coverage: "find_callers",
-    // Search — same profile as search_entities (grep across project + read top hits)
-    search_code: "search_entities",
-    // Single-entity reads — same profile as get_entity (find file + read it)
-    get_function: "get_entity",
-    get_class: "get_entity",
-    get_file: "get_entity",
-    // file_outline/file_read NOT aliased: get_entity assumes ONE returned entity,
-    // but file_outline returns N entities and file_read returns a body of content.
-    // Inheriting get_entity's cost curve produces negative savings (saved=-650 for
-    // a typical 15-entity outline) which suppresses the token-flow event.
-    // Letting them fall through to DEFAULT_RULE applies fileMultiplier=ceil(resultSize/2)
-    // which yields positive savings.
-    // Conventions
-    get_conventions: "show_conventions",
-    // Risk / structural — read deps + analyze manually
-    get_critical_nodes: "risk_assessment",
-    get_cross_boundary_links: "risk_assessment",
-    file_connections: "risk_assessment",
-    // Project-wide stats — counterfactual is reading many files to compute
-    get_project_stats: "health_grade",
-};
-function resolveQueryType(queryType) {
-    return TOOL_ALIAS[queryType] ?? queryType;
-}
-/**
- * Estimates the counterfactual token cost for a single query.
- *
- * @param queryType - the tool/query name (e.g. "blast_radius", "find_callers",
- *   or an actual MCP tool name like "get_references" — aliases are resolved
- *   to the matching rule)
- * @param resultSize - number of results returned (entities, callers, files, etc.)
- * @param entityCount - optional total entities involved (for community/health queries)
- */
-export function estimateExplorationCost(queryType, resultSize, entityCount) {
-    const ruleKey = resolveQueryType(queryType);
-    const rule = COUNTERFACTUAL_RULES[ruleKey] ?? DEFAULT_RULE;
-    const fileCount = rule.fileMultiplier(resultSize, entityCount);
-    const tokensWithout = rule.baseTokens + fileCount * rule.tokensPerFile;
-    const tokensUsed = estimateGraphQueryTokens(ruleKey, resultSize);
-    return {
-        queryType,
-        tokensUsed,
-        tokensWithout,
-        counterfactualMethod: rule.method,
-        explanation: rule.explain(resultSize, entityCount),
-    };
-}
-/**
- * Creates a session-scoped accumulator that tracks cumulative exploration savings.
- */
-export function createExplorationAccumulator() {
-    const history = [];
-    function record(estimate) {
-        history.push(estimate);
-    }
-    function getTotal() {
-        let totalUsed = 0;
-        let totalWithout = 0;
-        for (const est of history) {
-            totalUsed += est.tokensUsed;
-            totalWithout += est.tokensWithout;
-        }
-        const saved = totalWithout - totalUsed;
-        const ratio = totalWithout > 0 ? totalUsed / totalWithout : 1;
-        return {
-            saved,
-            without: totalWithout,
-            ratio: Math.round(ratio * 1000) / 1000,
-        };
-    }
-    function getHistory() {
-        return [...history];
-    }
-    function getBreakdown() {
-        const breakdown = new Map();
-        for (const est of history) {
-            const existing = breakdown.get(est.queryType) ?? {
-                saved: 0,
-                count: 0,
-            };
-            existing.saved += est.tokensWithout - est.tokensUsed;
-            existing.count += 1;
-            breakdown.set(est.queryType, existing);
-        }
-        return breakdown;
-    }
-    return { record, getTotal, getHistory, getBreakdown };
-}
-/**
- * Estimates tokens consumed by the graph-backed query itself.
- * Graph responses are compact structured JSON — much smaller than raw file reads.
- */
-function estimateGraphQueryTokens(queryType, resultSize) {
-    const perResultTokens = {
-        blast_radius: 30,
-        find_callers: 25,
-        show_community: 20,
-        search_entities: 35,
-        get_entity: 80,
-        health_grade: 50,
-        show_conventions: 40,
-        risk_assessment: 45,
-    };
-    const baseTokens = 50;
-    const perResult = perResultTokens[queryType] ?? 30;
-    return baseTokens + resultSize * perResult;
-}

package/dist/intelligence/exploration-pattern-tracker.js

@@ -1,61 +0,0 @@
-/**
- * Session Context Enhancement — tracks exploration patterns and predicts next queries.
- *
- * S.5: Observes which files/entities the agent queries and uses the pattern
- * to predict what it will need next. Enables pre-warming the subgraph cache.
- */
-export function createSessionContext() {
-    const directories = new Map();
-    const entities = new Map();
-    const recentFiles = [];
-    let queryCount = 0;
-    function recordQuery(filePath, entityKey) {
-        queryCount++;
-        recentFiles.push(filePath);
-        if (recentFiles.length > 50)
-            recentFiles.shift();
-        const dir = filePath.split("/").slice(0, -1).join("/");
-        if (dir)
-            directories.set(dir, (directories.get(dir) ?? 0) + 1);
-        if (entityKey)
-            entities.set(entityKey, (entities.get(entityKey) ?? 0) + 1);
-    }
-    function getPattern() {
-        return { directories, entities, recentFiles: [...recentFiles], queryCount };
-    }
-    function predictNextFiles(limit = 5) {
-        const activeDir = getActiveDirectory();
-        if (!activeDir)
-            return [];
-        const dirFiles = recentFiles.filter((f) => f.startsWith(activeDir));
-        const unique = [...new Set(dirFiles)];
-        return unique.slice(-limit);
-    }
-    function getActiveDirectory() {
-        if (directories.size === 0)
-            return null;
-        const recent = recentFiles.slice(-5);
-        const recentDirs = new Map();
-        for (const f of recent) {
-            const dir = f.split("/").slice(0, -1).join("/");
-            if (dir)
-                recentDirs.set(dir, (recentDirs.get(dir) ?? 0) + 1);
-        }
-        if (recentDirs.size === 0)
-            return null;
-        return [...recentDirs.entries()].sort((a, b) => b[1] - a[1])[0][0];
-    }
-    function reset() {
-        directories.clear();
-        entities.clear();
-        recentFiles.length = 0;
-        queryCount = 0;
-    }
-    return {
-        recordQuery,
-        getPattern,
-        predictNextFiles,
-        getActiveDirectory,
-        reset,
-    };
-}

package/dist/intelligence/fact-generator.js

@@ -1,322 +0,0 @@
-/**
- * Fact Generation Pipeline — automatically generates temporal facts from 4 algorithmic sources.
- *
- * Layer 9 PI-5: Runs in daemon mode when:
- *   1. A session summary arrives in .unerr/sessions/
- *   2. A full reindex completes (convention detection)
- *   3. A revert/rewind is detected (negative knowledge)
- *   4. A 24h survival window closes (causal bridge)
- *
- * All sources are purely algorithmic — zero LLM dependency.
- * Source #1 (Agent Explicit) is handled by the `record_fact` tool in PI-2.
- *
- * Pipeline flow:
- *   Source Event → Candidate Fact → Dedup Check → Existing?
- *     YES → Reinforce (bump count, update timestamp)
- *     NO  → Check contradictions → Create with base_confidence
- */
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-// ── Pipeline Orchestrator ────────────────────────────────────────────
-/**
- * Run the full fact generation pipeline.
- * Called by the daemon periodically or on specific triggers.
- */
-export async function runFactGenerationPipeline(factStore, unerrDir) {
-    const results = [];
-    try {
-        const sessionResult = await generateFromSessionAnalysis(factStore, unerrDir);
-        if (sessionResult)
-            results.push(sessionResult);
-    }
-    catch {
-        // Non-critical — session analysis failure doesn't block other sources
-    }
-    return results;
-}
-// ── Source 2: Convention Detector → Semantic Facts ────────────────────
-/**
- * Generate semantic facts from detected conventions.
- * Trigger: after full reindex completes.
- *
- * Conventions with >70% adherence rate become facts.
- * Already-existing facts get reinforced; new ones created.
- */
-export async function generateFromConventions(factStore, conventions) {
-    let created = 0;
-    let reinforced = 0;
-    const details = [];
-    const MIN_CONFIDENCE = 0.7;
-    const MIN_FREQUENCY = 5;
-    for (const conv of conventions) {
-        if (conv.confidence < MIN_CONFIDENCE)
-            continue;
-        if (conv.frequency < MIN_FREQUENCY)
-            continue;
-        const content = formatConventionFact(conv);
-        if (content.length > 280)
-            continue;
-        const input = {
-            fact_type: "semantic",
-            scope: inferScopeFromConvention(conv),
-            subject: conv.name,
-            content,
-            source: "convention_detector",
-            base_confidence: Math.min(0.9, conv.confidence),
-        };
-        const factId = await factStore.createFact(input);
-        if (factId) {
-            const isNew = !details.some((d) => d.includes(conv.name));
-            if (isNew) {
-                created++;
-                details.push(`[convention] ${conv.name}: ${content.slice(0, 80)}`);
-            }
-            else {
-                reinforced++;
-            }
-        }
-    }
-    return { created, reinforced, source: "convention_detector", details };
-}
-// ── Source 3: Negative Knowledge → Negative Facts ────────────────────
-/**
- * Generate negative facts from revert/rewind events.
- * Trigger: revert detected by causal bridge or ledger analysis.
- *
- * Each correction entry becomes a "don't do X" fact with high confidence.
- */
-export async function generateFromNegativeKnowledge(factStore, corrections) {
-    let created = 0;
-    const reinforced = 0;
-    const details = [];
-    for (const correction of corrections) {
-        const content = correction.reason.slice(0, 280);
-        const input = {
-            fact_type: "negative",
-            scope: correction.entityKey,
-            subject: correction.entityKey,
-            content,
-            source: "negative_knowledge",
-            base_confidence: 0.9,
-        };
-        const factId = await factStore.createFact(input);
-        if (factId) {
-            created++;
-            details.push(`[negative] ${correction.entityKey}: ${content.slice(0, 60)}`);
-        }
-    }
-    return { created, reinforced, source: "negative_knowledge", details };
-}
-// ── Source 4: Causal Bridge → Episodic Facts ─────────────────────────
-/**
- * Generate episodic facts from 24h survival analysis.
- * Trigger: 24h after a session ends, check if changes survived.
- *
- * Survived changes → episodic "survived" fact (confidence 1.0, never decays).
- * Reverted changes → triggers negative knowledge pipeline.
- */
-export async function generateFromCausalBridge(factStore, events) {
-    let created = 0;
-    const reinforced = 0;
-    const details = [];
-    for (const event of events) {
-        if (event.action === "survived") {
-            const content = `Change to ${event.entity_key} on ${new Date(event.timestamp).toISOString().split("T")[0]} survived — shipped to ${event.branch}`;
-            const input = {
-                fact_type: "episodic",
-                scope: event.entity_key,
-                subject: event.entity_key,
-                content: content.slice(0, 280),
-                source: "causal_bridge",
-                base_confidence: 1.0,
-            };
-            const factId = await factStore.createFact(input);
-            if (factId) {
-                created++;
-                details.push(`[episodic:survived] ${event.entity_key}`);
-            }
-        }
-        else if (event.action === "reverted") {
-            const content = `Change to ${event.entity_key} was reverted within 24h — approach was incorrect`;
-            const input = {
-                fact_type: "negative",
-                scope: event.entity_key,
-                subject: event.entity_key,
-                content: content.slice(0, 280),
-                source: "causal_bridge",
-                base_confidence: 0.85,
-            };
-            const factId = await factStore.createFact(input);
-            if (factId) {
-                created++;
-                details.push(`[negative:reverted] ${event.entity_key}`);
-            }
-        }
-    }
-    return { created, reinforced, source: "causal_bridge", details };
-}
-// ── Source 5: Session Analysis → Procedural Facts ────────────────────
-/**
- * Generate procedural facts from session summary aggregation.
- * Trigger: new session summary received.
- *
- * Detects patterns across sessions:
- *   - Hot files (read in >50% of sessions)
- *   - Common tool sequences
- *   - High-revert files (files that frequently get reverted)
- */
-export async function generateFromSessionAnalysis(factStore, unerrDir) {
-    let created = 0;
-    const reinforced = 0;
-    const details = [];
-    const summaries = loadRecentSessions(unerrDir, 20);
-    if (summaries.length < 3) {
-        return {
-            created: 0,
-            reinforced: 0,
-            source: "session_analysis",
-            details: [],
-        };
-    }
-    const hotFiles = detectHotFiles(summaries);
-    for (const [file, frequency] of hotFiles) {
-        const pct = Math.round(frequency * 100);
-        const content = `${file} is accessed in ${pct}% of sessions (hot file)`;
-        const confidence = Math.min(0.85, 0.4 + frequency * 0.5);
-        const input = {
-            fact_type: "procedural",
-            scope: file,
-            subject: "hot-file",
-            content,
-            source: "session_analysis",
-            base_confidence: confidence,
-        };
-        const factId = await factStore.createFact(input);
-        if (factId) {
-            created++;
-            details.push(`[procedural:hot] ${file} (${pct}%)`);
-        }
-    }
-    const highRevertFiles = detectHighRevertFiles(summaries);
-    for (const [file, revertRate] of highRevertFiles) {
-        const pct = Math.round(revertRate * 100);
-        const content = `${file} has a ${pct}% revert rate across sessions — changes here are fragile`;
-        const input = {
-            fact_type: "negative",
-            scope: file,
-            subject: file,
-            content: content.slice(0, 280),
-            source: "session_analysis",
-            base_confidence: Math.min(0.85, 0.5 + revertRate * 0.4),
-        };
-        const factId = await factStore.createFact(input);
-        if (factId) {
-            created++;
-            details.push(`[negative:fragile] ${file} (${pct}% revert rate)`);
-        }
-    }
-    return { created, reinforced, source: "session_analysis", details };
-}
-// ── Internal Helpers ─────────────────────────────────────────────────
-function loadRecentSessions(unerrDir, limit) {
-    const sessionsDir = join(unerrDir, "sessions");
-    if (!existsSync(sessionsDir))
-        return [];
-    try {
-        const files = readdirSync(sessionsDir)
-            .filter((f) => f.endsWith(".jsonl"))
-            .sort()
-            .slice(-limit);
-        const summaries = [];
-        for (const file of files) {
-            try {
-                const content = readFileSync(join(sessionsDir, file), "utf-8");
-                const lines = content.trim().split("\n").filter(Boolean);
-                const lastLine = lines[lines.length - 1];
-                if (lastLine) {
-                    summaries.push(JSON.parse(lastLine));
-                }
-            }
-            catch {
-                // Skip unreadable session files
-            }
-        }
-        return summaries;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Detect hot files — files that appear in >50% of sessions.
- * Returns [file, frequency] pairs sorted by frequency descending.
- */
-function detectHotFiles(summaries) {
-    const fileCounts = new Map();
-    const total = summaries.length;
-    for (const session of summaries) {
-        const seen = new Set();
-        for (const file of session.files_modified) {
-            if (!seen.has(file)) {
-                seen.add(file);
-                fileCounts.set(file, (fileCounts.get(file) ?? 0) + 1);
-            }
-        }
-    }
-    const HOT_THRESHOLD = 0.5;
-    return [...fileCounts.entries()]
-        .map(([file, count]) => [file, count / total])
-        .filter(([_, freq]) => freq >= HOT_THRESHOLD)
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 10);
-}
-/**
- * Detect files with high revert rates across sessions.
- * A file modified in session with revert_count > 0 = potential fragile file.
- */
-function detectHighRevertFiles(summaries) {
-    const fileModifiedCount = new Map();
-    const fileRevertCount = new Map();
-    for (const session of summaries) {
-        for (const file of session.files_modified) {
-            fileModifiedCount.set(file, (fileModifiedCount.get(file) ?? 0) + 1);
-            if (session.revert_count > 0) {
-                fileRevertCount.set(file, (fileRevertCount.get(file) ?? 0) + 1);
-            }
-        }
-    }
-    const HIGH_REVERT_THRESHOLD = 0.4;
-    const MIN_MODIFICATIONS = 3;
-    return [...fileModifiedCount.entries()]
-        .filter(([_, count]) => count >= MIN_MODIFICATIONS)
-        .map(([file, count]) => {
-        const reverts = fileRevertCount.get(file) ?? 0;
-        return [file, reverts / count];
-    })
-        .filter(([_, rate]) => rate >= HIGH_REVERT_THRESHOLD)
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 5);
-}
-function formatConventionFact(conv) {
-    const pct = Math.round(conv.confidence * 100);
-    switch (conv.kind) {
-        case "naming":
-            return `Naming convention: ${conv.name} (${pct}% confidence, ${conv.frequency} entities)`;
-        case "structure":
-            return `Structure pattern: ${conv.name} (${pct}% confidence)`;
-        case "import_direction":
-            return `Import convention: ${conv.name} (${pct}% confidence)`;
-        default:
-            return `Convention: ${conv.name} (${pct}% confidence)`;
-    }
-}
-function inferScopeFromConvention(conv) {
-    if (conv.exemplarKeys.length > 0) {
-        const first = conv.exemplarKeys[0];
-        const parts = first.split("/");
-        if (parts.length >= 2) {
-            return parts.slice(0, 2).join("/");
-        }
-    }
-    return "project";
-}

package/dist/intelligence/facts-schema.js

@@ -1,90 +0,0 @@
-/**
- * CozoDB Schema for facts.db — Temporal Intelligence (Layer 9).
- *
- * SEPARATE from graph.db (cozo-schema.ts). This schema manages:
- *   - facts: Temporal knowledge with decay model (procedural, semantic, negative, episodic)
- *   - entity_interactions: Cross-session entity access history
- *
- * Storage: `.unerr/facts.db` (SQLite-backed CozoDB, parallel to graph.db)
- *
- * Dual-mode access:
- *   - Daemon (unerr): read-write — generates facts, reinforces, prunes
- *   - Headless (--mcp): read-only + single atomic write via record_fact tool
- */
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-const FACTS_DB_FILENAME = "facts.db";
-/**
- * Open or create the facts.db CozoDB instance at `{projectRoot}/.unerr/facts.db`.
- */
-export async function openFactsDb(projectRoot) {
-    const unerrDir = join(projectRoot, ".unerr");
-    mkdirSync(unerrDir, { recursive: true });
-    const dbPath = join(unerrDir, FACTS_DB_FILENAME);
-    const isNew = !existsSync(dbPath);
-    const cozoModule = await import("cozo-node");
-    const CozoDbConstructor = cozoModule.default
-        ? cozoModule.default.CozoDb
-        : cozoModule.CozoDb;
-    const db = new CozoDbConstructor("sqlite", dbPath);
-    return { db, isNew, dbPath };
-}
-/**
- * Initialize facts.db schema. Creates only missing relations.
- * Safe to call on both fresh and existing databases.
- */
-export async function initFactsSchema(db) {
-    const existing = await getExistingRelations(db);
-    if (!existing.has("facts")) {
-        await db.run(`
-      :create facts {
-        fact_id: String
-        =>
-        fact_type: String,
-        scope: String,
-        subject: String,
-        content: String,
-        base_confidence: Float,
-        reinforcement_count: Int,
-        created_at: Float,
-        last_reinforced_at: Float,
-        last_contradicted_at: Float,
-        source: String,
-        evidence: String
-      }
-    `);
-    }
-    if (!existing.has("entity_interactions")) {
-        await db.run(`
-      :create entity_interactions {
-        entity_key: String,
-        session_id: String,
-        interaction_type: String,
-        timestamp: Float
-        =>
-        tool_name: String,
-        outcome: String
-      }
-    `);
-    }
-    if (!existing.has("signal_shows")) {
-        // Rotation persistence: how many times each signal/fact has been surfaced.
-        // KEY (signal_id, session_id) — each session writes only its own row, so
-        // parallel `unerr --mcp` instances in the same repo never contend on writes.
-        // Aggregate count = SUM(count) over all sessions; recency = MAX(last_shown_ms).
-        await db.run(`
-      :create signal_shows {
-        signal_id: String,
-        session_id: String
-        =>
-        scope: String,
-        count: Int,
-        last_shown_ms: Float
-      }
-    `);
-    }
-}
-async function getExistingRelations(db) {
-    const result = await db.run("::relations");
-    return new Set(result.rows.map((row) => row[0]));
-}