cc-context-stats 1.3.0

package/scripts/statusline-full.sh

@@ -0,0 +1,241 @@
+#!/bin/bash
+# Full-featured status line with context window usage
+# Usage: Copy to ~/.claude/statusline.sh and make executable
+#
+# Configuration:
+# Create/edit ~/.claude/statusline.conf and set:
+#
+#   autocompact=true   (when autocompact is enabled in Claude Code - default)
+#   autocompact=false  (when you disable autocompact via /config in Claude Code)
+#
+#   token_detail=true  (show exact token count like 64,000 - default)
+#   token_detail=false (show abbreviated tokens like 64.0k)
+#
+#   show_delta=true    (show token delta since last refresh like [+2,500] - default)
+#   show_delta=false   (disable delta display - saves file I/O on every refresh)
+#
+#   show_session=true  (show session_id in status line - default)
+#   show_session=false (hide session_id from status line)
+#
+# When AC is enabled, 22.5% of context window is reserved for autocompact buffer.
+#
+# State file format (CSV):
+#   timestamp,total_input_tokens,total_output_tokens,current_usage_input_tokens,current_usage_output_tokens,current_usage_cache_creation,current_usage_cache_read,total_cost_usd,total_lines_added,total_lines_removed,session_id,model_id,workspace_project_dir
+
+# Colors
+BLUE='\033[0;34m'
+MAGENTA='\033[0;35m'
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+DIM='\033[2m'
+RESET='\033[0m'
+
+# Read JSON input from stdin
+input=$(cat)
+
+# Extract information from JSON
+cwd=$(echo "$input" | jq -r '.workspace.current_dir')
+project_dir=$(echo "$input" | jq -r '.workspace.project_dir')
+model=$(echo "$input" | jq -r '.model.display_name // "Claude"')
+session_id=$(echo "$input" | jq -r '.session_id // empty')
+dir_name=$(basename "$cwd")
+
+# Git information (skip optional locks for performance)
+git_info=""
+if [[ -d "$project_dir/.git" ]]; then
+    git_branch=$(cd "$project_dir" 2>/dev/null && git --no-optional-locks rev-parse --abbrev-ref HEAD 2>/dev/null)
+    git_status_count=$(cd "$project_dir" 2>/dev/null && git --no-optional-locks status --porcelain 2>/dev/null | wc -l | tr -d ' ')
+
+    if [[ -n "$git_branch" ]]; then
+        if [[ "$git_status_count" != "0" ]]; then
+            git_info=" | ${MAGENTA}${git_branch}${RESET} ${CYAN}[${git_status_count}]${RESET}"
+        else
+            git_info=" | ${MAGENTA}${git_branch}${RESET}"
+        fi
+    fi
+fi
+
+# Read settings from ~/.claude/statusline.conf
+# Sync this manually when you change settings in Claude Code via /config
+autocompact_enabled=true
+token_detail_enabled=true
+show_delta_enabled=true
+show_session_enabled=true
+autocompact=""    # Will be set by sourced config
+token_detail=""   # Will be set by sourced config
+show_delta=""     # Will be set by sourced config
+show_session=""   # Will be set by sourced config
+ac_info=""
+delta_info=""
+session_info=""
+
+# Create config file with defaults if it doesn't exist
+if [[ ! -f ~/.claude/statusline.conf ]]; then
+    mkdir -p ~/.claude
+    cat >~/.claude/statusline.conf <<'EOF'
+# Autocompact setting - sync with Claude Code's /config
+autocompact=true
+
+# Token display format
+token_detail=true
+
+# Show token delta since last refresh (adds file I/O on every refresh)
+# Disable if you don't need it to reduce overhead
+show_delta=true
+
+# Show session_id in status line
+show_session=true
+EOF
+fi
+
+if [[ -f ~/.claude/statusline.conf ]]; then
+    # shellcheck source=/dev/null
+    source ~/.claude/statusline.conf
+    if [[ "$autocompact" == "false" ]]; then
+        autocompact_enabled=false
+    fi
+    if [[ "$token_detail" == "false" ]]; then
+        token_detail_enabled=false
+    fi
+    if [[ "$show_delta" == "false" ]]; then
+        show_delta_enabled=false
+    fi
+    if [[ "$show_session" == "false" ]]; then
+        show_session_enabled=false
+    fi
+    # Note: show_io_tokens setting is read but not yet implemented
+fi
+
+# Calculate context window - show remaining free space
+context_info=""
+total_size=$(echo "$input" | jq -r '.context_window.context_window_size // 0')
+current_usage=$(echo "$input" | jq '.context_window.current_usage')
+total_input_tokens=$(echo "$input" | jq -r '.context_window.total_input_tokens // 0')
+total_output_tokens=$(echo "$input" | jq -r '.context_window.total_output_tokens // 0')
+cost_usd=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
+lines_added=$(echo "$input" | jq -r '.cost.total_lines_added // 0')
+lines_removed=$(echo "$input" | jq -r '.cost.total_lines_removed // 0')
+model_id=$(echo "$input" | jq -r '.model.id // ""')
+workspace_project_dir=$(echo "$input" | jq -r '.workspace.project_dir // ""')
+
+if [[ "$total_size" -gt 0 && "$current_usage" != "null" ]]; then
+    # Get tokens from current_usage (includes cache)
+    input_tokens=$(echo "$current_usage" | jq -r '.input_tokens // 0')
+    cache_creation=$(echo "$current_usage" | jq -r '.cache_creation_input_tokens // 0')
+    cache_read=$(echo "$current_usage" | jq -r '.cache_read_input_tokens // 0')
+
+    # Total used from current request
+    used_tokens=$((input_tokens + cache_creation + cache_read))
+
+    # Calculate autocompact buffer (22.5% of context window = 45k for 200k)
+    autocompact_buffer=$((total_size * 225 / 1000))
+
+    # Free tokens calculation depends on autocompact setting
+    if [[ "$autocompact_enabled" == "true" ]]; then
+        # When AC enabled: subtract buffer to show actual usable space
+        free_tokens=$((total_size - used_tokens - autocompact_buffer))
+        buffer_k=$(awk "BEGIN {printf \"%.0f\", $autocompact_buffer / 1000}")
+        ac_info=" ${DIM}[AC:${buffer_k}k]${RESET}"
+    else
+        # When AC disabled: show full free space
+        free_tokens=$((total_size - used_tokens))
+        ac_info=" ${DIM}[AC:off]${RESET}"
+    fi
+
+    if [[ "$free_tokens" -lt 0 ]]; then
+        free_tokens=0
+    fi
+
+    # Calculate percentage with one decimal (relative to total size)
+    free_pct=$(awk "BEGIN {printf \"%.1f\", ($free_tokens * 100.0 / $total_size)}")
+    free_pct_int=${free_pct%.*}
+
+    # Format tokens based on token_detail setting
+    if [[ "$token_detail_enabled" == "true" ]]; then
+        # Use awk for portable comma formatting (works regardless of locale)
+        free_display=$(awk -v n="$free_tokens" 'BEGIN { printf "%\047d", n }')
+    else
+        free_display=$(awk "BEGIN {printf \"%.1fk\", $free_tokens / 1000}")
+    fi
+
+    # Color based on free percentage
+    if [[ "$free_pct_int" -gt 50 ]]; then
+        ctx_color="$GREEN"
+    elif [[ "$free_pct_int" -gt 25 ]]; then
+        ctx_color="$YELLOW"
+    else
+        ctx_color="$RED"
+    fi
+
+    context_info=" | ${ctx_color}${free_display} free (${free_pct}%)${RESET}"
+
+    # Calculate and display token delta if enabled
+    if [[ "$show_delta_enabled" == "true" ]]; then
+        # Use session_id for per-session state (avoids conflicts with parallel sessions)
+        state_dir=~/.claude/statusline
+        mkdir -p "$state_dir"
+
+        # Migrate old state files from ~/.claude/ to ~/.claude/statusline/ (one-time migration)
+        old_state_dir=~/.claude
+        for old_file in "$old_state_dir"/statusline*.state; do
+            if [[ -f "$old_file" ]]; then
+                new_file="${state_dir}/$(basename "$old_file")"
+                if [[ ! -f "$new_file" ]]; then
+                    mv "$old_file" "$new_file" 2>/dev/null || true
+                else
+                    # New file exists, just remove old one
+                    rm -f "$old_file" 2>/dev/null || true
+                fi
+            fi
+        done
+
+        if [[ -n "$session_id" ]]; then
+            state_file=${state_dir}/statusline.${session_id}.state
+        else
+            state_file=${state_dir}/statusline.state
+        fi
+        has_prev=false
+        prev_tokens=0
+        if [[ -f "$state_file" ]]; then
+            has_prev=true
+            # Read last line and calculate previous context usage
+            # CSV: ts[0],in[1],out[2],cur_in[3],cur_out[4],cache_create[5],cache_read[6]
+            last_line=$(tail -1 "$state_file" 2>/dev/null)
+            if [[ -n "$last_line" ]]; then
+                prev_cur_in=$(echo "$last_line" | cut -d',' -f4)
+                prev_cache_create=$(echo "$last_line" | cut -d',' -f6)
+                prev_cache_read=$(echo "$last_line" | cut -d',' -f7)
+                prev_tokens=$(( ${prev_cur_in:-0} + ${prev_cache_create:-0} + ${prev_cache_read:-0} ))
+            fi
+        fi
+        # Calculate delta
+        delta=$((used_tokens - prev_tokens))
+        # Only show positive delta (and skip first run when no previous state)
+        if [[ "$has_prev" == "true" && "$delta" -gt 0 ]]; then
+            if [[ "$token_detail_enabled" == "true" ]]; then
+                delta_display=$(awk -v n="$delta" 'BEGIN { printf "%\047d", n }')
+            else
+                delta_display=$(awk "BEGIN {printf \"%.1fk\", $delta / 1000}")
+            fi
+            delta_info=" ${DIM}[+${delta_display}]${RESET}"
+        fi
+        # Only append if context usage changed (avoid duplicates from multiple refreshes)
+        cur_input_tokens=$(echo "$current_usage" | jq -r '.input_tokens // 0')
+        cur_output_tokens=$(echo "$current_usage" | jq -r '.output_tokens // 0')
+        if [[ "$has_prev" != "true" || "$used_tokens" != "$prev_tokens" ]]; then
+            # Append current usage with comprehensive format
+            # Format: ts,in,out,cur_in,cur_out,cache_create,cache_read,cost,+lines,-lines,session,model,dir,size
+            echo "$(date +%s),$total_input_tokens,$total_output_tokens,$cur_input_tokens,$cur_output_tokens,$cache_creation,$cache_read,$cost_usd,$lines_added,$lines_removed,$session_id,$model_id,$workspace_project_dir,$total_size" >>"$state_file"
+        fi
+    fi
+fi
+
+# Display session_id if enabled
+if [[ "$show_session_enabled" == "true" && -n "$session_id" ]]; then
+    session_info=" ${DIM}${session_id}${RESET}"
+fi
+
+# Output: [Model] directory | branch [changes] | XXk free (XX%) [+delta] [AC] [S:session_id]
+echo -e "${DIM}[${model}]${RESET} ${BLUE}${dir_name}${RESET}${git_info}${context_info}${delta_info}${ac_info}${session_info}"

