claude-discover 1.9.1 → 1.9.4

package/out/main/main.js

@@ -1,4 +1,4 @@
-import { BrowserWindow, dialog, app, Menu, shell, WebContentsView, utilityProcess, ipcMain } from "electron";
+import { BrowserWindow, dialog, app, Menu, shell, WebContentsView, ipcMain } from "electron";
 import { EventEmitter } from "node:events";
 import fs from "node:fs";
 import fsp from "node:fs/promises";
@@ -10,6 +10,9 @@ import { sync } from "write-file-atomic";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import windowStateKeeper from "electron-window-state";
 import contextMenu from "electron-context-menu";
+import which from "which";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 const millisecondsInMinute = 6e4;
 const millisecondsInHour = 36e5;
 const constructFromSymbol = /* @__PURE__ */ Symbol.for("constructDateFrom");
@@ -289,7 +292,7 @@ class SessionFile {
 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 UPSTREAM = 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";
@@ -298,6 +301,7 @@ 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 isMcp = (name) => name.startsWith("mcp__");
 const MEMORY_LABELS = {
   "user's private global instructions for all projects": "User",
   "project instructions, checked into the codebase": "Project",
@@ -306,10 +310,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 start2 = text.indexOf(marker);
-  if (start2 === -1) return [];
-  let region = text.slice(start2 + marker.length);
+  const marker = text.match(/\n# claudeMd\r?\n|Codebase and user instructions are shown below\./);
+  if (!marker) return [];
+  let region = text.slice(marker.index + marker[0].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)];
@@ -352,10 +355,22 @@ const stripKind = (req) => {
   const kind = classifyRequest(req);
   return !kind || kind[0] === "main" || kind[0] === "tools" ? ["main", null] : kind;
 };
+const toStrip = (rec, file_path, label, content) => {
+  const [kind, kindLabel] = stripKind(rec.request);
+  return {
+    file_path,
+    memory_type: [kindLabel, label].filter(Boolean).join(", "),
+    model: rec.request.model,
+    content,
+    hash: contentHash(content),
+    kind
+  };
+};
 class RequestParser {
   constructor() {
     this.hashes = /* @__PURE__ */ new Map();
     this.seenTools = /* @__PURE__ */ new Set();
+    this.deferred = null;
   }
   // 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
@@ -399,26 +414,63 @@ class RequestParser {
     const sys = rec.request?.system;
     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: contentHash(content), kind };
-  }
-  // 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.
+    return toStrip(rec, "System Prompt", "", content);
+  }
+  // The deferred-tool roster Claude Code announces in the environment block of the first user
+  // message: names it can call but whose schemas are left out of `tools` until ToolSearch pulls one
+  // in. The list never appears in `tools`, so it is the only record of what a session declared but
+  // never paid for. One roster per session — cached on first sight.
+  deferredTools(rec) {
+    if (this.deferred) return this.deferred;
+    for (const m of rec.request?.messages || []) {
+      const content = m?.content;
+      for (const part of Array.isArray(content) ? content : [{ text: content }]) {
+        const text = part?.text;
+        if (typeof text !== "string") continue;
+        const intro = text.match(/deferred tools are now available[^\n]*:\r?\n/);
+        if (!intro) continue;
+        const names = [];
+        for (const line of text.slice(intro.index + intro[0].length).split(/\r?\n/)) {
+          if (!/^[A-Za-z_]\w*$/.test(line)) break;
+          names.push(line);
+        }
+        return this.deferred = names;
+      }
+    }
+    return [];
+  }
+  // The roster as a strip of its own. Names only — a deferred tool has no schema in the request, so
+  // this costs what the environment block's list costs, not what the tools would. Kept in announced
+  // order, which already runs native names before MCP ones, and fenced so markdown keeps one name
+  // per line instead of reflowing them all into one paragraph.
+  deferredStrip(rec) {
+    const names = this.deferredTools(rec);
+    if (!names.length) return null;
+    const mcp = names.filter(isMcp).length;
+    const count = (n, what) => n && `${n} deferred ${what} tool${n === 1 ? "" : "s"}`;
+    const label = [count(names.length - mcp, "system"), count(mcp, "MCP")].filter(Boolean).join(", ");
+    return toStrip(rec, "Deferred Tools", label, "```\n" + names.join("\n") + "\n```");
+  }
+  // The request's tool definitions, from a resolveRefs'd record, as a native and an MCP strip —
+  // MCP schemas are often the bulk of a prompt, so they are worth costing on their own. 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 (!Array.isArray(tools)) return null;
+    if (!Array.isArray(tools)) return [];
     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 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: contentHash(content), kind };
