pi-mega-compact 0.7.7 → 0.7.9

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-conflict-cmds.ts

@@ -13,7 +13,7 @@ import { addMemory, listMemories, searchMemories, recallMemory, type MemoryRecor
 import { resolveRepoRoot } from "./mega-config.js";
 import { defaultEmbedder } from "../src/embedder.js";
 import { upsertMemoryEmbedding } from "../src/store/memoryIndex.js";
-import { MegaRuntime } from "./mega-runtime.js";
+import type { MegaRuntime } from "./mega-runtime.js";
 
 /** Run the conflict scan and format a human-readable report. */
 export function validateExtensions(): { report: ConflictReport; lines: string[] } {
@@ -111,8 +111,12 @@ export function registerConflictCommands(pi: ExtensionAPI, runtime: MegaRuntime)
       }
 
       if (sub === "recall") {
+        if (parts[1] === undefined) {
+          ctx.ui.notify("[mega-memory] usage: /mega-memory recall <id>");
+          return;
+        }
         const id = Number(parts[1]);
-        if (!Number.isFinite(id) || parts[1] === undefined) {
+        if (!Number.isFinite(id)) {
           ctx.ui.notify("[mega-memory] usage: /mega-memory recall <id>");
           return;
         }

package/extensions/mega-dashboard-cmds.ts

@@ -10,14 +10,20 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { join, dirname, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync, writeFileSync, readFileSync, unlinkSync, openSync, closeSync } from "node:fs";
-import { spawn } from "node:child_process"; // guardrails-allow PREVENT-PI-004: spawns the optional, user-triggered localhost dashboard server only
-import { MegaRuntime } from "./mega-runtime.js";
+import { spawn, execSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: spawns the optional, user-triggered localhost dashboard server only
+import type { MegaRuntime } from "./mega-runtime.js";
 
 /** Register the dashboard server lifecycle commands. */
 export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime): void {
-  const portFile = join(runtime.currentStateDir, "port.pid");
-  const runnerFile = join(runtime.currentStateDir, "_dashboard-runner.mjs");
-  const launchLog = join(runtime.currentStateDir, "_dashboard-launch.log");
+  // H3 fix: read currentStateDir at CALL time, not registration time. The
+  // previous `const portFile = join(runtime.currentStateDir, ...)` captured the
+  // state dir once at extension load; after a repo switch (bindRepo updates
+  // currentStateDir) the dashboard commands would read/write the OLD repo's
+  // port.pid — potentially spawning a duplicate server or failing to stop the
+  // current one. Functions re-resolve on every call.
+  const portFile = (): string => join(runtime.currentStateDir, "port.pid");
+  const runnerFile = (): string => join(runtime.currentStateDir, "_dashboard-runner.mjs");
+  const launchLog = (): string => join(runtime.currentStateDir, "_dashboard-launch.log");
   // Whether the runner must be spawned with --experimental-strip-types (true only
   // when we fall back to the .ts source outside node_modules; false when using
   // the shipped compiled dist/extensions/dashboard-server.js).
@@ -46,12 +52,12 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
     const port = await findLivePort();
     if (!port) {
       // Stale marker with no live server behind it — clean up.
-      if (existsSync(portFile)) {
-        try { unlinkSync(portFile); } catch { /* ignore */ }
+      if (existsSync(portFile())) {
+        try { unlinkSync(portFile()); } catch { /* ignore */ }
       }
       return null;
     }
-    return { port, url: `http://localhost:${port}`, hasPidFile: existsSync(portFile) }; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
+    return { port, url: `http://localhost:${port}`, hasPidFile: existsSync(portFile()) }; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
   }
 
   /** Version the running server on `port` reports, or null. */
@@ -81,7 +87,6 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
    *  (Linux/macOS) — best-effort, returns null if unavailable. */
   function pidOnPort(port: number): number | null {
     try {
-      const { execSync } = require("node:child_process"); // guardrails-allow PREVENT-PI-004: localhost-only, reads our own dashboard port owner
       const out = execSync(`ss -ltnp 2>/dev/null | grep ':${port} '`, { encoding: "utf-8" });
       const m = out.match(/pid=(\d+)/);
       return m ? Number(m[1]) : null;
@@ -96,14 +101,14 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
   function killServerOnPort(port: number): void {
     let pid: number | null = null;
     try {
-      const info = JSON.parse(readFileSync(portFile, "utf-8"));
+      const info = JSON.parse(readFileSync(portFile(), "utf-8"));
       if (info && info.pid) pid = info.pid;
     } catch { /* no marker */ }
     if (pid == null) pid = pidOnPort(port); // orphan with no pid.pid
     if (pid != null) {
       try { process.kill(pid, "SIGTERM"); } catch { /* already gone */ }
     }
-    try { unlinkSync(portFile); } catch { /* ignore */ }
+    try { unlinkSync(portFile()); } catch { /* ignore */ }
   }
 
   /**
@@ -145,7 +150,7 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
     dashboardNeedsStrip = resolved.needsStripTypes;
     const script = [
       `import { appendFileSync } from "node:fs";`,
-      `const __log = ${JSON.stringify(launchLog)};`,
+      `const __log = ${JSON.stringify(launchLog())};`,
       `function __fail(err) {`,
       `  const msg = "[mega-compact] dashboard failed: " + (err && err.stack ? err.stack : String(err));`,
       `  try { appendFileSync(__log, msg + "\\n"); } catch { /* ignore */ }`,
@@ -155,7 +160,7 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
       `import { launchDashboardServer } from ${JSON.stringify(resolved.entry)};`,
       `launchDashboardServer(${JSON.stringify(runtime.currentStateDir)}).catch(__fail);`,
     ].join("\n");
-    writeFileSync(runnerFile, script);
+    writeFileSync(runnerFile(), script);
     return true;
   }
 
@@ -214,10 +219,10 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
       // Clear any stale marker so a fresh bind never collides with a lingering
       // orphan, and truncate the launch log so the next error report shows only
       // this attempt's output.
-      try { unlinkSync(portFile); } catch { /* ignore */ }
-      try { writeFileSync(launchLog, ""); } catch { /* ignore */ }
+      try { unlinkSync(portFile()); } catch { /* ignore */ }
+      try { writeFileSync(launchLog(), ""); } catch { /* ignore */ }
 
-      const args = dashboardNeedsStrip ? ["--experimental-strip-types", runnerFile] : [runnerFile];
+      const args = dashboardNeedsStrip ? ["--experimental-strip-types", runnerFile()] : [runnerFile()];
       // Redirect the child's stderr to the launch log so that a CRASH BEFORE the
       // runner's own __fail handler runs (e.g. an ESM module-load / parse error,
       // or a missing entry) is still captured. With the old `stdio: "ignore"`
@@ -226,7 +231,7 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
       // child; once spawned we close our copy (the child keeps its own dup).
       let stderrFd: number;
       try {
-        stderrFd = openSync(launchLog, "a");
+        stderrFd = openSync(launchLog(), "a");
       } catch {
         stderrFd = -1; // fall back to ignored stderr
       }
@@ -253,10 +258,10 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
       if (!port) {
         let detail = "";
         try {
-          const log = readFileSync(launchLog, "utf-8").trim();
+          const log = readFileSync(launchLog(), "utf-8").trim();
           if (log) detail = ` — ${log.split("\n").slice(-3).join("; ")}`;
         } catch { /* no log yet */ }
-        ctx.ui.notify(`[mega-compact] dashboard server failed to start${detail}. See ${launchLog}`);
+        ctx.ui.notify(`[mega-compact] dashboard server failed to start${detail}. See ${launchLog()}`);
         return;
       }
 
@@ -270,24 +275,25 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
   pi.registerCommand("mega-dashboard-stop", {
     description: "Stop the local dashboard server.",
     handler: async (_args: string, ctx: ExtensionContext) => {
-      if (!existsSync(portFile)) {
+      runtime.bindRepo(ctx.cwd);
+      if (!existsSync(portFile())) {
         ctx.ui.notify("[mega-compact] no dashboard server running.");
         return;
       }
       try {
-        const info = JSON.parse(readFileSync(portFile, "utf-8"));
+        const info = JSON.parse(readFileSync(portFile(), "utf-8"));
         // Verify the server is actually ours by probing the port before killing
         try {
           await fetch(`http://localhost:${info.port}/api/snapshot`, { signal: AbortSignal.timeout(1000) }); // guardrails-allow PREVENT-PI-004: localhost probe to verify the dashboard server is ours before stopping it
         } catch {
           // Not responding — just clean up stale pid file
-          try { unlinkSync(portFile); } catch { /* ok */ }
+          try { unlinkSync(portFile()); } catch { /* ok */ }
           ctx.ui.notify("[mega-compact] dashboard was not running (stale pid file cleaned up).");
           return;
         }
         if (info?.pid) process.kill(info.pid, "SIGTERM");
       } catch { /* already dead */ }
-      try { unlinkSync(portFile); } catch { /* ok */ }
+      try { unlinkSync(portFile()); } catch { /* ok */ }
       ctx.ui.notify("[mega-compact] dashboard stopped.");
     },
   });
