pi-mega-compact 0.7.6 → 0.7.8

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-dashboard.ts

@@ -114,6 +114,23 @@ export interface DashboardSnapshot {
     duplicatesCollapsed: number;     // dedup duplicates (original kept on survivor)
     bytesPermanentlyDeleted: number; // ALWAYS 0 — the invariant
   };
+  /** Cache-hit / recall-injection counters (live session + store-wide totals). */
+  cacheHits: {
+    session: number;            // dedup skips + recall injections this session
+    total: number;              // store-wide deduped collapses + recall injections
+    sessionTokensSaved: number; // tokens saved via cache hits this session
+    totalTokensSaved: number;   // store-wide tokens saved via cache hits
+  };
+  /** Compaction counters (live session + store-wide cumulative). */
+  compacts: {
+    session: number;            // compactions performed this session
+    total: number;              // store-wide cumulative compaction count
+  };
+  /** Estimated wall-clock time saved (rough tokens/sec heuristic). */
+  timeSaved: {
+    compact: { sessionSec: number; totalSec: number };
+    cacheHit: { sessionSec: number; totalSec: number };
+  };
   /** Active model/provider (captured live) — shown on the current-repo card. */
   model?: {
     name: string;          // Model.name or Model.id

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-pipeline.ts

@@ -15,7 +15,7 @@ import type { EngineMessage } from "../src/types.js";
 import { recallAndInline, recallAndInlineAsync, formatRecallBlock, type RecallInjectResult } 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 {
   type MegaRuntime,
@@ -146,6 +146,9 @@ function doCompact(
     ? 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++;
   // Grow the rolling "saved" goal so the progress bar always has a fresh
@@ -435,6 +438,13 @@ export function doRecall(
     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;
 }
 
@@ -493,6 +503,13 @@ export async function doRecallAsync(
       if (!seen.has(h.checkpoint.checkpointId)) { merged.push(h); seen.add(h.checkpoint.checkpointId); }
     }
     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()})` : ""}`),