+    const strip = (file_path, pick) => {
+      const list = fresh.filter((t) => pick(t.name));
+      if (!list.length) return null;
+      const content = list.map((t) => [`## ${t.name}`, t.description || "", schema(t)].filter(Boolean).join("\n\n")).join("\n\n");
+      return toStrip(rec, file_path, `${list.length} tool${list.length === 1 ? "" : "s"}`, content);
+    };
+    return [strip("System Tools", (n) => !isMcp(n)), strip("MCP Tools", isMcp)].filter(Boolean);
   }
   // 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.
+  // system-reminders — one { file_path, memory_type, content } per file listed.
   memoryFiles(rec) {
     const files = [];
     for (const m of rec.request?.messages || []) {
@@ -432,13 +484,14 @@ class RequestParser {
     return files;
   }
 }
+const agentKey = (id) => id?.includes("@") ? id.slice(0, id.indexOf("@")) : id?.replace(/^a/, "").replace(/-[0-9a-f]{16}$/, "") ?? null;
 class RequestFile {
   constructor(sessionId, { dir = REQUESTS_DIR, agentId = null } = {}) {
     this.filePath = join(dir, `${sessionId}.requests.jsonl`);
-    this.agentId = agentId;
+    this.agentKey = agentKey(agentId);
   }
   #mine(rec) {
-    return (rec.requestHeaders?.["x-claude-code-agent-id"] ?? null) === this.agentId;
+    return agentKey(rec.requestHeaders?.["x-claude-code-agent-id"] ?? null) === this.agentKey;
   }
   async lines() {
     const raw = await fsp.readFile(this.filePath, "utf8").catch(() => "");
@@ -466,12 +519,9 @@ class RequestFile {
       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.
-  // 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.
+  // System prompts, tool definitions and memory files (CLAUDE.md / MEMORY.md / … from a user
+  // message's instructions system-reminder) — none of which the transcript records, so the request
+  // log is the only source. Returns one record per unique prompt / tool batch / file_path.
   async readInstructions() {
     const parser = new RequestParser();
     const files = /* @__PURE__ */ new Map();
@@ -479,8 +529,9 @@ class RequestFile {
       const record = (f) => ({ timestamp: rec.timestamp, ...f });
       const sys = parser.systemPrompt(rec);
       if (sys && !files.has(sys.hash)) files.set(sys.hash, record(sys));
-      const tools = parser.systemTools(rec);
-      if (tools) files.set(tools.hash, record(tools));
+      const deferred = parser.deferredStrip(rec);
+      if (deferred && !files.has(deferred.hash)) files.set(deferred.hash, record(deferred));
+      for (const tools of parser.systemTools(rec)) 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));
       }
@@ -655,13 +706,9 @@ class SessionParser {
     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.
+  // One assistant reply spans several jsonl lines sharing message.id, with output_tokens growing
+  // toward its final value. Counting each line's *growth* lands the totals on that final value —
+  // what ccusage bills. Ids in `excludeIds` (already counted in a resumed-from session) never aggregate.
   _recordUsage(obj) {
     const meta = this.meta;
     const msg = obj.message;
@@ -768,7 +815,6 @@ 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();
@@ -813,10 +859,8 @@ class SessionsScanner {
     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.
+  // Every .jsonl under `dir`, at any depth — subagent transcripts nest arbitrarily deep. Subtrees
+  // can't be pruned by directory mtime: on Windows, appending to a transcript doesn't bump its parent dir.
   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));
@@ -827,12 +871,10 @@ class SessionsScanner {
     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.
+  // Calls onFile(filePath, stat) for every .jsonl passing _inPeriod, then onBatchDone() per project
+  // if any onFile returned truthy — so callers can flush UI updates incrementally. An aborted
+  // `signal` (a superseded scan) stops everything; once complete with the watcher live, the
+  // StatCache mirrors disk and serves later scans in memory.
   async scan(day, opts = {}) {
     if (this.statCache.complete && this.watcher) {
       return this.statCache.scan((stat) => this._inPeriod(stat, day), opts);
@@ -956,11 +998,16 @@ class MetaCache {
   }
 }
 const seed = {
+  "claude-opus-5": { "input": 5, "output": 25, "cacheRead": 0.5, "cacheWrite": 6.25, "cacheWrite1h": 10, "fastModeMplr": 2 },
+  "claude-fable-5-1": { "input": 10, "output": 50, "cacheRead": 0.25, "cacheWrite": 12.5, "cacheWrite1h": 20 },
   "claude-fable-5": { "input": 10, "output": 50, "cacheRead": 1, "cacheWrite": 12.5, "cacheWrite1h": 20 },
+  "claude-mythos-5-1": { "input": 10, "output": 50, "cacheRead": 0.25, "cacheWrite": 12.5, "cacheWrite1h": 20 },
+  "claude-mythos-5": { "input": 10, "output": 50, "cacheRead": 1, "cacheWrite": 12.5, "cacheWrite1h": 20 },
+  "claude-mythos-preview": { "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-7": { "input": 5, "output": 25, "cacheRead": 0.5, "cacheWrite": 6.25, "cacheWrite1h": 10 },
+  "claude-opus-4-6": { "input": 5, "output": 25, "cacheRead": 0.5, "cacheWrite": 6.25, "cacheWrite1h": 10 },
   "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 },
@@ -973,9 +1020,9 @@ const seed = {
   "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-opus": { "input": 15, "output": 75, "cacheRead": 1.5, "cacheWrite": 18.75, "cacheWrite1h": 30 },
   "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 }
+  "claude-3-haiku": { "input": 0.25, "output": 1.25, "cacheRead": 0.03, "cacheWrite": 0.3, "cacheWrite1h": 0.5 }
 };
 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";
@@ -1126,7 +1173,7 @@ class SessionsService extends EventEmitter {
   }
   // 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>.
+  // `agent-<id>`; RequestFile normalizes that id against the header's own spelling.
   #requestFile(sessionId, parentSessionId) {
     const agentId = parentSessionId && sessionId.startsWith("agent-") ? sessionId.slice("agent-".length) : null;
     return agentId ? new RequestFile(parentSessionId, { agentId }) : new RequestFile(sessionId);
@@ -1529,22 +1576,18 @@ class ClaudeSettings {
       }
     }
   }
-  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) {
+  // Removes every hook (any event) whose command matches `pattern`, dropping groups and events
+  // left empty. Returns the removed commands.
+  removeHooks(pattern) {
+    const matches = (h) => pattern.test(h.command ?? "");
+    const removed = [];
+    for (const [event, groups] of Object.entries(this.cfg.hooks ?? {})) {
+      const hit = groups.flatMap((g) => (g.hooks ?? []).filter(matches).map((h) => h.command));
+      if (!hit.length) continue;
+      removed.push(...hit);
       for (const g of groups) g.hooks = (g.hooks ?? []).filter((h) => !matches(h));
-      this.cfg.hooks[eventName] = groups.filter((g) => g.hooks.length);
+      this.cfg.hooks[event] = groups.filter((g) => g.hooks.length);
+      if (!this.cfg.hooks[event].length) delete this.cfg.hooks[event];
     }
     return removed;
   }
@@ -1575,11 +1618,6 @@ class ClaudeSettings {
   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`);
@@ -1587,55 +1625,195 @@ class ClaudeSettings {
     sync(CLAUDE_SETTINGS, JSON.stringify(this.cfg, null, 2));
   }
 }
-const HOOK_BASENAME = "hooks.mjs";
-const HOOK_COMMAND = `node "${CLAUDE_HOOKS_PATH}"`;
+class LoginService {
+  #service;
+  constructor({ name, command }) {
+    if (process.platform === "win32") this.#service = new TaskScheduler({ name, command });
+    else if (process.platform === "darwin") this.#service = new LaunchAgent({ name, command });
+    else this.#service = new SystemdUnit({ name, command });
+  }
+  install() {
+    return this.#service.install();
+  }
+  uninstall() {
+    return this.#service.uninstall();
+  }
+}
+async function exec(file, args) {
+  try {
+    return await promisify(execFile)(file, args, { windowsHide: true });
+  } catch (err) {
+    throw new Error(err.stderr?.trim() || err.message);
+  }
+}
+class TaskScheduler {
+  static #SYSTEM32 = path.join(process.env.SystemRoot ?? "C:\\Windows", "System32");
+  #name;
+  #command;
+  constructor({ name, command }) {
+    this.#name = name;
+    this.#command = command;
+  }
+  // Without admin rights only an interactive task can be registered, and that would open a console
+  // window — `conhost --headless` runs the command without one. conhost hides the exit code, so a
+  // minutely trigger restarts the process if it died (IgnoreNew: no-op while it runs). Started by
+  // the scheduler, the process is outside any terminal's job object, so closing a terminal can't
+  // kill it. The default settings would skip starting on battery and stop the task after 72h.
+  async install() {
+    const q = (s) => s.replace(/'/g, "''");
+    const conhost = path.join(TaskScheduler.#SYSTEM32, "conhost.exe");
+    await this.#ps(`
+      $user      = "$env:USERDOMAIN\\$env:USERNAME"
+      $action    = New-ScheduledTaskAction -Execute '${q(conhost)}' -Argument '--headless ${this.#command.map((s) => `"${q(s)}"`).join(" ")}'
+      $logon     = New-ScheduledTaskTrigger -AtLogOn -User $user
+      $revive    = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes 1)
+      $principal = New-ScheduledTaskPrincipal -UserId $user -LogonType Interactive -RunLevel Limited
+      $settings  = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit ([TimeSpan]::Zero) -MultipleInstances IgnoreNew
+      $null = Register-ScheduledTask -TaskName '${this.#name}' -Action $action -Trigger $logon, $revive -Principal $principal -Settings $settings -Force
+      Start-ScheduledTask -TaskName '${this.#name}'
+    `);
+  }
+  uninstall() {
+    return this.#ps(`Unregister-ScheduledTask -TaskName '${this.#name}' -Confirm:$false -ErrorAction SilentlyContinue`);
+  }
+  #ps(script) {
+    const powershell = path.join(TaskScheduler.#SYSTEM32, "WindowsPowerShell", "v1.0", "powershell.exe");
+    const wrapped = `$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+try {${script}} catch { [Console]::Error.WriteLine($_.Exception.Message); exit 1 }
+exit 0`;
+    const encoded = Buffer.from(wrapped, "utf16le").toString("base64");
+    return exec(powershell, ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded]);
+  }
+}
+class LaunchAgent {
+  // @macOS
+  #name;
+  #command;
+  #plist;
+  #domain = `gui/${process.getuid()}`;
+  constructor({ name, command }) {
+    this.#name = name;
+    this.#command = command;
+    this.#plist = path.join(os.homedir(), "Library", "LaunchAgents", `${name}.plist`);
+  }
+  // RunAtLoad starts it right away; KeepAlive restarts it only after a crash, so a clean exit stays stopped
+  async install() {
+    fs.mkdirSync(path.dirname(this.#plist), { recursive: true });
+    fs.writeFileSync(this.#plist, `
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${this.#name}</string>
+  <key>ProgramArguments</key><array>${this.#command.map((s) => `<string>${s}</string>`).join("")}</array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+</dict>
+</plist>
+`.trim());
+    await exec("launchctl", ["bootout", this.#domain, this.#plist]).catch(() => {
+    });
+    await exec("launchctl", ["bootstrap", this.#domain, this.#plist]);
+  }
+  async uninstall() {
+    await exec("launchctl", ["bootout", this.#domain, this.#plist]).catch(() => {
+    });
+    fs.rmSync(this.#plist, { force: true });
+  }
+}
+class SystemdUnit {
+  // @linux
+  #name;
+  #command;
+  #unit;
+  constructor({ name, command }) {
+    this.#name = name;
+    this.#command = command;
+    this.#unit = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "systemd", "user", `${name}.service`);
+  }
+  async install() {
+    fs.mkdirSync(path.dirname(this.#unit), { recursive: true });
+    fs.writeFileSync(this.#unit, `
+[Unit]
+Description=${this.#name}
+
+[Service]
+ExecStart=${this.#command.map((s) => `"${s}"`).join(" ")}
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`.trim());
+    await exec("systemctl", ["--user", "daemon-reload"]);
+    await exec("systemctl", ["--user", "enable", "--now", this.#name]);
+  }
+  async uninstall() {
+    await exec("systemctl", ["--user", "disable", "--now", this.#name]).catch(() => {
+    });
+    fs.rmSync(this.#unit, { force: true });
+    await exec("systemctl", ["--user", "daemon-reload"]).catch(() => {
+    });
+  }
+}
+const NODE = await which("node", { nothrow: true }) ?? "node";
 class ProxySwitch {
+  #service = new LoginService({ name: "claude-discover-proxy", command: [NODE, PROXY_PATH] });
+  constructor() {
+    try {
+      const settings = new ClaudeSettings();
+      if (settings.removeHooks(/claude-discover/).length) settings.save();
+    } catch {
+    }
+  }
   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 }.
+  // Install the proxy as a login service, then point Claude Code at it — only once it answers, so
+  // a failed start never touches settings.json. Throws on failure (Switchers turns that into { 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 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);
-    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) });
+      await fetch(new URL("/v1/models", UPSTREAM), { signal: AbortSignal.timeout(5e3) });
     } catch {
+      throw new Error("Cannot reach api.anthropic.com — not enabling capture. Check your network and try again.");
+    }
+    await this.#exit();
+    await this.#service.install();
+    if (!await this.#settle(true)) {
+      await this.#service.uninstall().catch(() => {
+      });
+      throw new Error(`Proxy did not start — see ${ERROR_LOG_PATH}`);
     }
+    settings.setEnv("ANTHROPIC_BASE_URL", PROXY_URL);
+    settings.setEnv("ENABLE_TOOL_SEARCH", "true");
+    settings.save();
+  }
+  // Stop the proxy, remove the service and our env keys — a foreign base URL is left alone
+  async deactivate() {
+    await this.#exit();
+    await this.#service.uninstall();
     const settings = new ClaudeSettings();
-    const ours = settings.env?.ANTHROPIC_BASE_URL === PROXY_URL;
-    const removedHook = settings.removeHook("SessionStart", HOOK_BASENAME).length > 0;
-    if (ours) {
+    if (settings.env?.ANTHROPIC_BASE_URL === PROXY_URL) {
       settings.deleteEnv("ANTHROPIC_BASE_URL");
       settings.deleteEnv("ENABLE_TOOL_SEARCH");
+      settings.save();
+    }
+  }
+  // Ask a running instance to exit via its control route and wait for the port to free up
+  async #exit() {
+    try {
+      await fetch(`${PROXY_URL}${EXIT_ROUTE}`, { method: "POST", signal: AbortSignal.timeout(1e3) });
+    } catch {
+      return;
     }
-    if (ours || removedHook) settings.save();
     await this.#settle(false);
   }
   async #running() {
@@ -1646,7 +1824,7 @@ class ProxySwitch {
       return false;
     }
   }
-  // Poll (≤8s — the proxy's startup upstream check can take 5s) until ping matches `target`
+  // Poll up to 8s until ping matches `target` (the service takes a moment to start it)
   async #settle(target) {
     for (let i = 0; i < 40; i++) {
       if (await this.#running() === target) return true;