pi-mega-compact 0.8.5 → 0.8.6

package/dist/extensions/mega-events/compact-handlers.js

@@ -128,6 +128,7 @@ export function registerCompactHandlers(pi, runtime, config) {
     pi.on("session_compact", async (_event, _ctx) => {
         runtime.rt.lastNativeCompactAt = Date.now();
         runtime.rt.lastCompactAt = Date.now();
+        runtime.trimCache = null; // v0.8.6: durable truncation changes the transcript — never replay the stale cached cut (PREVENT-PI-001/002)
         runtime.logger.info("session-compacted", {
             sessionId: runtime.rt.sessionId,
             at: runtime.rt.lastCompactAt,

package/dist/extensions/mega-events/context-handler.js

@@ -122,6 +122,34 @@ export function registerContextHandler(pi, runtime, config) {
             return;
         }
         runtime.debounceUntil = now + 2000;
+        // v0.8.6 cache-stability: replay the cached trim view when still in the
+        // same compaction epoch AND context hasn't grown enough to warrant a
+        // re-compact. This stabilizes the provider KV-cache prefix (the summary +
+        // cut are reused verbatim) instead of regenerating a fresh summary +
+        // sentinel every fire, which invalidated the prefix on every other turn
+        // (the alternating cache-miss regression). Re-compact only when context
+        // grew >=10% of the window (percent basis) or >=50% of the effective
+        // threshold (token basis, when percent is unavailable). The cached `cut`
+        // is only valid while the transcript grows within the epoch — it is
+        // cleared on session_compact (durable truncation) + resetRuntime, so we
+        // never replay a stale cut into a truncated transcript (PREVENT-PI-001/002).
+        const RECOMPACT_PCT_DELTA = 10;
+        if (runtime.trimCache &&
+            runtime.trimCache.checkpointId === runtime.rt.lastCheckpointId &&
+            runtime.trimCache.cut <= messages.length) {
+            const grewEnough = pct != null && runtime.trimCache.ctxPct != null
+                ? pct - runtime.trimCache.ctxPct >= RECOMPACT_PCT_DELTA
+                : currentTokens - (runtime.trimCache.ctxTokens ?? 0) >=
+                    runtime.effectiveThreshold * 0.5;
+            if (!grewEnough) {
+                const recent = messages.slice(runtime.trimCache.cut); // guardrails-allow PREVENT-PI-002: cached `cut` was sanitized once by computeLiveTrimCut (src/boundary.ts) and replayed verbatim; the transcript only grows within an epoch (cache is cleared on durable truncation), so the preserved run still starts on a toolPair-safe index.
+                runtime.diagLiveTrimFires++; // trim view returned this call (replay counts as a fire)
+                runtime.diagLiveTrimReplays++;
+                runtime.snapshot(ctx);
+                return { messages: [runtime.trimCache.summaryAgentMsg, ...recent] };
+            }
+            // else: context grew enough → fall through to re-compact (cache is stale)
+        }
         // Adaptive compression (Fix E): scale compression strength + keepFrom depth
         // 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
@@ -224,9 +252,22 @@ export function registerContextHandler(pi, runtime, config) {
             const summaryAgentMsg = {
                 role: "user",
                 content: summaryMsg.text,
-                timestamp: Date.now(),
+                // v0.8.6: stable timestamp across the epoch (NOT Date.now()) so the
+                // summary message bytes — and thus the KV-cache prefix — don't drift
+                // on every replay within the same compaction epoch.
+                timestamp: runtime.rt.lastCompactAt ?? Date.now(),
             };
             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.
+            // 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.
+            runtime.trimCache = {
+                checkpointId: ran.result.checkpointId ?? `epoch-${runtime.rt.lastCompactAt ?? Date.now()}`,
+                cut,
+                summaryAgentMsg,
+                ctxPct: pct ?? null,
+                ctxTokens: currentTokens,
+            };
             runtime.snapshot(ctx);
             // DIAG (team-run relief): confirm the live trim actually fires + how big
             // the window still is. The return is non-durable (per-LLM-call only), so

package/dist/extensions/mega-pipeline/compact.js

@@ -152,12 +152,19 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     }
     // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can
     // skip re-vectorizing an already-compacted region (zero token cost).
-    pi.appendEntry(MARKER_TYPE, {
-        checkpointId: result.checkpointId,
-        regionHash: result.regionHash,
-        tokenEstimate: result.tokenEstimate,
-        deduped: result.deduped,
-    });
+    // v0.8.6: gate on !result.deduped so the marker ONLY lands when a genuinely
+    // new checkpoint was created. Without this, every dedup re-fire appended a
+    // fresh sentinel to the real transcript, bloating it and perturbing the
+    // provider KV-cache prefix (the alternating cache-miss regression). Matches
+    // the RAPTOR + vector-index blocks above, which are already !deduped-gated.
+    if (!result.deduped) {
+        pi.appendEntry(MARKER_TYPE, {
+            checkpointId: result.checkpointId,
+            regionHash: result.regionHash,
+            tokenEstimate: result.tokenEstimate,
+            deduped: result.deduped,
+        });
+    }
     // Fix D: refresh the RAPTOR tree for this session so live recall (search) can
     // serve high-level summaries. Best-effort + non-fatal: never block compaction.
     // Budget-guarded (RAPTOR_BUDGET_MS) so it can't hang a large session.

package/dist/extensions/mega-runtime/state.js

@@ -50,6 +50,14 @@ export class MegaRuntime {
         cacheHitTokens: 0,
         lengthStopPending: false,
     };
+    // v0.8.6 cache-stability: the cached live-trim view for the current
+    // compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
+    // replayed verbatim on subsequent gated context events in the SAME epoch
+    // (same checkpointId) so the provider KV-cache prefix stays stable instead
+    // of being invalidated by a freshly regenerated summary + sentinel every
+    // fire. Invalidated on session restart (resetRuntime) and on any native
+    // durable compaction (session_compact) that truncates the transcript.
+    trimCache = null;
     debounceUntil = 0;
     // S16: debounce for the agent_end resume nudge (avoid busy-loops).
     resumeNudgeUntil = 0;
@@ -159,6 +167,7 @@ export class MegaRuntime {
      * updated and cost nothing).
      */
     diagLiveTrimFires = 0; // context handler returned a trimmed view
+    diagLiveTrimReplays = 0; // v0.8.6: trim view returned via cached replay (skipped re-compact)
     diagBeforeCompactFires = 0; // session_before_compact handler entered
     diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
     diagAgentEndIdle = 0; // agent_end with activeAgents===0
@@ -714,6 +723,7 @@ export class MegaRuntime {
             cacheHitTokens: 0,
             lengthStopPending: false,
         };
+        this.trimCache = null; // v0.8.6: never replay a stale trim into a new session
         this.statusKey = undefined;
         this.activeAgents = 0;
         this.currentTurn = 0;

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

@@ -159,6 +159,7 @@ export function registerCompactHandlers(
 		pi.on("session_compact", async (_event: SessionCompactEvent, _ctx: ExtensionContext) => {
 			runtime.rt.lastNativeCompactAt = Date.now();
 			runtime.rt.lastCompactAt = Date.now();
+			runtime.trimCache = null; // v0.8.6: durable truncation changes the transcript — never replay the stale cached cut (PREVENT-PI-001/002)
 			runtime.logger.info("session-compacted", {
 				sessionId: runtime.rt.sessionId,
 				at: runtime.rt.lastCompactAt,

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

@@ -157,6 +157,38 @@ export function registerContextHandler(
 		}
 		runtime.debounceUntil = now + 2000;
 
+		// v0.8.6 cache-stability: replay the cached trim view when still in the
+		// same compaction epoch AND context hasn't grown enough to warrant a
+		// re-compact. This stabilizes the provider KV-cache prefix (the summary +
+		// cut are reused verbatim) instead of regenerating a fresh summary +
+		// sentinel every fire, which invalidated the prefix on every other turn
+		// (the alternating cache-miss regression). Re-compact only when context
+		// grew >=10% of the window (percent basis) or >=50% of the effective
+		// threshold (token basis, when percent is unavailable). The cached `cut`
+		// is only valid while the transcript grows within the epoch — it is
+		// cleared on session_compact (durable truncation) + resetRuntime, so we
+		// never replay a stale cut into a truncated transcript (PREVENT-PI-001/002).
+		const RECOMPACT_PCT_DELTA = 10;
+		if (
+			runtime.trimCache &&
+			runtime.trimCache.checkpointId === runtime.rt.lastCheckpointId &&
+			runtime.trimCache.cut <= messages.length
+		) {
+			const grewEnough =
+				pct != null && runtime.trimCache.ctxPct != null
+					? pct - runtime.trimCache.ctxPct >= RECOMPACT_PCT_DELTA
+					: currentTokens - (runtime.trimCache.ctxTokens ?? 0) >=
+							runtime.effectiveThreshold * 0.5;
+			if (!grewEnough) {
+				const recent = messages.slice(runtime.trimCache.cut); // guardrails-allow PREVENT-PI-002: cached `cut` was sanitized once by computeLiveTrimCut (src/boundary.ts) and replayed verbatim; the transcript only grows within an epoch (cache is cleared on durable truncation), so the preserved run still starts on a toolPair-safe index.
+				runtime.diagLiveTrimFires++; // trim view returned this call (replay counts as a fire)
+				runtime.diagLiveTrimReplays++;
+				runtime.snapshot(ctx);
+				return { messages: [runtime.trimCache.summaryAgentMsg, ...recent] };
+			}
+			// else: context grew enough → fall through to re-compact (cache is stale)
+		}
+
 		// Adaptive compression (Fix E): scale compression strength + keepFrom depth
 		// 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
@@ -266,9 +298,22 @@ export function registerContextHandler(
 			const summaryAgentMsg = {
 				role: "user" as const,
 				content: summaryMsg.text,
-				timestamp: Date.now(),
+				// v0.8.6: stable timestamp across the epoch (NOT Date.now()) so the
+				// summary message bytes — and thus the KV-cache prefix — don't drift
+				// 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.
+			// 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.
+			runtime.trimCache = {
+				checkpointId: ran.result.checkpointId ?? `epoch-${runtime.rt.lastCompactAt ?? Date.now()}`,
+				cut,
+				summaryAgentMsg,
+				ctxPct: pct ?? null,
+				ctxTokens: currentTokens,
+			};
 			runtime.snapshot(ctx);
 			// DIAG (team-run relief): confirm the live trim actually fires + how big
 			// the window still is. The return is non-durable (per-LLM-call only), so

package/extensions/mega-pipeline/compact.ts

@@ -192,12 +192,19 @@ function doCompact(
 
   // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can
   // skip re-vectorizing an already-compacted region (zero token cost).
-  pi.appendEntry(MARKER_TYPE, {
-    checkpointId: result.checkpointId,
-    regionHash: result.regionHash,
-    tokenEstimate: result.tokenEstimate,
-    deduped: result.deduped,
-  });
+  // v0.8.6: gate on !result.deduped so the marker ONLY lands when a genuinely
+  // new checkpoint was created. Without this, every dedup re-fire appended a
+  // fresh sentinel to the real transcript, bloating it and perturbing the
+  // provider KV-cache prefix (the alternating cache-miss regression). Matches
+  // the RAPTOR + vector-index blocks above, which are already !deduped-gated.
+  if (!result.deduped) {
+    pi.appendEntry(MARKER_TYPE, {
+      checkpointId: result.checkpointId,
+      regionHash: result.regionHash,
+      tokenEstimate: result.tokenEstimate,
+      deduped: result.deduped,
+    });
+  }
 
   // Fix D: refresh the RAPTOR tree for this session so live recall (search) can
   // serve high-level summaries. Best-effort + non-fatal: never block compaction.

package/extensions/mega-runtime/state.ts

@@ -87,6 +87,20 @@ export class MegaRuntime {
 		cacheHitTokens: 0,
 		lengthStopPending: false,
 	};
+	// v0.8.6 cache-stability: the cached live-trim view for the current
+	// compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
+	// replayed verbatim on subsequent gated context events in the SAME epoch
+	// (same checkpointId) so the provider KV-cache prefix stays stable instead
+	// of being invalidated by a freshly regenerated summary + sentinel every
+	// fire. Invalidated on session restart (resetRuntime) and on any native
+	// durable compaction (session_compact) that truncates the transcript.
+	trimCache: {
+		checkpointId: string;
+		cut: number;
+		summaryAgentMsg: AgentMessage;
+		ctxPct: number | null;
+		ctxTokens: number | null;
+	} | null = null;
 	debounceUntil = 0;
 	// S16: debounce for the agent_end resume nudge (avoid busy-loops).
 	resumeNudgeUntil = 0;
@@ -199,6 +213,7 @@ export class MegaRuntime {
 	 * updated and cost nothing).
 	 */
 	diagLiveTrimFires = 0; // context handler returned a trimmed view
+	diagLiveTrimReplays = 0; // v0.8.6: trim view returned via cached replay (skipped re-compact)
 	diagBeforeCompactFires = 0; // session_before_compact handler entered
 	diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
 	diagAgentEndIdle = 0; // agent_end with activeAgents===0
@@ -795,6 +810,7 @@ export class MegaRuntime {
 			cacheHitTokens: 0,
 			lengthStopPending: false,
 	};
+		this.trimCache = null; // v0.8.6: never replay a stale trim into a new session
 		this.statusKey = undefined;
 		this.activeAgents = 0;
 		this.currentTurn = 0;

package/package.json

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