claude-rpc 1.1.4 → 1.2.1

package/SECURITY.md

@@ -208,6 +208,22 @@ anonymous 3a report, this one carries your chosen public identity. The
 It sends absolute totals (not deltas) and is idempotent worker-side (a SET, not
 an add). `profile off` stops it.
 
+**Claude Wrapped (opt-in one-shot, never automatic).** `claude-rpc wrapped
+--publish` publishes a year-in-review blob under your profile handle to
+`<endpoint>/wrapped`, rendered at `claude-rpc.com/wrapped/<handle>`. It never
+runs on a timer — it is a single explicit command, and the CLI **prints the
+exact payload and asks for confirmation** before sending (non-TTY requires
+`--yes`). The complete payload (`buildWrappedPayload`, enforced by the
+worker's `validateWrapped`/`sanitizeWrapped` allowlist) is year-scoped
+aggregate numbers — active time, sessions, prompts, tokens, cache %, lines,
+ships, streak/peaks, estimated cost — plus up to 5 top project **names**, 5
+language names, 4 model names with share %, and 3 tool names with share %. No
+file paths, no prompts, no per-day breakdowns. Project names respect the
+privacy lists and `privacy.patterns` before they ever appear in the preview;
+anything you see in the confirmation box is everything the server sees. Each
+publish overwrites the previous one; records expire worker-side after ~14
+months unless re-published.
+
 ### 3d. Subscription usage — your own token, to its issuer, ON by default
 
 **Source:** `src/usage.js`; consumed by the daemon poll, `claude-rpc usage`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-rpc",
-  "version": "1.1.4",
+  "version": "1.2.1",
   "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

@@ -25,7 +25,7 @@ import { spawnDaemonDetached, daemonAlive } from './ensure-daemon.js';
 // the stats/format/install code, so daemon-control and version stay near-instant.
 // (The repo already lazy-imports cold deps like doctor.js/card.js/mcp.js inside
 // their handlers — this just extends that to the graph the main switch needs.)
-let buildVars, fillTemplate, humanProject, humanTool, applyIdle, framePasses, fmtNum;
+let buildVars, fillTemplate, humanProject, humanTool, applyIdle, framePasses, fmtNum, fmtHours;
 let scan, readAggregate, findLiveSessions, dayKey, weekKey;
 let weekGrid;
 let runInstall, runUninstall, isInstalled, migrateConfig, installHooks, ensureCanonicalExe, installMcp, uninstallMcp, setupOutro;
@@ -49,7 +49,7 @@ async function loadStats() {
     import('./nudge.js'), import('./badge.js'), import('./pricing.js'),
     import('./privacy.js'), import('./usage.js'), import('./leaderboard.js'),
   ]);
-  ({ buildVars, fillTemplate, humanProject, humanTool, applyIdle, framePasses, fmtNum } = fmt);
+  ({ buildVars, fillTemplate, humanProject, humanTool, applyIdle, framePasses, fmtNum, fmtHours } = fmt);
   ({ scan, readAggregate, findLiveSessions, dayKey, weekKey } = scn);
   ({ weekGrid } = wk);
   ({ install: runInstall, uninstall: runUninstall, isInstalled, migrateConfig, installHooks, ensureCanonicalExe, installMcp, uninstallMcp, setupOutro } = inst);
@@ -687,6 +687,123 @@ function showWeek() {
   }
 }
 
