pi-mega-compact 0.4.19 → 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/dashboard-server.js

@@ -13,7 +13,8 @@
 import { createServer } from "node:http";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, watch, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import Database from "better-sqlite3";
 // --- Multi-repo index (Phase 5b) ------------------------------------------------
 // The extension writes a machine-wide repo registry into a single SQLite DB
@@ -46,7 +47,7 @@ function readIndex() {
         const rows = db
             .prepare("SELECT * FROM repo_registry ORDER BY last_seen DESC")
             .all();
-        const repos = rows.map((r) => ({
+        const mapped = rows.map((r) => ({
             repoRoot: String(r.repo_root ?? ""),
             displayName: String(r.display_name ?? ""),
             checkpointCount: Number(r.checkpoint_count ?? 0),
@@ -60,6 +61,23 @@ function readIndex() {
             outputRate: r.output_rate ?? null,
             lastSeen: Number(r.last_seen ?? 0),
         }));
+        // Defensive display hygiene (belt-and-suspenders — the real fix is that
+        // tests now isolate via MEGACOMPACT_INDEX_DIR): drop transient test/temp
+        // paths that should never have been real repos, and collapse duplicate
+        // display names to the most-recently-seen row (rows are last_seen DESC, so
+        // the first occurrence wins). Keeps the All-repos list readable.
+        const isTransient = (p) => /^\/tmp\//.test(p) || /^\/private\/tmp\//.test(p) || /^\/var\/folders\//.test(p) ||
+            /\/mc-(ext|e2e|resume|recall)-/.test(p);
+        const seenName = new Set();
+        const repos = [];
+        for (const r of mapped) {
+            if (isTransient(r.repoRoot))
+                continue;
+            if (seenName.has(r.displayName))
+                continue;
+            seenName.add(r.displayName);
+            repos.push(r);
+        }
         const summary = {
             totalRepos: repos.length,
             totalCheckpoints: repos.reduce((a, r) => a + r.checkpointCount, 0),
@@ -634,6 +652,26 @@ function dashboardHtml(tierName) {
 // Server
 // ---------------------------------------------------------------------------
 export function launchDashboardServer(stateDir) {
+    // Our own package version — exposed at /api/version so the launcher can
+    // detect a stale server (started by an older build) and replace it on
+    // upgrade instead of reuse it.
+    let SERVER_VERSION = "0.0.0";
+    try {
+        // dashboard-server.js lives at <pkg>/dist/extensions/, so package.json is
+        // two levels up. Guard each candidate so a dev-checkout layout still works.
+        const here = dirname(fileURLToPath(import.meta.url));
+        const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
+        for (const p of candidates) {
+            if (!existsSync(p))
+                continue;
+            const pkg = JSON.parse(readFileSync(p, "utf-8"));
+            if (pkg.version) {
+                SERVER_VERSION = pkg.version;
+                break;
+            }
+        }
+    }
+    catch { /* non-fatal */ }
     const portFile = join(stateDir, "port.pid");
     const snapshotPath = join(stateDir, "dashboard.json");
     const eventsPath = join(stateDir, "events.log");
@@ -674,6 +712,13 @@ export function launchDashboardServer(stateDir) {
             res.end(JSON.stringify(snap));
             return;
         }
+        // Server version — lets the /dashboard launcher detect a stale server from
+        // an older build and replace it on upgrade rather than reuse it.
+        if (req.url === "/api/version") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ version: SERVER_VERSION }));
+            return;
+        }
         // Multi-repo aggregate (Phase 5b): the machine-wide repo registry read
         // directly from SQLite (index.sqlite). Lets one dashboard show every repo's
         // checkpoints, tokens saved, and active model. Read-only.

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-compact.test.js

@@ -19,6 +19,9 @@ import { join } from "node:path";
 import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-ext-"));
+// Isolate the machine-wide repo index so test runs (which call bindRepo ->
+// upsertRepoRegistry) never pollute the developer's real ~/.mega-compact-index.
+process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
 let counter = 0;
 /** Build a mock pi + ctx and load the extension into them. */
 function harness(opts = {}) {
@@ -268,13 +271,14 @@ test("/dashboard-stop reports no server when pid file missing", async () => {
 test("/dashboard skips server spawn when already running", async () => {
     const h = harness();
     const confirms = [];
-    // Set up a fake HTTP server at a random port
+    // Set up a fake HTTP server on a port inside the dashboard's scan range
+    // (9320–9329) — isServerRunning() probes those ports, not the port.pid value.
     const { createServer } = await import("node:http");
     const server = createServer((_req, res) => {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test", version: 1, config: {}, session: {}, context: {}, trigger: {}, store: {} }));
     });
-    await new Promise((r) => server.listen(0, "127.0.0.1", r));
+    await new Promise((r) => server.listen(9320, "127.0.0.1", r));
     const addr = server.address();
     const { join: j } = await import("node:path");
     const { writeFileSync: wf } = await import("node:fs");
@@ -295,7 +299,8 @@ test("/dashboard skips server spawn when already running", async () => {
 });
 test("/dashboard-status reports running after dashboard start", async () => {
     const h = harness();
-    // Write a fake port.pid with a real port (use a server we control)
+    // Write a fake port.pid; the server must listen inside the scan range
+    // (9320–9329) or isServerRunning() won't detect it.
     const { createServer } = await import("node:http");
     const { join: j } = await import("node:path");
     const { writeFileSync: wf } = await import("node:fs");
@@ -303,7 +308,7 @@ test("/dashboard-status reports running after dashboard start", async () => {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test" }));
     });
-    await new Promise((r) => server.listen(0, "127.0.0.1", r));
+    await new Promise((r) => server.listen(9321, "127.0.0.1", r));
     const addr = server.address();
     wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: addr.port, pid: process.pid }));
     const ctx = h.ctx();

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-dashboard-cmds.js

@@ -32,7 +32,10 @@ export function registerDashboardCommands(pi, runtime) {
         }
         return null;
     }
-    /** Try to reach a running dashboard server. Returns { port, url } or null. */
+    /** Try to reach a running dashboard server. Returns details or null.
+     *  `hasPidFile` tells the caller whether this server was launched by us
+     *  (port.pid present) — a live server with NO pid file is an orphan from an
+     *  older/detached spawn that we should replace rather than reuse. */
     async function isServerRunning() {
         const port = await findLivePort();
         if (!port) {
@@ -45,7 +48,68 @@ export function registerDashboardCommands(pi, runtime) {
             }
             return null;
         }
-        return { port, url: `http://localhost:${port}` }; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
+        return { port, url: `http://localhost:${port}`, hasPidFile: existsSync(portFile) }; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
+    }
+    /** Version the running server on `port` reports, or null. */
+    async function serverVersion(port) {
+        try {
+            const res = await fetch(`http://localhost:${port}/api/version`, { signal: AbortSignal.timeout(800) }); // guardrails-allow PREVENT-PI-004: localhost version probe of the dashboard server this extension spawned
+            if (!res.ok)
+                return null;
+            const j = await res.json();
+            return j.version ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Version of THIS extension (read from its own package.json). */
+    function ownVersion() {
+        try {
+            const here = dirname(fileURLToPath(import.meta.url)); // .../extensions
+            const pkg = JSON.parse(readFileSync(join(here, "..", "package.json"), "utf-8"));
+            return pkg.version ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** PID listening on 127.0.0.1:port (our own server), or null. Uses `ss`
+     *  (Linux/macOS) — best-effort, returns null if unavailable. */
+    function pidOnPort(port) {
+        try {
+            const { execSync } = require("node:child_process"); // guardrails-allow PREVENT-PI-004: localhost-only, reads our own dashboard port owner
+            const out = execSync(`ss -ltnp 2>/dev/null | grep ':${port} '`, { encoding: "utf-8" });
+            const m = out.match(/pid=(\d+)/);
+            return m ? Number(m[1]) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Kill a running dashboard server (best-effort): read the pid from port.pid,
+     *  or — when there's no marker (an orphan) — from the port owner. Then remove
+     *  the marker so the next spawn starts fresh. */
+    function killServerOnPort(port) {
+        let pid = null;
+        try {
+            const info = JSON.parse(readFileSync(portFile, "utf-8"));
+            if (info && info.pid)
+                pid = info.pid;
+        }
+        catch { /* no marker */ }
+        if (pid == null)
+            pid = pidOnPort(port); // orphan with no pid.pid
+        if (pid != null) {
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch { /* already gone */ }
+        }
+        try {
+            unlinkSync(portFile);
+        }
+        catch { /* ignore */ }
     }
     /**
      * Resolve the launchable dashboard-server module.
@@ -119,11 +183,29 @@ export function registerDashboardCommands(pi, runtime) {
             runtime.bindRepo(ctx.cwd);
             let info = await isServerRunning();
             if (info) {
-                ctx.ui.notify(`[mega-compact] dashboard already running at ${info.url}`);
-                const open = await ctx.ui.confirm("mega-compact dashboard", `Open ${info.url} in browser?`);
-                if (open)
-                    openBrowser(info.url);
-                return;
+                // Replace the server when it's stale: either (a) an orphan — a live
+                // server with no port.pid (e.g. left running from a detached spawn or a
+                // previous upgrade) that keeps serving old HTML from memory; or (b) a
+                // server that reports a different version than this extension (an older
+                // build). A live server WITH a matching pid file and version is reused.
+                const orphan = !info.hasPidFile;
+                const running = await serverVersion(info.port);
+                const want = ownVersion();
+                const stale = orphan || (want != null && running != null && running !== want);
+                if (stale) {
+                    ctx.ui.notify(orphan
+                        ? "[mega-compact] replacing orphaned dashboard server…"
+                        : `[mega-compact] replacing stale dashboard (${running} → ${want})…`);
+                    killServerOnPort(info.port);
+                    info = null;
+                }
+                else {
+                    ctx.ui.notify(`[mega-compact] dashboard already running at ${info.url}`);
+                    const open = await ctx.ui.confirm("mega-compact dashboard", `Open ${info.url} in browser?`);
+                    if (open)
+                        openBrowser(info.url);
+                    return;
+                }
             }
             // Start the server
             ctx.ui.notify("[mega-compact] starting dashboard server…");

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;