pi-mega-compact 0.7.7 → 0.7.9

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

@@ -0,0 +1,145 @@
+import { getStateDir, normalizeSessionId } from "../../store.js";
+import { openStore, withTx, jsonText, encodeEmbedding, rowToCheckpoint, } from "./utils.js";
+/** Insert or replace a checkpoint (idempotent by id). */
+export function upsertCheckpoint(cp, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const sid = normalizeSessionId(cp.sessionId);
+    withTx(db, () => {
+        db.prepare(`INSERT INTO context_chunks
+        (id, session_id, region_hash, content_hash, content_hash2, content_hash_version,
+         normalized_text, summary, topic_summary, summary_hash,
+         key_decisions, next_steps, files_modified, embedding_blob,
+         token_estimate, original_token_estimate, timestamp, dedup_status, compressed_original)
+       VALUES (@id, @sid, @region_hash, @content_hash, @content_hash2, @content_hash_version,
+               @normalized_text, @summary, @topic_summary, @summary_hash,
+               @key_decisions, @next_steps, @files_modified, @embedding_blob,
+               @token_estimate, @original_token_estimate, @timestamp, @dedup_status, @compressed_original)
+       ON CONFLICT(session_id, id) DO UPDATE SET
+         summary=excluded.summary,
+         topic_summary=excluded.topic_summary,
+         summary_hash=excluded.summary_hash,
+         key_decisions=excluded.key_decisions,
+         next_steps=excluded.next_steps,
+         files_modified=excluded.files_modified,
+         embedding_blob=excluded.embedding_blob,
+         token_estimate=excluded.token_estimate,
+         original_token_estimate=excluded.original_token_estimate,
+         timestamp=excluded.timestamp,
+         dedup_status=excluded.dedup_status,
+         compressed_original=excluded.compressed_original`).run({
+            "@id": cp.checkpointId,
+            "@sid": sid,
+            "@region_hash": cp.regionHash ?? null,
+            "@content_hash": cp.contentHash ?? null,
+            "@content_hash2": cp.contentHash2 ?? null,
+            "@content_hash_version": cp.contentHashVersion ?? null,
+            "@normalized_text": cp.normalizedText ?? null,
+            "@summary": cp.summary ?? "",
+            "@topic_summary": cp.topicSummary ?? null,
+            "@summary_hash": cp.summaryHash ?? null,
+            "@key_decisions": jsonText(cp.keyDecisions),
+            "@next_steps": jsonText(cp.nextSteps),
+            "@files_modified": jsonText(cp.filesModified),
+            "@embedding_blob": encodeEmbedding(cp.embedding ?? []),
+            "@token_estimate": cp.tokenEstimate ?? 0,
+            "@original_token_estimate": cp.originalTokenEstimate ?? null,
+            "@timestamp": cp.timestamp ?? 0,
+            "@dedup_status": "active",
+            "@compressed_original": cp.compressedOriginal ?? null,
+        });
+        // FTS5 virtual tables don't support UPSERT — delete any prior row, reinsert.
+        // Store normalized_text (the L1 verify key); fall back to summary for rows
+        // that predate normalized_text population.
+        db.prepare("DELETE FROM context_chunks_trgm WHERE id = ?").run(cp.checkpointId);
+        db.prepare("INSERT INTO context_chunks_trgm(id, normalized_text) VALUES(?, ?)").run(cp.checkpointId, cp.normalizedText ?? cp.summary ?? "");
+    });
+}
+// --- Sprint 11: MinHash signatures + LSH buckets --------------------------
+/** 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);
+}
+/** All checkpoints for a session, sorted by id. */
+export function listCheckpoints(sessionId, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const sid = normalizeSessionId(sessionId);
+    const rows = db
+        .prepare("SELECT * FROM context_chunks WHERE session_id = ? ORDER BY id ASC")
+        .all(sid);
+    return rows.map(rowToCheckpoint);
+}
+/** S25: the newest checkpoint timestamp for a session, or 0 when none. Used by
+ *  the RAPTOR freshness guard to reject a tree older than the live checkpoints. */
+export function maxCheckpointTimestamp(sessionId, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const row = db
+        .prepare("SELECT MAX(timestamp) AS mx FROM context_chunks WHERE session_id = ?")
+        .get(normalizeSessionId(sessionId));
+    return Number(row?.mx ?? 0);
+}
+/** Next sequential checkpoint id (chkpt_001 …) for a session. */
+export function nextCheckpointId(sessionId, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const sid = normalizeSessionId(sessionId);
+    const row = db
+        .prepare("SELECT MAX(CAST(SUBSTR(id, 7) AS INTEGER)) AS n FROM context_chunks WHERE session_id = ?")
+        .get(sid);
+    const next = (row.n ?? 0) + 1;
+    return `chkpt_${String(next).padStart(3, "0")}`;
+}
+/** True if a checkpoint id already exists for a session. */
+export function hasCheckpoint(sessionId, checkpointId, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const row = db
+        .prepare("SELECT 1 FROM context_chunks WHERE session_id = ? AND id = ? LIMIT 1")
+        .get(normalizeSessionId(sessionId), checkpointId);
+    return row !== undefined;
+}
+/** Fetch a single checkpoint by (session, id), or undefined if absent. */
+export function getCheckpoint(sessionId, checkpointId, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const row = db
+        .prepare("SELECT * FROM context_chunks WHERE session_id = ? AND id = ? LIMIT 1")
+        .get(normalizeSessionId(sessionId), checkpointId);
+    return row ? rowToCheckpoint(row) : undefined;
+}
+/** Mark a checkpoint's dedup_status (e.g. 'removed' by SemDeDup). */
+export function setDedupStatus(checkpointId, sessionId, status, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    db.prepare("UPDATE context_chunks SET dedup_status = ? WHERE id = ? AND session_id = ?").run(status, checkpointId, normalizeSessionId(sessionId));
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Per-repo SQLite connection management (open / reuse / close).
+ *
+ * In-process cache so the same stateDir reuses one connection (and so a fresh
+ * VectorStore over the same dir shares the open DB). Cross-process durability
+ * comes from reopening the same file path — proven by the integration test.
+ */
+import { DatabaseSync } from "node:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getStateDir } from "../../store.js";
+import { initSchema } from "./schema.js";
+const cache = new Map();
+/** Open (or reuse) the SQLite store for a state dir. */
+export function openStore(stateDir = getStateDir()) {
+    const existing = cache.get(stateDir);
+    if (existing)
+        return existing;
+    if (!existsSync(stateDir))
+        mkdirSync(stateDir, { recursive: true });
+    const db = new DatabaseSync(join(stateDir, "sqlite.db"));
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    initSchema(db);
+    cache.set(stateDir, db);
+    return db;
+}
+/** Close and evict a cached connection (test teardown only). */
+export function closeStore(stateDir) {
+    const db = cache.get(stateDir);
+    if (db) {
+        db.close();
+        cache.delete(stateDir);
+    }
+}

package/dist/src/store/sqlite/dedup-mirror.js

@@ -0,0 +1,64 @@
+/**
+ * Upsert a row into dedup_mirror. If the hash already exists, increment ref_count.
+ * Returns true if this was a NEW unique content (first insert), false if it was a duplicate.
+ */
+export function upsertDedupMirror(db, contentHash, contentBytes, seq) {
+    const now = Date.now();
+    const existing = db
+        .prepare(`SELECT content_hash FROM dedup_mirror WHERE content_hash = @hash`)
+        .get({ "@hash": contentHash });
+    if (existing) {
+        db.prepare(`UPDATE dedup_mirror SET ref_count = ref_count + 1 WHERE content_hash = @hash`).run({
+            "@hash": contentHash,
+        });
+        return false;
+    }
+    db.prepare(`INSERT INTO dedup_mirror (content_hash, content_bytes, ref_count, first_seen_seq, created_at)
+     VALUES (@hash, @bytes, 1, @seq, @now)`).run({
+        "@hash": contentHash,
+        "@bytes": contentBytes,
+        "@seq": seq,
+        "@now": now,
+    });
+    return true;
+}
+/**
+ * Get dedup ratio for a session: total bytes vs unique bytes.
+ */
+export function getDedupRatio(db, sessionId) {
+    const totalRow = db
+        .prepare(`SELECT COALESCE(SUM(LENGTH(content_bytes)), 0) AS total
+       FROM raw_transcript
+       WHERE session_id = @session_id`)
+        .get({ "@session_id": sessionId });
+    const uniqueRow = db
+        .prepare(`SELECT COALESCE(SUM(LENGTH(content_bytes)), 0) AS unique_bytes
+       FROM dedup_mirror`)
+        .get();
+    const totalBytes = totalRow.total;
+    const uniqueBytes = uniqueRow.unique_bytes;
+    const ratio = uniqueBytes > 0 ? totalBytes / uniqueBytes : 1;
+    return { totalBytes, uniqueBytes, ratio };
+}
+/**
+ * Get dedup mirror stats (diagnostic / test helper).
+ */
+export function getDedupMirrorStats(db) {
+    const row = db
+        .prepare(`SELECT COUNT(*) AS cnt,
+              COALESCE(SUM(LENGTH(content_bytes)), 0) AS total_bytes,
+              COALESCE(AVG(ref_count), 0) AS avg_ref
+       FROM dedup_mirror`)
+        .get();
+    return { rowCount: row.cnt, totalBytes: row.total_bytes, avgRefCount: row.avg_ref };
+}
+/**
+ * Update raw_transcript.content_ref to point to dedup_mirror.
+ */
+export function updateRawTranscriptRef(db, sessionId, seq, contentHash) {
+    db.prepare(`UPDATE raw_transcript SET content_ref = @ref WHERE session_id = @sid AND seq = @seq`).run({
+        "@ref": contentHash,
+        "@sid": sessionId,
+        "@seq": seq,
+    });
+}

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

@@ -0,0 +1,38 @@
+/**
+ * foundation.ts — future-feature foundation (resume sessions / daily log / lessons).
+ *
+ * Scaffolded tables + minimal helpers so all store data lives in SQLite from
+ * day one. Full UI/recall for these lands in later sprints.
+ */
+import { getStateDir, normalizeSessionId } from "../../store.js";
+import { openStore } from "./utils.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);
+}

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

