claude-rpc 0.12.1 → 0.13.2

package/src/daemon.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { writeFileSync, existsSync, unlinkSync, watch, appendFileSync, mkdirSync, statSync, renameSync } from 'node:fs';
+import { dirname } from 'node:path';
 import { Client } from '@xhayper/discord-rpc';
 import { readState } from './state.js';
 import { buildVars, fillTemplate, framePasses, applyIdle, applyShipped, applyTrigger } from './format.js';
@@ -135,7 +136,13 @@ function pickFrames(p, status) {
   return { frames: [{ details: p.details, state: p.state }], largeImageTextTpl: null };
 }
 
-function buildActivity(opts = {}) {
+// Resolve the raw state file into the final presence state: idle/stale, shipped
+// and trigger overlays, live-session token enrichment, and the privacy verdict.
+// Run ONCE per tick (in pushPresence) and reused by buildActivity, so the
+// clear-vs-push decision and the rendered frame are guaranteed to agree —
+// previously this chain ran twice and only buildActivity applied the trigger
+// overlay, so the two could diverge.
+function resolvePresence(opts = {}) {
   let state = opts.state || readState();
   // Attach live sessions BEFORE applyIdle so the stale/idle decision can
   // see ongoing transcript activity, not just this daemon's hook state.
@@ -168,6 +175,13 @@ function buildActivity(opts = {}) {
   // visibility decision. Sets state._privacy so we can short-circuit to
   // clearActivity when visibility=hidden.
   state = applyPrivacy(state, config);
+  return state;
+}
+
+function buildActivity(opts = {}) {
+  // opts.resolved is an already-resolved state (the common path, from
+  // pushPresence). Fall back to resolving here for any standalone caller.
+  const state = opts.resolved || resolvePresence(opts);
 
   const vars = buildVars(state, config, opts.aggregate || aggregate);
   const p = config.presence || {};
@@ -302,17 +316,10 @@ function fireStatusSideEffects(resolved) {
 async function pushPresence() {
   if (!connected || !client?.user) return;
   try {
-    // Resolve state once so we can decide whether to push or clear.
-    // Mirrors buildActivity's first two lines — kept here so we don't
-    // have to round-trip through buildActivity just to learn the status.
-    let resolved = readState();
-    resolved.liveSessions = liveSessions;
-    resolved = applyIdle(resolved, config);
-    resolved = applyShipped(resolved, config);
-    // Privacy can convert any state into a "hidden" verdict — give it the
-    // same treatment as hideWhenStale: a single clearActivity, deduped via
-    // lastPayloadHash so we don't spam the IPC.
-    resolved = applyPrivacy(resolved, config);
+    // Resolve state ONCE — this same object decides clear-vs-push, drives the
+    // status side-effects, AND is rendered by buildActivity, so there's no way
+    // for the decision and the frame to disagree.
+    const resolved = resolvePresence();
 
     // Outbound side-effects on a status TRANSITION (fire once per change):
     // a desktop notification when Claude needs you, and an opt-in webhook POST.
@@ -333,7 +340,7 @@ async function pushPresence() {
       return;
     }
 
-    const activity = buildActivity({ state: resolved });
+    const activity = buildActivity({ resolved });
     const hash = JSON.stringify(activity);
     if (hash === lastPayloadHash) return;
     lastPayloadHash = hash;
@@ -412,12 +419,43 @@ function watchFiles() {
       stateTimer = setTimeout(pushPresence, 250);
     });
   }
-  watch(CONFIG_PATH, () => {
-    log('Config changed — reloading');
-    config = loadConfigWithLog();
-    lastPayloadHash = '';
-    pushPresence();
-  });
+  // 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);
+      });
+    }
+  }
   if (existsSync(AGGREGATE_PATH)) {
     let aggTimer = null;
     watch(AGGREGATE_PATH, () => {
@@ -573,18 +611,30 @@ setInterval(() => {
 // pile up locally until the next successful flush. Cadence is config-
 // driven (`community.flushIntervalMin`, default 30 min).
 async function runCommunityFlush() {
-  if (!config.community?.enabled) return;
+  // Both flushes self-guard (return {ok:false, reason:'disabled'} when their
+  // opt-in is off), so run whichever is enabled. The profile flush is
+  // independent of community totals but reuses the same anonymous instanceId.
+  if (!config.community?.enabled && !config.profile?.enabled) return;
   try {
-    const { flushCommunity } = await import('./community.js');
-    const result = await flushCommunity(config);
-    if (result.ok && result.delta) {
-      log(`community: flushed +${result.delta.sessions} sessions, +${result.delta.tokens} tokens`);
-    } else if (!result.ok && result.reason !== 'rate-limited' && result.reason !== 'no-delta') {
-      // Don't spam the log for routine "nothing to send" cases.
-      log(`community: ${result.reason}${result.error ? ' (' + result.error + ')' : ''}`);
+    const { flushCommunity, flushProfile } = await import('./community.js');
+    if (config.community?.enabled) {
+      const result = await flushCommunity(config);
+      if (result.ok && result.delta) {
+        log(`community: flushed +${result.delta.sessions} sessions, +${result.delta.tokens} tokens`);
+      } else if (!result.ok && result.reason !== 'rate-limited' && result.reason !== 'no-delta') {
+        log(`community: ${result.reason}${result.error ? ' (' + result.error + ')' : ''}`);
+      }
+    }
+    if (config.profile?.enabled) {
+      const pr = await flushProfile(config);
+      if (pr.ok && pr.delta) {
+        log(`profile: published @${config.profile.handle} (+${pr.delta.tokens} tokens)`);
+      } else if (!pr.ok && pr.reason !== 'rate-limited' && pr.reason !== 'disabled') {
+        log(`profile: ${pr.reason}${pr.error ? ' (' + pr.error + ')' : ''}`);
+      }
     }
   } catch (e) {
-    log('community flush threw:', e.message);
+    log('community/profile flush threw:', e.message);
   }
 }
 const communityFlushMs = Math.max(60_000, (config.community?.flushIntervalMin || 30) * 60 * 1000);

package/src/default-config.js

@@ -81,6 +81,14 @@ export const DEFAULT_CONFIG = {
     filename: "claude.svg",
     public: true,
   },
+  // Share nudges (v0.13). After you cross a genuine milestone (a streak
+  // record, a round number of sessions/hours), CLI commands like `today`
+  // print a single one-liner suggesting how to share it. Conservative by
+  // design — only the biggest NEW milestone, shown once. Set enabled:false
+  // to silence entirely. See src/nudge.js.
+  nudges: {
+    enabled: true,
+  },
   // Community totals. On by default for fresh installs — `setup` mints an
   // anonymous instanceId (UUID v4) into the freshly-seeded config so the
   // daemon starts batching deltas immediately. Existing users upgrading
@@ -96,6 +104,15 @@ export const DEFAULT_CONFIG = {
     endpoint: "https://claude-rpc-totals.claude-rpc.workers.dev",
     flushIntervalMin: 30,
   },
+  // Public leaderboard / profile (opt-in, off by default). When enabled with a
+  // handle, the daemon flush also publishes your display identity + validated
+  // usage deltas to the board. Link a GitHub user to earn the verified ✓.
+  profile: {
+    enabled: false,
+    handle: null,
+    displayName: null,
+    githubUser: null,
+  },
   showElapsed: true,
   activityType: 0,
   statusAssets: {
@@ -172,7 +189,12 @@ export const DEFAULT_CONFIG = {
     },
 
     buttons: [
-      { label: "Claude Code", url: "https://github.com/rar-file/claude-rpc" },
+      // The card others see in Discord is the project's main distribution
+      // surface — make the button a real call-to-action, not a bare repo link.
+      // ?ref=discord lets the landing page attribute installs that originate
+      // from a presence card. (When the cwd is a github repo the daemon also
+      // prepends a "View on GitHub →" button, so both can show.)
+      { label: "Get claude-rpc →", url: "https://claude-rpc.vercel.app/?ref=discord" },
     ],
   },
   statusIcons: {

package/src/doctor.js

@@ -20,15 +20,35 @@ import { c, check as uiCheck } from './ui.js';
 
 const counters = { pass: 0, fail: 0, warn: 0 };
 
+// Structured, machine-readable record of every non-passing check that has a
+// known repair, so `doctor --fix` can apply ONLY what's actually broken
+// (targeted) instead of blindly re-running the whole setup. Each fixable check
+// passes a `fixKind` — the CLI maps those to concrete repair actions.
+//   'setup'   — re-seed/migrate config + re-wire hooks (runInstall)
+//   'daemon'  — (re)start the daemon / clear a stale pid
+//   'rescan'  — rebuild the aggregate from transcripts
+//   'discord' — not auto-fixable (user must open Discord desktop); advice only
+let findings = [];
+
 // Thin wrapper around the shared ui.check so we can keep counters local
 // to this module without exporting a stateful version from ui.js.
-function check(label, status, detail = '', hint = '') {
+function check(label, status, detail = '', hint = '', fixKind = null) {
   if      (status === 'pass') counters.pass++;
   else if (status === 'fail') counters.fail++;
   else if (status === 'warn') counters.warn++;
+  if (fixKind && status !== 'pass') findings.push({ label, status, fixKind });
   uiCheck(label, status, detail, hint);
 }
 
+// Deduped, ordered list of repairs the last runDoctor() identified. Consumed by
+// the CLI's `--fix` path. Order matters: config/hooks before daemon (the daemon
+// must restart to pick up rewired hooks), aggregate last.
+export function fixPlan() {
+  const order = ['setup', 'rescan', 'daemon', 'discord'];
+  const kinds = new Set(findings.filter((f) => f.fixKind).map((f) => f.fixKind));
+  return order.filter((k) => kinds.has(k));
+}
+
 function section(title) {
   console.log(`\n${c.bold}${title}${c.reset}`);
 }
@@ -63,7 +83,7 @@ function checkMode() {
 function checkConfig() {
   if (!existsSync(CONFIG_PATH)) {
     check('config.json present', 'fail', CONFIG_PATH,
-      'run `claude-rpc setup` to seed a default config');
+      'run `claude-rpc setup` to seed a default config', 'setup');
     return null;
   }
   let cfg;
@@ -92,10 +112,10 @@ function checkConfig() {
     check('presence schema', 'pass', 'byStatus block present (v0.3.6+ shape)');
   } else if (hasRotation) {
     check('presence schema', 'warn', 'legacy rotation only — no byStatus block',
-      'run `claude-rpc setup` again to migrate config into the byStatus shape');
+      'run `claude-rpc setup` again to migrate config into the byStatus shape', 'setup');
   } else {
     check('presence schema', 'warn', 'no presence templates configured',
-      'either rotation or byStatus is needed for the card to render');
+      'either rotation or byStatus is needed for the card to render', 'setup');
   }
   return cfg;
 }
@@ -169,14 +189,14 @@ function checkHooks() {
       'all events wired against the current binary');
   } else if (missing.length === HOOK_EVENTS.length) {
     check('hooks registered', 'fail', 'no claude-rpc hooks found',
-      'run `claude-rpc setup` to register hooks');
+      'run `claude-rpc setup` to register hooks', 'setup');
   } else if (missing.length > 0) {
     check('hooks registered', 'warn', `missing: ${missing.join(', ')}`,
-      'run `claude-rpc setup` to add the missing events');
+      'run `claude-rpc setup` to add the missing events', 'setup');
   } else if (stale.length > 0) {
     check('hooks registered', 'warn',
       `${stale.length} pointing at an old binary path`,
-      'run `claude-rpc setup` to refresh hook commands against the current binary');
+      'run `claude-rpc setup` to refresh hook commands against the current binary', 'setup');
   }
 }
 
@@ -191,7 +211,7 @@ function checkCanonicalExe() {
     check('canonical exe installed', 'pass', `${CANONICAL_EXE} (${size})`);
   } else {
     check('canonical exe installed', 'fail', `missing: ${CANONICAL_EXE}`,
-      'run `claude-rpc setup` to copy this binary to the canonical location');
+      'run `claude-rpc setup` to copy this binary to the canonical location', 'setup');
   }
 }
 
