claude-discover 1.10.0 → 1.10.2

package/bin/claude/statusline.mjs

@@ -1,124 +1,125 @@
-#!/usr/bin/env node
-// Claude Code status line, installed by StatuslineSwitch. Reads the hook JSON from stdin and
-// prints one colored line — model, context usage, token totals, rate-limit windows:
-//   [Opus 4.8] Context: ▓▓▓░░░░░░░ 32% used (45.2k, 87% cached)  |  Tokens: 1.2M total (+45.2k, 3 turns)  |  Usage limit: 42% used (resets in 2h 30m)
-
-import { readFileSync } from 'node:fs'
-import { styleText } from 'node:util'
-
-
-// Formatting
-const THRESHOLDS = { // (white, yellow, red)
-  context: [0, 100_000, 160_000],
-  limit:   [0, 60, 90],
-  cache:   [90, 60, 0],
-  tokens:  [0, 250_000, 1_000_000],
-  session: [0, 5_000_000, 20_000_000],
-  turns:   [0, 10, 25],
-}
-
-const NO_COLOR = process.env.NO_COLOR !== undefined // standard opt-out; styleText can't honor it for piped output, so gate here
-
-function colorize(kind, text, value = 0) {
-  const bounds = THRESHOLDS[kind]
-  const n = bounds.filter(b => value >= b).length
-  const TIERS  = [null, 'yellow', 'red'] // indexed by severity tier
-  const idx = bounds[0] < bounds.at(-1) ? n - 1 : bounds.length - n
-  const color = TIERS[idx]
-  // validateStream:false forces codes through the pipe (statusline output isn't a TTY)
-  return color && !NO_COLOR ? styleText(color, text, { validateStream: false }) : text
-}
-
-
-// Collect stdin data
-const data = JSON.parse(readFileSync(0, 'utf-8')) // fd 0 = stdin
-const modelName = data.model?.display_name?.replace('Claude ', '') || '?'
-const parts = []
-
-
-
-// Context window
-const ctx = data.context_window || {}
-const total = ctx.context_window_size || 0
-if (total) {
-  const usage = ctx.current_usage || {}
-  const hit  = usage.cache_read_input_tokens || 0
-  const used = hit + (usage.cache_creation_input_tokens || 0) + (usage.input_tokens || 0)
-  const pct  = Math.round((used / total) * 100)
-  const cpct = used ? Math.floor((hit * 100) / used) : 0
-  const filled = Math.floor(pct / 10)
-  const bar    = '▓'.repeat(filled) + '░'.repeat(10 - filled)
-  const head   = colorize('context', `${bar} ${pct}% used`, used)
-  const tokens = colorize('context', `${(used / 1000).toFixed(1)}k`, used)
-  const cached = used ? colorize('cache', `${cpct}% cached`, cpct) : `${cpct}% cached`
-  parts.push(`Context: ${head} (${tokens}, ${cached})`)
-}
-
-
-
-// Total tokens (per session and per reply loop)
-function agentLoopUsage(transcriptPath) { // Read the transcript JSONL and sum API usage for the current agent loop and the whole session.
-  const lines   = readFileSync(transcriptPath, 'utf-8').split(/\r?\n/).filter(Boolean)
-  let loop      = { total: 0, turns: 0 } // last prompt-reply breakdown
-  const session = { total: 0, turns: 0 } // whole-session breakdown
-  let seen = new Set() // One API response spans multiple lines (one per content block), each repeating the usage block, so dedupe by message.id.
-
-  for (const line of lines) {
-    let e
-    try { e = JSON.parse(line) } catch { continue } // the transcript may be mid-append — skip a half-written line
-    const msg = e.message || {}
-
-    if (e.type === 'user' && !e.isMeta) {
-      const isToolReply = Array.isArray(msg.content) && msg.content.some(b => b.type === 'tool_result')
-      if (!isToolReply) { // real user prompt = new loop
-        loop = { total: 0, turns: 0 }
-        seen = new Set()
-      }
-    } else if (e.type === 'assistant' && !seen.has(msg.id)) {
-      seen.add(msg.id)
-      const u = msg.usage || {}
-      const tokens = (u.input_tokens || 0) + (u.output_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0)
-      for (const d of [loop, session]) {
-        d.total += tokens
-        d.turns += 1
-      }
-    }
-  }
-  return [loop, session]
-}
-
-if (data.transcript_path) {
-  const [loop, session] = agentLoopUsage(data.transcript_path)
-  const fmt = n => n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : `${(n / 1000).toFixed(1)}k`
-  const tokensS = colorize('tokens',  fmt(loop.total),    loop.total)
-  const sessS   = colorize('session', fmt(session.total), session.total)
-  const turnsS  = colorize('turns', `${loop.turns} turn${loop.turns !== 1 ? 's' : ''}`, loop.turns)
-  parts.push(`Tokens: ${sessS} total (+${tokensS}, ${turnsS})`)
-}
-
-
-
-// Rate limits (5-hour and weekly windows)
-function fmtReset(resetsAt) { // Format remaining time until a unix-epoch reset, e.g. "2h 30m" (null if no timestamp).
-  if (!resetsAt) return null
-  const secs = Math.max(0, Math.floor(Number(resetsAt)) - Math.floor(Date.now() / 1000))
-  const min  = Math.floor(secs / 60) % 60
-  const hrs  = Math.floor(secs / 3600) % 24
-  const days = Math.floor(secs / 86400)
-  if (days) return `${days}d ${hrs}h`
-  if (hrs)  return `${hrs}h ${min}m`
-  return `${min}m`
-}
-
-const rl = data.rate_limits || {}
-for (const [label, window] of [['Usage limit', rl.five_hour], ['Weekly limit', rl.seven_day]]) {
-  if (!window) continue
-  const pct      = Math.floor(window.used_percentage || 0)
-  const reset    = fmtReset(window.resets_at)
-  const resetStr = reset ? ` (resets in ${reset})` : ''
-  parts.push(`${label}: ${colorize('limit', `${pct}% used${resetStr}`, pct)}`)
-}
-
-
-// Status line
-process.stdout.write(`[${modelName}] ` + parts.join('  |  ') + '\n')
+#!/usr/bin/env node
+// Claude Code status line, installed by StatuslineSwitch. Reads the hook JSON from stdin and
+// prints one colored line — model and effort, context usage, token totals, rate-limit windows:
+//   [Opus 4.8 high] Context: ▓▓▓░░░░░░░ 32% used (45.2k, 87% cached)  |  Tokens: 1.2M total (+45.2k, 3 turns)  |  Daily: 42% used (resets in 2h 30m)
+
+import { readFileSync } from 'node:fs'
+import { styleText } from 'node:util'
+
+
+// Formatting
+const THRESHOLDS = { // (white, yellow, red)
+  context: [0, 100_000, 250_000],
+  limit:   [0, 60, 90],
+  cache:   [90, 60, 0],
+  tokens:  [0, 250_000, 1_000_000],
+  session: [0, 3_000_000, 8_000_000],
+  turns:   [0, 10, 25],
+}
+
+const NO_COLOR = process.env.NO_COLOR !== undefined // standard opt-out; styleText can't honor it for piped output, so gate here
+
+function colorize(kind, text, value = 0) {
+  const bounds = THRESHOLDS[kind]
+  const n = bounds.filter(b => value >= b).length
+  const TIERS  = [null, 'yellow', 'red'] // indexed by severity tier
+  const idx = bounds[0] < bounds.at(-1) ? n - 1 : bounds.length - n
+  const color = TIERS[idx]
+  // validateStream:false forces codes through the pipe (statusline output isn't a TTY)
+  return color && !NO_COLOR ? styleText(color, text, { validateStream: false }) : text
+}
+
+
+// Collect stdin data
+const data = JSON.parse(readFileSync(0, 'utf-8')) // fd 0 = stdin
+const modelName = data.model?.display_name?.replace('Claude ', '') || '?'
+const effort    = data.effort?.level // absent when the model doesn't support effort
+const parts = []
+
+
+
+// Context window
+const ctx = data.context_window || {}
+const total = ctx.context_window_size || 0
+if (total) {
+  const usage = ctx.current_usage || {}
+  const hit  = usage.cache_read_input_tokens || 0
+  const used = hit + (usage.cache_creation_input_tokens || 0) + (usage.input_tokens || 0)
+  const pct  = Math.round((used / total) * 100)
+  const cpct = used ? Math.floor((hit * 100) / used) : 0
+  const filled = Math.floor(pct / 10)
+  const bar    = '▓'.repeat(filled) + '░'.repeat(10 - filled)
+  const head   = colorize('context', `${bar} ${pct}% used`, used)
+  const tokens = colorize('context', `${(used / 1000).toFixed(1)}k`, used)
+  const cached = used ? colorize('cache', `${cpct}% cached`, cpct) : `${cpct}% cached`
+  parts.push(`Context: ${head} (${tokens}, ${cached})`)
+}
+
+
+
+// Total tokens (per session and per reply loop)
+function agentLoopUsage(transcriptPath) { // Read the transcript JSONL and sum API usage for the current agent loop and the whole session.
+  const lines   = readFileSync(transcriptPath, 'utf-8').split(/\r?\n/).filter(Boolean)
+  let loop      = { total: 0, turns: 0 } // last prompt-reply breakdown
+  const session = { total: 0, turns: 0 } // whole-session breakdown
+  let seen = new Set() // One API response spans multiple lines (one per content block), each repeating the usage block, so dedupe by message.id.
+
+  for (const line of lines) {
+    let e
+    try { e = JSON.parse(line) } catch { continue } // the transcript may be mid-append — skip a half-written line
+    const msg = e.message || {}
+
+    if (e.type === 'user' && !e.isMeta) {
+      const isToolReply = Array.isArray(msg.content) && msg.content.some(b => b.type === 'tool_result')
+      if (!isToolReply) { // real user prompt = new loop
+        loop = { total: 0, turns: 0 }
+        seen = new Set()
+      }
+    } else if (e.type === 'assistant' && !seen.has(msg.id)) {
+      seen.add(msg.id)
+      const u = msg.usage || {}
+      const tokens = (u.input_tokens || 0) + (u.output_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0)
+      for (const d of [loop, session]) {
+        d.total += tokens
+        d.turns += 1
+      }
+    }
+  }
+  return [loop, session]
+}
+
+if (data.transcript_path) {
+  const [loop, session] = agentLoopUsage(data.transcript_path)
+  const fmt = n => n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : `${(n / 1000).toFixed(1)}k`
+  const tokensS = colorize('tokens',  fmt(loop.total),    loop.total)
+  const sessS   = colorize('session', fmt(session.total), session.total)
+  const turnsS  = colorize('turns', `${loop.turns} turn${loop.turns !== 1 ? 's' : ''}`, loop.turns)
+  parts.push(`Tokens: ${sessS} total (+${tokensS}, ${turnsS})`)
+}
+
+
+
+// Rate limits (5-hour and weekly windows)
+function fmtReset(resetsAt) { // Format remaining time until a unix-epoch reset, e.g. "2h 30m" (null if no timestamp).
+  if (!resetsAt) return null
+  const secs = Math.max(0, Math.floor(Number(resetsAt)) - Math.floor(Date.now() / 1000))
+  const min  = Math.floor(secs / 60) % 60
+  const hrs  = Math.floor(secs / 3600) % 24
+  const days = Math.floor(secs / 86400)
+  if (days) return `${days}d ${hrs}h`
+  if (hrs)  return `${hrs}h ${min}m`
+  return `${min}m`
+}
+
+const rl = data.rate_limits || {}
+for (const [label, window] of [['Daily', rl.five_hour], ['Weekly', rl.seven_day]]) {
+  if (!window) continue
+  const pct      = Math.floor(window.used_percentage || 0)
+  const reset    = fmtReset(window.resets_at)
+  const resetStr = reset ? ` (resets in ${reset})` : ''
+  parts.push(`${label}: ${colorize('limit', `${pct}% used${resetStr}`, pct)}`)
+}
+
+
+// Status line
+process.stdout.write(`[${modelName}${effort ? ` ${effort}` : ''}] ` + parts.join('  |  ') + '\n')

