pi-mega-compact 0.8.26 → 0.9.1

package/dist/src/sprint4x-rag-verification.test.js

@@ -0,0 +1,93 @@
+/**
+ * sprint4x-rag-verification.test.ts — run the S40–S47 RAG suite once against
+ * the current implementation and assert the documented "default enable" claims.
+ *
+ * This is the verification pass demanded by the roadmap/backlog: each spec
+ * claims its feature flags DEFAULT ON. The honest check (not a re-statement of
+ * the spec) is: which flags actually exist in code, what do they default to,
+ * and is the consuming path wired?
+ *
+ * Findings recorded here, per spec:
+ *   S40 importance-scoring     — module src/importance.ts exists (S40A) but is
+ *                                NOT consumed by compactSession/vector-paths;
+ *                                no shipped flag, no adapter wiring.
+ *   S41 self-rag-quality-gate  — spec-only; NO flag, NO consumer.
+ *   S42 raptor-multilevel      — PARTIALLY SHIPPED: RAPTOR_MULTILEVEL_ENABLED
+ *                                and RAPTOR_LEAF_EXPANSION both default true
+ *                                with real consumers; the spec's claim holds.
+ *   S43 hyde-vague-queries     — spec-only (QUERY_REFORMULATION_ENABLED absent).
+ *   S44 three-tier-latency-routing — spec-only (TIERED_ROUTING_ENABLED absent).
+ *   S45 crag-quality-metrics   — spec-only (CRAG_ENABLED absent).
+ *   S46 visual-memory-map      — spec-only (MEMORY_MAP_ENABLED absent;
+ *                                memory-graph endpoint not in dashboard-server).
+ *   S47 auto-categorizing-wiki — spec-only (AUTO_WIKI_ENABLED absent).
+ *
+ * Policy: the suite runs against the flags that EXIST today. Unimplemented spec
+ * claims are pinned by the S4X_SPEC_ONLY tests so regressions can't silently
+ * add them in the wrong state, and this file records exactly which
+ * spec-vs-implementation gaps remain.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { loadDedupConfig } from "./config/dedup.js";
+/**
+ * Clear any env pollution so the default is measured, not the override.
+ */
+function fresh(envKey, get) {
+    delete process.env[envKey];
+    try {
+        return get();
+    }
+    finally {
+        delete process.env[envKey];
+    }
+}
+// ---- S42: shipped flags default ON (claim holds) ----------------------------
+test("S42 RAPTOR_MULTILEVEL_ENABLED defaults ON and honors env off", () => {
+    const d = fresh("MEGACOMPACT_RAPTOR_MULTILEVEL", () => loadDedupConfig());
+    assert.ok(d.RAPTOR_MULTILEVEL_ENABLED, "ship claim: multi-level on by default");
+    process.env.MEGACOMPACT_RAPTOR_MULTILEVEL = "false";
+    const off = loadDedupConfig();
+    assert.ok(!off.RAPTOR_MULTILEVEL_ENABLED, "env override: MEGACOMPACT_RAPTOR_MULTILEVEL=false turns it off");
+});
+test("S42 RAPTOR_LEAF_EXPANSION defaults ON and honors env off", () => {
+    const d = fresh("MEGACOMPACT_RAPTOR_LEAF_EXPANSION", () => loadDedupConfig());
+    assert.ok(d.RAPTOR_LEAF_EXPANSION, "ship claim: leaf-expansion on by default");
+    process.env.MEGACOMPACT_RAPTOR_LEAF_EXPANSION = "false";
+    const off = loadDedupConfig();
+    assert.ok(!off.RAPTOR_LEAF_EXPANSION, "env override off");
+});
+// ---- S40: module exists, claims do NOT yet hold at the flag/consumer level --
+test("S40 importance module exists in-tree (S40A artifact)", async () => {
+    // Load the module and confirm it exports the scoring surface the spec
+    // describes. This proves the S40A implementation exists even though nothing
+    // wires it into compaction/vector paths yet (documented gap).
+    const mod = await import("./importance.js");
+    assert.ok(mod && typeof mod === "object", "importance.ts loads");
+    // Exports per spec: score() plus item-type enum.
+    assert.ok(typeof mod.score === "function", "importance.ts exports score() function");
+});
+test("S40 has no shipped consumer flag in the current codebase (gap pinned)", async () => {
+    // The S40 spec claims an IMPORTANCE_SCORING flag defaults ON. In the
+    // current code no such flag exists, and no vector/compact path reads
+    // importance scores. This test documents the gap so a future wiring does
+    // not silently flip it on in the wrong shape.
+    const cfg = loadDedupConfig();
+    assert.ok(!("IMPORTANCE_SCORING" in cfg), "no IMPORTANCE_SCORING flag yet (S40 consumer wiring missing)");
+});
+// ---- S41/S43–S47: spec-only modules — pin the absence ------------------------
+test("S4X spec-only flags absent from DedupConfig", () => {
+    const cfg = loadDedupConfig();
+    const specFlags = [
+        "CRITIQUE_ENABLED", // S41
+        "QUERY_REFORMULATION_ENABLED", // S43
+        "TIERED_ROUTING_ENABLED", // S44
+        "CRAG_ENABLED", // S45
+        "CRAG_EXPANSION_ENABLED", // S45
+        "MEMORY_MAP_ENABLED", // S46
+        "AUTO_WIKI_ENABLED", // S47
+    ];
+    for (const f of specFlags) {
+        assert.ok(!(f in cfg), `${f} is spec-only — should not be present in DedupConfig`);
+    }
+});

