pi-mega-compact 0.4.20 → 0.4.21

package/dist/extensions/conflict-scan.js

@@ -0,0 +1,201 @@
+/**
+ * conflict-scan.ts — detect other installed pi extensions that overlap with
+ * pi-mega-compact's two owned responsibilities:
+ *
+ *   1. Conversation auto-compaction (we hook session_before_compact).
+ *   2. Durable "save to memory" (we now keep a `memories` table in our SQLite).
+ *
+ * This is a DETECT-AND-WARN scanner only. pi has no pre-load / veto hook — one
+ * extension cannot block another from loading — so we inspect the installed
+ * package set at startup and on demand, then report overlaps. No config is
+ * mutated. (See memory `pi-memory-mcp-review` for the original conflict pattern.)
+ *
+ * Pi-agnostic: reads package.json + greps source. No pi runtime types, so it is
+ * unit-testable against a fixture node_modules tree.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+// Marker sets. A package is flagged when its source matches a marker in a
+// category. File-grep (not AST) keeps this dependency-free and fast.
+const MARKERS = {
+    // Directly competes with our conversation compaction.
+    compaction: [
+        "session_before_compact",
+        "session_compact",
+        "compactSession",
+        "autoCompact",
+        "auto_compact",
+    ],
+    // Saves durable memory to its own store — the takeover target.
+    memory: [
+        "MEMORY_TOOL",
+        "learn-memory",
+        "saveMemory",
+        "memoryPolicy",
+        "wal_checkpoint",
+        "store/db.ts",
+        "memoryTool",
+    ],
+    // Tool-output shaping (compact/summarize tool results) — overlap, not a rival.
+    toolOutput: [
+        "tool_result",
+        "ToolResult",
+    ],
+};
+/** Resolve the node_modules dir that contains this package (or env override). */
+export function resolveExtensionRoot(selfDir = dirname(fileURLToPath(import.meta.url))) {
+    const override = process.env.MEGACOMPACT_EXT_SCAN_DIR;
+    if (override && override.trim() !== "")
+        return override;
+    // selfDir is <root>/extensions or <root>/dist/extensions. Walk up to the
+    // node_modules that holds pi-mega-compact.
+    let dir = selfDir;
+    for (let i = 0; i < 6; i++) {
+        const candidate = join(dir, "node_modules");
+        if (existsSync(candidate) && existsSync(join(candidate, "pi-mega-compact")))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Recursively collect source-ish files under a package, capped to avoid scans. */
+function collectFiles(root, max = 400) {
+    const out = [];
+    const walk = (dir) => {
+        if (out.length >= max)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (out.length >= max)
+                return;
+            const full = join(dir, e);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (e === "node_modules" || e === ".git")
+                    continue;
+                walk(full);
+            }
+            else if (/\.(ts|js|mjs|cjs|json|md)$/.test(e)) {
+                out.push(full);
+            }
+        }
+    };
+    walk(root);
+    return out;
+}
+/** Grep a package's source for any marker in `keys`; return matched markers. */
+function matchMarkers(pkgDir, keys) {
+    const found = new Set();
+    let files;
+    try {
+        files = collectFiles(pkgDir);
+    }
+    catch {
+        return [];
+    }
+    for (const f of files) {
+        let text;
+        try {
+            text = readFileSync(f, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        for (const m of keys) {
+            if (text.includes(m))
+                found.add(m);
+        }
+        if (found.size === keys.length)
+            break;
+    }
+    return [...found];
+}
+/**
+ * Scan installed extensions for overlaps with pi-mega-compact.
+ * @param selfName package name to skip (defaults to this package's name).
+ */
+export function detectConflicts(selfName = "pi-mega-compact") {
+    const root = resolveExtensionRoot();
+    const scanned = [];
+    const conflicts = [];
+    if (!root || !existsSync(root))
+        return { scanned, conflicts };
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return { scanned, conflicts };
+    }
+    for (const name of entries) {
+        const pkgDir = join(root, name);
+        if (!statSync(pkgDir).isDirectory())
+            continue;
+        const pkgJson = join(pkgDir, "package.json");
+        if (!existsSync(pkgJson))
+            continue;
+        let pkg;
+        try {
+            pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+        }
+        catch {
+            continue;
+        }
+        const pkgName = pkg.name ?? name;
+        if (pkgName === selfName)
+            continue;
+        // Only consider packages that declare pi extensions.
+        if (!pkg.pi || !Array.isArray(pkg.pi.extensions) || pkg.pi.extensions.length === 0)
+            continue;
+        scanned.push(pkgName);
+        const memHits = matchMarkers(pkgDir, MARKERS.memory);
+        const compHits = matchMarkers(pkgDir, MARKERS.compaction);
+        const toolHits = matchMarkers(pkgDir, MARKERS.toolOutput);
+        if (compHits.length > 0) {
+            conflicts.push({
+                package: pkgName,
+                severity: "high",
+                kind: "compaction",
+                evidence: compHits,
+                recommendation: "Disabling recommended — competes with pi-mega-compact's conversation compaction.",
+            });
+            continue; // compaction is the dominant conflict; don't double-flag.
+        }
+        if (memHits.length > 0) {
+            conflicts.push({
+                package: pkgName,
+                severity: "high",
+                kind: "memory",
+                evidence: memHits,
+                recommendation: "pi-mega-compact now owns save-to-memory (/mega-memory, its own SQLite). Disable this to avoid duplicate memory stores.",
+            });
+            continue;
+        }
+        if (toolHits.length > 0) {
+            conflicts.push({
+                package: pkgName,
+                severity: "info",
+                kind: "tool-output",
+                evidence: toolHits,
+                recommendation: "Shapes tool output (summarize/compact tool results). Generally compatible; no action needed.",
+            });
+        }
+    }
+    return { scanned, conflicts };
+}

package/dist/extensions/mega-compact.js

@@ -29,10 +29,12 @@ import { MegaRuntime } from "./mega-runtime.js";
 import { registerEventHandlers } from "./mega-events.js";
 import { registerCommands } from "./mega-commands.js";
 import { registerDashboardCommands } from "./mega-dashboard-cmds.js";
+import { registerConflictCommands } from "./mega-conflict-cmds.js";
 export default function (pi) {
     const config = loadConfig();
     const runtime = new MegaRuntime(config);
     registerEventHandlers(pi, runtime, config);
     registerCommands(pi, runtime, config);
     registerDashboardCommands(pi, runtime);
+    registerConflictCommands(pi, runtime);
 }

package/dist/extensions/mega-conflict-cmds.js

@@ -0,0 +1,121 @@
+/**
+ * mega-conflict-cmds.ts — extension conflict validator + save-to-memory command.
+ *
+ * Detects other installed extensions that overlap with pi-mega-compact
+ * (conversation compaction, or save-to-memory) and WARNs — pi has no pre-load
+ * veto hook, so this is detect-and-warn only. Also registers /mega-memory, our
+ * own durable memory store in SQLite (the takeover of memory extensions).
+ */
+import { detectConflicts } from "./conflict-scan.js";
+import { addMemory, listMemories, searchMemories, recallMemory } from "../src/store/sqlite.js";
+import { resolveRepoRoot } from "./mega-config.js";
+/** Run the conflict scan and format a human-readable report. */
+export function validateExtensions() {
+    const report = detectConflicts();
+    const lines = [];
+    if (report.conflicts.length === 0) {
+        lines.push(`[mega-compact] conflict check: ${report.scanned.length} extensions scanned, no overlaps.`);
+        return { report, lines };
+    }
+    const high = report.conflicts.filter((c) => c.severity === "high");
+    lines.push(`[mega-compact] conflict check: ${report.scanned.length} scanned, ${report.conflicts.length} overlap(s), ${high.length} high-severity.`);
+    for (const c of report.conflicts) {
+        const tag = c.severity === "high" ? "⚠ HIGH" : "ℹ info";
+        lines.push(`  ${tag} ${c.package} — ${c.kind} — ${c.recommendation}`);
+    }
+    return { report, lines };
+}
+/** Run the scan at activation and surface a one-line warning if needed. */
+export function runLoadTimeConflictCheck() {
+    try {
+        const { lines } = validateExtensions();
+        const high = lines.filter((l) => l.includes("⚠ HIGH"));
+        if (high.length > 0) {
+            // Non-fatal: just inform on stderr; the dashboard/commands carry details.
+            console.warn(lines.join("\n"));
+        }
+    }
+    catch {
+        /* best-effort; never block session load */
+    }
+}
+function memoryLine(m) {
+    const tags = m.tags.length ? ` [${m.tags.join(", ")}]` : "";
+    const snap = m.content.length > 80 ? m.content.slice(0, 77) + "…" : m.content;
+    return `#${m.id} (${m.kind})${tags}: ${snap}`;
+}
+/** Register conflict-check + memory commands. */
+export function registerConflictCommands(pi, runtime) {
+    runLoadTimeConflictCheck();
+    pi.registerCommand("mega-compat-check", {
+        description: "Scan installed extensions for overlaps with pi-mega-compact (compaction / save-to-memory) and warn.",
+        handler: async (_args, ctx) => {
+            const { lines } = validateExtensions();
+            for (const l of lines)
+                ctx.ui.notify(l);
+            if (lines.length === 1) {
+                ctx.ui.notify("[mega-compact] You own compaction + memory; no conflicting extensions detected.");
+            }
+        },
+    });
+    pi.registerCommand("mega-memory", {
+        description: "Save and recall durable memory in pi-mega-compact's SQLite store. Usage: /mega-memory save <text> | list | search <q> | recall <id>",
+        handler: async (args, ctx) => {
+            const repo = resolveRepoRoot(ctx.cwd) ?? runtime.currentStateDir;
+            const parts = args.trim().split(/\s+/);
+            const sub = parts[0]?.toLowerCase() ?? "list";
+            if (sub === "save") {
+                const text = args.trim().slice(4).trim();
+                if (!text) {
+                    ctx.ui.notify("[mega-memory] usage: /mega-memory save <text>");
+                    return;
+                }
+                // Optional "#tag #tag" parsing from the tail.
+                const tagMatches = [...text.matchAll(/#([\w-]+)/g)].map((m) => m[1]);
+                const content = text.replace(/#[\w-]+/g, "").trim();
+                const id = addMemory({ content, tags: tagMatches }, repo, runtime.currentStateDir);
+                ctx.ui.notify(`[mega-memory] saved #${id} to ${repo.split(/[\\/]/).pop()}`);
+                return;
+            }
+            if (sub === "search") {
+                const q = parts.slice(1).join(" ").trim();
+                if (!q) {
+                    ctx.ui.notify("[mega-memory] usage: /mega-memory search <query>");
+                    return;
+                }
+                const hits = searchMemories(q, repo, 50, runtime.currentStateDir);
+                if (!hits.length) {
+                    ctx.ui.notify("[mega-memory] no memories match.");
+                    return;
+                }
+                for (const m of hits)
+                    ctx.ui.notify(memoryLine(m));
+                return;
+            }
+            if (sub === "recall") {
+                const id = Number(parts[1]);
+                if (!Number.isFinite(id) || parts[1] === undefined) {
+                    ctx.ui.notify("[mega-memory] usage: /mega-memory recall <id>");
+                    return;
+                }
+                if (recallMemory(id, runtime.currentStateDir)) {
+                    const found = listMemories(repo, 1000, runtime.currentStateDir).find((m) => m.id === id);
+                    ctx.ui.notify(found ? `[mega-memory] ${memoryLine(found)}` : `[mega-memory] recalled #${id}`);
+                }
+                else {
+                    ctx.ui.notify(`[mega-memory] #${id} not found.`);
+                }
+                return;
+            }
+            // default: list
+            const all = listMemories(repo, 50, runtime.currentStateDir);
+            if (!all.length) {
+                ctx.ui.notify("[mega-memory] no saved memories yet. Use /mega-memory save <text>.");
+                return;
+            }
+            ctx.ui.notify(`[mega-memory] ${all.length} saved to ${repo.split(/[\\/]/).pop()}:`);
+            for (const m of all)
+                ctx.ui.notify(memoryLine(m));
+        },
+    });
+}

package/dist/extensions/mega-pipeline.js

@@ -56,15 +56,13 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
     // denominator (we don't want it pinned at 100% once we pass an old target).
     if (runtime.rt.tokensSaved > runtime.savedGoal)
         runtime.savedGoal = Math.ceil((runtime.rt.tokensSaved * 1.25) / 10_000) * 10_000;
-    // Live toolbar "now processing" line: what file/region just got compacted or
-    // deduped. Reset to the last-seen action after a few seconds (see snapshot).
+    // Live toolbar activity: what file/region just got compacted or deduped.
+    // Rendered via the rotating ticker line (see snapshot); the ring buffer is
+    // cycled one-per-repaint so the single line scrolls through recent files.
     const files = result.filesModified ?? [];
     const fileLabel = files.length
         ? files.map((f) => f.split("/").pop() ?? f).slice(0, 2).join(", ")
         : result.regionHash.slice(0, 8);
-    runtime.currentActivity = result.deduped
-        ? `♻ deduped ${fileLabel}`
-        : `🗜 compacted ${result.checkpointId} · ${fileLabel}`;
     runtime.lastActivityAt = Date.now();
     // Explain-why line: surfaced while fresh. Pulls the dedup reason (which for
     // L2 includes the cosine sim) so the user sees WHY a region was kept/dropped.

package/dist/extensions/mega-runtime.js

@@ -68,10 +68,7 @@ export class MegaRuntime {
     // on model_select + session_start; persisted to SQL so cost + the dashboard
     // can read it without a live ctx.
     currentModel;
-    // 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;
+    // 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
@@ -243,29 +240,27 @@ 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) {
@@ -295,7 +290,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/dist/src/store/sqlite.js

@@ -359,6 +359,20 @@ function initSchema(db) {
       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,
@@ -476,6 +490,51 @@ export function addLesson(sessionId, repo, lesson, stateDir = getStateDir()) {
     const now = Math.floor(Date.now() / 1000);
     db.prepare(`INSERT INTO lessons(session_id, repo, lesson, ts) VALUES(?, ?, ?, ?)`).run(normalizeSessionId(sessionId), repo ?? null, lesson, now);
 }
+/** Save a memory to the current repo's store. Returns the new row id. */
+export function addMemory(memory, repo, stateDir = getStateDir()) {
+    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, limit = 50, stateDir = getStateDir()) {
+    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.map(mapMemoryRow);
+}
+/** Substring search across content + tags. */
+export function searchMemories(query, repo = null, limit = 50, stateDir = getStateDir()) {
+    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.map(mapMemoryRow);
+}
+/** Mark a memory as recalled (updates last_recalled_at). Returns true if found. */
+export function recallMemory(id, stateDir = getStateDir()) {
+    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) {
+    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) {
     return {

package/extensions/conflict-scan.ts

@@ -0,0 +1,209 @@
+/**
+ * conflict-scan.ts — detect other installed pi extensions that overlap with
+ * pi-mega-compact's two owned responsibilities:
+ *
+ *   1. Conversation auto-compaction (we hook session_before_compact).
+ *   2. Durable "save to memory" (we now keep a `memories` table in our SQLite).
+ *
+ * This is a DETECT-AND-WARN scanner only. pi has no pre-load / veto hook — one
+ * extension cannot block another from loading — so we inspect the installed
+ * package set at startup and on demand, then report overlaps. No config is
+ * mutated. (See memory `pi-memory-mcp-review` for the original conflict pattern.)
+ *
+ * Pi-agnostic: reads package.json + greps source. No pi runtime types, so it is
+ * unit-testable against a fixture node_modules tree.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export type ConflictKind = "compaction" | "memory" | "tool-output";
+export type ConflictSeverity = "high" | "info";
+
+export interface ConflictHit {
+  package: string;
+  severity: ConflictSeverity;
+  kind: ConflictKind;
+  evidence: string[];
+  /** One-line recommended action for the user. */
+  recommendation: string;
+}
+
+export interface ConflictReport {
+  scanned: string[];
+  conflicts: ConflictHit[];
+}
+
+// Marker sets. A package is flagged when its source matches a marker in a
+// category. File-grep (not AST) keeps this dependency-free and fast.
+const MARKERS = {
+  // Directly competes with our conversation compaction.
+  compaction: [
+    "session_before_compact",
+    "session_compact",
+    "compactSession",
+    "autoCompact",
+    "auto_compact",
+  ],
+  // Saves durable memory to its own store — the takeover target.
+  memory: [
+    "MEMORY_TOOL",
+    "learn-memory",
+    "saveMemory",
+    "memoryPolicy",
+    "wal_checkpoint",
+    "store/db.ts",
+    "memoryTool",
+  ],
+  // Tool-output shaping (compact/summarize tool results) — overlap, not a rival.
+  toolOutput: [
+    "tool_result",
+    "ToolResult",
+  ],
+} as const;
+
+/** Resolve the node_modules dir that contains this package (or env override). */
+export function resolveExtensionRoot(selfDir: string = dirname(fileURLToPath(import.meta.url))): string | null {
+  const override = process.env.MEGACOMPACT_EXT_SCAN_DIR;
+  if (override && override.trim() !== "") return override;
+  // selfDir is <root>/extensions or <root>/dist/extensions. Walk up to the
+  // node_modules that holds pi-mega-compact.
+  let dir = selfDir;
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, "node_modules");
+    if (existsSync(candidate) && existsSync(join(candidate, "pi-mega-compact"))) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/** Recursively collect source-ish files under a package, capped to avoid scans. */
+function collectFiles(root: string, max = 400): string[] {
+  const out: string[] = [];
+  const walk = (dir: string): void => {
+    if (out.length >= max) return;
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (out.length >= max) return;
+      const full = join(dir, e);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        if (e === "node_modules" || e === ".git") continue;
+        walk(full);
+      } else if (/\.(ts|js|mjs|cjs|json|md)$/.test(e)) {
+        out.push(full);
+      }
+    }
+  };
+  walk(root);
+  return out;
+}
+
+/** Grep a package's source for any marker in `keys`; return matched markers. */
+function matchMarkers(pkgDir: string, keys: readonly string[]): string[] {
+  const found = new Set<string>();
+  let files: string[];
+  try {
+    files = collectFiles(pkgDir);
+  } catch {
+    return [];
+  }
+  for (const f of files) {
+    let text: string;
+    try {
+      text = readFileSync(f, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const m of keys) {
+      if (text.includes(m)) found.add(m);
+    }
+    if (found.size === keys.length) break;
+  }
+  return [...found];
+}
+
+/**
+ * Scan installed extensions for overlaps with pi-mega-compact.
+ * @param selfName package name to skip (defaults to this package's name).
+ */
+export function detectConflicts(selfName = "pi-mega-compact"): ConflictReport {
+  const root = resolveExtensionRoot();
+  const scanned: string[] = [];
+  const conflicts: ConflictHit[] = [];
+  if (!root || !existsSync(root)) return { scanned, conflicts };
+
+  let entries: string[];
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return { scanned, conflicts };
+  }
+
+  for (const name of entries) {
+    const pkgDir = join(root, name);
+    if (!statSync(pkgDir).isDirectory()) continue;
+    const pkgJson = join(pkgDir, "package.json");
+    if (!existsSync(pkgJson)) continue;
+    let pkg: { name?: string; pi?: { extensions?: string[] } };
+    try {
+      pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+    } catch {
+      continue;
+    }
+    const pkgName = pkg.name ?? name;
+    if (pkgName === selfName) continue;
+    // Only consider packages that declare pi extensions.
+    if (!pkg.pi || !Array.isArray(pkg.pi.extensions) || pkg.pi.extensions.length === 0) continue;
+    scanned.push(pkgName);
+
+    const memHits = matchMarkers(pkgDir, MARKERS.memory);
+    const compHits = matchMarkers(pkgDir, MARKERS.compaction);
+    const toolHits = matchMarkers(pkgDir, MARKERS.toolOutput);
+
+    if (compHits.length > 0) {
+      conflicts.push({
+        package: pkgName,
+        severity: "high",
+        kind: "compaction",
+        evidence: compHits,
+        recommendation: "Disabling recommended — competes with pi-mega-compact's conversation compaction.",
+      });
+      continue; // compaction is the dominant conflict; don't double-flag.
+    }
+    if (memHits.length > 0) {
+      conflicts.push({
+        package: pkgName,
+        severity: "high",
+        kind: "memory",
+        evidence: memHits,
+        recommendation: "pi-mega-compact now owns save-to-memory (/mega-memory, its own SQLite). Disable this to avoid duplicate memory stores.",
+      });
+      continue;
+    }
+    if (toolHits.length > 0) {
+      conflicts.push({
+        package: pkgName,
+        severity: "info",
+        kind: "tool-output",
+        evidence: toolHits,
+        recommendation: "Shapes tool output (summarize/compact tool results). Generally compatible; no action needed.",
+      });
+    }
+  }
+
+  return { scanned, conflicts };
+}

package/extensions/mega-compact.ts

@@ -31,6 +31,7 @@ import { MegaRuntime } from "./mega-runtime.js";
 import { registerEventHandlers } from "./mega-events.js";
 import { registerCommands } from "./mega-commands.js";
 import { registerDashboardCommands } from "./mega-dashboard-cmds.js";
+import { registerConflictCommands } from "./mega-conflict-cmds.js";
 
 export default function (pi: ExtensionAPI) {
   const config = loadConfig();
@@ -38,4 +39,5 @@ export default function (pi: ExtensionAPI) {
   registerEventHandlers(pi, runtime, config);
   registerCommands(pi, runtime, config);
   registerDashboardCommands(pi, runtime);
+  registerConflictCommands(pi, runtime);
 }

package/extensions/mega-conflict-cmds.ts

@@ -0,0 +1,129 @@
+/**
+ * mega-conflict-cmds.ts — extension conflict validator + save-to-memory command.
+ *
+ * Detects other installed extensions that overlap with pi-mega-compact
+ * (conversation compaction, or save-to-memory) and WARNs — pi has no pre-load
+ * veto hook, so this is detect-and-warn only. Also registers /mega-memory, our
+ * own durable memory store in SQLite (the takeover of memory extensions).
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { detectConflicts, type ConflictReport } from "./conflict-scan.js";
+import { addMemory, listMemories, searchMemories, recallMemory, type MemoryRecord } from "../src/store/sqlite.js";
+import { resolveRepoRoot } from "./mega-config.js";
+import { MegaRuntime } from "./mega-runtime.js";
+
+/** Run the conflict scan and format a human-readable report. */
+export function validateExtensions(): { report: ConflictReport; lines: string[] } {
+  const report = detectConflicts();
+  const lines: string[] = [];
+  if (report.conflicts.length === 0) {
+    lines.push(`[mega-compact] conflict check: ${report.scanned.length} extensions scanned, no overlaps.`);
+    return { report, lines };
+  }
+  const high = report.conflicts.filter((c) => c.severity === "high");
+  lines.push(`[mega-compact] conflict check: ${report.scanned.length} scanned, ${report.conflicts.length} overlap(s), ${high.length} high-severity.`);
+  for (const c of report.conflicts) {
+    const tag = c.severity === "high" ? "⚠ HIGH" : "ℹ info";
+    lines.push(`  ${tag} ${c.package} — ${c.kind} — ${c.recommendation}`);
+  }
+  return { report, lines };
+}
+
+/** Run the scan at activation and surface a one-line warning if needed. */
+export function runLoadTimeConflictCheck(): void {
+  try {
+    const { lines } = validateExtensions();
+    const high = lines.filter((l) => l.includes("⚠ HIGH"));
+    if (high.length > 0) {
+      // Non-fatal: just inform on stderr; the dashboard/commands carry details.
+      console.warn(lines.join("\n"));
+    }
+  } catch {
+    /* best-effort; never block session load */
+  }
+}
+
+function memoryLine(m: MemoryRecord): string {
+  const tags = m.tags.length ? ` [${m.tags.join(", ")}]` : "";
+  const snap = m.content.length > 80 ? m.content.slice(0, 77) + "…" : m.content;
+  return `#${m.id} (${m.kind})${tags}: ${snap}`;
+}
+
+/** Register conflict-check + memory commands. */
+export function registerConflictCommands(pi: ExtensionAPI, runtime: MegaRuntime): void {
+  runLoadTimeConflictCheck();
+
+  pi.registerCommand("mega-compat-check", {
+    description: "Scan installed extensions for overlaps with pi-mega-compact (compaction / save-to-memory) and warn.",
+    handler: async (_args: string, ctx: ExtensionContext) => {
+      const { lines } = validateExtensions();
+      for (const l of lines) ctx.ui.notify(l);
+      if (lines.length === 1) {
+        ctx.ui.notify("[mega-compact] You own compaction + memory; no conflicting extensions detected.");
+      }
+    },
+  });
+
+  pi.registerCommand("mega-memory", {
+    description: "Save and recall durable memory in pi-mega-compact's SQLite store. Usage: /mega-memory save <text> | list | search <q> | recall <id>",
+    handler: async (args: string, ctx: ExtensionContext) => {
+      const repo = resolveRepoRoot(ctx.cwd) ?? runtime.currentStateDir;
+      const parts = args.trim().split(/\s+/);
+      const sub = parts[0]?.toLowerCase() ?? "list";
+
+      if (sub === "save") {
+        const text = args.trim().slice(4).trim();
+        if (!text) {
+          ctx.ui.notify("[mega-memory] usage: /mega-memory save <text>");
+          return;
+        }
+        // Optional "#tag #tag" parsing from the tail.
+        const tagMatches = [...text.matchAll(/#([\w-]+)/g)].map((m) => m[1]);
+        const content = text.replace(/#[\w-]+/g, "").trim();
+        const id = addMemory({ content, tags: tagMatches }, repo, runtime.currentStateDir);
+        ctx.ui.notify(`[mega-memory] saved #${id} to ${repo.split(/[\\/]/).pop()}`);
+        return;
+      }
+
+      if (sub === "search") {
+        const q = parts.slice(1).join(" ").trim();
+        if (!q) {
+          ctx.ui.notify("[mega-memory] usage: /mega-memory search <query>");
+          return;
+        }
+        const hits = searchMemories(q, repo, 50, runtime.currentStateDir);
+        if (!hits.length) {
+          ctx.ui.notify("[mega-memory] no memories match.");
+          return;
+        }
+        for (const m of hits) ctx.ui.notify(memoryLine(m));
+        return;
+      }
+
+      if (sub === "recall") {
+        const id = Number(parts[1]);
+        if (!Number.isFinite(id) || parts[1] === undefined) {
+          ctx.ui.notify("[mega-memory] usage: /mega-memory recall <id>");
+          return;
+        }
+        if (recallMemory(id, runtime.currentStateDir)) {
+          const found = listMemories(repo, 1000, runtime.currentStateDir).find((m) => m.id === id);
+          ctx.ui.notify(found ? `[mega-memory] ${memoryLine(found)}` : `[mega-memory] recalled #${id}`);
+        } else {
+          ctx.ui.notify(`[mega-memory] #${id} not found.`);
+        }
+        return;
+      }
+
+      // default: list
+      const all = listMemories(repo, 50, runtime.currentStateDir);
+      if (!all.length) {
+        ctx.ui.notify("[mega-memory] no saved memories yet. Use /mega-memory save <text>.");
+        return;
+      }
+      ctx.ui.notify(`[mega-memory] ${all.length} saved to ${repo.split(/[\\/]/).pop()}:`);
+      for (const m of all) ctx.ui.notify(memoryLine(m));
+    },
+  });
+}

package/extensions/mega-pipeline.ts

@@ -78,15 +78,13 @@ export function runCompact(
   // denominator (we don't want it pinned at 100% once we pass an old target).
   if (runtime.rt.tokensSaved > runtime.savedGoal) runtime.savedGoal = Math.ceil((runtime.rt.tokensSaved * 1.25) / 10_000) * 10_000;
 
-  // Live toolbar "now processing" line: what file/region just got compacted or
-  // deduped. Reset to the last-seen action after a few seconds (see snapshot).
+  // Live toolbar activity: what file/region just got compacted or deduped.
+  // Rendered via the rotating ticker line (see snapshot); the ring buffer is
+  // cycled one-per-repaint so the single line scrolls through recent files.
   const files = result.filesModified ?? [];
   const fileLabel = files.length
     ? files.map((f) => f.split("/").pop() ?? f).slice(0, 2).join(", ")
     : result.regionHash.slice(0, 8);
-  runtime.currentActivity = result.deduped
-    ? `♻ deduped ${fileLabel}`
-    : `🗜 compacted ${result.checkpointId} · ${fileLabel}`;
   runtime.lastActivityAt = Date.now();
   // Explain-why line: surfaced while fresh. Pulls the dedup reason (which for
   // L2 includes the cosine sim) so the user sees WHY a region was kept/dropped.

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.20",
+  "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 {