claude-rpc 0.13.7 → 0.15.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/SECURITY.md

@@ -124,7 +124,25 @@ Publishes a badge SVG to *your own* GitHub gist via the `gh` CLI or a
 `gist.github.com`. Never runs unattended, never on install, never from the
 daemon.
 
-### 3c. Presence GIF assets — Discord-side only
+### 3c. Squads & web login — opt-in, profile-derived
+
+**Source:** `worker/src/index.js` (+ `worker/src/auth.js`), `src/cli.js`
+(`squad` command), `site/squad.html`. Squads are private mini-leaderboards
+that regroup stats you **already publish** via the opt-in profile — joining
+one sends nothing new from your machine; the worker derives weekly standings
+from the same clamped lifetime totals the public board uses.
+
+"Log in with GitHub" on the website is plain OAuth (no scopes — public
+identity only; we never see email or repos). Sessions are stateless signed
+tokens holding **only your public GitHub login**, stored in your browser's
+localStorage and expiring after 7 days. The browser never receives an
+`instanceId` — that remains the CLI's local credential; the worker resolves
+GitHub login → profile via the link your own gist verification created.
+Worker-side storage adds: `gh:<login>` → profile link, `squad:*` membership
+records, and weekly baseline snapshots (auto-expiring). Leaving your last
+squad deletes its record.
+
+### 3d. Presence GIF assets — Discord-side only
 
 `default-config.js` references `https://cdn.qualit.ly/clawd-*.gif`. These URLs
 are handed to Discord as image keys; **Discord's** client fetches them to render

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-rpc",
-  "version": "0.13.7",
+  "version": "0.15.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",
@@ -32,7 +32,7 @@
     "dist:mac": "npm run build:exe && npm run prep:dashboard && npm --prefix dashboard run dist:mac",
     "dist:win": "npm run build:exe && npm run prep:dashboard && npm --prefix dashboard run dist:win",
     "test": "node --test test/*.test.js",
-    "lint": "eslint src test",
+    "lint": "eslint src test vscode-extension",
     "format": "prettier --write \"src/**/*.js\" \"test/**/*.js\"",
     "format:check": "prettier --check \"src/**/*.js\" \"test/**/*.js\"",
     "typecheck": "tsc -p jsconfig.json"

package/src/cli.js

@@ -12,7 +12,7 @@ if (process.platform === 'win32' && process.stdout.isTTY) {
 }
 import { DAEMON_SCRIPT, PID_PATH, STATE_PATH, LOG_PATH, AGGREGATE_PATH, CONFIG_PATH, IS_PACKAGED, IS_NPX, EXE_PATH, CANONICAL_EXE } from './paths.js';
 import { readState } from './state.js';
-import { buildVars, fillTemplate, humanProject, humanTool, applyIdle, framePasses } from './format.js';
+import { buildVars, fillTemplate, humanProject, humanTool, applyIdle, framePasses, fmtNum } from './format.js';
 import { scan, readAggregate, findLiveSessions, dayKey, weekKey } from './scanner.js';
 import { runHookCli } from './hook.js';
 import { install as runInstall, uninstall as runUninstall, isInstalled, migrateConfig, installHooks, ensureCanonicalExe, installMcp, uninstallMcp, mcpServerCommand } from './install.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,230 @@ 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);
