@agent-native/core 0.113.0 → 0.114.0

package/src/cli/context-xray-local.ts

@@ -0,0 +1,2193 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import type { ClientId } from "./mcp-config-writers.js";
+
+export interface InstallLocalContextXrayOptions {
+  baseDir?: string;
+  clients: ClientId[];
+  scope: string;
+  dryRun?: boolean;
+}
+
+export interface InstallLocalContextXrayResult {
+  commands: string[];
+  scriptPath: string;
+  written: string[];
+}
+
+const CONTEXT_XRAY_EXECUTABLE = String.raw`#!/usr/bin/env node
+"use strict";
+
+const childProcess = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+
+const HOME = os.homedir();
+const CODEX_DIR = process.env.CODEX_HOME && process.env.CODEX_HOME.trim() ? process.env.CODEX_HOME.trim() : path.join(HOME, ".codex");
+const CLAUDE_DIR = path.join(HOME, ".claude");
+const OUT_DIR = path.join(CODEX_DIR, "context-xray");
+const SESSION_ID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+const CATEGORIES = ["user", "assistant", "tool_call", "tool_output", "reasoning", "instructions", "attachment", "metadata", "other"];
+const LABELS = {
+  user: "User asks",
+  assistant: "Assistant text",
+  tool_call: "Tool calls",
+  tool_output: "Tool output",
+  reasoning: "Reasoning",
+  instructions: "Instructions/context",
+  attachment: "Attachments",
+  metadata: "Metadata",
+  other: "Other",
+};
+const COLORS = {
+  user: "#8ba8ff",
+  assistant: "#55b982",
+  tool_call: "#f0a85b",
+  tool_output: "#e06b73",
+  reasoning: "#a77be8",
+  instructions: "#6ac3d5",
+  attachment: "#d6a85a",
+  metadata: "#9aa3ad",
+  other: "#c3c8ce",
+};
+const MAX_EVENT_SAMPLES = 80;
+const MAX_STEP_SAMPLES = 900;
+const PRESSURE_WINDOW = 5;
+const PRESSURE_TOKENS = 50000;
+
+function parseArgs(argv) {
+  const out = {
+    mode: "current",
+    source: "both",
+    since: "7d",
+    last: 12,
+    scanLimit: 80,
+    project: process.cwd(),
+    allProjects: false,
+    sessionId: "",
+    format: "html",
+    out: "",
+    open: false,
+    port: 0,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const eat = (flag) => {
+      if (arg === flag) return argv[++i] || "";
+      if (arg.startsWith(flag + "=")) return arg.slice(flag.length + 1);
+      return undefined;
+    };
+    let value;
+    if (arg === "threads" || arg === "--threads") out.mode = "threads";
+    else if (arg === "trends" || arg === "--trends") out.mode = "trends";
+    else if (arg === "current" || arg === "--current") out.mode = "current";
+    else if ((value = eat("--source")) !== undefined) out.source = value;
+    else if ((value = eat("--since")) !== undefined) out.since = value;
+    else if ((value = eat("--last")) !== undefined) out.last = Number(value) || out.last;
+    else if ((value = eat("--scan-limit")) !== undefined) out.scanLimit = Number(value) || out.scanLimit;
+    else if ((value = eat("--project")) !== undefined) out.project = value;
+    else if ((value = eat("--session-id")) !== undefined) out.sessionId = value;
+    else if ((value = eat("--format")) !== undefined) out.format = value;
+    else if ((value = eat("--out")) !== undefined) out.out = value;
+    else if ((value = eat("--port")) !== undefined) out.port = Number(value) || 0;
+    else if (arg === "--all-projects") out.allProjects = true;
+    else if (arg === "--open") out.open = true;
+    else if (arg === "--json") out.format = "json";
+    else if (arg === "--help" || arg === "-h") out.help = true;
+  }
+  if (process.env.CLAUDE_CODE_SESSION_ID && !out.sessionId && out.mode === "current") {
+    out.sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+  }
+  if (out.mode === "threads") {
+    out.allProjects = true;
+    out.last = Math.max(out.last, 30);
+  }
+  if (out.mode === "trends") {
+    out.allProjects = true;
+    out.last = Math.max(out.last, 60);
+  }
+  if (out.mode === "current") {
+    out.last = 1;
+  }
+  return out;
+}
+
+function help() {
+  console.log([
+    "Context X-Ray",
+    "",
+    "Usage:",
+    "  context-xray --open                    Visualize the current/recent local thread",
+    "  context-xray threads --open            Pick from recent Codex/Claude sessions",
+    "  context-xray trends --since 7d --open  Show recent usage trends",
+    "  context-xray --session-id <id> --open  Analyze one exact session",
+    "",
+    "Options:",
+    "  --source codex|claude|both",
+    "  --since 24h|7d|2w|ISO",
+    "  --last <n>",
+    "  --all-projects",
+    "  --format html|json",
+    "  --out <path>",
+  ].join("\n"));
+}
+
+function mkdirp(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function parseSince(value) {
+  const now = Date.now();
+  const match = String(value || "7d").trim().toLowerCase().match(/^(\d+)([hdw])$/);
+  if (match) {
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const mult = unit === "h" ? 3600000 : unit === "d" ? 86400000 : 604800000;
+    return now - amount * mult;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : now - 7 * 86400000;
+}
+
+function readJsonl(file) {
+  try {
+    return fs.readFileSync(file, "utf8").split(/\r?\n/).filter(Boolean).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function compact(value) {
+  try {
+    const text = JSON.stringify(value);
+    return text.length > 250000 ? text.slice(0, 250000) : text;
+  } catch {
+    return String(value || "");
+  }
+}
+
+function textFrom(value, depth) {
+  if (depth > 8 || value == null) return "";
+  if (typeof value === "string") return value.length > 250000 ? value.slice(0, 250000) : value;
+  if (typeof value !== "object") return "";
+  if (Array.isArray(value)) return value.map((item) => textFrom(item, depth + 1)).filter(Boolean).join("\n");
+  const skip = new Set(["encrypted_content", "id", "uuid", "call_id", "sessionId", "parentUuid"]);
+  const keys = new Set(["text", "message", "output", "result", "content", "summary", "arguments", "args", "input", "stdout", "stderr", "attachment"]);
+  const parts = [];
+  for (const key of Object.keys(value)) {
+    if (skip.has(key)) continue;
+    const item = value[key];
+    if (keys.has(key) || typeof item === "object") {
+      const text = textFrom(item, depth + 1);
+      if (text) parts.push(text);
+    }
+  }
+  return parts.join("\n");
+}
+
+function addCounter(counter, key, amount) {
+  if (!key || !amount) return;
+  counter[key] = (counter[key] || 0) + amount;
+}
+
+function mergeCounter(into, from) {
+  for (const key of Object.keys(from || {})) addCounter(into, key, from[key]);
+}
+
+function estimateTokens(chars) {
+  return chars > 0 ? Math.max(1, Math.ceil(chars / 4)) : 0;
+}
+
+function fmtTokens(tokens) {
+  if (tokens >= 1000000) return (tokens / 1000000).toFixed(1) + "m";
+  if (tokens >= 1000) return (tokens / 1000).toFixed(1) + "k";
+  return String(tokens);
+}
+
+function pct(part, total) {
+  return total > 0 ? Math.max(0, Math.min(100, (part / total) * 100)) : 0;
+}
+
+function pathCounts(text) {
+  const out = {};
+  const matches = String(text || "").match(/(?:(?:\/[\w@.+,=-]+)+|(?:[\w.-]+\/)+[\w.+,=-]+)(?:\.[A-Za-z0-9_+-]+)?/g) || [];
+  for (const raw of matches) {
+    const value = raw.replace(/['",.)]+$/g, "");
+    if (value.length > 5 && !value.startsWith("http") && value.includes("/")) addCounter(out, value, 1);
+  }
+  return out;
+}
+
+function eventPreview(text) {
+  return cleanTitle(String(text || "")).slice(0, 240);
+}
+
+function inferMcpTool(toolName) {
+  const value = String(toolName || "");
+  if (value.startsWith("mcp__")) {
+    const rest = value.slice(5);
+    const split = rest.indexOf("__");
+    if (split !== -1) return { server: rest.slice(0, split), tool: rest.slice(split + 2) };
+    const dot = rest.indexOf(".");
+    if (dot !== -1) return { server: rest.slice(0, dot), tool: rest.slice(dot + 1) };
+  }
+  if (value.startsWith("mcp_")) {
+    const rest = value.slice(4);
+    const split = rest.indexOf("_");
+    if (split !== -1) return { server: rest.slice(0, split), tool: rest.slice(split + 1) };
+  }
+  return { server: "", tool: "" };
+}
+
+function codexTitle(id) {
+  const index = path.join(CODEX_DIR, "session_index.jsonl");
+  for (const record of readJsonl(index)) {
+    if (record.id === id && record.thread_name) return String(record.thread_name);
+  }
+  return "";
+}
+
+function observedCodexTokens(payload) {
+  if (!payload || payload.type !== "token_count" || !payload.info) return 0;
+  const total = payload.info.total_token_usage;
+  if (total && Number(total.total_tokens)) return Number(total.total_tokens);
+  if (total && typeof total === "object") {
+    return ["input_tokens", "cached_input_tokens", "output_tokens", "reasoning_output_tokens"].reduce((sum, key) => sum + (Number(total[key]) || 0), 0);
+  }
+  const last = payload.info.last_token_usage;
+  if (last && Number(last.total_tokens)) return Number(last.total_tokens);
+  return 0;
+}
+
+function claudeUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") return 0;
+  return (Number(usage.input_tokens) || 0) + (Number(usage.output_tokens) || 0) + (Number(usage.cache_creation_input_tokens) || 0) + (Number(usage.cache_read_input_tokens) || 0);
+}
+
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadInputTokens: 0,
+    cachedInputTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: 0,
+    turnsWithUsage: 0,
+    peakTurnTokens: 0,
+    peakTurnLabel: "",
+    latestTurnTokens: 0,
+    latestInputTokens: 0,
+    series: [],
+  };
+}
+
+function usageTotal(usage) {
+  if (!usage) return 0;
+  if (Number(usage.totalTokens)) return Number(usage.totalTokens) || 0;
+  return (Number(usage.inputTokens) || 0) +
+    (Number(usage.outputTokens) || 0) +
+    (Number(usage.cacheCreationInputTokens) || 0) +
+    (Number(usage.cacheReadInputTokens) || 0) +
+    (Number(usage.reasoningOutputTokens) || 0);
+}
+
+function normalizedUsage(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const usage = {
+    inputTokens: Number(raw.input_tokens) || Number(raw.inputTokens) || 0,
+    outputTokens: Number(raw.output_tokens) || Number(raw.outputTokens) || 0,
+    cacheCreationInputTokens: Number(raw.cache_creation_input_tokens) || Number(raw.cacheCreationInputTokens) || 0,
+    cacheReadInputTokens: Number(raw.cache_read_input_tokens) || Number(raw.cacheReadInputTokens) || Number(raw.cached_input_tokens) || Number(raw.cachedInputTokens) || 0,
+    cachedInputTokens: Number(raw.cached_input_tokens) || Number(raw.cachedInputTokens) || 0,
+    reasoningOutputTokens: Number(raw.reasoning_output_tokens) || Number(raw.reasoningOutputTokens) || 0,
+    totalTokens: Number(raw.total_tokens) || Number(raw.totalTokens) || 0,
+  };
+  if (!usage.totalTokens) usage.totalTokens = usageTotal(usage);
+  return usage.totalTokens || usage.inputTokens || usage.outputTokens || usage.cacheCreationInputTokens || usage.cacheReadInputTokens ? usage : null;
+}
+
+function codexUsageFromPayload(payload) {
+  if (!payload || payload.type !== "token_count" || !payload.info) return null;
+  return normalizedUsage(payload.info.last_token_usage || payload.info.total_token_usage);
+}
+
+function addUsage(summary, usage, timestamp, label) {
+  if (!usage) return;
+  const total = usageTotal(usage);
+  summary.usage.inputTokens += usage.inputTokens || 0;
+  summary.usage.outputTokens += usage.outputTokens || 0;
+  summary.usage.cacheCreationInputTokens += usage.cacheCreationInputTokens || 0;
+  summary.usage.cacheReadInputTokens += usage.cacheReadInputTokens || 0;
+  summary.usage.cachedInputTokens += usage.cachedInputTokens || 0;
+  summary.usage.reasoningOutputTokens += usage.reasoningOutputTokens || 0;
+  summary.usage.totalTokens += total;
+  summary.usage.turnsWithUsage += 1;
+  summary.usage.latestTurnTokens = total;
+  summary.usage.latestInputTokens = (usage.inputTokens || 0) + (usage.cacheCreationInputTokens || 0) + (usage.cacheReadInputTokens || 0);
+  if (total > summary.usage.peakTurnTokens) {
+    summary.usage.peakTurnTokens = total;
+    summary.usage.peakTurnLabel = label || timestamp || "turn " + summary.usage.turnsWithUsage;
+  }
+  if (summary.usage.series.length < 260) {
+    summary.usage.series.push({
+      timestamp: String(timestamp || ""),
+      label: label || "turn " + summary.usage.turnsWithUsage,
+      totalTokens: total,
+      inputTokens: usage.inputTokens || 0,
+      outputTokens: usage.outputTokens || 0,
+      cacheCreationInputTokens: usage.cacheCreationInputTokens || 0,
+      cacheReadInputTokens: usage.cacheReadInputTokens || 0,
+      cachedInputTokens: usage.cachedInputTokens || 0,
+      reasoningOutputTokens: usage.reasoningOutputTokens || 0,
+    });
+  }
+}
+
+function sessionIdFromPath(file) {
+  const match = path.basename(file).match(SESSION_ID_RE);
+  return match ? match[0] : path.basename(file, ".jsonl");
+}
+
+function safeJson(value) {
+  if (!value || typeof value !== "string") return null;
+  const text = value.trim();
+  if (!text || !/^[{[]/.test(text)) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeToolInput(value) {
+  if (value == null) return {};
+  if (typeof value === "string") {
+    const parsed = safeJson(value);
+    return parsed && typeof parsed === "object" ? parsed : { text: value };
+  }
+  if (typeof value === "object") return value;
+  return { text: String(value) };
+}
+
+function codexToolInput(payload) {
+  if (!payload || typeof payload !== "object") return {};
+  if (Object.prototype.hasOwnProperty.call(payload, "input")) return normalizeToolInput(payload.input);
+  if (Object.prototype.hasOwnProperty.call(payload, "arguments")) return normalizeToolInput(payload.arguments);
+  if (Object.prototype.hasOwnProperty.call(payload, "args")) return normalizeToolInput(payload.args);
+  if (Object.prototype.hasOwnProperty.call(payload, "parameters")) return normalizeToolInput(payload.parameters);
+  return {};
+}
+
+function firstStringField(input, keys) {
+  if (!input || typeof input !== "object") return "";
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+
+function shortCommand(command) {
+  return cleanTitle(command).slice(0, 260);
+}
+
+function stripAnsi(value) {
+  return String(value || "").replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+
+function normalizeCommand(command) {
+  return stripAnsi(command)
+    .replace(/\/Users\/[^\s"']+/g, "<abs-path>")
+    .replace(/\/tmp\/[^\s"']+/g, "<tmp-path>")
+    .replace(/:\d+(:\d+)?/g, ":<line>")
+    .replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,36}\b/gi, "<id>")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 260)
+    .toLowerCase();
+}
+
+function toolFamily(toolName, input, inputText) {
+  const name = String(toolName || "").toLowerCase();
+  if (inferMcpTool(toolName).server) return "mcp";
+  if (/(^|_|\.)(task|agent|subagent|spawn_agent|delegate)/.test(name)) return "agent";
+  if (/(read|view|open_file|get_file|cat_file)/.test(name)) return "read";
+  if (/(grep|glob|search|find|ripgrep|rg|list|ls)/.test(name)) return "search";
+  if (/(edit|write|patch|apply_patch|replace|update_file|create_file|delete|rm)/.test(name)) return "write";
+  if (/(bash|shell|exec|terminal|command|run)/.test(name)) return "execute";
+  const text = String(inputText || "").toLowerCase();
+  if (/^\s*(rg|grep|find|ls)\b/.test(text)) return "search";
+  if (/^\s*(cat|sed|nl|head|tail)\b/.test(text)) return "read";
+  if (/^\s*(python|node|pnpm|npm|yarn|bun|cargo|go|git|make|pytest|vitest)\b/.test(text)) return "execute";
+  return "tool";
+}
+
+function toolTarget(toolName, input, inputText) {
+  const direct = firstStringField(input, ["file_path", "filePath", "path", "filename", "relative_path", "target", "cwd"]);
+  if (direct) return direct;
+  const command = firstStringField(input, ["command", "cmd", "shell", "script"]);
+  if (command) return shortCommand(command);
+  const paths = pathCounts(inputText || "");
+  const firstPath = Object.keys(paths)[0];
+  if (firstPath) return firstPath;
+  return shortCommand(inputText || toolName || "");
+}
+
+function toolCommand(toolName, input, inputText) {
+  const command = firstStringField(input, ["command", "cmd", "shell", "script"]);
+  if (command) return shortCommand(command);
+  const name = String(toolName || "").toLowerCase();
+  if (/(bash|shell|exec|terminal|command|run)/.test(name)) return shortCommand(inputText || "");
+  return "";
+}
+
+function outputLooksError(value, text) {
+  if (!value || typeof value !== "object") {
+    return /\b(exit code|status|error)\s*[:=]?\s*[1-9]\b/i.test(text || "") || /\bfailed\b|\btraceback\b|\bexception\b/i.test(text || "");
+  }
+  if (value.is_error === true || value.error === true || value.success === false) return true;
+  const code = Number(value.exit_code ?? value.exitCode ?? value.status ?? value.code);
+  if (Number.isFinite(code) && code !== 0) return true;
+  return /\b(exit code|status)\s*[:=]?\s*[1-9]\b/i.test(text || "") || /\btraceback\b|\bexception\b/i.test(text || "");
+}
+
+function initTraceFields(summary) {
+  summary.usage = emptyUsage();
+  summary.steps = [];
+  summary.stepCount = 0;
+  summary._callMap = {};
+  summary._lastToolStep = null;
+}
+
+function recordToolStep(summary, options) {
+  const input = normalizeToolInput(options.input);
+  const inputText = textFrom(input, 0) || compact(input);
+  const preview = eventPreview(inputText || options.preview || options.tool || "");
+  const family = toolFamily(options.tool, input, inputText || preview);
+  const command = toolCommand(options.tool, input, inputText || preview);
+  const mcp = inferMcpTool(options.tool);
+  const step = {
+    index: summary.stepCount++,
+    source: summary.source,
+    sessionId: summary.sessionId,
+    timestamp: String(options.timestamp || ""),
+    type: "tool_call",
+    tool: String(options.tool || "tool_call"),
+    family,
+    target: toolTarget(options.tool, input, inputText || preview),
+    command,
+    normalizedCommand: command ? normalizeCommand(command) : "",
+    mcpServer: mcp.server,
+    mcpTool: mcp.tool,
+    tokens: estimateTokens((inputText || preview).length),
+    preview,
+    isError: false,
+    errorPreview: "",
+  };
+  if (summary.steps.length < MAX_STEP_SAMPLES) summary.steps.push(step);
+  for (const id of options.ids || []) {
+    if (id) summary._callMap[String(id)] = step;
+  }
+  summary._lastToolStep = step;
+  return step;
+}
+
+function markToolResult(summary, ids, isError, preview) {
+  let step = null;
+  for (const id of ids || []) {
+    if (id && summary._callMap[String(id)]) {
+      step = summary._callMap[String(id)];
+      break;
+    }
+  }
+  if (!step) step = summary._lastToolStep;
+  if (!step) return;
+  if (isError) {
+    step.isError = true;
+    step.errorPreview = eventPreview(preview || step.errorPreview || "");
+  }
+}
+
+function contentBlocks(content) {
+  if (Array.isArray(content)) return content;
+  if (content == null) return [];
+  return [content];
+}
+
+function classifyCodex(record) {
+  const top = String(record.type || "");
+  const payload = record.payload && typeof record.payload === "object" ? record.payload : {};
+  const ptype = String(payload.type || "");
+  let category = "other";
+  const tools = {};
+  let toolName = "";
+  if (top === "session_meta") category = "metadata";
+  else if (top === "turn_context") category = "instructions";
+  else if (top === "event_msg") category = ptype === "user_message" ? "user" : "metadata";
+  else if (top === "response_item") {
+    if (["function_call", "custom_tool_call", "web_search_call", "tool_search_call", "tool_call"].includes(ptype) || payload.name && payload.call_id) {
+      category = "tool_call";
+      toolName = payload.name ? String(payload.name) : ptype || "tool_call";
+      if (payload.name) addCounter(tools, String(payload.name), 1);
+    } else if (["function_call_output", "custom_tool_call_output", "tool_search_output", "tool_result"].includes(ptype) || Object.prototype.hasOwnProperty.call(payload, "output")) {
+      category = "tool_output";
+      toolName = payload.name ? String(payload.name) : "tool output";
+    }
+    else if (ptype === "reasoning" || payload.summary) category = "reasoning";
+    else if (payload.role === "assistant") category = "assistant";
+    else if (payload.role === "user" || payload.role === "developer") category = "user";
+  }
+  const text = textFrom(record, 0) || (category === "metadata" ? compact(record) : "");
+  return {
+    category,
+    chars: text.length,
+    tools,
+    paths: pathCounts(text),
+    toolName,
+    mcp: inferMcpTool(toolName),
+    metadataType: top + (ptype ? ":" + ptype : ""),
+    preview: eventPreview(text),
+  };
+}
+
+function classifyClaude(record) {
+  let category = "other";
+  const tools = {};
+  let toolName = "";
+  const message = record.message && typeof record.message === "object" ? record.message : null;
+  let text = "";
+  if (message) {
+    if (message.role === "user") category = "user";
+    else if (message.role === "assistant") category = "assistant";
+    const content = Array.isArray(message.content) ? message.content : [message.content];
+    const parts = [];
+    for (const part of content) {
+      if (part && typeof part === "object") {
+        if (part.type === "tool_use") {
+          category = "tool_call";
+          toolName = part.name ? String(part.name) : "tool_use";
+          if (part.name) addCounter(tools, String(part.name), 1);
+        } else if (part.type === "tool_result") {
+          category = "tool_output";
+          toolName = "tool_result";
+        }
+        else if (part.type === "thinking") category = "reasoning";
+      }
+      parts.push(textFrom(part, 0));
+    }
+    text = parts.join("\n");
+  } else if (record.toolUseResult) {
+    category = "tool_output";
+    toolName = "toolUseResult";
+    text = textFrom(record.toolUseResult, 0);
+  } else if (record.attachment) {
+    category = "attachment";
+    text = textFrom(record.attachment, 0);
+  } else {
+    text = textFrom(record, 0);
+  }
+  return {
+    category,
+    chars: text.length,
+    tools,
+    paths: pathCounts(text),
+    toolName,
+    mcp: inferMcpTool(toolName),
+    metadataType: String(record.type || message && message.role || "record"),
+    preview: eventPreview(text),
+  };
+}
+
+function summarizeCodex(file) {
+  const stat = fs.statSync(file);
+  const summary = {
+    source: "codex",
+    path: file,
+    sessionId: sessionIdFromPath(file),
+    title: "",
+    cwd: "",
+    startedAt: "",
+    updatedAt: "",
+    categories: {},
+    tools: {},
+    toolTokens: {},
+    paths: {},
+    metadata: {},
+    mcpUsage: {},
+    mcpTools: {},
+    toolEvents: [],
+    metadataEvents: [],
+    observedTokens: 0,
+    bytes: stat.size,
+    mtime: stat.mtimeMs,
+  };
+  initTraceFields(summary);
+  const records = readJsonl(file);
+  for (const record of records) {
+    const payload = record.payload && typeof record.payload === "object" ? record.payload : {};
+    if (record.type === "session_meta") {
+      summary.sessionId = String(payload.id || summary.sessionId);
+      summary.cwd = String(payload.cwd || summary.cwd);
+      summary.startedAt = String(payload.timestamp || summary.startedAt);
+    }
+    if (payload.cwd && !summary.cwd) summary.cwd = String(payload.cwd);
+    if (record.timestamp) summary.updatedAt = String(record.timestamp);
+    summary.observedTokens = Math.max(summary.observedTokens, observedCodexTokens(payload));
+    addUsage(summary, codexUsageFromPayload(payload), String(record.timestamp || payload.timestamp || ""), "turn " + (summary.usage.turnsWithUsage + 1));
+    const stats = classifyCodex(record);
+    addCounter(summary.categories, stats.category, stats.chars);
+    mergeCounter(summary.tools, stats.tools);
+    if (stats.toolName && stats.category === "tool_call") {
+      recordToolStep(summary, {
+        tool: stats.toolName,
+        input: codexToolInput(payload),
+        ids: [payload.call_id, payload.id],
+        timestamp: record.timestamp || payload.timestamp,
+        preview: stats.preview,
+      });
+      addCounter(summary.toolTokens, stats.toolName, estimateTokens(stats.chars));
+      if (stats.mcp.server) {
+        addCounter(summary.mcpUsage, stats.mcp.server, 1);
+        addCounter(summary.mcpTools, stats.mcp.server + " / " + (stats.mcp.tool || stats.toolName), 1);
+      }
+      if (summary.toolEvents.length < MAX_EVENT_SAMPLES) {
+        summary.toolEvents.push({
+          source: "codex",
+          sessionId: summary.sessionId,
+          timestamp: String(record.timestamp || payload.timestamp || ""),
+          category: stats.category,
+          tool: stats.toolName,
+          mcpServer: stats.mcp.server,
+          mcpTool: stats.mcp.tool,
+          tokens: estimateTokens(stats.chars),
+          preview: stats.preview,
+        });
+      }
+    }
+    if (stats.category === "tool_output") {
+      const text = textFrom(payload, 0);
+      markToolResult(summary, [payload.call_id, payload.id], outputLooksError(payload, text), text);
+    }
+    if (stats.category === "metadata") {
+      addCounter(summary.metadata, stats.metadataType, stats.chars);
+      if (summary.metadataEvents.length < MAX_EVENT_SAMPLES) {
+        summary.metadataEvents.push({
+          source: "codex",
+          sessionId: summary.sessionId,
+          timestamp: String(record.timestamp || payload.timestamp || ""),
+          type: stats.metadataType,
+          tokens: estimateTokens(stats.chars),
+          preview: stats.preview,
+        });
+      }
+    }
+    mergeCounter(summary.paths, stats.paths);
+  }
+  summary.title = codexTitle(summary.sessionId) || summary.sessionId;
+  return finalizeSummary(summary);
+}
+
+function summarizeClaude(file) {
+  const stat = fs.statSync(file);
+  const summary = {
+    source: "claude",
+    path: file,
+    sessionId: sessionIdFromPath(file),
+    title: "",
+    cwd: "",
+    startedAt: "",
+    updatedAt: "",
+    categories: {},
+    tools: {},
+    toolTokens: {},
+    paths: {},
+    metadata: {},
+    mcpUsage: {},
+    mcpTools: {},
+    toolEvents: [],
+    metadataEvents: [],
+    observedTokens: 0,
+    bytes: stat.size,
+    mtime: stat.mtimeMs,
+  };
+  initTraceFields(summary);
+  const records = readJsonl(file);
+  for (const record of records) {
+    summary.sessionId = String(record.sessionId || summary.sessionId);
+    summary.cwd = String(record.cwd || summary.cwd);
+    if (record.timestamp) {
+      summary.updatedAt = String(record.timestamp);
+      if (!summary.startedAt) summary.startedAt = String(record.timestamp);
+    }
+    if (record.message && typeof record.message === "object") {
+      summary.observedTokens = Math.max(summary.observedTokens, claudeUsageTokens(record.message.usage));
+      addUsage(summary, normalizedUsage(record.message.usage), String(record.timestamp || ""), "turn " + (summary.usage.turnsWithUsage + 1));
+      if (!summary.title && record.message.role === "user") summary.title = cleanTitle(textFrom(record.message, 0)).slice(0, 90);
+      for (const part of contentBlocks(record.message.content)) {
+        if (!part || typeof part !== "object") continue;
+        if (part.type === "tool_use") {
+          recordToolStep(summary, {
+            tool: part.name || "tool_use",
+            input: part.input || {},
+            ids: [part.id, record.uuid],
+            timestamp: record.timestamp,
+            preview: textFrom(part.input || part, 0),
+          });
+        } else if (part.type === "tool_result") {
+          const text = textFrom(part, 0);
+          markToolResult(summary, [part.tool_use_id, record.sourceToolAssistantUUID], part.is_error === true || outputLooksError(part, text), text);
+        }
+      }
+    }
+    if (record.toolUseResult) {
+      const text = textFrom(record.toolUseResult, 0);
+      markToolResult(summary, [record.toolUseID, record.toolUseId, record.sourceToolAssistantUUID], outputLooksError(record.toolUseResult, text), text);
+    }
+    const stats = classifyClaude(record);
+    addCounter(summary.categories, stats.category, stats.chars);
+    mergeCounter(summary.tools, stats.tools);
+    if (stats.toolName && stats.category === "tool_call") {
+      addCounter(summary.toolTokens, stats.toolName, estimateTokens(stats.chars));
+      if (stats.mcp.server) {
+        addCounter(summary.mcpUsage, stats.mcp.server, 1);
+        addCounter(summary.mcpTools, stats.mcp.server + " / " + (stats.mcp.tool || stats.toolName), 1);
+      }
+      if (summary.toolEvents.length < MAX_EVENT_SAMPLES) {
+        summary.toolEvents.push({
+          source: "claude",
+          sessionId: summary.sessionId,
+          timestamp: String(record.timestamp || ""),
+          category: stats.category,
+          tool: stats.toolName,
+          mcpServer: stats.mcp.server,
+          mcpTool: stats.mcp.tool,
+          tokens: estimateTokens(stats.chars),
+          preview: stats.preview,
+        });
+      }
+    }
+    if (stats.category === "metadata") {
+      addCounter(summary.metadata, stats.metadataType, stats.chars);
+      if (summary.metadataEvents.length < MAX_EVENT_SAMPLES) {
+        summary.metadataEvents.push({
+          source: "claude",
+          sessionId: summary.sessionId,
+          timestamp: String(record.timestamp || ""),
+          type: stats.metadataType,
+          tokens: estimateTokens(stats.chars),
+          preview: stats.preview,
+        });
+      }
+    }
+    mergeCounter(summary.paths, stats.paths);
+  }
+  if (!summary.title) summary.title = summary.sessionId;
+  return finalizeSummary(summary);
+}
+
+function finalizeSummary(summary) {
+  const totalChars = Object.values(summary.categories).reduce((sum, value) => sum + value, 0);
+  summary.totalChars = totalChars;
+  summary.tokens = summary.observedTokens || estimateTokens(totalChars);
+  summary.tokenMethod = summary.observedTokens ? "observed" : "estimated";
+  summary.totalSteps = summary.stepCount || (summary.steps || []).length;
+  delete summary._callMap;
+  delete summary._lastToolStep;
+  return summary;
+}
+
+function walk(root) {
+  const out = [];
+  if (!fs.existsSync(root)) return out;
+  const visit = (dir) => {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const file = path.join(dir, entry.name);
+      if (entry.isDirectory()) visit(file);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(file);
+    }
+  };
+  visit(root);
+  return out;
+}
+
+function encodedProject(project) {
+  return path.resolve(project).replace(/\//g, "-");
+}
+
+function pathInsideOrEqual(value, parent) {
+  const relative = path.relative(parent, value);
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function candidateFiles(source, args) {
+  if (args.sessionId) {
+    const roots = source === "codex" ? [path.join(CODEX_DIR, "sessions"), path.join(CODEX_DIR, "archived_sessions")] : [path.join(CLAUDE_DIR, "projects")];
+    return roots.flatMap(walk).filter((file) => file.includes(args.sessionId));
+  }
+  const since = parseSince(args.since);
+  const roots = source === "codex" ? [path.join(CODEX_DIR, "sessions"), path.join(CODEX_DIR, "archived_sessions")] : [path.join(CLAUDE_DIR, "projects")];
+  const projectFragment = encodedProject(args.project);
+  const files = roots.flatMap(walk).filter((file) => {
+    let stat;
+    try {
+      stat = fs.statSync(file);
+    } catch {
+      return false;
+    }
+    if (stat.mtimeMs < since) return false;
+    if (args.allProjects || source === "codex") return true;
+    return file.includes(projectFragment) || file.includes(path.basename(args.project));
+  }).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+  return source === "codex" && !args.allProjects ? files : files.slice(0, args.scanLimit);
+}
+
+function projectMatches(session, args) {
+  if (args.allProjects || args.sessionId) return true;
+  const project = path.resolve(args.project);
+  if (session.cwd && pathInsideOrEqual(path.resolve(session.cwd), project)) return true;
+  return session.path.includes(encodedProject(project));
+}
+
+function collectSessions(args) {
+  const sources = args.source === "both" ? ["codex", "claude"] : [args.source];
+  const sessions = [];
+  for (const source of sources) {
+    for (const file of candidateFiles(source, args)) {
+      try {
+        const summary = source === "codex" ? summarizeCodex(file) : summarizeClaude(file);
+        if (projectMatches(summary, args)) sessions.push(summary);
+      } catch {}
+    }
+  }
+  if (args.mode === "current" || args.sessionId) sessions.sort((a, b) => b.mtime - a.mtime);
+  else sessions.sort((a, b) => b.tokens - a.tokens || b.mtime - a.mtime);
+  return sessions.slice(0, args.last);
+}
+
+function aggregate(sessions) {
+  const out = { categories: {}, tools: {}, toolTokens: {}, paths: {}, metadata: {}, mcpUsage: {}, mcpTools: {}, toolEvents: [], metadataEvents: [], steps: [], usage: emptyUsage() };
+  for (const session of sessions) {
+    mergeCounter(out.categories, session.categories);
+    mergeCounter(out.tools, session.tools);
+    mergeCounter(out.toolTokens, session.toolTokens);
+    mergeCounter(out.paths, session.paths);
+    mergeCounter(out.metadata, session.metadata);
+    mergeCounter(out.mcpUsage, session.mcpUsage);
+    mergeCounter(out.mcpTools, session.mcpTools);
+    out.usage.inputTokens += (session.usage && session.usage.inputTokens) || 0;
+    out.usage.outputTokens += (session.usage && session.usage.outputTokens) || 0;
+    out.usage.cacheCreationInputTokens += (session.usage && session.usage.cacheCreationInputTokens) || 0;
+    out.usage.cacheReadInputTokens += (session.usage && session.usage.cacheReadInputTokens) || 0;
+    out.usage.cachedInputTokens += (session.usage && session.usage.cachedInputTokens) || 0;
+    out.usage.reasoningOutputTokens += (session.usage && session.usage.reasoningOutputTokens) || 0;
+    out.usage.totalTokens += (session.usage && session.usage.totalTokens) || 0;
+    out.usage.turnsWithUsage += (session.usage && session.usage.turnsWithUsage) || 0;
+    if (session.usage && session.usage.peakTurnTokens > out.usage.peakTurnTokens) {
+      out.usage.peakTurnTokens = session.usage.peakTurnTokens;
+      out.usage.peakTurnLabel = (session.title || session.sessionId) + " · " + session.usage.peakTurnLabel;
+    }
+    for (const step of session.steps || []) {
+      if (out.steps.length < 2000) out.steps.push(Object.assign({ sessionTitle: session.title, cwd: session.cwd, sessionPath: session.path }, step));
+    }
+    for (const event of session.toolEvents || []) {
+      if (out.toolEvents.length < 500) out.toolEvents.push(Object.assign({ sessionTitle: session.title, cwd: session.cwd, sessionPath: session.path }, event));
+    }
+    for (const event of session.metadataEvents || []) {
+      if (out.metadataEvents.length < 500) out.metadataEvents.push(Object.assign({ sessionTitle: session.title, cwd: session.cwd, sessionPath: session.path }, event));
+    }
+  }
+  return out;
+}
+
+function sortedEntries(counter, limit) {
+  return Object.entries(counter || {}).sort((a, b) => b[1] - a[1]).slice(0, limit);
+}
+
+function normalizedTarget(value) {
+  return String(value || "").replace(/^file:\/\//, "").replace(/:\d+(:\d+)?$/g, "").replace(/\/+/g, "/").trim();
+}
+
+function severity(score) {
+  if (score >= 90) return "critical";
+  if (score >= 70) return "high";
+  if (score >= 40) return "medium";
+  if (score >= 15) return "low";
+  return "info";
+}
+
+function addFinding(findings, rule, score, category, title, summary, evidence, recommendation, action) {
+  findings.push({
+    rule,
+    severity: severity(score),
+    score: Math.round(score),
+    category,
+    title,
+    summary,
+    evidence: (evidence || []).filter(Boolean).slice(0, 5),
+    recommendation,
+    action: action || "prompt",
+    confidence: score >= 70 ? "high" : score >= 40 ? "medium" : "low",
+  });
+}
+
+function cacheStability(session) {
+  const series = session.usage && session.usage.series || [];
+  if (series.length < 5) {
+    return { classification: "stable", turnsAboveThreshold: 0, totalTurns: series.length, avgCacheCreationPct: 0, perTurnRatios: [] };
+  }
+  const ratios = series.map((turn) => {
+    const total = (turn.inputTokens || 0) + (turn.cacheCreationInputTokens || 0) + (turn.cacheReadInputTokens || 0);
+    return total ? (turn.cacheCreationInputTokens || 0) / total : 0;
+  });
+  const turnsAboveThreshold = ratios.filter((ratio) => ratio > 0.3).length;
+  const mid = Math.floor(ratios.length / 2);
+  const first = ratios.slice(0, mid);
+  const second = ratios.slice(mid);
+  const avg = (items) => items.length ? items.reduce((sum, item) => sum + item, 0) / items.length : 0;
+  const firstAvg = avg(first);
+  const secondAvg = avg(second);
+  const classification = secondAvg > firstAvg && secondAvg > 0.15 ? "degrading" : turnsAboveThreshold > 5 ? "churning" : "stable";
+  return {
+    classification,
+    turnsAboveThreshold,
+    totalTurns: series.length,
+    avgCacheCreationPct: avg(ratios) * 100,
+    perTurnRatios: ratios.map((ratio) => Math.round(ratio * 1000) / 10),
+  };
+}
+
+function contextGrowth(session) {
+  const series = session.usage && session.usage.series || [];
+  const perTurnInput = series.map((turn) => (turn.inputTokens || 0) + (turn.cacheCreationInputTokens || 0) + (turn.cacheReadInputTokens || 0));
+  let growthFactor = 0;
+  let flagged = false;
+  if (perTurnInput.length > 5 && perTurnInput[4] > 0) {
+    growthFactor = perTurnInput[perTurnInput.length - 1] / perTurnInput[4];
+    flagged = growthFactor > 2;
+  }
+  let pressureWindows = 0;
+  let peakWindowAvg = 0;
+  if (perTurnInput.length >= PRESSURE_WINDOW) {
+    for (let i = 0; i <= perTurnInput.length - PRESSURE_WINDOW; i++) {
+      const window = perTurnInput.slice(i, i + PRESSURE_WINDOW);
+      const avg = window.reduce((sum, value) => sum + value, 0) / PRESSURE_WINDOW;
+      if (avg > PRESSURE_TOKENS) pressureWindows += 1;
+      if (avg > peakWindowAvg) peakWindowAvg = avg;
+    }
+  }
+  return {
+    flagged,
+    growthFactor: Math.round(growthFactor * 10) / 10,
+    perTurnInput: perTurnInput.slice(0, 260),
+    pressureWindows,
+    peakWindowAvg: Math.round(peakWindowAvg),
+  };
+}
+
+function duplicateReadGroups(sessions) {
+  const groups = {};
+  let duplicateCount = 0;
+  for (const session of sessions) {
+    const seen = {};
+    const steps = (session.steps || []).slice().sort((a, b) => a.index - b.index);
+    for (const step of steps) {
+      const target = normalizedTarget(step.target);
+      if (!target || !target.includes("/")) continue;
+      if (step.family === "write") {
+        delete seen[target];
+        continue;
+      }
+      if (step.family !== "read") continue;
+      if (!seen[target]) {
+        seen[target] = step;
+        continue;
+      }
+      duplicateCount += 1;
+      const key = session.sessionId + "|" + target;
+      if (!groups[key]) {
+        groups[key] = {
+          path: target,
+          sessionId: session.sessionId,
+          sessionTitle: session.title,
+          count: 1,
+          firstIndex: seen[target].index,
+          repeated: [],
+        };
+      }
+      groups[key].count += 1;
+      groups[key].repeated.push(step.index);
+    }
+  }
+  return { duplicateCount, groups: Object.values(groups).sort((a, b) => b.count - a.count) };
+}
+
+function commandRetryGroups(sessions) {
+  const retries = [];
+  for (const session of sessions) {
+    const steps = (session.steps || []).slice().sort((a, b) => a.index - b.index);
+    let current = null;
+    let streak = [];
+    const flush = () => {
+      if (current && streak.length >= 3) {
+        retries.push({
+          command: current,
+          sessionId: session.sessionId,
+          sessionTitle: session.title,
+          count: streak.length,
+          steps: streak.map((step) => step.index),
+        });
+      }
+    };
+    for (const step of steps) {
+      const command = step.family === "execute" ? step.normalizedCommand : "";
+      if (command && command === current) {
+        streak.push(step);
+      } else {
+        flush();
+        current = command || null;
+        streak = command ? [step] : [];
+      }
+    }
+    flush();
+  }
+  return retries.sort((a, b) => b.count - a.count);
+}
+
+function failedToolLoops(sessions) {
+  const loops = [];
+  for (const session of sessions) {
+    const steps = (session.steps || []).slice().sort((a, b) => a.index - b.index);
+    let currentTool = "";
+    let streak = [];
+    const flush = () => {
+      if (currentTool && streak.length >= 3) {
+        loops.push({
+          tool: currentTool,
+          sessionId: session.sessionId,
+          sessionTitle: session.title,
+          count: streak.length,
+          steps: streak.map((step) => step.index),
+          sample: streak[0] && (streak[0].errorPreview || streak[0].preview),
+        });
+      }
+    };
+    for (const step of steps) {
+      if (step.isError && step.tool === currentTool) {
+        streak.push(step);
+      } else {
+        flush();
+        currentTool = step.isError ? step.tool : "";
+        streak = step.isError ? [step] : [];
+      }
+    }
+    flush();
+  }
+  return loops.sort((a, b) => b.count - a.count);
+}
+
+function dayKey(value) {
+  const date = new Date(value || Date.now());
+  if (!Number.isFinite(date.getTime())) return "unknown";
+  return date.toISOString().slice(0, 10);
+}
+
+function analyzeContext(sessions, args, mcpServers) {
+  const agg = aggregate(sessions);
+  const steps = agg.steps || [];
+  const familyCounts = {};
+  let failedTools = 0;
+  for (const step of steps) {
+    addCounter(familyCounts, step.family || "tool", 1);
+    if (step.isError) failedTools += 1;
+  }
+  const reads = familyCounts.read || 0;
+  const searches = familyCounts.search || 0;
+  const writes = familyCounts.write || 0;
+  const executes = familyCounts.execute || 0;
+  const agents = familyCounts.agent || 0;
+  const mcpCalls = familyCounts.mcp || 0;
+  const readSearch = reads + searches;
+  const explorationRatio = writes ? readSearch / writes : readSearch;
+  const usage = agg.usage || emptyUsage();
+  const cacheDenom = (usage.inputTokens || 0) + (usage.cacheCreationInputTokens || 0) + (usage.cacheReadInputTokens || 0);
+  const cacheHitRatio = cacheDenom ? (usage.cacheReadInputTokens || 0) / cacheDenom : 0;
+  const cacheCreationPct = cacheDenom ? (usage.cacheCreationInputTokens || 0) / cacheDenom : 0;
+  const duplicateReads = duplicateReadGroups(sessions);
+  const retries = commandRetryGroups(sessions);
+  const failureLoops = failedToolLoops(sessions);
+  const cacheSessions = sessions.map((session) => Object.assign({ sessionId: session.sessionId, sessionTitle: session.title }, cacheStability(session)));
+  const growthSessions = sessions.map((session) => Object.assign({ sessionId: session.sessionId, sessionTitle: session.title }, contextGrowth(session)));
+  const churning = cacheSessions.filter((item) => item.classification !== "stable");
+  const growing = growthSessions.filter((item) => item.flagged);
+  const pressure = growthSessions.filter((item) => item.pressureWindows > 0);
+  const byDay = {};
+  for (const session of sessions) {
+    const key = dayKey(session.updatedAt || session.startedAt || session.mtime);
+    if (!byDay[key]) byDay[key] = { day: key, sessions: 0, tokens: 0, observed: 0, codex: 0, claude: 0 };
+    byDay[key].sessions += 1;
+    byDay[key].tokens += session.tokens || 0;
+    if (session.tokenMethod === "observed") byDay[key].observed += 1;
+    byDay[key][session.source] = (byDay[key][session.source] || 0) + 1;
+  }
+  const categoryTotal = Object.values(agg.categories).reduce((sum, value) => sum + value, 0);
+  const toolOutputPct = pct(agg.categories.tool_output || 0, categoryTotal);
+  const metadataPct = pct(agg.categories.metadata || 0, categoryTotal);
+  const assistantPct = pct(agg.categories.assistant || 0, categoryTotal);
+  const maxSession = sessions.length ? sessions.reduce((a, b) => a.tokens > b.tokens ? a : b) : null;
+  const failureRate = steps.length ? failedTools / steps.length : 0;
+  const findings = [];
+  if (duplicateReads.duplicateCount > 0) {
+    addFinding(findings, "duplicate_read", Math.min(86, 35 + duplicateReads.duplicateCount * 6), "context", "Repeated file reads", duplicateReads.duplicateCount + " file reads repeated without an intervening edit/write.", duplicateReads.groups.slice(0, 4).map((group) => group.path + " read " + group.count + "x in " + group.sessionTitle), "Ask the agent to keep a short file-role note after the first read and reopen the file only when it needs exact line numbers.", "prompt");
+  }
+  if (retries.length) {
+    addFinding(findings, "command_retry_loop", 78, "loop", "Repeated command loop", "One or more shell commands ran 3+ times in a row.", retries.slice(0, 4).map((retry) => retry.command + " · " + retry.count + "x in " + retry.sessionTitle), "Ask the agent to stop after two identical failures, summarize the error, and change strategy before rerunning the command.", "prompt");
+  }
+  if (failureLoops.length || (failedTools >= 3 && failureRate > 0.12)) {
+    addFinding(findings, "failed_tool_loop", failureLoops.length ? 82 : 55, "loop", "Tool failures need a recovery plan", failedTools + " failed tool calls detected across " + steps.length + " normalized tool steps.", (failureLoops.length ? failureLoops : steps.filter((step) => step.isError).slice(0, 4)).map((item) => (item.tool || item.title || "tool") + " · " + (item.count || "failed") + " · " + (item.sessionTitle || item.sessionId || "")), "Tell the agent to diagnose the first failure, propose the next attempt, and avoid repeating the same tool call unchanged.", "prompt");
+  }
+  if (explorationRatio > 5 && readSearch >= 10) {
+    addFinding(findings, "exploration_ratio", Math.min(80, 35 + explorationRatio * 5), "workflow", "Exploration outweighs edits", "Read/search calls are " + explorationRatio.toFixed(1) + "x edit/write calls.", ["Reads/searches: " + readSearch, "Writes/edits: " + writes, "Execute calls: " + executes], "Give the agent a concrete inspection budget, then ask for a short implementation plan before more reading.", "prompt");
+  }
+  if (agents > 3) {
+    addFinding(findings, "subagent_sprawl", Math.min(72, 35 + agents * 6), "workflow", "Subagent usage is broad", agents + " agent/delegation tool calls were detected.", ["Agent-family calls: " + agents], "Ask for a coordination summary after subagents finish: decisions, files touched, and what should stay in the main thread.", "prompt");
+  }
+  if (churning.length) {
+    addFinding(findings, "cache_churn", churning.some((item) => item.classification === "churning") ? 78 : 62, "cache", "Cache is churning or degrading", churning.length + " session(s) had sustained or rising cache creation.", churning.slice(0, 4).map((item) => item.sessionTitle + " · " + item.classification + " · avg create " + item.avgCacheCreationPct.toFixed(0) + "%"), "Move stable instructions into a skill/repo doc and start long follow-up work from a compact handoff so cache writes settle earlier.", "workflow");
+  }
+  if (growing.length) {
+    addFinding(findings, "context_growth", 74, "context", "Context keeps growing late in the session", growing.length + " session(s) grew >2x from turn 5 to the final observed turn.", growing.slice(0, 4).map((item) => item.sessionTitle + " · " + item.growthFactor + "x growth"), "After a milestone, ask for a handoff summary and continue in a fresh thread rather than carrying the full transcript forward.", "workflow");
+  }
+  if (pressure.length) {
+    addFinding(findings, "context_pressure", 70, "context", "High context pressure windows", pressure.length + " session(s) crossed a " + fmtTokens(PRESSURE_TOKENS) + " five-turn average input window.", pressure.slice(0, 4).map((item) => item.sessionTitle + " · peak avg " + fmtTokens(item.peakWindowAvg)), "Use a context reset before the next implementation phase and preserve only decisions, current files, and known failing commands.", "workflow");
+  }
+  if (toolOutputPct > 45) {
+    addFinding(findings, "tool_output_heavy", Math.min(76, 35 + toolOutputPct), "context", "Tool output dominates the window", toolOutputPct.toFixed(0) + "% of transcript text came from tool output.", sortedEntries(agg.tools, 4).map((entry) => entry[0] + " x" + entry[1]), "Ask the agent to cap logs, request targeted excerpts, and summarize failing output unless exact lines are needed.", "prompt");
+  }
+  if (metadataPct > 18) {
+    addFinding(findings, "metadata_pressure", Math.min(64, 25 + metadataPct), "context", "Metadata is a visible share", metadataPct.toFixed(0) + "% of local transcript text was metadata or protocol state.", sortedEntries(agg.metadata, 4).map((entry) => entry[0] + " · about " + fmtTokens(estimateTokens(entry[1]))), "Keep the report in drilldown mode: inspect metadata when diagnosing protocol overhead, but optimize prompts around user/tool/output buckets first.", "workflow");
+  }
+  if (assistantPct > 45) {
+    addFinding(findings, "assistant_prose", Math.min(68, 25 + assistantPct), "workflow", "Assistant narration is heavy", assistantPct.toFixed(0) + "% of transcript text came from assistant prose.", ["Assistant bucket: about " + fmtTokens(estimateTokens(agg.categories.assistant || 0))], "Ask for concise progress notes and a final decision log, with detailed rationale moved into docs only when useful.", "prompt");
+  }
+  if (maxSession && maxSession.tokens > 80000) {
+    addFinding(findings, "large_session", Math.min(82, 42 + maxSession.tokens / 5000), "context", "One session is carrying a lot", "Largest session is about " + fmtTokens(maxSession.tokens) + " " + maxSession.tokenMethod + " tokens.", [maxSession.title + " · " + maxSession.source + " · " + (maxSession.cwd || maxSession.path)], "Start the next large change with a compact handoff summary instead of continuing the whole thread.", "workflow");
+  }
+  if ((mcpServers || []).length > 12 && mcpCalls < 3) {
+    addFinding(findings, "mcp_surface", 28, "mcp", "Configured MCP surface is broad", (mcpServers || []).length + " MCP servers are configured, but only " + mcpCalls + " MCP-style calls were detected.", (mcpServers || []).slice(0, 5).map((server) => server.source + " · " + server.name), "For focused CLI work, keep rarely used MCP servers disabled or project-scoped so tool lists stay easier to scan.", "configuration");
+  }
+  let score = 100;
+  score -= Math.min(18, duplicateReads.duplicateCount * 2);
+  score -= retries.length ? 14 : 0;
+  score -= failureLoops.length ? 16 : Math.min(12, Math.round(failureRate * 60));
+  score -= explorationRatio > 5 ? Math.min(15, Math.round((explorationRatio - 5) * 2)) : 0;
+  score -= churning.length ? 14 : 0;
+  score -= growing.length ? 12 : 0;
+  score -= pressure.length ? 10 : 0;
+  score -= toolOutputPct > 45 ? 8 : 0;
+  score = Math.max(0, Math.min(100, Math.round(score)));
+  findings.sort((a, b) => b.score - a.score);
+  return {
+    score,
+    scoreLabel: score >= 85 ? "healthy" : score >= 70 ? "watch" : score >= 50 ? "strained" : "critical",
+    metrics: {
+      normalizedSteps: steps.length,
+      failedTools,
+      failureRate,
+      successRate: steps.length ? 1 - failureRate : 1,
+      familyCounts,
+      reads,
+      searches,
+      writes,
+      executes,
+      agents,
+      mcpCalls,
+      explorationRatio: Math.round(explorationRatio * 10) / 10,
+      duplicateReadCount: duplicateReads.duplicateCount,
+      retryLoopCount: retries.length,
+      failureLoopCount: failureLoops.length,
+      cacheHitRatio,
+      cacheCreationPct,
+      tokenUsage: usage,
+      observedSessionCoverage: sessions.length ? sessions.filter((session) => session.tokenMethod === "observed").length / sessions.length : 0,
+      toolOutputPct,
+      metadataPct,
+      assistantPct,
+    },
+    findings,
+    evidence: {
+      duplicateReads: duplicateReads.groups.slice(0, 20),
+      commandRetries: retries.slice(0, 20),
+      failureLoops: failureLoops.slice(0, 20),
+      cacheStability: cacheSessions,
+      contextGrowth: growthSessions,
+    },
+    trends: {
+      byDay: Object.values(byDay).sort((a, b) => a.day.localeCompare(b.day)),
+      topTools: sortedEntries(agg.tools, 12),
+      topPaths: sortedEntries(agg.paths, 12),
+      topMetadata: sortedEntries(agg.metadata, 12),
+    },
+    sourceModel: {
+      sourceProjectSession: sessions.map((session) => ({
+        source: session.source,
+        project: session.cwd || args.project,
+        sessionId: session.sessionId,
+        title: session.title,
+        tokens: session.tokens,
+        updatedAt: session.updatedAt,
+        tokenMethod: session.tokenMethod,
+        steps: session.totalSteps || 0,
+      })),
+      privacy: "Metadata-first: the report stores counters, tool names, paths, short previews, and line offsets where available; transcript bodies stay local.",
+    },
+  };
+}
+
+function recommendations(sessions, analysis) {
+  if (!sessions.length) return ["No matching sessions found. Try context-xray threads --all-projects --since 2w --open."];
+  if (analysis && analysis.findings && analysis.findings.length) {
+    const seen = {};
+    const fromFindings = [];
+    for (const finding of analysis.findings) {
+      if (!finding.recommendation || seen[finding.recommendation]) continue;
+      seen[finding.recommendation] = true;
+      fromFindings.push(finding.recommendation);
+    }
+    if (fromFindings.length) return fromFindings.slice(0, 6);
+  }
+  const agg = aggregate(sessions);
+  const total = Object.values(agg.categories).reduce((sum, value) => sum + value, 0);
+  const tips = [];
+  const toolOutput = pct(agg.categories.tool_output || 0, total);
+  const instructions = pct(agg.categories.instructions || 0, total);
+  const assistant = pct(agg.categories.assistant || 0, total);
+  const maxSession = sessions.reduce((a, b) => a.tokens > b.tokens ? a : b);
+  if (toolOutput > 45) tips.push("Tool output dominates context. In your prompt, ask the agent to keep command output capped, summarize failures, and only expand logs when the exact lines matter.");
+  if (instructions > 25) tips.push("Instructions are a large share. Move durable workflow preferences into a skill, AGENTS.md, or CLAUDE.md so each thread can start with a shorter task prompt.");
+  if (assistant > 45) tips.push("Assistant prose is heavy. Ask for brief progress updates and a final decision log, instead of detailed narration during every loop.");
+  if (maxSession.tokens > 80000) tips.push("The largest session is about " + fmtTokens(maxSession.tokens) + " " + maxSession.tokenMethod + " tokens. Ask for a handoff summary, then continue in a fresh thread before the next large implementation pass.");
+  const topTool = sortedEntries(agg.tools, 1)[0];
+  if (topTool && topTool[1] > 20) tips.push(topTool[0] + " appears " + topTool[1] + " times. Tell the agent to batch independent inspection and avoid rerunning diagnostics unless state changed.");
+  const topPath = sortedEntries(agg.paths, 1)[0];
+  if (topPath && topPath[1] > 12) tips.push(topPath[0] + " appears repeatedly (" + topPath[1] + " mentions). Ask the agent to keep a short file-role summary and reopen the file only when it needs exact lines.");
+  return tips.length ? tips.slice(0, 6) : ["Recent sessions look balanced. Keep giving scoped tasks, ask for compaction after milestones, and preserve reusable decisions in a skill or repo doc."];
+}
+
+function escapeHtml(value) {
+  return String(value || "").replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }[ch]));
+}
+
+function cleanTitle(value) {
+  return String(value || "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+
+function categoryBar(categories) {
+  const total = Object.values(categories || {}).reduce((sum, value) => sum + value, 0);
+  if (!total) return "<div class=\"bar\"></div>";
+  return "<div class=\"bar\">" + CATEGORIES.map((cat) => {
+    const value = categories[cat] || 0;
+    if (!value) return "";
+    const width = Math.max(1, pct(value, total));
+    return "<span title=\"" + escapeHtml(LABELS[cat]) + "\" style=\"width:" + width.toFixed(2) + "%;background:" + COLORS[cat] + "\"></span>";
+  }).join("") + "</div>";
+}
+
+function readJsonFile(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function safeUrl(value) {
+  try {
+    const url = new URL(String(value || ""));
+    return url.origin + url.pathname;
+  } catch {
+    return String(value || "").split(/[?#]/)[0].slice(0, 120);
+  }
+}
+
+function mcpTarget(definition) {
+  if (!definition || typeof definition !== "object") return "configured";
+  if (definition.url) return safeUrl(definition.url);
+  if (definition.command) return String(definition.command);
+  if (definition.transport) return String(definition.transport);
+  return "configured";
+}
+
+function addMcpServer(out, name, source, definition) {
+  if (!name) return;
+  const key = source + ":" + name;
+  if (out.some((server) => server.key === key)) return;
+  out.push({
+    key,
+    name: String(name),
+    source,
+    target: mcpTarget(definition),
+  });
+}
+
+function readMcpJson(file, source, out) {
+  const json = readJsonFile(file);
+  if (!json || typeof json !== "object") return;
+  const servers = json.mcpServers || json.mcp_servers || json.servers;
+  if (!servers || typeof servers !== "object") return;
+  for (const name of Object.keys(servers)) addMcpServer(out, name, source, servers[name]);
+}
+
+function readCodexTomlServers(file, out) {
+  let text = "";
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return;
+  }
+  const lines = text.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const match = lines[index].match(/^\s*\[mcp_servers\.(?:"([^"]+)"|([^\]]+))\]\s*$/);
+    if (!match) continue;
+    const name = match[1] || match[2] || "";
+    const section = {};
+    for (let cursor = index + 1; cursor < lines.length; cursor++) {
+      if (/^\s*\[/.test(lines[cursor])) break;
+      const pair = lines[cursor].match(/^\s*([A-Za-z0-9_-]+)\s*=\s*"?([^"]+)"?\s*$/);
+      if (pair) section[pair[1]] = pair[2];
+    }
+    addMcpServer(out, name, "Codex config", section);
+  }
+}
+
+function readMcpServers(project) {
+  const out = [];
+  readCodexTomlServers(path.join(CODEX_DIR, "config.toml"), out);
+  readMcpJson(path.join(HOME, ".claude.json"), "Claude user config", out);
+  readMcpJson(path.join(CLAUDE_DIR, "settings.json"), "Claude settings", out);
+  readMcpJson(path.join(path.resolve(project), ".mcp.json"), "Project .mcp.json", out);
+  readMcpJson(path.join(path.resolve(project), ".cursor", "mcp.json"), "Project Cursor MCP", out);
+  readMcpJson(path.join(HOME, ".cowork", "mcp.json"), "Cowork MCP", out);
+  return out.sort((a, b) => a.name.localeCompare(b.name) || a.source.localeCompare(b.source));
+}
+
+function sourceCounts(sessions) {
+  return sessions.reduce((counts, session) => {
+    counts[session.source] = (counts[session.source] || 0) + 1;
+    return counts;
+  }, {});
+}
+
+function buildReport(sessions, args) {
+  const agg = aggregate(sessions);
+  const mcpServers = readMcpServers(args.project);
+  const analysis = analyzeContext(sessions, args, mcpServers);
+  return {
+    generatedAt: new Date().toISOString(),
+    generatedLabel: new Date().toLocaleString(),
+    mode: args.mode,
+    source: args.source,
+    since: args.since,
+    project: path.resolve(args.project),
+    sessionCount: sessions.length,
+    sourceCounts: sourceCounts(sessions),
+    totalTokens: sessions.reduce((sum, s) => sum + s.tokens, 0),
+    categories: agg.categories,
+    tools: sortedEntries(agg.tools, 50),
+    toolTokens: sortedEntries(agg.toolTokens, 50),
+    paths: sortedEntries(agg.paths, 50),
+    metadata: sortedEntries(agg.metadata, 50),
+    mcpUsage: sortedEntries(agg.mcpUsage, 50),
+    mcpTools: sortedEntries(agg.mcpTools, 50),
+    mcpServers,
+    analysis,
+    recommendations: recommendations(sessions, analysis),
+    toolEvents: agg.toolEvents,
+    metadataEvents: agg.metadataEvents,
+    steps: agg.steps,
+    sessions,
+  };
+}
+
+function jsonScript(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+
+function overviewEnhancementScript() {
+  return "(" + function () {
+    const dataEl = document.getElementById("xray-data");
+    if (!dataEl) return;
+    const report = JSON.parse(dataEl.textContent || "{}");
+    const cats = ["user", "assistant", "tool_call", "tool_output", "reasoning", "instructions", "attachment", "metadata", "other"];
+    const labels = {
+      user: "User asks",
+      assistant: "Assistant text",
+      tool_call: "Tool calls",
+      tool_output: "Tool output",
+      reasoning: "Reasoning",
+      instructions: "Instructions/context",
+      attachment: "Attachments",
+      metadata: "Metadata",
+      other: "Other",
+    };
+    const colors = {
+      user: "#8ba8ff",
+      assistant: "#55b982",
+      tool_call: "#f0a85b",
+      tool_output: "#e06b73",
+      reasoning: "#a77be8",
+      instructions: "#6ac3d5",
+      attachment: "#d6a85a",
+      metadata: "#9aa3ad",
+      other: "#c3c8ce",
+    };
+
+    function esc(value) {
+      return String(value || "").replace(/[&<>"']/g, function (ch) {
+        return { "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }[ch];
+      });
+    }
+
+    function fmt(value) {
+      const number = Number(value) || 0;
+      if (number >= 1000000) return (number / 1000000).toFixed(1) + "m";
+      if (number >= 1000) return (number / 1000).toFixed(1) + "k";
+      return String(number);
+    }
+
+    function tok(chars) {
+      chars = Number(chars) || 0;
+      return chars > 0 ? Math.max(1, Math.ceil(chars / 4)) : 0;
+    }
+
+    function totalCounter(counter) {
+      return Object.keys(counter || {}).reduce(function (sum, key) {
+        return sum + (Number(counter[key]) || 0);
+      }, 0);
+    }
+
+    function pct(part, total) {
+      return total > 0 ? Math.max(0, Math.min(100, (part / total) * 100)) : 0;
+    }
+
+    function actionRow(kind, value, title, subtitle, right, farRight, color) {
+      return "<button class=\"row-button\" data-overview-kind=\"" + esc(kind) + "\" data-overview-value=\"" + esc(value) + "\"><span><span class=\"row-title\">" + (color ? "<span class=\"badge\"><span class=\"dot\" style=\"background:" + esc(color) + "\"></span>" + esc(title) + "</span>" : esc(title)) + "</span><span class=\"meta\">" + esc(subtitle) + "</span></span><span class=\"row-meta\">" + esc(right) + "</span><span class=\"row-meta\">" + esc(farRight || "") + "</span></button>";
+    }
+
+    function bar(counter) {
+      const total = totalCounter(counter);
+      if (!total) return "<div class=\"bar\"></div>";
+      return "<div class=\"bar\">" + cats.map(function (cat) {
+        const value = (counter || {})[cat] || 0;
+        if (!value) return "";
+        return "<button type=\"button\" data-overview-kind=\"category\" data-overview-value=\"" + esc(cat) + "\" title=\"" + esc(labels[cat]) + "\" style=\"width:" + Math.max(1, pct(value, total)).toFixed(2) + "%;background:" + colors[cat] + ";border:0;padding:0;display:block;min-width:2px;cursor:pointer\"></button>";
+      }).join("") + "</div>";
+    }
+
+    function topTools(limit) {
+      return (report.tools || []).slice(0, limit || 8);
+    }
+
+    function toolTokens(name) {
+      const found = (report.toolTokens || []).filter(function (entry) {
+        return entry[0] === name;
+      })[0];
+      return found ? found[1] : 0;
+    }
+
+    function sessionMatches(kind, value) {
+      return (report.sessions || []).filter(function (session) {
+        if (kind === "category") return !!((session.categories || {})[value]);
+        if (kind === "path") return !!((session.paths || {})[value]);
+        return false;
+      }).sort(function (a, b) {
+        const left = kind === "path" ? (a.paths || {})[value] || 0 : (a.categories || {})[value] || 0;
+        const right = kind === "path" ? (b.paths || {})[value] || 0 : (b.categories || {})[value] || 0;
+        return right - left;
+      });
+    }
+
+    function sampleCards(events) {
+      events = (events || []).slice(0, 8);
+      if (!events.length) return "<p class=\"empty\">No sampled records for this item.</p>";
+      return "<div class=\"detail-list\">" + events.map(function (event) {
+        return "<article class=\"sample\"><div class=\"sample-top\"><span>" + esc(event.source) + " · " + esc(event.sessionTitle || event.sessionId) + "</span><span>" + fmt(event.tokens || 0) + " tok</span></div><p>" + esc(event.preview || "No preview captured.") + "</p></article>";
+      }).join("") + "</div>";
+    }
+
+    function sessionCards(sessions, kind, value) {
+      sessions = (sessions || []).slice(0, 8);
+      if (!sessions.length) return "<p class=\"empty\">No matching sessions for this item.</p>";
+      return "<div class=\"detail-list\">" + sessions.map(function (session) {
+        const amount = kind === "path" ? (session.paths || {})[value] || 0 : tok((session.categories || {})[value] || 0);
+        const unit = kind === "path" ? "mentions" : "tok";
+        return "<article class=\"sample\"><div class=\"sample-top\"><span>" + esc(session.source) + " · " + esc(session.updatedAt || "unknown time") + "</span><span>" + esc(fmt(amount) + " " + unit) + "</span></div><p><strong>" + esc(session.title || session.sessionId) + "</strong></p><p class=\"meta\">" + esc(session.cwd || session.path) + "</p></article>";
+      }).join("") + "</div>";
+    }
+
+    function openDetailTab(tab, selector, value) {
+      const tabButton = document.querySelector("[data-tab=\"" + tab + "\"]");
+      if (tabButton) tabButton.click();
+      if (!selector) return;
+      window.setTimeout(function () {
+        const rows = Array.prototype.slice.call(document.querySelectorAll(selector));
+        const row = rows.filter(function (item) {
+          return item.getAttribute(selector.slice(1, -1)) === value;
+        })[0];
+        if (row) row.click();
+      }, 0);
+    }
+
+    function jumpButton(tab, label, selector, value) {
+      return "<button class=\"row-button\" data-overview-jump=\"" + esc(tab) + "\" data-overview-selector=\"" + esc(selector) + "\" data-overview-value=\"" + esc(value || "") + "\"><span><span class=\"row-title\">" + esc(label) + "</span><span class=\"meta\">Open the full detail tab</span></span><span class=\"row-meta\">open</span><span class=\"row-meta\"></span></button>";
+    }
+
+    function setDetail(kind, value) {
+      const el = document.getElementById("overview-drilldown");
+      if (!el) return;
+      if (kind === "tool") {
+        const events = (report.toolEvents || []).filter(function (event) {
+          return event.tool === value;
+        });
+        el.innerHTML = "<div class=\"section-head\"><div><h2>" + esc(value) + "</h2><p class=\"meta\">Sampled calls from the selected sessions.</p></div></div>" + sampleCards(events) + "<div class=\"mini-label\">More</div>" + jumpButton("tools", "Open Tool Calls", "[data-tool]", value);
+      } else if (kind === "metadata") {
+        const events = (report.metadataEvents || []).filter(function (event) {
+          return event.type === value;
+        });
+        el.innerHTML = "<div class=\"section-head\"><div><h2>" + esc(value) + "</h2><p class=\"meta\">Sampled metadata records from transcripts.</p></div></div>" + sampleCards(events) + "<div class=\"mini-label\">More</div>" + jumpButton("metadata", "Open Metadata", "[data-meta]", value);
+      } else if (kind === "path") {
+        el.innerHTML = "<div class=\"section-head\"><div><h2>" + esc(value) + "</h2><p class=\"meta\">Sessions where this path repeats.</p></div></div>" + sessionCards(sessionMatches("path", value), "path", value) + "<div class=\"mini-label\">More</div>" + jumpButton("sessions", "Open Sessions", "", "");
+      } else {
+        const chars = (report.categories || {})[value] || 0;
+        const sessions = sessionMatches("category", value);
+        let extra = "";
+        if (value === "tool_call") {
+          extra = "<div class=\"mini-label\">Top tools</div>" + topTools(6).map(function (entry) {
+            return actionRow("tool", entry[0], entry[0], "Click for sampled calls", "x" + entry[1], fmt(toolTokens(entry[0])) + " tok");
+          }).join("");
+        } else if (value === "metadata") {
+          extra = "<div class=\"mini-label\">Metadata types</div>" + (report.metadata || []).slice(0, 6).map(function (entry) {
+            return actionRow("metadata", entry[0], entry[0], "Click for sampled records", fmt(tok(entry[1])) + " tok", fmt(entry[1]) + " ch");
+          }).join("");
+        }
+        el.innerHTML = "<div class=\"section-head\"><div><h2>" + esc(labels[value] || value) + "</h2><p class=\"meta\">" + esc(fmt(tok(chars)) + " estimated tokens across " + sessions.length + " session(s).") + "</p></div></div>" + (extra || sessionCards(sessions, "category", value));
+      }
+      bindOverview();
+    }
+
+    function bindOverview() {
+      Array.prototype.forEach.call(document.querySelectorAll("[data-overview-kind]"), function (button) {
+        button.onclick = function () {
+          setDetail(button.getAttribute("data-overview-kind"), button.getAttribute("data-overview-value"));
+        };
+      });
+      Array.prototype.forEach.call(document.querySelectorAll("[data-overview-jump]"), function (button) {
+        button.onclick = function () {
+          const selector = button.getAttribute("data-overview-selector");
+          const value = button.getAttribute("data-overview-value");
+          openDetailTab(button.getAttribute("data-overview-jump"), selector, value);
+        };
+      });
+    }
+
+    function renderOverview() {
+      const panel = document.getElementById("panel-overview");
+      if (!panel) return;
+      const total = totalCounter(report.categories);
+      const categoryRows = cats.map(function (cat) {
+        const chars = (report.categories || {})[cat] || 0;
+        if (!chars) return "";
+        return actionRow("category", cat, labels[cat], "Click for sessions and hotspots", fmt(tok(chars)) + " tok", pct(chars, total).toFixed(0) + "%", colors[cat]);
+      }).join("");
+      const toolRows = topTools(8).map(function (entry) {
+        return actionRow("tool", entry[0], entry[0], "Click for sampled calls", "x" + entry[1], fmt(toolTokens(entry[0])) + " tok");
+      }).join("") || "<p class=\"empty\">No tool calls detected.</p>";
+      const pathRows = (report.paths || []).slice(0, 8).map(function (entry) {
+        return actionRow("path", entry[0], entry[0], "Click for matching sessions", "x" + entry[1], "");
+      }).join("") || "<p class=\"empty\">No repeated paths detected.</p>";
+      const metadataRows = (report.metadata || []).slice(0, 8).map(function (entry) {
+        return actionRow("metadata", entry[0], entry[0], "Click for sampled records", fmt(tok(entry[1])) + " tok", fmt(entry[1]) + " ch");
+      }).join("") || "<p class=\"empty\">No metadata-heavy records detected.</p>";
+      panel.innerHTML = "<div class=\"grid\"><section class=\"card\"><div class=\"section-head\"><div><h2>Where The Context Is Going</h2><p class=\"meta\">Click a segment or row to inspect it.</p></div></div>" + bar(report.categories) + "<div>" + categoryRows + "</div></section><section class=\"card\" id=\"overview-drilldown\"><div class=\"section-head\"><div><h2>Warnings And Optimizations</h2><p class=\"meta\">Promptable changes you control.</p></div></div><ol class=\"tips\">" + (report.recommendations || []).map(function (tip) { return "<li>" + esc(tip) + "</li>"; }).join("") + "</ol></section></div><div class=\"grid equal\" style=\"margin-top:14px\"><section class=\"card\"><h2>Tool Hotspots</h2>" + toolRows + "</section><section class=\"card\"><h2>Top Paths</h2>" + pathRows + "</section></div><section class=\"card\" style=\"margin-top:14px\"><h2>Metadata Types</h2>" + metadataRows + "</section>";
+      bindOverview();
+    }
+
+    renderOverview();
+  }.toString() + ")();";
+}
+
+function insightsEnhancementScript() {
+  return "(" + function () {
+    const dataEl = document.getElementById("xray-data");
+    if (!dataEl) return;
+    const report = JSON.parse(dataEl.textContent || "{}");
+    const analysis = report.analysis || {};
+    const metrics = analysis.metrics || {};
+    const findings = analysis.findings || [];
+    const cats = ["user", "assistant", "tool_call", "tool_output", "reasoning", "instructions", "attachment", "metadata", "other"];
+    const labels = {
+      user: "User asks",
+      assistant: "Assistant text",
+      tool_call: "Tool calls",
+      tool_output: "Tool output",
+      reasoning: "Reasoning",
+      instructions: "Instructions/context",
+      attachment: "Attachments",
+      metadata: "Metadata",
+      other: "Other",
+    };
+    const colors = {
+      user: "#2563eb",
+      assistant: "#16a34a",
+      tool_call: "#d97706",
+      tool_output: "#dc2626",
+      reasoning: "#7c3aed",
+      instructions: "#0891b2",
+      attachment: "#b45309",
+      metadata: "#64748b",
+      other: "#94a3b8",
+    };
+
+    function esc(value) {
+      return String(value || "").replace(/[&<>"']/g, function (ch) {
+        return { "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }[ch];
+      });
+    }
+
+    function fmt(value) {
+      const number = Number(value) || 0;
+      if (Math.abs(number) >= 1000000) return (number / 1000000).toFixed(1) + "m";
+      if (Math.abs(number) >= 1000) return (number / 1000).toFixed(1) + "k";
+      return String(Math.round(number * 10) / 10);
+    }
+
+    function pctText(value) {
+      return Math.round((Number(value) || 0) * 100) + "%";
+    }
+
+    function totalCounter(counter) {
+      return Object.keys(counter || {}).reduce(function (sum, key) {
+        return sum + (Number(counter[key]) || 0);
+      }, 0);
+    }
+
+    function tok(chars) {
+      chars = Number(chars) || 0;
+      return chars > 0 ? Math.max(1, Math.ceil(chars / 4)) : 0;
+    }
+
+    function addStyle() {
+      if (document.getElementById("xray-insights-style")) return;
+      const style = document.createElement("style");
+      style.id = "xray-insights-style";
+      style.textContent = [
+        ".health-shell{display:grid;grid-template-columns:270px minmax(0,1fr);gap:14px;align-items:stretch;margin-bottom:14px}",
+        ".health-card{display:flex;gap:16px;align-items:center;background:hsl(var(--card));border:1px solid hsl(var(--border));border-radius:8px;padding:16px;box-shadow:var(--shadow)}",
+        ".health-dial{width:112px;height:112px;border-radius:999px;display:grid;place-items:center;background:conic-gradient(#16a34a calc(var(--score)*1%),hsl(var(--muted)) 0);position:relative;flex:0 0 auto}",
+        ".health-dial:after{content:\"\";position:absolute;inset:9px;border-radius:inherit;background:hsl(var(--card))}",
+        ".health-score{position:relative;z-index:1;font-size:30px;font-weight:750;letter-spacing:0}",
+        ".health-copy{min-width:0}.health-copy h2{font-size:18px}.health-copy p{margin-top:6px;color:hsl(var(--muted-foreground));font-size:13px}",
+        ".metric-grid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px}",
+        ".metric-tile{border:1px solid hsl(var(--border));border-radius:8px;padding:12px;background:hsl(var(--card));min-height:84px}",
+        ".metric-tile strong{display:block;font-size:22px;line-height:1.1;margin-top:7px}",
+        ".metric-tile span{font-size:11px;text-transform:uppercase;letter-spacing:.08em;font-weight:650;color:hsl(var(--muted-foreground))}",
+        ".finding-button{width:100%;border:1px solid hsl(var(--border));border-radius:8px;background:hsl(var(--card));padding:12px;text-align:left;display:grid;grid-template-columns:minmax(0,1fr) auto;gap:12px;cursor:pointer;margin-bottom:8px}",
+        ".finding-button:hover,.finding-button.active{background:hsl(var(--accent)/.45);border-color:hsl(var(--ring)/.45)}",
+        ".finding-title{font-size:14px;font-weight:650}.finding-summary{font-size:12px;color:hsl(var(--muted-foreground));margin-top:4px;overflow-wrap:anywhere}",
+        ".severity{display:inline-flex;align-items:center;border-radius:999px;border:1px solid hsl(var(--border));padding:3px 7px;font-size:11px;text-transform:uppercase;letter-spacing:.06em;font-weight:700;background:hsl(var(--background))}",
+        ".severity.critical,.severity.high{color:#dc2626;border-color:rgba(220,38,38,.28);background:rgba(220,38,38,.08)}",
+        ".severity.medium{color:#b45309;border-color:rgba(180,83,9,.28);background:rgba(180,83,9,.08)}",
+        ".severity.low,.severity.info{color:#0369a1;border-color:rgba(3,105,161,.26);background:rgba(3,105,161,.08)}",
+        ".insight-detail{position:sticky;top:82px}.evidence-list{display:grid;gap:7px;margin-top:10px}.evidence-item{border-left:3px solid hsl(var(--border));padding:7px 0 7px 10px;font-size:12px;overflow-wrap:anywhere}",
+        ".context-split{display:grid;grid-template-columns:minmax(0,1.1fr) minmax(300px,.9fr);gap:14px;align-items:start}.category-button{width:100%;display:grid;grid-template-columns:minmax(0,1fr) 74px 54px;gap:10px;border:0;background:transparent;border-radius:6px;padding:8px;text-align:left;cursor:pointer}.category-button:hover{background:hsl(var(--accent)/.4)}",
+        ".inline-bar{height:8px;border-radius:999px;background:hsl(var(--muted));overflow:hidden;margin-top:8px}.inline-bar span{display:block;height:100%}",
+        ".trend-bars{display:grid;gap:8px}.trend-row{display:grid;grid-template-columns:86px minmax(0,1fr) 80px;gap:10px;align-items:center;font-size:12px}.trend-track{height:9px;border-radius:999px;background:hsl(var(--muted));overflow:hidden}.trend-track span{display:block;height:100%;background:#2563eb}",
+        ".timeline-list{display:grid;gap:10px}.timeline-session{border:1px solid hsl(var(--border));border-radius:8px;background:hsl(var(--card));padding:12px}.timeline-top{display:flex;justify-content:space-between;gap:12px;margin-bottom:8px}.turn-strip{display:flex;gap:2px;align-items:end;height:42px}.turn-strip button{flex:1;min-width:3px;border:0;border-radius:3px 3px 0 0;background:#2563eb;cursor:pointer}.turn-strip button:hover{filter:brightness(1.15)}",
+        ".source-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:10px}.source-row{border:1px solid hsl(var(--border));border-radius:8px;background:hsl(var(--card));padding:11px;min-width:0}.source-row strong{display:block;font-size:13px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.source-row p{font-size:12px;color:hsl(var(--muted-foreground));overflow-wrap:anywhere}",
+        ".raw-note{border:1px dashed hsl(var(--border));border-radius:8px;padding:12px;background:hsl(var(--muted)/.2);font-size:12px;color:hsl(var(--muted-foreground))}",
+        "@media(max-width:920px){.health-shell,.context-split{grid-template-columns:1fr}.metric-grid,.source-grid{grid-template-columns:repeat(2,minmax(0,1fr))}.insight-detail{position:static}}",
+        "@media(max-width:620px){.metric-grid,.source-grid{grid-template-columns:1fr}.trend-row{grid-template-columns:74px minmax(0,1fr) 54px}.health-card{align-items:flex-start}.health-dial{width:88px;height:88px}.health-score{font-size:24px}}",
+      ].join("");
+      document.head.appendChild(style);
+    }
+
+    function ensureTab(name, label) {
+      const nav = document.querySelector(".tabs");
+      if (!nav || document.querySelector("[data-tab=\"" + name + "\"]")) return;
+      const button = document.createElement("button");
+      button.className = "tab";
+      button.setAttribute("data-tab", name);
+      button.type = "button";
+      button.textContent = label;
+      nav.appendChild(button);
+    }
+
+    function ensurePanel(name) {
+      if (document.getElementById("panel-" + name)) return;
+      const footer = document.querySelector(".footer");
+      const panel = document.createElement("section");
+      panel.className = "panel";
+      panel.id = "panel-" + name;
+      if (footer && footer.parentNode) footer.parentNode.insertBefore(panel, footer);
+    }
+
+    function activate(name) {
+      Array.prototype.forEach.call(document.querySelectorAll(".tab"), function (tab) {
+        tab.classList.toggle("active", tab.getAttribute("data-tab") === name);
+      });
+      Array.prototype.forEach.call(document.querySelectorAll(".panel"), function (panel) {
+        panel.classList.toggle("active", panel.id === "panel-" + name);
+      });
+      if (location.hash !== "#" + name) history.replaceState(null, "", "#" + name);
+    }
+
+    function wireTabs() {
+      Array.prototype.forEach.call(document.querySelectorAll(".tab"), function (tab) {
+        tab.onclick = function () {
+          activate(tab.getAttribute("data-tab"));
+        };
+      });
+    }
+
+    function metric(label, value, detail) {
+      return "<div class=\"metric-tile\"><span>" + esc(label) + "</span><strong>" + esc(value) + "</strong><p class=\"meta\">" + esc(detail || "") + "</p></div>";
+    }
+
+    function findingButton(finding, index) {
+      return "<button class=\"finding-button\" data-finding=\"" + index + "\"><span><span class=\"finding-title\">" + esc(finding.title) + "</span><span class=\"finding-summary\">" + esc(finding.summary) + "</span></span><span class=\"severity " + esc(finding.severity) + "\">" + esc(finding.severity) + "</span></button>";
+    }
+
+    function renderFindingDetail(index, targetId) {
+      const finding = findings[index] || findings[0];
+      const el = document.getElementById(targetId || "finding-detail");
+      if (!el) return;
+      if (!finding) {
+        el.innerHTML = "<h2>No Findings</h2><p class=\"empty\">No deterministic warning crossed the reporting threshold.</p>";
+        return;
+      }
+      const evidence = (finding.evidence || []).map(function (item) {
+        return "<div class=\"evidence-item\">" + esc(item) + "</div>";
+      }).join("") || "<p class=\"empty\">No evidence sample captured.</p>";
+      el.innerHTML = "<div class=\"section-head\"><div><span class=\"severity " + esc(finding.severity) + "\">" + esc(finding.severity) + "</span><h2 style=\"margin-top:8px\">" + esc(finding.title) + "</h2><p class=\"meta\">" + esc(finding.rule) + " · confidence " + esc(finding.confidence) + " · " + esc(finding.action) + "</p></div><strong>" + esc(finding.score) + "</strong></div><p>" + esc(finding.summary) + "</p><div class=\"mini-label\">Evidence</div><div class=\"evidence-list\">" + evidence + "</div><div class=\"mini-label\">Recommended Move</div><p class=\"raw-note\">" + esc(finding.recommendation || "No recommendation captured.") + "</p>";
+    }
+
+    function categoryRows() {
+      const total = totalCounter(report.categories);
+      return cats.map(function (cat) {
+        const chars = (report.categories || {})[cat] || 0;
+        if (!chars) return "";
+        const percentage = total ? chars / total : 0;
+        return "<button class=\"category-button\" data-category=\"" + esc(cat) + "\"><span><span class=\"badge\"><span class=\"dot\" style=\"background:" + colors[cat] + "\"></span>" + esc(labels[cat]) + "</span><span class=\"inline-bar\"><span style=\"width:" + Math.max(2, percentage * 100).toFixed(1) + "%;background:" + colors[cat] + "\"></span></span></span><span class=\"row-meta\">" + fmt(tok(chars)) + " tok</span><span class=\"row-meta\">" + Math.round(percentage * 100) + "%</span></button>";
+      }).join("");
+    }
+
+    function renderStats() {
+      const stats = document.getElementById("stats");
+      if (!stats) return;
+      stats.innerHTML = metric("Health", (analysis.score || 0) + "/100", analysis.scoreLabel || "unknown") +
+        metric("Findings", findings.length, findings.length ? findings[0].title : "no threshold crossed") +
+        metric("Cache hit", pctText(metrics.cacheHitRatio || 0), "create " + pctText(metrics.cacheCreationPct || 0)) +
+        metric("Tool success", pctText(metrics.successRate == null ? 1 : metrics.successRate), fmt(metrics.normalizedSteps || 0) + " normalized steps");
+    }
+
+    function renderOverview() {
+      const panel = document.getElementById("panel-overview");
+      if (!panel) return;
+      const topFindings = findings.slice(0, 4).map(findingButton).join("") || "<p class=\"empty\">No major issues found. Recent sessions look balanced.</p>";
+      panel.innerHTML = "<div class=\"health-shell\"><section class=\"health-card\"><div class=\"health-dial\" style=\"--score:" + esc(analysis.score || 0) + "\"><span class=\"health-score\">" + esc(analysis.score || 0) + "</span></div><div class=\"health-copy\"><div class=\"eyebrow\">Context Health</div><h2>" + esc(analysis.scoreLabel || "unknown") + "</h2><p>Score combines cache behavior, context pressure, duplicate reads, retry loops, tool failures, and exploration-to-edit ratio.</p></div></section><section class=\"card\" id=\"overview-finding-detail\"></section></div><div class=\"context-split\"><section class=\"card\"><div class=\"section-head\"><div><h2>Top Findings</h2><p class=\"meta\">Click a finding to inspect evidence and the suggested move.</p></div></div>" + topFindings + "</section><section class=\"card\"><div class=\"section-head\"><div><h2>Where Context Is Going</h2><p class=\"meta\">Bucket rows are clickable and stay local to this report.</p></div></div>" + categoryRows() + "</section></div><div class=\"metric-grid\" style=\"margin-top:14px\">" + metric("Exploration ratio", (metrics.explorationRatio || 0) + "x", "read/search to edit/write") + metric("Duplicate reads", metrics.duplicateReadCount || 0, "suppressed after edits") + metric("Retry loops", metrics.retryLoopCount || 0, "3+ identical commands") + metric("MCP calls", metrics.mcpCalls || 0, (report.mcpServers || []).length + " configured") + "</div>";
+      Array.prototype.forEach.call(panel.querySelectorAll("[data-finding]"), function (button) {
+        button.onclick = function () {
+          Array.prototype.forEach.call(panel.querySelectorAll("[data-finding]"), function (item) { item.classList.remove("active"); });
+          button.classList.add("active");
+          renderFindingDetail(Number(button.getAttribute("data-finding")), "overview-finding-detail");
+        };
+      });
+      Array.prototype.forEach.call(panel.querySelectorAll("[data-category]"), function (button) {
+        button.onclick = function () {
+          const category = button.getAttribute("data-category");
+          const sessions = (report.sessions || []).filter(function (session) { return (session.categories || {})[category]; }).slice(0, 4);
+          const detail = document.getElementById("overview-finding-detail");
+          if (!detail) return;
+          detail.innerHTML = "<div class=\"section-head\"><div><h2>" + esc(labels[category] || category) + "</h2><p class=\"meta\">Sessions contributing to this bucket.</p></div></div><div class=\"evidence-list\">" + (sessions.map(function (session) { return "<div class=\"evidence-item\"><strong>" + esc(session.title || session.sessionId) + "</strong><br>" + esc(session.source + " · " + fmt(tok((session.categories || {})[category] || 0)) + " tok · " + (session.cwd || session.path)) + "</div>"; }).join("") || "<p class=\"empty\">No sessions matched.</p>") + "</div>";
+        };
+      });
+      renderFindingDetail(0, "overview-finding-detail");
+      const first = panel.querySelector("[data-finding]");
+      if (first) first.classList.add("active");
+    }
+
+    function renderFindings() {
+      const panel = document.getElementById("panel-findings");
+      if (!panel) return;
+      panel.innerHTML = "<div class=\"grid\"><section class=\"card\"><div class=\"section-head\"><div><h2>Findings</h2><p class=\"meta\">Deterministic checks adapted from AgentSight, Argus, Cogpit, and usage dashboards.</p></div></div>" + (findings.map(findingButton).join("") || "<p class=\"empty\">No findings crossed threshold.</p>") + "</section><aside class=\"card detail insight-detail\" id=\"finding-detail\"></aside></div>";
+      Array.prototype.forEach.call(panel.querySelectorAll("[data-finding]"), function (button) {
+        button.onclick = function () {
+          Array.prototype.forEach.call(panel.querySelectorAll("[data-finding]"), function (item) { item.classList.remove("active"); });
+          button.classList.add("active");
+          renderFindingDetail(Number(button.getAttribute("data-finding")), "finding-detail");
+        };
+      });
+      renderFindingDetail(0, "finding-detail");
+      const first = panel.querySelector("[data-finding]");
+      if (first) first.classList.add("active");
+    }
+
+    function renderTrends() {
+      const panel = document.getElementById("panel-trends");
+      if (!panel) return;
+      const days = (analysis.trends && analysis.trends.byDay || []).slice(-14);
+      const maxTokens = days.reduce(function (max, day) { return Math.max(max, day.tokens || 0); }, 1);
+      const dayRows = days.map(function (day) {
+        return "<div class=\"trend-row\"><span>" + esc(day.day) + "</span><span class=\"trend-track\"><span style=\"width:" + Math.max(2, ((day.tokens || 0) / maxTokens) * 100).toFixed(1) + "%\"></span></span><span class=\"row-meta\">" + fmt(day.tokens || 0) + " tok</span></div>";
+      }).join("") || "<p class=\"empty\">No trend window found.</p>";
+      const toolRows = (analysis.trends && analysis.trends.topTools || []).slice(0, 10).map(function (entry) {
+        return "<tr><td>" + esc(entry[0]) + "</td><td>" + esc(entry[1]) + "</td></tr>";
+      }).join("") || "<tr><td>No tools detected</td><td></td></tr>";
+      const pathRows = (analysis.trends && analysis.trends.topPaths || []).slice(0, 10).map(function (entry) {
+        return "<tr><td>" + esc(entry[0]) + "</td><td>" + esc(entry[1]) + "</td></tr>";
+      }).join("") || "<tr><td>No paths detected</td><td></td></tr>";
+      panel.innerHTML = "<div class=\"grid\"><section class=\"card\"><div class=\"section-head\"><div><h2>Daily Trend</h2><p class=\"meta\">Sessions and observed/estimated token load by day.</p></div></div><div class=\"trend-bars\">" + dayRows + "</div></section><section class=\"card\"><h2>Hotspots</h2><div class=\"grid equal\" style=\"margin-top:10px\"><div><div class=\"mini-label\">Tools</div><table class=\"table\"><tbody>" + toolRows + "</tbody></table></div><div><div class=\"mini-label\">Paths</div><table class=\"table\"><tbody>" + pathRows + "</tbody></table></div></div></section></div>";
+    }
+
+    function turnHeight(turn, max) {
+      const value = Number(turn.totalTokens || turn.inputTokens || 0);
+      return Math.max(4, Math.round((value / Math.max(1, max)) * 40));
+    }
+
+    function renderTimeline() {
+      const panel = document.getElementById("panel-timeline");
+      if (!panel) return;
+      const sessions = (report.sessions || []).slice(0, 30);
+      panel.innerHTML = "<div class=\"timeline-list\">" + (sessions.map(function (session) {
+        const series = session.usage && session.usage.series || [];
+        const maxTurn = series.reduce(function (max, turn) { return Math.max(max, turn.totalTokens || turn.inputTokens || 0); }, 1);
+        const strip = series.length ? series.map(function (turn, index) {
+          const cache = (turn.cacheReadInputTokens || 0) + (turn.cachedInputTokens || 0);
+          const color = turn.cacheCreationInputTokens > turn.inputTokens ? "#b45309" : cache > turn.inputTokens ? "#16a34a" : "#2563eb";
+          return "<button title=\"" + esc((turn.label || "turn " + (index + 1)) + " · " + fmt(turn.totalTokens || 0) + " tokens") + "\" style=\"height:" + turnHeight(turn, maxTurn) + "px;background:" + color + "\"></button>";
+        }).join("") : "<p class=\"empty\">No observed per-turn token series in this session.</p>";
+        const cache = cacheStabilityClient(session);
+        const growth = contextGrowthClient(session);
+        return "<article class=\"timeline-session\"><div class=\"timeline-top\"><div><div class=\"eyebrow\">" + esc(session.source + " · " + (session.updatedAt || "unknown time")) + "</div><h2>" + esc(session.title || session.sessionId) + "</h2><p class=\"meta\">" + esc(session.cwd || session.path) + "</p></div><div style=\"text-align:right\"><strong>" + fmt(session.tokens || 0) + "</strong><p class=\"meta\">" + esc(session.tokenMethod || "") + "</p></div></div><div class=\"turn-strip\">" + strip + "</div><div class=\"badge-list\" style=\"margin-top:10px\"><span class=\"badge\">cache " + esc(cache.classification) + "</span><span class=\"badge\">growth " + esc(growth.growthFactor || 0) + "x</span><span class=\"badge\">steps " + esc(session.totalSteps || 0) + "</span></div></article>";
+      }).join("") || "<section class=\"card\"><p class=\"empty\">No sessions found.</p></section>") + "</div>";
+    }
+
+    function cacheStabilityClient(session) {
+      const match = (analysis.evidence && analysis.evidence.cacheStability || []).filter(function (item) { return item.sessionId === session.sessionId; })[0];
+      return match || { classification: "unknown" };
+    }
+
+    function contextGrowthClient(session) {
+      const match = (analysis.evidence && analysis.evidence.contextGrowth || []).filter(function (item) { return item.sessionId === session.sessionId; })[0];
+      return match || { growthFactor: 0 };
+    }
+
+    function renderSources() {
+      const panel = document.getElementById("panel-sources");
+      if (!panel) return;
+      const rows = (analysis.sourceModel && analysis.sourceModel.sourceProjectSession || []).slice(0, 60).map(function (item) {
+        return "<article class=\"source-row\"><strong>" + esc(item.title || item.sessionId) + "</strong><p>" + esc(item.source + " · " + fmt(item.tokens || 0) + " tok · " + (item.project || "")) + "</p><p>" + esc(item.updatedAt || "") + "</p></article>";
+      }).join("") || "<p class=\"empty\">No source records found.</p>";
+      panel.innerHTML = "<section class=\"card\"><div class=\"section-head\"><div><h2>Source / Project / Session</h2><p class=\"meta\">Metadata-first browser model for local Codex and Claude Code sessions.</p></div></div><p class=\"raw-note\">" + esc(analysis.sourceModel && analysis.sourceModel.privacy || "Transcript content stays local.") + "</p><div class=\"source-grid\" style=\"margin-top:12px\">" + rows + "</div></section>";
+    }
+
+    addStyle();
+    ensureTab("findings", "Findings");
+    ensureTab("timeline", "Timeline");
+    ensureTab("trends", "Trends");
+    ensureTab("sources", "Sources");
+    ensurePanel("findings");
+    ensurePanel("timeline");
+    ensurePanel("trends");
+    ensurePanel("sources");
+    wireTabs();
+    renderStats();
+    renderOverview();
+    renderFindings();
+    renderTimeline();
+    renderTrends();
+    renderSources();
+    const initial = (location.hash || "#overview").slice(1);
+    if (document.getElementById("panel-" + initial)) activate(initial);
+  }.toString() + ")();";
+}
+
+function renderHtml(sessions, args) {
+  const report = buildReport(sessions, args);
+  return "<!doctype html><html><head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width,initial-scale=1\"><title>Context X-Ray</title><style>" +
+    "@import url(\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap\");" +
+    ":root{--background:0 0% 100%;--foreground:220 10% 10%;--card:0 0% 100%;--muted:220 10% 95%;--muted-foreground:220 5% 45%;--accent:220 10% 92%;--border:220 10% 90%;--ring:220 10% 55%;--destructive:0 84% 60%;--radius:.5rem;--shadow:0 1px 2px rgba(16,24,40,.06);}" +
+    "@media(prefers-color-scheme:dark){:root{--background:220 10% 7%;--foreground:220 8% 92%;--card:220 9% 9%;--muted:220 8% 15%;--muted-foreground:220 6% 64%;--accent:220 8% 17%;--border:220 8% 18%;--ring:220 8% 54%;--destructive:0 72% 51%;--shadow:none;}}" +
+    "*{box-sizing:border-box}html{background:hsl(var(--background))}body{margin:0;background:hsl(var(--background));color:hsl(var(--foreground));font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,\"Segoe UI\",sans-serif;font-feature-settings:\"cv02\",\"cv03\",\"cv04\",\"cv11\";line-height:1.45}button{font:inherit;color:inherit}main{max-width:1180px;margin:0 auto;padding:20px 18px 44px}.topbar{border-bottom:1px solid hsl(var(--border));background:hsl(var(--background));position:sticky;top:0;z-index:10}.topbar-inner{max-width:1180px;margin:0 auto;padding:14px 18px;display:flex;align-items:center;justify-content:space-between;gap:16px}.title-row{display:flex;align-items:center;gap:9px}.logo-dot{width:10px;height:10px;border-radius:999px;background:#38bdf8;box-shadow:0 0 0 4px rgba(56,189,248,.12)}h1{font-size:20px;line-height:1.1;margin:0;font-weight:650;letter-spacing:0}h2{font-size:15px;line-height:1.2;margin:0;font-weight:650}h3{font-size:14px;line-height:1.3;margin:0;font-weight:600}p{margin:0}.muted,.eyebrow,.meta,.empty{color:hsl(var(--muted-foreground))}.eyebrow{text-transform:uppercase;letter-spacing:.08em;font-size:11px;font-weight:650}.meta{font-size:12px}.tabs{display:inline-flex;align-items:center;gap:2px;border:1px solid hsl(var(--border));background:hsl(var(--muted)/.35);border-radius:8px;padding:2px}.tab{border:0;background:transparent;border-radius:6px;padding:6px 10px;font-size:12px;line-height:1.1;cursor:pointer}.tab:hover{background:hsl(var(--accent)/.5)}.tab.active{background:hsl(var(--background));box-shadow:var(--shadow)}.stats{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px;margin:18px 0}.card{background:hsl(var(--card));border:1px solid hsl(var(--border));border-radius:8px;padding:14px;box-shadow:var(--shadow)}.stat-value{display:block;font-size:28px;line-height:1.1;font-weight:700;margin-top:6px}.panel{display:none}.panel.active{display:block}.grid{display:grid;grid-template-columns:minmax(0,1.35fr) minmax(280px,.8fr);gap:14px;align-items:start}.grid.equal{grid-template-columns:repeat(2,minmax(0,1fr))}.section-head{display:flex;align-items:flex-start;justify-content:space-between;gap:10px;margin-bottom:12px}.bar{display:flex;overflow:hidden;height:10px;border-radius:999px;background:hsl(var(--muted));margin:10px 0 12px}.bar span{display:block;min-width:2px}.table{width:100%;border-collapse:collapse;font-size:12px}.table th{text-align:left;color:hsl(var(--muted-foreground));font-weight:600;border-bottom:1px solid hsl(var(--border));padding:7px 8px}.table td{border-bottom:1px solid hsl(var(--border));padding:8px;vertical-align:top}.table th:last-child,.table td:last-child{text-align:right}.row-button{width:100%;display:grid;grid-template-columns:minmax(0,1fr) 74px 70px;gap:10px;align-items:center;text-align:left;border:1px solid transparent;background:transparent;border-radius:6px;padding:8px;cursor:pointer}.row-button:hover,.row-button.active{border-color:hsl(var(--border));background:hsl(var(--accent)/.35)}.row-title{font-size:13px;font-weight:600;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.row-meta{font-size:12px;color:hsl(var(--muted-foreground));text-align:right}.badge-list{display:flex;flex-wrap:wrap;gap:6px}.badge{display:inline-flex;align-items:center;gap:5px;border:1px solid hsl(var(--border));border-radius:999px;padding:3px 7px;font-size:11px;background:hsl(var(--background));max-width:100%}.badge .dot{width:7px;height:7px;border-radius:999px;flex:0 0 auto}.tips{margin:0;padding-left:20px}.tips li{margin:0 0 8px}.detail{min-height:228px}.detail-list{display:grid;gap:8px;margin-top:10px}.sample{border:1px solid hsl(var(--border));border-radius:8px;padding:10px;background:hsl(var(--muted)/.22)}.sample-top{display:flex;justify-content:space-between;gap:10px;margin-bottom:5px;font-size:11px;color:hsl(var(--muted-foreground))}.sample p{font-size:12px;color:hsl(var(--foreground));overflow-wrap:anywhere}.session-card{border:1px solid hsl(var(--border));border-radius:8px;background:hsl(var(--card));margin-bottom:10px;overflow:hidden}.session-card summary{list-style:none;display:flex;justify-content:space-between;gap:14px;cursor:pointer;padding:13px 14px}.session-card summary::-webkit-details-marker{display:none}.session-body{border-top:1px solid hsl(var(--border));padding:12px 14px}.session-title{font-size:13px;font-weight:650;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.session-path{font-size:12px;color:hsl(var(--muted-foreground));margin-top:3px;overflow-wrap:anywhere}.token-big{font-size:20px;font-weight:700;white-space:nowrap}.mini-label{margin:10px 0 6px;font-size:11px;text-transform:uppercase;letter-spacing:.08em;font-weight:650;color:hsl(var(--muted-foreground))}.footer{margin-top:20px;color:hsl(var(--muted-foreground));font-size:12px}.hidden{display:none!important}@media(max-width:840px){.topbar-inner{align-items:flex-start;flex-direction:column}.stats,.grid,.grid.equal{grid-template-columns:1fr}.tabs{width:100%;overflow:auto}.tab{white-space:nowrap}.row-button{grid-template-columns:minmax(0,1fr) 64px 58px}.session-card summary{align-items:flex-start;flex-direction:column}}" +
+    "</style></head><body><header class=\"topbar\"><div class=\"topbar-inner\"><div><div class=\"title-row\"><span class=\"logo-dot\"></span><h1>Context X-Ray</h1></div><p class=\"meta\">Generated " + escapeHtml(report.generatedLabel) + " · mode=" + escapeHtml(report.mode) + " · source=" + escapeHtml(report.source) + " · since=" + escapeHtml(report.since) + "</p></div><nav class=\"tabs\" aria-label=\"Report views\"><button class=\"tab active\" data-tab=\"overview\">Overview</button><button class=\"tab\" data-tab=\"tools\">Tool Calls</button><button class=\"tab\" data-tab=\"mcp\">MCP</button><button class=\"tab\" data-tab=\"metadata\">Metadata</button><button class=\"tab\" data-tab=\"sessions\">Sessions</button></nav></div></header><main><section class=\"stats\" id=\"stats\"></section><section class=\"panel active\" id=\"panel-overview\"></section><section class=\"panel\" id=\"panel-tools\"></section><section class=\"panel\" id=\"panel-mcp\"></section><section class=\"panel\" id=\"panel-metadata\"></section><section class=\"panel\" id=\"panel-sessions\"></section><p class=\"footer\">Reads local transcript and MCP config files only. No transcript content is uploaded.</p></main><script type=\"application/json\" id=\"xray-data\">" + jsonScript(report) + "</script><script>" +
+    "(function(){var report=JSON.parse(document.getElementById('xray-data').textContent);var cats=['user','assistant','tool_call','tool_output','reasoning','instructions','attachment','metadata','other'];var labels={user:'User asks',assistant:'Assistant text',tool_call:'Tool calls',tool_output:'Tool output',reasoning:'Reasoning',instructions:'Instructions/context',attachment:'Attachments',metadata:'Metadata',other:'Other'};var colors={user:'#8ba8ff',assistant:'#55b982',tool_call:'#f0a85b',tool_output:'#e06b73',reasoning:'#a77be8',instructions:'#6ac3d5',attachment:'#d6a85a',metadata:'#9aa3ad',other:'#c3c8ce'};function esc(v){return String(v||'').replace(/[&<>\"']/g,function(ch){return {'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',\"'\":'&#39;'}[ch];});}function fmt(n){n=Number(n)||0;if(n>=1000000)return(n/1000000).toFixed(1)+'m';if(n>=1000)return(n/1000).toFixed(1)+'k';return String(n);}function tok(chars){chars=Number(chars)||0;return chars>0?Math.max(1,Math.ceil(chars/4)):0;}function pc(part,total){return total>0?Math.max(0,Math.min(100,(part/total)*100)):0;}function totalCounter(counter){return Object.keys(counter||{}).reduce(function(sum,key){return sum+(Number(counter[key])||0);},0);}function bar(counter){var total=totalCounter(counter);if(!total)return'<div class=\"bar\"></div>';return'<div class=\"bar\">'+cats.map(function(cat){var value=counter[cat]||0;if(!value)return'';return'<span title=\"'+esc(labels[cat])+'\" style=\"width:'+Math.max(1,pc(value,total)).toFixed(2)+'%;background:'+colors[cat]+'\"></span>';}).join('')+'</div>';}function metric(label,value){return'<article class=\"card\"><div class=\"eyebrow\">'+esc(label)+'</div><span class=\"stat-value\">'+esc(value)+'</span></article>';}function tableRows(entries,kind){if(!entries||!entries.length)return'<tr><td>None detected</td><td></td></tr>';return entries.map(function(entry){var value=entry[1];var shown=kind==='chars'?fmt(tok(value)):(kind==='tokens'?fmt(value):String(value));return'<tr><td>'+esc(entry[0])+'</td><td>'+esc(shown)+'</td></tr>';}).join('');}function toolToken(name){var found=(report.toolTokens||[]).filter(function(entry){return entry[0]===name;})[0];return found?found[1]:0;}function renderStats(){var counts=report.sourceCounts||{};document.getElementById('stats').innerHTML=metric('Sessions',report.sessionCount)+metric('Observed/estimated tokens',fmt(report.totalTokens))+metric('Codex',counts.codex||0)+metric('Claude',counts.claude||0);}function renderOverview(){var categoryTotal=totalCounter(report.categories);var categoryRows=cats.map(function(cat){var chars=(report.categories||{})[cat]||0;if(!chars)return'';return'<tr><td><span class=\"badge\"><span class=\"dot\" style=\"background:'+colors[cat]+'\"></span>'+esc(labels[cat])+'</span></td><td>'+fmt(tok(chars))+'</td><td>'+pc(chars,categoryTotal).toFixed(0)+'%</td></tr>';}).join('');document.getElementById('panel-overview').innerHTML='<div class=\"grid\"><section class=\"card\"><div class=\"section-head\"><div><h2>Where The Context Is Going</h2><p class=\"meta\">Approximate contribution by transcript bucket.</p></div></div>'+bar(report.categories)+'<table class=\"table\"><tbody>'+categoryRows+'</tbody></table></section><section class=\"card\"><div class=\"section-head\"><div><h2>Warnings And Optimizations</h2><p class=\"meta\">Promptable changes you control.</p></div></div><ol class=\"tips\">'+(report.recommendations||[]).map(function(tip){return'<li>'+esc(tip)+'</li>';}).join('')+'</ol></section></div><div class=\"grid equal\" style=\"margin-top:14px\"><section class=\"card\"><h2>Top Paths</h2><table class=\"table\"><tbody>'+tableRows(report.paths,'count')+'</tbody></table></section><section class=\"card\"><h2>Metadata Types</h2><table class=\"table\"><tbody>'+tableRows(report.metadata,'chars')+'</tbody></table></section></div>';}function renderTools(){var rows=(report.tools||[]).map(function(entry,index){var name=entry[0];var count=entry[1];return'<button class=\"row-button'+(index===0?' active':'')+'\" data-tool=\"'+esc(name)+'\"><span><span class=\"row-title\">'+esc(name)+'</span><span class=\"meta\">Click to inspect sampled calls</span></span><span class=\"row-meta\">x'+count+'</span><span class=\"row-meta\">'+fmt(toolToken(name))+' tok</span></button>';}).join('')||'<div class=\"empty\">No tool calls detected in these sessions.</div>';document.getElementById('panel-tools').innerHTML='<div class=\"grid\"><section class=\"card\"><div class=\"section-head\"><div><h2>Tool Calls</h2><p class=\"meta\">Calls are clickable; samples are capped so the report stays light.</p></div></div><div>'+rows+'</div></section><aside class=\"card detail\" id=\"tool-detail\"></aside></div>';Array.prototype.forEach.call(document.querySelectorAll('[data-tool]'),function(btn){btn.addEventListener('click',function(){Array.prototype.forEach.call(document.querySelectorAll('[data-tool]'),function(item){item.classList.remove('active');});btn.classList.add('active');renderToolDetail(btn.getAttribute('data-tool'));});});if((report.tools||[]).length)renderToolDetail(report.tools[0][0]);else document.getElementById('tool-detail').innerHTML='<h2>Tool Detail</h2><p class=\"empty\">Nothing to inspect yet.</p>';}function renderToolDetail(name){var events=(report.toolEvents||[]).filter(function(event){return event.tool===name;}).slice(0,30);document.getElementById('tool-detail').innerHTML='<div class=\"section-head\"><div><h2>'+esc(name)+'</h2><p class=\"meta\">'+events.length+' sampled call'+(events.length===1?'':'s')+'</p></div></div><div class=\"detail-list\">'+(events.map(function(event){return'<article class=\"sample\"><div class=\"sample-top\"><span>'+esc(event.source)+' · '+esc(event.sessionTitle||event.sessionId)+'</span><span>'+fmt(event.tokens||0)+' tok</span></div><p>'+esc(event.preview||'No preview captured.')+'</p></article>';}).join('')||'<p class=\"empty\">No sampled call payloads for this tool.</p>')+'</div>';}function renderMcp(){var servers=report.mcpServers||[];var usage=report.mcpUsage||[];var configured=servers.map(function(server){return'<button class=\"row-button\" data-mcp=\"'+esc(server.name)+'\"><span><span class=\"row-title\">'+esc(server.name)+'</span><span class=\"meta\">'+esc(server.source)+' · '+esc(server.target)+'</span></span><span class=\"row-meta\">config</span><span class=\"row-meta\"></span></button>';}).join('')||'<div class=\"empty\">No MCP server config found in the common local config files.</div>';var detected=usage.map(function(entry,index){return'<button class=\"row-button'+(!servers.length&&index===0?' active':'')+'\" data-mcp=\"'+esc(entry[0])+'\"><span><span class=\"row-title\">'+esc(entry[0])+'</span><span class=\"meta\">Detected from mcp__server__tool style names</span></span><span class=\"row-meta\">x'+entry[1]+'</span><span class=\"row-meta\"></span></button>';}).join('')||'<div class=\"empty\">No MCP-prefixed tool calls detected in the selected sessions.</div>';document.getElementById('panel-mcp').innerHTML='<div class=\"grid\"><section class=\"card\"><div class=\"section-head\"><div><h2>MCP Servers</h2><p class=\"meta\">Configured locally plus inferred calls from transcripts.</p></div></div><div class=\"mini-label\">Configured</div>'+configured+'<div class=\"mini-label\">Detected usage</div>'+detected+'</section><aside class=\"card detail\" id=\"mcp-detail\"></aside></div>';Array.prototype.forEach.call(document.querySelectorAll('[data-mcp]'),function(btn){btn.addEventListener('click',function(){Array.prototype.forEach.call(document.querySelectorAll('[data-mcp]'),function(item){item.classList.remove('active');});btn.classList.add('active');renderMcpDetail(btn.getAttribute('data-mcp'));});});if(usage.length)renderMcpDetail(usage[0][0]);else if(servers.length)renderMcpDetail(servers[0].name);else document.getElementById('mcp-detail').innerHTML='<h2>MCP Detail</h2><p class=\"empty\">Install or run sessions with MCP tools to see usage here.</p>';}function renderMcpDetail(name){var server=(report.mcpServers||[]).filter(function(item){return item.name===name;})[0];var tools=(report.mcpTools||[]).filter(function(entry){return entry[0].indexOf(name+' / ')===0;});var events=(report.toolEvents||[]).filter(function(event){return event.mcpServer===name;}).slice(0,25);document.getElementById('mcp-detail').innerHTML='<div class=\"section-head\"><div><h2>'+esc(name)+'</h2><p class=\"meta\">'+(server?esc(server.source+' · '+server.target):'Detected from tool call names')+'</p></div></div><div class=\"mini-label\">Tools</div><table class=\"table\"><tbody>'+tableRows(tools,'count')+'</tbody></table><div class=\"mini-label\">Sample calls</div><div class=\"detail-list\">'+(events.map(function(event){return'<article class=\"sample\"><div class=\"sample-top\"><span>'+esc(event.mcpTool||event.tool)+'</span><span>'+fmt(event.tokens||0)+' tok</span></div><p>'+esc(event.preview||'No preview captured.')+'</p></article>';}).join('')||'<p class=\"empty\">No sampled MCP calls for this server in the selected sessions.</p>')+'</div>';}function renderMetadata(){var rows=(report.metadata||[]).map(function(entry,index){return'<button class=\"row-button'+(index===0?' active':'')+'\" data-meta=\"'+esc(entry[0])+'\"><span><span class=\"row-title\">'+esc(entry[0])+'</span><span class=\"meta\">Click to inspect sampled records</span></span><span class=\"row-meta\">'+fmt(tok(entry[1]))+' tok</span><span class=\"row-meta\">'+fmt(entry[1])+' ch</span></button>';}).join('')||'<div class=\"empty\">No metadata-heavy records detected.</div>';document.getElementById('panel-metadata').innerHTML='<div class=\"grid\"><section class=\"card\"><div class=\"section-head\"><div><h2>Metadata</h2><p class=\"meta\">Breakdown by transcript record type.</p></div></div>'+rows+'</section><aside class=\"card detail\" id=\"metadata-detail\"></aside></div>';Array.prototype.forEach.call(document.querySelectorAll('[data-meta]'),function(btn){btn.addEventListener('click',function(){Array.prototype.forEach.call(document.querySelectorAll('[data-meta]'),function(item){item.classList.remove('active');});btn.classList.add('active');renderMetadataDetail(btn.getAttribute('data-meta'));});});if((report.metadata||[]).length)renderMetadataDetail(report.metadata[0][0]);else document.getElementById('metadata-detail').innerHTML='<h2>Metadata Detail</h2><p class=\"empty\">Nothing to inspect yet.</p>';}function renderMetadataDetail(type){var events=(report.metadataEvents||[]).filter(function(event){return event.type===type;}).slice(0,30);document.getElementById('metadata-detail').innerHTML='<div class=\"section-head\"><div><h2>'+esc(type)+'</h2><p class=\"meta\">'+events.length+' sampled record'+(events.length===1?'':'s')+'</p></div></div><div class=\"detail-list\">'+(events.map(function(event){return'<article class=\"sample\"><div class=\"sample-top\"><span>'+esc(event.source)+' · '+esc(event.sessionTitle||event.sessionId)+'</span><span>'+fmt(event.tokens||0)+' tok</span></div><p>'+esc(event.preview||'No preview captured.')+'</p></article>';}).join('')||'<p class=\"empty\">No sampled records for this metadata type.</p>')+'</div>';}function renderSessions(){document.getElementById('panel-sessions').innerHTML=(report.sessions||[]).map(function(session,index){var catRows=Object.keys(session.categories||{}).sort(function(a,b){return session.categories[b]-session.categories[a];}).map(function(cat){var chars=session.categories[cat];return'<tr><td>'+esc(labels[cat]||cat)+'</td><td>'+fmt(tok(chars))+'</td><td>'+pc(chars,session.totalChars||0).toFixed(0)+'%</td></tr>';}).join('');var tools=(session.tools?Object.keys(session.tools):[]).sort(function(a,b){return session.tools[b]-session.tools[a];}).slice(0,8).map(function(name){return'<span class=\"badge\">'+esc(name)+' x'+session.tools[name]+'</span>';}).join('')||'<span class=\"empty\">none detected</span>';var paths=(session.paths?Object.keys(session.paths):[]).sort(function(a,b){return session.paths[b]-session.paths[a];}).slice(0,8).map(function(name){return'<span class=\"badge\">'+esc(name)+' x'+session.paths[name]+'</span>';}).join('')||'<span class=\"empty\">none detected</span>';return'<details class=\"session-card\"'+(index===0?' open':'')+'><summary><span><span class=\"eyebrow\">'+esc(session.source)+' · '+esc(session.updatedAt||'unknown time')+'</span><span class=\"session-title\">'+esc(session.title||session.sessionId)+'</span><span class=\"session-path\">'+esc(session.cwd||session.path)+'</span></span><span class=\"token-big\">'+fmt(session.tokens)+'</span></summary><div class=\"session-body\">'+bar(session.categories)+'<div class=\"grid equal\"><div><div class=\"mini-label\">Buckets</div><table class=\"table\"><tbody>'+catRows+'</tbody></table></div><div><div class=\"mini-label\">Frequent tools</div><div class=\"badge-list\">'+tools+'</div><div class=\"mini-label\">Repeated paths</div><div class=\"badge-list\">'+paths+'</div></div></div></div></details>';}).join('')||'<section class=\"card\"><p class=\"empty\">No matching sessions found.</p></section>';}function activate(name){Array.prototype.forEach.call(document.querySelectorAll('.tab'),function(tab){tab.classList.toggle('active',tab.getAttribute('data-tab')===name);});Array.prototype.forEach.call(document.querySelectorAll('.panel'),function(panel){panel.classList.toggle('active',panel.id==='panel-'+name);});if(location.hash!=='#'+name)history.replaceState(null,'','#'+name);}Array.prototype.forEach.call(document.querySelectorAll('.tab'),function(tab){tab.addEventListener('click',function(){activate(tab.getAttribute('data-tab'));});});renderStats();renderOverview();renderTools();renderMcp();renderMetadata();renderSessions();var initial=(location.hash||'#overview').slice(1);if(document.getElementById('panel-'+initial))activate(initial);})();" +
+    "</script><script>" + overviewEnhancementScript() + "</script><script>" + insightsEnhancementScript() + "</script></body></html>";
+}
+
+function writeJson(sessions, args, file) {
+  fs.writeFileSync(file, JSON.stringify(buildReport(sessions, args), null, 2));
+}
+
+function openUrl(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    childProcess.spawn(cmd, args, { detached: true, stdio: "ignore" }).unref();
+  } catch {}
+}
+
+function printSummary(sessions, args, file, url) {
+  const total = sessions.reduce((sum, s) => sum + s.tokens, 0);
+  const analysis = analyzeContext(sessions, args, readMcpServers(args.project));
+  const topFinding = analysis.findings && analysis.findings[0];
+  console.log("Context X-Ray: analyzed " + sessions.length + " session(s), about " + fmtTokens(total) + " observed/estimated tokens.");
+  if (url) console.log("Open: " + url);
+  else console.log("Report: " + file);
+  console.log("Health: " + analysis.score + "/100 (" + analysis.scoreLabel + ")" + (topFinding ? " · " + topFinding.title : ""));
+  if (topFinding && topFinding.evidence && topFinding.evidence.length) console.log("Evidence: " + topFinding.evidence[0]);
+  console.log("");
+  for (const tip of recommendations(sessions, analysis).slice(0, 4)) console.log("- " + tip);
+  const tools = sortedEntries(aggregate(sessions).tools, 5);
+  if (tools.length) console.log("- Frequent tools: " + tools.map((entry) => entry[0] + " x" + entry[1]).join(", "));
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) return help();
+  const sessions = collectSessions(args);
+  mkdirp(OUT_DIR);
+  const suffix = args.format === "json" ? "json" : "html";
+  const file = args.out || path.join(OUT_DIR, "context-xray-" + new Date().toISOString().replace(/[:.]/g, "-") + "." + suffix);
+  mkdirp(path.dirname(file));
+  if (args.format === "json") writeJson(sessions, args, file);
+  else fs.writeFileSync(file, renderHtml(sessions, args));
+  const url = args.open && args.format === "html" ? pathToFileURL(file).href : "";
+  if (url) openUrl(url);
+  printSummary(sessions, args, file, url);
+}
+
+main();
+`;
+
+export const CONTEXT_XRAY_SKILL_MD = `---
+name: context-xray
+description: >-
+  Visualize local Codex and Claude Code context usage, open an inline/browser
+  report, flag warnings, and suggest prompt/tooling optimizations. Use when the
+  user types /context-xray, asks where context is going, wants recent local
+  coding-agent trends, or wants to improve context efficiency.
+metadata:
+  visibility: exported
+---
+
+# Context X-Ray
+
+Use the locally installed Context X-Ray command to visualize recent Codex and
+Claude Code context usage. It reads local transcript files only and does not
+upload transcript content.
+
+Project-scoped installs write only project \`.agents\` skill and command
+artifacts; user-scoped installs write global Codex/Claude instructions.
+
+## Run
+
+Current or most recent local thread:
+
+\`\`\`sh
+~/.agent-native/context-xray/context-xray --open
+\`\`\`
+
+Thread picker / recent sessions:
+
+\`\`\`sh
+~/.agent-native/context-xray/context-xray threads --open
+\`\`\`
+
+Weekly trends:
+
+\`\`\`sh
+~/.agent-native/context-xray/context-xray trends --since 7d --open
+\`\`\`
+
+Exact session when the host exposes one:
+
+\`\`\`sh
+~/.agent-native/context-xray/context-xray --session-id "$CLAUDE_CODE_SESSION_ID" --open
+\`\`\`
+
+After running, report the link, the number of sessions analyzed, the largest
+context buckets, and 3-5 specific optimizations.
+\`--open\` opens the generated local HTML file directly and does not keep a
+background report server running.
+
+## Interpret
+
+- Treat the Overview score as a triage signal, then open Findings for evidence.
+- Repeated file reads: ask the agent to keep a short file-role note and reopen
+  only when exact line numbers are needed.
+- Retry loops or failed tool loops: ask the agent to stop after two identical
+  failures, summarize the error, and change strategy before rerunning.
+- Exploration heavy: give an inspection budget, then ask for a short
+  implementation plan before more reading.
+- Cache churn or context growth: move stable instructions into skills or repo
+  docs and continue large work from a compact handoff summary.
+- Tool output heavy: ask the agent to cap command output, summarize failures,
+  and only expand logs when exact lines matter.
+- Metadata heavy: use Metadata/Sources drilldowns for protocol overhead, but
+  prioritize prompt changes around user/tool/output buckets first.
+`;
+
+export const CONTEXT_XRAY_COMMAND_MD = `---
+description: Visualize local Codex/Claude context usage and get optimization tips.
+argument-hint: [current|threads|trends|--since 7d]
+---
+
+Run Context X-Ray locally and show the user the generated report link plus the
+top warnings.
+
+Choose the command from the user's arguments:
+
+- No arguments or \`current\`:
+  \`~/.agent-native/context-xray/context-xray --open\`
+- \`threads\`:
+  \`~/.agent-native/context-xray/context-xray threads --open\`
+- \`trends\`:
+  \`~/.agent-native/context-xray/context-xray trends --since 7d --open\`
+
+If \`$ARGUMENTS\` includes flags such as \`--since 24h\`, \`--last 20\`, or
+\`--all-projects\`, pass them through to the command. If the host exposes
+\`CLAUDE_CODE_SESSION_ID\`, prefer:
+
+\`\`\`sh
+~/.agent-native/context-xray/context-xray --session-id "$CLAUDE_CODE_SESSION_ID" --open
+\`\`\`
+
+\`--open\` opens a local HTML report file directly; there should not be a
+long-running server process to monitor.
+
+After the command finishes, summarize:
+
+- the report link
+- sessions analyzed
+- the health score and most important finding
+- one concrete evidence point
+- two or three promptable ways to improve this thread
+`;
+
+function codexHome(): string {
+  return process.env.CODEX_HOME?.trim() || path.join(os.homedir(), ".codex");
+}
+
+function writeExecutable(file: string, content: string): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content, "utf-8");
+  fs.chmodSync(file, 0o755);
+}
+
+function writeFile(file: string, content: string, written: string[]): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content, "utf-8");
+  written.push(file);
+}
+
+function installProjectArtifacts(baseDir: string, written: string[]): void {
+  writeFile(
+    path.join(baseDir, ".agents", "skills", "context-xray", "SKILL.md"),
+    CONTEXT_XRAY_SKILL_MD,
+    written,
+  );
+  writeFile(
+    path.join(baseDir, ".agents", "commands", "context-xray.md"),
+    CONTEXT_XRAY_COMMAND_MD,
+    written,
+  );
+}
+
+export function installLocalContextXray(
+  options: InstallLocalContextXrayOptions,
+): InstallLocalContextXrayResult {
+  const installDir = path.join(os.homedir(), ".agent-native", "context-xray");
+  const scriptPath = path.join(installDir, "context-xray");
+  const binPath = path.join(os.homedir(), ".local", "bin", "context-xray");
+  const written: string[] = [];
+
+  if (options.dryRun) {
+    return {
+      commands: ["context-xray --open"],
+      scriptPath,
+      written,
+    };
+  }
+
+  writeExecutable(scriptPath, CONTEXT_XRAY_EXECUTABLE);
+  written.push(scriptPath);
+  if (process.platform === "win32") {
+    const cmdPath = `${binPath}.cmd`;
+    writeExecutable(
+      cmdPath,
+      `@echo off\r\nnode ${JSON.stringify(scriptPath)} %*\r\n`,
+    );
+    written.push(cmdPath);
+  } else {
+    writeExecutable(
+      binPath,
+      `#!/usr/bin/env sh\nexec ${JSON.stringify(scriptPath)} "$@"\n`,
+    );
+    written.push(binPath);
+  }
+
+  const clientSet = new Set(options.clients);
+  const wantsCodex = clientSet.has("codex");
+  const wantsClaude =
+    clientSet.has("claude-code") || clientSet.has("claude-code-cli");
+
+  if (options.scope === "project" && options.baseDir) {
+    installProjectArtifacts(options.baseDir, written);
+  } else if (wantsCodex) {
+    writeFile(
+      path.join(codexHome(), "skills", "context-xray", "SKILL.md"),
+      CONTEXT_XRAY_SKILL_MD,
+      written,
+    );
+    writeFile(
+      path.join(codexHome(), "commands", "context-xray.md"),
+      CONTEXT_XRAY_COMMAND_MD,
+      written,
+    );
+  }
+
+  if (options.scope !== "project" && wantsClaude) {
+    writeFile(
+      path.join(os.homedir(), ".claude", "skills", "context-xray", "SKILL.md"),
+      CONTEXT_XRAY_SKILL_MD,
+      written,
+    );
+    writeFile(
+      path.join(os.homedir(), ".claude", "commands", "context-xray.md"),
+      CONTEXT_XRAY_COMMAND_MD,
+      written,
+    );
+  }
+
+  return {
+    commands: ["context-xray --open"],
+    scriptPath,
+    written,
+  };
+}