@@ -295,6 +301,7 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
   pi.registerCommand("mega-dashboard-status", {
     description: "Check if the dashboard server is running.",
     handler: async (_args: string, ctx: ExtensionContext) => {
+      runtime.bindRepo(ctx.cwd);
       const info = await isServerRunning();
       if (info) {
         ctx.ui.notify(`[mega-compact] dashboard running at ${info.url}`);

package/extensions/mega-db-cmds.ts

@@ -32,17 +32,17 @@ function fmtBytes(n: number): string {
 
 /** Register the /mega-db-* maintenance commands. */
 export function registerDbCommands(pi: ExtensionAPI, runtime: MegaRuntime): void {
-  const stateDir = runtime.currentStateDir;
-
   pi.registerCommand("mega-db-stats", {
     description:
       "Show mega-compact SQLite DB stats: table row counts, disk footprint (db + WAL + SHM), page count, freelist, WAL frames.",
     handler: async (_args: string, ctx: ExtensionContext) => {
+      runtime.bindRepo(ctx.cwd);
+      const stateDir = runtime.currentStateDir;
       const s = getDbStats(stateDir);
       ctx.ui.notify(`[mega-compact] DB stats — ${stateDir}`);
       ctx.ui.notify(`  main: ${fmtBytes(s.dbBytes)}  wal: ${fmtBytes(s.walBytes)}  shm: ${fmtBytes(s.shmBytes)}`);
       ctx.ui.notify(
-        `  pages: ${s.pageCount} (${s.pageSize}B each), freelist: ${s.freelistPages} (${s.pageCount > 0 ? ((s.freelistPages / s.pageCount) * 100).toFixed(1) : "0"}% reusable), wal frames: ${s.walFrames}`,
+        `  pages: ${s.pageCount} (${s.pageSize}B each), freelist: ${s.freelistPages} (${s.pageCount > 0 ? ((s.freelistPages / s.pageCount) * 100).toFixed(1) : "0.0"}% reusable), wal frames: ${s.walFrames}`,
       );
       const tableLines = Object.entries(s.tableCounts)
         .sort((a, b) => b[1] - a[1])
@@ -60,6 +60,8 @@ export function registerDbCommands(pi: ExtensionAPI, runtime: MegaRuntime): void
     description:
       "Prune raw_transcript + checkpoint_epochs + orphan dedup_mirror rows older than N days (default 30). Usage: /mega-db-prune [days]",
     handler: async (args: string, ctx: ExtensionContext) => {
+      runtime.bindRepo(ctx.cwd);
+      const stateDir = runtime.currentStateDir;
       const days = Number.parseInt(args.trim().split(/\s+/)[0] ?? "30", 10);
       const d = Number.isFinite(days) && days > 0 ? days : 30;
       const r = pruneOldRows(stateDir, d);
@@ -71,6 +73,8 @@ export function registerDbCommands(pi: ExtensionAPI, runtime: MegaRuntime): void
     description:
       "VACUUM the mega-compact SQLite DB (rebuild pages, reclaim freelist space). Heavy: briefly doubles disk usage.",
     handler: async (_args: string, ctx: ExtensionContext) => {
+      runtime.bindRepo(ctx.cwd);
+      const stateDir = runtime.currentStateDir;
       const r = vacuumDb(stateDir);
       ctx.ui.notify(`[mega-compact] ${r.summary}`);
     },
@@ -80,6 +84,8 @@ export function registerDbCommands(pi: ExtensionAPI, runtime: MegaRuntime): void
     description:
       "Run PRAGMA integrity_check + a WAL checkpoint on the mega-compact SQLite DB. Use after a crash or to fold the WAL into the main file.",
     handler: async (_args: string, ctx: ExtensionContext) => {
+      runtime.bindRepo(ctx.cwd);
+      const stateDir = runtime.currentStateDir;
       const lines = integrityCheck(stateDir);
       const healthy = lines.length === 1 && lines[0] === "ok";
       ctx.ui.notify(
@@ -98,6 +104,8 @@ export function registerDbCommands(pi: ExtensionAPI, runtime: MegaRuntime): void
     description:
       "Reconcile dedup_mirror.ref_count vs actual raw_transcript refs: fix drift, delete orphan dedup rows, backfill missing content_ref. Run after /mega-db-prune or a crash.",
     handler: async (_args: string, ctx: ExtensionContext) => {
+      runtime.bindRepo(ctx.cwd);
+      const stateDir = runtime.currentStateDir;
       const r: DedupReconcileResult = reconcileDedupMirror(stateDir);
       ctx.ui.notify(
         `[mega-compact] dedup reconcile: fixed ${r.fixedRefCount} ref_count drift, deleted ${r.orphansDeleted} orphan(s), backfilled ${r.refsBackfilled} content_ref`,

package/extensions/mega-events/agent-handlers.ts

@@ -0,0 +1,214 @@
+/**
+ * mega-events/agent-handlers.ts — agent/turn tracking event handlers.
+ *
+ * Registers agent_start/end (widget + status updates, durable-trim trigger)
+ * and turn_start/end (turn index, memory auto-review, length-stop detection).
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type MegaRuntime } from "../mega-runtime.js";
+import {
+	piCompactWouldNoop,
+	runMemoryReview,
+} from "../mega-pipeline.js";
+import {
+	memoryReviewCadence,
+	type MegaConfig,
+} from "../mega-config.js";
+
+/** Register agent/turn tracking event handlers. */
+export function registerAgentHandlers(
+	pi: ExtensionAPI,
+	runtime: MegaRuntime,
+	config: MegaConfig,
+): void {
+	// ---- Agent tracking for real-time widget + status-line updates ---------
+	pi.on("agent_start", async (_event, ctx) => {
+		runtime.activeAgents++;
+		runtime.dashboard.event("agent_start", {
+			activeAgents: runtime.activeAgents,
+		});
+		// Surface live agent activity on the status line (toolbar), not just the
+		// above-editor widget — otherwise concurrent agents look frozen.
+		runtime.setStatus(
+			ctx,
+			`mega-compact: ▶ ${runtime.activeAgents} agent${runtime.activeAgents === 1 ? "" : "s"}`,
+		);
+		runtime.snapshot(ctx);
+	});
+
+	pi.on("agent_end", async (_event, ctx) => {
+		runtime.activeAgents = Math.max(0, runtime.activeAgents - 1);
+		runtime.dashboard.event("agent_end", {
+			activeAgents: runtime.activeAgents,
+		});
+		if (runtime.activeAgents > 0) {
+			runtime.setStatus(
+				ctx,
+				`mega-compact: ▶ ${runtime.activeAgents} agent${runtime.activeAgents === 1 ? "" : "s"}`,
+			);
+		} else {
+			runtime.setStatus(
+				ctx,
+				config.auto ? "mega-compact: ready" : "mega-compact: manual only",
+			);
+		}
+		// S16 continuation fallback: if the turn settled idle right after a live-trim
+		// 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 || config.autoContinueLengthStop) && runtime.activeAgents === 0) {
+			try {
+				const idle = ctx.isIdle?.() ?? true;
+				const queued = ctx.hasPendingMessages?.() ?? false;
+				const now = Date.now();
+				// DIAG (team-run relief): surface whether the agent is idle + over
+				// threshold at agent_end so we can see if a mid-run durable-trim trigger
+				// *should* have fired but didn't.
+				const overThreshold =
+					(runtime.lastCtxTokens ?? 0) >= runtime.effectiveThreshold;
+				runtime.diagAgentEndIdle++;
+				runtime.logger.info("agent-end-idle", {
+					sessionId: runtime.rt.sessionId,
+					idle,
+					queued,
+					overThreshold,
+					ctxPct: runtime.lastCtxPercent,
+					ctxTokens: runtime.lastCtxTokens,
+					thresholdTokens: config.thresholdTokens,
+					wouldNudge:
+						idle &&
+						(queued || overThreshold) &&
+						now >= runtime.resumeNudgeUntil,
+				});
+				// S16+S24: MID-RUN DURABLE TRIM. During a long team run (sub-agents),
+				// pi's native durable compaction only fires from _checkCompaction at
+				// PARENT settle (agent-session.js:760/844), so the on-disk transcript +
+				// context meter balloon to ~150k and never relieve until the very end
+				// ("compacts but doesn't resume"). agent_end with activeAgents===0 is a
+				// SAFE, settled point: calling ctx.compact() here does NOT abort an
+				// in-flight turn (the S16 danger is only mid-turn). ctx.compact() runs
+				// pi's flow, which fires our session_before_compact handler to supply
+				// the durable trim (truncates the transcript from firstKeptEntryId).
+				// Guarded three ways: only when truly idle + over threshold, only when
+				// pi would actually compact (piCompactWouldNoop skips the user-facing
+				// no-op throw), and debounced (one durable trim per 2s) to avoid
+				// thrashing the transcript while sub-agents keep settling.
+				//
+				// FIX "compacts but doesn't resume": the manual ctx.compact() path
+				// STOPS the agent loop (agent-session.js:1345). The old resume-nudge
+				// was gated on `queued`, so when a sub-agent settled with no
+				// *immediately* queued message, the trim fired but the nudge did not,
+				// and the (stopped) session hung. The trim still fires on
+				// `idle && overThreshold` — we intentionally do NOT add a `!queued`
+				// guard, because that would suppress mid-run relief exactly during
+				// team-run waves where queued is usually true and relief is needed
+				// 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 (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:
+					// "Called after agent_end and before prompt submission"), so a
+					// synchronous `piCompactWouldNoop` branch check misses a native
+					// compaction that hasn't appended its entry yet — calling
+					// ctx.compact() then races with pi and throws "Already compacted"
+					// to the user. The `lastCompactAt` cooldown (updated by the
+					// session_compact listener for EVERY compaction, native or
+					// extension-supplied) closes that race window.
+					const sinceCompact = now - (runtime.rt.lastNativeCompactAt ?? 0);
+					if (sinceCompact < 10_000) {
+						runtime.diagAgentEndDurableSkipRecent++;
+					} else if (!piCompactWouldNoop(ctx)) {
+						runtime.debounceUntil = now + 2000;
+						runtime.diagAgentEndDurable++;
+						runtime.logger.info("agent-end-durable-trigger", {
+							sessionId: runtime.rt.sessionId,
+							ctxTokens: runtime.lastCtxTokens,
+							thresholdTokens: config.thresholdTokens,
+							queued,
+						});
+						ctx.compact({ customInstructions: undefined }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; agent settled so no in-flight abort. Race-guarded by lastCompactAt cooldown above (ctx.compact returns void → throw is surfaced by pi as compaction_end; the cooldown prevents the call entirely).
+						didDurableTrim = true;
+					}
+				}
+				// 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 &&
+					((config.auto && (didDurableTrim || queued)) || lengthStop)
+				) {
+					runtime.resumeNudgeUntil = now + 30_000;
+					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 */
+			}
+		}
+		runtime.snapshot(ctx);
+	});
+
+	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);
+	});
+
+	pi.on("turn_end", async (event, ctx) => {
+		runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
+		runtime.snapshot(ctx);
+
+		// S20+S24: auto-review the conversation and persist durable memories. The
+		// review cadence scales with pressure (memoryReviewCadence): as context
+		// fills, the conversation is reviewed more often so memories keep pace with
+		// faster churn. Best-effort + non-fatal: a review failure must never break
+		// the agent loop. Debounced by the pressure-adjusted interval.
+		if (config.memoryAutoReview && runtime.currentTurn > 0) {
+			const cadence = memoryReviewCadence(
+				runtime.pressureBand,
+				config.memoryReviewInterval,
+			);
+			if (runtime.currentTurn % cadence === 0) {
+				// S20+S24: review the conversation and persist durable memories. The
+				// cadence scales with pressure (memoryReviewCadence): as context fills,
+				// the conversation is reviewed more often so memories keep pace with
+				// faster churn. Shared runMemoryReview body (also used on compact).
+				const entries = ctx.sessionManager.getEntries();
+				const view = runtime.engineView(
+					entries.flatMap((e: any) => (e.message ? [e.message] : [])),
+				);
+				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 });
+		}
+	});
+}

package/extensions/mega-events/compact-handlers.ts

@@ -0,0 +1,164 @@
+/**
+ * mega-events/compact-handlers.ts — native compaction event handlers.
+ *
+ * Registers session_before_compact (supplies durable trim via
+ * driveNativeCompaction + fallback) and session_compact (tracks every
+ * compaction for the race-closing cooldown). Contains the helper functions
+ * fallbackCompaction and nudgeResume.
+ */
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+	SessionBeforeCompactEvent,
+	SessionCompactEvent,
+} from "@earendil-works/pi-coding-agent";
+import {
+	driveNativeCompaction,
+	type NativeCompactionResult,
+} from "../mega-compact-driver.js";
+import { estimateBlockTokens } from "../../src/tokens.js";
+import { type MegaRuntime } from "../mega-runtime.js";
+import type { MegaConfig } from "../mega-config.js";
+
+/**
+ * Build a minimal fallback compaction so pi never runs its throwing compact().
+ *
+ * Used when our Trident/RAPTOR summary is empty or there is nothing to
+ * summarize (the anchor floor protects every message). We still record a
+ * resume summary + truncate from prep.firstKeptEntryId so the session always
+ * gets a compact summary and resumes. Returns undefined only if pi handed us
+ * no preparation cut point at all.
+ */
+function fallbackCompaction(
+	event: SessionBeforeCompactEvent,
+): NativeCompactionResult | undefined {
+	const prep = event.preparation;
+	if (!prep?.firstKeptEntryId) return undefined;
+	// When messagesToSummarize is empty the anchor floor protects everything,
+	// so firstKeptEntryId == current first entry and the trim is a no-op — but
+	// we still record a resume summary so the session has context after compaction.
+	const tokensBefore = prep.tokensBefore ?? 0;
+	const summary =
+		`[mega-compact] context compacted at ${tokensBefore.toLocaleString()} tokens ` +
+		`(anchor floor active). Continue from the most recent messages above.`;
+	return {
+		compaction: {
+			summary,
+			firstKeptEntryId: prep.firstKeptEntryId,
+			tokensBefore,
+			estimatedTokensAfter: estimateBlockTokens(summary),
+		},
+	};
+}
+
+/**
+ * Debounced resume-nudge: restart the agent loop after a compaction (which
+ * may have stopped it). Idempotent — one nudge per 30s, never blocks.
+ */
+function nudgeResume(pi: ExtensionAPI, runtime: MegaRuntime): void {
+	try {
+		const now = Date.now();
+		if (now >= runtime.resumeNudgeUntil) {
+			runtime.resumeNudgeUntil = now + 30_000;
+			pi.sendUserMessage(
+				"[mega-compact] continue from the compacted context above.",
+			);
+		}
+	} catch {
+		/* non-fatal: a failed nudge never blocks */
+	}
+}
+
+/** Register native compaction event handlers. */
+export function registerCompactHandlers(
+	pi: ExtensionAPI,
+	runtime: MegaRuntime,
+	config: MegaConfig,
+): void {
+	// ---- Supply a DURABLE trim to pi's native compaction (Fix B) ----------
+	// We run the Trident pipeline to produce a compressed summary, then return
+	// it as a CompactionResult. pi writes the summary into a compactionSummary
+	// entry AND truncates the on-disk transcript from firstKeptEntryId. This is
+	// the durable fix for "tokens grow on read": the trim survives resume, so
+	// there is no full-reload + additive recall inflation.
+	pi.on(
+		"session_before_compact",
+		async (event: SessionBeforeCompactEvent, ctx: ExtensionContext) => {
+			runtime.resetRuntime(ctx.sessionManager.getSessionId());
+			// DIAG (team-run relief): this is the ONLY durable-trim entry point. Log
+			// every fire + whether we supplied a compaction (truncates transcript) or
+			// fell through to {} (pi runs its own). If this is sparse during a team
+			// run, the durable trim is firing too late (only at parent settle).
+			const prep = event.preparation;
+			runtime.diagBeforeCompactFires++;
+			runtime.logger.info("before-compact-entry", {
+				sessionId: runtime.rt.sessionId,
+				reason: event.reason,
+				hasPrep: !!prep,
+				msgsToSummarize: prep?.messagesToSummarize?.length ?? 0,
+				firstKeptEntryId: prep?.firstKeptEntryId ?? null,
+				activeAgents: runtime.activeAgents,
+			});
+			if (!config.auto) return {}; // let pi run its own native compaction
+			try {
+				const result = driveNativeCompaction(event, runtime, config);
+				if (result && result.compaction.summary?.trim()) {
+					runtime.diagBeforeCompactSupplied++;
+					runtime.logger.info("native-compact", {
+						sessionId: runtime.rt.sessionId,
+						firstKeptEntryId: result.compaction.firstKeptEntryId,
+						tokensBefore: result.compaction.tokensBefore,
+						summaryTokens: result.compaction.estimatedTokensAfter,
+					});
+					nudgeResume(pi, runtime);
+					return { compaction: result.compaction };
+				}
+				// FIX "compacts but doesn't resume" + "Nothing to compact" regression:
+				// when we have nothing to summarize (anchor floor protects everything →
+				// messagesToSummarize empty) or our Trident/RAPTOR summary came back
+				// EMPTY, pi's OWN compact() throws "Nothing to compact (session too
+				// small)" and leaves the session stuck with no resume context. Instead
+				// of returning {} (which makes pi run its throwing compact()), supply a
+				// fallback compaction from prep.firstKeptEntryId with a minimal resume
+				// summary. This ALWAYS injects a compact summary so the session
+				// resumes, and never surfaces the "Nothing to compact" error to the user.
+				const fb = fallbackCompaction(event);
+				if (fb) {
+					runtime.diagBeforeCompactSupplied++;
+					runtime.logger.info("native-compact-fallback", {
+						sessionId: runtime.rt.sessionId,
+						firstKeptEntryId: fb.compaction.firstKeptEntryId,
+						tokensBefore: fb.compaction.tokensBefore,
+						reason: event.reason,
+					});
+					nudgeResume(pi, runtime);
+					return { compaction: fb.compaction };
+				}
+			} catch (err) {
+				runtime.logger.error("native-compact-failed", {
+					sessionId: runtime.rt.sessionId,
+					error: String(err instanceof Error ? err.message : err),
+				});
+			}
+			// Absolute last resort: let pi run its own (may throw "Nothing to compact").
+			return {};
+		},
+	);
+
+		// COMPACT-DEDUP FIX: track EVERY compaction (native + extension-supplied)
+		// so the agent_end durable-trim guard can skip a redundant ctx.compact()
+		// when pi just compacted. Without this, agent_end fires ctx.compact()
+		// synchronously AFTER pi's native auto-compaction appended a compaction
+		// entry but BEFORE our branch read sees it on the next tick — racing
+		// into a user-facing "Already compacted" throw. `lastCompactAt` is the
+		// race-closing signal: any compaction (manual/threshold/overflow, ours
+		// or pi's own) stamps it, and the agent_end guard skips for 10s.
+		pi.on("session_compact", async (_event: SessionCompactEvent, _ctx: ExtensionContext) => {
+			runtime.rt.lastNativeCompactAt = Date.now();
+			runtime.rt.lastCompactAt = Date.now();
+			runtime.logger.info("session-compacted", {
+				sessionId: runtime.rt.sessionId,
+				at: runtime.rt.lastCompactAt,
+			});
+		});
+}