pi-mega-compact 0.4.21 → 0.4.24

package/dist/src/store/sqlite.js

@@ -2,11 +2,13 @@
  * sqlite.ts — Sprint 8 storage backbone (the "one store").
  *
  * Replaces the per-session gzipped-JSON checkpoint files with a single local
- * SQLite database (better-sqlite3, in-process, FS-backed, ZERO network calls —
- * honors PREVENT-PI-004). Chosen over PGlite because PGlite is async-only in
- * every published version, and VectorStore (engine.ts / recall.ts / the
- * extension) is fully synchronous — adopting PGlite would have cascaded async
- * through the whole call chain. SQLite keeps every VectorStore signature sync.
+ * SQLite database (node:sqlite — the Node built-in, in-process, FS-backed,
+ * ZERO network calls — honors PREVENT-PI-004). No native build and no install
+ * scripts, so it survives pi's npm blocked-install-scripts gate (better-sqlite3's
+ * native binary could not be built under pi, which crashed every `pi update
+ * --extensions`). node:sqlite is synchronous, so every VectorStore signature
+ * stays sync. PGlite + pgvector (async) is layered on in vectorIndex.ts for
+ * real HNSW indexing (Slice 2 of the dual-backend plan).
  *
  * FTS5 `trigram` tokenizer is created for the Sprint 9+ dedup tiers (MinHash/LSH
  * / pg_trgm-equivalent verification). The default cosine path stays a linear
