pi-mega-compact 0.5.2 → 0.6.0

package/README.md

@@ -6,7 +6,7 @@ sessions into a **local SQLite store** and offers **deduped inline recall** —
 running **locally inside the extension**, with **no remote MCP server** and
 **zero network calls at runtime** (PREVENT-PI-004).
 
-> **Current version:** `v0.5.1` — storage backend is **`node:sqlite`**
+> **Current version:** `v0.6.0` — storage backend is **`node:sqlite`**
 > (`DatabaseSync`, a Node ≥22.13 built-in), replacing the old `better-sqlite3`
 > native addon and the per-session gzipped JSON checkpoint files. **Zero native
 > build step, fully local, zero network at runtime.** Legacy
@@ -214,9 +214,10 @@ The commands (slash commands inside pi):
 | `/mega-restore <chkpt\|recent>` | Re-inject a checkpoint's verbatim original region into context. |
 | `/mega-history` | List this session's checkpoints (id, date, files, tokens). |
 | `/mega-view <chkpt\|recent>` | Show a checkpoint's verbatim original region. |
-| `/mega-help` | Explain the toolbar widget terms (tier, gate, dedup, tokens saved). |
-| `/mega-tier [name]` | Set the compaction tier (`low` / `medium` / `high` / `ultra` / `mega`). Shows current tier with no arg. |
+| `/mega-help` | Explain the toolbar widget terms (live tier, gate, dedup, tokens saved). |
 | `/mega-compat-check` | Detect extension conflicts (duplicate commands / overlapping handlers) across installed pi extensions. |
+
+The **tier** you see in the toolbar and dashboard is a *live pressure band* (`low` → `medium` → `high` → `ultra` → `mega`) that climbs automatically as your context window fills and falls back as it's relieved — it is driven by `currentTokens / thresholdTokens`, not a manual setting. The base compaction *threshold* (token budget) is still chosen by the `MEGACOMPACT_TIER` env var at startup (`low`/`medium`/`high`/`ultra`/`mega`, default `low`); `/mega-tier` was removed in v0.6.0. Higher pressure also deepens the live trim and reviews durable memory more often — the whole system reacts as one.
 | `/mega-dashboard` | Start the **localhost-only** live dashboard and open it in a browser (token gauge, store stats, live event stream, per-repo + cross-repo drift). |
 | `/mega-dashboard-status` | Report dashboard server status. |
 | `/mega-dashboard-stop` | Stop the dashboard server. |
@@ -226,7 +227,7 @@ The commands (slash commands inside pi):
 Above the pi editor the extension shows a compact widget:
 
 ```
- ⚡ medium v0.5.1 │ 142k/200k tokens (71%) │ 3 chkpts │ 🤖 2 agents │ turn 5
+ ⚡ high·low v0.6.0 │ 142k/200k tokens (71%) │ 3 chkpts │ 🤖 2 agents │ turn 5
    ◐ armed │ dedup: 92% │ saved: 45k tok
 ```
 

package/dist/extensions/dashboard-server.js

