claude-doom-statusbar 0.6.0 → 0.7.0

package/bin/cli.js

@@ -29,8 +29,11 @@ const STATUSLINE_CMD = `node "${STATUSLINE}"`;
 const HOOK_CMD = `node "${HOOK}"`;
 
 // Lifecycle events the mugshot hook understands (face reactions, geiger, subagents,
-// tasks, permission mode). PreToolUse has no matcher -> fires for every tool.
+// tasks, permission mode, git snapshots). PreToolUse has no matcher -> fires for every tool.
+// SessionStart resets the journal and primes git so the HUD is populated from the first
+// render. All entries are installed async (see install()) so they never block a tool.
 const HOOK_EVENTS = [
+  "SessionStart",
   "PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionDenied",
   "Stop", "SubagentStart", "SubagentStop", "TaskCreated", "TaskCompleted",
 ];
@@ -91,8 +94,9 @@ function install(cfg, preset) {
   for (const ev of HOOK_EVENTS) {
     const lst = (hooks[ev] ??= []);
     if (!lst.some(ours)) {
-      // idempotent: don't double-add
-      lst.push({ hooks: [{ type: "command", command: HOOK_CMD }] });
+      // idempotent: don't double-add. async:true keeps the hook off the blocking path —
+      // it only appends one journal line and returns; statusline folds it at render time.
+      lst.push({ hooks: [{ type: "command", command: HOOK_CMD, async: true }] });
     }
   }
   return notes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-doom-statusbar",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "DOOM-inspired status bar for the Claude Code CLI — a mugshot that tracks session health, plus usage, model, project, system, and a live subagent list.",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
   "scripts": {
     "statusline": "node src/statusline.js",
     "hook": "node src/hook.js",
-    "test": "node test/installer.test.mjs && node test/smoke.test.mjs && node test/hook-tasks.test.mjs && node test/statusline-tasks.test.mjs && node test/render-scroll.test.mjs && node test/statusline-savings.test.mjs && node test/e2e-tasks.test.mjs && node test/marquee.test.mjs && node test/layout.test.mjs && node test/resolve-preset.test.mjs",
+    "test": "node test/installer.test.mjs && node test/smoke.test.mjs && node test/hook-tasks.test.mjs && node test/statusline-tasks.test.mjs && node test/render-scroll.test.mjs && node test/statusline-savings.test.mjs && node test/e2e-tasks.test.mjs && node test/marquee.test.mjs && node test/layout.test.mjs && node test/resolve-preset.test.mjs && node test/preset-bands.test.mjs && node test/journal.test.mjs && node test/git-event.test.mjs",
     "preversion": "npm test",
     "postversion": "git push --follow-tags",
     "prepublishOnly": "npm test"

package/src/fold.js

@@ -0,0 +1,137 @@
+// Shared, pure reducer for the DOOM HUD state. No I/O, no spawns.
+//
+// Two writers used to fight over one state file (hook did read-modify-write per event).
+// Now hooks only APPEND raw events to a per-session journal, and statusline FOLDS that
+// journal into a checkpoint at render time. This module is the fold — identical state
+// shape as before (spans, squad, pending, tasks, tasks_ts, expr, ts, errors, mode, git),
+// so every downstream consumer (activityValues, the tests) is unchanged.
+
+import os from "node:os";
+import path from "node:path";
+
+export const GEIGER_WINDOW = 30.0; // seconds of tool-run history kept for the sparkline
+export const MAX_RUN = 300.0; // drop an unclosed span after this (assume the Post was lost)
+export const TASK_LINGER = 10.0; // seconds the TASKS box lingers after all tasks settle
+
+export const READ_TOOLS = new Set(["Read", "Grep", "Glob",
+  "ctx_read", "ctx_multi_read", "ctx_search", "ctx_semantic_search", "ctx_tree", "ctx_overview"]);
+export const WRITE_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit", "Bash", "ctx_shell", "ctx_edit"]);
+
+// Filesystem-safe session key, shared by hook + statusline so they agree on file names.
+export const sidKey = (id) => String(id || "default").replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 48);
+
+// Checkpoint (statusline-owned folded state) + journal (hook-appended events) live next to
+// each other so both processes derive the same pair from the session id. MUGSHOT_STATE
+// overrides the checkpoint path (tests, custom setups); the journal hangs off it.
+export function statePaths(sessionId) {
+  const base = process.env.MUGSHOT_STATE || path.join(os.tmpdir(), `mugshot_${sidKey(sessionId)}.json`);
+  return { checkpoint: base, journal: base + ".jsonl" };
+}
+
+export function base(tool) {
+  return tool.startsWith("mcp__") ? tool.split("__").pop() : tool;
+}
+
+// Task event subject: the exact key isn't documented, so try the likely ones.
+export function taskTitle(ev) {
+  return ev.task_title || ev.task_subject || ev.subject || ev.title ||
+    (ev.tool_input && ev.tool_input.subject) || "task";
+}
+
+export function expression(name, tool) {
+  const b = base(tool);
+  if (["PostToolUseFailure", "StopFailure", "PermissionDenied"].includes(name)) return "ouch";
+  if (["Stop", "TaskCompleted"].includes(name)) return "evl";
+  if (name === "PostToolUse") {
+    if (READ_TOOLS.has(b)) return Math.floor((Date.now() / 1000) * 2) % 2 === 0 ? "tl" : "tr";
+    if (WRITE_TOOLS.has(b)) return "kill";
+  }
+  return null;
+}
+
+export function foldActivity(st, name, ev, now) {
+  st.spans ??= [];
+  st.squad ??= {};
+  st.pending ??= [];
+  st.tasks ??= {};   // keyed map: id -> { title, status, ts }
+  st.errors ??= 0;
+
+  const tool = base(ev.tool_name || "");
+  if (name === "PreToolUse") {
+    st.spans.push([now, null]); // open a run interval
+    if (tool === "Agent") {
+      const ti = ev.tool_input || {};
+      st.pending.push({ type: ti.subagent_type || "", desc: ti.description || "", ts: now });
+      st.pending = st.pending.filter((p) => now - p.ts < 60).slice(-16);
+    }
+  } else if (["PostToolUse", "PostToolUseFailure", "PermissionDenied"].includes(name)) {
+    for (let i = st.spans.length - 1; i >= 0; i--) { // close the most recent open one
+      if (st.spans[i][1] === null) { st.spans[i][1] = now; break; }
+    }
+  }
+
+  if (["PostToolUseFailure", "StopFailure", "PermissionDenied"].includes(name)) {
+    st.errors += 1;
+  } else if (name === "SubagentStart") {
+    const aid = String(ev.agent_id || now);
+    const atype = ev.agent_type || "agent";
+    let desc = "";
+    for (let i = 0; i < st.pending.length; i++) { // FIFO match the launch by agent type
+      if (st.pending[i].type === atype) { desc = st.pending[i].desc; st.pending.splice(i, 1); break; }
+    }
+    st.squad[aid] = { type: atype, start: now, desc };
+  } else if (name === "SubagentStop") {
+    delete st.squad[String(ev.agent_id || "")];
+  } else if (name === "TaskCreated") {
+    const id = String(ev.task_id ?? now);
+    st.tasks[id] = { title: taskTitle(ev), status: "pending", ts: now };
+    st.tasks_ts = now;
+  } else if (name === "TaskCompleted") {
+    const id = String(ev.task_id ?? "");
+    if (st.tasks[id]) st.tasks[id].status = "completed";
+    else st.tasks[id] = { title: taskTitle(ev), status: "completed", ts: now };
+    st.tasks_ts = now;
+  } else if (name === "PostToolUse" && (ev.tool_name === "TaskUpdate") && ev.tool_input) {
+    const id = String(ev.tool_input.taskId ?? "");
+    const s = ev.tool_input.status;
+    if (id && st.tasks[id] && ["pending", "in_progress", "completed", "deleted"].includes(s)) {
+      st.tasks[id].status = s;
+      st.tasks_ts = now;
+    }
+  }
+
+  const win = now - GEIGER_WINDOW; // prune: closed spans out of window, orphaned open spans
+  st.spans = st.spans.filter((s) => (s[1] === null ? s[0] >= now - MAX_RUN : s[1] >= win));
+  st.squad = Object.fromEntries(Object.entries(st.squad).filter(([, v]) => now - v.start < MAX_RUN));
+
+  const taskVals = Object.values(st.tasks || {});
+  const anyOpen = taskVals.some((t) => t.status === "pending" || t.status === "in_progress");
+  if (taskVals.length && !anyOpen && now - (st.tasks_ts || 0) > TASK_LINGER) st.tasks = {};
+}
+
+// One full event fold: activity + face expression + permission mode + git snapshot.
+// This is exactly what hook.js's main() used to do per event — now applied at render time
+// over the journal. A `git` event carries a precomputed snapshot in ev.git.
+export function foldEvent(st, name, ev, now) {
+  foldActivity(st, name, ev, now);
+  const expr = expression(name, ev.tool_name || "");
+  if (expr) { st.expr = expr; st.ts = now; }
+  if (ev.permission_mode) st.mode = ev.permission_mode;
+  if (name === "git" && ev.git) st.git = ev.git; // { br, lr, st, cwd } or { cwd } when no repo
+}
+
+// Fold a batch of journal lines (each { name, ev, ts }) into st. Sort by ts first: async
+// hooks give no append-order guarantee, so SubagentStop can land before its Start. Sorting
+// the batch keeps open/close and create/consume in causal order (within the batch).
+export function foldBatch(st, lines) {
+  const evs = [];
+  for (const ln of lines) {
+    if (!ln) continue;
+    let o; try { o = JSON.parse(ln); } catch { continue; } // torn/partial line -> skip
+    if (!o || typeof o.ts !== "number" || typeof o.name !== "string") continue;
+    evs.push(o);
+  }
+  evs.sort((a, b) => a.ts - b.ts);
+  for (const o of evs) foldEvent(st, o.name, o.ev || {}, o.ts);
+  return st;
+}

package/src/hook.js

@@ -1,112 +1,87 @@
 #!/usr/bin/env node
-// Claude Code hook: an event-bus for the DOOM HUD. Port of hooks/mugshot_hook.py.
-// Each invocation reads the shared state file, folds in the lifecycle event, and
-// writes it back atomically. The status line reads that state.
+// Claude Code hook: an APPEND-ONLY event recorder for the DOOM HUD.
 //
-// State carries: face reaction {expr, ts}; activity spans[] [start,end] (geiger),
-// squad{} (running subagents), pending[] (Agent launch labels), tasks{} (id ->
-// {title,status,ts}), tasks_ts (last tasks mutation), errors, mode (permission mode). Always exits 0.
+// Old design did read-modify-write on a shared state file per event; under async hooks that
+// races (lost subagents/tasks). Now each invocation just APPENDS one slim line to a
+// per-session journal — append is atomic, so concurrent async hooks never clobber each
+// other. statusline.js folds the journal into a checkpoint at render time (see fold.js).
 //
-// State file: $MUGSHOT_STATE, else <temp>/mugshot_<session_id>.json.
+// Because the heavy work (folding, git) is off the blocking path, install these hooks with
+// "async": true (see bin/cli.js). This hook never reads the journal and always exits 0.
+//
+// Extra job: git lives here now, not on the render hot path. On write-affecting events (and
+// once per turn on Stop, and at SessionStart) we snapshot git into a `git` journal line,
+// throttled by DOOMBAR_GIT_TTL. statusline no longer spawns git at all -> the Windows MSYS
+// "bash flood" is gone by construction (git runs async, event-driven, rarely).
+//
+// Journal: <checkpoint>.jsonl where checkpoint is $MUGSHOT_STATE or <temp>/mugshot_<sid>.json.
 
-import { readFileSync, writeFileSync, renameSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
+import { appendFileSync, writeFileSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-
-const GEIGER_WINDOW = 30.0; // seconds of tool-run history kept for the sparkline
-const MAX_RUN = 300.0; // drop an unclosed span after this (assume the Post was lost)
-const TASK_LINGER = 10.0; // seconds the TASKS box lingers after all tasks settle
-
-const READ_TOOLS = new Set(["Read", "Grep", "Glob",
-  "ctx_read", "ctx_multi_read", "ctx_search", "ctx_semantic_search", "ctx_tree", "ctx_overview"]);
-const WRITE_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit", "Bash", "ctx_shell", "ctx_edit"]);
-
-function statePath(ev) {
-  if (process.env.MUGSHOT_STATE) return process.env.MUGSHOT_STATE;
-  const sid = String(ev.session_id || "default").replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 48);
-  return path.join(os.tmpdir(), `mugshot_${sid}.json`);
+import path from "node:path";
+import os from "node:os";
+import { base, statePaths, sidKey, WRITE_TOOLS } from "./fold.js";
+
+// Re-export the reducer so existing tests importing from hook.js keep working.
+export { foldActivity, expression } from "./fold.js";
+
+const GIT_TTL = Number.isFinite(Number(process.env.DOOMBAR_GIT_TTL))
+  ? Number(process.env.DOOMBAR_GIT_TTL)
+  : 4000; // ms; DOOMBAR_GIT_TTL=0 disables throttling (0 is a valid TTL)
+
+// Project an event down to only the fields fold.js consumes. Keeps journal lines tiny and
+// bounded — a raw Write/Edit event carries the whole file body in tool_input, which would
+// bloat the journal and stress append atomicity. We never journal that.
+function slim(ev) {
+  const ti = ev.tool_input || {};
+  const tn = ev.tool_name;
+  let tool_input;
+  if (tn === "TaskUpdate") tool_input = { taskId: ti.taskId, status: ti.status };
+  else if (tn === "Agent") tool_input = { subagent_type: ti.subagent_type, description: ti.description };
+  else if (ti.subject) tool_input = { subject: ti.subject };
+  return {
+    tool_name: tn,
+    tool_input,
+    agent_id: ev.agent_id,
+    agent_type: ev.agent_type,
+    task_id: ev.task_id,
+    task_title: ev.task_title, task_subject: ev.task_subject, subject: ev.subject, title: ev.title,
+    permission_mode: ev.permission_mode,
+  };
 }
 
-function base(tool) {
-  return tool.startsWith("mcp__") ? tool.split("__").pop() : tool;
+function gitCmd(cwd, ...args) {
+  try {
+    const r = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf8", timeout: 1000 });
+    return r.status === 0 ? r.stdout.trim() : null;
+  } catch { return null; }
 }
 
-// Task event subject: the exact key isn't documented, so try the likely ones.
-function taskTitle(ev) {
-  return ev.task_title || ev.task_subject || ev.subject || ev.title ||
-    (ev.tool_input && ev.tool_input.subject) || "task";
+function gitSnapshot(cwd) {
+  return {
+    cwd,
+    br: gitCmd(cwd, "branch", "--show-current"),
+    lr: gitCmd(cwd, "rev-list", "--count", "--left-right", "@{u}...HEAD"),
+    st: gitCmd(cwd, "status", "--porcelain"),
+  };
 }
 
-export function expression(name, tool) {
-  const b = base(tool);
-  if (["PostToolUseFailure", "StopFailure", "PermissionDenied"].includes(name)) return "ouch";
-  if (["Stop", "TaskCompleted"].includes(name)) return "evl";
-  if (name === "PostToolUse") {
-    if (READ_TOOLS.has(b)) return Math.floor((Date.now() / 1000) * 2) % 2 === 0 ? "tl" : "tr";
-    if (WRITE_TOOLS.has(b)) return "kill";
-  }
-  return null;
+// Best-effort per-session throttle (not a lock): a tiny marker holds the last git ts + cwd.
+// Worst case under a race is a redundant concurrent git spawn — harmless and rare.
+function gitMarkerPath(sid) {
+  return path.join(os.tmpdir(), `mugshot_git_${sidKey(sid)}.json`);
 }
 
-export function foldActivity(st, name, ev, now) {
-  st.spans ??= [];
-  st.squad ??= {};
-  st.pending ??= [];
-  st.tasks ??= {};   // keyed map: id -> { title, status, ts }
-  st.errors ??= 0;
-
-  const tool = base(ev.tool_name || "");
-  if (name === "PreToolUse") {
-    st.spans.push([now, null]); // open a run interval
-    if (tool === "Agent") {
-      const ti = ev.tool_input || {};
-      st.pending.push({ type: ti.subagent_type || "", desc: ti.description || "", ts: now });
-      st.pending = st.pending.filter((p) => now - p.ts < 60).slice(-16);
-    }
-  } else if (["PostToolUse", "PostToolUseFailure", "PermissionDenied"].includes(name)) {
-    for (let i = st.spans.length - 1; i >= 0; i--) { // close the most recent open one
-      if (st.spans[i][1] === null) { st.spans[i][1] = now; break; }
-    }
-  }
-
-  if (["PostToolUseFailure", "StopFailure", "PermissionDenied"].includes(name)) {
-    st.errors += 1;
-  } else if (name === "SubagentStart") {
-    const aid = String(ev.agent_id || now);
-    const atype = ev.agent_type || "agent";
-    let desc = "";
-    for (let i = 0; i < st.pending.length; i++) { // FIFO match the launch by agent type
-      if (st.pending[i].type === atype) { desc = st.pending[i].desc; st.pending.splice(i, 1); break; }
-    }
-    st.squad[aid] = { type: atype, start: now, desc };
-  } else if (name === "SubagentStop") {
-    delete st.squad[String(ev.agent_id || "")];
-  } else if (name === "TaskCreated") {
-    const id = String(ev.task_id ?? now);
-    st.tasks[id] = { title: taskTitle(ev), status: "pending", ts: now };
-    st.tasks_ts = now;
-  } else if (name === "TaskCompleted") {
-    const id = String(ev.task_id ?? "");
-    if (st.tasks[id]) st.tasks[id].status = "completed";
-    else st.tasks[id] = { title: taskTitle(ev), status: "completed", ts: now };
-    st.tasks_ts = now;
-  } else if (name === "PostToolUse" && (ev.tool_name === "TaskUpdate") && ev.tool_input) {
-    const id = String(ev.tool_input.taskId ?? "");
-    const s = ev.tool_input.status;
-    if (id && st.tasks[id] && ["pending", "in_progress", "completed", "deleted"].includes(s)) {
-      st.tasks[id].status = s;
-      st.tasks_ts = now;
-    }
-  }
-
-  const win = now - GEIGER_WINDOW; // prune: closed spans out of window, orphaned open spans
-  st.spans = st.spans.filter((s) => (s[1] === null ? s[0] >= now - MAX_RUN : s[1] >= win));
-  st.squad = Object.fromEntries(Object.entries(st.squad).filter(([, v]) => now - v.start < MAX_RUN));
-
-  const taskVals = Object.values(st.tasks || {});
-  const anyOpen = taskVals.some((t) => t.status === "pending" || t.status === "in_progress");
-  if (taskVals.length && !anyOpen && now - (st.tasks_ts || 0) > TASK_LINGER) st.tasks = {};
+function shouldSnapshotGit(name, ev, nowMs, sid) {
+  if (name !== "SessionStart" && name !== "Stop" &&
+      !(name === "PostToolUse" && WRITE_TOOLS.has(base(ev.tool_name || "")))) return false;
+  if (name === "SessionStart") return true; // always prime at start
+  let m = {};
+  try { m = JSON.parse(readFileSync(gitMarkerPath(sid), "utf8")); } catch { /* none */ }
+  const cwd = ev.cwd || (ev.workspace || {}).current_dir;
+  if (m.cwd !== cwd) return true; // cwd changed -> refresh regardless of TTL
+  return nowMs - (m.ts || 0) >= GIT_TTL;
 }
 
 function main() {
@@ -114,19 +89,31 @@ function main() {
     let ev = {};
     try { ev = JSON.parse(readFileSync(0, "utf8")); } catch { ev = {}; }
     const name = ev.hook_event_name || "";
-    const now = Date.now() / 1000;
-    const p = statePath(ev);
-
-    let st = {};
-    try { st = JSON.parse(readFileSync(p, "utf8")); } catch { st = {}; }
-
-    foldActivity(st, name, ev, now);
-    const expr = expression(name, ev.tool_name || "");
-    if (expr) { st.expr = expr; st.ts = now; }
-    if (ev.permission_mode) st.mode = ev.permission_mode;
+    const now = Date.now() / 1000; // seconds, matches fold's time base
+    const nowMs = Date.now();
+    const sid = ev.session_id || "default";
+    const { journal } = statePaths(sid);
+
+    // SessionStart resets the journal so each session starts clean (hygiene; sid is already
+    // per-session). At this instant no other hook is appending, so truncation is race-free.
+    if (name === "SessionStart") {
+      try { writeFileSync(journal, ""); } catch { /* ignore */ }
+    }
 
-    const tmp = `${p}.${process.pid}.tmp`;
-    try { writeFileSync(tmp, JSON.stringify(st)); renameSync(tmp, p); } catch { /* never block */ }
+    // Append the slim event line (atomic). foldEvent ignores names it doesn't know.
+    try {
+      appendFileSync(journal, JSON.stringify({ name, ev: slim(ev), ts: now }) + "\n", { flag: "a" });
+    } catch { /* never block a tool */ }
+
+    // Git snapshot on write-affecting events / per-turn Stop / session start, throttled.
+    const cwd = ev.cwd || (ev.workspace || {}).current_dir;
+    if (cwd && shouldSnapshotGit(name, ev, nowMs, sid)) {
+      const snap = gitSnapshot(cwd);
+      try {
+        appendFileSync(journal, JSON.stringify({ name: "git", ev: { git: snap }, ts: now }) + "\n", { flag: "a" });
+      } catch { /* ignore */ }
+      try { writeFileSync(gitMarkerPath(sid), JSON.stringify({ ts: nowMs, cwd })); } catch { /* ignore */ }
+    }
   } catch { /* swallow everything: a hook must never block a tool */ }
   process.exit(0);
 }

package/src/statusline.js

@@ -10,15 +10,15 @@
 // Config: $DOOMBAR_PRESET (default presets/standard.toml)  State: $MUGSHOT_STATE
 
 import {
-  readFileSync, writeFileSync, openSync, fstatSync, readSync, closeSync, statfsSync, statSync,
+  readFileSync, writeFileSync, renameSync, openSync, fstatSync, readSync, closeSync, statfsSync, statSync,
 } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { spawnSync } from "node:child_process";
 import { parse as parseToml } from "smol-toml";
 import { pyround, sgrFg } from "./ansi.js";
 import { buildBar, setValues, resolvePreset, OK, TEXT, CRIT } from "./render.js";
+import { foldBatch, statePaths } from "./fold.js";
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const REPO = path.dirname(HERE);
@@ -32,14 +32,9 @@ const GEIGER_BINS = 14;
 
 const has = (o, k) => Object.prototype.hasOwnProperty.call(o || {}, k);
 
-function git(cwd, ...args) {
-  try {
-    const r = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf8", timeout: 1000 });
-    return r.status === 0 ? r.stdout.trim() : null;
-  } catch {
-    return null;
-  }
-}
+// git is no longer spawned here. The async hook snapshots it into the journal (see hook.js
+// + fold.js); buildValues reads the folded snapshot from state.git. This keeps the render
+// hot path spawn-free — the Windows MSYS "bash flood" cannot happen by construction.
 
 // Clip a display label to at most `n` code points, ending with … when truncated,
 // so an oversized repo or branch name can't blow up the PROJECT box width.
@@ -111,7 +106,7 @@ function godFlash(data, advTs, now) {
 
 const f = sgrFg;
 
-export function buildValues(data) {
+export function buildValues(data, git) {
   const v = {};
   const cw = data.context_window || {};
   if ("used_percentage" in cw) v["context.hp"] = pyround(cw.used_percentage);
@@ -156,14 +151,13 @@ export function buildValues(data) {
   if (cwd) {
     const name = clip(path.basename(cwd.replace(/[/\\]+$/, "")) || cwd, 24);
     try { v["loc.cwd"] = _link(name, pathToFileURL(cwd).href); } catch { v["loc.cwd"] = name; }
-    const br = git(cwd, "branch", "--show-current");
+    // git fields come from the folded snapshot the async hook wrote, not a live spawn.
+    const { br = null, lr = null, st = null } = git || {};
     if (br) { const brLbl = clip(br, 24); v["git.branch"] = repoUrl ? _link(brLbl, `${repoUrl}/tree/${br}`) : brLbl; }
-    const lr = git(cwd, "rev-list", "--count", "--left-right", "@{u}...HEAD");
     if (lr && lr.includes("\t")) {
       const [behind, ahead] = lr.split("\t");
       v["git.behind"] = `↓${behind}`; v["git.ahead"] = `↑${ahead}`;
     }
-    const st = git(cwd, "status", "--porcelain");
     if (st !== null) v["git.status"] = String(st.split("\n").filter((l) => l.trim()).length);
     // Merge changed-file count + pull/push onto one line (icons baked in, like model.mode):
     // "✎ <files>  ⇅ ↓<behind> ↑<ahead>" — files first, then pull/push.
@@ -189,14 +183,54 @@ function _pick(bucket) {
   return x % 3;
 }
 
-function statePath(data) {
-  if (process.env.MUGSHOT_STATE) return process.env.MUGSHOT_STATE;
-  const sid = String(data.session_id || "default").replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 48);
-  return path.join(TMP, `mugshot_${sid}.json`);
-}
+// Fold the per-session journal into the checkpoint and return the folded state.
+//
+// Read cost is O(events since last render): we read only journal bytes past the stored
+// offset, so a multi-hour session never re-reads old events. Invariant: checkpoint.state
+// always equals fold(journal[0..offset]); state + offset are persisted together atomically,
+// so the reducer's push/increment ops never double-count across renders.
+export function loadState(data) {
+  const { checkpoint, journal } = statePaths(data.session_id);
+
+  let size = -1;
+  try { size = statSync(journal).size; } catch { /* no journal yet */ }
+
+  let raw = null;
+  try { raw = readFileSync(checkpoint, "utf8"); } catch { /* no checkpoint */ }
+  let st;
+  if (raw === null) {
+    st = { offset: 0 };                          // no checkpoint -> recompute from journal start
+  } else {
+    try { st = JSON.parse(raw); } catch { st = null; }
+    if (!st || typeof st !== "object") st = { offset: 0 }; // corrupt -> full recompute (journal has full history)
+    else if (typeof st.offset !== "number") st.offset = Math.max(0, size); // externally-supplied state is current
+  }
+
+  if (size < 0) return st;                        // no journal -> state stands as-is
+  if (st.offset > size) st = { offset: 0 };       // journal truncated/reset -> recompute from 0
+
+  if (size > st.offset) {
+    let chunk = "";
+    try {
+      const fd = openSync(journal, "r");
+      const buf = Buffer.alloc(size - st.offset);
+      readSync(fd, buf, 0, buf.length, st.offset);
+      closeSync(fd);
+      chunk = buf.toString("utf8");
+    } catch { chunk = ""; }
+    const lastNl = chunk.lastIndexOf("\n");       // consume complete lines only; keep any partial tail
+    if (lastNl >= 0) {
+      foldBatch(st, chunk.slice(0, lastNl).split("\n"));
+      st.offset += Buffer.byteLength(chunk.slice(0, lastNl + 1), "utf8");
+    }
+  }
 
-function readState(data) {
-  try { return JSON.parse(readFileSync(statePath(data), "utf8")); } catch { return {}; }
+  try { // persist state + offset together, atomically
+    const tmp = `${checkpoint}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(st));
+    renameSync(tmp, checkpoint);
+  } catch { /* ignore: next render retries */ }
+  return st;
 }
 
 function ramPercent() {
@@ -394,9 +428,9 @@ function main() {
   const cfg = parseToml(readFileSync(preset, "utf8"));
 
   const now = Date.now() / 1000;
-  const st = readState(data);
+  const st = loadState(data);
   const cwd = data.cwd || (data.workspace || {}).current_dir;
-  const values = { ...buildValues(data), ...activityValues(st, now), ...sysValues(cwd), ...statsValues(data, cwd) };
+  const values = { ...buildValues(data, st.git), ...activityValues(st, now), ...sysValues(cwd), ...statsValues(data, cwd) };
   const [advModel, advTs] = advisorInfo(data.transcript_path || "");
   if (advModel) values["advisor.model"] = advModel;
   const god_until = godFlash(data, advTs, now);