claude-best-statusline 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 [Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# Claude Code Enhanced Statusline
+
+![preview](preview.png)
+
+A real-time statusline for [Claude Code](https://github.com/anthropics/claude-code) that shows your current directory, model, context window usage, and session token limits at a glance. One script, zero config. Auto-detects subscription vs API key.
+
+## Why This Statusline
+
+There are only two things that really matter when vibe-coding: **Context Window** and **Usage** left in your session. Context matters because models have been shown to perform worse as context grows (context rot), and usage matters so you can squeeze every last token out of your session instead of leaving value on the table. This statusline keeps both front and center so you can focus on building.
+
+## Requirements
+
+- [Claude Code](https://github.com/anthropics/claude-code) installed
+- Node.js (comes with Claude Code)
+- Authenticated Claude account (for usage tracking on subscription plans)
+
+## Installation
+
+### Quick Install (Recommended)
+
+```bash
+npx claude-best-statusline
+```
+
+Or with bun:
+
+```bash
+bunx claude-best-statusline
+```
+
+Restart Claude Code or start a new session.
+
+### Clone & Install
+
+```bash
+git clone https://github.com/TahaSabir0/claude-statusline.git
+cd claude-statusline
+
+# macOS / Linux
+./install.sh
+
+# Windows (PowerShell)
+./install.ps1
+```
+
+### Manual Install
+
+1. **Download the script:**
+
+   ```bash
+   curl -o ~/.claude/hooks/statusline.js https://raw.githubusercontent.com/TahaSabir0/claude-statusline/main/statusline.js
+   ```
+
+2. **Make it executable:**
+
+   ```bash
+   chmod +x ~/.claude/hooks/statusline.js
+   ```
+
+3. **Update Claude Code settings:**
+
+   Edit `~/.claude/settings.json` and add/modify the `statusLine` section:
+
+   ```json
+   {
+     "statusLine": {
+       "type": "command",
+       "command": "node ~/.claude/hooks/statusline.js"
+     }
+   }
+   ```
+
+4. **Restart Claude Code** or start a new session.
+
+## Features
+
+- **Context Usage**: Visual bar showing token usage (green → yellow → orange → red)
+- **API Usage**: Real-time 5-hour session limit tracking with countdown timer (subscription users)
+- **Current Directory**: Shows your working directory
+- **Model Name**: Displays which Claude model you're using (Opus, Sonnet, Haiku)
+- **Auto-Detection**: Detects API key vs subscription and adapts automatically
+- **Adaptive Performance**: Fast after first prompt (1.2s vs 1.5s)
+- **Smart Caching**: Shares usage data across sessions, fallback on API timeout
+
+**Color Coding:**
+
+- 🟢 Green: < 50% usage
+- 🟡 Yellow: 50-75% usage
+- 🟠 Orange: 75-90% usage
+- 🔴 Red (blinking): > 90% usage
+
+## How It Works
+
+### Adaptive Timing
+
+- **First prompt**: Uses 1500ms timeout (cold start, OAuth validation)
+- **Subsequent prompts**: Uses 1200ms timeout (faster, connection reused)
+- **Result**: Smooth experience after initial setup
+
+### Caching System
+
+- Usage data is cached for 30 seconds in `~/.claude/cache/usage-cache.json`
+- All sessions share the same cache
+- If API call times out, shows cached data (no lag)
+
+### API Usage
+
+- Fetches from `https://api.anthropic.com/api/oauth/usage`
+- Tracks 5-hour session limits
+- Shows percentage used + time until reset
+- Fails gracefully (no statusline breakage)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Credits
+
+Created by [@TahaSabir0](https://github.com/TahaSabir0)
+
+Built for the [Claude Code](https://github.com/anthropics/claude-code) community.
+
+---
+
+**Star ⭐ this repo if you find it useful!**

package/bin/install.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const claudeDir = path.join(os.homedir(), '.claude');
+const hooksDir = path.join(claudeDir, 'hooks');
+const settingsFile = path.join(claudeDir, 'settings.json');
+const scriptDest = path.join(hooksDir, 'statusline.js');
+const scriptSrc = path.join(__dirname, '..', 'statusline.js');
+
+const green = '\x1b[32m';
+const red = '\x1b[31m';
+const yellow = '\x1b[33m';
+const cyan = '\x1b[36m';
+const reset = '\x1b[0m';
+
+console.log(`${cyan}======================================${reset}`);
+console.log(`${cyan}  Claude Code Statusline Installer${reset}`);
+console.log(`${cyan}======================================${reset}\n`);
+
+// Check Claude Code is installed
+if (!fs.existsSync(claudeDir)) {
+  console.log(`${red}Error: Claude Code not found!${reset}`);
+  console.log('Please install Claude Code first: https://github.com/anthropics/claude-code');
+  process.exit(1);
+}
+
+// Create hooks directory
+if (!fs.existsSync(hooksDir)) {
+  fs.mkdirSync(hooksDir, { recursive: true });
+}
+
+// Copy statusline script
+console.log(`${yellow}Installing statusline...${reset}`);
+fs.copyFileSync(scriptSrc, scriptDest);
+fs.chmodSync(scriptDest, 0o755);
+console.log(`${green}✓ Installed statusline.js${reset}`);
+
+// Update settings.json
+console.log(`${yellow}Updating settings...${reset}`);
+
+let settings = {};
+if (fs.existsSync(settingsFile)) {
+  // Backup existing settings
+  const backup = `${settingsFile}.backup.${Date.now()}`;
+  fs.copyFileSync(settingsFile, backup);
+  console.log(`${green}✓ Backed up existing settings${reset}`);
+
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+  } catch (e) {
+    settings = {};
+  }
+}
+
+settings.statusLine = {
+  type: 'command',
+  command: `node ${scriptDest.replace(/\\/g, '/')}`
+};
+
+fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+console.log(`${green}✓ Updated settings.json${reset}`);
+
+console.log(`\n${green}======================================${reset}`);
+console.log(`${green}  Installation Complete!${reset}`);
+console.log(`${green}======================================${reset}`);
+console.log('\nRestart Claude Code or start a new session.');
+console.log('The statusline will auto-detect your setup (subscription vs API key).\n');

package/install.ps1

@@ -0,0 +1,112 @@
+# Claude Code Enhanced Statusline - Windows PowerShell Installation Script
+
+$ErrorActionPreference = "Stop"
+
+$HOOKS_DIR = "$env:USERPROFILE\.claude\hooks"
+$SETTINGS_FILE = "$env:USERPROFILE\.claude\settings.json"
+$REPO_URL = "https://raw.githubusercontent.com/TahaSabir0/claude-statusline/main"
+
+Write-Host "======================================" -ForegroundColor Cyan
+Write-Host "  Claude Code Statusline Installer" -ForegroundColor Cyan
+Write-Host "======================================" -ForegroundColor Cyan
+Write-Host ""
+
+# Check if Claude Code is installed
+if (-not (Test-Path "$env:USERPROFILE\.claude")) {
+    Write-Host "Error: Claude Code not found!" -ForegroundColor Red
+    Write-Host "Please install Claude Code first: https://github.com/anthropics/claude-code"
+    exit 1
+}
+
+# Create hooks directory if it doesn't exist
+New-Item -ItemType Directory -Force -Path $HOOKS_DIR | Out-Null
+
+# Prompt user for version choice
+Write-Host "Which version would you like to install?"
+Write-Host "  1) Full version (with API usage tracking)"
+Write-Host "  2) Lite version (faster, no API calls)"
+Write-Host ""
+$choice = Read-Host "Enter your choice (1 or 2)"
+
+switch ($choice) {
+    "1" {
+        $SCRIPT_NAME = "statusline.js"
+        $VERSION_NAME = "Full version"
+    }
+    "2" {
+        $SCRIPT_NAME = "statusline-lite.js"
+        $VERSION_NAME = "Lite version"
+    }
+    default {
+        Write-Host "Invalid choice. Exiting." -ForegroundColor Red
+        exit 1
+    }
+}
+
+# Download the script
+Write-Host ""
+Write-Host "Downloading $VERSION_NAME..." -ForegroundColor Yellow
+
+try {
+    $url = "$REPO_URL/$SCRIPT_NAME"
+    $output = "$HOOKS_DIR\$SCRIPT_NAME"
+    Invoke-WebRequest -Uri $url -OutFile $output -UseBasicParsing
+    Write-Host "✓ Downloaded and installed $SCRIPT_NAME" -ForegroundColor Green
+} catch {
+    Write-Host "Error downloading script: $_" -ForegroundColor Red
+    exit 1
+}
+
+# Update settings.json
+Write-Host ""
+Write-Host "Updating Claude Code settings..." -ForegroundColor Yellow
+
+# Backup existing settings
+if (Test-Path $SETTINGS_FILE) {
+    $timestamp = Get-Date -Format "yyyyMMddHHmmss"
+    Copy-Item $SETTINGS_FILE "$SETTINGS_FILE.backup.$timestamp"
+    Write-Host "✓ Backed up existing settings" -ForegroundColor Green
+}
+
+# Read or create settings
+$settings = @{}
+if (Test-Path $SETTINGS_FILE) {
+    try {
+        $settings = Get-Content $SETTINGS_FILE | ConvertFrom-Json -AsHashtable
+    } catch {
+        # If parsing fails, start with empty settings
+        $settings = @{}
+    }
+}
+
+# Update statusLine setting (use forward slashes for cross-platform compatibility)
+$commandPath = "$HOOKS_DIR\$SCRIPT_NAME" -replace '\\', '/'
+$settings.statusLine = @{
+    type = "command"
+    command = "node $commandPath"
+}
+
+# Write back to file
+$settings | ConvertTo-Json -Depth 10 | Set-Content $SETTINGS_FILE
+Write-Host "✓ Updated settings.json" -ForegroundColor Green
+
+# Success message
+Write-Host ""
+Write-Host "======================================" -ForegroundColor Green
+Write-Host "  Installation Complete! ✓" -ForegroundColor Green
+Write-Host "======================================" -ForegroundColor Green
+Write-Host ""
+Write-Host "Next steps:"
+Write-Host "  1. Restart Claude Code or start a new session"
+Write-Host "  2. Your statusline should now be active!"
+Write-Host ""
+Write-Host "To switch versions:"
+Write-Host "  - Run this installer again, or"
+Write-Host "  - Edit ~/.claude/settings.json manually"
+Write-Host ""
+Write-Host "To uninstall:"
+Write-Host "  - Remove ~/.claude/hooks/$SCRIPT_NAME"
+Write-Host "  - Remove the 'statusLine' section from ~/.claude/settings.json"
+Write-Host ""
+Write-Host "For help, visit: https://github.com/TahaSabir0/claude-statusline"
+Write-Host ""

package/install.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+# Claude Code Enhanced Statusline - Installation Script
+
+set -e
+
+HOOKS_DIR="$HOME/.claude/hooks"
+SETTINGS_FILE="$HOME/.claude/settings.json"
+REPO_URL="https://raw.githubusercontent.com/TahaSabir0/claude-statusline/main"
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+echo "======================================"
+echo "  Claude Code Statusline Installer"
+echo "======================================"
+echo ""
+
+# Check if Claude Code is installed
+if [ ! -d "$HOME/.claude" ]; then
+    echo -e "${RED}Error: Claude Code not found!${NC}"
+    echo "Please install Claude Code first: https://github.com/anthropics/claude-code"
+    exit 1
+fi
+
+# Create hooks directory if it doesn't exist
+mkdir -p "$HOOKS_DIR"
+
+# Prompt user for version choice
+echo "Which version would you like to install?"
+echo "  1) Full version (with API usage tracking)"
+echo "  2) Lite version (faster, no API calls)"
+echo ""
+read -p "Enter your choice (1 or 2): " choice
+
+case $choice in
+    1)
+        SCRIPT_NAME="statusline.js"
+        VERSION_NAME="Full version"
+        ;;
+    2)
+        SCRIPT_NAME="statusline-lite.js"
+        VERSION_NAME="Lite version"
+        ;;
+    *)
+        echo -e "${RED}Invalid choice. Exiting.${NC}"
+        exit 1
+        ;;
+esac
+
+# Download the script
+echo ""
+echo -e "${YELLOW}Downloading $VERSION_NAME...${NC}"
+
+if command -v curl &> /dev/null; then
+    curl -fsSL "$REPO_URL/$SCRIPT_NAME" -o "$HOOKS_DIR/$SCRIPT_NAME"
+elif command -v wget &> /dev/null; then
+    wget -q "$REPO_URL/$SCRIPT_NAME" -O "$HOOKS_DIR/$SCRIPT_NAME"
+else
+    echo -e "${RED}Error: Neither curl nor wget found. Please install one of them.${NC}"
+    exit 1
+fi
+
+# Make executable
+chmod +x "$HOOKS_DIR/$SCRIPT_NAME"
+
+echo -e "${GREEN}✓ Downloaded and installed $SCRIPT_NAME${NC}"
+
+# Update settings.json
+echo ""
+echo -e "${YELLOW}Updating Claude Code settings...${NC}"
+
+# Backup existing settings
+if [ -f "$SETTINGS_FILE" ]; then
+    cp "$SETTINGS_FILE" "$SETTINGS_FILE.backup.$(date +%s)"
+    echo -e "${GREEN}✓ Backed up existing settings${NC}"
+fi
+
+# Check if settings.json exists
+if [ ! -f "$SETTINGS_FILE" ]; then
+    # Create new settings file
+    cat > "$SETTINGS_FILE" << EOF
+{
+  "statusLine": {
+    "type": "command",
+    "command": "node $HOOKS_DIR/$SCRIPT_NAME"
+  }
+}
+EOF
+    echo -e "${GREEN}✓ Created new settings.json${NC}"
+else
+    # Update existing settings.json using node
+    node << EOF
+const fs = require('fs');
+const path = require('path');
+
+const settingsPath = path.join(process.env.HOME, '.claude', 'settings.json');
+let settings = {};
+
+try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+} catch (e) {
+    // File doesn't exist or is invalid JSON
+}
+
+settings.statusLine = {
+    type: 'command',
+    command: 'node $HOOKS_DIR/$SCRIPT_NAME'
+};
+
+fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+console.log('Settings updated successfully');
+EOF
+
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}✓ Updated settings.json${NC}"
+    else
+        echo -e "${RED}✗ Failed to update settings.json automatically${NC}"
+        echo ""
+        echo "Please manually add this to $SETTINGS_FILE:"
+        echo ""
+        echo '  "statusLine": {'
+        echo '    "type": "command",'
+        echo "    \"command\": \"node $HOOKS_DIR/$SCRIPT_NAME\""
+        echo '  }'
+    fi
+fi
+
+# Success message
+echo ""
+echo -e "${GREEN}======================================"
+echo "  Installation Complete! ✓"
+echo "======================================${NC}"
+echo ""
+echo "Next steps:"
+echo "  1. Restart Claude Code or start a new session"
+echo "  2. Your statusline should now be active!"
+echo ""
+echo "To switch versions:"
+echo "  - Run this installer again, or"
+echo "  - Edit ~/.claude/settings.json manually"
+echo ""
+echo "To uninstall:"
+echo "  - Remove ~/.claude/hooks/$SCRIPT_NAME"
+echo "  - Remove the 'statusLine' section from ~/.claude/settings.json"
+echo ""
+echo "For help, visit: https://github.com/TahaSabir0/claude-statusline"
+echo ""

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "claude-best-statusline",
+  "version": "1.0.0",
+  "description": "A customizable statusline for Claude Code that tracks context usage and session limits",
+  "bin": {
+    "claude-best-statusline": "bin/install.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "vibe-coding",
+    "context-window"
+  ],
+  "author": "TahaSabir0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TahaSabir0/claude-statusline"
+  }
+}

