@echomem/mcp 1.4.1 → 1.4.2

package/dist/hud/electron-main.js

@@ -0,0 +1,224 @@
+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 { createHudServer } from "./server.js";
+const flags = parseFlags(process.argv.slice(2));
+const mode = parseMode(flags.client);
+const port = typeof flags.port === "string" ? Number(flags.port) || 17377 : 17377;
+const COLLAPSED_WIDTH = 360;
+const COLLAPSED_HEIGHT = 112;
+const EXPANDED_HEIGHT = 460;
+let hudServer = null;
+let mainWindow = null;
+// Single-instance: a second `echomem-hud app` brings the existing HUD back instead of opening another.
+const gotSingleInstanceLock = app.requestSingleInstanceLock();
+if (!gotSingleInstanceLock)
+    app.quit();
+app.on("second-instance", showExistingWindow);
+app.whenReady().then(async () => {
+    if (!gotSingleInstanceLock)
+        return;
+    ipcMain.on("hud:set-open", (event, payload) => {
+        const open = typeof payload === "object" ? Boolean(payload.open) : Boolean(payload);
+        const measured = typeof payload === "object" && typeof payload.height === "number" ? payload.height : undefined;
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (!win)
+            return;
+        const bounds = win.getBounds();
+        const height = open ? clampExpandedHeight(measured && measured > 200 ? measured : EXPANDED_HEIGHT) : COLLAPSED_HEIGHT;
+        win.setBounds({ ...bounds, height });
+        writeBounds(win);
+    });
+    const preferredUrl = `http://127.0.0.1:${port}`;
+    try {
+        hudServer = await createHudServer({ mode, port });
+        createWindow(hudServer.url);
+    }
+    catch (error) {
+        if (isAddrInUse(error) && await hasCompatibleHudState(preferredUrl, mode)) {
+            createWindow(preferredUrl);
+            return;
+        }
+        hudServer = await createHudServer({ mode, port: 0 });
+        createWindow(hudServer.url);
+    }
+}).catch((error) => {
+    console.error(error instanceof Error ? error.stack || error.message : String(error));
+    app.quit();
+});
+app.on("window-all-closed", async () => {
+    if (hudServer)
+        await hudServer.close();
+    app.quit();
+});
+function createWindow(url) {
+    const savedBounds = readBounds();
+    const bounds = savedBounds ? normalizedBounds(savedBounds) : defaultBounds();
+    const win = new BrowserWindow({
+        width: COLLAPSED_WIDTH,
+        height: COLLAPSED_HEIGHT,
+        x: bounds.x,
+        y: bounds.y,
+        frame: false,
+        resizable: false,
+        show: false,
+        transparent: true,
+        alwaysOnTop: true,
+        skipTaskbar: true,
+        acceptFirstMouse: true,
+        title: "EchoMem Context HUD",
+        webPreferences: {
+            contextIsolation: true,
+            nodeIntegration: false,
+            preload: fileURLPath("./preload.cjs"),
+        },
+    });
+    win.setAlwaysOnTop(true, "floating");
+    if (process.platform === "darwin") {
+        win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+        win.setFullScreenable(false);
+    }
+    win.on("moved", () => writeBounds(win));
+    mainWindow = win;
+    win.on("closed", () => { if (mainWindow === win)
+        mainWindow = null; });
+    win.webContents.on("context-menu", () => {
+        const menu = Menu.buildFromTemplate([
+            { label: "Hide for now", click: () => { if (!win.isDestroyed())
+                    win.hide(); } },
+            { type: "separator" },
+            { label: "Quit EchoMem HUD", click: () => app.quit() },
+        ]);
+        menu.popup({ window: win });
+    });
+    let shown = false;
+    const reveal = () => {
+        if (shown || win.isDestroyed())
+            return;
+        shown = true;
+        app.focus({ steal: true });
+        win.show();
+        win.moveTop();
+        win.focus();
+        writeBounds(win);
+    };
+    win.once("ready-to-show", reveal);
+    win.webContents.once("did-finish-load", reveal);
+    setTimeout(reveal, 1200);
+    if (process.env.ECHO_HUD_DEBUG)
+        win.webContents.openDevTools({ mode: "detach" });
+    win.loadURL(url);
+}
+function clampExpandedHeight(value) {
+    const workArea = screen.getPrimaryDisplay().workArea;
+    const max = Math.max(COLLAPSED_HEIGHT, workArea.height - 48);
+    return Math.min(max, Math.max(COLLAPSED_HEIGHT, Math.round(value)));
+}
+function showExistingWindow() {
+    if (!mainWindow || mainWindow.isDestroyed())
+        return;
+    if (!mainWindow.isVisible())
+        mainWindow.show();
+    mainWindow.moveTop();
+    app.focus({ steal: true });
+    mainWindow.focus();
+}
+async function hasCompatibleHudState(baseUrl, requestedMode) {
+    const signal = AbortSignal.timeout(750);
+    try {
+        const res = await fetch(`${baseUrl}/state`, { signal });
+        if (!res.ok)
+            return false;
+        const state = await res.json();
+        return compatibleMode(state.mode, requestedMode);
+    }
+    catch {
+        return false;
+    }
+}
+function compatibleMode(existingMode, requestedMode) {
+    if (existingMode === requestedMode)
+        return true;
+    const allSources = new Set(["auto", "both"]);
+    return typeof existingMode === "string" && allSources.has(existingMode) && allSources.has(requestedMode);
+}
+function isAddrInUse(error) {
+    return error instanceof Error && "code" in error && error.code === "EADDRINUSE";
+}
+function fileURLPath(relativePath) {
+    return fileURLToPath(new URL(relativePath, import.meta.url));
+}
+function boundsPath() {
+    return path.join(os.homedir(), ".echomem", "hud-window.json");
+}
+function readBounds() {
+    try {
+        return JSON.parse(fs.readFileSync(boundsPath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function defaultBounds() {
+    const width = COLLAPSED_WIDTH;
+    const workArea = screen.getPrimaryDisplay().workArea;
+    return {
+        width,
+        height: COLLAPSED_HEIGHT,
+        x: Math.max(workArea.x + 12, workArea.x + workArea.width - width - 24),
+        y: workArea.y + 24,
+    };
+}
+function normalizedBounds(saved) {
+    if (!saved)
+        return defaultBounds();
+    const width = COLLAPSED_WIDTH;
+    const height = COLLAPSED_HEIGHT;
+    const proposed = { x: saved.x, y: saved.y, width, height };
+    const displays = screen.getAllDisplays().map((display) => display.workArea);
+    const workArea = displays.find((area) => intersects(area, proposed)) ?? screen.getPrimaryDisplay().workArea;
+    return {
+        width,
+        height,
+        x: clamp(saved.x, workArea.x + 12, workArea.x + workArea.width - width - 12),
+        y: clamp(saved.y, workArea.y + 12, workArea.y + workArea.height - height - 12),
+    };
+}
+function intersects(a, b) {
+    return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+function clamp(value, min, max) {
+    if (max < min)
+        return min;
+    return Math.min(Math.max(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));
+}
+function parseFlags(argv) {
+    const parsed = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg.startsWith("--"))
+            continue;
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next && !next.startsWith("--")) {
+            parsed[key] = next;
+            i += 1;
+        }
+        else {
+            parsed[key] = true;
+        }
+    }
+    return parsed;
+}
+function parseMode(value) {
+    return value === "codex" || value === "claude-code" || value === "claude-desktop" || value === "both" || value === "auto"
+        ? value
+        : "auto";
+}

package/dist/hud/fs.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function homePath(...segments) {
+    return path.join(os.homedir(), ...segments);
+}
+export function walkFiles(root, predicate, out = []) {
+    let entries = [];
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = path.join(root, entry.name);
+        if (entry.isDirectory())
+            walkFiles(full, predicate, out);
+        else if (predicate(full))
+            out.push(full);
+    }
+    return out;
+}
+export function newestFile(files) {
+    let newest = null;
+    for (const file of files) {
+        try {
+            const stat = fs.statSync(file);
+            if (!newest || stat.mtimeMs > newest.mtimeMs)
+                newest = { file, mtimeMs: stat.mtimeMs };
+        }
+        catch {
+            // ignore disappearing live files
+        }
+    }
+    return newest?.file || null;
+}
+export function readJsonl(file) {
+    const text = fs.readFileSync(file, "utf8");
+    const records = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            records.push(JSON.parse(line));
+        }
+        catch {
+            // Malformed/incomplete live lines are ignored; the next poll can parse the completed record.
+        }
+    }
+    return records;
+}
+export function statSignature(file) {
+    if (!file)
+        return "";
+    try {
+        const stat = fs.statSync(file);
+        return `${file}:${stat.size}:${stat.mtimeMs}`;
+    }
+    catch {
+        return "";
+    }
+}

