pi-mega-compact 0.21.3 → 0.21.5

package/README.md

@@ -1,5 +1,7 @@
 # pi-mega-compact
 
+> **⚠️ LTS — patches only (2026-08-13).** This extension is maintained for bug fixes only. New feature development has moved to **[radcode](https://github.com/TheArchitectit/radcode)**, a Rust pi.dev replacement that has ported mega-compact's compaction/recall/dedup/RAPTOR stack. See [`docs/LTS.md`](docs/LTS.md) and [`docs/SUCCESSION.md`](docs/SUCCESSION.md).
+
 A local-first context compressor for the [pi coding agent](https://github.com/earendil-works/pi). Keeps long sessions running without overflowing the context window. Local by default — no cloud, no API calls, no telemetry. Bring your own localhost embedder (Ollama, ONNX, TEI) for better semantic matches, or opt in to a remote endpoint if you need to.
 
 ## Features

package/dist/extensions/mega-config.js

@@ -10,31 +10,41 @@ import { STATE_DIR_DEFAULT } from "../src/config.js";
 import { join } from "node:path";
 import { execSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: read-only `git rev-parse` to scope the store per-repo
 /**
- * Named compaction tiers. A tier sets the token threshold at which the
- * auto-trigger persists a checkpoint; pick by how aggressively you want the
- * session trimmed. Explicit MEGACOMPACT_THRESHOLD_TOKENS always wins.
+ * Named compaction tiers — each tier sets the compaction fire point as a
+ * FRACTION of the model's context window (NOT a static token amount): the live
+ * + durable trim fire at `tier × window`, so they always fire BELOW pi's native
+ * auto-compaction (~80% of window) for any model size (200k or 1M). Pick by how
+ * aggressively you want the session trimmed. Explicit
+ * MEGACOMPACT_THRESHOLD_TOKENS always wins (`custom`, tierPct null — absolute,
+ * never percent-scaled). This is the SINGLE source of truth for tier fractions;
+ * `keyof typeof COMPACT_TIERS` is the `CompactTier` type and
+ * `raw in COMPACT_TIERS` validates a named preset name.
  */
 export const COMPACT_TIERS = {
-    low: 50_000,
-    medium: 100_000,
-    high: 200_000,
-    ultra: 1_000_000,
-    mega: 10_000_000,
-};
-/**
- * Compaction thresholds as a FRACTION of the model's context window (NOT a
- * static token amount). The live + durable trim fire at tier% of the window,
- * so they always fire BELOW pi's native auto-compaction (~80% of window) for
- * any model size (200k or 1M). `custom` (explicit MEGACOMPACT_THRESHOLD_TOKENS)
- * is NOT scaled by this map — it stays an absolute token count.
- */
-export const TIER_PCT = {
     low: 0.5,
     medium: 0.6,
     high: 0.7,
     ultra: 0.7,
     mega: 0.75,
 };
+/**
+ * Boot-fallback context window (env-overridable). Used ONLY as a display/seed
+ * placeholder before the first real context event supplies the provider's
+ * window — the live fire point (`effectiveThresholdImpl`) DEFERS (returns
+ * `+Infinity`) when the window is unknown, so this value is never a guessed
+ * gate. Default 200k keeps the display seed stable; set
+ * `MEGACOMPACT_DEFAULT_CONTEXT_WINDOW=<tokens>` to repoint it (e.g. for a
+ * 32k-model fleet the seed should reflect that).
+ */
+export const DEFAULT_CONTEXT_WINDOW = envFlag("MEGACOMPACT_DEFAULT_CONTEXT_WINDOW", 200_000);
+/**
+ * Display seed for the progress-bar "saved tokens goal" denominator. The live
+ * value grows dynamically (`run.ts`: `savedGoal = ceil(tokensSaved × 1.25)` once
+ * exceeded), so this is only the initial target before the first compaction.
+ * Derived from the low-tier fire point at the default window (no bare magic):
+ * `COMPACT_TIERS.low × DEFAULT_CONTEXT_WINDOW`. Display-only.
+ */
+export const DEFAULT_SAVED_GOAL = Math.round(COMPACT_TIERS.low * DEFAULT_CONTEXT_WINDOW);
 function envFlag(name, fallback) {
     const v = process.env[name];
     if (v == null || v === "")
@@ -52,8 +62,8 @@ function envBool(name, fallback) {
  * Resolve the effective token threshold from TIER (or explicit) env vars.
  *
  * For a named tier the returned `thresholdTokens` is a BOOT FALLBACK
- * (`round(tierPct * 200_000)`) — sane before any context event reaches the
- * runtime. The true fire point is computed per-window at runtime via
+ * (`round(tierPct * DEFAULT_CONTEXT_WINDOW)`) — sane before any context event
+ * reaches the runtime. The true fire point is computed per-window at runtime via
  * `effectiveThresholdTokens(...)`. `custom` (explicit MEGACOMPACT_THRESHOLD_TOKENS)
  * keeps `tierPct: null` and an ABSOLUTE `thresholdTokens` (never percent-scaled).
  */
@@ -66,7 +76,7 @@ function resolveThreshold() {
     }
     const raw = (process.env.MEGACOMPACT_TIER ?? "low").toLowerCase();
     const tier = (raw in COMPACT_TIERS ? raw : "low");
-    let tierPct = TIER_PCT[tier];
+    let tierPct = COMPACT_TIERS[tier];
     // 3WF-2 threshold invariant: under the umbrella, when no named tier is set
     // the fire point is the configurable % of the ACTUAL model window (default
     // 0.80 — "20% free remaining"). Tiered (named preset) keeps its preset pct;
@@ -80,8 +90,9 @@ function resolveThreshold() {
     // Boot fallback: sane gate before the first context event provides a window.
     // (NO hardcoded window in the firing path — effectiveThresholdImpl defers
     // when window unknown; this remains only a display placeholder + custom
-    // companion under the umbrella.)
-    const thresholdTokens = Math.round(tierPct * 200_000);
+    // companion under the umbrella.) Env-overridable via
+    // MEGACOMPACT_DEFAULT_CONTEXT_WINDOW (see DEFAULT_CONTEXT_WINDOW).
+    const thresholdTokens = Math.round(tierPct * DEFAULT_CONTEXT_WINDOW);
     return { tier, tierPct, thresholdTokens };
 }
 /** Clamp `n` into [lo, hi]; non-finite → fallback. */
@@ -115,8 +126,11 @@ export function effectiveThresholdTokens(opts) {
  * Resolve the optional manual arming-floor override (MEGACOMPACT_FAST_GATE_PCT).
  * Kept for backward-compat: when unset, the default arming floor equals the
  * tier's percent threshold (tierPct*100) so the dashboard stays consistent;
- * `custom` (tierPct null) falls back to the legacy 70% default.
+ * `custom` (tierPct null — an explicit absolute opt-out of percent scaling by
+ * design) has no tier fraction to derive from, so it falls back to the named
+ * DEFAULT_FAST_GATE_PCT_CUSTOM. Env-overridable like every other default here.
  */
+export const DEFAULT_FAST_GATE_PCT_CUSTOM = 70;
 function resolveFastGatePct(tierPct) {
     const raw = process.env.MEGACOMPACT_FAST_GATE_PCT;
     if (raw != null && raw !== "") {
@@ -124,7 +138,7 @@ function resolveFastGatePct(tierPct) {
         if (Number.isFinite(n))
             return n;
     }
-    return tierPct != null ? Math.round(tierPct * 100) : 70;
+    return tierPct != null ? Math.round(tierPct * 100) : DEFAULT_FAST_GATE_PCT_CUSTOM;
 }
 /**
  * Pressure helpers for adaptive compression live in src/config.ts (pi-agnostic)
@@ -193,6 +207,9 @@ export function loadConfig() {
         memoryAutoReview: envBool("MEGACOMPACT_MEMORY_AUTO_REVIEW", true),
         memoryReviewInterval: envFlag("MEGACOMPACT_MEMORY_REVIEW_INTERVAL", 10),
         recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
+        // Phase H: output-error catch — trip compaction on a truncated model output
+        // (S28 stopReason==='length'). Default ON; OFF byte-identical pre-H.
+        outputErrorCompact: envBool("MEGACOMPACT_OUTPUT_ERROR_COMPACT", true),
         windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
         recallTailInject: envBool("MEGACOMPACT_RECALL_TAIL_INJECT", true),
         // 3WF-1: TriggerGuard — guarantee a staged recall block on every context

package/dist/extensions/mega-events/agent-handlers/turnEndHandler/lengthStop.js

@@ -7,6 +7,13 @@ export function lengthStop(event, runtime, config) {
         event.message.role === "assistant" &&
         event.message.stopReason === "length") {
         runtime.rt.lengthStopPending = true;
+        // Phase H: output-error catch — ALSO arm the one-shot force-compact flag so
+        // the next compaction gate trips immediately, freeing input headroom for
+        // the model's next response. Gated by config.outputErrorCompact (default
+        // ON; OFF = byte-identical pre-H — only the S28 auto-continue nudge fires).
+        if (config.outputErrorCompact) {
+            runtime.rt.forceCompactNextGate = true;
+        }
         runtime.dashboard.event("length_stop", { turnIndex: event.turnIndex });
     }
 }

package/dist/extensions/mega-events/agent-handlers/turnEndHandler/recordTurnRow.js

@@ -1,4 +1,4 @@
-import { ensureConversationIdFor, recordTurnWrite } from "../../../mega-turn-store.js";
+import { ensureConversationIdFor, recordTurnWrite, turnReaderFor } from "../../../mega-turn-store.js";
 /** S43: record one turn row with the cached metrics. Best-effort + non-fatal. */
 export function recordTurnRow(event, runtime, config) {
     // S43 (per-turn tracking): record one turn row with the cached metrics so
@@ -8,10 +8,16 @@ export function recordTurnRow(event, runtime, config) {
     // instead of silently producing a blank Turns tab.
     try {
         const convId = ensureConversationIdFor(config, runtime.rt.sessionId, runtime.currentStateDir);
+        // S49R: store the conversation-monotonic index (MAX+1) instead of the
+        // per-session event.turnIndex, which restarts at 0 on resume and would
+        // collide with UNIQUE(conversation_id, turn_index). Carry the session
+        // counter as sessionTurnIndex for the raw_transcript metrics join.
+        const turnIndex = turnReaderFor(runtime.currentStateDir).nextTurnIndexFor(convId);
         recordTurnWrite(config, {
             conversationId: convId,
             sessionId: runtime.rt.sessionId,
-            turnIndex: event.turnIndex,
+            turnIndex,
+            sessionTurnIndex: event.turnIndex,
             role: event.role ?? "assistant",
             endedAt: Date.now(),
             startedAt: undefined,
@@ -34,5 +40,9 @@ export function recordTurnRow(event, runtime, config) {
             error: e instanceof Error ? e.message : String(e),
             stack: e instanceof Error ? e.stack?.split("\n").slice(0, 3).join(" | ") : undefined,
         });
+        // Sprint H (Finding 3 / Option A): the turn-row write is an internal
+        // store-write failure the API-error `errorRate` ring never sees. Feed the
+        // separate `storeErrorRate` 6th axis.
+        runtime.recordInternalError("store_write");
     }
 }

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

@@ -48,6 +48,8 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
         }
         catch (e) {
             runtime.logger.warn("planv2-epoch-fail", { error: String(e) });
+            // Sprint H (Option A): checkpoint_epoch write failure.
+            runtime.recordInternalError("store_write");
         }
     }
     // S27 DB-mirror downstream: stamp turns, rebuild wiki, seed topics, dedup.
@@ -136,6 +138,9 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
                 runtime.logger.warn("wiki_rebuild_failed", {
                     error: String(wikiErr),
                 });
+                // Sprint H (Option A): wiki rebuild writes (topic model / overrides)
+                // to the isolated store — internal store write.
+                runtime.recordInternalError("store_write");
             }
             // D1: seed the topic model from raw_transcript when context_chunks is
             // thin (pre-compaction). Gated on WIKI_SEED_FROM_TURNS; non-fatal.
@@ -202,6 +207,9 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
                 runtime.logger.warn("wiki_seed_failed", {
                     error: String(seedErr),
                 });
+                // Sprint H (Option A): wiki seed rebuild writes to the isolated
+                // store — internal store write.
+                runtime.recordInternalError("store_write");
             }
             // S27 Task 6: Fire-and-forget dedup pipeline.
             // Deduplicates raw_transcript rows for the compacted range.
@@ -215,6 +223,9 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
         }
         catch (e) {
             runtime.logger.warn("db-mirror-epoch-fail", { error: String(e) });
+            // Sprint H (Option A): db-mirror downstream maintenance writes
+            // (stamp turns epoch / wiki / seed / dedup) — internal store writes.
+            runtime.recordInternalError("store_write");
         }
     }
     // VC6 Heal lifecycle emits (post-compact). VC6A: closure-optimization

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

@@ -76,6 +76,9 @@ export function appendMirrorAndLedger(runtime, config, messages) {
         }
         catch (e) {
             runtime.logger.warn("db-mirror-append-fail", { error: String(e) });
+            // Sprint H (Option A): raw_transcript / thread / tool_results write
+            // failure — internal store write. Feed the `storeErrorRate` axis.
+            runtime.recordInternalError("store_write");
         }
     }
     // VC1B (S1): canonical messages -> v2 ledger occurrences. Flag-OFF opens
@@ -87,5 +90,10 @@ export function appendMirrorAndLedger(runtime, config, messages) {
     }
     catch (e) {
         runtime.logger.warn("vc1b-ledger-append-fail", { error: String(e) });
+        // Sprint H (Option A): the v2 vector-cortex ledger append is a cortex
+        // write — this is the host-side hook for the cortex seam (the cortex
+        // contract forbids the store from holding a runtime handle, so the ring
+        // push happens here in the adapter, not inside src/vector-cortex).
+        runtime.recordInternalError("vector_index");
     }
 }

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

@@ -50,6 +50,23 @@ export function evaluateGate(runtime, config, opts) {
             : DEFAULT_FIRE_POINT_PCT,
         stateDir: runtime.currentStateDir,
     });