package/dist/src/store/memoryIndex.js

@@ -24,6 +24,7 @@ import { join } from "node:path";
 import { mkdirSync, rmSync, existsSync } from "node:fs";
 /** Vector dimension produced by the default TrigramEmbedder (src/embedder.ts). */
 export const MEMORY_INDEX_DIM = 512;
+import { withOpenTimeout } from "./pgOpenGuard.js";
 let db;
 let initPromise;
 let disabled = false;
@@ -110,12 +111,18 @@ async function openPgLite(retryOnCorrupt) {
             return undefined;
         const dir = indexDir();
         mkdirSync(dir, { recursive: true });
-        const pg = await new mod.PGlite({
-            dataDir: dir,
-            extensions: { vector: mod.vector },
-        });
-        await pg.exec("CREATE EXTENSION IF NOT EXISTS vector;");
-        await pg.exec(`
+        // Bounded open: PGlite is single-writer over a shared dataDir, so a second
+        // pi process on the same dir can block here forever. Without the ceiling the
+        // never-settling promise gets cached in initPromise and every later caller
+        // awaits it — which is how a stalled index wedged a whole pi turn.
+        let openTimedOut = false;
+        const pg = await withOpenTimeout((async () => {
+            const inst = await new mod.PGlite({
+                dataDir: dir,
+                extensions: { vector: mod.vector },
+            });
+            await inst.exec("CREATE EXTENSION IF NOT EXISTS vector;");
+            await inst.exec(`
       CREATE TABLE IF NOT EXISTS memory_index (
         repo_id    TEXT NOT NULL,
         memory_id  INTEGER NOT NULL,
@@ -124,7 +131,22 @@ async function openPgLite(retryOnCorrupt) {
         PRIMARY KEY (repo_id, memory_id)
       );
     `);
-        await pg.exec("CREATE INDEX IF NOT EXISTS memory_index_hnsw ON memory_index USING hnsw (embedding vector_cosine_ops);");
+            await inst.exec("CREATE INDEX IF NOT EXISTS memory_index_hnsw ON memory_index USING hnsw (embedding vector_cosine_ops);");
+            return inst;
+        })(), (reason) => {
+            openTimedOut = true;
+            logWarn(`init ${reason}`);
+        });
+        if (!pg) {
+            if (openTimedOut) {
+                // Don't leave the dead open cached, and don't retry on the next call —
+                // a contended dataDir would just burn another full timeout per caller.
+                // Same terminal state as any other init failure: fall back to the scan.
+                initPromise = undefined;
+                disabled = true;
+            }
+            return undefined;
+        }
         db = pg;
         return pg;
     }

package/dist/src/store/pgOpenGuard.js

@@ -0,0 +1,83 @@
+/**
+ * pgOpenGuard.ts — bound the PGlite open so a stalled WASM init can never wedge
+ * a pi turn.
+ *
+ * Both index modules (vectorIndex / memoryIndex) cache their in-flight open in a
+ * module-level `initPromise`. That cache is what turns a single stalled open
+ * into a permanent hang: PGlite is a single-writer WASM Postgres over a shared
+ * dataDir (~/.pi/mega-compact-vector), so a second pi process opening the same
+ * dir can block indefinitely. `await new PGlite(...)` then never settles, the
+ * never-settling promise is cached, and every later caller awaits that same dead
+ * promise — with no timers and no sockets left, node reports
+ * "Promise resolution is still pending but the event loop has already resolved"
+ * and the pi turn that awaited it never ends.
+ *
+ * withOpenTimeout() puts a ceiling on that wait. On timeout the caller gets
+ * undefined (both modules already degrade to a synchronous scan), and the
+ * abandoned open is disowned: if it does eventually settle, the instance is
+ * closed so a stray PGlite can't keep the loop alive or hold the dataDir lock.
+ *
+ * A rejected open is NOT swallowed — it propagates so the callers' existing
+ * corrupt-dir detection (Aborted / RuntimeError → wipe + one retry) still runs.
+ * Only the timeout resolves to undefined.
+ */
+/** Sentinel so a legitimately-undefined open is distinguishable from a timeout. */
+const TIMED_OUT = Symbol("pglite-open-timeout");
+/** Default ceiling for a PGlite open. Generous — a cold WASM + HNSW init is slow. */
+export const DEFAULT_PG_OPEN_TIMEOUT_MS = 30_000;
+/** Resolve the open timeout. 0 (or negative) disables the guard entirely. */
+export function pgOpenTimeoutMs() {
+    const raw = process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS;
+    if (raw === undefined || raw.trim() === "")
+        return DEFAULT_PG_OPEN_TIMEOUT_MS;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0)
+        return DEFAULT_PG_OPEN_TIMEOUT_MS;
+    return n;
+}
+/**
+ * Race `open` against the configured timeout.
+ *
+ * Resolves to the opened value, or to undefined when the open outruns the
+ * timeout (`onTimeout` fires first so the caller can log and flip its own
+ * disabled state). Rejections propagate to the caller unchanged.
+ */
+export async function withOpenTimeout(open, onTimeout, timeoutMs = pgOpenTimeoutMs()) {
+    // Guard disabled — preserve the original unbounded behavior verbatim.
+    if (timeoutMs <= 0)
+        return open;
+    let timer;
+    const expiry = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(TIMED_OUT), timeoutMs);
+        // Never hold the process open on account of the guard itself.
+        timer.unref?.();
+    });
+    try {
+        // `open` is raced as-is so a rejection rejects the race — and therefore
+        // this function — leaving the caller's corrupt-retry path intact.
+        const winner = await Promise.race([open, expiry]);
+        if (winner === TIMED_OUT) {
+            // Disown the open. If it ever settles, close the instance so an orphaned
+            // PGlite cannot keep the event loop alive or hold the dataDir lock.
+            void open
+                .then((late) => {
+                try {
+                    void late?.close?.();
+                }
+                catch {
+                    /* ignore */
+                }
+            })
+                .catch(() => {
+                /* the abandoned open failed on its own — nothing left to release */
+            });
+            onTimeout(`timed out after ${timeoutMs}ms`);
+            return undefined;
+        }
+        return winner;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/src/store/pgOpenGuard.test.js

@@ -0,0 +1,74 @@
+/**
+ * pgOpenGuard.test.ts — the PGlite open must never hang a turn.
+ *
+ * Regression cover for the wedge: a stalled `await new PGlite(...)` was cached
+ * in initPromise, so every later caller awaited a promise that could not settle
+ * and the pi turn awaiting it never ended.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { withOpenTimeout, pgOpenTimeoutMs, DEFAULT_PG_OPEN_TIMEOUT_MS } from "./pgOpenGuard.js";
+test("a never-settling open resolves to undefined instead of hanging", async () => {
+    const never = new Promise(() => {
+        /* deliberately never settles — the wedge */
+    });
+    const reasons = [];
+    const t0 = Date.now();
+    const result = await withOpenTimeout(never, (r) => reasons.push(r), 50);
+    assert.equal(result, undefined, "caller gets undefined and can fall back");
+    assert.ok(Date.now() - t0 < 5_000, "returned promptly rather than hanging");
+    assert.equal(reasons.length, 1, "onTimeout fired exactly once");
+    assert.match(reasons[0], /timed out after 50ms/);
+});
+test("a successful open passes its value through untouched", async () => {
+    const reasons = [];
+    const result = await withOpenTimeout(Promise.resolve("pg"), (r) => reasons.push(r), 5_000);
+    assert.equal(result, "pg");
+    assert.deepEqual(reasons, [], "no timeout reported on the happy path");
+});
+test("a rejected open propagates so the corrupt-dir retry still runs", async () => {
+    const reasons = [];
+    await assert.rejects(() => withOpenTimeout(Promise.reject(new Error("Aborted()")), (r) => reasons.push(r), 5_000), /Aborted/, "rejection reaches the caller's catch, which owns the wipe-and-retry path");
+    assert.deepEqual(reasons, [], "a rejection is not reported as a timeout");
+});
+test("an abandoned open is closed if it settles after the timeout", async () => {
+    let closed = false;
+    let release = () => { };
+    const late = new Promise((r) => {
+        release = r;
+    });
+    const result = await withOpenTimeout(late, () => { }, 25);
+    assert.equal(result, undefined, "timed out first");
+    // The open finally completes, long after we stopped waiting for it.
+    release({
+        close: () => {
+            closed = true;
+        },
+    });
+    await late;
+    await new Promise((r) => setImmediate(r));
+    assert.ok(closed, "the orphaned instance was closed, not left holding the dataDir");
+});
+test("timeout of 0 disables the guard (unbounded, original behavior)", async () => {
+    const result = await withOpenTimeout(Promise.resolve("pg"), () => { }, 0);
+    assert.equal(result, "pg");
+});
+test("pgOpenTimeoutMs honors the env override and rejects junk", async () => {
+    const prev = process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS;
+    try {
+        process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = "1234";
+        assert.equal(pgOpenTimeoutMs(), 1234);
+        process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = "0";
+        assert.equal(pgOpenTimeoutMs(), 0, "0 is a valid opt-out, not junk");
+        for (const junk of ["", "   ", "abc", "-5"]) {
+            process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = junk;
+            assert.equal(pgOpenTimeoutMs(), DEFAULT_PG_OPEN_TIMEOUT_MS, `junk "${junk}" falls back`);
+        }
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS;
+        else
+            process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = prev;
+    }
+});

package/dist/src/store/repoKey.js

@@ -0,0 +1,45 @@
+/**
+ * repoKey.ts — S25-B: the single repo-scope key for BOTH global PGlite indexes.
+ *
+ * Before S25 the checkpoint index (vector_index) keyed on stateDir while the
+ * memory index (memory_index) keyed on the git root — two scopes that meant
+ * cross-repo checkpoint hydration had no way back from repo_id → the repo's
+ * store. This helper unifies both indexes on ONE key: the resolved git root,
+ * falling back to stateDir outside git worktrees.
+ *
+ * stateDirForRepo() reverses the mapping via the machine-wide
+ * repo_registry (src/store/sqlite/global-index.ts): a repo_id hit from the
+ * index resolves to that repo's stateDir so getCheckpoint() can hydrate from
+ * the authoritative node:sqlite store. Returns undefined when unresolvable —
+ * the caller skips the hit (degrade, never crash).
+ *
+ * PREVENT-PI-004: `git rev-parse` is local + read-only (annotated below).
+ */
+import { execSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: read-only `git rev-parse` to scope the vector index per-repo
+import { getRepoRegistry } from "./sqlite/global-index.js";
+/**
+ * Resolve the canonical repo key for a state dir. Git root when inside a
+ * worktree, stateDir otherwise. Two repos sharing a git root (e.g. nested
+ * checkouts pointing at the same repo) collapse to one scope — intended.
+ */
+export function repoKey(stateDir) {
+    try {
+        const out = execSync("git rev-parse --show-toplevel", {
+            cwd: stateDir,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return out || stateDir;
+    }
+    catch {
+        return stateDir;
+    }
+}
+/**
+ * Reverse map: repo_id → stateDir. Registry hit wins (git-root scope, S25);
+ * otherwise the key is assumed to be a legacy/ungit-scoped stateDir and
+ * returned verbatim (callers treat undefined-unopenable dirs as skip/degrade).
+ */
+export function stateDirForRepo(repoId, indexDir) {
+    return getRepoRegistry(repoId, indexDir)?.stateDir ?? repoId;
+}

package/dist/src/store/vectorIndex.js

@@ -20,6 +20,7 @@ import { join } from "node:path";
 import { mkdirSync, rmSync, existsSync } from "node:fs";
 /** Vector dimension produced by the default TrigramEmbedder (src/embedder.ts). */
 export const EMBEDDING_DIM = 512;
+import { withOpenTimeout } from "./pgOpenGuard.js";
 let db;
 let initPromise;
 let disabled = false;
@@ -107,12 +108,18 @@ async function openPgLite(retryOnCorrupt) {
             return undefined;
         const dir = indexDir();
         mkdirSync(dir, { recursive: true });
-        const pg = await new mod.PGlite({
-            dataDir: dir,
-            extensions: { vector: mod.vector },
-        });
-        await pg.exec("CREATE EXTENSION IF NOT EXISTS vector;");
-        await pg.exec(`
+        // Bounded open: PGlite is single-writer over a shared dataDir, so a second
+        // pi process on the same dir can block here forever. Without the ceiling the
+        // never-settling promise gets cached in initPromise and every later caller
+        // awaits it — which is how a stalled index wedged a whole pi turn.
+        let openTimedOut = false;
+        const pg = await withOpenTimeout((async () => {
+            const inst = await new mod.PGlite({
+                dataDir: dir,
+                extensions: { vector: mod.vector },
+            });
+            await inst.exec("CREATE EXTENSION IF NOT EXISTS vector;");
+            await inst.exec(`
       CREATE TABLE IF NOT EXISTS vector_index (
         repo_id       TEXT NOT NULL,
         session_id    TEXT NOT NULL,
@@ -121,8 +128,23 @@ async function openPgLite(retryOnCorrupt) {
         PRIMARY KEY (repo_id, session_id, checkpoint_id)
       );
     `);
-        // HNSW index over cosine distance for fast NN. Created idempotently.
-        await pg.exec("CREATE INDEX IF NOT EXISTS vector_index_hnsw ON vector_index USING hnsw (embedding vector_cosine_ops);");
+            // HNSW index over cosine distance for fast NN. Created idempotently.
+            await inst.exec("CREATE INDEX IF NOT EXISTS vector_index_hnsw ON vector_index USING hnsw (embedding vector_cosine_ops);");
+            return inst;
+        })(), (reason) => {
+            openTimedOut = true;
+            logWarn(`init ${reason}`);
+        });
+        if (!pg) {
+            if (openTimedOut) {
+                // Don't leave the dead open cached, and don't retry on the next call —
+                // a contended dataDir would just burn another full timeout per caller.
+                // Same terminal state as any other init failure: fall back to the scan.
+                initPromise = undefined;
+                disabled = true;
+            }
+            return undefined;
+        }
         db = pg;
         return pg;
     }

package/dist/src/store/vectorIndex.test.js

@@ -11,7 +11,7 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { EMBEDDING_DIM, initVectorIndex, upsertEmbedding, searchAsync, closeVectorIndex, isVectorIndexDisabled, } from "./vectorIndex.js";
@@ -77,6 +77,30 @@ test("dimension guard: non-512 vectors are skipped, never corrupt the index", as
         delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
     }
 });
