claude-rpc 0.13.6 → 0.14.0

package/README.md

@@ -7,7 +7,7 @@
 
 # claude-rpc
 
-**Discord Rich Presence for [Claude Code](https://claude.com/claude-code).**
+**Discord Rich Presence (RPC) for [Claude Code](https://claude.com/claude-code).**
 Your live model, project, current tool, tokens, and lifetime stats — in your Discord profile. Driven by the hooks Claude Code already fires. Zero polling between sessions.
 
 **→ [claude-rpc.vercel.app](https://claude-rpc.vercel.app)** — what it looks like, in one page.
@@ -38,9 +38,11 @@ A small Node daemon that takes the lifecycle events Claude Code already fires an
 **macOS / Linux / any Node 18+** — one command:
 
 ```sh
-npx claude-rpc setup
+npx claude-rpc@latest setup
 ```
 
+(The `@latest` matters — bare `npx claude-rpc` will happily reuse a stale cached copy.)
+
 That installs `claude-rpc` globally, wires the hooks into Claude Code, and starts the daemon — no separate `start` step. Open Claude Code in any project and the card appears within a second. Something looks wrong? `claude-rpc doctor` (or `claude-rpc doctor --fix` to auto-repair).
 
 **Prefer a one-liner that figures it out for you?**
@@ -312,6 +314,8 @@ npm run build:exe         # SEA single-file binary for the current OS
 
 Tests are `node --test` with zero deps. The CI pipeline ([release.yml](.github/workflows/release.yml)) runs the suite (plus the Cloudflare Worker's own tests) across Node 18/20/22 and gates the matrix build and the npm publish behind it. Every pure/logic module in `src/*.js` is unit-tested, including the MCP transport and the SVG renderers; the long-running daemon, the TUI, and the CLI dispatcher are covered by integration and manual smoke testing rather than unit tests.
 
+Where the project is headed (and what it will deliberately never do) lives in [`ROADMAP.md`](ROADMAP.md).
+
 ## license
 
 [MIT](LICENSE) © Archer Simmons

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-rpc",
-  "version": "0.13.6",
+  "version": "0.14.0",
   "description": "Discord Rich Presence for Claude Code — live model, project, tokens, and lifetime stats driven by Claude Code's hook system.",
   "type": "module",
   "license": "MIT",

package/src/cli.js

@@ -22,10 +22,11 @@ import { maybeNudge } from './nudge.js';
 import { badgeSvg } from './badge.js';
 import { fmtCost } from './pricing.js';
 import { addPrivateCwd, removePrivateCwd, listPrivateCwds, resolveVisibility } from './privacy.js';
+import { parseDuration, setPause, clearPause, pauseUntil } from './pause.js';
 import { loadConfig, hasUserConfig } from './config.js';
 import * as lb from './leaderboard.js';
 import { VERSION } from './version.js';
-import { fail, EX_USER_ERROR, EX_BAD_STATE, EX_SYS_ERROR } from './ui.js';
+import { fail, tailLines, EX_USER_ERROR, EX_BAD_STATE, EX_SYS_ERROR } from './ui.js';
 import { randomUUID } from 'node:crypto';
 import { createInterface } from 'node:readline';
 import { basename } from 'node:path';
@@ -110,7 +111,7 @@ function box(title, lines, minWidth = 64) {
   const termWidth = process.stdout.columns || 100;
   const maxAllowed = Math.max(40, termWidth - 2);
   const width = Math.min(maxAllowed, Math.max(minWidth, longest + 4, title.length + 8));
-  const top    = `${c.gray}┌─ ${c.reset}${c.bold}${title}${c.reset} ${c.gray}${'─'.repeat(Math.max(0, width - 4 - title.length))}┐${c.reset}`;
+  const top    = `${c.gray}┌─ ${c.reset}${c.bold}${title}${c.reset} ${c.gray}${'─'.repeat(Math.max(0, width - 5 - title.length))}┐${c.reset}`;
   const bottom = `${c.gray}└${'─'.repeat(width - 2)}┘${c.reset}`;
   console.log(top);
   for (const raw of lines) {
@@ -932,6 +933,78 @@ function doPrivacy() {
   console.log('');
 }
 
+// ── Pause / resume ───────────────────────────────────────────────────────
+//
+// `claude-rpc pause [30m|2h|1h30m|90]` → snooze the Discord card globally
+// (default 1h). `claude-rpc resume` (or `pause off`) lifts it early; expiry
+// lifts it automatically. Privacy controls are per-cwd — this is the
+// "I'm screen-sharing" switch that hides everything regardless of project.
+
+function fmtClock(ts) {
+  const d = new Date(ts);
+  return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+}
+
+function doPause(argv) {
+  const arg = (argv[0] || '').toLowerCase();
+  if (arg === 'off' || arg === 'resume') return doResume();
+  if (arg === 'status') {
+    const until = pauseUntil();
+    if (until) console.log(`${c.yellow}●${c.reset} paused until ${c.cyan}${fmtClock(until)}${c.reset}`);
+    else console.log(`${c.green}○${c.reset} not paused`);
+    return;
+  }
+  const ms = parseDuration(argv[0]);
+  if (ms === null) {
+    fail(`could not parse duration: ${argv[0]}`,
+      { hint: 'use 30m, 2h, 1h30m, or a bare number of minutes (default: 1h)', code: EX_USER_ERROR });
+  }
+  const until = setPause(ms);
+  console.log(`${c.green}✓${c.reset} presence paused until ${c.cyan}${fmtClock(until)}${c.reset}`);
+  console.log(`${c.dim}  the daemon clears the card within a few seconds. Resume early with ${c.reset}${c.cyan}claude-rpc resume${c.reset}`);
+}
+
+function doResume() {
+  const was = pauseUntil();
+  clearPause();
+  if (was) {
+    console.log(`${c.green}✓${c.reset} presence resumed ${c.dim}(was paused until ${fmtClock(was)})${c.reset}`);
+  } else {
+    console.log(`${c.dim}presence wasn't paused.${c.reset}`);
+  }
+}
+
+// ── Export ───────────────────────────────────────────────────────────────
+//
+// `claude-rpc export [--csv] [--out <file>]` — the full aggregate as JSON, or
+// the per-day breakdown as CSV (same shape the dashboard's /api/export routes
+// serve, without needing the server up). Writes to stdout unless --out, so it
+// pipes cleanly into jq / a spreadsheet import.
+
+async function doExport(argv) {
+  const csv = argv.includes('--csv');
+  let out = '';
+  const i = argv.findIndex((a) => a === '--out' || a === '-o');
+  if (i !== -1) out = argv[i + 1] || '';
+  const aggregate = readAggregate();
+  if (!aggregate) {
+    fail('no aggregate yet — nothing to export', { hint: 'run `claude-rpc scan` first', code: EX_BAD_STATE });
+  }
+  let payload;
+  if (csv) {
+    const { aggregateToCsv } = await import('./server/api.js');
+    payload = aggregateToCsv(aggregate);
+  } else {
+    payload = JSON.stringify(aggregate, null, 2) + '\n';
+  }
+  if (out) {
+    writeFileSync(out, payload);
+    console.log(`${c.green}✓${c.reset} Wrote ${c.cyan}${out}${c.reset} (${payload.length} bytes, ${csv ? 'CSV' : 'JSON'})`);
+  } else {
+    process.stdout.write(payload);
+  }
+}
+
 // ── Community totals ─────────────────────────────────────────────────────
 //
 // `claude-rpc community`         → show current state + endpoint
@@ -1060,16 +1133,46 @@ function readFlag(argv, name) {
 
 function profileStatus() {
   const p = (loadConfig().profile) || {};
+  const handleOk = lb.isValidHandle(p.handle);
+  const boardUrl = handleOk ? `https://claude-rpc.vercel.app/u/${encodeURIComponent(p.handle)}` : '';
+
   console.log('');
-  console.log(`  ${c.bold}claude-rpc profile${c.reset}  ${c.dim}— public leaderboard identity${c.reset}`);
+  console.log(`  ${c.bold}${c.magenta}◆ profile${c.reset}  ${c.dim}— public leaderboard identity${c.reset}`);
   console.log('');
-  console.log(`  state:    ${p.enabled ? `${c.green}on${c.reset}` : `${c.dim}off${c.reset}`}`);
-  console.log(`  handle:   ${p.handle ? c.cyan + p.handle + c.reset : c.dim + '(unset)' + c.reset}`);
-  console.log(`  name:     ${p.displayName ? p.displayName : c.dim + '(unset)' + c.reset}`);
-  console.log(`  github:   ${p.githubUser ? `${p.githubUser} ${c.dim}(verify to earn ✓)${c.reset}` : c.dim + '(unset — unverified)' + c.reset}`);
+
+  const githubLine = p.githubUser
+    ? `${p.githubUser}${p.verified ? `  ${c.green}✓ verified${c.reset}` : `  ${c.dim}(unverified)${c.reset}`}`
+    : `${c.dim}—${c.reset}`;
+  box('profile', [
+    pair('state',  p.enabled ? `${c.green}● publishing${c.reset}` : `${c.dim}○ off${c.reset}`, ''),
+    pair('handle', handleOk ? `${c.cyan}${p.handle}${c.reset}` : `${c.dim}(unset)${c.reset}`, ''),
+    pair('name',   p.displayName || `${c.dim}—${c.reset}`, ''),
+    pair('github', githubLine, ''),
+    ...(p.enabled && handleOk ? [pair('board', boardUrl, c.cyan)] : []),
+  ]);
   console.log('');
-  if (!p.handle) console.log(`  ${c.dim}set one with:${c.reset} claude-rpc profile set --handle <name> [--name "..."] [--github <user>]`);
-  else if (!p.enabled) console.log(`  ${c.dim}publish to the board with:${c.reset} claude-rpc profile on`);
+
+  // Setup checklist — same shape every time, so the user always sees where
+  // they are and the exact next command. This is the screen the daemon's
+  // breadcrumbs point back to.
+  const steps = [
+    { done: handleOk,    label: 'set a handle',      cmd: 'claude-rpc profile set --handle <name>', note: p.handle },
+    { done: !!p.enabled, label: 'enable publishing', cmd: 'claude-rpc profile on',                  note: 'daemon republishes automatically' },
+    { done: !!p.verified, label: 'verify on GitHub', cmd: 'claude-rpc profile verify',              note: p.githubUser ? `@${p.githubUser}` : '' },
+  ];
+  if (steps.every((s) => s.done)) {
+    console.log(`  ${c.green}✓${c.reset} all set — you're live at ${c.cyan}${boardUrl}${c.reset}`);
+  } else {
+    const nextIdx = steps.findIndex((s) => !s.done);
+    box('next steps', steps.map((s, i) => {
+      const mark = s.done ? `${c.green}✓${c.reset}` : (i === nextIdx ? `${c.yellow}○${c.reset}` : `${c.dim}○${c.reset}`);
+      const label = s.done ? `${c.dim}${s.label}${c.reset}` : `${c.bold}${s.label}${c.reset}`;
+      const tail = s.done
+        ? `${c.dim}${s.note || 'done'}${c.reset}`
+        : `${c.cyan}${s.cmd}${c.reset}${i === nextIdx ? `  ${c.dim}← next${c.reset}` : ''}`;
+      return `${mark} ${i + 1}. ${label}${' '.repeat(Math.max(1, 20 - s.label.length))}${tail}`;
+    }));
+  }
   console.log('');
 }
 
@@ -1094,6 +1197,9 @@ function profileSet(argv) {
       if (!u) return fail(`invalid GitHub username: ${rawGh}`, { code: EX_USER_ERROR });
       next.githubUser = u;
     }
+    // The ✓ belongs to the account that was verified — switching accounts
+    // means re-verifying.
+    if (next.githubUser !== (userCfg.profile || {}).githubUser) delete next.verified;
   }
 
   userCfg.profile = next;
@@ -1127,7 +1233,7 @@ function profileEnable(on) {
   console.log(`${c.green}✓${c.reset} leaderboard publishing ${on ? 'enabled' : 'disabled'}`);
   if (on) {
     console.log(`  ${c.dim}publish now with ${c.reset}${c.cyan}claude-rpc profile publish${c.reset}${c.dim} (or wait for the next daemon flush).${c.reset}`);
-    console.log(`  ${c.dim}earn the ✓ with ${c.reset}${c.cyan}claude-rpc profile verify${c.reset}${c.dim}.${c.reset}`);
+    profileStatus();
   }
 }
 
@@ -1158,10 +1264,12 @@ async function profileVerify() {
   const cfg = loadConfig();
   const profile = cfg.profile || {};
   const community = cfg.community || {};
+  // No --github required up front: the worker treats it as a hint only and
+  // takes the authoritative identity from whoever owns the proof gist —
+  // and publishing that gist already requires gh auth, so the account is
+  // known by the time it matters.
   if (!profile.githubUser) {
-    return fail('set a GitHub username first', {
-      hint: 'claude-rpc profile set --github <user>', code: EX_BAD_STATE,
-    });
+    console.log(`${c.dim}no --github set — your verified identity will be the account that owns the proof gist.${c.reset}`);
   }
   if (!community.instanceId) {
     return fail('enable the profile first', { hint: 'claude-rpc profile on', code: EX_BAD_STATE });
@@ -1186,7 +1294,7 @@ async function profileVerify() {
       await flushProfile(cfg);
     }
     console.log(`${c.dim}requesting a verification token…${c.reset}`);
-    const start = await post('/verify/start', { instanceId: community.instanceId, githubUser: profile.githubUser });
+    const start = await post('/verify/start', { instanceId: community.instanceId, githubUser: profile.githubUser || null });
     if (!start.json?.token) return fail(`verify/start failed: ${start.json?.error || start.status}`, { code: EX_SYS_ERROR });
     const token = start.json.token;
 
@@ -1206,13 +1314,11 @@ async function profileVerify() {
     const check = await post('/verify/check', { instanceId: community.instanceId, gistId: gist.id });
     if (check.json?.verified) {
       const who = check.json.githubUser || gist.owner || profile.githubUser;
-      // Persist the authoritative owner so the local profile + future publishes
-      // match what got verified.
-      if (who && who !== profile.githubUser) {
-        const userCfg = readJson(CONFIG_PATH, {});
-        userCfg.profile = { ...(userCfg.profile || {}), githubUser: who };
-        writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
-      }
+      // Persist the authoritative owner + a local verified marker so the
+      // profile checklist and future publishes match what got verified.
+      const userCfg = readJson(CONFIG_PATH, {});
+      userCfg.profile = { ...(userCfg.profile || {}), ...(who ? { githubUser: who } : {}), verified: true };
+      writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
       console.log(`${c.green}✓${c.reset} verified as @${who} — you'll show the ✓ on the board.`);
       if (who && profile.githubUser && who.toLowerCase() !== profile.githubUser.toLowerCase()) {
         console.log(`  ${c.dim}(your gist is owned by @${who}, so the profile now uses that account.)${c.reset}`);
@@ -1260,8 +1366,7 @@ function tailLog() {
     return;
   }
   // Print the last ~30 lines, then follow.
-  const raw = readFileSync(LOG_PATH, 'utf8').split('\n');
-  const tail = raw.slice(-31, -1);
+  const tail = tailLines(readFileSync(LOG_PATH, 'utf8'));
   for (const line of tail) process.stdout.write(line + '\n');
   let lastSize = readFileSync(LOG_PATH).length;
   console.log(`${c.dim}-- tailing ${LOG_PATH} (Ctrl-C to stop) --${c.reset}`);
@@ -1375,6 +1480,9 @@ function help() {
     ['mcp install', 'Wire the stats MCP server into Claude Code (one command)'],
     ['mcp',       'Run the MCP server (stdio) — exposes your stats to Claude'],
     ['wrapped',   'Open your animated year-in-review (Claude Wrapped)'],
+    ['pause',     'Snooze the Discord card globally (pause [30m|2h], default 1h)'],
+    ['resume',    'Lift a pause early'],
+    ['export',    'Dump the aggregate as JSON, or daily rows as CSV (--csv --out)'],
     ['private',   'Mark the current directory as private (hide from Discord)'],
     ['public',    'Un-mark the current directory'],
     ['privacy',   'Show resolved visibility for the current directory'],
@@ -1483,6 +1591,10 @@ const packagedDefault = IS_PACKAGED && !cmd;
       break;
     }
     case 'wrapped':   process.env.CLAUDE_RPC_OPEN_PATH = '/wrapped'; await import('./server/index.js'); break;
+    case 'pause':     doPause(process.argv.slice(3)); break;
+    case 'resume':
+    case 'unpause':   doResume(); break;
+    case 'export':    await doExport(process.argv.slice(3)); break;
     case 'private':   doPrivate(); break;
     case 'public':    doPublic(); break;
     case 'privacy':   doPrivacy(); break;
@@ -1579,8 +1691,11 @@ const packagedDefault = IS_PACKAGED && !cmd;
         // click with no args" install-and-start flow.
         overview();
       } else {
-        fail(`unknown command: ${cmd}`,
-          { hint: 'run `claude-rpc --help` for the full list', code: EX_USER_ERROR });
+        // Version in the error line is deliberate: the #1 cause of "unknown
+        // command" in the wild is a stale global install resolving instead of
+        // the version the user read the docs for. Make the skew visible.
+        fail(`unknown command: ${cmd}  (claude-rpc v${VERSION})`,
+          { hint: 'run `claude-rpc --help` for the full list — if this command should exist, update first: npm install -g claude-rpc@latest', code: EX_USER_ERROR });
       }
     }
   }

package/src/daemon.js

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import { writeFileSync, existsSync, unlinkSync, watch, appendFileSync, mkdirSync, statSync, renameSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { basename, dirname } from 'node:path';
 import { Client } from './discord-ipc.js';
 import { readState } from './state.js';
 import { buildVars, fillTemplate, framePasses, applyIdle, applyShipped, applyTrigger } from './format.js';
 import { scan, readAggregate, findLiveSessions, readSessionTokens } from './scanner.js';
 import { detectGithubUrl } from './git.js';
 import { applyPrivacy } from './privacy.js';
+import { pauseUntil } from './pause.js';
 import { loadConfig } from './config.js';
 import { migrateConfig } from './install.js';
 import { desktopNotify, postWebhook, shouldWebhook, shouldNotify } from './notify.js';
 import { humanProject } from './format.js';
-import { CONFIG_PATH, STATE_PATH, PID_PATH, LOG_PATH, STATE_DIR, AGGREGATE_PATH } from './paths.js';
+import { CONFIG_PATH, STATE_PATH, PID_PATH, LOG_PATH, STATE_DIR, AGGREGATE_PATH, PAUSE_PATH } from './paths.js';
 
 if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
 
@@ -232,7 +233,8 @@ function buildActivity(opts = {}) {
   } else if (config.modelAssets && state.model && state.status !== 'stale') {
     const m = String(state.model).toLowerCase();
     let pick = null;
-    if (m.includes('opus'))   pick = config.modelAssets.opus;
+    if (m.includes('fable'))       pick = config.modelAssets.fable;
+    else if (m.includes('opus'))   pick = config.modelAssets.opus;
     else if (m.includes('sonnet')) pick = config.modelAssets.sonnet;
     else if (m.includes('haiku'))  pick = config.modelAssets.haiku;
     if (!pick) pick = config.modelAssets.default;
@@ -283,6 +285,16 @@ function buildActivity(opts = {}) {
       url: fillTemplate(b.url, vars),
     }));
   }
+
+  // Concurrent sessions render natively via Discord's party field — the card
+  // shows "(2 of 2)" with no template work. Only attached when more than one
+  // live session exists (a party of one is noise). Opt out: showPartySize:false.
+  const liveCount = (state.liveSessions || []).length;
+  if (config.showPartySize !== false && liveCount > 1) {
+    activity.partyId = 'claude-rpc';
+    activity.partySize = liveCount;
+    activity.partyMax = liveCount;
+  }
   return activity;
 }
 
@@ -327,7 +339,11 @@ async function pushPresence() {
 
     const hideWhenStale = config.hideWhenStale !== false;
     const privacyHidden = resolved._privacy?.visibility === 'hidden';
-    if ((resolved.status === 'stale' && hideWhenStale) || privacyHidden) {
+    // Global snooze (`claude-rpc pause`) — clears the card while the deadline
+    // is in the future. Re-checked every tick, so expiry resumes presence
+    // automatically (the 'cleared' stamp differs from the next frame's hash).
+    const pausedUntil = pauseUntil();
+    if ((resolved.status === 'stale' && hideWhenStale) || privacyHidden || pausedUntil) {
       const stamp = 'cleared';
       if (lastPayloadHash === stamp) return;
       lastPayloadHash = stamp;
@@ -335,7 +351,9 @@ async function pushPresence() {
       // elapsed timer rather than counting from a previous session.
       effectiveSessionStart = null;
       await client.user.clearActivity();
-      const reason = privacyHidden ? 'privacy=hidden in this project' : 'stale — Claude Code not running';
+      const reason = pausedUntil
+        ? `paused until ${new Date(pausedUntil).toLocaleTimeString()}`
+        : privacyHidden ? 'privacy=hidden in this project' : 'stale — Claude Code not running';
       log(`Presence cleared (${reason})`);
       return;
     }
@@ -414,61 +432,45 @@ function scheduleReconnect(reason = 'reconnect') {
 }
 
 function watchFiles() {
-  let stateTimer = null;
-  if (existsSync(STATE_PATH)) {
-    watch(STATE_PATH, () => {
-      clearTimeout(stateTimer);
-      stateTimer = setTimeout(pushPresence, 250);
-    });
-  }
-  // config.json may not exist yet on a fresh install where the daemon starts
-  // before `setup` seeds it (or if the user deletes it). watch() on a missing
-  // path throws ENOENT synchronously, which would crash startup — exactly the
-  // failure loadConfig was hardened against. Guard it, and if the file is
-  // absent, poll for its creation and attach the watcher once it lands.
-  const watchConfig = () => {
-    watch(CONFIG_PATH, () => {
-      log('Config changed — reloading');
-      config = loadConfigWithLog();
-      lastPayloadHash = '';
-      pushPresence();
-    });
-  };
-  if (existsSync(CONFIG_PATH)) {
-    watchConfig();
-  } else {
-    let configTimer = null;
-    const dir = dirname(CONFIG_PATH);
-    if (existsSync(dir)) {
-      const dirWatcher = watch(dir, () => {
-        if (!existsSync(CONFIG_PATH)) return;
-        clearTimeout(configTimer);
-        configTimer = setTimeout(() => {
-          try {
-            dirWatcher.close();
-          } catch {
-            /* already closed */
-          }
-          log('Config appeared — reloading');
-          config = loadConfigWithLog();
-          lastPayloadHash = '';
-          watchConfig();
-          pushPresence();
-        }, 250);
+  // Watch DIRECTORIES, not files. Every watched file here is written via
+  // tmp+rename (state.js, the scanner, the settings GUI), and inotify tracks
+  // the inode — a watcher attached to the file path goes silent after the
+  // first rename. A directory watcher survives renames AND works when the
+  // file doesn't exist yet (fresh install where the daemon starts before the
+  // first hook / before `setup` seeds config.json). Events are filtered by
+  // filename where the platform reports one; the rare null-filename event
+  // just costs one debounced no-op push (the payload hash dedupes it).
+  const watchDirFor = (targetPath, label, onChange, extraNames = []) => {
+    const dir = dirname(targetPath);
+    const names = new Set([basename(targetPath), ...extraNames]);
+    if (!existsSync(dir)) return;
+    let timer = null;
+    try {
+      watch(dir, (event, filename) => {
+        if (filename && !names.has(filename)) return;
+        clearTimeout(timer);
+        timer = setTimeout(onChange, 250);
       });
+    } catch (e) {
+      log(`watch failed for ${label} (poll fallback still covers it):`, e.message);
     }
-  }
-  if (existsSync(AGGREGATE_PATH)) {
-    let aggTimer = null;
-    watch(AGGREGATE_PATH, () => {
-      clearTimeout(aggTimer);
-      aggTimer = setTimeout(() => {
-        aggregate = readAggregate() || aggregate;
-        lastPayloadHash = '';
-        pushPresence();
-      }, 250);
-    });
-  }
+  };
+
+  // state.json and pause.json share STATE_DIR — one watcher serves both, so
+  // a `claude-rpc pause` clears the card on the next debounce, not the next
+  // 4s tick. The filename filter keeps daemon.log appends from triggering it.
+  watchDirFor(STATE_PATH, 'state', pushPresence, [basename(PAUSE_PATH)]);
+  watchDirFor(CONFIG_PATH, 'config', () => {
+    log('Config changed — reloading');
+    config = loadConfigWithLog();
+    lastPayloadHash = '';
+    pushPresence();
+  });
+  watchDirFor(AGGREGATE_PATH, 'aggregate', () => {
+    aggregate = readAggregate() || aggregate;
+    lastPayloadHash = '';
+    pushPresence();
+  });
 
   // Mtime-poll fallback. fs.watch on Windows occasionally drops events
   // when the writer uses an atomic-rename pattern (which `state.js` does

package/src/discord-ipc.js

@@ -133,6 +133,16 @@ export function formatActivity(activity = {}, pid) {
     if (activity.smallImageText) a.assets.small_text = activity.smallImageText;
   }
 
+  // Party — renders natively as "(2 of 4)" on the card. Same field names
+  // @xhayper used (partyId / partySize / partyMax); size requires both ends.
+  if (activity.partyId || (activity.partySize != null && activity.partyMax != null)) {
+    a.party = {};
+    if (activity.partyId) a.party.id = activity.partyId;
+    if (activity.partySize != null && activity.partyMax != null) {
+      a.party.size = [activity.partySize, activity.partyMax];
+    }
+  }
+
   if (activity.buttons?.length) a.buttons = activity.buttons;
 
   return { pid: pid ?? process?.pid ?? 0, activity: a };

package/src/format.js

@@ -81,11 +81,17 @@ function plural(n, sing, plur) {
   return `${fmtNum(n)} ${word}`;
 }
 
-// claude-opus-4-7 → Opus 4.7 · claude-sonnet-4-6-20250514 → Sonnet 4.6
+// claude-opus-4-7 → Opus 4.7 · claude-sonnet-4-6-20250514 → Sonnet 4.6 ·
+// claude-fable-5 → Fable 5 (no minor version). Version digits are capped at
+// two so a trailing date stamp ("…-5-20260301") can't be read as a minor.
 function humanModel(id) {
   if (!id || typeof id !== 'string') return 'Claude';
-  const m = id.match(/(opus|sonnet|haiku)[^\d]*(\d+)[-.](\d+)/i);
-  if (m) return `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()} ${m[2]}.${m[3]}`;
+  const m = id.match(/(opus|sonnet|haiku|fable)[^\d]*(\d{1,2})(?!\d)(?:[-.](\d{1,2})(?!\d))?/i);
+  if (m) {
+    const name = `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()}`;
+    return m[3] ? `${name} ${m[2]}.${m[3]}` : `${name} ${m[2]}`;
+  }
+  if (/fable/i.test(id)) return 'Fable';
   if (/opus/i.test(id)) return 'Opus';
   if (/sonnet/i.test(id)) return 'Sonnet';
   if (/haiku/i.test(id)) return 'Haiku';
@@ -841,13 +847,11 @@ export function applyIdle(state, cfg = {}) {
   // Local state is fresh.
   if (state.status === 'idle') {
     // No transcripts being written anywhere on disk — Claude Code may have
-    // closed without a SessionEnd hook (force-quit, OS sleep, crash). With
-    // idleWhenOpen (default) we keep showing 'idle': the session hasn't been
-    // authoritatively closed and the staleMs dormancy backstop above will
-    // still clear it if Claude is truly gone. Set idleWhenOpen:false to go
-    // straight to stale here — clears Discord ~90-120s after the last write,
-    // at the cost of dropping the card whenever you pause for a couple
-    // minutes with the session still open.
+    // closed without a SessionEnd hook (force-quit, OS sleep, crash). By
+    // default (idleWhenOpen=false) go straight to stale so a closed terminal
+    // clears the card within ~90-120s of the last write. Opt in with
+    // idleWhenOpen:true to keep showing 'idle' through short pauses; the
+    // staleMs dormancy backstop above still clears it if Claude is truly gone.
     if (liveSessions.length === 0 && !idleWhenOpen) return staleWipe(state);
     return state;
   }
@@ -855,10 +859,10 @@ export function applyIdle(state, cfg = {}) {
     // Hook channel is quiet, but a live transcript was modified recently?
     // Keep "working" instead of dropping to "idle".
     if (liveAgeMs <= idleMs) return state;
-    // Hooks quiet AND no live transcripts. With idleWhenOpen (default) the
+    // Hooks quiet AND no live transcripts. By default (idleWhenOpen=false)
+    // treat Claude as gone and go stale now. With idleWhenOpen:true the
     // session is treated as open-but-paused and drops to idle; the staleMs
-    // backstop above clears it if Claude is actually gone. Set
-    // idleWhenOpen:false to go straight to stale here (old behavior).
+    // backstop above clears it later if Claude actually exited.
     if (liveSessions.length === 0 && !idleWhenOpen) return staleWipe(state);
     // Going idle — wipe "current activity" indicators so rotation frames
     // gated on filesEdited / currentFile / currentTool stop showing stale

package/src/git.js

@@ -7,8 +7,8 @@
 // The detached-HEAD case (HEAD contains a raw SHA, not `ref: refs/heads/...`)
 // returns an empty branch — template `requires` will hide the branch frame.
 
-import { readFileSync, existsSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { readFileSync, statSync } from 'node:fs';
+import { basename, join, isAbsolute } from 'node:path';
 
 const TTL_MS = 5 * 60 * 1000;
 const cache = new Map(); // cwd → { ts, github, branch, repo }
@@ -17,6 +17,35 @@ function fresh(entry) {
   return entry && (Date.now() - entry.ts) < TTL_MS;
 }
 
+// Resolve a cwd's `.git` to the directory that actually holds HEAD etc.
+// Usually `.git` IS that directory, but in a linked worktree or a submodule
+// it's a one-line FILE — "gitdir: <path>" — pointing at the real location
+// (e.g. <main>/.git/worktrees/<name>). Treating the file as a directory made
+// every read below fail silently, so worktrees lost branch/repo/GitHub-button
+// detection entirely.
+function resolveGitDir(cwd) {
+  const dotGit = join(cwd, '.git');
+  let st;
+  try { st = statSync(dotGit); } catch { return null; }
+  if (st.isDirectory()) return dotGit;
+  try {
+    const m = readFileSync(dotGit, 'utf8').match(/^gitdir:\s*(.+?)\s*$/m);
+    if (!m) return null;
+    return isAbsolute(m[1]) ? m[1] : join(cwd, m[1]);
+  } catch { return null; }
+}
+
+// The COMMON git dir — where `config` lives. For a linked worktree the
+// per-worktree gitdir holds a `commondir` file with a (usually relative)
+// path back to the main `.git`; everywhere else the gitdir is its own
+// common dir (main repos, submodules).
+function commonGitDir(gitDir) {
+  try {
+    const rel = readFileSync(join(gitDir, 'commondir'), 'utf8').trim();
+    return isAbsolute(rel) ? rel : join(gitDir, rel);
+  } catch { return gitDir; }
+}
+
 function readGitInfo(cwd) {
   const out = { github: null, branch: '', repo: '' };
   if (!cwd) return out;
@@ -25,12 +54,12 @@ function readGitInfo(cwd) {
   // find a github origin.
   out.repo = basename(cwd) || '';
 
-  const gitDir = join(cwd, '.git');
-  if (!existsSync(gitDir)) return out;
+  const gitDir = resolveGitDir(cwd);
+  if (!gitDir) return out;
 
   // origin URL → github URL + repo name.
   try {
-    const cfg = readFileSync(join(gitDir, 'config'), 'utf8');
+    const cfg = readFileSync(join(commonGitDir(gitDir), 'config'), 'utf8');
     const m = cfg.match(/\[remote\s+"origin"\][^[]*?url\s*=\s*([^\r\n]+)/i);
     if (m) {
       const raw = m[1].trim();
@@ -84,8 +113,11 @@ export function detectGitRepo(cwd)   { return lookup(cwd).repo; }
 // just made a new one.
 export function detectLastCommitSubject(cwd, max = 80) {
   if (!cwd) return '';
-  const gitDir = join(cwd, '.git');
-  if (!existsSync(gitDir)) return '';
+  // Follow a worktree/submodule `.git` file to the real gitdir —
+  // COMMIT_EDITMSG and logs/HEAD are per-worktree, so the resolved
+  // dir (not the common dir) is the right place for both.
+  const gitDir = resolveGitDir(cwd);
+  if (!gitDir) return '';
 
   // COMMIT_EDITMSG: the editor buffer from the most recent `git commit`.
   // First non-blank, non-comment line is the subject.

package/src/hook.js

@@ -56,8 +56,17 @@ function shipKindForSegment(seg) {
 // leading command is git/gh — so a quoted mention ("git push later" inside an
 // echo or a commit message) no longer false-fires. Tolerates env prefixes,
 // sudo/time, chained commands, and git global flags.
+//
+// Quoted spans are blanked BEFORE splitting: separators inside quotes
+// (`echo "run git push && rejoice"`) used to create a fake segment whose
+// leading command was git. The real command's own quoted args (`git commit
+// -m "msg"`) classify the same with or without the message text, so blanking
+// is lossless for detection. An unbalanced quote leaves the string untouched.
 export function classifyShip(cmd) {
-  const segments = String(cmd || '').split(/[;&|\n]+/);
+  const blanked = String(cmd || '')
+    .replace(/'[^']*'/g, ' ')
+    .replace(/"(?:\\.|[^"\\])*"/g, ' ');
+  const segments = blanked.split(/[;&|\n]+/);
   const found = new Set();
   for (const seg of segments) {
     const k = shipKindForSegment(seg);

package/src/install.js

@@ -425,7 +425,31 @@ function promoteNpxToGlobal() {
   return !r.error && r.status === 0;
 }
 
+// Best-effort registry check. npx serves stale cached copies without
+// warning, and promoteNpxToGlobal pins @VERSION — so a stale npx cache
+// would otherwise propagate itself into the global install silently, and
+// the user's next `claude-rpc profile …` hits "unknown command" with no
+// clue why. Warn loudly up front; never block setup on it (offline is fine).
+function warnIfStale() {
+  try {
+    const r = spawnSync('npm', ['view', 'claude-rpc', 'version'], {
+      encoding: 'utf8', timeout: 4000,
+      shell: process.platform === 'win32',   // npm is npm.cmd on Windows
+    });
+    const latest = (r.stdout || '').trim();
+    if (!latest || latest === VERSION) return;
+    const num = (v) => v.split('.').map((n) => parseInt(n, 10) || 0);
+    const [l, v] = [num(latest), num(VERSION)];
+    const newer = l[0] !== v[0] ? l[0] > v[0] : l[1] !== v[1] ? l[1] > v[1] : l[2] > v[2];
+    if (newer) {
+      console.warn(`  ! you're running v${VERSION} but v${latest} is published — npx may have served a stale cache.`);
+      console.warn(`    for the newest version, stop here and re-run:  npx claude-rpc@latest setup`);
+    }
+  } catch { /* offline or npm missing — a version check must never block setup */ }
+}
+
 export async function install({ exePath, withStartup = true } = {}) {
+  warnIfStale();
   if (IS_NPX) {
     if (!promoteNpxToGlobal()) {
       console.error('\n  ✗ Global install failed. Run this once, then you\'re set:');

package/src/paths.js

@@ -70,6 +70,9 @@ export const STATE_DIR = join(tmpdir(), 'claude-rpc');
 export const STATE_PATH = join(STATE_DIR, 'state.json');
 export const PID_PATH = join(STATE_DIR, 'daemon.pid');
 export const LOG_PATH = join(STATE_DIR, 'daemon.log');
+// Presence snooze marker (`claude-rpc pause`). Lives in the tmp state dir on
+// purpose — a reboot clearing a forgotten pause is the right failure mode.
+export const PAUSE_PATH = join(STATE_DIR, 'pause.json');
 export const DATA_DIR = join(homedir(), '.claude-rpc');
 export const AGGREGATE_PATH = join(DATA_DIR, 'aggregate.json');
 export const SCAN_CACHE_PATH = join(DATA_DIR, 'scan-cache.json');

package/src/pause.js

@@ -0,0 +1,56 @@
+// Global presence snooze — `claude-rpc pause [30m|2h]` / `claude-rpc resume`.
+//
+// Privacy controls are per-cwd; this is the orthogonal "I'm screen-sharing
+// for an hour" switch. The CLI writes a tiny { until } marker and the daemon
+// checks it on every push tick, clearing the Discord card while the deadline
+// is in the future. Expiry is passive: once `until` passes, the next tick
+// resumes presence — no timer, no daemon restart, nothing to clean up.
+
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from 'node:fs';
+import { PAUSE_PATH, STATE_DIR } from './paths.js';
+
+const DEFAULT_PAUSE_MS = 60 * 60 * 1000; // bare `pause` = 1 hour
+
+// Parse a human duration: "30m", "2h", "1h30m", or a bare number (minutes).
+// Returns milliseconds, or null when the input doesn't parse / is <= 0.
+export function parseDuration(raw) {
+  if (raw == null || raw === '') return DEFAULT_PAUSE_MS;
+  const s = String(raw).trim().toLowerCase();
+  if (/^\d+$/.test(s)) {
+    const min = Number(s);
+    return min > 0 ? min * 60_000 : null;
+  }
+  const m = s.match(/^(?:(\d+)h)?(?:(\d+)m)?$/);
+  if (!m || (!m[1] && !m[2])) return null;
+  const ms = (Number(m[1] || 0) * 60 + Number(m[2] || 0)) * 60_000;
+  return ms > 0 ? ms : null;
+}
+
+export function setPause(ms, { path = PAUSE_PATH, now = Date.now() } = {}) {
+  const until = now + ms;
+  if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
+  writeFileSync(path, JSON.stringify({ until }));
+  return until;
+}
+
+export function clearPause({ path = PAUSE_PATH } = {}) {
+  try {
+    if (existsSync(path)) {
+      unlinkSync(path);
+      return true;
+    }
+  } catch { /* already gone, or unwritable tmp — either way not paused anymore */ }
+  return false;
+}
+
+// Epoch ms the pause runs until, or 0 when not paused (missing file,
+// unreadable JSON, or a deadline already in the past).
+export function pauseUntil({ path = PAUSE_PATH, now = Date.now() } = {}) {
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    const until = Number(raw?.until);
+    return Number.isFinite(until) && until > now ? until : 0;
+  } catch {
+    return 0;
+  }
+}

package/src/pricing.js

@@ -6,11 +6,16 @@
 // To customize: edit this file and run `claude-rpc rescan`.
 
 const PRICING = {
-  // Opus 4.x family
+  // Fable family — Anthropic's frontier tier above Opus.
+  'fable-5': { input: 10.00, output: 50.00, cacheRead: 1.00, cacheWrite: 12.50 },
+
+  // Opus 4.x family. 4.0/4.1 launched at $15/$75; the list price dropped to
+  // $5/$25 with Opus 4.5 and has held through 4.8.
   'opus-4':   { input: 15.00, output: 75.00, cacheRead: 1.50, cacheWrite: 18.75 },
-  'opus-4-5': { input: 15.00, output: 75.00, cacheRead: 1.50, cacheWrite: 18.75 },
-  'opus-4-6': { input: 15.00, output: 75.00, cacheRead: 1.50, cacheWrite: 18.75 },
-  'opus-4-7': { input: 15.00, output: 75.00, cacheRead: 1.50, cacheWrite: 18.75 },
+  'opus-4-5': { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
+  'opus-4-6': { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
+  'opus-4-7': { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
+  'opus-4-8': { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
 
   // Sonnet 4.x family
   'sonnet-4':   { input: 3.00, output: 15.00, cacheRead: 0.30, cacheWrite: 3.75 },
@@ -21,15 +26,17 @@ const PRICING = {
   'haiku-4':   { input: 1.00, output: 5.00, cacheRead: 0.10, cacheWrite: 1.25 },
   'haiku-4-5': { input: 1.00, output: 5.00, cacheRead: 0.10, cacheWrite: 1.25 },
 
-  // Generic fallbacks by tier.
-  'opus':   { input: 15.00, output: 75.00, cacheRead: 1.50, cacheWrite: 18.75 },
+  // Generic fallbacks by tier. Opus uses the current-generation rates —
+  // unknown/future opus ids are far more likely to be 4.5+ than 4.1-era.
+  'fable':  { input: 10.00, output: 50.00, cacheRead: 1.00, cacheWrite: 12.50 },
+  'opus':   { input: 5.00,  output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
   'sonnet': { input: 3.00,  output: 15.00, cacheRead: 0.30, cacheWrite: 3.75 },
   'haiku':  { input: 1.00,  output: 5.00,  cacheRead: 0.10, cacheWrite: 1.25 },
 };
 
 const DEFAULT = PRICING.sonnet;
 
-const TIERS = new Set(['opus', 'sonnet', 'haiku']);
+const TIERS = new Set(['opus', 'sonnet', 'haiku', 'fable']);
 
 // Map a model id like "claude-opus-4-7-20251101" to a pricing key.
 //

package/src/scanner.js

@@ -208,11 +208,8 @@ function readHead(path, maxBytes = 65536) {
   }
 }
 
-// Parse a single transcript JSONL into a per-file summary.
-export function parseTranscript(filePath) {
-  const raw = readFileSync(filePath, 'utf8');
-  const lines = iterLines(raw);
-  const summary = {
+function blankTranscriptSummary() {
+  return {
     sessionId: null,
     project: null,
     cwd: null,
@@ -244,18 +241,31 @@ export function parseTranscript(filePath) {
     modelsUsed: {},       // raw model id → assistant turns
     byModel: {},          // pricing key → { turns, tokens, cost } (model split)
   };
-  const fileSet = new Set();
-  // Claude Code splits one assistant message (a single message.id) across
-  // several JSONL lines — one per content block (thinking / text / tool_use)
-  // — and repeats the SAME `usage` object on every line. Token/cost/turn
-  // counting must happen once per message.id, or a 3-block turn is counted 3×
-  // (this was the source of wildly inflated token + cost totals). Content
-  // blocks themselves are distinct per line, so those stay counted per line.
-  const usageCountedIds = new Set();
+}
+
+// Sliding window for assistant message-id dedup (see parseChunkInto). Blocks
+// of one message land on ADJACENT lines, so a small window catches every real
+// split while staying cheap to persist in the scan cache.
+const RECENT_IDS_MAX = 200;
+
+// Parse complete JSONL lines into `summary`, mutating it in place. `pstate`
+// carries the cross-chunk bookkeeping that incremental (append-only) parsing
+// needs to behave exactly like a full parse:
+//   recentIds — recently counted assistant message.ids. Claude Code splits
+//               one assistant message (a single message.id) across several
+//               JSONL lines — one per content block — repeating the SAME
+//               `usage` object on every line. Token/cost/turn counting must
+//               happen once per message.id, or a 3-block turn counts 3×.
+//               Content blocks themselves are distinct per line, so those
+//               stay counted per line.
+//   lastRec   — the previous chunk's final timestamped record, so the
+//               active-time gap across a chunk boundary still accrues.
+function parseChunkInto(text, summary, pstate) {
+  const fileSet = new Set(summary.files || []);
   // Records in their original order, retaining timestamps for per-day bucketing.
   const records = [];
 
-  for (const line of lines) {
+  for (const line of iterLines(text)) {
     if (!line) continue;
     const r = safeJson(line);
     if (!r) continue;
@@ -277,10 +287,13 @@ export function parseTranscript(filePath) {
       const turnModel = r.message?.model || summary.model;
       const u = r.message?.usage;
       // Count usage/cost/turn only the first time we see this message.id (see
-      // usageCountedIds note above). No id (rare/legacy) → count it.
+      // the pstate.recentIds note above). No id (rare/legacy) → count it.
       const msgId = r.message?.id;
-      const firstSeen = !msgId || !usageCountedIds.has(msgId);
-      if (msgId) usageCountedIds.add(msgId);
+      const firstSeen = !msgId || !pstate.recentIds.includes(msgId);
+      if (msgId && firstSeen) {
+        pstate.recentIds.push(msgId);
+        if (pstate.recentIds.length > RECENT_IDS_MAX) pstate.recentIds.shift();
+      }
       // Per-model split bucket, keyed by pricing key so cost/tokens/turns align.
       const mkey = turnModel ? pricingKeyFor(turnModel) : null;
       const mb = mkey ? (summary.byModel[mkey] ||= { turns: 0, tokens: 0, cost: 0 }) : null;
@@ -373,24 +386,84 @@ export function parseTranscript(filePath) {
   summary.files = Array.from(fileSet);
   if (records.length) {
     records.sort((a, b) => a.ts - b.ts);
-    summary.firstTs = records[0].ts;
-    summary.lastTs = records[records.length - 1].ts;
-    let active = 0;
-    for (let i = 1; i < records.length; i++) {
-      const prev = records[i - 1];
-      const gap = records[i].ts - prev.ts;
-      if (gap > 0 && gap < ACTIVE_GAP_CAP_MS) {
-        active += gap;
-        // Charge the gap's active time to the day/week/hour of the earlier record.
-        if (prev.day)  (summary.byDay[prev.day]   ||= blankDay()).activeMs += gap;
-        if (prev.week) (summary.byWeek[prev.week] ||= blankDay()).activeMs += gap;
-        if (prev.hour !== null && prev.hour !== undefined) {
-          (summary.byHour[prev.hour] ||= blankDay()).activeMs += gap;
+    if (!summary.firstTs || records[0].ts < summary.firstTs) summary.firstTs = records[0].ts;
+    const chunkLast = records[records.length - 1].ts;
+    if (!summary.lastTs || chunkLast > summary.lastTs) summary.lastTs = chunkLast;
+    // Charge each gap's active time to the day/week/hour of the earlier
+    // record. The first record's "earlier" is the previous chunk's last.
+    let prev = pstate.lastRec;
+    for (const rec of records) {
+      if (prev) {
+        const gap = rec.ts - prev.ts;
+        if (gap > 0 && gap < ACTIVE_GAP_CAP_MS) {
+          summary.activeMs += gap;
+          if (prev.day)  (summary.byDay[prev.day]   ||= blankDay()).activeMs += gap;
+          if (prev.week) (summary.byWeek[prev.week] ||= blankDay()).activeMs += gap;
+          if (prev.hour !== null && prev.hour !== undefined) {
+            (summary.byHour[prev.hour] ||= blankDay()).activeMs += gap;
+          }
         }
       }
+      prev = rec;
+    }
+    pstate.lastRec = prev;
+  }
+}
+
+// Parse a single transcript JSONL into a per-file summary.
+//
+// With a prior cache entry (`prev`), parses only the bytes appended since the
+// last scan — transcripts are append-only, and an active session's multi-MB
+// file otherwise gets fully re-read every rescan tick. The entry carries
+// `_offset` (bytes consumed through the last complete line) and `_parse`
+// (the cross-chunk bookkeeping for parseChunkInto); anything that breaks the
+// append assumption (file shrank, entry predates these fields, `_offset`
+// null) falls back to a from-scratch parse.
+export function parseTranscript(filePath, prev = null) {
+  const st = statSync(filePath);
+  const canAppend = !!(prev && prev._parse && typeof prev._offset === 'number'
+    && st.size >= prev._offset);
+  const summary = canAppend ? structuredClone(prev) : blankTranscriptSummary();
+  const pstate = canAppend
+    ? { recentIds: (prev._parse.recentIds || []).slice(), lastRec: prev._parse.lastRec || null }
+    : { recentIds: [], lastRec: null };
+  const startOffset = canAppend ? prev._offset : 0;
+
+  let text = '';
+  const len = st.size - startOffset;
+  if (len > 0) {
+    let fd;
+    try {
+      fd = openSync(filePath, 'r');
+      const buf = Buffer.allocUnsafe(len);
+      const n = readSync(fd, buf, 0, len, startOffset);
+      text = buf.toString('utf8', 0, n);
+    } finally {
+      if (fd !== undefined) {
+        try { closeSync(fd); } catch { /* already closed */ }
+      }
     }
-    summary.activeMs = active;
   }
+
+  // Consume through the last newline; \n is single-byte ASCII so the boundary
+  // is exact even with multi-byte content in the lines.
+  const lastNl = text.lastIndexOf('\n');
+  const complete = lastNl === -1 ? '' : text.slice(0, lastNl + 1);
+  const remainder = lastNl === -1 ? text : text.slice(lastNl + 1);
+  parseChunkInto(complete, summary, pstate);
+  let offset = startOffset + Buffer.byteLength(complete, 'utf8');
+  if (remainder.trim()) {
+    if (safeJson(remainder) !== null) {
+      // A complete final line that just isn't newline-terminated (fully
+      // written file). Count it, but mark the entry non-appendable — if more
+      // bytes ever land we can't tell whether they extend this line.
+      parseChunkInto(remainder, summary, pstate);
+      offset = null;
+    }
+    // else: a partial line mid-write — leave it for the next (append) read.
+  }
+  summary._offset = offset;
+  summary._parse = { recentIds: pstate.recentIds, lastRec: pstate.lastRec };
   return summary;
 }
 
@@ -426,12 +499,25 @@ function isSubagentPath(p) {
   return /[\\/]subagents[\\/]/.test(p);
 }
 
+// The daemon runs for weeks; these per-transcript caches would otherwise grow
+// one entry per file ever observed. LRU with a generous cap — the hot set is
+// the handful of live sessions, so an eviction just costs one re-read.
+const CACHE_MAX_ENTRIES = 512;
+function lruTouch(map, key, value) {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  if (map.size > CACHE_MAX_ENTRIES) map.delete(map.keys().next().value);
+}
+
 // Pull the real cwd from the head of a transcript so live sessions can show
 // "my-app" instead of the slugified directory name.
 const cwdCache = new Map(); // path → { mtime, cwd }
 function readTranscriptCwd(path, mtimeMs) {
   const cached = cwdCache.get(path);
-  if (cached && cached.mtime === mtimeMs) return cached.cwd;
+  if (cached && cached.mtime === mtimeMs) {
+    lruTouch(cwdCache, path, cached);
+    return cached.cwd;
+  }
   let cwd = null;
   try {
     let seen = 0;
@@ -442,7 +528,7 @@ function readTranscriptCwd(path, mtimeMs) {
       if (r?.cwd) { cwd = r.cwd; break; }
     }
   } catch { /* transcript head unreadable — cwd stays null, project name falls back to slug */ }
-  cwdCache.set(path, { mtime: mtimeMs, cwd });
+  lruTouch(cwdCache, path, { mtime: mtimeMs, cwd });
   return cwd;
 }
 
@@ -480,7 +566,10 @@ export function readSessionTokens(path) {
   let st;
   try { st = statSync(path); } catch { return null; }
   const cached = sessionTokenCache.get(path);
-  if (cached && cached.mtime === st.mtimeMs) return cached.tokens;
+  if (cached && cached.mtime === st.mtimeMs) {
+    lruTouch(sessionTokenCache, path, cached);
+    return cached.tokens;
+  }
 
   // Transcripts are append-only JSONL. If the file only grew since the last
   // read, parse just the appended tail from the cached byte offset instead of
@@ -519,7 +608,7 @@ export function readSessionTokens(path) {
     }
   }
 
-  sessionTokenCache.set(path, { mtime: st.mtimeMs, size: st.size, offset: newOffset, tokens });
+  lruTouch(sessionTokenCache, path, { mtime: st.mtimeMs, size: st.size, offset: newOffset, tokens });
   return tokens;
 }
 
@@ -941,7 +1030,9 @@ export function scan({ projectsDir, projectsDirs, onProgress, force = false, ext
       continue;
     }
     try {
-      const summary = parseTranscript(fp);
+      // Hand the prior entry to parseTranscript so an active session's
+      // growing transcript parses only its appended tail (force = from scratch).
+      const summary = parseTranscript(fp, force ? null : cache.files[fp]);
       summary._sig = sig;
       summary.isSubagent = isSubagentPath(fp);
       cache.files[fp] = summary;
@@ -965,7 +1056,21 @@ export function scan({ projectsDir, projectsDirs, onProgress, force = false, ext
       removed += 1;
     }
   }
-  writeCache(cache);
+  const changed = scanned > 0 || removed > 0;
+  if (changed) {
+    writeCache(cache);
+  } else {
+    // Nothing parsed, nothing removed — the cache on disk is byte-identical,
+    // so skip rewriting it (it can be tens of MB) AND skip the aggregate
+    // recompute, UNLESS the local day has rolled since the aggregate was
+    // generated: streak / daysSinceFirst / hotspot-aging are derived from
+    // "today" and go stale at midnight even with no new data.
+    const existing = readAggregate();
+    if (existing && existing._v === CACHE_VERSION
+        && dayKey(existing.generatedAt || 0) === dayKey(Date.now())) {
+      return { aggregate: existing, scanned, skipped, removed, total: transcripts.length, dirs };
+    }
+  }
   const aggregate = aggregateFrom(cache);
   writeAggregate(aggregate);
   return { aggregate, scanned, skipped, removed, total: transcripts.length, dirs };

package/src/server/index.js

@@ -30,6 +30,10 @@ function parseUrl(rawUrl) {
   return { path: url.pathname, query: Object.fromEntries(url.searchParams) };
 }
 
+function safeDecode(s) {
+  try { return decodeURIComponent(s); } catch { return null; }
+}
+
 // Loopback-only Host allowlist. Binding to 127.0.0.1 blocks the LAN, but not
 // DNS rebinding: a malicious page can point its own hostname at 127.0.0.1 and
 // become "same-origin" with this server, then read /api/export.json. Rejecting
@@ -64,7 +68,8 @@ const server = createServer((req, res) => {
   // Project drilldown. Path-prefix dispatch (the project name is in the
   // URL itself, not in a query string).
   if (req.method === 'GET' && path.startsWith('/api/project/')) {
-    const name = decodeURIComponent(path.slice('/api/project/'.length));
+    const name = safeDecode(path.slice('/api/project/'.length));
+    if (name === null) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: 'bad request' })); return; }
     const result = projectDrilldown(name);
     res.writeHead(result ? 200 : 404, JSON_HEADERS);
     res.end(JSON.stringify(result || { error: 'not found' }));
@@ -73,7 +78,8 @@ const server = createServer((req, res) => {
 
   // Day detail. Same pattern — day key in the URL path.
   if (req.method === 'GET' && path.startsWith('/api/day/')) {
-    const day = decodeURIComponent(path.slice('/api/day/'.length));
+    const day = safeDecode(path.slice('/api/day/'.length));
+    if (day === null) { res.writeHead(400, JSON_HEADERS).end(JSON.stringify({ error: 'bad request' })); return; }
     const result = dayDetail(day);
     res.writeHead(result ? 200 : 404, JSON_HEADERS);
     res.end(JSON.stringify(result || { error: 'not found' }));

package/src/server/sse.js

@@ -4,6 +4,7 @@
 // shared client set.
 
 import { watch } from 'node:fs';
+import { dirname, basename } from 'node:path';
 import { STATE_PATH, AGGREGATE_PATH } from '../paths.js';
 
 export const sseClients = new Set();
@@ -15,18 +16,31 @@ export function broadcast(payload) {
   }
 }
 
-export function watchSources() {
-  let stTimer = null, agTimer = null;
+// Watch a file that is updated via atomic rename (write-tmp + renameSync).
+// Watching the file path directly binds to the inode at watch-time — on
+// Linux that inode is replaced by the first rename, so the watcher fires
+// once then goes permanently silent. Watching the parent directory avoids
+// this: directory inodes are stable across entry renames.
+export function watchFile(filePath, callback) {
+  const dir = dirname(filePath);
+  const name = basename(filePath);
   try {
-    watch(STATE_PATH, () => {
-      clearTimeout(stTimer);
-      stTimer = setTimeout(() => broadcast({ type: 'state' }), 200);
+    return watch(dir, (_, filename) => {
+      if (!filename || filename === name) callback();
     });
-  } catch { /* state file not on disk yet — dashboard still works, just no SSE state events until daemon writes one */ }
-  try {
-    watch(AGGREGATE_PATH, () => {
-      clearTimeout(agTimer);
-      agTimer = setTimeout(() => broadcast({ type: 'aggregate' }), 200);
-    });
-  } catch { /* aggregate not on disk yet — dashboard renders empty stats until first scan completes */ }
+  } catch {
+    return null;
+  }
+}
+
+export function watchSources() {
+  let stTimer = null, agTimer = null;
+  watchFile(STATE_PATH, () => {
+    clearTimeout(stTimer);
+    stTimer = setTimeout(() => broadcast({ type: 'state' }), 200);
+  });
+  watchFile(AGGREGATE_PATH, () => {
+    clearTimeout(agTimer);
+    agTimer = setTimeout(() => broadcast({ type: 'aggregate' }), 200);
+  });
 }

package/src/ui.js

@@ -72,6 +72,16 @@ export function fail(label, { hint = 'run `claude-rpc doctor` for a full diagnos
   process.exit(code);
 }
 
+// Return the last n lines of a log file's raw text, trimming the trailing
+// empty element that split('\n') produces when the file ends with a newline.
+// When the file lacks a trailing newline the last element is the last real
+// line — the old raw.slice(-31,-1) pattern silently dropped it.
+export function tailLines(raw, n = 30) {
+  const lines = raw.split('\n');
+  if (lines.at(-1) === '') lines.pop();
+  return lines.slice(-n);
+}
+
 // Compatibility with doctor.js's existing API. Same `check(label, status,
 // detail, hint)` signature; doctor.js can switch its private copy out for
 // this without behavior change.

package/src/version.js

@@ -11,7 +11,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ROOT } from './paths.js';
 
-const BAKED = '0.13.6';
+const BAKED = '0.14.0';
 
 function readPkgVersion() {
   try {