@buckits/claude-statusline 2.3.2 → 3.0.0

package/README.md

@@ -9,7 +9,7 @@
 
 <br>
 
-![Statusline Preview](assets/statusline-preview.svg)
+![Statusline Preview](assets/50-bars.png)
 
 <br>
 
@@ -34,7 +34,7 @@ Claude Code's default statusline is... minimal. You deserve better.
 
 ### 🎨 Gradient Progress Bar
 
-50 segments that smoothly transition through colors as your context fills up. The gradient is calculated relative to the auto-compact threshold, not total capacity—so you always know how close you are to summarization.
+Smoothly transitions through colors as your context fills up. Choose your width during install—Compact (25), Medium (38), Full (50), or Custom (any number 10-100). The gradient is calculated relative to the auto-compact threshold, not total capacity—so you always know how close you are to summarization.
 
 ### ⚡ Auto-Compact Threshold
 
@@ -68,8 +68,9 @@ npx @buckits/claude-statusline
 
 That's it. The installer will:
 1. Ask where to install (global or local)
-2. Copy the statusline script
-3. Configure your settings
+2. Let you choose your progress bar width
+3. Copy the statusline script
+4. Configure your settings
 
 ### Options
 
@@ -92,23 +93,17 @@ npx @buckits/claude-statusline --global --uninstall
 
 ## What It Looks Like
 
-### 🟢 Normal Usage (Green Zone)
+### Compact (25 bars)
 
-![Green Zone](assets/statusline-green.svg)
+![Compact](assets/25-bars.png)
 
-Safe and sound. Plenty of context remaining.
+### Medium (38 bars)
 
-### 🟡 Getting Busy (Yellow Zone)
+![Medium](assets/38-bars.png)
 
-![Yellow Zone](assets/statusline-yellow.svg)
+### Full (50 bars)
 
-Making progress. Keep an eye on that threshold.
-
-### 🔴 Approaching Limit (Red Zone)
-
-![Red Zone](assets/statusline-red.svg)
-
-Getting close to auto-compact. Consider wrapping up or starting fresh.
+![Full](assets/50-bars.png)
 
 ## 🤝 GSD Compatible
 
@@ -125,36 +120,22 @@ npx get-shit-done-cc
 ## Requirements
 
 - **Claude Code CLI** (obviously)