+test("corrupt-dir self-heal: torn PGlite dir is deleted + retried, never crashes", async () => {
+    delete process.env.MEGACOMPACT_PGLITE_DISABLED;
+    const dir = isolateIndexDir();
+    try {
+        await closeVectorIndex();
+        // Tear the dir: garbage bytes where PGlite expects its data/ files.
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "data"), Buffer.from([0xde, 0xad, 0xbe, 0xef, 0xde, 0xad]));
+        // openPgLite(retryOnCorrupt=true) deletes + retries; if that still fails it
+        // disables gracefully. Either path must NOT throw.
+        const pg = await initVectorIndex();
+        assert.ok(pg, "index self-healed after corruption ");
+        // And the index works after heal: upsert + search round-trip.
+        await upsertEmbedding("/repoE/.pi/mega-compact", "sessE", "chkpt_001", spikeVec(7));
+        const hits = await searchAsync(spikeVec(7), { k: 1 });
+        assert.equal(hits.length, 1, "search works on the healed index");
+        assert.equal(hits[0].checkpointId, "chkpt_001");
+    }
+    finally {
+        await closeVectorIndex();
+        rmSync(dir, { recursive: true, force: true });
+        delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
+    }
+});
 test("kill-switch: MEGACOMPACT_PGLITE_DISABLED disables the index gracefully", async () => {
     const dir = isolateIndexDir();
     process.env.MEGACOMPACT_PGLITE_DISABLED = "true";

package/dist/src/vector-search.js

@@ -13,6 +13,7 @@
 import { cosineSimilarity } from "./embedder.js";
 import { normalizeSessionId } from "./store.js";
 import { mmrRerank } from "./dedup/mmr.js";
+import { stateDirForRepo } from "./store/repoKey.js";
 import { topK } from "./dedup/topk.js";
 import { listCheckpoints, getCheckpoint, maxCheckpointTimestamp, maxRaptorNodeBuiltAt, } from "./store/sqlite.js";
 import { initVectorIndex, searchAsync as vectorIndexSearch, } from "./store/vectorIndex.js";
@@ -255,13 +256,18 @@ export async function vectorSearchAsync(store, sessionId, query, k = 3, opts = {
         // Index empty/unavailable → synchronous per-session fallback (this repo).
         return vectorSearch(store, sid, query, k);
     }
-    // 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.
+    // Hydrate each index hit from the authoritative node:sqlite store. The
+    // index keys on repo_id (S25: git root via repoKey; legacy rows keyed by
+    // stateDir) — resolve repo_id → stateDir via stateDirForRepo, and skip
+    // unresolvable/foreign hits (degrade, never crash). Cross-repo hits carry
+    // their source repoId so the recall block can label them; same-repo stays
+    // unlabeled.
     const hydrated = [];
     for (const h of indexHits) {
-        const cp = getCheckpoint(h.sessionId, h.checkpointId, h.repoId);
+        const hitStateDir = stateDirForRepo(h.repoId);
+        if (!hitStateDir)
+            continue;
+        const cp = getCheckpoint(h.sessionId, h.checkpointId, hitStateDir);
         if (cp && cp.dedupStatus !== "removed") {
             const crossRepo = opts.crossRepo && selfRepo && h.repoId && h.repoId !== selfRepo;
             hydrated.push({

package/dist/src/vectorStore.js

@@ -11,6 +11,7 @@ import { createHash } from "node:crypto";
 import { cosineSimilarity, defaultEmbedder } from "./embedder.js";
 import { loadDedupConfig, } from "./config/dedup.js";
 import { logDecision } from "./monitoring.js";
+import { repoKey } from "./store/repoKey.js";
 import { getStateDir, normalizeSessionId, compressSmart } from "./store.js";
 import { computeContentDigest } from "./dedup/digest.js";
 import { minhashSignature, SIGNATURE_VERSION, NUM_HASHES, } from "./dedup/l1-minhash.js";
@@ -54,7 +55,9 @@ export class VectorStore {
     constructor(opts = {}) {
         this.embedder = opts.embedder ?? defaultEmbedder();
         this.stateDir = opts.stateDir ?? getStateDir();
-        this.repoId = opts.repoId ?? this.stateDir;
+        // S25: single repo-scope key shared with the memory index (git-root
+        // scoped; falls back to stateDir outside git).
+        this.repoId = opts.repoId ?? repoKey(this.stateDir);
         // Sprint 14: all tier flags/thresholds flow from the single config source
         // (DedupConfig). The legacy opts.dedupSim / opts.l2Enabled remain accepted
         // for backward-compat callers but flags are authoritative via `cfg`.

package/extensions/mega-compact.ts

@@ -27,6 +27,8 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { closeVectorIndex } from "../src/store/vectorIndex.js";
+import { closeMemoryIndex } from "../src/store/memoryIndex.js";
 import { loadConfig } from "./mega-config.js";
 import { MegaRuntime } from "./mega-runtime.js";
 import { registerEventHandlers } from "./mega-events.js";
@@ -82,5 +84,18 @@ export default function (pi: ExtensionAPI) {
   // dispose() is idempotent, and the next snapshot() re-opens the watcher
   // lazily via bindRepo() → ensureGameStateWatcher(), so there is no permanent
   // leak and no per-session fd accumulation.
-  pi.on("session_shutdown", () => runtime.dispose());
+  // The PGlite indexes (vectorIndex / memoryIndex) are lazily opened module
+  // singletons. closeVectorIndex()/closeMemoryIndex() existed but had no
+  // non-test callers, so a session left both open: PGlite is WASM Postgres and
+  // its handles keep node's event loop alive, so `pi -p` produced its answer
+  // and then hung until killed rather than exiting. dispose() only released the
+  // fs.watch handle and the perf interval, neither of which was the culprit
+  // (the interval is unref'd).
+  //
+  // Both closes are idempotent and safe when the index was never opened, and
+  // the next initVectorIndex()/initMemoryIndex() re-opens lazily.
+  pi.on("session_shutdown", async () => {
+    runtime.dispose();
+    await Promise.all([closeVectorIndex(), closeMemoryIndex()]);
+  });
 }

package/extensions/mega-config.ts

@@ -147,6 +147,13 @@ export interface MegaConfig {
    *  a hit whose summary is ≥ dedupSim similar to a live message — "dedupe on
    *  inline/read" so we never re-inject context already resident. */
   windowDedupe: boolean;
+  /** Render the above-editor TUI widget (MEGACOMPACT_TUI_WIDGET). Default true.
+   *  Set to 0 to suppress the panel entirely — the widget is a persistent,
+   *  animated, full-width region that repaints on its own cadence, which fights
+   *  terminals where the user drives scrollback themselves (notably pi running
+   *  inside a Neovim `:terminal`, where every repaint yanks the view back to
+   *  the bottom). Compaction is unaffected; only the panel is suppressed. */
+  tuiWidget: boolean;
   debug: boolean;
 }
 
@@ -292,6 +299,7 @@ export function loadConfig(): MegaConfig {
     memoryReviewInterval: envFlag("MEGACOMPACT_MEMORY_REVIEW_INTERVAL", 10),
     recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
     windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
+    tuiWidget: envBool("MEGACOMPACT_TUI_WIDGET", true),
     debug: envBool("MEGACOMPACT_DEBUG", false),
   };
 }

package/extensions/mega-pipeline/compact.ts

@@ -14,6 +14,7 @@ import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { compactSession } from "../../src/engine.js";
 import type { EngineMessage } from "../../src/types.js";
 import { normalizeSessionId } from "../../src/store.js";
+import { repoKey } from "../../src/store/repoKey.js";
 import { estimateBlockTokens } from "../../src/tokens.js";
 import { touchSession, logDaily, incCompactCount, incCacheHitTokens } from "../../src/store/sqlite.js";
 import { consolidateMemories } from "../../src/memory.js";
@@ -265,7 +266,7 @@ function doCompact(
       const latest = all.find((cp) => cp.checkpointId === result.checkpointId);
       if (latest?.embedding) {
         void indexUpsertEmbedding(
-          runtime.currentStateDir,
+          repoKey(runtime.currentStateDir),
           sid,
           latest.checkpointId,
           latest.embedding,