aidimag 1.0.0

package/dist/db/store.js

@@ -0,0 +1,906 @@
+/**
+ * MemoryStore — all persistence for aidimag.
+ * Local-first: a single SQLite file at <repo>/.aidimag/memory.db
+ */
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import path from "node:path";
+import { SCHEMA_SQL, SCHEMA_VERSION, MIGRATIONS, EVIDENCE_REBUILD_V6, MEMORIES_REBUILD_V8, PROPOSALS_REBUILD_V8, EVENTS_REBUILD_V9 } from "./schema.js";
+import { debugLog } from "../debug.js";
+export const AIDIMAG_DIR = ".aidimag";
+export const DB_FILE = "memory.db";
+/** Walk up from `start` looking for an existing .aidimag dir (or .git as repo root). */
+export function findRepoRoot(start = process.cwd()) {
+    let dir = path.resolve(start);
+    for (;;) {
+        if (existsSync(path.join(dir, AIDIMAG_DIR)) || existsSync(path.join(dir, ".git"))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export function dbPathFor(repoRoot) {
+    return path.join(repoRoot, AIDIMAG_DIR, DB_FILE);
+}
+/**
+ * Stable per-machine id (CLOUD_DESIGN: "3 of 4 machines confirm…").
+ * Persisted once in ~/.aidimag/machine-id; hostname-prefixed for readability.
+ */
+export function machineId() {
+    const p = path.join(homedir(), ".aidimag", "machine-id");
+    try {
+        const existing = readFileSync(p, "utf8").trim();
+        if (existing)
+            return existing;
+    }
+    catch {
+        // first run
+    }
+    const id = `${hostname()}-${randomUUID().slice(0, 8)}`;
+    try {
+        mkdirSync(path.dirname(p), { recursive: true });
+        writeFileSync(p, id + "\n", { mode: 0o600 });
+    }
+    catch {
+        // unwritable home — fall back to a session-stable value
+    }
+    return id;
+}
+export class MemoryStore {
+    db;
+    dbPath;
+    /** true if the sqlite-vec extension loaded (vector search available) */
+    vecAvailable;
+    machine = machineId();
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+        mkdirSync(path.dirname(dbPath), { recursive: true });
+        this.db = new Database(dbPath);
+        let vecOk = false;
+        try {
+            sqliteVec.load(this.db);
+            vecOk = true;
+        }
+        catch (err) {
+            // vector search unavailable on this platform — FTS-only mode
+            debugLog("sqlite-vec load (semantic search disabled)", err);
+        }
+        this.vecAvailable = vecOk;
+        // version BEFORE this open (0 = fresh DB; SCHEMA_SQL below creates current shape)
+        let prevVersion = 0;
+        try {
+            const row = this.db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+            prevVersion = row ? parseInt(row.value, 10) : 0;
+        }
+        catch {
+            prevVersion = 0; // meta table doesn't exist yet
+        }
+        this.db.exec(SCHEMA_SQL);
+        for (const m of MIGRATIONS) {
+            try {
+                this.db.exec(m);
+            }
+            catch (err) {
+                // usually "duplicate column" = already applied; AIDIMAG_DEBUG=1 shows which
+                debugLog("schema migration (likely already applied)", err);
+            }
+        }
+        // v6: evidence CHECK gains TICKET_REF — needs a one-time table rebuild
+        if (prevVersion > 0 && prevVersion < 6) {
+            const tx = this.db.transaction(() => this.db.exec(EVIDENCE_REBUILD_V6));
+            tx();
+        }
+        // v8: memories/proposals CHECK gains GUARDRAIL + SKILL kinds — full table
+        // rebuild. Rowids are preserved and FTS is rebuilt; foreign keys are
+        // disabled around it (DROP TABLE memories has children), so this runs
+        // outside a transaction with manual BEGIN/COMMIT.
+        if (prevVersion > 0 && prevVersion < 8) {
+            this.db.pragma("foreign_keys = OFF");
+            this.db.exec("BEGIN");
+            try {
+                this.db.exec(MEMORIES_REBUILD_V8);
+                this.db.exec(PROPOSALS_REBUILD_V8);
+                this.db.exec("COMMIT");
+            }
+            catch (err) {
+                this.db.exec("ROLLBACK");
+                this.db.pragma("foreign_keys = ON");
+                throw err;
+            }
+            this.db.pragma("foreign_keys = ON");
+            // dropping/recreating the tables removed their triggers and indexes —
+            // SCHEMA_SQL recreates them (all CREATE ... IF NOT EXISTS, idempotent).
+            this.db.exec(SCHEMA_SQL);
+        }
+        // v9: events CHECK gains updated, evidence_added, evidence_removed types
+        if (prevVersion > 0 && prevVersion < 9) {
+            const tx = this.db.transaction(() => this.db.exec(EVENTS_REBUILD_V9));
+            tx();
+        }
+        this.db
+            .prepare("INSERT INTO meta (key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+            .run(String(SCHEMA_VERSION));
+        this.migrateEvidenceTrust();
+    }
+    /** Open the store for the repo containing `cwd`. Throws if not initialized and create=false. */
+    static open(cwd = process.cwd(), opts = {}) {
+        const root = findRepoRoot(cwd);
+        if (!root) {
+            throw new Error("Not inside a git repo or aidimag project. Run `dim init` at your repo root.");
+        }
+        const file = dbPathFor(root);
+        if (!existsSync(file) && !opts.create) {
+            throw new Error(`aidimag not initialized here. Run \`dim init\` in ${root}.`);
+        }
+        return new MemoryStore(file);
+    }
+    // ---------------------------------------------------------------- event log (SaaS sync model)
+    /** Append an event to the local log (shipped to the sync server on `dim sync`). */
+    recordEvent(type, memoryId, payload = {}) {
+        this.db
+            .prepare(`INSERT INTO events (id, type, memory_id, payload, machine, schema_version, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(randomUUID(), type, memoryId, JSON.stringify(payload), this.machine, SCHEMA_VERSION, new Date().toISOString());
+    }
+    /** Events not yet pushed to the sync server, oldest first. */
+    unsyncedEvents(limit = 500) {
+        const rows = this.db
+            .prepare("SELECT * FROM events WHERE synced = 0 ORDER BY seq ASC LIMIT ?")
+            .all(limit);
+        return rows.map((r) => ({
+            seq: r.seq,
+            id: r.id,
+            type: r.type,
+            memoryId: r.memory_id ?? null,
+            payload: JSON.parse(r.payload || "{}"),
+            machine: r.machine,
+            schemaVersion: r.schema_version,
+            createdAt: r.created_at,
+        }));
+    }
+    markEventsSynced(seqs) {
+        if (!seqs.length)
+            return;
+        const stmt = this.db.prepare("UPDATE events SET synced = 1 WHERE seq = ?");
+        const tx = this.db.transaction(() => seqs.forEach((s) => stmt.run(s)));
+        tx();
+    }
+    // ---------------------------------------------------------------- write
+    write(input) {
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        const hasEvidence = (input.evidence?.length ?? 0) > 0;
+        const insert = this.db.transaction(() => {
+            this.db
+                .prepare(`INSERT INTO memories (id, kind, claim, confidence, status, created_by, created_at, updated_at, pinned, guardrail_level)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(id, input.kind, input.claim, hasEvidence ? 0.7 : 0.5, "UNVERIFIED", input.createdBy ?? "human", now, now, input.pinned ? 1 : 0, input.kind === "GUARDRAIL" ? input.guardrailLevel ?? "ask-first" : null);
+            const scopeStmt = this.db.prepare("INSERT OR IGNORE INTO memory_scopes (memory_id, scope_type, value) VALUES (?, ?, ?)");
+            for (const p of input.paths ?? [])
+                scopeStmt.run(id, "path", p);
+            for (const s of input.symbols ?? [])
+                scopeStmt.run(id, "symbol", s);
+            const evStmt = this.db.prepare("INSERT INTO evidence (id, memory_id, type, payload, result) VALUES (?, ?, ?, ?, 'UNKNOWN')");
+            for (const ev of input.evidence ?? []) {
+                evStmt.run(randomUUID(), id, ev.type, ev.payload);
+                if (input.trustExecutableEvidence) {
+                    this.trustEvidencePayload(ev.payload);
+                }
+            }
+            this.recordEvent("memory_created", id, {
+                kind: input.kind,
+                claim: input.claim,
+                createdBy: input.createdBy ?? "human",
+            });
+        });
+        insert();
+        return this.get(id);
+    }
+    // ---------------------------------------------------------------- evidence trust gate
+    // Executable evidence (STATIC_CHECK / TEST_RESULT / EXEC_TRACE) runs shell
+    // commands on THIS machine — including automatically via git hooks. A synced
+    // teammate's (or attacker's) memory must not become remote code execution:
+    // only payloads explicitly trusted on this machine ever execute.
+    // CLI human writes and approved proposals opt in; agents/UI use proposals or `dim verify --trust`.
+    static evTrustKey(payload) {
+        return `evtrust:${createHash("sha256").update(payload).digest("hex").slice(0, 16)}`;
+    }
+    /** Mark an evidence payload as approved to execute on this machine. */
+    trustEvidencePayload(payload) {
+        this.setMeta(MemoryStore.evTrustKey(payload), new Date().toISOString());
+    }
+    isEvidencePayloadTrusted(payload) {
+        return this.getMeta(MemoryStore.evTrustKey(payload)) !== null;
+    }
+    /** Executable-evidence payloads currently NOT trusted (i.e. arrived via sync). */
+    untrustedEvidence() {
+        const rows = this.db
+            .prepare(`SELECT e.memory_id, m.claim, e.type, e.payload FROM evidence e
+         JOIN memories m ON m.id = e.memory_id
+         WHERE e.type IN ('STATIC_CHECK','TEST_RESULT','EXEC_TRACE')`)
+            .all();
+        return rows
+            .filter((r) => !this.isEvidencePayloadTrusted(r.payload))
+            .map((r) => ({ memoryId: r.memory_id, claim: r.claim, type: r.type, payload: r.payload }));
+    }
+    /** Trust every currently-untrusted executable payload (after human inspection). Returns count. */
+    trustAllEvidence() {
+        const pending = this.untrustedEvidence();
+        for (const p of pending)
+            this.trustEvidencePayload(p.payload);
+        return pending.length;
+    }
+    /**
+     * One-time migration: evidence that existed before the trust gate shipped
+     * was locally authored (sync always re-writes through applyRemoteMemory,
+     * which doesn't trust) — grandfather it so `dim verify` keeps working.
+     */
+    migrateEvidenceTrust() {
+        if (this.getMeta("evtrust_migrated"))
+            return;
+        try {
+            const rows = this.db
+                .prepare("SELECT DISTINCT payload FROM evidence WHERE type IN ('STATIC_CHECK','TEST_RESULT','EXEC_TRACE')")
+                .all();
+            for (const r of rows)
+                this.trustEvidencePayload(r.payload);
+        }
+        catch {
+            /* evidence table always exists post-SCHEMA_SQL; belt and braces */
+        }
+        this.setMeta("evtrust_migrated", new Date().toISOString());
+    }
+    // ---------------------------------------------------------------- read
+    get(id) {
+        const row = this.db
+            .prepare("SELECT * FROM memories WHERE id = ?")
+            .get(id);
+        if (!row)
+            return null;
+        return this.hydrate(row);
+    }
+    search(opts) {
+        const limit = Math.min(opts.limit ?? 10, 50);
+        const conditions = [];
+        const params = [];
+        // FTS match (sanitize: quote each term to avoid FTS syntax errors)
+        const ftsQuery = opts.query
+            .split(/\s+/)
+            .filter(Boolean)
+            .map((t) => `"${t.replace(/"/g, '""')}"`)
+            .join(" OR ");
+        if (opts.kind) {
+            conditions.push("m.kind = ?");
+            params.push(opts.kind);
+        }
+        if (opts.status) {
+            conditions.push("m.status = ?");
+            params.push(opts.status);
+        }
+        else if (!opts.includeRefuted) {
+            conditions.push("m.status != 'REFUTED'");
+        }
+        if (opts.paths?.length) {
+            // memory matches if unscoped (repo-wide) or any scope path prefixes/equals a query path
+            const pathClauses = opts.paths
+                .map(() => "(? LIKE s.value || '%' OR s.value LIKE ? || '%')")
+                .join(" OR ");
+            conditions.push(`(
+        NOT EXISTS (SELECT 1 FROM memory_scopes s WHERE s.memory_id = m.id AND s.scope_type = 'path')
+        OR EXISTS (SELECT 1 FROM memory_scopes s WHERE s.memory_id = m.id AND s.scope_type = 'path' AND (${pathClauses}))
+      )`);
+            for (const p of opts.paths)
+                params.push(p, p);
+        }
+        const where = conditions.length ? `AND ${conditions.join(" AND ")}` : "";
+        // Status-aware ranking (Phase 4 pilot tuning): trust dominates relevance.
+        // FTS bm25 rank is negative (more relevant = more negative), so we add a
+        // status penalty: VERIFIED +0, UNVERIFIED +2, STALE +10 — a stale memory
+        // only surfaces when nothing trustworthy matches.
+        const statusPenalty = "(CASE m.status WHEN 'VERIFIED' THEN 0 WHEN 'UNVERIFIED' THEN 2 WHEN 'STALE' THEN 10 ELSE 20 END)";
+        let rows;
+        if (ftsQuery) {
+            rows = this.db
+                .prepare(`SELECT m.* FROM memories_fts f
+           JOIN memories m ON m.rowid = f.rowid
+           WHERE memories_fts MATCH ? ${where}
+           ORDER BY (rank + ${statusPenalty}) ASC, m.confidence DESC
+           LIMIT ?`)
+                .all(ftsQuery, ...params, limit);
+        }
+        else {
+            rows = this.db
+                .prepare(`SELECT m.* FROM memories m WHERE 1=1 ${where}
+           ORDER BY ${statusPenalty} ASC, m.confidence DESC, m.created_at DESC LIMIT ?`)
+                .all(...params, limit);
+        }
+        return rows.map((r) => this.hydrate(r));
+    }
+    /** All memories whose scope overlaps the given file paths (plus repo-wide memories). */
+    getForFiles(paths, limit = 20) {
+        return this.search({ query: "", paths, limit });
+    }
+    list(limit = 50) {
+        const rows = this.db
+            .prepare("SELECT * FROM memories ORDER BY created_at DESC LIMIT ?")
+            .all(limit);
+        return rows.map((r) => this.hydrate(r));
+    }
+    statusSummary() {
+        const byStatus = {
+            VERIFIED: 0,
+            UNVERIFIED: 0,
+            STALE: 0,
+            REFUTED: 0,
+        };
+        for (const r of this.db
+            .prepare("SELECT status, COUNT(*) AS n FROM memories GROUP BY status")
+            .all()) {
+            byStatus[r.status] = r.n;
+        }
+        const byKind = {};
+        for (const r of this.db
+            .prepare("SELECT kind, COUNT(*) AS n FROM memories GROUP BY kind")
+            .all()) {
+            byKind[r.kind] = r.n;
+        }
+        const total = this.db.prepare("SELECT COUNT(*) AS n FROM memories").get().n;
+        const pinned = this.db.prepare("SELECT COUNT(*) AS n FROM memories WHERE pinned = 1").get().n;
+        const pendingProposals = this.db.prepare("SELECT COUNT(*) AS n FROM proposals WHERE status = 'PENDING'").get().n;
+        return { total, byStatus, byKind, pinned, dbPath: this.dbPath, pendingProposals };
+    }
+    // ---------------------------------------------------------------- embeddings (semantic recall)
+    /**
+     * Ensure the vec0 table exists for the given model+dimension.
+     * If the model changed since last index, drops and requires reindex.
+     * Returns false if vector search is unavailable.
+     */
+    ensureVecTable(model, dim) {
+        if (!this.vecAvailable)
+            return false;
+        const current = this.getMeta("embedding_model");
+        if (current && current !== `${model}:${dim}`) {
+            this.db.exec("DROP TABLE IF EXISTS vec_memories");
+        }
+        this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(memory_rowid integer primary key, embedding float[${dim}])`);
+        this.setMeta("embedding_model", `${model}:${dim}`);
+        return true;
+    }
+    upsertEmbedding(memoryId, vector) {
+        if (!this.vecAvailable)
+            return;
+        const row = this.db.prepare("SELECT rowid FROM memories WHERE id = ?").get(memoryId);
+        if (!row)
+            return;
+        this.db.prepare("DELETE FROM vec_memories WHERE memory_rowid = ?").run(BigInt(row.rowid));
+        this.db
+            .prepare("INSERT INTO vec_memories (memory_rowid, embedding) VALUES (?, ?)")
+            .run(BigInt(row.rowid), new Float32Array(vector));
+    }
+    /** Memory ids missing an embedding (for reindex/backfill). */
+    unembeddedIds() {
+        if (!this.vecAvailable)
+            return [];
+        try {
+            return this.db
+                .prepare(`SELECT m.id FROM memories m
+             WHERE m.rowid NOT IN (SELECT memory_rowid FROM vec_memories)`)
+                .all().map((r) => r.id);
+        }
+        catch {
+            return this.list(10_000).map((m) => m.id); // vec table doesn't exist yet
+        }
+    }
+    /** KNN over memory embeddings → [memoryId, distance] pairs, nearest first. */
+    knn(queryVector, k = 10) {
+        if (!this.vecAvailable)
+            return [];
+        try {
+            return this.db
+                .prepare(`SELECT m.id, v.distance FROM vec_memories v
+           JOIN memories m ON m.rowid = v.memory_rowid
+           WHERE v.embedding MATCH ? AND k = ?
+           ORDER BY v.distance`)
+                .all(new Float32Array(queryVector), BigInt(k));
+        }
+        catch {
+            return [];
+        }
+    }
+    // ---------------------------------------------------------------- proposals (Phase 2)
+    /** Queue a proposed memory for human review. Returns null if a duplicate already exists. */
+    propose(input) {
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        try {
+            this.db
+                .prepare(`INSERT INTO proposals (id, kind, claim, paths, symbols, evidence, source, source_ref, rationale, created_at, updated_at, ticket_ref, guardrail_level)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(id, input.kind, input.claim, JSON.stringify(input.paths ?? []), JSON.stringify(input.symbols ?? []), JSON.stringify(input.evidence ?? []), input.source, 
+            // NOTE: empty string, not NULL — SQLite treats NULLs as distinct in
+            // unique indexes, which would break (source, source_ref, claim) dedupe.
+            input.sourceRef ?? "", input.rationale ?? null, now, now, input.ticketRef ?? null, input.kind === "GUARDRAIL" ? input.guardrailLevel ?? "ask-first" : null);
+        }
+        catch (err) {
+            // UNIQUE(source, source_ref, claim) — already proposed
+            if (err instanceof Error && /UNIQUE constraint/.test(err.message))
+                return null;
+            throw err;
+        }
+        this.recordEvent("proposal_created", id, { kind: input.kind, claim: input.claim, source: input.source });
+        return this.getProposal(id);
+    }
+    getProposal(id) {
+        const row = this.db.prepare("SELECT * FROM proposals WHERE id = ?").get(id);
+        return row ? this.hydrateProposal(row) : null;
+    }
+    listProposals(status = "PENDING", limit = 50) {
+        const rows = this.db
+            .prepare("SELECT * FROM proposals WHERE status = ? ORDER BY created_at ASC LIMIT ?")
+            .all(status, limit);
+        return rows.map((r) => this.hydrateProposal(r));
+    }
+    /**
+     * Approve a proposal: creates the verified memory and removes the proposal row
+     * (tombstoned for team sync). `overrides.claim` lets the reviewer reword before promote.
+     */
+    approveProposal(id, overrides) {
+        const p = this.findProposalByPrefix(id);
+        if (!p)
+            throw new Error(`No proposal matching id '${id}'`);
+        if (p.status !== "PENDING")
+            throw new Error(`Proposal ${p.id} is already ${p.status}`);
+        const entry = this.write({
+            kind: p.kind,
+            claim: overrides?.claim?.trim() || p.claim,
+            paths: p.paths,
+            symbols: p.symbols,
+            evidence: p.evidence,
+            createdBy: p.source,
+            guardrailLevel: p.guardrailLevel,
+            // Knowledgebase docs are curated reference material — pin on approval so
+            // they don't decay with age (still falsifiable if evidence fails).
+            // Callers can override (e.g. requireReview:false auto-approval never pins).
+            pinned: overrides?.pinned ?? p.source.startsWith("knowledge:"),
+            trustExecutableEvidence: true,
+        });
+        this.recordEvent("proposal_approved", p.id, { memoryId: entry.id, claim: p.claim });
+        this.discardProposal(p.id);
+        return entry;
+    }
+    rejectProposal(id) {
+        const p = this.findProposalByPrefix(id);
+        if (!p)
+            throw new Error(`No proposal matching id '${id}'`);
+        if (p.status !== "PENDING")
+            throw new Error(`Proposal ${p.id} is already ${p.status}`);
+        this.recordEvent("proposal_rejected", p.id, { claim: p.claim });
+        this.discardProposal(p.id);
+        return { ...p, status: "REJECTED" };
+    }
+    /** Claims from rejected proposals — used by triage (survives proposal row deletion). */
+    listRejectedClaims(limit = 500) {
+        const claims = [];
+        const rows = this.db
+            .prepare(`SELECT payload FROM events WHERE type = 'proposal_rejected' ORDER BY seq DESC LIMIT ?`)
+            .all(limit);
+        for (const r of rows) {
+            try {
+                const claim = JSON.parse(r.payload || "{}").claim;
+                if (typeof claim === "string" && claim)
+                    claims.push(claim);
+            }
+            catch {
+                // ignore malformed event payloads
+            }
+        }
+        return [...new Set(claims)];
+    }
+    /**
+     * Remove resolved proposals (approved/rejected) and tombstone for sync.
+     * Use after upgrading brains that still carry historical APPROVED rows.
+     */
+    gcResolvedProposals(opts = {}) {
+        const rows = this.db
+            .prepare("SELECT id FROM proposals WHERE status IN ('APPROVED', 'REJECTED')")
+            .all();
+        if (!opts.dryRun) {
+            for (const r of rows)
+                this.discardProposal(r.id);
+        }
+        return { removed: rows.length };
+    }
+    findProposalByPrefix(idOrPrefix) {
+        const row = this.db
+            .prepare("SELECT * FROM proposals WHERE id = ? OR id LIKE ? || '%' LIMIT 1")
+            .get(idOrPrefix, idOrPrefix);
+        return row ? this.hydrateProposal(row) : null;
+    }
+    // ---------------------------------------------------------------- search log (passive capture)
+    /**
+     * Record a memory search (MCP or CLI). Zero-hit queries are coverage gaps:
+     * an agent needed knowledge the brain couldn't supply. Local-only, never synced.
+     */
+    logSearch(query, paths, resultCount, source = "mcp") {
+        const q = query.trim();
+        if (!q)
+            return;
+        this.db
+            .prepare("INSERT INTO search_log (id, query, paths, result_count, source, created_at) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(randomUUID(), q, JSON.stringify(paths), resultCount, source, new Date().toISOString());
+    }
+    /**
+     * Zero-hit searches grouped by normalized query — the repo's knowledge gaps,
+     * most-asked first. `sinceDays` bounds the window (default 30).
+     */
+    searchGaps(opts = {}) {
+        const since = new Date(Date.now() - (opts.sinceDays ?? 30) * 86_400_000).toISOString();
+        const rows = this.db
+            .prepare(`SELECT LOWER(TRIM(query)) AS q, MAX(query) AS query, COUNT(*) AS misses,
+                MAX(created_at) AS last_asked, MAX(paths) AS paths
+         FROM search_log
+         WHERE result_count = 0 AND created_at >= ?
+         GROUP BY q
+         ORDER BY misses DESC, last_asked DESC
+         LIMIT ?`)
+            .all(since, Math.min(opts.limit ?? 20, 100));
+        return rows.map((r) => {
+            let paths = [];
+            try {
+                paths = JSON.parse(r.paths);
+            }
+            catch {
+                /* legacy/garbled row — treat as unscoped */
+            }
+            return { query: r.query, misses: r.misses, lastAsked: r.last_asked, paths };
+        });
+    }
+    /** Clear logged searches (e.g. after the gaps have been addressed). */
+    clearSearchGaps() {
+        return this.db.prepare("DELETE FROM search_log").run().changes;
+    }
+    /** Last mined commit sha (commit-miner cursor), or null. */
+    getMeta(key) {
+        const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+        return row?.value ?? null;
+    }
+    setMeta(key, value) {
+        this.db
+            .prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+            .run(key, value);
+    }
+    hydrateProposal(row) {
+        return {
+            id: row.id,
+            kind: row.kind,
+            claim: row.claim,
+            paths: JSON.parse(row.paths),
+            symbols: JSON.parse(row.symbols),
+            evidence: JSON.parse(row.evidence),
+            source: row.source,
+            sourceRef: row.source_ref || undefined,
+            rationale: row.rationale ?? undefined,
+            createdAt: row.created_at,
+            status: row.status,
+            memoryId: row.memory_id ?? null,
+            updatedAt: row.updated_at ?? null,
+            ticketRef: row.ticket_ref ?? undefined,
+            guardrailLevel: row.guardrail_level ?? undefined,
+        };
+    }
+    // ---------------------------------------------------------------- mutate
+    setStatus(id, status) {
+        const now = new Date().toISOString();
+        const verifiedAt = status === "VERIFIED" ? now : null;
+        const res = this.db
+            .prepare("UPDATE memories SET status = ?, verified_at = COALESCE(?, verified_at), updated_at = ? WHERE id = ?")
+            .run(status, verifiedAt, now, id);
+        if (res.changes === 0)
+            throw new Error(`No memory with id ${id}`);
+        this.recordEvent("status_changed", id, { status });
+    }
+    setConfidence(id, confidence) {
+        this.db
+            .prepare("UPDATE memories SET confidence = ?, updated_at = ? WHERE id = ?")
+            .run(Math.max(0, Math.min(1, confidence)), new Date().toISOString(), id);
+    }
+    /**
+     * Pin/unpin a memory. Pinned memories never decay with time (but evidence
+     * failure still marks them STALE — pinning removes the clock, not the test).
+     */
+    setPinned(id, pinned) {
+        const res = this.db
+            .prepare("UPDATE memories SET pinned = ?, updated_at = ? WHERE id = ?")
+            .run(pinned ? 1 : 0, new Date().toISOString(), id);
+        if (res.changes === 0)
+            throw new Error(`No memory with id ${id}`);
+        this.recordEvent("status_changed", id, { pinned });
+    }
+    touchVerified(id) {
+        const now = new Date().toISOString();
+        this.db
+            .prepare("UPDATE memories SET verified_at = ?, updated_at = ? WHERE id = ?")
+            .run(now, now, id);
+    }
+    updateEvidenceResult(evidenceId, result, lastRun) {
+        this.db
+            .prepare("UPDATE evidence SET result = ?, last_run = ? WHERE id = ?")
+            .run(result, lastRun, evidenceId);
+        this.db
+            .prepare("UPDATE memories SET updated_at = ? WHERE id = (SELECT memory_id FROM evidence WHERE id = ?)")
+            .run(lastRun, evidenceId);
+        const owner = this.db
+            .prepare("SELECT memory_id, type FROM evidence WHERE id = ?")
+            .get(evidenceId);
+        if (owner) {
+            this.recordEvent("evidence_result", owner.memory_id, {
+                evidenceId,
+                evidenceType: owner.type,
+                result,
+                at: lastRun,
+            });
+        }
+    }
+    refute(id, supersededBy) {
+        const res = this.db
+            .prepare("UPDATE memories SET status = 'REFUTED', superseded_by = ?, updated_at = ? WHERE id = ?")
+            .run(supersededBy ?? null, new Date().toISOString(), id);
+        if (res.changes === 0)
+            throw new Error(`No memory with id ${id}`);
+        this.recordEvent("refuted", id, supersededBy ? { supersededBy } : {});
+        if (supersededBy)
+            this.recordEvent("superseded", id, { by: supersededBy });
+    }
+    forget(id) {
+        const tx = this.db.transaction(() => {
+            // clear proposal back-references (older DBs lack ON DELETE SET NULL)
+            this.db.prepare("UPDATE proposals SET memory_id = NULL WHERE memory_id = ?").run(id);
+            this.db.prepare("UPDATE memories SET superseded_by = NULL WHERE superseded_by = ?").run(id);
+            const res = this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+            if (res.changes === 0)
+                throw new Error(`No memory with id ${id}`);
+            this.db
+                .prepare("INSERT OR REPLACE INTO tombstones (id, tbl, deleted_at) VALUES (?, 'memories', ?)")
+                .run(id, new Date().toISOString());
+            this.recordEvent("forgotten", id);
+        });
+        tx();
+    }
+    /** Delete a proposal row and record a tombstone so team sync drops it on the remote brain. */
+    discardProposal(id, deletedAt) {
+        const at = deletedAt ?? new Date().toISOString();
+        const tx = this.db.transaction(() => {
+            const res = this.db.prepare("DELETE FROM proposals WHERE id = ?").run(id);
+            if (res.changes === 0)
+                throw new Error(`No proposal with id ${id}`);
+            this.db
+                .prepare("INSERT OR REPLACE INTO tombstones (id, tbl, deleted_at) VALUES (?, 'proposals', ?)")
+                .run(id, at);
+        });
+        tx();
+    }
+    link(fromId, toId, relation) {
+        this.db
+            .prepare("INSERT OR IGNORE INTO memory_links (from_id, to_id, relation) VALUES (?, ?, ?)")
+            .run(fromId, toId, relation);
+    }
+    update(id, updates) {
+        const sets = [];
+        const values = [];
+        if (updates.claim !== undefined) {
+            sets.push("claim = ?");
+            values.push(updates.claim);
+        }
+        if (updates.kind !== undefined) {
+            sets.push("kind = ?");
+            values.push(updates.kind);
+        }
+        if (updates.guardrailLevel !== undefined) {
+            sets.push("guardrail_level = ?");
+            values.push(updates.guardrailLevel);
+        }
+        if (sets.length === 0)
+            return;
+        sets.push("updated_at = ?");
+        values.push(new Date().toISOString());
+        values.push(id);
+        const sql = `UPDATE memories SET ${sets.join(", ")} WHERE id = ?`;
+        const res = this.db.prepare(sql).run(...values);
+        if (res.changes === 0)
+            throw new Error(`No memory with id ${id}`);
+        this.recordEvent("updated", id, updates);
+    }
+    addEvidence(memoryId, ev) {
+        const id = randomUUID();
+        this.db
+            .prepare("INSERT INTO evidence (id, memory_id, type, payload, result) VALUES (?, ?, ?, ?, 'UNKNOWN')")
+            .run(id, memoryId, ev.type, ev.payload);
+        this.recordEvent("evidence_added", memoryId, { evidenceId: id, type: ev.type });
+        return id;
+    }
+    removeEvidence(evidenceId) {
+        const ev = this.db.prepare("SELECT memory_id FROM evidence WHERE id = ?").get(evidenceId);
+        if (!ev)
+            throw new Error(`No evidence with id ${evidenceId}`);
+        const res = this.db.prepare("DELETE FROM evidence WHERE id = ?").run(evidenceId);
+        if (res.changes === 0)
+            throw new Error(`No evidence with id ${evidenceId}`);
+        this.recordEvent("evidence_removed", ev.memory_id, { evidenceId });
+    }
+    // ---------------------------------------------------------------- sync (Phase 6)
+    // State-based LWW sync support consumed by src/sync/client.ts.
+    /** Local changes since `sinceIso` (null = everything), for pushing to a sync server. */
+    changedSince(sinceIso) {
+        const since = sinceIso ?? "";
+        const memRows = this.db
+            .prepare("SELECT * FROM memories WHERE COALESCE(updated_at, created_at) > ?")
+            .all(since);
+        const propRows = this.db
+            .prepare("SELECT * FROM proposals WHERE COALESCE(updated_at, created_at) > ?")
+            .all(since);
+        const tombs = this.db
+            .prepare("SELECT id, tbl, deleted_at FROM tombstones WHERE deleted_at > ?")
+            .all(since);
+        return {
+            memories: memRows.map((r) => this.hydrate(r)),
+            proposals: propRows.map((r) => this.hydrateProposal(r)),
+            tombstones: tombs.map((t) => ({ id: t.id, tbl: t.tbl, deletedAt: t.deleted_at })),
+        };
+    }
+    /** Per-memory updated_at (for LWW comparisons). */
+    memoryUpdatedAt(id) {
+        const row = this.db
+            .prepare("SELECT COALESCE(updated_at, created_at) AS u FROM memories WHERE id = ?")
+            .get(id);
+        return row?.u ?? null;
+    }
+    isTombstoned(id, tbl) {
+        return !!this.db.prepare("SELECT 1 FROM tombstones WHERE id = ? AND tbl = ?").get(id, tbl);
+    }
+    /** Upsert a remote memory snapshot (caller already did the LWW check). */
+    applyRemoteMemory(m) {
+        const tx = this.db.transaction(() => {
+            this.db
+                .prepare(`INSERT INTO memories (id, kind, claim, confidence, status, created_by, created_at, verified_at, superseded_by, updated_at, pinned, guardrail_level)
+           VALUES (@id, @kind, @claim, @confidence, @status, @created_by, @created_at, @verified_at, @superseded_by, @updated_at, @pinned, @guardrail_level)
+           ON CONFLICT(id) DO UPDATE SET
+             kind=excluded.kind, claim=excluded.claim, confidence=excluded.confidence,
+             status=excluded.status, verified_at=excluded.verified_at,
+             superseded_by=excluded.superseded_by, updated_at=excluded.updated_at,
+             pinned=excluded.pinned, guardrail_level=excluded.guardrail_level`)
+                .run({
+                id: m.id,
+                kind: m.kind,
+                claim: m.claim,
+                confidence: m.confidence,
+                status: m.status,
+                created_by: m.createdBy,
+                created_at: m.createdAt,
+                verified_at: m.verifiedAt,
+                superseded_by: null, // applied without FK risk; relinked below if target exists
+                updated_at: m.updatedAt ?? m.createdAt,
+                pinned: m.pinned ? 1 : 0,
+                guardrail_level: m.guardrailLevel ?? null,
+            });
+            if (m.supersededBy) {
+                this.db
+                    .prepare("UPDATE memories SET superseded_by = ? WHERE id = ? AND EXISTS (SELECT 1 FROM memories WHERE id = ?)")
+                    .run(m.supersededBy, m.id, m.supersededBy);
+            }
+            this.db.prepare("DELETE FROM memory_scopes WHERE memory_id = ?").run(m.id);
+            const scopeStmt = this.db.prepare("INSERT OR IGNORE INTO memory_scopes (memory_id, scope_type, value) VALUES (?, ?, ?)");
+            for (const p of m.scope.paths)
+                scopeStmt.run(m.id, "path", p);
+            for (const s of m.scope.symbols)
+                scopeStmt.run(m.id, "symbol", s);
+            this.db.prepare("DELETE FROM evidence WHERE memory_id = ?").run(m.id);
+            const evStmt = this.db.prepare("INSERT INTO evidence (id, memory_id, type, payload, last_run, result) VALUES (?, ?, ?, ?, ?, ?)");
+            for (const e of m.grounding)
+                evStmt.run(e.id, m.id, e.type, e.payload, e.lastRun, e.result);
+        });
+        tx();
+    }
+    proposalUpdatedAt(id) {
+        const row = this.db
+            .prepare("SELECT COALESCE(updated_at, created_at) AS u FROM proposals WHERE id = ?")
+            .get(id);
+        return row?.u ?? null;
+    }
+    applyRemoteProposal(p) {
+        try {
+            this.db
+                .prepare(`INSERT INTO proposals (id, kind, claim, paths, symbols, evidence, source, source_ref, rationale, created_at, status, memory_id, updated_at, ticket_ref, guardrail_level)
+           VALUES (@id, @kind, @claim, @paths, @symbols, @evidence, @source, @source_ref, @rationale, @created_at, @status, NULL, @updated_at, @ticket_ref, @guardrail_level)
+           ON CONFLICT(id) DO UPDATE SET status=excluded.status, updated_at=excluded.updated_at`)
+                .run({
+                id: p.id,
+                kind: p.kind,
+                claim: p.claim,
+                paths: JSON.stringify(p.paths),
+                symbols: JSON.stringify(p.symbols),
+                evidence: JSON.stringify(p.evidence),
+                source: p.source,
+                source_ref: p.sourceRef ?? "",
+                rationale: p.rationale ?? null,
+                created_at: p.createdAt,
+                status: p.status,
+                updated_at: p.updatedAt ?? p.createdAt,
+                ticket_ref: p.ticketRef ?? null,
+                guardrail_level: p.guardrailLevel ?? null,
+            });
+        }
+        catch (err) {
+            // (source, source_ref, claim) dedupe collision with a different id —
+            // the claim is already represented locally; skip rather than fail sync.
+            if (err instanceof Error && /UNIQUE constraint/.test(err.message))
+                return;
+            throw err;
+        }
+    }
+    /** Apply a remote tombstone: delete locally without creating a new tombstone loop. */
+    applyRemoteTombstone(id, tbl, deletedAt) {
+        const tx = this.db.transaction(() => {
+            if (tbl === "memories") {
+                this.db.prepare("UPDATE proposals SET memory_id = NULL WHERE memory_id = ?").run(id);
+                this.db.prepare("UPDATE memories SET superseded_by = NULL WHERE superseded_by = ?").run(id);
+                this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+            }
+            else {
+                this.db.prepare("DELETE FROM proposals WHERE id = ?").run(id);
+            }
+            this.db
+                .prepare("INSERT OR REPLACE INTO tombstones (id, tbl, deleted_at) VALUES (?, ?, ?)")
+                .run(id, tbl, deletedAt);
+        });
+        tx();
+    }
+    close() {
+        this.db.close();
+    }
+    // ---------------------------------------------------------------- private
+    hydrate(row) {
+        const scopes = this.db
+            .prepare("SELECT scope_type, value FROM memory_scopes WHERE memory_id = ?")
+            .all(row.id);
+        const evidence = this.db
+            .prepare("SELECT * FROM evidence WHERE memory_id = ?")
+            .all(row.id);
+        const links = this.db
+            .prepare("SELECT from_id, to_id, relation FROM memory_links WHERE from_id = ? OR to_id = ?")
+            .all(row.id, row.id);
+        return {
+            id: row.id,
+            kind: row.kind,
+            claim: row.claim,
+            scope: {
+                paths: scopes.filter((s) => s.scope_type === "path").map((s) => s.value),
+                symbols: scopes.filter((s) => s.scope_type === "symbol").map((s) => s.value),
+            },
+            confidence: row.confidence,
+            status: row.status,
+            pinned: !!row.pinned,
+            createdBy: row.created_by,
+            createdAt: row.created_at,
+            verifiedAt: row.verified_at,
+            supersededBy: row.superseded_by,
+            updatedAt: row.updated_at ?? null,
+            grounding: evidence.map((e) => ({
+                id: e.id,
+                memoryId: e.memory_id,
+                type: e.type,
+                payload: e.payload,
+                lastRun: e.last_run,
+                result: e.result,
+            })),
+            links: links.map((l) => ({ fromId: l.from_id, toId: l.to_id, relation: l.relation })),
+            guardrailLevel: row.guardrail_level ?? undefined,
+        };
+    }
+}
+//# sourceMappingURL=store.js.map