package/scripts/statusline-git.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# Git-aware status line - shows model, directory, and git branch
+# Usage: Copy to ~/.claude/statusline.sh and make executable
+
+# Colors
+BLUE='\033[0;34m'
+MAGENTA='\033[0;35m'
+CYAN='\033[0;36m'
+RESET='\033[0m'
+
+input=$(cat)
+
+MODEL_DISPLAY=$(echo "$input" | jq -r '.model.display_name // "Claude"')
+CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir // "~"')
+DIR_NAME="${CURRENT_DIR##*/}"
+
+# Git branch detection
+GIT_INFO=""
+if git -C "$CURRENT_DIR" rev-parse --git-dir > /dev/null 2>&1; then
+    BRANCH=$(git -C "$CURRENT_DIR" branch --show-current 2>/dev/null)
+    if [ -n "$BRANCH" ]; then
+        # Count uncommitted changes
+        CHANGES=$(git -C "$CURRENT_DIR" status --porcelain 2>/dev/null | wc -l | tr -d ' ')
+        if [ "$CHANGES" -gt 0 ]; then
+            GIT_INFO=" | ${MAGENTA}${BRANCH}${RESET} ${CYAN}[${CHANGES}]${RESET}"
+        else
+            GIT_INFO=" | ${MAGENTA}${BRANCH}${RESET}"
+        fi
+    fi
+fi
+
+echo -e "[${MODEL_DISPLAY}] ${BLUE}${DIR_NAME}${RESET}${GIT_INFO}"