@@ -136,6 +136,8 @@ function readSnapshot(snapshotPath) {
             version: 1,
             updatedAt: null,
             tier: "unknown",
+            presetTier: "unknown",
+            pressure: 0,
             config: { fastGatePct: 80, thresholdTokens: 100_000, anchorUserMessages: 1, preserveRecent: 2, auto: true, autoInlineK: 3 },
             session: { id: null, state: null, persistedThisSession: false, lastCheckpointId: null, lastCompactedFrom: 0 },
             context: { tokens: null, percent: null, contextWindow: 0 },
@@ -261,7 +263,7 @@ function dashboardHtml(tierName) {
 
 <div class="offline-banner" id="offline-banner">Dashboard data unavailable — waiting for a pi session to write snapshot...</div>
 
-<h1><span>mega-compact</span><span class="tier">${tierName}</span><span class="version-pill">v${dashboardServerVersion}</span><span class="model-pill" id="hdr-model">—</span></h1>
+<h1><span>mega-compact</span><span class="tier" id="hdr-tier">${tierName}</span><span class="version-pill">v${dashboardServerVersion}</span><span class="model-pill" id="hdr-model">—</span></h1>
 
 <nav class="tabs">
   <button class="tab active" data-tab="current">Current repo</button>
@@ -323,7 +325,9 @@ function dashboardHtml(tierName) {
   <div class="card">
     <h2>Configuration</h2>
     <div class="conf-grid">
-      <span class="label">Tier</span><span class="value" id="cf-tier">${tierName}</span>
+      <span class="label" title="Live pressure band — climbs low→mega as context fills the window.">Tier (live)</span><span class="value" id="cf-tier">${tierName}</span>
+      <span class="label" title="The env-resolved base compaction preset (low/medium/high/ultra/mega) that set the token threshold.">Preset</span><span class="value" id="cf-preset">—</span>
+      <span class="label" title="Live pressure = currentTokens / thresholdTokens (0–100%).">Pressure</span><span class="value" id="cf-pressure">—</span>
       <span class="label">Threshold</span><span class="value" id="cf-threshold">—</span>
       <span class="label">Fast Gate</span><span class="value" id="cf-gate">—</span>
       <span class="label">Auto</span><span class="value" id="cf-auto">—</span>
@@ -502,7 +506,12 @@ function dashboardHtml(tierName) {
     document.getElementById('cr-status').textContent = (crew.activeAgents > 0)
       ? ('▶ ' + crew.activeAgents + ' running') : 'idle';
 
-    document.getElementById('cf-tier').textContent = d.tier;
+    // S24: headline tier is the LIVE pressure band; the config card shows the
+    // env preset + live pressure ratio so the user sees the system react.
+    document.getElementById('hdr-tier').textContent = d.tier;
+    document.getElementById('cf-tier').textContent = d.tier + ' (live)';
+    document.getElementById('cf-preset').textContent = d.presetTier;
+    document.getElementById('cf-pressure').textContent = Math.round((d.pressure || 0) * 100) + '%';
     document.getElementById('cf-threshold').textContent = d.config.thresholdTokens.toLocaleString();
     document.getElementById('cf-gate').textContent = d.config.fastGatePct + '%';
     document.getElementById('cf-auto').textContent = d.config.auto ? 'enabled' : 'disabled';

package/dist/extensions/mega-commands.js

@@ -12,7 +12,6 @@ import { decompressSmart } from "../src/store/compression.js";
 import { loadMetrics, fpRate, p95 } from "../src/monitoring.js";
 import { C, recentUserQuery } from "./mega-runtime.js";
 import { runCompact, doRecall, doRecallAsync } from "./mega-pipeline.js";
-import { setTier, COMPACT_TIERS } from "./mega-config.js";
 /** Resolve a checkpoint by id (or "recent"/"last") from this session's store. */
 export function findCheckpoint(runtime, sid, ref) {
     const all = listCheckpoints(sid, runtime.currentStateDir);
@@ -117,7 +116,8 @@ export function registerCommands(pi, runtime, config) {
             }
             catch { /* non-fatal */ }
             const crossRepoStr = `${crossRepoInjections} cross-repo injections recorded · ${repoCount} repos indexed`;
-            ctx.ui.notify(`[mega-compact] pct=${pct} tokens=${tokens} tier=${config.tier} fastGate=${config.fastGatePct}% ` +
+            ctx.ui.notify(`[mega-compact] pct=${pct} tokens=${tokens} tier=${runtime.pressureBand} (live) preset=${config.tier} ` +
+                `pressure=${Math.round(runtime.pressure * 100)}% fastGate=${config.fastGatePct}% ` +
                 `threshold=${config.thresholdTokens} auto=${config.auto} autoInline=${config.autoInline}\n` +
                 `[mega-compact] store: ${st.checkpointCount} chkpt · ` +
                 `${st.totalTokenEstimate} tok · last=${st.lastCheckpointId ?? "—"} · ` +
@@ -215,25 +215,7 @@ export function registerCommands(pi, runtime, config) {
                 `• data safety — every compressed region is kept verbatim; nothing is permanently deleted. /mega-restore brings any of it back.`);
         },
     });
-    pi.registerCommand("mega-tier", {
-        description: "Show or change the compaction tier at runtime. Usage: /mega-tier [low|medium|high|ultra|mega]",
-        handler: async (args, ctx) => {
-            const arg = args.trim().toLowerCase();
-            if (!arg) {
-                // Show current tier and available options.
-                ctx.ui.notify(`[mega-compact] current tier: ${config.tier} (${config.thresholdTokens} tok)\n` +
-                    `[mega-compact] available tiers: ${Object.entries(COMPACT_TIERS).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-                return;
-            }
-            if (!(arg in COMPACT_TIERS)) {
-                ctx.ui.notify(`[mega-compact] unknown tier "${arg}". Available: ${Object.keys(COMPACT_TIERS).join(", ")}`);
-                return;
-            }
-            const newTier = arg;
-            setTier(config, newTier);
-            runtime.setStatus(ctx, `mega-compact: tier → ${newTier} (${config.thresholdTokens} tok)`);
-            ctx.ui.notify(`[mega-compact] tier changed to ${newTier} (threshold: ${config.thresholdTokens} tokens)`);
-            runtime.snapshot(ctx);
-        },
-    });
+    // NOTE: /mega-tier was removed in S24. The tier the user sees is now the LIVE
+    // pressure band (low/medium/high/ultra/mega), which climbs automatically as
+    // context fills — there is no manual tier to set. See docs/specs/s24-unified-pressure.md.
 }

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

@@ -384,16 +384,19 @@ const TIER_CASES = [
     ["mega", 10_000_000],
 ];
 for (const [tier, threshold] of TIER_CASES) {
-    test(`tier "${tier}" resolves to a ${threshold}-token threshold`, async () => {
+    test(`tier "${tier}" resolves to a ${threshold}-token threshold (preset; live band shown separately)`, async () => {
         // Keep tier + keep threshold UNSET so the tier (not an explicit number)
         // drives the threshold. harness() would otherwise reset the threshold.
         delete process.env.MEGACOMPACT_THRESHOLD_TOKENS;
         process.env.MEGACOMPACT_TIER = tier;
         const h = harness({ keepTier: true, keepThreshold: true });
+        // tokens=1 against a 2M window → near-zero pressure → live band "low".
         const ctx = h.ctx({ getContextUsage: () => ({ tokens: 1, contextWindow: 2_000_000, percent: 0.01 }) });
         await h.commands["mega-status"].handler("", ctx);
         delete process.env.MEGACOMPACT_TIER;
-        assert.ok(h.notifies.some((n) => n.includes(`tier=${tier}`) && n.includes(`threshold=${threshold}`)), `status should report tier=${tier} threshold=${threshold}`);
+        assert.ok(h.notifies.some((n) => n.includes(`preset=${tier}`) && n.includes(`threshold=${threshold}`)), `status should report preset=${tier} threshold=${threshold}`);
+        // S24: the headline tier is the LIVE pressure band, shown as "tier=low (live)".
+        assert.ok(h.notifies.some((n) => n.includes("tier=low (live)")), "live band reported (low at near-zero pressure)");
     });
 }
 test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
@@ -403,7 +406,7 @@ test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
     const ctx = h.ctx({ getContextUsage: () => ({ tokens: 1, contextWindow: 2_000_000, percent: 0.01 }) });
     await h.commands["mega-status"].handler("", ctx);
     delete process.env.MEGACOMPACT_TIER;
-    assert.ok(h.notifies.some((n) => n.includes("tier=custom") && n.includes("threshold=777")), "explicit threshold wins over tier (tier=custom)");
+    assert.ok(h.notifies.some((n) => n.includes("preset=custom") && n.includes("threshold=777")), "explicit threshold wins over tier (preset=custom)");
 });
 // ---- /dashboard commands ----------------------------------------------------
 test("/dashboard-status reports no server when pid file missing", async () => {

package/dist/extensions/mega-config.js

@@ -47,11 +47,13 @@ function resolveThreshold() {
     return { tier, thresholdTokens: COMPACT_TIERS[tier] };
 }
 /**
- * Pressure helpers for adaptive compression (Fix E) live in src/config.ts
- * (pi-agnostic) so unit tests can import them without the pi runtime. Re-export
- * here so the extension has one import surface.
+ * Pressure helpers for adaptive compression live in src/config.ts (pi-agnostic)
+ * so unit tests can import them without the pi runtime. Re-export here so the
+ * extension has one import surface. (S24 unified the previously percentage-only
+ * signal into pressureRatio/pressureBand, which the runtime uses as the single
+ * "how full" signal that drives the tier label, trim depth, and memory cadence.)
  */
-export { pressureFromPct, preserveRecentForPressure } from "../src/config.js";
+export { pressureFromPct, preserveRecentForPressure, pressureRatio, pressureBand, memoryReviewCadence, } from "../src/config.js";
 /** Build the resolved config from env + defaults. */
 export function loadConfig() {
     const { tier, thresholdTokens } = resolveThreshold();
@@ -80,11 +82,12 @@ export function loadConfig() {
         debug: envBool("MEGACOMPACT_DEBUG", false),
     };
 }
-/** Mutate tier + threshold in place (used by /mega-tier at runtime). */
-export function setTier(config, tier) {
-    config.tier = tier;
-    config.thresholdTokens = COMPACT_TIERS[tier];
-}
+/**
+ * Remove a cached tier mutation helper here — the live tier the user sees is the
+ * pressure band (MegaRuntime.pressureBand), and the base preset is env-resolved
+ * at load (loadConfig). The /mega-tier command was removed in S24 so there is no
+ * runtime tier mutation; see the S24 spec (docs/specs/s24-unified-pressure.md).
+ */
 /**
  * Resolve the current repo's git root from a cwd. Returns undefined for a
  * non-git directory (caller falls back to a global state dir).

package/dist/extensions/mega-events.js

@@ -14,7 +14,7 @@ import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop } from "./mega-
 import { recallMemoriesAndInline } from "../src/recall.js";
 import { driveNativeCompaction } from "./mega-compact-driver.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "./mega-trim.js";
-import { pressureFromPct } from "./mega-config.js";
+import { pressureFromPct, memoryReviewCadence } from "./mega-config.js";
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi, runtime, config) {
     // ---- Session lifecycle (state reset points) -------------------------------
@@ -158,26 +158,31 @@ export function registerEventHandlers(pi, runtime, config) {
     pi.on("turn_end", async (event, ctx) => {
         runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
         runtime.snapshot(ctx);
-        // S20: auto-review the conversation every N turns and persist durable
-        // memories. Best-effort + non-fatal: a review failure must never break the
-        // agent loop. Debounced by memoryReviewInterval turns.
-        if (config.memoryAutoReview && runtime.currentTurn > 0 && runtime.currentTurn % config.memoryReviewInterval === 0) {
-            try {
-                const { reviewConversation } = await import("../src/memory.js");
-                const { applyMemoryOps } = await import("../src/memoryOps.js");
-                const entries = ctx.sessionManager.getEntries();
-                const view = runtime.engineView(entries.flatMap((e) => (e.message ? [e.message] : [])));
-                const ops = reviewConversation(view, []);
-                if (ops.length) {
-                    await applyMemoryOps(ops, runtime.currentStateDir);
-                    // S21.2: a memory op landed in this turn window. The pipeline reads
-                    // this counter after a successful compaction and fires
-                    // `consolidateMemories` only when it's > 0.
-                    runtime.memoriesTouchedThisCompaction += ops.length;
+        // 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) {
+                try {
+                    const { reviewConversation } = await import("../src/memory.js");
+                    const { applyMemoryOps } = await import("../src/memoryOps.js");
+                    const entries = ctx.sessionManager.getEntries();
+                    const view = runtime.engineView(entries.flatMap((e) => (e.message ? [e.message] : [])));
+                    const ops = reviewConversation(view, []);
+                    if (ops.length) {
+                        await applyMemoryOps(ops, runtime.currentStateDir);
+                        // S21.2: a memory op landed in this turn window. The pipeline reads
+                        // this counter after a successful compaction and fires
+                        // `consolidateMemories` only when it's > 0.
+                        runtime.memoriesTouchedThisCompaction += ops.length;
+                    }
+                }
+                catch {
+                    /* non-fatal — auto-review must not break the turn loop */
                 }
-            }
-            catch {
-                /* non-fatal — auto-review must not break the turn loop */
             }
         }
     });

package/dist/extensions/mega-pipeline.js

@@ -133,6 +133,28 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
             /* non-fatal */
         }
     }
+    // S24 review-on-compact: when pressure is high, the just-compacted region is
+    // exactly the context worth remembering, so review it immediately rather than
+    // waiting for the next turn-cadence tick. Fire-and-forget (doCompact is sync):
+    // best-effort + non-fatal, paralleling the consolidate pass above. Only fires
+    // above the `high` band so low-pressure compactions don't pay the review cost.
+    if (!result.deduped && config.memoryAutoReview && runtime.pressureBand !== "low" && runtime.pressureBand !== "medium") {
+        void (async () => {
+            try {
+                const { reviewConversation } = await import("../src/memory.js");
+                const { applyMemoryOps } = await import("../src/memoryOps.js");
+                const ops = reviewConversation(view, []);
+                if (ops.length) {
+                    await applyMemoryOps(ops, runtime.currentStateDir);
+                    runtime.memoriesTouchedThisCompaction += ops.length;
+                    runtime.pushTicker(`${C.green}🧠${C.reset} reviewed ${ops.length} memory op${ops.length === 1 ? "" : "s"} (pressure)`);
+                }
+            }
+            catch {
+                /* non-fatal — review-on-compact must never break the compaction */
+            }
+        })();
+    }
     // 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, {

package/dist/extensions/mega-runtime.js

@@ -17,7 +17,7 @@ import { toEngineMessages } from "../src/adapt.js";
 import { normalizeSessionId } from "../src/store.js";
 import { Logger } from "../src/log.js";
 import { recordModelSnapshot, latestModelSnapshot, upsertRepoRegistry, recordRepoModel } from "../src/store/sqlite.js";
-import { repoStateDir, resolveRepoRoot } from "./mega-config.js";
+import { repoStateDir, resolveRepoRoot, pressureRatio, pressureFromPct, pressureBand } from "./mega-config.js";
 import { Dashboard } from "./mega-dashboard.js";
 export const STATUS_KEY = "mega-compact";
 export const WIDGET_KEY = "mega-compact-stats";
@@ -120,6 +120,24 @@ export class MegaRuntime {
     lastCtxTokens = null;
     lastCtxPercent = null;
     lastCtxWindow = 0;
+    /**
+     * Live 0–1 pressure: how full the context window is relative to the compaction
+     * threshold. Computed from the most recent context event the runtime already
+     * tracks (token count when available — the direct signal — otherwise the usage
+     * percentage). This is the single "how full" number every subsystem reads; the
+     * toolbar/dashboard tier label is `pressureBand` over this, so it climbs
+     * low→mega as context rises (S24). Always finite + in [0,1].
+     */
+    get pressure() {
+        if (this.lastCtxTokens != null && this.lastCtxTokens > 0 && this.config.thresholdTokens > 0) {
+            return pressureRatio(this.lastCtxTokens, this.config.thresholdTokens);
+        }
+        return pressureFromPct(this.lastCtxPercent);
+    }
+    /** Live discrete pressure band (low/medium/high/ultra/mega) over `pressure`. */
+    get pressureBand() {
+        return pressureBand(this.pressure);
+    }
     constructor(config) {
         this.config = config;
         this.store = new VectorStore({ dedupSim: config.dedupSim, stateDir: config.stateDir });
@@ -190,7 +208,11 @@ export class MegaRuntime {
         this.dashboard.snapshot({
             version: 1,
             updatedAt: new Date().toISOString(),
-            tier: this.config.tier,
+            // S24: the headline tier is the LIVE pressure band; the env preset is kept
+            // alongside as presetTier so the dashboard can show both.
+            tier: this.pressureBand,
+            presetTier: this.config.tier,
+            pressure: this.pressure,
             config: {
                 fastGatePct: this.config.fastGatePct,
                 thresholdTokens: this.config.thresholdTokens,
@@ -236,6 +258,11 @@ export class MegaRuntime {
             const tokStr = this.lastCtxTokens != null ? `${Math.round(this.lastCtxTokens / 1000)}k` : "?";
             const maxStr = this.lastCtxWindow > 0 ? `${Math.round(this.lastCtxWindow / 1000)}k` : "?";
             const pctStr = this.lastCtxPercent != null ? `${Math.round(this.lastCtxPercent * 10) / 10}%` : "?%";
+            // S24: the tier label is the LIVE pressure band (low/medium/high/ultra/
+            // mega), not the static env preset. It climbs as context fills, so the
+            // user can see the system react. The base preset is shown as a dim suffix.
+            const liveBand = this.pressureBand;
+            const tierLabel = `${C.bold}${liveBand}${C.reset}${C.gray}·${this.config.tier}${C.reset}`;
             const triggerLabel = ready ? `${C.green}● ready${C.reset}` : armed ? `${C.amber}◐ armed${C.reset}` : `${C.gray}○ idle${C.reset}`;
             // Storage dedup rate is cumulative (store-wide, per-repo) and survives
             // session resets. Always show a number: 0% before any compaction, a
@@ -258,7 +285,7 @@ export class MegaRuntime {
             // Phase 3 — pulsing status glyph while a compaction is in flight.
             const pulse = this.pulsing ? `${C.cyan}${PULSE[Math.floor(Date.now() / 250) % PULSE.length]}${C.reset} ` : "";
             const lines = [
-                ` ${C.amber}⚡ ${this.config.tier}${C.reset} v${C.bold}${ownVersion()}${C.reset} │ ${tokStr}/${maxStr} tokens (${C.bold}${pctStr}${C.reset}) │ ${st.checkpointCount} saved${agentStr}${turnStr}`,
+                ` ${C.amber}⚡ ${tierLabel}${C.reset} v${C.bold}${ownVersion()}${C.reset} │ ${tokStr}/${maxStr} tokens (${C.bold}${pctStr}${C.reset}) │ ${st.checkpointCount} saved${agentStr}${turnStr}`,
                 `   ${triggerLabel} │ ${C.magenta}repeat-skipped: ${dedupStr}${C.reset} │ ${C.gray}memory held:${C.reset} ${usedStr} │ ${C.gray}space freed:${C.reset} ${savedStr}`,
             ];
             // Phase 3 — compact progress bar: session tokens saved toward the rolling goal.

package/dist/src/config.js

@@ -31,3 +31,51 @@ export function preserveRecentForPressure(pressure, preserveRecent, preserveRece
     const v = Math.round(preserveRecent - (preserveRecent - preserveRecentMin) * p);
     return Math.max(preserveRecentMin, Math.min(preserveRecent, v));
 }
+/** Clamp a pressure ratio into [0, 1]. */
+function clamp01(p) {
+    if (!Number.isFinite(p))
+        return 0;
+    return p < 0 ? 0 : p > 1 ? 1 : p;
+}
+/**
+ * Pressure as a 0–1 ratio from live token usage relative to the compaction
+ * threshold. Cheaper + more direct than deriving from a usage percentage when
+ * we already have both numbers (the context handler does). Re-exports
+ * `pressureFromPct` covers the percentage-only path. (S24.)
+ */
+export function pressureRatio(currentTokens, thresholdTokens) {
+    if (!Number.isFinite(currentTokens) || currentTokens <= 0)
+        return 0;
+    const t = Number.isFinite(thresholdTokens) && thresholdTokens > 0 ? thresholdTokens : 0;
+    return clamp01(t > 0 ? currentTokens / t : 0);
+}
+/** Map a 0–1 pressure ratio to a discrete band. (S24.) */
+export function pressureBand(pressure) {
+    const p = clamp01(pressure);
+    if (p >= 1.0)
+        return "mega";
+    if (p >= 0.9)
+        return "ultra";
+    if (p >= 0.75)
+        return "high";
+    if (p >= 0.5)
+        return "medium";
+    return "low";
+}
+/**
+ * Memory auto-review cadence (in turns) for a given pressure band. As pressure
+ * climbs, the conversation is reviewed more often so durable memories keep pace
+ * with the faster context churn. Returns a divisor used as
+ * `turn % cadence === 0`. Always >= 1. (S24 — memory cadence tie-in.)
+ */
+export function memoryReviewCadence(band, baseInterval) {
+    const base = baseInterval >= 1 ? baseInterval : 1;
+    switch (band) {
+        case "mega": return Math.max(1, Math.round(base / 5));
+        case "ultra": return Math.max(1, Math.round(base / 3));
+        case "high": return Math.max(1, Math.round(base / 2));
+        case "medium": return Math.max(1, Math.round((base * 2) / 3));
+        case "low":
+        default: return base;
+    }
+}

package/dist/src/memoryOps.test.js

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { applyMemoryOps } from "./memoryOps.js";
-import { addMemory, listMemories } from "./store/sqlite.js";
+import { addMemory, listMemories, replaceMemory, referenceMemory, MEMORY_MAX_CHARS, MEMORY_MAX_ROWS, } from "./store/sqlite.js";
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-memops-"));
 test("applyMemoryOps: ADD inserts a new memory", async () => {
     const dir = join(baseTmp, "add");
@@ -36,6 +36,55 @@ test("applyMemoryOps: REMOVE deletes the matching memory", async () => {
     const rows = listMemories(null, 50, dir);
     assert.ok(!rows.some((m) => /obsolete note/.test(m.content)), "removed");
 });
+test("S24: addMemory truncates content to MEMORY_MAX_CHARS", () => {
+    const dir = join(baseTmp, "cap");
+    const big = "x".repeat(MEMORY_MAX_CHARS + 5000);
+    const id = addMemory({ content: big, category: "note" }, null, dir);
+    const rows = listMemories(null, 50, dir);
+    const row = rows.find((m) => m.id === id);
+    assert.ok(row, "row present");
+    assert.ok(row.content.length <= MEMORY_MAX_CHARS + 12, "content capped (incl. marker)");
+    assert.ok(row.content.endsWith("…[truncated]"), "marker appended");
+});
+test("S24: replaceMemory also truncates oversized content", () => {
+    const dir = join(baseTmp, "capreplace");
+    const id = addMemory({ content: "short", category: "note" }, null, dir);
+    const big = "y".repeat(MEMORY_MAX_CHARS + 1000);
+    replaceMemory(id, { content: big }, dir);
+    const rows = listMemories(null, 50, dir);
+    const row = rows.find((m) => m.id === id);
+    assert.ok(row, "row present");
+    assert.ok(row.content.length <= MEMORY_MAX_CHARS + 12, "replaced content capped");
+    assert.ok(row.content.endsWith("…[truncated]"), "marker appended");
+});
+test("S24: addMemory evicts LRU rows past MEMORY_MAX_ROWS per repo", () => {
+    const dir = join(baseTmp, "lru");
+    const n = MEMORY_MAX_ROWS;
+    const seeds = n - 2;
+    for (let i = 0; i < seeds; i++)
+        addMemory({ content: `seed-${i}`, category: "note" }, null, dir);
+    const keep1 = addMemory({ content: "keep-recent-1", category: "note" }, null, dir);
+    const keep2 = addMemory({ content: "keep-recent-2", category: "note" }, null, dir);
+    // Mark the two as referenced so the LRU eviction spares them (they get a
+    // higher last_referenced than the un-referenced seeds).
+    assert.ok(referenceMemory(keep1, dir), "reference keep1");
+    assert.ok(referenceMemory(keep2, dir), "reference keep2");
+    // Insert 3 more — 3 over the cap across the inserts. The two referenced rows
+    // must survive; only un-referenced (oldest) seeds should be evicted.
+    addMemory({ content: "new-1", category: "note" }, null, dir);
+    addMemory({ content: "new-2", category: "note" }, null, dir);
+    addMemory({ content: "new-3", category: "note" }, null, dir);
+    const rows = listMemories(null, 1000, dir);
+    assert.equal(rows.length, n, "row count clamped to MEMORY_MAX_ROWS");
+    assert.ok(rows.some((m) => /keep-recent-1/.test(m.content)), "referenced row survived");
+    assert.ok(rows.some((m) => /keep-recent-2/.test(m.content)), "referenced row survived");
+    assert.ok(rows.some((m) => /new-3/.test(m.content)), "newest row present");
+    const seedRows = rows.filter((m) => /seed-/.test(m.content));
+    // 3 rows were evicted (the inserts pushed 3 past the cap); all evicted rows
+    // must be un-referenced seeds — the referenced rows survived above.
+    assert.equal(seedRows.length, seeds - 3, "exactly 3 oldest un-referenced seeds evicted");
+    assert.ok(!seedRows.some((m) => /seed-0/.test(m.content)), "oldest un-referenced seed evicted");
+});
 test("cleanup memops", () => {
     rmSync(baseTmp, { recursive: true, force: true });
 });

package/dist/src/store/compression.test.js

@@ -113,3 +113,27 @@ test("pressureFromPct + preserveRecentForPressure scale with context (Fix E)", a
     assert.equal(preserveRecentForPressure(0.5, 4, 2), 3, "p=0.5 → interpolates");
     assert.ok(preserveRecentForPressure(1, 4, 2) >= 2, "never below floor");
 });
+test("S24: pressureRatio + pressureBand + memoryReviewCadence unify the signal", async () => {
+    const { pressureRatio, pressureBand, memoryReviewCadence } = await import("../config.js");
+    // pressureRatio: current/threshold, clamped to [0,1].
+    assert.equal(pressureRatio(50_000, 100_000), 0.5, "half threshold → 0.5");
+    assert.equal(pressureRatio(0, 100_000), 0, "no tokens → 0");
+    assert.equal(pressureRatio(10_000_000, 100_000), 1, "over threshold → clamped 1");
+    assert.equal(pressureRatio(50_000, 0), 0, "zero threshold → 0");
+    assert.equal(pressureRatio(NaN, 100_000), 0, "NaN current → 0");
+    // pressureBand: discrete bands drive the toolbar/dashboard tier label.
+    assert.equal(pressureBand(0.2), "low");
+    assert.equal(pressureBand(0.5), "medium");
+    assert.equal(pressureBand(0.75), "high");
+    assert.equal(pressureBand(0.9), "ultra");
+    assert.equal(pressureBand(1.0), "mega");
+    assert.equal(pressureBand(2.0), "mega", "over 1 → mega");
+    assert.equal(pressureBand(-1), "low", "below 0 → low");
+    // memoryReviewCadence: higher pressure → smaller (more frequent) divisor.
+    assert.equal(memoryReviewCadence("low", 10), 10, "low keeps base interval");
+    assert.equal(memoryReviewCadence("medium", 10), 7, "medium shortens");
+    assert.equal(memoryReviewCadence("high", 10), 5, "high halves");
+    assert.equal(memoryReviewCadence("ultra", 10), 3, "ultra shortens more");
+    assert.equal(memoryReviewCadence("mega", 10), 2, "mega near base/5");
+    assert.equal(memoryReviewCadence("high", 0), 1, "never below 1");
+});

package/dist/src/store/sqlite.js

@@ -573,14 +573,71 @@ export function addLesson(sessionId, repo, lesson, stateDir = getStateDir()) {
     const now = Math.floor(Date.now() / 1000);
     db.prepare(`INSERT INTO lessons(session_id, repo, lesson, ts) VALUES(?, ?, ?, ?)`).run(normalizeSessionId(sessionId), repo ?? null, lesson, now);
 }
-/** Save a memory to the current repo's store. Returns the new row id. */
+// --- Durable memory (save-to-memory takeover) ---------------------------------
+// One SQLite store for user-saved memories, scoped by repo. Mirrors the
+// lessons/sessions pattern: all state lives in SQLite from day one.
+// S24 storage hardening: keep each memory row bounded so the durable store can
+// never blow a downstream consumer's per-entry buffer (e.g. pi's native
+// file-backed memory caps a single entry at ~5k chars). We truncate content at
+// MEMORY_MAX_CHARS and evict the least-recently-referenced rows past
+// MEMORY_MAX_ROWS per repo via LRU. Both are SQLite-only (PREVENT-PI-004): no
+// file-backed memory is written anywhere.
+export const MEMORY_MAX_CHARS = 4000;
+export const MEMORY_MAX_ROWS = 200;
+/** Truncate memory content to the per-entry cap, preserving a trailing marker. */
+function capMemoryContent(content) {
+    if (content.length <= MEMORY_MAX_CHARS)
+        return content;
+    return content.slice(0, MEMORY_MAX_CHARS) + "…[truncated]";
+}
+/**
+ * Evict the least-recently-referenced rows for a repo past MEMORY_MAX_ROWS.
+ * LRU key = COALESCE(last_referenced, last_recalled_at, created_at) so a memory
+ * that is recalled/referenced survives over a stale one. Best-effort: any error
+ * is swallowed by the caller. Repo-scoped so one noisy repo can't evict another.
+ */
+function evictMemoryLru(repo, stateDir) {
+    const db = openStore(stateDir);
+    // SQLite `= NULL` is never true, so the null-repo scope (memories are
+    // stateDir-scoped when repo is null — the applyMemoryOps path) needs `IS NULL`.
+    const where = repo == null ? "repo IS NULL" : "repo = ?";
+    const countRow = repo == null
+        ? db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get()
+        : db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get(repo);
+    const count = countRow.n;
+    const over = count - MEMORY_MAX_ROWS;
+    if (over <= 0)
+        return;
+    // Delete the `over` least-recently-used rows. ORDER BY the LRU key ASC, id ASC
+    // (id ASC breaks ties deterministically — oldest created first). The `where`
+    // clause is a code-controlled constant (never user input) → PREVENT-002 OK.
+    const sql = `DELETE FROM memories WHERE ${where} AND id IN (
+       SELECT id FROM memories WHERE ${where}
+       ORDER BY COALESCE(last_referenced, last_recalled_at, created_at) ASC, id ASC
+       LIMIT ?
+     )`;
+    if (repo == null)
+        db.prepare(sql).run(over);
+    else
+        db.prepare(sql).run(repo, repo, over);
+}
+/** Save a memory to the current repo's store. Returns the new row id.
+ *  S24 hardening: content is truncated to MEMORY_MAX_CHARS and, once the per-repo
+ *  row count exceeds MEMORY_MAX_ROWS, the least-recently-used rows are evicted
+ *  (LRU) so the store stays bounded. */
 export function addMemory(memory, repo, stateDir = getStateDir()) {
     const db = openStore(stateDir);
     const now = Math.floor(Date.now() / 1000);
     const res = db
         .prepare(`INSERT INTO memories(repo, kind, content, tags, created_at, last_recalled_at, category, target, source_turn)
        VALUES(?, ?, ?, ?, ?, NULL, ?, ?, ?)`)
-        .run(repo ?? null, memory.kind ?? "note", memory.content, JSON.stringify(memory.tags ?? []), now, memory.category ?? null, memory.target ?? null, memory.sourceTurn ?? null);
+        .run(repo ?? null, memory.kind ?? "note", capMemoryContent(memory.content), JSON.stringify(memory.tags ?? []), now, memory.category ?? null, memory.target ?? null, memory.sourceTurn ?? null);
+    try {
+        evictMemoryLru(repo, stateDir);
+    }
+    catch {
+        /* non-fatal: eviction must never fail an add */
+    }
     return Number(res.lastInsertRowid);
 }
 /** List recent memories for a repo (or all repos when repo is null). */
@@ -626,7 +683,7 @@ export function replaceMemory(id, patch, stateDir = getStateDir()) {
            target = COALESCE(?, target),
            source_turn = COALESCE(?, source_turn)
        WHERE id = ?`)
-        .run(patch.kind ?? null, patch.content ?? null, patch.tags ? JSON.stringify(patch.tags) : null, "category" in patch ? (patch.category ?? null) : null, "target" in patch ? (patch.target ?? null) : null, "sourceTurn" in patch ? (patch.sourceTurn ?? null) : null, id);
+        .run(patch.kind ?? null, patch.content != null ? capMemoryContent(patch.content) : null, patch.tags ? JSON.stringify(patch.tags) : null, "category" in patch ? (patch.category ?? null) : null, "target" in patch ? (patch.target ?? null) : null, "sourceTurn" in patch ? (patch.sourceTurn ?? null) : null, id);
     return res.changes > 0;
 }
 /** Remove a memory by id. Returns true if a row was deleted. */

package/extensions/dashboard-server.ts

@@ -138,6 +138,8 @@ interface Snapshot {
   version: number;
   updatedAt: string | null;
   tier: string;
+  presetTier: string;
+  pressure: number;
   config: {
     fastGatePct: number;
     thresholdTokens: number;
@@ -217,6 +219,8 @@ function readSnapshot(snapshotPath: string) {
       version: 1,
       updatedAt: null,
       tier: "unknown",
+      presetTier: "unknown",
+      pressure: 0,
       config: { fastGatePct: 80, thresholdTokens: 100_000, anchorUserMessages: 1, preserveRecent: 2, auto: true, autoInlineK: 3 },
       session: { id: null, state: null, persistedThisSession: false, lastCheckpointId: null, lastCompactedFrom: 0 },
       context: { tokens: null, percent: null, contextWindow: 0 },
@@ -343,7 +347,7 @@ function dashboardHtml(tierName: string): string {
 
 <div class="offline-banner" id="offline-banner">Dashboard data unavailable — waiting for a pi session to write snapshot...</div>
 
-<h1><span>mega-compact</span><span class="tier">${tierName}</span><span class="version-pill">v${dashboardServerVersion}</span><span class="model-pill" id="hdr-model">—</span></h1>
+<h1><span>mega-compact</span><span class="tier" id="hdr-tier">${tierName}</span><span class="version-pill">v${dashboardServerVersion}</span><span class="model-pill" id="hdr-model">—</span></h1>
 
 <nav class="tabs">
   <button class="tab active" data-tab="current">Current repo</button>
@@ -405,7 +409,9 @@ function dashboardHtml(tierName: string): string {
   <div class="card">
     <h2>Configuration</h2>
     <div class="conf-grid">
-      <span class="label">Tier</span><span class="value" id="cf-tier">${tierName}</span>
+      <span class="label" title="Live pressure band — climbs low→mega as context fills the window.">Tier (live)</span><span class="value" id="cf-tier">${tierName}</span>
+      <span class="label" title="The env-resolved base compaction preset (low/medium/high/ultra/mega) that set the token threshold.">Preset</span><span class="value" id="cf-preset">—</span>
+      <span class="label" title="Live pressure = currentTokens / thresholdTokens (0–100%).">Pressure</span><span class="value" id="cf-pressure">—</span>
       <span class="label">Threshold</span><span class="value" id="cf-threshold">—</span>
       <span class="label">Fast Gate</span><span class="value" id="cf-gate">—</span>
       <span class="label">Auto</span><span class="value" id="cf-auto">—</span>
@@ -584,7 +590,12 @@ function dashboardHtml(tierName: string): string {
     document.getElementById('cr-status').textContent = (crew.activeAgents > 0)
       ? ('▶ ' + crew.activeAgents + ' running') : 'idle';
 
-    document.getElementById('cf-tier').textContent = d.tier;
+    // S24: headline tier is the LIVE pressure band; the config card shows the
+    // env preset + live pressure ratio so the user sees the system react.
+    document.getElementById('hdr-tier').textContent = d.tier;
+    document.getElementById('cf-tier').textContent = d.tier + ' (live)';
+    document.getElementById('cf-preset').textContent = d.presetTier;
+    document.getElementById('cf-pressure').textContent = Math.round((d.pressure || 0) * 100) + '%';
     document.getElementById('cf-threshold').textContent = d.config.thresholdTokens.toLocaleString();
     document.getElementById('cf-gate').textContent = d.config.fastGatePct + '%';
     document.getElementById('cf-auto').textContent = d.config.auto ? 'enabled' : 'disabled';

package/extensions/mega-commands.ts

@@ -14,7 +14,7 @@ import { decompressSmart } from "../src/store/compression.js";
 import { loadMetrics, fpRate, p95 } from "../src/monitoring.js";
 import { MegaRuntime, C, recentUserQuery } from "./mega-runtime.js";
 import { runCompact, doRecall, doRecallAsync } from "./mega-pipeline.js";
-import { setTier, COMPACT_TIERS, type MegaConfig, type CompactTier } from "./mega-config.js";
+import { type MegaConfig } from "./mega-config.js";
 
 /** Resolve a checkpoint by id (or "recent"/"last") from this session's store. */
 export function findCheckpoint(runtime: MegaRuntime, sid: string, ref: string) {
@@ -126,7 +126,8 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, config:
       } catch { /* non-fatal */ }
       const crossRepoStr = `${crossRepoInjections} cross-repo injections recorded · ${repoCount} repos indexed`;
       ctx.ui.notify(
-        `[mega-compact] pct=${pct} tokens=${tokens} tier=${config.tier} fastGate=${config.fastGatePct}% ` +
+        `[mega-compact] pct=${pct} tokens=${tokens} tier=${runtime.pressureBand} (live) preset=${config.tier} ` +
+          `pressure=${Math.round(runtime.pressure * 100)}% fastGate=${config.fastGatePct}% ` +
           `threshold=${config.thresholdTokens} auto=${config.auto} autoInline=${config.autoInline}\n` +
           `[mega-compact] store: ${st.checkpointCount} chkpt · ` +
           `${st.totalTokenEstimate} tok · last=${st.lastCheckpointId ?? "—"} · ` +
@@ -239,27 +240,7 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, config:
     },
   });
 
-  pi.registerCommand("mega-tier", {
-    description: "Show or change the compaction tier at runtime. Usage: /mega-tier [low|medium|high|ultra|mega]",
-    handler: async (args: string, ctx: ExtensionContext) => {
-      const arg = args.trim().toLowerCase();
-      if (!arg) {
-        // Show current tier and available options.
-        ctx.ui.notify(
-          `[mega-compact] current tier: ${config.tier} (${config.thresholdTokens} tok)\n` +
-          `[mega-compact] available tiers: ${Object.entries(COMPACT_TIERS).map(([k, v]) => `${k}=${v}`).join(", ")}`,
-        );
-        return;
-      }
-      if (!(arg in COMPACT_TIERS)) {
-        ctx.ui.notify(`[mega-compact] unknown tier "${arg}". Available: ${Object.keys(COMPACT_TIERS).join(", ")}`);
-        return;
-      }
-      const newTier = arg as CompactTier;
-      setTier(config, newTier);
-      runtime.setStatus(ctx, `mega-compact: tier → ${newTier} (${config.thresholdTokens} tok)`);
-      ctx.ui.notify(`[mega-compact] tier changed to ${newTier} (threshold: ${config.thresholdTokens} tokens)`);
-      runtime.snapshot(ctx);
-    },
-  });
+  // NOTE: /mega-tier was removed in S24. The tier the user sees is now the LIVE
+  // pressure band (low/medium/high/ultra/mega), which climbs automatically as
+  // context fills — there is no manual tier to set. See docs/specs/s24-unified-pressure.md.
 }

package/extensions/mega-compact.test.ts

@@ -416,19 +416,22 @@ const TIER_CASES: Array<[string, number]> = [
   ["mega", 10_000_000],
 ];
 for (const [tier, threshold] of TIER_CASES) {
-  test(`tier "${tier}" resolves to a ${threshold}-token threshold`, async () => {
+  test(`tier "${tier}" resolves to a ${threshold}-token threshold (preset; live band shown separately)`, async () => {
     // Keep tier + keep threshold UNSET so the tier (not an explicit number)
     // drives the threshold. harness() would otherwise reset the threshold.
     delete process.env.MEGACOMPACT_THRESHOLD_TOKENS;
     process.env.MEGACOMPACT_TIER = tier;
     const h = harness({ keepTier: true, keepThreshold: true });
+    // tokens=1 against a 2M window → near-zero pressure → live band "low".
     const ctx = h.ctx({ getContextUsage: () => ({ tokens: 1, contextWindow: 2_000_000, percent: 0.01 }) });
     await h.commands["mega-status"].handler("", ctx);
     delete process.env.MEGACOMPACT_TIER;
     assert.ok(
-      h.notifies.some((n) => n.includes(`tier=${tier}`) && n.includes(`threshold=${threshold}`)),
-      `status should report tier=${tier} threshold=${threshold}`,
+      h.notifies.some((n) => n.includes(`preset=${tier}`) && n.includes(`threshold=${threshold}`)),
+      `status should report preset=${tier} threshold=${threshold}`,
     );
+    // S24: the headline tier is the LIVE pressure band, shown as "tier=low (live)".
+    assert.ok(h.notifies.some((n) => n.includes("tier=low (live)")), "live band reported (low at near-zero pressure)");
   });
 }
 
@@ -440,8 +443,8 @@ test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
   await h.commands["mega-status"].handler("", ctx);
   delete process.env.MEGACOMPACT_TIER;
   assert.ok(
-    h.notifies.some((n) => n.includes("tier=custom") && n.includes("threshold=777")),
-    "explicit threshold wins over tier (tier=custom)",
+    h.notifies.some((n) => n.includes("preset=custom") && n.includes("threshold=777")),
+    "explicit threshold wins over tier (preset=custom)",
   );
 });
 

package/extensions/mega-config.ts

@@ -25,8 +25,13 @@ export const COMPACT_TIERS = {
 } as const;
 export type CompactTier = keyof typeof COMPACT_TIERS;
 
-/** Resolved, frozen-at-load config. tier/thresholdTokens are mutated at
- *  runtime by /mega-tier via `setTier`. */
+/**
+ * Resolved, frozen-at-load config. `tier` is the base compaction PRESET chosen
+ * by env (low/medium/high/ultra/mega) — it sets the threshold token budget and
+ * is NOT changed at runtime (the /mega-tier command was removed in S24). The
+ * *displayed* tier the user sees in the toolbar/dashboard is the LIVE pressure
+ * band (see MegaRuntime.pressureBand), which climbs low→mega as context fills.
+ */
 export interface MegaConfig {
   tier: CompactTier | "custom";
   thresholdTokens: number;
@@ -97,11 +102,20 @@ function resolveThreshold(): { tier: CompactTier | "custom"; thresholdTokens: nu
 }
 
 /**
- * Pressure helpers for adaptive compression (Fix E) live in src/config.ts
- * (pi-agnostic) so unit tests can import them without the pi runtime. Re-export
- * here so the extension has one import surface.
+ * Pressure helpers for adaptive compression live in src/config.ts (pi-agnostic)
+ * so unit tests can import them without the pi runtime. Re-export here so the
+ * extension has one import surface. (S24 unified the previously percentage-only
+ * signal into pressureRatio/pressureBand, which the runtime uses as the single
+ * "how full" signal that drives the tier label, trim depth, and memory cadence.)
  */
-export { pressureFromPct, preserveRecentForPressure } from "../src/config.js";
+export {
+  pressureFromPct,
+  preserveRecentForPressure,
+  pressureRatio,
+  pressureBand,
+  memoryReviewCadence,
+  type PressureBand,
+} from "../src/config.js";
 
 /** Build the resolved config from env + defaults. */
 export function loadConfig(): MegaConfig {
@@ -132,11 +146,12 @@ export function loadConfig(): MegaConfig {
   };
 }
 
-/** Mutate tier + threshold in place (used by /mega-tier at runtime). */
-export function setTier(config: MegaConfig, tier: CompactTier): void {
-  config.tier = tier;
-  config.thresholdTokens = COMPACT_TIERS[tier];
-}
+/**
+ * Remove a cached tier mutation helper here — the live tier the user sees is the
+ * pressure band (MegaRuntime.pressureBand), and the base preset is env-resolved
+ * at load (loadConfig). The /mega-tier command was removed in S24 so there is no
+ * runtime tier mutation; see the S24 spec (docs/specs/s24-unified-pressure.md).
+ */
 
 /**
  * Resolve the current repo's git root from a cwd. Returns undefined for a

package/extensions/mega-dashboard.ts

@@ -19,7 +19,12 @@ import { existsSync, mkdirSync, writeFileSync, appendFileSync } from "node:fs";
 export interface DashboardSnapshot {
   version: 1;
   updatedAt: string;
+  /** Live pressure band (low/medium/high/ultra/mega) — climbs as context fills. */
   tier: string;
+  /** Base compaction preset from env (the S24-removed /mega-tier style selector). */
+  presetTier: string;
+  /** Live 0–1 pressure ratio (currentTokens / thresholdTokens). */
+  pressure: number;
   config: {
     fastGatePct: number;
     thresholdTokens: number;

package/extensions/mega-events.ts

@@ -17,7 +17,7 @@ import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop } from "./mega-
 import { recallMemoriesAndInline } from "../src/recall.js";
 import { driveNativeCompaction } from "./mega-compact-driver.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "./mega-trim.js";
-import { pressureFromPct, type MegaConfig } from "./mega-config.js";
+import { pressureFromPct, memoryReviewCadence, type MegaConfig } from "./mega-config.js";
 
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, config: MegaConfig): void {
@@ -164,25 +164,30 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
     runtime.snapshot(ctx);
 
-    // S20: auto-review the conversation every N turns and persist durable
-    // memories. Best-effort + non-fatal: a review failure must never break the
-    // agent loop. Debounced by memoryReviewInterval turns.
-    if (config.memoryAutoReview && runtime.currentTurn > 0 && runtime.currentTurn % config.memoryReviewInterval === 0) {
-      try {
-        const { reviewConversation } = await import("../src/memory.js");
-        const { applyMemoryOps } = await import("../src/memoryOps.js");
-        const entries = ctx.sessionManager.getEntries();
-        const view = runtime.engineView(entries.flatMap((e: any) => (e.message ? [e.message] : [])));
-        const ops = reviewConversation(view, []);
-        if (ops.length) {
-          await applyMemoryOps(ops, runtime.currentStateDir);
-          // S21.2: a memory op landed in this turn window. The pipeline reads
-          // this counter after a successful compaction and fires
-          // `consolidateMemories` only when it's > 0.
-          runtime.memoriesTouchedThisCompaction += ops.length;
+    // 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) {
+        try {
+          const { reviewConversation } = await import("../src/memory.js");
+          const { applyMemoryOps } = await import("../src/memoryOps.js");
+          const entries = ctx.sessionManager.getEntries();
+          const view = runtime.engineView(entries.flatMap((e: any) => (e.message ? [e.message] : [])));
+          const ops = reviewConversation(view, []);
+          if (ops.length) {
+            await applyMemoryOps(ops, runtime.currentStateDir);
+            // S21.2: a memory op landed in this turn window. The pipeline reads
+            // this counter after a successful compaction and fires
+            // `consolidateMemories` only when it's > 0.
+            runtime.memoriesTouchedThisCompaction += ops.length;
+          }
+        } catch {
+          /* non-fatal — auto-review must not break the turn loop */
         }
-      } catch {
-        /* non-fatal — auto-review must not break the turn loop */
       }
     }
   });

package/extensions/mega-pipeline.ts

@@ -175,6 +175,28 @@ function doCompact(
     }
   }
 
+  // S24 review-on-compact: when pressure is high, the just-compacted region is
+  // exactly the context worth remembering, so review it immediately rather than
+  // waiting for the next turn-cadence tick. Fire-and-forget (doCompact is sync):
+  // best-effort + non-fatal, paralleling the consolidate pass above. Only fires
+  // above the `high` band so low-pressure compactions don't pay the review cost.
+  if (!result.deduped && config.memoryAutoReview && runtime.pressureBand !== "low" && runtime.pressureBand !== "medium") {
+    void (async () => {
+      try {
+        const { reviewConversation } = await import("../src/memory.js");
+        const { applyMemoryOps } = await import("../src/memoryOps.js");
+        const ops = reviewConversation(view, []);
+        if (ops.length) {
+          await applyMemoryOps(ops, runtime.currentStateDir);
+          runtime.memoriesTouchedThisCompaction += ops.length;
+          runtime.pushTicker(`${C.green}🧠${C.reset} reviewed ${ops.length} memory op${ops.length === 1 ? "" : "s"} (pressure)`);
+        }
+      } catch {
+        /* non-fatal — review-on-compact must never break the compaction */
+      }
+    })();
+  }
+
   // 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, {

package/extensions/mega-runtime.ts

@@ -20,7 +20,7 @@ import { toEngineMessages } from "../src/adapt.js";
 import { normalizeSessionId } from "../src/store.js";
 import { Logger } from "../src/log.js";
 import { recordModelSnapshot, latestModelSnapshot, upsertRepoRegistry, recordRepoModel, type ModelSnapshot } from "../src/store/sqlite.js";
-import { repoStateDir, resolveRepoRoot, type MegaConfig } from "./mega-config.js";
+import { repoStateDir, resolveRepoRoot, pressureRatio, pressureFromPct, pressureBand, type MegaConfig, type PressureBand } from "./mega-config.js";
 import { Dashboard, type DashboardSnapshot } from "./mega-dashboard.js";
 
 export const STATUS_KEY = "mega-compact";
@@ -143,6 +143,26 @@ export class MegaRuntime {
   lastCtxPercent: number | null = null;
   lastCtxWindow = 0;
 
+  /**
+   * Live 0–1 pressure: how full the context window is relative to the compaction
+   * threshold. Computed from the most recent context event the runtime already
+   * tracks (token count when available — the direct signal — otherwise the usage
+   * percentage). This is the single "how full" number every subsystem reads; the
+   * toolbar/dashboard tier label is `pressureBand` over this, so it climbs
+   * low→mega as context rises (S24). Always finite + in [0,1].
+   */
+  get pressure(): number {
+    if (this.lastCtxTokens != null && this.lastCtxTokens > 0 && this.config.thresholdTokens > 0) {
+      return pressureRatio(this.lastCtxTokens, this.config.thresholdTokens);
+    }
+    return pressureFromPct(this.lastCtxPercent);
+  }
+
+  /** Live discrete pressure band (low/medium/high/ultra/mega) over `pressure`. */
+  get pressureBand(): PressureBand {
+    return pressureBand(this.pressure);
+  }
+
   constructor(config: MegaConfig) {
     this.config = config;
     this.store = new VectorStore({ dedupSim: config.dedupSim, stateDir: config.stateDir });
@@ -214,7 +234,11 @@ export class MegaRuntime {
     this.dashboard.snapshot({
       version: 1,
       updatedAt: new Date().toISOString(),
-      tier: this.config.tier,
+      // S24: the headline tier is the LIVE pressure band; the env preset is kept
+      // alongside as presetTier so the dashboard can show both.
+      tier: this.pressureBand,
+      presetTier: this.config.tier,
+      pressure: this.pressure,
       config: {
         fastGatePct: this.config.fastGatePct,
         thresholdTokens: this.config.thresholdTokens,
@@ -261,6 +285,11 @@ export class MegaRuntime {
       const tokStr = this.lastCtxTokens != null ? `${Math.round(this.lastCtxTokens / 1000)}k` : "?";
       const maxStr = this.lastCtxWindow > 0 ? `${Math.round(this.lastCtxWindow / 1000)}k` : "?";
       const pctStr = this.lastCtxPercent != null ? `${Math.round(this.lastCtxPercent * 10) / 10}%` : "?%";
+      // S24: the tier label is the LIVE pressure band (low/medium/high/ultra/
+      // mega), not the static env preset. It climbs as context fills, so the
+      // user can see the system react. The base preset is shown as a dim suffix.
+      const liveBand = this.pressureBand;
+      const tierLabel = `${C.bold}${liveBand}${C.reset}${C.gray}·${this.config.tier}${C.reset}`;
       const triggerLabel = ready ? `${C.green}● ready${C.reset}` : armed ? `${C.amber}◐ armed${C.reset}` : `${C.gray}○ idle${C.reset}`;
       // Storage dedup rate is cumulative (store-wide, per-repo) and survives
       // session resets. Always show a number: 0% before any compaction, a
@@ -283,7 +312,7 @@ export class MegaRuntime {
       // Phase 3 — pulsing status glyph while a compaction is in flight.
       const pulse = this.pulsing ? `${C.cyan}${PULSE[Math.floor(Date.now() / 250) % PULSE.length]}${C.reset} ` : "";
       const lines = [
-        ` ${C.amber}⚡ ${this.config.tier}${C.reset} v${C.bold}${ownVersion()}${C.reset} │ ${tokStr}/${maxStr} tokens (${C.bold}${pctStr}${C.reset}) │ ${st.checkpointCount} saved${agentStr}${turnStr}`,
+        ` ${C.amber}⚡ ${tierLabel}${C.reset} v${C.bold}${ownVersion()}${C.reset} │ ${tokStr}/${maxStr} tokens (${C.bold}${pctStr}${C.reset}) │ ${st.checkpointCount} saved${agentStr}${turnStr}`,
         `   ${triggerLabel} │ ${C.magenta}repeat-skipped: ${dedupStr}${C.reset} │ ${C.gray}memory held:${C.reset} ${usedStr} │ ${C.gray}space freed:${C.reset} ${savedStr}`,
       ];
       // Phase 3 — compact progress bar: session tokens saved toward the rolling goal.

package/package.json

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

package/src/config.ts

@@ -39,3 +39,64 @@ export function preserveRecentForPressure(
   const v = Math.round(preserveRecent - (preserveRecent - preserveRecentMin) * p);
   return Math.max(preserveRecentMin, Math.min(preserveRecent, v));
 }
+
+/**
+ * Discrete pressure band derived from the live 0–1 pressure ratio. This is the
+ * single signal every subsystem (tier label, trim depth, memory cadence)
+ * branches on, so context rising actually *moves* the dashboard/menu instead of
+ * sitting on a static env-resolved preset. (S24 — unified pressure signal.)
+ *
+ * Bands:
+ *   low    < 0.50   plenty of headroom — minimal trimming, infrequent review
+ *   medium 0.50–0.75
+ *   high   0.75–0.90
+ *   ultra  0.90–1.00
+ *   mega   >= 1.00  at/over threshold — deepest trim, most aggressive review
+ */
+export type PressureBand = "low" | "medium" | "high" | "ultra" | "mega";
+
+/** Clamp a pressure ratio into [0, 1]. */
+function clamp01(p: number): number {
+  if (!Number.isFinite(p)) return 0;
+  return p < 0 ? 0 : p > 1 ? 1 : p;
+}
+
+/**
+ * Pressure as a 0–1 ratio from live token usage relative to the compaction
+ * threshold. Cheaper + more direct than deriving from a usage percentage when
+ * we already have both numbers (the context handler does). Re-exports
+ * `pressureFromPct` covers the percentage-only path. (S24.)
+ */
+export function pressureRatio(currentTokens: number, thresholdTokens: number): number {
+  if (!Number.isFinite(currentTokens) || currentTokens <= 0) return 0;
+  const t = Number.isFinite(thresholdTokens) && thresholdTokens > 0 ? thresholdTokens : 0;
+  return clamp01(t > 0 ? currentTokens / t : 0);
+}
+
+/** Map a 0–1 pressure ratio to a discrete band. (S24.) */
+export function pressureBand(pressure: number): PressureBand {
+  const p = clamp01(pressure);
+  if (p >= 1.0) return "mega";
+  if (p >= 0.9) return "ultra";
+  if (p >= 0.75) return "high";
+  if (p >= 0.5) return "medium";
+  return "low";
+}
+
+/**
+ * Memory auto-review cadence (in turns) for a given pressure band. As pressure
+ * climbs, the conversation is reviewed more often so durable memories keep pace
+ * with the faster context churn. Returns a divisor used as
+ * `turn % cadence === 0`. Always >= 1. (S24 — memory cadence tie-in.)
+ */
+export function memoryReviewCadence(band: PressureBand, baseInterval: number): number {
+  const base = baseInterval >= 1 ? baseInterval : 1;
+  switch (band) {
+    case "mega": return Math.max(1, Math.round(base / 5));
+    case "ultra": return Math.max(1, Math.round(base / 3));
+    case "high": return Math.max(1, Math.round(base / 2));
+    case "medium": return Math.max(1, Math.round((base * 2) / 3));
+    case "low":
+    default: return base;
+  }
+}

package/src/memoryOps.test.ts

@@ -4,7 +4,14 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { applyMemoryOps } from "./memoryOps.js";
-import { addMemory, listMemories } from "./store/sqlite.js";
+import {
+  addMemory,
+  listMemories,
+  replaceMemory,
+  referenceMemory,
+  MEMORY_MAX_CHARS,
+  MEMORY_MAX_ROWS,
+} from "./store/sqlite.js";
 
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-memops-"));
 
@@ -48,6 +55,57 @@ test("applyMemoryOps: REMOVE deletes the matching memory", async () => {
   assert.ok(!rows.some((m) => /obsolete note/.test(m.content)), "removed");
 });
 
+test("S24: addMemory truncates content to MEMORY_MAX_CHARS", () => {
+  const dir = join(baseTmp, "cap");
+  const big = "x".repeat(MEMORY_MAX_CHARS + 5000);
+  const id = addMemory({ content: big, category: "note" }, null, dir);
+  const rows = listMemories(null, 50, dir);
+  const row = rows.find((m) => m.id === id);
+  assert.ok(row, "row present");
+  assert.ok(row!.content.length <= MEMORY_MAX_CHARS + 12, "content capped (incl. marker)");
+  assert.ok(row!.content.endsWith("…[truncated]"), "marker appended");
+});
+
+test("S24: replaceMemory also truncates oversized content", () => {
+  const dir = join(baseTmp, "capreplace");
+  const id = addMemory({ content: "short", category: "note" }, null, dir);
+  const big = "y".repeat(MEMORY_MAX_CHARS + 1000);
+  replaceMemory(id, { content: big }, dir);
+  const rows = listMemories(null, 50, dir);
+  const row = rows.find((m) => m.id === id);
+  assert.ok(row, "row present");
+  assert.ok(row!.content.length <= MEMORY_MAX_CHARS + 12, "replaced content capped");
+  assert.ok(row!.content.endsWith("…[truncated]"), "marker appended");
+});
+
+test("S24: addMemory evicts LRU rows past MEMORY_MAX_ROWS per repo", () => {
+  const dir = join(baseTmp, "lru");
+  const n = MEMORY_MAX_ROWS;
+  const seeds = n - 2;
+  for (let i = 0; i < seeds; i++) addMemory({ content: `seed-${i}`, category: "note" }, null, dir);
+  const keep1 = addMemory({ content: "keep-recent-1", category: "note" }, null, dir);
+  const keep2 = addMemory({ content: "keep-recent-2", category: "note" }, null, dir);
+  // Mark the two as referenced so the LRU eviction spares them (they get a
+  // higher last_referenced than the un-referenced seeds).
+  assert.ok(referenceMemory(keep1, dir), "reference keep1");
+  assert.ok(referenceMemory(keep2, dir), "reference keep2");
+  // Insert 3 more — 3 over the cap across the inserts. The two referenced rows
+  // must survive; only un-referenced (oldest) seeds should be evicted.
+  addMemory({ content: "new-1", category: "note" }, null, dir);
+  addMemory({ content: "new-2", category: "note" }, null, dir);
+  addMemory({ content: "new-3", category: "note" }, null, dir);
+  const rows = listMemories(null, 1000, dir);
+  assert.equal(rows.length, n, "row count clamped to MEMORY_MAX_ROWS");
+  assert.ok(rows.some((m) => /keep-recent-1/.test(m.content)), "referenced row survived");
+  assert.ok(rows.some((m) => /keep-recent-2/.test(m.content)), "referenced row survived");
+  assert.ok(rows.some((m) => /new-3/.test(m.content)), "newest row present");
+  const seedRows = rows.filter((m) => /seed-/.test(m.content));
+  // 3 rows were evicted (the inserts pushed 3 past the cap); all evicted rows
+  // must be un-referenced seeds — the referenced rows survived above.
+  assert.equal(seedRows.length, seeds - 3, "exactly 3 oldest un-referenced seeds evicted");
+  assert.ok(!seedRows.some((m) => /seed-0/.test(m.content)), "oldest un-referenced seed evicted");
+});
+
 test("cleanup memops", () => {
   rmSync(baseTmp, { recursive: true, force: true });
 });

package/src/store/compression.test.ts

@@ -139,3 +139,30 @@ test("pressureFromPct + preserveRecentForPressure scale with context (Fix E)", a
   assert.equal(preserveRecentForPressure(0.5, 4, 2), 3, "p=0.5 → interpolates");
   assert.ok(preserveRecentForPressure(1, 4, 2) >= 2, "never below floor");
 });
+
+test("S24: pressureRatio + pressureBand + memoryReviewCadence unify the signal", async () => {
+  const { pressureRatio, pressureBand, memoryReviewCadence } = await import("../config.js");
+  // pressureRatio: current/threshold, clamped to [0,1].
+  assert.equal(pressureRatio(50_000, 100_000), 0.5, "half threshold → 0.5");
+  assert.equal(pressureRatio(0, 100_000), 0, "no tokens → 0");
+  assert.equal(pressureRatio(10_000_000, 100_000), 1, "over threshold → clamped 1");
+  assert.equal(pressureRatio(50_000, 0), 0, "zero threshold → 0");
+  assert.equal(pressureRatio(NaN, 100_000), 0, "NaN current → 0");
+
+  // pressureBand: discrete bands drive the toolbar/dashboard tier label.
+  assert.equal(pressureBand(0.2), "low");
+  assert.equal(pressureBand(0.5), "medium");
+  assert.equal(pressureBand(0.75), "high");
+  assert.equal(pressureBand(0.9), "ultra");
+  assert.equal(pressureBand(1.0), "mega");
+  assert.equal(pressureBand(2.0), "mega", "over 1 → mega");
+  assert.equal(pressureBand(-1), "low", "below 0 → low");
+
+  // memoryReviewCadence: higher pressure → smaller (more frequent) divisor.
+  assert.equal(memoryReviewCadence("low", 10), 10, "low keeps base interval");
+  assert.equal(memoryReviewCadence("medium", 10), 7, "medium shortens");
+  assert.equal(memoryReviewCadence("high", 10), 5, "high halves");
+  assert.equal(memoryReviewCadence("ultra", 10), 3, "ultra shortens more");
+  assert.equal(memoryReviewCadence("mega", 10), 2, "mega near base/5");
+  assert.equal(memoryReviewCadence("high", 0), 1, "never below 1");
+});

package/src/store/sqlite.ts

@@ -713,6 +713,51 @@ export function addLesson(
 // One SQLite store for user-saved memories, scoped by repo. Mirrors the
 // lessons/sessions pattern: all state lives in SQLite from day one.
 
+// S24 storage hardening: keep each memory row bounded so the durable store can
+// never blow a downstream consumer's per-entry buffer (e.g. pi's native
+// file-backed memory caps a single entry at ~5k chars). We truncate content at
+// MEMORY_MAX_CHARS and evict the least-recently-referenced rows past
+// MEMORY_MAX_ROWS per repo via LRU. Both are SQLite-only (PREVENT-PI-004): no
+// file-backed memory is written anywhere.
+export const MEMORY_MAX_CHARS = 4000;
+export const MEMORY_MAX_ROWS = 200;
+
+/** Truncate memory content to the per-entry cap, preserving a trailing marker. */
+function capMemoryContent(content: string): string {
+  if (content.length <= MEMORY_MAX_CHARS) return content;
+  return content.slice(0, MEMORY_MAX_CHARS) + "…[truncated]";
+}
+
+/**
+ * Evict the least-recently-referenced rows for a repo past MEMORY_MAX_ROWS.
+ * LRU key = COALESCE(last_referenced, last_recalled_at, created_at) so a memory
+ * that is recalled/referenced survives over a stale one. Best-effort: any error
+ * is swallowed by the caller. Repo-scoped so one noisy repo can't evict another.
+ */
+function evictMemoryLru(repo: string | null, stateDir: string): void {
+  const db = openStore(stateDir);
+  // SQLite `= NULL` is never true, so the null-repo scope (memories are
+  // stateDir-scoped when repo is null — the applyMemoryOps path) needs `IS NULL`.
+  const where = repo == null ? "repo IS NULL" : "repo = ?";
+  const countRow = repo == null
+    ? db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get()
+    : db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get(repo);
+  const count = (countRow as { n: number }).n;
+  const over = count - MEMORY_MAX_ROWS;
+  if (over <= 0) return;
+  // Delete the `over` least-recently-used rows. ORDER BY the LRU key ASC, id ASC
+  // (id ASC breaks ties deterministically — oldest created first). The `where`
+  // clause is a code-controlled constant (never user input) → PREVENT-002 OK.
+  const sql =
+    `DELETE FROM memories WHERE ${where} AND id IN (
+       SELECT id FROM memories WHERE ${where}
+       ORDER BY COALESCE(last_referenced, last_recalled_at, created_at) ASC, id ASC
+       LIMIT ?
+     )`;
+  if (repo == null) db.prepare(sql).run(over);
+  else db.prepare(sql).run(repo, repo, over);
+}
+
 export interface MemoryRecord {
   id: number;
   repo: string | null;
@@ -727,7 +772,10 @@ export interface MemoryRecord {
   sourceTurn: number | null;
 }
 
-/** Save a memory to the current repo's store. Returns the new row id. */
+/** Save a memory to the current repo's store. Returns the new row id.
+ *  S24 hardening: content is truncated to MEMORY_MAX_CHARS and, once the per-repo
+ *  row count exceeds MEMORY_MAX_ROWS, the least-recently-used rows are evicted
+ *  (LRU) so the store stays bounded. */
 export function addMemory(
   memory: { kind?: string; content: string; tags?: string[]; category?: string; target?: string; sourceTurn?: number },
   repo: string | null,
@@ -743,13 +791,18 @@ export function addMemory(
     .run(
       repo ?? null,
       memory.kind ?? "note",
-      memory.content,
+      capMemoryContent(memory.content),
       JSON.stringify(memory.tags ?? []),
       now,
       memory.category ?? null,
       memory.target ?? null,
       memory.sourceTurn ?? null,
     );
+  try {
+    evictMemoryLru(repo, stateDir);
+  } catch {
+    /* non-fatal: eviction must never fail an add */
+  }
   return Number(res.lastInsertRowid);
 }
 
@@ -808,7 +861,7 @@ export function replaceMemory(
     )
     .run(
       patch.kind ?? null,
-      patch.content ?? null,
+      patch.content != null ? capMemoryContent(patch.content) : null,
       patch.tags ? JSON.stringify(patch.tags) : null,
       "category" in patch ? (patch.category ?? null) : null,
       "target" in patch ? (patch.target ?? null) : null,