pi-mega-compact 0.7.8 → 0.7.9

package/dist/src/store/sqlite/maintenance.js

@@ -0,0 +1,235 @@
+/**
+ * maintenance.ts — S27 Task 10 DB maintenance / housekeeping primitives.
+ *
+ * All pi-agnostic, all parameterized (PREVENT-002), all local (PREVENT-PI-004).
+ * Exposed via the /mega-db-* slash commands in extensions/mega-db-cmds.ts.
+ */
+import { statSync } from "node:fs";
+import { join } from "node:path";
+import { getStateDir } from "../../store.js";
+import { openStore, withTx } from "./utils.js";
+const DB_TABLE_NAMES = [
+    "context_chunks",
+    "session_state",
+    "raw_transcript",
+    "checkpoint_epochs",
+    "dedup_mirror",
+    "memories",
+    "dedup_stats",
+    "daily_log",
+];
+function fileSizeIfExists(path) {
+    try {
+        const st = statSync(path);
+        return st.size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Gather DB stats for /mega-db-stats: per-table row counts, disk footprint
+ * (main + WAL + SHM), page count, freelist, WAL frame count.
+ *
+ * Read-only: no PRAGMA writes, no VACUUM. Safe to call any time.
+ */
+export function getDbStats(stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const tableCounts = {};
+    for (const t of DB_TABLE_NAMES) {
+        try {
+            const row = db.prepare(`SELECT COUNT(*) AS c FROM ${t}`).get();
+            if (row)
+                tableCounts[t] = row.c;
+        }
+        catch {
+            // Table doesn't exist on this DB (e.g. raw_transcript on a pre-S27 store).
+            // Skip silently — /mega-db-stats lists only tables that exist.
+        }
+    }
+    const pageStat = db.prepare("PRAGMA page_count").get();
+    const freelistStat = db.prepare("PRAGMA freelist_count").get();
+    const pageSizeStat = db.prepare("PRAGMA page_size").get();
+    let walFrames = 0;
+    try {
+        const walInfo = db.prepare("PRAGMA wal_info").get();
+        walFrames = walInfo?.frames ?? 0;
+    }
+    catch {
+        // node:sqlite may not expose wal_info on all versions; not fatal.
+    }
+    const dbPath = join(stateDir, "sqlite.db");
+    return {
+        tableCounts,
+        dbBytes: fileSizeIfExists(dbPath),
+        walBytes: fileSizeIfExists(`${dbPath}-wal`),
+        shmBytes: fileSizeIfExists(`${dbPath}-shm`),
+        pageSize: pageSizeStat?.page_size ?? 0,
+        pageCount: pageStat?.page_count ?? 0,
+        freelistPages: freelistStat?.freelist_count ?? 0,
+        walFrames,
+    };
+}
+/**
+ * Prune raw_transcript + checkpoint_epochs rows older than `daysOld`.
+ * Uses `message_timestamp` (raw_transcript) and `created_at` (epochs), both
+ * epoch-ms. Returns the total deleted rows + reclaimed disk bytes.
+ *
+ * PREVENT-002: parameterized. PREVENT-PI-004: local SQLite only.
+ */
+export function pruneOldRows(stateDir = getStateDir(), daysOld = 30) {
+    const db = openStore(stateDir);
+    const cutoff = Date.now() - daysOld * 86_400_000;
+    const beforeBytes = fileSizeIfExists(join(stateDir, "sqlite.db"));
+    // raw_transcript: message_timestamp may be NULL (pre-S27 rows); those use
+    // the row's insertion order implicitly via seq, so we prune NULL-ts rows
+    // only when the whole session is older than the cutoff (join via session_id
+    // to checkpoint_epochs.created_at). Simpler: prune NULL-ts rows older than
+    // cutoff by falling back to the MIN(created_at) of their epoch.
+    // Delete raw_transcript rows whose message_timestamp is older than cutoff,
+    // OR whose message_timestamp is NULL and the session's latest epoch is older.
+    const delRt = db.prepare(`DELETE FROM raw_transcript
+     WHERE message_timestamp IS NOT NULL AND message_timestamp < ?
+        OR (message_timestamp IS NULL
+            AND session_id IN (
+              SELECT session_id FROM checkpoint_epochs
+              GROUP BY session_id HAVING MAX(created_at) < ?
+            ))`).run(cutoff, cutoff);
+    const rtDeleted = delRt?.changes ?? 0;
+    // checkpoint_epochs: created_at is NOT NULL.
+    const delEp = db.prepare(`DELETE FROM checkpoint_epochs WHERE created_at < ?`).run(cutoff);
+    const epDeleted = delEp?.changes ?? 0;
+    // dedup_mirror: cascade-delete orphan rows whose ref_count has dropped to 0
+    // after the raw_transcript deletes. Safe even if FK is off (raw_transcript has
+    // no FK to dedup_mirror; ref_count is maintained by the dedup pipeline).
+    const delDedup = db.prepare(`DELETE FROM dedup_mirror WHERE ref_count <= 0`).run();
+    const dedupDeleted = delDedup?.changes ?? 0;
+    const afterBytes = fileSizeIfExists(join(stateDir, "sqlite.db"));
+    const total = rtDeleted + epDeleted + dedupDeleted;
+    return {
+        affected: total,
+        reclaimedBytes: Math.max(0, beforeBytes - afterBytes),
+        summary: `pruned ${rtDeleted} raw_transcript + ${epDeleted} epochs + ${dedupDeleted} dedup_mirror rows older than ${daysOld}d`,
+    };
+}
+/**
+ * Force a WAL checkpoint (TRUNCATE mode) so the -wal sidecar is reclaimed.
+ * Returns the WAL bytes reclaimed (pre-wal size minus post-wal size).
+ */
+export function checkpointWal(stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const dbPath = join(stateDir, "sqlite.db");
+    const beforeWal = fileSizeIfExists(`${dbPath}-wal`);
+    // PRAGMA wal_checkpoint(TRUNCATE) blocks until all frames are folded into the
+    // main db and the WAL file is truncated to 0 bytes.
+    const res = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+    const afterWal = fileSizeIfExists(`${dbPath}-wal`);
+    const reclaimed = Math.max(0, beforeWal - afterWal);
+    return {
+        affected: res?.checkpointed ?? 0,
+        reclaimedBytes: reclaimed,
+        summary: `wal_checkpoint(TRUNCATE): ${res?.checkpointed ?? 0} frames folded, WAL ${beforeWal}→${afterWal} bytes${res?.busy ? " (busy: " + res.busy + ")" : ""}`,
+    };
+}
+/**
+ * VACUUM the main DB file (rebuilds pages, reclaims freelist space).
+ * Heavy: briefly doubles disk usage. Run only when freelist is large or the
+ * user explicitly invokes /mega-db-vacuum.
+ */
+export function vacuumDb(stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const dbPath = join(stateDir, "sqlite.db");
+    const beforeBytes = fileSizeIfExists(dbPath);
+    db.exec("VACUUM"); // VACUUM cannot be parameterized; it rewrites the whole DB.
+    const afterBytes = fileSizeIfExists(dbPath);
+    const reclaimed = Math.max(0, beforeBytes - afterBytes);
+    return {
+        affected: 0,
+        reclaimedBytes: reclaimed,
+        summary: `VACUUM: db ${beforeBytes}→${afterBytes} bytes (reclaimed ${reclaimed})`,
+    };
+}
+/**
+ * Run `PRAGMA integrity_check` and return the result lines.
+ * Returns ["ok"] when the DB is healthy; otherwise returns the error lines.
+ */
+export function integrityCheck(stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const rows = db.prepare("PRAGMA integrity_check").all();
+    return (rows ?? []).map((r) => r.integrity_check);
+}
+/**
+ * Reconcile dedup_mirror vs raw_transcript after pruning or crashes:
+ *   1. Recompute ref_count = COUNT(raw_transcript rows pointing at this hash).
+ *   2. Delete orphan dedup_mirror rows whose recomputed ref_count is 0.
+ *   3. Backfill raw_transcript.content_ref for rows still storing inline bytes.
+ *
+ * Idempotent. Read-modify-write within a single transaction (withTx).
+ */
+export function reconcileDedupMirror(stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const result = { fixedRefCount: 0, orphansDeleted: 0, refsBackfilled: 0 };
+    withTx(db, () => {
+        // 1. Recompute ref_count for every dedup_mirror row from the actual
+        //    raw_transcript references.
+        const recompute = db.prepare(`UPDATE dedup_mirror AS dm
+       SET ref_count = COALESCE((
+         SELECT COUNT(*) FROM raw_transcript rt WHERE rt.content_ref = dm.content_hash
+       ), 0)
+       WHERE dm.ref_count != COALESCE((
+         SELECT COUNT(*) FROM raw_transcript rt WHERE rt.content_ref = dm.content_hash
+       ), 0)`).run();
+        result.fixedRefCount = recompute?.changes ?? 0;
+        // 2. Delete orphan dedup_mirror rows (no raw_transcript refs).
+        const delOrphans = db.prepare(`DELETE FROM dedup_mirror
+       WHERE content_hash NOT IN (SELECT DISTINCT content_ref FROM raw_transcript WHERE content_ref IS NOT NULL)`).run();
+        result.orphansDeleted = delOrphans?.changes ?? 0;
+        // 3. Backfill content_ref for rows still storing inline content_bytes (no
+        //    ref yet). Only safe when a matching dedup_mirror row exists; otherwise
+        //    we'd need to insert one, which is the dedup pipeline's job, not the
+        //    reconciler's.
+        const backfill = db.prepare(`UPDATE raw_transcript AS rt
+       SET content_ref = (
+         SELECT dm.content_hash FROM dedup_mirror dm WHERE dm.content_bytes = rt.content_bytes
+       )
+       WHERE rt.content_ref IS NULL
+         AND EXISTS (SELECT 1 FROM dedup_mirror dm WHERE dm.content_bytes = rt.content_bytes)`).run();
+        result.refsBackfilled = backfill?.changes ?? 0;
+    });
+    return result;
+}
+/**
+ * One-shot auto-maintenance pass for the session_start hook: prune old rows,
+ * checkpoint the WAL if it's grown large, and (only if the DB is huge) VACUUM.
+ * Best-effort: swallows errors so a session never fails to start over a
+ * housekeeping hiccup. Returns a short summary for the diagnostic log.
+ */
+export function autoMaintain(stateDir = getStateDir()) {
+    try {
+        const stats = getDbStats(stateDir);
+        const parts = [];
+        // Prune rows older than 30d (default retention).
+        const prune = pruneOldRows(stateDir, 30);
+        if (prune.affected > 0)
+            parts.push(`pruned ${prune.affected}`);
+        // Checkpoint the WAL if it's over 10 MB (avoid pathological WAL growth).
+        if (stats.walBytes > 10 * 1024 * 1024) {
+            const ck = checkpointWal(stateDir);
+            if (ck.reclaimedBytes > 0)
+                parts.push(`wal -${ck.reclaimedBytes}B`);
+        }
+        // VACUUM only if the DB is over 100 MB AND freelist is >20% of pages.
+        if (stats.dbBytes > 100 * 1024 * 1024 &&
+            stats.pageCount > 0 &&
+            stats.freelistPages / stats.pageCount > 0.2) {
+            const v = vacuumDb(stateDir);
+            if (v.reclaimedBytes > 0)
+                parts.push(`vacuum -${v.reclaimedBytes}B`);
+        }
+        return parts.length ? `auto-maintain: ${parts.join(", ")}` : "auto-maintain: nothing to do";
+    }
+    catch (err) {
+        // Never block session start over housekeeping.
+        return `auto-maintain: skipped (${err.message})`;
+    }
+}

package/dist/src/store/sqlite/memories.js

@@ -0,0 +1,164 @@
+/**
+ * memories.ts — durable "save to memory" store (taken over from memory extensions).
+ *
+ * One SQLite store for user-saved memories, scoped by repo. Mirrors the
+ * lessons/sessions pattern: all state lives in SQLite from day one.
+ */
+import { getStateDir } from "../../store.js";
+import { openStore } from "./utils.js";
+// S24 storage hardening: keep each memory row bounded so the durable store can
+// never blow a downstream consumer's per-entry buffer (e.g. pi's native
+// file-backed memory caps a single entry at ~5k chars). We truncate content at
+// MEMORY_MAX_CHARS and evict the least-recently-referenced rows past
+// MEMORY_MAX_ROWS per repo via LRU. Both are SQLite-only (PREVENT-PI-004): no
+// file-backed memory is written anywhere. Defaults are overridable via env
+// (MEGACOMPACT_MEMORY_MAX_CHARS / MEGACOMPACT_MEMORY_MAX_ROWS).
+export const MEMORY_MAX_CHARS = 4000;
+export const MEMORY_MAX_ROWS = 500;
+/** Read an env override as a positive int, falling back to `fallback`. */
+function envInt(name, fallback) {
+    const v = process.env[name];
+    if (v == null || v === "")
+        return fallback;
+    const n = Number(v);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+/** Effective per-entry char cap (env-overridable, default MEMORY_MAX_CHARS). */
+export function memoryMaxChars() {
+    return envInt("MEGACOMPACT_MEMORY_MAX_CHARS", MEMORY_MAX_CHARS);
+}
+/** Effective per-repo row cap (env-overridable, default MEMORY_MAX_ROWS). */
+export function memoryMaxRows() {
+    return envInt("MEGACOMPACT_MEMORY_MAX_ROWS", MEMORY_MAX_ROWS);
+}
+/** Truncate memory content to the per-entry cap, preserving a trailing marker. */
+function capMemoryContent(content) {
+    const cap = memoryMaxChars();
+    if (content.length <= cap)
+        return content;
+    return content.slice(0, cap) + "…[truncated]";
+}
+/**
+ * Evict the least-recently-referenced rows for a repo past MEMORY_MAX_ROWS.
+ * LRU key = COALESCE(last_referenced, last_recalled_at, created_at) so a memory
+ * that is recalled/referenced survives over a stale one. Best-effort: any error
+ * is swallowed by the caller. Repo-scoped so one noisy repo can't evict another.
+ */
+function evictMemoryLru(repo, stateDir) {
+    const db = openStore(stateDir);
+    const maxRows = memoryMaxRows();
+    // SQLite `= NULL` is never true, so the null-repo scope (memories are
+    // stateDir-scoped when repo is null — the applyMemoryOps path) needs `IS NULL`.
+    const where = repo == null ? "repo IS NULL" : "repo = ?";
+    const countRow = repo == null
+        ? db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get()
+        : db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get(repo);
+    const count = countRow.n;
+    const over = count - maxRows;
+    if (over <= 0)
+        return;
+    // Delete the `over` least-recently-used rows. ORDER BY the LRU key ASC, id ASC
+    // (id ASC breaks ties deterministically — oldest created first). The `where`
+    // clause is a code-controlled constant (never user input) → PREVENT-002 OK.
+    const sql = `DELETE FROM memories WHERE ${where} AND id IN (
+       SELECT id FROM memories WHERE ${where}
+       ORDER BY COALESCE(last_referenced, last_recalled_at, created_at) ASC, id ASC
+       LIMIT ?
+     )`;
+    if (repo == null)
+        db.prepare(sql).run(over);
+    else
+        db.prepare(sql).run(repo, repo, over);
+}
+/** Save a memory to the current repo's store. Returns the new row id.
+ *  S24 hardening: content is truncated to MEMORY_MAX_CHARS and, once the per-repo
+ *  row count exceeds MEMORY_MAX_ROWS, the least-recently-used rows are evicted
+ *  (LRU) so the store stays bounded. */
+export function addMemory(memory, repo, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const now = Math.floor(Date.now() / 1000);
+    const res = db
+        .prepare(`INSERT INTO memories(repo, kind, content, tags, created_at, last_recalled_at, category, target, source_turn)
+       VALUES(?, ?, ?, ?, ?, NULL, ?, ?, ?)`)
+        .run(repo ?? null, memory.kind ?? "note", capMemoryContent(memory.content), JSON.stringify(memory.tags ?? []), now, memory.category ?? null, memory.target ?? null, memory.sourceTurn ?? null);
+    try {
+        evictMemoryLru(repo, stateDir);
+    }
+    catch {
+        /* non-fatal: eviction must never fail an add */
+    }
+    return Number(res.lastInsertRowid);
+}
+/** List recent memories for a repo (or all repos when repo is null). */
+export function listMemories(repo, limit = 50, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const rows = repo
+        ? db.prepare("SELECT * FROM memories WHERE repo = ? ORDER BY created_at DESC LIMIT ?").all(repo, limit)
+        : db.prepare("SELECT * FROM memories ORDER BY created_at DESC LIMIT ?").all(limit);
+    return rows.map(mapMemoryRow);
+}
+/** Substring search across content + tags. */
+export function searchMemories(query, repo = null, limit = 50, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const like = `%${query}%`;
+    const rows = repo
+        ? db.prepare("SELECT * FROM memories WHERE repo = ? AND (content LIKE ? OR tags LIKE ?) ORDER BY created_at DESC LIMIT ?").all(repo, like, like, limit)
+        : db.prepare("SELECT * FROM memories WHERE content LIKE ? OR tags LIKE ? ORDER BY created_at DESC LIMIT ?").all(like, like, limit);
+    return rows.map(mapMemoryRow);
+}
+/** Mark a memory as recalled (updates last_recalled_at). Returns true if found. */
+export function recallMemory(id, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const now = Math.floor(Date.now() / 1000);
+    const res = db.prepare("UPDATE memories SET last_recalled_at = ? WHERE id = ?").run(now, id);
+    return res.changes > 0;
+}
+/** Mark a memory as referenced (updates last_referenced). Returns true if found. */
+export function referenceMemory(id, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const now = Math.floor(Date.now() / 1000);
+    const res = db.prepare("UPDATE memories SET last_referenced = ? WHERE id = ?").run(now, id);
+    return res.changes > 0;
+}
+/** Replace a memory's mutable fields by id. Returns true if a row was updated. */
+export function replaceMemory(id, patch, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const res = db
+        .prepare(`UPDATE memories
+       SET kind = COALESCE(?, kind),
+           content = COALESCE(?, content),
+           tags = COALESCE(?, tags),
+           category = COALESCE(?, category),
+           target = COALESCE(?, target),
+           source_turn = COALESCE(?, source_turn)
+       WHERE id = ?`)
+        .run(patch.kind ?? null, patch.content != null ? capMemoryContent(patch.content) : null, patch.tags ? JSON.stringify(patch.tags) : null, "category" in patch ? (patch.category ?? null) : null, "target" in patch ? (patch.target ?? null) : null, "sourceTurn" in patch ? (patch.sourceTurn ?? null) : null, id);
+    return res.changes > 0;
+}
+/** Remove a memory by id. Returns true if a row was deleted. */
+export function removeMemory(id, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const res = db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+    return res.changes > 0;
+}
+/** Look up a single memory by id (or undefined). */
+export function getMemory(id, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const row = db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+    return row ? mapMemoryRow(row) : undefined;
+}
+function mapMemoryRow(row) {
+    return {
+        id: row.id,
+        repo: row.repo ?? null,
+        kind: row.kind ?? "note",
+        content: row.content ?? "",
+        tags: row.tags ? JSON.parse(row.tags) : [],
+        createdAt: row.created_at ?? 0,
+        lastRecalledAt: row.last_recalled_at ?? null,
+        category: row.category ?? null,
+        target: row.target ?? null,
+        lastReferenced: row.last_referenced ?? null,
+        sourceTurn: row.source_turn ?? null,
+    };
+}

package/dist/src/store/sqlite/memory.js

@@ -0,0 +1,54 @@
+/**
+ * Durable "save to memory" store (taken over from memory extensions).
+ *
+ * One SQLite store for user-saved memories, scoped by repo. Mirrors the
+ * lessons/sessions pattern: all state lives in SQLite from day one. All queries
+ * are parameterized (PREVENT-002).
+ */
+import { getStateDir } from "../../store.js";
+import { openStore } from "./connection.js";
+/** Save a memory to the current repo's store. Returns the new row id. */
+export function addMemory(memory, repo, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const now = Math.floor(Date.now() / 1000);
+    const res = db
+        .prepare(`INSERT INTO memories(repo, kind, content, tags, created_at, last_recalled_at)
+       VALUES(?, ?, ?, ?, ?, NULL)`)
+        .run(repo ?? null, memory.kind ?? "note", memory.content, JSON.stringify(memory.tags ?? []), now);
+    return Number(res.lastInsertRowid);
+}
+/** List recent memories for a repo (or all repos when repo is null). */
+export function listMemories(repo, limit = 50, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const rows = repo
+        ? db.prepare("SELECT * FROM memories WHERE repo = ? ORDER BY created_at DESC LIMIT ?").all(repo, limit)
+        : db.prepare("SELECT * FROM memories ORDER BY created_at DESC LIMIT ?").all(limit);
+    return rows.map(mapMemoryRow);
+}
+/** Substring search across content + tags. */
+export function searchMemories(query, repo = null, limit = 50, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const like = `%${query}%`;
+    const rows = repo
+        ? db.prepare("SELECT * FROM memories WHERE repo = ? AND (content LIKE ? OR tags LIKE ?) ORDER BY created_at DESC LIMIT ?").all(repo, like, like, limit)
+        : db.prepare("SELECT * FROM memories WHERE content LIKE ? OR tags LIKE ? ORDER BY created_at DESC LIMIT ?").all(like, like, limit);
+    return rows.map(mapMemoryRow);
+}
+/** Mark a memory as recalled (updates last_recalled_at). Returns true if found. */
+export function recallMemory(id, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const now = Math.floor(Date.now() / 1000);
+    const res = db.prepare("UPDATE memories SET last_recalled_at = ? WHERE id = ?").run(now, id);
+    return res.changes > 0;
+}
+function mapMemoryRow(row) {
+    return {
+        id: row.id,
+        repo: row.repo ?? null,
+        kind: row.kind ?? "note",
+        content: row.content ?? "",
+        tags: row.tags ? JSON.parse(row.tags) : [],
+        createdAt: row.created_at ?? 0,
+        lastRecalledAt: row.last_recalled_at ?? null,
+    };
+}

package/dist/src/store/sqlite/meta.js

@@ -0,0 +1,82 @@
+/**
+ * meta.ts — `meta` table key/value helpers + cumulative counters
+ * (tokens_saved, dedup stats, compact count, recall injected, cache-hit tokens).
+ */
+import { getStateDir } from "../../store.js";
+import { openStore } from "./utils.js";
+/** Read a string-valued meta key (or undefined). Used for cumulative counters. */
+export function getMeta(key, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const row = db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value;
+}
+/**
+ * Cumulative "tokens saved" — the sum of stored checkpoint token estimates across
+ * all compactions in this store (one per repo). Persisted in the SQLite `meta`
+ * table so it survives session restarts and travels with the repo's state dir,
+ * mirroring how `storageDedupRate` is cumulative. Incremented in VectorStore.add()
+ * when a new (non-deduped) checkpoint is persisted.
+ */
+export function getTokensSaved(stateDir = getStateDir()) {
+    const raw = getMeta("tokens_saved", stateDir);
+    const n = raw == null ? 0 : Number(raw);
+    return Number.isFinite(n) ? n : 0;
+}
+/** Add `delta` (>=0) to the cumulative tokens-saved counter. */
+export function addTokensSaved(delta, stateDir = getStateDir()) {
+    if (!(delta > 0))
+        return;
+    const db = openStore(stateDir);
+    db.prepare(`INSERT INTO meta(key, value) VALUES('tokens_saved', ?)
+     ON CONFLICT(key) DO UPDATE SET value = CAST(CAST(value AS INTEGER) + ? AS TEXT)`).run(String(delta), delta);
+}
+/** Read a store-wide integer counter from the meta table (0 if absent). */
+export function getMetaNumber(key, stateDir = getStateDir()) {
+    const raw = getMeta(key, stateDir);
+    const n = raw == null ? 0 : Number(raw);
+    return Number.isFinite(n) ? n : 0;
+}
+/** Atomically add `delta` to an integer meta counter. */
+function incMeta(key, delta, stateDir = getStateDir()) {
+    if (!(delta > 0))
+        return;
+    const db = openStore(stateDir);
+    db.prepare(`INSERT INTO meta(key, value) VALUES(?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = CAST(CAST(value AS INTEGER) + ? AS TEXT)`).run(key, String(delta), delta);
+}
+/** Read the cumulative store-wide dedup counters. */
+export function getDedupStats(stateDir = getStateDir()) {
+    return {
+        attempts: getMetaNumber("dedup_attempts", stateDir),
+        deduped: getMetaNumber("deduped", stateDir),
+    };
+}
+/** Increment the store-wide dedup counters for one add() call. */
+export function bumpDedupStats(deduped, stateDir = getStateDir()) {
+    incMeta("dedup_attempts", 1, stateDir);
+    if (deduped)
+        incMeta("deduped", 1, stateDir);
+}
+// --- Live dashboard counters (schemaless meta key/value — NO migration) -----
+// These reuse the private `incMeta` atomically-incrementing integer counter so
+// all cumulative tallies live in the same `meta` table as tokens_saved etc.
+export function incCompactCount(stateDir = getStateDir()) {
+    incMeta("compact_count", 1, stateDir);
+}
+export function getCompactCount(stateDir = getStateDir()) {
+    return getMetaNumber("compact_count", stateDir);
+}
+export function incRecallInjected(n, stateDir = getStateDir()) {
+    if (n > 0)
+        incMeta("recall_injected", n, stateDir);
+}
+export function getRecallInjected(stateDir = getStateDir()) {
+    return getMetaNumber("recall_injected", stateDir);
+}
+export function incCacheHitTokens(delta, stateDir = getStateDir()) {
+    if (delta > 0)
+        incMeta("cache_hit_tokens_saved", delta, stateDir);
+}
+export function getCacheHitTokensSaved(stateDir = getStateDir()) {
+    return getMetaNumber("cache_hit_tokens_saved", stateDir);
+}

package/dist/src/store/sqlite/minhash-lsh.js

@@ -0,0 +1,47 @@
+/**
+ * Sprint 11: MinHash signatures + LSH bucket persistence and candidate lookup.
+ *
+ * All queries are parameterized (PREVENT-002) — never string-concatenated.
+ */
+import { getStateDir, normalizeSessionId } from "../../store.js";
+import { openStore } from "./connection.js";
+import { withTx } from "./transaction.js";
+/** Persist a checkpoint's MinHash signature (idempotent by chunk_id + version). */
+export function upsertMinhashSignature(chunkId, sessionId, signatureVersion, signatures, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const sid = normalizeSessionId(sessionId);
+    db.prepare(`INSERT INTO minhash_signatures(chunk_id, session_id, signature_version, signatures)
+     VALUES(?, ?, ?, ?)
+     ON CONFLICT(chunk_id, signature_version) DO UPDATE SET
+       session_id=excluded.session_id, signatures=excluded.signatures`).run(chunkId, sid, signatureVersion, JSON.stringify(signatures));
+}
+/** Persist LSH bucket memberships for a chunk (one row per bucket key). */
+export function insertLshBuckets(chunkId, sessionId, signatureVersion, bucketKeys, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const sid = normalizeSessionId(sessionId);
+    const del = db.prepare("DELETE FROM dedup_lsh_buckets WHERE chunk_id = ?");
+    const ins = db.prepare("INSERT OR IGNORE INTO dedup_lsh_buckets(bucket_key, chunk_id, session_id, signature_version) VALUES(?, ?, ?, ?)");
+    withTx(db, () => {
+        del.run(chunkId);
+        for (const key of bucketKeys)
+            ins.run(key, chunkId, sid, signatureVersion);
+    });
+}
+/**
+ * Candidate chunk_ids sharing any LSH bucket with `bucketKeys`, scoped to the
+ * session, capped at `limit`. Single query (no N loops) — QA #15 amplification
+ * guard. Returns DISTINCT chunk_ids excluding `excludeChunkId` (the new row).
+ */
+export function lshCandidateChunks(bucketKeys, sessionId, excludeChunkId, stateDir = getStateDir(), limit = 100) {
+    if (bucketKeys.length === 0)
+        return [];
+    const db = openStore(stateDir);
+    const sid = normalizeSessionId(sessionId);
+    const placeholders = bucketKeys.map(() => "?").join(",");
+    const rows = db
+        .prepare(`SELECT DISTINCT chunk_id FROM dedup_lsh_buckets
+       WHERE bucket_key IN (${placeholders}) AND session_id = ? AND chunk_id != ?
+       LIMIT ?`)
+        .all(...bucketKeys, sid, excludeChunkId, limit);
+    return rows.map((r) => r.chunk_id);
+}

package/dist/src/store/sqlite/model-snapshots.js

@@ -0,0 +1,47 @@
+/**
+ * model-snapshots.ts — `model_snapshots` table (active model/provider per repo).
+ */
+import { getStateDir } from "../../store.js";
+import { openStore } from "./utils.js";
+/** Persist the active model/provider for a repo (latest row wins per repo). */
+export function recordModelSnapshot(repoRoot, snap, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    db.prepare(`INSERT INTO model_snapshots
+       (repo_root, provider, provider_name, model_id, model_name, input_rate,
+        output_rate, context_window, max_tokens, reasoning, captured_at)
+     VALUES (@repo_root, @provider, @provider_name, @model_id, @model_name,
+             @input_rate, @output_rate, @context_window, @max_tokens, @reasoning, @captured_at)`).run({
+        repo_root: repoRoot,
+        provider: snap.provider,
+        provider_name: snap.providerName,
+        model_id: snap.modelId,
+        model_name: snap.modelName,
+        input_rate: snap.inputRate,
+        output_rate: snap.outputRate,
+        context_window: snap.contextWindow,
+        max_tokens: snap.maxTokens,
+        reasoning: snap.reasoning ? 1 : 0,
+        captured_at: Date.now(),
+    });
+}
+/** Most recent model/provider snapshot for a repo, or undefined. */
+export function latestModelSnapshot(stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const row = db
+        .prepare(`SELECT * FROM model_snapshots ORDER BY captured_at DESC LIMIT 1`)
+        .get();
+    if (!row)
+        return undefined;
+    return {
+        provider: row.provider,
+        providerName: row.provider_name,
+        modelId: row.model_id,
+        modelName: row.model_name,
+        inputRate: row.input_rate,
+        outputRate: row.output_rate,
+        contextWindow: row.context_window,
+        maxTokens: row.max_tokens,
+        reasoning: row.reasoning === 1,
+        capturedAt: row.captured_at,
+    };
+}