pi-mega-compact 0.4.19 → 0.4.21

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/dashboard-server.ts

@@ -14,7 +14,8 @@
 import { createServer, type IncomingMessage, type ServerResponse } 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) ------------------------------------------------
@@ -61,7 +62,7 @@ function readIndex(): { updatedAt: string; summary: unknown; repos: unknown[] }
     const rows = db
       .prepare("SELECT * FROM repo_registry ORDER BY last_seen DESC")
       .all() as Record<string, unknown>[];
-    const repos: IndexRepo[] = rows.map((r) => ({
+    const mapped: IndexRepo[] = rows.map((r) => ({
       repoRoot: String(r.repo_root ?? ""),
       displayName: String(r.display_name ?? ""),
       checkpointCount: Number(r.checkpoint_count ?? 0),
@@ -75,6 +76,22 @@ function readIndex(): { updatedAt: string; summary: unknown; repos: unknown[] }
       outputRate: (r.output_rate as number | null) ?? 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: string) =>
+      /^\/tmp\//.test(p) || /^\/private\/tmp\//.test(p) || /^\/var\/folders\//.test(p) ||
+      /\/mc-(ext|e2e|resume|recall)-/.test(p);
+    const seenName = new Set<string>();
+    const repos: IndexRepo[] = [];
+    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),
@@ -722,6 +739,21 @@ function dashboardHtml(tierName: string): string {
 // ---------------------------------------------------------------------------
 
 export function launchDashboardServer(stateDir: string): Promise<{ port: number; url: string }> {
+  // 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");
@@ -769,6 +801,14 @@ export function launchDashboardServer(stateDir: string): Promise<{ port: number;
       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/extensions/mega-compact.test.ts

@@ -22,6 +22,9 @@ import type { AgentMessage } from "@earendil-works/pi-agent-core";
 
 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. */
@@ -297,13 +300,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: boolean[] = [];
-  // 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<void>((r) => server.listen(0, "127.0.0.1", r));
+  await new Promise<void>((r) => server.listen(9320, "127.0.0.1", r));
   const addr = server.address() as any;
   const { join: j } = await import("node:path");
   const { writeFileSync: wf } = await import("node:fs");
@@ -328,7 +332,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");
@@ -336,7 +341,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<void>((r) => server.listen(0, "127.0.0.1", r));
+  await new Promise<void>((r) => server.listen(9321, "127.0.0.1", r));
   const addr = server.address() as any;
   wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: addr.port, pid: process.pid }));
 

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

@@ -36,8 +36,11 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
     return null;
   }
 
-  /** Try to reach a running dashboard server. Returns { port, url } or null. */
-  async function isServerRunning(): Promise<{ port: number; url: string } | 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(): Promise<{ port: number; url: string; hasPidFile: boolean } | null> {
     const port = await findLivePort();
     if (!port) {
       // Stale marker with no live server behind it — clean up.
@@ -46,7 +49,59 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
       }
       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: number): Promise<string | null> {
+    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() as { version?: string };
+      return j.version ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Version of THIS extension (read from its own package.json). */
+  function ownVersion(): string | null {
+    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: number): number | null {
+    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: number): void {
+    let pid: number | null = 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 */ }
   }
 
   /**
@@ -122,10 +177,29 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
       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

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.