pi-mega-compact 0.5.2 → 0.6.1

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.1` — 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,55 @@ 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)");
+});
+// ---- 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() {
+    const out = [];
+    for (let i = 0; i < 14; i++) {
+        out.push({ role: "user", content: `actually we decided to use approach ${i} for module ${i}`, timestamp: i });
+        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 });
+        out.push({ role: "toolResult", content: [{ type: "text", text: `edited module ${i}` }], toolCallId: `c${i}`, toolName: "Edit", isError: false, timestamp: i });
+    }
+    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 () => {

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

@@ -10,11 +10,11 @@ import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens } from "../src/tokens.js";
 import { 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 } 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,21 @@ 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");
+        // 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) => (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/dist/extensions/mega-pipeline.js

@@ -18,6 +18,35 @@ import { resolveRepoRoot, preserveRecentForPressure } from "./mega-config.js";
 import { runRaptor } from "../src/dedup/raptor/index.js";
 import { loadDedupConfig } from "../src/config/dedup.js";
 import { upsertEmbedding as indexUpsertEmbedding } from "../src/store/vectorIndex.js";
+/**
+ * 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, view, label) {
+    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, runtime, config, ctx, messages, opts = {}) {
     runtime.bindRepo(ctx.cwd);
@@ -133,6 +162,14 @@ 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. 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/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, } 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,78 @@ 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", () => {
+    // Use a small env cap for a fast, deterministic LRU check (the production
+    // default is 500; this exercises the same code path).
+    process.env.MEGACOMPACT_MEMORY_MAX_ROWS = "10";
+    try {
+        const dir = join(baseTmp, "lru");
+        const n = 10;
+        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");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_MEMORY_MAX_ROWS;
+    }
+});
+test("S24: MEGACOMPACT_MEMORY_MAX_CHARS env override truncates content", () => {
+    process.env.MEGACOMPACT_MEMORY_MAX_CHARS = "50";
+    try {
+        const dir = join(baseTmp, "cap-env");
+        const id = addMemory({ content: "x".repeat(500), category: "note" }, null, dir);
+        const rows = listMemories(null, 50, dir);
+        const row = rows.find((m) => m.id === id);
+        assert.ok(row, "row present");
+        assert.equal(row.content.length, 50 + "…[truncated]".length, "truncated to env cap + marker");
+        assert.ok(row.content.endsWith("…[truncated]"), "marker appended");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_MEMORY_MAX_CHARS;
+    }
+});
 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");
+});