claude-discover 1.9.0

package/out/main/main.js

@@ -0,0 +1,1542 @@
+import { BrowserWindow, dialog, app, Menu, shell, WebContentsView, ipcMain } from "electron";
+import { EventEmitter } from "node:events";
+import { parseISO, endOfWeek, startOfWeek, endOfMonth, startOfMonth, endOfDay, startOfDay } from "date-fns";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path, { join, dirname, basename } from "node:path";
+import os, { homedir } from "node:os";
+import chokidar from "chokidar";
+import { sync } from "write-file-atomic";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import windowStateKeeper from "electron-window-state";
+import contextMenu from "electron-context-menu";
+import { spawn } from "node:child_process";
+import __cjs_mod__ from "node:module";
+const __filename = import.meta.filename;
+const __dirname = import.meta.dirname;
+const require2 = __cjs_mod__.createRequire(import.meta.url);
+class SessionFile {
+  constructor(filePath) {
+    this.filePath = filePath;
+    const parts = path.dirname(filePath).split(path.sep);
+    this.parentSessionId = parts[parts.indexOf("subagents") - 1] ?? null;
+    const base = path.basename(filePath, ".jsonl");
+    this.sessionId = base === "journal" ? `${parts.at(-1)}-journal` : base;
+  }
+  async stat() {
+    try {
+      return await fsp.stat(this.filePath);
+    } catch {
+      return null;
+    }
+  }
+  // Streams every complete line as parsed JSON; a partially-written trailing line
+  // (no newline yet) is skipped, so reading a live session never sees a half record.
+  async stream(onLine) {
+    let leftover = "";
+    await new Promise((resolve) => {
+      const stream = fs.createReadStream(this.filePath, { encoding: "utf8" });
+      stream.on("data", (chunk) => {
+        leftover += chunk;
+        let idx;
+        while ((idx = leftover.indexOf("\n")) !== -1) {
+          const raw = leftover.slice(0, idx);
+          leftover = leftover.slice(idx + 1);
+          const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+          if (!line) continue;
+          let obj;
+          try {
+            obj = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          onLine(obj);
+        }
+      });
+      stream.on("close", resolve);
+      stream.on("error", resolve);
+    });
+  }
+}
+const HOST = "127.0.0.1";
+const PORT = process.env.CLAUDE_DISCOVER_PORT || 41414;
+const PROXY_URL = `http://${HOST}:${PORT}`;
+process.env.CLAUDE_DISCOVER_UPSTREAM || "https://api.anthropic.com";
+const EXIT_ROUTE = "/claude-discover/exit";
+const PING_ROUTE = "/claude-discover/ping";
+const PING_RESPONSE = "claude-discover-proxy";
+const DATA_DIR$1 = process.env.CLAUDE_DISCOVER_DIR || path.join(os.homedir(), ".claude-discover");
+const REQUESTS_DIR = path.join(DATA_DIR$1, "requests");
+const ERROR_LOG_PATH = path.join(DATA_DIR$1, "proxy.error.log");
+const jsonBytes = (x) => x == null ? 0 : Buffer.byteLength(JSON.stringify(x));
+const MEMORY_LABELS = {
+  "user's private global instructions for all projects": "User",
+  "project instructions, checked into the codebase": "Project",
+  "user's private project instructions, not checked in": "Local",
+  "user's auto-memory, persists across conversations": "Auto"
+};
+const MEMORY_FILES = { User: "CLAUDE.md", Project: "CLAUDE.md", Local: "CLAUDE.local.md", Auto: "MEMORY.md" };
+function parseClaudeMd(text) {
+  const marker = "\n# claudeMd\n";
+  const start = text.indexOf(marker);
+  if (start === -1) return [];
+  let region = text.slice(start + marker.length);
+  const ends = [/\n# [a-z][a-zA-Z0-9]*\r?\n/, /\n\s*IMPORTANT: this context/, /<\/system-reminder>/].map((re) => region.search(re)).filter((i) => i !== -1);
+  if (ends.length) region = region.slice(0, Math.min(...ends));
+  const heads = [...region.matchAll(/^Contents of (.+?) \(([^)]*)\):\r?\n/gm)];
+  return heads.map((h, i) => {
+    const memory_type = MEMORY_LABELS[h[2]] ?? h[2];
+    const base = h[1].split(/[\\/]/).pop();
+    return {
+      file_path: h[1],
+      name: base === MEMORY_FILES[memory_type] ? base : h[1],
+      memory_type,
+      content: region.slice(h.index + h[0].length, heads[i + 1]?.index ?? region.length).trim()
+    };
+  });
+}
+const classifyRequest = (req, url) => {
+  if (url?.includes("/count_tokens")) return ["count", "Token count"];
+  if (!req) return null;
+  const un = (x) => x?.value ?? x;
+  const sys = un(req.system);
+  const sysText = (typeof sys === "string" ? sys : Array.isArray(sys) ? sys.map((b) => un(b)?.text ?? "").join("\n") : "").slice(0, 600);
+  const last = (req.messages || []).map(un).findLast((m) => m?.role === "user");
+  const content = un(last?.content);
+  const blocks = Array.isArray(content) ? content.map(un) : null;
+  const user = (typeof content === "string" ? content : blocks?.find((b) => b?.type === "text")?.text ?? "").trimStart().slice(0, 300);
+  const tail = (blocks?.findLast((b) => b?.type === "text")?.text ?? user).slice(0, 600);
+  if (req.max_tokens === 1 || user.trim() === "quota") return ["quota", "Quota probe"];
+  if (sysText.includes("You are a security monitor") || user.startsWith("<transcript>")) return ["security", "Security check"];
+  if (sysText.includes("Generate a concise, sentence-case title")) return ["title", "Session title"];
+  if (sysText.includes("performing a web search")) return ["web", "Web search"];
+  if (user.startsWith("[SUGGESTION MODE")) return ["suggest", "Suggestions"];
+  if (user.startsWith("Web page content")) return ["web", "Web fetch"];
+  if (user.startsWith("Describe your most recent action")) return ["status", "Status blurb"];
+  if (tail.includes("detailed summary of the conversation")) return ["compact", "Compact"];
+  if (sysText.includes("built on Anthropic's Claude Agent SDK")) return ["agent", "Subagent"];
+  if (!sysText.includes("You are Claude Code")) return null;
+  const continues = !last || blocks?.some((b) => b?.type === "tool_result");
+  return continues ? ["tools", "Tool turn"] : ["main", "User message"];
+};
+const stripKind = (req) => {
+  const kind = classifyRequest(req);
+  return !kind || kind[0] === "main" || kind[0] === "tools" ? ["main", null] : kind;
+};
+class RequestParser {
+  constructor() {
+    this.hashes = /* @__PURE__ */ new Map();
+    this.seenTools = /* @__PURE__ */ new Set();
+  }
+  // Resolves $hash/$ref dedup wrappers at any depth — children first, so stored and returned
+  // values are always fully resolved. Feed records in file order. When `seen` is given, the
+  // dot-path of every resolved (known) $ref is pushed into it — 'system', 'messages.3.content.2', …
+  resolve(v, path2 = "", seen = null) {
+    if (v?.$hash) {
+      const r = this.resolve(v.value, path2, seen);
+      this.hashes.set(v.$hash, r);
+      return r;
+    }
+    if (v?.$ref) {
+      if (!this.hashes.has(v.$ref)) return v;
+      seen?.push(path2);
+      return this.hashes.get(v.$ref);
+    }
+    if (Array.isArray(v)) return v.map((x, i) => this.resolve(x, `${path2}.${i}`, seen));
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, this.resolve(x, `${path2}.${k}`, seen)]));
+    return v;
+  }
+  // Resolves the request's $hash/$ref parts back to full values in place, and annotates the
+  // record with $seen — which parts repeated earlier content — so the UI can fade them:
+  // `messages` flags whole-message repeats, `paths` every repeated node at any depth.
+  resolveRefs(rec) {
+    const wasSeen = (x) => !!x?.$ref && this.hashes.has(x.$ref);
+    const req = rec.request;
+    if (req) {
+      const paths = [];
+      rec.$seen = { messages: (req.messages || []).map(wasSeen), paths };
+      if (req.system != null) req.system = this.resolve(req.system, "system", paths);
+      if (req.tools != null) req.tools = this.resolve(req.tools, "tools", paths);
+      if (req.messages) req.messages = req.messages.map((m, i) => this.resolve(m, `messages.${i}`, paths));
+    }
+    rec.kind = classifyRequest(req, rec.url);
+    rec.reqSize = jsonBytes(req);
+    rec.resSize = jsonBytes(rec.response);
+    return rec;
+  }
+  // The request's system prompt, only when this record logs it in full ({ $hash, value } — repeats
+  // are $refs). `system` is either a plain string or an array of text blocks.
+  systemPrompt(rec) {
+    const sys = rec.request?.system;
+    if (!sys?.$hash) return null;
+    const value = this.resolve(sys.value);
+    const content = typeof value === "string" ? value : value.map((b) => b?.text ?? "").join("\n\n");
+    const [kind, kindLabel] = stripKind(rec.request);
+    return { file_path: "System Prompt", memory_type: kindLabel || "", model: rec.request.model, content, hash: sys.$hash, kind };
+  }
+  // The request's tool definitions, only when this record logs the array in full (repeats are
+  // $refs). The array grows as deferred tools load mid-session, so only tools this parser hasn't
+  // seen yet are returned — the first request yields the full set, later arrays just the additions.
+  systemTools(rec) {
+    const tools = rec.request?.tools;
+    if (!tools?.$hash) return null;
+    const fresh = this.resolve(tools.value).filter((t) => t?.name && !this.seenTools.has(t.name));
+    if (!fresh.length) return null;
+    for (const t of fresh) this.seenTools.add(t.name);
+    const content = fresh.map((t) => `## ${t.name}
+
+${t.description || ""}`.trim()).join("\n\n");
+    const [kind, kindLabel] = stripKind(rec.request);
+    const label = [kindLabel, `${fresh.length} tool${fresh.length === 1 ? "" : "s"}`].filter(Boolean).join(", ");
+    return { file_path: "System Tools", memory_type: label, model: rec.request.model, content, hash: tools.$hash, kind };
+  }
+  // Memory files (CLAUDE.md / MEMORY.md / …) carried by the record's messages inside `# claudeMd`
+  // system-reminders — one { file_path, memory_type, content } per file listed.
+  memoryFiles(rec) {
+    const files = [];
+    for (const m of rec.request?.messages || []) {
+      const content = (m?.value ?? m)?.content;
+      for (const part of Array.isArray(content) ? content : [{ text: content }]) {
+        const text = (part?.value ?? part)?.text;
+        if (typeof text !== "string" || !text.includes("<system-reminder>")) continue;
+        files.push(...parseClaudeMd(text));
+      }
+    }
+    return files;
+  }
+}
+class RequestFile {
+  constructor(sessionId, dir = REQUESTS_DIR) {
+    this.filePath = join(dir, `${sessionId}.requests.jsonl`);
+  }
+  async lines() {
+    const raw = await fsp.readFile(this.filePath, "utf8").catch(() => "");
+    return raw.split("\n").filter(Boolean);
+  }
+  // `range` is { start, end } epoch ms. Refs are resolved over the whole file before the
+  // range filter — an out-of-range record may hold the $hash an in-range record refs —
+  // so callers see every request exactly as it was sent to the API.
+  async read(range = null) {
+    const parser = new RequestParser();
+    const records = [];
+    for (const line of await this.lines()) {
+      let rec;
+      try {
+        rec = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      records.push(parser.resolveRefs(rec));
+    }
+    if (!range) return records;
+    return records.filter((r) => {
+      const t = Date.parse(r.timestamp);
+      return t >= range.start && t <= range.end;
+    });
+  }
+  // System prompts (request.system), tool definitions (request.tools) and memory files
+  // (CLAUDE.md / MEMORY.md / … inside a user message's `# claudeMd` system-reminder) — none of
+  // which Claude Code records in the session transcript, so the request log is the only source.
+  // Returns one record per unique system prompt / tool batch / file_path; readSession ships them
+  // alongside the transcript items.
+  async readInstructions() {
+    const parser = new RequestParser();
+    const files = /* @__PURE__ */ new Map();
+    for (const line of await this.lines()) {
+      const hasSystem = line.includes('"system":{"$hash"');
+      const hasTools = line.includes('"tools":{"$hash"');
+      if (!hasSystem && !hasTools && !line.includes("# claudeMd")) continue;
+      let rec;
+      try {
+        rec = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const record = (f) => ({ timestamp: rec.timestamp, ...f });
+      const sys = hasSystem && parser.systemPrompt(rec);
+      if (sys && !files.has(sys.hash)) files.set(sys.hash, record(sys));
+      const tools = hasTools && parser.systemTools(rec);
+      if (tools) files.set(tools.hash, record(tools));
+      for (const f of parser.memoryFiles(rec)) {
+        if (!files.has(f.file_path)) files.set(f.file_path, record(f));
+      }
+    }
+    return [...files.values()];
+  }
+}
+const ACTIVITY_GAP_MS = 5 * 60 * 1e3;
+const TOKEN_FIELDS = ["input", "output", "cacheRead", "cacheCreation", "cacheCreation5m", "cacheCreation1h"];
+function emptyBucket() {
+  return Object.fromEntries(TOKEN_FIELDS.map((k) => [k, 0]));
+}
+function addUsage(target, delta) {
+  for (const k of TOKEN_FIELDS) target[k] += delta[k];
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((b) => typeof b === "string" ? b : b?.type === "text" ? b.text : "").filter(Boolean).join("\n");
+}
+function shortProject(dir, depth = 2) {
+  if (!dir) return "(no project)";
+  const parts = dir.replace(/\\/g, "/").split("/").filter(Boolean);
+  return parts.slice(-depth).join("/") || dir;
+}
+function suffixLabels(dirs, depth = 2) {
+  const labels = new Map([...new Set(dirs)].map((dir) => [dir, shortProject(dir, depth)]));
+  const counts = /* @__PURE__ */ new Map();
+  for (const label of labels.values()) counts.set(label, (counts.get(label) ?? 0) + 1);
+  for (const [dir, label] of labels) if (counts.get(label) > 1) labels.set(dir, shortProject(dir, depth + 1));
+  return labels;
+}
+function classifySource(meta) {
+  if (meta.hasScheduledTask) return "scheduled";
+  return (meta.entrypoint || "").toLowerCase() || "other";
+}
+function freshMeta({ sessionId, parentSessionId, filePath, fileSize, mtime }) {
+  return {
+    sessionId,
+    parentSessionId,
+    filePath,
+    fileSize,
+    mtime,
+    startedAt: null,
+    lastActivityAt: null,
+    entrypoint: null,
+    project: null,
+    worktree: null,
+    worktreePath: null,
+    gitBranch: null,
+    version: null,
+    model: null,
+    models: [],
+    serviceTier: null,
+    speed: null,
+    fastPricingUnknown: false,
+    priceUnknown: false,
+    summary: null,
+    aiTitle: null,
+    customTitle: null,
+    agentName: null,
+    firstUserPrompt: null,
+    firstUserCommand: null,
+    forkedFrom: null,
+    messageCount: 0,
+    workflowAgents: 0,
+    toolCalls: 0,
+    tokens: emptyBucket(),
+    tokensByModel: {},
+    tokensByModelFast: {},
+    lastContextTokens: 0,
+    serverToolUse: { webSearch: 0, webFetch: 0 },
+    hasScheduledTask: false,
+    activityPeriods: [],
+    costSamples: [],
+    seenMessageIds: /* @__PURE__ */ new Set()
+  };
+}
+class SessionParser {
+  constructor({ sessionId, parentSessionId, filePath, fileSize = 0, mtime = 0, pricing = null, range = null, excludeIds = null }) {
+    this.range = range;
+    this.excludeIds = excludeIds;
+    this.pricing = pricing;
+    this.meta = freshMeta({ sessionId, parentSessionId, filePath, fileSize, mtime });
+    this.prevMessage = null;
+    this.tokenTotal = 0;
+    this.lastSeenTs = null;
+    this.appliedById = /* @__PURE__ */ new Map();
+  }
+  // Returns true if the item passes `this.range`.
+  feed(obj) {
+    const meta = this.meta;
+    const t = obj.type;
+    if (t === "summary" && obj.summary) meta.summary = obj.summary;
+    if (t === "ai-title" && obj.aiTitle) meta.aiTitle = obj.aiTitle;
+    if (t === "custom-title" && obj.customTitle) meta.customTitle = obj.customTitle;
+    if (t === "agent-name" && obj.agentName) meta.agentName = obj.agentName;
+    if (t === "queue-operation" && obj.content?.includes("<scheduled-task")) meta.hasScheduledTask = true;
+    if (t === "started" && obj.key && obj.agentId) meta.workflowAgents += 1;
+    if (obj.cwd && !meta.project) meta.project = obj.cwd;
+    if (obj.gitBranch && !meta.gitBranch) meta.gitBranch = obj.gitBranch;
+    if (obj.entrypoint && !meta.entrypoint) meta.entrypoint = obj.entrypoint;
+    if (obj.version && !meta.version) meta.version = obj.version;
+    const parsed = obj.timestamp && Date.parse(obj.timestamp);
+    const inherited = parsed > 0 ? parsed : this.lastSeenTs;
+    const ts = inherited ?? meta.mtime;
+    if (parsed > 0) this.lastSeenTs = parsed;
+    if (this.range && (ts < this.range.start || ts > this.range.end)) return false;
+    obj._ts = ts;
+    if (inherited != null) {
+      if (meta.startedAt == null || inherited < meta.startedAt) meta.startedAt = inherited;
+      if (inherited > meta.lastActivityAt) meta.lastActivityAt = inherited;
+    }
+    if (t === "attachment") {
+      obj.isMeta = true;
+      this.prevMessage = obj;
+      return true;
+    }
+    if (t !== "user" && t !== "assistant") return true;
+    meta.messageCount += 1;
+    const last = meta.activityPeriods[meta.activityPeriods.length - 1];
+    if (last && ts - last.end <= ACTIVITY_GAP_MS) {
+      if (ts > last.end) last.end = ts;
+    } else {
+      meta.activityPeriods.push({ start: ts, end: ts });
+    }
+    if (t === "user") {
+      this._feedUser(obj);
+    } else if (t === "assistant") {
+      const msg = obj.message;
+      if (!msg || msg.model === "<synthetic>") return true;
+      if (msg.model) {
+        if (!meta.model) meta.model = msg.model;
+        if (!meta.models.includes(msg.model)) meta.models.push(msg.model);
+      }
+      if (Array.isArray(msg.content)) {
+        for (const b of msg.content) if (b?.type === "tool_use") meta.toolCalls += 1;
+      }
+      this._recordUsage(obj);
+    }
+    this.prevMessage = obj;
+    return true;
+  }
+  // Capture the first user prompt / command for the session list.
+  _feedUser(obj) {
+    const meta = this.meta;
+    if (!meta.forkedFrom && obj.forkedFrom?.sessionId) meta.forkedFrom = obj.forkedFrom;
+    const text = extractText(obj.message?.content);
+    if (text.startsWith("<command-name>") || text.startsWith("<command-message>")) {
+      if (!meta.firstUserCommand) meta.firstUserCommand = text;
+      obj.isMeta = true;
+    } else if (text.startsWith("<local-command-stdout>")) {
+      if (meta.firstUserCommand) meta.firstUserCommand += "\n" + text;
+      obj.isMeta = true;
+    } else if (text.startsWith("<local-command-caveat>")) {
+      obj.isMeta = true;
+    } else if (text.startsWith("<scheduled-task")) {
+      meta.hasScheduledTask = true;
+    } else if (text) {
+      if (!meta.firstUserPrompt) meta.firstUserPrompt = text.slice(0, 300);
+    }
+  }
+  // Stamp obj (and the turn that caused it) with per-item running token totals for the UI.
+  // Input tokens attribute to the turn that *caused* the call (user prompt or tool_result) —
+  // the model is billed for reading the preceding turn.
+  _stampRunningTotals(obj, contextSize, output) {
+    const inputTarget = this.prevMessage && this.prevMessage._tokenDelta == null ? this.prevMessage : obj;
+    this.tokenTotal += contextSize;
+    inputTarget._tokenDelta = (inputTarget._tokenDelta || 0) + contextSize;
+    inputTarget._tokenTotal = this.tokenTotal;
+    this.tokenTotal += output;
+    obj._tokenDelta = (obj._tokenDelta || 0) + output;
+    obj._tokenTotal = this.tokenTotal;
+  }
+  // One assistant reply is written as several jsonl lines sharing message.id:
+  // input/cache stay fixed while output_tokens grows toward its final value. We
+  // add each line's *growth* over the previous one (the full usage on the first
+  // line), so the totals land on the final value — what ccusage bills. The
+  // per-item running-total stamps and the stream-stable metadata come only from
+  // the first line; ids in `excludeIds` (already counted in an earlier
+  // resumed-from session) stamp but never aggregate.
+  _recordUsage(obj) {
+    const meta = this.meta;
+    const msg = obj.message;
+    const u = msg?.usage;
+    const msgId = msg?.id;
+    if (!u || !msgId) return;
+    const cc = u.cache_creation || {};
+    const usage = {
+      input: u.input_tokens || 0,
+      output: u.output_tokens || 0,
+      cacheRead: u.cache_read_input_tokens || 0,
+      cacheCreation: u.cache_creation_input_tokens || 0,
+      cacheCreation5m: cc.ephemeral_5m_input_tokens || 0,
+      cacheCreation1h: cc.ephemeral_1h_input_tokens || 0
+    };
+    const model = msg.model || "unknown";
+    const fast = u.speed === "fast";
+    const contextSize = usage.input + usage.cacheRead + usage.cacheCreation;
+    if (!meta.seenMessageIds.has(msgId)) {
+      meta.seenMessageIds.add(msgId);
+      this._stampRunningTotals(obj, contextSize, usage.output);
+    }
+    if (this.excludeIds?.has(msgId)) return;
+    const applied = this.appliedById.get(msgId);
+    if (!applied) {
+      meta.lastContextTokens = contextSize;
+      if (u.service_tier) meta.serviceTier = u.service_tier;
+      if (this.pricing && this.pricing.priceFor(model) == null) meta.priceUnknown = true;
+      if (fast) {
+        meta.speed = "fast";
+        if (this.pricing && this.pricing.fastMultiplier(model) == null) meta.fastPricingUnknown = true;
+      } else if (u.speed && meta.speed !== "fast") {
+        meta.speed = u.speed;
+      }
+      if (u.server_tool_use) {
+        meta.serverToolUse.webSearch += u.server_tool_use.web_search_requests || 0;
+        meta.serverToolUse.webFetch += u.server_tool_use.web_fetch_requests || 0;
+      }
+    }
+    const growth = emptyBucket();
+    let changed = false;
+    for (const k of TOKEN_FIELDS) {
+      growth[k] = Math.max(0, usage[k] - (applied?.[k] ?? 0));
+      if (growth[k] !== 0) changed = true;
+    }
+    if (applied) addUsage(applied, growth);
+    else this.appliedById.set(msgId, usage);
+    if (!changed) return;
+    const byModel = fast ? meta.tokensByModelFast : meta.tokensByModel;
+    addUsage(meta.tokens, growth);
+    addUsage(byModel[model] ??= emptyBucket(), growth);
+    const cost = this.pricing && obj._ts != null ? this.pricing.costForDelta(model, growth, { fast }) : null;
+    if (cost > 0) {
+      const prevTs = this.prevMessage?._ts;
+      meta.costSamples.push({ start: prevTs != null && prevTs < obj._ts ? prevTs : obj._ts, end: obj._ts, cost });
+    }
+  }
+  finalize(mtimeFallback) {
+    const meta = this.meta;
+    if (meta.startedAt == null) meta.startedAt = mtimeFallback;
+    if (meta.lastActivityAt == null) meta.lastActivityAt = mtimeFallback;
+    meta.source = classifySource(meta);
+    const wt = meta.project && meta.project.replace(/\\/g, "/").match(/\/\.claude\/worktrees\/([^/]+)/);
+    if (wt) {
+      meta.worktree = wt[1];
+      meta.worktreePath = meta.project.slice(0, wt.index + wt[0].length);
+      meta.project = meta.project.slice(0, wt.index);
+    }
+    meta.projectShort = shortProject(meta.project);
+    meta.activeMs = meta.activityPeriods.reduce((sum, p) => sum + Math.max(0, p.end - p.start), 0);
+    const t = meta.tokens;
+    meta.totalTokens = t.input + t.output + t.cacheRead + t.cacheCreation;
+    const cacheDenom = t.cacheRead + t.cacheCreation;
+    meta.cacheHitRatio = cacheDenom > 0 ? t.cacheRead / cacheDenom : null;
+    const costOf = (opts) => !this.pricing ? 0 : (this.pricing.costUSD(meta.tokensByModel, opts) || 0) + (this.pricing.costUSD(meta.tokensByModelFast, { ...opts, fast: true }) || 0);
+    meta.cost = costOf({});
+    meta.savings = { using5mCache: meta.cost - costOf({ ignoreCache1hPremium: true }) };
+    return meta;
+  }
+}
+class ConfigFile {
+  dataDir = join(homedir(), ".claude-discover");
+  configFile = join(this.dataDir, "config.json");
+  read() {
+    try {
+      return JSON.parse(fs.readFileSync(this.configFile, "utf8"));
+    } catch (err) {
+      if (err.code !== "ENOENT") console.warn(`Ignoring unreadable ${this.configFile}: ${err.message}`);
+      return {};
+    }
+  }
+  save(data) {
+    fs.mkdirSync(this.dataDir, { recursive: true });
+    sync(this.configFile, JSON.stringify({ ...this.read(), ...data }, null, 2));
+  }
+}
+const config = new ConfigFile();
+const local = config.read();
+const DATA_DIR = config.dataDir;
+const CLAUDE_DIR = local.claudeDir || process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+const RECENT_CLAUDE_DIRS = local.recents || [CLAUDE_DIR];
+const CLAUDE_PROJECTS_DIR = join(CLAUDE_DIR, "projects");
+const CLAUDE_SETTINGS = join(CLAUDE_DIR, "settings.json");
+const IS_EPHEMERAL = import.meta.dirname.split(/[\\/]/).includes("_npx");
+const STATUSLINE_PATH = join(import.meta.dirname, "../../bin/claude/statusline.mjs");
+const PROXY_PATH = join(import.meta.dirname, "../../bin/proxy.mjs");
+const CLAUDE_HOOKS_PATH = join(import.meta.dirname, "../../bin/claude/hooks.mjs");
+class StatCache {
+  constructor() {
+    this.stats = /* @__PURE__ */ new Map();
+    this.complete = false;
+  }
+  record(filePath, stat) {
+    if (stat) this.stats.set(filePath, stat);
+  }
+  remove(filePath) {
+    this.stats.delete(filePath);
+  }
+  markComplete() {
+    this.complete = true;
+  }
+  clear() {
+    this.stats.clear();
+    this.complete = false;
+  }
+  // In-memory disk walk: one batch over the cached stats, same callbacks as SessionsScanner.scan.
+  async scan(inPeriod, { onFile, onBatchDone, onProgress, signal } = {}) {
+    const tasks = [];
+    for (const [filePath, stat] of this.stats) {
+      if (signal?.aborted) return;
+      if (inPeriod(stat)) tasks.push(onFile?.(filePath, stat));
+    }
+    await Promise.all(tasks);
+    if (signal?.aborted) return;
+    await onBatchDone?.();
+    onProgress?.({ done: 1, total: 1, scanning: false });
+  }
+}
+const isJsonl = (p) => p.endsWith(".jsonl");
+class SessionsScanner {
+  constructor({ root = CLAUDE_PROJECTS_DIR } = {}) {
+    this.root = root;
+    this.watcher = null;
+    this.statCache = new StatCache();
+  }
+  async _listDirs(p) {
+    const entries = await fsp.readdir(p, { withFileTypes: true }).catch(() => []);
+    return entries.filter((e) => e.isDirectory()).map((e) => path.join(e.parentPath, e.name));
+  }
+  // Every .jsonl under `dir`, at any depth — subagent transcripts live arbitrarily deep
+  // (e.g. <session>/subagents/workflows/<wf>/agent-*.jsonl). The walk can't prune subtrees
+  // by directory mtime, because on Windows appending to an existing transcript does NOT
+  // bump its parent dir's mtime.
+  async _listJsonl(dir) {
+    const entries = await fsp.readdir(dir, { recursive: true, withFileTypes: true }).catch(() => []);
+    return entries.filter((e) => e.isFile() && isJsonl(e.name)).map((e) => path.join(e.parentPath, e.name));
+  }
+  // Append-only transcripts span [birthtime, mtime], so files outside the period are skipped
+  // Note birthtime is trusted only when well older than mtime, since copies/restores (git checkout, scp, zip) get a fresh birthtime over old content.
+  _inPeriod(stat, day) {
+    if (stat.mtimeMs < day.start) return false;
+    return !(stat.birthtimeMs > day.end && stat.birthtimeMs + 2e3 <= stat.mtimeMs);
+  }
+  // Walks each project subtree in full. For each .jsonl whose stat passes _inPeriod
+  // (file mtime IS updated on append, unlike dir mtime), calls onFile(filePath, stat).
+  // After each project's files are processed, calls onBatchDone() if any onFile returned
+  // truthy — lets callers flush UI updates incrementally. An aborted `signal` (a superseded
+  // scan) stops the walk: no further stats, onFile calls or emits. Once a walk has completed
+  // with the watcher live, the StatCache mirrors the disk and serves later scans in memory.
+  async scan(day, { onFile, onBatchDone, onProgress, signal } = {}) {
+    if (this.statCache.complete && this.watcher) return this.statCache.scan((stat) => this._inPeriod(stat, day), { onFile, onBatchDone, onProgress, signal });
+    const projects = await this._listDirs(this.root);
+    let done = 0;
+    const progress = () => onProgress?.({ done, total: projects.length, scanning: done < projects.length });
+    progress();
+    await Promise.all(projects.map(async (projDir) => {
+      if (signal?.aborted) return;
+      const results = await Promise.all((await this._listJsonl(projDir)).map(async (fp) => {
+        const stat = signal?.aborted ? null : await fsp.stat(fp).catch(() => null);
+        this.statCache.record(fp, stat);
+        return stat && this._inPeriod(stat, day) && !signal?.aborted ? onFile?.(fp, stat) : null;
+      }));
+      if (signal?.aborted) return;
+      if (onBatchDone && results.some(Boolean)) await onBatchDone();
+      done++;
+      progress();
+    }));
+    if (signal?.aborted) return;
+    if (this.watcher) this.statCache.markComplete();
+    if (onBatchDone) await onBatchDone();
+    progress();
+  }
+  watch({ onChange, onUnlink } = {}) {
+    const isUNC = this.root.startsWith("\\\\") || this.root.startsWith("//");
+    this.watcher = chokidar.watch(this.root, {
+      ignoreInitial: true,
+      alwaysStat: true,
+      awaitWriteFinish: { stabilityThreshold: 400, pollInterval: 100 },
+      ignored: (p, stats) => !!stats?.isFile() && !isJsonl(p),
+      ...isUNC && { usePolling: true, interval: 1e3 }
+    });
+    const changed = (p, stat) => {
+      if (!isJsonl(p)) return;
+      this.statCache.record(p, stat);
+      onChange?.(p, stat);
+    };
+    const removed = (p) => {
+      if (!isJsonl(p)) return;
+      this.statCache.remove(p);
+      onUnlink?.(p);
+    };
+    this.watcher.on("add", changed);
+    this.watcher.on("change", changed);
+    this.watcher.on("unlink", removed);
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+      this.statCache.clear();
+    }
+  }
+}
+class MetaCache {
+  constructor() {
+    this.periodKey = null;
+    this.files = /* @__PURE__ */ new Map();
+    this.periodMetas = /* @__PURE__ */ new Map();
+  }
+  // New period → drop the period layer; re-entering the same period keeps it.
+  setPeriod(key) {
+    if (this.periodKey === key) return;
+    this.periodKey = key;
+    this.periodMetas.clear();
+  }
+  get(filePath) {
+    return this.periodMetas.get(filePath);
+  }
+  byId(sessionId) {
+    return [...this.periodMetas.values()].find((m) => m.sessionId === sessionId);
+  }
+  values() {
+    return this.periodMetas.values();
+  }
+  // Meta for one file within `day` ({ start, end, key }), or null when it has no activity there.
+  // `parse(range)` runs only on cache misses (range = null → whole file) and for files straddling a period edge.
+  async resolve(filePath, stat, day, parse) {
+    let e = this.files.get(filePath);
+    if (!e || e.size !== stat.size || e.mtimeMs !== stat.mtimeMs) {
+      e = { size: stat.size, mtimeMs: stat.mtimeMs, meta: await parse(null) };
+      this.files.set(filePath, e);
+    }
+    let m = e.meta;
+    if (m && (m.lastActivityAt < day.start || m.startedAt > day.end)) m = null;
+    else if (m && !(m.startedAt >= day.start && m.lastActivityAt <= day.end)) m = await parse(day);
+    if (day.key !== this.periodKey) return m;
+    if (!m) {
+      this.periodMetas.delete(filePath);
+      return null;
+    }
+    this.periodMetas.set(filePath, m);
+    return m;
+  }
+  // Drop both layers, e.g. when a pricing change invalidates every meta.
+  clear() {
+    this.files.clear();
+    this.periodMetas.clear();
+  }
+  // Forget a deleted file. True if the period layer shrank.
+  evict(filePath) {
+    this.files.delete(filePath);
+    return this.periodMetas.delete(filePath);
+  }
+}
+const seed = {
+  "claude-fable-5": { "input": 10, "output": 50, "cacheRead": 1, "cacheWrite": 12.5, "cacheWrite1h": 20 },
+  "claude-sonnet-5": { "input": 2, "output": 10, "cacheRead": 0.2, "cacheWrite": 2.5, "cacheWrite1h": 4 },
+  "claude-opus-4-8": { "input": 5, "output": 25, "cacheRead": 0.5, "cacheWrite": 6.25, "cacheWrite1h": 10, "fastModeMplr": 2 },
+  "claude-opus-4-7": { "input": 5, "output": 25, "cacheRead": 0.5, "cacheWrite": 6.25, "cacheWrite1h": 10, "fastModeMplr": 6 },
+  "claude-opus-4-6": { "input": 5, "output": 25, "cacheRead": 0.5, "cacheWrite": 6.25, "cacheWrite1h": 10, "fastModeMplr": 6 },
+  "claude-opus-4-5": { "input": 5, "output": 25, "cacheRead": 0.5, "cacheWrite": 6.25, "cacheWrite1h": 10 },
+  "claude-opus-4-1": { "input": 15, "output": 75, "cacheRead": 1.5, "cacheWrite": 18.75, "cacheWrite1h": 30 },
+  "claude-opus-4": { "input": 15, "output": 75, "cacheRead": 1.5, "cacheWrite": 18.75, "cacheWrite1h": 30 },
+  "claude-4-opus": { "input": 15, "output": 75, "cacheRead": 1.5, "cacheWrite": 18.75 },
+  "claude-sonnet-4-6": { "input": 3, "output": 15, "cacheRead": 0.3, "cacheWrite": 3.75, "cacheWrite1h": 6 },
+  "claude-sonnet-4-5": { "input": 3, "output": 15, "cacheRead": 0.3, "cacheWrite": 3.75, "cacheWrite1h": 6 },
+  "claude-sonnet-4": { "input": 3, "output": 15, "cacheRead": 0.3, "cacheWrite": 3.75, "cacheWrite1h": 6 },
+  "claude-4-sonnet": { "input": 3, "output": 15, "cacheRead": 0.3, "cacheWrite": 3.75 },
+  "claude-haiku-4-5": { "input": 1, "output": 5, "cacheRead": 0.1, "cacheWrite": 1.25, "cacheWrite1h": 2 },
+  "claude-3-7-sonnet": { "input": 3, "output": 15, "cacheRead": 0.3, "cacheWrite": 3.75, "cacheWrite1h": 6 },
+  "claude-3-5-sonnet": { "input": 3, "output": 15, "cacheRead": 0.3, "cacheWrite": 3.75 },
+  "claude-3-5-haiku": { "input": 0.8, "output": 4, "cacheRead": 0.08, "cacheWrite": 1 },
+  "claude-3-opus": { "input": 15, "output": 75, "cacheRead": 1.5, "cacheWrite": 18.75, "cacheWrite1h": 6 },
+  "claude-3-sonnet": { "input": 3, "output": 15, "cacheRead": 0.3, "cacheWrite": 3.75 },
+  "claude-3-haiku": { "input": 0.25, "output": 1.25, "cacheRead": 0.03, "cacheWrite": 0.3, "cacheWrite1h": 6 }
+};
+const CURRENT_PATH = path.join(DATA_DIR, "prices.current.json");
+const LITELLM_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+const DAY_MS = 24 * 3600 * 1e3;
+const MILLION = 1e6;
+class Pricing extends EventEmitter {
+  #prices = {};
+  #keys = [];
+  // longest first, so 'claude-opus-4-7' wins over 'claude-opus-4'
+  constructor() {
+    super();
+    this.load();
+    this.refreshFromLiteLLM().catch((err) => console.warn("[pricing] refresh failed:", err.message));
+  }
+  get prices() {
+    return this.#prices;
+  }
+  set prices(rates) {
+    this.#prices = {};
+    for (const [key, p] of Object.entries(rates))
+      if ([p.input, p.output, p.cacheRead, p.cacheWrite].every((r) => r > 0)) this.#prices[key] = p;
+    this.#keys = Object.keys(this.#prices).sort((a, b) => b.length - a.length);
+  }
+  load() {
+    this.prices = fs.existsSync(CURRENT_PATH) ? JSON.parse(fs.readFileSync(CURRENT_PATH, "utf8")) : seed;
+  }
+  priceFor(model) {
+    if (!model) return null;
+    const m = model.toLowerCase();
+    const key = this.#keys.find((k) => m.startsWith(k) && !/^\w/.test(m.slice(k.length)));
+    return key ? this.#prices[key] : null;
+  }
+  // Fast mode (usage.speed === "fast") bills at a flat per-model multiple of
+  // standard rates, applied uniformly across every token category. Sourced from
+  // LiteLLM's provider_specific_entry.fast. null when unknown for the model.
+  fastMultiplier(model) {
+    return this.priceFor(model)?.fastModeMplr ?? null;
+  }
+  costForDelta(model, bucket, { ignoreCache1hPremium = false, fast = false } = {}) {
+    const p = this.priceFor(model);
+    if (!p || !bucket) return null;
+    const tokens5m = ignoreCache1hPremium ? 0 : bucket.cacheCreation5m || 0;
+    const tokens1h = ignoreCache1hPremium ? 0 : bucket.cacheCreation1h || 0;
+    const tokensUnknown = (bucket.cacheCreation || 0) - tokens5m - tokens1h;
+    const base = ((bucket.input || 0) * p.input + (bucket.output || 0) * p.output + (bucket.cacheRead || 0) * p.cacheRead + tokens5m * p.cacheWrite + tokens1h * (p.cacheWrite1h ?? p.cacheWrite) + // 1h premium unknown → bill at the base write rate, not $0
+    tokensUnknown * p.cacheWrite) / MILLION;
+    return fast ? base * (this.fastMultiplier(model) ?? 1) : base;
+  }
+  costUSD(tokensByModel, opts = {}) {
+    if (!tokensByModel) return null;
+    let total = 0;
+    let priced = false;
+    for (const [model, bucket] of Object.entries(tokensByModel)) {
+      const c = this.costForDelta(model, bucket, opts);
+      if (c == null) continue;
+      total += c;
+      priced = true;
+    }
+    return priced ? total : null;
+  }
+  async refreshFromLiteLLM(verbose = true) {
+    if (fs.existsSync(CURRENT_PATH) && Date.now() - fs.statSync(CURRENT_PATH).mtimeMs < DAY_MS) return;
+    if (verbose) console.info("[pricing] refreshing prices from LiteLLM:", LITELLM_URL);
+    const res = await fetch(LITELLM_URL, { signal: AbortSignal.timeout(1e4) });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const litellm = await res.json();
+    const collect = (prefix) => {
+      const id = (k) => k.slice(prefix.length).replace(/[-@]\d{8}(-v\d+(:\d+)?)?$|-v\d+(:\d+)?$/, "");
+      const out2 = {};
+      Object.entries(litellm).filter(([key]) => key.startsWith(prefix)).forEach(([key, v]) => Object.assign(out2[id(key)] ??= {}, v));
+      return out2;
+    };
+    const claude = collect("claude-");
+    const anthropic = collect("anthropic.claude-");
+    const models = /* @__PURE__ */ new Set([...Object.keys(anthropic), ...Object.keys(claude)]);
+    const out = {};
+    for (const name of models) {
+      const m = Object.assign({}, anthropic[name], claude[name]);
+      const per = (c) => Number.isFinite(c) ? Number((c * MILLION).toPrecision(12)) : void 0;
+      out["claude-" + name] = {
+        input: per(m.input_cost_per_token),
+        output: per(m.output_cost_per_token),
+        cacheRead: per(m.cache_read_input_token_cost),
+        cacheWrite: per(m.cache_creation_input_token_cost),
+        cacheWrite1h: per(m.cache_creation_input_token_cost_above_1hr)
+      };
+      const fast = m.provider_specific_entry?.fast;
+      if (typeof fast === "number") out["claude-" + name].fastModeMplr = fast;
+    }
+    if (Object.keys(out).length) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+      fs.writeFileSync(CURRENT_PATH, JSON.stringify(out, null, 2) + "\n");
+      const before = JSON.stringify(this.#prices);
+      this.load();
+      if (verbose) console.info(`[pricing] updated ${Object.keys(out).length} model prices`);
+      if (JSON.stringify(this.#prices) !== before) this.emit("update");
+    }
+  }
+}
+const WEEK = { weekStartsOn: 1 };
+function periodBounds(date, granularity = "day", tz = void 0) {
+  const opts = { in: tz };
+  const d = parseISO(date, opts);
+  if (granularity === "week") return { start: +startOfWeek(d, { ...WEEK, ...opts }), end: +endOfWeek(d, { ...WEEK, ...opts }) };
+  if (granularity === "month") return { start: +startOfMonth(d, opts), end: +endOfMonth(d, opts) };
+  return { start: +startOfDay(d, opts), end: +endOfDay(d, opts) };
+}
+function intersectsDay(meta, day) {
+  return meta.lastActivityAt >= day.start && meta.startedAt <= day.end;
+}
+function stripInternal({ seenMessageIds, ...meta }) {
+  return meta;
+}
+class SessionsService extends EventEmitter {
+  constructor({ root, throttleMs = 100, scanner = null } = {}) {
+    super();
+    this.scanner = scanner ?? new SessionsScanner(root ? { root } : {});
+    this.pricing = new Pricing();
+    this.throttleMs = throttleMs;
+    this.metaCache = new MetaCache();
+    this.activeDay = null;
+    this.scanAbort = null;
+    this.updateTimer = null;
+    this.lastUpdateAt = 0;
+  }
+  // Always parses the whole file from 0: the parser's running token totals only stamp
+  // correctly from a fresh start, so live updates re-read rather than resume at an offset.
+  async readSession(sessionId, date = null, granularity = "day") {
+    const meta = this.metaCache.byId(sessionId);
+    if (!meta) return null;
+    const range = date ? periodBounds(date, granularity) : null;
+    const reader = new SessionFile(meta.filePath);
+    const parser = new SessionParser({ sessionId: reader.sessionId, parentSessionId: reader.parentSessionId, filePath: reader.filePath, mtime: meta.mtime, range });
+    const items = [];
+    await reader.stream((obj) => {
+      if (parser.feed(obj)) items.push(obj);
+    });
+    items.sort((a, b) => a._ts - b._ts);
+    for (const o of items) delete o._ts;
+    const instructions = await new RequestFile(reader.sessionId).readInstructions();
+    return { items, instructions };
+  }
+  // Captured API requests for a session (see bin/proxy.mjs), period-filtered like readSession.
+  async readRequests(sessionId, date = null, granularity = "day") {
+    if (!/^[\w-]+$/.test(sessionId)) return [];
+    const range = date ? periodBounds(date, granularity) : null;
+    return new RequestFile(sessionId).read(range);
+  }
+  // Scan `period` ({ start, end } epoch ms, optional `key`/`date`; see periodBounds). watch:true (UI) streams 'update' events per dir batch and returns the current cache immediately; watch:false (CLIs/tests) awaits completion and returns the deduped sessions with no emits.
+  async scan(period, { watch = false } = {}) {
+    const day = period.key ? period : { ...period, key: `${period.start}|${period.end}` };
+    this.metaCache.setPeriod(day.key);
+    this.activeDay = day;
+    this.scanAbort?.abort();
+    this.scanAbort = new AbortController();
+    const fresh = () => this.activeDay?.key === day.key;
+    const scan = this.scanner.scan(day, {
+      onFile: (filePath, stat) => this._processFile(filePath, day, stat),
+      signal: this.scanAbort.signal,
+      ...watch && {
+        onBatchDone: () => {
+          if (fresh()) this._scheduleUpdate();
+        },
+        onProgress: (p) => {
+          if (fresh()) this.emit("progress", p);
+        }
+      }
+    });
+    if (watch) scan.catch(console.error);
+    else await scan;
+    return this._dedupedDay(day);
+  }
+  // IPC/UI entry: build the period from date+granularity and watch it.
+  list(date, granularity = "day") {
+    const key = `${granularity}|${date}`;
+    return this.scan({ ...periodBounds(date, granularity), date, key }, { watch: true });
+  }
+  start() {
+    this.pricing.on("update", () => this._reprice());
+    this.scanner.watch({
+      onChange: (p, stat) => this._refresh(p, stat),
+      onUnlink: (p) => this._evict(p)
+    });
+    return this;
+  }
+  stop() {
+    this.pricing.removeAllListeners("update");
+    this.scanner.stop();
+    this.scanAbort?.abort();
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+      this.updateTimer = null;
+    }
+  }
+  // Stat the file, stream every line through a fresh SessionParser, and finalize.
+  // `excludeIds` skips message ids already counted in an earlier session.
+  async _scanSession(reader, { range = null, excludeIds = null, stat = null } = {}) {
+    if (!stat) stat = await reader.stat();
+    if (!stat) return null;
+    const parser = new SessionParser({
+      sessionId: reader.sessionId,
+      parentSessionId: reader.parentSessionId,
+      filePath: reader.filePath,
+      fileSize: stat.size,
+      mtime: stat.mtimeMs,
+      range,
+      excludeIds,
+      pricing: this.pricing
+    });
+    await reader.stream((obj) => parser.feed(obj));
+    return parser.finalize(stat.mtimeMs);
+  }
+  // Resume/fork copies prior message.ids verbatim. Walk earliest-first; if a
+  // session's ids overlap one already counted, rescan it with the overlap
+  // excluded so it contributes only its NEW messages.
+  async _dedupSessions(metas, range) {
+    const sorted = [...metas].sort((a, b) => a.startedAt - b.startedAt);
+    const globalSeen = /* @__PURE__ */ new Set();
+    const rescans = /* @__PURE__ */ new Map();
+    for (const m of sorted) {
+      let overlap = null;
+      for (const id of m.seenMessageIds || []) {
+        if (globalSeen.has(id)) (overlap ||= /* @__PURE__ */ new Set()).add(id);
+        globalSeen.add(id);
+      }
+      if (overlap) rescans.set(m.sessionId, this._scanSession(new SessionFile(m.filePath), { range, excludeIds: overlap }));
+    }
+    const sessions = await Promise.all(metas.map(async (m) => {
+      const rescanned = await rescans.get(m.sessionId);
+      return stripInternal(rescanned ? { ...m, ...rescanned } : m);
+    }));
+    const labels = suffixLabels(sessions.map((m) => m.project));
+    for (const m of sessions) m.projectShort = labels.get(m.project);
+    return sessions;
+  }
+  _dedupedDay(day) {
+    const metas = [...this.metaCache.values()].filter((m) => intersectsDay(m, day)).sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+    return this._dedupSessions(metas, day);
+  }
+  _processFile(filePath, day, stat) {
+    const parse = (range) => this._scanSession(new SessionFile(filePath), { range, stat });
+    return this.metaCache.resolve(filePath, stat, day, parse);
+  }
+  async _refresh(filePath, stat) {
+    const day = this.activeDay;
+    if (!day || !stat) return;
+    const cached = this.metaCache.get(filePath);
+    const isChanged = !cached || cached.fileSize !== stat.size || cached.mtime !== stat.mtimeMs;
+    if (!isChanged) return;
+    const meta = await this._processFile(filePath, day, stat);
+    if (meta && intersectsDay(meta, day)) this._scheduleUpdate();
+  }
+  _evict(filePath) {
+    if (this.metaCache.evict(filePath)) this._scheduleUpdate();
+  }
+  // Prices changed after metas were parsed (first launch races the LiteLLM refresh) — reparse with the new rates.
+  _reprice() {
+    if (!this.activeDay) return;
+    this.metaCache.clear();
+    this.scan(this.activeDay, { watch: true }).catch(console.error);
+  }
+  // Leading+trailing throttle: the first call emits immediately, calls within throttleMs
+  // coalesce into one trailing emit — so scans paint fast but bursts cost one update.
+  _scheduleUpdate() {
+    if (this.updateTimer) return;
+    const emit = async () => {
+      this.updateTimer = null;
+      this.lastUpdateAt = Date.now();
+      const day = this.activeDay;
+      try {
+        if (day) this.emit("update", await this._dedupedDay(day));
+      } catch (err) {
+        console.error("sessions update emit failed:", err);
+      }
+    };
+    const wait = this.lastUpdateAt + this.throttleMs - Date.now();
+    if (wait <= 0) emit();
+    else this.updateTimer = setTimeout(emit, wait);
+  }
+}
+const DEFAULT = { work_hours: { start: "09:00", end: "17:00" } };
+class WorkHours {
+  read() {
+    const { work_hours } = config.read();
+    return work_hours ? { work_hours } : DEFAULT;
+  }
+  write(data) {
+    config.save({ work_hours: data.work_hours });
+    return data;
+  }
+}
+class AgentRunner {
+  async run(text, sender, systemTools = false, cache = false) {
+    const send = (chunk) => {
+      if (!sender.isDestroyed()) sender.send("agent:output", chunk);
+    };
+    const response = query({
+      prompt: text,
+      options: {
+        includePartialMessages: true,
+        env: cache ? { ...process.env, FORCE_PROMPT_CACHING_5M: "1" } : { ...process.env, DISABLE_PROMPT_CACHING: "1" },
+        tools: systemTools ? void 0 : [],
+        settingSources: systemTools ? void 0 : []
+      }
+    });
+    for await (const message of response) {
+      if (message.type === "stream_event") {
+        const delta = message.event.delta;
+        if (delta?.type === "text_delta" && delta.text) send(delta.text);
+      } else if (message.type === "result") {
+        return { code: message.is_error ? 1 : 0 };
+      }
+    }
+    return { code: 0 };
+  }
+}
+const IS_DEV = !!process.env.ELECTRON_RENDERER_URL;
+class ClaudeDirSwitch {
+  status() {
+    return { dir: CLAUDE_DIR };
+  }
+  // "Change directory" — browse for a new dir; selecting one restarts the app on it.
+  activate() {
+    return browseForClaudeDir(BrowserWindow.getFocusedWindow());
+  }
+  deactivate() {
+    throw new Error("Nothing to deactivate");
+  }
+}
+async function browseForClaudeDir(win) {
+  const r = await dialog.showOpenDialog(win, {
+    title: "Select Claude directory",
+    defaultPath: CLAUDE_DIR,
+    properties: ["openDirectory"]
+  });
+  if (!r.canceled) {
+    switchToClaudeDir(r.filePaths[0]);
+  }
+}
+function switchToClaudeDir(claudeDir) {
+  if (!claudeDir || claudeDir === CLAUDE_DIR) return;
+  config.save({ claudeDir, recents: [.../* @__PURE__ */ new Set([...RECENT_CLAUDE_DIRS, claudeDir])] });
+  if (IS_DEV) {
+    dialog.showMessageBoxSync({ type: "info", message: "Restart required", detail: "Stop and re-run `npm run dev` to apply the new directory." });
+    app.quit();
+  } else {
+    app.relaunch();
+    BrowserWindow.getAllWindows().forEach((w) => w.close());
+    app.exit(0);
+  }
+}
+function buildAppMenu({ onFind, onEscape } = {}) {
+  return Menu.buildFromTemplate([
+    ...process.platform === "darwin" ? [{ role: "appMenu" }] : [],
+    // @macOS
+    {
+      label: "File",
+      submenu: [
+        { label: "Change directory…", click: (_i, win) => browseForClaudeDir(win) },
+        { type: "separator" },
+        ...RECENT_CLAUDE_DIRS.map((p) => ({
+          label: p,
+          type: "checkbox",
+          checked: p === CLAUDE_DIR,
+          click: () => switchToClaudeDir(p)
+        })),
+        { type: "separator" },
+        { role: "quit" }
+      ]
+    },
+    {
+      // @macOS Cmd+C/V/A have no key equivalents without an Edit menu; Windows/Linux get these from Chromium
+      label: "Edit",
+      submenu: [
+        { role: "copy" },
+        { role: "paste" },
+        { role: "selectAll" },
+        { label: "Find…", accelerator: "CmdOrCtrl+F", click: () => onFind?.() },
+        { label: "Deselect", accelerator: "Escape", click: (_i, win) => onEscape?.(win) }
+      ]
+    },
+    {
+      label: "View",
+      submenu: [
+        { role: "reload" },
+        { role: "forceReload" },
+        { role: "toggleDevTools" }
+      ]
+    }
+  ]);
+}
+const VIEWABLE_EXT = /* @__PURE__ */ new Set([".md", ".txt", ".json", ".jsonl", ".log", ".csv", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".pdf"]);
+async function openLinkSafely(href, baseFile) {
+  if (/^(https?:|mailto:)/i.test(href)) return shell.openExternal(href);
+  if (!baseFile) return;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(href);
+  } catch {
+    return;
+  }
+  const baseDir = path.dirname(path.resolve(baseFile));
+  const abs = path.resolve(baseDir, decoded);
+  const rel = path.relative(baseDir, abs);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) return;
+  if (!VIEWABLE_EXT.has(path.extname(abs).toLowerCase())) return shell.showItemInFolder(abs);
+  const err = await shell.openPath(abs);
+  if (err) shell.showItemInFolder(abs);
+  return err;
+}
+const DEV_ORIGIN = process.env.ELECTRON_RENDERER_URL && new URL(process.env.ELECTRON_RENDERER_URL).origin;
+const APP_PAGES = pathToFileURL(path.join(import.meta.dirname, "../renderer/")).href;
+function lockNavigation(contents) {
+  const toBrowser = (url) => /^(https?|mailto):/i.test(url) && shell.openExternal(url);
+  const block = (e, url) => {
+    const { href, origin } = new URL(url);
+    if (href.startsWith(APP_PAGES) || origin === DEV_ORIGIN) return;
+    e.preventDefault();
+    toBrowser(url);
+  };
+  contents.setWindowOpenHandler(({ url }) => {
+    toBrowser(url);
+    return { action: "deny" };
+  });
+  contents.on("will-navigate", block);
+  contents.on("will-redirect", block);
+}
+const __dirname$2 = path.dirname(fileURLToPath(import.meta.url));
+const DEV_URL$1 = process.env.ELECTRON_RENDERER_URL;
+const WIDTH = 320, HEIGHT = 56, MARGIN = 6;
+class FindBar {
+  constructor(win) {
+    this.win = win;
+    this.view = new WebContentsView({
+      webPreferences: {
+        preload: path.join(__dirname$2, "../preload/findPreload.cjs"),
+        contextIsolation: true,
+        nodeIntegration: false,
+        sandbox: true
+      }
+    });
+    this.view.setBackgroundColor("#00000000");
+    lockNavigation(this.view.webContents);
+    win.contentView.addChildView(this.view);
+    this.view.setVisible(false);
+    if (DEV_URL$1) this.view.webContents.loadURL(`${DEV_URL$1}/find/find.html`);
+    else this.view.webContents.loadFile(path.join(__dirname$2, "../renderer/find/find.html"));
+    win.webContents.on("found-in-page", (_e, r) => {
+      return this.view.webContents.send("find:result", { active: r.activeMatchOrdinal, total: r.matches, id: r.requestId });
+    });
+    win.on("resize", () => {
+      if (this.visible) this.layout();
+    });
+  }
+  get visible() {
+    return this.view.getVisible();
+  }
+  layout() {
+    const [w] = this.win.getContentSize();
+    this.view.setBounds({ x: Math.max(0, w - WIDTH - MARGIN), y: MARGIN, width: WIDTH, height: HEIGHT });
+  }
+  query(text, options) {
+    this.win.webContents.findInPage(text, options);
+  }
+  stop() {
+    this.win.webContents.stopFindInPage("clearSelection");
+  }
+  show() {
+    this.layout();
+    this.view.setVisible(true);
+    this.view.webContents.focus();
+    this.view.webContents.send("find:open");
+    this.win.webContents.send("find:active", true);
+  }
+  hide() {
+    if (!this.visible) return;
+    this.view.setVisible(false);
+    this.stop();
+    this.win.webContents.focus();
+    this.win.webContents.send("find:active", false);
+  }
+}
+const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+const DEV_URL = process.env.ELECTRON_RENDERER_URL;
+class MainWindow {
+  constructor() {
+    this.win = null;
+  }
+  create() {
+    Menu.setApplicationMenu(buildAppMenu({
+      onFind: () => this.findBar?.show(),
+      onEscape: (win) => this.findBar?.visible ? this.findBar.hide() : win?.webContents.unselect()
+    }));
+    const state = windowStateKeeper({ defaultWidth: 1500, defaultHeight: 900 });
+    this.win = new BrowserWindow({
+      x: state.x,
+      y: state.y,
+      width: state.width,
+      height: state.height,
+      backgroundColor: "#0b0d12",
+      autoHideMenuBar: true,
+      title: `Claude Discover v${app.getVersion()}`,
+      webPreferences: {
+        preload: path.join(__dirname$1, "../preload/preload.cjs"),
+        contextIsolation: true,
+        nodeIntegration: false,
+        sandbox: true
+      }
+    });
+    state.manage(this.win);
+    this.win.on("page-title-updated", (e) => e.preventDefault());
+    lockNavigation(this.win.webContents);
+    contextMenu({ window: this.win, showSelectAll: true, showCopyImage: true, showCopyLink: true, showInspectElement: true });
+    if (DEV_URL) {
+      this.win.loadURL(DEV_URL);
+    } else {
+      this.win.loadFile(path.join(__dirname$1, "../renderer/index.html"));
+    }
+    this.findBar = new FindBar(this.win);
+    return this.win;
+  }
+  send(channel, payload) {
+    if (this.win && !this.win.isDestroyed()) this.win.webContents.send(channel, payload);
+  }
+}
+const mtimeOf = (path2) => fs.statSync(path2, { throwIfNoEntry: false })?.mtimeMs;
+class ClaudeSettings {
+  constructor() {
+    this.cfg = {};
+    this.mtime = mtimeOf(CLAUDE_SETTINGS);
+    if (this.mtime !== void 0) {
+      try {
+        this.cfg = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS, "utf8"));
+      } catch (err) {
+        console.warn(`Failed to read ${CLAUDE_SETTINGS}: ${err.message}`);
+        this.loadFailed = true;
+      }
+    }
+  }
+  hooks(eventName) {
+    return (this.cfg.hooks?.[eventName] ?? []).flatMap((g) => g.hooks ?? []);
+  }
+  // The hook entry on this event whose command mentions `needle` (basename, so stale absolute paths still match), or undefined.
+  findHook(eventName, needle) {
+    return this.hooks(eventName).find((h) => h.command?.includes(needle));
+  }
+  // Removes every hook on this event whose command mentions `needle` (basename, so stale
+  // absolute paths still match); groups left empty are dropped. Returns the removed commands.
+  removeHook(eventName, needle) {
+    const matches = (h) => h.command?.includes(needle);
+    const groups = this.cfg.hooks?.[eventName] ?? [];
+    const removed = groups.flatMap((g) => (g.hooks ?? []).filter(matches).map((h) => h.command));
+    if (removed.length) {
+      for (const g of groups) g.hooks = (g.hooks ?? []).filter((h) => !matches(h));
+      this.cfg.hooks[eventName] = groups.filter((g) => g.hooks.length);
+    }
+    return removed;
+  }
+  // Days Claude Code keeps transcripts before auto-deleting them; undefined when unset (its default is 30).
+  get cleanupPeriodDays() {
+    return this.cfg.cleanupPeriodDays;
+  }
+  set cleanupPeriodDays(days) {
+    if (days === void 0) delete this.cfg.cleanupPeriodDays;
+    else this.cfg.cleanupPeriodDays = days;
+  }
+  // Claude Code's status line config: { type: 'command', command }; undefined when unset.
+  get statusLine() {
+    return this.cfg.statusLine;
+  }
+  set statusLine(value) {
+    if (value === void 0) delete this.cfg.statusLine;
+    else this.cfg.statusLine = value;
+  }
+  // Environment variables Claude Code applies to every session; undefined when unset.
+  get env() {
+    return this.cfg.env;
+  }
+  setEnv(name, value) {
+    this.cfg.env ??= {};
+    this.cfg.env[name] = value;
+  }
+  deleteEnv(name) {
+    delete this.cfg.env?.[name];
+  }
+  addHook(eventName, command) {
+    this.cfg.hooks ??= {};
+    this.cfg.hooks[eventName] ??= [];
+    this.cfg.hooks[eventName].push({ hooks: [{ type: "command", command }] });
+  }
+  save() {
+    if (this.loadFailed) throw new Error(`Refusing to save ${CLAUDE_SETTINGS}: settings did not load cleanly`);
+    if (mtimeOf(CLAUDE_SETTINGS) !== this.mtime) throw new Error(`Refusing to save ${CLAUDE_SETTINGS}: file changed on disk since load`);
+    fs.mkdirSync(dirname(CLAUDE_SETTINGS), { recursive: true });
+    sync(CLAUDE_SETTINGS, JSON.stringify(this.cfg, null, 2));
+  }
+}
+const HOOK_BASENAME = "hooks.mjs";
+const HOOK_COMMAND = `node "${CLAUDE_HOOKS_PATH}"`;
+class ProxySwitch {
+  async status() {
+    return {
+      running: await this.#running(),
+      configured: new ClaudeSettings().env?.ANTHROPIC_BASE_URL === PROXY_URL
+    };
+  }
+  // Spawn the proxy detached (it outlives the app) and point Claude Code at it only once it's
+  // confirmed listening — a failed start never changes settings.json. The proxy verifies the
+  // upstream itself before listening (exit code 2 when unreachable), so a successful start
+  // proves end-to-end connectivity. Failures throw; Switchers maps them to { error }.
+  async activate() {
+    const settings = new ClaudeSettings();
+    const baseUrl = settings.env?.ANTHROPIC_BASE_URL;
+    if (baseUrl && baseUrl !== PROXY_URL)
+      throw new Error(`Leaving your existing env.ANTHROPIC_BASE_URL in place (${baseUrl}) — remove it from settings.json to enable capture.`);
+    const child = spawn(process.execPath, [PROXY_PATH, "--restart"], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" }
+    });
+    const exited = new Promise((resolve) => child.once("exit", resolve));
+    child.unref();
+    const outcome = await Promise.race([exited, this.#settle(true).then((ok) => ok ? "up" : "unresponsive")]);
+    if (outcome !== "up")
+      throw new Error(outcome === 2 ? "Cannot reach api.anthropic.com — not enabling capture. Check your network and try again." : `Proxy did not start — see ${ERROR_LOG_PATH}`);
+    const hook = settings.findHook("SessionStart", HOOK_BASENAME);
+    if (!baseUrl || settings.env?.ENABLE_TOOL_SEARCH !== "true" || hook?.command !== HOOK_COMMAND) {
+      settings.setEnv("ANTHROPIC_BASE_URL", PROXY_URL);
+      settings.setEnv("ENABLE_TOOL_SEARCH", "true");
+      if (hook?.command !== HOOK_COMMAND) {
+        settings.removeHook("SessionStart", HOOK_BASENAME);
+        settings.addHook("SessionStart", HOOK_COMMAND);
+      }
+      settings.save();
+    }
+  }
+  // Exit the proxy via its control route and remove the env keys + revive hook — env keys only
+  // when the base URL is ours, so a foreign gateway config is never touched.
+  async deactivate() {
+    try {
+      await fetch(`${PROXY_URL}${EXIT_ROUTE}`, { method: "POST", signal: AbortSignal.timeout(1e3) });
+    } catch {
+    }
+    const settings = new ClaudeSettings();
+    const ours = settings.env?.ANTHROPIC_BASE_URL === PROXY_URL;
+    const removedHook = settings.removeHook("SessionStart", HOOK_BASENAME).length > 0;
+    if (ours) {
+      settings.deleteEnv("ANTHROPIC_BASE_URL");
+      settings.deleteEnv("ENABLE_TOOL_SEARCH");
+    }
+    if (ours || removedHook) settings.save();
+    await this.#settle(false);
+  }
+  async #running() {
+    try {
+      const res = await fetch(`${PROXY_URL}${PING_ROUTE}`, { signal: AbortSignal.timeout(1e3) });
+      return res.ok && await res.text() === PING_RESPONSE;
+    } catch {
+      return false;
+    }
+  }
+  // Poll (≤8s — the proxy's startup upstream check can take 5s) until ping matches `target`
+  async #settle(target) {
+    for (let i = 0; i < 40; i++) {
+      if (await this.#running() === target) return true;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    return false;
+  }
+}
+const STATUS_FILE = basename(STATUSLINE_PATH);
+const STATUS_CMD = `node "${STATUSLINE_PATH}"`;
+class StatuslineSwitch {
+  status() {
+    return { installed: new ClaudeSettings().statusLine?.command?.includes(STATUS_FILE) ?? false };
+  }
+  // Install our status line, repairing a stale absolute path in place (matched by basename).
+  // A different already-configured status line is never overwritten — that throws instead.
+  activate() {
+    const settings = new ClaudeSettings();
+    const command = settings.statusLine?.command;
+    if (command && !command.includes(STATUS_FILE))
+      throw new Error(`Leaving your existing status line in place (${command}) — remove it from settings.json to use ours.`);
+    if (command !== STATUS_CMD) {
+      settings.statusLine = { type: "command", command: STATUS_CMD };
+      settings.save();
+    }
+  }
+  // Remove the statusLine entry — only when it's ours, so a foreign status line is never touched.
+  deactivate() {
+    const settings = new ClaudeSettings();
+    if (settings.statusLine?.command?.includes(STATUS_FILE)) {
+      settings.statusLine = void 0;
+      settings.save();
+    }
+  }
+}
+const DEFAULT_DAYS = 30;
+const RETAIN_DAYS = 365;
+class RetentionSwitch {
+  status() {
+    const days = new ClaudeSettings().cleanupPeriodDays ?? DEFAULT_DAYS;
+    return { days, raised: days >= RETAIN_DAYS };
+  }
+  // Raise retention to RETAIN_DAYS; an already-higher value is left as is.
+  activate() {
+    const settings = new ClaudeSettings();
+    if ((settings.cleanupPeriodDays ?? DEFAULT_DAYS) < RETAIN_DAYS) {
+      settings.cleanupPeriodDays = RETAIN_DAYS;
+      settings.save();
+    }
+  }
+  // Remove the setting — back to Claude Code's default.
+  deactivate() {
+    const settings = new ClaudeSettings();
+    if (settings.cleanupPeriodDays !== void 0) {
+      settings.cleanupPeriodDays = void 0;
+      settings.save();
+    }
+  }
+}
+class Switchers {
+  #switches = {
+    proxy: new ProxySwitch(),
+    statusline: new StatuslineSwitch(),
+    retention: new RetentionSwitch(),
+    claudedir: new ClaudeDirSwitch()
+  };
+  #keepActive = { proxy: true, statusline: true };
+  // toggle feature persisting on app quit — starts on, so a switch this run didn't activate is never undone by it
+  async status(name) {
+    const s = await this.#get(name).status();
+    return name in this.#keepActive ? { ...s, keepActive: this.#keepActive[name], ephemeral: IS_EPHEMERAL } : s;
+  }
+  activate(name) {
+    return this.#attempt(name, async (s) => {
+      await s.activate();
+      this.#keepActive[name] &&= !IS_EPHEMERAL;
+    });
+  }
+  // an npx-cache run undoes what it activated
+  deactivate(name) {
+    return this.#attempt(name, (s) => s.deactivate());
+  }
+  setKeepActive(name, value) {
+    return this.#attempt(name, () => this.#keepActive[name] = !!value);
+  }
+  // Deactivate every switch not marked keep-active
+  async deactivateOnQuit() {
+    for (const name in this.#keepActive) {
+      if (!this.#keepActive[name]) await this.deactivate(name);
+    }
+  }
+  // Resolved outside #attempt's try — an unknown name is a bug, thrown raw to IPC, not a toggle error
+  #get(name) {
+    if (!this.#switches[name]) throw new Error(`Unknown switch: ${name}`);
+    return this.#switches[name];
+  }
+  async #attempt(name, fn) {
+    const sw = this.#get(name);
+    try {
+      await fn(sw);
+      return this.status(name);
+    } catch (err) {
+      return { ...await this.status(name), error: String(err?.message || err) };
+    }
+  }
+}
+app.whenReady().then(() => {
+  const win = new MainWindow();
+  const agentRunner = new AgentRunner();
+  const workHours = new WorkHours();
+  const sessionsService = new SessionsService();
+  sessionsService.on("update", (sessions) => win.send("sessions:update", sessions));
+  sessionsService.on("progress", (p) => win.send("sessions:scan-progress", p));
+  sessionsService.start();
+  win.create();
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) win.create();
+  });
+  ipcMain.handle("sessions:list", (_e, date, granularity) => sessionsService.list(date, granularity));
+  ipcMain.handle("sessions:read", (_e, sessionId, date, granularity) => sessionsService.readSession(sessionId, date, granularity));
+  ipcMain.handle("sessions:read-requests", (_e, sessionId, date, granularity) => sessionsService.readRequests(sessionId, date, granularity));
+  ipcMain.handle("work-hours:get", () => workHours.read());
+  ipcMain.handle("work-hours:set", (_e, data) => workHours.write(data));
+  ipcMain.handle("agent:run", (e, text, systemTools, cache) => agentRunner.run(text, e.sender, systemTools, cache));
+  ipcMain.handle("shell:open-link", (_e, href, baseFile) => openLinkSafely(href, baseFile));
+  ipcMain.on("find:query", (_e, text, options) => win.findBar?.query(text, options));
+  ipcMain.on("find:stop", () => win.findBar?.stop());
+  ipcMain.on("find:close", () => win.findBar?.hide());
+  ipcMain.on("claude-settings:get", (e) => e.returnValue = { claudeDir: CLAUDE_DIR });
+  const switchers = new Switchers();
+  app.on("will-quit", async (e) => {
+    e.preventDefault();
+    await switchers.deactivateOnQuit();
+    app.exit();
+  });
+  ipcMain.handle("switch:status", (_e, name) => switchers.status(name));
+  ipcMain.handle("switch:activate", (_e, name) => switchers.activate(name));
+  ipcMain.handle("switch:deactivate", (_e, name) => switchers.deactivate(name));
+  ipcMain.handle("switch:keep-active", (_e, name, value) => switchers.setKeepActive(name, value));
+});
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") app.quit();
+});