pi-mega-compact 0.15.3 → 0.16.0

package/extensions/dashboard-server/resolve-snapshot.ts

@@ -2,21 +2,23 @@
  * dashboard-server/resolve-snapshot.ts — dynamic per-repo snapshot resolver.
  *
  * The dashboard server is launched with a single static stateDir, but the
- * active pi session may be running in a different repo. This module queries
- * the repo registry to find the most recently active repo's dashboard.json,
- * so the Overview always shows live data from the repo pi is actually running
- * in.
+ * active pi session may be running in a different repo. This module resolves
+ * which repo's dashboard.json to serve as the "this session" snapshot.
  *
- * The launch stateDir is a candidate like any other (NOT excluded): when
- * `/dashboard` was run in the repo you are still coding in, the launch dir
- * IS the most-recently-active repo and must win. Excluding it would serve a
- * stale other-repo snapshot, surfacing a phantom 0% "this session" gauge
- * plus a duplicate live-session gauge.
- *
- * Resolution order:
- * 1. Most recently seen repo (by last_seen in repo_registry, launch dir
- *    included) whose dashboard.json exists and has a non-null updatedAt
- * 2. The static launch stateDir's dashboard.json (original behavior)
+ * Resolution order (the launch dir is the OWNer of this dashboard):
+ * 1. The launch stateDir's OWN dashboard.json — the pi process that launched
+ *    this dashboard server is the session you are coding in, so its snapshot
+ *    is "this session" by definition. This must win over any other repo
+ *    regardless of last_seen freshness; otherwise a more-recently-active
+ *    OTHER repo steals the "this session" slot and your actual session gets
+ *    demoted to an "other" gauge, producing the exact duplicate-gauge bug
+ *    (this session + pi-<launchrepo> both showing the same active session
+ *    split across two boxes).
+ * 2. Most recently seen OTHER repo (by last_seen in repo_registry) whose
+ *    dashboard.json exists and has a non-null updatedAt — fallback for when
+ *    the launch dir has no live snapshot yet (e.g. dashboard launched before
+ *    any compaction wrote dashboard.json).
+ * 3. The static launch stateDir's dashboard.json (original behavior).
  */
 
 import { existsSync } from "node:fs";
@@ -40,17 +42,12 @@ interface RepoRegistryRow {
 }
 
 /**
- * Find the most recently active repo's stateDir by scanning the repo registry
- * for the repo with the highest last_seen whose dashboard.json exists and has
- * a non-null updatedAt. Returns null if no suitable repo is found.
- *
- * The launch stateDir is NOT excluded: if it is itself the most-recently-active
- * repo (the common case — `/dashboard` was run in the repo you are still
- * coding in), its live dashboard.json must be served. Excluding it would cause
- * a stale *other*-repo snapshot to win, producing a phantom 0% "this session"
- * gauge + a duplicate live-session gauge.
+ * Find the most recently active OTHER repo's stateDir (excluding the launch
+ * dir, which is handled by the caller) by scanning the repo registry for the
+ * repo with the highest last_seen whose dashboard.json exists and has a
+ * non-null updatedAt. Returns null if no suitable repo is found.
  */
