pi-mega-compact 0.8.16 → 0.8.18

package/dist/src/store/sqlite/global-index.js

@@ -12,7 +12,7 @@
  * infrequent idempotent upserts (ON CONFLICT). Fully local (PREVENT-PI-004).
  */
 import { DatabaseSync } from "node:sqlite";
-import { existsSync, mkdirSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 /** Resolve the machine-wide index directory (env-overridable). */
@@ -71,6 +71,31 @@ export function openIndexStore(indexDir = getIndexDir()) {
       PRIMARY KEY (checkpoint_id, session_id)
     );
     CREATE INDEX IF NOT EXISTS idx_injected_global_cid ON injected_global(checkpoint_id);
+    -- S39: machine-wide session heartbeats + token time-series for the live
+    -- multi-pi stacked-memory graph. One row per (pid, session_id), updated
+    -- on every material snapshot() change (NOT on idle/context-repeat events).
+    -- Written by every pi process; read by the dashboard server. WAL-safe.
+    -- PRAMETERIZED queries (PREVENT-002); local node:sqlite (PREVENT-PI-004).
+    CREATE TABLE IF NOT EXISTS session_heartbeats (
+      pid          INTEGER NOT NULL,
+      session_id   TEXT NOT NULL,
+      repo_root    TEXT,
+      state_dir    TEXT,
+      ctx_window   INTEGER DEFAULT 0,
+      last_seen    INTEGER NOT NULL,
+      PRIMARY KEY (pid, session_id)
+    );
+    CREATE TABLE IF NOT EXISTS token_samples (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id   TEXT NOT NULL,
+      repo_root    TEXT,
+      tokens       INTEGER NOT NULL,
+      percent      REAL NOT NULL,
+      ctx_window   INTEGER DEFAULT 0,
+      ts           INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_token_samples_ts ON token_samples(ts);
+    CREATE INDEX IF NOT EXISTS idx_token_samples_sid_ts ON token_samples(session_id, ts);
   `);
     indexCache = iddb;
     indexCacheDir = indexDir;
@@ -222,3 +247,176 @@ export function countInjectedGlobal(indexDir = getIndexDir()) {
     const row = db.prepare("SELECT COUNT(*) AS n FROM injected_global").get();
     return row?.n ?? 0;
 }
+/** Stable color palette for per-session series (hash-based, no randomness). */
+const SESSION_COLORS = [
+    "#60a5fa", // blue-400
+    "#34d399", // emerald-400
+    "#fbbf24", // amber-400
+    "#f87171", // red-400
+    "#a78bfa", // violet-400
+    "#f472b6", // pink-400
+    "#22d3ee", // cyan-400
+    "#a3e635", // lime-400
+];
+/** Hash a sessionId to a stable color index. */
+function sessionColor(sessionId) {
+    let h = 0;
+    for (let i = 0; i < sessionId.length; i++) {
+        h = (h * 31 + sessionId.charCodeAt(i)) | 0;
+    }
+    return SESSION_COLORS[Math.abs(h) % SESSION_COLORS.length];
+}
+/**
+ * Record (upsert) a session heartbeat. Called from snapshot() on every material
+ * change. PRIMARY KEY (pid, session_id) means concurrent pi processes each get
+ * their own row. Non-fatal on conflict (INSERT ... ON CONFLICT DO UPDATE).
+ */
+export function recordSessionHeartbeat(pid, sessionId, repoRoot, stateDir, ctxWindow, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const now = Date.now();
+    db.prepare(`INSERT INTO session_heartbeats (pid, session_id, repo_root, state_dir, ctx_window, last_seen)
+     VALUES (@pid, @session_id, @repo_root, @state_dir, @ctx_window, @last_seen)
+     ON CONFLICT(pid, session_id) DO UPDATE SET
+       repo_root = excluded.repo_root,
+       state_dir = excluded.state_dir,
+       ctx_window = excluded.ctx_window,
+       last_seen = excluded.last_seen`).run({
+        pid,
+        session_id: sessionId,
+        repo_root: repoRoot,
+        state_dir: stateDir,
+        ctx_window: ctxWindow,
+        last_seen: now,
+    });
+}
+/**
+ * Append a token sample row + optionally a session_sample line to events.log
+ * (for SSE real-time push via /api/events). The eventsLogPath is optional —
+ * callers without an events.log (e.g. tests) can omit it.
+ */
+export function appendTokenSample(sessionId, repoRoot, tokens, percent, ctxWindow, eventsLogPath, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const now = Date.now();
+    db.prepare(`INSERT INTO token_samples (session_id, repo_root, tokens, percent, ctx_window, ts)
+     VALUES (@session_id, @repo_root, @tokens, @percent, @ctx_window, @ts)`).run({
+        session_id: sessionId,
+        repo_root: repoRoot,
+        tokens,
+        percent,
+        ctx_window: ctxWindow,
+        ts: now,
+    });
+    // Step 5: also append a session_sample JSON line to events.log so the
+    // existing /api/events SSE tail streams it for free (real-time chart push).
+    // Mirrors the DashboardEmitter events.log append pattern in
+    // extensions/mega-dashboard.ts:{ event(type, data) }: a JSON object with
+    // `ts` (ISO 8601 string), `type`, and the event-specific payload. The ISO
+    // timestamp matches the shape of every other SSE variant (SseSessionSample
+    // contract; every SSE variant's `ts` is a string); a numeric ms `ts` would
+    // violate the contract union's "every SSE variant has a ts field of type
+    // string" invariant and break DashboardEmitter consumers.
+    if (eventsLogPath) {
+        try {
+            const dir = eventsLogPath.includes("/") ? eventsLogPath.slice(0, eventsLogPath.lastIndexOf("/")) : ".";
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            appendFileSync(eventsLogPath, JSON.stringify({
+                ts: new Date(now).toISOString(),
+                type: "session_sample",
+                sessionId,
+                tokens,
+                percent,
+            }) + "\n");
+        }
+        catch {
+            /* non-fatal: SSE push is best-effort */
+        }
+    }
+}
+/**
+ * Prune stale session heartbeats (sessions not seen within maxAgeMs).
+ * Default 30-min retention. Called by /api/sessions.
+ */
+export function pruneStaleSessions(maxAgeMs = 1_800_000, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const cutoff = Date.now() - maxAgeMs;
+    const result = db.prepare("DELETE FROM session_heartbeats WHERE last_seen < @cutoff").run({ cutoff });
+    return Number(result.changes);
+}
+/**
+ * Prune old token samples older than maxAgeMs. Default 30-min retention.
+ * Called by /api/sessions/timeseries.
+ */
+export function pruneTokenSamples(maxAgeMs = 1_800_000, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const cutoff = Date.now() - maxAgeMs;
+    const result = db.prepare("DELETE FROM token_samples WHERE ts < @cutoff").run({ cutoff });
+    return Number(result.changes);
+}
+/**
+ * Read all active sessions with their latest token sample (if any).
+ * JOINs session_heartbeats with the latest token_samples per session_id
+ * via a correlated subquery. Returns rows sorted by last_seen descending.
+ */
+export function readActiveSessions(indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const rows = db.prepare(`SELECT h.pid, h.session_id, h.repo_root, h.state_dir, h.ctx_window, h.last_seen,
+            s.tokens, s.percent
+     FROM session_heartbeats h
+     LEFT JOIN token_samples s ON s.id = (
+       SELECT id FROM token_samples t
+       WHERE t.session_id = h.session_id
+       ORDER BY t.ts DESC LIMIT 1
+     )
+     ORDER BY h.last_seen DESC`).all();
+    return rows.map((r) => ({
+        pid: r.pid,
+        sessionId: r.session_id,
+        repoRoot: r.repo_root,
+        stateDir: r.state_dir,
+        ctxWindow: r.ctx_window ?? 0,
+        lastSeen: r.last_seen,
+        tokens: r.tokens,
+        percent: r.percent,
+    }));
+}
+/**
+ * Read token samples since sinceMs, returning a recharts-ready stacked shape:
+ * per-session `SessionSeries` (with stable color) + a `totals` array
+ * [{ts, tokens}] (sum of all sessions at each timestamp).
+ */
+export function readSessionTimeseries(sinceMs, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const rows = db.prepare(`SELECT session_id, tokens, percent, ts FROM token_samples WHERE ts >= @since ORDER BY ts ASC`).all({ since: sinceMs });
+    // Group by session_id → series; + accumulate totals per timestamp.
+    const seriesMap = new Map();
+    const totalsMap = new Map();
+    for (const r of rows) {
+        let pts = seriesMap.get(r.session_id);
+        if (!pts) {
+            pts = [];
+            seriesMap.set(r.session_id, pts);
+        }
+        pts.push({ ts: r.ts, tokens: r.tokens, percent: r.percent });
+        totalsMap.set(r.ts, (totalsMap.get(r.ts) ?? 0) + r.tokens);
+    }
+    const series = [];
+    for (const [sessionId, data] of seriesMap) {
+        const label = sessionId.length > 12 ? sessionId.slice(0, 12) : sessionId;
+        series.push({ sessionId, label, color: sessionColor(sessionId), data });
+    }
+    // Sort series by first-timestamp for stable legend order.
+    series.sort((a, b) => (a.data[0]?.ts ?? 0) - (b.data[0]?.ts ?? 0));
+    const totals = Array.from(totalsMap.entries())
+        .sort((a, b) => a[0] - b[0])
+        .map(([ts, tokens]) => ({ ts, tokens }));
+    return { series, totals };
+}
+/**
+ * Clear a session's heartbeat row (e.g. on clean shutdown / session reset).
+ * Non-fatal: no-op if the row doesn't exist.
+ */
+export function clearSessionHeartbeat(pid, sessionId, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    db.prepare("DELETE FROM session_heartbeats WHERE pid = @pid AND session_id = @session_id").run({ pid, session_id: sessionId });
+}

package/dist/src/store/sqlite/global-index.test.js

@@ -0,0 +1,136 @@
+/**
+ * global-index.test.ts — S39 session heartbeats + token_samples round-trip.
+ *
+ * Verifies recordSessionHeartbeat + appendTokenSample + readActiveSessions +
+ * readSessionTimeseries + pruneStaleSessions + pruneTokenSamples +
+ * clearSessionHeartbeat, with particular focus on the Step 5 events.log
+ * session_sample JSONL line shape (the SSE real-time push wire format).
+ *
+ * Pi-agnostic. Uses an isolated mock index dir (never the real user
+ * `~/.mega-compact-index/` — guardrail G7). PREVENT-PI-004 (zero network):
+ * every operation is local SQLite + local FS append.
+ */
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { recordSessionHeartbeat, appendTokenSample, readActiveSessions, readSessionTimeseries, pruneStaleSessions, pruneTokenSamples, clearSessionHeartbeat, closeIndexStore, } from "./global-index.js";
+describe("global-index session time-series (S39)", () => {
+    let indexDir;
+    let eventsLogPath;
+    before(() => {
+        indexDir = mkdtempSync(join(tmpdir(), "mc-global-idx-"));
+        eventsLogPath = join(indexDir, "events.log");
+    });
+    after(() => {
+        closeIndexStore();
+        rmSync(indexDir, { recursive: true, force: true });
+    });
+    it("recordSessionHeartbeat + readActiveSessions: heartbeat row appears", () => {
+        recordSessionHeartbeat(12_345, "sess-abc-1", "/home/u/repos/proj-a", "/home/u/.pi/state-a", 200_000, indexDir);
+        const sessions = readActiveSessions(indexDir);
+        assert.equal(sessions.length, 1);
+        const s = sessions[0];
+        assert.equal(s.pid, 12_345);
+        assert.equal(s.sessionId, "sess-abc-1");
+        assert.equal(s.repoRoot, "/home/u/repos/proj-a");
+        assert.equal(s.stateDir, "/home/u/.pi/state-a");
+        assert.equal(s.ctxWindow, 200_000);
+        assert.ok(s.lastSeen > 0);
+        // No token sample yet → tokens/percent are null.
+        assert.equal(s.tokens, null);
+        assert.equal(s.percent, null);
+    });
+    it("appendTokenSample writes a token_samples row + a session_sample JSONL line", () => {
+        appendTokenSample("sess-abc-1", "/home/u/repos/proj-a", 42_000, 21.5, 200_000, eventsLogPath, indexDir);
+        // The token_samples row should now be the latest sample for this session.
+        const sessions = readActiveSessions(indexDir);
+        const s = sessions.find((x) => x.sessionId === "sess-abc-1");
+        assert.ok(s, "session must still appear in readActiveSessions");
+        assert.equal(s.tokens, 42_000);
+        assert.equal(s.percent, 21.5);
+        // The events.log JSONL line should exist and match the wire format
+        // described by the SseSessionSample contract: an object with `ts`
+        // (ISO 8601 string), `type: 'session_sample'`, and the payload fields.
+        assert.ok(existsSync(eventsLogPath), "events.log should exist");
+        const lines = readFileSync(eventsLogPath, "utf-8")
+            .trim()
+            .split("\n")
+            .filter(Boolean);
+        assert.equal(lines.length, 1, "exactly one JSONL line expected");
+        const parsed = JSON.parse(lines[0]);
+        assert.equal(parsed["type"], "session_sample");
+        assert.equal(parsed["sessionId"], "sess-abc-1");
+        assert.equal(parsed["tokens"], 42_000);
+        assert.equal(parsed["percent"], 21.5);
+        // Step 5 contract mirroring: `ts` is an ISO 8601 string (matches every
+        // other SseEvent variant's `ts: string` and the DashboardEmitter
+        // events.log pattern), NOT a numeric ms value.
+        assert.equal(typeof parsed["ts"], "string", "ts must be an ISO 8601 string (matches other SseEvent variants)");
+        // Must be ISO-parseable (NaN if invalid → typeof won't be number).
+        const tsMs = Date.parse(parsed["ts"]);
+        assert.ok(Number.isFinite(tsMs), "ts must be a valid ISO 8601 timestamp");
+        // And recent (within the last 5s).
+        assert.ok(Math.abs(Date.now() - tsMs) < 5_000, "ts must be within ~5s of now");
+    });
+    it("readSessionTimeseries returns per-session series + totals in chronological order", () => {
+        // Two sessions, two samples each — fully within the rolling window.
+        // sess-xyz-9 needs its own heartbeat row so readActiveSessions can later
+        // surface it (heartbeats are the primary key, not the samples).
+        recordSessionHeartbeat(67_890, "sess-xyz-9", "/home/u/repos/proj-b", "/home/u/.pi/state-b", 200_000, indexDir);
+        appendTokenSample("sess-abc-1", "/home/u/repos/proj-a", 50_000, 25, 200_000, null, // no events.log line for this assertion
+        indexDir);
+        appendTokenSample("sess-xyz-9", "/home/u/repos/proj-b", 10_000, 5, 200_000, null, indexDir);
+        appendTokenSample("sess-xyz-9", "/home/u/repos/proj-b", 30_000, 15, 200_000, null, indexDir);
+        const since = Date.now() - 60_000;
+        const result = readSessionTimeseries(since, indexDir);
+        const seriesIds = result.series.map((s) => s.sessionId).sort();
+        assert.deepEqual(seriesIds, ["sess-abc-1", "sess-xyz-9"]);
+        const xyz = result.series.find((s) => s.sessionId === "sess-xyz-9");
+        assert.ok(xyz, "sess-xyz-9 series must exist");
+        assert.equal(xyz.data.length, 2);
+        assert.equal(xyz.data[0].tokens, 10_000);
+        assert.equal(xyz.data[1].tokens, 30_000);
+        // Stable hash-based color from the SESSION_COLORS palette.
+        assert.match(xyz.color, /^#[0-9a-f]{6}$/i);
+        // Totals: each timestamp summed across sessions.
+        assert.ok(result.totals.length >= 2);
+        for (const t of result.totals) {
+            assert.ok(typeof t.ts === "number" && t.ts > 0);
+            assert.ok(typeof t.tokens === "number" && t.tokens >= 0);
+        }
+        // Totals are sorted ascending by ts.
+        for (let i = 1; i < result.totals.length; i++) {
+            assert.ok(result.totals[i].ts >= result.totals[i - 1].ts, "totals must be chronologically ascending");
+        }
+    });
+    it("pruneStaleSessions clears heartbeats older than the cutoff (and only those)", () => {
+        // At this point we have 2 sessions; both are fresh (lastSeen ≈ now).
+        const beforeCount = readActiveSessions(indexDir).length;
+        assert.equal(beforeCount, 2);
+        // With a 0 ms cutoff, both are stale → pruned.
+        const pruned = pruneStaleSessions(0, indexDir);
+        assert.equal(pruned, 2, "both heartbeats should be pruned");
+        assert.equal(readActiveSessions(indexDir).length, 0);
+    });
+    it("pruneTokenSamples clears token_samples older than the cutoff", () => {
+        // Re-seed two samples; the previously-written ones were for two
+        // sessions (sess-abc-1 + sess-xyz-9). The prunedStaleSessions call
+        // above left token_samples untouched (separate table).
+        const sinceBefore = Date.now() - 60_000;
+        const before = readSessionTimeseries(sinceBefore, indexDir);
+        const beforeCount = before.series.reduce((n, s) => n + s.data.length, 0);
+        assert.ok(beforeCount >= 3, "expected to find the seeded samples");
+        const npurged = pruneTokenSamples(0, indexDir);
+        assert.ok(npurged >= 3, "should have pruned the seeded samples");
+        const after = readSessionTimeseries(sinceBefore, indexDir);
+        const afterCount = after.series.reduce((n, s) => n + s.data.length, 0);
+        assert.equal(afterCount, 0, "no samples should remain after pruning");
+    });
+    it("clearSessionHeartbeat is a no-op on missing rows (never throws)", () => {
+        const before = readActiveSessions(indexDir).length;
+        assert.doesNotThrow(() => clearSessionHeartbeat(99_999, "nonexistent-session", indexDir));
+        assert.equal(readActiveSessions(indexDir).length, before);
+    });
+});

package/dist/src/store/sqlite/index-store.js

@@ -0,0 +1,167 @@
+/**
+ * Global machine-wide index store (Phase 5b).
+ *
+ * A single SQLite DB, separate from every per-repo store, that aggregates one
+ * row per repo this machine has run on. The multi-repo dashboard (Summary /
+ * All-repos tabs) reads it so ONE dashboard can show every repo's checkpoints,
+ * tokens saved, and active model — instead of a per-repo dashboard that only
+ * ever sees the repo it was launched from.
+ *
+ * Written by every pi process on repo-switch (bindRepo) + model capture; read by
+ * the dashboard server. Concurrency across 10+ pi processes is handled by WAL +
+ * infrequent idempotent upserts (ON CONFLICT). Fully local (PREVENT-PI-004).
+ */
+import { DatabaseSync } from "node:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+/** Resolve the machine-wide index directory (env-overridable). */
+export function getIndexDir() {
+    const override = process.env.MEGACOMPACT_INDEX_DIR;
+    if (override && override.trim() !== "")
+        return override;
+    // homedir() can throw in exotic sandboxes; fall back to tmpdir.
+    try {
+        return join(homedir(), ".mega-compact-index");
+    }
+    catch {
+        return join(tmpdir(), ".mega-compact-index");
+    }
+}
+let indexCache;
+let indexCacheDir;
+/** Open (or reuse) the machine-wide index DB. WAL for concurrent writers. */
+export function openIndexStore(indexDir = getIndexDir()) {
+    if (indexCache && indexCacheDir === indexDir)
+        return indexCache;
+    if (!existsSync(indexDir))
+        mkdirSync(indexDir, { recursive: true });
+    const iddb = new DatabaseSync(join(indexDir, "index.sqlite"));
+    iddb.exec("PRAGMA journal_mode = WAL");
+    iddb.exec("PRAGMA busy_timeout = 3000"); // tolerate brief cross-process write contention
+    iddb.exec(`
+    CREATE TABLE IF NOT EXISTS repo_registry (
+      repo_root                 TEXT PRIMARY KEY,
+      display_name              TEXT,
+      state_dir                 TEXT NOT NULL,
+      first_seen                INTEGER,
+      last_seen                 INTEGER,
+      last_compacted_at         INTEGER,
+      checkpoint_count          INTEGER DEFAULT 0,
+      tokens_saved              INTEGER DEFAULT 0,
+      compressed_original_bytes INTEGER DEFAULT 0,
+      provider                  TEXT,
+      provider_name             TEXT,
+      model_name                TEXT,
+      input_rate                REAL,
+      output_rate               REAL,
+      model_captured_at         INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_registry_last_seen ON repo_registry(last_seen DESC);
+  `);
+    indexCache = iddb;
+    indexCacheDir = indexDir;
+    return iddb;
+}
+/**
+ * Upsert a repo's aggregate stats into the global index. Called on repo-switch
+ * (infrequent). Preserves first_seen + the model columns on update (model is
+ * written separately by recordRepoModel so we never clobber it here with nulls).
+ */
+export function upsertRepoRegistry(row, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const now = Date.now();
+    db.prepare(`INSERT INTO repo_registry
+       (repo_root, display_name, state_dir, first_seen, last_seen, last_compacted_at,
+        checkpoint_count, tokens_saved, compressed_original_bytes)
+     VALUES (@repo_root, @display_name, @state_dir, @now, @now, @last_compacted_at,
+             @checkpoint_count, @tokens_saved, @compressed_original_bytes)
+     ON CONFLICT(repo_root) DO UPDATE SET
+       display_name = excluded.display_name,
+       state_dir = excluded.state_dir,
+       last_seen = excluded.last_seen,
+       last_compacted_at = COALESCE(excluded.last_compacted_at, repo_registry.last_compacted_at),
+       checkpoint_count = excluded.checkpoint_count,
+       tokens_saved = excluded.tokens_saved,
+       compressed_original_bytes = excluded.compressed_original_bytes`).run({
+        repo_root: row.repoRoot,
+        display_name: row.displayName,
+        state_dir: row.stateDir,
+        now,
+        last_compacted_at: row.lastCompactedAt ?? null,
+        checkpoint_count: row.checkpointCount,
+        tokens_saved: row.tokensSaved,
+        compressed_original_bytes: row.compressedOriginalBytes,
+    });
+}
+/**
+ * Record the active model/provider for a repo in the global index (denormalized
+ * so the All-repos table shows model without opening each repo's DB). Upserts a
+ * bare registry row if the repo isn't registered yet.
+ */
+export function recordRepoModel(repoRoot, model, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const now = Date.now();
+    db.prepare(`INSERT INTO repo_registry
+       (repo_root, display_name, state_dir, first_seen, last_seen,
+        provider, provider_name, model_name, input_rate, output_rate, model_captured_at)
+     VALUES (@repo_root, @display_name, @state_dir, @now, @now,
+             @provider, @provider_name, @model_name, @input_rate, @output_rate, @now)
+     ON CONFLICT(repo_root) DO UPDATE SET
+       last_seen = excluded.last_seen,
+       provider = excluded.provider,
+       provider_name = excluded.provider_name,
+       model_name = excluded.model_name,
+       input_rate = excluded.input_rate,
+       output_rate = excluded.output_rate,
+       model_captured_at = excluded.model_captured_at`).run({
+        repo_root: repoRoot,
+        display_name: model.displayName,
+        state_dir: model.stateDir,
+        now,
+        provider: model.provider,
+        provider_name: model.providerName,
+        model_name: model.modelName,
+        input_rate: model.inputRate,
+        output_rate: model.outputRate,
+    });
+}
+function mapRegistryRow(row) {
+    return {
+        repoRoot: row.repo_root,
+        displayName: row.display_name ?? "",
+        stateDir: row.state_dir,
+        firstSeen: row.first_seen ?? 0,
+        lastSeen: row.last_seen ?? 0,
+        lastCompactedAt: row.last_compacted_at ?? null,
+        checkpointCount: row.checkpoint_count ?? 0,
+        tokensSaved: row.tokens_saved ?? 0,
+        compressedOriginalBytes: row.compressed_original_bytes ?? 0,
+        provider: row.provider ?? null,
+        providerName: row.provider_name ?? null,
+        modelName: row.model_name ?? null,
+        inputRate: row.input_rate ?? null,
+        outputRate: row.output_rate ?? null,
+        modelCapturedAt: row.model_captured_at ?? null,
+    };
+}
+/** All registered repos, most-recently-seen first. */
+export function listRepoRegistry(indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const rows = db.prepare("SELECT * FROM repo_registry ORDER BY last_seen DESC").all();
+    return rows.map(mapRegistryRow);
+}
+/** A single repo's registry row, or undefined. */
+export function getRepoRegistry(repoRoot, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const row = db.prepare("SELECT * FROM repo_registry WHERE repo_root = ?").get(repoRoot);
+    return row ? mapRegistryRow(row) : undefined;
+}
+/** Close the cached index connection (test teardown only). */
+export function closeIndexStore() {
+    if (indexCache) {
+        indexCache.close();
+        indexCache = undefined;
+        indexCacheDir = undefined;
+    }
+}

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/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/sessions.js

@@ -0,0 +1,39 @@
+/**
+ * Future-feature foundation: resume sessions, daily activity log, lessons learned.
+ *
+ * Scaffolded tables + minimal helpers so all store data lives in SQLite from
+ * day one. Full UI/recall for these lands in later sprints. All queries are
+ * parameterized (PREVENT-002).
+ */
+import { getStateDir, normalizeSessionId } from "../../store.js";
+import { openStore } from "./connection.js";
+/** Upsert a `sessions` row (resume + per-repo session history). */
+export function touchSession(sessionId, repo, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const sid = normalizeSessionId(sessionId);
+    const existing = db
+        .prepare("SELECT started_at FROM sessions WHERE session_id = ?")
+        .get(sid);
+    const now = Math.floor(Date.now() / 1000);
+    if (!existing) {
+        db.prepare(`INSERT INTO sessions(session_id, repo, started_at, last_compacted_at, status)
+       VALUES(?, ?, ?, ?, 'active')`).run(sid, repo ?? null, now, now);
+    }
+    else {
+        db.prepare("UPDATE sessions SET last_compacted_at = ?, repo = COALESCE(?, repo), status = 'active' WHERE session_id = ?").run(now, repo ?? null, sid);
+    }
+}
+/** Append a `daily_log` entry (day = YYYY-MM-DD, local-naive from Date). */
+export function logDaily(sessionId, event, detail, tokensSaved, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const day = new Date().toISOString().slice(0, 10);
+    const now = Math.floor(Date.now() / 1000);
+    db.prepare(`INSERT INTO daily_log(day, session_id, event, detail, tokens_saved, ts)
+     VALUES(?, ?, ?, ?, ?, ?)`).run(day, normalizeSessionId(sessionId), event, detail ?? null, tokensSaved, now);
+}
+/** Append a `lessons` entry (future lessons-learned browse/recall). */
+export function addLesson(sessionId, repo, lesson, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const now = Math.floor(Date.now() / 1000);
+    db.prepare(`INSERT INTO lessons(session_id, repo, lesson, ts) VALUES(?, ?, ?, ?)`).run(normalizeSessionId(sessionId), repo ?? null, lesson, now);
+}