@echomem/mcp 1.4.4 → 1.4.6

package/dist/hud/electron-main.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { app, BrowserWindow, ipcMain, Menu, screen } from "electron";
+import { app, BrowserWindow, ipcMain, Menu, screen, shell } from "electron";
 import { createHudServer } from "./server.js";
 const flags = parseFlags(process.argv.slice(2));
 const mode = parseMode(flags.client);
@@ -32,8 +32,16 @@ app.whenReady().then(async () => {
         writeBounds(win);
     });
     const preferredUrl = `http://127.0.0.1:${port}`;
+    const onReveal = (filePath) => {
+        try {
+            shell.showItemInFolder(filePath);
+        }
+        catch {
+            /* best-effort */
+        }
+    };
     try {
-        hudServer = await createHudServer({ mode, port });
+        hudServer = await createHudServer({ mode, port, onReveal });
         createWindow(hudServer.url);
     }
     catch (error) {
@@ -41,7 +49,7 @@ app.whenReady().then(async () => {
             createWindow(preferredUrl);
             return;
         }
-        hudServer = await createHudServer({ mode, port: 0 });
+        hudServer = await createHudServer({ mode, port: 0, onReveal });
         createWindow(hudServer.url);
     }
 }).catch((error) => {

package/dist/hud/monitor.js

@@ -2,11 +2,13 @@ import { execFileSync } from "node:child_process";
 import { EventEmitter } from "node:events";
 import fs from "node:fs";
 import path from "node:path";
-import { adapterList } from "./adapters.js";
+import { adapterList, adapters } from "./adapters.js";
 import { homePath, newestFile, walkFiles } from "./fs.js";
 const LIVE_WINDOW_MS = 45_000;
 const ONGOING_WINDOW_MS = 300_000; // a thread counts as "ongoing" if its log was written in the last 5 min
 const FOCUS_GRACE_MS = 8_000; // keep the last-known frontmost client this long when detection momentarily misses
+const RECENT_WINDOW_MS = 12 * 60 * 60 * 1000; // a session is a "recent tab" if its log was touched in the last 12h
+const RECENT_CAP = 16; // most-recent N sessions kept as switchable tabs
 export class HudMonitor extends EventEmitter {
     mode;
     pollMs;
@@ -22,6 +24,13 @@ export class HudMonitor extends EventEmitter {
     lastActiveClient = null;
     threadCounts = {};
     threadCountsAt = 0;
+    recentSessions = [];
+    codexTitles = new Map();
+    codexTitlesSig = "";
+    claudeTitleCache = new Map();
+    lastPersistedRecent = "";
+    pinnedId = null;
+    pinnedScore = null;
     constructor(mode = "auto", pollMs = 750) {
         super();
         this.mode = mode;
@@ -41,7 +50,7 @@ export class HudMonitor extends EventEmitter {
     }
     snapshot() {
         const focused = this.frontmostPreferredClient();
-        this.refreshThreadCounts();
+        this.refreshRecent();
         const now = Date.now();
         const sessions = [...this.scores.values()].map((score) => {
             // Liveness uses file mtime (real last write), not score.updatedAt — the Claude cache stamps
@@ -64,12 +73,16 @@ export class HudMonitor extends EventEmitter {
                 return a.live ? -1 : 1;
             return a.lastActiveMs - b.lastActiveMs;
         });
+        // A user-pinned tab overrides auto-selection: it becomes the primary and never flips away.
+        const pinned = this.pinnedView(now);
+        const ordered = pinned ? [pinned, ...sessions.filter((s) => s.sourcePath !== pinned.sourcePath)] : sessions;
         return {
             mode: this.mode,
-            active: sessions[0] || null,
-            scores: sessions,
-            sessions,
+            active: ordered[0] || null,
+            scores: ordered,
+            sessions: ordered,
             threadCounts: this.threadCounts,
+            recentSessions: this.recentSessions,
             missing: this.missing,
             updatedAt: new Date().toISOString(),
         };
@@ -82,6 +95,40 @@ export class HudMonitor extends EventEmitter {
         this.labelCache.set(score.sourcePath, label);
         return label;
     }
+    // Pin a recent-session id as the primary view (or null to return to auto-selection).
+    pin(id) {
+        if (id === this.pinnedId)
+            return;
+        this.pinnedId = id;
+        this.pinnedScore = null;
+    }
+    // The user-selected tab, scored on demand (cached by file signature). null if nothing is pinned or
+    // the pinned session has aged out of the recent list.
+    pinnedView(now) {
+        if (!this.pinnedId)
+            return null;
+        const rec = this.recentSessions.find((r) => r.id === this.pinnedId);
+        if (!rec)
+            return null;
+        let stat = null;
+        try {
+            stat = fs.statSync(rec.sourcePath);
+        }
+        catch {
+            return null;
+        }
+        const sig = `${rec.sourcePath}:${stat.size}:${stat.mtimeMs}`;
+        if (!this.pinnedScore || this.pinnedScore.sig !== sig) {
+            try {
+                this.pinnedScore = { sig, score: adapters[rec.client].score(rec.sourcePath) };
+            }
+            catch {
+                return null;
+            }
+        }
+        const lastActiveMs = Math.max(0, now - stat.mtimeMs);
+        return { ...this.pinnedScore.score, live: lastActiveMs < LIVE_WINDOW_MS, focused: true, label: rec.title, lastActiveMs };
+    }
     frontmostPreferredClient() {
         if (this.mode !== "auto" && this.mode !== "both")
             return null;
@@ -103,28 +150,171 @@ export class HudMonitor extends EventEmitter {
         }
         return this.frontmostClient && this.scores.has(this.frontmostClient) ? this.frontmostClient : null;
     }
-    // Count each client's "ongoing" threads = session files written within ONGOING_WINDOW_MS. Throttled,
-    // since it walks every session file per client (cheap at a few-second cadence, wasteful at 750ms).
-    refreshThreadCounts() {
+    // One throttled walk over every session file per client → both the ongoing-thread counts and the
+    // "recent tabs" list (touched in the last RECENT_WINDOW_MS), which is persisted to disk so the tab
+    // set survives HUD restarts. Cheap at a few-second cadence; too heavy for the 750ms tick.
+    refreshRecent() {
         const now = Date.now();
-        if (now - this.threadCountsAt < 2500 && Object.keys(this.threadCounts).length)
+        if (this.threadCountsAt && now - this.threadCountsAt < 2500)
             return;
         this.threadCountsAt = now;
+        this.loadCodexTitles();
         const counts = {};
+        const recent = [];
+        const newestByClient = new Map();
         for (const adapter of adapterList(this.mode)) {
             let n = 0;
             for (const file of adapter.findAll()) {
+                let mtimeMs = 0;
                 try {
-                    if (now - fs.statSync(file).mtimeMs < ONGOING_WINDOW_MS)
-                        n += 1;
+                    mtimeMs = fs.statSync(file).mtimeMs;
                 }
                 catch {
-                    /* ignore files that vanish mid-walk */
+                    continue; // vanished mid-walk
                 }
+                const age = now - mtimeMs;
+                if (age < ONGOING_WINDOW_MS)
+                    n += 1;
+                const newest = newestByClient.get(adapter.client);
+                if (!newest || mtimeMs > newest.mtimeMs)
+                    newestByClient.set(adapter.client, { file, mtimeMs });
+                if (age < RECENT_WINDOW_MS)
+                    recent.push(this.buildRecent(adapter.client, file, age));
             }
             counts[adapter.client] = n;
         }
+        recent.sort((a, b) => a.lastActiveMs - b.lastActiveMs); // newest first
+        const list = recent.slice(0, RECENT_CAP);
+        // Always keep each agent's latest session reachable as a tab (so you can switch to "my last Codex"
+        // even if it's been idle longer than the window). Appended if the window didn't already include it.
+        for (const [client, info] of newestByClient) {
+            if (!list.some((r) => r.client === client))
+                list.push(this.buildRecent(client, info.file, now - info.mtimeMs));
+        }
         this.threadCounts = counts;
+        this.recentSessions = list;
+        this.persistRecent();
+    }
+    buildRecent(client, file, age) {
+        return {
+            id: sessionIdFromPath(file),
+            client,
+            title: this.titleFor(client, file),
+            sourcePath: file,
+            lastActiveMs: age,
+            live: age < LIVE_WINDOW_MS,
+        };
+    }
+    titleFor(client, file) {
+        if (client === "codex") {
+            const uuid = codexUuidFromPath(file);
+            const title = uuid && this.codexTitles.get(uuid);
+            if (title)
+                return title;
+        }
+        else {
+            const title = this.claudeTitle(file);
+            if (title)
+                return title;
+        }
+        return sessionLabel(file, client); // repo/cwd basename fallback
+    }
+    // Claude has no title index, so derive one from the thread's first real user message (cached per file
+    // — the first message never changes). Distinguishes two threads in the same repo.
+    claudeTitle(file) {
+        const cached = this.claudeTitleCache.get(file);
+        if (cached !== undefined)
+            return cached;
+        let title = "";
+        try {
+            const fd = fs.openSync(file, "r");
+            try {
+                const buf = Buffer.alloc(64 * 1024);
+                const bytes = fs.readSync(fd, buf, 0, buf.length, 0);
+                for (const line of buf.toString("utf8", 0, bytes).split("\n")) {
+                    if (!line.includes('"user"'))
+                        continue;
+                    let obj;
+                    try {
+                        obj = JSON.parse(line);
+                    }
+                    catch {
+                        continue; // partial/last line
+                    }
+                    if (!isRecord(obj) || obj.type !== "user")
+                        continue;
+                    const message = isRecord(obj.message) ? obj.message : null;
+                    const content = message ? message.content : undefined;
+                    let body = "";
+                    if (typeof content === "string")
+                        body = content;
+                    else if (Array.isArray(content))
+                        body = content.map((b) => (isRecord(b) && typeof b.text === "string" ? b.text : "")).join(" ");
+                    body = body.replace(/\s+/g, " ").trim();
+                    if (!body || body.startsWith("<") || /^#\s*claudeMd\b/i.test(body) || body.startsWith("Caveat:"))
+                        continue;
+                    title = body.length > 48 ? `${body.slice(0, 47)}…` : body;
+                    break;
+                }
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            /* unreadable → falls back to repo label */
+        }
+        this.claudeTitleCache.set(file, title);
+        return title;
+    }
+    // Codex writes a lightweight index of every thread (id + human title). Load it (mtime-cached) so tabs
+    // show real titles like "Verify file state" instead of a UUID.
+    loadCodexTitles() {
+        const indexPath = homePath(".codex", "session_index.jsonl");
+        let sig = "";
+        try {
+            const stat = fs.statSync(indexPath);
+            sig = `${stat.size}:${stat.mtimeMs}`;
+        }
+        catch {
+            return;
+        }
+        if (sig === this.codexTitlesSig)
+            return;
+        this.codexTitlesSig = sig;
+        const map = new Map();
+        try {
+            for (const line of fs.readFileSync(indexPath, "utf8").split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (obj && typeof obj.id === "string" && typeof obj.thread_name === "string")
+                        map.set(obj.id, obj.thread_name);
+                }
+                catch {
+                    /* skip malformed line */
+                }
+            }
+        }
+        catch {
+            /* index unreadable — titles fall back to labels */
+        }
+        this.codexTitles = map;
+    }
+    persistRecent() {
+        const signature = JSON.stringify(this.recentSessions.map((s) => `${s.id}:${s.live}`));
+        if (signature === this.lastPersistedRecent)
+            return; // only rewrite when the set/liveness changes
+        this.lastPersistedRecent = signature;
+        try {
+            const dir = homePath(".echomem");
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(path.join(dir, "hud-recent-sessions.json"), JSON.stringify({ updatedAt: new Date().toISOString(), sessions: this.recentSessions }, null, 2));
+        }
+        catch {
+            /* best-effort — persistence never blocks the HUD */
+        }
     }
     tick() {
         const missing = [];
@@ -185,6 +375,16 @@ function detectFrontmostClient() {
     }
     return null;
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sessionIdFromPath(file) {
+    return codexUuidFromPath(file) || path.basename(file).replace(/\.jsonl$|\.json$/, "");
+}
+function codexUuidFromPath(file) {
+    const match = path.basename(file).match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
+    return match ? match[0] : "";
+}
 function defaultLabel(client) {
     if (client === "codex")
         return "Codex";

package/dist/hud/server.js

@@ -36,6 +36,31 @@ export async function createHudServer(opts = {}) {
             res.end(JSON.stringify(latest, null, 2));
             return;
         }
+        if (url.pathname === "/select") {
+            const id = url.searchParams.get("id");
+            monitor.pin(id && id !== "auto" ? id : null);
+            latest = monitor.snapshot();
+            const payload = `data: ${JSON.stringify(latest)}\n\n`;
+            for (const client of clients)
+                client.write(payload);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, pinned: id && id !== "auto" ? id : null }));
+            return;
+        }
+        if (url.pathname === "/reveal") {
+            const target = url.searchParams.get("path") || "";
+            // Only reveal paths we actually track — never open an arbitrary path from a query string.
+            const known = new Set([
+                ...(latest.recentSessions || []).map((s) => s.sourcePath),
+                ...(latest.sessions || []).map((s) => s.sourcePath),
+            ]);
+            const canReveal = Boolean(target) && known.has(target) && typeof opts.onReveal === "function";
+            if (canReveal)
+                opts.onReveal(target);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: canReveal, reason: canReveal ? undefined : opts.onReveal ? "unknown_path" : "no_desktop" }));
+            return;
+        }
         if (url.pathname === "/capsule") {
             const active = latest.active;
             if (!active) {

package/dist/hud/web.js

@@ -125,8 +125,9 @@ export const HUD_HTML = String.raw `<!doctype html>
         z-index: 2;
         min-width: 0;
         display: grid;
+        grid-template-columns: minmax(0, 1fr);
         gap: 4px;
-        padding: 20px 22px 18px 30px;
+        padding: 20px 38px 18px 30px;
       }
       .dot {
         position: absolute;
@@ -180,17 +181,46 @@ export const HUD_HTML = String.raw `<!doctype html>
       #hud.open .details { display: block; }
       .head {
         display: flex;
-        justify-content: flex-end;
+        justify-content: space-between;
+        align-items: baseline;
         min-height: 15px;
         margin-bottom: 10px;
       }
-      .turn {
+      .turn, .upd {
         overflow: hidden;
         text-overflow: ellipsis;
         white-space: nowrap;
         font-size: 11px;
         color: var(--faint);
       }
+      .tabs { display: flex; gap: 6px; overflow-x: auto; margin: 2px 0 12px; padding-bottom: 2px; }
+      .tabs::-webkit-scrollbar { height: 0; }
+      .tab {
+        flex: 0 0 auto; font-size: 10.5px; line-height: 1; padding: 5px 10px; border-radius: 999px;
+        border: 1px solid rgba(0, 0, 0, .12); background: rgba(0, 0, 0, .04);
+        color: var(--faint); cursor: pointer; white-space: nowrap; font-family: inherit;
+      }
+      .tab:hover { background: rgba(0, 0, 0, .08); }
+      .tab.active { border-color: rgba(0, 0, 0, .38); background: rgba(0, 0, 0, .10); color: #111; font-weight: 700; }
+      .spin {
+        display: inline-block; width: 9px; height: 9px; margin-right: 5px; vertical-align: -1px;
+        border: 1.5px solid rgba(0, 0, 0, .2); border-top-color: #1a3a8f; border-radius: 50%;
+        animation: echospin .8s linear infinite;
+      }
+      @keyframes echospin { to { transform: rotate(360deg); } }
+      .headctl { display: flex; align-items: center; gap: 8px; }
+      .switchbtn {
+        width: 22px; height: 22px; border-radius: 50%; padding: 0; line-height: 1; font-size: 12px;
+        border: 1px solid rgba(0, 0, 0, .2); background: rgba(0, 0, 0, .05); color: var(--faint);
+        cursor: pointer; font-family: inherit;
+      }
+      .switchbtn:hover { background: rgba(0, 0, 0, .1); color: #111; }
+      .reveal {
+        margin-top: 8px; font-size: 10.5px; padding: 4px 11px; border-radius: 999px;
+        border: 1px solid rgba(0, 0, 0, .12); background: rgba(0, 0, 0, .04); color: var(--faint);
+        cursor: pointer; font-family: inherit;
+      }
+      .reveal:hover { background: rgba(0, 0, 0, .08); color: #111; }
       .state-row {
         display: flex;
         align-items: center;
@@ -373,7 +403,8 @@ export const HUD_HTML = String.raw `<!doctype html>
         </div>
       </div>
       <div class="details">
-        <div class="head"><span class="turn" id="turn"></span></div>
+        <div class="head"><span class="upd" id="updated"></span><span class="headctl"><span class="turn" id="turn"></span><button class="switchbtn" id="switchbtn" title="Switch agent" style="display:none">⇄</button></span></div>
+        <div class="tabs" id="tabs"></div>
         <div class="state-row">
           <span class="state-dot" id="stateDot"></span>
           <span class="state-word" id="stateWord">Fresh</span>
@@ -398,6 +429,7 @@ export const HUD_HTML = String.raw `<!doctype html>
         </div>
         <div class="meta" id="meta"></div>
         <div class="path" id="path"></div>
+        <button class="reveal" id="reveal" style="display:none">↗ Reveal session log in Finder</button>
         <div class="missing" id="missing"></div>
       </div>
     </section>
@@ -425,13 +457,57 @@ export const HUD_HTML = String.raw `<!doctype html>
       const copyBtn = document.getElementById("copybtn");
       const metaEl = document.getElementById("meta");
       const pathEl = document.getElementById("path");
+      const updatedEl = document.getElementById("updated");
+      const tabsEl = document.getElementById("tabs");
+      const switchBtn = document.getElementById("switchbtn");
+      const revealEl = document.getElementById("reveal");
       const missing = document.getElementById("missing");
       const hudVersion = "v${MCP_PACKAGE_VERSION}";
       let prevTurnState = null;
       let lastCapsule = "";
+      let activityEpoch = null;
+      let lastState = null;
+      let currentSrc = null;
+
+      // Reveal the active session's log file in Finder (Electron only; no-op in browser mode).
+      if (revealEl) revealEl.addEventListener("click", () => {
+        if (!currentSrc) return;
+        fetch("/reveal?path=" + encodeURIComponent(currentSrc)).catch(() => {});
+      });
+
+      // Circular top-right toggle: jump to the next agent's newest session (Claude ⇄ Codex).
+      if (switchBtn) switchBtn.addEventListener("click", (e) => {
+        e.stopPropagation();
+        const st = lastState;
+        if (!st || !st.recentSessions) return;
+        const clients = [];
+        for (const s of st.recentSessions) if (clients.indexOf(s.client) < 0) clients.push(s.client);
+        if (clients.length < 2) return;
+        const cur = st.active ? st.active.client : clients[0];
+        const next = clients[(clients.indexOf(cur) + 1) % clients.length];
+        const target = st.recentSessions.filter((s) => s.client === next)[0]; // newest of that agent
+        if (!target) return;
+        fetch("/select?id=" + encodeURIComponent(target.id))
+          .then(() => fetch("/state"))
+          .then((r) => r.json())
+          .then(render)
+          .catch(() => {});
+      });
+
+      // Click a tab → pin that session as the primary view (or "Auto" to return to auto-selection).
+      if (tabsEl) tabsEl.addEventListener("click", (e) => {
+        const btn = e.target && e.target.closest ? e.target.closest(".tab") : null;
+        if (!btn) return;
+        const id = btn.getAttribute("data-id");
+        fetch("/select?id=" + encodeURIComponent(id))
+          .then(() => fetch("/state"))
+          .then((r) => r.json())
+          .then(render)
+          .catch(() => {});
+      });
 
       document.getElementById("toggle").addEventListener("click", (event) => {
-        if (event.target instanceof HTMLElement && event.target.closest(".drag")) return;
+        if (event.target instanceof HTMLElement && (event.target.closest(".drag") || event.target.closest(".switchbtn"))) return;
         hud.classList.toggle("open");
         syncHeight();
       });
@@ -477,6 +553,13 @@ export const HUD_HTML = String.raw `<!doctype html>
 
       function render(state) {
         const score = state.active || state;
+        lastState = state;
+        renderTabs(state, score && score.sourcePath ? activeIdFor(state, score.sourcePath) : null);
+        if (switchBtn) {
+          const clients = [];
+          for (const s of (state.recentSessions || [])) if (clients.indexOf(s.client) < 0) clients.push(s.client);
+          switchBtn.style.display = clients.length >= 2 ? "inline-block" : "none";
+        }
         if (!score || typeof score.usefulPct !== "number") {
           renderIdle(state);
           return;
@@ -489,29 +572,37 @@ export const HUD_HTML = String.raw `<!doctype html>
         const repeatCount = score.buckets && score.buckets.range_redundant ? score.buckets.range_redundant.count || 0 : 0;
         const edits = score.stats && score.stats.patchEdits ? Number(score.stats.patchEdits) : 0;
 
-        dot.className = "dot " + color;
-        stateDot.className = "state-dot " + color;
+        // A session idle for >10 min shouldn't wear the cheerful "Fresh/clean" look — its quality
+        // numbers are stale. Show it muted as Idle so a 47h-old pinned session never reads as current.
+        const stale = typeof score.lastActiveMs === "number" && score.lastActiveMs > 600000;
+        const shownColor = stale ? "idle" : color;
+        dot.className = "dot " + shownColor;
+        stateDot.className = stale ? "state-dot" : "state-dot " + color;
         hud.classList.remove("s-green", "s-amber", "s-red");
-        hud.classList.add("s-" + color);
-        main.textContent = stateName + " - " + fmt(score.ctTokens) + " ctx";
-        client.textContent = label(score.client) + " - " + hudVersion;
+        if (!stale) hud.classList.add("s-" + color);
+        main.textContent = (stale ? "Idle" : stateName) + " - " + fmt(score.ctTokens) + " ctx";
+        client.textContent = sessionIdentity(score, state);
+        activityEpoch = typeof score.lastActiveMs === "number" ? Date.now() - score.lastActiveMs : null;
+        renderUpdated();
         turnEl.textContent = typeof score.turn === "number" && score.turn > 0 ? "turn " + score.turn : "";
-        stateWordEl.textContent = stateName;
+        stateWordEl.textContent = stale ? "Idle" : stateName;
         fullness.textContent = fullnessLine(sat, score);
-        fullness.style.color = tone(color);
-        lead.textContent = leadLine(color);
-        lead.style.color = tone(color);
+        fullness.style.color = stale ? "#6b675d" : tone(color);
+        lead.textContent = stale ? "This session is idle - showing its last state" : leadLine(color);
+        lead.style.color = stale ? "#6b675d" : tone(color);
         evidence.textContent = evidenceLine(score, oldPct, repeatCount);
         usefulbar.style.width = Math.max(0, 100 - oldPct) + "%";
         oldbar.style.width = oldPct + "%";
         metaEl.textContent = ctSourceLabel(score.ctSource) + " - lower-bound signal - " + edits + " edits";
-        pathEl.textContent = score.sourcePath ? "Reading " + score.sourcePath : "";
+        pathEl.textContent = "";
+        currentSrc = score.sourcePath || null;
+        if (revealEl) revealEl.style.display = currentSrc ? "inline-block" : "none";
         missing.textContent = formatMissing(state.missing);
 
         renderAlert(score, oldPct, repeatCount);
         renderNudge(color, sat);
 
-        if (renewBtn) renewBtn.style.display = color === "red" || color === "amber" ? "block" : "none";
+        if (renewBtn) renewBtn.style.display = "block"; // always available — warm-start any session, even fresh
         prevTurnState = {
           src: score.sourcePath,
           turn: score.turn,
@@ -530,6 +621,10 @@ export const HUD_HTML = String.raw `<!doctype html>
         prevTurnState = null;
         main.textContent = "No active session yet";
         client.textContent = "EchoMem HUD - " + hudVersion;
+        activityEpoch = null;
+        if (updatedEl) updatedEl.textContent = "";
+        currentSrc = null;
+        if (revealEl) revealEl.style.display = "none";
         turnEl.textContent = "";
         stateWordEl.textContent = "Fresh";
         fullness.textContent = "";
@@ -634,6 +729,56 @@ export const HUD_HTML = String.raw `<!doctype html>
         return "Not seeing " + list.map(label).join(", ") + " yet";
       }
 
+      // Subtitle: which session this is (client + project) + version. The "other clients working"
+      // signal now lives in the live-spinner tabs, so it's dropped here to keep the line short.
+      function sessionIdentity(score) {
+        const parts = [label(score.client)];
+        if (score.label) parts.push(score.label);
+        parts.push(hudVersion);
+        return parts.join(" · ");
+      }
+
+      // Recent sessions as switchable tabs. "Auto" clears the pin. Hidden when there's only one session.
+      function renderTabs(state, activeId) {
+        if (!tabsEl) return;
+        const list = (state && state.recentSessions) || [];
+        if (list.length <= 1) { tabsEl.innerHTML = ""; return; }
+        const chips = list.map((s) => {
+          const cls = s.id === activeId ? "tab active" : "tab";
+          const dot = s.live ? '<span class="spin"></span>' : "";
+          const title = s.title || label(s.client);
+          return '<button class="' + cls + '" data-id="' + esc(s.id) + '" title="' + esc(label(s.client) + " · " + title) + '">' + dot + esc(shortTitle(title)) + "</button>";
+        });
+        chips.unshift('<button class="tab' + (activeId ? "" : " active") + '" data-id="auto">Auto</button>');
+        tabsEl.innerHTML = chips.join("");
+      }
+      function activeIdFor(state, src) {
+        const list = (state && state.recentSessions) || [];
+        const match = list.filter((s) => s.sourcePath === src)[0];
+        return match ? match.id : null;
+      }
+      function shortTitle(t) {
+        t = String(t || "");
+        return t.length > 22 ? t.slice(0, 21) + "…" : t;
+      }
+      function esc(s) {
+        return String(s).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
+      }
+
+      function renderUpdated() {
+        if (!updatedEl) return;
+        updatedEl.textContent = activityEpoch === null ? "" : "updated " + relTime(Date.now() - activityEpoch);
+      }
+      function relTime(ms) {
+        const s = Math.max(0, Math.round(ms / 1000));
+        if (s < 5) return "now";
+        if (s < 60) return s + "s ago";
+        const m = Math.round(s / 60);
+        if (m < 60) return m + "m ago";
+        return Math.round(m / 60) + "h ago";
+      }
+      setInterval(renderUpdated, 1000);
+
       function label(clientName) {
         if (clientName === "codex") return "Codex";
         if (clientName === "claude-code") return "Claude Code";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "EchoMem Cloud-First MCP Server",
   "main": "dist/index.js",
   "type": "module",