pi-mega-compact 0.6.0 → 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.6.0` — 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

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

@@ -408,6 +408,54 @@ test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
     delete process.env.MEGACOMPACT_TIER;
     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 () => {
     // Private base so this asserts "no server" on a range nothing else uses,

package/dist/extensions/mega-events.js

@@ -10,7 +10,7 @@ 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";
@@ -166,23 +166,13 @@ export function registerEventHandlers(pi, runtime, config) {
         if (config.memoryAutoReview && runtime.currentTurn > 0) {
             const cadence = memoryReviewCadence(runtime.pressureBand, config.memoryReviewInterval);
             if (runtime.currentTurn % cadence === 0) {
-                try {
-                    const { reviewConversation } = await import("../src/memory.js");
-                    const { applyMemoryOps } = await import("../src/memoryOps.js");
-                    const entries = ctx.sessionManager.getEntries();
-                    const view = runtime.engineView(entries.flatMap((e) => (e.message ? [e.message] : [])));
-                    const ops = reviewConversation(view, []);
-                    if (ops.length) {
-                        await applyMemoryOps(ops, runtime.currentStateDir);
-                        // S21.2: a memory op landed in this turn window. The pipeline reads
-                        // this counter after a successful compaction and fires
-                        // `consolidateMemories` only when it's > 0.
-                        runtime.memoriesTouchedThisCompaction += ops.length;
-                    }
-                }
-                catch {
-                    /* non-fatal — auto-review must not break the turn loop */
-                }
+                // 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] : [])));
+                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);
@@ -135,25 +164,11 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     }
     // 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.
+    // 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 (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 */
-            }
-        })();
+        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).

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, replaceMemory, referenceMemory, MEMORY_MAX_CHARS, MEMORY_MAX_ROWS, } 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");
@@ -58,32 +58,55 @@ test("S24: replaceMemory also truncates oversized content", () => {
     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");
+    // 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/sqlite.js

@@ -581,14 +581,32 @@ export function addLesson(sessionId, repo, lesson, stateDir = getStateDir()) {
 // 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.
+// 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 = 200;
+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) {
-    if (content.length <= MEMORY_MAX_CHARS)
+    const cap = memoryMaxChars();
+    if (content.length <= cap)
         return content;
-    return content.slice(0, MEMORY_MAX_CHARS) + "…[truncated]";
+    return content.slice(0, cap) + "…[truncated]";
 }
 /**
  * Evict the least-recently-referenced rows for a repo past MEMORY_MAX_ROWS.
@@ -598,6 +616,7 @@ function capMemoryContent(content) {
  */
 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 = ?";
@@ -605,7 +624,7 @@ function evictMemoryLru(repo, stateDir) {
         ? 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;
+    const over = count - maxRows;
     if (over <= 0)
         return;
     // Delete the `over` least-recently-used rows. ORDER BY the LRU key ASC, id ASC

package/extensions/mega-compact.test.ts

@@ -448,6 +448,56 @@ test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
   );
 });
 
+// ---- 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-events.ts

@@ -13,7 +13,7 @@ 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";
@@ -172,22 +172,13 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     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 */
-        }
+        // 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] : [])));
+        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,
@@ -177,24 +210,11 @@ 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.
+  // 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 (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 */
-      }
-    })();
+    void runMemoryReview(runtime, view, "pressure");
   }
 
   // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.6.0",
+  "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/memoryOps.test.ts

@@ -10,7 +10,6 @@ import {
   replaceMemory,
   referenceMemory,
   MEMORY_MAX_CHARS,
-  MEMORY_MAX_ROWS,
 } from "./store/sqlite.js";
 
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-memops-"));
@@ -79,31 +78,53 @@ test("S24: replaceMemory also truncates oversized content", () => {
 });
 
 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");
+  // 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", () => {

package/src/store/sqlite.ts

@@ -718,14 +718,34 @@ export function addLesson(
 // 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.
+// 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 = 200;
+export const MEMORY_MAX_ROWS = 500;
+
+/** Read an env override as a positive int, falling back to `fallback`. */
+function envInt(name: string, fallback: number): number {
+  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(): number {
+  return envInt("MEGACOMPACT_MEMORY_MAX_CHARS", MEMORY_MAX_CHARS);
+}
+
+/** Effective per-repo row cap (env-overridable, default MEMORY_MAX_ROWS). */
+export function memoryMaxRows(): number {
+  return envInt("MEGACOMPACT_MEMORY_MAX_ROWS", MEMORY_MAX_ROWS);
+}
 
 /** Truncate memory content to the per-entry cap, preserving a trailing marker. */
 function capMemoryContent(content: string): string {
-  if (content.length <= MEMORY_MAX_CHARS) return content;
-  return content.slice(0, MEMORY_MAX_CHARS) + "…[truncated]";
+  const cap = memoryMaxChars();
+  if (content.length <= cap) return content;
+  return content.slice(0, cap) + "…[truncated]";
 }
 
 /**
@@ -736,6 +756,7 @@ function capMemoryContent(content: string): string {
  */
 function evictMemoryLru(repo: string | null, stateDir: string): void {
   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 = ?";
@@ -743,7 +764,7 @@ function evictMemoryLru(repo: string | null, stateDir: string): void {
     ? db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get()
     : db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get(repo);
   const count = (countRow as { n: number }).n;
-  const over = count - MEMORY_MAX_ROWS;
+  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`