+// `projects` — every project the scanner has attributed, ranked by active
+// time. The aggregate has carried per-project records since v0.6; this is the
+// first terminal surface for them (the web dashboard's drilldown came first).
+function showProjects(argv = []) {
+  const aggregate = readAggregate();
+  const entries = Object.entries(aggregate?.projects || {});
+  if (!entries.length) {
+    console.log(`\n  No project data yet — run ${c.cyan}claude-rpc scan${c.reset} first.\n`);
+    return;
+  }
+  const limitFlag = argv.indexOf('--limit');
+  const limit = limitFlag !== -1 ? Math.max(1, Number(argv[limitFlag + 1]) || 12) : 12;
+  const ranked = entries.sort((a, b) => (b[1].activeMs || 0) - (a[1].activeMs || 0));
+  const name = (n) => n.length > 22 ? n.slice(0, 21) + '…' : n;
+
+  console.log('');
+  console.log(`  ${c.bold}${c.magenta}◆ Projects${c.reset}  ${c.dim}— ${entries.length} tracked, by active time${c.reset}`);
+  console.log('');
+  const maxMs = ranked[0][1].activeMs || 1;
+  const lines = ranked.slice(0, limit).map(([n, p]) => {
+    const toks = (p.inputTokens || 0) + (p.outputTokens || 0);
+    return `${name(n).padEnd(23)} ${bar(p.activeMs || 0, maxMs, 14)} ${c.cyan}${fmtHours(p.activeMs || 0).padStart(6)}${c.reset}` +
+      ` ${c.dim}·${c.reset} ${String(p.sessions || 0).padStart(4)} sess` +
+      ` ${c.dim}·${c.reset} ${fmtNum(toks).padStart(7)} tok` +
+      ` ${c.dim}·${c.reset} ${c.yellow}${fmtCost(p.cost || 0).padStart(8)}${c.reset}`;
+  });
+  if (ranked.length > limit) lines.push(`${c.dim}… ${ranked.length - limit} more — --limit ${ranked.length} to see all${c.reset}`);
+  box('projects', lines, 76);
+  console.log(`\n  ${c.dim}drill in: ${c.reset}${c.cyan}claude-rpc project <name>${c.reset}\n`);
+}
+
+// `project <name>` — one project's full record + its recent daily rhythm
+// (attributed per-day since scan cache v5).
+function showProject(rawName) {
+  if (!rawName) {
+    console.log(`\n  Usage: ${c.cyan}claude-rpc project <name>${c.reset}  (see ${c.cyan}claude-rpc projects${c.reset})\n`);
+    process.exitCode = EX_USER_ERROR;
+    return;
+  }
+  const aggregate = readAggregate();
+  const projects = aggregate?.projects || {};
+  const key = Object.keys(projects).find((k) => k.toLowerCase() === rawName.toLowerCase())
+    || Object.keys(projects).find((k) => k.toLowerCase().includes(rawName.toLowerCase()));
+  if (!key) {
+    console.log(`\n  No project matching ${c.bold}${rawName}${c.reset} — ${c.cyan}claude-rpc projects${c.reset} lists what's tracked.\n`);
+    process.exitCode = EX_USER_ERROR;
+    return;
+  }
+  const p = projects[key];
+  const toks = (p.inputTokens || 0) + (p.outputTokens || 0);
+
+  console.log('');
+  console.log(`  ${c.bold}${c.magenta}◆ ${key}${c.reset}`);
+  console.log('');
+  box(key, [
+    pair('active',     `${c.bold}${c.green}${fmtHours(p.activeMs || 0)}${c.reset}`, ''),
+    pair('sessions',   String(p.sessions || 0)),
+    pair('prompts',    fmtNum(p.userMessages || 0), c.yellow),
+    pair('tool calls', fmtNum(p.toolCalls || 0), c.yellow),
+    pair('tokens',     `${c.bold}${fmtNum(toks)}${c.reset}  ${c.dim}in+out${c.reset}`, ''),
+    pair('lines',      `${c.green}+${fmtNum(p.linesAdded || 0)}${c.reset} ${c.red}-${fmtNum(p.linesRemoved || 0)}${c.reset}`, ''),
+    pair('est. cost',  fmtCost(p.cost || 0), c.yellow),
+  ]);
+  console.log('');
+
+  // Last 14 days of per-day attribution, oldest first.
+  const days = Object.entries(aggregate?.byDay || {})
+    .filter(([, d]) => d.projects?.[key])
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .slice(-14)
+    .map(([day, d]) => ({ day, ms: d.projects[key].activeMs || 0 }));
+  if (days.length) {
+    const maxMs = Math.max(...days.map((d) => d.ms), 1);
+    box('last 14 active days', days.map(({ day, ms }) =>
+      `${day}  ${bar(ms, maxMs, 20)} ${c.cyan}${fmtHours(ms).padStart(6)}${c.reset}`
+    ));
+    console.log('');
+  }
+}
+
+// `compare` — the full this-week-vs-last-week diff. The deltas existed in
+// three partial forms (insights, showWeek, web api); this is the first
+// complete side-by-side.
+function showCompare() {
+  const aggregate = readAggregate();
+  if (!aggregate?.byWeek) {
+    console.log(`\n  No history yet — run ${c.cyan}claude-rpc scan${c.reset} first.\n`);
+    return;
+  }
+  const prevRef = new Date();
+  prevRef.setHours(12, 0, 0, 0);
+  prevRef.setDate(prevRef.getDate() - 7);
+  const nowKey = weekKey(Date.now());
+  const prevKey = weekKey(prevRef.getTime());
+  const wk = aggregate.byWeek[nowKey] || {};
+  const pw = aggregate.byWeek[prevKey] || {};
+
+  console.log('');
+  console.log(`  ${c.bold}${c.magenta}◆ ${nowKey} vs ${prevKey}${c.reset}  ${c.dim}— this week so far vs all of last week${c.reset}`);
+  console.log('');
+  const row = (label, cur, prev, fmt = fmtNum) => {
+    const d = fmtDelta(cur, prev);
+    return pair(label, `${c.bold}${fmt(cur)}${c.reset}  ${c.dim}was ${fmt(prev)}${c.reset}${d ? `  ${d}` : ''}`, '');
+  };
+  box('week over week', [
+    row('active',     wk.activeMs || 0,      pw.activeMs || 0, fmtHours),
+    row('prompts',    wk.userMessages || 0,  pw.userMessages || 0),
+    row('tool calls', wk.toolCalls || 0,     pw.toolCalls || 0),
+    row('sessions',   wk.sessions || 0,      pw.sessions || 0),
+    row('tokens',     dayTokens(wk),         dayTokens(pw)),
+    row('lines +',    wk.linesAdded || 0,    pw.linesAdded || 0),
+    row('ships',      wk.ships || 0,         pw.ships || 0),
+    row('est. cost',  wk.cost || 0,          pw.cost || 0, fmtCost),
+  ], 72);
+  console.log('');
+}
+
 // Rows for the subscription-usage box (shared by `status` and `usage`).
 // Bars ride the heat ramp — the % IS the intensity. Absent buckets (per-model
 // outside Max plans) drop out.
@@ -1951,6 +2068,75 @@ async function profileVerify() {
   }
 }
 
