mixdog 0.7.18 → 0.8.0

package/bin/statusline.mjs

@@ -1,638 +0,0 @@
-#!/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';
-import { formatGatewayLimitSegments, loadGatewayStatus } from './statusline-route.mjs';
-import { writeClaudeCodeCurrentSnapshot } from '../src/gateway/claude-current.mjs';
-
-function claudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
-}
-
-function pluginDataDir() {
-  return process.env.CLAUDE_PLUGIN_DATA || path.join(claudeConfigDir(), 'plugins', 'data', 'mixdog-trib-plugin');
-}
-
-// ── 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 = ''; }
-try { writeClaudeCodeCurrentSnapshot(CC_JSON); } catch {}
-
-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(
-      pluginDataDir(), '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(claudeConfigDir(), 'settings.json'), 'utf8'
-    );
-    CC_EFFORT = extract(settingsRaw, /"effortLevel"\s*:\s*"([^"]+)"/);
-  } catch {}
-}
-
-const GATEWAY_STATUS = loadGatewayStatus();
-if (GATEWAY_STATUS) {
-  CC_MODEL = GATEWAY_STATUS.modelDisplay || CC_MODEL;
-  if (GATEWAY_STATUS.contextUsedPct !== null && GATEWAY_STATUS.contextUsedPct !== undefined) {
-    CC_CTX_USED = String(GATEWAY_STATUS.contextUsedPct);
-  } else {
-    CC_CTX_USED = '';
-  }
-  CC_EFFORT = GATEWAY_STATUS.effort || '';
-  if (GATEWAY_STATUS.fast) CC_EFFORT = CC_EFFORT ? `${CC_EFFORT} · FAST` : 'FAST';
-}
-
-// ── 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(claudeConfigDir(), '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(claudeConfigDir(), '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 = pluginDataDir();
-    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}`;
-}
-
-const gatewayLimitSegments = formatGatewayLimitSegments(GATEWAY_STATUS, {
-  COLS, D, R, RED, GRN, YLW, colourPct, epochMsToHHMM,
-});
-
-// 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 (gatewayLimitSegments.length) {
-  for (const seg of gatewayLimitSegments) addL1(seg);
-} else {
-  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(pluginDataDir(), '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');