pi-mega-compact 0.4.26 → 0.4.28

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

@@ -77,6 +77,9 @@ function harness(opts = {}) {
     const sessionManager = {
         getSessionId: () => "sess_ext_001",
         getEntries: () => session.map(toEntry),
+        // Faithful mock: getBranch() returns the current branch's entries, which
+        // piCompactWouldNoop() reads to predict whether ctx.compact() would no-op.
+        getBranch: () => session.map(toEntry),
     };
     function makeCtx(over = {}) {
         return {
@@ -163,19 +166,46 @@ function harness(opts = {}) {
 test("auto-trigger: past threshold persists a chkpt and starts a durable trim", async () => {
     const h = harness();
     const messages = h.session;
+    // The mock session is tiny (~100 tokens). piCompactWouldNoop() would skip
+    // ctx.compact() for a transcript under pi's keepRecentTokens budget — so
+    // lower the floor to 0 to simulate a transcript large enough that pi WOULD
+    // compact (the positive path this test exercises).
+    process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0";
+    try {
+        const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+        const res = await h.fire("context", { type: "context", messages }, ctx);
+        // L1->L4 ran: a checkpoint was persisted to the SQLite store + a marker entry written.
+        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");
+        // 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");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+    }
+});
+test("auto-trigger: skips ctx.compact() when pi would no-op (session too small)", async () => {
+    const h = harness();
+    const messages = h.session;
+    // Default floor (20000): the tiny mock transcript is below pi's
+    // keepRecentTokens budget, so piCompactWouldNoop() must skip ctx.compact()
+    // rather than surface pi's "Nothing to compact (session too small)" throw.
+    delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
     const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
     const res = await h.fire("context", { type: "context", messages }, ctx);
-    // L1->L4 ran: a checkpoint was persisted to the SQLite store + a marker entry written.
-    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");
-    // 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");
+    assert.equal(h.compactCalls.length, 0, "ctx.compact() NOT called — pi would no-op");
+    // Our recall checkpoint still persisted (Path A) — the durable trim is the
+    // only thing skipped; recall is independent of it.
+    const { listCheckpoints } = await import("../src/store/sqlite.js");
+    assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "recall checkpoint still persisted");
+    assert.equal(h.appended.some((a) => a.t === "mega-compact-marker"), true, "marker sentinel still appended");
 });
 test("session_before_compact supplies our durable trim (not pi's summary)", async () => {
     const h = harness();

package/dist/extensions/mega-events.js

@@ -10,7 +10,7 @@ import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens } from "../src/tokens.js";
 import { recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
-import { runCompact, doRecall } from "./mega-pipeline.js";
+import { runCompact, doRecall, piCompactWouldNoop } from "./mega-pipeline.js";
 import { driveNativeCompaction } from "./mega-compact-driver.js";
 import { pressureFromPct } from "./mega-config.js";
 /** Register all pi lifecycle event handlers. */
@@ -151,6 +151,14 @@ export function registerEventHandlers(pi, runtime, config) {
         const ran = runCompact(pi, runtime, config, ctx, messages, { compressionPressure: pressure });
         if (ran.skipped)
             return;
+        // Skip pi's durable-trim flow when pi would no-op ("Nothing to compact /
+        // Already compacted"). pi throws that error *before* session_before_compact
+        // fires and renders it via a compaction_end event we can't mute (onError is
+        // too late), so the only fix is to not call ctx.compact() on a no-op. Our
+        // recall checkpoint above is already persisted; the durable trim is
+        // unnecessary for a transcript pi would keep in full anyway.
+        if (piCompactWouldNoop(ctx))
+            return;
         // 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 });

package/dist/extensions/mega-pipeline.js

@@ -10,6 +10,7 @@ import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import { compactSession } from "../src/engine.js";
 import { recallAndInline } from "../src/recall.js";
 import { normalizeSessionId } from "../src/store.js";
+import { estimateBlockTokens } from "../src/tokens.js";
 import { touchSession, logDaily } from "../src/store/sqlite.js";
 import { C, MARKER_TYPE, } from "./mega-runtime.js";
 import { resolveRepoRoot, preserveRecentForPressure } from "./mega-config.js";
@@ -27,8 +28,19 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
     // compact more of the session, down to the preserveRecentMin floor.
     const preserve = preserveRecentForPressure(opts.compressionPressure ?? 0, config.preserveRecent, config.preserveRecentMin);
     const keepFrom = opts.keepFrom ?? Math.max(0, view.length - preserve);
-    if (keepFrom <= 0)
-        return { skipped: true };
+    // For very small sessions (fewer messages than preserveRecent), allow
+    // compacting everything except the last message — the user explicitly
+    // requested compaction, so don't refuse it just because the session is short.
+    if (keepFrom <= 0) {
+        if (view.length <= 1)
+            return { skipped: true };
+        // Use the fallback: compact everything except the last message
+        const fallbackKeepFrom = view.length - 1;
+        return doCompact(view, fallbackKeepFrom, opts, sid, config, pi, ctx, runtime);
+    }
+    return doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime);
+}
+function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     runtime.pulsing = true; // animate the status line while the (sync) pipeline runs
     const result = compactSession({
         sessionId: sid,
@@ -170,6 +182,100 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
     runtime.snapshot(ctx);
     return { skipped: false, result, keepFrom, saved };
 }
+/**
+ * Predict whether pi's `ctx.compact()` would throw a no-op error — "Already
+ * compacted" or "Nothing to compact (session too small)" — so the auto-trigger
+ * can SKIP the call instead of surfacing a hard, user-facing error.
+ *
+ * Why we can't intercept or suppress it: pi's public `compact()` computes
+ * `prepareCompaction()` and throws *before* it emits `session_before_compact`,
+ * so our handler there never runs on the no-op path. And `ctx.compact()`'s
+ * `onError` callback fires only AFTER pi has already emitted a `compaction_end`
+ * event carrying the error message (which the interactive UI renders) — so
+ * `onError` cannot mute it either. The only robust fix is to not call
+ * `ctx.compact()` when pi would no-op. (pi's own `_runAutoCompaction` path is
+ * silent on this same condition; the public path we're forced through is the
+ * one that throws.)
+ *
+ * Skipping is correct, not a compromise: by the time this runs, `runCompact()`
+ * has already persisted the recall checkpoint (Path A). The durable on-disk
+ * trim is only useful when pi can actually summarize a region; a transcript
+ * under pi's `keepRecentTokens` budget is small enough that reloading it on
+ * resume isn't a token-growth problem, so the durable trim is unnecessary
+ * there anyway.
+ *
+ * Mirrors pi's `prepareCompaction()` return-undefined conditions (compaction.js):
+ *  (1) last entry is a compaction      → "Already compacted"
+ *  (2) <2 cut-point messages since the last compaction → nothing to summarize
+ *      (a cut point = any non-toolResult message — user/assistant/bash/custom/
+ *       branchSummary/compactionSummary — matching pi's isCutPointMessage)
+ *  (3) transcript tokens since the last compaction < keepRecentTokens → pi
+ *      keeps everything → nothing to summarize
+ * `keepRecentTokens` isn't readable from the extension API, so (3) uses the pi
+ * default (20000) as a conservative floor; raise it via
+ * `MEGACOMPACT_DURABLE_TRIM_FLOOR` if you raise pi's `compact.keepRecentTokens`.
+ *
+ * Best-effort: on any read error returns true (skip) — skipping a durable trim
+ * is always safe; calling `ctx.compact()` on a no-op throws to the user.
+ */
+export function piCompactWouldNoop(ctx) {
+    try {
+        const branch = ctx.sessionManager.getBranch();
+        if (branch.length === 0)
+            return true;
+        // (1) already compacted — pi throws "Already compacted"
+        if (branch[branch.length - 1].type === "compaction")
+            return true;
+        // boundaryStart = index just after the most recent compaction entry (or 0)
+        let boundaryStart = 0;
+        for (let i = branch.length - 1; i >= 0; i--) {
+            if (branch[i].type === "compaction") {
+                boundaryStart = i + 1;
+                break;
+            }
+        }
+        let cutPoints = 0;
+        let tokens = 0;
+        for (let i = boundaryStart; i < branch.length; i++) {
+            const e = branch[i];
+            if (e.type === "compaction")
+                continue;
+            let isCut = false;
+            for (const m of sessionEntryToContextMessages(e)) {
+                // pi's isCutPointMessage: every role except toolResult
+                if (m.role !== "toolResult")
+                    isCut = true;
+                const c = m.content;
+                const text = typeof c === "string" ? c
+                    : Array.isArray(c)
+                        ? c.map((b) => b?.text ?? "").join(" ")
+                        : "";
+                if (text)
+                    tokens += estimateBlockTokens(text);
+            }
+            if (isCut)
+                cutPoints++;
+        }
+        // (2) need >=2 cut points so the kept cut isn't the first message
+        if (cutPoints < 2)
+            return true;
+        // (3) transcript under pi's keepRecentTokens budget → pi keeps everything
+        if (tokens < durableTrimFloorTokens())
+            return true;
+        return false;
+    }
+    catch {
+        return true; // safe: skip the durable trim rather than risk a user-facing throw
+    }
+}
+/** pi's default keepRecentTokens (compaction settings). Override with
+ *  MEGACOMPACT_DURABLE_TRIM_FLOOR if you raise pi's compact.keepRecentTokens. */
+function durableTrimFloorTokens() {
+    const raw = process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+    if (raw !== undefined && Number.isFinite(Number(raw)))
+        return Number(raw);
+    return 20_000;
+}
 /**
  * Unified recall (Layer 5). The ONE path that injects. Returns the recall
  * result; callers decide whether to stage it for before_agent_start (resume)

package/extensions/mega-compact.test.ts

@@ -83,6 +83,9 @@ function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
   const sessionManager = {
     getSessionId: () => "sess_ext_001",
     getEntries: () => session.map(toEntry),
+    // Faithful mock: getBranch() returns the current branch's entries, which
+    // piCompactWouldNoop() reads to predict whether ctx.compact() would no-op.
+    getBranch: () => session.map(toEntry),
   };
 
   function makeCtx(over: Partial<any> = {}) {
@@ -177,19 +180,46 @@ function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
 test("auto-trigger: past threshold persists a chkpt and starts a durable trim", async () => {
   const h = harness();
   const messages = h.session;
+  // The mock session is tiny (~100 tokens). piCompactWouldNoop() would skip
+  // ctx.compact() for a transcript under pi's keepRecentTokens budget — so
+  // lower the floor to 0 to simulate a transcript large enough that pi WOULD
+  // compact (the positive path this test exercises).
+  process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0";
+  try {
+    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+    const res = await h.fire("context", { type: "context", messages }, ctx);
+    // L1->L4 ran: a checkpoint was persisted to the SQLite store + a marker entry written.
+    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");
+    // 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");
+  } finally {
+    delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+  }
+});
+
+test("auto-trigger: skips ctx.compact() when pi would no-op (session too small)", async () => {
+  const h = harness();
+  const messages = h.session;
+  // Default floor (20000): the tiny mock transcript is below pi's
+  // keepRecentTokens budget, so piCompactWouldNoop() must skip ctx.compact()
+  // rather than surface pi's "Nothing to compact (session too small)" throw.
+  delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
   const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
   const res = await h.fire("context", { type: "context", messages }, ctx);
-  // L1->L4 ran: a checkpoint was persisted to the SQLite store + a marker entry written.
-  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");
-  // 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");
+  assert.equal(h.compactCalls.length, 0, "ctx.compact() NOT called — pi would no-op");
+  // Our recall checkpoint still persisted (Path A) — the durable trim is the
+  // only thing skipped; recall is independent of it.
+  const { listCheckpoints } = await import("../src/store/sqlite.js");
+  assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "recall checkpoint still persisted");
+  assert.equal(h.appended.some((a) => a.t === "mega-compact-marker"), true, "marker sentinel still appended");
 });
 
 test("session_before_compact supplies our durable trim (not pi's summary)", async () => {

package/extensions/mega-events.ts

@@ -12,7 +12,7 @@ import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens } from "../src/tokens.js";
 import { MegaRuntime, recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
-import { runCompact, doRecall } from "./mega-pipeline.js";
+import { runCompact, doRecall, piCompactWouldNoop } from "./mega-pipeline.js";
 import { driveNativeCompaction } from "./mega-compact-driver.js";
 import { pressureFromPct, type MegaConfig } from "./mega-config.js";
 
@@ -162,6 +162,14 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     const ran = runCompact(pi, runtime, config, ctx, messages, { compressionPressure: pressure });
     if (ran.skipped) return;
 
+    // Skip pi's durable-trim flow when pi would no-op ("Nothing to compact /
+    // Already compacted"). pi throws that error *before* session_before_compact
+    // fires and renders it via a compaction_end event we can't mute (onError is
+    // too late), so the only fix is to not call ctx.compact() on a no-op. Our
+    // recall checkpoint above is already persisted; the durable trim is
+    // unnecessary for a transcript pi would keep in full anyway.
+    if (piCompactWouldNoop(ctx)) return;
+
     // 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 });

package/extensions/mega-pipeline.ts

@@ -11,8 +11,10 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { compactSession } from "../src/engine.js";
+import type { EngineMessage } from "../src/types.js";
 import { recallAndInline } from "../src/recall.js";
 import { normalizeSessionId } from "../src/store.js";
+import { estimateBlockTokens } from "../src/tokens.js";
 import { touchSession, logDaily } from "../src/store/sqlite.js";
 import {
   MegaRuntime,
@@ -51,8 +53,29 @@ export function runCompact(
     config.preserveRecentMin,
   );
   const keepFrom = opts.keepFrom ?? Math.max(0, view.length - preserve);
-  if (keepFrom <= 0) return { skipped: true };
+  // For very small sessions (fewer messages than preserveRecent), allow
+  // compacting everything except the last message — the user explicitly
+  // requested compaction, so don't refuse it just because the session is short.
+  if (keepFrom <= 0) {
+    if (view.length <= 1) return { skipped: true };
+    // Use the fallback: compact everything except the last message
+    const fallbackKeepFrom = view.length - 1;
+    return doCompact(view, fallbackKeepFrom, opts, sid, config, pi, ctx, runtime);
+  }
+
+  return doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime);
+}
 
+function doCompact(
+  view: EngineMessage[],
+  keepFrom: number,
+  opts: { keepFrom?: number; summary?: string; compressionPressure?: number },
+  sid: string,
+  config: MegaConfig,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  runtime: MegaRuntime,
+): RunCompactResult {
   runtime.pulsing = true; // animate the status line while the (sync) pipeline runs
   const result = compactSession(
     {
@@ -212,6 +235,90 @@ export function runCompact(
   return { skipped: false, result, keepFrom, saved };
 }
 
+/**
+ * Predict whether pi's `ctx.compact()` would throw a no-op error — "Already
+ * compacted" or "Nothing to compact (session too small)" — so the auto-trigger
+ * can SKIP the call instead of surfacing a hard, user-facing error.
+ *
+ * Why we can't intercept or suppress it: pi's public `compact()` computes
+ * `prepareCompaction()` and throws *before* it emits `session_before_compact`,
+ * so our handler there never runs on the no-op path. And `ctx.compact()`'s
+ * `onError` callback fires only AFTER pi has already emitted a `compaction_end`
+ * event carrying the error message (which the interactive UI renders) — so
+ * `onError` cannot mute it either. The only robust fix is to not call
+ * `ctx.compact()` when pi would no-op. (pi's own `_runAutoCompaction` path is
+ * silent on this same condition; the public path we're forced through is the
+ * one that throws.)
+ *
+ * Skipping is correct, not a compromise: by the time this runs, `runCompact()`
+ * has already persisted the recall checkpoint (Path A). The durable on-disk
+ * trim is only useful when pi can actually summarize a region; a transcript
+ * under pi's `keepRecentTokens` budget is small enough that reloading it on
+ * resume isn't a token-growth problem, so the durable trim is unnecessary
+ * there anyway.
+ *
+ * Mirrors pi's `prepareCompaction()` return-undefined conditions (compaction.js):
+ *  (1) last entry is a compaction      → "Already compacted"
+ *  (2) <2 cut-point messages since the last compaction → nothing to summarize
+ *      (a cut point = any non-toolResult message — user/assistant/bash/custom/
+ *       branchSummary/compactionSummary — matching pi's isCutPointMessage)
+ *  (3) transcript tokens since the last compaction < keepRecentTokens → pi
+ *      keeps everything → nothing to summarize
+ * `keepRecentTokens` isn't readable from the extension API, so (3) uses the pi
+ * default (20000) as a conservative floor; raise it via
+ * `MEGACOMPACT_DURABLE_TRIM_FLOOR` if you raise pi's `compact.keepRecentTokens`.
+ *
+ * Best-effort: on any read error returns true (skip) — skipping a durable trim
+ * is always safe; calling `ctx.compact()` on a no-op throws to the user.
+ */
+export function piCompactWouldNoop(ctx: ExtensionContext): boolean {
+  try {
+    const branch = ctx.sessionManager.getBranch();
+    if (branch.length === 0) return true;
+    // (1) already compacted — pi throws "Already compacted"
+    if (branch[branch.length - 1].type === "compaction") return true;
+    // boundaryStart = index just after the most recent compaction entry (or 0)
+    let boundaryStart = 0;
+    for (let i = branch.length - 1; i >= 0; i--) {
+      if (branch[i].type === "compaction") { boundaryStart = i + 1; break; }
+    }
+    let cutPoints = 0;
+    let tokens = 0;
+    for (let i = boundaryStart; i < branch.length; i++) {
+      const e = branch[i];
+      if (e.type === "compaction") continue;
+      let isCut = false;
+      for (const m of sessionEntryToContextMessages(e)) {
+        // pi's isCutPointMessage: every role except toolResult
+        if ((m as { role?: string }).role !== "toolResult") isCut = true;
+        const c = (m as { content?: unknown }).content;
+        const text =
+          typeof c === "string" ? c
+          : Array.isArray(c)
+            ? (c as { text?: string }[]).map((b) => b?.text ?? "").join(" ")
+            : "";
+        if (text) tokens += estimateBlockTokens(text);
+      }
+      if (isCut) cutPoints++;
+    }
+    // (2) need >=2 cut points so the kept cut isn't the first message
+    if (cutPoints < 2) return true;
+    // (3) transcript under pi's keepRecentTokens budget → pi keeps everything
+    if (tokens < durableTrimFloorTokens()) return true;
+    return false;
+  } catch {
+    return true; // safe: skip the durable trim rather than risk a user-facing throw
+  }
+}
+
+/** pi's default keepRecentTokens (compaction settings). Override with
+ *  MEGACOMPACT_DURABLE_TRIM_FLOOR if you raise pi's compact.keepRecentTokens. */
+function durableTrimFloorTokens(): number {
+  const raw = process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+  if (raw !== undefined && Number.isFinite(Number(raw))) return Number(raw);
+  return 20_000;
+}
+
 /**
  * Unified recall (Layer 5). The ONE path that injects. Returns the recall
  * result; callers decide whether to stage it for before_agent_start (resume)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.4.26",
+  "version": "0.4.28",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",
@@ -42,7 +42,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "lint": "tsc --noEmit && node scripts/guardrails-scan.mjs",
-    "test": "npm run build && node --test \"dist/src/**/*.test.js\" \"dist/extensions/**/*.test.js\"",
+    "test": "npm run build && node --test --test-timeout=180000 \"dist/src/**/*.test.js\" \"dist/extensions/**/*.test.js\"",
     "guardrails": "python3 scripts/regression_check.py --all || node scripts/guardrails-scan.mjs",
     "precommit": "bash .claude/hooks/pre-commit.sh",
     "prepublishOnly": "npm run build",