+// `wrapped --publish [--year N] [--yes]` — put your year-in-review on the web
+// at claude-rpc.com/wrapped/<handle>. Opt-in and explicit: the exact payload
+// is printed and confirmed before anything leaves the machine (the name-level
+// privacy filter can't see everything the presence valve can, so the human
+// check is part of the design, not politeness).
+async function doWrappedPublish(argv) {
+  await loadStats();
+  const cfg = loadConfig();
+  const aggregate = readAggregate();
+  if (!aggregate) return fail('no aggregate yet', { hint: 'run `claude-rpc scan` first', code: EX_BAD_STATE });
+  if (!cfg.profile?.handle || cfg.profile?.enabled === false) {
+    return fail('wrapped publishes under your leaderboard profile', {
+      hint: 'set one up first: `claude-rpc profile set --handle <you>` then `claude-rpc profile publish`',
+      code: EX_BAD_STATE,
+    });
+  }
+  const instanceId = cfg.community?.instanceId;
+  if (!instanceId) return fail('no instanceId — run `claude-rpc setup`', { code: EX_BAD_STATE });
+
+  const yearFlag = argv.indexOf('--year');
+  const year = yearFlag !== -1 ? Number(argv[yearFlag + 1]) : new Date().getFullYear();
+  const { buildWrappedPayload, publishWrapped } = await import('./community.js');
+  const payload = buildWrappedPayload(aggregate, cfg, { instanceId, year });
+  const w = payload.wrapped;
+
+  console.log('');
+  console.log(`  ${c.bold}${c.magenta}◆ Claude Wrapped ${year}${c.reset}  ${c.dim}— what will be published${c.reset}`);
+  console.log('');
+  box(`wrapped ${year}`, [
+    pair('active',    fmtHours(w.activeMs), c.green),
+    pair('sessions',  fmtNum(w.sessions)),
+    pair('tokens',    fmtNum(w.tokens)),
+    pair('prompts',   fmtNum(w.prompts), c.yellow),
+    pair('best streak', `${w.streakBest}d`),
+    pair('days active', String(w.daysActive)),
+    pair('ships',     fmtNum(w.ships)),
+    pair('est. cost', fmtCost(w.costUsd), c.yellow),
+    pair('projects',  w.topProjects.map((p) => p.name).join(' · ') || c.dim + '(none public)' + c.reset, ''),
+    pair('languages', w.topLanguages.map((l) => l.name).join(' · ') || '—', ''),
+    pair('models',    w.topModels.map((m) => `${m.name} ${m.pct}%`).join(' · ') || '—', ''),
+    pair('hotspot',   w.hotspot ? `${w.hotspot.name} (${fmtNum(w.hotspot.count)} edits)` : '—', ''),
+  ], 72);
+  console.log(`  ${c.dim}full payload: the fields above plus lines/cache%/peaks — nothing else.${c.reset}`);
+  console.log(`  ${c.dim}private-listed and pattern-matched project names are already excluded.${c.reset}\n`);
+
+  if (!argv.includes('--yes')) {
+    if (!process.stdout.isTTY) {
+      return fail('refusing to publish without confirmation on a non-TTY', {
+        hint: 'pass --yes to publish non-interactively', code: EX_USER_ERROR,
+      });
+    }
+    const answer = (await prompt(`  publish to claude-rpc.com/wrapped/${cfg.profile.handle}? [y/N] `)).trim().toLowerCase();
+    if (answer !== 'y' && answer !== 'yes') { console.log(`  ${c.dim}nothing sent.${c.reset}\n`); return; }
+  }
+
+  const res = await publishWrapped(cfg, payload);
+  if (!res.ok) {
+    if (res.reason === 'no-profile') {
+      return fail('the worker has no published profile for this machine yet', {
+        hint: 'run `claude-rpc profile publish` once, then retry', code: EX_BAD_STATE,
+      });
+    }
+    return fail(`publish failed: ${res.reason}${res.error ? ` (${res.error})` : ''}`, { code: EX_SYS_ERROR });
+  }
+  console.log(`  ${c.green}✓ published${c.reset}  ${c.bold}${res.url}${c.reset}`);
+  console.log(`  ${c.dim}share card:${c.reset} ${(cfg.community?.endpoint || '').replace(/\/+$/, '')}/wrapped/${res.handle}.svg`);
+  console.log(`  ${c.dim}re-publish any time — same command overwrites.${c.reset}\n`);
+}
+
 async function doProfile(argv) {
   const sub = (argv[0] || 'status').toLowerCase();
   if (sub === 'status' || sub === '') return profileStatus();
@@ -2084,6 +2270,9 @@ function help() {
     ['status',    'Interactive stats TUI; --dump (or piped) prints static text'],
     ['today',     'Focus view: today\'s stats + 24h activity histogram'],
     ['week',      'Focus view: this week, daily breakdown'],
+    ['compare',   'This week vs last week — the full side-by-side diff'],
+    ['projects',  'Every project ranked by active time (--limit N)'],
+    ['project',   'One project\'s full record + recent daily rhythm'],
     ['usage',     'Subscription limits — session + weekly % (what /usage shows)'],
     ['serve',     'Open a live web dashboard in your browser'],
     ['preview',   'Show how each rotation frame renders right now'],
@@ -2103,6 +2292,7 @@ function help() {
     ['mcp uninstall', 'Remove the stats MCP server from Claude Code'],
     ['mcp',       'Run the MCP server (stdio) — exposes your stats to Claude'],
     ['wrapped',   'Open your animated year-in-review (Claude Wrapped)'],
+    ['wrapped --publish', 'Put your Wrapped on the web at claude-rpc.com/wrapped/<handle>'],
     ['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)'],
@@ -2240,6 +2430,9 @@ process.on('unhandledRejection', (e) => {
     case 'dump':      showStatus(); break;
     case 'today':     showToday(); break;
     case 'week':      showWeek(); break;
+    case 'projects':  showProjects(process.argv.slice(3)); break;
+    case 'project':   showProject(process.argv[3]); break;
+    case 'compare':   showCompare(); break;
     case 'usage':     await showUsage(); break;
     case 'serve':     await import('./server/index.js'); break;
     case 'preview':   showPreview(); break;
@@ -2263,7 +2456,9 @@ process.on('unhandledRejection', (e) => {
       await doMcp();
       break;
     }
-    case 'wrapped':   process.env.CLAUDE_RPC_OPEN_PATH = '/wrapped'; await import('./server/index.js'); break;
+    case 'wrapped':
+      if (process.argv.slice(3).includes('--publish')) { await doWrappedPublish(process.argv.slice(3)); break; }
+      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;

package/src/community.js

@@ -24,6 +24,9 @@ import { platform } from 'node:os';
 import { AGGREGATE_PATH, STATE_DIR } from './paths.js';
 import { VERSION } from './version.js';
 import { profileIsPublishable } from './leaderboard.js';
+import { projectNameIsPrivate } from './privacy.js';
+import { cleanProjectName } from './scanner.js';
+import { humanModel } from './format.js';
 
 const CURSOR_PATH = join(STATE_DIR, 'community-cursor.json');
 
@@ -116,6 +119,152 @@ export function buildProfilePayload(aggregate, profileCfg, { instanceId, now = D
   };
 }
 
+// ── Claude Wrapped ───────────────────────────────────────────────────────
+//
+// Schema pair with the worker's validateWrapped/sanitizeWrapped — add fields
+// in BOTH places. Everything here is derived from aggregate.json; per-day
+// slices are year-scoped, and the few lifetime-only dimensions (languages,
+// tool mix, session lengths) are labeled as such on the page. Project names
+// pass the name-level privacy check AND the whole payload is shown to the
+// user before anything is sent — publish is a one-shot, explicit action.
+export function buildWrappedPayload(aggregate, config, { instanceId, year, now = Date.now() }) {
+  const agg = aggregate || {};
+  const y = year || new Date(now).getFullYear();
+  const days = Object.entries(agg.byDay || {}).filter(([k]) => k.startsWith(`${y}-`));
+
+  const sum = (f) => days.reduce((acc, [, d]) => acc + (d[f] || 0), 0);
+  const tokensOf = (d) => (d.inputTokens || 0) + (d.outputTokens || 0) + (d.cacheReadTokens || 0) + (d.cacheWriteTokens || 0);
+  const tokens = days.reduce((acc, [, d]) => acc + tokensOf(d), 0);
+  const cacheTokens = days.reduce((acc, [, d]) => acc + (d.cacheReadTokens || 0) + (d.cacheWriteTokens || 0), 0);
+
+  // Peak day by active time.
+  let peakDay = null;
+  for (const [date, d] of days) {
+    if ((d.activeMs || 0) > 0 && (!peakDay || d.activeMs > peakDay.activeMs)) {
+      peakDay = { date, activeMs: d.activeMs };
+    }
+  }
+
+  // Year-scoped project ranking from per-day attribution, privacy-filtered.
+  const projMs = {};
+  for (const [, d] of days) {
+    for (const [name, p] of Object.entries(d.projects || {})) {
+      projMs[name] = (projMs[name] || 0) + (p.activeMs || 0);
+    }
+  }
+  const topProjects = Object.entries(projMs)
+    .filter(([name]) => !projectNameIsPrivate(name, config, cleanProjectName))
+    .sort((a, b) => b[1] - a[1]).slice(0, 5)
+    .map(([name, activeMs]) => ({ name, activeMs }));
+
+  // Year-scoped model mix from the per-day byModel buckets (scan cache v7).
+  // Share is by SPEND, matching the local wrapped's "your models, by spend"
+  // slide; token share is the fallback when everything costed to zero. Names
+  // are humanized here so the web story renders "Opus 4.8", same as local.
+  const modelAgg = {};
+  for (const [, d] of days) {
+    for (const [m, v] of Object.entries(d.byModel || {})) {
+      const t = (modelAgg[m] ||= { tokens: 0, cost: 0 });
+      t.tokens += v.tokens || 0;
+      t.cost += v.cost || 0;
+    }
+  }
+  const costTotal = Object.values(modelAgg).reduce((a, b) => a + b.cost, 0);
+  const tokTotal = Object.values(modelAgg).reduce((a, b) => a + b.tokens, 0);
+  const share = (v) => costTotal > 0 ? v.cost / costTotal : (tokTotal > 0 ? v.tokens / tokTotal : 0);
+  const topModels = Object.entries(modelAgg).sort((a, b) => share(b[1]) - share(a[1])).slice(0, 4)
+    .map(([name, v]) => ({ name: humanModel(name) || name, pct: Math.round(share(v) * 100) }));
+
+  // Lifetime dimensions (no yearly slice exists for these).
+  const toolTotal = Object.values(agg.toolBreakdown || {}).reduce((a, b) => a + b, 0);
+  const toolMix = Object.entries(agg.toolBreakdown || {}).sort((a, b) => b[1] - a[1]).slice(0, 3)
+    .map(([name, n]) => ({ name, pct: toolTotal ? Math.round((n / toolTotal) * 100) : 0 }));
+  const topLanguages = Object.entries(agg.languages || {})
+    .sort((a, b) => (b[1].edits || 0) - (a[1].edits || 0)).slice(0, 5)
+    .map(([name, v]) => ({ name, edits: v.edits || 0 }));
+  const sl = agg.sessionLengths || {};
+  const marathonPct = sl.count ? Math.round((((sl.buckets?.h2to4 || 0) + (sl.buckets?.gt4h || 0)) / sl.count) * 100) : 0;
+
+  // The hotspot file (basename only, never a path) and peak weekday — the two
+  // remaining slides of the local story. Both lifetime, like the local page.
+  const top = (agg.topEditedFiles || [])[0] || null;
+  const hotName = top ? String(top.path || '').split(/[\\/]/).pop() : null;
+  const hotspot = top && hotName && !projectNameIsPrivate(hotName, config, cleanProjectName)
+    ? { name: hotName, count: top.count || 0, ...(top.daysSinceLastEdit != null ? { daysSinceLastEdit: top.daysSinceLastEdit } : {}) }
+    : null;
+  let peakWeekday = null;
+  {
+    const WD = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+    for (const [k, v] of Object.entries(agg.byWeekday || {})) {
+      if ((v.activeMs || 0) > 0 && (!peakWeekday || v.activeMs > peakWeekday.activeMs)) {
+        peakWeekday = { name: WD[Number(k)] || '', activeMs: v.activeMs };
+      }
+    }
+  }
+
+  const compactions = Object.entries(agg.compactionsByDay || {})
+    .filter(([k]) => k.startsWith(`${y}-`)).reduce((acc, [, n]) => acc + n, 0);
+
+  return {
+    instanceId,
+    year: y,
+    wrapped: {
+      activeMs: sum('activeMs'),
+      sessions: sum('sessions'),
+      tokens,
+      prompts: sum('userMessages'),
+      streakBest: agg.longestStreak || 0,
+      streak: agg.streak || 0,
+      daysSinceFirst: agg.daysSinceFirst || 0,
+      daysActive: days.filter(([, d]) => (d.activeMs || 0) > 0 || (d.userMessages || 0) > 0).length,
+      linesAdded: sum('linesAdded'),
+      linesRemoved: sum('linesRemoved'),
+      ships: sum('ships'),
+      cachePct: tokens ? Math.round((cacheTokens / tokens) * 100) : 0,
+      peakHour: agg.peakHour?.hour ?? 0,
+      ...(peakDay ? { peakDay } : {}),
+      longestSessionMs: sl.longestMs || 0,
+      marathonPct,
+      compactions,
+      subagentActiveMs: agg.subagentActiveMs || 0,
+      costUsd: Math.round(sum('cost') * 100) / 100,
+      topProjects,
+      topLanguages,
+      topModels,
+      toolMix,
+      ...(hotspot ? { hotspot } : {}),
+      ...(peakWeekday ? { peakWeekday } : {}),
+    },
+  };
+}
+
+// One-shot POST of a built wrapped payload. Mirrors flushProfile's error
+// contract: never throws, returns { ok, reason?, url? }.
+export async function publishWrapped(cfg, payload, { fetchImpl = globalThis.fetch } = {}) {
+  const community = cfg?.community || {};
+  if (!community.endpoint) return { ok: false, reason: 'no-endpoint' };
+  const url = community.endpoint.replace(/\/+$/, '') + '/wrapped';
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(10_000),
+    });
+  } catch (e) {
+    return { ok: false, reason: 'network', error: e.message };
+  }
+  let body = null;
+  try { body = await res.json(); } catch { /* non-JSON error body */ }
+  if (!res.ok) {
+    if (res.status === 403) return { ok: false, reason: 'no-profile' };
+    if (res.status === 429) return { ok: false, reason: 'rate-limited' };
+    return { ok: false, reason: `http-${res.status}`, error: body?.error };
+  }
+  return { ok: true, url: body?.url, handle: body?.handle, year: body?.year };
+}
+
 export async function flushProfile(cfg, {
   aggregatePath = AGGREGATE_PATH,
   fetchImpl = globalThis.fetch,

package/src/daemon.js

@@ -6,7 +6,7 @@ import { Client } from './discord-ipc.js';
 import { readState, sweepStaleStateTmp, listSessionStates, sweepStaleSessionStates } from './state.js';
 import { makeRotationCursor, pickFrames, selectFrame, resolveLargeImageKey, shouldShowGithubButton, pickActiveSession, throttleDecision } from './presence.js';
 import { buildVars, fillTemplate, framePasses, applyIdle, applyShipped, applyTrigger } from './format.js';
-import { scan, readAggregate, findLiveSessions, readSessionTokens } from './scanner.js';
+import { scan, readAggregate, findLiveSessions, readSessionTokens, readSessionModel } from './scanner.js';
 import { detectGithubUrl } from './git.js';
 import { applyPrivacy } from './privacy.js';
 import { pauseUntil } from './pause.js';
@@ -167,9 +167,17 @@ if (ownerPid) {
 }
 
 // Reclaim any per-pid state tmp files orphaned by a hard-killed writer, plus
-// per-session state files from sessions that ended long ago.
+// per-session state files from sessions that ended long ago. The session-state
+// sweep repeats every 30 min — a daemon runs for weeks, and every file left
+// behind is re-read by listSessionStates on every render tick, so boot-only
+// sweeping leaks both disk and per-tick CPU.
 sweepStaleStateTmp();
 sweepStaleSessionStates();
+const sweepTimer = setInterval(() => {
+  sweepStaleStateTmp();
+  sweepStaleSessionStates();
+}, 30 * 60 * 1000);
+if (sweepTimer.unref) sweepTimer.unref();
 
 // pickFrames / selectFrame / resolveLargeImageKey now live in presence.js (pure
 // + unit-tested). The rotation cursor (rotationCursor) is owned here and passed
@@ -228,6 +236,11 @@ function resolvePresence(opts = {}) {
     if (match) {
       const t = readSessionTokens(match.path);
       if (t) state.tokens = t;
+      // The hook only learns the model at SessionStart; a mid-session /model
+      // switch is visible only in the transcript. Render-time override — the
+      // state file stays hook-owned.
+      const liveModel = readSessionModel(match.path);
+      if (liveModel) state.model = liveModel;
     }
   }
 

package/src/format.js

@@ -1,6 +1,6 @@
 import { basename, dirname, extname } from 'node:path';
 import { dayKey, weekKey, DATE_SUFFIX_RE, cleanProjectName } from './scanner.js';
-import { fmtCost } from './pricing.js';
+import { fmtCost, ratesFor } from './pricing.js';
 import { languageOf } from './languages.js';
 import { detectGitBranch, detectGitRepo } from './git.js';
 import { fmtResetTime, fmtResetDay } from './usage.js';
@@ -296,6 +296,27 @@ export function buildVars(state, config, aggregate) {
   const totalToolCalls = mcpCalls + builtinCalls;
   const mcpPct = totalToolCalls > 0 ? Math.round((mcpCalls / totalToolCalls) * 100) : 0;
 
+  // Tool mix — the actual top tools (Read/Edit/Bash…), not just the MCP split.
+  const toolCallsTotal = Object.values(agg.toolBreakdown || {}).reduce((a, b) => a + b, 0);
+  const toolsTop = topN(agg.toolBreakdown, 3);
+  const topToolEntry = toolsTop[0] || null;
+  const toolMixLabel = toolCallsTotal > 0
+    ? toolsTop.map(([name, n]) => `${name} ${Math.round((n / toolCallsTotal) * 100)}%`).join(' · ')
+    : '';
+
+  // Peak weekday by active time — byWeekday holds one blankDay bucket per 0–6.
+  const WEEKDAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+  let peakWd = null;
+  for (const [wd, b] of Object.entries(agg.byWeekday || {})) {
+    if ((b.activeMs || 0) > 0 && (!peakWd || b.activeMs > peakWd.activeMs)) {
+      peakWd = { name: WEEKDAY_NAMES[Number(wd)] || '', activeMs: b.activeMs };
+    }
+  }
+
+  // Context compactions — appended by the PreCompact hook since v0.8, counted
+  // into the aggregate since v1.2.
+  const compactionsToday = (agg.compactionsByDay || {})[dayKey(Date.now())] || 0;
+
   // Cost.
   const todayCost = today.cost || 0;
   const weekCost = thisWeek.cost || 0;
@@ -389,6 +410,12 @@ export function buildVars(state, config, aggregate) {
   const TOOL_ELAPSED_THRESHOLD_MS = 5_000;
   const toolElapsed = toolMs >= TOOL_ELAPSED_THRESHOLD_MS ? fmtToolElapsed(toolMs) : '';
 
+  // What cache reuse saved vs. paying fresh-input rates for the same tokens —
+  // an estimate priced at the top-by-spend model's rates (DEFAULT when unknown).
+  const savingsRates = ratesFor(topModelEntry?.model || '');
+  const cacheSavedUsd = ((agg.cacheReadTokens || 0) / 1e6)
+    * Math.max(0, (savingsRates.input || 0) - (savingsRates.cacheRead || 0));
+
   // Compaction vars — populated only while a compaction is in flight so
   // the {compactDuration} suffix in the compacting template collapses
   // away naturally otherwise (via fillTemplate's `·` collapse).
@@ -724,6 +751,26 @@ export function buildVars(state, config, aggregate) {
     builtinToolCallsFmt: fmtNum(builtinCalls),
     mcpToolPercent: mcpPct,
     mcpToolPercentLabel: totalToolCalls ? `${mcpPct}% MCP` : '',
+    // Tool mix (v1.2) — the actual top tools, lifetime.
+    topTool: topToolEntry ? topToolEntry[0] : '',
+    topToolCount: topToolEntry ? topToolEntry[1] : 0,
+    topToolLabel: topToolEntry ? `${topToolEntry[0]} × ${fmtNum(topToolEntry[1])}` : '',
+    toolMixLabel,
+
+    // ── Delegated work / rhythm / context (v1.2) ────────────────
+    subagentActiveMs: agg.subagentActiveMs || 0,
+    subagentHours: fmtHours(agg.subagentActiveMs || 0),
+    subagentHoursLabel: (agg.subagentActiveMs || 0) > 0
+      ? `${fmtHours(agg.subagentActiveMs)} delegated` : '',
+    peakWeekday: peakWd ? peakWd.name : '',
+    peakWeekdayLabel: peakWd ? `busiest on ${peakWd.name}s` : '',
+    compactions: agg.compactions || 0,
+    compactionsToday,
+    compactionsTodayLabel: compactionsToday > 0
+      ? `${compactionsToday} context squeeze${compactionsToday === 1 ? '' : 's'} today` : '',
+    cacheSavedUsd,
+    cacheSavedFmt: fmtCost(cacheSavedUsd),
+    cacheSavedLabel: cacheSavedUsd >= 1 ? `≈${fmtCost(cacheSavedUsd)} saved by cache` : '',
 
     // ── Cost ────────────────────────────────────────────────────
     todayCost,

package/src/privacy.js

@@ -255,6 +255,30 @@ export function resolveVisibility(cwd, config = {}) {
   return { visibility: 'public', projectName: proj?.projectName ?? null, reason: 'default' };
 }
 
+// Name-level privacy check for surfaces that only have a project NAME, not a
+// cwd (the wrapped publish payload). Weaker than resolveVisibility — without a
+// cwd it can't read .claude-rpc.json or auto-detect gh-private — which is why
+// the wrapped publish ALSO shows the exact payload and asks before sending.
+// `clean` lets the caller pass scanner.cleanProjectName so list entries match
+// the cleaned names the aggregate uses (kept an argument to keep this module
+// import-light for the hook path).
+export function projectNameIsPrivate(name, config = {}, clean = (s) => s) {
+  if (!name) return true;
+  const n = String(name).toLowerCase();
+  const matches = (cwd) => {
+    const leaf = basename(cwd);
+    return leaf.toLowerCase() === n || String(clean(leaf)).toLowerCase() === n;
+  };
+  for (const cwd of listPrivateCwds()) if (matches(cwd)) return true;
+  for (const [cwd, level] of Object.entries(listVisibility())) {
+    if (level !== 'public' && matches(cwd)) return true;
+  }
+  for (const p of config?.privacy?.patterns || []) {
+    if (matchesPattern(n, p)) return true;
+  }
+  return false;
+}
+
 // Glob-lite. '*' matches any run; otherwise plain text. Case-insensitive.
 function matchesPattern(name, pattern) {
   if (pattern === name) return true;

package/src/scanner.js

@@ -11,7 +11,9 @@ import { classifyShip } from './ships.js';
 // v5: per-day ships/shipKinds + per-day project attribution (recap).
 // v6: day/week/hour buckets carry firstTs/lastTs (they were declared but
 //     never assigned, leaving {startTimeLabel} permanently blank).
-const CACHE_VERSION = 6;
+// v7: per-day byModel buckets in transcript summaries — bump forces the one
+// full rescan that backfills model-mix history for already-scanned files.
+const CACHE_VERSION = 7;
 
 // Cap counted gap between consecutive timestamps. Anything larger is treated
 // as the user walking away — we count only what's plausibly active time.
@@ -140,6 +142,8 @@ function blankDay() {
     //   shipKinds — { push|commit|pr|issue|tag → count } (only when a ship lands)
     //   projects  — { name → { activeMs, tokens } } (aggregate-level only,
     //               attributed at merge time where the file's project is known)
+    //   byModel   — { pricingKey → { turns, tokens, cost } } (day buckets only —
+    //               week/hour stay lean; powers model-mix-over-time)
   };
 }
 
@@ -160,6 +164,12 @@ function mergeDay(target, src) {
   for (const [k, n] of Object.entries(src.shipKinds || {})) {
     (target.shipKinds ||= {})[k] = (target.shipKinds[k] || 0) + n;
   }
+  for (const [m, v] of Object.entries(src.byModel || {})) {
+    const t = ((target.byModel ||= {})[m] ||= { turns: 0, tokens: 0, cost: 0 });
+    t.turns += v.turns || 0;
+    t.tokens += v.tokens || 0;
+    t.cost += v.cost || 0;
+  }
   if (src.firstTs && (!target.firstTs || src.firstTs < target.firstTs)) target.firstTs = src.firstTs;
   if (src.lastTs && (!target.lastTs || src.lastTs > target.lastTs)) target.lastTs = src.lastTs;
 }
@@ -336,6 +346,13 @@ function parseChunkInto(text, summary, pstate) {
           mb.tokens += (u.input_tokens || 0) + (u.output_tokens || 0)
                      + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0);
         }
+        // Per-day model split (day granularity only — week/hour stay lean).
+        // Powers model-mix-over-time; the all-time byModel can't trend.
+        if (mkey && dayBucket) {
+          const dm = ((dayBucket.byModel ||= {})[mkey] ||= { turns: 0, tokens: 0, cost: 0 });
+          dm.tokens += (u.input_tokens || 0) + (u.output_tokens || 0)
+                     + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0);
+        }
         // Per-turn cost — uses this turn's model id, not the session's first-seen one.
         const turnCost = costFor({ model: turnModel, usage: u });
         if (turnCost > 0) {
@@ -346,6 +363,10 @@ function parseChunkInto(text, summary, pstate) {
           const ck = mkey || 'sonnet';
           summary.costByModel[ck] = (summary.costByModel[ck] || 0) + turnCost;
           if (mb) mb.cost += turnCost;
+          if (dayBucket) {
+            const dm = ((dayBucket.byModel ||= {})[ck] ||= { turns: 0, tokens: 0, cost: 0 });
+            dm.cost += turnCost;
+          }
           for (const bucket of allBuckets) bucket.cost += turnCost;
         }
       }
@@ -354,6 +375,10 @@ function parseChunkInto(text, summary, pstate) {
         if (firstSeen) {
           summary.modelsUsed[turnModel] = (summary.modelsUsed[turnModel] || 0) + 1;
           if (mb) mb.turns += 1;
+          if (mkey && dayBucket) {
+            const dm = ((dayBucket.byModel ||= {})[mkey] ||= { turns: 0, tokens: 0, cost: 0 });
+            dm.turns += 1;
+          }
         }
       }
       const blocks = r.message?.content || [];
@@ -592,16 +617,29 @@ function readTranscriptCwd(path, mtimeMs) {
 // Per-transcript token cache. Reading a multi-MB .jsonl on every push tick
 // (4s) would be wasteful, so we only re-parse when the file's mtime has
 // advanced since the last read.
-const sessionTokenCache = new Map();  // path → { mtime, size, offset, tokens }
+const sessionTokenCache = new Map();  // path → { mtime, size, offset, tokens, seenIds, model }
 
 // Accumulate assistant-usage tokens from a chunk of complete JSONL lines.
-function sumUsageLines(text, tokens) {
+// Claude Code repeats the same `usage` object on every content-block line of
+// one assistant message, so count each message.id once (`seenIds`, the same
+// bounded-ring dedup parseChunkInto uses) — otherwise the live count drifts
+// above the lifetime aggregate on multi-block turns. Lines with no id
+// (rare/legacy) are counted every time, matching the full scanner. Also
+// captures the newest turn's model so a mid-session /model switch is visible.
+function sumUsageLines(text, tokens, seenIds, meta) {
   for (const line of iterLines(text)) {
     if (!line) continue;
     const r = safeJson(line);
     if (!r || r.type !== 'assistant') continue;
+    if (meta && r.message?.model) meta.model = r.message.model;
     const u = r.message?.usage;
     if (!u) continue;
+    const msgId = r.message?.id;
+    if (msgId && seenIds) {
+      if (seenIds.includes(msgId)) continue;
+      seenIds.push(msgId);
+      if (seenIds.length > RECENT_IDS_MAX) seenIds.shift();
+    }
     tokens.input      += u.input_tokens || 0;
     tokens.output     += u.output_tokens || 0;
     tokens.cacheRead  += u.cache_read_input_tokens || 0;
@@ -636,6 +674,8 @@ export function readSessionTokens(path) {
   const tokens = canAppend
     ? { ...cached.tokens }
     : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  const seenIds = canAppend ? (cached.seenIds || []) : [];
+  const meta = { model: canAppend ? cached.model : null };
   const startOffset = canAppend ? cached.offset : 0;
   let newOffset = startOffset;
 
@@ -654,7 +694,7 @@ export function readSessionTokens(path) {
       if (lastNl !== -1) {
         const complete = text.slice(0, lastNl + 1);
         newOffset = startOffset + Buffer.byteLength(complete, 'utf8');
-        sumUsageLines(complete, tokens);
+        sumUsageLines(complete, tokens, seenIds, meta);
       }
     }
   } catch {
@@ -665,10 +705,26 @@ export function readSessionTokens(path) {
     }
   }
 
-  lruTouch(sessionTokenCache, path, { mtime: st.mtimeMs, size: st.size, offset: newOffset, tokens });
+  lruTouch(sessionTokenCache, path, { mtime: st.mtimeMs, size: st.size, offset: newOffset, tokens, seenIds, model: meta.model });
   return tokens;
 }
 
+// Latest assistant-turn model seen in a transcript — the live answer to "which
+// model is this session on NOW". SessionStart is the only hook that carries a
+// model, so a mid-session /model switch never reaches the state file; the
+// transcript is the only source of truth. Piggybacks on readSessionTokens'
+// cache entry (same parse, same mtime discipline) — call it AFTER
+// readSessionTokens for O(1); standalone calls populate the cache themselves.
+export function readSessionModel(path) {
+  const cached = sessionTokenCache.get(path);
+  let mtime;
+  try { mtime = statSync(path).mtimeMs; } catch { return null; }
+  if (!cached || cached.mtime !== mtime) {
+    if (readSessionTokens(path) === null) return null;
+  }
+  return sessionTokenCache.get(path)?.model || null;
+}
+
 // Detect live sessions by transcript mtime. Returns array of { path, project, cwd, mtime, ageSec }.
 // A session is "live" if its .jsonl was modified within thresholdMs.
 // Roots default to the same set scan() uses — the canonical ~/.claude/projects
@@ -732,10 +788,12 @@ function writeCache(cache) {
 
 // Per-day notification counts come from a hook-side append log, since
 // transcripts don't carry Notification events reliably.
-function readNotificationsByDay() {
-  const out = {};
+function readEventsByDay() {
+  const out = { notifications: {}, compactions: {} };
   // The hook rotates events.jsonl to `.1` at 5MB; read both (oldest first) so a
-  // rotation doesn't silently drop a day's notification counts.
+  // rotation doesn't silently drop a day's counts. PreCompact events have been
+  // appended since the hook first shipped them — counting them here finally
+  // surfaces how hard sessions push context.
   for (const path of [EVENTS_LOG_PATH + '.1', EVENTS_LOG_PATH]) {
     if (!existsSync(path)) continue;
     try {
@@ -743,9 +801,13 @@ function readNotificationsByDay() {
       for (const line of raw.split('\n')) {
         if (!line) continue;
         const e = safeJson(line);
-        if (!e || e.type !== 'notification' || !e.ts) continue;
+        if (!e || !e.ts) continue;
+        const bucket = e.type === 'notification' ? out.notifications
+          : e.type === 'precompact' ? out.compactions
+          : null;
+        if (!bucket) continue;
         const k = dayKey(e.ts);
-        out[k] = (out[k] || 0) + 1;
+        bucket[k] = (bucket[k] || 0) + 1;
       }
     } catch { /* a rotation file unreadable/truncated — count what we can */ }
   }
@@ -772,6 +834,15 @@ export function aggregateFrom(cache) {
     sessions: 0,
     subagentRuns: 0,
     subagentActiveMs: 0,
+    // Session-length distribution (ACTIVE time, top-level sessions only —
+    // subagents overlap their parent). Wall clock was tried first and lies:
+    // a transcript left open across a week reads as a 170h "session".
+    // activeMs already excludes ≥5-min gaps, so it measures the sitting, not
+    // the tab. Histogram, not raw durations, to keep aggregate.json lean.
+    sessionLengths: {
+      count: 0, totalMs: 0, longestMs: 0,
+      buckets: { lt15m: 0, m15to30: 0, m30to60: 0, h1to2: 0, h2to4: 0, gt4h: 0 },
+    },
     inputTokens: 0,
     outputTokens: 0,
     cacheReadTokens: 0,
@@ -892,6 +963,12 @@ export function aggregateFrom(cache) {
           for (const [kind, n] of Object.entries(src.shipKinds || {})) {
             (target.shipKinds ||= {})[kind] = (target.shipKinds[kind] || 0) + n;
           }
+          for (const [m, v] of Object.entries(src.byModel || {})) {
+            const t = ((target.byModel ||= {})[m] ||= { turns: 0, tokens: 0, cost: 0 });
+            t.turns += v.turns || 0;
+            t.tokens += v.tokens || 0;
+            t.cost += v.cost || 0;
+          }
         }
       };
       mergeSubBuckets(summary.byDay, agg.byDay);
@@ -907,6 +984,17 @@ export function aggregateFrom(cache) {
       agg.userMessages += summary.userMessages || 0;
       agg.activeMs += summary.activeMs || 0;
       if (summary.firstTs && summary.lastTs) agg.wallMs += summary.lastTs - summary.firstTs;
+      const durMs = summary.activeMs || 0;
+      if (durMs > 0) {
+        const sl = agg.sessionLengths;
+        sl.count += 1;
+        sl.totalMs += durMs;
+        if (durMs > sl.longestMs) sl.longestMs = durMs;
+        const mins = durMs / 60_000;
+        const bucket = mins < 15 ? 'lt15m' : mins < 30 ? 'm15to30' : mins < 60 ? 'm30to60'
+          : mins < 120 ? 'h1to2' : mins < 240 ? 'h2to4' : 'gt4h';
+        sl.buckets[bucket] += 1;
+      }
       if (summary.project) {
         const p = agg.projects[summary.project] = agg.projects[summary.project] || {
           sessions: 0, activeMs: 0, inputTokens: 0, outputTokens: 0, userMessages: 0, toolCalls: 0,
@@ -1072,15 +1160,22 @@ export function aggregateFrom(cache) {
   // Folded line totals.
   agg.linesNet = (agg.linesAdded || 0) - (agg.linesRemoved || 0);
 
-  // Notifications from the hook-side append log.
-  const notifByDay = readNotificationsByDay();
+  // Notifications + compactions from the hook-side append log.
+  const events = readEventsByDay();
   let notifTotal = 0;
-  for (const [k, n] of Object.entries(notifByDay)) {
+  for (const [k, n] of Object.entries(events.notifications)) {
     const d = agg.byDay[k] ||= blankDay();
     d.notifications = (d.notifications || 0) + n;
     notifTotal += n;
   }
   agg.notifications = notifTotal;
+  let compactTotal = 0;
+  agg.compactionsByDay = {};
+  for (const [k, n] of Object.entries(events.compactions)) {
+    agg.compactionsByDay[k] = n;
+    compactTotal += n;
+  }
+  agg.compactions = compactTotal;
 
   return agg;
 }

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 = '1.1.4';
+const BAKED = '1.2.1';
 
 function readPkgVersion() {
   try {