mixdog 0.7.1

package/bin/statusline.mjs

@@ -0,0 +1,607 @@
+#!/usr/bin/env bun
+// mixdog statusline wrapper — v0.1.45 (Bun/Node port of statusline.sh)
+// Functional 1:1 parity with the bash original. Replaces bash startup (~50-100ms
+// MSYS overhead) with a single Bun/Node process launch (~5-15ms).
+// Node-builtins only: fs, os, node:http — no third-party deps.
+
+import fs from 'fs';
+import os from 'os';
+import http from 'node:http';
+import path from 'path';
+
+// ── ANSI palette (identical to bash original) ────────────────────────────────
+const R  = '\x1b[0m';
+const B  = '\x1b[1m';
+const D  = '\x1b[2m';
+const RED = '\x1b[31m';
+const GRN = '\x1b[32m';
+const YLW = '\x1b[33m';
+const CYN = '\x1b[36m';
+const GREY = '\x1b[90m';
+
+// ── Terminal width ────────────────────────────────────────────────────────────
+let COLS = parseInt(process.env.COLUMNS || '120', 10);
+if (!Number.isFinite(COLS) || COLS <= 0) COLS = 120;
+
+// ── Read CC stdin JSON synchronously ─────────────────────────────────────────
+let CC_JSON = '';
+try { CC_JSON = fs.readFileSync(0, 'utf8'); } catch { CC_JSON = ''; }
+
+if (process.env.MIXDOG_STATUSLINE_TRACE && CC_JSON && process.env.CLAUDE_PLUGIN_DATA) {
+  try {
+    fs.writeFileSync(
+      path.join(process.env.CLAUDE_PLUGIN_DATA, 'statusline-stdin.json'),
+      CC_JSON
+    );
+  } catch {}
+}
+
+// ── One-shot log rotation at entry (5 MB threshold) ──────────────────────────
+if (process.env.MIXDOG_STATUSLINE_TRACE) {
+  try {
+    const traceFile = path.join(
+      os.homedir(), '.claude', 'plugins', 'data', 'mixdog-trib-plugin', 'statusline-trace.log'
+    );
+    const st = fs.statSync(traceFile);
+    if (st.size > 5 * 1024 * 1024) fs.writeFileSync(traceFile, '');
+  } catch {}
+}
+
+// ── JSON field extraction helpers (regex, matching bash anchoring) ────────────
+function extract(json, re) {
+  const m = re.exec(json);
+  return m ? m[1] : '';
+}
+
+// Slice a substring from after `key` up to (but not including) `stopKey`.
+// Mirrors bash's `${CC_JSON#*"key"}` / `${var%%"stopKey"*}`.
+function slice(json, key, stopKey) {
+  const idx = json.indexOf(key);
+  if (idx < 0) return null;
+  const tail = json.slice(idx + key.length);
+  if (stopKey) {
+    const stop = tail.indexOf(stopKey);
+    return stop >= 0 ? tail.slice(0, stop) : tail;
+  }
+  return tail;
+}
+
+// ── Extract CC fields ─────────────────────────────────────────────────────────
+let CC_MODEL       = extract(CC_JSON, /"display_name"\s*:\s*"([^"]+)"/);
+let CC_CTX_USED    = '';
+let CC_RL_5H       = '';
+let CC_RL_7D       = '';
+let CC_RL_5H_RESET = '';
+
+// context_window scope — cap at "rate_limits" sibling so cold-start payloads
+// don't accidentally pick up the five_hour used_percentage.
+const ctxTail = slice(CC_JSON, '"context_window"', '"rate_limits"');
+if (ctxTail !== null) {
+  CC_CTX_USED = extract(ctxTail, /"used_percentage"\s*:\s*([0-9.]+)/);
+}
+
+const fiveTail = slice(CC_JSON, '"five_hour"', '"seven_day"');
+if (fiveTail !== null) {
+  CC_RL_5H       = extract(fiveTail, /"used_percentage"\s*:\s*([0-9.]+)/);
+  CC_RL_5H_RESET = extract(fiveTail, /"resets_at"\s*:\s*([0-9]+)/);
+}
+
+const sevenTail = slice(CC_JSON, '"seven_day"', null);
+if (sevenTail !== null) {
+  CC_RL_7D = extract(sevenTail, /"used_percentage"\s*:\s*([0-9.]+)/);
+}
+
+// ── Extract effort level ──────────────────────────────────────────────────────
+// Priority: CC_JSON effort.level → env CLAUDE_CODE_EFFORT_LEVEL → settings.json
+let CC_EFFORT = extract(CC_JSON, /"effort"\s*:\s*\{[^}]*"level"\s*:\s*"([^"]+)"/);
+if (!CC_EFFORT) CC_EFFORT = process.env.CLAUDE_CODE_EFFORT_LEVEL || '';
+if (!CC_EFFORT) {
+  try {
+    const settingsRaw = fs.readFileSync(
+      path.join(os.homedir(), '.claude', 'settings.json'), 'utf8'
+    );
+    CC_EFFORT = extract(settingsRaw, /"effortLevel"\s*:\s*"([^"]+)"/);
+  } catch {}
+}
+
+// ── Extract CC session_id ─────────────────────────────────────────────────────
+const CC_SESSION_ID = extract(CC_JSON, /"session_id"\s*:\s*"([^"]+)"/);
+const STATUS_ARGS = (() => {
+  try {
+    const parsed = JSON.parse(CC_JSON);
+    return Array.isArray(parsed?._args) ? parsed._args.map(String) : [];
+  } catch { return []; }
+})();
+function statusArg(prefix) {
+  return STATUS_ARGS.find(arg => arg.startsWith(prefix))?.slice(prefix.length) || '';
+}
+function positiveInt(value) {
+  const n = parseInt(String(value || ''), 10);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+const CLIENT_HOST_PID = positiveInt(statusArg('--client-host-pid=')) || positiveInt(process.ppid);
+// Bash-jobs scope pid: ONLY the explicitly passed --client-host-pid (the
+// shim-provided claude.exe pid). No process.ppid fallback here — under a
+// no-shim invocation ppid is the renderer's parent (the daemon/launcher),
+// NOT claude.exe, so falling back would count jobs that merely match that
+// unrelated pid. Absent ⇒ 0 ⇒ the segment attributes nothing.
+const CLIENT_HOST_PID_JOBS = positiveInt(statusArg('--client-host-pid='));
+function advertPidAlive(content) {
+  const pid = positiveInt(extract(content, /"pid"\s*:\s*([0-9]+)/));
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+function advertCcMatches(content) {
+  return !!(CC_SESSION_ID && content.includes('"cc_session_id"') && content.includes(`"${CC_SESSION_ID}"`));
+}
+function advertClaimed(content) {
+  return content.includes('"cc_session_id"');
+}
+function advertClientHostPid(content) {
+  return positiveInt(extract(content, /"clientHostPid"\s*:\s*([0-9]+)/))
+    || positiveInt(extract(content, /"client_host_pid"\s*:\s*([0-9]+)/));
+}
+function advertHostMatches(content, { allowUnclaimed = false } = {}) {
+  if (!CLIENT_HOST_PID) return true;
+  const clientHostPid = advertClientHostPid(content);
+  if (clientHostPid) return clientHostPid === CLIENT_HOST_PID;
+  if (allowUnclaimed && !advertClaimed(content)) return true;
+  const ownerHostPid = positiveInt(extract(content, /"ownerHostPid"\s*:\s*([0-9]+)/));
+  return ownerHostPid === CLIENT_HOST_PID;
+}
+
+// ── Advert routing ────────────────────────────────────────────────────────────
+// Fast path: read `.cc-<sessionId>.path` mapping (written after a successful
+// claim on an earlier tick) and resolve straight to the cached advert.
+// Verified by pid liveness + cc_session_id match in the advert body — any
+// mismatch falls through to the O(N) scan and re-writes the mapping at the
+// end. With a CC session_id, never bind to an advert already claimed by a
+// different CC session: that leaks another terminal's workers into this
+// statusline.
+let statusAdvert = '';
+let needClaim    = false;
+const advertDir  = path.join(os.homedir(), '.claude', 'mixdog-status');
+const mappingPath = CC_SESSION_ID
+  ? path.join(advertDir, `.cc-${CC_SESSION_ID}.path`)
+  : '';
+
+if (mappingPath) {
+  try {
+    const cached = fs.readFileSync(mappingPath, 'utf8').trim();
+    if (cached) {
+      const cachedAdvert = path.isAbsolute(cached) ? cached : path.join(advertDir, cached);
+      const advertContent = fs.readFileSync(cachedAdvert, 'utf8');
+      if (advertPidAlive(advertContent) && advertCcMatches(advertContent) && advertHostMatches(advertContent)) {
+        statusAdvert = cachedAdvert;
+        needClaim = false;
+      } else {
+        try { fs.unlinkSync(mappingPath); } catch {}
+      }
+    } else {
+      try { fs.unlinkSync(mappingPath); } catch {}
+    }
+  } catch {
+    try { fs.unlinkSync(mappingPath); } catch {}
+  }
+}
+
+if (!statusAdvert) {
+  try {
+    const files = fs.readdirSync(advertDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => path.join(advertDir, f));
+
+    for (const f of files) {
+      let content;
+      try { content = fs.readFileSync(f, 'utf8'); } catch { continue; }
+      if (!advertPidAlive(content)) continue;
+
+      // Step 1: paired — cc_session_id matches
+      if (advertCcMatches(content)) {
+        if (!advertHostMatches(content)) continue;
+        statusAdvert = f;
+        needClaim    = false;
+        break;
+      }
+      // Step 2: first unclaimed same-host advert. Never fetch an advert already
+      // claimed by a different CC session; that would leak another terminal's
+      // bridge workers into this statusline for at least one tick.
+      if (!statusAdvert && CC_SESSION_ID && !advertClaimed(content) && advertHostMatches(content, { allowUnclaimed: true })) {
+        statusAdvert = f;
+        needClaim    = true;
+        // keep scanning — a paired advert may appear later
+      }
+    }
+
+    // Legacy/no-session fallback only. A statusline with session_id must not
+    // attach to another CC session's claimed advert.
+    if (!statusAdvert && !CC_SESSION_ID) {
+      for (const f of files) {
+        try { fs.readFileSync(f, 'utf8'); statusAdvert = f; break; } catch {}
+      }
+    }
+  } catch {}
+
+  // Persist mapping for the next tick — fast path will reuse it. Skip when
+  // we still need to claim (the next tick will validate and write itself).
+  if (statusAdvert && mappingPath && !needClaim) {
+    try { fs.writeFileSync(mappingPath, statusAdvert); } catch {}
+  }
+}
+
+// Legacy single-file fallback.
+if (!statusAdvert && !CC_SESSION_ID) {
+  statusAdvert = path.join(os.homedir(), '.claude', 'mixdog-status.json');
+}
+
+// ── Read port from advert ─────────────────────────────────────────────────────
+let statusPort = '';
+try {
+  const advertContent = fs.readFileSync(statusAdvert, 'utf8');
+  statusPort = extract(advertContent, /"port"\s*:\s*([0-9]+)/);
+} catch {}
+
+// ── Fire-and-forget claim POST ────────────────────────────────────────────────
+// Response MUST be consumed (res.resume()) — Node http keeps the socket
+// open until the body is read or destroyed, so an unread 200 leaks one
+// socket per tick on a 1-5 s refresh cadence. setTimeout < the GET
+// budget below so a stuck POST never overlaps the next statusline spawn.
+if (needClaim && CC_SESSION_ID && statusPort) {
+  const claimPayload = { cc_session_id: CC_SESSION_ID };
+  if (CLIENT_HOST_PID) claimPayload.client_host_pid = CLIENT_HOST_PID;
+  const body = JSON.stringify(claimPayload);
+  try {
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: parseInt(statusPort, 10),
+      path: '/register-cc-session',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+    }, (res) => { res.resume(); });
+    req.on('error', () => {});
+    req.setTimeout(800, () => { try { req.destroy(); } catch {} });
+    req.write(body);
+    req.end();
+  } catch {}
+}
+
+// ── Fetch /bridge/status with 1s timeout ─────────────────────────────────────
+let bridgeJson = '';
+if (statusPort) {
+  bridgeJson = await new Promise(resolve => {
+    try {
+      const statusUrl = `http://127.0.0.1:${statusPort}/bridge/status?format=statusline-json`
+        + (CLIENT_HOST_PID ? `&clientHostPid=${CLIENT_HOST_PID}` : '');
+      const req = http.get(
+        statusUrl,
+        { timeout: 500 },
+        res => {
+          let data = '';
+          res.on('data', chunk => { data += chunk; });
+          res.on('end', () => resolve(data));
+        }
+      );
+      req.on('error', () => resolve(''));
+      req.on('timeout', () => { req.destroy(); resolve(''); });
+    } catch { resolve(''); }
+  });
+}
+if (!bridgeJson.startsWith('{')) bridgeJson = '';
+
+// ── NOBRIDGE trace ────────────────────────────────────────────────────────────
+if (!bridgeJson && process.env.MIXDOG_STATUSLINE_TRACE) {
+  try {
+    const traceDir = path.join(os.homedir(), '.claude', 'plugins', 'data', 'mixdog-trib-plugin');
+    if (fs.existsSync(traceDir)) {
+      const advertPresent = (() => { try { fs.accessSync(statusAdvert); return 'present'; } catch { return 'missing'; } })();
+      const ts = new Date().toISOString().replace('T', ' ').slice(0, 19);
+      fs.appendFileSync(
+        path.join(traceDir, 'statusline-trace.log'),
+        `${ts} NOBRIDGE port=${statusPort || '?'} advert=${advertPresent}\n`
+      );
+    }
+  } catch {}
+}
+
+// ── Extract bridge fields ─────────────────────────────────────────────────────
+let bSessRoles    = '';
+let bSchedNextAt  = '';
+let bSchedNextName = '';
+// Worker list carrying running/idle status alongside each tag, surfaced by
+// the aggregator's sessions.workers segment. Falls back to roles (running-
+// only) when an older aggregator payload lacks the workers array.
+let bWorkers      = [];
+
+if (bridgeJson) {
+  const sessRaw = extract(bridgeJson, /"sessions"\s*:\s*\{[^}]*"roles"\s*:\s*\[([^\]]*)\]/);
+  if (sessRaw) bSessRoles = sessRaw.replace(/"/g, '').replace(/\s/g, '');
+  const workersRaw = extract(bridgeJson, /"workers"\s*:\s*\[([^\]]*)\]/);
+  if (workersRaw) {
+    // Parse [{"tag":"x","status":"running"},...] without a full JSON.parse
+    // of the whole payload (matches the existing regex-extract approach).
+    const re = /\{[^}]*?"tag"\s*:\s*"([^"]*)"[^}]*?"status"\s*:\s*"([^"]*)"[^}]*?\}/g;
+    let m;
+    while ((m = re.exec(workersRaw)) !== null) {
+      bWorkers.push({ tag: m[1], status: m[2] === 'idle' ? 'idle' : 'running' });
+    }
+  }
+
+  bSchedNextAt   = extract(bridgeJson, /"next"\s*:\s*\{[^}]*"fireAt"\s*:\s*([0-9]+)/);
+  bSchedNextName = extract(bridgeJson, /"next"\s*:\s*\{[^}]*"name"\s*:\s*"([^"]*)"/);
+}
+
+// ── Format helpers ────────────────────────────────────────────────────────────
+
+// Model short form — collapse "(1M context)" → "(1M)", prefix with family name.
+let modelStr = '';
+if (CC_MODEL) {
+  let raw = CC_MODEL.replace('(1M context)', '(1M)');
+  if (raw.includes('Opus'))   modelStr = 'Opus'   + raw.slice(raw.indexOf('Opus')   + 4);
+  else if (raw.includes('Sonnet')) modelStr = 'Sonnet' + raw.slice(raw.indexOf('Sonnet') + 6);
+  else if (raw.includes('Haiku'))  modelStr = 'Haiku'  + raw.slice(raw.indexOf('Haiku')  + 5);
+  else modelStr = raw;
+}
+const modelShort = modelStr.split(' ')[0];
+const effortStr  = CC_EFFORT ? CC_EFFORT.toUpperCase() : '';
+
+// Round float string to nearest integer (replicates printf "%.0f").
+function roundPct(s) {
+  const n = parseFloat(s);
+  return Number.isFinite(n) ? Math.round(n) : null;
+}
+
+const ctxInt    = roundPct(CC_CTX_USED);
+const rl5hInt   = roundPct(CC_RL_5H);
+const rl7dInt   = roundPct(CC_RL_7D);
+
+// HH:MM from ms epoch (local time).
+function epochMsToHHMM(ms) {
+  const d = new Date(parseInt(ms, 10));
+  if (isNaN(d.getTime())) return '';
+  return d.toLocaleTimeString('sv-SE', { hour: '2-digit', minute: '2-digit', hour12: false });
+}
+
+const resetStr = CC_RL_5H_RESET ? epochMsToHHMM(CC_RL_5H_RESET * 1000) : '';
+
+// Schedule next HH:MM — fireAt is ms epoch directly.
+const schedNextHHMM = bSchedNextAt ? epochMsToHHMM(parseInt(bSchedNextAt, 10)) : '';
+
+// Colour a percentage integer string.
+function colourPct(p) {
+  if (p >= 90) return `${RED}${p}%${R}`;
+  if (p >= 70) return `${YLW}${p}%${R}`;
+  return `${GRN}${p}%${R}`;
+}
+
+// Build bar: ▓ for filled, ░ for empty.
+function makeBar(pct, cells) {
+  if (pct === null || cells <= 0) return '';
+  let filled = Math.floor(pct * cells / 100);
+  if (filled < 0) filled = 0;
+  if (filled > cells) filled = cells;
+  if (pct > 0 && filled === 0) filled = 1;
+  return '▓'.repeat(filled) + '░'.repeat(cells - filled);
+}
+
+// ── Build L1 ──────────────────────────────────────────────────────────────────
+const SEP = `${D}│${R}`;
+const l1Parts = [];
+function addL1(seg) { if (seg) l1Parts.push(seg); }
+
+// Model + effort
+if (modelStr) {
+  const m = COLS >= 120 ? modelStr : modelShort;
+  if (effortStr) {
+    addL1(`${CYN}◆${R} ${B}${m}${R} ${D}·${R} ${B}${effortStr}${R}`);
+  } else {
+    addL1(`${CYN}◆${R} ${B}${m}${R}`);
+  }
+}
+
+// Context bar
+if (ctxInt !== null) {
+  const fill = ctxInt >= 90 ? RED : ctxInt >= 70 ? YLW : GRN;
+  let barOut = '';
+  if      (COLS >= 120) barOut = makeBar(ctxInt, 14);
+  else if (COLS >= 80)  barOut = makeBar(ctxInt, 8);
+
+  if (barOut) {
+    const filledPart = barOut.replace(/░/g, '');
+    const emptyPart  = barOut.replace(/▓/g, '');
+    const bar        = `${fill}${filledPart}${R}${D}${emptyPart}${R}`;
+    addL1(`${bar} ${ctxInt}%`);
+  } else {
+    addL1(`${fill}${ctxInt}%${R}`);
+  }
+}
+
+// Rate limits + reset
+if (rl5hInt !== null) {
+  addL1(`${D}5H${R} ${colourPct(rl5hInt)}`);
+}
+if (COLS >= 80) {
+  if (rl7dInt !== null) {
+    addL1(`${D}7D${R} ${colourPct(rl7dInt)}`);
+  }
+  if (resetStr) {
+    addL1(`${D}↻ ${resetStr}${R}`);
+  }
+}
+
+// ── Role classification ───────────────────────────────────────────────────────
+let workCount    = 0;
+let workOrder    = '';
+let hasCycle1    = false;
+let hasCycle2    = false;
+let hasCycle3    = false;
+let hasSched     = false;
+let hasWebhook   = false;
+let hasExplorer  = false;
+
+function classifyMaint(role) {
+  switch (role) {
+    case 'cycle1-agent':    hasCycle1   = true; return true;
+    case 'cycle2-agent':    hasCycle2   = true; return true;
+    case 'cycle3-agent':    hasCycle3   = true; return true;
+    case 'scheduler-task':  hasSched    = true; return true;
+    case 'webhook-handler': hasWebhook  = true; return true;
+    case 'explorer':        hasExplorer = true; return true;
+    default: return false;
+  }
+}
+
+// Idle worker tags (greyed in L2), threaded from the aggregator's
+// sessions.workers[].status. Running user-workers still feed workCount /
+// workOrder so the existing "N Running (tags)" badge is unchanged.
+const idleWorkers = [];
+if (bWorkers.length) {
+  // Preferred path: per-worker running/idle status from the aggregator.
+  for (const w of bWorkers) {
+    if (classifyMaint(w.tag)) continue; // maintenance → L1, not the worker badge
+    if (w.status === 'idle') {
+      idleWorkers.push(w.tag);
+    } else {
+      workCount++;
+      workOrder = workOrder ? `${workOrder}, ${w.tag}` : w.tag;
+    }
+  }
+} else if (bSessRoles) {
+  // Fallback: legacy roles array (running-only, no idle/status info).
+  for (const role of bSessRoles.split(',')) {
+    if (!role) continue;
+    if (classifyMaint(role)) continue;
+    workCount++;
+    workOrder = workOrder ? `${workOrder}, ${role}` : role;
+  }
+}
+
+// Maint/system/retrieval badges → single L1 segment
+const maintParts = [];
+if (hasCycle1)    maintParts.push(`${GRN}↻${R} ${B}cycle1${R}`);
+if (hasCycle2)    maintParts.push(`${GRN}↻${R} ${B}cycle2${R}`);
+if (hasCycle3)    maintParts.push(`${GRN}↻${R} ${B}cycle3${R}`);
+if (hasSched)     maintParts.push(`${GRN}↻${R} ${B}scheduler${R}`);
+if (hasWebhook)   maintParts.push(`${GRN}↻${R} ${B}webhook${R}`);
+if (hasExplorer)  maintParts.push(`${GRN}↻${R} ${B}explorer${R}`);
+if (maintParts.length) addL1(maintParts.join(' '));
+
+// Background bash jobs: a running job is a `<jobId>.json` whose sibling
+// `<jobId>.done` (written on exit) is absent. Surviving candidates are then
+// liveness-filtered — the `.json` carries the wrapper `pid`; an orphaned job
+// (wrapper crashed, `.done` never written, pid dead for days) is skipped via
+// process.kill(pid, 0). Bounded per tick: candidates are ordered newest-first
+// (the jobId embeds its spawn Date.now()) and at most JOB_SCAN_CAP of them are
+// read — keeping each render O(cap), not O(total on-disk jobs). When the scan
+// is truncated a trailing `+` overflow marker is appended to the count. One
+// readFileSync/statSync per scanned job for the oldest startedAt (the .json is
+// written at job start); tolerate the dir being missing and never throw.
+const JOB_SCAN_CAP = 30;
+const bashJobsSeg = (() => {
+  try {
+    const dir = path.join(os.homedir(), '.claude', 'plugins', 'data', 'mixdog-trib-plugin', 'shell-jobs');
+    const names = fs.readdirSync(dir);
+    const done = new Set();
+    const jobs = [];
+    const ownerByJob = new Map();
+    for (const n of names) {
+      if (n.endsWith('.done')) done.add(n.slice(0, -5));
+      else if (n.endsWith('.json')) jobs.push(n.slice(0, -5));
+      else {
+        // Owner sidecar `<jobId>.owner-<pid>` — a zero-byte marker whose NAME
+        // carries the owning CC host pid, written next to the .json at spawn.
+        const i = n.lastIndexOf('.owner-');
+        if (i > 0) { const pid = positiveInt(n.slice(i + 7)); if (pid) ownerByJob.set(n.slice(0, i), pid); }
+      }
+    }
+    // Owner-filter BEFORE the scan cap, from the directory listing alone: each
+    // job's owning claude.exe pid is read from its `.owner-<pid>` marker name
+    // (no JSON read), so another session's newer jobs can never evict ours at
+    // the cap. Only jobs whose marker pid equals THIS statusline's
+    // --client-host-pid survive; legacy jobs without a marker — and every job
+    // when no host pid was passed (CLIENT_HOST_PID_JOBS absent) — are excluded.
+    // Then ordered newest-first by the spawn timestamp embedded in
+    // `job_<ms>_<rand>`, so truncation drops only this session's oldest tail.
+    const jobStampMs = (id) => { const m = /^job_(\d+)/.exec(id); return m ? Number(m[1]) : 0; };
+    const candidates = jobs
+      .filter((id) => !done.has(id) && CLIENT_HOST_PID_JOBS && ownerByJob.get(id) === CLIENT_HOST_PID_JOBS)
+      .sort((a, b) => jobStampMs(b) - jobStampMs(a));
+    if (candidates.length === 0) return '';
+    const scan = candidates.slice(0, JOB_SCAN_CAP);
+    const truncated = candidates.length > JOB_SCAN_CAP;
+    let count = 0;
+    let oldestMs = Infinity;
+    for (const id of scan) {
+      const p = path.join(dir, `${id}.json`);
+      let pid, tmo, enforced;
+      try {
+        const d = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        pid = d.pid; tmo = Number(d.timeoutMs);
+        // Runtime enforcement proof: PS records timeoutEnforced:true; the
+        // posix wrapper touches <id>.enforced iff its `timeout` branch ran.
+        enforced = d.timeoutEnforced === true || fs.existsSync(path.join(dir, `${id}.enforced`));
+      }
+      catch { continue; } // unreadable/unparseable → skip
+      let st;
+      try { st = fs.statSync(p); }
+      catch { continue; }
+      // Deadline: the wrapper force-kills at timeoutMs, so a job older than
+      // timeoutMs + grace is dead even when its pid was recycled by an
+      // unrelated live process (pid-reuse-proof, mirrors the sweep). Trusted
+      // only when the record proves in-wrapper enforcement (timeoutEnforced).
+      if (enforced && Number.isFinite(tmo) && tmo > 0 && (Date.now() - st.mtimeMs) > tmo + 30 * 60_000) continue;
+      // kill(0, 0) probes the whole process group and "succeeds" — a
+      // malformed pid (0, "", []) must be rejected before the probe.
+      pid = Number(pid);
+      if (!Number.isInteger(pid) || pid <= 0) continue;
+      // Liveness: process.kill(pid, 0) succeeds or throws EPERM → alive;
+      // ESRCH/invalid pid → dead → skip.
+      let alive = false;
+      try { process.kill(pid, 0); alive = true; }
+      catch (e) { alive = e && e.code === 'EPERM'; }
+      if (!alive) continue;
+      count++;
+      if (st.mtimeMs < oldestMs) oldestMs = st.mtimeMs;
+    }
+    if (count === 0) return '';
+    let elapsed = '';
+    if (Number.isFinite(oldestMs)) {
+      const secs = Math.max(0, Math.floor((Date.now() - oldestMs) / 1000));
+      elapsed = secs < 60 ? ` ${secs}s` : ` ${Math.floor(secs / 60)}m`;
+    }
+    // Overflow marker: the scan was capped, so jobs may exist beyond what was
+    // counted — surface a trailing `+` so the figure reads as a lower bound.
+    const overflow = truncated ? '+' : '';
+    return `${GREY}⚙  bash:${count}${overflow}${elapsed}${R}`;
+  } catch { return ''; }
+})();
+if (bashJobsSeg) addL1(bashJobsSeg);
+
+// ── Build L2 ──────────────────────────────────────────────────────────────────
+const l2Parts = [];
+function addL2(seg) { if (seg) l2Parts.push(seg); }
+
+// Work sessions
+if (workCount > 0 && workOrder) {
+  addL2(`${GRN}●${R} ${B}${workCount} Running${R} ${D}(${R}${CYN}${workOrder}${R}${D})${R}`);
+}
+
+if (idleWorkers.length) {
+  // Idle workers: filled grey dot (●) + explicit 'idle' marker + tag list.
+  // Filled (not hollow ○) so the glyph matches the running ● weight; only
+  // the colour (grey vs green) distinguishes idle from running.
+  const idleTags = idleWorkers.join(', ');
+  addL2(`${GREY}● ${idleWorkers.length} idle (${idleTags})${R}`);
+}
+
+// Schedule next
+if (bSchedNextName && schedNextHHMM) {
+  addL2(`${YLW}⏰${R} ${B}${bSchedNextName}${R} ${D}${schedNextHHMM}${R}`);
+}
+
+// Suppress "Idle" fallback (matches bash: if L2 = "Idle" → suppress)
+const l1 = l1Parts.join(` ${SEP} `) || 'mixdog';
+let l2   = l2Parts.join(` ${SEP} `);
+if (l2 === 'Idle') l2 = '';
+
+process.stdout.write(l1 + '\n');
+if (l2) process.stdout.write(l2 + '\n');