pi-mega-compact 0.7.6 → 0.7.8

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

@@ -44,6 +44,7 @@ function harness(opts = {}) {
     let statusText;
     const notifies = [];
     const compactCalls = [];
+    const sendUserMessages = [];
     // Minimal AgentMessage factory for the session we project into the extension.
     function msg(role, text, toolName) {
         if (role === "assistant" && toolName) {
@@ -178,7 +179,7 @@ function harness(opts = {}) {
         registerMessageRenderer: () => { },
         registerEntryRenderer: () => { },
         sendMessage: (_m) => { },
-        sendUserMessage: () => { },
+        sendUserMessage: (m) => { sendUserMessages.push(m); },
         appendEntry: (t, d) => appended.push({ t, d }),
         setSessionName: () => { },
         getSessionName: () => undefined,
@@ -205,6 +206,7 @@ function harness(opts = {}) {
         },
         notifies,
         compactCalls,
+        sendUserMessages,
         fire: (ev, event, ctx) => handlers[ev](event, ctx),
         ctx: makeCtx,
         session,
@@ -733,27 +735,6 @@ test("/dashboard skips server spawn when already running", async () => {
     await new Promise((r) => server.close(() => r()));
     delete process.env.MEGACOMPACT_DASHBOARD_PORT;
 });
-test("/dashboard-status reports running after dashboard start", async () => {
-    // Private dashboard port base for this harness — never collides with the
-    // parallel dashboard-server.test.js (9320 family) or a leftover server.
-    process.env.MEGACOMPACT_DASHBOARD_PORT = "39320";
-    const h = harness();
-    const livPort = 39320;
-    const { createServer } = await import("node:http");
-    const { join: j } = await import("node:path");
-    const { writeFileSync: wf } = await import("node:fs");
-    const server = createServer((_req, res) => {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test" }));
-    });
-    await new Promise((r) => server.listen(livPort, "127.0.0.1", r));
-    wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: livPort, pid: process.pid }));
-    const ctx = h.ctx();
-    await h.commands["mega-dashboard-status"].handler("", ctx);
-    assert.ok(h.notifies.some((n) => n.includes("running") && n.includes(String(livPort))), "reports running with port");
-    await new Promise((r) => server.close(() => r()));
-    delete process.env.MEGACOMPACT_DASHBOARD_PORT;
-});
 test("state snapshot writes dashboard.json after compaction", async () => {
     const h = harness();
     const ctx = h.ctx({
@@ -806,6 +787,224 @@ test("events.log receives compaction events", async () => {
         assert.ok(ex(j(h.stateDir, "dashboard.json")), "dashboard.json proves post-compact ran");
     }
 });
+test("S28: length-stop auto-continue nudges once, no ctx.compact on low-pressure length path", async () => {
+    const h = harness();
+    // Force a low-pressure context so the durable-trim branch (which calls
+    // ctx.compact()) is NOT taken; only the length-stop nudge should fire.
+    const lowPressureCtx = h.ctx({
+        isIdle: () => true,
+        hasPendingMessages: () => false,
+        getContextUsage: () => ({ tokens: 100, contextWindow: 200000, percent: 0 }),
+    });
+    // 1) Normal stop: no length flag armed → no nudge.
+    await h.fire("turn_end", { type: "turn_end", turnIndex: 1, message: { role: "assistant", stopReason: "stop" } }, lowPressureCtx);
+    await h.fire("agent_end", { type: "agent_end", messages: [] }, lowPressureCtx);
+    assert.equal(h.sendUserMessages.length, 0, "normal stop: no nudge");
+    assert.equal(h.compactCalls.length, 0, "normal stop: no ctx.compact");
+    // 2) Length stop: arms the flag, agent_end fires exactly one continue nudge
+    //    that references the output-token truncation (not a compaction).
+    await h.fire("turn_end", { type: "turn_end", turnIndex: 2, message: { role: "assistant", stopReason: "length" } }, lowPressureCtx);
+    await h.fire("agent_end", { type: "agent_end", messages: [] }, lowPressureCtx);
+    assert.equal(h.sendUserMessages.length, 1, "length stop: exactly one nudge");
+    assert.match(h.sendUserMessages[0], /output-token cap/, "length stop: nudge references the output-token truncation");
+    assert.equal(h.compactCalls.length, 0, "length path: ctx.compact() NOT called (low pressure)");
+    // 3) One-shot: a second agent_end without a new length stop must NOT re-nudge.
+    await h.fire("agent_end", { type: "agent_end", messages: [] }, lowPressureCtx);
+    assert.equal(h.sendUserMessages.length, 1, "one-shot: no second nudge without a new length stop");
+});
+test("S28: length-stop auto-continue fires even when config.auto === false (autoContinueLengthStop is the sole gate)", async () => {
+    // Disable auto (durable-trim + queued-resume) but keep the length-stop flag on.
+    // Set BEFORE harness() loads the compiled extension so loadConfig() picks it up.
+    const prevAuto = process.env.MEGACOMPACT_AUTO;
+    process.env.MEGACOMPACT_AUTO = "false";
+    try {
+        // Re-load the extension with the new env so config.auto is false but
+        // autoContinueLengthStop stays true (default).
+        const h2 = harness();
+        const lowPressureCtx = h2.ctx({
+            isIdle: () => true,
+            hasPendingMessages: () => false,
+            getContextUsage: () => ({ tokens: 100, contextWindow: 200000, percent: 0 }),
+        });
+        // Length stop arms the flag; agent_end must still nudge despite auto=false.
+        await h2.fire("turn_end", { type: "turn_end", turnIndex: 1, message: { role: "assistant", stopReason: "length" } }, lowPressureCtx);
+        await h2.fire("agent_end", { type: "agent_end", messages: [] }, lowPressureCtx);
+        assert.equal(h2.sendUserMessages.length, 1, "auto=false: length stop still nudges");
+        assert.match(h2.sendUserMessages[0], /output-token cap/, "auto=false: nudge references the output-token truncation");
+        assert.equal(h2.compactCalls.length, 0, "auto=false: ctx.compact() NOT called (auto gates durable-trim)");
+    }
+    finally {
+        if (prevAuto === undefined)
+            delete process.env.MEGACOMPACT_AUTO;
+        else
+            process.env.MEGACOMPACT_AUTO = prevAuto;
+    }
+});
+// Helper: read <stateDir>/events.log JSONL and return the list of event `type`s.
+// Dashboard.event (extensions/mega-dashboard.ts) appends `{ ts, type, ...data }`
+// per line. Used to assert the S28 length_stop / length_stop_continue dashboard
+// events fire on the right paths (spec acceptance #7; OPEN issue #3).
+function eventTypes(stateDir) {
+    const { readFileSync: rf, existsSync: ex } = require("node:fs");
+    const { join: j } = require("node:path");
+    const logPath = j(stateDir, "events.log");
+    if (!ex(logPath))
+        return [];
+    const content = rf(logPath, "utf-8").trim();
+    if (content.length === 0)
+        return [];
+    return content
+        .split("\n")
+        .map((line) => {
+        try {
+            return JSON.parse(line).type;
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((t) => typeof t === "string");
+}
+test("S28: length_stop + length_stop_continue dashboard events fire on the right paths", async () => {
+    const h = harness();
+    const lowPressureCtx = h.ctx({
+        isIdle: () => true,
+        hasPendingMessages: () => false,
+        getContextUsage: () => ({ tokens: 100, contextWindow: 200000, percent: 0 }),
+    });
+    // Normal stop: no length_stop event, no nudge, no length_stop_continue.
+    await h.fire("turn_end", { type: "turn_end", turnIndex: 1, message: { role: "assistant", stopReason: "stop" } }, lowPressureCtx);
+    await h.fire("agent_end", { type: "agent_end", messages: [] }, lowPressureCtx);
+    const afterNormal = eventTypes(h.stateDir);
+    assert.ok(!afterNormal.includes("length_stop"), "normal stop: no length_stop dashboard event");
+    assert.ok(!afterNormal.includes("length_stop_continue"), "normal stop: no length_stop_continue dashboard event");
+    assert.equal(h.sendUserMessages.length, 0, "normal stop: no nudge");
+    // Length stop: length_stop fires on turn_end, length_stop_continue on agent_end.
+    await h.fire("turn_end", { type: "turn_end", turnIndex: 2, message: { role: "assistant", stopReason: "length" } }, lowPressureCtx);
+    const afterTurnEnd = eventTypes(h.stateDir);
+    assert.ok(afterTurnEnd.includes("length_stop"), "length stop: length_stop dashboard event fired on turn_end");
+    await h.fire("agent_end", { type: "agent_end", messages: [] }, lowPressureCtx);
+    const afterAgentEnd = eventTypes(h.stateDir);
+    assert.ok(afterAgentEnd.includes("length_stop_continue"), "length stop: length_stop_continue dashboard event fired on agent_end");
+    assert.equal(h.sendUserMessages.length, 1, "length stop: exactly one nudge");
+});
+test("S28: non-length stopReasons do not arm the flag (no nudge, no length_stop event)", async () => {
+    const h = harness();
+    const lowPressureCtx = h.ctx({
+        isIdle: () => true,
+        hasPendingMessages: () => false,
+        getContextUsage: () => ({ tokens: 100, contextWindow: 200000, percent: 0 }),
+    });
+    // Every other pi-ai StopReason must leave the flag unset → no nudge + no event.
+    for (const stopReason of ["tool_use", "error", "aborted"]) {
+        await h.fire("turn_end", { type: "turn_end", turnIndex: 1, message: { role: "assistant", stopReason } }, lowPressureCtx);
+        await h.fire("agent_end", { type: "agent_end", messages: [] }, lowPressureCtx);
+    }
+    assert.equal(h.sendUserMessages.length, 0, "non-length stopReasons: no nudge");
+    assert.ok(!eventTypes(h.stateDir).includes("length_stop"), "non-length stopReasons: no length_stop dashboard event");
+});
+// ---- S29: percent-based auto-compact trigger (gate on context %, not tokens) -
+// The context-handler gate now fires on pct/100 >= (autoPctTrigger ?? tierPct)
+// for tiered configs, with a token FALLBACK when pct is null. `custom` keeps the
+// absolute token gate. These are the first tests to drive a `context` event
+// on a tiered config (the default harness forces custom via THRESHOLD_TOKENS=50).
+/** S29 tiered-config helper: tiered (not custom), low tier (tierPct 0.5), with
+ *  the legacy durable-trim flag off + anchor floor lowered so the live trim
+ *  returns a trimmed view (mirrors the S16 live-trim test setup at ~line 329). */
+function s29TieredCtx(h, usage) {
+    delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+    delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+    process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES = "1";
+    return h.ctx({
+        isIdle: () => true,
+        hasPendingMessages: () => false,
+        getContextUsage: () => usage,
+    });
+}
+test("S29: percent gate fires when tokens under-report (tiered low, percent 55, tokens 10)", async () => {
+    process.env.MEGACOMPACT_TIER = "low";
+    delete process.env.MEGACOMPACT_THRESHOLD_TOKENS;
+    delete process.env.MEGACOMPACT_AUTO_PCT_TRIGGER;
+    try {
+        const h = harness({ keepTier: true, keepThreshold: true });
+        // tokens=10 (under the 0.5×10000=5000 token gate), percent=55 (>= 0.5).
+        // The OLD token-only gate would return (10 < 5000) → no trim. The S29
+        // percent gate (0.55 >= 0.5) fires → live trim returns a trimmed view.
+        const ctx = s29TieredCtx(h, { tokens: 10, contextWindow: 10000, percent: 55 });
+        const res = await h.fire("context", { type: "context", messages: h.session }, ctx);
+        assert.ok(res && typeof res === "object", "percent gate: live trim returned a result object");
+        assert.ok(Array.isArray(res.messages), "percent gate: result has a trimmed messages array");
+        assert.ok(res.messages.length < h.session.length, "percent gate: trimmed view is shorter than the full session");
+        assert.equal(h.compactCalls.length, 0, "percent gate: live trim, no ctx.compact()");
+        // Control: percent 40 (< 0.5) → no trim, even with the same under-reported tokens.
+        const h2 = harness({ keepTier: true, keepThreshold: true });
+        const ctx2 = s29TieredCtx(h2, { tokens: 10, contextWindow: 10000, percent: 40 });
+        const res2 = await h2.fire("context", { type: "context", messages: h2.session }, ctx2);
+        assert.ok(!(res2 && typeof res2 === "object" && Array.isArray(res2.messages)), "percent below fire point: no trim (token count 10 is also below the token gate)");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_TIER;
+        delete process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES;
+    }
+});
+test("S29: MEGACOMPACT_AUTO_PCT_TRIGGER overrides the tier fire point (0.85)", async () => {
+    process.env.MEGACOMPACT_TIER = "low"; // tierPct 0.5
+    process.env.MEGACOMPACT_AUTO_PCT_TRIGGER = "0.85";
+    delete process.env.MEGACOMPACT_THRESHOLD_TOKENS;
+    try {
+        // percent 80 < 0.85 → no trim.
+        const h = harness({ keepTier: true, keepThreshold: true });
+        const ctx80 = s29TieredCtx(h, { tokens: 10, contextWindow: 10000, percent: 80 });
+        const res80 = await h.fire("context", { type: "context", messages: h.session }, ctx80);
+        assert.ok(!(res80 && typeof res80 === "object" && Array.isArray(res80.messages)), "override 0.85: percent 80 does NOT trim (below the override fire point)");
+        // percent 90 >= 0.85 → trim fires (despite the tier's own 0.5 fire point).
+        const h2 = harness({ keepTier: true, keepThreshold: true });
+        const ctx90 = s29TieredCtx(h2, { tokens: 10, contextWindow: 10000, percent: 90 });
+        const res90 = await h2.fire("context", { type: "context", messages: h2.session }, ctx90);
+        assert.ok(res90 && Array.isArray(res90.messages) && res90.messages.length < h2.session.length, "override 0.85: percent 90 DOES trim (above the override fire point)");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_TIER;
+        delete process.env.MEGACOMPACT_AUTO_PCT_TRIGGER;
+        delete process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES;
+    }
+});
+test("S29: custom tier keeps the absolute token gate (percent 40 but tokens 100 >= 50)", async () => {
+    // MEGACOMPACT_THRESHOLD_TOKENS → custom (tierPct null) → token gate, percent ignored.
+    process.env.MEGACOMPACT_THRESHOLD_TOKENS = "50";
+    delete process.env.MEGACOMPACT_TIER;
+    delete process.env.MEGACOMPACT_AUTO_PCT_TRIGGER;
+    try {
+        const h = harness({ keepTier: true, keepThreshold: true });
+        // percent 40 (low) BUT tokens 100 >= 50 threshold → custom token gate fires.
+        const ctx = s29TieredCtx(h, { tokens: 100, contextWindow: 10000, percent: 40 });
+        const res = await h.fire("context", { type: "context", messages: h.session }, ctx);
+        assert.ok(res && Array.isArray(res.messages) && res.messages.length < h.session.length, "custom tier: token gate fires (tokens 100 >= 50) despite low percent 40");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_THRESHOLD_TOKENS;
+        delete process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES;
+    }
+});
+test("S29: tiered config with pct==null falls back to the token gate (not skipped)", async () => {
+    // The regression guard for the audit finding: a percent-ONLY gate would skip
+    // compaction when percent is unreported. S29 falls back to the token gate
+    // (S27 boot-fallback guarantee). tiered low: effectiveThreshold = 0.5×10000 = 5000;
+    // tokens 6000 >= 5000 → token fallback fires.
+    process.env.MEGACOMPACT_TIER = "low";
+    delete process.env.MEGACOMPACT_THRESHOLD_TOKENS;
+    delete process.env.MEGACOMPACT_AUTO_PCT_TRIGGER;
+    try {
+        const h = harness({ keepTier: true, keepThreshold: true });
+        const ctx = s29TieredCtx(h, { tokens: 6000, contextWindow: 10000, percent: null });
+        const res = await h.fire("context", { type: "context", messages: h.session }, ctx);
+        assert.ok(res && Array.isArray(res.messages) && res.messages.length < h.session.length, "pct==null on tiered: token fallback fires (NOT skipped) — S27 boot-fallback preserved");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_TIER;
+        delete process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES;
+    }
+});
 test("cleanup", async () => {
     // Terminate the global PGlite cross-repo index (WASM worker thread) so the
     // test process can exit. Without this, node --test never returns even though

package/dist/extensions/mega-config.js

@@ -118,6 +118,14 @@ export { pressureFromPct, preserveRecentForPressure, pressureRatio, pressureBand
 /** Build the resolved config from env + defaults. */
 export function loadConfig() {
     const { tier, tierPct, thresholdTokens } = resolveThreshold();
+    // S29: optional percent-based fire-point override for tiered configs.
+    // null = inherit tierPct (default; preserves existing fire points). Clamped
+    // to [0.1, 1] so a bogus env can't disable or invert the gate. Ignored by
+    // the `custom` tier (tierPct null) which keeps the absolute token gate.
+    const aptRaw = process.env.MEGACOMPACT_AUTO_PCT_TRIGGER;
+    const autoPctTrigger = aptRaw && aptRaw !== "" && Number.isFinite(Number(aptRaw))
+        ? Math.min(1, Math.max(0.1, Number(aptRaw)))
+        : null;
     return {
         tier,
         tierPct,
@@ -131,6 +139,8 @@ export function loadConfig() {
         preserveRecentMin: envFlag("MEGACOMPACT_PRESERVE_RECENT_MIN", 2),
         auto: envBool("MEGACOMPACT_AUTO", true),
         autoInline: envBool("MEGACOMPACT_AUTO_INLINE", true),
+        autoContinueLengthStop: envBool("MEGACOMPACT_AUTO_CONTINUE_LENGTH_STOP", true),
+        autoPctTrigger,
         autoInlineK: envFlag("MEGACOMPACT_AUTO_INLINE_K", 3),
         dedupSim: Number(process.env.MEGACOMPACT_DEDUP_SIM ?? "0.9"),
         raptorEnabled: envBool("MEGACOMPACT_RAPTOR_ENABLED", true),

package/dist/extensions/mega-events.js

@@ -16,7 +16,7 @@ import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop, runMemoryRevie
 import { recallMemoriesAndInline } from "../src/recall.js";
 import { driveNativeCompaction, } from "./mega-compact-driver.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "./mega-trim.js";
-import { pressureFromPct, memoryReviewCadence, } from "./mega-config.js";
+import { pressureFromPct, pressureRatio, memoryReviewCadence, } from "./mega-config.js";
 import { createHash } from "node:crypto";
 /**
  * Convert a pi AgentMessage to a RawTranscriptRow for the DB mirror.
@@ -217,7 +217,7 @@ export function registerEventHandlers(pi, runtime, config) {
         // compaction AND there is queued work AND we haven't nudged recently, nudge
         // once so the agent continues (the live trim should make this rare). Guarded
         // to never busy-loop: one nudge per 30s, only when truly idle + queued.
-        if (config.auto && runtime.activeAgents === 0) {
+        if ((config.auto || config.autoContinueLengthStop) && runtime.activeAgents === 0) {
             try {
                 const idle = ctx.isIdle?.() ?? true;
                 const queued = ctx.hasPendingMessages?.() ?? false;
@@ -264,7 +264,7 @@ export function registerEventHandlers(pi, runtime, config) {
                 // most. Instead we DECOUPLE the nudge from `queued`: after a durable
                 // trim we ALWAYS nudge so the agent reliably restarts. Debounced 30s.
                 let didDurableTrim = false;
-                if (idle && overThreshold && now >= runtime.debounceUntil) {
+                if (config.auto && idle && overThreshold && now >= runtime.debounceUntil) {
                     // COMPACT-DEDUP FIX: skip the manual durable-trim trigger when pi's
                     // NATIVE auto-compaction just fired (or is in-flight). pi emits
                     // agent_end BEFORE its own _checkCompaction (per its docstring:
@@ -295,11 +295,26 @@ export function registerEventHandlers(pi, runtime, config) {
                 // Restart the agent after a mid-run durable trim (which stopped it), or
                 // when it settled idle with queued work. Decoupled from `queued` for the
                 // durable-trim case — see FIX note above. Debounced 30s; never blocks.
+                const lengthStop = config.autoContinueLengthStop && runtime.rt.lengthStopPending;
                 if (idle &&
                     now >= runtime.resumeNudgeUntil &&
-                    (didDurableTrim || queued)) {
+                    ((config.auto && (didDurableTrim || queued)) || lengthStop)) {
                     runtime.resumeNudgeUntil = now + 30_000;
-                    pi.sendUserMessage("[mega-compact] continue from the compacted context above.");
+                    if (runtime.rt.lengthStopPending) {
+                        runtime.rt.lengthStopPending = false; // one-shot: never re-fire for same stop
+                        runtime.dashboard.event("length_stop_continue", { turnIndex: runtime.currentTurn });
+                        runtime.logger.info("length_stop_continue", {
+                            sessionId: runtime.rt.sessionId,
+                            didDurableTrim,
+                            queued,
+                        });
+                    }
+                    // S28: when a length-stop (max-output-token truncation) fired WITHOUT a durable trim, do NOT claim a compaction happened
+                    // (nothing was compacted on the low-pressure length path). Branch the message so the nudge matches reality.
+                    const nudgeMsg = lengthStop && !didDurableTrim
+                        ? "[mega-compact] the last response hit the output-token cap; continue from where it stopped."
+                        : "[mega-compact] continue from the compacted context above.";
+                    pi.sendUserMessage(nudgeMsg);
                 }
             }
             catch {
@@ -310,6 +325,7 @@ export function registerEventHandlers(pi, runtime, config) {
     });
     pi.on("turn_start", async (event, ctx) => {
         runtime.currentTurn = event.turnIndex;
+        runtime.rt.lengthStopPending = false; // S28: re-arm defensively each user turn
         runtime.dashboard.event("turn_start", { turnIndex: event.turnIndex });
         runtime.snapshot(ctx);
     });
@@ -333,6 +349,15 @@ export function registerEventHandlers(pi, runtime, config) {
                 await runMemoryReview(runtime, view, "turn");
             }
         }
+        // S28: detect max-output-token truncation. event.message.stopReason is the
+        // pi-ai StopReason union; 'length' == generation hit max_tokens OUTPUT cap
+        // (INPUT-orthogonal to context-window overflow). Arm the agent_end nudge.
+        if (config.autoContinueLengthStop &&
+            event.message.role === "assistant" &&
+            event.message.stopReason === "length") {
+            runtime.rt.lengthStopPending = true;
+            runtime.dashboard.event("length_stop", { turnIndex: event.turnIndex });
+        }
     });
     // ---- Auto-trigger: live trim (compact and continue) + native durable ----
     // S16 redesign: we NO LONGER call ctx.compact() from the auto-trigger by
@@ -358,13 +383,11 @@ export function registerEventHandlers(pi, runtime, config) {
         runtime.lastCtxPercent = pct ?? null;
         runtime.lastCtxWindow = usage?.contextWindow ?? 0;
         runtime.snapshot(ctx);
-        if (pct == null)
-            return;
         const messages = event.messages;
         const view = runtime.engineView(messages);
         const currentTokens = usage?.tokens ??
             estimateSessionTokens(view) ??
-            Math.round((pct / 100) * (usage?.contextWindow ?? 0));
+            Math.round(((pct ?? 0) / 100) * (usage?.contextWindow ?? 0));
         // S27 DB-mirror: append ALL incoming messages to raw_transcript.
         // Runs BEFORE fast-gate so every message is captured, even if we
         // don't compact this turn. Append is idempotent (content_hash PK).
@@ -382,14 +405,36 @@ export function registerEventHandlers(pi, runtime, config) {
                 runtime.logger.warn("db-mirror-append-fail", { error: String(e) });
             }
         }
-        // FAST GATE: token-based (tier% of the window), not a static amount.
-        if (currentTokens < runtime.effectiveThreshold) {
-            runtime.diagCtxFastGate++;
-            return;
+        // S29 FAST GATE: drive the auto-trigger off the context % (the number the
+        // menu bar shows), NOT the token count — the model under-reports tokens,
+        // so a token-only gate misses the overshoot that causes max-output-token
+        // truncation. The fire point is the tier's percent threshold (tierPct)
+        // unless overridden by MEGACOMPACT_AUTO_PCT_TRIGGER. `custom` (absolute
+        // MEGACOMPACT_THRESHOLD_TOKENS, tierPct null) is an explicit opt-out of
+        // percent scaling — it keeps the token gate. When pct is unavailable
+        // (window unknown / a model that doesn't report percent) a tiered config
+        // falls back to the token gate (S27 boot-fallback guarantee) instead of
+        // skipping compaction — a percent-only gate would regress that.
+        let gatePassed = false;
+        if (config.tierPct != null && pct != null) {
+            const firePct = config.autoPctTrigger ?? config.tierPct;
+            gatePassed = pct / 100 >= firePct;
         }
-        const check = autoCompactCheck(currentTokens, runtime.effectiveThreshold); // SERVER-STYLE CONFIRM (local)
-        if (!check.shouldCompact) {
-            runtime.diagCtxNoCompact++;
+        else {
+            // custom tier OR tiered-but-pct-unavailable → token gate (S27 fallback).
+            if (currentTokens < runtime.effectiveThreshold) {
+                runtime.diagCtxFastGate++;
+                return;
+            }
+            const check = autoCompactCheck(currentTokens, runtime.effectiveThreshold); // SERVER-STYLE CONFIRM (local)
+            if (!check.shouldCompact) {
+                runtime.diagCtxNoCompact++;
+                return;
+            }
+            gatePassed = true;
+        }
+        if (!gatePassed) {
+            runtime.diagCtxFastGate++;
             return;
         }
         // Debounce so we don't fire on every context event past threshold.
@@ -400,8 +445,10 @@ export function registerEventHandlers(pi, runtime, config) {
         }
         runtime.debounceUntil = now + 2000;
         // Adaptive compression (Fix E): scale compression strength + keepFrom depth
-        // with how close we are to the model context limit.
-        const pressure = pressureFromPct(pct);
+        // with how close we are to the model context limit. Null-safe: when the
+        // token-fallback path ran (pct unavailable) use the token-basis pressure
+        // (the same basis the runtime `pressure` getter uses for custom/no-window).
+        const pressure = pct != null ? pressureFromPct(pct) : pressureRatio(currentTokens, runtime.effectiveThreshold);
         const ran = runCompact(pi, runtime, config, ctx, messages, {
             compressionPressure: pressure,
         });

package/dist/extensions/mega-pipeline.js

@@ -11,7 +11,7 @@ import { compactSession } from "../src/engine.js";
 import { recallAndInline, recallAndInlineAsync, formatRecallBlock } 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 { touchSession, logDaily, incCompactCount, incRecallInjected, incCacheHitTokens } from "../src/store/sqlite.js";
 import { consolidateMemories } from "../src/memory.js";
 import { C, MARKER_TYPE, } from "./mega-runtime.js";
 import { resolveRepoRoot, preserveRecentForPressure } from "./mega-config.js";
@@ -104,6 +104,12 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
         ? result.originalTokenEstimate
         : Math.max(0, result.originalTokenEstimate - result.tokenEstimate);
     runtime.rt.tokensSaved += saved;
+    runtime.rt.compactCount += 1;
+    incCompactCount(runtime.currentStateDir);
+    if (result.deduped) {
+        runtime.rt.cacheHitTokens += saved;
+        incCacheHitTokens(saved, runtime.currentStateDir);
+    }
     runtime.rt.lastCompactAt = Date.now();
     if (result.deduped)
         runtime.rt.dedupSkips++;
@@ -376,6 +382,15 @@ export function doRecall(runtime, config, ctx, query, source) {
         runtime.pushTicker(`${C.amber}↩${C.reset} recalled ${top.checkpoint.checkpointId} · ${scorePct}% · ${label}`);
         runtime.lastWhy = `why: recalled@${scorePct}% (${result.toInject.length} chkpt)`;
     }
+    if (result.toInject.length > 0) {
+        let sumTokens = 0;
+        for (const h of result.toInject)
+            sumTokens += h.checkpoint.tokenEstimate;
+        runtime.rt.recallInjections += result.toInject.length;
+        runtime.rt.cacheHitTokens += sumTokens;
+        incRecallInjected(result.toInject.length, runtime.currentStateDir);
+        incCacheHitTokens(sumTokens, runtime.currentStateDir);
+    }
     return result;
 }
 /**
@@ -425,6 +440,15 @@ export async function doRecallAsync(runtime, config, ctx, query, source, opts =
             }
         }
         const block = merged.length ? formatRecallBlock(merged) : "";
+        if (merged.length > 0) {
+            let sumTokens = 0;
+            for (const h of merged)
+                sumTokens += h.checkpoint.tokenEstimate;
+            runtime.rt.recallInjections += merged.length;
+            runtime.rt.cacheHitTokens += sumTokens;
+            incRecallInjected(merged.length, runtime.currentStateDir);
+            incCacheHitTokens(sumTokens, runtime.currentStateDir);
+        }
         return {
             toInject: merged,
             report: merged.map((h) => `  • ${h.checkpoint.checkpointId}${h.repoId ? ` (from ${h.repoId.split("/").filter(Boolean).pop()})` : ""}`),

package/dist/extensions/mega-runtime.js

@@ -16,7 +16,7 @@ import { VectorStore } from "../src/vectorStore.js";
 import { toEngineMessages } from "../src/adapt.js";
 import { normalizeSessionId } from "../src/store.js";
 import { Logger } from "../src/log.js";
-import { recordModelSnapshot, latestModelSnapshot, upsertRepoRegistry, recordRepoModel, } from "../src/store/sqlite.js";
+import { recordModelSnapshot, latestModelSnapshot, upsertRepoRegistry, recordRepoModel, getDedupStats, getCompactCount, getRecallInjected, getCacheHitTokensSaved, } from "../src/store/sqlite.js";
 import { detectCrossRepoDrift } from "../src/driftDetection.js";
 import { repoStateDir, resolveRepoRoot, pressureRatio, pressureFromPct, pressureBand, effectiveThresholdTokens, } from "./mega-config.js";
 import { Dashboard } from "./mega-dashboard.js";
@@ -57,6 +57,10 @@ export const C = {
     red: "\x1b[38;5;203m", // pressure / overflow
 };
 const PULSE = ["◐", "◓", "◑", "◒"];
+// Rough tokens-processed-per-second heuristic for the dashboard's "time saved"
+// estimate. Throughput varies by model/hardware; this is order-of-magnitude so
+// the dashboard can show a human-readable figure, not a precise measurement.
+const TOKENS_PER_SEC_ESTIMATE = 2000;
 // ── Full-width widget panel helpers ────────────────────────────────────────
 // pi's above-editor widget renderer (a Container of Text lines) does NOT pass
 // a terminal width to setWidget(), so lines render left-aligned by default. To
@@ -192,6 +196,10 @@ export class MegaRuntime {
         tokensSaved: 0,
         lastCompactAt: null,
         lastNativeCompactAt: null,
+        compactCount: 0,
+        recallInjections: 0,
+        cacheHitTokens: 0,
+        lengthStopPending: false,
     };
     debounceUntil = 0;
     // S16: debounce for the agent_end resume nudge (avoid busy-loops).
@@ -390,6 +398,12 @@ export class MegaRuntime {
         const st = this.store.stats(this.rt.sessionId);
         const repo = this.store.repoStats();
         const di = this.store.dataInvariant();
+        // Live + store-wide cache-hit / compaction counters for the dashboard.
+        const ds = getDedupStats(this.currentStateDir);
+        const cacheHitsTotal = ds.deduped + getRecallInjected(this.currentStateDir);
+        const cacheHitsTotalTokens = getCacheHitTokensSaved(this.currentStateDir);
+        const cacheHitsSession = this.rt.dedupSkips + this.rt.recallInjections;
+        const sec = (tok) => (tok || 0) / TOKENS_PER_SEC_ESTIMATE;
         // Active model/provider for the current-repo card + the multi-repo table.
         const modelSnap = latestModelSnapshot(this.currentStateDir);
         const model = modelSnap
@@ -402,15 +416,26 @@ export class MegaRuntime {
             }
             : undefined;
         // effectiveThresholdPct: the live fire point as a % of the window (null for
-        // `custom`, which has no tierPct). Used by armed/ready + the dashboard.
-        const effectiveThresholdPct = this.config.tierPct != null ? this.config.tierPct * 100 : null;
+        // `custom`, which has no tierPct). S29: honors MEGACOMPACT_AUTO_PCT_TRIGGER
+        // override so the dashboard's armed/ready match the context-handler gate
+        // (which fires on this same %). Used by armed/ready + the dashboard.
+        const effectiveThresholdPct = this.config.tierPct != null
+            ? (this.config.autoPctTrigger ?? this.config.tierPct) * 100
+            : null;
         // armed lights at/above the REAL fire point: max(effectiveThresholdPct,
         // fastGatePct). fastGatePct already equals tierPct*100 by default, but a
         // MEGACOMPACT_FAST_GATE_PCT override can raise it, so we take the max.
         const armed = this.lastCtxPercent != null &&
             this.lastCtxPercent >=
                 Math.max(effectiveThresholdPct ?? 0, this.config.fastGatePct);
-        const ready = armed && (this.lastCtxTokens ?? 0) >= this.effectiveThreshold;
+        // S29: ready mirrors the context-handler gate's basis — percent for tiered
+        // (the gate fires on pct), tokens for custom (the gate fires on tokens).
+        // Previously this always required tokens, so the dashboard could show
+        // "armed" (percent high) but never "ready" when tokens were under-reported
+        // — the same inconsistency the S29 gate fix removes.
+        const ready = this.config.tierPct != null
+            ? armed && (this.lastCtxPercent ?? 0) >= (effectiveThresholdPct ?? 0)
+            : armed && (this.lastCtxTokens ?? 0) >= this.effectiveThreshold;
         this.dashboard.snapshot({
             version: 1,
             updatedAt: new Date().toISOString(),
@@ -505,6 +530,20 @@ export class MegaRuntime {
                 duplicatesCollapsed: di.duplicatesCollapsed,
                 bytesPermanentlyDeleted: di.bytesPermanentlyDeleted,
             },
+            cacheHits: {
+                session: cacheHitsSession,
+                total: cacheHitsTotal,
+                sessionTokensSaved: this.rt.cacheHitTokens,
+                totalTokensSaved: cacheHitsTotalTokens,
+            },
+            compacts: {
+                session: this.rt.compactCount,
+                total: getCompactCount(this.currentStateDir),
+            },
+            timeSaved: {
+                compact: { sessionSec: sec(this.rt.tokensSaved), totalSec: sec(this.store.repoStats().tokensSaved) },
+                cacheHit: { sessionSec: sec(this.rt.cacheHitTokens), totalSec: sec(cacheHitsTotalTokens) },
+            },
             model,
         });
         // Live stats widget above the editor
@@ -517,7 +556,9 @@ export class MegaRuntime {
                 ? `${Math.round(this.lastCtxWindow / 1000)}k`
                 : "?";
             const pctStr = this.lastCtxPercent != null
-                ? `${Math.round(this.lastCtxPercent * 10) / 10}%`
+                ? this.lastCtxPercent > 100
+                    ? `>100%` // S29: overshoot warning, not a raw "250%" — the percent trigger now compacts before 100%, so this is the residual case where it can't keep up.
+                    : `${Math.round(this.lastCtxPercent * 10) / 10}%`
                 : "?%";
             // S24: the tier label is the LIVE pressure band (low/medium/high/ultra/
             // mega), not the static env preset. It climbs as context fills.
@@ -722,6 +763,10 @@ export class MegaRuntime {
             tokensSaved: 0,
             lastCompactAt: null,
             lastNativeCompactAt: null,
+            compactCount: 0,
+            recallInjections: 0,
+            cacheHitTokens: 0,
+            lengthStopPending: false,
         };
         this.statusKey = undefined;
         this.activeAgents = 0;