@@ -0,0 +1,224 @@
+/**
+ * global-index.ts — machine-wide index DB (repo registry + injected-set).
+ *
+ * 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);
+    -- S18: machine-wide injected-set. A foreign checkpoint injected in repo A is
+    -- recorded here so repo B's recall never re-injects it. Keyed by checkpoint
+    -- + session (a checkpoint may be injected once per session); repo_id is the
+    -- source repo (the foreign repo's stateDir) for tracking/source labels.
+    -- PRAMETERIZED queries (PREVENT-002); local node:sqlite (PREVENT-PI-004).
+    CREATE TABLE IF NOT EXISTS injected_global (
+      checkpoint_id TEXT NOT NULL,
+      repo_id       TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      injected_at   INTEGER NOT NULL,
+      PRIMARY KEY (checkpoint_id, session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_injected_global_cid ON injected_global(checkpoint_id);
+  `);
+    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,
+        provider, provider_name, model_name, input_rate, output_rate, model_captured_at)
+     VALUES (@repo_root, @display_name, @state_dir, @first_seen, @last_seen, @last_compacted_at,
+             @checkpoint_count, @tokens_saved, @compressed_original_bytes,
+             @provider, @provider_name, @model_name, @input_rate, @output_rate, @model_captured_at)
+     ON CONFLICT(repo_root) DO UPDATE SET
+       display_name = excluded.display_name,
+       state_dir = excluded.state_dir,
+       last_seen = COALESCE(excluded.last_seen, @now),
+       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,
+       provider = COALESCE(excluded.provider, repo_registry.provider),
+       provider_name = COALESCE(excluded.provider_name, repo_registry.provider_name),
+       model_name = COALESCE(excluded.model_name, repo_registry.model_name),
+       input_rate = COALESCE(excluded.input_rate, repo_registry.input_rate),
+       output_rate = COALESCE(excluded.output_rate, repo_registry.output_rate),
+       model_captured_at = COALESCE(excluded.model_captured_at, repo_registry.model_captured_at)`).run({
+        repo_root: row.repoRoot,
+        display_name: row.displayName,
+        state_dir: row.stateDir,
+        now,
+        first_seen: row.firstSeen ?? null,
+        last_seen: row.lastSeen ?? null,
+        last_compacted_at: row.lastCompactedAt ?? null,
+        checkpoint_count: row.checkpointCount,
+        tokens_saved: row.tokensSaved,
+        compressed_original_bytes: row.compressedOriginalBytes,
+        provider: row.provider ?? null,
+        provider_name: row.providerName ?? null,
+        model_name: row.modelName ?? null,
+        input_rate: row.inputRate ?? null,
+        output_rate: row.outputRate ?? null,
+        model_captured_at: row.modelCapturedAt ?? null,
+    });
+}
+/**
+ * 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;
+    }
+}
+// ---------------------------------------------------------------------------
+// S18: machine-wide injected-set (cross-repo dedup markers)
+//
+// A foreign checkpoint injected in repo A is recorded here so repo B's recall
+// never re-injects it (a stronger, machine-wide version of the per-session
+// injected-set in the local store). Keyed by (checkpoint_id, session_id); the
+// session_id here is the RECEIVING session, so the same foreign checkpoint can
+// be injected into different sessions but never twice into the same one.
+// PRAMETERIZED queries (PREVENT-002); local node:sqlite + WAL (PREVENT-PI-004),
+// multi-process safe.
+// ---------------------------------------------------------------------------
+/** Record that a (foreign) checkpoint was injected into `sessionId`. Idempotent. */
+export function markInjectedGlobal(checkpointId, repoId, sessionId, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    db.prepare("INSERT OR IGNORE INTO injected_global (checkpoint_id, repo_id, session_id, injected_at) VALUES ($cid, $rid, $sid, $ts)").run({ $cid: checkpointId, $rid: repoId, $sid: sessionId, $ts: Date.now() });
+}
+/** True when a checkpoint was already injected into `sessionId` (machine-wide). */
+export function wasInjectedGlobal(checkpointId, sessionId, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const row = db.prepare("SELECT 1 FROM injected_global WHERE checkpoint_id = $cid AND session_id = $sid LIMIT 1").get({ $cid: checkpointId, $sid: sessionId });
+    return row !== undefined;
+}
+/** Count of cross-repo injections recorded (for /mega-status stats). */
+export function countInjectedGlobal(indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const row = db.prepare("SELECT COUNT(*) AS n FROM injected_global").get();
+    return row?.n ?? 0;
+}

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;
+    }
+}