+  }
+}
+
+// ── Squads — private mini-leaderboards (terminal parity for the web UI) ───
+//
+// `claude-rpc squad create <name>` → invite code + link
+// `claude-rpc squad join <code>`
+// `claude-rpc squad` / `squad status`  → standings for every squad you're in
+// `claude-rpc squad leave [id]`
+// The web flow (claude-rpc.vercel.app + GitHub login) drives the same worker
+// endpoints; the CLI authenticates with the community instanceId it already has.
+
+function squadAuth() {
+  const cfg = loadConfig();
+  const endpoint = (cfg.community?.endpoint || '').replace(/\/+$/, '');
+  const instanceId = cfg.community?.instanceId;
+  if (!endpoint) fail('no community endpoint configured', { code: EX_BAD_STATE });
+  if (!instanceId) {
+    fail('squads need an identity', {
+      hint: 'run `claude-rpc profile set --handle <name> && claude-rpc profile on` first',
+      code: EX_BAD_STATE,
+    });
+  }
+  const post = async (path, body) => {
+    const res = await fetch(endpoint + path, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ instanceId, ...body }),
+    });
+    return { status: res.status, json: await res.json().catch(() => ({})) };
+  };
+  const get = async (path) => {
+    const res = await fetch(endpoint + path);
+    return { status: res.status, json: await res.json().catch(() => ({})) };
+  };
+  return { cfg, endpoint, instanceId, post, get };
+}
+
+function squadPageUrl(id) { return `https://claude-rpc.vercel.app/squad/${id}`; }
+
+function printSquadInvite(squad) {
+  console.log('');
+  console.log(`  ${c.green}✓${c.reset} squad ${c.bold}${squad.name}${c.reset}`);
+  console.log(`    ${c.dim}invite code:${c.reset} ${c.cyan}${squad.code}${c.reset}`);
+  console.log(`    ${c.dim}standings:  ${c.reset} ${c.cyan}${squadPageUrl(squad.id)}${c.reset}`);
+  console.log('');
+  console.log(`  ${c.dim}send your crew this:${c.reset}`);
+  console.log(`    join my Claude Code squad "${squad.name}" — npx claude-rpc@latest setup, then:`);
+  console.log(`    ${c.cyan}claude-rpc squad join ${squad.code}${c.reset}  ${c.dim}(or join in the browser: ${squadPageUrl(squad.id)})${c.reset}`);
+  console.log('');
+}
+
+async function squadStatus({ post, get }) {
+  const mine = await post('/squads/mine', {});
+  if (!mine.json?.squads) return fail(`could not load squads: ${mine.json?.error || mine.status}`, { code: EX_SYS_ERROR });
+  if (!mine.json.squads.length) {
+    console.log('');
+    console.log(`  ${c.dim}no squads yet — start one:${c.reset} ${c.cyan}claude-rpc squad create "the night shift"${c.reset}`);
+    console.log('');
+    return;
+  }
+  for (const s of mine.json.squads) {
+    const r = await get(`/squad?id=${encodeURIComponent(s.id)}`);
+    const standings = r.json?.standings || [];
+    const lines = standings.map((row) => {
+      const who = `${row.displayName || '@' + row.handle}${row.verified ? ' ✓' : ''}${row.owner ? ` ${c.dim}(owner)${c.reset}` : ''}`;
+      return `${c.bold}#${row.rank}${c.reset} ${who.padEnd(28)} ${c.cyan}${fmtNum(row.weekTokens)}${c.reset} ${c.dim}this week${c.reset} · ${fmtNum(row.tokens)} ${c.dim}lifetime${c.reset}`;
+    });
+    lines.push('');
+    lines.push(`${c.dim}week ${r.json?.squad?.week || ''} · invite ${c.reset}${c.cyan}${s.code}${c.reset}${c.dim} · ${squadPageUrl(s.id)}${c.reset}`);
+    box(`${s.name} (${s.members})`, lines, 70);
+    console.log('');
+  }
+}
+
+async function doSquadCmd(argv) {
+  const sub = (argv[0] || 'status').toLowerCase();
+  const ctx = squadAuth();
+  if (sub === 'status' || sub === '') return squadStatus(ctx);
+  if (sub === 'create') {
+    const name = argv.slice(1).join(' ').trim();
+    if (!name) return fail('usage: claude-rpc squad create <name>', { code: EX_USER_ERROR });
+    const r = await ctx.post('/squad/create', { name });
+    if (r.status !== 200) return fail(`create failed: ${r.json?.error || r.status}`, { code: EX_SYS_ERROR });
+    return printSquadInvite(r.json.squad);
+  }
+  if (sub === 'join') {
+    const code = (argv[1] || '').trim();
+    if (!code) return fail('usage: claude-rpc squad join SQ-XXXXXX', { code: EX_USER_ERROR });
+    const r = await ctx.post('/squad/join', { code });
+    if (r.status !== 200) return fail(`join failed: ${r.json?.error || r.status}`, { code: EX_SYS_ERROR });
+    const s = r.json.squad;
+    console.log(`${c.green}✓${c.reset} ${s.alreadyMember ? 'already in' : 'joined'} ${c.bold}${s.name}${c.reset} (${s.members} member${s.members === 1 ? '' : 's'})`);
+    console.log(`  ${c.dim}standings: ${squadPageUrl(s.id)}  ·  claude-rpc squad${c.reset}`);
+    return;
+  }
+  if (sub === 'leave') {
+    const mine = await ctx.post('/squads/mine', {});
+    const squads = mine.json?.squads || [];
+    if (!squads.length) return fail('you are not in any squads', { code: EX_BAD_STATE });
+    let target = null;
+    const wanted = (argv[1] || '').toLowerCase();
+    if (wanted) target = squads.find((s) => s.id === wanted || s.name.toLowerCase() === wanted);
+    else if (squads.length === 1) target = squads[0];
+    if (!target) {
+      return fail(squads.length > 1 && !wanted ? 'you are in several squads — name one' : `no squad matching "${argv[1]}"`, {
+        hint: `claude-rpc squad leave <id|name> — yours: ${squads.map((s) => `${s.name} (${s.id})`).join(', ')}`,
+        code: EX_USER_ERROR,
+      });
+    }
+    const r = await ctx.post('/squad/leave', { squadId: target.id });
+    if (r.status !== 200) return fail(`leave failed: ${r.json?.error || r.status}`, { code: EX_SYS_ERROR });
+    console.log(`${c.green}✓${c.reset} left ${c.bold}${target.name}${c.reset}${r.json.dissolved ? ` ${c.dim}(last member — squad dissolved)${c.reset}` : ''}`);
+    return;
+  }
+  fail(`unknown squad subcommand: ${sub}`, {
+    hint: 'try: squad [status|create <name>|join <code>|leave [id]]',
+    code: EX_USER_ERROR,
+  });
+}
+
+// ── Link (CLI ↔ web pairing) ─────────────────────────────────────────────
+//
+// `claude-rpc link <code>` — the code comes from claude-rpc.vercel.app/squads
+// while logged in with GitHub. Claims it against this install's instanceId,
+// which verifies the profile (✓) and unlocks managing squads from the
+// browser. Replaces the gist dance for anyone who uses the website.
+
+async function doLink(argv) {
+  const code = (argv[0] || '').trim();
+  if (!code) {
+    fail('usage: claude-rpc link <code>', {
+      hint: 'log in at https://claude-rpc.vercel.app/squads — it shows you the code',
+      code: EX_USER_ERROR,
+    });
+  }
+  const ctx = squadAuth();
+  // Make sure the profile row exists server-side before claiming — same
+  // pre-publish profileVerify does, so link works on a fresh `profile on`.
+  if (lb.profileIsPublishable(ctx.cfg.profile || {})) {
+    const { flushProfile } = await import('./community.js');
+    await flushProfile(ctx.cfg);
+  }
+  const r = await ctx.post('/pair/claim', { code });
+  if (r.status !== 200) {
+    return fail(`link failed: ${r.json?.error || r.status}`, { code: EX_SYS_ERROR });
+  }
+  // Mirror the verified identity locally so `profile status` agrees.
+  const userCfg = readJson(CONFIG_PATH, {});
+  userCfg.profile = { ...(userCfg.profile || {}), githubUser: r.json.githubUser, verified: true };
+  writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
+  console.log(`${c.green}✓${c.reset} linked as ${c.cyan}@${r.json.githubUser}${c.reset} — profile verified, squads unlocked in the browser.`);
+  console.log(`  ${c.dim}head back to https://claude-rpc.vercel.app/squads — it picks the link up automatically.${c.reset}`);
+}
+
 // ── Community totals ─────────────────────────────────────────────────────
 //
 // `claude-rpc community`         → show current state + endpoint
@@ -1060,16 +1285,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 +1349,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 +1385,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 +1416,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 +1446,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 +1466,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 +1518,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,11 +1632,16 @@ 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'],
     ['community', 'Opt in/out of anonymous community totals (on|off|status|report)'],
     ['profile',   'Public leaderboard identity (status|set|on|off|publish|verify)'],
+    ['squad',     'Private mini-leaderboards with friends (create|join|leave|status)'],
+    ['link',      'Pair this install with your web login (code from /squads page)'],
     ['doctor',    'Run a diagnostic checklist — common-failure triage (--fix to auto-repair)'],
     ['tail',      'Tail the daemon log file'],
     ['daemon',    'Run daemon in foreground (debug)'],
@@ -1483,11 +1745,17 @@ 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;
     case 'community': await doCommunity(process.argv.slice(3)); break;
     case 'profile':   await doProfile(process.argv.slice(3)); break;
+    case 'squad':     await doSquadCmd(process.argv.slice(3)); break;
+    case 'link':      await doLink(process.argv.slice(3)); break;
     case 'doctor': {
       const { runDoctor, fixPlan } = await import('./doctor.js');
       const fix = process.argv.includes('--fix');
@@ -1579,8 +1847,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 });
       }
     }
   }