+    // Phase H: output-error catch. A truncated model output (S28
+    // stopReason==='length' — "Response was truncated before completion") trips
+    // a one-shot force-compact so the next compaction runs IMMEDIATELY, freeing
+    // input headroom for the model's next response. This closes the
+    // small-context-model deadlock: the model truncates MID-OUTPUT below the
+    // 80% INPUT threshold (so the gate never fires) → "compact never" → every
+    // subsequent response also truncates. lengthStop.ts sets this flag
+    // alongside its auto-continue nudge; gated by config.outputErrorCompact
+    // (default ON; OFF = byte-identical pre-H). One-shot: cleared on consumption.
+    // thrashGuardBlocks is consulted separately by the handler; in the reported
+    // "compact never" case compactCount===0 so the guard is never armed and will
+    // not block this trip.
+    if (config.outputErrorCompact && runtime.rt?.forceCompactNextGate) {
+        runtime.rt.forceCompactNextGate = false;
+        runtime.diagCtxOutputErrorTrip++;
+        return { kind: "proceed", perModelThreshold };
+    }
     // S29 FAST GATE: `custom` (absolute MEGACOMPACT_THRESHOLD_TOKENS,
     // tierPct null) is an explicit opt-out of percent scaling — it keeps the
     // token gate. When pct is unavailable (window unknown / a model that

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

