pi-mega-compact 0.5.2 → 0.6.1

package/dist/src/store/sqlite.js

@@ -573,14 +573,90 @@ 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. Defaults are overridable via env
+// (MEGACOMPACT_MEMORY_MAX_CHARS / MEGACOMPACT_MEMORY_MAX_ROWS).
+export const MEMORY_MAX_CHARS = 4000;
+export const MEMORY_MAX_ROWS = 500;
+/** Read an env override as a positive int, falling back to `fallback`. */
+function envInt(name, fallback) {
+    const v = process.env[name];
+    if (v == null || v === "")
+        return fallback;
+    const n = Number(v);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+/** Effective per-entry char cap (env-overridable, default MEMORY_MAX_CHARS). */
+export function memoryMaxChars() {
+    return envInt("MEGACOMPACT_MEMORY_MAX_CHARS", MEMORY_MAX_CHARS);
+}
+/** Effective per-repo row cap (env-overridable, default MEMORY_MAX_ROWS). */
+export function memoryMaxRows() {
+    return envInt("MEGACOMPACT_MEMORY_MAX_ROWS", MEMORY_MAX_ROWS);
+}
+/** Truncate memory content to the per-entry cap, preserving a trailing marker. */
+function capMemoryContent(content) {
+    const cap = memoryMaxChars();
+    if (content.length <= cap)
+        return content;
+    return content.slice(0, cap) + "…[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);
+    const maxRows = memoryMaxRows();
+    // 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 - maxRows;
+    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 +702,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,11 +443,61 @@ 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)",
   );
 });
 
+// ---- S24: memory review tied to pressure / compaction -----------------------
+// Build a decision-bearing session large enough to guarantee a real (non-skipped,
+// non-deduped) compaction. Each user turn contains a decision phrase
+// (/\bactually\b/i, /\bwe (?:use|decided)\b/i) so reviewConversation yields ops.
+function decisionSession(): AgentMessage[] {
+  const out: AgentMessage[] = [];
+  for (let i = 0; i < 14; i++) {
+    out.push({ role: "user", content: `actually we decided to use approach ${i} for module ${i}`, timestamp: i } as unknown as AgentMessage);
+    out.push({ role: "assistant", content: [{ type: "toolCall", name: "Edit", id: `c${i}`, arguments: {} }], api: "anthropic-messages", provider: "anthropic", model: "m", usage: { inputTokens: 1, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 }, stopReason: "tool_use", timestamp: i } as unknown as AgentMessage);
+    out.push({ role: "toolResult", content: [{ type: "text", text: `edited module ${i}` }], toolCallId: `c${i}`, toolName: "Edit", isError: false, timestamp: i } as unknown as AgentMessage);
+  }
+  return out;
+}
+
+test("S24: high pressure triggers a memory review on compaction", async () => {
+  const h = harness();
+  // Force a real (non-legacy) compaction at full pressure → pressureBand "mega",
+  // which must fire the shared runMemoryReview on compact (review-on-compact).
+  process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM = "false";
+  try {
+    const messages = decisionSession();
+    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+    await h.fire("context", { type: "context", messages }, ctx);
+    // review-on-compact runs as a fire-and-forget async (doCompact is sync), so
+    // let the microtask/macrotask queue drain before asserting the side effect.
+    await new Promise((r) => setTimeout(r, 20));
+    const { listMemories, listCheckpoints } = await import("../src/store/sqlite.js");
+    // A checkpoint must have been persisted (proves compaction ran, not skipped).
+    assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "checkpoint persisted to local vector db");
+    // The just-compacted region is worth remembering, so durable memories must
+    // have been written to the SQLite store (review-on-compact path).
+    const mem = listMemories(null, 50, h.stateDir);
+    assert.ok(mem.length > 0, "memory review wrote durable memories on compact");
+  } finally {
+    delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+  }
+});
+
+test("S24: /mega-status reports the live pressure band + %", async () => {
+  const h = harness();
+  // Populate the runtime's live context first (a context event sets
+  // lastCtxTokens/lastCtxPercent), then read /mega-status. At 100% usage the live
+  // band must read "mega" and pressure must report 100%.
+  const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+  await h.fire("context", { type: "context", messages: h.session }, ctx);
+  await h.commands["mega-status"].handler("", ctx);
+  assert.ok(h.notifies.some((n) => n.includes("tier=mega (live)")), "live band reported as mega at 100% pressure");
+  assert.ok(h.notifies.some((n) => n.includes("pressure=100%")), "live pressure % reported");
+});
+
 // ---- /dashboard commands ----------------------------------------------------
 test("/dashboard-status reports no server when pid file missing", async () => {
   // Private base so this asserts "no server" on a range nothing else uses,

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

@@ -13,11 +13,11 @@ import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens } from "../src/tokens.js";
 import { MegaRuntime, recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
-import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop } from "./mega-pipeline.js";
+import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop, runMemoryReview } from "./mega-pipeline.js";
 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,21 @@ 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");
+    // 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) {
+        // S20+S24: review the conversation and persist durable memories. The
+        // cadence scales with pressure (memoryReviewCadence): as context fills,
+        // the conversation is reviewed more often so memories keep pace with
+        // faster churn. Shared runMemoryReview body (also used on compact).
         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 */
+        await runMemoryReview(runtime, view, "turn");
       }
     }
   });

package/extensions/mega-pipeline.ts

@@ -31,6 +31,39 @@ export type RunCompactResult =
   | { skipped: true }
   | { skipped: false; result: ReturnType<typeof compactSession>; keepFrom: number; saved: number };
 
+/**
+ * Review the live conversation and persist durable memories (S20+S24). Shared by
+ * the pressure-scaled turn-end cadence (mega-events.ts) AND review-on-compact
+ * (below) so both paths run the identical review body. Best-effort + non-fatal:
+ * a review failure is swallowed and never breaks the caller. On success, the
+ * number of applied ops is returned so callers can feed the consolidation gate.
+ *
+ * @param view the engine message view to review (caller builds it)
+ * @param label a short source tag for the ticker line (e.g. "pressure" / "turn")
+ */
+export async function runMemoryReview(
+  runtime: MegaRuntime,
+  view: ReturnType<MegaRuntime["engineView"]>,
+  label: string,
+): Promise<number> {
+  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);
+      // S21.2: ops landed — the compaction path reads this counter and fires
+      // `consolidateMemories` only when > 0.
+      runtime.memoriesTouchedThisCompaction += ops.length;
+      runtime.pushTicker(`${C.green}🧠${C.reset} reviewed ${ops.length} memory op${ops.length === 1 ? "" : "s"} (${label})`);
+    }
+    return ops.length;
+  } catch {
+    /* non-fatal — auto-review must never break the turn loop / compaction */
+    return 0;
+  }
+}
+
 /** Run the full compaction pipeline and persist a checkpoint. Returns the result. */
 export function runCompact(
   pi: ExtensionAPI,
@@ -175,6 +208,15 @@ 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. Uses the shared runMemoryReview
+  // helper (fire-and-forget; doCompact is sync). Best-effort + non-fatal. Only
+  // fires above the `high` band so low-pressure compactions don't pay the cost.
+  if (!result.deduped && config.memoryAutoReview && runtime.pressureBand !== "low" && runtime.pressureBand !== "medium") {
+    void runMemoryReview(runtime, view, "pressure");
+  }
+
   // 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.1",
   "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;
+  }
+}