pi-mega-compact 0.5.2 → 0.6.1

package/src/memoryOps.test.ts

@@ -4,7 +4,13 @@ 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-"));
 
@@ -48,6 +54,79 @@ test("applyMemoryOps: REMOVE deletes the matching memory", async () => {
   assert.ok(!rows.some((m) => /obsolete note/.test(m.content)), "removed");
 });
 
+test("S24: addMemory truncates content to MEMORY_MAX_CHARS", () => {
+  const dir = join(baseTmp, "cap");
+  const big = "x".repeat(MEMORY_MAX_CHARS + 5000);
+  const id = addMemory({ content: big, category: "note" }, null, dir);
+  const rows = listMemories(null, 50, dir);
+  const row = rows.find((m) => m.id === id);
+  assert.ok(row, "row present");
+  assert.ok(row!.content.length <= MEMORY_MAX_CHARS + 12, "content capped (incl. marker)");
+  assert.ok(row!.content.endsWith("…[truncated]"), "marker appended");
+});
+
+test("S24: replaceMemory also truncates oversized content", () => {
+  const dir = join(baseTmp, "capreplace");
+  const id = addMemory({ content: "short", category: "note" }, null, dir);
+  const big = "y".repeat(MEMORY_MAX_CHARS + 1000);
+  replaceMemory(id, { content: big }, dir);
+  const rows = listMemories(null, 50, dir);
+  const row = rows.find((m) => m.id === id);
+  assert.ok(row, "row present");
+  assert.ok(row!.content.length <= MEMORY_MAX_CHARS + 12, "replaced content capped");
+  assert.ok(row!.content.endsWith("…[truncated]"), "marker appended");
+});
+
+test("S24: addMemory evicts LRU rows past MEMORY_MAX_ROWS per repo", () => {
+  // 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/src/store/compression.test.ts

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

package/src/store/sqlite.ts

@@ -713,6 +713,72 @@ export function addLesson(
 // One SQLite store for user-saved memories, scoped by repo. Mirrors the
 // lessons/sessions pattern: all state lives in SQLite from day one.
 
+// S24 storage hardening: keep each memory row bounded so the durable store can
+// never blow a downstream consumer's per-entry buffer (e.g. pi's native
+// file-backed memory caps a single entry at ~5k chars). We truncate content at
+// MEMORY_MAX_CHARS and evict the least-recently-referenced rows past
+// MEMORY_MAX_ROWS per repo via LRU. Both are SQLite-only (PREVENT-PI-004): no
+// file-backed memory is written anywhere. 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: 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 {
+  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: 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 = ?";
+  const countRow = repo == null
+    ? db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get()
+    : db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get(repo);
+  const count = (countRow as { n: number }).n;
+  const over = count - 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);
+}
+
 export interface MemoryRecord {
   id: number;
   repo: string | null;
@@ -727,7 +793,10 @@ export interface MemoryRecord {
   sourceTurn: number | null;
 }
 
-/** Save a memory to the current repo's store. Returns the new row id. */
+/** Save a memory to the current repo's store. Returns the new row id.
+ *  S24 hardening: content is truncated to MEMORY_MAX_CHARS and, once the per-repo
+ *  row count exceeds MEMORY_MAX_ROWS, the least-recently-used rows are evicted
+ *  (LRU) so the store stays bounded. */
 export function addMemory(
   memory: { kind?: string; content: string; tags?: string[]; category?: string; target?: string; sourceTurn?: number },
   repo: string | null,
@@ -743,13 +812,18 @@ export function addMemory(
     .run(
       repo ?? null,
       memory.kind ?? "note",
-      memory.content,
+      capMemoryContent(memory.content),
       JSON.stringify(memory.tags ?? []),
       now,
       memory.category ?? null,
       memory.target ?? null,
       memory.sourceTurn ?? null,
     );
+  try {
+    evictMemoryLru(repo, stateDir);
+  } catch {
+    /* non-fatal: eviction must never fail an add */
+  }
   return Number(res.lastInsertRowid);
 }
 
@@ -808,7 +882,7 @@ export function replaceMemory(
     )
     .run(
       patch.kind ?? null,
-      patch.content ?? null,
+      patch.content != null ? capMemoryContent(patch.content) : null,
       patch.tags ? JSON.stringify(patch.tags) : null,
       "category" in patch ? (patch.category ?? null) : null,
       "target" in patch ? (patch.target ?? null) : null,