@echomem/mcp 1.4.9 → 1.4.12

package/dist/hud/adapters.js

@@ -1,8 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
+import { calculateContextMetrics } from "../context-metrics/calculate.js";
+import { estimateResidentWaste } from "../context-metrics/estimator.js";
+import { parseCodexSession } from "../context-metrics/parse-codex.js";
+import { parseClaudeSession } from "../context-metrics/parse-claude.js";
 import { resolveClaudeProjectsDir, resolveCodexSessionsDir } from "../local-data-paths.js";
-import { homePath, newestFile, readJsonl, walkFiles } from "./fs.js";
-import { bumpTurn, newMetricState, recordEdit, recordRead, recordTool, scoreMetric, shellRead, } from "./metric.js";
+import { homePath, newestFile, resolveClaudeTranscript, walkFiles } from "./fs.js";
+import { BUCKETS, newMetricState, qualityColor, scoreMetric } from "./metric.js";
 export const adapters = {
     codex: {
         client: "codex",
@@ -39,87 +43,7 @@ function findActiveCodex() {
     return newestFile(listCodex());
 }
 function scoreCodex(file) {
-    const state = newMetricState();
-    let ctTokens = 0;
-    let modelContextWindow = 0;
-    let compactMarkers = 0;
-    let patchEdits = 0;
-    let functionOutputs = 0;
-    let largeFunctionOutputs = 0;
-    let lastTool = "";
-    const largeByTool = {};
-    const outputTokensByTool = {};
-    const filesByTool = {};
-    let updatedAt = new Date().toISOString();
-    for (const record of readJsonl(file)) {
-        const top = isRecord(record) ? record : {};
-        const payload = isRecord(top.payload) ? top.payload : {};
-        const payloadType = typeof payload.type === "string" ? payload.type : "";
-        if (typeof top.timestamp === "string")
-            updatedAt = top.timestamp;
-        if (payloadType === "task_started")
-            bumpTurn(state);
-        else if (payloadType === "token_count") {
-            const info = isRecord(payload.info) ? payload.info : {};
-            const last = isRecord(info.last_token_usage) ? info.last_token_usage : {};
-            ctTokens = readNumber(last.input_tokens) || ctTokens;
-            modelContextWindow = readNumber(info.model_context_window) || modelContextWindow;
-        }
-        else if (payloadType === "function_call") {
-            const name = typeof payload.name === "string" ? payload.name : "";
-            recordTool(state, name);
-            if (name)
-                lastTool = name;
-            const args = parseArguments(payload.arguments);
-            const cmd = isRecord(args) && typeof args.cmd === "string" ? args.cmd : "";
-            if ((name === "exec_command" || name === "shell") && cmd) {
-                const read = shellRead(cmd);
-                if (read) {
-                    recordRead(state, read.file, read.start, read.end);
-                    addToolFile(filesByTool, name, read.file);
-                }
-            }
-        }
-        else if (payloadType === "function_call_output") {
-            functionOutputs += 1;
-            const outTool = lastTool || "output";
-            const osize = outputSize(payload.output);
-            // Image outputs (base64 PNGs) cost ~IMG_TOK, not their byte length — Kobe's calibration.
-            const outTok = /image/i.test(outTool) ? 4000 : Math.round(osize / 4);
-            outputTokensByTool[outTool] = (outputTokensByTool[outTool] || 0) + outTok;
-            if (osize > 12_000) {
-                largeFunctionOutputs += 1;
-                largeByTool[outTool] = (largeByTool[outTool] || 0) + 1;
-            }
-        }
-        else if (payloadType === "patch_apply_end") {
-            const changes = isRecord(payload.changes) ? payload.changes : {};
-            for (const changed of Object.keys(changes)) {
-                recordEdit(state, changed);
-                patchEdits += 1;
-            }
-        }
-        else if (payloadType === "context_compacted" || top.type === "compacted") {
-            compactMarkers += 1;
-        }
-    }
-    const score = scoreMetric({
-        client: "codex",
-        sourcePath: file,
-        state,
-        ctTokens,
-        ctSource: "token_count",
-        modelContextWindow,
-        updatedAt,
-        stats: { compactMarkers, patchEdits, functionOutputs, largeFunctionOutputs },
-    });
-    if (Object.keys(largeByTool).length)
-        score.largeOutputsByTool = largeByTool;
-    if (Object.keys(outputTokensByTool).length)
-        score.outputTokensByTool = outputTokensByTool;
-    if (Object.keys(filesByTool).length)
-        score.filesByTool = topFilesByTool(filesByTool);
-    return score;
+    return scoreFromParsed("codex", file, parseCodexSession(fs.readFileSync(file, "utf8")), "token_count");
 }
 function listClaudeCode() {
     const root = resolveClaudeProjectsDir();
@@ -135,6 +59,12 @@ function findActiveClaudeCode() {
 }
 function scoreClaudeCode(file) {
     if (file.includes(`${path.sep}.claude${path.sep}echo-ctx${path.sep}`) || file.endsWith(".json")) {
+        // statusline cache: the transcript is the real data source; the cache only locates it
+        const transcript = resolveClaudeTranscript(file);
+        if (transcript) {
+            const score = scoreClaudeTranscript(transcript, "claude-code", "usage_estimate");
+            return { ...score, sourcePath: file };
+        }
         const raw = JSON.parse(fs.readFileSync(file, "utf8"));
         return normalizeCachedClaudeScore(raw, file, "claude-code", "statusline");
     }
@@ -151,101 +81,64 @@ function scoreClaudeDesktop(file) {
     return scoreClaudeTranscript(file, "claude-desktop", "usage_estimate");
 }
 function scoreClaudeTranscript(file, client, ctSource) {
-    const state = newMetricState();
-    let ctTokens = 0;
-    let updatedAt = new Date().toISOString();
-    const toolById = new Map();
-    const outputTokensByTool = {};
-    const filesByTool = {};
-    for (const record of readJsonl(file)) {
-        const obj = isRecord(record) ? record : {};
-        if (typeof obj.timestamp === "string")
-            updatedAt = obj.timestamp;
-        const message = isRecord(obj.message) ? obj.message : obj;
-        const role = typeof obj.type === "string" ? obj.type : typeof message.role === "string" ? message.role : "";
-        if (role === "assistant")
-            bumpTurn(state);
-        const usage = isRecord(message.usage) ? message.usage : isRecord(obj.usage) ? obj.usage : null;
-        if (usage) {
-            const input = readNumber(usage.input_tokens) || 0;
-            const cacheRead = readNumber(usage.cache_read_input_tokens) || 0;
-            const cacheCreate = readNumber(usage.cache_creation_input_tokens) || 0;
-            ctTokens = input + cacheRead + cacheCreate || ctTokens;
-        }
-        const content = Array.isArray(message.content) ? message.content : [];
-        for (const block of content) {
-            if (!isRecord(block))
-                continue;
-            if (block.type === "tool_use") {
-                const name = typeof block.name === "string" ? block.name : "";
-                if (typeof block.id === "string" && name)
-                    toolById.set(block.id, name);
-                const input = isRecord(block.input) ? block.input : {};
-                recordTool(state, name);
-                if (name === "Read" && typeof input.file_path === "string") {
-                    const start = readNumber(input.offset) || 1;
-                    const end = input.limit ? start + (readNumber(input.limit) || 1) - 1 : 1e9;
-                    recordRead(state, input.file_path, start, end);
-                    addToolFile(filesByTool, name, input.file_path);
-                }
-                else if ((name === "Edit" || name === "Write" || name === "MultiEdit") && typeof input.file_path === "string") {
-                    recordEdit(state, input.file_path);
-                    addToolFile(filesByTool, name, input.file_path);
-                }
-                else if (name === "Bash" && typeof input.command === "string") {
-                    const read = shellRead(input.command);
-                    if (read) {
-                        recordRead(state, read.file, read.start, read.end);
-                        addToolFile(filesByTool, "Bash", read.file);
-                    }
-                }
-            }
-            else if (block.type === "tool_result") {
-                const id = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
-                const tool = toolById.get(id) || "tool";
-                outputTokensByTool[tool] = (outputTokensByTool[tool] || 0) + claudeResultTokens(block.content);
-            }
-        }
-    }
-    const score = scoreMetric({ client, sourcePath: file, state, ctTokens, ctSource, updatedAt });
-    if (Object.keys(outputTokensByTool).length)
-        score.outputTokensByTool = outputTokensByTool;
-    if (Object.keys(filesByTool).length)
-        score.filesByTool = topFilesByTool(filesByTool);
+    return scoreFromParsed(client, file, parseClaudeSession(fs.readFileSync(file, "utf8")), ctSource);
+}
+// Assemble the HUD Score from a parsed ledger: the latest local-live partition supplies resident
+// waste, the shared calculator turns it into pollution/useful/health, and the ledger extras carry
+// the session facts (tools, files, stats) the capsule and panels display.
+function scoreFromParsed(client, file, parsed, ctSource) {
+    const estimate = estimateResidentWaste(parsed.ledger);
+    const empty = {
+        turn: 0, latestInputTokens: 0, wasteTokens: 0, usefulTokens: 0, trackedWasteTokens: 0,
+        dupTokens: 0, refindTokens: 0, deadReadTokens: 0, deadImageTokens: 0, dupCount: 0,
+        turnsSeen: 0, anchorSource: "none",
+    };
+    const e = estimate ?? empty;
+    const modelWindow = parsed.extras.modelContextWindow;
+    const metrics = calculateContextMetrics({
+        latestInputTokens: e.latestInputTokens,
+        modelContextLimitTokens: modelWindow,
+        currentResidentWasteTokens: e.wasteTokens,
+    });
+    const pollution = Math.min(0.95, metrics.noisePct);
+    const pollutionPct = Math.round(pollution * 100);
+    const saturationPct = metrics.contextFullnessPct !== undefined ? Math.round(metrics.contextFullnessPct * 100) : null;
+    const otherDead = Math.max(0, e.wasteTokens - e.dupTokens - e.refindTokens - e.deadReadTokens - e.deadImageTokens);
+    const buckets = {
+        [BUCKETS.rangeRedundant]: { tokens: e.dupTokens, count: e.dupCount },
+        [BUCKETS.staleRead]: { tokens: e.deadReadTokens + otherDead, count: 0 },
+        [BUCKETS.supersededImage]: { tokens: e.deadImageTokens, count: 0 },
+        [BUCKETS.staleToolOutput]: { tokens: e.refindTokens, count: 0 },
+        [BUCKETS.compactionRecoverable]: { tokens: 0, count: 0 },
+    };
+    const reads = parsed.ledger.items.reduce((n, it) => n + (it.kind === "read" ? 1 : 0), 0);
+    const score = {
+        client,
+        sourcePath: file,
+        turn: e.turnsSeen,
+        reads,
+        redundantCount: e.dupCount,
+        usefulPct: Math.round(Math.max(0, Math.min(1, metrics.usefulPct)) * 100),
+        healthScorePct: metrics.healthScorePct,
+        pollutionPct,
+        pollutionTok: e.wasteTokens,
+        ctTokens: e.latestInputTokens,
+        ctSource,
+        modelContextWindow: modelWindow,
+        saturationPct,
+        color: qualityColor(pollutionPct, saturationPct),
+        buckets,
+        honesty: "tracked lower bound",
+        updatedAt: parsed.extras.updatedAt,
+        stats: { ...parsed.extras.stats, trackedWasteTokens: e.trackedWasteTokens, anchorSource: e.anchorSource },
+        tools: parsed.extras.toolCounts,
+    };
+    if (Object.keys(parsed.extras.outputTokensByTool).length)
+        score.outputTokensByTool = parsed.extras.outputTokensByTool;
+    if (Object.keys(parsed.extras.filesByTool).length)
+        score.filesByTool = parsed.extras.filesByTool;
     return score;
 }
-function addToolFile(map, tool, file) {
-    if (!tool || !file)
-        return;
-    const inner = map[tool] || (map[tool] = {});
-    inner[file] = (inner[file] || 0) + 1;
-}
-function topFilesByTool(map) {
-    const out = {};
-    for (const tool of Object.keys(map)) {
-        out[tool] = Object.entries(map[tool]).sort((a, b) => b[1] - a[1]).slice(0, 12).map((entry) => entry[0]);
-    }
-    return out;
-}
-function claudeResultTokens(content) {
-    if (typeof content === "string")
-        return Math.round(outputSize(content) / 4);
-    if (Array.isArray(content)) {
-        let total = 0;
-        for (const block of content) {
-            if (!isRecord(block))
-                continue;
-            if (block.type === "image")
-                total += 4000; // IMG_TOK, not base64 byte-length
-            else if (typeof block.text === "string")
-                total += Math.round(outputSize(block.text) / 4);
-            else
-                total += Math.round(outputSize(block) / 4);
-        }
-        return total;
-    }
-    return Math.round(outputSize(content) / 4);
-}
 function normalizeCachedClaudeScore(raw, file, client, ctSource) {
     const ctTokens = readNumber(raw.ctTokens) || readNumber(raw.size) || readNumber(raw.contextTokens) || 0;
     const pollutionTok = readNumber(raw.pollutionTok) || readNumber(raw.redundantTok) || readNumber(raw.pollution_tokens) || 0;
@@ -265,28 +158,6 @@ function normalizeCachedClaudeScore(raw, file, client, ctSource) {
         updatedAt: new Date().toISOString(),
     });
 }
-function parseArguments(value) {
-    if (!value)
-        return {};
-    if (isRecord(value))
-        return value;
-    if (typeof value !== "string")
-        return {};
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return {};
-    }
-}
-function outputSize(value) {
-    if (typeof value === "string")
-        return Buffer.byteLength(value);
-    return Buffer.byteLength(JSON.stringify(value || ""));
-}
 function readNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/dist/hud/electron-main.js

@@ -12,8 +12,9 @@ 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;
+// Mini mode: a slim always-on pill (dot · score · agent icon · session · repo) — wide enough to
+// read the full session name.
+const MINI_WIDTH = 300;
 const MINI_HEIGHT = 48;
 const AGENT_VISIBILITY_POLL_MS = 900;
 let miniPref = false;

package/dist/hud/fs.js

@@ -61,3 +61,17 @@ export function statSignature(file) {
         return "";
     }
 }
+// The Claude Code active source can be the echo-ctx statusline cache (<sessionId>.json). The real
+// transcript with usage/tool data lives under ~/.claude/projects — resolve it by session id.
+const transcriptCache = new Map();
+export function resolveClaudeTranscript(cacheFile) {
+    if (!cacheFile.endsWith(".json") || !cacheFile.includes(`${path.sep}echo-ctx${path.sep}`))
+        return null;
+    const cached = transcriptCache.get(cacheFile);
+    if (cached !== undefined)
+        return cached;
+    const sessionId = path.basename(cacheFile, ".json");
+    const transcript = newestFile(walkFiles(homePath(".claude", "projects"), (f) => path.basename(f) === `${sessionId}.jsonl`));
+    transcriptCache.set(cacheFile, transcript);
+    return transcript;
+}

package/dist/hud/metric.js

@@ -6,19 +6,11 @@ export const BUCKETS = {
     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}$/;
-// A re-read counts as redundant only if a prior read substantially re-covers THIS read. A shared
-// boundary line (sequential paging, e.g. sed 1,260p then 260,620p) is not a re-read; requiring ≥50%
-// of the new range to be already-seen keeps paging out while still catching genuine sub-range re-reads.
-const REDUNDANT_OVERLAP_FRACTION = 0.5;
 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 },
