claude-rpc 0.8.1 → 0.9.1

package/README.md

@@ -21,6 +21,7 @@ Your live model, project, current tool, tokens, and lifetime stats — in your D
 [![Claude Code](https://img.shields.io/badge/Claude%20Code-hooks-d97757.svg)](https://claude.com/claude-code)
 [![Discord RPC](https://img.shields.io/badge/Discord-RPC-5865F2.svg?logo=discord&logoColor=white)](https://discord.com/developers/docs/topics/rpc)
 [![Release](https://img.shields.io/github/v/release/rar-file/claude-rpc?color=4c1)](https://github.com/rar-file/claude-rpc/releases/latest)
+[![npm downloads](https://img.shields.io/npm/dm/claude-rpc?color=cb3837&logo=npm&logoColor=white&label=downloads)](https://www.npmjs.com/package/claude-rpc)
 
 </div>
 
@@ -253,6 +254,7 @@ The full default config is in [`src/default-config.js`](src/default-config.js)
 | `insights`       | Print 3–5 auto-generated lines about your week |
 | `badge`          | Shields-style SVG (`--metric` `--range` `--out` `--gist`) |
 | `card`           | Poster-style SVG (`--range year\|month\|week\|all`) |
+| `github-stat`    | Embeddable profile stat card (`--handle` `--out` `--gist`) |
 | `private` / `public` / `privacy` | Per-cwd visibility toggles + status |
 | `community`      | Opt-in community totals — `on` \| `off` \| `status` \| `report` |
 | `doctor`         | Diagnostic checklist with one-line fix hints |

package/package.json

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

@@ -750,6 +750,41 @@ async function doCard(argv) {
   }
 }
 
+// GitHub profile stat card — a compact, embeddable lifetime summary meant
+// for a profile README. `--gist` publishes it to a gist (raw URL stays stable
+// across re-runs) so the README image auto-refreshes when you re-run it.
+function parseGithubStatArgs(argv) {
+  const out = { out: '', gist: false, handle: '' };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--out' || a === '-o') out.out = argv[++i];
+    else if (a === '--handle' || a === '-u') out.handle = argv[++i];
+    else if (a === '--gist') out.gist = true;
+  }
+  return out;
+}
+
+async function doGithubStat(argv) {
+  const opts = parseGithubStatArgs(argv);
+  const aggregate = readAggregate();
+  if (!aggregate) {
+    fail('no aggregate yet — nothing to render', { hint: 'run `claude-rpc scan` first', code: EX_BAD_STATE });
+  }
+  const { renderProfileCard } = await import('./profile.js');
+  const svg = renderProfileCard(aggregate, { handle: opts.handle });
+  if (opts.gist) {
+    await publishBadgeToGist(svg, { metric: 'profile', range: 'all-time' });
+    return;
+  }
+  if (opts.out) {
+    writeFileSync(opts.out, svg);
+    console.log(`${c.green}✓${c.reset} Wrote ${c.cyan}${opts.out}${c.reset} (${svg.length} bytes)`);
+    console.log(`${c.dim}Embed in your README:  <img src="${opts.out}" alt="Claude Code stats" width="500" />${c.reset}`);
+  } else {
+    process.stdout.write(svg);
+  }
+}
+
 // ── Privacy commands ─────────────────────────────────────────────────────
 //
 // `claude-rpc private`        → add current cwd to ~/.claude-rpc/private-list.json
@@ -1039,6 +1074,7 @@ function help() {
     ['insights',  'Auto-generated insights from your history'],
     ['badge',     'Render a Shields-style SVG (--metric --range --out --gist)'],
     ['card',      'Render a poster-style SVG summary (--range year|month|week|all)'],
+    ['github-stat', 'Render an embeddable profile stat card (--handle --out --gist)'],
     ['private',   'Mark the current directory as private (hide from Discord)'],
     ['public',    'Un-mark the current directory'],
     ['privacy',   'Show resolved visibility for the current directory'],
@@ -1111,6 +1147,7 @@ const packagedDefault = IS_PACKAGED && !cmd;
     case 'insights':  showInsights(); break;
     case 'badge':     await doBadge(process.argv.slice(3)); break;
     case 'card':      await doCard(process.argv.slice(3)); break;
+    case 'github-stat': await doGithubStat(process.argv.slice(3)); break;
     case 'private':   doPrivate(); break;
     case 'public':    doPublic(); break;
     case 'privacy':   doPrivacy(); break;

package/src/default-config.js

@@ -21,12 +21,14 @@ export const DEFAULT_CONFIG = {
   // when Claude isn't open, the Discord presence should disappear quickly.
   // The SessionEnd hook short-circuits this — see hook.js + format.applyIdle.
   staleSessionMin: 5,
-  // When the Claude Code session is still open but its transcript has gone
-  // quiet (you paused, stepped away briefly), show 'idle' rather than
-  // clearing the card. Only an authoritative SessionEnd or the full
-  // staleSessionMin dormancy window drops to stale. Set false to restore the
-  // old behavior (clear ~90-120s after the last transcript write).
-  idleWhenOpen: true,
+  // Closing the terminal kills Claude Code without firing its SessionEnd hook,
+  // so the daemon can't tell "closed" from "paused" — it only sees the
+  // transcript stop. Default false: clear the card ~90-120s after the
+  // transcript goes quiet, so a closed terminal doesn't leave a stale card up.
+  // Set true to instead linger as 'idle' until staleSessionMin (keeps the card
+  // up through short pauses, at the cost of a closed terminal showing idle for
+  // up to staleSessionMin minutes before clearing).
+  idleWhenOpen: false,
   // When true, the daemon CLEARS Discord activity entirely once the state
   // goes stale — your profile shows nothing instead of an "Away" frame.
   hideWhenStale: true,
@@ -87,6 +89,11 @@ export const DEFAULT_CONFIG = {
         details: "Working in {project}",
         state:   "{currentToolPretty} · {currentFilePretty} · {toolElapsed} · {tokensLabel}",
         largeImageText: "Working on a {fileLang} file",
+        rotation: [
+          // Pops in for ~5min when the session crosses an hour milestone, then
+          // the `requires` gate drops it and we're back to the single frame.
+          { details: "{sessionMilestoneLabel} · {project}", state: "{tokensLabel} · {messagesLabel}", requires: ["sessionMilestoneHit"] },
+        ],
       },
       thinking: {
         details: "Thinking in {project}",
@@ -99,7 +106,9 @@ export const DEFAULT_CONFIG = {
         largeImageText: "Compacting · {compactTriggerLabel}",
       },
       shipped: {
-        details: "Just shipped in {project}",
+        // {justShippedLabel} adapts to the action: "Pushed to main",
+        // "Committed on feat/x", "Opened a pull request", "Opened an issue".
+        details: "{justShippedLabel} · {project}",
         state:   "{lastCommit}",
         largeImageText: "{justShippedLabel}",
       },
@@ -115,9 +124,11 @@ export const DEFAULT_CONFIG = {
         rotation: [
           { details: "This week · {weekHours}",                state: "{weekPromptsLabel} · {weekTokensFmt} tokens", requires: ["weekActiveMs"] },
           { details: "{streakLabel}",                          state: "{daysSinceFirstLabel} · {allSessionsLabel}",  requires: ["streakIsMilestone"] },
-          { details: "Hotspot · {topEditedFile}",              state: "{topEditedCountLabel} all-time",              requires: ["topEditedCount"] },
+          { details: "Hotspot · {topEditedFile}",              state: "{topEditedCountLabel} · {topEditedAgeLabel}", requires: ["topEditedCount"] },
+          { details: "Model split",                            state: "{modelSplitLabel}",                          requires: ["modelSplitLabel"] },
           { details: "{allHours} on Claude all-time",          state: "{allSessionsLabel} · {allMessagesFmt} prompts", requires: ["allSessions"] },
           { details: "Lifetime · {allTokensFmt} tokens",       state: "{allToolsFmt} tool calls · {allFilesFmt} files", requires: ["allTools"] },
+          { details: "{allFreshTokensFmt} fresh tokens",       state: "{allCachePctLabel}",                         requires: ["allCachePctLabel"] },
           { details: "Code churn · {linesAddedFmt} added",     state: "{linesNetFmt} net · {topLanguage}",            requires: ["topLanguage"] },
           { details: "Cost · {todayCostFmt} today",            state: "{allCostFmt} all-time",                        requires: ["allCost"] },
         ],

package/src/format.js

@@ -317,6 +317,31 @@ export function buildVars(state, config, aggregate) {
     && (streak % 7 === 0 || streak === 30 || streak === 60 || streak === 100 || streak === 365)
     ? 1 : 0;
 
+  // Session-duration milestones — surface a celebratory frame for a few
+  // minutes after the live session crosses 1h/2h/3h/5h/8h/12h. Stateless:
+  // derived from elapsed duration, so no per-session bookkeeping is needed.
+  const SESSION_MILESTONES_H = [1, 2, 3, 5, 8, 12];
+  let sessionMilestoneHit = 0;
+  let sessionMilestoneLabel = '';
+  if (sessionActive && duration > 0) {
+    for (const h of SESSION_MILESTONES_H) {
+      const t = h * 3_600_000;
+      if (duration >= t && duration - t < 5 * 60_000) {
+        sessionMilestoneHit = 1;
+        sessionMilestoneLabel = `${h}-hour session`;
+      }
+    }
+  }
+
+  // Model split — per-model share of all-time spend, biggest first.
+  const modelSplit = Array.isArray(agg.modelSplit) ? agg.modelSplit : [];
+  const topModelEntry = modelSplit[0] || null;
+  const modelSplitLabel = modelSplit
+    .slice(0, 3)
+    .filter((m) => (m.costPct || 0) > 0)
+    .map((m) => `${humanModel(m.model)} ${Math.round(m.costPct * 100)}%`)
+    .join(' · ');
+
   // Idle duration for sleeker idle copy.
   const idleMs = state.status === 'idle' && state.lastActivity
     ? Math.max(0, Date.now() - state.lastActivity)
@@ -448,7 +473,13 @@ export function buildVars(state, config, aggregate) {
       ? (state.justShippedBranch ? `Pushed to ${state.justShippedBranch}` : 'Pushed')
       : state.justShippedKind === 'commit'
         ? (state.justShippedBranch ? `Committed on ${state.justShippedBranch}` : 'Committed')
-        : '',
+        : state.justShippedKind === 'pr'
+          ? 'Opened a pull request'
+          : state.justShippedKind === 'issue'
+            ? 'Opened an issue'
+            : state.justShippedKind === 'tag'
+              ? (state.justShippedBranch ? `Tagged ${state.justShippedBranch}` : 'Tagged a release')
+              : '',
     // {lastCommit} reads more naturally than {justShippedSubject} in user templates.
     lastCommit: state.justShippedSubject || '',
 
@@ -477,6 +508,20 @@ export function buildVars(state, config, aggregate) {
     allCacheTokens: fmtNum(allCache),
     allCacheReadTokens: fmtNum(allCacheRead),
     allCacheWriteTokens: fmtNum(allCacheWrite),
+    // Fresh (input+output) vs cache breakdown — clarifies the lumped total so
+    // "X tokens" isn't mistaken for billable spend (most of it is cheap cache).
+    allFreshTokens: allReal,
+    allFreshTokensFmt: fmtNum(allReal),
+    allCachePct: allTotal > 0 ? Math.round((allCache / allTotal) * 100) : 0,
+    allCachePctLabel: allTotal > 0 ? `${Math.round((allCache / allTotal) * 100)}% from cache` : '',
+    // Model split (v0.9) — top model by spend + a compact share label.
+    topModel: topModelEntry ? topModelEntry.model : '',
+    topModelPretty: topModelEntry ? humanModel(topModelEntry.model) : '',
+    topModelCostPct: topModelEntry ? Math.round((topModelEntry.costPct || 0) * 100) : 0,
+    topModelShareLabel: topModelEntry && (topModelEntry.costPct || 0) > 0
+      ? `${humanModel(topModelEntry.model)} · ${Math.round(topModelEntry.costPct * 100)}% of spend`
+      : '',
+    modelSplitLabel,
     allHours: fmtHours(agg.activeMs || 0),
     allWallHours: fmtHours(agg.wallMs || 0),
     allMessages: agg.userMessages || 0,
@@ -543,6 +588,12 @@ export function buildVars(state, config, aggregate) {
     topEditedFile: hotspot ? basename(hotspot.path) : '',
     topEditedCount: hotspot?.count || 0,
     topEditedCountLabel: hotspot ? plural(hotspot.count, 'edit') : '0 edits',
+    // Hotspot aging — how long since the top file was last touched.
+    topEditedDaysAgo: hotspot && hotspot.daysSinceLastEdit != null ? hotspot.daysSinceLastEdit : null,
+    topEditedAgeLabel: !hotspot || hotspot.daysSinceLastEdit == null ? ''
+      : hotspot.daysSinceLastEdit === 0 ? 'edited today'
+      : hotspot.daysSinceLastEdit === 1 ? 'edited yesterday'
+      : `${hotspot.daysSinceLastEdit}d since last edit`,
 
     // Per-project (current cwd's project)
     projectHours: projectStats ? fmtHours(projectStats.activeMs || 0) : '0h',
@@ -555,6 +606,9 @@ export function buildVars(state, config, aggregate) {
 
     // Streak milestone gate (for special rotation frame)
     streakIsMilestone,
+    // Session-duration milestone gate + label (v0.9)
+    sessionMilestoneHit,
+    sessionMilestoneLabel,
 
     // ── Code churn ───────────────────────────────────────────────
     linesAdded: allLinesAdded,
@@ -682,12 +736,13 @@ export function applyIdle(state, cfg = {}) {
   const idleMs = (cfg.idleThresholdSec || 60) * 1000;
   const staleMs = Math.max(60_000, (cfg.staleSessionMin || 5) * 60 * 1000);
   const notificationMs = (cfg.notificationWindowSec || 8) * 1000;
-  // When the Claude Code session is still open (no authoritative SessionEnd)
-  // but its transcript has gone quiet, prefer 'idle' over clearing the card.
-  // Only an explicit close (claudeClosed) or the staleMs dormancy backstop
-  // drops us to stale. Default on; set idleWhenOpen:false to restore the old
-  // aggressive ~90-120s clear when no transcript is being written.
-  const idleWhenOpen = cfg.idleWhenOpen !== false;
+  // Closing the terminal kills Claude Code without firing SessionEnd, so the
+  // only passive "is it gone?" signal is "no transcript is being written".
+  // DEFAULT (false): clear the card within ~90-120s of the transcript going
+  // quiet — a closed terminal shouldn't leave a card up for 5 minutes. Opt in
+  // with idleWhenOpen:true to instead linger as 'idle' until the staleMs
+  // backstop (keeps the card up through short pauses with the terminal open).
+  const idleWhenOpen = cfg.idleWhenOpen === true;
 
   // Authoritative close signal from the SessionEnd hook — trust it instead
   // of waiting on staleSessionMin. Any other hook clears the flag, so a

package/src/hook.js

@@ -5,10 +5,24 @@ import { updateState, resetState, pushUnique, shortFile } from './state.js';
 import { detectLastCommitSubject, detectGitBranch } from './git.js';
 import { EVENTS_LOG_PATH } from './paths.js';
 
-// Match the bash invocations we treat as "just shipped" — captures the
-// verb (push / commit) for state.justShippedKind. Tolerates extra args,
-// leading env vars, and chained commands ("git add . && git commit -m ...").
-const GIT_SHIP_RE = /(?:^|[;&|]|\s)git\s+(push|commit)(?:\s|$)/;
+// 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|$)/ },
+];
+
+// Return the "shipped" kind for a shell command, or null. Exported for tests.
+export function classifyShip(cmd) {
+  const s = String(cmd || '');
+  for (const p of SHIP_PATTERNS) if (p.re.test(s)) return p.kind;
+  return null;
+}
 
 const EVENTS_LOG_ROTATE_BYTES = 5 * 1024 * 1024;
 
@@ -112,13 +126,15 @@ export function processHookEvent(event, input = {}) {
       let shipSubject = null;
       let shipBranch = null;
       if (toolName === 'Bash') {
-        const cmd = String(toolInput.command || '');
-        const m = cmd.match(GIT_SHIP_RE);
-        if (m) {
-          shipKind = m[1];
+        shipKind = classifyShip(toolInput.command);
+        if (shipKind) {
           const shipCwd = input.cwd || process.cwd();
-          shipSubject = detectLastCommitSubject(shipCwd) || null;
           shipBranch = detectGitBranch(shipCwd) || null;
+          // Only commit/push carry a meaningful "what shipped" subject; a PR
+          // or issue creation doesn't map to a commit message.
+          if (shipKind === 'commit' || shipKind === 'push') {
+            shipSubject = detectLastCommitSubject(shipCwd) || null;
+          }
         }
       }
       updateState((s) => {

package/src/profile.js

@@ -0,0 +1,160 @@
+// GitHub-profile stat card — a compact, embeddable SVG summary of your
+// all-time Claude Code stats, meant to drop into a profile README via a
+// raw gist URL (see `claude-rpc github-stat --gist`). Same paper/terracotta
+// brand as the poster card (card.js); smaller and lifetime-focused.
+//
+// Output is pure SVG — GitHub renders it inline in a README <img>.
+
+import { fmtCost } from './pricing.js';
+import { VERSION } from './version.js';
+
+const W = 520;
+const H = 240;
+
+const PALETTE = {
+  paper:  '#f4ede0',
+  paper2: '#ebe2d2',
+  paper3: '#e1d6c0',
+  ink:    '#1a1611',
+  inkMute:'#5c5147',
+  inkFaint:'#8a7c6d',
+  rust:   '#c2491e',
+  tape:   '#f2d76e',
+  grass:  '#4a9462',
+  blurple:'#5865f2',
+};
+
+function escapeXml(s) {
+  return String(s == null ? '' : s)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function fmtNum(n) {
+  if (!n) return '0';
+  if (n < 1000) return String(Math.round(n));
+  if (n < 1_000_000) return `${(n / 1000).toFixed(1)}k`;
+  if (n < 1_000_000_000) return `${(n / 1_000_000).toFixed(2)}M`;
+  return `${(n / 1_000_000_000).toFixed(2)}B`;
+}
+
+function fmtHours(ms) {
+  if (!ms || ms < 0) return '0h';
+  const h = ms / 3_600_000;
+  if (h < 1) return `${Math.round(h * 60)}m`;
+  if (h < 10) return `${h.toFixed(1)}h`;
+  return `${Math.round(h)}h`;
+}
+
+function topLanguage(aggregate) {
+  const langs = aggregate?.languages || {};
+  let best = null;
+  for (const [name, v] of Object.entries(langs)) {
+    if (!best || (v.edits || 0) > (best.edits || 0)) best = { name, edits: v.edits || 0 };
+  }
+  return best;
+}
+
+// One "LABEL / value" stat cell. Label in mono caps above a display-font value.
+function statCell(x, y, label, value, accent = PALETTE.ink) {
+  return `
+  <text x="${x}" y="${y}"
+        font-family="JetBrains Mono, ui-monospace, monospace"
+        font-size="11" font-weight="700" letter-spacing="2"
+        fill="${PALETTE.inkMute}">${escapeXml(label.toUpperCase())}</text>
+  <text x="${x}" y="${y + 28}"
+        font-family="Space Grotesk, Inter, system-ui, sans-serif"
+        font-size="26" font-weight="800" letter-spacing="-0.5"
+        fill="${accent}">${escapeXml(value)}</text>`;
+}
+
+function tapeSticker(x, y, text, { rotate = 3 } = {}) {
+  const pad = 11;
+  const fontSize = 12;
+  const w = text.length * 7.6 + pad * 2;
+  const h = fontSize + 11;
+  return `
+  <g transform="translate(${x} ${y}) rotate(${rotate})">
+    <rect x="0" y="0" width="${w}" height="${h}" fill="${PALETTE.tape}" stroke="${PALETTE.ink}" stroke-width="1.5"/>
+    <text x="${w / 2}" y="${h / 2 + 4.5}"
+          font-family="JetBrains Mono, ui-monospace, monospace"
+          font-size="${fontSize}" font-weight="700" letter-spacing="1.2"
+          text-anchor="middle" fill="${PALETTE.ink}">${escapeXml(text.toUpperCase())}</text>
+  </g>`;
+}
+
+// Lifetime totals straight off the aggregate (not windowed — a profile card
+// is an all-time brag).
+function lifetime(aggregate) {
+  const a = aggregate || {};
+  const tokens = (a.inputTokens || 0) + (a.outputTokens || 0)
+               + (a.cacheReadTokens || 0) + (a.cacheWriteTokens || 0);
+  const linesNet = a.linesNet ?? ((a.linesAdded || 0) - (a.linesRemoved || 0));
+  return {
+    hours: a.activeMs || 0,
+    sessions: a.sessions || 0,
+    prompts: a.userMessages || 0,
+    tokens,
+    streak: a.streak || 0,
+    longestStreak: a.longestStreak || 0,
+    linesNet,
+    cost: a.estimatedCost || 0,
+    daysSinceFirst: a.daysSinceFirst || 0,
+  };
+}
+
+export function renderProfileCard(aggregate, { handle = '', generatedAt = new Date() } = {}) {
+  const t = lifetime(aggregate);
+  const lang = topLanguage(aggregate);
+  const who = handle ? `@${String(handle).replace(/^@/, '')}` : 'on Claude Code';
+  const sub = `${who} · Day ${t.daysSinceFirst} · as of ${generatedAt.toISOString().slice(0, 10)}`;
+  const netStr = `${t.linesNet >= 0 ? '+' : '−'}${fmtNum(Math.abs(t.linesNet))}`;
+
+  // 3 columns × 2 rows of stats.
+  const C = [40, 210, 380];
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${W} ${H}" width="${W}" height="${H}" role="img" aria-label="Claude Code stats">
+  <defs>
+    <pattern id="dg" width="22" height="22" patternUnits="userSpaceOnUse">
+      <circle cx="1" cy="1" r="1" fill="${PALETTE.ink}" opacity="0.06"/>
+    </pattern>
+  </defs>
+  <rect x="3" y="4" width="${W - 6}" height="${H - 7}" fill="${PALETTE.ink}"/>
+  <rect x="0.75" y="0.75" width="${W - 7}" height="${H - 9}" fill="${PALETTE.paper}" stroke="${PALETTE.ink}" stroke-width="1.5"/>
+  <rect x="0.75" y="0.75" width="${W - 7}" height="${H - 9}" fill="url(#dg)"/>
+
+  <!-- header -->
+  <text x="40" y="50"
+        font-family="Space Grotesk, Inter, system-ui, sans-serif"
+        font-size="30" font-weight="800" letter-spacing="-1"
+        fill="${PALETTE.ink}">Claude Code</text>
+  <text x="40" y="72"
+        font-family="JetBrains Mono, ui-monospace, monospace"
+        font-size="12" fill="${PALETTE.inkMute}">${escapeXml(sub)}</text>
+  ${lang ? tapeSticker(W - 150, 28, lang.name, { rotate: 3 }) : ''}
+
+  <line x1="40" y1="92" x2="${W - 40}" y2="92" stroke="${PALETTE.ink}" stroke-width="1" opacity="0.18"/>
+
+  <!-- stat grid: row 1 -->
+  ${statCell(C[0], 120, 'Time with Claude', fmtHours(t.hours), PALETTE.rust)}
+  ${statCell(C[1], 120, 'Sessions', fmtNum(t.sessions))}
+  ${statCell(C[2], 120, 'Streak', t.streak ? `${t.streak}d` : '—')}
+
+  <!-- stat grid: row 2 -->
+  ${statCell(C[0], 184, 'Prompts', fmtNum(t.prompts))}
+  ${statCell(C[1], 184, 'Tokens', fmtNum(t.tokens))}
+  ${statCell(C[2], 184, 'Lines', netStr, PALETTE.grass)}
+
+  <!-- footer -->
+  <text x="40" y="${H - 18}"
+        font-family="JetBrains Mono, ui-monospace, monospace"
+        font-size="11" fill="${PALETTE.inkFaint}">${escapeXml(`best streak ${t.longestStreak}d · ≈${fmtCost(t.cost)} · claude-rpc v${VERSION}`)}</text>
+</svg>`;
+}
+
+// Top-level convenience matching badge.js / card.js shape.
+export function profileCardSvg({ aggregate, handle = '' } = {}) {
+  return renderProfileCard(aggregate, { handle });
+}

package/src/scanner.js

@@ -7,7 +7,7 @@ import { costFor, pricingKeyFor } from './pricing.js';
 
 // Bumping this forces a full re-parse on next scan. Increment whenever the
 // per-transcript summary schema changes in a way old caches can't satisfy.
-const CACHE_VERSION = 2;
+const CACHE_VERSION = 3;
 
 // Cap counted gap between consecutive timestamps. Anything larger is treated
 // as the user walking away — we count only what's plausibly active time.
@@ -175,6 +175,7 @@ export function parseTranscript(filePath) {
     byWeek: {},    // ISO week key → blankDay
     byHour: {},    // hour-of-day (0..23) → blankDay
     fileEdits: {}, // absolute path → edit count
+    fileEditTs: {}, // absolute path → most-recent edit timestamp (hotspot aging)
     // Phase 1 enrichments
     linesAdded: 0,
     linesRemoved: 0,
@@ -184,6 +185,7 @@ export function parseTranscript(filePath) {
     cost: 0,              // estimated USD
     costByModel: {},      // pricing key → USD
     modelsUsed: {},       // raw model id → assistant turns
+    byModel: {},          // pricing key → { turns, tokens, cost } (model split)
   };
   const fileSet = new Set();
   // Records in their original order, retaining timestamps for per-day bucketing.
@@ -210,6 +212,9 @@ export function parseTranscript(filePath) {
     if (r.type === 'assistant') {
       const turnModel = r.message?.model || summary.model;
       const u = r.message?.usage;
+      // Per-model split bucket, keyed by pricing key so cost/tokens/turns align.
+      const mkey = turnModel ? pricingKeyFor(turnModel) : null;
+      const mb = mkey ? (summary.byModel[mkey] ||= { turns: 0, tokens: 0, cost: 0 }) : null;
       if (u) {
         summary.inputTokens += u.input_tokens || 0;
         summary.outputTokens += u.output_tokens || 0;
@@ -221,18 +226,23 @@ export function parseTranscript(filePath) {
           bucket.cacheReadTokens += u.cache_read_input_tokens || 0;
           bucket.cacheWriteTokens += u.cache_creation_input_tokens || 0;
         }
+        if (mb) {
+          mb.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) {
           summary.cost += turnCost;
-          const key = pricingKeyFor(turnModel);
-          summary.costByModel[key] = (summary.costByModel[key] || 0) + turnCost;
+          summary.costByModel[mkey] = (summary.costByModel[mkey] || 0) + turnCost;
+          if (mb) mb.cost += turnCost;
           for (const bucket of allBuckets) bucket.cost += turnCost;
         }
       }
       if (turnModel) {
         if (!summary.model) summary.model = turnModel;
         summary.modelsUsed[turnModel] = (summary.modelsUsed[turnModel] || 0) + 1;
+        if (mb) mb.turns += 1;
       }
       const blocks = r.message?.content || [];
       for (const b of blocks) {
@@ -246,6 +256,7 @@ export function parseTranscript(filePath) {
             fileSet.add(f);
             if (EDITING_TOOLS.has(b.name)) {
               summary.fileEdits[f] = (summary.fileEdits[f] || 0) + 1;
+              if (ts && ts > (summary.fileEditTs[f] || 0)) summary.fileEditTs[f] = ts;
             }
           }
           // Code churn — lines added/removed. For Edit, we count
@@ -505,6 +516,7 @@ function aggregateFrom(cache) {
     byHour: {},
     byWeekday: {},
     fileEdits: {},
+    fileEditTs: {},
     streak: 0,
     longestStreak: 0,
     daysSinceFirst: 0,
@@ -524,6 +536,8 @@ function aggregateFrom(cache) {
     estimatedCost: 0,
     costByModel: {},
     modelsUsed: {},
+    byModel: {},
+    modelSplit: [],
     notifications: 0,
     generatedAt: Date.now(),
     _v: CACHE_VERSION,
@@ -553,6 +567,15 @@ function aggregateFrom(cache) {
     for (const [m, v] of Object.entries(summary.modelsUsed || {})) {
       agg.modelsUsed[m] = (agg.modelsUsed[m] || 0) + v;
     }
+    for (const [m, v] of Object.entries(summary.byModel || {})) {
+      const t = agg.byModel[m] ||= { turns: 0, tokens: 0, cost: 0 };
+      t.turns += v.turns || 0;
+      t.tokens += v.tokens || 0;
+      t.cost += v.cost || 0;
+    }
+    for (const [f, t] of Object.entries(summary.fileEditTs || {})) {
+      if (t > (agg.fileEditTs[f] || 0)) agg.fileEditTs[f] = t;
+    }
     for (const [c, n] of Object.entries(summary.bashCommands || {})) {
       agg.bashCommands[c] = (agg.bashCommands[c] || 0) + n;
     }
@@ -690,11 +713,36 @@ function aggregateFrom(cache) {
     agg.peakHour = bestHour;
   }
 
-  // Top edited files (paths + counts), descending.
+  // Top edited files (paths + counts), descending. Carries last-edit time and
+  // age in days so the dashboard / insights can flag a hotspot cooling off.
+  const nowMs = Date.now();
   agg.topEditedFiles = Object.entries(agg.fileEdits)
     .sort((a, b) => b[1] - a[1])
     .slice(0, 25)
-    .map(([path, count]) => ({ path, count }));
+    .map(([path, count]) => {
+      const lastTs = agg.fileEditTs[path] || 0;
+      return {
+        path,
+        count,
+        lastEditedTs: lastTs || null,
+        daysSinceLastEdit: lastTs ? Math.floor((nowMs - lastTs) / 86_400_000) : null,
+      };
+    });
+
+  // Model split — per pricing key, sorted by cost. Each entry carries its share
+  // of total cost so the dashboard / card can show "Sonnet · 61% of spend".
+  const splitCostTotal = Object.values(agg.byModel).reduce((s, v) => s + (v.cost || 0), 0);
+  const splitTokenTotal = Object.values(agg.byModel).reduce((s, v) => s + (v.tokens || 0), 0);
+  agg.modelSplit = Object.entries(agg.byModel)
+    .map(([model, v]) => ({
+      model,
+      turns: v.turns || 0,
+      tokens: v.tokens || 0,
+      cost: v.cost || 0,
+      costPct: splitCostTotal > 0 ? (v.cost || 0) / splitCostTotal : 0,
+      tokenPct: splitTokenTotal > 0 ? (v.tokens || 0) / splitTokenTotal : 0,
+    }))
+    .sort((a, b) => b.cost - a.cost);
 
   // Languages: bucket file edits by extension via languages.js.
   for (const [path, count] of Object.entries(agg.fileEdits)) {

package/src/version.js

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