@@ -14,7 +16,7 @@
  *
  * All queries are parameterized (PREVENT-002) — never string-concatenated.
  */
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
 import { existsSync, mkdirSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
@@ -28,14 +30,17 @@ function encodeEmbedding(v) {
         buf.writeFloatLE(v[i] ?? 0, i * 4);
     return buf;
 }
-/** Decode a Float32 BLOB back to a number[]. */
+/** Decode a Float32 BLOB back to a number[]. node:sqlite returns BLOBs as
+ *  Uint8Array, so decode via DataView (Buffer is a Uint8Array subclass — both
+ *  work). */
 function decodeEmbedding(buf) {
     if (!buf || buf.length === 0)
         return [];
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
     const n = buf.length / 4;
     const out = new Array(n);
     for (let i = 0; i < n; i++)
-        out[i] = buf.readFloatLE(i * 4);
+        out[i] = dv.getFloat32(i * 4, true);
     return out;
 }
 function jsonText(v) {
@@ -52,9 +57,9 @@ export function openStore(stateDir = getStateDir()) {
         return existing;
     if (!existsSync(stateDir))
         mkdirSync(stateDir, { recursive: true });
-    const db = new Database(join(stateDir, "sqlite.db"));
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
+    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;
@@ -91,10 +96,10 @@ export function openIndexStore(indexDir = getIndexDir()) {
         return indexCache;
     if (!existsSync(indexDir))
         mkdirSync(indexDir, { recursive: true });
-    const db = new Database(join(indexDir, "index.sqlite"));
-    db.pragma("journal_mode = WAL");
-    db.pragma("busy_timeout = 3000"); // tolerate brief cross-process write contention
-    db.exec(`
+    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,
@@ -114,9 +119,9 @@ export function openIndexStore(indexDir = getIndexDir()) {
     );
     CREATE INDEX IF NOT EXISTS idx_registry_last_seen ON repo_registry(last_seen DESC);
   `);
-    indexCache = db;
+    indexCache = iddb;
     indexCacheDir = indexDir;
-    return db;
+    return iddb;
 }
 /**
  * Upsert a repo's aggregate stats into the global index. Called on repo-switch
@@ -535,6 +540,24 @@ function mapMemoryRow(row) {
         lastRecalledAt: row.last_recalled_at ?? null,
     };
 }
+/**
+ * Run `fn` atomically. Uses SAVEPOINT so it nests safely under an outer
+ * transaction (unlike `BEGIN`, which SQLite rejects when one is already open).
+ * Mirrors better-sqlite3's `db.transaction(fn)` semantics — callers that wrap a
+ * batch in withTx (e.g. backfill) can still call helpers that also use withTx.
+ */
+export function withTx(db, fn) {
+    db.exec("SAVEPOINT mc_tx");
+    try {
+        fn();
+        db.exec("RELEASE mc_tx");
+    }
+    catch (e) {
+        db.exec("ROLLBACK TO mc_tx");
+        db.exec("RELEASE mc_tx");
+        throw e;
+    }
+}
 /** Map a DB row to the public StoredCheckpoint shape. */
 function rowToCheckpoint(row) {
     return {
@@ -553,7 +576,9 @@ function rowToCheckpoint(row) {
         contentHash2: row.content_hash2 ?? undefined,
         contentHashVersion: row.content_hash_version ?? undefined,
         normalizedText: row.normalized_text ?? undefined,
-        compressedOriginal: row.compressed_original ?? undefined,
+        // node:sqlite returns BLOBs as Uint8Array; normalize to Buffer so callers
+        // (e.g. decompressSmart → Buffer.toString) behave as under better-sqlite3.
+        compressedOriginal: row.compressed_original ? Buffer.from(row.compressed_original) : undefined,
         embedding: decodeEmbedding(row.embedding_blob),
         timestamp: Number(row.timestamp ?? 0),
         dedupStatus: row.dedup_status ?? undefined,
@@ -563,7 +588,7 @@ function rowToCheckpoint(row) {
 export function upsertCheckpoint(cp, stateDir = getStateDir()) {
     const db = openStore(stateDir);
     const sid = normalizeSessionId(cp.sessionId);
-    const tx = db.transaction(() => {
+    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,
@@ -586,25 +611,25 @@ export function upsertCheckpoint(cp, stateDir = getStateDir()) {
          timestamp=excluded.timestamp,
          dedup_status=excluded.dedup_status,
          compressed_original=excluded.compressed_original`).run({
-            id: cp.checkpointId,
-            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,
+            "@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
@@ -612,7 +637,6 @@ export function upsertCheckpoint(cp, stateDir = getStateDir()) {
         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 ?? "");
     });
-    tx();
 }
 // --- Sprint 11: MinHash signatures + LSH buckets --------------------------
 /** Persist a checkpoint's MinHash signature (idempotent by chunk_id + version). */
@@ -630,12 +654,11 @@ export function insertLshBuckets(chunkId, sessionId, signatureVersion, bucketKey
     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(?, ?, ?, ?)");
-    const tx = db.transaction(() => {
+    withTx(db, () => {
         del.run(chunkId);
         for (const key of bucketKeys)
             ins.run(key, chunkId, sid, signatureVersion);
     });
-    tx();
 }
 /**
  * Candidate chunk_ids sharing any LSH bucket with `bucketKeys`, scoped to the

package/dist/src/store.test.js

@@ -109,6 +109,25 @@ test("compression tier: GZIP-1 and GZIP-6 tiers produce valid, smaller output",
     assert.ok(big.length < Buffer.from("compress me ".repeat(1800)).length, "GZIP-6 output smaller than input");
     assert.deepEqual(decompressSmart(big), Buffer.from("compress me ".repeat(1800)));
 });
+test("Fix E: pressure escalates gzip tier strength (sync, no zstd)", () => {
+    const small = Buffer.from("compress me ".repeat(200)); // 512B–4KB band
+    const medium = Buffer.from("compress me ".repeat(1800)); // 4KB–32KB band
+    // Low pressure → cheap levels (gzip-1 / gzip-6).
+    const lowSmall = compressSmart(small, 0);
+    const lowMedium = compressSmart(medium, 0);
+    assert.equal(lowSmall[3], 0x01, "small tier tag");
+    assert.equal(lowMedium[3], 0x02, "medium tier tag");
+    assert.ok(decompressSmart(lowSmall).equals(small), "low-pressure small roundtrips");
+    assert.ok(decompressSmart(lowMedium).equals(medium), "low-pressure medium roundtrips");
+    // High pressure → stronger levels (gzip-9 / gzip-9); tag unchanged, output
+    // must still decode to the exact original (versioned header preserved).
+    const highSmall = compressSmart(small, 1);
+    const highMedium = compressSmart(medium, 1);
+    assert.equal(highSmall[3], 0x01, "tag unchanged under pressure");
+    assert.equal(highMedium[3], 0x02, "tag unchanged under pressure");
+    assert.ok(decompressSmart(highSmall).equals(small), "high-pressure small roundtrips");
+    assert.ok(decompressSmart(highMedium).equals(medium), "high-pressure medium roundtrips");
+});
 // ---------------------------------------------------------------------------
 // normalizeSessionId
 // ---------------------------------------------------------------------------

package/dist/src/vectorStore.js

@@ -20,6 +20,8 @@ import { mmrRerank } from "./dedup/mmr.js";
 import { topK } from "./dedup/topk.js";
 import { openBloom, saveBloom } from "./store/bloom.js";
 import { listCheckpoints, nextCheckpointId, upsertCheckpoint, loadSessionState, saveSessionState, upsertMinhashSignature, insertLshBuckets, lshCandidateChunks, setDedupStatus, addTokensSaved, getDedupStats, bumpDedupStats, repoStats as repoStatsFromStore, dataInvariantStats, } from "./store/sqlite.js";
+import { rehydrateRaptorTree } from "./dedup/raptor/index.js";
+import { stagedExpansion } from "./dedup/raptor/retrieval.js";
 import { migrateJsonToSqlite } from "./store/migrate.js";
 /** Default L2 semantic-dedup enable flag (trigram embedder is local, zero-network). */
 export const L2_ENABLED = true;
@@ -242,7 +244,7 @@ export class VectorStore {
             contentHash2: digest.contentHash2,
             contentHashVersion: digest.contentHashVersion,
             normalizedText: digest.normalizedText,
-            compressedOriginal: compressSmart(Buffer.from(input.regionText, "utf-8")),
+            compressedOriginal: compressSmart(Buffer.from(input.regionText, "utf-8"), input.compressionPressure),
             embedding,
             timestamp: input.timestamp,
         };
@@ -339,6 +341,27 @@ export class VectorStore {
         // (Sprint 14 flag), returning the plain relevance-ranked window instead.
         if (!this.cfg.L2_ENABLED)
             return window.slice(0, k);
+        // Fix D: when RAPTOR is promoted, ALSO recall high-level tree summaries and
+        // merge them with the flat hits via MMR so RAPTOR + flat don't double-cover.
+        // RAPTOR returns fewer, broader hits (O(log n) high-level nodes) than the
+        // O(n) flat leaves, tightening the block at read time.
+        if (this.cfg.RAPTOR_ENABLED) {
+            const raptorHits = this.raptorSearchHits(sid, query, k);
+            if (raptorHits.length > 0) {
+                const merged = [...window];
+                for (const rh of raptorHits) {
+                    if (!merged.some((m) => m.checkpoint.checkpointId === rh.checkpoint.checkpointId)) {
+                        merged.push(rh);
+                    }
+                }
+                const mmrItems = merged.map((h) => ({
+                    item: h,
+                    vector: h.checkpoint.embedding,
+                    relevance: h.score,
+                }));
+                return mmrRerank(mmrItems, k, this.cfg.MMR_LAMBDA);
+            }
+        }
         const mmrItems = window.map((h) => ({
             item: h,
             vector: h.checkpoint.embedding,
@@ -347,6 +370,38 @@ export class VectorStore {
         const ranked = mmrRerank(mmrItems, k, this.cfg.MMR_LAMBDA);
         return ranked;
     }
+    /**
+     * Serve the RAPTOR tree for a query (Fix D): rehydrate the persisted tree and
+     * return its staged-expansion leaf hits as SearchHits. Returns [] when no tree
+     * exists (small sessions — flat search remains the path). Best-effort/non-fatal.
+     */
+    raptorSearchHits(sid, query, k) {
+        try {
+            const tree = rehydrateRaptorTree(sid, this.stateDir);
+            if (!tree || !tree.rootId)
+                return [];
+            const leafIds = stagedExpansion(query, tree, {
+                embedder: this.embedder,
+                k,
+                topM: this.cfg.RAPTOR_CLUSTERS_PER_LEVEL,
+                mmrLambda: this.cfg.MMR_LAMBDA,
+            });
+            if (leafIds.length === 0)
+                return [];
+            const all = listCheckpoints(sid, this.stateDir).filter((cp) => cp.dedupStatus !== "removed");
+            const qv = this.embedder.embed(query);
+            const hits = [];
+            for (const id of leafIds) {
+                const cp = all.find((c) => c.checkpointId === id);
+                if (cp)
+                    hits.push({ checkpoint: cp, score: cosineSimilarity(qv, cp.embedding) });
+            }
+            return hits;
+        }
+        catch {
+            return [];
+        }
+    }
     /**
      * SemDeDup offline cleanup (Sprint 12, QA #17): within a session, mark the
      * lower-quality row of any pair scoring cosine > `threshold` as

package/extensions/DASHBOARD.md

@@ -2,8 +2,8 @@
 
 A lightweight local web dashboard for monitoring mega-compact's live state — compactions, context usage, checkpoints, and recall hits.
 
-Uses Node built-in modules (`http`, `fs`, `path`) plus `better-sqlite3` (the
-project's one-store DB backend) to read the machine-wide multi-repo index.
+Uses Node built-in modules (`http`, `fs`, `path`, `node:sqlite` — the project's
+one-store DB backend) to read the machine-wide multi-repo index.
 
 ## Quick Start
 
@@ -74,7 +74,7 @@ The server runs as a detached child process, independent of the pi session. It:
 - Auto-discovers the state directory from the `port.pid` file
 - Cleans up stale `port.pid` files from dead processes
 - Supports `SIGTERM`/`SIGINT` for graceful shutdown
-- Serves static HTML; reads the multi-repo index from SQLite (`better-sqlite3`)
+- Serves static HTML; reads the multi-repo index from SQLite (`node:sqlite`)
 
 ## Browser UI
 

package/extensions/dashboard-server.test.ts

@@ -10,6 +10,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { spawn } from "node:child_process";
 
 // ---------------------------------------------------------------------------
 // helpers
@@ -122,3 +123,79 @@ describe("port.pid file", () => {
     rmSync(dir, { recursive: true });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Lifecycle integration — launch the compiled server as a real subprocess
+// (the same way the /dashboard command spawns it) and assert the two failure
+// modes that historically produced a silent "failed to start":
+//   1. a stale port.pid pointing at a dead port is dropped, and the server
+//      binds fresh (instead of returning the dead port);
+//   2. a module-load crash is captured to the launch log instead of going
+//      silent under stdio:"ignore".
+// ---------------------------------------------------------------------------
+
+const SERVER_ENTRY = new URL("./dashboard-server.js", import.meta.url).pathname;
+
+function waitFor(cond: () => boolean | Promise<boolean>, timeoutMs = 6000): Promise<void> {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    const tick = async () => {
+      if (await cond()) return resolve();
+      if (Date.now() - start > timeoutMs) return reject(new Error("timeout"));
+      setTimeout(tick, 50);
+    };
+    tick();
+  });
+}
+
+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 }));
+
+    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+    try {
+      // Wait for the server to actually be live (not just any port.pid — the
+      // stale marker already exists at t=0 and would pass a naive check).
+      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"));
+      assert.equal(typeof raw.port, "number");
+      assert.notEqual(raw.port, 9325, "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);
+    } finally {
+      child.kill("SIGTERM");
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("writes a dashboard.log with startup lines", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "dash-log-"));
+    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+    try {
+      await waitFor(() => {
+        try {
+          return /server running/.test(readFileSync(join(dir, "dashboard.log"), "utf-8"));
+        } catch {
+          return false;
+        }
+      });
+      const log = readFileSync(join(dir, "dashboard.log"), "utf-8");
+      assert.match(log, /\[mega-compact\]\[dashboard\]/);
+      assert.match(log, /server running/);
+    } finally {
+      child.kill("SIGTERM");
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/extensions/dashboard-server.ts

@@ -12,11 +12,31 @@
  */
 
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, watch, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, watch, writeFileSync, appendFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
+
+// ---------------------------------------------------------------------------
+// Local runtime log
+//
+// The dashboard server is spawned as a DETACHED child. When it is launched with
+// `stdio: "ignore"` (the old default) any crash before the first console.log is
+// invisible — there is no log to "check". We therefore mirror every lifecycle
+// line to a file in the state dir so a failed start is always diagnosable. The
+// launcher also captures stderr, so this doubles as defense-in-depth.
+// ---------------------------------------------------------------------------
+
+let LOG_PATH: string | null = null;
+function log(...parts: unknown[]): void {
+  const line = `[mega-compact][dashboard] ${parts.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ")}`;
+  // eslint-disable-next-line no-console
+  console.error(line); // stderr — captured by the launcher pipe
+  if (LOG_PATH) {
+    try { appendFileSync(LOG_PATH, new Date().toISOString() + " " + line + "\n"); } catch { /* non-fatal */ }
+  }
+}
 
 // --- Multi-repo index (Phase 5b) ------------------------------------------------
 // The extension writes a machine-wide repo registry into a single SQLite DB
@@ -54,11 +74,11 @@ interface IndexRepo {
 function readIndex(): { updatedAt: string; summary: unknown; repos: unknown[] } | null {
   const indexPath = join(getIndexDir(), "index.sqlite");
   if (!existsSync(indexPath)) return null;
-  let db: Database.Database | undefined;
+  let db: DatabaseSync | undefined;
   try {
     // Read-only + immutable WAL so a concurrent writer's WAL never blocks us.
-    db = new Database(indexPath, { readonly: true, fileMustExist: true });
-    db.pragma("journal_mode = WAL");
+    db = new DatabaseSync(indexPath, { readOnly: true });
+    db.exec("PRAGMA journal_mode = WAL");
     const rows = db
       .prepare("SELECT * FROM repo_registry ORDER BY last_seen DESC")
       .all() as Record<string, unknown>[];
@@ -738,7 +758,7 @@ function dashboardHtml(tierName: string): string {
 // Server
 // ---------------------------------------------------------------------------
 
-export function launchDashboardServer(stateDir: string): Promise<{ port: number; url: string }> {
+export async function launchDashboardServer(stateDir: string): Promise<{ port: number; url: string }> {
   // Our own package version — exposed at /api/version so the launcher can
   // detect a stale server (started by an older build) and replace it on
   // upgrade instead of reuse it.
@@ -757,17 +777,37 @@ export function launchDashboardServer(stateDir: string): Promise<{ port: number;
   const portFile = join(stateDir, "port.pid");
   const snapshotPath = join(stateDir, "dashboard.json");
   const eventsPath = join(stateDir, "events.log");
-
-  // ── Existing server? ──────────────────────────────────────────────────────
+  LOG_PATH = join(stateDir, "dashboard.log");
+  log("launch invoked", { stateDir });
+
+  // ── Existing server? ───────────────────────────────────────────────────────
+  // A stale port.pid pointing at a dead/competing process is the classic cause
+  // of "dashboard failed to start" — we return a port that is NOT actually
+  // serving. Probe for a live server on that port first; only reuse the marker
+  // when something real answers /api/version. Otherwise drop it and start fresh.
   if (existsSync(portFile)) {
     try {
       const info = JSON.parse(readFileSync(portFile, "utf-8"));
       if (info && info.port) {
-        return Promise.resolve({ port: info.port, url: `http://localhost:${info.port}` });
+        let live = false;
+        try {
+          const probe = await fetch(`http://localhost:${info.port}/api/version`, { signal: AbortSignal.timeout(800) });
+          live = probe.ok;
+        } catch {
+          live = false;
+        }
+        if (live) {
+          log("reusing live server from port.pid", { port: info.port });
+          return { port: info.port, url: `http://localhost:${info.port}` };
+        }
+        log("port.pid present but no live server — treating as stale", { port: info.port });
       }
     } catch {
-      // stale file, overwrite
+      log("port.pid unparseable — treating as stale");
     }
+    // stale file, remove so the fresh bind does not collide with a lingering
+    // process that still holds the port
+    try { unlinkSync(portFile); } catch { /* ignore */ }
   }
 
   // ── New server ────────────────────────────────────────────────────────────
@@ -891,20 +931,26 @@ export function launchDashboardServer(stateDir: string): Promise<{ port: number;
     function tryPort(port: number) {
       server.once("error", (err: NodeJS.ErrnoException) => {
         if (err.code === "EADDRINUSE" && port < TARGET_PORT + PORT_RANGE - 1) {
+          log("port in use, trying next", { port });
           tryPort(port + 1);
         } else {
+          log("listen failed", { port, code: err.code, message: err.message });
           reject(err);
         }
       });
 
       server.listen(port, "127.0.0.1", () => {
         const url = `http://localhost:${port}`;
+        log("server running", { url });
+        // eslint-disable-next-line no-console
         console.log(`[mega-compact] dashboard server running: ${url}`);
 
         // Write port.pid
         try {
           writeFileSync(portFile, JSON.stringify({ port, pid: process.pid }));
-        } catch { /* non-fatal */ }
+        } catch (e) {
+          log("could not write port.pid", { error: String(e) });
+        }
 
         // Graceful cleanup
         const cleanup = () => {

package/extensions/mega-compact-driver.ts

@@ -0,0 +1,105 @@
+/**
+ * mega-compact-driver.ts — the durable-trim driver (Fix B).
+ *
+ * The read-path token-growth bug: the old design cancelled pi's native
+ * compaction (`{ cancel: true }`) and did its own ephemeral `context`-hook
+ * drop. That drop only affected the outgoing request — the on-disk transcript
+ * was never trimmed (the session manager is read-only for extensions). So on
+ * resume pi reloaded the FULL transcript and we ADDED a recall block on top →
+ * more tokens than before compaction.
+ *
+ * The fix: on `session_before_compact` we RUN the Trident pipeline to produce a
+ * genuinely compressed summary, then RETURN it as a `CompactionResult`. pi
+ * durably writes our summary into a `compactionSummary` entry AND truncates the
+ * transcript from `firstKeptEntryId`. After that, resume reloads the already-
+ * trimmed transcript (summary baked in) — no additive re-injection, no token
+ * growth.
+ *
+ * We reuse pi's `preparation.firstKeptEntryId` (pi already computed the cut
+ * honoring the anchor-floor + tool-pair guards — PREVENT-PI-002) rather than
+ * recomputing it, so we cannot hand pi a boundary that splits a tool pair.
+ */
+
+import type { SessionBeforeCompactEvent } from "@earendil-works/pi-coding-agent";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { compactSession } from "../src/engine.js";
+import { toEngineMessages } from "../src/adapt.js";
+import { estimateBlockTokens, estimateSessionTokens } from "../src/tokens.js";
+import type { MegaRuntime } from "./mega-runtime.js";
+import type { MegaConfig } from "./mega-config.js";
+import { recallRaptorRootSummary } from "../src/dedup/raptor/index.js";
+
+export interface NativeCompactionResult {
+  /** Our trimmed summary + the pi entry to keep from (durable trim). */
+  compaction: {
+    summary: string;
+    firstKeptEntryId: string;
+    tokensBefore: number;
+    estimatedTokensAfter: number;
+  };
+}
+
+/**
+ * Build our durable compaction result from pi's pre-computed preparation.
+ *
+ * Returns undefined when there is nothing to summarize (pi will then run its
+ * own native compaction, or skip). Never throws for "empty" — best-effort.
+ */
+export function driveNativeCompaction(
+  event: SessionBeforeCompactEvent,
+  runtime: MegaRuntime,
+  config: MegaConfig,
+): NativeCompactionResult | undefined {
+  const prep = event.preparation;
+  if (!prep) return undefined;
+
+  const sid = runtime.rt.sessionId;
+  const messagesToSummarize: AgentMessage[] = prep.messagesToSummarize ?? [];
+  if (messagesToSummarize.length === 0) return undefined;
+
+  const engineView = toEngineMessages(messagesToSummarize);
+  // We don't drop anything here — pi keeps from prep.firstKeptEntryId. We only
+  // summarize the region pi is about to discard.
+  const keepFrom = engineView.length;
+
+  const result = compactSession(
+    {
+      sessionId: sid,
+      messages: engineView,
+      keepFrom,
+      timestamp: Date.now(),
+      useExtractiveSummary: true,
+    },
+    runtime.store,
+  );
+  if (result.skipped) return undefined;
+
+  // Prefer the RAPTOR root summary when the tree is built + enabled (Fix D):
+  // it is a session-level compressed summary, broader than one slice's. Fall
+  // back to the extractive topicSummary of this slice.
+  let summary = result.summary;
+  if (config.raptorEnabled) {
+    const root = recallRaptorRootSummary(sid, runtime.currentStateDir);
+    if (root) summary = root;
+  }
+
+  const tokensBefore = prep.tokensBefore ?? estimateSessionTokens(engineView);
+  const summaryTokens = estimateBlockTokens(summary);
+  // pi keeps the tail from firstKeptEntryId; our summary replaces the discarded
+  // region. Honest saved = discarded-region tokens − our summary tokens.
+  const savedTokens = Math.max(0, tokensBefore - summaryTokens);
+
+  runtime.rt.lastCompactedFrom = keepFrom;
+  runtime.rt.lastCompactedTokens = tokensBefore;
+  runtime.rt.tokensSaved += savedTokens;
+  runtime.rt.persistedThisSession = true;
+
+  return {
+    compaction: {
+      summary,
+      firstKeptEntryId: prep.firstKeptEntryId,
+      tokensBefore,
+      estimatedTokensAfter: summaryTokens,
+    },
+  };
+}