@@ -29,42 +21,6 @@ export function newMetricState() {
         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 newLines = Math.max(1, safeEnd - safeStart + 1);
-    const redundant = previous.some((read) => {
-        if (read.turn < lastEdit)
-            return false; // an edit since this read invalidated it — re-read is fresh
-        const overlap = Math.min(safeEnd, read.end) - Math.max(safeStart, read.start) + 1;
-        return overlap > 0 && overlap / newLines >= REDUNDANT_OVERLAP_FRACTION;
-    });
-    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);
@@ -105,34 +61,6 @@ export function scoreMetric(params) {
         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)
@@ -145,36 +73,14 @@ export function formatGlance(score) {
     const dot = score.color === "amber" ? "◑" : "●";
     return `${dot} ${score.healthScorePct}% score · ${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 >= 35 ||
-        (saturationPct !== null && saturationPct >= 95) ||
-        (saturationPct !== null && saturationPct >= 85 && pollutionPct >= 20)) {
+export function qualityColor(pollutionPct, saturationPct) {
+    const usefulPct = 100 - Math.max(0, Math.min(100, pollutionPct));
+    if (usefulPct <= 40)
         return "red";
-    }
-    if (pollutionPct >= 18 || (saturationPct !== null && saturationPct >= 75))
+    if (usefulPct <= 60)
         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

@@ -3,7 +3,7 @@ import { EventEmitter } from "node:events";
 import fs from "node:fs";
 import path from "node:path";
 import { adapterList, adapters } from "./adapters.js";
-import { homePath, newestFile, walkFiles } from "./fs.js";
+import { homePath, resolveClaudeTranscript } 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 RECENT_WINDOW_MS = 12 * 60 * 60 * 1000; // a session is a "recent tab" if its log was touched in the last 12h
@@ -501,17 +501,6 @@ function liveMtime(client, file, cacheMtimeMs) {
         return cacheMtimeMs;
     }
 }
-const transcriptCache = new Map();
-function resolveClaudeTranscript(cacheFile) {
-    if (!cacheFile.endsWith(".json") || !cacheFile.includes(`${path.sep}echo-ctx${path.sep}`))
-        return null;
-    if (transcriptCache.has(cacheFile))
-        return transcriptCache.get(cacheFile) ?? null;
-    const sessionId = path.basename(cacheFile, ".json");
-    const transcript = newestFile(walkFiles(homePath(".claude", "projects"), (f) => path.basename(f) === `${sessionId}.jsonl`));
-    transcriptCache.set(cacheFile, transcript);
-    return transcript;
-}
 function peekCwd(file) {
     try {
         const fd = fs.openSync(file, "r");

package/dist/hud/render.js

@@ -1,16 +1,17 @@
 import { formatGlance, formatTokens } from "./metric.js";
 export function renderScoreText(score) {
     const range = score.buckets.range_redundant;
+    const snr = score.pollutionTok > 0 ? `${(Math.max(0, score.ctTokens - score.pollutionTok) / score.pollutionTok).toFixed(1)}:1` : "clean";
     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.`,
+        `Tracked dead-weight ${formatTokens(score.pollutionTok)} (${score.pollutionPct}% of the window · SNR ${snr}).`,
+        `Superseded copies (re-reads + old write versions): ${formatTokens(range.tokens)} · ${range.count} re-read files.`,
         `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.",
+        "Honesty: tracked lower bound — latest local-live waste from the resident context window; provider eviction is not directly observable.",
     ].filter(Boolean);
     return lines.join("\n");
 }

package/dist/hud/server.js

@@ -157,6 +157,35 @@ export async function createHudServer(opts = {}) {
             res.end(JSON.stringify({ ok: canReveal, reason: canReveal ? undefined : opts.onReveal ? "unknown_path" : "no_desktop" }));
             return;
         }
+        if (url.pathname === "/jump") {
+            // Deep-link into the session's own app, at the conversation level:
+            //   Claude Code CLI session -> claude://resume?session=<uuid>  (imports + opens in Claude desktop)
+            //   Codex thread            -> codex://threads/<uuid>          (opens in the ChatGPT app's Codex)
+            // The uuid is the one already embedded in the tracked transcript filename.
+            const id = url.searchParams.get("id") || "";
+            const rec = (latest.recentSessions || []).find((s) => s.id === id);
+            let link = "";
+            if (rec) {
+                const uuid = (path.basename(rec.sourcePath).match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i) || [])[0] || "";
+                if (uuid)
+                    link = rec.client === "codex" ? `codex://threads/${uuid}` : `claude://resume?session=${uuid}`;
+                else if (rec.client === "claude-desktop")
+                    link = "claude://";
+            }
+            let ok = false;
+            if (link) {
+                try {
+                    execFileSync("open", [link]);
+                    ok = true;
+                }
+                catch {
+                    ok = false;
+                }
+            }
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok, link: link || undefined }));
+            return;
+        }
         if (url.pathname === "/renew") {
             handleRenew(latest, res).catch((error) => {
                 if (res.writableEnded)
@@ -511,6 +540,7 @@ function serveHudAsset(pathname, res) {
         "/assets/hud/echo-face-cutout.png": { path: "../../assets/hud/echo-face-cutout.png", type: "image/png" },
         "/assets/hud/claude.svg": { path: "../../assets/hud/claude.svg", type: "image/svg+xml; charset=utf-8" },
         "/assets/hud/codex.svg": { path: "../../assets/hud/codex.svg", type: "image/svg+xml; charset=utf-8" },
+        "/assets/hud/github.svg": { path: "../../assets/hud/github.svg", type: "image/svg+xml; charset=utf-8" },
     };
     const asset = assets[pathname];
     if (!asset)