@@ -8,6 +8,7 @@
  *
  * PREVENT-PI-004: zero network (local TrigramEmbedder + SQLite only).
  */
+import { RING_MAX } from "../mega-runtime/runtime.js";
 import { defaultEmbedder } from "../../src/embedder.js";
 import { computeOutputQuality } from "../../src/contextHealth/outputQuality.js";
 import { computeTopicDrift, computeErrorEscalation, computePrefixInstability, computeDriftScore, } from "../../src/contextHealth/drift.js";
@@ -15,7 +16,6 @@ import { computePrefixHash, checkPrefixHash, evaluateCachePoison, } from "../../
 import { computeHealthScore, recordContextHealth, } from "../../src/contextHealth.js";
 import { recordCachePoisonEvent, } from "../../src/store/sqlite/context-health.js";
 import { getHealthMitigate } from "../../src/store/sqlite/meta.js";
-const RING_MAX = 5;
 /** Extract assistant text from the turn_end event message. */
 function extractAssistantText(event) {
     const msg = event.message;
@@ -69,8 +69,15 @@ export function handleTurnEndHealth(event, runtime, config) {
             const prefix = computePrefixInstability(0, 5);
             drift = computeDriftScore(topic, error, prefix);
         }
-        // Error rate sub-score (1 = no errors)
+        // Error rate sub-score (1 = no errors) — API-retry errors only.
         const errorScore = computeErrorEscalation(runtime.recentErrorCategories);
+        // Sprint H (B2): store-error sub-score (1 = no store-write failures).
+        // Distinct from errorScore — internal store/service-write failures
+        // (turn rows, recall, dbMirror, ledger, epoch, stats, memory consolidate,
+        // compact persist, vector index, embedder, migration) never reach the
+        // API-retry errorRate ring. Mirrors computeErrorEscalation: 1 - (n/RING_MAX).
+        const recentInternalCount = Math.min(runtime.recentInternalErrors.length, RING_MAX);
+        const storeErrorScore = 1 - recentInternalCount / RING_MAX;
         // Cache health (from perf-handler)
         const cacheHealth = runtime.rt._lastCacheHealthScore ?? 1.0;
         // Cache poison sub-score
@@ -113,6 +120,7 @@ export function handleTurnEndHealth(event, runtime, config) {
             errorRate: errorScore,
             cacheHealth,
             cachePoison,
+            storeErrorRate: storeErrorScore,
         };
         const composite = computeHealthScore(sub);
         // Persist
@@ -126,6 +134,7 @@ export function handleTurnEndHealth(event, runtime, config) {
             cacheHealth,
             cachePoison,
             composite,
+            storeErrorScore,
             modelId: runtime.currentModel?.modelId,
             repetitionRatio,
             coherenceScore,
@@ -137,6 +146,7 @@ export function handleTurnEndHealth(event, runtime, config) {
             drift,
             outputQuality,
             errorRate: errorScore,
+            storeErrorRate: storeErrorScore,
             cacheHealth,
             cachePoison,
             turnIndex: event.turnIndex,

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

@@ -90,6 +90,7 @@ export function registerSessionHandlers(pi, runtime, config) {
         }
         catch (e) {
             runtime.logger.warn("db-auto-maintain-fail", { error: String(e) });
+            runtime.recordInternalError("store_write");
         }
         runtime.dashboard.event("session_start", {
             reason: event.reason,

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

@@ -130,6 +130,9 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
         logDaily(sid, "compact", result.checkpointId, saved, runtime.currentStateDir);
     }
     catch {
+        // Sprint H (Option A): session-activity / daily-log write is an internal
+        // store-write failure — feed the separate `storeErrorRate` axis.
+        runtime.recordInternalError("store_write");
         /* non-fatal: stats bookkeeping only */
     }
     // S21.2: best-effort consolidation of near-duplicate memories for this repo.
@@ -145,10 +148,14 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
                 if (n > 0)
                     runtime.pushTicker(`${C.green}∫${C.reset} consolidated ${n} memory dup${n === 1 ? "" : "s"}`);
             }, () => {
+                // Sprint H (Option A): memory-consolidation write failure.
+                runtime.recordInternalError("store_write");
                 /* swallow: consolidate failures must never surface to the user */
             });
         }
         catch {
+            // Sprint H (Option A): memory-consolidation write failure (sync throw).
+            runtime.recordInternalError("store_write");
             /* non-fatal */
         }
     }
