@alyibrahim/claude-statusline 1.5.4 → 1.6.1

package/README.md

@@ -34,7 +34,7 @@ Done. The statusline configures itself automatically. Restart Claude Code to see
 
 > If auto-setup didn't run: `claude-statusline setup`
 
-**Plugin install (Claude Code marketplace):** Search for `claude-statusline` in the Claude Code plugin browser. The plugin auto-configures on first session start. To get the native Rust binary after a plugin install, run:
+**Plugin install (Claude Code marketplace):** Search for `claude-statusline` in the Claude Code plugin browser. The plugin auto-configures during installation. To get the native Rust binary after a plugin install, run:
 
 ```bash
 claude-statusline download-binary
@@ -64,6 +64,7 @@ claude-statusline setup
 | Git branch | Detected automatically, silently absent if not a git repo |
 | Session commits | Shows `+N` next to the branch for commits made during the current session |
 | Directory label | Displays as `~/parent/dir` so you always know which project you're in |
+| Terminal wrapping | Lines wrap to fit terminal width — reads `COLUMNS` or `stdout.columns` automatically |
 
 ---
 
@@ -162,6 +163,43 @@ Rows are color-coded by exit reason: green = normal, yellow = interrupted, orang
 
 <div align="center">
 
+## Realtime Renderer
+
+</div>
+
+An optional background process that maintains a persistent Unix socket per terminal, enabling terminal-resize awareness and faster state access. **Disabled by default.**
+
+**Enable** by setting the environment variable (add to your shell profile to persist):
+
+```bash
+export CLAUDE_STATUSLINE_REALTIME=1
+```
+
+Accepted values: `1`, `true`, `TRUE`.
+
+When enabled, the native binary auto-spawns a renderer process the first time it runs in a terminal session. The renderer listens on a Unix socket and persists state to `~/.claude/statusline-state-{tty}.json`. It exits automatically on `session_end` or when explicitly stopped.
+
+**Terminal identification**
+
+Each terminal gets its own renderer, identified by a *TTY slug* derived in priority order from:
+
+1. `CLAUDE_STATUSLINE_TTY` — set this explicitly for a stable, human-readable slug
+2. `TERM_SESSION_ID` — used automatically by terminal emulators that set it
+3. `pid-{PID}` — fallback, changes on each shell restart
+
+**Commands:**
+
+```bash
+claude-statusline realtime-status   # Show renderer state and paths for current terminal
+claude-statusline realtime-stop     # Request renderer shutdown for current terminal
+```
+
+> The realtime renderer is Unix-only. On Windows, the feature flag is silently ignored.
+
+---
+
+<div align="center">
+
 ## Platform support
 
 </div>

package/bin/cli.js

@@ -6,6 +6,7 @@ const config = require('../scripts/config');
 const { getSettingsPath } = config;
 const { spawnSync } = require('child_process');
 const path = require('path');
+const fs = require('fs');
 
 const USAGE = `
 claude-statusline <command>
@@ -16,6 +17,8 @@ Commands:
   download-binary  Download the native binary for this platform
   enable-history   Enable tracking session analytics to JSONL (default on setup)
   disable-history  Remove history tracking hooks from Claude settings
