@alyibrahim/claude-statusline 1.5.3 → 1.6.0

package/README.md

@@ -34,6 +34,13 @@ 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:
+
+```bash
+claude-statusline download-binary
+claude-statusline setup
+```
+
 ---
 
 <div align="center">
@@ -57,6 +64,7 @@ Done. The statusline configures itself automatically. Restart Claude Code to see
 | 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 |
 
 ---
 
@@ -95,15 +103,17 @@ Data is stored at `~/.claude/statusline-history.jsonl`.
 
 ### Claude Code slash commands
 
-History commands are also available directly inside Claude Code as slash commands:
+Commands are also available directly inside Claude Code as slash commands:
 
 - `/history`
 - `/history-enable`
 - `/history-disable`
 - `/history-mode <web|terminal>`
+- `/download-binary`
 
 Project contributors get these from the repo at `.claude/commands/`.
 Global npm installs copy them to `~/.claude/commands/` automatically.
+Plugin installs include them via the plugin's `commands/` directory.
 
 ### Terminal TUI
 
@@ -153,12 +163,51 @@ 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>
 
 Pre-built Rust binaries are available for **Linux x64/arm64, macOS x64/arm64, and Windows x64**. All Linux distributions (Ubuntu, Arch, Fedora, etc.) are supported. Any other platform falls back to the JS implementation automatically — no action needed.
 
+Plugin installs skip `npm install`, so the binary is not downloaded automatically. Run `claude-statusline download-binary` once to get it.
+
 See [PLATFORMS.md](PLATFORMS.md) for the full compatibility guide, per-platform install instructions, and feature availability table.
 
 ---

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();
@@ -23,7 +26,7 @@ Commands:
 const TERMINAL_FALLBACK_WARNING = [
   '[claude-statusline] terminal mode requires the native binary.',
   'Falling back to web dashboard. To install the binary, run:',
-  '  npm install -g @alyibrahim/claude-statusline'
+  '  claude-statusline download-binary'
 ].join('\n');
 
 function parseHistoryMode(args) {
@@ -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/hooks/hooks.json

@@ -6,7 +6,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "${CLAUDE_NODE_EXEC} \"${CLAUDE_PLUGIN_ROOT}/statusline.js\" hook start"
+            "command": "${CLAUDE_NODE_EXEC} \"${CLAUDE_PLUGIN_ROOT}/statusline.js\" hook start --marker=${HOOK_MARKER}"
           }
         ]
       }
@@ -17,7 +17,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "${CLAUDE_NODE_EXEC} \"${CLAUDE_PLUGIN_ROOT}/statusline.js\" hook end"
+            "command": "${CLAUDE_NODE_EXEC} \"${CLAUDE_PLUGIN_ROOT}/statusline.js\" hook end --marker=${HOOK_MARKER}"
           }
         ]
       }

package/hooks/plugin-setup.json

@@ -6,7 +6,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "${CLAUDE_NODE_EXEC} \"${CLAUDE_PLUGIN_ROOT}/scripts/plugin-autosetup.js\""
+            "command": "${CLAUDE_NODE_EXEC} \"${CLAUDE_PLUGIN_ROOT}/scripts/plugin-autosetup.js\" --marker=${HOOK_MARKER}"
           }
         ]
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alyibrahim/claude-statusline",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "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",
@@ -37,7 +37,8 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
     "preuninstall": "node scripts/preuninstall.js",