@@ -215,6 +222,8 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
             }
         }
         catch {
+            // Sprint H (Option A): RAPTOR tree-refresh write failure.
+            runtime.recordInternalError("vector_index");
             /* non-fatal: tree refresh never blocks a compaction */
         }
     }
@@ -228,6 +237,8 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
             const latest = all.find((cp) => cp.checkpointId === result.checkpointId);
             if (latest?.embedding) {
                 void indexUpsertEmbedding(repoKey(runtime.currentStateDir), sid, latest.checkpointId, latest.embedding).catch(() => {
+                    // Sprint H (Option A): async global vector-index upsert failure.
+                    runtime.recordInternalError("vector_index");
                     /* non-fatal: index refresh never blocks a compaction */
                 });
             }

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

@@ -8,6 +8,7 @@
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { readFileSync } from "node:fs";
+import { normalizeSessionId } from "../../src/store.js";
 // ── Public string constants ────────────────────────────────────────────────
 // Exported via the barrel — consumers (mega-events.ts, mega-pipeline.ts) use
 // these keys to register widgets/markers with pi.
@@ -38,3 +39,48 @@ export function ownVersion() {
     CACHED_VERSION = v;
     return v;
 }
+/**
+ * createSessionRuntime() — the default per-session runtime state.
+ *
+ * Extracted from runtime.ts (delegate-shell split) so the MegaRuntime class
+ * stays a field-declarations + 1-line-delegate shell. Returns a fresh
+ * SessionRuntime for each session (reset on session_start / session_tree).
+ * Mirrors the neuralwatt-mcr per-session closure.
+ */
+export function createSessionRuntime() {
+    return {
+        sessionId: normalizeSessionId(undefined),
+        persistedThisSession: false,
+        lastCheckpointId: undefined,
+        lastCompactedFrom: 0,
+        lastCompactedTokens: 0,
+        dedupSkips: 0,
+        dedupAttempts: 0,
+        tokensSaved: 0,
+        lastCompactAt: null,
+        lastRecallAt: null,
+        lastInjectAt: null,
+        _prevCacheHitPct: null,
+        _lastCacheHealthScore: undefined,
+        lastNativeCompactAt: null,
+        compactCount: 0,
+        recallInjections: 0,
+        cacheHitTokens: 0,
+        lengthStopPending: false,
+        forceCompactNextGate: false,
+        errorRetryCount: 0,
+        errorRetryUntil: 0,
+        consecutiveErrors: 0,
+        lastErrorRetryAt: 0,
+        retryNudgePending: false,
+        errorRetrySessionCount: 0,
+        lastErrorText: undefined,
+        errorTextRepeatCount: 0,
+        poisonedAdviseSent: false,
+        providerOutageAdvised: false,
+        poisonedCompactSignatures: new Set(),
+        recallInjectedThisTurn: false,
+        poisonedCount: 0,
+        extensionInitiatedTurn: false,
+    };
+}