package/scripts/statusline-minimal.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+# Minimal status line - shows model and current directory
+# Usage: Copy to ~/.claude/statusline.sh and make executable
+
+input=$(cat)
+
+MODEL_DISPLAY=$(echo "$input" | jq -r '.model.display_name // "Claude"')
+CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir // "~"')
+DIR_NAME="${CURRENT_DIR##*/}"
+
+echo "[$MODEL_DISPLAY] $DIR_NAME"

package/scripts/statusline.js

@@ -0,0 +1,350 @@
+#!/usr/bin/env node
+/**
+ * Node.js status line script for Claude Code
+ * Usage: Copy to ~/.claude/statusline.js and make executable
+ *
+ * Configuration:
+ * Create/edit ~/.claude/statusline.conf and set:
+ *
+ *   autocompact=true   (when autocompact is enabled in Claude Code - default)
+ *   autocompact=false  (when you disable autocompact via /config in Claude Code)
+ *
+ *   token_detail=true  (show exact token count like 64,000 - default)
+ *   token_detail=false (show abbreviated tokens like 64.0k)
+ *
+ *   show_delta=true    (show token delta since last refresh like [+2,500] - default)
+ *   show_delta=false   (disable delta display - saves file I/O on every refresh)
+ *
+ *   show_session=true  (show session_id in status line - default)
+ *   show_session=false (hide session_id from status line)
+ *
+ * When AC is enabled, 22.5% of context window is reserved for autocompact buffer.
+ *
+ * State file format (CSV):
+ *   timestamp,total_input_tokens,total_output_tokens,current_usage_input_tokens,
+ *   current_usage_output_tokens,current_usage_cache_creation,current_usage_cache_read,
+ *   total_cost_usd,total_lines_added,total_lines_removed,session_id,model_id,
+ *   workspace_project_dir
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// ANSI Colors
+const BLUE = '\x1b[0;34m';
+const MAGENTA = '\x1b[0;35m';
+const CYAN = '\x1b[0;36m';
+const GREEN = '\x1b[0;32m';
+const YELLOW = '\x1b[0;33m';
+const RED = '\x1b[0;31m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+function getGitInfo(projectDir) {
+    const gitDir = path.join(projectDir, '.git');
+    if (!fs.existsSync(gitDir) || !fs.statSync(gitDir).isDirectory()) {
+        return '';
+    }
+
+    try {
+        // Get branch name (skip optional locks for performance)
+        const branch = execSync('git --no-optional-locks rev-parse --abbrev-ref HEAD', {
+            cwd: projectDir,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+
+        if (!branch) {
+            return '';
+        }
+
+        // Count changes
+        const status = execSync('git --no-optional-locks status --porcelain', {
+            cwd: projectDir,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const changes = status.split('\n').filter(l => l.trim()).length;
+
+        if (changes > 0) {
+            return ` | ${MAGENTA}${branch}${RESET} ${CYAN}[${changes}]${RESET}`;
+        }
+        return ` | ${MAGENTA}${branch}${RESET}`;
+    } catch {
+        return '';
+    }
+}
+
+function readConfig() {
+    const config = {
+        autocompact: true,
+        tokenDetail: true,
+        showDelta: true,
+        showSession: true,
+        showIoTokens: true,
+    };
+    const configPath = path.join(os.homedir(), '.claude', 'statusline.conf');
+
+    // Create config file with defaults if it doesn't exist
+    if (!fs.existsSync(configPath)) {
+        try {
+            const configDir = path.dirname(configPath);
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            const defaultConfig = `# Autocompact setting - sync with Claude Code's /config
+autocompact=true
+
+# Token display format
+token_detail=true
+
+# Show token delta since last refresh (adds file I/O on every refresh)
+# Disable if you don't need it to reduce overhead
+show_delta=true
+
+# Show session_id in status line
+show_session=true
+`;
+            fs.writeFileSync(configPath, defaultConfig);
+        } catch {
+            // Ignore errors creating config
+        }
+        return config;
+    }
+
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('#') || !trimmed.includes('=')) {
+                continue;
+            }
+            const [key, value] = trimmed.split('=', 2);
+            const keyTrimmed = key.trim();
+            const valueTrimmed = value.trim().toLowerCase();
+            if (keyTrimmed === 'autocompact') {
+                config.autocompact = valueTrimmed !== 'false';
+            } else if (keyTrimmed === 'token_detail') {
+                config.tokenDetail = valueTrimmed !== 'false';
+            } else if (keyTrimmed === 'show_delta') {
+                config.showDelta = valueTrimmed !== 'false';
+            } else if (keyTrimmed === 'show_session') {
+                config.showSession = valueTrimmed !== 'false';
+            } else if (keyTrimmed === 'show_io_tokens') {
+                config.showIoTokens = valueTrimmed !== 'false';
+            }
+        }
+    } catch {
+        // Ignore errors
+    }
+    return config;
+}
+
+let input = '';
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => (input += chunk));
+
+process.stdin.on('end', () => {
+    let data;
+    try {
+        data = JSON.parse(input);
+    } catch {
+        console.log('[Claude] ~');
+        return;
+    }
+
+    // Extract data
+    const cwd = data.workspace?.current_dir || '~';
+    const projectDir = data.workspace?.project_dir || cwd;
+    const model = data.model?.display_name || 'Claude';
+    const dirName = path.basename(cwd) || '~';
+
+    // Git info
+    const gitInfo = getGitInfo(projectDir);
+
+    // Read settings from config file
+    const config = readConfig();
+    const autocompactEnabled = config.autocompact;
+    const tokenDetail = config.tokenDetail;
+    const showDelta = config.showDelta;
+    const showSession = config.showSession;
+    // Note: showIoTokens setting is read but not yet implemented
+
+    // Extract session_id once for reuse
+    const sessionId = data.session_id;
+
+    // Context window calculation
+    let contextInfo = '';
+    let acInfo = '';
+    let deltaInfo = '';
+    let sessionInfo = '';
+    const totalSize = data.context_window?.context_window_size || 0;
+    const currentUsage = data.context_window?.current_usage;
+    const totalInputTokens = data.context_window?.total_input_tokens || 0;
+    const totalOutputTokens = data.context_window?.total_output_tokens || 0;
+    const costUsd = data.cost?.total_cost_usd || 0;
+    const linesAdded = data.cost?.total_lines_added || 0;
+    const linesRemoved = data.cost?.total_lines_removed || 0;
+    const modelId = data.model?.id || '';
+    const workspaceProjectDir = data.workspace?.project_dir || '';
+
+    if (totalSize > 0 && currentUsage) {
+        // Get tokens from current_usage (includes cache)
+        const inputTokens = currentUsage.input_tokens || 0;
+        const cacheCreation = currentUsage.cache_creation_input_tokens || 0;
+        const cacheRead = currentUsage.cache_read_input_tokens || 0;
+
+        // Total used from current request
+        const usedTokens = inputTokens + cacheCreation + cacheRead;
+
+        // Calculate autocompact buffer (22.5% of context window = 45k for 200k)
+        const autocompactBuffer = Math.floor(totalSize * 0.225);
+
+        // Free tokens calculation depends on autocompact setting
+        let freeTokens;
+        if (autocompactEnabled) {
+            // When AC enabled: subtract buffer to show actual usable space
+            freeTokens = totalSize - usedTokens - autocompactBuffer;
+            const bufferK = Math.floor(autocompactBuffer / 1000);
+            acInfo = ` ${DIM}[AC:${bufferK}k]${RESET}`;
+        } else {
+            // When AC disabled: show full free space
+            freeTokens = totalSize - usedTokens;
+            acInfo = ` ${DIM}[AC:off]${RESET}`;
+        }
+
+        if (freeTokens < 0) {
+            freeTokens = 0;
+        }
+
+        // Calculate percentage with one decimal (relative to total size)
+        const freePct = (freeTokens * 100.0) / totalSize;
+        const freePctInt = Math.floor(freePct);
+
+        // Format tokens based on token_detail setting
+        const freeDisplay = tokenDetail
+            ? freeTokens.toLocaleString('en-US')
+            : `${(freeTokens / 1000).toFixed(1)}k`;
+
+        // Color based on free percentage
+        let ctxColor;
+        if (freePctInt > 50) {
+            ctxColor = GREEN;
+        } else if (freePctInt > 25) {
+            ctxColor = YELLOW;
+        } else {
+            ctxColor = RED;
+        }
+
+        contextInfo = ` | ${ctxColor}${freeDisplay} free (${freePct.toFixed(1)}%)${RESET}`;
+
+        // Calculate and display token delta if enabled
+        if (showDelta) {
+            const stateDir = path.join(os.homedir(), '.claude', 'statusline');
+            if (!fs.existsSync(stateDir)) {
+                fs.mkdirSync(stateDir, { recursive: true });
+            }
+
+            const oldStateDir = path.join(os.homedir(), '.claude');
+            try {
+                const oldFiles = fs
+                    .readdirSync(oldStateDir)
+                    .filter(f => f.match(/^statusline.*\.state$/));
+                for (const fileName of oldFiles) {
+                    const oldFile = path.join(oldStateDir, fileName);
+                    const newFile = path.join(stateDir, fileName);
+                    if (fs.statSync(oldFile).isFile()) {
+                        if (!fs.existsSync(newFile)) {
+                            fs.renameSync(oldFile, newFile);
+                        } else {
+                            fs.unlinkSync(oldFile);
+                        }
+                    }
+                }
+            } catch {
+                /* migration errors are non-fatal */
+            }
+
+            const stateFileName = sessionId ? `statusline.${sessionId}.state` : 'statusline.state';
+            const stateFile = path.join(stateDir, stateFileName);
+            let hasPrev = false;
+            let prevTokens = 0;
+            try {
+                if (fs.existsSync(stateFile)) {
+                    hasPrev = true;
+                    // Read last line to get previous context usage
+                    const content = fs.readFileSync(stateFile, 'utf8').trim();
+                    const lines = content.split('\n');
+                    const lastLine = lines[lines.length - 1];
+                    if (lastLine.includes(',')) {
+                        const parts = lastLine.split(',');
+                        // Calculate previous context usage:
+                        // cur_input + cache_creation + cache_read
+                        // CSV indices: cur_in[3], cache_create[5], cache_read[6]
+                        const prevCurInput = parseInt(parts[3], 10) || 0;
+                        const prevCacheCreation = parseInt(parts[5], 10) || 0;
+                        const prevCacheRead = parseInt(parts[6], 10) || 0;
+                        prevTokens = prevCurInput + prevCacheCreation + prevCacheRead;
+                    } else {
+                        // Old format - single value
+                        prevTokens = parseInt(lastLine, 10) || 0;
+                    }
+                }
+            } catch {
+                prevTokens = 0;
+            }
+            // Calculate delta (difference in context window usage)
+            const delta = usedTokens - prevTokens;
+            // Only show positive delta (and skip first run when no previous state)
+            if (hasPrev && delta > 0) {
+                const deltaDisplay = tokenDetail
+                    ? delta.toLocaleString('en-US')
+                    : `${(delta / 1000).toFixed(1)}k`;
+                deltaInfo = ` ${DIM}[+${deltaDisplay}]${RESET}`;
+            }
+            // Only append if context usage changed (avoid duplicates from multiple refreshes)
+            if (!hasPrev || usedTokens !== prevTokens) {
+                // Append current usage with comprehensive format
+                // Format: ts,total_in,total_out,cur_in,cur_out,cache_create,cache_read,
+                //         cost_usd,lines_added,lines_removed,session_id,model_id,project_dir
+                try {
+                    const timestamp = Math.floor(Date.now() / 1000);
+                    const curInputTokens = currentUsage.input_tokens || 0;
+                    const curOutputTokens = currentUsage.output_tokens || 0;
+                    const stateData = [
+                        timestamp,
+                        totalInputTokens,
+                        totalOutputTokens,
+                        curInputTokens,
+                        curOutputTokens,
+                        cacheCreation,
+                        cacheRead,
+                        costUsd,
+                        linesAdded,
+                        linesRemoved,
+                        sessionId || '',
+                        modelId,
+                        workspaceProjectDir,
+                        totalSize,
+                    ].join(',');
+                    fs.appendFileSync(stateFile, `${stateData}\n`);
+                } catch {
+                    // Ignore errors
+                }
+            }
+        }
+    }
+
+    // Display session_id if enabled
+    if (showSession && sessionId) {
+        sessionInfo = ` ${DIM}${sessionId}${RESET}`;
+    }
+
+    // Output: [Model] directory | branch [changes] | XXk free (XX%) [+delta] [AC] [S:session_id]
+    console.log(
+        `${DIM}[${model}]${RESET} ${BLUE}${dirName}${RESET}${gitInfo}${contextInfo}${deltaInfo}${acInfo}${sessionInfo}`
+    );
+});