package/dist/hud/hooks.js

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function installHooks(mode) {
+    const written = [];
+    if (mode === "codex" || mode === "both" || mode === "auto") {
+        written.push(installCodexHooks());
+    }
+    if (mode === "claude-code" || mode === "both" || mode === "auto") {
+        written.push(installClaudeCodeSnippet());
+    }
+    return written;
+}
+function installCodexHooks() {
+    const dir = path.join(os.homedir(), ".codex");
+    const file = path.join(dir, "hooks.json");
+    fs.mkdirSync(dir, { recursive: true });
+    const hookCommand = `${JSON.stringify(process.execPath)} ${JSON.stringify(process.argv[1])} summary --client codex --json`;
+    const content = readHooksFile(file);
+    content.hooks = content.hooks || {};
+    content.hooks.PostToolUse = mergeHookGroup(content.hooks.PostToolUse, { matcher: "*", hooks: [{ type: "command", command: hookCommand, timeout: 5 }] });
+    content.hooks.PostCompact = mergeHookGroup(content.hooks.PostCompact, { hooks: [{ type: "command", command: hookCommand, timeout: 5 }] });
+    content.hooks.Stop = mergeHookGroup(content.hooks.Stop, { hooks: [{ type: "command", command: hookCommand, timeout: 5 }] });
+    fs.writeFileSync(file, JSON.stringify(content, null, 2));
+    return file;
+}
+function installClaudeCodeSnippet() {
+    const dir = path.join(os.homedir(), ".claude", "echo-ctx");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function readHooksFile(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function mergeHookGroup(existing, group) {
+    const groups = Array.isArray(existing) ? existing.filter((item) => !isEchoHudGroup(item)) : [];
+    groups.push(group);
+    return groups;
+}
+function isEchoHudGroup(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return JSON.stringify(value).includes("summary --client codex --json");
+}

package/dist/hud/metric.js

@@ -0,0 +1,158 @@
+export const BUCKETS = {
+    rangeRedundant: "range_redundant",
+    staleRead: "stale_read",
+    supersededImage: "superseded_image",
+    staleToolOutput: "stale_tool_output",
+    compactionRecoverable: "compaction_recoverable",
+};
+const SHELL_READ_BINS = new Set(["cat", "head", "tail", "sed", "nl", "less", "more", "bat"]);
+const EXT = /\.[A-Za-z0-9]{1,8}$/;
+export function newMetricState() {
+    return {
+        turn: 0,
+        reads: 0,
+        redundantCount: 0,
+        readHist: new Map(),
+        editTurn: new Map(),
+        buckets: {
+            [BUCKETS.rangeRedundant]: { tokens: 0, count: 0 },
+            [BUCKETS.staleRead]: { tokens: 0, count: 0 },
+            [BUCKETS.supersededImage]: { tokens: 0, count: 0 },
+            [BUCKETS.staleToolOutput]: { tokens: 0, count: 0 },
+            [BUCKETS.compactionRecoverable]: { tokens: 0, count: 0 },
+        },
+        tools: {},
+    };
+}
+export function bumpTurn(state) {
+    state.turn += 1;
+}
+export function recordTool(state, name) {
+    if (!name)
+        return;
+    state.tools[name] = (state.tools[name] || 0) + 1;
+}
+export function recordEdit(state, file) {
+    if (!file)
+        return;
+    state.editTurn.set(file, state.turn);
+}
+export function recordRead(state, file, start = 1, end = 1e9) {
+    if (!file)
+        return;
+    const safeStart = Number(start) || 1;
+    const safeEnd = Number(end) || 1e9;
+    const tokens = estimateReadTokens(safeStart, safeEnd);
+    const previous = state.readHist.get(file) || [];
+    const lastEdit = state.editTurn.get(file) ?? -1;
+    const redundant = previous.some((read) => read.turn >= lastEdit && safeStart <= read.end && safeEnd >= read.start);
+    state.reads += 1;
+    if (redundant) {
+        addBucket(state, BUCKETS.rangeRedundant, tokens, 1);
+        state.redundantCount += 1;
+    }
+    previous.push({ start: safeStart, end: safeEnd, turn: state.turn, tokens });
+    state.readHist.set(file, previous);
+}
+export function addBucket(state, bucket, tokens, count = 1) {
+    state.buckets[bucket].tokens += Math.max(0, Math.round(tokens));
+    state.buckets[bucket].count += Math.max(0, count);
+}
+export function scoreMetric(params) {
+    const ct = Number(params.ctTokens) || 0;
+    const modelWindow = Number(params.modelContextWindow) || 0;
+    const pollutionTok = Object.values(params.state.buckets).reduce((sum, bucket) => sum + bucket.tokens, 0);
+    const pollution = ct > 0 ? Math.min(0.95, pollutionTok / ct) : 0;
+    const pollutionPct = Math.round(pollution * 100);
+    const saturationPct = modelWindow > 0 ? Math.round((ct / modelWindow) * 100) : null;
+    return {
+        client: params.client,
+        sourcePath: params.sourcePath,
+        turn: params.state.turn,
+        reads: params.state.reads,
+        redundantCount: params.state.redundantCount,
+        usefulPct: Math.round((1 - pollution) * 100),
+        pollutionPct,
+        pollutionTok,
+        ctTokens: ct,
+        ctSource: params.ctSource,
+        modelContextWindow: modelWindow || null,
+        saturationPct,
+        color: qualityColor(pollutionPct, saturationPct),
+        buckets: cloneBuckets(params.state.buckets),
+        honesty: "tracked lower bound",
+        updatedAt: params.updatedAt || new Date().toISOString(),
+        stats: params.stats,
+        tools: { ...params.state.tools },
+    };
+}
+export function shellRead(cmd) {
+    const text = String(cmd || "").trim();
+    if (!text)
+        return null;
+    const firstPipeline = text.split(/[|;&]/)[0].trim();
+    const tokens = firstPipeline.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    if (!tokens.length)
+        return null;
+    let bin = stripQuotes(tokens[0] || "").split("/").pop() || "";
+    if (bin === "sudo")
+        bin = stripQuotes(tokens[1] || "").split("/").pop() || "";
+    if (!SHELL_READ_BINS.has(bin))
+        return null;
+    let file = "";
+    for (let i = tokens.length - 1; i >= 1; i -= 1) {
+        const token = stripQuotes(tokens[i] || "");
+        if (!token || token.startsWith("-") || /^\d+(,\d+)?p?$/.test(token))
+            continue;
+        if (token.includes("/") || EXT.test(token)) {
+            file = token;
+            break;
+        }
+    }
+    if (!file)
+        return null;
+    const [start, end] = rangeFromCmd(text);
+    return { file, start, end };
+}
+export function formatTokens(tokens) {
+    const n = Number(tokens) || 0;
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(n >= 10_000_000 ? 0 : 1)}m`;
+    if (n >= 1_000)
+        return `${Math.round(n / 1_000)}k`;
+    return String(Math.round(n));
+}
+export function formatGlance(score) {
+    const dot = score.color === "amber" ? "◑" : "●";
+    return `${dot} ${score.usefulPct}% clean · ${formatTokens(score.ctTokens)}`;
+}
+function estimateReadTokens(start, end) {
+    const boundedEnd = Math.min(end, start + 4000);
+    const lines = Math.max(1, boundedEnd - start + 1);
+    return Math.min(8000, Math.max(40, lines * 12));
+}
+function qualityColor(pollutionPct, saturationPct) {
+    if (pollutionPct > 40 || (saturationPct !== null && saturationPct >= 95))
+        return "red";
+    if (pollutionPct >= 25 || (saturationPct !== null && saturationPct >= 90))
+        return "amber";
+    return "green";
+}
+function rangeFromCmd(cmd) {
+    const sed = cmd.match(/\bsed\s+(?:[^\n;|&]*?\s)?-n\s*['"]?\s*(\d+)\s*,\s*(\d+)\s*p/);
+    if (sed)
+        return [Number(sed[1]), Number(sed[2])];
+    const nlSed = cmd.match(/\bnl\b[\s\S]*?\|\s*sed\s+-n\s*['"]?\s*(\d+)\s*,\s*(\d+)\s*p/);
+    if (nlSed)
+        return [Number(nlSed[1]), Number(nlSed[2])];
+    const head = cmd.match(/\bhead\s+(?:-n\s*)?(\d+)\b/);
+    if (head)
+        return [1, Number(head[1])];
+    return [1, 1e9];
+}
+function stripQuotes(value) {
+    return value.replace(/^['"]|['"]$/g, "");
+}
+function cloneBuckets(buckets) {
+    return Object.fromEntries(Object.entries(buckets).map(([name, value]) => [name, { ...value }]));
+}

package/dist/hud/monitor.js

@@ -0,0 +1,106 @@
+import { execFileSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { adapterList } from "./adapters.js";
+import { statSignature } from "./fs.js";
+export class HudMonitor extends EventEmitter {
+    mode;
+    pollMs;
+    timer = null;
+    signatures = new Map();
+    scores = new Map();
+    missing = [];
+    frontmostCheckedAt = 0;
+    frontmostClient = null;
+    lastActiveClient = null;
+    constructor(mode = "auto", pollMs = 750) {
+        super();
+        this.mode = mode;
+        this.pollMs = pollMs;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.tick();
+        this.timer = setInterval(() => this.tick(), this.pollMs);
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+    snapshot() {
+        const preferred = this.frontmostPreferredClient();
+        const scores = [...this.scores.values()].sort((a, b) => {
+            if (preferred && a.client === preferred && b.client !== preferred)
+                return -1;
+            if (preferred && b.client === preferred && a.client !== preferred)
+                return 1;
+            return Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+        });
+        return {
+            mode: this.mode,
+            active: scores[0] || null,
+            scores,
+            missing: this.missing,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    frontmostPreferredClient() {
+        if (this.mode !== "auto" && this.mode !== "both")
+            return null;
+        const now = Date.now();
+        if (now - this.frontmostCheckedAt > 1500) {
+            this.frontmostCheckedAt = now;
+            this.frontmostClient = detectFrontmostClient();
+        }
+        return this.frontmostClient && this.scores.has(this.frontmostClient) ? this.frontmostClient : null;
+    }
+    tick() {
+        const missing = [];
+        let changed = false;
+        for (const adapter of adapterList(this.mode)) {
+            const file = adapter.findActive();
+            if (!file) {
+                missing.push(adapter.client);
+                if (this.scores.delete(adapter.client))
+                    changed = true;
+                continue;
+            }
+            const signature = statSignature(file);
+            if (!signature || signature === this.signatures.get(adapter.client))
+                continue;
+            this.signatures.set(adapter.client, signature);
+            try {
+                this.scores.set(adapter.client, adapter.score(file));
+                changed = true;
+            }
+            catch (error) {
+                missing.push(`${adapter.client}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.missing = missing;
+        const activeClient = this.snapshot().active?.client ?? null;
+        if (activeClient !== this.lastActiveClient) {
+            this.lastActiveClient = activeClient;
+            changed = true;
+        }
+        if (changed)
+            this.emit("state", this.snapshot());
+    }
+}
+function detectFrontmostClient() {
+    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";
+    }
+    catch {
+        /* Accessibility may be unavailable; fall back to newest log. */
+    }
+    return null;
+}