-    "test": "jest"
+    "test": "jest",
+    "check-versions": "node scripts/check-version-alignment.js"
   },
   "jest": {
     "testPathIgnorePatterns": [
@@ -57,11 +58,11 @@
     "open": "^10.1.0"
   },
   "optionalDependencies": {
-    "@alyibrahim/claude-statusline-linux-x64": "1.5.2",
-    "@alyibrahim/claude-statusline-linux-arm64": "1.5.2",
-    "@alyibrahim/claude-statusline-darwin-x64": "1.5.2",
-    "@alyibrahim/claude-statusline-darwin-arm64": "1.5.2",
-    "@alyibrahim/claude-statusline-win32-x64": "1.5.2"
+    "@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"
   },
   "devDependencies": {
     "jest": "^29.0.0"

package/scripts/check-version-alignment.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function readCargoVersion(cargoTomlPath) {
+  const content = fs.readFileSync(cargoTomlPath, 'utf8');
+  const match = content.match(/^version\s*=\s*"([^"]+)"/m);
+  return match ? match[1] : null;
+}
+
+function main() {
+  const 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');
+  const pluginJsonPath = path.join(root, '.claude-plugin', 'plugin.json');
+  const marketplaceJsonPath = path.join(root, '.claude-plugin', 'marketplace.json');
+
+  const rootPkg = readJson(packageJsonPath);
+  const lock = readJson(packageLockPath);
+  const cargoVersion = readCargoVersion(cargoTomlPath);
+  const pluginJson = readJson(pluginJsonPath);
+  const marketplaceJson = readJson(marketplaceJsonPath);
+  const optionalDeps = rootPkg.optionalDependencies || {};
+
+  const errors = [];
+  const expected = rootPkg.version;
+
+  if (!expected) {
+    errors.push('package.json is missing a version');
+  }
+
+  if (!cargoVersion) {
+    errors.push('Cargo.toml is missing a version');
+  } else if (cargoVersion !== expected) {
+    errors.push(`Cargo.toml version ${cargoVersion} does not match package.json version ${expected}`);
+  }
+
+  if (!pluginJson.version) {
+    errors.push('.claude-plugin/plugin.json is missing a version');
+  } else if (pluginJson.version !== expected) {
+    errors.push(`.claude-plugin/plugin.json version ${pluginJson.version} does not match package.json version ${expected}`);
+  }
+
+  const marketplaceVersion = marketplaceJson.plugins && marketplaceJson.plugins[0] && marketplaceJson.plugins[0].version;
+  if (!marketplaceVersion) {
+    errors.push('.claude-plugin/marketplace.json is missing plugins[0].version');
+  } else if (marketplaceVersion !== expected) {
+    errors.push(`.claude-plugin/marketplace.json plugins[0].version ${marketplaceVersion} does not match package.json version ${expected}`);
+  }
+
+  for (const [name, version] of Object.entries(optionalDeps)) {
+    const lockRootVersion = lock.packages && lock.packages[''] && lock.packages[''].optionalDependencies
+      ? lock.packages[''].optionalDependencies[name]
+      : undefined;
+    if (lockRootVersion !== version) {
+      errors.push(`package-lock.json root optionalDependencies[${name}] is ${lockRootVersion}, expected ${version}`);
+    }
+    // node_modules entries are only resolved once the package exists on npm.
+    // Pre-publish they contain only { optional: true } — skip the version check in that case.
+    const lockPkg = lock.packages && lock.packages[`node_modules/${name}`];
+    if (lockPkg && lockPkg.version !== undefined && lockPkg.version !== version) {
+      errors.push(`package-lock.json node_modules entry for ${name} is ${lockPkg.version}, expected ${version}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    console.error('[check-versions] Failed version alignment checks:');
+    for (const err of errors) {
+      console.error(`- ${err}`);
+    }
+    process.exit(1);
+  }
+
+  console.log(`[check-versions] OK (version ${expected})`);
+}
+
+main();

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

@@ -3,6 +3,7 @@ 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(
   process.env.HOME || process.env.USERPROFILE || os.homedir(),
@@ -65,7 +66,7 @@ function handleHookEnd() {
 
     const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
     const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
-    const slug = projectDir.replace(/[/\\]/g, '-');
+    const slug = normalizeProjectSlug(projectDir);
     const projectsDir = path.join(home, '.claude', 'projects', slug);
 
     // Read session stats from the most recently modified JSONL in the project dir

package/scripts/setup.js

@@ -5,6 +5,7 @@ const config = require('./config');
 const { getSettingsPath, atomicWrite } = config;
 
 const UNSAFE_CHARS = /["`$!()\\]/;
+const HOOK_MARKER = 'claude-statusline-owned-v1';
 
 function buildNodeExecCommand() {
   return `"${process.execPath}"`;
@@ -108,6 +109,7 @@ function updateHooks(settings, enable, { nodeExecCommand = buildNodeExecCommand(
     const resolved = resolveHooksFromFile(f, {
       CLAUDE_PLUGIN_ROOT: escapedRoot,
       CLAUDE_NODE_EXEC: escapedNodeExec,
+      HOOK_MARKER,
     });
     for (const entries of Object.values(resolved)) {
       for (const entry of entries) {
@@ -122,6 +124,7 @@ function updateHooks(settings, enable, { nodeExecCommand = buildNodeExecCommand(
     const resolvedHooks = resolveHooksFromFile(f, {
       CLAUDE_PLUGIN_ROOT: escapedRoot,
       CLAUDE_NODE_EXEC: escapedNodeExec,
+      HOOK_MARKER,
     });
 
     for (const [event, entries] of Object.entries(resolvedHooks)) {
@@ -133,11 +136,21 @@ function updateHooks(settings, enable, { nodeExecCommand = buildNodeExecCommand(
           const hasOwnedMarker = /claude-statusline|CLAUDE_PLUGIN_ROOT/i.test(cmd);
           return hasScript && hasOwnedMarker;
         };
+        const hasOwnedMarker = cmd => cmd && cmd.includes(`--marker=${HOOK_MARKER}`);
+        const isLegacyStatuslineHook = cmd => {
+          if (!cmd) return false;
+          const isHookSuffix = cmd.endsWith(' hook start') || cmd.endsWith(' hook end');
+          if (!isHookSuffix) return false;
+          // Keep backward compatibility with older commands while avoiding broad suffix-only matches.
+          return /(?:^|\s)(?:statusline|claude-statusline)(?:\s|$)/i.test(cmd);
+        };
         const isOurs = inner => inner.command && (
-          // Suffix match — catches hooks written by older package versions
-          inner.command.endsWith(' hook start') || inner.command.endsWith(' hook end') ||
+          // Marker match — canonical ownership check for new installs.
+          hasOwnedMarker(inner.command) ||
           // Exact match — catches current hooks including plugin-setup entries
           ourCommands.has(inner.command) ||
+          // Backward-compatible statusline suffix match for older package versions.
+          isLegacyStatuslineHook(inner.command) ||
           // Legacy autosetup fallback — catches prior install roots
           isLegacyAutosetup(inner.command)
         );

package/scripts/slug-utils.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function normalizeProjectSlug(projectPath) {
+  return String(projectPath || '').replace(/[/\\]/g, '-');
+}
+
+module.exports = { normalizeProjectSlug };

package/statusline.js

@@ -6,6 +6,136 @@ const fs = require('fs');
 const path = require('path');
 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') {
@@ -17,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
@@ -30,7 +168,7 @@ if (cmd === 'history') {
 // Returns { totalIn, totalOut } or null on any error.
 function readSessionTokens(claudeDir, session, absDir) {
   if (!session) return null;
-  const slug = absDir.replace(/\//g, '-');
+  const slug = normalizeProjectSlug(absDir);
   const jsonlPath = path.join(claudeDir, 'projects', slug, `${session}.jsonl`);
   const cachePath = path.join(claudeDir, `statusline-tokcache-${session}.json`);
   try {
@@ -88,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 || '';
@@ -229,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' };
@@ -261,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
   }