claude-rpc 0.6.2 → 0.7.0

package/README.md

@@ -106,6 +106,7 @@ Shields-style badges and a poster-style summary card you can paste into a README
 ```sh
 claude-rpc badge --metric hours  --range 7d   --out claude-hours.svg
 claude-rpc badge --metric streak              --out claude-streak.svg
+claude-rpc badge --metric hours  --gist                                     # publish to a gist (live README badge)
 claude-rpc card  --range year                 --out year-on-claude.svg
 ```
 
@@ -113,6 +114,8 @@ claude-rpc card  --range year                 --out year-on-claude.svg
   <img src="site/examples/year-on-claude.svg" width="560" alt="Year-on-claude card — hours, prompts, tokens, lines, cost, daily activity strip" />
 </div>
 
+`badge --gist` writes the SVG to your own GitHub gist (creates one on first run, updates it after — id remembered in `config.json`). The URL printed back is README-ready and updates every time you re-run the command. Uses `gh` if available, else `GH_TOKEN` with `gist` scope.
+
 Live equivalents when the daemon is up:
 
 - `http://127.0.0.1:47474/api/badge.svg?metric=hours&range=7d`
@@ -120,6 +123,24 @@ Live equivalents when the daemon is up:
 
 Cost numbers come from `src/pricing.js`, seeded with **approximate** public list prices. Your actual Claude Code subscription bill is unrelated.
 