-- **jq** - for JSON parsing ([install guide](https://stedolan.github.io/jq/download/))
-- **Bash** - ships with macOS/Linux
+- **Node.js** >= 14
 - **Git** - for git status features (optional)
 
-### Installing jq
-
-```bash
-# macOS
-brew install jq
-
-# Ubuntu/Debian
-sudo apt install jq
-
-# Windows (via chocolatey)
-choco install jq
-```
-
 ## Manual Installation
 
 If you prefer to install manually:
 
-1. Copy `statusline.sh` to `~/.claude/statusline.sh`
-2. Make it executable: `chmod +x ~/.claude/statusline.sh`
+1. Copy `statusline.js` to `~/.claude/statusline.js`
+2. Make it executable: `chmod +x ~/.claude/statusline.js`
 3. Add to `~/.claude/settings.json`:
 
 ```json
 {
   "statusLine": {
     "type": "command",
-    "command": "/Users/YOUR_USERNAME/.claude/statusline.sh"
+    "command": "/Users/YOUR_USERNAME/.claude/statusline.js --width 50"
   }
 }
 ```
@@ -164,12 +145,11 @@ If you prefer to install manually:
 ### Statusline not showing?
 
 1. Make sure you restarted Claude Code after installation
-2. Check that `jq` is installed: `which jq`
-3. Verify the script is executable: `ls -la ~/.claude/statusline.sh`
+2. Verify the script is executable: `ls -la ~/.claude/statusline.js`
 
 ### Wrong colors?
 
-Your terminal needs to support 256 colors. Most modern terminals do.
+Your terminal needs to support true color (24-bit). Most modern terminals do.
 
 ### Git status not showing?
 

package/bin/install.js

@@ -59,37 +59,10 @@ ${cyan}   ╔═╗╦  ╔═╗╦ ╦╔╦╗╔═╗
    ${bold}The statusline Claude Code deserves${reset} ${dim}v${pkg.version}${reset}
 
    ${dim}───────────────────────────────────────────${reset}
-   ${green}█${reset}${green}█${reset}${yellow}█${reset}${yellow}█${reset}${red}█${reset}${red}█${reset}░░░░⚡░░░  ${dim}Gradient progress • Git status${reset}
+   ${green}██${reset}${yellow}██${reset}${red}██${reset}${dim}░░░░${reset}${red}⚡${reset}${dim}░░░  Gradient progress • Git status${reset}
    ${dim}───────────────────────────────────────────${reset}
 `;
 
-const features = `
-   ${cyan}✦${reset} ${bold}Gradient Progress Bar${reset}
-     50 segments that flow ${green}green${reset} → ${yellow}yellow${reset} → ${red}red${reset}
-     as you approach the context limit
-
-   ${cyan}✦${reset} ${bold}⚡ Auto-Compact Threshold${reset}
-     Red lightning bolt shows exactly where
-     Claude will auto-summarize (78%)
-
-   ${cyan}✦${reset} ${bold}Git Integration${reset}
-     Branch • ${green}✓${reset}/${yellow}●${reset}/${green}✚${reset} status • ${green}↑${reset}ahead ${red}↓${reset}behind
-
-   ${cyan}✦${reset} ${bold}Session Cost Tracking${reset}
-     See your running \$ cost in real-time
-
-   ${cyan}✦${reset} ${bold}2-Line Dashboard${reset}
-     Line 1: 🤖 Model • Cost • Context
-     Line 2: 📁 Project • Branch • Status
-`;
-
-const example = `
-   ${dim}┌─────────────────────────────────────────────────────────────────┐${reset}
-   ${dim}│${reset} 🤖 ${cyan}Opus 4.5${reset} ${green}(\$12.41)${reset} │ [${green}████████${yellow}████${red}██${reset}░░░░░░░⚡░░░░░] ${yellow}62k${reset}/${cyan}200k${reset} ${dim}│${reset}
-   ${dim}│${reset} 📁 ${cyan}my-project${reset} ${magenta}main${reset} ${green}✓${reset} → ${cyan}origin/main${reset} ${green}↑2${reset}               ${dim}│${reset}
-   ${dim}└─────────────────────────────────────────────────────────────────┘${reset}
-`;
-
 // Help text
 if (hasHelp) {
   console.log(banner);
@@ -161,10 +134,10 @@ function uninstall(isGlobal) {
   let removed = false;
 
   // Remove statusline.sh
-  const statuslinePath = path.join(targetDir, 'statusline.sh');
+  const statuslinePath = path.join(targetDir, 'statusline.js');
   if (fs.existsSync(statuslinePath)) {
     fs.unlinkSync(statuslinePath);
-    console.log(`   ${green}✓${reset} Removed statusline.sh`);
+    console.log(`   ${green}✓${reset} Removed statusline.js`);
     removed = true;
   }
 
@@ -174,7 +147,7 @@ function uninstall(isGlobal) {
     const settings = readSettings(settingsPath);
 
     if (settings.statusLine && settings.statusLine.command &&
-        settings.statusLine.command.includes('statusline.sh')) {
+        settings.statusLine.command.includes('statusline.js')) {
       delete settings.statusLine;
       writeSettings(settingsPath, settings);
       console.log(`   ${green}✓${reset} Removed statusline from settings.json`);
@@ -202,7 +175,8 @@ function uninstall(isGlobal) {
 /**
  * Install statusline
  */
-function install(isGlobal) {
+function install(isGlobal, barWidth) {
+  barWidth = barWidth || 50;
   const targetDir = isGlobal ? getGlobalDir() : getLocalDir();
   const locationLabel = isGlobal
     ? targetDir.replace(os.homedir(), '~')
@@ -217,11 +191,11 @@ function install(isGlobal) {
   }
 
   // Copy statusline.sh
-  const statuslineSrc = path.join(__dirname, '..', 'statusline.sh');
-  const statuslineDest = path.join(targetDir, 'statusline.sh');
+  const statuslineSrc = path.join(__dirname, '..', 'statusline.js');
+  const statuslineDest = path.join(targetDir, 'statusline.js');
   fs.copyFileSync(statuslineSrc, statuslineDest);
   fs.chmodSync(statuslineDest, '755');
-  console.log(`   ${green}✓${reset} Installed statusline.sh`);
+  console.log(`   ${green}✓${reset} Installed statusline.js`);
 
   // Update settings.json
   const settingsPath = path.join(targetDir, 'settings.json');
@@ -248,7 +222,7 @@ function install(isGlobal) {
     // Set new format
     settings.statusLine = {
       type: 'command',
-      command: statuslineDest
+      command: statuslineDest + ' --width ' + barWidth
     };
 
     writeSettings(settingsPath, settings);
@@ -276,13 +250,10 @@ function install(isGlobal) {
 function promptLocation() {
   if (!process.stdin.isTTY) {
     console.log(`   ${dim}Non-interactive mode, defaulting to global install${reset}\n`);
-    install(true);
+    install(true, 50);
     return;
   }
 
-  console.log(features);
-  console.log(example);
-
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
@@ -309,12 +280,47 @@ function promptLocation() {
       This project only
 `);
 
-  rl.question(`   Choice ${dim}[1]${reset}: `, (answer) => {
-    answered = true;
-    rl.close();
+  rl.question(`   Choice ${dim}[1]${reset}: `, (locAnswer) => {
+    const isGlobal = (locAnswer.trim() || '1') !== '2';
     console.log('');
-    const choice = answer.trim() || '1';
-    install(choice !== '2');
+    promptWidth(rl, (barWidth) => {
+      answered = true;
+      rl.close();
+      console.log('');
+      install(isGlobal, barWidth);
+    });
+  });
+}
+
+/**
+ * Interactive prompt for bar width
+ */
+function promptWidth(rl, callback) {
+  console.log(`   ${yellow}Progress bar width?${reset}
+
+   ${cyan}1${reset}) ${bold}Compact${reset}  ${dim}[${green}${'██'.repeat(3)}${reset}${dim}${'░'.repeat(19)}${red}ϟ${reset}${dim}${'░'.repeat(3)}]${reset}  ${dim}25 bars${reset}
+   ${cyan}2${reset}) ${bold}Medium${reset}   ${dim}[${green}${'██'.repeat(5)}${reset}${dim}${'░'.repeat(24)}${red}ϟ${reset}${dim}${'░'.repeat(5)}]${reset}  ${dim}38 bars${reset}
+   ${cyan}3${reset}) ${bold}Full${reset}     ${dim}[${green}${'██'.repeat(7)}${reset}${dim}${'░'.repeat(28)}${red}ϟ${reset}${dim}${'░'.repeat(8)}]${reset}  ${dim}50 bars${reset}
+   ${cyan}4${reset}) ${bold}Custom${reset}   ${dim}Enter your own number${reset}
+`);
+
+  rl.question(`   Choice ${dim}[3]${reset}: `, (answer) => {
+    const choice = answer.trim() || '3';
+    const widths = { '1': 25, '2': 38, '3': 50 };
+
+    if (choice === '4') {
+      rl.question(`   Number of bars ${dim}(10-100)${reset}: `, (numAnswer) => {
+        const num = parseInt(numAnswer.trim(), 10);
+        if (num >= 10 && num <= 100) {
+          callback(num);
+        } else {
+          console.log(`   ${yellow}⚠${reset} Invalid number, using default (50)\n`);
+          callback(50);
+        }
+      });
+    } else {
+      callback(widths[choice] || 50);
+    }
   });
 }
 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@buckits/claude-statusline",
-  "version": "2.3.2",
+  "version": "3.0.0",
   "description": "The statusline Claude Code deserves - gradient progress bar, auto-compact threshold marker, git status, cost tracking, 2-line dashboard",
   "bin": {
     "claude-statusline": "bin/install.js"
   },
   "files": [
     "bin/",
-    "statusline.sh"
+    "statusline.js"
   ],
   "keywords": [
     "claude",

package/statusline.js

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Parse --width arg (default 50)
+const widthArgIdx = process.argv.indexOf('--width');
+const BAR_WIDTH = widthArgIdx !== -1 && process.argv[widthArgIdx + 1]
+  ? parseInt(process.argv[widthArgIdx + 1], 10) || 50
+  : 50;
+
+// Read JSON input from stdin
+let inputData = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { inputData += chunk; });
+process.stdin.on('end', () => {
+  try {
+    main(JSON.parse(inputData));
+  } catch (e) {
+    process.exit(1);
+  }
+});
+
+function main(input) {
+  // Extract values from JSON
+  const cwd = (input.workspace && input.workspace.current_dir) || input.cwd || '';
+  const model = (input.model && input.model.display_name) || '';
+
+  // Extract token information from context_window
+  const cw = input.context_window || {};
+  const cu = cw.current_usage || {};
+  const totalInput = Number(cw.total_input_tokens) || 0;
+  const totalOutput = Number(cw.total_output_tokens) || 0;
+  const cacheRead = Number(cu.cache_read_input_tokens) || 0;
+
+  // Total used = input + output + cached tokens being used
+  let usedTokens = totalInput + totalOutput + cacheRead;
+  const maxTokens = Number(cw.context_window_size) || 200000;
+
+  // Use the pre-calculated percentage if available (more accurate)
+  let percent;
+  const percentPrecalc = cw.used_percentage;
+  if (percentPrecalc != null && percentPrecalc !== '') {
+    percent = Math.trunc(Number(percentPrecalc));
+    // Recalculate used_tokens from percentage for display accuracy
+    usedTokens = Math.trunc(maxTokens * percent / 100);
+  } else {
+    // Fallback: calculate percentage from tokens
+    percent = maxTokens > 0 ? Math.trunc(usedTokens * 100 / maxTokens) : 0;
+  }
+
+  // Clamp percent to 0-100
+  if (percent < 0) percent = 0;
+  if (percent > 100) percent = 100;
+
+  // Progress bar settings
+  const barWidth = BAR_WIDTH;
+  const filled = Math.trunc(percent * barWidth / 100);
+
+  // ── Git information ──────────────────────────────────
+  let gitBranch = '';
+  let gitRemote = '';
+  let gitAhead = '';
+  let gitBehind = '';
+  let gitStatusIndicator = '';
+
+  if (cwd) {
+    try {
+      execFileSync('git', ['rev-parse', '--git-dir'], { cwd, stdio: 'pipe' });
+
+      // Branch name
+      try {
+        gitBranch = execFileSync('git', ['branch', '--show-current'],
+          { cwd, encoding: 'utf8', stdio: 'pipe' }).trim();
+      } catch (e) {}
+
+      // Upstream tracking branch
+      let upstream = '';
+      try {
+        upstream = execFileSync('git',
+          ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'],
+          { cwd, encoding: 'utf8', stdio: 'pipe' }).trim();
+        gitRemote = upstream;
+      } catch (e) {}
+
+      // Ahead/behind counts
+      if (upstream) {
+        try {
+          const ab = execFileSync('git',
+            ['rev-list', '--left-right', '--count', 'HEAD...' + upstream],
+            { cwd, encoding: 'utf8', stdio: 'pipe' }).trim();
+          const parts = ab.split(/\s+/);
+          const ahead = parseInt(parts[0], 10);
+          const behind = parseInt(parts[1], 10);
+          if (ahead > 0) gitAhead = String(ahead);
+          if (behind > 0) gitBehind = String(behind);
+        } catch (e) {}
+      }
+
+      // Git status (dirty/staged indicators)
+      try {
+        const porcelain = execFileSync('git', ['status', '--porcelain'],
+          { cwd, encoding: 'utf8', stdio: 'pipe' });
+
+        let hasUnstaged = false;
+        let hasStaged = false;
+
+        if (porcelain) {
+          const lines = porcelain.split('\n');
+          for (const line of lines) {
+            if (!line) continue;
+            // Check for staged changes (first column not space)
+            if (/^[MADRC]/.test(line)) hasStaged = true;
+            // Check for unstaged changes (second column not space, or untracked files)
+            if (/^\?\?/.test(line) || /^.[MD]/.test(line)) hasUnstaged = true;
+          }
+        }
+
+        // Build status indicator
+        if (hasUnstaged && hasStaged) {
+          gitStatusIndicator = '\x1b[1;33m●\x1b[1;32m✚\x1b[0m';  // Both
+        } else if (hasUnstaged) {
+          gitStatusIndicator = '\x1b[1;33m●\x1b[0m';              // Unstaged (yellow)
+        } else if (hasStaged) {
+          gitStatusIndicator = '\x1b[1;32m✚\x1b[0m';              // Staged (green)
+        } else {
+          gitStatusIndicator = '\x1b[1;32m✓\x1b[0m';              // Clean (green)
+        }
+      } catch (e) {}
+    } catch (e) {
+      // Not a git repo — skip git info
+    }
+  }
+
+  // Project name from directory
+  const projectName = cwd ? path.basename(cwd) : '';
+
+  // ── Token formatting ─────────────────────────────────
+
+  // Format tokens for display (e.g., 45.2k/200k)
+  function formatTokens(tokens) {
+    if (tokens >= 1000000) {
+      const millions = Math.trunc(tokens / 1000000);
+      const decimal = Math.trunc((tokens % 1000000) / 100000);
+      return millions + '.' + decimal + 'M';
+    } else if (tokens >= 1000) {
+      const thousands = Math.trunc(tokens / 1000);
+      const decimal = Math.trunc((tokens % 1000) / 100);
+      return thousands + '.' + decimal + 'k';
+    }
+    return String(tokens);
+  }
+
+  // Format tokens without decimals (e.g., 72k/200k)
+  function formatTokensInt(tokens) {
+    if (tokens >= 1000000) {
+      return Math.trunc(tokens / 1000000) + 'M';
+    } else if (tokens >= 1000) {
+      return Math.trunc(tokens / 1000) + 'k';
+    }
+    return String(tokens);
+  }
+
+  const usedFmtInt = formatTokensInt(usedTokens);
+  const maxFmtInt = formatTokensInt(maxTokens);
+
+  // ── Cost ──────────────────────────────────────────────
+  let costDisplay = '';
+  const costUsd = input.cost && input.cost.total_cost_usd;
+  if (costUsd != null && costUsd !== '' && costUsd !== null) {
+    costDisplay = '$' + Number(costUsd).toFixed(2);
+  }
+
+  // ── Tools / Skills / Agents counts ────────────────────
+  const ctx = input.context || {};
+  const skillsCount = Array.isArray(ctx.skills) ? ctx.skills.length : 0;
+  const agentsCount = Array.isArray(ctx.agents) ? ctx.agents.length : 0;
+  const mcpToolsCount = Array.isArray(ctx.mcp_tools) ? ctx.mcp_tools.length : 0;
+  const totalTools = skillsCount + agentsCount + mcpToolsCount;
+  let toolsDisplay = '';
+  if (totalTools > 0) {
+    toolsDisplay = '\uD83D\uDD27 ' + totalTools; // 🔧
+  }
+
+  // ── Background tasks ──────────────────────────────────
+  const bgTasksArr = input.background_tasks || input.running_agents || input.active_tasks;
+  let bgTasksCount = 0;
+  if (bgTasksArr != null) {
+    bgTasksCount = Array.isArray(bgTasksArr) ? bgTasksArr.length : 0;
+  }
+  let bgDisplay = '';
+  if (bgTasksCount > 0) {
+    bgDisplay = '\u231B ' + bgTasksCount; // ⏳
+  }
+
+  // ── Auto-compact threshold ────────────────────────────
+  const AUTO_COMPACT_THRESHOLD = 22;
+  let untilCompact = cw.until_compact != null ? Number(cw.until_compact)
+    : cw.until_auto_compact != null ? Number(cw.until_auto_compact)
+    : null;
+
+  if (untilCompact == null) {
+    const remainingPct = Number(cw.remaining_percentage) || 0;
+    if (remainingPct > AUTO_COMPACT_THRESHOLD) {
+      untilCompact = remainingPct - AUTO_COMPACT_THRESHOLD;
+    } else {
+      untilCompact = 0;
+    }
+  }
+
+  let compactColor = '38;5;46';
+  let compactIndicatorText = '';
+  let compactIndicatorPct = '';
+
+  if (untilCompact && untilCompact !== 0) {
+    if (untilCompact >= 25) compactColor = '38;5;46';
+    else if (untilCompact >= 20) compactColor = '38;5;154';
+    else if (untilCompact >= 15) compactColor = '38;5;226';
+    else if (untilCompact >= 10) compactColor = '38;5;220';
+    else if (untilCompact >= 7) compactColor = '38;5;214';
+    else if (untilCompact >= 4) compactColor = '38;5;208';
+    else compactColor = '38;5;196';
+
+    // Calculate tokens until compact threshold
+    const tokensUntilCompact = Math.trunc(untilCompact * maxTokens / 100);
+    const tokensUntilCompactFmt = formatTokens(tokensUntilCompact);
+
+    // Build indicator with tokens primary (gradient color) and percentage in parens (dim)
+    compactIndicatorText = '\u26A1' + tokensUntilCompactFmt + ' until compact'; // ⚡
+    compactIndicatorPct = '(' + untilCompact + '%)';
+  }
+
+  // ══════════════════════════════════════════════════════
+  // 2-LINE DASHBOARD LAYOUT
+  // ══════════════════════════════════════════════════════
+
+  // LINE 1: Model + Context
+  // Format: Opus 4.5 ($12.01) [███████░░░░░░░░⚡░░░░░] 74k/200k
+
+  const compactThresholdPct = 100 - AUTO_COMPACT_THRESHOLD; // 78%
+  const thresholdPosition = Math.trunc(compactThresholdPct * barWidth / 100);
+
+  // Build unified progress bar with per-bar gradient toward threshold
+  let unifiedBar = '[';
+  let unifiedRightmostColor = '38;2;0;255;0'; // Default green
+
+  // Smooth RGB gradient: green(0,255,0) → yellow(255,255,0) → red(255,0,0)
+  // t = 0.0 → green, t = 0.5 → yellow, t = 1.0 → red
+  function gradientRGB(i) {
+    const t = thresholdPosition > 0 ? i / thresholdPosition : 0;
+    let r, g;
+    if (t <= 0.5) {
+      // Green → Yellow: R ramps up, G stays max
+      r = Math.round(t * 2 * 255);
+      g = 255;
+    } else {
+      // Yellow → Red: R stays max, G ramps down
+      r = 255;
+      g = Math.round((1 - t) * 2 * 255);
+    }
+    return { r, g, b: 0 };
+  }
+
+  for (let i = 0; i < barWidth; i++) {
+    if (i === thresholdPosition) {
+      // Threshold marker: bolt replaces this bar segment
+      if (i < filled) {
+        // Filled: gradient background with contrasting bold white bolt
+        const { r, g, b } = gradientRGB(i);
+        unifiedRightmostColor = '38;2;' + r + ';' + g + ';' + b;
+        unifiedBar += '\x1b[48;2;' + r + ';' + g + ';' + b + ';1;37m\u03DF\x1b[0m';
+      } else {
+        // Not filled: bright red bolt on theme-adaptive dark background
+        unifiedBar += '\x1b[100;38;2;255;0;0m\u03DF\x1b[0m';
+      }
+    } else if (i < filled) {
+      if (i > thresholdPosition) {
+        // Past threshold: always red
+        unifiedRightmostColor = '38;2;255;0;0';
+        unifiedBar += '\x1b[38;2;255;0;0m\u2588\x1b[0m';
+      } else {
+        const { r, g, b } = gradientRGB(i);
+        const color = '38;2;' + r + ';' + g + ';' + b;
+        unifiedRightmostColor = color;
+        unifiedBar += '\x1b[' + color + 'm\u2588\x1b[0m';
+      }
+    } else {
+      unifiedBar += '\u2591'; // ░
+    }
+  }
+
+  unifiedBar += ']';
+
+  // Assemble Line 1
+  let line1 = '';
+
+  // Robot icon and model name in cyan
+  if (model) {
+    line1 += '\uD83E\uDD16 \x1b[1;36m' + model + '\x1b[0m'; // 🤖
+  }
+
+  // Add cost after model name (bright green)
+  if (costDisplay) {
+    line1 += ' \x1b[1;32m(' + costDisplay + ')\x1b[0m';
+  }
+
+  // Add subtle separator between cost and progress bar
+  line1 += ' \x1b[2;37m\u2502\x1b[0m'; // │
+
+  // Add progress bar and tokens to line 1
+  line1 += ' ' + unifiedBar
+    + ' \x1b[' + unifiedRightmostColor + 'm' + usedFmtInt + '\x1b[0m'
+    + '\x1b[1;36m/' + maxFmtInt + '\x1b[0m';
+
+  // LINE 2: Project/Git Info
+  // Format: 📁 myproject main ✓ → origin/main ↑11
+  let line2 = '';
+
+  // Folder icon and project name in cyan
+  if (projectName) {
+    line2 += '\uD83D\uDCC1 \x1b[1;36m' + projectName + '\x1b[0m'; // 📁
+  }
+
+  // Git branch and tracking
+  if (gitBranch) {
+    if (line2) line2 += ' ';
+
+    // Branch in magenta
+    line2 += '\x1b[1;35m' + gitBranch + '\x1b[0m';
+
+    // Git status indicator (after branch name)
+    if (gitStatusIndicator) {
+      line2 += ' ' + gitStatusIndicator;
+    }
+
+    // Arrow and tracking
+    line2 += ' \x1b[2;37m\u2192\x1b[0m'; // →
+
+    if (gitRemote) {
+      // Tracking branch in blue
+      line2 += ' \x1b[1;34m' + gitRemote + '\x1b[0m';
+
+      // Ahead/behind indicators
+      if (gitAhead || gitBehind) {
+        line2 += ' ';
+        if (gitAhead) line2 += '\x1b[0;32m\u2191' + gitAhead + '\x1b[0m'; // ↑
+        if (gitBehind) {
+          if (gitAhead) line2 += ' ';
+          line2 += '\x1b[0;31m\u2193' + gitBehind + '\x1b[0m'; // ↓
+        }
+      }
+    } else {
+      line2 += ' \x1b[2;37m(no upstream)\x1b[0m';
+    }
+  }
+
+  // ── GSD Update check ─────────────────────────────────
+  let gsdUpdateSuffix = '';
+  const gsdCacheFile = path.join(os.homedir(), '.claude', 'cache', 'gsd-update-check.json');
+
+  // Check for GSD in project first, then global
+  let gsdVersionFile = '';
+  if (cwd) {
+    const localGsd = path.join(cwd, '.claude', 'get-shit-done', 'VERSION');
+    if (fs.existsSync(localGsd)) {
+      gsdVersionFile = localGsd;
+    }
+  }
+  if (!gsdVersionFile) {
+    const globalGsd = path.join(os.homedir(), '.claude', 'get-shit-done', 'VERSION');
+    if (fs.existsSync(globalGsd)) {
+      gsdVersionFile = globalGsd;
+    }
+  }
+
+  if (gsdVersionFile) {
+    let installedVer = '';
+    try {
+      installedVer = fs.readFileSync(gsdVersionFile, 'utf8').trim();
+    } catch (e) {}
+    if (!installedVer) installedVer = '0.0.0';
+
+    // Get latest version from cache (populated by SessionStart hook)
+    if (fs.existsSync(gsdCacheFile)) {
+      try {
+        const cache = JSON.parse(fs.readFileSync(gsdCacheFile, 'utf8'));
+        const latestVer = cache.latest || 'unknown';
+
+        // Compare versions - append to line2 if they differ
+        if (latestVer !== 'unknown' && installedVer !== latestVer) {
+          gsdUpdateSuffix = '    |  GSD ' + installedVer + '>' + latestVer;
+        }
+      } catch (e) {}
+    }
+  }
+
+  // Append GSD update to line2 if available
+  line2 += gsdUpdateSuffix;
+
+  // Output the dashboard (2 lines, no trailing newline)
+  process.stdout.write(line1 + '\x1b[K\n' + line2 + '\x1b[K');
+}

package/statusline.sh

@@ -1,437 +0,0 @@
-#!/bin/bash
-
-# Claude Code Status Line Script
-# Read JSON input from stdin
-
-input=$(cat)
-
-# Extract values from JSON
-cwd=$(echo "$input" | jq -r '.workspace.current_dir // .cwd // empty')
-model=$(echo "$input" | jq -r '.model.display_name // empty')
-
-# Extract token information from context_window
-# The actual context usage includes cache tokens from prompt caching
-total_input=$(echo "$input" | jq -r '.context_window.total_input_tokens // 0')
-total_output=$(echo "$input" | jq -r '.context_window.total_output_tokens // 0')
-cache_read=$(echo "$input" | jq -r '.context_window.current_usage.cache_read_input_tokens // 0')
-
-# Total used = input + output + cached tokens being used
-used_tokens=$((total_input + total_output + cache_read))
-max_tokens=$(echo "$input" | jq -r '.context_window.context_window_size // 200000')
-
-# Use the pre-calculated percentage if available (more accurate)
-percent_precalc=$(echo "$input" | jq -r '.context_window.used_percentage // empty')
-if [ -n "$percent_precalc" ]; then
-    percent=$percent_precalc
-    # Recalculate used_tokens from percentage for display accuracy
-    used_tokens=$((max_tokens * percent / 100))
-else
-    # Fallback: calculate percentage from tokens
-    if [ "$max_tokens" -gt 0 ] 2>/dev/null; then
-        percent=$((used_tokens * 100 / max_tokens))
-    else
-        percent=0
-    fi
-fi
-
-# Clamp percent to 0-100
-[ "$percent" -lt 0 ] && percent=0
-[ "$percent" -gt 100 ] && percent=100
-
-# Progress bar settings - 50 squares (4k tokens each for 200k context)
-bar_width=50
-filled=$((percent * bar_width / 100))
-empty=$((bar_width - filled))
-
-# Get color for a specific bar position (0 to bar_width-1)
-# Each bar position gets its own color based on progression
-get_bar_color_for_position() {
-    local pos=$1
-    local total=$2
-    # Calculate percentage for this specific bar position
-    local bar_pct=$((pos * 100 / total))
-
-    if [ "$bar_pct" -le 33 ]; then
-        # Green range: 0-33%
-        # Bright green (46) → yellow-green (154) → green (34)
-        if [ "$bar_pct" -le 16 ]; then
-            echo "38;5;46"  # Bright green
-        elif [ "$bar_pct" -le 25 ]; then
-            echo "38;5;118" # Green-yellow
-        else
-            echo "38;5;154" # Yellow-green
-        fi
-    elif [ "$bar_pct" -le 66 ]; then
-        # Orange range: 34-66%
-        # Yellow (226) → orange (214) → dark orange (208)
-        local adj_pct=$((bar_pct - 33))
-        if [ "$adj_pct" -le 11 ]; then
-            echo "38;5;226" # Yellow
-        elif [ "$adj_pct" -le 22 ]; then
-            echo "38;5;220" # Light orange
-        else
-            echo "38;5;214" # Orange
-        fi
-    else
-        # Red range: 67-100%
-        # Orange-red (208) → red (196) → dark red (160)
-        local adj_pct=$((bar_pct - 66))
-        if [ "$adj_pct" -le 11 ]; then
-            echo "38;5;208" # Orange-red
-        elif [ "$adj_pct" -le 22 ]; then
-            echo "38;5;202" # Red-orange
-        else
-            echo "38;5;196" # Bright red
-        fi
-    fi
-}
-
-# Build progress bar with gradient colors
-# Track the color of the rightmost filled bar for the percentage text
-bar="["
-rightmost_color="38;5;46"  # Default to bright green
-for ((i=0; i<filled; i++)); do
-    bar_color=$(get_bar_color_for_position $i $bar_width)
-    rightmost_color=$bar_color  # Keep updating to track the last one
-    bar+=$(printf "\033[${bar_color}m█\033[0m")
-done
-for ((i=0; i<empty; i++)); do
-    bar+="░"
-done
-bar+="]"
-
-# Get git information if in a git repo
-git_branch=""
-git_remote=""
-if [ -n "$cwd" ] && git -C "$cwd" rev-parse --git-dir >/dev/null 2>&1; then
-    git_branch=$(git -C "$cwd" branch --show-current 2>/dev/null)
-
-    # Get the upstream tracking branch
-    upstream=$(git -C "$cwd" rev-parse --abbrev-ref --symbolic-full-name @{upstream} 2>/dev/null)
-    if [ -n "$upstream" ]; then
-        # upstream will be in format like "origin/POC" or "origin/main"
-        git_remote="$upstream"
-    fi
-
-    # Get ahead/behind counts
-    git_ahead=""
-    git_behind=""
-    if [ -n "$upstream" ]; then
-        # Get number of commits ahead/behind
-        ahead_behind=$(git -C "$cwd" rev-list --left-right --count HEAD...$upstream 2>/dev/null)
-        if [ -n "$ahead_behind" ]; then
-            ahead=$(echo "$ahead_behind" | awk '{print $1}')
-            behind=$(echo "$ahead_behind" | awk '{print $2}')
-            [ "$ahead" -gt 0 ] && git_ahead="$ahead"
-            [ "$behind" -gt 0 ] && git_behind="$behind"
-        fi
-    fi
-
-    # Get git status (dirty/staged indicators)
-    git_status_indicator=""
-    if git -C "$cwd" rev-parse --git-dir >/dev/null 2>&1; then
-        porcelain=$(git -C "$cwd" status --porcelain 2>/dev/null)
-
-        has_unstaged=false
-        has_staged=false
-
-        if [ -n "$porcelain" ]; then
-            # Check for staged changes (first column not space)
-            if echo "$porcelain" | grep -q '^[MADRC]'; then
-                has_staged=true
-            fi
-
-            # Check for unstaged changes (second column not space, or untracked files)
-            if echo "$porcelain" | grep -q '^\?\?' || echo "$porcelain" | grep -q '^.[MD]'; then
-                has_unstaged=true
-            fi
-        fi
-
-        # Build status indicator
-        if [ "$has_unstaged" = true ] && [ "$has_staged" = true ]; then
-            git_status_indicator=$(printf "\033[1;33m●\033[1;32m✚\033[0m")  # Both
-        elif [ "$has_unstaged" = true ]; then
-            git_status_indicator=$(printf "\033[1;33m●\033[0m")  # Unstaged (yellow)
-        elif [ "$has_staged" = true ]; then
-            git_status_indicator=$(printf "\033[1;32m✚\033[0m")  # Staged (green)
-        else
-            git_status_indicator=$(printf "\033[1;32m✓\033[0m")  # Clean (green)
-        fi
-    fi
-fi
-
-# Get project name from directory
-project_name=""
-if [ -n "$cwd" ]; then
-    project_name=$(basename "$cwd")
-fi
-
-# Format tokens for display (e.g., 45.2k/200k)
-format_tokens() {
-    local tokens=$1
-    # Use pure bash arithmetic to avoid bc dependency
-    if [ "$tokens" -ge 1000000 ]; then
-        local millions=$((tokens / 1000000))
-        local remainder=$((tokens % 1000000))
-        local decimal=$((remainder / 100000))
-        printf "%d.%dM" "$millions" "$decimal"
-    elif [ "$tokens" -ge 1000 ]; then
-        local thousands=$((tokens / 1000))
-        local remainder=$((tokens % 1000))
-        local decimal=$((remainder / 100))
-        printf "%d.%dk" "$thousands" "$decimal"
-    else
-        echo "$tokens"
-    fi
-}
-
-# Format tokens without decimals (e.g., 72k/200k)
-format_tokens_int() {
-    local tokens=$1
-    if [ "$tokens" -ge 1000000 ]; then
-        local millions=$((tokens / 1000000))
-        printf "%dM" "$millions"
-    elif [ "$tokens" -ge 1000 ]; then
-        local thousands=$((tokens / 1000))
-        printf "%dk" "$thousands"
-    else
-        echo "$tokens"
-    fi
-}
-
-used_fmt=$(format_tokens $used_tokens)
-max_fmt=$(format_tokens $max_tokens)
-used_fmt_int=$(format_tokens_int $used_tokens)
-max_fmt_int=$(format_tokens_int $max_tokens)
-
-# Extract cost information
-cost_usd=$(echo "$input" | jq -r '.cost.total_cost_usd // empty')
-cost_display=""
-if [ -n "$cost_usd" ] && [ "$cost_usd" != "null" ]; then
-    # Format cost to 2 decimal places
-    cost_display=$(printf "\$%.2f" "$cost_usd")
-fi
-
-# Extract tools/skills/agents counts
-skills_count=$(echo "$input" | jq -r '.context.skills // [] | length')
-agents_count=$(echo "$input" | jq -r '.context.agents // [] | length')
-mcp_tools_count=$(echo "$input" | jq -r '.context.mcp_tools // [] | length')
-total_tools=$((skills_count + agents_count + mcp_tools_count))
-tools_display=""
-if [ "$total_tools" -gt 0 ]; then
-    tools_display=$(printf "🔧 %d" "$total_tools")
-fi
-
-# Extract background tasks (check for various possible field names)
-bg_tasks=$(echo "$input" | jq -r '.background_tasks // .running_agents // .active_tasks // empty | length')
-bg_display=""
-if [ -n "$bg_tasks" ] && [ "$bg_tasks" != "null" ] && [ "$bg_tasks" -gt 0 ]; then
-    bg_display=$(printf "⏳ %d" "$bg_tasks")
-fi
-
-# Extract "until compact" percentage
-# Auto-compact triggers at a threshold (appears to be around 78% usage / 22% remaining)
-# The "until compact" value = remaining_percentage - threshold_remaining
-# If threshold is 22%, and you have 24% remaining, then until_compact = 24% - 22% = 2%
-
-# First check if there's an explicit field (unlikely but worth checking)
-until_compact=$(echo "$input" | jq -r '.context_window.until_compact // .context_window.until_auto_compact // empty')
-
-if [ -z "$until_compact" ]; then
-    # Calculate based on auto-compact threshold
-    # Auto-compact threshold appears to be 22% remaining (78% used)
-    AUTO_COMPACT_THRESHOLD=22
-
-    remaining_pct=$(echo "$input" | jq -r '.context_window.remaining_percentage // 0')
-
-    if [ "$remaining_pct" -gt "$AUTO_COMPACT_THRESHOLD" ]; then
-        until_compact=$((remaining_pct - AUTO_COMPACT_THRESHOLD))
-    else
-        # Already past threshold or at it
-        until_compact=0
-    fi
-fi
-
-compact_indicator=""
-compact_color="38;5;46"
-if [ -n "$until_compact" ] && [ "$until_compact" != "null" ] && [ "$until_compact" != "0" ]; then
-    if [ "$until_compact" -ge 25 ]; then
-        compact_color="38;5;46"
-    elif [ "$until_compact" -ge 20 ]; then
-        compact_color="38;5;154"
-    elif [ "$until_compact" -ge 15 ]; then
-        compact_color="38;5;226"
-    elif [ "$until_compact" -ge 10 ]; then
-        compact_color="38;5;220"
-    elif [ "$until_compact" -ge 7 ]; then
-        compact_color="38;5;214"
-    elif [ "$until_compact" -ge 4 ]; then
-        compact_color="38;5;208"
-    else
-        compact_color="38;5;196"
-    fi
-
-    # Calculate tokens until compact threshold
-    # Auto-compact threshold is 22% remaining (78% used)
-    # Tokens until compact = until_compact * context_window_size / 100
-    remaining_pct=$(echo "$input" | jq -r '.context_window.remaining_percentage // 0')
-    tokens_until_compact=$((until_compact * max_tokens / 100))
-    tokens_until_compact_fmt=$(format_tokens $tokens_until_compact)
-
-    # Build indicator with tokens primary (gradient color) and percentage in parens (dim)
-    compact_indicator_text=$(printf "⚡%s until compact" "$tokens_until_compact_fmt")
-    compact_indicator_pct=$(printf "(%d%%)" "$until_compact")
-fi
-
-# ==========================================
-# 2-LINE DASHBOARD LAYOUT
-# ==========================================
-
-# LINE 1: Model + Context
-# Format: Opus 4.5 ($12.01) [███████░░░░░░░░⚡░░░░░] 74k/200k
-line1=""
-
-# Robot icon and model name in cyan
-if [ -n "$model" ]; then
-    line1+=$(printf "🤖 \033[1;36m%s\033[0m" "$model")
-fi
-
-# Add cost after model name (bright green)
-if [ -n "$cost_display" ]; then
-    line1+=$(printf " \033[1;32m(%s)\033[0m" "$cost_display")
-fi
-
-# Add subtle separator between cost and progress bar
-line1+=$(printf " \033[2;37m│\033[0m")
-
-# Build progress bar for line 1
-# Calculate compact threshold position (78% of bar = 22% remaining)
-AUTO_COMPACT_THRESHOLD=22
-compact_threshold_pct=$((100 - AUTO_COMPACT_THRESHOLD))  # 78%
-threshold_position=$((compact_threshold_pct * bar_width / 100))
-
-# Build unified progress bar with per-bar gradient toward threshold
-unified_bar="["
-unified_rightmost_color="38;5;46"  # Default green
-
-for ((i=0; i<bar_width; i++)); do
-    if [ "$i" -eq "$threshold_position" ]; then
-        # Insert red lightning bolt threshold marker
-        unified_bar+=$(printf "\033[0;31m⚡\033[0m")
-    fi
-
-    if [ "$i" -lt "$filled" ]; then
-        # Calculate color for this specific bar position
-        # Gradient from green (position 0) to red (threshold position)
-        if [ "$threshold_position" -gt 0 ]; then
-            bar_position_pct=$((i * 100 / threshold_position))
-        else
-            bar_position_pct=0
-        fi
-
-        # Map position percentage to gradient colors
-        if [ "$bar_position_pct" -le 20 ]; then
-            bar_color="38;5;46"   # Bright green
-        elif [ "$bar_position_pct" -le 40 ]; then
-            bar_color="38;5;118"  # Green-yellow
-        elif [ "$bar_position_pct" -le 60 ]; then
-            bar_color="38;5;154"  # Yellow-green
-        elif [ "$bar_position_pct" -le 70 ]; then
-            bar_color="38;5;226"  # Yellow
-        elif [ "$bar_position_pct" -le 80 ]; then
-            bar_color="38;5;220"  # Light orange
-        elif [ "$bar_position_pct" -le 90 ]; then
-            bar_color="38;5;214"  # Orange
-        elif [ "$bar_position_pct" -le 95 ]; then
-            bar_color="38;5;208"  # Orange-red
-        else
-            bar_color="38;5;196"  # Red
-        fi
-
-        unified_rightmost_color=$bar_color
-        unified_bar+=$(printf "\033[${bar_color}m█\033[0m")
-    else
-        unified_bar+="░"
-    fi
-done
-
-unified_bar+="]"
-
-# Add progress bar and tokens to line 1
-line1+=$(printf " %s \033[${unified_rightmost_color}m%s\033[0m\033[1;36m/%s\033[0m" "$unified_bar" "$used_fmt_int" "$max_fmt_int")
-
-# LINE 2: Project/Git Info
-# Format: 📁 trellis POC → origin/POC ↑11
-line2=""
-
-# Folder icon and project name in cyan
-if [ -n "$project_name" ]; then
-    line2+=$(printf "📁 \033[1;36m%s\033[0m" "$project_name")
-fi
-
-# Git branch and tracking
-if [ -n "$git_branch" ]; then
-    [ -n "$line2" ] && line2+=" "
-
-    # Branch in magenta
-    line2+=$(printf "\033[1;35m%s\033[0m" "$git_branch")
-
-    # Git status indicator (after branch name)
-    if [ -n "$git_status_indicator" ]; then
-        line2+=$(printf " %s" "$git_status_indicator")
-    fi
-
-    # Arrow and tracking
-    line2+=$(printf " \033[2;37m→\033[0m")
-
-    if [ -n "$git_remote" ]; then
-        # Tracking branch in blue
-        line2+=$(printf " \033[1;34m%s\033[0m" "$git_remote")
-
-        # Ahead/behind indicators
-        if [ -n "$git_ahead" ] || [ -n "$git_behind" ]; then
-            line2+=" "
-            [ -n "$git_ahead" ] && line2+=$(printf "\033[0;32m↑%s\033[0m" "$git_ahead")
-            if [ -n "$git_behind" ]; then
-                [ -n "$git_ahead" ] && line2+=" "
-                line2+=$(printf "\033[0;31m↓%s\033[0m" "$git_behind")
-            fi
-        fi
-    else
-        line2+=$(printf " \033[2;37m(no upstream)\033[0m")
-    fi
-fi
-
-# GSD Update check (appended to line 2 if update available)
-gsd_update_suffix=""
-gsd_cache_file="$HOME/.claude/cache/gsd-update-check.json"
-
-# Check for GSD in project first, then global
-gsd_version_file=""
-if [ -n "$cwd" ] && [ -f "$cwd/.claude/get-shit-done/VERSION" ]; then
-    gsd_version_file="$cwd/.claude/get-shit-done/VERSION"
-elif [ -f "$HOME/.claude/get-shit-done/VERSION" ]; then
-    gsd_version_file="$HOME/.claude/get-shit-done/VERSION"
-fi
-
-if [ -n "$gsd_version_file" ]; then
-    # Read installed version directly from the VERSION file we found
-    installed_ver=$(cat "$gsd_version_file" 2>/dev/null | tr -d '[:space:]')
-    [ -z "$installed_ver" ] && installed_ver="0.0.0"
-
-    # Get latest version from cache (populated by SessionStart hook)
-    if [ -f "$gsd_cache_file" ]; then
-        latest_ver=$(jq -r '.latest // "unknown"' "$gsd_cache_file" 2>/dev/null)
-
-        # Compare versions - append to line2 if they differ
-        if [ "$latest_ver" != "unknown" ] && [ "$installed_ver" != "$latest_ver" ]; then
-            gsd_update_suffix=$(printf "    |  GSD %s>%s" "$installed_ver" "$latest_ver")
-        fi
-    fi
-fi
-
-# Append GSD update to line2 if available
-line2+="$gsd_update_suffix"
-
-# Output the dashboard (2 lines, no trailing newline)
-printf "%s\033[K\n%s\033[K" "$line1" "$line2"