package/dist/hud/preload.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+// CommonJS preload (.cts -> .cjs). Sandboxed Electron preloads must be CommonJS;
+// an ESM preload throws "Cannot use import statement outside a module" on load.
+electron_1.contextBridge.exposeInMainWorld("echomemHud", {
+    setOpen(open, height) {
+        electron_1.ipcRenderer.send("hud:set-open", { open, height });
+    },
+});

package/dist/hud/render.js

@@ -0,0 +1,39 @@
+import { formatGlance, formatTokens } from "./metric.js";
+export function renderScoreText(score) {
+    const range = score.buckets.range_redundant;
+    const lines = [
+        `${clientLabel(score.client)} context health: ${formatGlance(score)}`,
+        "",
+        `Tracked dead-weight ≥ ${formatTokens(score.pollutionTok)} (${score.pollutionPct}% pollution lower bound).`,
+        `Range redundant: ${formatTokens(range.tokens)} · ${range.count} reads.`,
+        `Reads: ${score.reads} · Edits: ${score.stats?.patchEdits ?? 0} · Large outputs: ${score.stats?.largeFunctionOutputs ?? 0} · Compactions: ${score.stats?.compactMarkers ?? 0}.`,
+        score.saturationPct !== null ? `Saturation: ${score.saturationPct}% of ${formatTokens(score.modelContextWindow || 0)}.` : "",
+        `Context token source: ${score.ctSource}.`,
+        "",
+        "Honesty: tracked lower bound; provider eviction and exact context composition are not observable.",
+    ].filter(Boolean);
+    return lines.join("\n");
+}
+export function renderStateText(state) {
+    if (!state.active) {
+        return [
+            "EchoMem context HUD: no local active Codex/Claude source found.",
+            state.missing.length ? `Missing: ${state.missing.join(", ")}` : "",
+        ].filter(Boolean).join("\n");
+    }
+    if (state.scores.length <= 1)
+        return renderScoreText(state.active);
+    return [
+        renderScoreText(state.active),
+        "",
+        "Other visible sources:",
+        ...state.scores.slice(1).map((score) => `- ${clientLabel(score.client)}: ${formatGlance(score)}`),
+    ].join("\n");
+}
+export function clientLabel(client) {
+    if (client === "codex")
+        return "Codex";
+    if (client === "claude-code")
+        return "Claude Code";
+    return "Claude Desktop";
+}