@echomem/mcp 1.4.7 → 1.4.9

package/dist/hud/monitor.js

@@ -6,7 +6,6 @@ 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 {
@@ -19,18 +18,21 @@ export class HudMonitor extends EventEmitter {
     labelCache = new Map();
     missing = [];
     frontmostCheckedAt = 0;
-    frontmostSeenAt = 0;
-    frontmostClient = null;
+    frontmostFamily = null;
     lastActiveClient = null;
     threadCounts = {};
     threadCountsAt = 0;
     recentSessions = [];
     codexTitles = new Map();
     codexTitlesSig = "";
+    claudeTitles = new Map();
+    claudeTitlesSig = "";
+    claudeTitlesCheckedAt = 0;
     claudeTitleCache = new Map();
     lastPersistedRecent = "";
     pinnedId = null;
     pinnedScore = null;
+    pinnedFromFamily = null;
     constructor(mode = "auto", pollMs = 750) {
         super();
         this.mode = mode;
@@ -49,8 +51,9 @@ export class HudMonitor extends EventEmitter {
         this.timer = null;
     }
     snapshot() {
-        const focused = this.frontmostPreferredClient();
+        const focusedFamily = this.frontmostPreferredFamily();
         this.refreshRecent();
+        this.releasePinAfterForegroundSwitch(focusedFamily);
         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
@@ -60,22 +63,19 @@ export class HudMonitor extends EventEmitter {
             return {
                 ...score,
                 live: lastActiveMs < LIVE_WINDOW_MS,
-                focused: focused === score.client,
+                focused: focusedFamily === agentFamily(score.client),
                 label: this.labelFor(score),
                 lastActiveMs,
             };
         });
-        // focused first, then live (most-recent first), then idle (most-recent first).
-        sessions.sort((a, b) => {
-            if (a.focused !== b.focused)
-                return a.focused ? -1 : 1;
-            if (a.live !== b.live)
-                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.
+        // The user's foreground agent is the primary truth. Background agents can keep writing logs, but
+        // they should never steal the main HUD away from Codex/Claude while that app is what the user opened.
+        sessions.sort((a, b) => hudSelectionRank(a) - hudSelectionRank(b) || a.lastActiveMs - b.lastActiveMs);
+        // A pin selects one session while the user remains in the same agent. Crossing to the other
+        // foreground agent releases it so Auto can follow the workflow again.
         const pinned = this.pinnedView(now);
         const ordered = pinned ? [pinned, ...sessions.filter((s) => s.sourcePath !== pinned.sourcePath)] : sessions;
+        const pinnedId = pinned ? this.pinnedId : null;
         return {
             mode: this.mode,
             active: ordered[0] || null,
@@ -83,6 +83,7 @@ export class HudMonitor extends EventEmitter {
             sessions: ordered,
             threadCounts: this.threadCounts,
             recentSessions: this.recentSessions,
+            pinnedId,
             missing: this.missing,
             updatedAt: new Date().toISOString(),
         };
@@ -101,6 +102,16 @@ export class HudMonitor extends EventEmitter {
             return;
         this.pinnedId = id;
         this.pinnedScore = null;
+        this.pinnedFromFamily = id ? this.frontmostPreferredFamily() : null;
+    }
+    releasePinAfterForegroundSwitch(focusedFamily) {
+        if (!this.pinnedId || !this.pinnedFromFamily || !focusedFamily)
+            return;
+        if (focusedFamily === this.pinnedFromFamily)
+            return;
+        this.pinnedId = null;
+        this.pinnedScore = null;
+        this.pinnedFromFamily = 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.
@@ -127,28 +138,27 @@ export class HudMonitor extends EventEmitter {
             }
         }
         const lastActiveMs = Math.max(0, now - stat.mtimeMs);
-        return { ...this.pinnedScore.score, live: lastActiveMs < LIVE_WINDOW_MS, focused: true, label: rec.title, lastActiveMs };
+        return { ...this.pinnedScore.score, live: lastActiveMs < LIVE_WINDOW_MS, focused: true, label: rec.label || rec.title, lastActiveMs };
     }
-    frontmostPreferredClient() {
+    frontmostPreferredFamily() {
         if (this.mode !== "auto" && this.mode !== "both")
             return null;
         const now = Date.now();
         if (now - this.frontmostCheckedAt > 1500) {
             this.frontmostCheckedAt = now;
-            const detected = detectFrontmostClient();
+            const detected = detectFrontmostFamily();
             if (detected) {
-                // Positive detection wins immediately (real focus switch, e.g. Codex → Claude Desktop).
-                this.frontmostClient = detected;
-                this.frontmostSeenAt = now;
-            }
-            else if (now - this.frontmostSeenAt > FOCUS_GRACE_MS) {
-                // Detection missed (osascript timeout, or a non-agent app like a browser is front). Hold the
-                // last-known focus for a grace window so the active slot doesn't flip to a background client
-                // just because it's writing — then release once the grace expires.
-                this.frontmostClient = null;
+                // Positive detection wins immediately. Claude Code and Claude Desktop share one family;
+                // recency below decides which Claude source is the conversation the user is actually using.
+                this.frontmostFamily = detected;
             }
         }
-        return this.frontmostClient && this.scores.has(this.frontmostClient) ? this.frontmostClient : null;
+        if (this.frontmostFamily === "codex")
+            return this.scores.has("codex") ? "codex" : null;
+        if (this.frontmostFamily === "claude") {
+            return this.scores.has("claude-code") || this.scores.has("claude-desktop") ? "claude" : null;
+        }
+        return null;
     }
     // 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
@@ -159,6 +169,7 @@ export class HudMonitor extends EventEmitter {
             return;
         this.threadCountsAt = now;
         this.loadCodexTitles();
+        this.loadClaudeTitles();
         const counts = {};
         const recent = [];
         const newestByClient = new Map();
@@ -200,6 +211,7 @@ export class HudMonitor extends EventEmitter {
             id: sessionIdFromPath(file),
             client,
             title: this.titleFor(client, file),
+            label: sessionLabel(file, client),
             sourcePath: file,
             lastActiveMs: age,
             live: age < LIVE_WINDOW_MS,
@@ -213,60 +225,18 @@ export class HudMonitor extends EventEmitter {
                 return title;
         }
         else {
-            const title = this.claudeTitle(file);
-            if (title)
-                return title;
+            const metadataTitle = this.claudeTitles.get(sessionIdFromPath(file));
+            if (metadataTitle)
+                return metadataTitle;
+            const cached = this.claudeTitleCache.get(file);
+            if (cached !== undefined)
+                return cached;
+            const title = claudeDisplayTitle(file, client);
+            this.claudeTitleCache.set(file, 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() {
@@ -302,6 +272,28 @@ export class HudMonitor extends EventEmitter {
         }
         this.codexTitles = map;
     }
+    // Claude Desktop keeps its sidebar titles outside the transcripts. Join those records by
+    // cliSessionId so the HUD can show the same title the user sees in Claude.
+    loadClaudeTitles() {
+        const now = Date.now();
+        if (this.claudeTitlesCheckedAt && now - this.claudeTitlesCheckedAt < 5000)
+            return;
+        this.claudeTitlesCheckedAt = now;
+        const files = listClaudeSessionMetadataFiles();
+        const signature = files.map((file) => {
+            try {
+                const stat = fs.statSync(file);
+                return `${file}:${stat.size}:${stat.mtimeMs}`;
+            }
+            catch {
+                return "";
+            }
+        }).join("|");
+        if (signature === this.claudeTitlesSig)
+            return;
+        this.claudeTitlesSig = signature;
+        this.claudeTitles = claudeSessionTitlesFromFiles(files);
+    }
     persistRecent() {
         const signature = JSON.stringify(this.recentSessions.map((s) => `${s.id}:${s.live}`));
         if (signature === this.lastPersistedRecent)
@@ -360,21 +352,68 @@ export class HudMonitor extends EventEmitter {
             this.emit("state", this.snapshot());
     }
 }
-function detectFrontmostClient() {
+export function hudSelectionRank(session) {
+    if (session.focused)
+        return 0;
+    if (session.live)
+        return 1;
+    return 2;
+}
+export function claudeDisplayTitle(file, client) {
+    const label = sessionLabel(file, client);
+    const stamp = sessionTimeLabel(resolveClaudeTranscript(file) ?? file);
+    return label === defaultLabel(client) ? stamp : `${label} · ${stamp}`;
+}
+export function claudeSessionTitlesFromFiles(files) {
+    const entries = new Map();
+    for (const file of files) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+            if (!isRecord(raw))
+                continue;
+            const id = typeof raw.cliSessionId === "string" ? raw.cliSessionId.trim() : "";
+            const title = typeof raw.title === "string" ? raw.title.trim() : "";
+            if (!id || !title)
+                continue;
+            const freshness = Number(raw.lastFocusedAt) || Number(raw.lastActivityAt) || fs.statSync(file).mtimeMs;
+            const previous = entries.get(id);
+            if (!previous || freshness >= previous.freshness)
+                entries.set(id, { title, freshness });
+        }
+        catch {
+            /* Ignore incomplete or disappearing live metadata files. */
+        }
+    }
+    return new Map([...entries].map(([id, entry]) => [id, entry.title]));
+}
+function detectFrontmostFamily() {
     if (process.platform !== "darwin")
         return null;
     try {
-        const name = execFileSync("osascript", ["-e", 'tell application "System Events" to get name of first application process whose frontmost is true'], { encoding: "utf8", timeout: 500, stdio: ["ignore", "pipe", "ignore"] }).trim().toLowerCase();
-        if (name.includes("codex"))
-            return "codex";
-        if (name.includes("claude"))
-            return "claude-desktop";
+        const output = execFileSync("osascript", [
+            "-e",
+            'tell application "System Events" to tell first application process whose frontmost is true to return (name as text) & linefeed & (bundle identifier as text)',
+        ], { encoding: "utf8", timeout: 500, stdio: ["ignore", "pipe", "ignore"] }).trim();
+        const [name = "", bundleId = ""] = output.split("\n");
+        return agentFamilyForApplication(name, bundleId);
     }
     catch {
         /* Accessibility may be unavailable; fall back to newest log. */
     }
     return null;
 }
+export function agentFamilyForApplication(name, bundleId = "") {
+    const appName = name.trim().toLowerCase();
+    const appId = bundleId.trim().toLowerCase();
+    if (appId === "com.openai.codex" || appName.includes("codex"))
+        return "codex";
+    if (appId === "com.anthropic.claudefordesktop" || appName.includes("claude"))
+        return "claude";
+    return null;
+}
+export function agentFamily(client) {
+    return client === "codex" ? "codex" : "claude";
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -392,6 +431,41 @@ function defaultLabel(client) {
         return "Claude Code";
     return "Claude Desktop";
 }
+function listClaudeSessionMetadataFiles() {
+    const roots = [
+        homePath("Library", "Application Support", "Claude", "claude-code-sessions"),
+        homePath("Library", "Application Support", "Claude", "local-agent-mode-sessions"),
+    ];
+    const files = [];
+    for (const root of roots) {
+        for (const account of childDirectories(root)) {
+            for (const organization of childDirectories(account)) {
+                let entries = [];
+                try {
+                    entries = fs.readdirSync(organization, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const entry of entries) {
+                    if (entry.isFile() && /^local_[0-9a-f-]+\.json$/i.test(entry.name))
+                        files.push(path.join(organization, entry.name));
+                }
+            }
+        }
+    }
+    return files.sort();
+}
+function childDirectories(root) {
+    try {
+        return fs.readdirSync(root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(root, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
 // Recognizable label = basename of the session's cwd. Both Codex rollouts and Claude transcripts
 // carry a "cwd" field; the Claude Code active source is the echo-ctx cache (<sessionId>.json, no cwd),
 // so resolve its transcript by sessionId first. Falls back to the client name when cwd is absent.
@@ -400,6 +474,19 @@ function sessionLabel(file, client) {
     const cwd = peekCwd(target);
     return cwd ? path.basename(cwd) : defaultLabel(client);
 }
+function sessionTimeLabel(file) {
+    try {
+        const date = new Date(fs.statSync(file).mtimeMs);
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const hour = String(date.getHours()).padStart(2, "0");
+        const minute = String(date.getMinutes()).padStart(2, "0");
+        return `${month}/${day} ${hour}:${minute}`;
+    }
+    catch {
+        return sessionIdFromPath(file).slice(0, 8) || "session";
+    }
+}
 // The Claude Code active source is the echo-ctx cache (<sessionId>.json), whose mtime only bumps when
 // the statusline re-renders — stale during a long turn. The transcript grows every tool call, so it's
 // the true liveness signal. Take the fresher of the two. Cached per cache-file (paths are stable).

package/dist/hud/preload.cjs

@@ -7,6 +7,9 @@ electron_1.contextBridge.exposeInMainWorld("echomemHud", {
     setOpen(open, height) {
         electron_1.ipcRenderer.send("hud:set-open", { open, height });
     },
+    setMini(mini) {
+        electron_1.ipcRenderer.send("hud:set-mini", { mini });
+    },
     startDrag(screenX, screenY) {
         electron_1.ipcRenderer.send("hud:drag-start", { screenX, screenY });
     },