package/statusline.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+// Claude Code Enhanced Statusline
+// Shows: directory | model | context usage | API usage (5-hour limit) | current task
+// Auto-detects API key vs subscription usage
+// https://github.com/TahaSabir0/claude-statusline
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+
+const IS_API_KEY = !!process.env.ANTHROPIC_API_KEY;
+
+// Cache configuration
+const CACHE_DIR = path.join(os.homedir(), '.claude', 'cache');
+const USAGE_CACHE_FILE = path.join(CACHE_DIR, 'usage-cache.json');
+const CACHE_TTL_MS = 30000; // Cache valid for 30 seconds
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  orange: '\x1b[38;5;208m',
+  red: '\x1b[31m',
+  blink: '\x1b[5m'
+};
+
+function getUsageColor(percentage) {
+  if (percentage < 50) return colors.green;
+  if (percentage < 75) return colors.yellow;
+  if (percentage < 90) return colors.orange;
+  return colors.red;
+}
+
+function getContextBar(remaining) {
+  const effectiveRemaining = remaining ?? 89;
+  const used = Math.max(0, Math.min(100, 100 - Math.round(effectiveRemaining)));
+
+  const filled = Math.floor(used / 10);
+  const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
+
+  let coloredBar;
+  if (used < 50) {
+    coloredBar = `${colors.green}${bar} ${used}%${colors.reset}`;
+  } else if (used < 65) {
+    coloredBar = `${colors.yellow}${bar} ${used}%${colors.reset}`;
+  } else if (used < 80) {
+    coloredBar = `${colors.orange}${bar} ${used}%${colors.reset}`;
+  } else {
+    coloredBar = `${colors.blink}${colors.red}\u{1F480} ${bar} ${used}%${colors.reset}`;
+  }
+
+  return coloredBar;
+}
+
+// Read cached usage data
+function getCachedUsage() {
+  try {
+    if (!fs.existsSync(USAGE_CACHE_FILE)) return null;
+
+    const cache = JSON.parse(fs.readFileSync(USAGE_CACHE_FILE, 'utf8'));
+    const age = Date.now() - cache.timestamp;
+
+    // Return cached data if fresh enough
+    if (age < CACHE_TTL_MS) {
+      return cache.data;
+    }
+
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+// Write usage data to cache (shared across all sessions)
+function setCachedUsage(data) {
+  try {
+    if (!fs.existsSync(CACHE_DIR)) {
+      fs.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+
+    const cache = {
+      timestamp: Date.now(),
+      data: data
+    };
+
+    fs.writeFileSync(USAGE_CACHE_FILE, JSON.stringify(cache), 'utf8');
+  } catch (e) {
+    // Silently fail
+  }
+}
+
+function getApiUsage(callback) {
+  try {
+    // Read credentials
+    const credsPath = path.join(os.homedir(), '.claude', '.credentials.json');
+    if (!fs.existsSync(credsPath)) {
+      return callback(null);
+    }
+
+    const creds = JSON.parse(fs.readFileSync(credsPath, 'utf8'));
+    const accessToken = creds.claudeAiOauth?.accessToken;
+
+    if (!accessToken) {
+      return callback(null);
+    }
+
+    // Adaptive timeout: if cache exists, be faster (1200ms); if not, be patient (1500ms)
+    // API typically takes ~850ms, so 1200ms gives reasonable headroom
+    const hasCache = fs.existsSync(USAGE_CACHE_FILE);
+    const timeout = hasCache ? 1200 : 1500;
+
+    // Make API call with adaptive timeout
+    const req = https.request({
+      hostname: 'api.anthropic.com',
+      path: '/api/oauth/usage',
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+        'anthropic-beta': 'oauth-2025-04-20'
+      },
+      timeout: timeout
+    }, (res) => {
+      let data = '';
+
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const usage = JSON.parse(data);
+
+          // Get 5-hour session usage
+          if (usage.five_hour) {
+            const percentage = Math.round(usage.five_hour.utilization);
+            const resetsAt = usage.five_hour.resets_at;
+
+            // Parse reset time
+            let timeStr = '';
+            if (resetsAt) {
+              const resetDate = new Date(resetsAt);
+              const now = new Date();
+              const diffMs = resetDate - now;
+              const diffMins = Math.floor(diffMs / 60000);
+              const hours = Math.floor(diffMins / 60);
+              const mins = diffMins % 60;
+
+              if (hours > 0) {
+                timeStr = `${hours}h${mins}m`;
+              } else {
+                timeStr = `${mins}m`;
+              }
+            }
+
+            // Build bar
+            const barWidth = 10;
+            const filledWidth = Math.round((percentage / 100) * barWidth);
+            const filled = '\u2588'.repeat(filledWidth);
+            const empty = '\u2591'.repeat(barWidth - filledWidth);
+            const color = getUsageColor(percentage);
+
+            const bar = `${color}${filled}${empty} ${percentage}%${colors.reset}${colors.dim} (${timeStr})${colors.reset}`;
+
+            // Cache the result for other sessions
+            setCachedUsage(bar);
+
+            callback(bar);
+          } else {
+            callback(null);
+          }
+        } catch (e) {
+          callback(null);
+        }
+      });
+    });
+
+    req.on('error', () => callback(null));
+    req.on('timeout', () => {
+      req.destroy();
+      callback(null);
+    });
+
+    req.end();
+  } catch (e) {
+    callback(null);
+  }
+}
+
+// Get usage with cache fallback
+function getUsageWithCache(callback) {
+  // First, try to get fresh data from API
+  getApiUsage((freshData) => {
+    if (freshData) {
+      // Got fresh data, use it
+      callback(freshData);
+    } else {
+      // API failed or timed out, try cache
+      const cachedData = getCachedUsage();
+      callback(cachedData);
+    }
+  });
+}
+
+function getCurrentTask(sessionId) {
+  if (!sessionId) return '';
+
+  const homeDir = os.homedir();
+  const todosDir = path.join(homeDir, '.claude', 'todos');
+
+  if (!fs.existsSync(todosDir)) return '';
+
+  try {
+    const files = fs.readdirSync(todosDir)
+      .filter(f => f.startsWith(sessionId) && f.includes('-agent-') && f.endsWith('.json'))
+      .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+      .sort((a, b) => b.mtime - a.mtime);
+
+    if (files.length > 0) {
+      const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+      const inProgress = todos.find(t => t.status === 'in_progress');
+      if (inProgress) return inProgress.activeForm || '';
+    }
+  } catch (e) {}
+
+  return '';
+}
+
+// Main
+function outputStatus(data, usageBar) {
+  try {
+    const model = data?.model?.display_name || 'Claude';
+    const dir = data?.workspace?.current_dir || process.cwd();
+    const dirname = path.basename(dir);
+    const sessionId = data?.session_id || '';
+    const remaining = data?.context_window?.remaining_percentage;
+
+    const contextBar = getContextBar(remaining);
+    const task = getCurrentTask(sessionId);
+    const parts = [];
+    parts.push(dirname);
+    parts.push(model);
+    parts.push(`context: ${contextBar}`);
+
+    if (usageBar) {
+      parts.push(`usage: ${usageBar}`);
+    }
+
+    if (task) parts.push(`${colors.dim}${task}${colors.reset}`);
+    process.stdout.write(parts.join(' \u2502 '));
+  } catch (e) {
+    process.stdout.write('Status unavailable');
+  }
+}
+
+function outputFallback(usageBar) {
+  const contextBar = getContextBar(undefined);
+  const parts = ['~', 'Claude', `context: ${contextBar}`];
+  if (usageBar) parts.push(`usage: ${usageBar}`);
+  process.stdout.write(parts.join(' \u2502 '));
+}
+
+// Wrapper that skips usage fetch for API key users
+function getUsage(callback) {
+  if (IS_API_KEY) {
+    callback(null);
+  } else {
+    getUsageWithCache(callback);
+  }
+}
+
+// Process with timeout
+if (process.stdin.isTTY) {
+  getUsage((usageBar) => {
+    outputFallback(usageBar);
+    process.exit(0);
+  });
+} else {
+  let input = '';
+  let timeoutReached = false;
+
+  const overallTimeout = IS_API_KEY ? 500 : (fs.existsSync(USAGE_CACHE_FILE) ? 1300 : 1600);
+
+  const timeout = setTimeout(() => {
+    timeoutReached = true;
+    getUsage((usageBar) => {
+      if (input.length > 0) {
+        try {
+          const data = JSON.parse(input);
+          outputStatus(data, usageBar);
+        } catch (e) {
+          outputFallback(usageBar);
+        }
+      } else {
+        outputFallback(usageBar);
+      }
+      process.exit(0);
+    });
+  }, overallTimeout);
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => input += chunk);
+  process.stdin.on('end', () => {
+    if (timeoutReached) return;
+    clearTimeout(timeout);
+
+    getUsage((usageBar) => {
+      try {
+        const data = JSON.parse(input);
+        outputStatus(data, usageBar);
+      } catch (e) {
+        outputFallback(usageBar);
+      }
+      process.exit(0);
+    });
+  });
+}