claude-doom-statusbar 0.1.0

package/bin/cli.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+// Wire claude-doom-statusbar into Claude Code, so you never touch settings.json by hand.
+// 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 --project     # install into ./.claude/settings.json instead
+//   claude-doom-statusbar uninstall             # remove everything this installer added
+//
+// It merges into your existing settings (other hooks / statusline are preserved or
+// backed up), is safe to re-run, and prints what to do next.
+
+import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url)); // bin/
+const ROOT = path.dirname(HERE); // package root
+
+// Normalise to forward slashes, like install.py's `.replace("\\", "/")`. The marker we
+// DETECT below must match the command we WRITE byte-for-byte, including slash direction —
+// otherwise a second install double-adds. So everything goes through this one funnel.
+const slash = (p) => p.replace(/\\/g, "/");
+
+const STATUSLINE = slash(path.join(ROOT, "src", "statusline.js"));
+const HOOK = slash(path.join(ROOT, "src", "hook.js"));
+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.
+const HOOK_EVENTS = [
+  "PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionDenied",
+  "Stop", "SubagentStart", "SubagentStop", "TaskCreated", "TaskCompleted",
+];
+
+// How we recognise our own entries — current JS scripts plus legacy Python ones, so a
+// user who ran install.py earlier still gets cleaned up by `uninstall`.
+const HOOK_MARKS = ["src/hook.js", "mugshot_hook.py"];
+const SL_MARKS = ["src/statusline.js", "statusline.py"];
+const hasMark = (s, marks) => marks.some((m) => slash(String(s || "")).includes(m));
+
+function die(msg) {
+  process.stderr.write(msg + "\n");
+  process.exit(1);
+}
+
+function settingsFile(project) {
+  const base = project ? path.join(process.cwd(), ".claude") : path.join(os.homedir(), ".claude");
+  return path.join(base, "settings.json");
+}
+
+function load(p) {
+  let text;
+  try {
+    text = readFileSync(p, "utf-8");
+  } catch (e) {
+    if (e.code === "ENOENT") return {};
+    throw e;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    die(`! ${p} is not valid JSON (${e.message}); fix or move it, then re-run.`);
+  }
+}
+
+function save(p, data) {
+  mkdirSync(path.dirname(p), { recursive: true });
+  if (existsSync(p)) copyFileSync(p, p + ".bak"); // one-level backup before writing
+  writeFileSync(p, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+const ours = (entry) => (entry.hooks || []).some((h) => hasMark(h.command, HOOK_MARKS));
+
+function install(cfg, preset) {
+  const notes = [];
+  const existing = cfg.statusLine;
+  if (existing && !hasMark(JSON.stringify(existing), SL_MARKS)) {
+    notes.push("replaced your existing statusLine (the old one is in settings.json.bak)");
+  }
+  cfg.statusLine = { type: "command", command: STATUSLINE_CMD, refreshInterval: 1 };
+
+  const env = (cfg.env ??= {});
+  const presetFile = preset.endsWith(".toml") ? preset : preset + ".toml";
+  env.DOOMBAR_PRESET = slash(path.join(ROOT, "presets", presetFile));
+  env.FORCE_HYPERLINK ??= "1"; // clickable links (Windows Terminal needs this)
+
+  const hooks = (cfg.hooks ??= {});
+  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 }] });
+    }
+  }
+  return notes;
+}
+
+function uninstall(cfg) {
+  if (hasMark(cfg.statusLine?.command, SL_MARKS)) delete cfg.statusLine;
+
+  const env = cfg.env || {};
+  for (const k of ["DOOMBAR_PRESET", "FORCE_HYPERLINK"]) delete env[k];
+  if (Object.keys(env).length === 0) delete cfg.env;
+
+  const hooks = cfg.hooks || {};
+  for (const ev of Object.keys(hooks)) {
+    hooks[ev] = hooks[ev].filter((e) => !ours(e));
+    if (hooks[ev].length === 0) delete hooks[ev];
+  }
+  if (Object.keys(hooks).length === 0) delete cfg.hooks;
+}
+
+function parseArgs(argv) {
+  const out = { cmd: "install", preset: "full", project: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "install" || a === "uninstall") out.cmd = a;
+    else if (a === "--uninstall") out.cmd = "uninstall";
+    else if (a === "--project") out.project = true;
+    else if (a === "--preset") out.preset = argv[++i];
+    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)");
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const p = settingsFile(args.project);
+  const cfg = load(p);
+
+  if (args.cmd === "uninstall") {
+    uninstall(cfg);
+    save(p, cfg);
+    console.log(`✓ removed claude-doom-statusbar from ${p}`);
+    console.log("  restart Claude Code to apply.");
+    return;
+  }
+
+  if (!existsSync(fileURLToPath(new URL("../src/statusline.js", import.meta.url)))) {
+    die(`! can't find ${STATUSLINE} — reinstall the package.`);
+  }
+  const notes = install(cfg, args.preset);
+  save(p, cfg);
+
+  console.log(`✓ installed claude-doom-statusbar into ${p}`);
+  console.log(`  statusline : ${STATUSLINE_CMD}`);
+  console.log(`  preset     : ${args.preset}`);
+  console.log(`  hooks      : ${HOOK_EVENTS.join(", ")}`);
+  for (const n of notes) console.log(`  note       : ${n}`);
+  console.log();
+  console.log("Next:");
+  console.log("  1. (optional) install chafa for a sharper mugshot; without it a pre-rendered face is used.");
+  console.log("  2. restart Claude Code.");
+  console.log("  Clickable links need FORCE_HYPERLINK=1 (set for you here; on Windows Terminal you may");
+  console.log("  also need to launch with it:  $env:FORCE_HYPERLINK='1'; claude ).");
+}
+
+main();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "claude-doom-statusbar",
+  "version": "0.1.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": {
+    "claude-doom-statusbar": "bin/cli.js"
+  },
+  "files": [
+    "src",
+    "bin",
+    "presets",
+    "assets"
+  ],
+  "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/e2e-tasks.test.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "smol-toml": "^1.6.1"
+  },
+  "keywords": [
+    "claude-code",
+    "statusline",
+    "doom",
+    "terminal",
+    "hud",
+    "tui"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/99LevelsUp/claude-doom-statusbar.git"
+  },
+  "license": "MIT"
+}