@@ -202,13 +222,13 @@ function isAlive(pid) {
 function checkDaemon() {
   if (!existsSync(PID_PATH)) {
     check('daemon running', 'warn', 'no pid file',
-      'run `claude-rpc start` to launch the daemon');
+      'run `claude-rpc start` to launch the daemon', 'daemon');
     return false;
   }
   const pid = Number(readFileSync(PID_PATH, 'utf8'));
   if (!pid || !isAlive(pid)) {
     check('daemon running', 'fail', `stale pid file (${pid})`,
-      'run `claude-rpc start` — old daemon died without cleaning up');
+      'run `claude-rpc start` — old daemon died without cleaning up', 'daemon');
     return false;
   }
   check('daemon running', 'pass', `pid ${pid}`);
@@ -248,7 +268,7 @@ function checkDaemonLog() {
       `connected · ${sizeKB} KB log · last write ${ageMin.toFixed(1)} min ago`);
   } else if (ipc === 'down') {
     check('discord IPC connection', 'warn', 'daemon is reconnecting to Discord',
-      'is the discord desktop client running? rpc only works via desktop, not browser');
+      'is the discord desktop client running? rpc only works via desktop, not browser', 'discord');
   } else {
     check('discord IPC connection', 'warn', 'no connection activity in the log yet',
       'start the daemon with discord desktop running');
@@ -277,7 +297,7 @@ function checkState() {
 function checkAggregate() {
   if (!existsSync(AGGREGATE_PATH)) {
     check('aggregate built', 'warn', 'never scanned',
-      'run `claude-rpc scan` to build lifetime stats from your transcripts');
+      'run `claude-rpc scan` to build lifetime stats from your transcripts', 'rescan');
     return;
   }
   try {
@@ -288,7 +308,7 @@ function checkAggregate() {
       `${agg.sessions || 0} sessions · ${hours}h · refreshed ${ageMin.toFixed(0)} min ago`);
   } catch (e) {
     check('aggregate built', 'fail', `parse error: ${e.message}`,
-      'run `claude-rpc rescan` to rebuild the aggregate from scratch');
+      'run `claude-rpc rescan` to rebuild the aggregate from scratch', 'rescan');
   }
 }
 