package/bin/update.mjs

@@ -0,0 +1,33 @@
+// Updates an `npm i -g` install from outside it. AutoUpdate starts it detached as the app quits:
+// Windows locks the app's running electron.exe, so npm can only replace the package once the app is gone.
+//
+// Usage: node bin/update.mjs <pid> <version> [--no-reopen]   (dev passes --no-reopen)
+
+import { spawn, spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { setTimeout as sleep } from 'node:timers/promises'
+
+const [pid, version, noReopen] = process.argv.slice(2)
+
+while (isRunning(pid)) await sleep(200)
+
+try {
+  // Into the helper's console window (@windows), where --loglevel=http lists each package as npm fetches it
+  const { status } = spawnSync(`npm i -g claude-discover@${version} --loglevel=http`, { shell: true, stdio: 'inherit' })
+  if (status !== 0) await sleep(5_000) // leaves npm's error readable before the window closes
+} finally {
+  // Reopen the global install (the one just updated, or just created from an npx run), even when the update failed
+  if (!noReopen) {
+    const root = spawnSync('npm root -g', { shell: true, encoding: 'utf8' }).stdout.trim()
+    spawn(process.execPath, [path.join(root, 'claude-discover/bin/claude-discover.mjs')], { detached: true, stdio: 'ignore' }).unref()
+  }
+}
+
+function isRunning(pid) {
+  try {
+    process.kill(Number(pid), 0)
+    return true
+  } catch (err) {
+    return err.code === 'EPERM' // alive, just not ours to signal
+  }
+}

package/out/main/main.js

@@ -7,8 +7,10 @@ import { sync } from "write-file-atomic";
 import fsp from "node:fs/promises";
 import crypto from "node:crypto";
 import which from "which";
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
+import latestVersion from "latest-version";
+import semver from "semver";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import windowStateKeeper from "electron-window-state";
 import contextMenu from "electron-context-menu";
@@ -35,9 +37,17 @@ const CLAUDE_DIR = local.claudeDir || process.env.CLAUDE_CONFIG_DIR || join(home
 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 UPDATE_PATH = join(import.meta.dirname, "../../bin/update.mjs");
+const LAUNCH_MODES = { NPM_DEV: "npm-dev", NPM_START: "npm-start", NPX_TEMP: "npx-temp", NPM_GLOBAL: "npm-global" };
+const LAUNCH_MODE = detectLaunchMode();
+function detectLaunchMode() {
+  const dirs = import.meta.dirname.split(/[\\/]/);
+  if (dirs.includes("_npx")) return LAUNCH_MODES.NPX_TEMP;
+  if (dirs.includes("node_modules")) return LAUNCH_MODES.NPM_GLOBAL;
+  return LAUNCH_MODES.NPM_START;
+}
 const SCHEME = "claude-discover";
 class DeepLink extends EventEmitter {
   #pending = null;
@@ -51,6 +61,7 @@ class DeepLink extends EventEmitter {
     });
     this.#register();
     this.#pending = findTarget(process.argv);
+    return this;
   }
   open(target) {
     if (target) this.emit("open", target);
@@ -71,7 +82,7 @@ class DeepLink extends EventEmitter {
   // @windows Rewritten on every launch — idempotent, and the last launched checkout wins.
   #register() {
     if (process.platform !== "win32") return;
-    if (IS_EPHEMERAL) return;
+    if (LAUNCH_MODE === LAUNCH_MODES.NPX_TEMP) return;
     app.setAsDefaultProtocolClient(SCHEME, process.execPath, [app.getAppPath()]);
   }
 }
@@ -638,6 +649,7 @@ class RequestFile {
     const parser = new RequestParser();
     const files = /* @__PURE__ */ new Map();
     for (const rec of await this.read()) {
+      if (!rec.request) continue;
       const record = (f) => ({ timestamp: rec.timestamp, ...f });
       const sys = parser.systemPrompt(rec);
       if (sys && !files.has(sys.hash)) files.set(sys.hash, record(sys));
@@ -693,6 +705,8 @@ function freshMeta({ sessionId, parentSessionId, filePath, parentFilePath, fileS
     mtime,
     startedAt: null,
     lastActivityAt: null,
+    continuesFrom: null,
+    continuesTo: null,
     entrypoint: null,
     project: null,
     worktree: null,
@@ -701,6 +715,7 @@ function freshMeta({ sessionId, parentSessionId, filePath, parentFilePath, fileS
     version: null,
     model: null,
     models: [],
+    efforts: [],
     serviceTier: null,
     speed: null,
     fastPricingUnknown: false,
@@ -737,6 +752,8 @@ class SessionParser {
     this.prevMessage = null;
     this.tokenTotal = 0;
     this.lastSeenTs = null;
+    this.commandUuids = /* @__PURE__ */ new Set();
+    this.seenUuids = /* @__PURE__ */ new Set();
     this.appliedById = /* @__PURE__ */ new Map();
   }
   // Returns true if the item passes `this.range`.
@@ -758,12 +775,23 @@ class SessionParser {
     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;
+    if (this.range && (ts < this.range.start || ts > this.range.end)) {
+      if (inherited != null && ts < this.range.start && ts > meta.continuesFrom) meta.continuesFrom = ts;
+      if (inherited != null && ts > this.range.end && (meta.continuesTo == null || ts < meta.continuesTo)) meta.continuesTo = ts;
+      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 (obj.uuid) {
+      if (this.seenUuids.has(obj.uuid)) {
+        obj._relogged = true;
+        return true;
+      }
+      this.seenUuids.add(obj.uuid);
+    }
     if (t === "attachment") {
       obj.isMeta = true;
       if (obj.attachment?.type !== "queued_command") this.prevMessage = obj;
@@ -778,7 +806,7 @@ class SessionParser {
       meta.activityPeriods.push({ start: ts, end: ts });
     }
     if (t === "user") {
-      if (obj.turnCompanion && !obj.sourceToolUseID) meta.skillCalls += 1;
+      if (obj.turnCompanion && !obj.sourceToolUseID && this.commandUuids.has(obj.parentUuid)) meta.skillCalls += 1;
       this._feedUser(obj);
     } else if (t === "assistant") {
       const msg = obj.message;
@@ -787,6 +815,8 @@ class SessionParser {
         if (!meta.model) meta.model = msg.model;
         if (!meta.models.includes(msg.model)) meta.models.push(msg.model);
       }
+      const effort = obj.perTurnEffort ?? obj.effort;
+      if (effort && !meta.efforts.includes(effort)) meta.efforts.push(effort);
       if (Array.isArray(msg.content)) {
         for (const b of msg.content) {
           if (b?.type !== "tool_use") continue;
@@ -806,6 +836,7 @@ class SessionParser {
     const text = extractText(obj.message?.content);
     if (text.startsWith("<command-name>") || text.startsWith("<command-message>")) {
       if (!meta.firstUserCommand) meta.firstUserCommand = text;
+      if (obj.uuid) this.commandUuids.add(obj.uuid);
       obj.isMeta = true;
     } else if (text.startsWith("<local-command-stdout>")) {
       if (meta.firstUserCommand) meta.firstUserCommand += "\n" + text;
@@ -814,7 +845,7 @@ class SessionParser {
       obj.isMeta = true;
     } else if (text.startsWith("<scheduled-task")) {
       meta.hasScheduledTask = true;
-    } else if (text && !obj.isMeta) {
+    } else if (text && !obj.isMeta && !obj.isCompactSummary) {
       if (!meta.firstUserPrompt) meta.firstUserPrompt = text.slice(0, 300);
     }
   }
@@ -1513,7 +1544,7 @@ class WorkHours {
   }
 }
 class AgentRunner {
-  async run(text, sender, systemTools = false, cache = false) {
+  async run(text, sender) {
     const { query } = await import("@anthropic-ai/claude-agent-sdk");
     const send = (chunk) => {
       if (!sender.isDestroyed()) sender.send("agent:output", chunk);
@@ -1522,9 +1553,10 @@ class AgentRunner {
       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 : []
+        env: { ...process.env, DISABLE_PROMPT_CACHING: "1" },
+        // @macOS - process.env must be included
+        tools: [],
+        settingSources: []
       }
     });
     for await (const message of response) {
@@ -1900,12 +1932,12 @@ class Switchers {
   }
   async status(name) {
     const s = await this.#get(name).status();
-    return name in this.#keepActive ? { ...s, keepActive: this.#keepActive[name], ephemeral: IS_EPHEMERAL } : s;
+    return name in this.#keepActive ? { ...s, keepActive: this.#keepActive[name], ephemeral: LAUNCH_MODE === LAUNCH_MODES.NPX_TEMP } : s;
   }
   activate(name, ...args) {
     return this.#attempt(name, async (s) => {
       await s.activate(...args);
-      this.#keepActive[name] &&= !IS_EPHEMERAL;
+      this.#keepActive[name] &&= LAUNCH_MODE !== LAUNCH_MODES.NPX_TEMP;
     });
   }
   // an npx-cache run undoes what it activated
@@ -1936,6 +1968,30 @@ class Switchers {
     }
   }
 }
+class AutoUpdate {
+  #result = null;
+  // Once per launch — a renderer reload reuses the answer
+  check() {
+    return this.#result ??= this.#fetchNewer().catch((err) => {
+      console.warn("[auto-update] failed:", err.message);
+      return null;
+    });
+  }
+  async install() {
+    const update = await this.check();
+    if (!update) return;
+    const args = [UPDATE_PATH, process.pid, update.latest, ...LAUNCH_MODE === LAUNCH_MODES.NPM_DEV ? ["--no-reopen"] : []].map(String);
+    const [command, commandArgs] = process.platform === "win32" ? ["cmd", ["/c", "start", "Updating Claude Discover", "node", ...args]] : ["node", args];
+    spawn(command, commandArgs, { detached: true, stdio: ["ignore", "inherit", "inherit"], cwd: homedir() }).once("spawn", () => app.quit()).once("error", (err) => dialog.showErrorBox("Update failed", `Could not start node: ${err.message}`));
+  }
+  async #fetchNewer() {
+    if (LAUNCH_MODE === LAUNCH_MODES.NPM_START) return null;
+    const latest = await latestVersion("claude-discover");
+    const current = app.getVersion();
+    if (LAUNCH_MODE === LAUNCH_MODES.NPX_TEMP) return { current, latest, fromNpx: true };
+    return semver.gt(latest, current) ? { current, latest } : null;
+  }
+}
 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);
@@ -2079,14 +2135,15 @@ class Application {
     this.agentRunner = new AgentRunner();
     this.workHours = new WorkHours();
     this.sessionsService = new SessionsService();
+    this.autoUpdate = new AutoUpdate();
     this.switchers = new Switchers({ restart: () => this.restart() });
   }
   start() {
-    const { deepLink, win, agentRunner, workHours, sessionsService, switchers } = this;
+    const { deepLink, win, agentRunner, workHours, sessionsService, autoUpdate, switchers } = this;
     Menu.setApplicationMenu(this.#buildMenu());
     sessionsService.on("update", (sessions) => win.send("sessions:update", sessions));
     sessionsService.on("progress", (p) => win.send("sessions:scan-progress", p));
-    deepLink.on("open", (target) => {
+    deepLink?.on("open", (target) => {
       win.focus();
       win.send("deeplink:open-session", target);
     });
@@ -2099,9 +2156,11 @@ class Application {
     ipcMain.handle("switch:keep-active", (_e, name, value) => switchers.setKeepActive(name, value));
     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("auto-update:check", () => autoUpdate.check());
+    ipcMain.handle("auto-update:install", () => autoUpdate.install());
+    ipcMain.handle("agent:run", (e, text) => agentRunner.run(text, e.sender));
     ipcMain.handle("shell:open-link", (_e, href, baseFile) => openLinkSafely(href, baseFile));
-    ipcMain.handle("deeplink:take-pending", () => deepLink.takePending());
+    ipcMain.handle("deeplink:take-pending", () => deepLink?.takePending() ?? null);
     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());
@@ -2171,11 +2230,80 @@ class Application {
     ]);
   }
 }
+const APP_ID = "claude-discover";
+const GLOBAL = LAUNCH_MODE === LAUNCH_MODES.NPM_GLOBAL;
+const NAME = GLOBAL ? "Claude Discover" : "Claude Discover (local)";
+class Shortcuts {
+  #os = process.platform === "win32" ? new WindowsLinks() : process.platform === "darwin" ? new MacBundle() : null;
+  // Call before any window is created, so the window picks up the app id.
+  activate() {
+    if (process.platform === "win32") app.setAppUserModelId(APP_ID);
+    if (!this.#os || LAUNCH_MODE === LAUNCH_MODES.NPX_TEMP || LAUNCH_MODE === LAUNCH_MODES.NPM_DEV) return;
+    const created = config.read().shortcuts ?? {};
+    const install = fs.statSync(app.getAppPath()).birthtimeMs;
+    const newInstall = created[NAME] !== install;
+    for (const path2 of this.#os.paths()) {
+      const exists = fs.existsSync(path2);
+      if (!exists && !newInstall) continue;
+      this.#os.write(path2, exists);
+    }
+    if (newInstall) config.save({ shortcuts: { ...created, [NAME]: install } });
+  }
+}
+class WindowsLinks {
+  // @windows
+  paths() {
+    return [join(app.getPath("appData"), "Microsoft/Windows/Start Menu/Programs"), app.getPath("desktop")].map((dir) => join(dir, `${NAME}.lnk`));
+  }
+  write(path2, exists) {
+    const written = shell.writeShortcutLink(path2, exists ? "replace" : "create", {
+      target: process.execPath,
+      args: `"${app.getAppPath()}"`,
+      description: "Browse your local Claude Code sessions",
+      icon: process.execPath,
+      iconIndex: 0,
+      appUserModelId: APP_ID
+    });
+    if (!written) throw new Error(`cannot write ${path2}`);
+  }
+}
+class MacBundle {
+  // @macOS
+  paths() {
+    return [join(app.getPath("home"), "Applications", `${NAME}.app`)];
+  }
+  write(path2) {
+    const electronApp = join(process.execPath, "../../..");
+    const quote = (s) => `'${s.replaceAll("'", `'\\''`)}'`;
+    fs.mkdirSync(join(path2, "Contents/MacOS"), { recursive: true });
+    fs.mkdirSync(join(path2, "Contents/Resources"), { recursive: true });
+    fs.copyFileSync(join(electronApp, "Contents/Resources/electron.icns"), join(path2, "Contents/Resources/icon.icns"));
+    fs.writeFileSync(join(path2, "Contents/MacOS/launch"), [
+      "#!/bin/sh",
+      `exec open -n ${quote(electronApp)} --env ${quote(`PATH=${process.env.PATH}`)} --args ${quote(app.getAppPath())}`,
+      ""
+    ].join("\n"), { mode: 493 });
+    fs.writeFileSync(join(path2, "Contents/Info.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>CFBundleName</key><string>${NAME}</string>
+  <key>CFBundleIdentifier</key><string>com.dichev.${APP_ID}${GLOBAL ? "" : ".local"}</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleExecutable</key><string>launch</string>
+  <key>CFBundleIconFile</key><string>icon</string>
+  <key>LSUIElement</key><true/>
+</dict>
+</plist>
+`);
+  }
+}
 const isFirstInstance = app.requestSingleInstanceLock();
 if (isFirstInstance) {
-  let application;
-  const deepLink = new DeepLink();
-  deepLink.activate();
+  let application = null;
+  let deepLink = null;
+  optional("deep links", () => deepLink = new DeepLink().activate());
+  optional("shortcuts", () => new Shortcuts().activate());
   app.whenReady().then(() => {
     application = new Application({ deepLink });
     application.start();
@@ -2185,7 +2313,7 @@ if (isFirstInstance) {
     if (argv.includes("--restart")) {
       application?.restart();
     } else if (target) {
-      deepLink.open(target);
+      deepLink?.open(target);
     } else {
       application?.win.focus();
     }
@@ -2193,3 +2321,10 @@ if (isFirstInstance) {
 } else {
   app.exit(0);
 }
+function optional(label, activate) {
+  try {
+    activate();
+  } catch (err) {
+    console.warn(`[${label}] skipped:`, err.message);
+  }
+}

package/out/preload/preload.cjs

@@ -20,8 +20,10 @@ electron.contextBridge.exposeInMainWorld("api", {
   onScanProgress: subscribe("sessions:scan-progress"),
   getWorkHours: () => electron.ipcRenderer.invoke("work-hours:get"),
   setWorkHours: (data) => electron.ipcRenderer.invoke("work-hours:set", data),
-  runAgentPrompt: (text, systemTools, cache) => electron.ipcRenderer.invoke("agent:run", text, systemTools, cache),
+  runAgentPrompt: (text) => electron.ipcRenderer.invoke("agent:run", text),
   onAgentOutput: subscribe("agent:output"),
+  checkUpdate: () => electron.ipcRenderer.invoke("auto-update:check"),
+  installUpdate: () => electron.ipcRenderer.invoke("auto-update:install"),
   openLink: (href, baseFile) => electron.ipcRenderer.invoke("shell:open-link", href, baseFile),
   onFindActive: subscribe("find:active"),
   findClose: () => electron.ipcRenderer.send("find:close"),