pi-mega-compact 0.6.9 → 0.7.0

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

@@ -47,12 +47,39 @@ function harness(opts = {}) {
     // Minimal AgentMessage factory for the session we project into the extension.
     function msg(role, text, toolName) {
         if (role === "assistant" && toolName) {
-            return { role: "assistant", content: [{ type: "toolCall", name: toolName, id: "c1", arguments: {} }], api: "anthropic-messages", provider: "anthropic", model: "m", usage: { inputTokens: 1, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 }, stopReason: "tool_use", timestamp: 0 };
+            return {
+                role: "assistant",
+                content: [
+                    { type: "toolCall", name: toolName, id: "c1", arguments: {} },
+                ],
+                api: "anthropic-messages",
+                provider: "anthropic",
+                model: "m",
+                usage: {
+                    inputTokens: 1,
+                    outputTokens: 1,
+                    cacheReadTokens: 0,
+                    cacheWriteTokens: 0,
+                },
+                stopReason: "tool_use",
+                timestamp: 0,
+            };
         }
         if (role === "toolResult" && toolName) {
-            return { role: "toolResult", toolCallId: "c1", toolName, content: [{ type: "text", text }], isError: false, timestamp: 0 };
+            return {
+                role: "toolResult",
+                toolCallId: "c1",
+                toolName,
+                content: [{ type: "text", text }],
+                isError: false,
+                timestamp: 0,
+            };
         }
-        return { role: "user", content: text, timestamp: 0 };
+        return {
+            role: "user",
+            content: text,
+            timestamp: 0,
+        };
     }
     const session = [
         msg("user", "read src/vec.ts and understand the index"),
@@ -85,7 +112,10 @@ function harness(opts = {}) {
     function makeCtx(over = {}) {
         return {
             ui: {
-                setStatus: (k, t) => { statusKey = k; statusText = t; },
+                setStatus: (k, t) => {
+                    statusKey = k;
+                    statusText = t;
+                },
                 notify: (s) => notifies.push(s),
                 select: () => { },
                 confirm: async () => true,
@@ -104,7 +134,11 @@ function harness(opts = {}) {
             abort: () => { },
             hasPendingMessages: () => false,
             shutdown: () => { },
-            getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }),
+            getContextUsage: () => ({
+                tokens: 200000,
+                contextWindow: 200000,
+                percent: 100,
+            }),
             // Faithful mock: ctx.compact() starts pi's flow, which fires the
             // session_before_compact handler (where WE supply the durable trim).
             compact: (opts) => {
@@ -131,8 +165,12 @@ function harness(opts = {}) {
         };
     }
     const pi = {
-        on: (ev, h) => { handlers[ev] = h; },
-        registerCommand: (name, opts) => { commands[name] = opts; },
+        on: (ev, h) => {
+            handlers[ev] = h;
+        },
+        registerCommand: (name, opts) => {
+            commands[name] = opts;
+        },
         registerTool: () => { },
         registerShortcut: () => { },
         registerFlag: () => { },
@@ -158,7 +196,15 @@ function harness(opts = {}) {
     const mod = require("./mega-compact.js");
     mod.default(pi);
     return {
-        stateDir, handlers, commands, appended, get status() { return { statusKey, statusText }; }, notifies, compactCalls,
+        stateDir,
+        handlers,
+        commands,
+        appended,
+        get status() {
+            return { statusKey, statusText };
+        },
+        notifies,
+        compactCalls,
         fire: (ev, event, ctx) => handlers[ev](event, ctx),
         ctx: makeCtx,
         session,
@@ -177,7 +223,13 @@ test("auto-trigger (legacy): past threshold persists a chkpt and starts a durabl
     process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0";
     process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM = "true";
     try {
-        const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+        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");
@@ -205,7 +257,13 @@ test("auto-trigger: skips ctx.compact() when pi would no-op (session too small,
     delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
     process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM = "true";
     try {
-        const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+        const ctx = h.ctx({
+            getContextUsage: () => ({
+                tokens: 200000,
+                contextWindow: 200000,
+                percent: 100,
+            }),
+        });
         const res = await h.fire("context", { type: "context", messages }, ctx);
         assert.equal(res, undefined, "legacy context handler returns nothing (no local drop)");
         assert.equal(h.compactCalls.length, 0, "ctx.compact() NOT called — pi would no-op");
@@ -230,7 +288,13 @@ test("auto-trigger (S16): trims the live view and does NOT call ctx.compact()",
     delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
     process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES = "1";
     try {
-        const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+        const ctx = h.ctx({
+            getContextUsage: () => ({
+                tokens: 200000,
+                contextWindow: 200000,
+                percent: 100,
+            }),
+        });
         const res = await h.fire("context", { type: "context", messages }, ctx);
         // S16: context handler returns a TRIMMED messages array (live trim), not undefined.
         assert.ok(res && typeof res === "object", "context handler returns a result object (live trim)");
@@ -254,7 +318,13 @@ test("auto-trigger (S16): does not trim when below the anchor floor (returns und
     delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
     delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
     const shortSession = [h.session[0], h.session[1]]; // one user + one assistant
-    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+    const ctx = h.ctx({
+        getContextUsage: () => ({
+            tokens: 200000,
+            contextWindow: 200000,
+            percent: 100,
+        }),
+    });
     const res = await h.fire("context", { type: "context", messages: shortSession }, ctx);
     // Either it skipped (undefined) or trimmed safely — but it must never call ctx.compact.
     assert.equal(h.compactCalls.length, 0, "ctx.compact() NOT called under live trim (short session)");
@@ -284,8 +354,11 @@ test("auto-trigger (S16): durable trim still happens via pi native auto-compacti
         tokensBefore: 500,
     };
     const res = await h.fire("session_before_compact", {
-        type: "session_before_compact", reason: "threshold", willRetry: false,
-        signal: undefined, preparation: prep,
+        type: "session_before_compact",
+        reason: "threshold",
+        willRetry: false,
+        signal: undefined,
+        preparation: prep,
     }, h.ctx());
     assert.ok(res?.compaction, "we supply a durable compaction result to pi's native path");
     assert.ok(res.compaction.firstKeptEntryId === "e2", "reuses pi's boundary (PREVENT-PI-002)");
@@ -298,41 +371,78 @@ test("session_before_compact supplies our durable trim (not pi's summary)", asyn
         type: "session_before_compact",
         reason: "overflow",
         willRetry: true,
-        preparation: { firstKeptEntryId: "e2", messagesToSummarize: h.session.slice(0, 2), tokensBefore: 500 },
+        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(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 falls back to pi when nothing to summarize", async () => {
+test("session_before_compact supplies a fallback summary when nothing to summarize", async () => {
     const h = harness();
-    // Empty preparation → no messages to summarize → return {} so pi compacts natively.
+    // Empty preparation → no messages to summarize (anchor floor protects
+    // everything). We MUST still supply a compaction (never {}), otherwise pi
+    // runs its own compact() which throws "Nothing to compact (session too
+    // small)" and leaves the session stuck with no resume context. The fallback
+    // records a minimal resume summary so the session always resumes.
     const res = await h.fire("session_before_compact", {
         type: "session_before_compact",
         reason: "threshold",
         willRetry: false,
-        preparation: { firstKeptEntryId: "e0", messagesToSummarize: [], tokensBefore: 0 },
+        preparation: {
+            firstKeptEntryId: "e0",
+            messagesToSummarize: [],
+            tokensBefore: 0,
+        },
         signal: undefined,
     }, h.ctx());
-    assert.deepEqual(res, {}, "no compaction supplied → pi runs its own");
+    assert.ok(res && res.compaction, "fallback compaction supplied (never {})");
+    assert.ok(res.compaction.summary.includes("context compacted"), "fallback summary injected so the session resumes");
+    assert.equal(res.compaction.firstKeptEntryId, "e0", "keeps pi's cut point");
 });
 test("resume auto-inline stages recall into the system prompt", async () => {
     const h = harness();
     // Seed a checkpoint first (simulate a prior session that compacted).
-    await h.fire("context", { type: "context", messages: h.session }, h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) }));
+    await h.fire("context", { type: "context", messages: h.session }, h.ctx({
+        getContextUsage: () => ({
+            tokens: 200000,
+            contextWindow: 200000,
+            percent: 100,
+        }),
+    }));
     // Fresh resume: session_start with reason "resume".
     const ctx = h.ctx();
-    await h.fire("session_start", { type: "session_start", reason: "resume", previousSessionFile: undefined }, ctx);
+    await h.fire("session_start", {
+        type: "session_start",
+        reason: "resume",
+        previousSessionFile: undefined,
+    }, ctx);
     // The next before_agent_start must prepend the recalled block.
-    const res = await h.fire("before_agent_start", { type: "before_agent_start", prompt: "base system", images: undefined, systemPrompt: "base system", systemPromptOptions: {} }, ctx);
+    const res = await h.fire("before_agent_start", {
+        type: "before_agent_start",
+        prompt: "base system",
+        images: undefined,
+        systemPrompt: "base system",
+        systemPromptOptions: {},
+    }, ctx);
     assert.ok(res && typeof res.systemPrompt === "string", "before_agent_start returns a systemPrompt");
     assert.ok(res.systemPrompt.includes("Recalled context"), "recalled block injected into system prompt");
 });
 test("/recall-context reports and stages the top checkpoint", async () => {
     const h = harness();
-    await h.fire("context", { type: "context", messages: h.session }, h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) }));
+    await h.fire("context", { type: "context", messages: h.session }, h.ctx({
+        getContextUsage: () => ({
+            tokens: 200000,
+            contextWindow: 200000,
+            percent: 100,
+        }),
+    }));
     const ctx = h.ctx();
     await h.commands["mega-recall"].handler("dedupe bug store.ts", ctx);
     assert.ok(h.notifies.some((n) => n.includes("recall staged")), "command reports staged checkpoints");
@@ -340,8 +450,20 @@ test("/recall-context reports and stages the top checkpoint", async () => {
 });
 test("/megacompact-status reports live store stats", async () => {
     const h = harness();
-    await h.fire("context", { type: "context", messages: h.session }, h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) }));
-    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 50000, contextWindow: 200000, percent: 25 }) });
+    await h.fire("context", { type: "context", messages: h.session }, h.ctx({
+        getContextUsage: () => ({
+            tokens: 200000,
+            contextWindow: 200000,
+            percent: 100,
+        }),
+    }));
+    const ctx = h.ctx({
+        getContextUsage: () => ({
+            tokens: 50000,
+            contextWindow: 200000,
+            percent: 25,
+        }),
+    });
     await h.commands["mega-status"].handler("", ctx);
     assert.ok(h.notifies.some((n) => n.includes("store:") && n.includes("chkpt")), "status shows checkpoint count");
 });
@@ -349,8 +471,18 @@ test("/megacompact-status reports live store stats", async () => {
 test("model_select captures model + provider into SQL", async () => {
     const h = harness();
     const modelCtx = h.ctx({
-        model: { id: "claude-opus-4-8", name: "Claude Opus 4.8", provider: "anthropic", contextWindow: 200000, maxTokens: 32000, reasoning: false, cost: { input: 0.000015, output: 0.000075 } },
-        modelRegistry: { getProviderDisplayName: (p) => (p === "anthropic" ? "Anthropic" : p) },
+        model: {
+            id: "claude-opus-4-8",
+            name: "Claude Opus 4.8",
+            provider: "anthropic",
+            contextWindow: 200000,
+            maxTokens: 32000,
+            reasoning: false,
+            cost: { input: 0.000015, output: 0.000075 },
+        },
+        modelRegistry: {
+            getProviderDisplayName: (p) => p === "anthropic" ? "Anthropic" : p,
+        },
     });
     await h.fire("model_select", {}, modelCtx);
     const { latestModelSnapshot } = await import("../src/store/sqlite.js");
@@ -364,37 +496,71 @@ test("model_select captures model + provider into SQL", async () => {
 test("/mega-status surfaces the captured model + provider", async () => {
     const h = harness();
     const modelCtx = h.ctx({
-        model: { id: "claude-opus-4-8", name: "Claude Opus 4.8", provider: "anthropic", contextWindow: 200000, maxTokens: 32000, reasoning: false, cost: { input: 0.000015, output: 0.000075 } },
+        model: {
+            id: "claude-opus-4-8",
+            name: "Claude Opus 4.8",
+            provider: "anthropic",
+            contextWindow: 200000,
+            maxTokens: 32000,
+            reasoning: false,
+            cost: { input: 0.000015, output: 0.000075 },
+        },
         modelRegistry: { getProviderDisplayName: () => "Anthropic" },
     });
     await h.fire("model_select", {}, modelCtx);
-    await h.fire("context", { type: "context", messages: h.session }, h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) }));
-    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 50000, contextWindow: 200000, percent: 25 }) });
+    await h.fire("context", { type: "context", messages: h.session }, h.ctx({
+        getContextUsage: () => ({
+            tokens: 200000,
+            contextWindow: 200000,
+            percent: 100,
+        }),
+    }));
+    const ctx = h.ctx({
+        getContextUsage: () => ({
+            tokens: 50000,
+            contextWindow: 200000,
+            percent: 25,
+        }),
+    });
     await h.commands["mega-status"].handler("", ctx);
-    assert.ok(h.notifies.some((n) => n.includes("🤖 model:") && n.includes("Claude Opus 4.8") && n.includes("Anthropic")), "status surfaces captured model + provider");
+    assert.ok(h.notifies.some((n) => n.includes("🤖 model:") &&
+        n.includes("Claude Opus 4.8") &&
+        n.includes("Anthropic")), "status surfaces captured model + provider");
 });
 // ---- Named compaction tiers -------------------------------------------------
 // low=50k, medium=100k, high=200k, ultra=1M, mega=10M. Driven through the REAL
 // loadConfig()/status path by setting MEGACOMPACT_TIER before loading the ext.
+// Percentage-based thresholds: tierPct × the model context window. The harness
+// getContextUsage below reports contextWindow=2_000_000, so each tier resolves to
+// tierPct × 2_000_000 — which fires BELOW pi's native ~80% auto-compaction for
+// ANY model size (200k or 1M). Driven through the REAL loadConfig()/status path
+// by setting MEGACOMPACT_TIER before loading the ext.
 const TIER_CASES = [
-    ["low", 50_000],
-    ["medium", 100_000],
-    ["high", 200_000],
-    ["ultra", 1_000_000],
-    ["mega", 10_000_000],
+    ["low", 1_000_000], // 0.50 × 2_000_000
+    ["medium", 1_200_000], // 0.60 × 2_000_000
+    ["high", 1_400_000], // 0.70 × 2_000_000
+    ["ultra", 1_400_000], // 0.70 × 2_000_000
+    ["mega", 1_500_000], // 0.75 × 2_000_000
 ];
 for (const [tier, threshold] of TIER_CASES) {
-    test(`tier "${tier}" resolves to a ${threshold}-token threshold (preset; live band shown separately)`, async () => {
+    test(`tier "${tier}" resolves to a ${threshold.toLocaleString()}-token threshold (tierPct × 2M window; live band shown separately)`, async () => {
         // Keep tier + keep threshold UNSET so the tier (not an explicit number)
         // drives the threshold. harness() would otherwise reset the threshold.
         delete process.env.MEGACOMPACT_THRESHOLD_TOKENS;
         process.env.MEGACOMPACT_TIER = tier;
         const h = harness({ keepTier: true, keepThreshold: true });
         // tokens=1 against a 2M window → near-zero pressure → live band "low".
-        const ctx = h.ctx({ getContextUsage: () => ({ tokens: 1, contextWindow: 2_000_000, percent: 0.01 }) });
+        const ctx = h.ctx({
+            getContextUsage: () => ({
+                tokens: 1,
+                contextWindow: 2_000_000,
+                percent: 0.01,
+            }),
+        });
         await h.commands["mega-status"].handler("", ctx);
         delete process.env.MEGACOMPACT_TIER;
-        assert.ok(h.notifies.some((n) => n.includes(`preset=${tier}`) && n.includes(`threshold=${threshold}`)), `status should report preset=${tier} threshold=${threshold}`);
+        // /mega-status renders threshold with toLocaleString() (thousands commas).
+        assert.ok(h.notifies.some((n) => n.includes(`preset=${tier}`) && n.includes(`threshold=${threshold.toLocaleString()}`)), `status should report preset=${tier} threshold=${threshold.toLocaleString()} (tierPct × 2M window)`);
         // S24: the headline tier is the LIVE pressure band, shown as "tier=low (live)".
         assert.ok(h.notifies.some((n) => n.includes("tier=low (live)")), "live band reported (low at near-zero pressure)");
     });
@@ -403,7 +569,13 @@ test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
     process.env.MEGACOMPACT_TIER = "mega";
     process.env.MEGACOMPACT_THRESHOLD_TOKENS = "777";
     const h = harness({ keepTier: true, keepThreshold: true });
-    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 1, contextWindow: 2_000_000, percent: 0.01 }) });
+    const ctx = h.ctx({
+        getContextUsage: () => ({
+            tokens: 1,
+            contextWindow: 2_000_000,
+            percent: 0.01,
+        }),
+    });
     await h.commands["mega-status"].handler("", ctx);
     delete process.env.MEGACOMPACT_TIER;
     assert.ok(h.notifies.some((n) => n.includes("preset=custom") && n.includes("threshold=777")), "explicit threshold wins over tier (preset=custom)");
@@ -415,9 +587,34 @@ test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
 function decisionSession() {
     const out = [];
     for (let i = 0; i < 14; i++) {
-        out.push({ role: "user", content: `actually we decided to use approach ${i} for module ${i}`, timestamp: i });
-        out.push({ role: "assistant", content: [{ type: "toolCall", name: "Edit", id: `c${i}`, arguments: {} }], api: "anthropic-messages", provider: "anthropic", model: "m", usage: { inputTokens: 1, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 }, stopReason: "tool_use", timestamp: i });
-        out.push({ role: "toolResult", content: [{ type: "text", text: `edited module ${i}` }], toolCallId: `c${i}`, toolName: "Edit", isError: false, timestamp: i });
+        out.push({
+            role: "user",
+            content: `actually we decided to use approach ${i} for module ${i}`,
+            timestamp: i,
+        });
+        out.push({
+            role: "assistant",
+            content: [{ type: "toolCall", name: "Edit", id: `c${i}`, arguments: {} }],
+            api: "anthropic-messages",
+            provider: "anthropic",
+            model: "m",
+            usage: {
+                inputTokens: 1,
+                outputTokens: 1,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+            },
+            stopReason: "tool_use",
+            timestamp: i,
+        });
+        out.push({
+            role: "toolResult",
+            content: [{ type: "text", text: `edited module ${i}` }],
+            toolCallId: `c${i}`,
+            toolName: "Edit",
+            isError: false,
+            timestamp: i,
+        });
     }
     return out;
 }
@@ -428,7 +625,13 @@ test("S24: high pressure triggers a memory review on compaction", async () => {
     process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM = "false";
     try {
         const messages = decisionSession();
-        const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+        const ctx = h.ctx({
+            getContextUsage: () => ({
+                tokens: 200000,
+                contextWindow: 200000,
+                percent: 100,
+            }),
+        });
         await h.fire("context", { type: "context", messages }, ctx);
         // review-on-compact runs as a fire-and-forget async (doCompact is sync), so
         // let the microtask/macrotask queue drain before asserting the side effect.
@@ -450,7 +653,13 @@ test("S24: /mega-status reports the live pressure band + %", async () => {
     // Populate the runtime's live context first (a context event sets
     // lastCtxTokens/lastCtxPercent), then read /mega-status. At 100% usage the live
     // band must read "mega" and pressure must report 100%.
-    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+    const ctx = h.ctx({
+        getContextUsage: () => ({
+            tokens: 200000,
+            contextWindow: 200000,
+            percent: 100,
+        }),
+    });
     await h.fire("context", { type: "context", messages: h.session }, ctx);
     await h.commands["mega-status"].handler("", ctx);
     assert.ok(h.notifies.some((n) => n.includes("tier=mega (live)")), "live band reported as mega at 100% pressure");
@@ -489,7 +698,16 @@ test("/dashboard skips server spawn when already running", async () => {
     const { createServer } = await import("node:http");
     const server = createServer((_req, res) => {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test", version: 1, config: {}, session: {}, context: {}, trigger: {}, store: {} }));
+        res.end(JSON.stringify({
+            updatedAt: new Date().toISOString(),
+            tier: "test",
+            version: 1,
+            config: {},
+            session: {},
+            context: {},
+            trigger: {},
+            store: {},
+        }));
     });
     await new Promise((r) => server.listen(livPort, "127.0.0.1", r));
     const { join: j } = await import("node:path");
@@ -498,9 +716,14 @@ test("/dashboard skips server spawn when already running", async () => {
     const ctx = h.ctx({
         ui: {
             setStatus: () => { },
-            notify: (s) => { h.notifies.push(s); },
+            notify: (s) => {
+                h.notifies.push(s);
+            },
             select: () => { },
-            confirm: async () => { confirms.push(true); return true; },
+            confirm: async () => {
+                confirms.push(true);
+                return true;
+            },
             input: async () => "",
         },
     });
@@ -533,7 +756,13 @@ test("/dashboard-status reports running after dashboard start", async () => {
 });
 test("state snapshot writes dashboard.json after compaction", async () => {
     const h = harness();
-    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+    const ctx = h.ctx({
+        getContextUsage: () => ({
+            tokens: 200000,
+            contextWindow: 200000,
+            percent: 100,
+        }),
+    });
     // Fire auto-trigger compaction (context event above 80% threshold)
     await h.fire("context", { type: "context", messages: h.session }, ctx);
     const { existsSync: ex, readFileSync: rf } = await import("node:fs");
@@ -554,7 +783,13 @@ test("state snapshot writes dashboard.json after compaction", async () => {
 });
 test("events.log receives compaction events", async () => {
     const h = harness();
-    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+    const ctx = h.ctx({
+        getContextUsage: () => ({
+            tokens: 200000,
+            contextWindow: 200000,
+            percent: 100,
+        }),
+    });
     // Fire auto-trigger compaction twice (first fires compaction, second also fires)
     await h.fire("context", { type: "context", messages: h.session }, ctx);
     const { readFileSync: rf, existsSync: ex } = await import("node:fs");

package/dist/extensions/mega-config.js

@@ -21,6 +21,20 @@ export const COMPACT_TIERS = {
     ultra: 1_000_000,
     mega: 10_000_000,
 };
+/**
+ * Compaction thresholds as a FRACTION of the model's context window (NOT a
+ * static token amount). The live + durable trim fire at tier% of the window,
+ * so they always fire BELOW pi's native auto-compaction (~80% of window) for
+ * any model size (200k or 1M). `custom` (explicit MEGACOMPACT_THRESHOLD_TOKENS)
+ * is NOT scaled by this map — it stays an absolute token count.
+ */
+export const TIER_PCT = {
+    low: 0.5,
+    medium: 0.6,
+    high: 0.7,
+    ultra: 0.7,
+    mega: 0.75,
+};
 function envFlag(name, fallback) {
     const v = process.env[name];
     if (v == null || v === "")
@@ -34,17 +48,64 @@ function envBool(name, fallback) {
         return fallback;
     return v === "true" || v === "1";
 }
-/** Resolve the effective token threshold from TIER (or explicit) env vars. */
+/**
+ * Resolve the effective token threshold from TIER (or explicit) env vars.
+ *
+ * For a named tier the returned `thresholdTokens` is a BOOT FALLBACK
+ * (`round(tierPct * 200_000)`) — sane before any context event reaches the
+ * runtime. The true fire point is computed per-window at runtime via
+ * `effectiveThresholdTokens(...)`. `custom` (explicit MEGACOMPACT_THRESHOLD_TOKENS)
+ * keeps `tierPct: null` and an ABSOLUTE `thresholdTokens` (never percent-scaled).
+ */
 function resolveThreshold() {
     const explicit = process.env.MEGACOMPACT_THRESHOLD_TOKENS;
     if (explicit != null && explicit !== "") {
         const n = Number(explicit);
         if (Number.isFinite(n))
-            return { tier: "custom", thresholdTokens: n };
+            return { tier: "custom", tierPct: null, thresholdTokens: n };
     }
     const raw = (process.env.MEGACOMPACT_TIER ?? "low").toLowerCase();
     const tier = (raw in COMPACT_TIERS ? raw : "low");
-    return { tier, thresholdTokens: COMPACT_TIERS[tier] };
+    const tierPct = TIER_PCT[tier];
+    // Boot fallback: sane gate before the first context event provides a window.
+    const thresholdTokens = Math.round(tierPct * 200_000);
+    return { tier, tierPct, thresholdTokens };
+}
+/**
+ * Pure helper: the real compaction fire point, given the model context window.
+ *
+ *   custom           -> explicitThreshold (ABSOLUTE, never percent-scaled)
+ *   tiered+window>0  -> round(tierPct * window)
+ *   tiered+window<=0 -> fallbackThreshold (boot fallback; no window known yet)
+ *
+ * This is the single source of truth consumed by the runtime gates
+ * (FAST GATE / autoCompactCheck / agent_end durable trigger) and the
+ * pressure/armed/ready computations. Keeping it pure makes it trivially
+ * unit-testable without the pi runtime.
+ */
+export function effectiveThresholdTokens(opts) {
+    if (opts.tierPct == null) {
+        // custom: absolute threshold, never percent-scaled
+        return opts.explicitThreshold ?? opts.fallbackThreshold;
+    }
+    if (opts.window > 0)
+        return Math.round(opts.tierPct * opts.window);
+    return opts.fallbackThreshold;
+}
+/**
+ * Resolve the optional manual arming-floor override (MEGACOMPACT_FAST_GATE_PCT).
+ * Kept for backward-compat: when unset, the default arming floor equals the
+ * tier's percent threshold (tierPct*100) so the dashboard stays consistent;
+ * `custom` (tierPct null) falls back to the legacy 70% default.
+ */
+function resolveFastGatePct(tierPct) {
+    const raw = process.env.MEGACOMPACT_FAST_GATE_PCT;
+    if (raw != null && raw !== "") {
+        const n = Number(raw);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return tierPct != null ? Math.round(tierPct * 100) : 70;
 }
 /**
  * Pressure helpers for adaptive compression live in src/config.ts (pi-agnostic)
@@ -56,13 +117,14 @@ function resolveThreshold() {
 export { pressureFromPct, preserveRecentForPressure, pressureRatio, pressureBand, memoryReviewCadence, } from "../src/config.js";
 /** Build the resolved config from env + defaults. */
 export function loadConfig() {
-    const { tier, thresholdTokens } = resolveThreshold();
+    const { tier, tierPct, thresholdTokens } = resolveThreshold();
     return {
         tier,
+        tierPct,
         // Global default; the live store/dashboard are rebound per-repo at runtime
         // via MegaRuntime.bindRepo() so each git repo gets its own isolated state dir.
         stateDir: process.env.MEGACOMPACT_STATE_DIR ?? STATE_DIR_DEFAULT,
-        fastGatePct: envFlag("MEGACOMPACT_FAST_GATE_PCT", 70),
+        fastGatePct: resolveFastGatePct(tierPct),
         thresholdTokens,
         anchorUserMessages: envFlag("MEGACOMPACT_ANCHOR_USER_MESSAGES", 3),
         preserveRecent: envFlag("MEGACOMPACT_PRESERVE_RECENT", 4),