ctxline-claude 1.5.0 → 1.6.0

package/README.md

@@ -23,7 +23,7 @@
 </p>
 
 <p align="center">
-  <img src="preview.svg" alt="Claude Code Statusline">
+  <img src="docs/assets/preview.svg" alt="Claude Code Statusline">
 </p>
 
 <p align="center">
@@ -77,6 +77,17 @@ chmod +x ~/.claude/hooks/statusline.js
 }
 ```
 
+**Subagent rows.** The same script also renders per-task rows in the agent panel for running subagents — wire it as a separate `subagentStatusLine` command:
+
+```json
+{
+  "subagentStatusLine": {
+    "type": "command",
+    "command": "node ~/.claude/hooks/statusline.js subagent"
+  }
+}
+```
+
 </details>
 
 ## Update

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctxline-claude",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "A customizable statusline for Claude Code that tracks context usage and session limits",
   "bin": {
     "ctxline-claude": "bin/install.js"

package/statusline.js

@@ -54,6 +54,10 @@ const GIT_FRESH_TTL_MS = 5000;          // 5s: reuse counts within a render burs
 const GIT_STALE_TTL_MS = 60000;         // 60s: fall back to last counts if git fails
 const GIT_TIMEOUT_MS = 500;             // hard cap on the rev-list subprocess (warm ~130ms)
 
+// Subagent mode reads only stdin (no usage API to race), so its stdin read gets a
+// short hard cap of its own instead of the main-mode overallTimeout.
+const SUBAGENT_TIMEOUT_MS = 500;
+
 // ANSI color codes
 const colors = {
   reset: '\x1b[0m',
@@ -96,6 +100,19 @@ function shortenModel(name) {
   return name.replace(/\s+context\)/i, ')');
 }
 
+// Shorten a resolved model ID (subagent task.model, e.g. "claude-opus-5") for the
+// subagent row: "claude-opus-5" -> "Opus 5", "claude-haiku-4-5-20251001" -> "Haiku 4.5".
+// Distinct from shortenModel, which trims a display name rather than parsing an ID.
+function shortenModelId(id) {
+  if (!id) return '';
+  const stripped = String(id).replace(/^(us\.)?(anthropic\.)?claude-/, '').replace(/-\d{8}$/, '');
+  const [family, ...rest] = stripped.split('-');
+  if (!family) return stripped;
+  const name = family[0].toUpperCase() + family.slice(1);
+  const version = rest.join('.');
+  return version ? `${name} ${version}` : name;
+}
+
 // Tail-truncate an over-long branch name, preserving the leading ticket ID.
 function truncateBranch(name) {
   return name.length > MAX_BRANCH_LEN ? name.slice(0, MAX_BRANCH_LEN - 1) + '…' : name;
@@ -208,10 +225,11 @@ function formatAheadBehind(ab) {
   return s;
 }
 
-function getContextBar(remaining) {
-  const effectiveRemaining = remaining ?? 100;
-  const used = Math.max(0, Math.min(100, 100 - Math.round(effectiveRemaining)));
-
+// Colored "C<used> <bar>" (e.g. "C45 ███░░░") for an already-clamped 0-100 used
+// percentage. Shared by the main context bar (derived from remaining%) and the
+// subagent row (derived from tokenCount/contextWindowSize) so both use the same
+// thresholds and bar style.
+function renderContextBar(used) {
   const filled = Math.round((used / 100) * BAR_WIDTH);
   const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(BAR_WIDTH - filled);
 
@@ -222,10 +240,15 @@ function getContextBar(remaining) {
   else if (used < 80) color = colors.orange;
   else color = colors.blink + colors.red;
 
-  // Compact label form: "C<used> <bar>" (e.g. "C45 ███░░░"), colored as a whole.
   return `${color}C${used} ${bar}${colors.reset}`;
 }
 
+function getContextBar(remaining) {
+  const effectiveRemaining = remaining ?? 100;
+  const used = Math.max(0, Math.min(100, 100 - Math.round(effectiveRemaining)));
+  return renderContextBar(used);
+}
+
 // Render a compact usage segment from raw data: "<label><pct> ↺ <countdown>"
 // (e.g. "H81 ↺ 2h21m") — no bar. Called on every read (live or cached) so the reset
 // countdown is always recomputed from resetsAt rather than frozen at fetch time.
@@ -682,11 +705,103 @@ function emit(data) {
   });
 }
 
+// now - startTime as "45s" / "4m12s" / "2h5m". '' when startTime is missing/unparseable.
+// Format isn't documented by Claude Code, so accept epoch-seconds, epoch-ms, or an ISO
+// string: numbers below 1e12 are epoch-seconds (today's epoch-seconds ~1.7e9, epoch-ms
+// ~1.7e12 — far enough apart that the threshold is unambiguous for any real timestamp).
+function formatElapsed(startTime) {
+  if (startTime == null) return '';
+  const ms = typeof startTime === 'number' && startTime < 1e12 ? startTime * 1000 : startTime;
+  const start = new Date(ms).getTime();
+  if (Number.isNaN(start)) return '';
+
+  const diffSec = Math.max(0, Math.floor((Date.now() - start) / 1000));
+  const hours = Math.floor(diffSec / 3600);
+  const mins = Math.floor((diffSec % 3600) / 60);
+  const secs = diffSec % 60;
+  if (hours > 0) return `${hours}h${mins}m`;
+  if (mins > 0) return `${mins}m${secs}s`;
+  return `${secs}s`;
+}
+
+// One subagentStatusLine row: "name │ Model · effort │ C<used> <bar> │ ⏱ <elapsed>".
+// Every segment past name is conditional on its source being present/finite.
+function renderSubagentTask(t) {
+  const parts = [t.label || t.name || t.description || 'agent'];
+
+  const model = shortenModelId(t.model);
+  // effort absent = subagent inherits the session effort; show model alone then.
+  const effort = t.effort != null ? String(t.effort) : '';
+  if (model) {
+    parts.push(effort
+      ? `${model}${getEffortColor(effort)} · ${effort}${colors.reset}`
+      : model);
+  } else if (effort) {
+    parts.push(`${getEffortColor(effort)}${effort}${colors.reset}`);
+  }
+
+  if (Number.isFinite(t.tokenCount) && Number.isFinite(t.contextWindowSize) && t.contextWindowSize > 0) {
+    const used = Math.max(0, Math.min(100, Math.round((t.tokenCount / t.contextWindowSize) * 100)));
+    parts.push(renderContextBar(used));
+  }
+
+  const elapsed = formatElapsed(t.startTime);
+  if (elapsed) parts.push(`${colors.dim}⏱ ${elapsed}${colors.reset}`);
+
+  return parts.join(SEGMENT_SEP);
+}
+
+// subagentStatusLine mode: emit one {id, content} JSON line per task with an id, then
+// exit. No usage/git/todos/cache work — the task objects carry everything needed.
+// Bad payload or a task that fails to render -> emit nothing, keeping default
+// rendering for every task, rather than a partial/broken output.
+function emitSubagent(data) {
+  try {
+    const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
+    const out = tasks
+      .filter(t => t && t.id)
+      .map(t => JSON.stringify({ id: t.id, content: renderSubagentTask(t) }))
+      .join('\n');
+    if (out) {
+      // Exit from the write callback: process.exit() would drop output still queued
+      // behind stdout backpressure. A write error (e.g. EPIPE) also lands here — the
+      // callback form reports it instead of throwing, and the answer is the same: exit 0.
+      process.stdout.write(out + '\n', () => process.exit(0));
+      return;
+    }
+  } catch (e) {}
+  process.exit(0);
+}
+
 // Entry point, guarded so tests can require this file to exercise payload parsing
 // directly (the /usage response shape is the easiest thing here to get wrong, and it
 // can't be reached through stdin). Running the script normally is unchanged.
 if (require.main === module) {
-  if (process.stdin.isTTY) {
+  if (process.argv[2] === 'subagent') {
+    if (process.stdin.isTTY) {
+      emitSubagent(null);
+    } else {
+      let input = '';
+      let finished = false;
+
+      // Single guarded exit shared by all three triggers: timeout, stdin 'end', and
+      // stdin 'error' (which can fire before 'end' and would otherwise throw unhandled,
+      // breaking the never-throw contract). Whatever accumulated so far gets rendered.
+      const finish = () => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timeout);
+        emitSubagent(parseInput(input));
+      };
+
+      const timeout = setTimeout(finish, SUBAGENT_TIMEOUT_MS);
+
+      process.stdin.setEncoding('utf8');
+      process.stdin.on('data', chunk => input += chunk);
+      process.stdin.on('end', finish);
+      process.stdin.on('error', finish);
+    }
+  } else if (process.stdin.isTTY) {
     emit(null);
   } else {
     let input = '';