pi-mega-compact 0.4.28 → 0.5.0

package/dist/src/memoryRecall.test.js

@@ -0,0 +1,92 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { recallMemories } from "./memoryRecall.js";
+import { addMemory, getMemory } from "./store/sqlite.js";
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-memrec-"));
+function biGramEmbedder() {
+    // Deterministic test embedder — bigger dim + binary encoding so two semantically
+    // related strings have higher cosine than unrelated ones.
+    const dim = 64;
+    return {
+        dim,
+        embed(text) {
+            const v = new Array(dim).fill(0);
+            const norm = text.toLowerCase().replace(/[^a-z0-9 ]/g, "").trim();
+            for (let i = 0; i < norm.length - 1; i++) {
+                const idx = ((norm.charCodeAt(i) * 31 + norm.charCodeAt(i + 1)) >>> 0) % dim;
+                v[idx] = 1;
+            }
+            return v;
+        },
+    };
+}
+test("recallMemories: ranks relevant memory above unrelated", async () => {
+    const dir = join(baseTmp, "rank");
+    addMemory({ content: "we use sqlite for the durable store", category: "decision" }, null, dir);
+    addMemory({ content: "the threshold is 100 thousand tokens", category: "decision" }, null, dir);
+    addMemory({ content: "katz says hi", category: "note" }, null, dir);
+    const hits = await recallMemories("what store do we use?", dir, {
+        embedder: biGramEmbedder(),
+        topK: 3,
+        minSimilarity: 0.0,
+    });
+    assert.ok(hits.length >= 2, "finds relevant");
+    assert.ok(/sqlite/.test(hits[0].memory.content), "top hit is sqlite one");
+    assert.ok(!/katz/.test(hits[0].memory.content), "unrelated not on top");
+});
+test("recallMemories: marks referenced hits (last_referenced updated)", async () => {
+    const dir = join(baseTmp, "ref");
+    addMemory({ content: "policy is local-only", category: "rule" }, null, dir);
+    const hits = await recallMemories("local-only policy", dir, { embedder: biGramEmbedder() });
+    assert.ok(hits.length >= 1);
+    const fresh = getMemory(hits[0].memory.id, dir);
+    assert.ok(fresh && fresh.lastReferenced && fresh.lastReferenced > 0, "lastReferenced set");
+});
+test("recallMemories: empty store returns []", async () => {
+    const dir = join(baseTmp, "empty");
+    const hits = await recallMemories("anything", dir, { embedder: biGramEmbedder() });
+    assert.deepEqual(hits, []);
+});
+test("recallMemories: decision category beats fact category at equal similarity", async () => {
+    const dir = join(baseTmp, "category");
+    // Two memories that share many bigrams with the query — both will have very
+    // similar cosine. The decision category should win because of categoryWeight.
+    addMemory({ content: "we use redis for cache" }, null, dir);
+    const aId = addMemory({ content: "we use redis as primary cache key", category: "fact" }, null, dir);
+    const dId = addMemory({ content: "we use redis as primary cache layer", category: "decision" }, null, dir);
+    const hits = await recallMemories("redis cache layer", dir, {
+        embedder: biGramEmbedder(),
+        topK: 3,
+        minSimilarity: 0.0,
+    });
+    assert.ok(hits.length >= 2);
+    assert.equal(hits[0].memory.id, dId, "decision-tagged memory outranks fact-tagged");
+    assert.notEqual(hits[0].memory.id, aId, "top is the decision row, not the unknown-category row");
+});
+test("recallMemories: fresher reference beats older at equal similarity", async () => {
+    const dir = join(baseTmp, "recency");
+    const aId = addMemory({ content: "we use redis for cache", category: "fact" }, null, dir);
+    const bId = addMemory({ content: "we use redis for cache layer", category: "fact" }, null, dir);
+    // Backdate aId so its last_referenced is older; bId stays fresh.
+    const { openStore, closeStore } = await import("./store/sqlite.js");
+    const db = openStore(dir);
+    const longAgo = Math.floor(Date.now() / 1000) - 30 * 86_400; // 30d
+    db.prepare("UPDATE memories SET last_referenced = ? WHERE id = ?").run(longAgo, aId);
+    // closeStore evicts the cached handle — calling db.close() directly would
+    // leave a stale closed DB in the openStore cache and break subsequent
+    // callers (the "database is not open" failure under parallel runs).
+    closeStore(dir);
+    const hits = await recallMemories("redis cache layer", dir, {
+        embedder: biGramEmbedder(),
+        topK: 3,
+        minSimilarity: 0.0,
+    });
+    assert.ok(hits.length >= 2);
+    assert.equal(hits[0].memory.id, bId, "freshly-referenced memory outranks 30-day-old one");
+});
+test("cleanup memrec", () => {
+    rmSync(baseTmp, { recursive: true, force: true });
+});