+  realtime-status  Show realtime renderer state for current terminal
+  realtime-stop    Request realtime renderer shutdown for current terminal
   history          Open the session analytics dashboard
                    --mode web|terminal (persist dashboard mode preference)
 `.trim();
@@ -100,6 +103,72 @@ function runHistory() {
   process.exit(child.status || 0);
 }
 
+function runRealtimeStatus() {
+  const paths = config.getRealtimePaths();
+  let registry = null;
+  let state = null;
+
+  try {
+    if (fs.existsSync(paths.registryPath)) {
+      registry = JSON.parse(fs.readFileSync(paths.registryPath, 'utf8'));
+    }
+  } catch (e) {}
+
+  try {
+    if (fs.existsSync(paths.statePath)) {
+      state = JSON.parse(fs.readFileSync(paths.statePath, 'utf8'));
+    }
+  } catch (e) {}
+
+  const summary = {
+    ttySlug: paths.ttySlug,
+    registryPath: paths.registryPath,
+    statePath: paths.statePath,
+    socketPath: paths.socketPath,
+    hasRegistry: !!registry,
+    hasState: !!state,
+    registry,
+    stateEventType: state?.event_type || null,
+    stateUpdatedAt: state?.updated_at_ms || null,
+  };
+
+  console.log(JSON.stringify(summary, null, 2));
+  process.exit(0);
+}
+
+function runRealtimeStop() {
+  const net = require('net');
+  const paths = config.getRealtimePaths();
+  const ts = Date.now();
+  const event = {
+    version: 1,
+    event_type: 'shutdown',
+    tty_slug: paths.ttySlug,
+    updated_at_ms: ts,
+  };
+
+  try {
+    config.atomicWrite(paths.statePath, event);
+  } catch (e) {}
+
+  const done = () => {
+    console.log('✓ Realtime shutdown event sent');
+    process.exit(0);
+  };
+
+  if (fs.existsSync(paths.socketPath)) {
+    const client = net.createConnection(paths.socketPath);
+    client.on('connect', () => {
+      client.write(JSON.stringify(event) + '\n');
+      client.end();
+    });
+    client.on('close', done);
+    client.on('error', done);
+  } else {
+    done();
+  }
+}
+
 const cmd = process.argv[2];
 
 if (cmd === 'setup') {
@@ -161,6 +230,12 @@ if (cmd === 'setup') {
 } else if (cmd === 'history') {
   runHistory();
 
+} else if (cmd === 'realtime-status') {
+  runRealtimeStatus();
+
+} else if (cmd === 'realtime-stop') {
+  runRealtimeStop();
+
 } else if (cmd === undefined) {
   console.log(USAGE);
   process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alyibrahim/claude-statusline",
-  "version": "1.5.4",
+  "version": "1.6.1",
   "description": "Rich statusline for Claude Code — model, context bar, real-time token tracking, git branch, rate limits, and session stats. Rust binary, ~5ms startup.",
   "keywords": [
     "claude",
@@ -58,11 +58,11 @@
     "open": "^10.1.0"
   },
   "optionalDependencies": {
-    "@alyibrahim/claude-statusline-linux-x64": "1.5.4",
-    "@alyibrahim/claude-statusline-linux-arm64": "1.5.4",
-    "@alyibrahim/claude-statusline-darwin-x64": "1.5.4",
-    "@alyibrahim/claude-statusline-darwin-arm64": "1.5.4",
-    "@alyibrahim/claude-statusline-win32-x64": "1.5.4"
+    "@alyibrahim/claude-statusline-linux-x64": "1.6.1",
+    "@alyibrahim/claude-statusline-linux-arm64": "1.6.1",
+    "@alyibrahim/claude-statusline-darwin-x64": "1.6.1",
+    "@alyibrahim/claude-statusline-darwin-arm64": "1.6.1",
+    "@alyibrahim/claude-statusline-win32-x64": "1.6.1"
   },
   "devDependencies": {
     "jest": "^29.0.0"

package/scripts/check-version-alignment.js

@@ -15,7 +15,7 @@ function readCargoVersion(cargoTomlPath) {
 }
 
 function main() {
-  const root = path.resolve(__dirname, '..');
+  const root = process.env.CHECK_VERSIONS_ROOT || path.resolve(__dirname, '..');
   const packageJsonPath = path.join(root, 'package.json');
   const packageLockPath = path.join(root, 'package-lock.json');
   const cargoTomlPath = path.join(root, 'Cargo.toml');
@@ -56,6 +56,11 @@ function main() {
   }
 
   for (const [name, version] of Object.entries(optionalDeps)) {
+    // Each platform package must be pinned to the root version — they are published together.
+    if (version !== expected) {
+      errors.push(`optionalDependencies[${name}] is pinned to ${version}, expected root version ${expected}`);
+    }
+
     const lockRootVersion = lock.packages && lock.packages[''] && lock.packages[''].optionalDependencies
       ? lock.packages[''].optionalDependencies[name]
       : undefined;

package/scripts/config.js

@@ -3,11 +3,43 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-function getSettingsPath() {
+function getClaudeConfigDir() {
   const configDir = process.env.CLAUDE_CONFIG_DIR;
-  const base = (configDir && configDir.trim())
+  return (configDir && configDir.trim())
     ? configDir
     : path.join(os.homedir(), '.claude');
+}
+
+function sanitizeSlug(s) {
+  return String(s || '')
+    .replace(/[^a-zA-Z0-9_-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function getRealtimeTtySlug() {
+  const preferred = [process.env.CLAUDE_STATUSLINE_TTY, process.env.TERM_SESSION_ID];
+  for (const raw of preferred) {
+    const slug = sanitizeSlug(raw || '');
+    if (slug) return slug;
+  }
+  return sanitizeSlug(`pid-${process.pid}`);
+}
+
+function getRealtimePaths() {
+  const claudeDir = getClaudeConfigDir();
+  const ttySlug = getRealtimeTtySlug();
+  return {
+    claudeDir,
+    ttySlug,
+    registryPath: path.join(claudeDir, `statusline-renderer-${ttySlug}.json`),
+    statePath: path.join(claudeDir, `statusline-state-${ttySlug}.json`),
+    socketPath: path.join(claudeDir, `statusline-rt-${ttySlug}.sock`),
+  };
+}
+
+function getSettingsPath() {
+  const base = getClaudeConfigDir();
   return path.join(base, 'settings.json');
 }
 
@@ -40,4 +72,11 @@ function resolveBinary() {
   return binaryPath;
 }
 
-module.exports = { getSettingsPath, atomicWrite, resolveBinary };
+module.exports = {
+  getSettingsPath,
+  atomicWrite,
+  resolveBinary,
+  getClaudeConfigDir,
+  getRealtimeTtySlug,
+  getRealtimePaths,
+};

package/scripts/history.js

@@ -2,7 +2,6 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const open = require('open');
 const { normalizeProjectSlug } = require('./slug-utils');
 
 const JSONL_PATH = path.join(
@@ -165,6 +164,7 @@ async function handleHistory() {
   const tempPath = path.join(os.tmpdir(), 'claude-statusline-dashboard.html');
   fs.writeFileSync(tempPath, html);
   try {
+    const open = require('open');
     await open.default(tempPath);
     console.log(`Dashboard opened: ${tempPath}`);
   } catch (e) {

package/scripts/plugin-autosetup.js

@@ -2,34 +2,49 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { atomicWrite } = require('./config');
+const { atomicWrite, resolveBinary } = require('./config');
 
-// Only meaningful in plugin context — exit silently otherwise
-const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
-if (!pluginRoot) process.exit(0);
+function pluginAutoSetup(pluginRoot = process.env.CLAUDE_PLUGIN_ROOT) {
+  // Only meaningful in plugin context.
+  if (!pluginRoot) return { ok: true, configured: false };
 
-const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
-const settingsPath = path.join(configDir, 'settings.json');
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const settingsPath = path.join(configDir, 'settings.json');
 
-let settings = {};
-try {
-  settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-} catch (e) {}
+  let settings = {};
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (e) {}
 
-// Already configured — nothing to do
-if (settings.statusLine) process.exit(0);
+  // Already configured; leave user config untouched.
+  if (settings.statusLine) return { ok: true, configured: false };
 
-const script = path.join(pluginRoot, 'statusline.js');
-if (!fs.existsSync(script)) process.exit(0);
+  const script = path.join(pluginRoot, 'statusline.js');
+  const binaryPath = resolveBinary();
+  if (!binaryPath && !fs.existsSync(script)) return { ok: true, configured: false };
 
-settings.statusLine = {
-  type: 'command',
-  command: `"${process.execPath}" "${script}"`,
-};
+  const command = binaryPath
+    ? `"${binaryPath}"`
+    : `"${process.execPath}" "${script}"`;
 
-try {
-  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-  atomicWrite(settingsPath, settings);
-} catch (e) {
-  process.exit(0); // Non-fatal — user can run /claude-statusline:setup manually
+  settings.statusLine = {
+    type: 'command',
+    command,
+  };
+
+  try {
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    atomicWrite(settingsPath, settings);
+  } catch (e) {
+    return { ok: true, configured: false }; // Non-fatal.
+  }
+
+  return { ok: true, configured: true };
+}
+
+module.exports = { pluginAutoSetup };
+
+if (require.main === module) {
+  pluginAutoSetup();
+  process.exit(0); // never fail plugin startup
 }

package/scripts/postinstall.js

@@ -3,8 +3,19 @@
 const fs = require('fs');
 const path = require('path');
 const { setup } = require('./setup');
+const { pluginAutoSetup } = require('./plugin-autosetup');
 const config = require('./config');
 try {
+  // Plugin installs run npm scripts in plugin context; configure statusLine once at install time.
+  if (process.env.CLAUDE_PLUGIN_ROOT) {
+    pluginAutoSetup(process.env.CLAUDE_PLUGIN_ROOT);
+    const pluginBinaryPath = config.resolveBinary();
+    if (pluginBinaryPath && process.platform !== 'win32') {
+      try { fs.chmodSync(pluginBinaryPath, 0o755); } catch (e) {}
+    }
+    process.exit(0);
+  }
+
   const result = setup({ force: false });
   if (result.settingsPath === null) process.exit(0); // non-global install, skip silently
 

package/scripts/setup.js

@@ -59,6 +59,9 @@ function setup({ force = false } = {}) {
     } catch (e) {
       return { ok: false, error: 'settings.json contains invalid JSON — fix manually then re-run.' };
     }
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      return { ok: false, error: 'settings.json does not contain a JSON object — fix manually then re-run.' };
+    }
   }
 
   const binaryPath = config.resolveBinary();
@@ -180,6 +183,9 @@ function toggleHistory(enable) {
     } catch (e) {
       return { ok: false, error: 'settings.json contains invalid JSON — fix manually then re-run.' };
     }
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      return { ok: false, error: 'settings.json does not contain a JSON object — fix manually then re-run.' };
+    }
   }
 
   try {
@@ -209,6 +215,9 @@ function getDashboardMode() {
   } catch (e) {
     return { ok: false, error: 'settings.json contains invalid JSON - fix manually then re-run.' };
   }
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+    return { ok: false, error: 'settings.json does not contain a JSON object - fix manually then re-run.' };
+  }
 
   const mode = settings.dashboardMode === 'terminal' ? 'terminal' : 'web';
   return { ok: true, settingsPath, mode };
@@ -227,6 +236,9 @@ function setDashboardMode(mode) {
     } catch (e) {
       return { ok: false, error: 'settings.json contains invalid JSON - fix manually then re-run.' };
     }
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      return { ok: false, error: 'settings.json does not contain a JSON object - fix manually then re-run.' };
+    }
   }
 
   settings.dashboardMode = mode;

package/scripts/uninstall.js

@@ -12,6 +12,9 @@ function uninstall() {
   } catch (e) {
     return { ok: false, error: 'settings.json contains invalid JSON — cannot safely modify.' };
   }
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+    return { ok: false, error: 'settings.json does not contain a JSON object — cannot safely modify.' };
+  }
 
   if (settings.statusLine) {
     delete settings.statusLine;

package/statusline.js

@@ -8,6 +8,135 @@ const os = require('os');
 const { execSync, execFileSync } = require('child_process');
 const { normalizeProjectSlug } = require('./scripts/slug-utils');
 
+function realtimeEnabled() {
+  const v = process.env.CLAUDE_STATUSLINE_REALTIME;
+  return v === '1' || v === 'true' || v === 'TRUE';
+}
+
+function realtimeTtySlug() {
+  const raw = (process.env.CLAUDE_STATUSLINE_TTY || process.env.TERM_SESSION_ID || `pid-${process.pid}`).trim();
+  return raw.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+}
+
+function atomicWrite(filePath, obj) {
+  const tmp = `${filePath}.tmp`;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(tmp, JSON.stringify(obj));
+  fs.renameSync(tmp, filePath);
+}
+
+function emitRealtimeEvent(eventType, payload) {
+  if (!realtimeEnabled()) return;
+  try {
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+    const ttySlug = realtimeTtySlug();
+    const now = Date.now();
+    const statePath = path.join(claudeDir, `statusline-state-${ttySlug}.json`);
+    const registryPath = path.join(claudeDir, `statusline-renderer-${ttySlug}.json`);
+
+    atomicWrite(registryPath, {
+      version: 1,
+      pid: process.pid,
+      tty_slug: ttySlug,
+      heartbeat_at_ms: now,
+      socket_path: path.join(claudeDir, `statusline-rt-${ttySlug}.sock`),
+    });
+
+    atomicWrite(statePath, {
+      version: 1,
+      event_type: eventType,
+      tty_slug: ttySlug,
+      updated_at_ms: now,
+      payload: payload || {},
+    });
+  } catch (_) {
+    // Silent fail - never break statusline rendering
+  }
+}
+
+function stripSgr(s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function visibleLen(s) {
+  return [...stripSgr(String(s))].reduce((sum, ch) => sum + (ch.codePointAt(0) > 0xFFFF ? 2 : 1), 0);
+}
+
+function terminalColumns() {
+  const fromStdout = Number(process.stdout && process.stdout.columns);
+  if (Number.isFinite(fromStdout) && fromStdout > 0) return fromStdout;
+  const fromEnv = Number(process.env.COLUMNS);
+  if (Number.isFinite(fromEnv) && fromEnv > 0) return fromEnv;
+  return null;
+}
+
+function truncateVisible(s, maxVisible) {
+  if (!maxVisible || maxVisible <= 0) return '';
+  if (visibleLen(s) <= maxVisible) return String(s);
+
+  const src = String(s);
+  let out = '';
+  let visible = 0;
+  for (let i = 0; i < src.length;) {
+    if (src[i] === '\x1b' && src[i + 1] === '[') {
+      let j = i + 2;
+      while (j < src.length && /[0-9;]/.test(src[j])) j++;
+      if (j < src.length && /[mGKHFABCDJ]/.test(src[j])) {
+        out += src.slice(i, j + 1);
+        i = j + 1;
+        continue;
+      }
+    }
+
+    const code = src.codePointAt(i);
+    const ch = String.fromCodePoint(code);
+    const width = code > 0xFFFF ? 2 : 1;
+    if (visible + width > maxVisible) break;
+    out += ch;
+    visible += width;
+    i += code > 0xFFFF ? 2 : 1;
+  }
+  return `${out}…\x1b[0m`;
+}
+
+function wrapChunks(chunks, width, sep) {
+  if (!width) return [chunks.join(sep)];
+  if (width < 8) {
+    return chunks.map(c => truncateVisible(c, Math.max(1, width - 1)));
+  }
+
+  const sepLen = visibleLen(sep);
+  const lines = [];
+  let current = '';
+  let currentLen = 0;
+
+  for (const rawChunk of chunks) {
+    const chunk = visibleLen(rawChunk) > width
+      ? truncateVisible(rawChunk, Math.max(1, width - 1))
+      : rawChunk;
+    const chunkLen = visibleLen(chunk);
+
+    if (!current) {
+      current = chunk;
+      currentLen = chunkLen;
+      continue;
+    }
+
+    const needed = currentLen + sepLen + chunkLen;
+    if (needed <= width) {
+      current += `${sep}${chunk}`;
+      currentLen = needed;
+    } else {
+      lines.push(current);
+      current = chunk;
+      currentLen = chunkLen;
+    }
+  }
+
+  if (current) lines.push(current);
+  return lines;
+}
+
 const cmd = process.argv[2];
 if (cmd === 'history') {
   require('./scripts/history').handleHistory().catch(e => {
@@ -18,12 +147,20 @@ if (cmd === 'history') {
 } else if (cmd === 'hook') {
   const hookcmd = process.argv[3];
   if (hookcmd === 'start') {
+    emitRealtimeEvent('session_start', {});
     require('./scripts/history').handleHookStart();
     return;
   } else if (hookcmd === 'end') {
+    emitRealtimeEvent('session_end', {});
     require('./scripts/history').handleHookEnd();
     return;
   }
+} else if (cmd === 'realtime') {
+  const subcmd = process.argv[3];
+  if (subcmd === 'shutdown') {
+    emitRealtimeEvent('shutdown', {});
+    return;
+  }
 }
 
 // Reads cumulative token totals from the session JSONL file, using a byte-offset
@@ -89,6 +226,7 @@ process.stdin.on('end', () => {
   try {
     const sanitize = s => String(s).replace(/\x1b\[[0-9;]*[mGKHFABCDJ]/g, '');
     const data = JSON.parse(input);
+    emitRealtimeEvent('state_update', data);
     const model = sanitize(data.model?.display_name || 'Claude');
     const dir = data.workspace?.current_dir || process.cwd();
     const session = data.session_id || '';
@@ -230,13 +368,14 @@ process.stdin.on('end', () => {
       const fmt = n => n >= 1_000_000 ? (n % 1_000_000 === 0 ? `${n / 1_000_000}M` : `${(n / 1_000_000).toFixed(1)}M`)
                      : n >= 1000     ? `${(n / 1000).toFixed(1)}k`
                      : String(n);
-      tokenDisplay = `\x1b[2m│\x1b[0m \x1b[97m${fmt(totalIn ?? 0)}↓ ${fmt(totalOut ?? 0)}↑\x1b[0m`;
+      tokenDisplay = `\x1b[97m${fmt(totalIn ?? 0)}↓ ${fmt(totalOut ?? 0)}↑\x1b[0m`;
     }
 
     const usageContent = [u7d, u5h].filter(Boolean).join('  ');
-    const line2 = (usageContent || costDisplay || tokenDisplay)
-      ? `\x1b[0m\x1b[32mUsage\x1b[0m \x1b[2m│\x1b[0m ${[usageContent, costDisplay, tokenDisplay].filter(Boolean).join('  ')}`
-      : '';
+    const line2Chunks = ['\x1b[0m\x1b[32mUsage\x1b[0m'];
+    if (usageContent) line2Chunks.push(usageContent);
+    if (costDisplay) line2Chunks.push(costDisplay.trimStart());
+    if (tokenDisplay) line2Chunks.push(tokenDisplay);
     // Effort level: read from env var first, then settings.json, then fall back to
     // model-based default (sonnet-4/opus-4 default to "medium" in Claude Code).
     const effortLetters = { low: 'L', medium: 'M', high: 'H' };
@@ -262,12 +401,17 @@ process.stdin.on('end', () => {
 
     const agentDisplay = activeAgents > 0 ? ` \x1b[0m\x1b[36m↪ ${activeAgents}\x1b[0m` : '';
     const modelDisplay = `\x1b[0m\x1b[94m${model}\x1b[0m` + effortSuffix + agentDisplay;
-    const line1 = task
-      ? `${modelDisplay} \x1b[2m│\x1b[0m \x1b[1m${task}\x1b[0m \x1b[2m│\x1b[0m ${dirDisplay}${ctx}`
-      : `${modelDisplay} \x1b[2m│\x1b[0m ${dirDisplay}${ctx}`;
-    const visibleLen = line1.replace(/\x1b\[[0-9;]*m/g, '').length;
-    const sep = `\x1b[2m${'─'.repeat(visibleLen)}\x1b[0m`;
-    process.stdout.write(line2 ? `${line1}\n${sep}\n${line2}` : line1);
+    const line1Chunks = [modelDisplay];
+    if (task) line1Chunks.push(`\x1b[1m${task}\x1b[0m`);
+    line1Chunks.push(`${dirDisplay}${ctx}`);
+
+    const columns = terminalColumns();
+    const sepToken = ' \x1b[2m│\x1b[0m ';
+    const wrappedLine1 = wrapChunks(line1Chunks, columns, sepToken);
+    const sepLen = wrappedLine1.reduce((max, line) => Math.max(max, visibleLen(line)), 0);
+    const sep = `\x1b[2m${'─'.repeat(sepLen)}\x1b[0m`;
+    const wrappedLine2 = line2Chunks.length > 1 ? wrapChunks(line2Chunks, columns, sepToken) : [];
+    process.stdout.write(wrappedLine2.length ? `${wrappedLine1.join('\n')}\n${sep}\n${wrappedLine2.join('\n')}` : wrappedLine1.join('\n'));
   } catch (e) {
     // Silent fail - don't break statusline on parse errors
   }