@echomem/mcp 1.4.6 → 1.4.8

package/dist/hud/autostart.js

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+// Show-after-restart for the HUD via a macOS LaunchAgent. We ship a CLI, not an .app bundle, so this is
+// the standard way to make the overlay persist across quit/reboot. Shared by the CLI (`echomem-hud
+// autostart`) and the Electron context menu so both write an identical, robust registration.
+const LABEL = "com.echomem.hud";
+export function autostartPlistPath() {
+    return path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+export function autostartSupported() {
+    return process.platform === "darwin";
+}
+export function isAutostartEnabled() {
+    return autostartSupported() && fs.existsSync(autostartPlistPath());
+}
+function escapeXml(value) {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function launchctlUid() {
+    return typeof process.getuid === "function" ? process.getuid() : 501;
+}
+/**
+ * Register the LaunchAgent. `programArgs` is the full ProgramArguments array — the caller supplies the
+ * exact launch command (electron binary + electron-main.js + flags) so it works regardless of whether
+ * node is on launchd's PATH. Loads immediately as well as at future logins.
+ */
+export function enableAutostart(programArgs) {
+    if (!autostartSupported())
+        return { ok: false, message: "autostart is currently macOS-only." };
+    const plist = autostartPlistPath();
+    const argsXml = programArgs.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key><array>
+${argsXml}
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>/tmp/echomem-hud.log</string>
+  <key>StandardErrorPath</key><string>/tmp/echomem-hud.log</string>
+</dict></plist>
+`;
+    fs.mkdirSync(path.dirname(plist), { recursive: true });
+    fs.writeFileSync(plist, xml);
+    const uid = launchctlUid();
+    spawnSync("launchctl", ["bootout", `gui/${uid}/${LABEL}`], { stdio: "ignore" }); // replace stale reg
+    const boot = spawnSync("launchctl", ["bootstrap", `gui/${uid}`, plist], { encoding: "utf8" });
+    return boot.status === 0
+        ? { ok: true, message: `EchoMem HUD will show after restart. Off anytime: echomem-hud autostart off` }
+        : { ok: true, message: `Wrote ${plist} — shows after your next restart.` };
+}
+export function disableAutostart() {
+    if (!autostartSupported())
+        return;
+    const uid = launchctlUid();
+    spawnSync("launchctl", ["bootout", `gui/${uid}/${LABEL}`], { stdio: "ignore" });
+    try {
+        fs.rmSync(autostartPlistPath(), { force: true });
+    }
+    catch {
+        /* already gone */
+    }
+}

package/dist/hud/cli.js

@@ -3,6 +3,7 @@ import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { adapterList } from "./adapters.js";
+import { autostartPlistPath, autostartSupported, disableAutostart, enableAutostart, isAutostartEnabled } from "./autostart.js";
 import { statSignature } from "./fs.js";
 import { installHooks } from "./hooks.js";
 import { HudMonitor } from "./monitor.js";
@@ -23,6 +24,8 @@ try {
         await cmdApp(flags);
     else if (command === "install-hooks")
         await cmdInstallHooks(flags);
+    else if (command === "autostart")
+        cmdAutostart(argv[1] || "status", flags);
     else if (command === "status")
         await cmdStatus(flags);
     else if (command === "report")
@@ -79,6 +82,33 @@ async function cmdApp(flags) {
     child.unref();
     console.log("EchoMem HUD app launched.");
 }
+/**
+ * `echomem-hud autostart on|off|status` — show the HUD after restart via a macOS LaunchAgent, so
+ * closing/rebooting doesn't lose it (we ship a CLI, not an .app, so this is the standard mechanism).
+ * The registration runs the electron binary directly on electron-main.js — no dependency on node
+ * being on launchd's PATH — matching what the in-app "Show after restart" toggle writes.
+ */
+function cmdAutostart(action, flags) {
+    if (!autostartSupported()) {
+        console.log("autostart is currently macOS-only (LaunchAgent).");
+        return;
+    }
+    if (action === "on") {
+        const require = createRequire(import.meta.url);
+        const electronPath = require("electron");
+        const mainPath = fileURLToPath(new URL("./electron-main.js", import.meta.url));
+        const client = typeof flags.client === "string" ? flags.client : "auto";
+        const result = enableAutostart([electronPath, mainPath, "--client", client]);
+        console.log(`✅ ${result.message}`);
+        return;
+    }
+    if (action === "off") {
+        disableAutostart();
+        console.log("✅ Show after restart disabled — the HUD will not relaunch after restart.");
+        return;
+    }
+    console.log(isAutostartEnabled() ? `Autostart: ON (${autostartPlistPath()})` : "Autostart: OFF. Enable with: echomem-hud autostart on");
+}
 async function cmdInstallHooks(flags) {
     const paths = installHooks(parseMode(flags.client));
     console.log(`Installed EchoMem HUD hook support:\n${paths.map((p) => `- ${p}`).join("\n")}`);
@@ -136,6 +166,7 @@ Usage:
   echomem-hud serve [--client codex|claude-code|claude-desktop|both|auto] [--port 17377]
   echomem-hud app [--client codex|claude-code|claude-desktop|both|auto]
   echomem-hud install-hooks [--client codex|claude-code|both]
+  echomem-hud autostart on|off|status   (show the HUD after restart — macOS)
   echomem-hud status
   echomem-hud report [--client codex|claude-code|claude-desktop|auto] [--limit 40] [--json]
 `);

package/dist/hud/electron-main.js

@@ -1,8 +1,10 @@
+import { execFileSync } from "node:child_process";
 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, shell } from "electron";
+import { app, BrowserWindow, dialog, ipcMain, Menu, nativeImage, screen, shell } from "electron";
+import { disableAutostart, enableAutostart, isAutostartEnabled } from "./autostart.js";
 import { createHudServer } from "./server.js";
 const flags = parseFlags(process.argv.slice(2));
 const mode = parseMode(flags.client);
@@ -10,8 +12,17 @@ const port = typeof flags.port === "string" ? Number(flags.port) || 17377 : 1737
 const COLLAPSED_WIDTH = 360;
 const COLLAPSED_HEIGHT = 112;
 const EXPANDED_HEIGHT = 460;
+// Mini mode: a small always-on pill (status dot + tokens) for users who find the full bubble too big.
+const MINI_WIDTH = 190;
+const MINI_HEIGHT = 48;
+const AGENT_VISIBILITY_POLL_MS = 900;
+let miniPref = false;
+let onlyShowWhenAgentOpen = false;
+let manuallyHidden = false;
 let hudServer = null;
 let mainWindow = null;
+let visibilityTimer = null;
+const dragState = new Map();
 // Single-instance: a second `echomem-hud app` brings the existing HUD back instead of opening another.
 const gotSingleInstanceLock = app.requestSingleInstanceLock();
 if (!gotSingleInstanceLock)
@@ -27,10 +38,52 @@ app.whenReady().then(async () => {
         if (!win)
             return;
         const bounds = win.getBounds();
-        const height = open ? clampExpandedHeight(measured && measured > 200 ? measured : EXPANDED_HEIGHT) : COLLAPSED_HEIGHT;
-        win.setBounds({ ...bounds, height });
+        // Closing returns to the user's preferred resting size (mini pill or the full bubble).
+        const width = open ? COLLAPSED_WIDTH : miniPref ? MINI_WIDTH : COLLAPSED_WIDTH;
+        const height = open ? clampExpandedHeight(measured && measured > 200 ? measured : EXPANDED_HEIGHT) : miniPref ? MINI_HEIGHT : COLLAPSED_HEIGHT;
+        win.setBounds({ ...bounds, width, height });
         writeBounds(win);
     });
+    ipcMain.on("hud:set-mini", (event, payload) => {
+        miniPref = typeof payload === "object" ? Boolean(payload.mini) : Boolean(payload);
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (!win)
+            return;
+        const bounds = win.getBounds();
+        win.setBounds({
+            ...bounds,
+            width: miniPref ? MINI_WIDTH : COLLAPSED_WIDTH,
+            height: miniPref ? MINI_HEIGHT : COLLAPSED_HEIGHT,
+        });
+        writeBounds(win);
+    });
+    ipcMain.on("hud:drag-start", (event, payload) => {
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (!win)
+            return;
+        const point = dragPoint(payload);
+        if (!point)
+            return;
+        dragState.set(event.sender.id, { ...point, bounds: win.getBounds() });
+    });
+    ipcMain.on("hud:drag-move", (event, payload) => {
+        const win = BrowserWindow.fromWebContents(event.sender);
+        const state = dragState.get(event.sender.id);
+        const point = dragPoint(payload);
+        if (!win || !state || !point)
+            return;
+        win.setBounds({
+            ...state.bounds,
+            x: Math.round(state.bounds.x + point.startX - state.startX),
+            y: Math.round(state.bounds.y + point.startY - state.startY),
+        });
+    });
+    ipcMain.on("hud:drag-end", (event) => {
+        dragState.delete(event.sender.id);
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (win)
+            writeBounds(win);
+    });
     const preferredUrl = `http://127.0.0.1:${port}`;
     const onReveal = (filePath) => {
         try {
@@ -40,8 +93,16 @@ app.whenReady().then(async () => {
             /* best-effort */
         }
     };
+    const onOpenExternal = (externalUrl) => {
+        try {
+            shell.openExternal(externalUrl);
+        }
+        catch {
+            /* best-effort */
+        }
+    };
     try {
-        hudServer = await createHudServer({ mode, port, onReveal });
+        hudServer = await createHudServer({ mode, port, onReveal, onOpenExternal });
         createWindow(hudServer.url);
     }
     catch (error) {
@@ -49,7 +110,7 @@ app.whenReady().then(async () => {
             createWindow(preferredUrl);
             return;
         }
-        hudServer = await createHudServer({ mode, port: 0, onReveal });
+        hudServer = await createHudServer({ mode, port: 0, onReveal, onOpenExternal });
         createWindow(hudServer.url);
     }
 }).catch((error) => {
@@ -63,10 +124,12 @@ app.on("window-all-closed", async () => {
 });
 function createWindow(url) {
     const savedBounds = readBounds();
+    miniPref = Boolean(savedBounds?.mini);
+    onlyShowWhenAgentOpen = Boolean(savedBounds?.onlyShowWhenAgentOpen);
     const bounds = savedBounds ? normalizedBounds(savedBounds) : defaultBounds();
     const win = new BrowserWindow({
-        width: COLLAPSED_WIDTH,
-        height: COLLAPSED_HEIGHT,
+        width: miniPref ? MINI_WIDTH : COLLAPSED_WIDTH,
+        height: miniPref ? MINI_HEIGHT : COLLAPSED_HEIGHT,
         x: bounds.x,
         y: bounds.y,
         frame: false,
@@ -90,14 +153,30 @@ function createWindow(url) {
     }
     win.on("moved", () => writeBounds(win));
     mainWindow = win;
-    win.on("closed", () => { if (mainWindow === win)
-        mainWindow = null; });
+    const webContentsId = win.webContents.id;
+    win.on("closed", () => {
+        dragState.delete(webContentsId);
+        stopAgentVisibilityLoop();
+        if (mainWindow === win)
+            mainWindow = null;
+    });
     win.webContents.on("context-menu", () => {
         const menu = Menu.buildFromTemplate([
-            { label: "Hide for now", click: () => { if (!win.isDestroyed())
-                    win.hide(); } },
+            { label: "Hide for now", click: () => { hideForNow(win); } },
+            {
+                label: "Only show when Codex/Claude is open",
+                type: "checkbox",
+                checked: onlyShowWhenAgentOpen,
+                click: (item) => { setOnlyShowWhenAgentOpen(item.checked, win); },
+            },
+            {
+                label: "Show after restart",
+                type: "checkbox",
+                checked: isAutostartEnabled(),
+                click: (item) => { setAutostart(item.checked); },
+            },
             { type: "separator" },
-            { label: "Quit EchoMem HUD", click: () => app.quit() },
+            { label: "Quit EchoMem HUD", click: () => quitWithAutostartPrompt(win) },
         ]);
         menu.popup({ window: win });
     });
@@ -106,10 +185,11 @@ function createWindow(url) {
         if (shown || win.isDestroyed())
             return;
         shown = true;
-        app.focus({ steal: true });
-        win.show();
-        win.moveTop();
-        win.focus();
+        if (onlyShowWhenAgentOpen)
+            syncAgentVisibility(win);
+        else
+            showHudWindow(win, true);
+        startAgentVisibilityLoop(win);
         writeBounds(win);
     };
     win.once("ready-to-show", reveal);
@@ -119,6 +199,31 @@ function createWindow(url) {
         win.webContents.openDevTools({ mode: "detach" });
     win.loadURL(url);
 }
+// Show-after-restart registration that runs THIS electron binary on electron-main.js directly — no node
+// PATH dependency. Mirrors what `echomem-hud autostart on` writes, so CLI and menu stay in sync.
+function setAutostart(on) {
+    if (on)
+        enableAutostart([process.execPath, fileURLPath("./electron-main.js"), "--client", String(mode), "--port", String(port)]);
+    else
+        disableAutostart();
+}
+// Quitting is the moment the HUD truly disappears (unlike "Hide for now"), so if it won't come back on
+// its own, that's exactly when to offer show-after-restart — per the user's "ask me when it goes away".
+function quitWithAutostartPrompt(win) {
+    if (process.platform !== "darwin" || isAutostartEnabled())
+        return void app.quit();
+    const choice = showRecoveryPrompt({
+        buttons: ["Show after restart & quit", "Just quit", "Cancel"],
+        cancelId: 2,
+        message: "Bring EchoMem back automatically?",
+        detail: "EchoMem has no app icon to relaunch from. Turn on Show after restart and it will be waiting after your computer restarts. You can also tell your coding agent to run `echomem-hud app`.",
+    });
+    if (choice === 2)
+        return;
+    if (choice === 0)
+        setAutostart(true);
+    app.quit();
+}
 function clampExpandedHeight(value) {
     const workArea = screen.getPrimaryDisplay().workArea;
     const max = Math.max(COLLAPSED_HEIGHT, workArea.height - 48);
@@ -127,11 +232,11 @@ function clampExpandedHeight(value) {
 function showExistingWindow() {
     if (!mainWindow || mainWindow.isDestroyed())
         return;
-    if (!mainWindow.isVisible())
-        mainWindow.show();
-    mainWindow.moveTop();
-    app.focus({ steal: true });
-    mainWindow.focus();
+    manuallyHidden = false;
+    if (onlyShowWhenAgentOpen)
+        syncAgentVisibility(mainWindow);
+    else
+        showHudWindow(mainWindow, true);
 }
 async function hasCompatibleHudState(baseUrl, requestedMode) {
     const signal = AbortSignal.timeout(750);
@@ -205,7 +310,109 @@ function clamp(value, min, max) {
 function writeBounds(win) {
     const b = win.getBounds();
     fs.mkdirSync(path.dirname(boundsPath()), { recursive: true });
-    fs.writeFileSync(boundsPath(), JSON.stringify(b, null, 2));
+    fs.writeFileSync(boundsPath(), JSON.stringify({ ...b, mini: miniPref, onlyShowWhenAgentOpen }, null, 2));
+}
+function hideForNow(win) {
+    if (win.isDestroyed())
+        return;
+    if (process.platform === "darwin" && !isAutostartEnabled()) {
+        const choice = showRecoveryPrompt({
+            buttons: ["Show after restart & hide", "Hide for now", "Cancel"],
+            cancelId: 2,
+            message: "Hide EchoMem for now?",
+            detail: "It will stay hidden until you restart it. Turn on Show after restart to bring it back after your computer restarts. Before then, you can ask your coding agent to run `echomem-hud app`.",
+        });
+        if (choice === 2)
+            return;
+        if (choice === 0)
+            setAutostart(true);
+    }
+    manuallyHidden = true;
+    win.hide();
+}
+function showRecoveryPrompt(options) {
+    app.focus({ steal: true });
+    const cancelId = typeof options.cancelId === "number" ? options.cancelId : options.buttons.length - 1;
+    const { cancelId: _cancelId, ...dialogOptions } = options;
+    return dialog.showMessageBoxSync({
+        type: "question",
+        defaultId: 0,
+        cancelId,
+        icon: nativeImage.createFromPath(fileURLPath("../../assets/hud/echo-face-cutout.png")),
+        ...dialogOptions,
+    });
+}
+function setOnlyShowWhenAgentOpen(next, win) {
+    onlyShowWhenAgentOpen = next;
+    manuallyHidden = false;
+    writeBounds(win);
+    if (next)
+        syncAgentVisibility(win);
+    else
+        showHudWindow(win, true);
+}
+function startAgentVisibilityLoop(win) {
+    stopAgentVisibilityLoop();
+    visibilityTimer = setInterval(() => syncAgentVisibility(win), AGENT_VISIBILITY_POLL_MS);
+}
+function stopAgentVisibilityLoop() {
+    if (!visibilityTimer)
+        return;
+    clearInterval(visibilityTimer);
+    visibilityTimer = null;
+}
+function syncAgentVisibility(win) {
+    if (win.isDestroyed() || !onlyShowWhenAgentOpen)
+        return;
+    const frontmost = frontmostAppKind();
+    if (frontmost === "agent") {
+        if (!manuallyHidden && !win.isVisible())
+            showHudWindow(win, false);
+        else if (!manuallyHidden)
+            win.moveTop();
+        return;
+    }
+    // Leave the HUD alone while the user is interacting with the HUD/menu itself, or when macOS does
+    // not report a frontmost process. The next concrete app detection will settle visibility.
+    if (frontmost === "self" || frontmost === "unknown")
+        return;
+    if (win.isVisible())
+        win.hide();
+}
+function showHudWindow(win, focus) {
+    if (win.isDestroyed())
+        return;
+    if (focus) {
+        app.focus({ steal: true });
+        win.show();
+        win.focus();
+    }
+    else {
+        win.showInactive();
+    }
+    win.moveTop();
+}
+function frontmostAppKind() {
+    if (process.platform !== "darwin")
+        return "unknown";
+    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)
+            return "unknown";
+        if (name.includes("codex") || name.includes("claude"))
+            return "agent";
+        if (name.includes("echomem") || name.includes("electron") || name === app.getName().toLowerCase())
+            return "self";
+        return "other";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function dragPoint(payload) {
+    const startX = typeof payload.screenX === "number" && Number.isFinite(payload.screenX) ? payload.screenX : null;
+    const startY = typeof payload.screenY === "number" && Number.isFinite(payload.screenY) ? payload.screenY : null;
+    return startX === null || startY === null ? null : { startX, startY };
 }
 function parseFlags(argv) {
     const parsed = {};

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,7 +18,6 @@ export class HudMonitor extends EventEmitter {
     labelCache = new Map();
     missing = [];
     frontmostCheckedAt = 0;
-    frontmostSeenAt = 0;
     frontmostClient = null;
     lastActiveClient = null;
     threadCounts = {};
@@ -65,17 +63,13 @@ export class HudMonitor extends EventEmitter {
                 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;
-        });
+        // 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 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;
+        const pinnedId = pinned ? this.pinnedId : null;
         return {
             mode: this.mode,
             active: ordered[0] || null,
@@ -83,6 +77,7 @@ export class HudMonitor extends EventEmitter {
             sessions: ordered,
             threadCounts: this.threadCounts,
             recentSessions: this.recentSessions,
+            pinnedId,
             missing: this.missing,
             updatedAt: new Date().toISOString(),
         };
@@ -139,13 +134,6 @@ export class HudMonitor extends EventEmitter {
             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;
             }
         }
         return this.frontmostClient && this.scores.has(this.frontmostClient) ? this.frontmostClient : null;
@@ -213,60 +201,15 @@ export class HudMonitor extends EventEmitter {
                 return title;
         }
         else {
-            const title = this.claudeTitle(file);
-            if (title)
-                return title;
+            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() {
@@ -360,6 +303,18 @@ export class HudMonitor extends EventEmitter {
             this.emit("state", this.snapshot());
     }
 }
+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}`;
+}
 function detectFrontmostClient() {
     if (process.platform !== "darwin")
         return null;
@@ -400,6 +355,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,4 +7,16 @@ 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 });
+    },
+    moveDrag(screenX, screenY) {
+        electron_1.ipcRenderer.send("hud:drag-move", { screenX, screenY });
+    },
+    endDrag() {
+        electron_1.ipcRenderer.send("hud:drag-end");
+    },
 });