package/dist/extensions/mega-runtime/internal-errors.js

@@ -0,0 +1,14 @@
+/**
+ * RING_MAX — the cap for the rolling health ring buffers
+ * (`recentTurnEmbeddings`, `recentErrorCategories`, `recentInternalErrors`).
+ * Defined here (with the ring writer) and re-exported from runtime.ts so the
+ * ring + its writer live together; health-handler.ts imports it.
+ */
+export const RING_MAX = 5;
+/** Push a category into the internal-error ring. Mirrors `recentErrorCategories`. */
+export function recordInternalErrorImpl(rt, category) {
+    rt.recentInternalErrors.push(category);
+    if (rt.recentInternalErrors.length > RING_MAX) {
+        rt.recentInternalErrors.shift();
+    }
+}

package/dist/extensions/mega-runtime/pressure-getters.js

@@ -51,16 +51,18 @@ export function pressureImpl(self) {
  * always below pi's native auto-compaction (~80% of window).
  */
 export function effectiveThresholdImpl(self) {
-    // 3WF-2 threshold invariant: under the umbrella, a tiered config with an
-    // UNKNOWN window (lastCtxWindow <= 0) DEFERS — auto-compaction must never
-    // substitute a guessed window. Returning +Infinity keeps every downstream
-    // `tokens >= threshold` comparison false (gateCheck token path,
-    // agent_end durable trigger, live-trim re-compact), so no compaction fires
-    // until the provider reports a real window. custom (tierPct null) and
-    // umbrella-OFF fall through to the legacy helper (byte-identical).
-    if (self.config.threeWayFailback &&
-        self.config.tierPct != null &&
-        self.lastCtxWindow <= 0) {
+    // 3WF-2 threshold invariant (LTS-correctness fix, Phase C): a tiered config
+    // (tierPct != null) with an UNKNOWN window (lastCtxWindow <= 0) DEFERS —
+    // auto-compaction must never substitute a guessed window, under ANY umbrella
+    // state. Returning +Infinity keeps every downstream `tokens >= threshold`
+    // comparison false (gateCheck token path, agent_end durable trigger, live-trim
+    // re-compact), so no compaction fires until the provider reports a real
+    // window. This closes the small-context-model deadlock: umbrella-OFF
+    // previously fell through to the legacy 200k helper (round(tierPct × 200k)),
+    // which is unreachable on a 32k window → the model truncates before the gate
+    // ever fires → "compact never". custom (tierPct null) always falls through
+    // to the explicit absolute.
+    if (self.config.tierPct != null && self.lastCtxWindow <= 0) {
         return Number.POSITIVE_INFINITY;
     }
     return effectiveThresholdTokens({

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

@@ -9,6 +9,7 @@
  * runtime-helpers.ts.
  */
 import { normalizeSessionId } from "../../src/store.js";
+import { DEFAULT_SAVED_GOAL } from "../mega-config.js";
 // --------------------------------------------------------------- resetRuntime
 export function resetRuntimeImpl(self, sessionId) {
     // Only call normalizeSessionId when a real sessionId string is passed.
@@ -37,6 +38,7 @@ export function resetRuntimeImpl(self, sessionId) {
         recallInjections: 0,
         cacheHitTokens: 0,
         lengthStopPending: false,
+        forceCompactNextGate: false,
         errorRetryCount: 0,
         errorRetryUntil: 0,
         consecutiveErrors: 0,
@@ -60,7 +62,7 @@ export function resetRuntimeImpl(self, sessionId) {
     self.tierTrace = undefined;
     self.ticker.length = 0;
     self.pulsing = false;
-    self.savedGoal = 50_000;
+    self.savedGoal = DEFAULT_SAVED_GOAL;
     self.lastWhy = undefined;
     // S31 audit P2: symmetry with bindRepo — a reset can coincide with a context
     // that re-binds the repo, so drop the memo too. Cheap; the next