-function mostRecentRepoStateDir(_staticStateDir: string): string | null {
+function mostRecentOtherRepoStateDir(launchStateDir: string): string | null {
 	const indexPath = join(getIndexDir(), "index.sqlite");
 	if (!existsSync(indexPath)) return null;
 	let db;
@@ -62,9 +59,10 @@ function mostRecentRepoStateDir(_staticStateDir: string): string | null {
 			.prepare(
 				`SELECT state_dir, last_seen FROM repo_registry
 				 WHERE state_dir IS NOT NULL AND last_seen IS NOT NULL
+				   AND state_dir != @launch
 				 ORDER BY last_seen DESC`,
 			)
-			.all() as unknown as RepoRegistryRow[];
+			.all({ launch: launchStateDir }) as unknown as RepoRegistryRow[];
 		for (const r of rows) {
 			const dashPath = join(r.state_dir, "dashboard.json");
 			if (!existsSync(dashPath)) continue;
@@ -93,8 +91,20 @@ export function resolveSnapshot(
 	staticSnapshotPath: string,
 	staticStateDir: string,
 ): ResolvedSnapshot {
-	// Try the most recently active repo first.
-	const activeDir = mostRecentRepoStateDir(staticStateDir);
+	// 1. The launch dir's OWN snapshot is "this session" — the pi process that
+	//    launched this dashboard is the session you are coding in. It wins over
+	//    any other repo regardless of last_seen, so a more-recently-active OTHER
+	//    repo can't steal the "this session" slot and demote your actual session
+	//    to a duplicate "other" gauge.
+	if (existsSync(staticSnapshotPath)) {
+		const launchSnap = readSnapshot(staticSnapshotPath);
+		if (launchSnap.updatedAt) {
+			return { snapshot: launchSnap, stateDir: staticStateDir };
+		}
+	}
+	// 2. Fall back to the most recently active OTHER repo (launch dir had no
+	//    live snapshot yet).
+	const activeDir = mostRecentOtherRepoStateDir(staticStateDir);
 	if (activeDir) {
 		const activePath = join(activeDir, "dashboard.json");
 		const snap = readSnapshot(activePath);
@@ -102,7 +112,7 @@ export function resolveSnapshot(
 			return { snapshot: snap, stateDir: activeDir };
 		}
 	}
-	// Fall back to the static launch path.
+	// 3. Last resort: the static launch path (even if stale).
 	return {
 		snapshot: readSnapshot(staticSnapshotPath),
 		stateDir: staticStateDir,

package/extensions/mega-events/context-handler.ts

@@ -19,7 +19,7 @@ import {
 	openStore,
 } from "../../src/store/sqlite.js";
 import { autoCompactCheck } from "../../src/compact.js";
-import { estimateSessionTokens } from "../../src/tokens.js";
+import { estimateSessionTokens, estimateBlockTokens, estimateMessageTokens } from "../../src/tokens.js";
 import type { MegaRuntime } from "../mega-runtime.js";
 import { runCompact, piCompactWouldNoop } from "../mega-pipeline.js";
 import {
@@ -324,13 +324,23 @@ export function registerContextHandler(
 				compactedFrom: ran.result.compactedFrom,
 				summary: ran.result.summary,
 				anchorUserMessages,
-				// CRITICAL-OVER ESCAPE HATCH: when context is at/over ~90% of the
-				// window, relief takes priority over the anchor floor. Without this,
-				// computeLiveTrimCut bails to null (can't satisfy the floor) and the
-				// model is fed a raw overflow that errors every turn — the
-				// "Already compacted" + overflow death-spiral (2026-08-01 incident).
-				// A thin anchor is recoverable; an overflowed session is not.
-				criticalOver: (pct ?? 0) >= 90,
+			// CRITICAL-OVER ESCAPE HATCH: when context is at/over ~90% of the
+			// window, relief takes priority over the anchor floor. Without this,
+			// computeLiveTrimCut bails to null (can't satisfy the floor) and the
+			// model is fed a raw overflow that errors every turn — the
+			// "Already compacted" + overflow death-spiral (2026-08-01 incident).
+			// A thin anchor is recoverable; an overflowed session is not.
+			//
+			// CRITICAL: pct is null for OpenAI-compatible providers that don't
+			// report usage.percent (e.g. neuralwatt). Without the token-pressure
+			// fallback the hatch never armed → cut=null → raw overflow → 400
+			// "conversation too long even after compaction" (2026-08-03 incident
+			// on glm-5.2-short, 200K window). Now also fires on pressure >= 0.9
+			// (token-basis) so the hatch arms regardless of whether the provider
+			// reports pct.
+				criticalOver:
+					(pct ?? 0) >= 90 ||
+					pressure >= 0.9,
 			});
 			if (cut === null) {
 				runtime.diagCtxCutNull++;
@@ -357,7 +367,69 @@ export function registerContextHandler(
 				// on every replay within the same compaction epoch.
 				timestamp: runtime.rt.lastCompactAt ?? Date.now(),
 			} as unknown as AgentMessage;
-			const recent = messages.slice(cut); // guardrails-allow PREVENT-PI-002: `cut` is the pre-sanitized `compactedFrom` produced by src/boundary.ts computeDropRange, so the preserved run begins on a toolPair-safe index.
+			const recentRaw = messages.slice(cut); // guardrails-allow PREVENT-PI-002: `cut` is the pre-sanitized `compactedFrom` produced by src/boundary.ts computeDropRange, so the preserved run begins on a toolPair-safe index.
+
+			// FIX 2 (2026-08-03 incident): TOKEN-BUDGET CAP on the live-trim view.
+			// Compaction fires at tier% of the window (140K for a 200K window),
+			// but a SINGLE turn can inject a huge tool output (file read, bash) that
+			// jumps context from 139K → 199K+ before the next gate fires. When that
+			// happens [summary + preserved tail] can STILL exceed the model window,
+			// and the provider rejects with 400 "conversation too long even after
+			// compaction". The anchor floor (PREVENT-PI-001) keeps ≥N user messages
+			// but has NO token cap, so a 2-message tail of two 80K bash outputs sails
+			// right past the window.
+			//
+			// Cap: when the model context window is known, reserve room for the
+			// summary + the model's max output tokens + a 10% safety margin, then
+			// drop oldest preserved messages from the front of `recentRaw` until the
+			// tail fits. Never drops below the FINAL message (always keep the latest
+			// turn so the agent can respond). This is a last-resort HARD cap — it
+			// only fires when the preserved tail alone is oversized, which is rare.
+			const ctxWindow = runtime.lastCtxWindow;
+			// Reserve room for output tokens. Use the model's reported max output
+			// when known; fall back to 10% of the window (scales with any model —
+			// 20K for a 200K window, 100K for a 1M window) so we never let the
+			// preserved tail eat the model's output budget when maxTokens is unknown.
+			const maxOutput =
+				runtime.currentModel?.maxTokens && runtime.currentModel.maxTokens > 0
+					? runtime.currentModel.maxTokens
+					: Math.ceil(ctxWindow * 0.1);
+			let recent = recentRaw;
+			if (ctxWindow > 0 && recentRaw.length > 1) {
+				const summaryTokens = estimateBlockTokens(summaryMsg.text);
+				// Reserve: summary + max output + 10% safety margin.
+				const safetyMargin = Math.ceil(ctxWindow * 0.1);
+				const budget =
+					ctxWindow - maxOutput - safetyMargin - summaryTokens;
+				if (budget > 0) {
+					// Walk recent from the front, dropping oldest first until the
+					// remaining tail fits. Use the AgentMessage→engine-text estimate via
+					// messageContentText (already imported) + estimateMessageTokens.
+					let tailTokens = 0;
+					for (let i = recentRaw.length - 1; i >= 0; i--) {
+						const m = recentRaw[i];
+						tailTokens += estimateMessageTokens({
+							text: messageContentText(m),
+						});
+						if (tailTokens > budget) {
+							// Keep from i+1 onward; but never fewer than the final message.
+							const startIdx = Math.min(i + 1, recentRaw.length - 1);
+							if (startIdx > 0) {
+								recent = recentRaw.slice(startIdx);
+								runtime.logger.warn("live-trim-tail-cap", {
+									sessionId: runtime.rt.sessionId,
+									dropped: startIdx,
+									tailTokens,
+									budget,
+									ctxWindow,
+								});
+							}
+							break;
+						}
+					}
+				}
+			}
+
 			// v0.8.6: cache the trim view so subsequent gated calls in this epoch
 			// replay it verbatim (stabilizing the KV-cache prefix) instead of
 			// regenerating a fresh summary + sentinel every fire.

package/package.json

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