pi-mega-compact 0.5.1 → 0.6.0

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.
@@ -292,7 +321,10 @@ export class MegaRuntime {
         const pct = Math.min(100, Math.round((this.rt.tokensSaved / goal) * 100));
         const filled = Math.round((pct / 100) * 10);
         const bar = "▓".repeat(filled) + "░".repeat(10 - filled);
-        lines.push(`   ${C.green}saved ${fmt(this.rt.tokensSaved)} ${bar}${C.reset} ${pct}% of ${fmt(goal)}`);
+        // Session tokens saved, with the repo-wide total held alongside so the
+        // bar reads "saved X of goal" and the right side shows saved vs total.
+        const totalHeld = st.totalTokenEstimate > 0 ? st.totalTokenEstimate : repo.totalTokenEstimate;
+        lines.push(`   ${C.green}saved ${fmt(this.rt.tokensSaved)} ${bar}${C.reset} ${pct}% of ${fmt(goal)} ${C.gray}│${C.reset} ${C.blue}${fmt(this.rt.tokensSaved)}${C.reset}/${C.blue}${fmt(totalHeld)}${C.reset} tok held`);
       }
       // Live "now processing" line + why + recent deduped/compacted events,
       // collapsed to ONE rotating line (fresh only). The ticker ring buffer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.5.1",
+  "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",