@@ -332,7 +352,7 @@ function checkLiveSessions() {
 function checkDataDir() {
   if (!existsSync(USER_CONFIG_DIR)) {
     check('user config dir', 'warn', `${USER_CONFIG_DIR} missing`,
-      'run `claude-rpc setup` — this is created automatically');
+      'run `claude-rpc setup` — this is created automatically', 'setup');
     return;
   }
   check('user config dir', 'pass', USER_CONFIG_DIR);
@@ -341,6 +361,8 @@ function checkDataDir() {
 // ── public entry point ──────────────────────────────────────────────────
 
 export function runDoctor() {
+  counters.pass = 0; counters.fail = 0; counters.warn = 0;
+  findings = [];
   console.log(`${c.bold}${c.cyan}claude-rpc doctor${c.reset}  ${c.dim}— diagnostic checklist${c.reset}`);
 
   section('Runtime');

package/src/format.js

@@ -107,9 +107,13 @@ function humanTool(name) {
   return name;
 }
 
-// "C--Users-simmo-Downloads-CLAUDE" → "CLAUDE"
-// "-home-alice-projects-my-app"     → "my-app"
-// "archive-2026-04-25T185311Z"      → "archive"
+// Given a real path, the basename is exact: "/home/alice/my-app" → "my-app".
+// Given a Claude Code project *slug* (path with separators replaced by '-')
+// we can only best-effort the last segment: "C--Users-simmo-Downloads-CLAUDE"
+// → "CLAUDE". A hyphenated name ("my-app") can't be recovered from a bare slug
+// because '-' also encodes the separators — but callers pass the real cwd
+// wherever they have it (live sessions, aggregate keys), so the slug branch is
+// a rare fallback for transcripts whose cwd we never saw.
 function humanProject(slugOrPath) {
   if (!slugOrPath) return '';
   const raw = String(slugOrPath);
@@ -122,8 +126,10 @@ function humanProject(slugOrPath) {
         || raw.startsWith('-tmp-')
         || raw.startsWith('-var-')
         || raw.startsWith('-opt-')) {
-    // Path-style slug — take the last segment.
-    const parts = raw.split('-').filter((p) => p && p !== 'C');
+    // Path-style slug — strip a leading Windows drive letter ("C--") and take
+    // the last segment. (The old code filtered out every segment equal to 'C',
+    // which wrongly dropped a real path/project segment literally named "C".)
+    const parts = raw.replace(/^[A-Za-z]--/, '').split('-').filter(Boolean);
     name = parts[parts.length - 1] || raw;
   } else {
     name = raw;

package/src/git.js

@@ -31,7 +31,7 @@ function readGitInfo(cwd) {
   // origin URL → github URL + repo name.
   try {
     const cfg = readFileSync(join(gitDir, 'config'), 'utf8');
-    const m = cfg.match(/\[remote\s+"origin"\][^\[]*?url\s*=\s*([^\r\n]+)/i);
+    const m = cfg.match(/\[remote\s+"origin"\][^[]*?url\s*=\s*([^\r\n]+)/i);
     if (m) {
       const raw = m[1].trim();
       const ssh = raw.match(/^git@github\.com:([^\s]+?)(?:\.git)?$/i);

package/src/hook.js

@@ -5,22 +5,65 @@ import { updateState, resetState, pushUnique, shortFile } from './state.js';
 import { detectLastCommitSubject, detectGitBranch } from './git.js';
 import { EVENTS_LOG_PATH } from './paths.js';
 
-// Bash invocations we treat as "just shipped", classified into a kind for
-// state.justShippedKind. Tolerates extra args, leading env vars, and chained
-// commands ("git add . && git commit -m …"). Order matters: push outranks
-// commit when a command does both (`git commit && git push`).
-const SHIP_PATTERNS = [
-  { kind: 'push',   re: /(?:^|[;&|]|\s)git\s+push(?:\s|$)/ },
-  { kind: 'commit', re: /(?:^|[;&|]|\s)git\s+commit(?:\s|$)/ },
-  { kind: 'pr',     re: /(?:^|[;&|]|\s)gh\s+pr\s+create(?:\s|$)/ },
-  { kind: 'issue',  re: /(?:^|[;&|]|\s)gh\s+issue\s+create(?:\s|$)/ },
-  { kind: 'tag',    re: /(?:^|[;&|]|\s)gh\s+release\s+create(?:\s|$)/ },
-];
+// Precedence when a command ships more than one way (`git commit && git push`
+// → push). Highest first.
+const SHIP_PRECEDENCE = ['push', 'commit', 'pr', 'issue', 'tag'];
+
+// Tokenize one command segment the way a shell roughly would for our purposes:
+// strip leading env assignments (FOO=bar) and sudo/time wrappers, drop the path
+// from the leading binary (/usr/bin/git → git), lowercase it.
+function tokenizeSegment(seg) {
+  const stripped = seg.replace(/^\s*(?:[A-Za-z_][A-Za-z0-9_]*=\S+\s+)+/, '').trim();
+  let toks = stripped.split(/\s+/).filter(Boolean);
+  while (toks.length && (toks[0] === 'sudo' || toks[0] === 'time')) toks = toks.slice(1);
+  if (toks.length) {
+    const slash = toks[0].lastIndexOf('/');
+    if (slash !== -1) toks[0] = toks[0].slice(slash + 1);
+    toks[0] = toks[0].toLowerCase();
+  }
+  return toks;
+}
+
+// First real git subcommand, skipping global flags and their values
+// (`git -C /repo -c k=v push` → push).
+function gitSubcommand(args) {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '-C' || a === '-c') { i++; continue; } // flag that takes a value
+    if (a.startsWith('-')) continue;
+    return a.toLowerCase();
+  }
+  return null;
+}
+
+function shipKindForSegment(seg) {
+  const toks = tokenizeSegment(seg);
+  if (!toks.length) return null;
+  if (toks[0] === 'git') {
+    const sub = gitSubcommand(toks.slice(1));
+    if (sub === 'push') return 'push';
+    if (sub === 'commit') return 'commit';
+  } else if (toks[0] === 'gh') {
+    if (toks[1] === 'pr' && toks[2] === 'create') return 'pr';
+    if (toks[1] === 'issue' && toks[2] === 'create') return 'issue';
+    if (toks[1] === 'release' && toks[2] === 'create') return 'tag';
+  }
+  return null;
+}
 
 // Return the "shipped" kind for a shell command, or null. Exported for tests.
+// Splits on shell separators and only classifies a segment whose *actual*
+// 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.
 export function classifyShip(cmd) {
-  const s = String(cmd || '');
-  for (const p of SHIP_PATTERNS) if (p.re.test(s)) return p.kind;
+  const segments = String(cmd || '').split(/[;&|\n]+/);
+  const found = new Set();
+  for (const seg of segments) {
+    const k = shipKindForSegment(seg);
+    if (k) found.add(k);
+  }
+  for (const kind of SHIP_PRECEDENCE) if (found.has(kind)) return kind;
   return null;
 }
 

package/src/install.js

@@ -12,10 +12,11 @@ import { spawn, spawnSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import {
   CLAUDE_SETTINGS, CONFIG_PATH, USER_CONFIG_DIR, ROOT,
-  HOOK_SCRIPT, IS_PACKAGED, IS_NPM_INSTALL,
+  HOOK_SCRIPT, IS_PACKAGED, IS_NPM_INSTALL, IS_NPX,
   CANONICAL_EXE, CANONICAL_INSTALL_DIR, CANONICAL_EXE_NAME,
 } from './paths.js';
 import { DEFAULT_CONFIG } from './default-config.js';
+import { VERSION } from './version.js';
 
 const STARTUP_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
 const STARTUP_VALUE = 'ClaudeRPC';
@@ -329,20 +330,32 @@ export function migrateConfig({ silent = false } = {}) {
     added.push('community (preserved-off)');
   }
 
-  // v0.8.1: the default presence button moved from the Claude Code website
-  // to the project repo. Existing configs carry their own `buttons` array,
-  // which fully REPLACES the default (arrays don't deep-merge) — so the new
-  // default never reaches upgraders just by bumping the package. Rewrite
-  // ONLY a button still pointing at the verbatim old default URL; anything a
-  // user has customized (label or url) is left untouched.
-  const OLD_BTN_URL = 'https://claude.com/claude-code';
-  const NEW_BTN_URL = DEFAULT_CONFIG.presence?.buttons?.[0]?.url;
-  if (NEW_BTN_URL && Array.isArray(cfg.presence?.buttons)) {
+  // Button defaults have moved twice: the Claude Code website (pre-v0.8.1) →
+  // the project repo (v0.8.1) → a landing-page call-to-action (v0.13). Existing
+  // configs carry their own `buttons` array, which fully REPLACES the default
+  // (arrays don't deep-merge), so a new default never reaches upgraders just by
+  // bumping the package. Upgrade any button that's still a verbatim shipped
+  // default to the current CTA; as a safety net, also repoint a button that's
+  // merely been relabeled but still aims at the long-dead claude.com URL.
+  // Anything a user fully customized (their own label AND url) is left alone.
+  const NEW_BTN = DEFAULT_CONFIG.presence?.buttons?.[0];
+  const SHIPPED_DEFAULT_BTNS = [
+    { label: 'Claude Code', url: 'https://claude.com/claude-code' },
+    { label: 'Claude Code', url: 'https://github.com/rar-file/claude-rpc' },
+  ];
+  if (NEW_BTN && Array.isArray(cfg.presence?.buttons)) {
     let changed = false;
     for (const b of cfg.presence.buttons) {
-      if (b && b.url === OLD_BTN_URL) { b.url = NEW_BTN_URL; changed = true; }
+      if (!b) continue;
+      const isShippedDefault = SHIPPED_DEFAULT_BTNS.some((d) => d.label === b.label && d.url === b.url);
+      const alreadyCurrent = b.label === NEW_BTN.label && b.url === NEW_BTN.url;
+      if (isShippedDefault && !alreadyCurrent) {
+        b.label = NEW_BTN.label; b.url = NEW_BTN.url; changed = true;
+      } else if (b.url === 'https://claude.com/claude-code') {
+        b.url = NEW_BTN.url; changed = true;   // dead link, keep their custom label
+      }
     }
-    if (changed) added.push('presence.buttons[].url → repo');
+    if (changed) added.push('presence.buttons[] → CTA');
   }
 
   if (added.length === 0) {
@@ -397,7 +410,32 @@ function verifyHookPipe(exePath) {
   return { ok: true, detail: 'SessionStart round-trip succeeded' };
 }
 
+// `npx claude-rpc setup` runs from npm's throwaway _npx cache, so the
+// `claude-rpc` bin the hooks resolve through PATH disappears the moment npx
+// exits. Promote to a real global install first, then the rest of setup wires
+// hooks to the now-persistent global bin exactly like a normal npm install.
+// Best-effort + loud: a failed -g (perms, offline) returns false so the caller
+// can stop with the manual command rather than wire a dead hook.
+function promoteNpxToGlobal() {
+  console.log('  npx is one-off — installing claude-rpc globally so hooks survive…');
+  const r = spawnSync('npm', ['install', '-g', `claude-rpc@${VERSION}`], {
+    stdio: 'inherit',
+    shell: process.platform === 'win32',   // npm is npm.cmd on Windows
+  });
+  return !r.error && r.status === 0;
+}
+
 export async function install({ exePath, withStartup = true } = {}) {
+  if (IS_NPX) {
+    if (!promoteNpxToGlobal()) {
+      console.error('\n  ✗ Global install failed. Run this once, then you\'re set:');
+      console.error('      npm install -g claude-rpc && claude-rpc setup');
+      const err = new Error('npx self-install failed');
+      err.code = 3;   // system error (see exit-code contract)
+      throw err;
+    }
+    console.log('  ✓ claude-rpc installed globally\n');
+  }
   if (process.platform !== 'win32' && withStartup) {
     console.warn('Note: startup registration only works on Windows; other steps still run.');
   }
@@ -428,19 +466,17 @@ export async function install({ exePath, withStartup = true } = {}) {
   }
 
   console.log('\nDone.');
-  console.log(`Edit ${CONFIG_PATH} to set your Discord clientId, then run:`);
-  // Per-mode "start" instructions — packaged exe takes a daemon subcommand,
-  // the npm bin shim handles `start` as a subcommand of itself, and dev
-  // mode runs the daemon script directly through node.
+  console.log(`Config: ${CONFIG_PATH}`);
+  console.log(`  (a working Discord app is bundled — edit clientId only to use your own)`);
+  // setup auto-starts the daemon (see cli.js), so we point at management +
+  // verification rather than a start command. The packaged exe manages the
+  // daemon via its own subcommands; the npm/dev bin uses `claude-rpc …`.
   if (IS_PACKAGED) {
-    console.log(`  "${target}" daemon`);
-  } else if (IS_NPM_INSTALL) {
-    console.log(`  claude-rpc start`);
+    console.log(`\nManage the daemon:  "${target}" daemon  (start) · check with claude-rpc doctor`);
   } else {
-    console.log(`  node "${join(ROOT, 'src', 'daemon.js').replace(/\\/g, '/')}"`);
-    console.log(`  # or: claude-rpc start  (if you've run \`npm link\`)`);
+    console.log(`\nManage the daemon:  claude-rpc start | stop | status`);
+    console.log(`Verify wiring:      claude-rpc doctor`);
   }
-  console.log(`\nThen: \`claude-rpc doctor\` to verify everything is wired.`);
 }
 
 export async function uninstall() {

package/src/mcp.js

@@ -7,7 +7,7 @@
 // The tool HANDLERS are pure functions of an aggregate, so they're unit-tested
 // without standing up the transport.
 
-import { readAggregate } from './scanner.js';
+import { readAggregate, dayKey } from './scanner.js';
 import { buildVars } from './format.js';
 import { readState } from './state.js';
 import { loadConfig } from './config.js';
@@ -44,7 +44,10 @@ export const TOOLS = {
   get_today: {
     description: "Today's Claude Code activity: active hours, prompts, tool calls, tokens, estimated cost.",
     handler(agg) {
-      const today = (agg.byDay || {})[new Date().toISOString().slice(0, 10)] || {};
+      // Key by LOCAL date via the same dayKey the scanner uses to WRITE byDay
+      // (and format.js uses to read it). A UTC slice here silently surfaced the
+      // wrong/empty bucket for anyone not on UTC once local and UTC dates split.
+      const today = (agg.byDay || {})[dayKey(Date.now())] || {};
       const tokens = (today.inputTokens || 0) + (today.outputTokens || 0) + (today.cacheReadTokens || 0) + (today.cacheWriteTokens || 0);
       return [
         `Active time:  ${fmtH(today.activeMs)}`,
@@ -86,7 +89,13 @@ export function toolList() {
   }));
 }
 
-// Dispatch a tools/call by name. Reads a fresh aggregate per call (cheap).
+/**
+ * Dispatch a tools/call by name. Reads a fresh aggregate per call (cheap).
+ * @param {string} name - Tool name (a key of TOOLS).
+ * @param {() => object} [getAgg] - Aggregate provider; defaults to readAggregate (injectable for tests).
+ * @returns {string} The tool's text result.
+ * @throws {Error} If the tool name is unknown.
+ */
 export function callTool(name, getAgg = readAggregate) {
   const t = TOOLS[name];
   if (!t) throw new Error(`unknown tool: ${name}`);
@@ -94,7 +103,14 @@ export function callTool(name, getAgg = readAggregate) {
   return t.handler(agg);
 }
 
-// ── stdio JSON-RPC transport (newline-delimited) ──────────────────────────
+/**
+ * stdio JSON-RPC transport (newline-delimited). Wires the MCP protocol methods
+ * (initialize, tools/list, tools/call, ping) to the tool handlers.
+ * @param {{input?: NodeJS.ReadableStream, output?: {write: (s: string) => void}}} [io]
+ *   Streams to read requests from / write responses to. Defaults to process stdio;
+ *   injectable for tests.
+ * @returns {void}
+ */
 export function runMcpServer({ input = process.stdin, output = process.stdout } = {}) {
   let buf = '';
   const send = (msg) => output.write(JSON.stringify(msg) + '\n');