package/dist/src/recall.js

@@ -22,7 +22,11 @@ export function formatRecallBlock(hits) {
         return "";
     const parts = hits.map((h, i) => {
         const score = (h.score * 100).toFixed(0);
-        return (`### Recalled context [${i + 1}] (relevance ${score}%)\n` +
+        // S17: label a cross-repo hit with its source repo (the repoId doubles as
+        // that repo's stateDir, so the last path segment is the repo's display
+        // name). Same-repo hits (no repoId) stay unlabeled.
+        const repoName = h.repoId ? ` (from repo ${h.repoId.split("/").filter(Boolean).pop() ?? h.repoId})` : "";
+        return (`### Recalled context [${i + 1}] (relevance ${score}%)${repoName}\n` +
             `${h.checkpoint.summary.trim()}\n` +
             (h.checkpoint.filesModified.length
                 ? `Key files: ${h.checkpoint.filesModified.join(", ")}.\n`
@@ -84,6 +88,47 @@ export function recallAndInline(opts, store) {
         empty: toInject.length === 0,
     };
 }
+/** Format one memory hit for the recall block. Category + score for traceability. */
+export function formatMemoryRecallBlock(hits) {
+    if (hits.length === 0)
+        return "";
+    const parts = hits.map((h, i) => {
+        const pct = (h.score * 100).toFixed(0);
+        const cat = h.category ? `[${h.category}] ` : "";
+        return `### Recalled memory [${i + 1}] (relevance ${pct}%)\n${cat}${h.content.trim()}`;
+    });
+    return ("The following facts about this project were saved from earlier turns " +
+        "and are relevant to the current request. Treat them as established:\n\n" +
+        parts.join("\n"));
+}
+/** Recall top-k durable memories, format into a token-capped block. */
+export async function recallMemoriesAndInline(opts) {
+    const limit = opts.limit ?? 5;
+    const maxTokens = opts.recallMaxTokens ?? 0;
+    const { recallMemories } = await import("./memoryRecall.js");
+    const hits = await recallMemories(opts.query, opts.stateDir, {
+        topK: limit,
+        minSimilarity: opts.minSimilarity ?? 0.2,
+    });
+    if (hits.length === 0)
+        return { empty: true, block: "", report: [] };
+    // Same incremental token cap pattern as checkpoint recall.
+    const parts = [];
+    const report = [];
+    let blockTokens = 0;
+    for (const h of hits) {
+        const part = formatMemoryRecallBlock([
+            { content: h.memory.content, category: h.memory.category, score: h.score },
+        ]);
+        const partTokens = estimateBlockTokens(part);
+        if (maxTokens > 0 && blockTokens + partTokens > maxTokens)
+            break;
+        parts.push(part);
+        report.push(`  • memory#${h.memory.id} (${(h.score * 100).toFixed(0)}%): ${h.memory.content.slice(0, 60).replace(/\n/g, " ")}…`);
+        blockTokens += partTokens;
+    }
+    return { empty: parts.length === 0, block: parts.join("\n"), report };
+}
 /**
  * Slice 2 async cross-repo recall. Same dedup/bound/inline contract as
  * `recallAndInline`, but backed by `VectorStore.searchAsync` so it can recall
@@ -121,6 +166,19 @@ export async function recallAndInlineAsync(opts, store) {
     for (const h of hits) {
         if (skip && store.wasInjected(opts.sessionId, h.checkpoint.checkpointId))
             continue;
+        // S18: machine-wide injected-set — a foreign checkpoint already injected
+        // (in any session) is never re-injected. Only applies to cross-repo hits
+        // (same-repo hits have no repoId and are handled by the per-session set).
+        if (opts.globalIndexDir && h.repoId) {
+            try {
+                const { wasInjectedGlobal } = await import("./store/sqlite.js");
+                if (wasInjectedGlobal(h.checkpoint.checkpointId, opts.sessionId, opts.globalIndexDir))
+                    continue;
+            }
+            catch {
+                /* non-fatal: degrade to per-session injected-set only */
+            }
+        }
         if (doWindowDedupe && liveEmbeddings.length > 0) {
             const hitVec = defaultEmbedder().embed(h.checkpoint.summary);
             if (liveEmbeddings.some((v) => cosineSimilarity(v, hitVec) >= dedupSim))
@@ -134,6 +192,17 @@ export async function recallAndInlineAsync(opts, store) {
         toInject.push(h);
         blockTokens += partTokens;
         store.markInjected(opts.sessionId, h.checkpoint.checkpointId);
+        // S18: record the cross-repo injection machine-wide so it's not re-injected
+        // by a later recall (same or different session).
+        if (opts.globalIndexDir && h.repoId) {
+            try {
+                const { markInjectedGlobal } = await import("./store/sqlite.js");
+                markInjectedGlobal(h.checkpoint.checkpointId, h.repoId, opts.sessionId, opts.globalIndexDir);
+            }
+            catch {
+                /* non-fatal */
+            }
+        }
     }
     const block = parts.join("\n");
     const report = toInject.map((h) => `  • ${h.checkpoint.checkpointId} (${h.checkpoint.summary.slice(0, 60).replace(/\n/g, " ")}…)`);

package/dist/src/recall.test.js

@@ -5,7 +5,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { VectorStore } from "./vectorStore.js";
 import { compactSession } from "./engine.js";
-import { recallAndInline, formatRecallBlock } from "./recall.js";
+import { recallAndInline, recallAndInlineAsync, formatRecallBlock } from "./recall.js";
+import { markInjectedGlobal, wasInjectedGlobal, closeIndexStore } from "./store/sqlite.js";
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-recall-"));
 let counter = 0;
 function store() {
@@ -39,6 +40,24 @@ test("recallAndInline skipInjected=false re-returns hits", () => {
 test("formatRecallBlock is empty for no hits", () => {
     assert.equal(formatRecallBlock([]), "");
 });
+test("formatRecallBlock (S17): labels a cross-repo hit with its source repo", () => {
+    const hit = {
+        checkpoint: { checkpointId: "chkpt_x", summary: "did thing Y", filesModified: ["a.ts"] },
+        score: 0.91,
+        repoId: "/home/u/rad-gateway",
+    };
+    const block = formatRecallBlock([hit]);
+    assert.ok(block.includes("from repo"), "labels cross-repo source");
+    assert.ok(block.includes("rad-gateway"), "includes the repo display name");
+});
+test("formatRecallBlock (S17): omits the label for same-repo hits (no repoId)", () => {
+    const hit = {
+        checkpoint: { checkpointId: "c1", summary: "s", filesModified: [] },
+        score: 0.9,
+    };
+    const block = formatRecallBlock([hit]);
+    assert.ok(!block.includes("from repo"), "no source label for same-repo hits");
+});
 test("recallAndInline empty when store has nothing for query", () => {
     const s = store();
     const r = recallAndInline({ sessionId: SESS, query: "no such topic exists here", limit: 5, source: "command" }, s);
@@ -73,6 +92,55 @@ test("Fix C: inline dedupe drops a hit already resident in the live window", ()
     assert.ok(rDedup.toInject.length <= rNoDedup.toInject.length, "dedupe never adds hits");
     assert.ok(rDedup.toInject.length < rNoDedup.toInject.length, "inline dedupe dropped a resident hit");
 });
+test("S18: global injected-set skips a foreign checkpoint already injected machine-wide", async () => {
+    const indexDir = mkdtempSync(join(tmpdir(), "mc-gi-"));
+    try {
+        const sess = "sess_cross";
+        // A foreign checkpoint already marked injected globally (in this session).
+        markInjectedGlobal("chkpt_foreign", "/repo/other", sess, indexDir);
+        assert.equal(wasInjectedGlobal("chkpt_foreign", sess, indexDir), true);
+        // searchAsync returns the foreign hit; recallAndInlineAsync must skip it
+        // (globally injected) → toInject is empty.
+        const mockStore = {
+            searchAsync: async () => [{
+                    checkpoint: { checkpointId: "chkpt_foreign", summary: "foreign work", filesModified: [], dedupStatus: "active" },
+                    score: 0.92,
+                    repoId: "/repo/other",
+                }],
+            wasInjected: () => false,
+            markInjected: () => { },
+        };
+        const r = await recallAndInlineAsync({ sessionId: sess, query: "foreign", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir }, mockStore);
+        assert.equal(r.toInject.length, 0, "globally-injected foreign checkpoint skipped");
+    }
+    finally {
+        closeIndexStore();
+        rmSync(indexDir, { recursive: true, force: true });
+    }
+});
+test("S18: a fresh foreign checkpoint is injected AND recorded globally", async () => {
+    const indexDir = mkdtempSync(join(tmpdir(), "mc-gi2-"));
+    try {
+        const sess = "sess_fresh";
+        assert.equal(wasInjectedGlobal("chkpt_new", sess, indexDir), false);
+        const mockStore = {
+            searchAsync: async () => [{
+                    checkpoint: { checkpointId: "chkpt_new", summary: "brand new foreign work", filesModified: [], dedupStatus: "active" },
+                    score: 0.93,
+                    repoId: "/repo/alpha",
+                }],
+            wasInjected: () => false,
+            markInjected: () => { },
+        };
+        const r = await recallAndInlineAsync({ sessionId: sess, query: "foreign", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir }, mockStore);
+        assert.equal(r.toInject.length, 1, "fresh foreign checkpoint injected");
+        assert.equal(wasInjectedGlobal("chkpt_new", sess, indexDir), true, "recorded machine-wide");
+    }
+    finally {
+        closeIndexStore();
+        rmSync(indexDir, { recursive: true, force: true });
+    }
+});
 test("cleanup", () => {
     rmSync(baseTmp, { recursive: true, force: true });
 });

package/dist/src/store/sqlite.js

@@ -53,8 +53,18 @@ 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 (existing) {
+        // A closed handle in the cache (e.g. a test calling db.close() directly
+        // instead of closeStore) would surface as "database is not open" on the
+        // next reuse. Detect and evict so callers never see a dead handle.
+        try {
+            existing.prepare("SELECT 1");
+            return existing;
+        }
+        catch {
+            cache.delete(stateDir);
+        }
+    }
     if (!existsSync(stateDir))
         mkdirSync(stateDir, { recursive: true });
     const db = new DatabaseSync(join(stateDir, "sqlite.db"));
@@ -118,6 +128,19 @@ export function openIndexStore(indexDir = getIndexDir()) {
       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;
@@ -133,25 +156,41 @@ export function upsertRepoRegistry(row, indexDir = getIndexDir()) {
     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)
+        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 = excluded.last_seen,
+       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`).run({
+       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,
     });
 }
 /**
@@ -225,6 +264,34 @@ export function closeIndexStore() {
         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;
+}
 function initSchema(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS context_chunks (
@@ -374,7 +441,12 @@ function initSchema(db) {
       content           TEXT NOT NULL,
       tags              TEXT,                   -- JSON array of strings
       created_at        INTEGER,
-      last_recalled_at  INTEGER
+      last_recalled_at  INTEGER,
+      -- S20 memory-RAG extension (auto-review add/replace/remove ops).
+      category          TEXT,                   -- typed bucket, e.g. decision | fact | preference
+      target            TEXT,                   -- optional subject/scope this memory targets
+      last_referenced   INTEGER,               -- last time memory was referenced by recall (epoch s)
+      source_turn       INTEGER                -- conversation turn that produced this memory
     );
     CREATE INDEX IF NOT EXISTS idx_memories_repo ON memories(repo);
 
@@ -391,6 +463,12 @@ function initSchema(db) {
     // databases created by an older version — otherwise repoStats()/upsert crash
     // with "no such column" and the extension fails to load. Additive only.
     ensureColumn(db, "context_chunks", "original_token_estimate", "INTEGER");
+    // S20 memory-RAG extension: additive columns for auto-review ops. Idempotent —
+    // only alters DBs created by an older version that lack these columns.
+    ensureColumn(db, "memories", "category", "TEXT");
+    ensureColumn(db, "memories", "target", "TEXT");
+    ensureColumn(db, "memories", "last_referenced", "INTEGER");
+    ensureColumn(db, "memories", "source_turn", "INTEGER");
     const v = db.prepare("SELECT value FROM meta WHERE key='schema_version'").get();
     if (!v) {
         db.prepare("INSERT INTO meta(key, value) VALUES(?, ?)").run("schema_version", String(SCHEMA_VERSION));
@@ -500,9 +578,9 @@ 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);
+        .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", memory.content, JSON.stringify(memory.tags ?? []), now, memory.category ?? null, memory.target ?? null, memory.sourceTurn ?? null);
     return Number(res.lastInsertRowid);
 }
 /** List recent memories for a repo (or all repos when repo is null). */
@@ -529,6 +607,40 @@ export function recallMemory(id, stateDir = getStateDir()) {
     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, 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,
@@ -538,6 +650,10 @@ function mapMemoryRow(row) {
         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/vectorStore.js

@@ -240,6 +240,7 @@ export class VectorStore {
         const checkpoint = {
             checkpointId,
             sessionId,
+            repoId: this.repoId,
             summary: input.summary,
             topicSummary: input.topicSummary,
             summaryHash,
@@ -412,11 +413,15 @@ export class VectorStore {
         }
         // Hydrate each index hit from the authoritative node:sqlite store. repoId is
         // that repo's stateDir, so cross-repo hits resolve against their own store.
+        // Tag cross-repo hits with their source repoId so the recall block can label
+        // them ("from repo <name>"); same-repo hits stay unlabeled.
+        const selfRepo = this.repoId;
         const hydrated = [];
         for (const h of indexHits) {
             const cp = getCheckpoint(h.sessionId, h.checkpointId, h.repoId);
             if (cp && cp.dedupStatus !== "removed") {
-                hydrated.push({ checkpoint: cp, score: h.score });
+                const crossRepo = opts.crossRepo && selfRepo && h.repoId && h.repoId !== selfRepo;
+                hydrated.push({ checkpoint: cp, score: h.score, repoId: crossRepo ? h.repoId : undefined });
             }
         }
         if (hydrated.length === 0)

package/extensions/dashboard-server.test.ts

@@ -124,6 +124,110 @@ describe("port.pid file", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Multi-repo dashboard (S19 / Phase 5b) — launch the real server subprocess,
+// seed the machine-wide repo_registry, and assert /api/index returns every repo
+// plus the aggregate summary the Summary + All-repos tabs render.
+// ---------------------------------------------------------------------------
+
+describe("multi-repo /api/index (S19)", () => {
+  test("lists all repos from the global index with an aggregate summary", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "dash-index-"));
+    const indexDir = mkdtempSync(join(tmpdir(), "index-"));
+    // The server reads MEGACOMPACT_INDEX_DIR for the machine-wide registry.
+    process.env.MEGACOMPACT_INDEX_DIR = indexDir;
+    process.env.MEGACOMPACT_DASHBOARD_PORT = "19321"; // private base, non-colliding
+
+    const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
+    upsertRepoRegistry(
+      { repoRoot: "/home/u/repoA", displayName: "repoA", stateDir: dir, checkpointCount: 3, tokensSaved: 1000, compressedOriginalBytes: 0 },
+      indexDir,
+    );
+    upsertRepoRegistry(
+      { repoRoot: "/home/u/repoB", displayName: "repoB", stateDir: dir, checkpointCount: 5, tokensSaved: 2000, compressedOriginalBytes: 0 },
+      indexDir,
+    );
+
+    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+    try {
+      await waitFor(async () => {
+        try {
+          const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+          const res = await fetch(`http://localhost:${raw.port}/api/version`);
+          return res.ok;
+        } catch {
+          return false;
+        }
+      });
+      const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+      const idx = (await fetch(`http://localhost:${raw.port}/api/index`).then((r) => r.json())) as {
+        summary: { totalRepos: number; totalCheckpoints: number; totalTokensSaved: number };
+        repos: { repoRoot: string; displayName: string; checkpointCount: number; tokensSaved: number }[];
+      };
+      const names = idx.repos.map((r) => r.displayName).sort();
+      assert.deepEqual(names, ["repoA", "repoB"], "both repos from the global index");
+      assert.equal(idx.summary.totalRepos, 2, "repo count");
+      assert.equal(idx.summary.totalCheckpoints, 8, "3 + 5 checkpoints");
+      assert.equal(idx.summary.totalTokensSaved, 3000, "1000 + 2000 tokens saved");
+    } finally {
+      child.kill("SIGTERM");
+      delete process.env.MEGACOMPACT_INDEX_DIR;
+      delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+      rmSync(dir, { recursive: true, force: true });
+      rmSync(indexDir, { recursive: true, force: true });
+    }
+  });
+
+  test("/api/repos filters by ?active=Nh and /api/summary counts activeRepos", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "dash-active-"));
+    const indexDir = mkdtempSync(join(tmpdir(), "index-active-"));
+    process.env.MEGACOMPACT_INDEX_DIR = indexDir;
+    process.env.MEGACOMPACT_DASHBOARD_PORT = "19322";
+
+    const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
+    // Fresh repo, last_seen = now
+    upsertRepoRegistry(
+      { repoRoot: "/home/u/fresh", displayName: "fresh", stateDir: dir, checkpointCount: 1, tokensSaved: 100, compressedOriginalBytes: 0, lastSeen: Math.floor(Date.now() / 1000) },
+      indexDir,
+    );
+    // Stale repo, last_seen = 90 days ago — must be filtered out by ?active=24h.
+    const longAgo = Math.floor(Date.now() / 1000) - 90 * 86_400;
+    upsertRepoRegistry(
+      { repoRoot: "/home/u/stale", displayName: "stale", stateDir: dir, checkpointCount: 2, tokensSaved: 200, compressedOriginalBytes: 0, lastSeen: longAgo },
+      indexDir,
+    );
+
+    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+    try {
+      await waitFor(async () => {
+        try {
+          const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+          const res = await fetch(`http://localhost:${raw.port}/api/version`);
+          return res.ok;
+        } catch { return false; }
+      });
+      const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+
+      const allRepos = (await fetch(`http://localhost:${raw.port}/api/repos`).then((r) => r.json())) as { repos: { displayName: string }[]; count: number };
+      assert.equal(allRepos.count, 2, "unfiltered list has both repos");
+
+      const activeRepos = (await fetch(`http://localhost:${raw.port}/api/repos?active=24h`).then((r) => r.json())) as { repos: { displayName: string }[]; count: number };
+      assert.equal(activeRepos.count, 1, "active=24h drops the 90-day-old repo");
+      assert.equal(activeRepos.repos[0].displayName, "fresh");
+
+      const summary = (await fetch(`http://localhost:${raw.port}/api/summary`).then((r) => r.json())) as { activeRepos: number; totalRepos: number };
+      assert.equal(summary.activeRepos, 1, "summary counts only fresh repo as active");
+      assert.equal(summary.totalRepos, 2, "summary counts both repos total");
+    } finally {
+      child.kill("SIGTERM");
+      delete process.env.MEGACOMPACT_INDEX_DIR;
+      delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+      rmSync(dir, { recursive: true, force: true });
+      rmSync(indexDir, { recursive: true, force: true });
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Lifecycle integration — launch the compiled server as a real subprocess
 // (the same way the /dashboard command spawns it) and assert the two failure
@@ -136,6 +240,12 @@ describe("port.pid file", () => {
 
 const SERVER_ENTRY = new URL("./dashboard-server.js", import.meta.url).pathname;
 
+// Tests run in parallel across files and a killed run can leave a server bound
+// to 9320. Use a private, non-colliding base so this file never races the
+// mega-compact.test.js dashboard tests (which scan a DIFFERENT base) and never
+// collides with a leftover production server on 9320.
+process.env.MEGACOMPACT_DASHBOARD_PORT = "19320";
+
 function waitFor(cond: () => boolean | Promise<boolean>, timeoutMs = 6000): Promise<void> {
   const start = Date.now();
   return new Promise((resolve, reject) => {
@@ -151,8 +261,10 @@ function waitFor(cond: () => boolean | Promise<boolean>, timeoutMs = 6000): Prom
 describe("server lifecycle", () => {
   test("drops a stale port.pid and binds a fresh port", async () => {
     const dir = mkdtempSync(join(tmpdir(), "dash-stale-"));
-    // A marker claiming a port where nothing is listening.
-    writeFileSync(join(dir, "port.pid"), JSON.stringify({ port: 9325, pid: 999999 }));
+    // A marker claiming a port where nothing is listening — use the test's own
+    // private base + 5 so the dead port is inside the server's scan range.
+    const deadPort = 19325;
+    writeFileSync(join(dir, "port.pid"), JSON.stringify({ port: deadPort, pid: 999999 }));
 
     const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
     try {
@@ -169,7 +281,7 @@ describe("server lifecycle", () => {
       });
       const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
       assert.equal(typeof raw.port, "number");
-      assert.notEqual(raw.port, 9325, "should not reuse the dead port from the stale marker");
+      assert.notEqual(raw.port, deadPort, "should not reuse the dead port from the stale marker");
       // And a real server must answer on it.
       const res = await fetch(`http://localhost:${raw.port}/api/version`);
       assert.equal(res.ok, true);