claude-doom-statusbar 0.5.0 → 0.7.0

package/README.md

@@ -38,7 +38,7 @@ npx claude-doom-statusbar install
 That writes the `statusLine`, the lifecycle hooks, and the preset into `~/.claude/settings.json` for you (merging into whatever's already there, with a one-level `.bak`). Restart Claude Code and the HUD is live.
 
 ```bash
-npx claude-doom-statusbar install --preset full   # full | default | minimal (default: full)
+npx claude-doom-statusbar install --preset full   # full | standard | minimal (default: full)
 npx claude-doom-statusbar install --project       # write ./.claude/settings.json instead of ~/.claude
 npx claude-doom-statusbar uninstall                # remove everything the installer added
 ```
@@ -65,14 +65,18 @@ $env:FORCE_HYPERLINK = "1"; claude
 
 ## Presets
 
-`DOOMBAR_PRESET` picks the layout (defaults to `presets/default.toml`):
+`DOOMBAR_PRESET` picks the layout (defaults to `presets/standard.toml`):
 
 - **`minimal`** — a couple of bars, blends into the terminal.
-- **`default`** — balanced HUD.
+- **`standard`** — balanced HUD.
 - **`full`** — every box, the look in the screenshot above.
 
 A preset is TOML: a `[bar]` style block, a `[mugshot]` block, and a list of `[[segment]]` boxes. Each box lists metrics with a render type — `bar`, `number`, `text`, `spark`, `ammo`, `list`, `scroll`, or a `group`. Copy one and rearrange the boxes, swap icons, or change which metrics show.
 
+### Responsive width
+
+As the terminal narrows, the HUD shrinks: bars contract and text columns shrink together, and whatever overflows scrolls (the marquee). When even the smallest layout no longer fits, the preset falls back to a smaller one via its `[bar].fallback` key — `full → standard → minimal`. Your chosen preset is the ceiling; widening the terminal recovers it. It's stateless — each refresh re-reads the terminal width (`COLUMNS`), so it follows live resizes.
+
 ## How it works
 
 - **`src/statusline.js`** is the statusLine command. Claude Code pipes session JSON on stdin; it maps that (plus git via shell, system metrics from Node built-ins, and the hook state file) to metric values, picks the mugshot sprite, and renders the preset.

package/bin/cli.js

@@ -3,7 +3,7 @@
 // Port of install.py.
 //
 //   claude-doom-statusbar install              # install into ~/.claude/settings.json
-//   claude-doom-statusbar install --preset full # pick a preset (full | default | minimal)
+//   claude-doom-statusbar install --preset full # pick a preset (full | standard | minimal)
 //   claude-doom-statusbar install --project     # install into ./.claude/settings.json instead
 //   claude-doom-statusbar uninstall             # remove everything this installer added
 //
@@ -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;
@@ -124,7 +128,7 @@ function parseArgs(argv) {
     else if (a.startsWith("--preset=")) out.preset = a.slice("--preset=".length);
     else die(`! unknown argument: ${a}`);
   }
-  if (out.cmd === "install" && !out.preset) die("! --preset needs a value (full | default | minimal)");
+  if (out.cmd === "install" && !out.preset) die("! --preset needs a value (full | standard | minimal)");
   return out;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-doom-statusbar",
-  "version": "0.5.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",
+    "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/presets/full.toml

@@ -4,6 +4,7 @@ border_style   = "vertical"
 border_color   = "term-bg"      # seamless cuts through the panel
 box_background = "#1c2036"
 headers        = true
+fallback       = "standard"     # degrade to this preset when the terminal is too narrow
 
 [mugshot]
 background = "#000000"
@@ -66,6 +67,7 @@ metric = [
 [[segment]]
 type  = "box"
 title = "AGENTS"
+max_width = 22                      # cap width so long agent labels marquee (scroll back and forth)
 metric = [
   { id = "act.subagents", render = "scroll", anchor = "top", icon = "👹" },
 ]
@@ -73,6 +75,7 @@ metric = [
 [[segment]]
 type  = "box"
 title = "TASKS"
+max_width = 22                      # cap width so long task titles marquee (scroll back and forth)
 metric = [
   { id = "act.tasklist", render = "scroll", anchor = "boundary" },
 ]

package/presets/minimal.toml

@@ -1,19 +1,56 @@
-# minimal — blends into the terminal, smallest footprint
+# minimal — MODEL, USAGE, mugshot, PROJECT, ACTIVITY
 [bar]
-border_style   = "none"
-box_background = "term-bg"
-headers        = false
+border_style   = "vertical"
+border_color   = "term-bg"      # seamless cuts through the panel
+box_background = "#1c2036"
+headers        = true
 
 [mugshot]
-background = "term-bg"
+background = "#000000"
 
 [[segment]]
-type = "box"
+type  = "box"
+title = "MODEL"
+metric = [
+  { id = "model.name",       render = "text", icon = "🤖", right = "model.effort" },
+  { id = "model.mode",       render = "text" },                 # 💭 thinking  🚀 fast
+  { id = "model.permission", render = "text" },                 # 📋 plan / ⏩ auto (hidden on default)
+  { id = "model.style",      render = "text", icon = "🎨" },
+  { id = "advisor.model",    render = "text", icon = "🧙" },
+]
+
+[[segment]]
+type  = "box"
+title = "USAGE"
 metric = [
   { id = "context.hp",   render = "bar",    icon = "🧠", color = "threshold" },
-  { id = "ratelimit.5h", render = "ammo",   icon = "🕔" },
+  { id = "ratelimit.5h", render = "bar",    icon = "🕔", color = "threshold", show_pct = false, suffix = "usage.reset5h" },
+  { id = "ratelimit.7d", render = "bar",    icon = "📅", color = "threshold", show_pct = false, suffix = "usage.reset7d" },
+  { id = "sys.ram",      render = "bar",    icon = "💾", color = "threshold" },
   { id = "cost.total",   render = "number", icon = "💰" },
 ]
 
 [[segment]]
 type = "mugshot"
+
+[[segment]]
+type  = "box"
+title = "PROJECT"
+metric = [
+  { id = "session.name", render = "text", icon = "🎮" },
+  { id = "loc.cwd",      render = "text", icon = "📁" },
+  { id = "git.branch",   render = "text", icon = "🌿" },
+  { id = "git.work",     render = "text" },                # ✎ files  ⇅ pull/push
+  { id = "loc.churn",    render = "text", icon = "📝" },
+  { id = "pr.state",     render = "text", icon = "⇧ " },
+]
+
+[[segment]]
+type  = "box"
+title = "ACTIVITY"
+metric = [
+  { id = "act.geiger", render = "spark",  icon = "📟", spark_style = "octant", spark_max = 1 },
+  { id = "act.agents", render = "number", icon = "👹" },
+  { id = "act.tasks",  render = "number", icon = "🎯" },
+  { id = "act.errors", render = "number", icon = "💢", color = "threshold" },
+]

package/presets/standard.toml

@@ -0,0 +1,73 @@
+# standard — full minus SAVE and SYS
+[bar]
+border_style   = "vertical"
+border_color   = "term-bg"      # seamless cuts through the panel
+box_background = "#1c2036"
+headers        = true
+fallback       = "minimal"      # degrade to this preset when the terminal is too narrow
+
+[mugshot]
+background = "#000000"
+
+[[segment]]
+type  = "box"
+title = "MODEL"
+metric = [
+  { id = "model.name",       render = "text", icon = "🤖", right = "model.effort" },
+  { id = "model.mode",       render = "text" },                 # 💭 thinking  🚀 fast
+  { id = "model.permission", render = "text" },                 # 📋 plan / ⏩ auto (hidden on default)
+  { id = "model.style",      render = "text", icon = "🎨" },
+  { id = "advisor.model",    render = "text", icon = "🧙" },
+]
+
+[[segment]]
+type  = "box"
+title = "USAGE"
+metric = [
+  { id = "context.hp",   render = "bar",    icon = "🧠", color = "threshold" },
+  { id = "ratelimit.5h", render = "bar",    icon = "🕔", color = "threshold", show_pct = false, suffix = "usage.reset5h" },
+  { id = "ratelimit.7d", render = "bar",    icon = "📅", color = "threshold", show_pct = false, suffix = "usage.reset7d" },
+  { id = "sys.ram",      render = "bar",    icon = "💾", color = "threshold" },
+  { id = "cost.total",   render = "number", icon = "💰" },
+]
+
+[[segment]]
+type  = "box"
+title = "PROJECT"
+metric = [
+  { id = "session.name", render = "text", icon = "🎮" },
+  { id = "loc.cwd",      render = "text", icon = "📁" },
+  { id = "git.branch",   render = "text", icon = "🌿" },
+  { id = "git.work",     render = "text" },                # ✎ files  ⇅ pull/push
+  { id = "loc.churn",    render = "text", icon = "📝" },
+  { id = "pr.state",     render = "text", icon = "⇧ " },
+]
+
+[[segment]]
+type = "mugshot"
+
+[[segment]]
+type  = "box"
+title = "ACTIVITY"
+metric = [
+  { id = "act.geiger", render = "spark",  icon = "📟", spark_style = "octant", spark_max = 1 },
+  { id = "act.agents", render = "number", icon = "👹" },
+  { id = "act.tasks",  render = "number", icon = "🎯" },
+  { id = "act.errors", render = "number", icon = "💢", color = "threshold" },
+]
+
+[[segment]]
+type  = "box"
+title = "AGENTS"
+max_width = 22                      # cap width so long agent labels marquee (scroll back and forth)
+metric = [
+  { id = "act.subagents", render = "scroll", anchor = "top", icon = "👹" },
+]
+
+[[segment]]
+type  = "box"
+title = "TASKS"
+max_width = 22                      # cap width so long task titles marquee (scroll back and forth)
+metric = [
+  { id = "act.tasklist", render = "scroll", anchor = "boundary" },
+]

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/render.js

@@ -203,7 +203,20 @@ function barMeta(entry) {
   return [lw, 0, entry.render || "text"];
 }
 
-export function metricFixedWidth(entry) {
+// Display width of a plain text run, capped at `textCap` columns — but only when
+// it is marquee-safe. Values carrying ANSI/OSC escapes (coloured text, hyperlinks)
+// can't be column-sliced without corrupting the escape, so they keep full width
+// (a hard floor): their box shrinks less, which is what trips the preset fallback.
+const TEXTCAP_MAX = 24; // upper bound — matches statusline's clip(…, 24)
+const TEXTCAP_MIN = 10; // lower bound — the readable floor before falling back
+const ESC_RE = /\x1b/;
+function capLen(s, textCap) {
+  const str = String(s);
+  const w = vlen(str);
+  return ESC_RE.test(str) ? w : Math.min(w, textCap);
+}
+
+export function metricFixedWidth(entry, textCap = TEXTCAP_MAX) {
   const icon = entry.icon || "";
   const lw = vlen(icon ? icon + " " : "");
   const r = entry.render || "text";
@@ -211,7 +224,7 @@ export function metricFixedWidth(entry) {
   const rextra = rid && rid in VALUES ? 1 + vlen(String(VALUES[rid])) : 0;
   if ("group" in entry) {
     const sep = entry.sep ?? " ";
-    return lw + vlen(entry.group.filter((i) => i in VALUES).map((i) => String(VALUES[i])).join(sep)) + rextra;
+    return lw + capLen(entry.group.filter((i) => i in VALUES).map((i) => String(VALUES[i])).join(sep), textCap) + rextra;
   }
   if (r === "spark") return lw + Math.floor(((VALUES[entry.id] || []).length + 1) / 2);
   if (r === "ammo") return lw + 5 + vlen(" " + (entry.id in VALUES ? VALUES[entry.id] : 0) + "%");
@@ -220,21 +233,27 @@ export function metricFixedWidth(entry) {
     if (items.length === 0) return lw;
     return Math.max(...items.map((it) =>
       Array.isArray(it) && it.length === 2
-        ? lw + vlen(String(it[0])) + 1 + vlen(String(it[1]))
-        : lw + vlen(String(it))));
+        ? lw + capLen(it[0], textCap) + 1 + vlen(String(it[1]))
+        : lw + capLen(it, textCap)));
   }
   if (r === "scroll") {
     const items = VALUES[entry.id] || [];
     if (items.length === 0) return lw;
     return Math.max(...items.map((it) => {
       if (Array.isArray(it) && it.length === 2)
-        return lw + vlen(String(it[0])) + 1 + vlen(String(it[1]));
+        return lw + capLen(it[0], textCap) + 1 + vlen(String(it[1]));
       // object {mark, text}
-      return lw + vlen(String(it.mark || "")) + 1 + vlen(String(it.text || ""));
+      return lw + vlen(String(it.mark || "")) + 1 + capLen(it.text || "", textCap);
     }));
   }
   if (r === "bar") return null;
-  return lw + vlen(String(entry.id in VALUES ? VALUES[entry.id] : "?")) + rextra;
+  return lw + capLen(entry.id in VALUES ? VALUES[entry.id] : "?", textCap) + rextra;
+}
+
+// The coupled text cap for a given bar-cell count: cells 14 -> cap 24, cells 4 ->
+// cap 10, linearly in between. One scale drives bars and text together (approach A).
+export function textCapFor(cells) {
+  return Math.round(TEXTCAP_MIN + (cells - 4) / (14 - 4) * (TEXTCAP_MAX - TEXTCAP_MIN));
 }
 
 export function scrollWindow(n, h, anchor, boundary) {
@@ -246,16 +265,63 @@ export function scrollWindow(n, h, anchor, boundary) {
   return { start, up: start, down: n - start - h };
 }
 
+// --- horizontal marquee (the "car radio" scroll) ----------------------------
+// Long text that won't fit its column budget glides left until its tail shows,
+// pauses, then glides back to the start and pauses again — ping-pong, driven by
+// the same per-refresh `tick` as the mugshot/geiger. Pure function of `tick`
+// (no Date in here) so renders stay deterministic and testable.
+const MARQUEE_STEP = 1;   // display columns advanced per tick
+const MARQUEE_DWELL = 3;  // ticks held at each end before reversing
+
+// Triangular offset wave 0..span..0 with a dwell at both extremes.
+function marqueeOffset(span, tick) {
+  if (span <= 0) return 0;
+  const sweep = Math.ceil(span / MARQUEE_STEP);
+  const cycle = 2 * (MARQUEE_DWELL + sweep);
+  let t = ((tick % cycle) + cycle) % cycle;
+  if (t < MARQUEE_DWELL) return 0;                            // hold at start
+  t -= MARQUEE_DWELL;
+  if (t < sweep) return Math.min(span, t * MARQUEE_STEP);     // glide forward 0->span
+  t -= sweep;
+  if (t < MARQUEE_DWELL) return span;                         // hold at end
+  t -= MARQUEE_DWELL;
+  return Math.max(0, span - t * MARQUEE_STEP);                // glide back span->0
+}
+
+// Take a `width`-wide display window starting `off` columns in, never splitting a
+// 2-col glyph; the result is always exactly `width` columns (padded with spaces).
+function sliceCols(text, off, width) {
+  let col = 0, taken = 0, out = "";
+  for (const ch of [...String(text)]) {
+    const cw = vlen(ch);
+    if (col < off) { col += cw; continue; }          // still left of the window
+    if (taken + cw > width) break;                   // glyph would overflow the window
+    out += ch; taken += cw; col += cw;
+  }
+  if (taken < width) out += " ".repeat(width - taken);
+  return out;
+}
+
+// Fit `text` into exactly `width` display columns. Fits -> left-aligned + padded.
+// Overflows -> ping-pong marquee window for the current `tick`.
+export function marquee(text, width, tick = 0) {
+  text = String(text);
+  if (width <= 0) return "";
+  const tw = vlen(text);
+  if (tw <= width) return text + " ".repeat(width - tw);
+  return sliceCols(text, marqueeOffset(tw - width, tick), width);
+}
+
 function available(entry) {
   if ("group" in entry) return entry.group.some((i) => i in VALUES);
   if (entry.render === "list") return true;
   return entry.id in VALUES;
 }
 
-function boxWidth(box, cells) {
+function boxWidth(box, cells, textCap = TEXTCAP_MAX) {
   const widths = [vlen(box.title || "")];
   for (const m of box.metric) {
-    let fw = metricFixedWidth(m);
+    let fw = metricFixedWidth(m, textCap);
     if (fw === null) {
       const [lw, sw] = barMeta(m);
       fw = lw + cells + sw;
@@ -280,17 +346,15 @@ function hpRow(thresholds = HP_THRESHOLDS) {
   return thresholds.filter((t) => headroom < t).length;
 }
 
-export function buildBar(cfg, target, spriteFor) {
+// Width-relevant layout context shared by buildBar (render) and planLayout (fit
+// test). Filters unavailable metrics, computes the row count, and loads the mugshot
+// art so its width counts toward the layout. spriteFor defaults to the idle face;
+// the exact sprite never changes the mugshot's column width.
+function layoutContext(cfg, spriteFor) {
   if (!spriteFor) spriteFor = (hp) => `STFST${hp}1`;
-
   const bar = cfg.bar || {};
   const style = bar.border_style ?? "vertical";
   const headers = (bar.headers ?? true) && style !== "frame";
-  const boxRgb = rgbOf(bar.box_background ?? "term-bg");
-  const bcol = bar.border_color ?? "term-fg";
-  const mugRgb = rgbOf((cfg.mugshot || {}).background ?? "#000000");
-
-  // availability: drop metrics whose value is absent; collapse empty boxes.
   const segs = [];
   for (const s of cfg.segment) {
     if (s.type === "mugshot") { segs.push(s); continue; }
@@ -301,35 +365,79 @@ export function buildBar(cfg, target, spriteFor) {
   const rowcount = (b) => b.metric.reduce((n, m) =>
     n + (m.render === "list" ? (VALUES[m.id] || []).length : (m.render === "scroll" ? 0 : 1)), 0);
   const dataRows = boxes.length ? Math.max(...boxes.map(rowcount)) : 0;
-  const headersExtra = headers ? 1 : 0;
-  const totalRows = Math.max(dataRows + headersExtra, 4); // 4 = mugshot floor
-
+  const totalRows = Math.max(dataRows + (headers ? 1 : 0), 4); // 4 = mugshot floor
   const hp = hpRow();
   const face = loadFace(spriteFor(hp), totalRows);
   const faceW = Math.max(...face.map((r) => r.length));
+  return { bar, style, headers, segs, totalRows, hp, face, faceW };
+}
 
-  const colWidths = (cells) => {
-    const ws = [];
-    let mug = null;
-    segs.forEach((s, i) => {
-      if (s.type === "mugshot") { ws.push(faceW + 2); mug = i; }
-      else ws.push(boxWidth(s, cells) + 2);
-    });
-    return [ws, mug];
-  };
-
-  const balancedWidth = (cells) => {
-    const [ws, mug] = colWidths(cells);
-    if (mug === null) return ws.reduce((a, b) => a + b, 0) + (ws.length - 1);
-    const left = ws.slice(0, mug).reduce((a, b) => a + b, 0) + mug;
-    const right = ws.slice(mug + 1).reduce((a, b) => a + b, 0) + (ws.length - 1 - mug);
-    return 2 * Math.max(left, right) + ws[mug];
-  };
-
-  let cells = 4;
+function colWidthsOf(segs, faceW, cells, textCap) {
+  const ws = [];
+  let mug = null;
+  segs.forEach((s, i) => {
+    if (s.type === "mugshot") { ws.push(faceW + 2); mug = i; }
+    else ws.push(boxWidth(s, cells, textCap) + 2);
+  });
+  return [ws, mug];
+}
+
+function balancedWidthOf(segs, faceW, cells, textCap) {
+  const [ws, mug] = colWidthsOf(segs, faceW, cells, textCap);
+  if (mug === null) return ws.reduce((a, b) => a + b, 0) + (ws.length - 1);
+  const left = ws.slice(0, mug).reduce((a, b) => a + b, 0) + mug;
+  const right = ws.slice(mug + 1).reduce((a, b) => a + b, 0) + (ws.length - 1 - mug);
+  return 2 * Math.max(left, right) + ws[mug];
+}
+
+// Largest lockstep scale (bars 14->4, text 24->10) whose balanced layout fits
+// `target`. Returns the minimum scale with fits=false when nothing fits — the
+// caller (statusline) reads `fits` to decide whether to fall back to a smaller
+// preset. Pure: no filesystem, deterministic for a given cfg + VALUES.
+export function planLayout(cfg, target, spriteFor) {
+  const { segs, faceW } = layoutContext(cfg, spriteFor);
   for (let c = 14; c >= 4; c--) {
-    if (balancedWidth(c) <= target) { cells = c; break; }
+    const textCap = textCapFor(c);
+    const width = balancedWidthOf(segs, faceW, c, textCap);
+    if (width <= target) return { cells: c, textCap, width, fits: true };
   }
+  const textCap = textCapFor(4);
+  return { cells: 4, textCap, width: balancedWidthOf(segs, faceW, 4, textCap), fits: false };
+}
+
+// Walk the per-preset fallback chain from `chosenCfg` (the ceiling) downward and
+// return the first preset whose layout fits `target`; if none fit, return the last
+// (smallest) one reached. `loadByName(name) -> cfg | null` loads a sibling preset;
+// returning null (missing/unreadable) ends the chain. Stateless: ceiling + recovery
+// fall out of re-deriving from `target` each call. Guards against fallback cycles.
+export function resolvePreset(chosenCfg, target, loadByName, spriteFor) {
+  let cfg = chosenCfg, last = chosenCfg;
+  const seen = new Set();
+  while (cfg) {
+    last = cfg;
+    // Fit-test with the SAME sprite buildBar will render, so the mugshot column
+    // width matches: plan.fits then implies the rendered layout actually fits.
+    if (planLayout(cfg, target, spriteFor).fits) return cfg;
+    const next = cfg.bar && cfg.bar.fallback;
+    if (!next || seen.has(next)) break;   // terminus or cycle
+    seen.add(next);
+    const loaded = loadByName(next);
+    if (!loaded) break;                    // missing/unreadable fallback
+    cfg = loaded;
+  }
+  return last;                             // nothing fit -> smallest reached
+}
+
+export function buildBar(cfg, target, spriteFor, tick = 0) {
+  if (!spriteFor) spriteFor = (hp) => `STFST${hp}1`;
+
+  const { style, headers, segs, totalRows, hp, face, faceW } = layoutContext(cfg, spriteFor);
+  const bar = cfg.bar || {};
+  const boxRgb = rgbOf(bar.box_background ?? "term-bg");
+  const bcol = bar.border_color ?? "term-fg";
+  const mugRgb = rgbOf((cfg.mugshot || {}).background ?? "#000000");
+
+  const { cells, textCap } = planLayout(cfg, target, spriteFor);
 
   const columns = [];
   let mugIdx = null;
@@ -339,7 +447,7 @@ export function buildBar(cfg, target, spriteFor) {
       columns.push(Array.from({ length: totalRows }, (_, r) => faceCell(face[r], faceW, mugRgb)));
       continue;
     }
-    const w = boxWidth(s, cells);
+    const w = boxWidth(s, cells, textCap);
     const col = [];
     if (headers) {
       const t = s.title || "";
@@ -354,12 +462,12 @@ export function buildBar(cfg, target, spriteFor) {
         for (const item of VALUES[m.id] || []) {
           let body;
           if (Array.isArray(item) && item.length === 2) {
-            const left = lbl + f(TEXT) + String(item[0]);
             const right = f(TEXT) + String(item[1]);
-            body = left + " ".repeat(Math.max(0, w - vlen(left) - vlen(right))) + right;
+            const budget = Math.max(0, w - vlen(lbl) - vlen(String(item[1])) - 1); // 1 = min gap
+            const left = lbl + f(TEXT) + marquee(String(item[0]), budget, tick);
+            body = left + " ".repeat(Math.max(0, w - vlen(left) - vlen(String(item[1])))) + right;
           } else {
-            body = lbl + f(TEXT) + String(item);
-            body += " ".repeat(Math.max(0, w - vlen(body)));
+            body = lbl + f(TEXT) + marquee(String(item), Math.max(0, w - vlen(lbl)), tick);
           }
           col.push(bgsgrBox(boxRgb) + " " + body + " " + RESET);
         }
@@ -384,20 +492,16 @@ export function buildBar(cfg, target, spriteFor) {
             const right = f(TEXT) + String(item[1]) + (marker ? f(TEXT) + tail : "");
             const rightW = vlen(String(item[1])) + tailW;
             const labelMax = Math.max(0, w - vlen(lbl) - rightW - 1); // 1 = min gap
-            let label = String(item[0]);
-            if (vlen(label) > labelMax) label = [...label].slice(0, Math.max(0, labelMax - 1)).join("") + "…";
-            const left = lbl + f(TEXT) + label;
+            const left = lbl + f(TEXT) + marquee(String(item[0]), labelMax, tick);
             const room = Math.max(0, w - vlen(left) - rightW);
             body = left + " ".repeat(room) + right;
           } else {                                         // {mark, markRgb, text} (tasks)
             const markCol = item.markRgb ? f(item.markRgb) : f(TEXT);
             const m = String(item.mark);
             const mPad = m + (vlen(m) < 2 ? " " : "");      // normalize mark to 2 cols so text aligns
-            let text = String(item.text);
             const head = markCol + mPad + " " + f(TEXT);
-            const max = w - vlen(mPad) - 1 - tailW;         // reserve gap + marker on the right
-            if (vlen(text) > max) text = [...text].slice(0, Math.max(0, max - 1)).join("") + "…";
-            body = head + text;
+            const max = Math.max(0, w - vlen(mPad) - 1 - tailW); // reserve gap + marker on the right
+            body = head + marquee(String(item.text), max, tick);
             body += " ".repeat(Math.max(0, w - tailW - vlen(body)));
             if (tail) body += f(TEXT) + tail;
           }
@@ -408,6 +512,21 @@ export function buildBar(cfg, target, spriteFor) {
       let body = renderValue(m, m.render === "bar" ? cells : 0, boxRgb);
       const rid = m.right;
       const rhs = rid && rid in VALUES ? f(TEXT) + String(VALUES[rid]) : "";
+      // Plain text/number that overflows its column budget -> marquee. Skipped when
+      // the value carries ANSI/OSC escapes (colours, hyperlinks): those can't be
+      // sliced by column without corrupting the escape sequence.
+      const r = m.render || "text";
+      if ((r === "text" || r === "number") && !("group" in m) && m.id in VALUES) {
+        const raw = String(VALUES[m.id]);
+        const lbl = m.icon ? m.icon + " " : "";
+        const budget = w - vlen(lbl) - vlen(rhs);
+        if (!/[\x1b]/.test(raw) && budget > 0 && vlen(raw) > budget) {
+          let col;
+          if (m.color === "threshold") col = threshold(parseInt(raw.replace(/\D/g, "") || "0", 10));
+          else col = m.color ? rgbOf(m.color) : TEXT;
+          body = lbl + f(col) + marquee(raw, budget, tick);
+        }
+      }
       body += " ".repeat(Math.max(0, w - vlen(body) - vlen(rhs))) + rhs;
       col.push(bgsgrBox(boxRgb) + " " + body + " " + RESET);
     }
@@ -456,11 +575,12 @@ function main() {
     p = path.isAbsolute(arg) ? arg : path.join(process.cwd(), arg);
     try { readFileSync(p); } catch { p = path.join(REPO, "presets", path.basename(arg)); }
   } else {
-    p = path.join(REPO, "presets", "default.toml");
+    p = path.join(REPO, "presets", "standard.toml");
   }
   const target = process.argv[3] ? parseInt(process.argv[3], 10) : 100;
+  const tick = process.argv[4] ? parseInt(process.argv[4], 10) : 0; // marquee phase for previews
   const cfg = parseToml(readFileSync(p, "utf8"));
-  const res = buildBar(cfg, target);
+  const res = buildBar(cfg, target, undefined, tick);
   const out = ["", `  preset: ${path.basename(p)}   style=${res.style}  headers=${res.headers}  bar=${res.cells}`, ""];
   out.push(...res.lines, "");
   process.stdout.write(out.join("\n") + "\n");

package/src/statusline.js

@@ -7,18 +7,18 @@
 // settings.json:
 //   "statusLine": { "type": "command",
 //       "command": "node /abs/path/src/statusline.js", "refreshInterval": 1 }
-// Config: $DOOMBAR_PRESET (default presets/default.toml)  State: $MUGSHOT_STATE
+// 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, OK, TEXT, CRIT } from "./render.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);
 
-function readState(data) {
-  try { return JSON.parse(readFileSync(statePath(data), "utf8")); } catch { return {}; }
+  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");
+    }
+  }
+
+  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() {
@@ -366,7 +400,9 @@ export function activityValues(st, now) {
   const squad = st.squad || {};
   v["act.agents"] = String(Object.keys(squad).length);
   const agents = Object.values(squad).sort((a, b) => a.start - b.start);
-  v["act.subagents"] = agents.map((a) => [clip(a.desc || a.type || "agent", 24), _dur(now - a.start)]);
+  // Clip generously (not 24): the box caps width and the label marquees, so a long
+  // agent description should stay long enough to be worth scrolling through.
+  v["act.subagents"] = agents.map((a) => [clip(a.desc || a.type || "agent", 60), _dur(now - a.start)]);
 
   const tasks = st.tasks && typeof st.tasks === "object" ? Object.values(st.tasks) : [];
   const live = tasks.filter((t) => t.status !== "deleted");
@@ -377,7 +413,7 @@ export function activityValues(st, now) {
     .sort((a, b) => (TASK_ORDER[a.status] - TASK_ORDER[b.status]) || (a.ts - b.ts));
   v["act.tasklist"] = ordered.map((t) => {
     const [mark, markRgb] = TASK_MARK[t.status] || ["🎯", null];
-    return { mark, markRgb, text: clip(t.title, 24) };
+    return { mark, markRgb, text: clip(t.title, 60) }; // generous clip: box width caps it, title marquees
   });
 
   if ("errors" in st) v["act.errors"] = String(st.errors);
@@ -388,13 +424,13 @@ function main() {
   let data = {};
   try { data = JSON.parse(readFileSync(0, "utf8")); } catch { data = {}; }
 
-  const preset = process.env.DOOMBAR_PRESET || path.join(REPO, "presets", "default.toml");
+  const preset = process.env.DOOMBAR_PRESET || path.join(REPO, "presets", "standard.toml");
   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);
@@ -425,7 +461,17 @@ function main() {
   };
 
   const target = parseInt(process.env.COLUMNS || "100", 10);
-  const res = buildBar(cfg, target, spriteFor);
+  const tick = Math.floor(now); // one marquee step per refresh (~1s); pure fn of time
+  // Pick the preset that fits the terminal: the chosen preset is the ceiling; if it
+  // (at its minimum scale) overflows COLUMNS, fall back down its [bar].fallback chain.
+  // Sibling presets resolve relative to the chosen preset's directory.
+  const presetDir = path.dirname(preset);
+  const loadByName = (name) => {
+    try { return parseToml(readFileSync(path.join(presetDir, `${name}.toml`), "utf8")); }
+    catch { return null; }
+  };
+  const selected = resolvePreset(cfg, target, loadByName, spriteFor);
+  const res = buildBar(selected, target, spriteFor, tick);
   process.stdout.write(res.lines.join("\n") + "\n");
 }
 

package/presets/default.toml

@@ -1,38 +0,0 @@
-# default — balanced (the live-mockup look)
-[bar]
-border_style   = "vertical"
-border_color   = "term-fg"
-box_background = "term-bg"
-headers        = true
-
-[mugshot]
-background = "#000000"
-
-[[segment]]
-type  = "box"
-title = "USAGE"
-metric = [
-  { id = "context.hp",   render = "bar", icon = "🧠", color = "threshold" },
-  { id = "ratelimit.5h", render = "bar", icon = "🕔", color = "threshold" },
-  { id = "ratelimit.7d", render = "bar", icon = "📅", color = "threshold" },
-]
-
-[[segment]]
-type  = "box"
-title = "SAVE"
-metric = [
-  { id = "save.leanctx", render = "text", icon = "🪶" },
-  { id = "save.lingua",  render = "text", icon = "📜" },
-]
-
-[[segment]]
-type = "mugshot"
-
-[[segment]]
-type  = "box"
-title = "GIT"
-metric = [
-  { id = "git.branch", render = "text",   icon = "🌿" },
-  { group = ["git.behind", "git.ahead"], render = "number", sep = " ", icon = "⇅" },
-  { id = "cost.total", render = "number", icon = "💰" },
-]