pi-mega-compact 0.21.0 → 0.21.1

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

@@ -35,6 +35,30 @@ export const ReductionValidator = {
         return { effective, liveBefore, liveAfter };
     },
 };
+/**
+ * Disarm the ThrashGuard — clears the persisted `blocked_until` so subsequent
+ * compactions are not refused. Called when a compaction is judged EFFECTIVE
+ * (the thrash condition is over) and on session start (so a stale guard from a
+ * prior session cannot suppress the next session's compactions).
+ *
+ * Best-effort: any failure is swallowed (never blocks on a store fault).
+ */
+export function disarmThrashGuard(stateDir, logger, emit) {
+    try {
+        setMetaNumber(THRASH_BLOCKED_KEY, 0, stateDir);
+        setMetaNumber(THRASH_BASELINE_KEY, 0, stateDir);
+        logger?.info("thrasguard_disarmed", { reason: "effective_or_reset" });
+        try {
+            emit?.("thrasguard_disarmed", { reason: "effective_or_reset" });
+        }
+        catch {
+            /* non-fatal */
+        }
+    }
+    catch {
+        /* non-fatal: best-effort meta write */
+    }
+}
 /**
  * Arm the ThrashGuard after an ineffective compaction. Persists:
  *  - `thrasguard.baseline_tokens` = the live currentTokens at this (post-fire)
@@ -201,6 +225,16 @@ export function evaluatePendingReduction(runtime, currentTokens, config) {
                 : undefined;
             armThrashGuard(currentTokens, config.thrashRearmPct, runtime.effectiveThreshold, runtime.currentStateDir, runtime.logger, emit);
         }
+        else {
+            // Effective compaction — the thrash condition is over. Disarm the guard
+            // so it does not block legitimate subsequent compactions (the bug: without
+            // this, `blocked_until` from the prior ineffective fire persists and blocks
+            // the now-smaller window from ever re-firing).
+            const emit = typeof runtime.appendEvent === "function"
+                ? runtime.appendEvent.bind(runtime)
+                : undefined;
+            disarmThrashGuard(runtime.currentStateDir, runtime.logger, emit);
+        }
     }
     catch {
         /* non-fatal */

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

@@ -5,6 +5,7 @@ import { doRecall, doRecallAsync } from "../mega-pipeline.js";
 import { recallMemoriesAndInline } from "../../src/recall.js";
 import { vectorStats } from "../../src/vectorStore.js";
 import { openTurnStore } from "../../src/store/turns/connection.js";
+import { disarmThrashGuard } from "./context-handler/thrashGuard.js";
 import { openIntentQueue } from "../../src/intent.js";
 /** Register session lifecycle event handlers. */
 export function registerSessionHandlers(pi, runtime, config) {
@@ -15,6 +16,17 @@ export function registerSessionHandlers(pi, runtime, config) {
     });
     pi.on("session_start", async (event, ctx) => {
         runtime.resetRuntime(ctx.sessionManager.getSessionId());
+        // Disarm the ThrashGuard on session start so a stale `blocked_until` from a
+        // prior session cannot suppress this session's compactions. Bind FIRST:
+        // currentStateDir defaults to the global dir until bindRepo resolves the
+        // per-repo <repo>/.pi/mega-compact store, and the guard arms in the
+        // PER-REPO store — disarming before the bind would clear the wrong (global)
+        // dir after a process restart. Gated on the umbrella so flag-OFF stays
+        // byte-identical (no meta writes).
+        if (config.threeWayFailback) {
+            runtime.bindRepo(ctx.cwd);
+            disarmThrashGuard(runtime.currentStateDir);
+        }
         runtime.captureModel(ctx); // best-effort: ctx.model may be set by session start
         runtime.setStatus(ctx, config.auto ? "mega-compact: ready" : "mega-compact: manual only");
         // S21: clear any stale memory block from a prior session.

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

@@ -62,6 +62,33 @@ export const ReductionValidator = {
 	},
 };
 
+/**
+ * Disarm the ThrashGuard — clears the persisted `blocked_until` so subsequent
+ * compactions are not refused. Called when a compaction is judged EFFECTIVE
+ * (the thrash condition is over) and on session start (so a stale guard from a
+ * prior session cannot suppress the next session's compactions).
+ *
+ * Best-effort: any failure is swallowed (never blocks on a store fault).
+ */
+export function disarmThrashGuard(
+	stateDir: string,
+	logger?: { info(event: string, fields?: Record<string, unknown>): void },
+	emit?: (event: string, fields: Record<string, unknown>) => void,
+): void {
+	try {
+		setMetaNumber(THRASH_BLOCKED_KEY, 0, stateDir);
+		setMetaNumber(THRASH_BASELINE_KEY, 0, stateDir);
+		logger?.info("thrasguard_disarmed", { reason: "effective_or_reset" });
+		try {
+			emit?.("thrasguard_disarmed", { reason: "effective_or_reset" });
+		} catch {
+			/* non-fatal */
+		}
+	} catch {
+		/* non-fatal: best-effort meta write */
+	}
+}
+
 /**
  * Arm the ThrashGuard after an ineffective compaction. Persists:
  *  - `thrasguard.baseline_tokens` = the live currentTokens at this (post-fire)
@@ -245,6 +272,16 @@ export function evaluatePendingReduction(
 				runtime.logger,
 				emit,
 			);
+		} else {
+			// Effective compaction — the thrash condition is over. Disarm the guard
+			// so it does not block legitimate subsequent compactions (the bug: without
+			// this, `blocked_until` from the prior ineffective fire persists and blocks
+			// the now-smaller window from ever re-firing).
+			const emit =
+				typeof runtime.appendEvent === "function"
+					? runtime.appendEvent.bind(runtime)
+					: undefined;
+			disarmThrashGuard(runtime.currentStateDir, runtime.logger, emit);
 		}
 	} catch {
 		/* non-fatal */

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

@@ -16,6 +16,7 @@ import { doRecall, doRecallAsync } from "../mega-pipeline.js";
 import { recallMemoriesAndInline } from "../../src/recall.js";
 import { vectorStats } from "../../src/vectorStore.js";
 import { openTurnStore } from "../../src/store/turns/connection.js";
+import { disarmThrashGuard } from "./context-handler/thrashGuard.js";
 import { openIntentQueue } from "../../src/intent.js";
 import type { MegaConfig } from "../mega-config.js";
 
@@ -33,6 +34,17 @@ export function registerSessionHandlers(
 
 	pi.on("session_start", async (event, ctx) => {
 		runtime.resetRuntime(ctx.sessionManager.getSessionId());
+		// Disarm the ThrashGuard on session start so a stale `blocked_until` from a
+		// prior session cannot suppress this session's compactions. Bind FIRST:
+		// currentStateDir defaults to the global dir until bindRepo resolves the
+		// per-repo <repo>/.pi/mega-compact store, and the guard arms in the
+		// PER-REPO store — disarming before the bind would clear the wrong (global)
+		// dir after a process restart. Gated on the umbrella so flag-OFF stays
+		// byte-identical (no meta writes).
+		if (config.threeWayFailback) {
+			runtime.bindRepo(ctx.cwd);
+			disarmThrashGuard(runtime.currentStateDir);
+		}
 		runtime.captureModel(ctx); // best-effort: ctx.model may be set by session start
 		runtime.setStatus(
 			ctx,

package/package.json

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