claude-rpc 1.0.3 → 1.1.0

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.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

@@ -858,6 +858,34 @@ 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) {
   const out = { metric: 'hours', range: '7d', out: '', gist: false };
   for (let i = 0; i < argv.length; i++) {
@@ -2005,6 +2033,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 +2190,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/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;
 

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/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

@@ -4,10 +4,12 @@ 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).
+const CACHE_VERSION = 5;
 
 // 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 +131,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 +154,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 +247,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
@@ -385,6 +398,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;
@@ -767,6 +787,8 @@ export function aggregateFrom(cache) {
     linesAdded: 0,
     linesRemoved: 0,
     linesNet: 0,
+    ships: 0,
+    shipKinds: {},
     bashCommands: {},
     webDomains: {},
     subagents: {},
@@ -800,6 +822,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 +874,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 +912,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);

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.0';
 
 function readPkgVersion() {
   try {