package/presets/default.toml

@@ -0,0 +1,30 @@
+# 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 = "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 = "💰" },
+]

package/presets/full.toml

@@ -0,0 +1,80 @@
+# full — DOOM panel, everything on
+[bar]
+border_style   = "vertical"
+border_color   = "term-bg"      # seamless cuts through the panel
+box_background = "#1c2036"
+headers        = true
+
+[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 = "loc.cwd",    render = "text",   icon = "📁" },
+  { id = "git.branch", render = "text",   icon = "🌿" },
+  { group = ["git.behind", "git.ahead"], render = "number", sep = " ", icon = "⇅ " },
+  { id = "git.status", render = "number", icon = "✎ " },
+  { 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"
+metric = [
+  { id = "act.subagents", render = "scroll", anchor = "top", icon = "👹" },
+]
+
+[[segment]]
+type  = "box"
+title = "TASKS"
+metric = [
+  { id = "act.tasklist", render = "scroll", anchor = "boundary" },
+]
+
+[[segment]]
+type  = "box"
+title = "SYS"
+metric = [
+  { id = "sys.cpu",     render = "number", icon = "🔥" },
+  { id = "sys.disk",    render = "bar",    icon = "💿", color = "threshold" },
+  { id = "sys.session", render = "text",   icon = "🕙" },
+  { id = "sys.clock",   render = "text",   icon = "🕓" },
+]

package/presets/minimal.toml

@@ -0,0 +1,19 @@
+# minimal — blends into the terminal, smallest footprint
+[bar]
+border_style   = "none"
+box_background = "term-bg"
+headers        = false
+
+[mugshot]
+background = "term-bg"
+
+[[segment]]
+type = "box"
+metric = [
+  { id = "context.hp",   render = "bar",    icon = "🧠", color = "threshold" },
+  { id = "ratelimit.5h", render = "ammo",   icon = "🕔" },
+  { id = "cost.total",   render = "number", icon = "💰" },
+]
+
+[[segment]]
+type = "mugshot"

package/src/ansi.js

@@ -0,0 +1,20 @@
+// Shared low-level ANSI primitives, used by both the face loader and the render
+// engine. Kept dependency-free and tiny.
+
+export const RESET = "\x1b[0m";
+export const BOLD = "\x1b[1m";
+export const TERM_RGB = [0, 0, 0]; // assumed terminal background (for blends/look)
+
+// Truecolor foreground / background SGR from an [r,g,b] array.
+export const sgrFg = (c) => `\x1b[38;2;${c[0]};${c[1]};${c[2]}m`;
+export const sgrBg = (c) => `\x1b[48;2;${c[0]};${c[1]};${c[2]}m`;
+
+// Python's round() is round-half-to-even (banker's); JS Math.round is half-up.
+// We must match Python exactly or bar/spark heights drift by one at .5 boundaries.
+export function pyround(x) {
+  const fl = Math.floor(x);
+  const d = x - fl;
+  if (d < 0.5) return fl;
+  if (d > 0.5) return fl + 1;
+  return fl % 2 === 0 ? fl : fl + 1; // exactly .5 -> nearest even
+}

package/src/face.js

@@ -0,0 +1,126 @@
+// Mugshot face loader — port of the face logic in tools/mockup_boxes.py.
+// chafa rasterises a pre-baked *transparent* sprite into block-art at the
+// requested height; when chafa is absent we fall back to the pre-rendered .ans
+// (heights 4..16). The ANSI is parsed into rows of [char, fg, bg] (fg/bg an
+// [r,g,b] or null = transparent), then composited onto the mugshot background.
+
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RESET, sgrBg } from "./ansi.js";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO = path.dirname(HERE);
+const ALPHA_DIR = path.join(REPO, "assets", "images", "mugshot", "alpha"); // pre-baked transparent
+const ANS_DIR = path.join(REPO, "assets", "images", "mugshot", "ans");
+const ANS_SIZES = [4, 16];
+const SYMS = "block+half+quad+sextant+wedge+legacy";
+const TERM_BG = "term-bg";
+
+const _cache = new Map();
+
+function chafaFace(name, rows) {
+  const sprite = path.join(ALPHA_DIR, name + ".png");
+  const args = ["-f", "symbols", "--polite", "on", "--colors", "full",
+    "--symbols", SYMS, "--size", `9999x${rows}`, sprite];
+  const r = spawnSync("chafa", args, { maxBuffer: 1 << 24 });
+  if (r.error) return null; // chafa not on PATH
+  return r.status === 0 && r.stdout && r.stdout.length ? r.stdout.toString("utf8") : null;
+}
+
+function ansiFace(name, rows) {
+  const r = Math.max(ANS_SIZES[0], Math.min(ANS_SIZES[1], rows));
+  try {
+    return readFileSync(path.join(ANS_DIR, String(r), name + ".ans"), "utf8");
+  } catch {
+    return "";
+  }
+}
+
+const FINAL = "ABCDEFGHJKSTfhilmnpqrsu"; // CSI final bytes we scan to
+
+function parseAnsi(text) {
+  const chars = [...text]; // code points (face glyphs are astral)
+  let fgc = null, bgc = null, rev = false;
+  const out = [];
+  let row = [];
+  let i = 0;
+  while (i < chars.length) {
+    const c = chars[i];
+    if (c === "\r") {
+      i += 1;
+    } else if (c === "\n") {
+      out.push(row);
+      row = [];
+      i += 1;
+    } else if (c === "\x1b" && i + 1 < chars.length && chars[i + 1] === "[") {
+      let j = i + 2;
+      while (j < chars.length && !FINAL.includes(chars[j])) j += 1;
+      if (j < chars.length && chars[j] === "m") {
+        const ps = chars.slice(i + 2, j).join("").split(";");
+        let k = 0;
+        while (k < ps.length) {
+          const p = ps[k] === "" ? 0 : parseInt(ps[k], 10);
+          if (p === 0) { fgc = null; bgc = null; rev = false; }
+          else if (p === 7) rev = true;
+          else if (p === 27) rev = false;
+          else if (p === 39) fgc = null;
+          else if (p === 49) bgc = null;
+          else if ((p === 38 || p === 48) && k + 4 < ps.length && ps[k + 1] === "2") {
+            const col = [parseInt(ps[k + 2], 10), parseInt(ps[k + 3], 10), parseInt(ps[k + 4], 10)];
+            if (p === 38) fgc = col; else bgc = col;
+            k += 4;
+          }
+          k += 1;
+        }
+      }
+      i = j + 1;
+    } else {
+      const [efg, ebg] = rev ? [bgc, fgc] : [fgc, bgc];
+      row.push([c, efg, ebg]);
+      i += 1;
+    }
+  }
+  if (row.length) out.push(row);
+  return out;
+}
+
+export function loadFace(name, rows) {
+  const key = `${name}@${rows}`;
+  if (_cache.has(key)) return _cache.get(key);
+  let text = chafaFace(name, rows);
+  if (!text) text = ansiFace(name, rows); // no chafa -> pre-rendered ANSI
+  let out = parseAnsi(text);
+  out = out.slice(0, rows);
+  while (out.length < rows) out.push([]); // exactly `rows` lines (fallback clamps)
+  _cache.set(key, out);
+  return out;
+}
+
+const tc = (code, c) => `\x1b[${code};2;${c[0]};${c[1]};${c[2]}m`;
+
+function emitCell(ch, efg, ebg, boxBg) {
+  if (boxBg !== TERM_BG) {
+    const fcol = efg !== null ? efg : boxBg;
+    const bcol = ebg !== null ? ebg : boxBg;
+    return "\x1b[27m" + tc(38, fcol) + tc(48, bcol) + ch;
+  }
+  if (efg === null && ebg === null) return "\x1b[27m\x1b[39m\x1b[49m" + ch;
+  if (efg === null) return "\x1b[7m" + tc(38, ebg) + "\x1b[49m" + ch;
+  if (ebg === null) return "\x1b[27m" + tc(38, efg) + "\x1b[49m" + ch;
+  return "\x1b[27m" + tc(38, efg) + tc(48, ebg) + ch;
+}
+
+const bg = (color) => (color === TERM_BG ? "\x1b[49m" : sgrBg(color));
+
+export function faceCell(cells, w, boxBg) {
+  const vis = cells.length;
+  const total = Math.max(0, w - vis);
+  const left = Math.floor(total / 2);
+  const right = total - left;
+  let s = bg(boxBg) + " " + " ".repeat(left);
+  for (const [ch, efg, ebg] of cells) s += emitCell(ch, efg, ebg, boxBg);
+  s += RESET + bg(boxBg) + " ".repeat(right) + " " + RESET;
+  return s;
+}

package/src/hook.js

@@ -0,0 +1,136 @@
+#!/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.
+//
+// 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.
+//
+// State file: $MUGSHOT_STATE, else <temp>/mugshot_<session_id>.json.
+
+import { readFileSync, writeFileSync, renameSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+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`);
+}
+
+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.
+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 = {};
+}
+
+function main() {
+  try {
+    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 tmp = `${p}.${process.pid}.tmp`;
+    try { writeFileSync(tmp, JSON.stringify(st)); renameSync(tmp, p); } catch { /* never block */ }
+  } catch { /* swallow everything: a hook must never block a tool */ }
+  process.exit(0);
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
+  main();
+}