pi-mega-compact 0.4.21 → 0.4.24

package/dist/extensions/dashboard-server.js

@@ -11,11 +11,32 @@
  * @module
  */
 import { createServer } 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 = null;
+function log(...parts) {
+    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
 // (<indexDir>/index.sqlite) as the concurrency-safe write path; the dashboard
@@ -42,8 +63,8 @@ function readIndex() {
     let db;
     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();
@@ -651,7 +672,7 @@ function dashboardHtml(tierName) {
 // ---------------------------------------------------------------------------
 // Server
 // ---------------------------------------------------------------------------
-export function launchDashboardServer(stateDir) {
+export async function launchDashboardServer(stateDir) {
     // 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.
@@ -675,17 +696,41 @@ export function launchDashboardServer(stateDir) {
     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 ────────────────────────────────────────────────────────────
     mkdirSync(stateDir, { recursive: true });
@@ -799,20 +844,26 @@ export function launchDashboardServer(stateDir) {
         function tryPort(port) {
             server.once("error", (err) => {
                 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 = () => {
                     try {

package/dist/extensions/dashboard-server.test.js

@@ -9,6 +9,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
 // ---------------------------------------------------------------------------
@@ -109,3 +110,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, timeoutMs = 6000) {
+    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/dist/extensions/mega-compact-driver.js

@@ -0,0 +1,79 @@
+/**
+ * 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 { compactSession } from "../src/engine.js";
+import { toEngineMessages } from "../src/adapt.js";
+import { estimateBlockTokens, estimateSessionTokens } from "../src/tokens.js";
+import { recallRaptorRootSummary } from "../src/dedup/raptor/index.js";
+/**
+ * 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, runtime, config) {
+    const prep = event.preparation;
+    if (!prep)
+        return undefined;
+    const sid = runtime.rt.sessionId;
+    const messagesToSummarize = 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,
+        },
+    };
+}

package/dist/extensions/mega-compact.test.js

@@ -42,6 +42,7 @@ function harness(opts = {}) {
     let statusKey;
     let statusText;
     const notifies = [];
+    const compactCalls = [];
     // Minimal AgentMessage factory for the session we project into the extension.
     function msg(role, text, toolName) {
         if (role === "assistant" && toolName) {
@@ -100,7 +101,27 @@ function harness(opts = {}) {
             hasPendingMessages: () => false,
             shutdown: () => { },
             getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }),
-            compact: () => { },
+            // Faithful mock: ctx.compact() starts pi's flow, which fires the
+            // session_before_compact handler (where WE supply the durable trim).
+            compact: (opts) => {
+                compactCalls.push(opts);
+                if (handlers["session_before_compact"]) {
+                    return handlers["session_before_compact"]({
+                        type: "session_before_compact",
+                        reason: "threshold",
+                        willRetry: false,
+                        signal: undefined,
+                        // pi computed the cut honoring anchor floor + tool-pair (PREVENT-PI-002);
+                        // our handler reuses it as firstKeptEntryId.
+                        preparation: {
+                            firstKeptEntryId: "e2",
+                            messagesToSummarize: session.slice(0, 2),
+                            tokensBefore: 500,
+                        },
+                    }, makeCtx());
+                }
+                return undefined;
+            },
             getSystemPrompt: () => "system base",
             ...over,
         };
@@ -133,13 +154,13 @@ function harness(opts = {}) {
     const mod = require("./mega-compact.js");
     mod.default(pi);
     return {
-        stateDir, handlers, commands, appended, get status() { return { statusKey, statusText }; }, notifies,
+        stateDir, handlers, commands, appended, get status() { return { statusKey, statusText }; }, notifies, compactCalls,
         fire: (ev, event, ctx) => handlers[ev](event, ctx),
         ctx: makeCtx,
         session,
     };
 }
-test("auto-trigger: past threshold persists a chkpt and drops context", async () => {
+test("auto-trigger: past threshold persists a chkpt and starts a durable trim", async () => {
     const h = harness();
     const messages = h.session;
     const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
@@ -148,25 +169,40 @@ test("auto-trigger: past threshold persists a chkpt and drops context", async ()
     const { listCheckpoints } = await import("../src/store/sqlite.js");
     assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "checkpoint persisted to local vector db");
     assert.equal(h.appended.some((a) => a.t === "mega-compact-marker"), true, "marker sentinel appended");
-    // Context dropped (the compacted range was trimmed).
-    assert.ok(res && Array.isArray(res.messages), "context handler returns filtered messages");
-    assert.ok(res.messages.length < messages.length, "outgoing context shrank");
+    // The context handler no longer drops messages itself (that was ephemeral —
+    // the read-path token-growth bug). It triggers pi's compaction flow, which
+    // calls our session_before_compact handler to supply the DURABLE trim.
+    assert.equal(res, undefined, "context handler returns nothing (no local drop)");
+    assert.equal(h.compactCalls.length, 1, "ctx.compact() called to start durable trim");
+    // The durable trim was supplied (summary + firstKeptEntryId from pi's prep).
+    assert.ok(h.compactCalls[0] !== undefined, "compaction flow executed");
 });
-test("session_before_compact cancels once we've persisted", async () => {
+test("session_before_compact supplies our durable trim (not pi's summary)", async () => {
     const h = harness();
-    const ctx = h.ctx();
-    // First fire the auto-trigger so a checkpoint is persisted this session.
-    await h.fire("context", { type: "context", messages: h.session }, h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) }));
-    // Now pi tries to compact natively — we must cancel (no double-compact).
-    const res = await h.fire("session_before_compact", { type: "session_before_compact", reason: "overflow", willRetry: true, preparation: {}, signal: undefined }, ctx);
-    assert.deepEqual(res, { cancel: true });
+    // pi fires session_before_compact with its own computed preparation.
+    const res = await h.fire("session_before_compact", {
+        type: "session_before_compact",
+        reason: "overflow",
+        willRetry: true,
+        preparation: { firstKeptEntryId: "e2", messagesToSummarize: h.session.slice(0, 2), tokensBefore: 500 },
+        signal: undefined,
+    }, h.ctx());
+    assert.ok(res && res.compaction, "returns a compaction result");
+    assert.equal(res.compaction.firstKeptEntryId, "e2", "reuses pi's cut boundary (PREVENT-PI-002 safe)");
+    assert.ok(typeof res.compaction.summary === "string" && res.compaction.summary.length > 0, "our summary supplied");
+    assert.ok(res.compaction.tokensBefore >= 0, "tokensBefore reported");
 });
-test("session_before_compact does NOT cancel when nothing persisted", async () => {
+test("session_before_compact falls back to pi when nothing to summarize", async () => {
     const h = harness();
-    const ctx = h.ctx();
-    // Do NOT fire context first; this session has no checkpoint.
-    const res = await h.fire("session_before_compact", { type: "session_before_compact", reason: "threshold", willRetry: false, preparation: {}, signal: undefined }, ctx);
-    assert.deepEqual(res, {});
+    // Empty preparation → no messages to summarize → return {} so pi compacts natively.
+    const res = await h.fire("session_before_compact", {
+        type: "session_before_compact",
+        reason: "threshold",
+        willRetry: false,
+        preparation: { firstKeptEntryId: "e0", messagesToSummarize: [], tokensBefore: 0 },
+        signal: undefined,
+    }, h.ctx());
+    assert.deepEqual(res, {}, "no compaction supplied → pi runs its own");
 });
 test("resume auto-inline stages recall into the system prompt", async () => {
     const h = harness();

package/dist/extensions/mega-config.js

@@ -46,6 +46,12 @@ function resolveThreshold() {
     const tier = (raw in COMPACT_TIERS ? raw : "low");
     return { tier, thresholdTokens: COMPACT_TIERS[tier] };
 }
+/**
+ * Pressure helpers for adaptive compression (Fix E) live in src/config.ts
+ * (pi-agnostic) so unit tests can import them without the pi runtime. Re-export
+ * here so the extension has one import surface.
+ */
+export { pressureFromPct, preserveRecentForPressure } from "../src/config.js";
 /** Build the resolved config from env + defaults. */
 export function loadConfig() {
     const { tier, thresholdTokens } = resolveThreshold();
@@ -58,10 +64,14 @@ export function loadConfig() {
         thresholdTokens,
         anchorUserMessages: envFlag("MEGACOMPACT_ANCHOR_USER_MESSAGES", 3),
         preserveRecent: envFlag("MEGACOMPACT_PRESERVE_RECENT", 4),
+        preserveRecentMin: envFlag("MEGACOMPACT_PRESERVE_RECENT_MIN", 2),
         auto: envBool("MEGACOMPACT_AUTO", true),
         autoInline: envBool("MEGACOMPACT_AUTO_INLINE", true),
         autoInlineK: envFlag("MEGACOMPACT_AUTO_INLINE_K", 3),
         dedupSim: Number(process.env.MEGACOMPACT_DEDUP_SIM ?? "0.9"),
+        raptorEnabled: envBool("MEGACOMPACT_RAPTOR_ENABLED", true),
+        recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
+        windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
         debug: envBool("MEGACOMPACT_DEBUG", false),
     };
 }

package/dist/extensions/mega-dashboard-cmds.js

@@ -7,7 +7,7 @@
  */
 import { join, dirname, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, writeFileSync, readFileSync, unlinkSync, openSync, closeSync } from "node:fs";
 import { spawn } from "node:child_process"; // guardrails-allow PREVENT-PI-004: spawns the optional, user-triggered localhost dashboard server only
 /** Register the dashboard server lifecycle commands. */
 export function registerDashboardCommands(pi, runtime) {
@@ -213,11 +213,41 @@ export function registerDashboardCommands(pi, runtime) {
                 ctx.ui.notify("[mega-compact] dashboard entry not found — check logs.");
                 return;
             }
+            // Clear any stale marker so a fresh bind never collides with a lingering
+            // orphan, and truncate the launch log so the next error report shows only
+            // this attempt's output.
+            try {
+                unlinkSync(portFile);
+            }
+            catch { /* ignore */ }
+            try {
+                writeFileSync(launchLog, "");
+            }
+            catch { /* ignore */ }
             const args = dashboardNeedsStrip ? ["--experimental-strip-types", runnerFile] : [runnerFile];
+            // Redirect the child's stderr to the launch log so that a CRASH BEFORE the
+            // runner's own __fail handler runs (e.g. an ESM module-load / parse error,
+            // or a missing entry) is still captured. With the old `stdio: "ignore"`
+            // these failures were completely silent and the "check logs" message
+            // pointed at an empty file. We open the fd in the parent and pass it to the
+            // child; once spawned we close our copy (the child keeps its own dup).
+            let stderrFd;
+            try {
+                stderrFd = openSync(launchLog, "a");
+            }
+            catch {
+                stderrFd = -1; // fall back to ignored stderr
+            }
             const child = spawn(process.execPath, args, {
                 detached: true,
-                stdio: "ignore",
+                stdio: ["ignore", "ignore", stderrFd >= 0 ? stderrFd : "ignore"],
             });
+            if (stderrFd >= 0) {
+                try {
+                    closeSync(stderrFd);
+                }
+                catch { /* ignore */ }
+            }
             child.unref();
             // Poll for a live server (port 9320–9329) instead of relying solely on the
             // port.pid marker, which can land in a different state dir than the one we

package/dist/extensions/mega-events.js

@@ -9,9 +9,10 @@
 import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens } from "../src/tokens.js";
-import { dropCompactedRange } from "../src/adapt.js";
 import { recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
 import { runCompact, doRecall } from "./mega-pipeline.js";
+import { driveNativeCompaction } from "./mega-compact-driver.js";
+import { pressureFromPct } from "./mega-config.js";
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi, runtime, config) {
     // ---- Session lifecycle (state reset points) -------------------------------
@@ -108,7 +109,15 @@ export function registerEventHandlers(pi, runtime, config) {
         runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
         runtime.snapshot(ctx);
     });
-    // ---- Auto-trigger: fast-gate → confirm → Trident+persist → drop --------
+    // ---- Auto-trigger: own the decision, pi owns the durable write ----------
+    // OUR auto-trigger (over threshold + debounce): persist our Trident checkpoint,
+    // then start pi's compaction flow via ctx.compact(). That fires
+    // `session_before_compact`, where OUR handler returns our summary +
+    // firstKeptEntryId, and pi durably writes the trim to disk (appendCompaction).
+    // Result: auto-compact AND a durable trim — resume reloads the trimmed window,
+    // no full-reload + additive recall inflation (Fix B kills the token-growth bug).
+    // We do NOT drop messages here (that would be ephemeral; the read-only session
+    // manager can't trim disk, so the trim has to come through pi).
     pi.on("context", async (event, ctx) => {
         if (!config.auto)
             return;
@@ -123,13 +132,9 @@ export function registerEventHandlers(pi, runtime, config) {
             return;
         const messages = event.messages;
         const view = runtime.engineView(messages);
-        // Prefer the runtime's real token estimate; fall back to our heuristic
-        // (and to a percent-of-window proxy when tokens is unknown).
         const currentTokens = usage?.tokens ?? estimateSessionTokens(view) ??
             Math.round((pct / 100) * (usage?.contextWindow ?? 0));
         // FAST GATE: token-based (tier threshold), not percentage-based.
-        // A 20% gate on a 2M window = 400k, which is way above the 50k low-tier
-        // threshold. Gate on the actual token count instead.
         if (currentTokens < config.thresholdTokens)
             return;
         const check = autoCompactCheck(currentTokens, config.thresholdTokens); // SERVER-STYLE CONFIRM (local)
@@ -140,28 +145,45 @@ export function registerEventHandlers(pi, runtime, config) {
         if (now < runtime.debounceUntil)
             return;
         runtime.debounceUntil = now + 2000;
-        const ran = runCompact(pi, runtime, config, ctx, messages);
+        // Adaptive compression (Fix E): scale compression strength + keepFrom depth
+        // with how close we are to the model context limit.
+        const pressure = pressureFromPct(pct);
+        const ran = runCompact(pi, runtime, config, ctx, messages, { compressionPressure: pressure });
         if (ran.skipped)
             return;
-        // DROP the compacted range from the outgoing context, honoring the anchor
-        // floor + tool-pair boundary guards (PREVENT-PI-001/002).
-        const kept = dropCompactedRange(messages, ran.keepFrom, config.anchorUserMessages);
-        if (kept.length < messages.length) {
-            return { messages: kept };
-        }
+        // Start pi's compaction flow so our session_before_compact handler can
+        // supply the durable trim (pi writes it to disk). We never use pi's summary.
+        ctx.compact({ customInstructions: undefined });
     });
-    // ---- Cancel native compaction once we've persisted our own -------------
-    pi.on("session_before_compact", async (_event, ctx) => {
+    // ---- Supply a DURABLE trim to pi's native compaction (Fix B) ----------
+    // We run the Trident pipeline to produce a compressed summary, then return
+    // it as a CompactionResult. pi writes the summary into a compactionSummary
+    // entry AND truncates the on-disk transcript from firstKeptEntryId. This is
+    // the durable fix for "tokens grow on read": the trim survives resume, so
+    // there is no full-reload + additive recall inflation.
+    pi.on("session_before_compact", async (event, ctx) => {
         runtime.resetRuntime(ctx.sessionManager.getSessionId());
-        if (runtime.rt.persistedThisSession) {
-            // We already persisted a checkpoint for this session (via the context
-            // hook drop) — cancel pi's own compaction to avoid double-compacting.
-            // Our context-hook drop already trimmed the window.
-            return { cancel: true };
+        if (!config.auto)
+            return {}; // let pi run its own native compaction
+        try {
+            const result = driveNativeCompaction(event, runtime, config);
+            if (result) {
+                runtime.logger.info("native-compact", {
+                    sessionId: runtime.rt.sessionId,
+                    firstKeptEntryId: result.compaction.firstKeptEntryId,
+                    tokensBefore: result.compaction.tokensBefore,
+                    summaryTokens: result.compaction.estimatedTokensAfter,
+                });
+                return { compaction: result.compaction };
+            }
+        }
+        catch (err) {
+            runtime.logger.error("native-compact-failed", {
+                sessionId: runtime.rt.sessionId,
+                error: String(err instanceof Error ? err.message : err),
+            });
         }
-        // We haven't persisted yet this session: let pi run its native compaction.
-        // (Our auto-trigger only fires again past the threshold, and will then
-        // capture a checkpoint next time around.)
+        // Fall back to pi's own native compaction if we can't supply one.
         return {};
     });
 }