claude-discover 1.9.0 → 1.9.1

package/README.md

@@ -3,7 +3,7 @@
 
 Ever wondered what Claude Code is **actually** doing all day?
 
-<img width="1660" height="1256" alt="claude-discover-dimmed-screenshot" src="https://github.com/user-attachments/assets/708d05c7-8769-47d8-b5bd-14337d1d6037" />
+<img width="1660" alt="claude-discover-dimmed-screenshot" src="https://github.com/user-attachments/assets/708d05c7-8769-47d8-b5bd-14337d1d6037" />
 <br><br>
 
 **Claude Discover** is a desktop tool that shows you what **Claude Code** is actually doing. It collects all your sessions (from the CLI, Desktop, or SDK) and puts them on one timeline, where you can read every conversation, peek at the system prompts, memories, and tools, inspect the raw API traffic behind it all, and see exactly where your tokens - and your money - went. (Spoiler: mostly on re-sending tool definitions.)

package/bin/proxy.mjs

@@ -9,6 +9,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import http from 'node:http'
+import { spawn } from 'node:child_process'
 import https from 'node:https'
 import zlib from 'node:zlib'
 import crypto from 'node:crypto'
@@ -227,7 +228,19 @@ function logError(err, context) {
 }
 
 const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href
-if (isMain) {
+if (process.parentPort) {
+  // Forked as an Electron utility process (ProxySwitch): Chromium gives those a clean handle
+  // table, unlike the app's main process whose children inherit the dev CDP server's socket on
+  // Windows and keep its port bound after the app quits. Utility processes die with the app,
+  // so re-spawn detached from here (as node — no system `node` required) and relay an early
+  // exit code back as a message until the app kills this relay.
+  const child = spawn(process.execPath, process.argv.slice(1), {
+    detached: true, stdio: 'ignore', windowsHide: true,
+    env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
+  })
+  child.once('exit', code => { process.parentPort.postMessage(code); process.exit(0) })
+}
+else if (isMain) {
   const args = parseArgs({
     options: {
       restart: { type: 'boolean' }, // replace an already-running instance instead of exiting

package/out/main/main.js

@@ -1,21 +1,248 @@
-import { BrowserWindow, dialog, app, Menu, shell, WebContentsView, ipcMain } from "electron";
+import { BrowserWindow, dialog, app, Menu, shell, WebContentsView, utilityProcess, 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 crypto from "node:crypto";
 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);
+const millisecondsInMinute = 6e4;
+const millisecondsInHour = 36e5;
+const constructFromSymbol = /* @__PURE__ */ Symbol.for("constructDateFrom");
+function constructFrom(date, value) {
+  if (typeof date === "function") return date(value);
+  if (date && typeof date === "object" && constructFromSymbol in date)
+    return date[constructFromSymbol](value);
+  if (date instanceof Date) return new date.constructor(value);
+  return new Date(value);
+}
+function toDate(argument, context) {
+  return constructFrom(context || argument, argument);
+}
+let defaultOptions = {};
+function getDefaultOptions() {
+  return defaultOptions;
+}
+function startOfWeek(date, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
+  const _date = toDate(date, options?.in);
+  const day = _date.getDay();
+  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  _date.setDate(_date.getDate() - diff);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+function startOfDay(date, options) {
+  const _date = toDate(date, options?.in);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+function endOfDay(date, options) {
+  const _date = toDate(date, options?.in);
+  _date.setHours(23, 59, 59, 999);
+  return _date;
+}
+function endOfMonth(date, options) {
+  const _date = toDate(date, options?.in);
+  const month = _date.getMonth();
+  _date.setFullYear(_date.getFullYear(), month + 1, 0);
+  _date.setHours(23, 59, 59, 999);
+  return _date;
+}
+function startOfMonth(date, options) {
+  const _date = toDate(date, options?.in);
+  _date.setDate(1);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+function endOfWeek(date, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
+  const _date = toDate(date, options?.in);
+  const day = _date.getDay();
+  const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
+  _date.setDate(_date.getDate() + diff);
+  _date.setHours(23, 59, 59, 999);
+  return _date;
+}
+function parseISO(argument, options) {
+  const invalidDate = () => constructFrom(options?.in, NaN);
+  const additionalDigits = options?.additionalDigits ?? 2;
+  const dateStrings = splitDateString(argument);
+  let date;
+  if (dateStrings.date) {
+    const parseYearResult = parseYear(dateStrings.date, additionalDigits);
+    date = parseDate(parseYearResult.restDateString, parseYearResult.year);
+  }
+  if (!date || isNaN(+date)) return invalidDate();
+  const timestamp = +date;
+  let time = 0;
+  let offset;
+  if (dateStrings.time) {
+    time = parseTime(dateStrings.time);
+    if (isNaN(time)) return invalidDate();
+  }
+  if (dateStrings.timezone) {
+    offset = parseTimezone(dateStrings.timezone);
+    if (isNaN(offset)) return invalidDate();
+  } else {
+    const tmpDate = new Date(timestamp + time);
+    const result = toDate(0, options?.in);
+    result.setFullYear(
+      tmpDate.getUTCFullYear(),
+      tmpDate.getUTCMonth(),
+      tmpDate.getUTCDate()
+    );
+    result.setHours(
+      tmpDate.getUTCHours(),
+      tmpDate.getUTCMinutes(),
+      tmpDate.getUTCSeconds(),
+      tmpDate.getUTCMilliseconds()
+    );
+    return result;
+  }
+  return toDate(timestamp + time + offset, options?.in);
+}
+const patterns = {
+  dateTimeDelimiter: /[T ]/,
+  timeZoneDelimiter: /[Z ]/i,
+  timezone: /([Z+-].*)$/
+};
+const dateRegex = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
+const timeRegex = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
+const timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+function splitDateString(dateString) {
+  const dateStrings = {};
+  const array = dateString.split(patterns.dateTimeDelimiter);
+  let timeString;
+  if (array.length > 2) {
+    return dateStrings;
+  }
+  if (/:/.test(array[0])) {
+    timeString = array[0];
+  } else {
+    dateStrings.date = array[0];
+    timeString = array[1];
+    if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
+      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
+      timeString = dateString.substr(
+        dateStrings.date.length,
+        dateString.length
+      );
+    }
+  }
+  if (timeString) {
+    const token = patterns.timezone.exec(timeString);
+    if (token) {
+      dateStrings.time = timeString.replace(token[1], "");
+      dateStrings.timezone = token[1];
+    } else {
+      dateStrings.time = timeString;
+    }
+  }
+  return dateStrings;
+}
+function parseYear(dateString, additionalDigits) {
+  const regex = new RegExp(
+    "^(?:(\\d{4}|[+-]\\d{" + (4 + additionalDigits) + "})|(\\d{2}|[+-]\\d{" + (2 + additionalDigits) + "})$)"
+  );
+  const captures = dateString.match(regex);
+  if (!captures) return { year: NaN, restDateString: "" };
+  const year = captures[1] ? parseInt(captures[1]) : null;
+  const century = captures[2] ? parseInt(captures[2]) : null;
+  return {
+    year: century === null ? year : century * 100,
+    restDateString: dateString.slice((captures[1] || captures[2]).length)
+  };
+}
+function parseDate(dateString, year) {
+  if (year === null) return /* @__PURE__ */ new Date(NaN);
+  const captures = dateString.match(dateRegex);
+  if (!captures) return /* @__PURE__ */ new Date(NaN);
+  const isWeekDate = !!captures[4];
+  const dayOfYear = parseDateUnit(captures[1]);
+  const month = parseDateUnit(captures[2]) - 1;
+  const day = parseDateUnit(captures[3]);
+  const week = parseDateUnit(captures[4]);
+  const dayOfWeek = parseDateUnit(captures[5]) - 1;
+  if (isWeekDate) {
+    if (!validateWeekDate(year, week, dayOfWeek)) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+    return dayOfISOWeekYear(year, week, dayOfWeek);
+  } else {
+    const date = /* @__PURE__ */ new Date(0);
+    if (!validateDate(year, month, day) || !validateDayOfYearDate(year, dayOfYear)) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+    date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
+    return date;
+  }
+}
+function parseDateUnit(value) {
+  return value ? parseInt(value) : 1;
+}
+function parseTime(timeString) {
+  const captures = timeString.match(timeRegex);
+  if (!captures) return NaN;
+  const hours = parseTimeUnit(captures[1]);
+  const minutes = parseTimeUnit(captures[2]);
+  const seconds = parseTimeUnit(captures[3]);
+  if (!validateTime(hours, minutes, seconds)) {
+    return NaN;
+  }
+  return hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1e3;
+}
+function parseTimeUnit(value) {
+  return value && parseFloat(value.replace(",", ".")) || 0;
+}
+function parseTimezone(timezoneString) {
+  if (timezoneString === "Z") return 0;
+  const captures = timezoneString.match(timezoneRegex);
+  if (!captures) return 0;
+  const sign = captures[1] === "+" ? -1 : 1;
+  const hours = parseInt(captures[2]);
+  const minutes = captures[3] && parseInt(captures[3]) || 0;
+  if (!validateTimezone(hours, minutes)) {
+    return NaN;
+  }
+  return sign * (hours * millisecondsInHour + minutes * millisecondsInMinute);
+}
+function dayOfISOWeekYear(isoWeekYear, week, day) {
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(isoWeekYear, 0, 4);
+  const fourthOfJanuaryDay = date.getUTCDay() || 7;
+  const diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
+  date.setUTCDate(date.getUTCDate() + diff);
+  return date;
+}
+const daysInMonths = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isLeapYearIndex(year) {
+  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+function validateDate(year, month, date) {
+  return month >= 0 && month <= 11 && date >= 1 && date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28));
+}
+function validateDayOfYearDate(year, dayOfYear) {
+  return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
+}
+function validateWeekDate(_year, week, day) {
+  return week >= 1 && week <= 53 && day >= 0 && day <= 6;
+}
+function validateTime(hours, minutes, seconds) {
+  if (hours === 24) {
+    return minutes === 0 && seconds === 0;
+  }
+  return seconds >= 0 && seconds < 60 && minutes >= 0 && minutes < 60 && hours >= 0 && hours < 25;
+}
+function validateTimezone(_hours, minutes) {
+  return minutes >= 0 && minutes <= 59;
+}
 class SessionFile {
   constructor(filePath) {
     this.filePath = filePath;
@@ -70,6 +297,7 @@ const DATA_DIR$1 = process.env.CLAUDE_DISCOVER_DIR || path.join(os.homedir(), ".
 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 contentHash = (s) => crypto.createHash("sha256").update(s).digest("base64url").slice(0, 16);
 const MEMORY_LABELS = {
   "user's private global instructions for all projects": "User",
   "project instructions, checked into the codebase": "Project",
@@ -79,9 +307,9 @@ const MEMORY_LABELS = {
 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 start2 = text.indexOf(marker);
+  if (start2 === -1) return [];
+  let region = text.slice(start2 + 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)];
@@ -108,7 +336,7 @@ const classifyRequest = (req, url) => {
   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("You are a security monitor") || user.startsWith("<transcript>")) return ["security", "Auto-mode 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"];
@@ -165,40 +393,38 @@ class RequestParser {
     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.
+  // The request's system prompt, from a resolveRefs'd record — a plain string or an array of
+  // text blocks. The content hash is the dedup key: repeats collapse in the caller's map.
   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");
+    if (sys == null || sys.$ref) return null;
+    const content = typeof sys === "string" ? sys : sys.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 };
+    return { file_path: "System Prompt", memory_type: kindLabel || "", model: rec.request.model, content, hash: contentHash(content), 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.
+  // The request's tool definitions, from a resolveRefs'd record. 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 (!Array.isArray(tools)) return null;
+    const fresh = tools.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 schema = (t) => t.input_schema ? "```json\n" + JSON.stringify(t.input_schema, null, 2) + "\n```" : "";
+    const content = fresh.map((t) => [`## ${t.name}`, t.description || "", schema(t)].filter(Boolean).join("\n\n")).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 };
+    return { file_path: "System Tools", memory_type: label, model: rec.request.model, content, hash: contentHash(content), 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.
+  // Memory files (CLAUDE.md / MEMORY.md / …) carried by a resolveRefs'd 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;
+      const content = m?.content;
       for (const part of Array.isArray(content) ? content : [{ text: content }]) {
-        const text = (part?.value ?? part)?.text;
+        const text = part?.text;
         if (typeof text !== "string" || !text.includes("<system-reminder>")) continue;
         files.push(...parseClaudeMd(text));
       }
@@ -207,16 +433,20 @@ ${t.description || ""}`.trim()).join("\n\n");
   }
 }
 class RequestFile {
-  constructor(sessionId, dir = REQUESTS_DIR) {
+  constructor(sessionId, { dir = REQUESTS_DIR, agentId = null } = {}) {
     this.filePath = join(dir, `${sessionId}.requests.jsonl`);
+    this.agentId = agentId;
+  }
+  #mine(rec) {
+    return (rec.requestHeaders?.["x-claude-code-agent-id"] ?? null) === this.agentId;
   }
   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.
+  // `range` is { start, end } epoch ms. Refs are resolved over the whole file before the range and
+  // agent filters — an out-of-range (or another agent's) 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 = [];
@@ -229,8 +459,9 @@ class RequestFile {
       }
       records.push(parser.resolveRefs(rec));
     }
-    if (!range) return records;
     return records.filter((r) => {
+      if (!this.#mine(r)) return false;
+      if (!range) return true;
       const t = Date.parse(r.timestamp);
       return t >= range.start && t <= range.end;
     });
@@ -238,25 +469,17 @@ class RequestFile {
   // 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.
+  // Works on read()'s output, so dedup wrappers and the agent scope are already handled.
   // 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;
-      }
+    for (const rec of await this.read()) {
       const record = (f) => ({ timestamp: rec.timestamp, ...f });
-      const sys = hasSystem && parser.systemPrompt(rec);
+      const sys = parser.systemPrompt(rec);
       if (sys && !files.has(sys.hash)) files.set(sys.hash, record(sys));
-      const tools = hasTools && parser.systemTools(rec);
+      const tools = 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));
@@ -373,7 +596,7 @@ class SessionParser {
     }
     if (t === "attachment") {
       obj.isMeta = true;
-      this.prevMessage = obj;
+      if (obj.attachment?.type !== "queued_command") this.prevMessage = obj;
       return true;
     }
     if (t !== "user" && t !== "assistant") return true;
@@ -582,6 +805,8 @@ class SessionsScanner {
   constructor({ root = CLAUDE_PROJECTS_DIR } = {}) {
     this.root = root;
     this.watcher = null;
+    this.watchWanted = false;
+    this.walkDone = Promise.withResolvers();
     this.statCache = new StatCache();
   }
   async _listDirs(p) {
@@ -608,8 +833,17 @@ class SessionsScanner {
   // 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 });
+  async scan(day, opts = {}) {
+    if (this.statCache.complete && this.watcher) {
+      return this.statCache.scan((stat) => this._inPeriod(stat, day), opts);
+    }
+    try {
+      await this._walk(day, opts);
+    } finally {
+      this.walkDone.resolve();
+    }
+  }
+  async _walk(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 });
@@ -631,7 +865,14 @@ class SessionsScanner {
     if (onBatchDone) await onBatchDone();
     progress();
   }
-  watch({ onChange, onUnlink } = {}) {
+  // Starts chokidar once a scan has finished, and resolves when it's live. Its setup walks the whole
+  // projects dir to register watchers, and on a cold disk those stats are the bulk of startup, so it
+  // waits instead of racing our walk. The gap is self-healing: `ignoreInitial` skips files present at
+  // startup anyway, and a session still being written emits on its next append.
+  async watch({ onChange, onUnlink } = {}) {
+    this.watchWanted = true;
+    await this.walkDone.promise;
+    if (!this.watchWanted) return;
     const isUNC = this.root.startsWith("\\\\") || this.root.startsWith("//");
     this.watcher = chokidar.watch(this.root, {
       ignoreInitial: true,
@@ -655,6 +896,7 @@ class SessionsScanner {
     this.watcher.on("unlink", removed);
   }
   stop() {
+    this.watchWanted = false;
     if (this.watcher) {
       this.watcher.close();
       this.watcher = null;
@@ -873,14 +1115,21 @@ class SessionsService extends EventEmitter {
     });
     items.sort((a, b) => a._ts - b._ts);
     for (const o of items) delete o._ts;
-    const instructions = await new RequestFile(reader.sessionId).readInstructions();
+    const instructions = await this.#requestFile(reader.sessionId, reader.parentSessionId).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);
+    return this.#requestFile(sessionId, this.metaCache.byId(sessionId)?.parentSessionId).read(range);
+  }
+  // Subagents send the parent's session id, so the proxy logs their requests into the parent's
+  // file, tagged x-claude-code-agent-id — route their reads there. The transcript filename is
+  // `agent-<id>` while the header carries the bare <id>.
+  #requestFile(sessionId, parentSessionId) {
+    const agentId = parentSessionId && sessionId.startsWith("agent-") ? sessionId.slice("agent-".length) : null;
+    return agentId ? new RequestFile(parentSessionId, { agentId }) : new RequestFile(sessionId);
   }
   // 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 } = {}) {
@@ -1027,6 +1276,7 @@ class WorkHours {
 }
 class AgentRunner {
   async run(text, sender, systemTools = false, cache = false) {
+    const { query } = await import("@anthropic-ai/claude-agent-sdk");
     const send = (chunk) => {
       if (!sender.isDestroyed()) sender.send("agent:output", chunk);
     };
@@ -1258,6 +1508,12 @@ class MainWindow {
   send(channel, payload) {
     if (this.win && !this.win.isDestroyed()) this.win.webContents.send(channel, payload);
   }
+  focus() {
+    if (!this.win || this.win.isDestroyed()) return;
+    if (this.win.isMinimized()) this.win.restore();
+    this.win.show();
+    this.win.focus();
+  }
 }
 const mtimeOf = (path2) => fs.statSync(path2, { throwIfNoEntry: false })?.mtimeMs;
 class ClaudeSettings {
@@ -1349,15 +1605,9 @@ class ProxySwitch {
     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")]);
+    const launcher = utilityProcess.fork(PROXY_PATH, ["--restart"], { stdio: "ignore" });
+    const exited = new Promise((resolve) => launcher.once("message", resolve));
+    const outcome = await Promise.race([exited, this.#settle(true).then((ok) => ok ? "up" : "unresponsive")]).finally(() => launcher.kill());
     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);
@@ -1503,7 +1753,51 @@ class Switchers {
     }
   }
 }
-app.whenReady().then(() => {
+const SCHEME = "claude-discover";
+class DeepLink extends EventEmitter {
+  #pending = null;
+  #live = false;
+  // the renderer has pulled the cold-start link, so later links can be pushed to it
+  // Call at startup, before app.whenReady(). Returns false when another instance already holds the
+  // lock — the caller must then quit, our argv has been forwarded to the window that owns it.
+  requestLock() {
+    if (!app.requestSingleInstanceLock()) return false;
+    app.on("second-instance", (_e, argv) => this.emit("open", findTarget(argv)));
+    app.on("open-url", (e, url) => {
+      e.preventDefault();
+      this.#deliver(findTarget([url]));
+    });
+    this.#register();
+    this.#pending = findTarget(process.argv);
+    return true;
+  }
+  takePending() {
+    this.#live = true;
+    const target = this.#pending;
+    this.#pending = null;
+    return target;
+  }
+  // @macOS Launch Services reuses the running bundle instead of launching a second process, so links
+  // come as events — and a cold-start one fires before the renderer exists, hence the park.
+  #deliver(target) {
+    if (!target) return;
+    if (this.#live) this.emit("open", target);
+    else this.#pending = target;
+  }
+  // @windows Rewritten on every launch — idempotent, and the last launched checkout wins.
+  #register() {
+    if (process.platform !== "win32") return;
+    if (IS_EPHEMERAL) return;
+    app.setAsDefaultProtocolClient(SCHEME, process.execPath, [app.getAppPath()]);
+  }
+}
+function findTarget(argv) {
+  const link = URL.parse(argv.find((a) => a.startsWith(`${SCHEME}://`)) ?? "");
+  const id = link?.searchParams.get("id");
+  return id ? { id, date: link.searchParams.get("date") } : null;
+}
+const deepLink = new DeepLink();
+function start() {
   const win = new MainWindow();
   const agentRunner = new AgentRunner();
   const workHours = new WorkHours();
@@ -1511,6 +1805,10 @@ app.whenReady().then(() => {
   sessionsService.on("update", (sessions) => win.send("sessions:update", sessions));
   sessionsService.on("progress", (p) => win.send("sessions:scan-progress", p));
   sessionsService.start();
+  deepLink.on("open", (target) => {
+    win.focus();
+    if (target) win.send("deeplink:open-session", target);
+  });
   win.create();
   app.on("activate", () => {
     if (BrowserWindow.getAllWindows().length === 0) win.create();
@@ -1522,6 +1820,7 @@ app.whenReady().then(() => {
   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.handle("deeplink:take-pending", () => deepLink.takePending());
   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());
@@ -1536,7 +1835,13 @@ app.whenReady().then(() => {
   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();
 });
+const isFirstInstance = deepLink.requestLock();
+if (isFirstInstance) {
+  app.whenReady().then(start);
+} else {
+  app.exit(0);
+}

package/out/preload/preload.cjs

@@ -24,5 +24,7 @@ electron.contextBridge.exposeInMainWorld("api", {
   onAgentOutput: subscribe("agent:output"),
   openLink: (href, baseFile) => electron.ipcRenderer.invoke("shell:open-link", href, baseFile),
   onFindActive: subscribe("find:active"),
-  findClose: () => electron.ipcRenderer.send("find:close")
+  findClose: () => electron.ipcRenderer.send("find:close"),
+  onDeepLink: subscribe("deeplink:open-session"),
+  takeDeepLink: () => electron.ipcRenderer.invoke("deeplink:take-pending")
 });