pi-mega-compact 0.7.8 → 0.7.9

package/dist/extensions/mega-dashboard-cmds.js

@@ -8,12 +8,18 @@
 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 { spawn, execSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: spawns the optional, user-triggered localhost dashboard server only
 /** Register the dashboard server lifecycle commands. */
 export function registerDashboardCommands(pi, runtime) {
-    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 = () => join(runtime.currentStateDir, "port.pid");
+    const runnerFile = () => join(runtime.currentStateDir, "_dashboard-runner.mjs");
+    const launchLog = () => 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).
@@ -42,15 +48,15 @@ export function registerDashboardCommands(pi, runtime) {
         const port = await findLivePort();
         if (!port) {
             // Stale marker with no live server behind it — clean up.
-            if (existsSync(portFile)) {
+            if (existsSync(portFile())) {
                 try {
-                    unlinkSync(portFile);
+                    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. */
     async function serverVersion(port) {
@@ -80,7 +86,6 @@ export function registerDashboardCommands(pi, runtime) {
      *  (Linux/macOS) — best-effort, returns null if unavailable. */
     function pidOnPort(port) {
         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;
@@ -95,7 +100,7 @@ export function registerDashboardCommands(pi, runtime) {
     function killServerOnPort(port) {
         let pid = 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;
         }
@@ -109,7 +114,7 @@ export function registerDashboardCommands(pi, runtime) {
             catch { /* already gone */ }
         }
         try {
-            unlinkSync(portFile);
+            unlinkSync(portFile());
         }
         catch { /* ignore */ }
     }
@@ -154,7 +159,7 @@ export function registerDashboardCommands(pi, runtime) {
         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 */ }`,
@@ -164,7 +169,7 @@ export function registerDashboardCommands(pi, runtime) {
             `import { launchDashboardServer } from ${JSON.stringify(resolved.entry)};`,
             `launchDashboardServer(${JSON.stringify(runtime.currentStateDir)}).catch(__fail);`,
         ].join("\n");
-        writeFileSync(runnerFile, script);
+        writeFileSync(runnerFile(), script);
         return true;
     }
     /** Open a URL in the default browser. Platform-aware. Uses spawn (not exec) to avoid shell injection. */
@@ -219,14 +224,14 @@ export function registerDashboardCommands(pi, runtime) {
             // orphan, and truncate the launch log so the next error report shows only
             // this attempt's output.
             try {
-                unlinkSync(portFile);
+                unlinkSync(portFile());
             }
             catch { /* ignore */ }
             try {
-                writeFileSync(launchLog, "");
+                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"`
@@ -235,7 +240,7 @@ export function registerDashboardCommands(pi, runtime) {
             // child; once spawned we close our copy (the child keeps its own dup).
             let stderrFd;
             try {
-                stderrFd = openSync(launchLog, "a");
+                stderrFd = openSync(launchLog(), "a");
             }
             catch {
                 stderrFd = -1; // fall back to ignored stderr
@@ -265,12 +270,12 @@ export function registerDashboardCommands(pi, runtime) {
             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;
             }
             const url = `http://localhost:${port}`; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
@@ -283,12 +288,13 @@ export function registerDashboardCommands(pi, runtime) {
     pi.registerCommand("mega-dashboard-stop", {
         description: "Stop the local dashboard server.",
         handler: async (_args, ctx) => {
-            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
@@ -296,7 +302,7 @@ export function registerDashboardCommands(pi, runtime) {
                 catch {
                     // Not responding — just clean up stale pid file
                     try {
-                        unlinkSync(portFile);
+                        unlinkSync(portFile());
                     }
                     catch { /* ok */ }
                     ctx.ui.notify("[mega-compact] dashboard was not running (stale pid file cleaned up).");
@@ -307,7 +313,7 @@ export function registerDashboardCommands(pi, runtime) {
             }
             catch { /* already dead */ }
             try {
-                unlinkSync(portFile);
+                unlinkSync(portFile());
             }
             catch { /* ok */ }
             ctx.ui.notify("[mega-compact] dashboard stopped.");
@@ -316,6 +322,7 @@ export function registerDashboardCommands(pi, runtime) {
     pi.registerCommand("mega-dashboard-status", {
         description: "Check if the dashboard server is running.",
         handler: async (_args, ctx) => {
+            runtime.bindRepo(ctx.cwd);
             const info = await isServerRunning();
             if (info) {
                 ctx.ui.notify(`[mega-compact] dashboard running at ${info.url}`);

package/dist/extensions/mega-db-cmds.js

@@ -22,14 +22,15 @@ function fmtBytes(n) {
 }
 /** Register the /mega-db-* maintenance commands. */
 export function registerDbCommands(pi, runtime) {
-    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, ctx) => {
+            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}`);
+            ctx.ui.notify(`  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])
                 .map(([t, c]) => `  ${t.padEnd(22)} ${String(c).padStart(8)}`);
@@ -46,6 +47,8 @@ export function registerDbCommands(pi, runtime) {
     pi.registerCommand("mega-db-prune", {
         description: "Prune raw_transcript + checkpoint_epochs + orphan dedup_mirror rows older than N days (default 30). Usage: /mega-db-prune [days]",
         handler: async (args, ctx) => {
+            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);
@@ -55,6 +58,8 @@ export function registerDbCommands(pi, runtime) {
     pi.registerCommand("mega-db-vacuum", {
         description: "VACUUM the mega-compact SQLite DB (rebuild pages, reclaim freelist space). Heavy: briefly doubles disk usage.",
         handler: async (_args, ctx) => {
+            runtime.bindRepo(ctx.cwd);
+            const stateDir = runtime.currentStateDir;
             const r = vacuumDb(stateDir);
             ctx.ui.notify(`[mega-compact] ${r.summary}`);
         },
@@ -62,6 +67,8 @@ export function registerDbCommands(pi, runtime) {
     pi.registerCommand("mega-db-check", {
         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, ctx) => {
+            runtime.bindRepo(ctx.cwd);
+            const stateDir = runtime.currentStateDir;
             const lines = integrityCheck(stateDir);
             const healthy = lines.length === 1 && lines[0] === "ok";
             ctx.ui.notify(`[mega-compact] integrity_check: ${healthy ? "✓ ok" : `⚠ ${lines.length} issue(s)`}`);
@@ -78,6 +85,8 @@ export function registerDbCommands(pi, runtime) {
     pi.registerCommand("mega-db-reconcile", {
         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, ctx) => {
+            runtime.bindRepo(ctx.cwd);
+            const stateDir = runtime.currentStateDir;
             const r = 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/dist/extensions/mega-events/agent-handlers.js

@@ -0,0 +1,173 @@
+import { piCompactWouldNoop, runMemoryReview, } from "../mega-pipeline.js";
+import { memoryReviewCadence, } from "../mega-config.js";
+/** Register agent/turn tracking event handlers. */
+export function registerAgentHandlers(pi, runtime, config) {
+    // ---- 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) => (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/dist/extensions/mega-events/compact-handlers.js

@@ -0,0 +1,133 @@
+import { driveNativeCompaction, } from "../mega-compact-driver.js";
+import { estimateBlockTokens } from "../../src/tokens.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) {
+    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, runtime) {
+    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, runtime, config) {
+    // ---- 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, ctx) => {
+        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, _ctx) => {
+        runtime.rt.lastNativeCompactAt = Date.now();
+        runtime.rt.lastCompactAt = Date.now();
+        runtime.logger.info("session-compacted", {
+            sessionId: runtime.rt.sessionId,
+            at: runtime.rt.lastCompactAt,
+        });
+    });
+}