claude-rpc 1.0.3 → 1.1.1

package/README.md

@@ -133,6 +133,7 @@ claude-rpc today                  (today's stats, focused)
 claude-rpc week                   (weekday breakdown)
 claude-rpc preview                (every rotation frame rendered with real data)
 claude-rpc insights               (3–5 auto-generated lines: trend, peak, hotspot)
+claude-rpc recap --md             (standup-ready: yesterday's projects, ships, churn)
 ```
 
 The web dashboard pushes updates via SSE; the TUI refreshes on a 3-second tick.
@@ -309,6 +310,7 @@ It's a thin bootstrapper — on the first session it just runs `npx claude-rpc@l
 | `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 |
+| `recap`          | Standup summary — yesterday's work, paste-ready (`today\|week\|date`, `--md`) |
 | `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`) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-rpc",
-  "version": "1.0.3",
+  "version": "1.1.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/calendar.js

@@ -3,6 +3,7 @@
 // `claude-rpc calendar --out cal.svg [--gist]`.
 
 import { dayKey } from './scanner.js';
+import { localDateStamp } from './fmt.js';
 import { VERSION } from './version.js';
 
 const PALETTE = {
@@ -80,7 +81,7 @@ export function renderCalendar(aggregate, { weeks = 53, generatedAt = new Date()
   return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${W} ${H}" width="${W}" height="${H}" role="img" aria-label="Claude Code activity calendar">
   <rect width="${W}" height="${H}" fill="${PALETTE.paper}"/>
   <text x="${padX}" y="28" font-family="Space Grotesk, Inter, system-ui, sans-serif" font-size="20" font-weight="800" fill="${PALETTE.ink}">a year on Claude Code</text>
-  <text x="${padX}" y="44" font-family="JetBrains Mono, ui-monospace, monospace" font-size="11" fill="${PALETTE.inkMute}">${escapeXml(activeDays)} active days · ${escapeXml(totalHours)}h · as of ${generatedAt.toISOString().slice(0, 10)}</text>
+  <text x="${padX}" y="44" font-family="JetBrains Mono, ui-monospace, monospace" font-size="11" fill="${PALETTE.inkMute}">${escapeXml(activeDays)} active days · ${escapeXml(totalHours)}h · as of ${localDateStamp(generatedAt)}</text>
   ${monthLabels}
   ${cells}
   <text x="${W - 170}" y="${H - 10}" font-family="JetBrains Mono, ui-monospace, monospace" font-size="9" fill="${PALETTE.inkFaint}">less</text>

package/src/card.js

@@ -15,7 +15,7 @@ import { dayKey } from './scanner.js';
 import { fmtCost } from './pricing.js';
 import { rangeToDays, rangeLabel, pickWindow } from './badge.js';
 import { VERSION } from './version.js';
-import { fmtNum, fmtHours } from './fmt.js';
+import { fmtNum, fmtHours, localDateStamp } from './fmt.js';
 
 const W = 880;
 const H = 540;
@@ -237,7 +237,7 @@ export function renderCard(aggregate, { range = 'year', generatedAt = new Date()
   const linesNet = r.linesAdded - r.linesRemoved;
   const allTimeHours = ((aggregate?.activeMs || 0) / 3_600_000).toFixed(1);
 
-  const subtitle = `${escapeXml(r.daysActive)} active days / ${escapeXml(rangeLabel(range))} ending ${escapeXml(generatedAt.toISOString().slice(0, 10))}`;
+  const subtitle = `${escapeXml(r.daysActive)} active days / ${escapeXml(rangeLabel(range))} ending ${escapeXml(localDateStamp(generatedAt))}`;
 
   // Layout grid
   //   Title block          80 →  W-80

package/src/cli.js

@@ -116,6 +116,19 @@ function takeValue(v, flag) {
   return v;
 }
 
+// Expand `--flag=value` into two tokens so every takeValue-based parser
+// accepts the escape hatch takeValue's error message promises. Split on the
+// FIRST `=` only — values may contain their own (`--template={a}={b}`).
+function splitEqArgs(argv) {
+  const out = [];
+  for (const a of argv) {
+    const eq = typeof a === 'string' && a.startsWith('--') ? a.indexOf('=') : -1;
+    if (eq > 2) out.push(a.slice(0, eq), a.slice(eq + 1));
+    else out.push(a);
+  }
+  return out;
+}
+
 function startDaemon({ quiet = false } = {}) {
   const pid = daemonAlive();
   if (pid) {
@@ -241,8 +254,9 @@ function renderHourHistogram(byHour, opts = {}) {
     const ch = heightChars[idx];
     colored.push(h === opts.peakHour ? `${c.bold}${heat(1)}${ch}${c.reset}` : `${heat(ms / max)}${ch}${c.reset}`);
   }
-  // Hour labels under every 3rd hour.
-  const labels = '00  03  06  09  12  15  18  21  ';
+  // Hour labels under every 3rd hour — 3-char pitch to match the 1-char-per-
+  // hour bars above (a 4-char pitch drifted the labels a column per group).
+  const labels = '00 03 06 09 12 15 18 21';
   return [
     `  ${colored.join('')}`,
     `  ${c.dim}${labels}${c.reset}`,
@@ -302,8 +316,26 @@ function renderHeatmap(byDay, days = 91) {
       lastMonth = d.getMonth();
     }
   }
-  // Build header (3-letter months stretched across columns).
-  const header = labelRow.map((s) => (s + '   ').slice(0, 2)).join(' ');
+  // Build header on the SAME 2-chars-per-column pitch as the body rows
+  // (joining with a space drifted month labels a column per week, ~6 columns
+  // off by the right edge — and 2-char truncation made Mar/May both "Ma").
+  // Full 3-letter names are stamped into a char grid; months are always ≥4
+  // columns apart so an overhanging name can't collide with the next label.
+  const headerChars = new Array(cols * 2).fill(' ');
+  const stamps = [];
+  labelRow.forEach((s, col) => {
+    const name = String(s).trim(); // labelRow is prefilled with '  ' blanks
+    if (name) stamps.push({ name, col });
+  });
+  for (let i = 0; i < stamps.length; i++) {
+    const { name, col } = stamps[i];
+    const next = stamps[i + 1];
+    // Window-edge crowding: a month with a single week in view sits right
+    // next to the following month's label — yield to the newer month.
+    if (next && next.col * 2 < col * 2 + name.length + 1) continue;
+    for (let k = 0; k < name.length && col * 2 + k < headerChars.length; k++) headerChars[col * 2 + k] = name[k];
+  }
+  const header = headerChars.join('').replace(/\s+$/, '');
 
   const dayLabels = [' ', 'M', ' ', 'W', ' ', 'F', ' '];
   const lines = [`     ${c.dim}${header}${c.reset}`];
@@ -858,7 +890,36 @@ function showInsights() {
   console.log('');
 }
 
+// `claude-rpc recap [today|yesterday|week|YYYY-MM-DD] [--md|--json]` — the
+// standup answer. Defaults to yesterday (with Monday-covers-Friday fallback,
+// see recap.js). --md prints paste-ready markdown; --json the raw numbers.
+async function doRecap(argv) {
+  const { buildRecap, renderRecapMarkdown, renderRecapLines, recapTitle } = await import('./recap.js');
+  let spec = 'yesterday', md = false, json = false;
+  for (const a of argv) {
+    if (a === '--md' || a === '--markdown') md = true;
+    else if (a === '--json') json = true;
+    else if (!a.startsWith('-')) spec = a;
+    else return fail(`unknown flag ${a}`, { hint: 'usage: claude-rpc recap [today|yesterday|week|YYYY-MM-DD] [--md|--json]', code: EX_USER_ERROR });
+  }
+  const aggregate = readAggregate();
+  if (!aggregate) return fail('no stats yet', { hint: 'run `claude-rpc scan` to build your history first', code: EX_BAD_STATE });
+  const r = buildRecap(aggregate, spec);
+  if (!r) return fail(`unknown range: ${spec}`, { hint: 'usage: claude-rpc recap [today|yesterday|week|YYYY-MM-DD] [--md|--json]', code: EX_USER_ERROR });
+  if (json) { console.log(JSON.stringify(r, null, 2)); return; }
+  if (md) { console.log(renderRecapMarkdown(r)); return; }
+  console.log('');
+  console.log(`  ${c.bold}${c.magenta}◆ Recap${c.reset}  ${c.dim}— ${recapTitle(r)}${c.reset}`);
+  console.log('');
+  box('recap', renderRecapLines(r, c));
+  console.log('');
+  if (process.stdout.isTTY && !r.empty) {
+    console.log(`  ${c.dim}↗ standup-ready markdown: claude-rpc recap${spec === 'yesterday' ? '' : ` ${spec}`} --md${c.reset}\n`);
+  }
+}
+
 function parseBadgeArgs(argv) {
+  argv = splitEqArgs(argv);
   const out = { metric: 'hours', range: '7d', out: '', gist: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -893,11 +954,18 @@ async 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) {
+async function publishBadgeToGist(svg, opts, kind = 'badge') {
   const { publishGistFile, gistMarkdown } = await import('./gist.js');
   const cfg = loadConfig();
   const stored = cfg.gist || {};
-  const filename = stored.filename || 'claude.svg';
+  // One shared gist, but a filename PER ARTIFACT KIND — badge, calendar, and
+  // github-stat used to all write `claude.svg`, so publishing one silently
+  // replaced whichever the user had embedded. The legacy single `filename`
+  // stays with the badge (the original artifact); other kinds get their own
+  // stable file the first time they publish.
+  const files = stored.files || {};
+  const filename = files[kind]
+    || (kind === 'badge' ? (stored.filename || 'claude.svg') : `claude-${kind}.svg`);
   try {
     const result = await publishGistFile({
       svg,
@@ -915,8 +983,11 @@ async function publishBadgeToGist(svg, opts) {
       ...(userCfg.gist || {}),
       id: result.id,
       owner: result.owner,
-      filename,
+      files: { ...((userCfg.gist || {}).files || {}), [kind]: filename },
     };
+    // Keep the legacy field pointing at the badge so an older CLI version
+    // reading `gist.filename` still updates the right file.
+    if (kind === 'badge') userCfg.gist.filename = filename;
     if (stored.public !== undefined) userCfg.gist.public = stored.public;
     writeUserConfig(userCfg);
     const wasUpdate = !!stored.id;
@@ -940,6 +1011,7 @@ async function publishBadgeToGist(svg, opts) {
 // for a range (year / month / week / all-time). Output is SVG only;
 // screenshot or convert to PNG offline if needed.
 function parseCardArgs(argv) {
+  argv = splitEqArgs(argv);
   const out = { range: 'year', out: '' };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -970,6 +1042,7 @@ async function doCard(argv) {
 // 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) {
+  argv = splitEqArgs(argv);
   const out = { out: '', gist: false, handle: '' };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -989,7 +1062,7 @@ async function doGithubStat(argv) {
   const { renderProfileCard } = await import('./profile.js');
   const svg = renderProfileCard(aggregate, { handle: opts.handle });
   if (opts.gist) {
-    await publishBadgeToGist(svg, { metric: 'profile', range: 'all-time' });
+    await publishBadgeToGist(svg, { metric: 'profile', range: 'all-time' }, 'github-stat');
     return;
   }
   if (opts.out) {
@@ -1015,6 +1088,7 @@ function liveVars() {
 // statusline — a compact one-line status for tmux / starship / shell prompts
 // and Claude Code's own statusline. `--template "..."` overrides the format.
 function doStatusline(argv) {
+  argv = splitEqArgs(argv);
   let tpl = '{statusVerbose} · {project} · {modelPretty}{tokensLabelPad}';
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--template' || argv[i] === '-t') tpl = takeValue(argv[++i], '--template');
@@ -1026,6 +1100,7 @@ function doStatusline(argv) {
 
 // Activity calendar — GitHub-contributions-style year heatmap SVG.
 async function doCalendar(argv) {
+  argv = splitEqArgs(argv);
   const opts = { out: '', gist: false };
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--out' || argv[i] === '-o') opts.out = takeValue(argv[++i], '--out');
@@ -1035,7 +1110,7 @@ async function doCalendar(argv) {
   if (!aggregate) fail('no aggregate yet — nothing to render', { hint: 'run `claude-rpc scan` first', code: EX_BAD_STATE });
   const { renderCalendar } = await import('./calendar.js');
   const svg = renderCalendar(aggregate, {});
-  if (opts.gist) return publishBadgeToGist(svg, { metric: 'calendar', range: 'year' });
+  if (opts.gist) return publishBadgeToGist(svg, { metric: 'calendar', range: 'year' }, 'calendar');
   if (opts.out) {
     writeFileSync(opts.out, svg);
     console.log(`  ${c.green}✓${c.reset}  wrote ${c.cyan}${opts.out}${c.reset}  ${c.dim}(${svg.length} bytes)${c.reset}`);
@@ -1044,6 +1119,7 @@ async function doCalendar(argv) {
 
 // Per-session recap card — current/most-recent session as a shareable SVG.
 async function doSessionCard(argv) {
+  argv = splitEqArgs(argv);
   const opts = { out: '' };
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--out' || argv[i] === '-o') opts.out = takeValue(argv[++i], '--out');
@@ -1258,10 +1334,12 @@ function doResume() {
 // pipes cleanly into jq / a spreadsheet import.
 
 async function doExport(argv) {
+  argv = splitEqArgs(argv);
   const csv = argv.includes('--csv');
   let out = '';
-  const i = argv.findIndex((a) => a === '--out' || a === '-o');
-  if (i !== -1) out = argv[i + 1] || '';
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--out' || argv[i] === '-o') out = takeValue(argv[++i], '--out');
+  }
   const aggregate = readAggregate();
   if (!aggregate) {
     fail('no aggregate yet — nothing to export', { hint: 'run `claude-rpc scan` first', code: EX_BAD_STATE });
@@ -1601,7 +1679,13 @@ async function communityReport() {
   } else if (result.ok) {
     console.log(`  ${c.cyan}·${c.reset}  ${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}`);
+    // Scripts rely on the exit code (`claude-rpc community report || alert`),
+    // so a failed flush must exit non-zero, not just print a warning.
+    console.log('');
+    return fail('flush did not complete', {
+      hint: `${result.reason}${result.error ? ': ' + result.error : ''}`,
+      code: EX_SYS_ERROR,
+    });
   }
   console.log('');
 }
@@ -1717,8 +1801,10 @@ function profileSet(argv) {
       next.githubUser = u;
     }
     // The ✓ belongs to the account that was verified — switching accounts
-    // means re-verifying.
-    if (next.githubUser !== (userCfg.profile || {}).githubUser) delete next.verified;
+    // means re-verifying. GitHub usernames are case-insensitive, so a
+    // case-only respelling of the same account keeps the badge.
+    const prevGh = String((userCfg.profile || {}).githubUser || '').toLowerCase();
+    if (String(next.githubUser || '').toLowerCase() !== prevGh) delete next.verified;
   }
 
   userCfg.profile = next;
@@ -2005,6 +2091,7 @@ 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'],
+    ['recap',     'Standup summary (yesterday by default; today|week|date, --md for markdown)'],
     ['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)'],
@@ -2161,6 +2248,7 @@ process.on('unhandledRejection', (e) => {
     case 'rescan':    doScan(true); break;
     case 'backfill':  doBackfill(process.argv.slice(3)); break;
     case 'insights':  showInsights(); break;
+    case 'recap':     await doRecap(process.argv.slice(3)); 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;

package/src/daemon.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { existsSync, unlinkSync, watch, appendFileSync, mkdirSync, statSync, renameSync } from 'node:fs';
-import { basename, dirname } from 'node:path';
+import { existsSync, unlinkSync, watch, appendFileSync, mkdirSync, statSync, renameSync, readdirSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
 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';
@@ -291,10 +291,13 @@ function buildActivity(opts = {}) {
 
   if (state.status === 'stale') {
     effectiveSessionStart = null;
-  } else if (state.sessionStart) {
+  } else if (state.sessionStart && !state.borrowed) {
     effectiveSessionStart = state.sessionStart;
   } else if (!effectiveSessionStart) {
-    effectiveSessionStart = state.lastActivity || Date.now();
+    // Borrowed states carry a moving transcript mtime as sessionStart — seed
+    // the timer from the first observation and hold it, or the elapsed clock
+    // restarts every refreshLiveSessions tick.
+    effectiveSessionStart = state.sessionStart || state.lastActivity || Date.now();
   }
   if (config.showElapsed && effectiveSessionStart && state.status !== 'stale') {
     // Discord IPC expects millisecond timestamps (not seconds).
@@ -574,7 +577,15 @@ function watchFiles() {
   // every writer here (state.js, pause.js, the scanner, the settings GUI)
   // commits via tmp+rename.
   const targets = [
-    { path: STATE_PATH, label: 'state', onChange: pushPresence },
+    // Hooks write per-session state-<sid>.json (state.json only for legacy
+    // payloads without a session_id), so the state target matches the whole
+    // family — filtering on the literal 'state.json' made the instant watcher
+    // path dead for every real session, leaving only the poll tick.
+    {
+      path: STATE_PATH, label: 'state', onChange: pushPresence,
+      matches: (f) => /^state(-.+)?\.json$/.test(f),
+      scanDir: STATE_DIR,
+    },
     { path: PAUSE_PATH, label: 'pause', onChange: pushPresence },
     { path: CONFIG_PATH, label: 'config', onChange: () => {
       log('Config changed — reloading');
@@ -595,17 +606,38 @@ function watchFiles() {
   // poll only logs a "fallback caught it" line for events the watcher truly
   // missed, not for everything it already handled.
   const lastMtime = new Map();
-  const recordMtime = (path) => {
-    try { if (existsSync(path)) lastMtime.set(path, statSync(path).mtimeMs); }
-    catch { /* mid-rename; a later observation records it */ }
+  // Current mtime for a target: single file by default, or the max across a
+  // directory's matching files for family targets (state-<sid>.json). Max is
+  // monotone under writes, so pollDecision's `cur > prev` still works; a
+  // deleted session file lowers it, which correctly doesn't fire.
+  const statTarget = (t) => {
+    if (t.scanDir) {
+      let max;
+      try {
+        for (const name of readdirSync(t.scanDir)) {
+          if (!t.matches(name)) continue;
+          try {
+            const m = statSync(join(t.scanDir, name)).mtimeMs;
+            if (max === undefined || m > max) max = m;
+          } catch { /* file vanished mid-scan */ }
+        }
+      } catch { /* dir missing (pre-first-hook) */ }
+      return max;
+    }
+    try { return existsSync(t.path) ? statSync(t.path).mtimeMs : undefined; }
+    catch { return undefined; /* mid-rename; a later observation records it */ }
+  };
+  const recordMtime = (t) => {
+    const m = statTarget(t);
+    if (m !== undefined) lastMtime.set(t.path, m);
   };
   // Seed baselines so the first poll tick doesn't fire for files that merely
   // already existed when the daemon started.
-  targets.forEach((t) => recordMtime(t.path));
+  targets.forEach((t) => recordMtime(t));
 
   const fire = (t, viaPoll) => {
     if (viaPoll) log(`${t.label} changed — poll fallback caught an event fs.watch missed`);
-    recordMtime(t.path); // record before onChange so a re-entrant tick can't double-fire
+    recordMtime(t); // record before onChange so a re-entrant tick can't double-fire
     t.onChange();
   };
 
@@ -625,11 +657,12 @@ function watchFiles() {
   }
   for (const [dir, group] of groups) {
     if (!existsSync(dir)) continue;
-    const byName = new Map(group.map((t) => [basename(t.path), t]));
     let timer = null;
     try {
       watch(dir, (event, filename) => {
-        const hits = filename ? (byName.has(filename) ? [byName.get(filename)] : []) : group;
+        const hits = filename
+          ? group.filter((t) => (t.matches ? t.matches(String(filename)) : basename(t.path) === filename))
+          : group;
         if (!hits.length) return;
         clearTimeout(timer);
         timer = setTimeout(() => hits.forEach((t) => fire(t, false)), 250);
@@ -646,9 +679,7 @@ function watchFiles() {
   // until the next unrelated state change.
   setInterval(() => {
     for (const t of targets) {
-      let cur;
-      try { cur = existsSync(t.path) ? statSync(t.path).mtimeMs : undefined; }
-      catch { continue; /* mid-rename; next tick picks it up */ }
+      const cur = statTarget(t);
       const decision = pollDecision(lastMtime.get(t.path), cur);
       if (decision === 'seed') lastMtime.set(t.path, cur);
       else if (decision === 'fire') fire(t, true);

package/src/fmt.js

@@ -31,3 +31,11 @@ export function fmtHours(ms) {
   const hours = mins / 60;
   return hours < 10 ? `${hours.toFixed(1)}h` : `${Math.round(hours)}h`;
 }
+
+// Local calendar date "YYYY-MM-DD" — the same day the scanner's byDay buckets
+// key on. Card/calendar/profile stamps used toISOString(), which is UTC and
+// labels the data with the wrong day for any non-UTC user near midnight.
+export function localDateStamp(d = new Date()) {
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}

package/src/format.js

@@ -805,6 +805,10 @@ function borrowLiveSession(state, liveSessions, now) {
   return {
     ...state,
     status: 'working',
+    // sessionStart here is a moving transcript mtime, not a real anchor — the
+    // flag lets the daemon pin its elapsed timer to the first observation
+    // instead of restarting it every 30s refresh.
+    borrowed: true,
     cwd: recent.cwd || state.cwd || '',
     sessionStart: recent.mtime || now,
     lastActivity: recent.mtime || now,

package/src/hook.js

@@ -6,93 +6,10 @@ import { detectLastCommitSubject, detectGitBranch } from './git.js';
 import { EVENTS_LOG_PATH } from './paths.js';
 import { loadConfig } from './config.js';
 import { ensureDaemonRunning } from './ensure-daemon.js';
-
-// Precedence when a command ships more than one way (`git commit && git push`
-// → push). Highest first.
-const SHIP_PRECEDENCE = ['push', 'commit', 'pr', 'issue', 'tag'];
-
-// Tokenize one command segment the way a shell roughly would for our purposes:
-// strip leading env assignments (FOO=bar) and sudo/time wrappers, drop the path
-// from the leading binary (/usr/bin/git → git), lowercase it.
-function tokenizeSegment(seg) {
-  const stripped = seg.replace(/^\s*(?:[A-Za-z_][A-Za-z0-9_]*=\S+\s+)+/, '').trim();
-  let toks = stripped.split(/\s+/).filter(Boolean);
-  while (toks.length && (toks[0] === 'sudo' || toks[0] === 'time')) toks = toks.slice(1);
-  if (toks.length) {
-    const slash = toks[0].lastIndexOf('/');
-    if (slash !== -1) toks[0] = toks[0].slice(slash + 1);
-    toks[0] = toks[0].toLowerCase();
-  }
-  return toks;
-}
-
-// First real git subcommand, skipping global flags and their values
-// (`git -C /repo -c k=v push` → push).
-function gitSubcommand(args) {
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (a === '-C' || a === '-c') { i++; continue; } // flag that takes a value
-    if (a.startsWith('-')) continue;
-    return a.toLowerCase();
-  }
-  return null;
-}
-
-// First two gh positionals (noun, verb), skipping global flags so the canonical
-// targeted form `gh -R owner/repo pr create` still classifies. -R/--repo take a
-// value; other globals here don't precede a create, so skipping the rest is safe.
-function ghSubcommand(args) {
-  const pos = [];
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (a === '-R' || a === '--repo') { i++; continue; } // flag that takes a value
-    if (a.startsWith('-')) continue;
-    pos.push(a.toLowerCase());
-    if (pos.length === 2) break;
-  }
-  return { noun: pos[0], verb: pos[1] };
-}
-
-function shipKindForSegment(seg) {
-  const toks = tokenizeSegment(seg);
-  if (!toks.length) return null;
-  if (toks[0] === 'git') {
-    const sub = gitSubcommand(toks.slice(1));
-    if (sub === 'push') return 'push';
-    if (sub === 'commit') return 'commit';
-  } else if (toks[0] === 'gh') {
-    const { noun, verb } = ghSubcommand(toks.slice(1));
-    if (noun === 'pr' && verb === 'create') return 'pr';
-    if (noun === 'issue' && verb === 'create') return 'issue';
-    if (noun === 'release' && verb === 'create') return 'tag';
-  }
-  return null;
-}
-
-// Return the "shipped" kind for a shell command, or null. Exported for tests.
-// Splits on shell separators and only classifies a segment whose *actual*
-// leading command is git/gh — so a quoted mention ("git push later" inside an
-// echo or a commit message) no longer false-fires. Tolerates env prefixes,
-// sudo/time, chained commands, and git global flags.
-//
-// Quoted spans are blanked BEFORE splitting: separators inside quotes
-// (`echo "run git push && rejoice"`) used to create a fake segment whose
-// leading command was git. The real command's own quoted args (`git commit
-// -m "msg"`) classify the same with or without the message text, so blanking
-// is lossless for detection. An unbalanced quote leaves the string untouched.
-export function classifyShip(cmd) {
-  const blanked = String(cmd || '')
-    .replace(/'[^']*'/g, ' ')
-    .replace(/"(?:\\.|[^"\\])*"/g, ' ');
-  const segments = blanked.split(/[;&|\n]+/);
-  const found = new Set();
-  for (const seg of segments) {
-    const k = shipKindForSegment(seg);
-    if (k) found.add(k);
-  }
-  for (const kind of SHIP_PRECEDENCE) if (found.has(kind)) return kind;
-  return null;
-}
+// Ship classification lives in ships.js (shared with the scanner); re-exported
+// here so existing importers/tests keep working.
+import { classifyShip } from './ships.js';
+export { classifyShip };
 
 const EVENTS_LOG_ROTATE_BYTES = 5 * 1024 * 1024;
 
@@ -150,6 +67,23 @@ export function processHookEvent(event, input = {}) {
 
   switch (event) {
     case 'SessionStart': {
+      // Post-compaction continuation, NOT a new session: Claude Code re-fires
+      // SessionStart with source:'compact' after every compaction. Resetting
+      // here wiped the elapsed timer and message/tool/file counters mid-turn.
+      // Just clear the compacting marker and carry on; the turn that triggered
+      // the compaction resumes immediately, hence 'working'.
+      if (input.source === 'compact') {
+        update((s) => {
+          delete s.compactStartedAt;
+          delete s.compactTrigger;
+          s.status = 'working';
+          s.lastActivity = now;
+          s.claudeClosed = false;
+          if (!s.sessionStart) s.sessionStart = now;
+          return s;
+        });
+        break;
+      }
       reset({
         cwd: input.cwd || process.cwd(),
         model: input.model?.id || input.model || 'claude',
@@ -215,7 +149,7 @@ export function processHookEvent(event, input = {}) {
     case 'PostToolUse': {
       const toolName = input.tool_name || input.toolName || '';
       const toolInput = input.tool_input || input.toolInput || {};
-      const file = toolInput.file_path || toolInput.path || null;
+      const file = toolInput.file_path || toolInput.path || toolInput.notebook_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
@@ -310,8 +244,15 @@ export function processHookEvent(event, input = {}) {
       });
       break;
     }
+    case 'SubagentStop': {
+      // A subagent finishing is not the SESSION going idle — the parent turn
+      // is still running (often with sibling subagents in flight). Flipping to
+      // idle here showed "Standing by" mid-generation. Just record liveness;
+      // the parent's own Stop/PreToolUse hooks drive status.
+      setActivity({});
+      break;
+    }
     case 'Stop':
-    case 'SubagentStop':
     default: {
       setActivity({ status: 'idle', currentTool: null, currentFile: null });
     }

package/src/mcp.js

@@ -8,6 +8,7 @@
 // without standing up the transport.
 
 import { readAggregate, dayKey } from './scanner.js';
+import { buildRecap, renderRecapMarkdown } from './recap.js';
 import { VERSION } from './version.js';
 
 function fmtH(ms) { const h = (ms || 0) / 3_600_000; return h < 1 ? `${Math.round(h * 60)}m` : `${h.toFixed(1)}h`; }
@@ -75,6 +76,25 @@ export const TOOLS = {
       return split.map((m) => `${m.model}: $${(m.cost || 0).toFixed(2)} (${Math.round((m.costPct || 0) * 100)}%) · ${fmtN(m.tokens)} tokens · ${m.turns} turns`).join('\n');
     },
   },
+  get_recap: {
+    description: 'Standup-ready recap of a day or week of Claude Code work: active time, sessions, projects touched, ships (commits/pushes/PRs), code churn, tokens/cost. Answers "what did I work on yesterday/this week?".',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        range: {
+          type: 'string',
+          description: 'today | yesterday | week | YYYY-MM-DD (default yesterday; an inactive yesterday falls back to the most recent active day, so Monday covers Friday)',
+        },
+      },
+      additionalProperties: false,
+    },
+    handler(agg, args) {
+      const spec = args?.range || 'yesterday';
+      const r = buildRecap(agg, spec);
+      if (!r) return `Unknown range "${spec}" — use today, yesterday, week, or YYYY-MM-DD.`;
+      return renderRecapMarkdown(r);
+    },
+  },
 };
 
 // Build a tools/list payload from the registry.
@@ -82,7 +102,7 @@ export function toolList() {
   return Object.entries(TOOLS).map(([name, t]) => ({
     name,
     description: t.description,
-    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    inputSchema: t.inputSchema || { type: 'object', properties: {}, additionalProperties: false },
   }));
 }
 
@@ -90,10 +110,11 @@ export function toolList() {
  * Dispatch a tools/call by name. Reads a fresh aggregate per call (cheap).
  * @param {string} name - Tool name (a key of TOOLS).
  * @param {() => object} [getAgg] - Aggregate provider; defaults to readAggregate (injectable for tests).
+ * @param {object} [args] - Tool arguments (params.arguments from tools/call).
  * @returns {string} The tool's text result.
  * @throws {Error} If the tool name is unknown.
  */
-export function callTool(name, getAgg = readAggregate) {
+export function callTool(name, getAgg = readAggregate, args = {}) {
   const t = TOOLS[name];
   if (!t) throw new Error(`unknown tool: ${name}`);
   const agg = getAgg();
@@ -101,7 +122,7 @@ export function callTool(name, getAgg = readAggregate) {
   // a `|| {}` here would render all-zeros, indistinguishable from a genuinely
   // idle day. Surface the same hint every other surface uses instead.
   if (agg == null) return 'No stats yet — run `claude-rpc scan` to build your history.';
-  return t.handler(agg);
+  return t.handler(agg, args);
 }
 
 /**
@@ -144,7 +165,7 @@ export function runMcpServer({ input = process.stdin, output = process.stdout }
       if (!name) return replyErr(id, -32602, 'missing tool name');
       if (!TOOLS[name]) return replyErr(id, -32602, `unknown tool: ${name}`);
       try {
-        const text = callTool(name);
+        const text = callTool(name, undefined, params?.arguments || {});
         return reply(id, { content: [{ type: 'text', text }], isError: false });
       } catch (e) {
         return reply(id, { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true });

package/src/nudge.js

@@ -26,9 +26,11 @@ function reached(value, list) {
 const fmt = (n) => n >= 1000 ? n.toLocaleString('en-US') : String(n);
 
 // Returns { key, weight, message } for the biggest milestone the aggregate has
-// crossed, or null. `weight` ranks across milestone types so we only ever show
-// the single most impressive one.
-export function pickShareNudge(agg) {
+// crossed that hasn't been shown yet, or null. `weight` ranks across milestone
+// types so we show the single most impressive UNSEEN one — without the `shown`
+// filter, a standing streak record (weight 1000+) re-won every pick, matched
+// the dedup, and permanently silenced every other milestone behind it.
+export function pickShareNudge(agg, shown = new Set()) {
   if (!agg || typeof agg !== 'object') return null;
   const out = [];
 
@@ -58,9 +60,10 @@ export function pickShareNudge(agg) {
     message: `${fmt(h)}+ hours on Claude Code. Your year-in-review is ready — \`claude-rpc serve\` then open /wrapped and hit Share.`,
   });
 
-  if (!out.length) return null;
-  out.sort((a, b) => b.weight - a.weight);
-  return out[0];
+  const fresh = out.filter((n) => !shown.has(n.key));
+  if (!fresh.length) return null;
+  fresh.sort((a, b) => b.weight - a.weight);
+  return fresh[0];
 }
 
 // A quiet, local celebration line for `claude-rpc today`. Complements the
@@ -88,15 +91,22 @@ export function pickTodayMilestone(agg, todayTokens = 0) {
   return null;
 }
 
-function readLastKey(path = NUDGE_STATE) {
-  try { return JSON.parse(readFileSync(path, 'utf8')).key || null; }
-  catch { return null; }
+// Set of every nudge key already shown. Older state files stored a single
+// `key`; fold it in so upgrading doesn't re-show the last nudge.
+function readShownKeys(path = NUDGE_STATE) {
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    const keys = Array.isArray(raw.shown) ? raw.shown : [];
+    if (raw.key) keys.push(raw.key);
+    return new Set(keys.filter((k) => typeof k === 'string'));
+  } catch { return new Set(); }
 }
 
-function writeLastKey(key, path = NUDGE_STATE) {
+function writeShownKeys(shown, path = NUDGE_STATE) {
   try {
     mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify({ key, ts: Date.now() }));
+    // Cap the history — milestone lists are finite, 100 is plenty.
+    writeFileSync(path, JSON.stringify({ shown: [...shown].slice(-100), ts: Date.now() }));
   } catch { /* best-effort */ }
 }
 
@@ -104,9 +114,10 @@ function writeLastKey(key, path = NUDGE_STATE) {
 // dedup. Returns a string to print, or null. Marks the nudge as shown.
 export function maybeNudge(agg, config = {}, { path = NUDGE_STATE } = {}) {
   if (config?.nudges?.enabled === false) return null;
-  const n = pickShareNudge(agg);
+  const shown = readShownKeys(path);
+  const n = pickShareNudge(agg, shown);
   if (!n) return null;
-  if (n.key === readLastKey(path)) return null;   // already shown this one
-  writeLastKey(n.key, path);
+  shown.add(n.key);
+  writeShownKeys(shown, path);
   return n.message;
 }

package/src/profile.js

@@ -7,7 +7,7 @@
 
 import { fmtCost } from './pricing.js';
 import { VERSION } from './version.js';
-import { fmtNum, fmtHours } from './fmt.js';
+import { fmtNum, fmtHours, localDateStamp } from './fmt.js';
 
 const W = 520;
 const H = 240;
@@ -94,7 +94,7 @@ export function renderProfileCard(aggregate, { handle = '', generatedAt = new Da
   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 sub = `${who} · Day ${t.daysSinceFirst} · as of ${localDateStamp(generatedAt)}`;
   const netStr = `${t.linesNet >= 0 ? '+' : '−'}${fmtNum(Math.abs(t.linesNet))}`;
 
   // 3 columns × 2 rows of stats.

package/src/recap.js

@@ -0,0 +1,205 @@
+// Standup recap — "what did I do yesterday?" answered from aggregate.json.
+// Pure functions of (aggregate, range spec, now): buildRecap assembles the
+// numbers, renderRecapMarkdown/renderRecapLines format them for pasting into
+// a standup message or printing in the terminal. Consumed by `claude-rpc
+// recap` and the MCP `get_recap` tool.
+//
+// Range semantics:
+//   today       — the current local day
+//   yesterday   — the previous local day; if it had no activity (weekend,
+//                 day off), falls back to the most recent active day before
+//                 today and says so — Monday standups cover Friday.
+//   week        — the last 7 local days, ending today
+//   YYYY-MM-DD  — one explicit local day
+import { dayKey } from './scanner.js';
+
+const WEEKDAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const SHIP_LABELS = [
+  ['commit', 'commit', 'commits'],
+  ['push', 'push', 'pushes'],
+  ['pr', 'PR', 'PRs'],
+  ['issue', 'issue', 'issues'],
+  ['tag', 'release', 'releases'],
+];
+
+function fmtDur(ms) {
+  const m = Math.round((ms || 0) / 60_000);
+  if (m < 1) return '0m';
+  if (m < 60) return `${m}m`;
+  return `${(m / 60).toFixed(1)}h`;
+}
+
+function fmtN(n) {
+  if (!n) return '0';
+  if (n < 1000) return String(Math.round(n));
+  if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+  if (n < 1e9) return `${(n / 1e6).toFixed(2)}M`;
+  return `${(n / 1e9).toFixed(2)}B`;
+}
+
+function dayKeyAt(now, offsetDays) {
+  const d = new Date(now);
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() - offsetDays);
+  return dayKey(d.getTime());
+}
+
+// "Tue 2026-07-01" — manual weekday names so output is locale-stable.
+function prettyDay(key) {
+  const [y, m, d] = String(key).split('-').map(Number);
+  if (!y || !m || !d) return String(key);
+  return `${WEEKDAYS[new Date(y, m - 1, d).getDay()]} ${key}`;
+}
+
+// A day "has activity" when real work landed — active time, prompts, tool
+// calls, sessions, or tokens. Notification-only days (the daemon logging a
+// permission ping) don't count.
+function hasActivity(bucket) {
+  if (!bucket) return false;
+  return (bucket.activeMs || 0) > 0 || (bucket.userMessages || 0) > 0
+    || (bucket.toolCalls || 0) > 0 || (bucket.sessions || 0) > 0
+    || (bucket.inputTokens || 0) + (bucket.outputTokens || 0)
+     + (bucket.cacheReadTokens || 0) + (bucket.cacheWriteTokens || 0) > 0;
+}
+
+// Resolve a range spec to { label, days, note }. Exported for tests.
+export function resolveRecapRange(spec, agg, now = Date.now()) {
+  const byDay = agg?.byDay || {};
+  const s = String(spec || 'yesterday').toLowerCase();
+  if (s === 'today') return { label: 'today', days: [dayKeyAt(now, 0)] };
+  if (s === 'week') {
+    const days = [];
+    for (let i = 6; i >= 0; i--) days.push(dayKeyAt(now, i));
+    return { label: 'last 7 days', days };
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return { label: prettyDay(s), days: [s] };
+  if (s !== 'yesterday') return null; // unknown spec — caller reports usage
+  const yesterday = dayKeyAt(now, 1);
+  if (hasActivity(byDay[yesterday])) return { label: 'yesterday', days: [yesterday] };
+  // Walk back for the most recent active day before today (bounded so a
+  // fresh install doesn't loop through a year of nothing).
+  for (let i = 2; i <= 366; i++) {
+    const k = dayKeyAt(now, i);
+    if (hasActivity(byDay[k])) {
+      return {
+        label: 'yesterday',
+        days: [k],
+        note: `no activity yesterday — showing ${prettyDay(k)}, your most recent active day`,
+      };
+    }
+  }
+  return { label: 'yesterday', days: [yesterday] }; // genuinely nothing — renders as empty
+}
+
+/**
+ * Assemble a recap for a range of days.
+ * @param {object} agg - aggregate.json contents
+ * @param {string} [spec] - today|yesterday|week|YYYY-MM-DD (default yesterday)
+ * @param {number} [now] - injectable clock for tests
+ * @returns {object|null} recap data, or null for an unknown spec
+ */
+export function buildRecap(agg, spec = 'yesterday', now = Date.now()) {
+  const range = resolveRecapRange(spec, agg, now);
+  if (!range) return null;
+  const byDay = agg?.byDay || {};
+  const r = {
+    label: range.label,
+    days: range.days,
+    from: range.days[0],
+    to: range.days[range.days.length - 1],
+    note: range.note || null,
+    activeMs: 0, sessions: 0, prompts: 0, toolCalls: 0,
+    tokens: 0, cost: 0, linesAdded: 0, linesRemoved: 0,
+    ships: 0, shipKinds: {}, projects: [],
+  };
+  const projects = {};
+  for (const k of range.days) {
+    const d = byDay[k];
+    if (!d) continue;
+    r.activeMs += d.activeMs || 0;
+    r.sessions += d.sessions || 0;
+    r.prompts += d.userMessages || 0;
+    r.toolCalls += d.toolCalls || 0;
+    r.tokens += (d.inputTokens || 0) + (d.outputTokens || 0) + (d.cacheReadTokens || 0) + (d.cacheWriteTokens || 0);
+    r.cost += d.cost || 0;
+    r.linesAdded += d.linesAdded || 0;
+    r.linesRemoved += d.linesRemoved || 0;
+    r.ships += d.ships || 0;
+    for (const [kind, n] of Object.entries(d.shipKinds || {})) {
+      r.shipKinds[kind] = (r.shipKinds[kind] || 0) + n;
+    }
+    for (const [name, p] of Object.entries(d.projects || {})) {
+      const t = projects[name] ||= { name, activeMs: 0, tokens: 0 };
+      t.activeMs += p.activeMs || 0;
+      t.tokens += p.tokens || 0;
+    }
+  }
+  r.projects = Object.values(projects)
+    .sort((a, b) => (b.activeMs - a.activeMs) || (b.tokens - a.tokens) || a.name.localeCompare(b.name));
+  r.empty = !(r.activeMs || r.prompts || r.toolCalls || r.sessions || r.tokens);
+  return r;
+}
+
+/** Human title for a recap: "Tue 2026-07-01 (yesterday)" / "last 7 days (…)". */
+export function recapTitle(r) {
+  if (r.days.length > 1) return `${r.label} (${r.from} → ${r.to})`;
+  const day = prettyDay(r.from);
+  return r.label === 'today' || r.label === 'yesterday' ? `${day} (${r.label})` : day;
+}
+
+function shipPhrase(r) {
+  const parts = [];
+  for (const [kind, singular, plural] of SHIP_LABELS) {
+    const n = r.shipKinds[kind] || 0;
+    if (n) parts.push(`${n} ${n === 1 ? singular : plural}`);
+  }
+  // Counted ships whose kind map got lost (old partial data) still show up.
+  if (!parts.length && r.ships) parts.push(`${r.ships}×`);
+  return parts.join(' · ');
+}
+
+function projectPhrase(r, max = 6) {
+  const shown = r.projects.slice(0, max)
+    .map((p) => (p.activeMs >= 60_000 ? `${p.name} (${fmtDur(p.activeMs)})` : p.name));
+  const extra = r.projects.length - max;
+  if (extra > 0) shown.push(`+${extra} more`);
+  return shown.join(', ');
+}
+
+/** Markdown recap — standup-paste-ready. */
+export function renderRecapMarkdown(r) {
+  const lines = [`**Claude Code recap — ${recapTitle(r)}**`, ''];
+  if (r.empty) {
+    lines.push(`_No Claude Code activity ${r.days.length > 1 ? 'in this range' : `on ${prettyDay(r.from)}`}._`);
+    return lines.join('\n');
+  }
+  lines.push(`- **Active:** ${fmtDur(r.activeMs)} across ${r.sessions} session${r.sessions === 1 ? '' : 's'} · ${r.prompts} prompt${r.prompts === 1 ? '' : 's'}`);
+  if (r.projects.length) lines.push(`- **Projects:** ${projectPhrase(r)}`);
+  if (r.ships) lines.push(`- **Shipped:** ${shipPhrase(r)}`);
+  if (r.linesAdded || r.linesRemoved) lines.push(`- **Code:** +${fmtN(r.linesAdded)} / −${fmtN(r.linesRemoved)} lines · ${fmtN(r.toolCalls)} tool calls`);
+  lines.push(`- **Tokens:** ${fmtN(r.tokens)} · est. $${r.cost.toFixed(2)}`);
+  if (r.note) lines.push('', `_(${r.note})_`);
+  return lines.join('\n');
+}
+
+/**
+ * Terminal recap — array of lines for the CLI's box renderer.
+ * @param {object} r - buildRecap result
+ * @param {object} [c] - optional ANSI palette ({bold, dim, cyan, green, reset, …}); omit for plain text
+ */
+export function renderRecapLines(r, c = {}) {
+  const B = c.bold || '', D = c.dim || '', C = c.cyan || '', G = c.green || '', R = c.reset || '';
+  if (r.empty) {
+    const where = r.days.length > 1 ? 'in this range' : `on ${prettyDay(r.from)}`;
+    return [`${D}no Claude Code activity ${where}${R}`];
+  }
+  const lines = [
+    `${D}active${R}    ${B}${fmtDur(r.activeMs)}${R} · ${r.sessions} session${r.sessions === 1 ? '' : 's'} · ${r.prompts} prompt${r.prompts === 1 ? '' : 's'}`,
+  ];
+  if (r.projects.length) lines.push(`${D}projects${R}  ${C}${projectPhrase(r)}${R}`);
+  if (r.ships) lines.push(`${D}shipped${R}   ${G}${shipPhrase(r)}${R}`);
+  if (r.linesAdded || r.linesRemoved) lines.push(`${D}code${R}      +${fmtN(r.linesAdded)} / −${fmtN(r.linesRemoved)} lines · ${fmtN(r.toolCalls)} tool calls`);
+  lines.push(`${D}tokens${R}    ${fmtN(r.tokens)} · est. $${r.cost.toFixed(2)}`);
+  if (r.note) lines.push(`${D}(${r.note})${R}`);
+  return lines;
+}

package/src/scanner.js

@@ -1,13 +1,17 @@
-import { readdirSync, readFileSync, statSync, existsSync, writeFileSync, mkdirSync, renameSync, openSync, readSync, closeSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync, existsSync, writeFileSync, mkdirSync, renameSync, openSync, readSync, closeSync, realpathSync } from 'node:fs';
 import { join, dirname, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { CLAUDE_PROJECTS, SCAN_CACHE_PATH, AGGREGATE_PATH, DATA_DIR, EVENTS_LOG_PATH } from './paths.js';
 import { languageOf } from './languages.js';
 import { costFor, pricingKeyFor } from './pricing.js';
+import { classifyShip } from './ships.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 = 4;
+// 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;
 
 // Cap counted gap between consecutive timestamps. Anything larger is treated
 // as the user walking away — we count only what's plausibly active time.
@@ -129,8 +133,13 @@ function blankDay() {
     linesRemoved: 0,
     cost: 0,
     notifications: 0,
+    ships: 0,
     firstTs: null,
     lastTs: null,
+    // Day buckets may also lazily carry:
+    //   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)
   };
 }
 
@@ -147,6 +156,10 @@ function mergeDay(target, src) {
   target.linesRemoved += src.linesRemoved || 0;
   target.cost += src.cost || 0;
   target.notifications += src.notifications || 0;
+  target.ships += src.ships || 0;
+  for (const [k, n] of Object.entries(src.shipKinds || {})) {
+    (target.shipKinds ||= {})[k] = (target.shipKinds[k] || 0) + n;
+  }
   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;
 }
@@ -236,6 +249,8 @@ function blankTranscriptSummary() {
     bashCommands: {},     // first token → count
     webDomains: {},       // hostname → count
     subagents: {},        // subagent_type → count
+    ships: 0,             // shipped-command count (git commit/push, gh pr/issue/release create)
+    shipKinds: {},        // ship kind → count
     cost: 0,              // estimated USD
     costByModel: {},      // pricing key → USD
     modelsUsed: {},       // raw model id → assistant turns
@@ -282,6 +297,15 @@ function parseChunkInto(text, summary, pstate) {
     const weekBucket = week ? (summary.byWeek[week] ||= blankDay()) : null;
     const hourBucket = hour !== null ? (summary.byHour[hour] ||= blankDay()) : null;
     const allBuckets = [dayBucket, weekBucket, hourBucket].filter(Boolean);
+    // First/last activity within each bucket — blankDay declares these and
+    // mergeDay merges them, but nothing assigned them, so "started 09:14"-style
+    // labels never rendered.
+    if (ts) {
+      for (const bucket of allBuckets) {
+        if (!bucket.firstTs || ts < bucket.firstTs) bucket.firstTs = ts;
+        if (!bucket.lastTs || ts > bucket.lastTs) bucket.lastTs = ts;
+      }
+    }
 
     if (r.type === 'assistant') {
       const turnModel = r.message?.model || summary.model;
@@ -385,6 +409,13 @@ function parseChunkInto(text, summary, pstate) {
           } else if (b.name === 'Bash') {
             const cmd = firstShellToken(input.command);
             if (cmd) summary.bashCommands[cmd] = (summary.bashCommands[cmd] || 0) + 1;
+            const shipKind = classifyShip(input.command);
+            if (shipKind) {
+              summary.ships = (summary.ships || 0) + 1;
+              summary.shipKinds[shipKind] = (summary.shipKinds[shipKind] || 0) + 1;
+              for (const bucket of allBuckets) bucket.ships = (bucket.ships || 0) + 1;
+              if (dayBucket) (dayBucket.shipKinds ||= {})[shipKind] = (dayBucket.shipKinds[shipKind] || 0) + 1;
+            }
           } else if (b.name === 'WebFetch' || b.name === 'WebSearch') {
             const host = b.name === 'WebFetch' ? domainOf(input.url) : '';
             if (host) summary.webDomains[host] = (summary.webDomains[host] || 0) + 1;
@@ -691,7 +722,10 @@ function readCache() {
 function writeCache(cache) {
   ensureDataDir();
   cache._v = CACHE_VERSION;
-  const tmp = SCAN_CACHE_PATH + '.tmp';
+  // Pid-suffixed like state.js: the daemon's background rescan and a user-run
+  // `claude-rpc scan` can overlap, and a shared tmp name lets one writer's
+  // rename land a half-written file (or ENOENT the other's rename).
+  const tmp = `${SCAN_CACHE_PATH}.${process.pid}.tmp`;
   writeFileSync(tmp, JSON.stringify(cache));
   renameSync(tmp, SCAN_CACHE_PATH);
 }
@@ -720,7 +754,7 @@ function readNotificationsByDay() {
 
 function writeAggregate(agg) {
   ensureDataDir();
-  const tmp = AGGREGATE_PATH + '.tmp';
+  const tmp = `${AGGREGATE_PATH}.${process.pid}.tmp`;
   writeFileSync(tmp, JSON.stringify(agg, null, 2));
   renameSync(tmp, AGGREGATE_PATH);
 }
@@ -767,6 +801,8 @@ export function aggregateFrom(cache) {
     linesAdded: 0,
     linesRemoved: 0,
     linesNet: 0,
+    ships: 0,
+    shipKinds: {},
     bashCommands: {},
     webDomains: {},
     subagents: {},
@@ -800,6 +836,10 @@ export function aggregateFrom(cache) {
     // — they represent real work done by Claude.
     agg.linesAdded += summary.linesAdded || 0;
     agg.linesRemoved += summary.linesRemoved || 0;
+    agg.ships += summary.ships || 0;
+    for (const [k, n] of Object.entries(summary.shipKinds || {})) {
+      agg.shipKinds[k] = (agg.shipKinds[k] || 0) + n;
+    }
     agg.estimatedCost += summary.cost || 0;
     for (const [m, v] of Object.entries(summary.costByModel || {})) {
       agg.costByModel[m] = (agg.costByModel[m] || 0) + v;
@@ -848,6 +888,10 @@ export function aggregateFrom(cache) {
           target.linesAdded += src.linesAdded || 0;
           target.linesRemoved += src.linesRemoved || 0;
           target.cost += src.cost || 0;
+          target.ships += src.ships || 0;
+          for (const [kind, n] of Object.entries(src.shipKinds || {})) {
+            (target.shipKinds ||= {})[kind] = (target.shipKinds[kind] || 0) + n;
+          }
         }
       };
       mergeSubBuckets(summary.byDay, agg.byDay);
@@ -882,7 +926,17 @@ export function aggregateFrom(cache) {
       if (summary.lastTs) agg.lastTs = agg.lastTs ? Math.max(agg.lastTs, summary.lastTs) : summary.lastTs;
       // Full per-day/week/hour merge for top-level sessions.
       for (const [k, day] of Object.entries(summary.byDay || {})) {
-        mergeDay(agg.byDay[k] ||= blankDay(), day);
+        const target = agg.byDay[k] ||= blankDay();
+        mergeDay(target, day);
+        // Per-day project attribution — only possible here, where the whole
+        // file's project is known. Presence in the map means "touched that
+        // day", even if activeMs rounded to 0.
+        if (summary.project) {
+          const pm = (target.projects ||= {});
+          const p = pm[summary.project] ||= { activeMs: 0, tokens: 0 };
+          p.activeMs += day.activeMs || 0;
+          p.tokens += (day.inputTokens || 0) + (day.outputTokens || 0) + (day.cacheReadTokens || 0) + (day.cacheWriteTokens || 0);
+        }
       }
       for (const [k, w] of Object.entries(summary.byWeek || {})) {
         mergeDay(agg.byWeek[k] ||= blankDay(), w);
@@ -1064,6 +1118,18 @@ export function scan({ projectsDir, projectsDirs, onProgress, force = false, ext
     dirs.push(CLAUDE_PROJECTS);
     dirs.push(...discoverAltProjectDirs());
   }
+  // Dedupe by REAL path, not path string: a symlinked alt location (e.g.
+  // ~/.config/claude → ~/.claude) otherwise walks the same transcripts twice
+  // under two absolute paths and exactly doubles every lifetime stat.
+  {
+    const seen = new Set();
+    for (let i = 0; i < dirs.length; i++) {
+      let key = dirs[i];
+      try { key = realpathSync(key); } catch { /* missing dir — keep literal */ }
+      if (seen.has(key)) { dirs.splice(i, 1); i--; continue; }
+      seen.add(key);
+    }
+  }
   for (const d of extraDirs) if (!dirs.includes(d)) dirs.push(d);
 
   const cache = readCache();

package/src/session-card.js

@@ -4,6 +4,7 @@
 // `claude-rpc session-card --out s.svg`.
 
 import { VERSION } from './version.js';
+import { localDateStamp } from './fmt.js';
 
 const W = 520;
 const H = 230;
@@ -47,7 +48,7 @@ export function renderSessionCard(vars = {}, { generatedAt = new Date() } = {})
   <rect x="0.75" y="0.75" width="${W - 7}" height="${H - 9}" fill="url(#dg)"/>
 
   <text x="40" y="50" font-family="Space Grotesk, Inter, system-ui, sans-serif" font-size="28" font-weight="800" letter-spacing="-1" fill="${PALETTE.ink}">${escapeXml(v.project || 'this session')}</text>
-  <text x="40" y="72" font-family="JetBrains Mono, ui-monospace, monospace" font-size="12" fill="${PALETTE.inkMute}">${escapeXml(`${v.modelPretty || 'Claude'} · ${v.duration || '0s'} · ${generatedAt.toISOString().slice(0, 10)}`)}</text>
+  <text x="40" y="72" font-family="JetBrains Mono, ui-monospace, monospace" font-size="12" fill="${PALETTE.inkMute}">${escapeXml(`${v.modelPretty || 'Claude'} · ${v.duration || '0s'} · ${localDateStamp(generatedAt)}`)}</text>
   ${v.modelPretty ? tape(W - 150, 28, String(v.modelPretty)) : ''}
 
   <line x1="40" y1="92" x2="${W - 40}" y2="92" stroke="${PALETTE.ink}" stroke-width="1" opacity="0.18"/>

package/src/ships.js

@@ -0,0 +1,91 @@
+// "Ship" classification — deciding whether a shell command published work to
+// the world (commit, push, PR, issue, release). Shared by the hook (live
+// celebration frame) and the scanner (per-day ship counts in aggregate.json),
+// so both surfaces agree on what counts as shipping.
+
+// Precedence when a command ships more than one way (`git commit && git push`
+// → push). Highest first.
+const SHIP_PRECEDENCE = ['push', 'commit', 'pr', 'issue', 'tag'];
+
+// Tokenize one command segment the way a shell roughly would for our purposes:
+// strip leading env assignments (FOO=bar) and sudo/time wrappers, drop the path
+// from the leading binary (/usr/bin/git → git), lowercase it.
+function tokenizeSegment(seg) {
+  const stripped = seg.replace(/^\s*(?:[A-Za-z_][A-Za-z0-9_]*=\S+\s+)+/, '').trim();
+  let toks = stripped.split(/\s+/).filter(Boolean);
+  while (toks.length && (toks[0] === 'sudo' || toks[0] === 'time')) toks = toks.slice(1);
+  if (toks.length) {
+    const slash = toks[0].lastIndexOf('/');
+    if (slash !== -1) toks[0] = toks[0].slice(slash + 1);
+    toks[0] = toks[0].toLowerCase();
+  }
+  return toks;
+}
+
+// First real git subcommand, skipping global flags and their values
+// (`git -C /repo -c k=v push` → push).
+function gitSubcommand(args) {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '-C' || a === '-c') { i++; continue; } // flag that takes a value
+    if (a.startsWith('-')) continue;
+    return a.toLowerCase();
+  }
+  return null;
+}
+
+// First two gh positionals (noun, verb), skipping global flags so the canonical
+// targeted form `gh -R owner/repo pr create` still classifies. -R/--repo take a
+// value; other globals here don't precede a create, so skipping the rest is safe.
+function ghSubcommand(args) {
+  const pos = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '-R' || a === '--repo') { i++; continue; } // flag that takes a value
+    if (a.startsWith('-')) continue;
+    pos.push(a.toLowerCase());
+    if (pos.length === 2) break;
+  }
+  return { noun: pos[0], verb: pos[1] };
+}
+
+function shipKindForSegment(seg) {
+  const toks = tokenizeSegment(seg);
+  if (!toks.length) return null;
+  if (toks[0] === 'git') {
+    const sub = gitSubcommand(toks.slice(1));
+    if (sub === 'push') return 'push';
+    if (sub === 'commit') return 'commit';
+  } else if (toks[0] === 'gh') {
+    const { noun, verb } = ghSubcommand(toks.slice(1));
+    if (noun === 'pr' && verb === 'create') return 'pr';
+    if (noun === 'issue' && verb === 'create') return 'issue';
+    if (noun === 'release' && verb === 'create') return 'tag';
+  }
+  return null;
+}
+
+// Return the "shipped" kind for a shell command, or null. Exported for tests.
+// Splits on shell separators and only classifies a segment whose *actual*
+// leading command is git/gh — so a quoted mention ("git push later" inside an
+// echo or a commit message) no longer false-fires. Tolerates env prefixes,
+// sudo/time, chained commands, and git global flags.
+//
+// Quoted spans are blanked BEFORE splitting: separators inside quotes
+// (`echo "run git push && rejoice"`) used to create a fake segment whose
+// leading command was git. The real command's own quoted args (`git commit
+// -m "msg"`) classify the same with or without the message text, so blanking
+// is lossless for detection. An unbalanced quote leaves the string untouched.
+export function classifyShip(cmd) {
+  const blanked = String(cmd || '')
+    .replace(/'[^']*'/g, ' ')
+    .replace(/"(?:\\.|[^"\\])*"/g, ' ');
+  const segments = blanked.split(/[;&|\n]+/);
+  const found = new Set();
+  for (const seg of segments) {
+    const k = shipKindForSegment(seg);
+    if (k) found.add(k);
+  }
+  for (const kind of SHIP_PRECEDENCE) if (found.has(kind)) return kind;
+  return null;
+}

package/src/version.js

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