pi-mega-compact 0.7.7 → 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-runtime.js

@@ -199,6 +199,7 @@ export class MegaRuntime {
         compactCount: 0,
         recallInjections: 0,
         cacheHitTokens: 0,
+        lengthStopPending: false,
     };
     debounceUntil = 0;
     // S16: debounce for the agent_end resume nudge (avoid busy-loops).
@@ -415,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(),
@@ -544,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.
@@ -752,6 +766,7 @@ export class MegaRuntime {
             compactCount: 0,
             recallInjections: 0,
             cacheHitTokens: 0,
+            lengthStopPending: false,
         };
         this.statusKey = undefined;
         this.activeAgents = 0;

package/extensions/mega-compact.test.ts

@@ -50,6 +50,7 @@ function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
 	let statusText: string | undefined;
 	const notifies: string[] = [];
 	const compactCalls: any[] = [];
+	const sendUserMessages: string[] = [];
 
 	// Minimal AgentMessage factory for the session we project into the extension.
 	function msg(role: string, text: string, toolName?: string): AgentMessage {
@@ -192,7 +193,7 @@ function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
 		registerMessageRenderer: () => {},
 		registerEntryRenderer: () => {},
 		sendMessage: (_m: any) => {},
-		sendUserMessage: () => {},
+		sendUserMessage: (m: string) => { sendUserMessages.push(m); },
 		appendEntry: (t: string, d: any) => appended.push({ t, d }),
 		setSessionName: () => {},
 		getSessionName: () => undefined,
@@ -221,6 +222,7 @@ function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
 		},
 		notifies,
 		compactCalls,
+		sendUserMessages,
 		fire: (ev: string, event: any, ctx: any) => handlers[ev](event, ctx),
 		ctx: makeCtx,
 		session,
@@ -957,40 +959,6 @@ test("/dashboard skips server spawn when already running", async () => {
 	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<void>((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<void>((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({
@@ -1056,6 +1024,299 @@ test("events.log receives compaction events", async () => {
 	}
 });
 
+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: string): string[] {
+	const { readFileSync: rf, existsSync: ex } = require("node:fs") as typeof import("node:fs");
+	const { join: j } = require("node:path") as typeof import("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): t is string => 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"] as const) {
+		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: ReturnType<typeof harness>, usage: { tokens: number; contextWindow: number; percent: number | null }) {
+	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 as any,
+	});
+}
+
+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 as any).messages), "percent gate: result has a trimmed messages array");
+		assert.ok(
+			(res as any).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 as any).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 as any).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 as any).messages) && (res90 as any).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 as any).messages) && (res as any).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 as any).messages) && (res as any).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/extensions/mega-config.ts

@@ -66,6 +66,17 @@ export interface MegaConfig {
   auto: boolean;
   autoInline: boolean;
   autoInlineK: number;
+  /** S28: auto-continue the agent after a max-output-token length stop by
+   *  reusing the existing S16 resume-nudge. Default true. Off = silent (the
+   *  prior behavior). PREVENT-PI-003: restart via user-role sendUserMessage. */
+  autoContinueLengthStop: boolean;
+  /** S29: override the auto-compact fire point for tiered configs, as a
+   *  fraction of the context window (e.g. 0.85). null = inherit the tier's
+   *  tierPct (default; preserves existing fire points). The context-handler
+   *  gate fires on context % (reliable), not token count (under-reported),
+   *  so it catches the overshoot that causes max-output-token truncation.
+   *  `custom` (tierPct null) ignores this — it keeps the absolute token gate. */
+  autoPctTrigger: number | null;
   dedupSim: number;
   /** RAPTOR hierarchical recall enabled (Fix D). Drives both live recall and
    *  the durable-trim summary source (root summary). */
@@ -204,6 +215,15 @@ export {
 /** Build the resolved config from env + defaults. */
 export function loadConfig(): MegaConfig {
   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,
@@ -217,6 +237,8 @@ export function loadConfig(): MegaConfig {
     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/extensions/mega-events.ts

@@ -40,6 +40,7 @@ import {
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "./mega-trim.js";
 import {
 	pressureFromPct,
+	pressureRatio,
 	memoryReviewCadence,
 	type MegaConfig,
 } from "./mega-config.js";
@@ -267,7 +268,7 @@ export function registerEventHandlers(
 		// 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;
@@ -316,7 +317,7 @@ export function registerEventHandlers(
 				// 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:
@@ -346,15 +347,28 @@ export function registerEventHandlers(
 				// 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 {
 				/* non-fatal: a failed nudge never blocks */
@@ -365,6 +379,7 @@ export function registerEventHandlers(
 
 	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);
 	});
@@ -395,6 +410,18 @@ export function registerEventHandlers(
 				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 ----
@@ -420,14 +447,13 @@ export function registerEventHandlers(
 		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
@@ -445,15 +471,35 @@ export function registerEventHandlers(
 			}
 		}
 
-		// 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;
+		} 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;
 		}
-
-		const check = autoCompactCheck(currentTokens, runtime.effectiveThreshold); // SERVER-STYLE CONFIRM (local)
-		if (!check.shouldCompact) {
-			runtime.diagCtxNoCompact++;
+		if (!gatePassed) {
+			runtime.diagCtxFastGate++;
 			return;
 		}
 
@@ -466,8 +512,10 @@ export function registerEventHandlers(
 		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/extensions/mega-runtime.ts

@@ -81,6 +81,7 @@ interface SessionRuntime {
 	compactCount: number; // compactions performed this session-instance
 	recallInjections: number; // recall blocks injected this session-instance
 	cacheHitTokens: number; // tokens saved via cache hits (dedup + recall) this session
+	lengthStopPending: boolean; // S28: set on turn_end when stopReason==='length'
 }
 
 /** ANSI palette for the toolbar. The pi TUI's Text component preserves ANSI
@@ -290,6 +291,7 @@ export class MegaRuntime {
 		compactCount: 0,
 		recallInjections: 0,
 		cacheHitTokens: 0,
+		lengthStopPending: false,
 	};
 	debounceUntil = 0;
 	// S16: debounce for the agent_end resume nudge (avoid busy-loops).
@@ -519,9 +521,13 @@ 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.
+		// `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.tierPct * 100 : null;
+			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.
@@ -529,7 +535,15 @@ export class MegaRuntime {
 			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(),
@@ -656,7 +670,9 @@ export class MegaRuntime {
 					: "?";
 			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.
@@ -888,6 +904,7 @@ export class MegaRuntime {
 			compactCount: 0,
 			recallInjections: 0,
 			cacheHitTokens: 0,
+			lengthStopPending: false,
 	};
 		this.statusKey = undefined;
 		this.activeAgents = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",