pi-mega-compact 0.4.19 → 0.4.21

package/extensions/mega-runtime.ts

@@ -90,10 +90,7 @@ export class MegaRuntime {
   // on model_select + session_start; persisted to SQL so cost + the dashboard
   // can read it without a live ctx.
   currentModel: ModelSnapshot | undefined;
-  // Live "what it's doing right now" line for the toolbar. Set on each
-  // compaction; shown in teal while recent, then kept as the last-seen action so
-  // the widget is never blank. Cleared on session reset.
-  currentActivity: string | undefined;
+  // Live "what it's doing right now" timestamp, used for the fresh-window.
   lastActivityAt = 0;
   // Live per-tier dedup trace (Phase 1): e.g. "L0 ✓ → L1 ✓ → L2 0.91 → stored".
   // Built from the store's sync onTier callback during a compaction so the user
@@ -269,25 +266,25 @@ export class MegaRuntime {
         const bar = "▓".repeat(filled) + "░".repeat(10 - filled);
         lines.push(`   ${C.green}saved ${fmt(this.rt.tokensSaved)} ${bar}${C.reset} ${pct}% of ${fmt(goal)}`);
       }
-      // Live "now processing" line — teal while fresh (≤4s), then the last-seen
-      // action keeps the widget lively. Cleared on session reset.
+      // Live "now processing" line + why + recent deduped/compacted events,
+      // collapsed to ONE rotating line (fresh only). The ticker ring buffer
+      // (≤5 most-recent events) is cycled one-per-repaint so the line scrolls
+      // through recent files in real time while activity fires. We rotate on a
+      // 250ms step (same cadence as the pulse), using an event counter as the
+      // deterministic phase so consecutive repaints advance the visible entry.
       const fresh = Date.now() - this.lastActivityAt < 4000;
       if (this.tierTrace && fresh) {
         lines.push(`   ${pulse}${this.tierTrace}`);
-      } else if (this.currentActivity) {
-        lines.push(`   ${fresh ? C.teal : C.dim}${this.currentActivity}${C.reset}`);
+      } else if (this.ticker.length > 0) {
+        const step = Math.floor(Date.now() / 250);
+        const idx = this.ticker.length - 1 - (step % this.ticker.length);
+        const head = this.ticker[idx].text;
+        const why = this.lastWhy ? ` ${C.gray}· ${this.lastWhy}${C.reset}` : "";
+        const more = this.ticker.length > 1 ? ` ${C.dim}(+${this.ticker.length - 1} more)${C.reset}` : "";
+        lines.push(`   ${fresh ? C.teal : C.dim}${head}${why}${more}${C.reset}`);
       } else if (this.pulsing) {
         lines.push(`   ${pulse}${C.teal}compacting…${C.reset}`);
       }
-      // Phase 3 — explain-why line (fresh only).
-      if (this.lastWhy && fresh) lines.push(`   ${C.gray}${this.lastWhy}${C.reset}`);
-      // Phase 3 — recall/activity ticker (most-recent first), fresh only.
-      if (fresh) {
-        for (let i = this.ticker.length - 1; i >= 0; i--) {
-          if (lines.length >= 9) break; // leave room for the hint line (MAX 10)
-          lines.push(`   ${i === this.ticker.length - 1 ? "" : C.dim}${this.ticker[i].text}${C.reset}`);
-        }
-      }
       // Plain-language hint so first-time users understand the widget. Always
       // last, dimmed. "/mega-help explains these terms."
       if (lines.length < 10) {
@@ -318,7 +315,6 @@ export class MegaRuntime {
     this.statusKey = undefined;
     this.activeAgents = 0;
     this.currentTurn = 0;
-    this.currentActivity = undefined;
     this.lastActivityAt = 0;
     this.tierTrace = undefined;
     this.ticker.length = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.4.19",
+  "version": "0.4.21",
   "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/store/sqlite.ts

@@ -415,6 +415,20 @@ function initSchema(db: Database.Database): void {
       ts            INTEGER
     );
 
+    -- Durable "save to memory" store (taken over from memory extensions).
+    -- One row per saved memory; scoped by repo so memory travels with the
+    -- clone. All params are parameterized (PREVENT-002).
+    CREATE TABLE IF NOT EXISTS memories (
+      id                INTEGER PRIMARY KEY AUTOINCREMENT,
+      repo              TEXT,
+      kind              TEXT DEFAULT 'note',   -- note | fact | decision | preference
+      content           TEXT NOT NULL,
+      tags              TEXT,                   -- JSON array of strings
+      created_at        INTEGER,
+      last_recalled_at  INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_memories_repo ON memories(repo);
+
     -- FTS5 trigram virtual table (Sprint 9+ pg_trgm-equivalent verification).
     CREATE VIRTUAL TABLE IF NOT EXISTS context_chunks_trgm USING fts5(
       id UNINDEXED,
@@ -582,6 +596,76 @@ export function addLesson(
   ).run(normalizeSessionId(sessionId), repo ?? null, lesson, now);
 }
 
+// --- Durable memory (save-to-memory takeover) ---------------------------------
+// One SQLite store for user-saved memories, scoped by repo. Mirrors the
+// lessons/sessions pattern: all state lives in SQLite from day one.
+
+export interface MemoryRecord {
+  id: number;
+  repo: string | null;
+  kind: string;
+  content: string;
+  tags: string[];
+  createdAt: number;
+  lastRecalledAt: number | null;
+}
+
+/** Save a memory to the current repo's store. Returns the new row id. */
+export function addMemory(
+  memory: { kind?: string; content: string; tags?: string[] },
+  repo: string | null,
+  stateDir: string = getStateDir(),
+): number {
+  const db = openStore(stateDir);
+  const now = Math.floor(Date.now() / 1000);
+  const res = db
+    .prepare(
+      `INSERT INTO memories(repo, kind, content, tags, created_at, last_recalled_at)
+       VALUES(?, ?, ?, ?, ?, NULL)`,
+    )
+    .run(repo ?? null, memory.kind ?? "note", memory.content, JSON.stringify(memory.tags ?? []), now);
+  return Number(res.lastInsertRowid);
+}
+
+/** List recent memories for a repo (or all repos when repo is null). */
+export function listMemories(repo: string | null, limit = 50, stateDir: string = getStateDir()): MemoryRecord[] {
+  const db = openStore(stateDir);
+  const rows = repo
+    ? db.prepare("SELECT * FROM memories WHERE repo = ? ORDER BY created_at DESC LIMIT ?").all(repo, limit)
+    : db.prepare("SELECT * FROM memories ORDER BY created_at DESC LIMIT ?").all(limit);
+  return (rows as any[]).map(mapMemoryRow);
+}
+
+/** Substring search across content + tags. */
+export function searchMemories(query: string, repo: string | null = null, limit = 50, stateDir: string = getStateDir()): MemoryRecord[] {
+  const db = openStore(stateDir);
+  const like = `%${query}%`;
+  const rows = repo
+    ? db.prepare("SELECT * FROM memories WHERE repo = ? AND (content LIKE ? OR tags LIKE ?) ORDER BY created_at DESC LIMIT ?").all(repo, like, like, limit)
+    : db.prepare("SELECT * FROM memories WHERE content LIKE ? OR tags LIKE ? ORDER BY created_at DESC LIMIT ?").all(like, like, limit);
+  return (rows as any[]).map(mapMemoryRow);
+}
+
+/** Mark a memory as recalled (updates last_recalled_at). Returns true if found. */
+export function recallMemory(id: number, stateDir: string = getStateDir()): boolean {
+  const db = openStore(stateDir);
+  const now = Math.floor(Date.now() / 1000);
+  const res = db.prepare("UPDATE memories SET last_recalled_at = ? WHERE id = ?").run(now, id);
+  return res.changes > 0;
+}
+
+function mapMemoryRow(row: any): MemoryRecord {
+  return {
+    id: row.id,
+    repo: row.repo ?? null,
+    kind: row.kind ?? "note",
+    content: row.content ?? "",
+    tags: row.tags ? JSON.parse(row.tags) : [],
+    createdAt: row.created_at ?? 0,
+    lastRecalledAt: row.last_recalled_at ?? null,
+  };
+}
+
 /** Map a DB row to the public StoredCheckpoint shape. */
 function rowToCheckpoint(row: any): StoredCheckpoint {
   return {