+### community totals (opt-in)
+
+A small Cloudflare Worker ([`worker/`](worker/)) hosts running totals of sessions and tokens across every install that has opted in:
+
+![sessions](https://claude-rpc-totals.claude-rpc.workers.dev/sessions.svg)
+![tokens](https://claude-rpc-totals.claude-rpc.workers.dev/tokens.svg)
+
+The opt-in is per-install and **off by default**:
+
+```sh
+claude-rpc community              # show state
+claude-rpc community on           # opt in (consent flow + prints exact payload)
+claude-rpc community off          # opt out
+claude-rpc community report       # one-shot manual flush (testing)
+```
+
+Each report sends only: a `sessionsDelta`, a `tokensDelta`, the claude-rpc version, OS family (`linux`/`darwin`/`win32`), and an anonymous UUID v4. No prompts, paths, models, repos, costs, usernames, or hostnames — the Worker's [`validateReport`](worker/src/index.js) is the schema of record. The full Worker source is in this repo so the privacy claim is auditable.
+
 ## three pieces, glued by json files
 
 ```
@@ -225,9 +246,10 @@ The full default config is in [`src/default-config.js`](src/default-config.js)
 | `scan` / `rescan`| Incremental / forced re-parse of `~/.claude/projects` |
 | `backfill <dir>` | Import transcripts from any folder (backup, other machine) |
 | `insights`       | Print 3–5 auto-generated lines about your week |
-| `badge`          | Shields-style SVG (`--metric` `--range` `--out`) |
+| `badge`          | Shields-style SVG (`--metric` `--range` `--out` `--gist`) |
 | `card`           | Poster-style SVG (`--range year\|month\|week\|all`) |
 | `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 |
 | `tail` / `logs`  | Tail the daemon log |
 | `daemon`         | Run the daemon in the foreground (debugging) |
@@ -247,7 +269,7 @@ Exit codes: `0` ok · `1` user error · `2` system error · `3` wrong state. `--
 ## development
 
 ```sh
-npm test                  # 134 tests, ~1.7s
+npm test                  # 200+ tests, ~1.7s
 npm run start             # run daemon in foreground
 npm run serve             # web dashboard against your real data
 npm run dashboard         # Electron settings GUI (dev mode)

package/package.json

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

package/src/cli.js

@@ -24,6 +24,8 @@ import { addPrivateCwd, removePrivateCwd, listPrivateCwds, resolveVisibility } f
 import { loadConfig, hasUserConfig } from './config.js';
 import { VERSION } from './version.js';
 import { fail, EX_USER_ERROR, EX_BAD_STATE } from './ui.js';
+import { randomUUID } from 'node:crypto';
+import { createInterface } from 'node:readline';
 import { basename } from 'node:path';
 
 const cmd = process.argv[2];
@@ -641,24 +643,29 @@ function showInsights() {
 }
 
 function parseBadgeArgs(argv) {
-  const out = { metric: 'hours', range: '7d', out: '' };
+  const out = { metric: 'hours', range: '7d', out: '', gist: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === '--metric' || a === '-m') out.metric = argv[++i];
     else if (a === '--range' || a === '-r') out.range = argv[++i];
     else if (a === '--out' || a === '-o') out.out = argv[++i];
     else if (a === '--label' || a === '-l') out.label = argv[++i];
+    else if (a === '--gist') out.gist = true;
   }
   return out;
 }
 
-function doBadge(argv) {
+async function doBadge(argv) {
   const opts = parseBadgeArgs(argv);
   const aggregate = readAggregate();
   if (!aggregate) {
     fail('no aggregate yet — nothing to render', { hint: 'run `claude-rpc scan` first', code: EX_BAD_STATE });
   }
   const svg = badgeSvg({ aggregate, metric: opts.metric, range: opts.range, label: opts.label });
+  if (opts.gist) {
+    await publishBadgeToGist(svg, opts);
+    return;
+  }
   if (opts.out) {
     writeFileSync(opts.out, svg);
     console.log(`${c.green}✓${c.reset} Wrote ${c.cyan}${opts.out}${c.reset} (${svg.length} bytes)`);
@@ -667,6 +674,52 @@ function doBadge(argv) {
   }
 }
 
+// Publish the rendered badge to a GitHub gist and emit the README-ready
+// markdown snippet. First successful publish records id+owner in
+// config.json so subsequent runs UPDATE that gist (raw URL stays stable).
+async function publishBadgeToGist(svg, opts) {
+  const { publishGistFile, gistMarkdown } = await import('./gist.js');
+  const cfg = loadConfig();
+  const stored = cfg.gist || {};
+  const filename = stored.filename || 'claude.svg';
+  try {
+    const result = await publishGistFile({
+      svg,
+      filename,
+      description: `claude-rpc — ${opts.metric || 'hours'} (${opts.range || '7d'})`,
+      gistId: stored.id || undefined,
+      owner: stored.owner || undefined,
+      isPublic: stored.public !== false,
+    });
+    // Persist the resolved id+owner so the next `--gist` run does an EDIT.
+    // We merge into the user's config.json directly (not the merged-defaults)
+    // so the file stays minimal.
+    const userCfg = readJson(CONFIG_PATH, {});
+    userCfg.gist = {
+      ...(userCfg.gist || {}),
+      id: result.id,
+      owner: result.owner,
+      filename,
+    };
+    if (stored.public !== undefined) userCfg.gist.public = stored.public;
+    writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
+    const wasUpdate = !!stored.id;
+    console.log('');
+    console.log(`  ${c.green}✓${c.reset} ${wasUpdate ? 'Updated' : 'Created'} gist ${c.cyan}${result.id}${c.reset}`);
+    console.log(`  ${c.dim}raw:${c.reset}      ${c.cyan}${result.rawUrl}${c.reset}`);
+    if (result.htmlUrl) console.log(`  ${c.dim}gist:${c.reset}     ${c.dim}${result.htmlUrl}${c.reset}`);
+    console.log('');
+    console.log(`  ${c.dim}Paste into your README:${c.reset}`);
+    console.log(`    ${gistMarkdown({ owner: result.owner, id: result.id, filename, label: 'Claude' })}`);
+    console.log('');
+  } catch (e) {
+    fail(`gist publish failed: ${e.message}`, {
+      hint: 'install gh (`gh auth login`) or set GH_TOKEN with `gist` scope',
+      code: EX_USER_ERROR,
+    });
+  }
+}
+
 // Poster-style SVG card. Bigger sibling of `badge` — shareable summary
 // for a range (year / month / week / all-time). Output is SVG only;
 // screenshot or convert to PNG offline if needed.
@@ -745,6 +798,130 @@ function doPrivacy() {
   console.log('');
 }
 
+// ── Community totals ─────────────────────────────────────────────────────
+//
+// `claude-rpc community`         → show current opt-in state + endpoint
+// `claude-rpc community on`      → interactive consent flow, mint instanceId
+// `claude-rpc community off`     → flip the flag off; instanceId retained
+// `claude-rpc community report`  → one-shot manual flush (useful for testing)
+//
+// See src/community.js for the payload schema and worker/src/index.js
+// for the receiving end. The opt-in is per-install — disabled by default.
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => { rl.close(); resolve(answer); });
+  });
+}
+
+function communityStatus() {
+  const cfg = loadConfig();
+  const community = cfg.community || {};
+  const on = !!community.enabled;
+  console.log('');
+  console.log(`  ${c.bold}community totals${c.reset}`);
+  console.log(`    ${c.dim}state:    ${c.reset} ${on ? c.green + 'on' + c.reset : c.yellow + 'off' + c.reset}`);
+  console.log(`    ${c.dim}endpoint: ${c.reset} ${community.endpoint || '(unset)'}`);
+  if (community.instanceId) {
+    console.log(`    ${c.dim}id:       ${c.reset} ${c.dim}…${community.instanceId.slice(-8)}${c.reset}`);
+  }
+  console.log('');
+  if (!on) {
+    console.log(`  ${c.dim}enable with ${c.reset}${c.cyan}claude-rpc community on${c.reset}`);
+  } else {
+    console.log(`  ${c.dim}disable with ${c.reset}${c.cyan}claude-rpc community off${c.reset}`);
+  }
+  console.log('');
+}
+
+async function communityOn() {
+  const cfg = loadConfig();
+  const community = cfg.community || {};
+  if (community.enabled) {
+    console.log(`${c.green}✓${c.reset} community totals are already enabled`);
+    return;
+  }
+  console.log('');
+  console.log(`  ${c.bold}claude-rpc community totals${c.reset}`);
+  console.log('');
+  console.log(`  ${c.dim}What gets sent (and only this):${c.reset}`);
+  console.log(`    ${c.green}·${c.reset} sessions delta since the last report`);
+  console.log(`    ${c.green}·${c.reset} tokens   delta since the last report`);
+  console.log(`    ${c.green}·${c.reset} claude-rpc version (${c.cyan}${VERSION}${c.reset})`);
+  console.log(`    ${c.green}·${c.reset} OS family (${c.cyan}${process.platform}${c.reset})`);
+  console.log(`    ${c.green}·${c.reset} anonymous instanceId (a fresh UUID v4)`);
+  console.log('');
+  console.log(`  ${c.dim}What never leaves your machine:${c.reset}`);
+  console.log(`    ${c.red}·${c.reset} prompts, file paths, models, repos, costs`);
+  console.log(`    ${c.red}·${c.reset} usernames, hostnames, IPs (the worker stores none)`);
+  console.log('');
+  console.log(`  ${c.dim}Endpoint:${c.reset} ${community.endpoint}`);
+  console.log(`  ${c.dim}Source:  ${c.reset} ${c.cyan}worker/src/index.js${c.reset} in the claude-rpc repo`);
+  console.log('');
+  const answer = (await prompt(`  Enable? ${c.dim}[y/N]${c.reset} `)).trim();
+  if (!/^y(es)?$/i.test(answer)) {
+    console.log('');
+    console.log(`  ${c.dim}cancelled.${c.reset}`);
+    console.log('');
+    return;
+  }
+  const userCfg = readJson(CONFIG_PATH, {});
+  const next = {
+    ...(userCfg.community || {}),
+    enabled: true,
+    instanceId: userCfg.community?.instanceId || community.instanceId || randomUUID(),
+  };
+  userCfg.community = next;
+  writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
+  console.log('');
+  console.log(`  ${c.green}✓${c.reset} community totals enabled`);
+  console.log(`    ${c.dim}id: …${next.instanceId.slice(-8)}${c.reset}`);
+  console.log(`    ${c.dim}the daemon flushes every ${community.flushIntervalMin || 30} min${c.reset}`);
+  console.log('');
+}
+
+function communityOff() {
+  const userCfg = readJson(CONFIG_PATH, {});
+  if (!userCfg.community?.enabled) {
+    console.log(`${c.dim}community totals are already off.${c.reset}`);
+    return;
+  }
+  userCfg.community = { ...userCfg.community, enabled: false };
+  writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
+  console.log(`${c.green}✓${c.reset} community totals disabled. instanceId retained for re-enable continuity.`);
+}
+
+async function communityReport() {
+  const cfg = loadConfig();
+  if (!cfg.community?.enabled) {
+    fail('community totals are off', { hint: 'run `claude-rpc community on` first', code: EX_BAD_STATE });
+  }
+  const { flushCommunity } = await import('./community.js');
+  const result = await flushCommunity(cfg);
+  console.log('');
+  if (result.ok && result.delta) {
+    console.log(`  ${c.green}✓${c.reset} reported  ${c.cyan}+${result.delta.sessions} sessions${c.reset}  ${c.cyan}+${result.delta.tokens} tokens${c.reset}`);
+  } else if (result.ok) {
+    console.log(`  ${c.dim}${result.reason}${c.reset}`);
+  } else {
+    console.log(`  ${c.yellow}↳${c.reset} flush did not complete  ${c.dim}(${result.reason}${result.error ? ': ' + result.error : ''})${c.reset}`);
+  }
+  console.log('');
+}
+
+async function doCommunity(argv) {
+  const sub = (argv[0] || 'status').toLowerCase();
+  if (sub === 'on') return communityOn();
+  if (sub === 'off') return communityOff();
+  if (sub === 'status' || sub === '') return communityStatus();
+  if (sub === 'report' || sub === 'flush') return communityReport();
+  fail(`unknown community subcommand: ${sub}`, {
+    hint: 'try: community [status|on|off|report]',
+    code: EX_USER_ERROR,
+  });
+}
+
 function tailLog() {
   if (!existsSync(LOG_PATH)) {
     console.log(`${c.yellow}No log yet at ${LOG_PATH}${c.reset}`);
@@ -857,11 +1034,12 @@ function help() {
     ['rescan',    'Force re-parse every transcript (ignores cache)'],
     ['backfill',  'Import transcripts from any folder (e.g. a backup)'],
     ['insights',  'Auto-generated insights from your history'],
-    ['badge',     'Render a Shields-style SVG (--metric --range --out)'],
+    ['badge',     'Render a Shields-style SVG (--metric --range --out --gist)'],
     ['card',      'Render a poster-style SVG summary (--range year|month|week|all)'],
     ['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)'],
     ['doctor',    'Run a diagnostic checklist — common-failure triage'],
     ['tail',      'Tail the daemon log file'],
     ['daemon',    'Run daemon in foreground (debug)'],
@@ -924,11 +1102,12 @@ const packagedDefault = IS_PACKAGED && !cmd;
     case 'rescan':    doScan(true); break;
     case 'backfill':  doBackfill(process.argv.slice(3)); break;
     case 'insights':  showInsights(); break;
-    case 'badge':     doBadge(process.argv.slice(3)); break;
+    case 'badge':     await doBadge(process.argv.slice(3)); break;
     case 'card':      await doCard(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 'doctor': {
       const { runDoctor } = await import('./doctor.js');
       process.exit(runDoctor());

package/src/community.js

@@ -0,0 +1,127 @@
+// Opt-in community-totals client. Reads aggregate.json + a small cursor
+// file to compute counter DELTAs (not absolute values — the cursor moves
+// forward as we report), then POSTs to the configured worker endpoint.
+//
+// Three guarantees this module owes the rest of the codebase:
+//
+//   1. Never throws. The daemon calls this from a setInterval and must
+//      not crash on a network burp or a malformed response. All failure
+//      modes resolve to `{ ok: false, reason }` and move on.
+//   2. Never sends anything beyond the documented payload. No file paths,
+//      no prompts, no models, no cwd — the buildPayload function is the
+//      complete schema, and it's audited by the worker's validateReport.
+//   3. Never advances the cursor on a failed flush. A 5xx today + a
+//      successful flush tomorrow still reports today's deltas.
+//
+// See worker/src/index.js for the receiving end.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { platform } from 'node:os';
+import { AGGREGATE_PATH, STATE_DIR } from './paths.js';
+import { VERSION } from './version.js';
+
+const CURSOR_PATH = join(STATE_DIR, 'community-cursor.json');
+
+export function readCursor(path = CURSOR_PATH) {
+  if (!existsSync(path)) return { sessions: 0, tokens: 0, ts: 0 };
+  try { return { sessions: 0, tokens: 0, ts: 0, ...JSON.parse(readFileSync(path, 'utf8')) }; }
+  catch { return { sessions: 0, tokens: 0, ts: 0 }; }
+}
+
+export function writeCursor(c, path = CURSOR_PATH) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(c, null, 2));
+  } catch {
+    // Cursor write failure is recoverable — the next flush will resend
+    // the same delta, which the worker accepts (we accumulate at the
+    // server, not de-dup on payload content).
+  }
+}
+
+export function osFamily() {
+  const p = platform();
+  if (p === 'win32') return 'win32';
+  if (p === 'darwin') return 'darwin';
+  // freebsd / openbsd / aix all collapse to 'linux' for telemetry
+  // — the worker only accepts the three canonical values.
+  return 'linux';
+}
+
+// Pure: given an aggregate and a cursor, produce the next payload. The
+// worker's validateReport must accept this shape; if you add a field
+// here, add it there too.
+export function buildPayload(aggregate, cursor, { instanceId, now = Date.now() }) {
+  const sessions = aggregate?.sessions || 0;
+  const tokens = (aggregate?.inputTokens || 0)
+    + (aggregate?.outputTokens || 0)
+    + (aggregate?.cacheReadTokens || 0)
+    + (aggregate?.cacheWriteTokens || 0);
+  return {
+    instanceId,
+    sessionsDelta: Math.max(0, sessions - (cursor.sessions || 0)),
+    tokensDelta:   Math.max(0, tokens   - (cursor.tokens   || 0)),
+    version: VERSION,
+    osFamily: osFamily(),
+    ts: now,
+  };
+}
+
+// Single best-effort flush. Returns { ok, reason, delta? } — never throws.
+// Caller passes in the merged config so we can be tested without touching
+// disk for config too.
+export async function flushCommunity(cfg, {
+  aggregatePath = AGGREGATE_PATH,
+  cursorPath = CURSOR_PATH,
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  const community = cfg?.community || {};
+  if (!community.enabled) return { ok: false, reason: 'disabled' };
+  if (!community.instanceId) return { ok: false, reason: 'no-instance-id' };
+  if (!community.endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!existsSync(aggregatePath)) return { ok: false, reason: 'no-aggregate' };
+
+  let aggregate;
+  try { aggregate = JSON.parse(readFileSync(aggregatePath, 'utf8')); }
+  catch { return { ok: false, reason: 'unreadable-aggregate' }; }
+
+  const cursor = readCursor(cursorPath);
+  const payload = buildPayload(aggregate, cursor, { instanceId: community.instanceId });
+  if (payload.sessionsDelta === 0 && payload.tokensDelta === 0) {
+    return { ok: true, reason: 'no-delta' };
+  }
+
+  const url = community.endpoint.replace(/\/+$/, '') + '/report';
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+  } catch (e) {
+    return { ok: false, reason: 'network', error: e.message };
+  }
+  if (!res.ok) {
+    // 429 is rate-limit — not actually a failure, just "come back later".
+    if (res.status === 429) return { ok: false, reason: 'rate-limited' };
+    return { ok: false, reason: `http-${res.status}` };
+  }
+
+  // Only move the cursor on confirmed acceptance. If we crash between
+  // the response and the cursor write, the next flush resends — the
+  // worker accumulates blindly, so a duplicate would double-count.
+  // Rate-limiting on the worker side bounds the damage to one
+  // duplicate per minute per instance.
+  writeCursor({
+    sessions: (cursor.sessions || 0) + payload.sessionsDelta,
+    tokens:   (cursor.tokens   || 0) + payload.tokensDelta,
+    ts: payload.ts,
+  }, cursorPath);
+
+  return {
+    ok: true,
+    delta: { sessions: payload.sessionsDelta, tokens: payload.tokensDelta },
+  };
+}

package/src/daemon.js

@@ -2,7 +2,7 @@
 import { writeFileSync, existsSync, unlinkSync, watch, appendFileSync, mkdirSync, statSync, renameSync } from 'node:fs';
 import { Client } from '@xhayper/discord-rpc';
 import { readState } from './state.js';
-import { buildVars, fillTemplate, framePasses, applyIdle } from './format.js';
+import { buildVars, fillTemplate, framePasses, applyIdle, applyShipped } from './format.js';
 import { scan, readAggregate, findLiveSessions, readSessionTokens } from './scanner.js';
 import { detectGithubUrl } from './git.js';
 import { applyPrivacy } from './privacy.js';
@@ -121,6 +121,9 @@ function buildActivity(opts = {}) {
   // see ongoing transcript activity, not just this daemon's hook state.
   state.liveSessions = opts.liveSessions || liveSessions;
   state = applyIdle(state, config);
+  // Shipped overlay sits on top of idle/working/thinking — but never over
+  // stale (we don't celebrate when Claude isn't running).
+  state = applyShipped(state, config);
 
   // Pull live session tokens from the transcript file. Claude Code's hook
   // payloads don't include usage data, so state.tokens from PostToolUse
@@ -250,6 +253,7 @@ async function pushPresence() {
     let resolved = readState();
     resolved.liveSessions = liveSessions;
     resolved = applyIdle(resolved, config);
+    resolved = applyShipped(resolved, config);
     // Privacy can convert any state into a "hidden" verdict — give it the
     // same treatment as hideWhenStale: a single clearActivity, deduped via
     // lastPayloadHash so we don't spam the IPC.
@@ -449,3 +453,29 @@ function refreshLiveSessions() {
 }
 refreshLiveSessions();
 setInterval(refreshLiveSessions, 30_000);
+
+// Community-totals flush. Disabled by default; turns on via
+// `claude-rpc community on`. Best-effort — flushCommunity swallows every
+// failure mode, so a flaky endpoint or no network just means the deltas
+// pile up locally until the next successful flush. Cadence is config-
+// driven (`community.flushIntervalMin`, default 30 min).
+async function runCommunityFlush() {
+  if (!config.community?.enabled) return;
+  try {
+    const { flushCommunity } = await import('./community.js');
+    const result = await flushCommunity(config);
+    if (result.ok && result.delta) {
+      log(`community: flushed +${result.delta.sessions} sessions, +${result.delta.tokens} tokens`);
+    } else if (!result.ok && result.reason !== 'rate-limited' && result.reason !== 'no-delta') {
+      // Don't spam the log for routine "nothing to send" cases.
+      log(`community: ${result.reason}${result.error ? ' (' + result.error + ')' : ''}`);
+    }
+  } catch (e) {
+    log('community flush threw:', e.message);
+  }
+}
+const communityFlushMs = Math.max(60_000, (config.community?.flushIntervalMin || 30) * 60 * 1000);
+setInterval(runCommunityFlush, communityFlushMs);
+// Initial flush after a short delay — gives the scan above a chance to
+// build aggregate.json before we ask community.js to read it.
+setTimeout(runCommunityFlush, 60_000);

package/src/default-config.js

@@ -25,11 +25,38 @@ export const DEFAULT_CONFIG = {
   // goes stale — your profile shows nothing instead of an "Away" frame.
   hideWhenStale: true,
   notificationWindowSec: 8,
+  // How long after a `git push` / `git commit` the card stays on the
+  // celebratory "Just shipped" frame before falling back to the
+  // underlying status. Set 0 to disable the overlay entirely.
+  shippedFrameSec: 60,
+  // `claude-rpc badge --gist` records id+owner here after a successful
+  // first publish so subsequent publishes UPDATE the same gist (the raw
+  // URL in your README stays stable). filename is the file inside the
+  // gist — change it only if you publish multiple badges to one gist.
+  gist: {
+    id: null,
+    owner: null,
+    filename: "claude.svg",
+    public: true,
+  },
+  // Opt-in community totals. Disabled by default. `claude-rpc community on`
+  // walks through the consent flow and flips `enabled`, mints an anonymous
+  // instanceId (UUID v4), and the daemon starts batching deltas to the
+  // endpoint. See worker/src/index.js for the receiving end and exactly
+  // what payload is accepted (the validator there is the schema of record).
+  community: {
+    enabled: false,
+    instanceId: null,
+    endpoint: "https://claude-rpc-totals.claude-rpc.workers.dev",
+    flushIntervalMin: 30,
+  },
   showElapsed: true,
   activityType: 0,
   statusAssets: {
     working:      "https://cdn.qualit.ly/clawd-working-building.gif",
     thinking:     "https://cdn.qualit.ly/clawd-working-typing.gif",
+    compacting:   "https://cdn.qualit.ly/clawd-working-typing.gif",
+    shipped:      "https://cdn.qualit.ly/clawd-working-building.gif",
     idle:         "https://cdn.qualit.ly/clawd-sleeping.gif",
     stale:        "https://cdn.qualit.ly/clawd-sleeping.gif",
     notification: "https://cdn.qualit.ly/clawd-notification.gif",
@@ -48,14 +75,24 @@ export const DEFAULT_CONFIG = {
     byStatus: {
       working: {
         details: "Working in {project}",
-        state:   "{currentToolPretty} · {currentFilePretty} · {tokensFmt} tokens",
+        state:   "{currentToolPretty} · {currentFilePretty} · {toolElapsed} · {tokensLabel}",
         largeImageText: "Working on a {fileLang} file",
       },
       thinking: {
         details: "Thinking in {project}",
-        state:   "{modelPretty} · {messagesLabel} · {tokensFmt} tokens",
+        state:   "{modelPretty} · {messagesLabel} · {tokensLabel}",
         largeImageText: "Reasoning with {modelPretty}",
       },
+      compacting: {
+        details: "Compacting context in {project}",
+        state:   "{modelPretty} · {messagesLabel}",
+        largeImageText: "Compacting · {compactTriggerLabel}",
+      },
+      shipped: {
+        details: "Just shipped in {project}",
+        state:   "{lastCommit}",
+        largeImageText: "{justShippedLabel}",
+      },
       notification: {
         details: "Waiting on you · {project}",
         state:   "{modelPretty} · {messagesLabel}",
@@ -84,6 +121,8 @@ export const DEFAULT_CONFIG = {
   statusIcons: {
     working:      "working",
     thinking:     "thinking",
+    compacting:   "thinking",
+    shipped:      "working",
     idle:         "idle",
     notification: "",
     stale:        "",

package/src/format.js

@@ -51,6 +51,23 @@ function fmtDuration(ms) {
   return `${sec}s`;
 }
 
+// Tighter formatter for the working-frame "tool has been running for X" var.
+// Sub-minute: bare seconds. Sub-hour: decimal minutes (1.5min) up to 10,
+// integer minutes thereafter. Hour+: "1h 5m" to match fmtDuration. The
+// short forms keep the working frame readable on Discord's narrow rows
+// — fmtDuration's "120m 0s" wraps awkwardly there.
+function fmtToolElapsed(ms) {
+  if (!ms || ms < 0) return '';
+  const sec = Math.floor(ms / 1000);
+  if (sec < 60) return `${sec}s`;
+  const min = sec / 60;
+  if (min < 10) return `${min.toFixed(1)}min`;
+  if (sec < 3600) return `${Math.round(min)}min`;
+  const h = Math.floor(sec / 3600);
+  const m = Math.floor((sec % 3600) / 60);
+  return `${h}h ${m}m`;
+}
+
 function fmtHours(ms) {
   if (!ms || ms < 0) return '0h';
   const hours = ms / 3_600_000;
@@ -118,6 +135,7 @@ function statusVerbose(status, currentToolPretty, idleMs) {
   switch (status) {
     case 'working': return currentToolPretty ? `Using ${currentToolPretty}` : 'Working';
     case 'thinking': return 'Thinking';
+    case 'compacting': return 'Compacting context';
     case 'notification': return 'Waiting on you';
     case 'idle': {
       if (idleMs && idleMs > 60_000) {
@@ -304,6 +322,29 @@ export function buildVars(state, config, aggregate) {
     ? Math.max(0, Date.now() - state.lastActivity)
     : 0;
 
+  // Tool-duration spotlight. Empty until the running tool has burned past
+  // a short threshold — quick Reads/Edits don't need a timer on the card,
+  // and showing it flickers as fast tools complete. Once it does exceed
+  // the threshold, "Bash · running tests · 2.5min" reads naturally.
+  const toolMs = (state.status === 'working' && state.toolStartedAt)
+    ? Math.max(0, Date.now() - state.toolStartedAt)
+    : 0;
+  const TOOL_ELAPSED_THRESHOLD_MS = 5_000;
+  const toolElapsed = toolMs >= TOOL_ELAPSED_THRESHOLD_MS ? fmtToolElapsed(toolMs) : '';
+
+  // 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).
+  const compactMs = state.compactStartedAt
+    ? Math.max(0, Date.now() - state.compactStartedAt)
+    : 0;
+  const compactTrigger = state.compactTrigger || '';
+  const compactTriggerLabel = compactTrigger === 'manual'
+    ? 'manual compaction'
+    : compactTrigger === 'auto'
+      ? 'auto-compaction'
+      : 'context squeeze';
+
   const currentFilePretty = prettyFilePath(state.currentFile);
 
   // ── File / directory / language vars ──────────────────────────────────────
@@ -379,7 +420,10 @@ export function buildVars(state, config, aggregate) {
     // Literal single space — handy for blanking a line without `requires`.
     empty: ' ',
 
-    // pluralized session labels
+    // Pluralized session labels. tokensLabel is empty when zero so the
+    // `· {tokensLabel}` suffix in default templates collapses away —
+    // "Bash · · 0 tokens" is not a useful frame.
+    tokensLabel: sessionTokens > 0 ? `${fmtNum(sessionTokens)} tokens` : '',
     messagesLabel: plural(messages, 'prompt'),
     toolsLabel: plural(tools, 'tool call'),
     filesEditedLabel: plural(filesEdited, 'edit'),
@@ -389,6 +433,31 @@ export function buildVars(state, config, aggregate) {
     // session lifecycle flag (for `requires` gating)
     sessionActive,
 
+    // ── Tool-duration spotlight (v0.7) ──────────────────────────
+    toolMs,
+    toolElapsed,
+
+    // ── Just-shipped (v0.7) ─────────────────────────────────────
+    justShippedKind: state.justShippedKind || '',
+    justShippedSubject: state.justShippedSubject || '',
+    justShippedBranch: state.justShippedBranch || '',
+    // Friendly headline for the largeImageText — "Pushed to main" or
+    // "Committed to feat/x". Falls back to a verb-only label when no
+    // branch is available (detached HEAD, sparse `.git`, etc.).
+    justShippedLabel: state.justShippedKind === 'push'
+      ? (state.justShippedBranch ? `Pushed to ${state.justShippedBranch}` : 'Pushed')
+      : state.justShippedKind === 'commit'
+        ? (state.justShippedBranch ? `Committed on ${state.justShippedBranch}` : 'Committed')
+        : '',
+    // {lastCommit} reads more naturally than {justShippedSubject} in user templates.
+    lastCommit: state.justShippedSubject || '',
+
+    // ── Compaction (v0.7) ───────────────────────────────────────
+    compactMs,
+    compactDuration: compactMs ? fmtDuration(compactMs) : '',
+    compactTrigger,
+    compactTriggerLabel,
+
     // concurrent / live
     concurrent,
     concurrentOther,
@@ -562,7 +631,19 @@ export function buildVars(state, config, aggregate) {
 
 export function fillTemplate(tpl, vars) {
   if (typeof tpl !== 'string') return tpl;
-  return tpl.replace(/\{(\w+)\}/g, (_, key) => (key in vars ? String(vars[key]) : `{${key}}`));
+  const filled = tpl.replace(/\{(\w+)\}/g, (_, key) => (key in vars ? String(vars[key]) : `{${key}}`));
+  return collapseSeparators(filled);
+}
+
+// After substitution, a template like "{currentToolPretty} · {currentFilePretty} · {tokensFmt} tokens"
+// can resolve to "Bash ·  · 0 tokens" when the tool doesn't have a file path
+// and no tokens have accumulated yet. Split on `·`, trim each segment, drop
+// empty segments, rejoin — so empty middle vars don't leave orphan separators
+// and trailing/leading separators disappear entirely. Templates without `·`
+// pass through untouched.
+function collapseSeparators(s) {
+  if (!s.includes('·')) return s;
+  return s.split('·').map((p) => p.trim()).filter(Boolean).join(' · ');
 }
 
 // Helper used by every "go stale" branch in applyIdle. Wipes the current-
@@ -685,6 +766,24 @@ export function applyIdle(state, cfg = {}) {
   return state;
 }
 
+// Promote status to 'shipped' for a brief celebratory window after a
+// `git push` / `git commit` is observed. Called by the daemon AFTER
+// applyIdle — stale/idle decisions still take precedence over the shipped
+// overlay (we don't celebrate when Claude isn't running). The window is
+// configurable via `shippedFrameSec` (default 60).
+//
+// Pure: returns a new state object when promoting, the input otherwise.
+// The underlying `state.status` is untouched so the daemon falls back
+// cleanly once the window expires.
+export function applyShipped(state, cfg = {}) {
+  if (!state.justShipped) return state;
+  if (state.status === 'stale') return state;
+  const windowMs = Math.max(5_000, (cfg.shippedFrameSec ?? 60) * 1000);
+  const age = Date.now() - state.justShipped;
+  if (age < 0 || age > windowMs) return state;
+  return { ...state, status: 'shipped' };
+}
+
 // True when `requires` (string or array of strings) all resolve to non-zero / non-empty.
 export function framePasses(frame, vars) {
   const req = frame.requires;
@@ -697,4 +796,4 @@ export function framePasses(frame, vars) {
   return true;
 }
 
-export { fmtNum, fmtDuration, fmtHours, humanModel, humanTool, humanProject, plural };
+export { fmtNum, fmtDuration, fmtHours, fmtToolElapsed, humanModel, humanTool, humanProject, plural };

package/src/gist.js

@@ -0,0 +1,167 @@
+// Publishes a single SVG file to a GitHub gist so a README can render it
+// via raw.githubusercontent.com. Two paths:
+//
+//   1. The `gh` CLI (if installed + authed). This is the common terminal
+//      flow — no token plumbing required. We shell out to `gh gist create`
+//      / `gh gist edit` against a temp file.
+//   2. The GitHub REST API directly, using GH_TOKEN / GITHUB_TOKEN. Falls
+//      through here when `gh` is missing — useful for CI cron jobs that
+//      can mint a fine-grained token but can't install gh.
+//
+// On create we capture { id, owner } and return them so cli.js can persist
+// the linkage in config.json. Subsequent runs hit the EDIT path against
+// the same gist, so the README markdown URL stays stable across updates.
+
+import { spawnSync } from 'node:child_process';
+import { writeFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// Extract { owner, id } from a "https://gist.github.com/<user>/<hash>"
+// URL. Returns null on no match — callers throw with the raw output so
+// debugging an unparseable gh response is straightforward.
+export function parseGistUrl(url) {
+  if (!url || typeof url !== 'string') return null;
+  const m = url.match(/gist\.github\.com\/([^/\s]+)\/([0-9a-fA-F]+)/);
+  if (!m) return null;
+  return { owner: m[1], id: m[2] };
+}
+
+// Stable raw URL for a gist file — GitHub camo will cache + serve through
+// this in a README image tag. The /raw/ path with no SHA resolves to the
+// latest revision, so `claude-rpc badge --gist` runs always end up rendered
+// without README edits.
+export function rawGistUrl({ owner, id, filename }) {
+  return `https://gist.githubusercontent.com/${owner}/${id}/raw/${filename}`;
+}
+
+// Markdown snippet a user can paste into a README. The filename trailing
+// the URL doubles as the alt-text/title hint.
+export function gistMarkdown({ owner, id, filename, label = 'Claude' }) {
+  return `![${label}](${rawGistUrl({ owner, id, filename })})`;
+}
+
+export function hasGh() {
+  try {
+    const r = spawnSync('gh', ['--version'], { stdio: 'ignore' });
+    return r.status === 0;
+  } catch {
+    // gh missing entirely → spawn throws on some platforms instead of
+    // returning a non-zero status. Either signal means "not available".
+    return false;
+  }
+}
+
+function ghCreate(filePath, description, isPublic) {
+  const args = ['gist', 'create', filePath, '--desc', description];
+  if (isPublic) args.push('--public');
+  const r = spawnSync('gh', args, { encoding: 'utf8' });
+  if (r.status !== 0) {
+    throw new Error(`gh gist create failed: ${(r.stderr || r.stdout || '').trim()}`);
+  }
+  const out = (r.stdout || '').trim();
+  // gh prints assorted progress lines; the actual URL is the only token
+  // beginning with http(s)://.
+  const url = out.split(/\s+/).filter((s) => /^https?:\/\//.test(s)).pop() || out;
+  const parsed = parseGistUrl(url);
+  if (!parsed) throw new Error(`could not parse gist URL from gh output: ${out}`);
+  return { ...parsed, htmlUrl: url };
+}
+
+function ghEdit(gistId, filePath) {
+  const r = spawnSync('gh', ['gist', 'edit', gistId, filePath], { encoding: 'utf8' });
+  if (r.status !== 0) {
+    throw new Error(`gh gist edit failed: ${(r.stderr || r.stdout || '').trim()}`);
+  }
+}
+
+async function restCreate({ svg, filename, description, isPublic, token }) {
+  const res = await fetch('https://api.github.com/gists', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Accept': 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      description,
+      public: !!isPublic,
+      files: { [filename]: { content: svg } },
+    }),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`POST /gists ${res.status}: ${body.slice(0, 200)}`);
+  }
+  const j = await res.json();
+  return { id: j.id, owner: j.owner?.login || '', htmlUrl: j.html_url };
+}
+
+async function restEdit({ svg, filename, gistId, token }) {
+  const res = await fetch(`https://api.github.com/gists/${gistId}`, {
+    method: 'PATCH',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Accept': 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ files: { [filename]: { content: svg } } }),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`PATCH /gists/${gistId} ${res.status}: ${body.slice(0, 200)}`);
+  }
+}
+
+// Publish (create or update) a single file in a gist. `gistId` + `owner`
+// passed in => EDIT path; absent => CREATE path. Returns the resolved
+// gist identity + raw URL the caller can put in a README.
+export async function publishGistFile({
+  svg,
+  filename = 'claude.svg',
+  description = 'claude-rpc badge — autogenerated',
+  gistId,
+  owner,
+  isPublic = true,
+  token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN,
+}) {
+  if (!svg || typeof svg !== 'string') throw new Error('publishGistFile: svg must be a non-empty string');
+  if (hasGh()) {
+    const dir = mkdtempSync(join(tmpdir(), 'claude-rpc-gist-'));
+    const path = join(dir, filename);
+    writeFileSync(path, svg);
+    try {
+      if (gistId) {
+        ghEdit(gistId, path);
+        return { id: gistId, owner: owner || '', filename, rawUrl: rawGistUrl({ owner: owner || '', id: gistId, filename }) };
+      }
+      const created = ghCreate(path, description, isPublic);
+      return {
+        id: created.id,
+        owner: created.owner,
+        filename,
+        htmlUrl: created.htmlUrl,
+        rawUrl: rawGistUrl({ owner: created.owner, id: created.id, filename }),
+      };
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+  if (!token) {
+    throw new Error('neither `gh` CLI nor GH_TOKEN/GITHUB_TOKEN available — run `gh auth login` or set GH_TOKEN');
+  }
+  if (gistId) {
+    await restEdit({ svg, filename, gistId, token });
+    return { id: gistId, owner: owner || '', filename, rawUrl: rawGistUrl({ owner: owner || '', id: gistId, filename }) };
+  }
+  const created = await restCreate({ svg, filename, description, isPublic, token });
+  return {
+    id: created.id,
+    owner: created.owner,
+    filename,
+    htmlUrl: created.htmlUrl,
+    rawUrl: rawGistUrl({ owner: created.owner, id: created.id, filename }),
+  };
+}

package/src/git.js

@@ -72,3 +72,47 @@ function lookup(cwd) {
 export function detectGithubUrl(cwd) { return lookup(cwd).github; }
 export function detectGitBranch(cwd) { return lookup(cwd).branch; }
 export function detectGitRepo(cwd)   { return lookup(cwd).repo; }
+
+// Last commit subject for the "just shipped" frame. Read on demand from
+// `.git/COMMIT_EDITMSG` (written by `git commit` and left in place after).
+// Falls back to the last line of `.git/logs/HEAD` when COMMIT_EDITMSG is
+// missing — that file always reflects the most recent ref movement.
+//
+// Not cached on purpose: this is only called the moment a `git
+// push`/`git commit` is detected, so we want the freshest possible value,
+// and a cache hit might return the *previous* commit's subject if the user
+// just made a new one.
+export function detectLastCommitSubject(cwd, max = 80) {
+  if (!cwd) return '';
+  const gitDir = join(cwd, '.git');
+  if (!existsSync(gitDir)) return '';
+
+  // COMMIT_EDITMSG: the editor buffer from the most recent `git commit`.
+  // First non-blank, non-comment line is the subject.
+  try {
+    const raw = readFileSync(join(gitDir, 'COMMIT_EDITMSG'), 'utf8');
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      return trimmed.slice(0, max);
+    }
+  } catch { /* file may not exist on a freshly cloned repo */ }
+
+  // logs/HEAD line shape:
+  //   <old> <new> Name <email> <ts> <tz>\t<action>: <subject>
+  // We split on the tab, take the action message, strip a leading
+  // "commit: " / "commit (initial): " / "merge ..." prefix.
+  try {
+    const raw = readFileSync(join(gitDir, 'logs', 'HEAD'), 'utf8');
+    const lines = raw.split(/\r?\n/).filter(Boolean);
+    if (!lines.length) return '';
+    const last = lines[lines.length - 1];
+    const tab = last.indexOf('\t');
+    if (tab < 0) return '';
+    let msg = last.slice(tab + 1).trim();
+    msg = msg.replace(/^(commit(?:\s+\([^)]+\))?:\s*)/, '');
+    return msg.slice(0, max);
+  } catch { /* no logs/HEAD — repo too young or .git/logs disabled */ }
+
+  return '';
+}

package/src/hook.js

@@ -2,8 +2,14 @@
 import { readFileSync, appendFileSync, existsSync, mkdirSync, statSync, renameSync } from 'node:fs';
 import { dirname } from 'node:path';
 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|$)/;
+
 const EVENTS_LOG_ROTATE_BYTES = 5 * 1024 * 1024;
 
 function appendEvent(entry) {
@@ -81,6 +87,7 @@ export function processHookEvent(event, input = {}) {
         s.toolBreakdown[toolName] = (s.toolBreakdown[toolName] || 0) + 1;
         s.currentTool = toolName;
         s.currentFile = shortFile(file);
+        s.toolStartedAt = now;
         s.status = 'working';
         s.lastActivity = now;
         s.claudeClosed = false;
@@ -97,8 +104,26 @@ export function processHookEvent(event, input = {}) {
       const toolName = input.tool_name || input.toolName || '';
       const toolInput = input.tool_input || input.toolInput || {};
       const file = toolInput.file_path || toolInput.path || null;
+      // Just-shipped detection: any Bash command that contains `git push`
+      // or `git commit`. Capture cwd + branch + last commit subject NOW
+      // — by the time the daemon renders the next frame this info may be
+      // gone (Claude often `cd`s after a commit).
+      let shipKind = null;
+      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];
+          const shipCwd = input.cwd || process.cwd();
+          shipSubject = detectLastCommitSubject(shipCwd) || null;
+          shipBranch = detectGitBranch(shipCwd) || null;
+        }
+      }
       updateState((s) => {
         s.currentTool = null;
+        s.toolStartedAt = null;
         s.lastActivity = now;
         s.claudeClosed = false;
         if (!s.sessionStart) s.sessionStart = now;
@@ -106,6 +131,12 @@ export function processHookEvent(event, input = {}) {
           s.filesEdited = pushUnique(s.filesEdited, file);
           s.filesOpened = pushUnique(s.filesOpened, file);
         }
+        if (shipKind) {
+          s.justShipped = now;
+          s.justShippedKind = shipKind;
+          s.justShippedSubject = shipSubject;
+          s.justShippedBranch = shipBranch;
+        }
         const usage = input.tool_response?.usage || input.usage;
         if (usage) {
           s.tokens.input += usage.input_tokens || 0;
@@ -131,6 +162,39 @@ export function processHookEvent(event, input = {}) {
       appendEvent({ type: 'notification', ts: now, cwd: input.cwd || null });
       break;
     }
+    case 'PreCompact': {
+      // Compaction is mechanically distinct from "thinking" — the model is
+      // rewriting earlier context, not advancing a turn. Surface it as its
+      // own state so the card stops reading "Thinking…" for the 10-60s
+      // compactions can take on big sessions.
+      updateState((s) => {
+        s.status = 'compacting';
+        s.compactStartedAt = now;
+        s.compactTrigger = input.trigger || input.matcher || null;
+        s.currentTool = null;
+        s.currentFile = null;
+        s.lastActivity = now;
+        s.claudeClosed = false;
+        if (!s.sessionStart) s.sessionStart = now;
+        return s;
+      });
+      appendEvent({ type: 'precompact', ts: now, trigger: input.trigger || input.matcher || null, cwd: input.cwd || null });
+      break;
+    }
+    case 'PostCompact': {
+      // Compaction finished — clear the marker and drop to idle. The next
+      // hook (UserPromptSubmit / PreToolUse) will set the real next state.
+      updateState((s) => {
+        s.status = 'idle';
+        s.compactStartedAt = null;
+        s.compactTrigger = null;
+        s.lastActivity = now;
+        s.claudeClosed = false;
+        return s;
+      });
+      appendEvent({ type: 'postcompact', ts: now, cwd: input.cwd || null });
+      break;
+    }
     case 'SessionEnd': {
       // Authoritative "Claude Code is gone" signal — don't wait on the
       // staleSessionMin timeout. applyIdle short-circuits to stale when it

package/src/install.js

@@ -260,6 +260,25 @@ export function migrateConfig() {
     added.push('presence.largeImageText');
   }
 
+  // v0.6.3: byStatus.working.state and .thinking.state used `{tokensFmt} tokens`
+  // which renders "0 tokens" before any session activity has accrued — combined
+  // with empty `{currentFilePretty}` for tools like Bash, that surfaced as
+  // "Bash · · 0 tokens" on the card. New default uses `{tokensLabel}` which is
+  // empty until tokens > 0, and fillTemplate now collapses adjacent separators.
+  // Migrate only the verbatim old template — leave anything the user customized.
+  const OLD_WORKING = '{currentToolPretty} · {currentFilePretty} · {tokensFmt} tokens';
+  const OLD_THINKING = '{modelPretty} · {messagesLabel} · {tokensFmt} tokens';
+  if (cfg.presence.byStatus?.working?.state === OLD_WORKING &&
+      DEFAULT_CONFIG.presence?.byStatus?.working?.state) {
+    cfg.presence.byStatus.working.state = DEFAULT_CONFIG.presence.byStatus.working.state;
+    added.push('presence.byStatus.working.state');
+  }
+  if (cfg.presence.byStatus?.thinking?.state === OLD_THINKING &&
+      DEFAULT_CONFIG.presence?.byStatus?.thinking?.state) {
+    cfg.presence.byStatus.thinking.state = DEFAULT_CONFIG.presence.byStatus.thinking.state;
+    added.push('presence.byStatus.thinking.state');
+  }
+
   if (added.length === 0) {
     console.log(`  config up to date → ${CONFIG_PATH}`);
     return false;

package/src/state.js

@@ -10,6 +10,23 @@ const DEFAULT_STATE = {
   status: 'idle',
   currentTool: null,
   currentFile: null,
+  // Set by PreCompact, cleared by PostCompact. While non-null the daemon
+  // renders the `compacting` frame so the card never reads "thinking"
+  // during a context squeeze (which is mechanically distinct from reasoning).
+  compactStartedAt: null,
+  compactTrigger: null,
+  // Set by PreToolUse, cleared by PostToolUse. format.js derives {toolElapsed}
+  // from this when the working tool has been running long enough to be
+  // worth surfacing (>5s by default — quick reads don't flicker on the card).
+  toolStartedAt: null,
+  // Set by PostToolUse when a `git push` or `git commit` is observed.
+  // format.applyShipped promotes status to 'shipped' for shippedFrameSec
+  // (default 60s) after this timestamp, so the card briefly celebrates
+  // a ship instead of immediately returning to "Working in <project>".
+  justShipped: null,
+  justShippedKind: null,     // 'push' | 'commit'
+  justShippedSubject: null,
+  justShippedBranch: null,
   model: 'claude',
   cwd: process.cwd(),
   messages: 0,

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