pi-mega-compact 0.5.1 → 0.6.0

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;
+  }
+}

package/src/memoryOps.test.ts

@@ -4,7 +4,14 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { applyMemoryOps } from "./memoryOps.js";
-import { addMemory, listMemories } from "./store/sqlite.js";
+import {
+  addMemory,
+  listMemories,
+  replaceMemory,
+  referenceMemory,
+  MEMORY_MAX_CHARS,
+  MEMORY_MAX_ROWS,
+} from "./store/sqlite.js";
 
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-memops-"));
 
@@ -48,6 +55,57 @@ 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", () => {
+  const dir = join(baseTmp, "lru");
+  const n = MEMORY_MAX_ROWS;
+  const seeds = n - 2;
+  for (let i = 0; i < seeds; i++) addMemory({ content: `seed-${i}`, category: "note" }, null, dir);
+  const keep1 = addMemory({ content: "keep-recent-1", category: "note" }, null, dir);
+  const keep2 = addMemory({ content: "keep-recent-2", category: "note" }, null, dir);
+  // Mark the two as referenced so the LRU eviction spares them (they get a
+  // higher last_referenced than the un-referenced seeds).
+  assert.ok(referenceMemory(keep1, dir), "reference keep1");
+  assert.ok(referenceMemory(keep2, dir), "reference keep2");
+  // Insert 3 more — 3 over the cap across the inserts. The two referenced rows
+  // must survive; only un-referenced (oldest) seeds should be evicted.
+  addMemory({ content: "new-1", category: "note" }, null, dir);
+  addMemory({ content: "new-2", category: "note" }, null, dir);
+  addMemory({ content: "new-3", category: "note" }, null, dir);
+  const rows = listMemories(null, 1000, dir);
+  assert.equal(rows.length, n, "row count clamped to MEMORY_MAX_ROWS");
+  assert.ok(rows.some((m) => /keep-recent-1/.test(m.content)), "referenced row survived");
+  assert.ok(rows.some((m) => /keep-recent-2/.test(m.content)), "referenced row survived");
+  assert.ok(rows.some((m) => /new-3/.test(m.content)), "newest row present");
+  const seedRows = rows.filter((m) => /seed-/.test(m.content));
+  // 3 rows were evicted (the inserts pushed 3 past the cap); all evicted rows
+  // must be un-referenced seeds — the referenced rows survived above.
+  assert.equal(seedRows.length, seeds - 3, "exactly 3 oldest un-referenced seeds evicted");
+  assert.ok(!seedRows.some((m) => /seed-0/.test(m.content)), "oldest un-referenced seed evicted");
+});
+
 test("cleanup memops", () => {
   rmSync(baseTmp, { recursive: true, force: true });
 });

package/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,51 @@ 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.
+export const MEMORY_MAX_CHARS = 4000;
+export const MEMORY_MAX_ROWS = 200;
+
+/** Truncate memory content to the per-entry cap, preserving a trailing marker. */
+function capMemoryContent(content: string): string {
+  if (content.length <= MEMORY_MAX_CHARS) return content;
+  return content.slice(0, MEMORY_MAX_CHARS) + "…[truncated]";
+}
+
+/**
+ * Evict the least-recently-referenced rows for a repo past MEMORY_MAX_ROWS.
+ * LRU key = COALESCE(last_referenced, last_recalled_at, created_at) so a memory
+ * that is recalled/referenced survives over a stale one. Best-effort: any error
+ * is swallowed by the caller. Repo-scoped so one noisy repo can't evict another.
+ */
+function evictMemoryLru(repo: string | null, stateDir: string): void {
+  const db = openStore(stateDir);
+  // SQLite `= NULL` is never true, so the null-repo scope (memories are
+  // stateDir-scoped when repo is null — the applyMemoryOps path) needs `IS NULL`.
+  const where = repo == null ? "repo IS NULL" : "repo = ?";
+  const countRow = repo == null
+    ? db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get()
+    : db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get(repo);
+  const count = (countRow as { n: number }).n;
+  const over = count - MEMORY_MAX_ROWS;
+  if (over <= 0) return;
+  // Delete the `over` least-recently-used rows. ORDER BY the LRU key ASC, id ASC
+  // (id ASC breaks ties deterministically — oldest created first). The `where`
+  // clause is a code-controlled constant (never user input) → PREVENT-002 OK.
+  const sql =
+    `DELETE FROM memories WHERE ${where} AND id IN (
+       SELECT id FROM memories WHERE ${where}
+       ORDER BY COALESCE(last_referenced, last_recalled_at, created_at) ASC, id ASC
+       LIMIT ?
+     )`;
+  if (repo == null) db.prepare(sql).run(over);
+  else db.prepare(sql).run(repo, repo, over);
+}
+
 export interface MemoryRecord {
   id: number;
   repo: string | null;
@@ -727,7 +772,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 +791,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 +861,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,