Passen Sie Ihre Statuszeile an

Konfigurieren Sie eine benutzerdefinierte Statusleiste zur Überwachung der Kontextfensternutzung, Kosten und Git-Status in Claude Code

Die Statuszeile ist eine anpassbare Leiste am unteren Rand von Claude Code, die jedes Shell-Skript ausführt, das Sie konfigurieren. Sie empfängt JSON-Sitzungsdaten auf stdin und zeigt alles an, was Ihr Skript ausgibt, und bietet Ihnen eine persistente, auf einen Blick sichtbare Ansicht der Kontextnutzung, Kosten, Git-Status oder alles andere, das Sie verfolgen möchten.

Statuszeilen sind nützlich, wenn Sie:

• Die Kontextfensternutzung während der Arbeit überwachen möchten
• Sitzungskosten verfolgen müssen
• Über mehrere Sitzungen hinweg arbeiten und diese unterscheiden müssen
• Git-Branch und Status immer sichtbar haben möchten

Die Statuszeile wird in ihrer eigenen Zeile über den integrierten Fußzeilenabzeichen gerendert und ersetzt diese nicht. Mit einer konfigurierten benutzerdefinierten Statuszeile zeigt Claude Code die meisten Tastaturhinweise der Fußzeile nicht mehr an, einschließlich esc zum Unterbrechen, des ? für Verknüpfungen Fallbacks und des Leertaste halten zum Sprechen Sprachdiktierhinweises. Um anklickbare Link-Abzeichen in der Fußzeile hinzuzufügen, wenn eine ID im Gespräch angezeigt wird, ohne ein Skript zu schreiben, konfigurieren Sie stattdessen footerLinksRegexes.

Hier ist ein Beispiel einer mehrzeiligen Statuszeile, die Git-Informationen in der ersten Zeile und einen farbcodierten Kontextbalken in der zweiten Zeile anzeigt.

Diese Seite führt Sie durch das Einrichten einer grundlegenden Statuszeile, erklärt wie die Daten fließen von Claude Code zu Ihrem Skript, listet alle Felder auf, die Sie anzeigen können, und bietet einsatzbereite Beispiele für häufige Muster wie Git-Status, Kostenverfolgung und Fortschrittsbalken.

Richten Sie eine Statuszeile ein

Verwenden Sie den /statusline Befehl, um Claude Code ein Skript für Sie generieren zu lassen, oder erstellen Sie manuell ein Skript und fügen Sie es zu Ihren Einstellungen hinzu.

Verwenden Sie den /statusline Befehl

Der /statusline Befehl akzeptiert Anweisungen in natürlicher Sprache, die beschreiben, was Sie angezeigt haben möchten. Claude Code generiert eine Skriptdatei in ~/.claude/ und aktualisiert Ihre Einstellungen automatisch:

/statusline show model name and context percentage with a progress bar

Genehmigen Sie die Dateibearbeitungs-Eingabeaufforderungen, wenn Claude Code während der Einrichtung um Genehmigung fragt.

Statuszeile manuell konfigurieren

Fügen Sie ein statusLine Feld zu Ihren Benutzereinstellungen (~/.claude/settings.json, wobei ~ Ihr Heimatverzeichnis ist) oder Projekteinstellungen hinzu. Setzen Sie type auf "command" und verweisen Sie command auf einen Skriptpfad oder einen Inline-Shell-Befehl. Eine vollständige Anleitung zum Erstellen eines Skripts finden Sie unter Erstellen Sie eine Statuszeile Schritt für Schritt.

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh",
    "padding": 2
  }
}

Das command Feld wird in einer Shell ausgeführt, sodass Sie auch Inline-Befehle anstelle einer Skriptdatei verwenden können. Dieses Beispiel verwendet jq, um die JSON-Eingabe zu analysieren und den Modellnamen und den Kontextprozentsatz anzuzeigen:

{
  "statusLine": {
    "type": "command",
    "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'"
  }
}

Das optionale padding Feld fügt zusätzlichen horizontalen Abstand (in Zeichen) zum Inhalt der Statuszeile hinzu. Standardmäßig 0. Dieser Abstand wird zusätzlich zum integrierten Abstand der Benutzeroberfläche hinzugefügt, sodass er die relative Einrückung steuert, anstatt den absoluten Abstand vom Terminalrand.

Das optionale refreshInterval Feld führt Ihren Befehl zusätzlich zu den ereignisgesteuerten Aktualisierungen alle N Sekunden erneut aus. Das Minimum ist 1. Setzen Sie dies, wenn Ihre Statuszeile zeitbasierte Daten wie eine Uhr anzeigt, oder wenn Hintergrund-Subagenten den Git-Status ändern, während die Hauptsitzung untätig ist. Lassen Sie es ungesetzt, um nur bei Ereignissen auszuführen.

Das optionale hideVimModeIndicator Feld unterdrückt den integrierten -- INSERT -- Text unter der Eingabeaufforderung. Setzen Sie dies auf true, wenn Ihr Skript vim.mode selbst rendert, sodass der Modus nicht zweimal angezeigt wird.

Deaktivieren Sie die Statuszeile

Führen Sie /statusline aus und bitten Sie es, Ihre Statuszeile zu entfernen oder zu löschen (z. B. /statusline delete, /statusline clear, /statusline remove it). Sie können auch das statusLine Feld manuell aus Ihrer settings.json löschen.

Erstellen Sie eine Statuszeile Schritt für Schritt

Diese Anleitung zeigt, was /statusline für Sie einrichtet, indem Sie manuell eine Statuszeile erstellen, die das aktuelle Modell, das Arbeitsverzeichnis und den Prozentsatz der Kontextfensternutzung anzeigt.

[!NOTE]

Das Ausführen von /statusline mit einer Beschreibung dessen, was Sie möchten, konfiguriert all dies automatisch für Sie.

Diese Beispiele verwenden Bash-Skripte, die auf macOS und Linux funktionieren. Unter Windows finden Sie unter Windows-Konfiguration PowerShell- und Git Bash-Beispiele.

1. Erstellen Sie ein Skript, das JSON liest und Ausgabe druckt

Claude Code sendet JSON-Daten über stdin an Ihr Skript. Dieses Skript verwendet jq, einen Befehlszeilen-JSON-Parser, den Sie möglicherweise installieren müssen, um den Modellnamen, das Verzeichnis und den Kontextprozentsatz zu extrahieren, und druckt dann eine formatierte Zeile.

Speichern Sie dies unter ~/.claude/statusline.sh (wobei ~ Ihr Heimatverzeichnis ist, z. B. /Users/username auf macOS oder /home/username auf Linux):

#!/bin/bash
# Read JSON data that Claude Code sends to stdin
input=$(cat)

# Extract fields using jq
MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')
# The "// 0" provides a fallback if the field is null
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)

# Output the status line - ${DIR##*/} extracts just the folder name
echo "[$MODEL] 📁 ${DIR##*/} | ${PCT}% context"

2. Machen Sie es ausführbar

Markieren Sie das Skript als ausführbar, damit Ihre Shell es ausführen kann:

chmod +x ~/.claude/statusline.sh

3. Zu Einstellungen hinzufügen

Teilen Sie Claude Code mit, dass es Ihr Skript als Statuszeile ausführen soll. Fügen Sie diese Konfiguration zu ~/.claude/settings.json hinzu, die type auf "command" setzt (was bedeutet „diesen Shell-Befehl ausführen“) und command auf Ihr Skript verweist:

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  }
}

Ihre Statuszeile wird am unteren Rand der Benutzeroberfläche angezeigt. Claude Code lädt Einstellungen automatisch neu und führt Ihr Skript aus, sobald Sie die Datei speichern.

Wie Statuszeilen funktionieren

Claude Code führt Ihr Skript mit JSON-Sitzungsdaten auf stdin aus und zeigt alles an, was das Skript auf stdout ausgibt.

[!NOTE]

Die Statuszeile wird lokal ausgeführt und verbraucht keine API-Token. Sie wird bei bestimmten UI-Interaktionen vorübergehend ausgeblendet, darunter das Hilfemenü und Berechtigungsabfragen.

Wann die Statuszeile aktualisiert wird

Ihr Skript wird einmal ausgeführt, wenn eine Sitzung startet, auch wenn Sie eine Sitzung fortsetzen. Danach wird es erneut ausgeführt, wenn:

• Eine neue Assistentennachricht eintrifft
• /compact abgeschlossen ist
• Sich der Berechtigungsmodus ändert
• Der Vim-Modus umgeschaltet wird
• Sie den command in Ihren statusLine-Einstellungen ändern
• Ein refreshInterval-Timer abläuft, sofern Sie einen festgelegt haben
• Ein Rate-Limit-Zeitfenster in den zuletzt von Ihrem Skript empfangenen Daten seinen resets_at-Zeitpunkt erreicht
• Ein warmer Prompt-Cache in den zuletzt von Ihrem Skript empfangenen Daten seinen expires_at-Zeitpunkt erreicht

Claude Code entprellt Aktualisierungen mit 300 ms, sodass schnell aufeinanderfolgende Änderungen gebündelt werden und Ihr Skript einmal ausgeführt wird, nachdem die Änderungen aufhören. Eine Änderung am command selbst überspringt die Entprellung: Claude Code führt den neuen Befehl sofort aus. Wenn eine neue Aktualisierung ausgelöst wird, während Ihr Skript noch läuft, bricht Claude Code das laufende Skript ab. Wenn Sie Ihr Skript bearbeiten, erscheinen die Änderungen beim nächsten Mal, wenn ein Aktualisierungsauslöser es erneut ausführt.

Die ereignisgesteuerten Auslöser können ausbleiben, wenn die Hauptsitzung inaktiv ist, zum Beispiel während ein Koordinator auf Subagenten im Hintergrund wartet. Um zeitbasierte oder extern bezogene Segmente auch in Leerlaufphasen aktuell zu halten, setzen Sie refreshInterval, damit der Befehl zusätzlich in einem festen Intervall erneut ausgeführt wird.

Was Ihr Skript ausgeben kann

Ihr Skript kann mehr als eine einzelne Zeile einfachen Texts ausgeben:

• Mehrere Zeilen: Jede echo- oder print-Anweisung wird als separate Zeile angezeigt. Siehe das Beispiel mit mehreren Zeilen.
• Farben: Verwenden Sie ANSI-Escape-Codes wie \033[32m für Grün (das Terminal muss diese unterstützen). Siehe das Git-Status-Beispiel.
• Links: Verwenden Sie OSC-8-Escape-Sequenzen, um Text anklickbar zu machen (Cmd+Klick unter macOS, Ctrl+Klick unter Windows/Linux). Erfordert ein Terminal, das Hyperlinks unterstützt, wie iTerm2, Kitty oder WezTerm. Siehe das Beispiel für anklickbare Links.

Ausgabe an die Terminalgröße anpassen

Claude Code erfasst die Ausgabe Ihres Skripts, anstatt sie direkt mit dem Terminal zu verbinden, daher können tput cols und die Breitenerkennung auf Sprachebene die Terminalgröße nicht aus dem Skript heraus auslesen. Lesen Sie stattdessen die Umgebungsvariablen COLUMNS und LINES. Claude Code setzt diese auf die aktuellen Terminalabmessungen, bevor Ihr Skript ausgeführt wird.

Verfügbare Daten

Claude Code sendet die folgenden JSON-Felder über stdin an Ihr Skript:

[accordion] Vollständiges JSON-Schema

Ihr Statuszeilen-Befehl erhält diese JSON-Struktur über stdin:

{
  "cwd": "/current/working/directory",
  "session_id": "abc123...",
  "session_name": "my-session",
  "prompt_id": "550e8400-e29b-41d4-a716-446655440000",
  "transcript_path": "/path/to/transcript.jsonl",
  "model": {
    "id": "claude-opus-5-5",
    "display_name": "Opus"
  },
  "workspace": {
    "current_dir": "/current/working/directory",
    "project_dir": "/original/project/directory",
    "added_dirs": [],
    "git_worktree": "feature-xyz",
    "repo": {
      "host": "github.com",
      "owner": "anthropics",
      "name": "claude-code"
    }
  },
  "version": "2.1.90",
  "output_style": {
    "name": "default"
  },
  "cost": {
    "total_cost_usd": 0.01234,
    "total_duration_ms": 45000,
    "total_api_duration_ms": 2300,
    "total_lines_added": 156,
    "total_lines_removed": 23
  },
  "context_window": {
    "total_input_tokens": 15500,
    "total_output_tokens": 1200,
    "context_window_size": 200000,
    "used_percentage": 8,
    "remaining_percentage": 92,
    "current_usage": {
      "input_tokens": 8500,
      "output_tokens": 1200,
      "cache_creation_input_tokens": 5000,
      "cache_read_input_tokens": 2000
    }
  },
  "exceeds_200k_tokens": false,
  "prompt_cache": {
    "warm": true,
    "caching_observed": true,
    "ttl": "1h",
    "expires_at": 1738429200,
    "requests": 14,
    "misses": 2,
    "expected_rebuilds": 1,
    "hit_ratio": 0.91,
    "cache_write_tokens": 352000,
    "miss_recache_tokens": 310200,
    "last_miss_at": 1738425230,
    "last_miss_cause": {
      "causes": ["tools_changed"],
      "tools_added": 2,
      "tools_removed": 0
    },
    "miss_causes": {
      "tools_changed": 2
    },
    "recache_tokens_if_cold": 45000
  },
  "fast_mode": false,
  "effort": {
    "level": "high"
  },
  "thinking": {
    "enabled": true
  },
  "rate_limits": {
    "five_hour": {
      "used_percentage": 23.5,
      "resets_at": 1738425600
    },
    "seven_day": {
      "used_percentage": 41.2,
      "resets_at": 1738857600
    },
    "spend_limit": {
      "used_percentage": 62.8,
      "resets_at": 1740787200,
      "used_usd": 314.12,
      "limit_usd": 500,
      "period": "monthly"
    }
  },
  "vim": {
    "mode": "NORMAL"
  },
  "agent": {
    "name": "security-reviewer"
  },
  "pr": {
    "number": 1234,
    "url": "https://github.com/anthropics/claude-code/pull/1234",
    "review_state": "pending"
  },
  "worktree": {
    "name": "my-feature",
    "path": "/path/to/.claude/worktrees/my-feature",
    "branch": "worktree-my-feature",
    "original_cwd": "/path/to/project",
    "original_branch": "main"
  }
}

Felder, die fehlen können (nicht im JSON vorhanden):

• session_name: erscheint, wenn ein benutzerdefinierter Name mit --name oder /rename festgelegt wurde oder sobald ein KI-generierter Sitzungstitel existiert. Der Standard-Anzeigename, etwa my-app-3f, befüllt es nicht
• prompt_id: erscheint erst nach der ersten Benutzereingabe
• workspace.git_worktree: erscheint nur, wenn sich das aktuelle Verzeichnis in einem verknüpften Git-Worktree befindet
• workspace.repo: erscheint nur innerhalb eines Git-Repositorys mit konfiguriertem Remote origin
• effort: erscheint nur, wenn das aktuelle Modell den Parameter für den Reasoning-Aufwand unterstützt
• vim: erscheint nur, wenn der Vim-Modus aktiviert ist
• agent: erscheint nur bei Ausführung mit dem Flag --agent oder bei konfigurierten Agenteneinstellungen
• pr: erscheint nur, solange für den aktuellen Branch ein offener PR oder GitLab Merge Request gefunden wird, und wird entfernt, sobald dieser gemergt oder geschlossen wird. pr.review_state und pr.kind können unabhängig fehlen
• worktree: erscheint nur, solange sich die Sitzung in einer Worktree-Sitzung befindet. Wenn vorhanden, können branch und original_branch bei Hook-basierten Worktrees ebenfalls fehlen
• rate_limits: erscheint nur für Abonnenten von claude.ai Pro, Max und Ultra oder hinter einem Claude-Apps-Gateway, das ein Ausgabenlimit für Sie festlegt. Selbst dann erscheint es erst nach der ersten API-Antwort in der Sitzung. Jedes Fenster (five_hour, seven_day, spend_limit) kann unabhängig fehlen, und Claude Code entfernt ein Fenster, sobald dessen resets_at-Zeitpunkt verstrichen ist. Verwenden Sie jq -r '.rate_limits.five_hour.used_percentage // empty', um fehlende Werte sauber zu behandeln.
• prompt_cache: erscheint nach der ersten API-Antwort der Hauptkonversation. Siehe Felder des Prompt-Caches

Felder, die null sein können:

• context_window.current_usage: null vor dem ersten API-Aufruf in einer Sitzung und erneut nach /compact, bis der nächste API-Aufruf es wieder befüllt
• context_window.used_percentage, context_window.remaining_percentage: können früh in der Sitzung null sein

Behandeln Sie in Ihren Skripten fehlende Felder mit bedingtem Zugriff und null-Werte mit Fallback-Standardwerten.

Felder des Kontextfensters

Das Objekt context_window beschreibt das aktuelle Kontextfenster aus der letzten API-Antwort.

• Kombinierte Summen (total_input_tokens, total_output_tokens): Token, die sich aktuell im Kontextfenster befinden. total_input_tokens ist die Summe aus input_tokens, cache_creation_input_tokens und cache_read_input_tokens; total_output_tokens sind die Ausgabe-Token aus der letzten Antwort. Beide sind vor der ersten API-Antwort 0.
• Nutzung pro Komponente (current_usage): dieselben Token-Anzahlen, aufgeschlüsselt nach Kategorie. Verwenden Sie dies, wenn Sie Cache-Treffer getrennt von neuer Eingabe benötigen.

Das Objekt current_usage enthält:

• input_tokens: Eingabe-Token im aktuellen Kontext
• output_tokens: generierte Ausgabe-Token
• cache_creation_input_tokens: in den Cache geschriebene Token
• cache_read_input_tokens: aus dem Cache gelesene Token

Was die Cache-Felder bedeuten und wie sie abgerechnet werden, erfahren Sie unter Cache-Leistung prüfen.

Das Feld used_percentage wird ausschließlich aus Eingabe-Token berechnet: input_tokens + cache_creation_input_tokens + cache_read_input_tokens. Es enthält keine output_tokens.

Wenn Sie den Kontext-Prozentsatz manuell aus current_usage berechnen, verwenden Sie dieselbe Formel, die nur Eingabe-Token berücksichtigt, damit der Wert mit used_percentage übereinstimmt.

Das Objekt current_usage ist vor dem ersten API-Aufruf in einer Sitzung null und erneut unmittelbar nach /compact, bis der nächste API-Aufruf es wieder befüllt.

Felder des Ausgabenlimits

Hinter einem Claude-Apps-Gateway mit Ausgabenlimits beschreibt das Objekt rate_limits.spend_limit das Ausgabenlimit, das für Sie gilt. Es erscheint nach der ersten API-Antwort der Sitzung und erfordert Claude Code v2.1.251 oder höher. Ihr Skript erhält seine Felder in unterschiedlichen Intervallen:

• used_percentage und resets_at: werden mit jeder Antwort geliefert und sind daher immer vorhanden, wenn spend_limit vorhanden ist. used_percentage reicht von 0 bis 100 oder liegt über 100, sobald Sie das Limit überschreiten, und resets_at gibt die Unix-Epoch-Sekunden an, zu denen der Zeitraum des Limits zurückgesetzt wird.
• used_usd, limit_usd und period: Ihre bisherigen geschätzten Ausgaben und Ihr Limit in US-Dollar sowie der Zeitraum, den das Limit abdeckt, einer der Werte daily, weekly oder monthly. Das Gateway berechnet used_usd aus Token-Anzahlen, daher handelt es sich um eine Schätzung und nicht um einen abgerechneten Betrag. Claude Code liest diese Werte in einer separaten Anfrage vom Gateway, etwa alle fünf Minuten, während Sie Anfragen senden. Die Dollarbeträge können etwa fünf Minuten älter sein als used_percentage, sodass die beiden Werte kurzzeitig voneinander abweichen können. Erfordert v2.1.284 oder höher sowohl bei Claude Code als auch beim Gateway.

Behandeln Sie used_usd, limit_usd und period als optional, auch wenn spend_limit vorhanden ist, da Ihr Skript den Prozentsatz vor ihnen erhält. Lesen Sie jedes dieser Felder in Ihrem Skript mit einem Fallback, etwa jq -r '.rate_limits.spend_limit.used_usd // empty'. Vor Claude Code v2.1.295 fehlten sie dauerhaft, wenn Sie CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC gesetzt hatten, da dadurch diese Anfrage deaktiviert wurde.

Felder des Prompt-Caches

Das Objekt prompt_cache fasst zusammen, wie die Hauptkonversation der Sitzung den Prompt-Cache nutzt. Claude Code berechnet es aus den Cache-Token-Anzahlen in den Antworten der API, daher funktioniert es bei jedem Anbieter.

Das Objekt erscheint nach der ersten API-Antwort der Hauptkonversation. Claude Code zählt Anfragen von Subagenten nicht in diese Statistiken ein. Erfordert Claude Code v2.1.251 oder höher.

Die Tabelle listet jedes Feld mit seiner Bedeutung auf. Zeitstempel sind Unix-Epoch-Sekunden, dieselbe Einheit wie bei rate_limits.*.resets_at. Eine kurze Statuszeile zeigt in der Regel ein oder zwei dieser Felder an; warm und hit_ratio fassen den Cache-Zustand am direktesten zusammen.

Claude Code zeigt dieselben Statistiken im Terminal an, in der Zeile Prompt cache (main) des Befehls /usage.

Ursache des letzten Misses

Das Objekt last_miss_cause gibt an, was Claude Code als wahrscheinliche Ursache des letzten Misses ermittelt hat. Sein Array causes enthält einen oder mehrere Ursachennamen, etwa tools_changed, system_prompt_changed, ttl_expired_5m oder likely_server_side. Das Objekt ist bis zum ersten Miss der Sitzung null und erneut immer dann, wenn Claude Code keine Ursache für den letzten Miss ermitteln konnte. Erfordert Claude Code v2.1.260 oder höher.

Zwei Ursachen fügen dem Objekt Zählwerte hinzu:

• tools_added und tools_removed: bei tools_changed, wie viele Tools der Anfrage hinzugefügt oder aus ihr entfernt wurden
• system_char_delta: bei system_prompt_changed, die Änderung der Länge des System-Prompts in Zeichen

Beispiele

Diese Beispiele zeigen häufige Statuszeilen-Muster. Um ein Beispiel zu verwenden:

1. Speichern Sie das Skript in einer Datei wie ~/.claude/statusline.sh (oder .py/.js)
2. Machen Sie es ausführbar: chmod +x ~/.claude/statusline.sh
3. Fügen Sie den Pfad zu Ihren Einstellungen hinzu

Die Bash-Beispiele verwenden jq zum Analysieren von JSON. Python und Node.js haben integriertes JSON-Parsing.

Kontextfensternutzung

Zeigen Sie das aktuelle Modell und die Kontextfensternutzung mit einem visuellen Fortschrittsbalken an. Jedes Skript liest JSON von stdin, extrahiert das used_percentage Feld und erstellt einen 10-Zeichen-Balken, wobei gefüllte Blöcke (▓) die Nutzung darstellen:

#!/bin/bash
# Read all of stdin into a variable
input=$(cat)

# Extract fields with jq, "// 0" provides fallback for null
MODEL=$(echo "$input" | jq -r '.model.display_name')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)

# Build progress bar: printf -v creates a run of spaces, then
# ${var// /▓} replaces each space with a block character
BAR_WIDTH=10
FILLED=$((PCT * BAR_WIDTH / 100))
EMPTY=$((BAR_WIDTH - FILLED))
BAR=""
[ "$FILLED" -gt 0 ] && printf -v FILL "%${FILLED}s" && BAR="${FILL// /▓}"
[ "$EMPTY" -gt 0 ] && printf -v PAD "%${EMPTY}s" && BAR="${BAR}${PAD// /░}"

echo "[$MODEL] $BAR $PCT%"

#!/usr/bin/env python3
import json, sys

# json.load reads and parses stdin in one step
data = json.load(sys.stdin)
model = data['model']['display_name']
# "or 0" handles null values
pct = int(data.get('context_window', {}).get('used_percentage', 0) or 0)

# String multiplication builds the bar
filled = pct * 10 // 100
bar = '▓' * filled + '░' * (10 - filled)

print(f"[{model}] {bar} {pct}%")

#!/usr/bin/env node
// Node.js reads stdin asynchronously with events
let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    const model = data.model.display_name;
    // Optional chaining (?.) safely handles null fields
    const pct = Math.floor(data.context_window?.used_percentage || 0);

    // String.repeat() builds the bar
    const filled = Math.floor(pct * 10 / 100);
    const bar = '▓'.repeat(filled) + '░'.repeat(10 - filled);

    console.log(`[${model}] ${bar} ${pct}%`);
});

Git-Status mit Farben

Zeigen Sie Git-Branch mit farbcodierten Indikatoren für bereitgestellte und geänderte Dateien an. Dieses Skript verwendet ANSI-Escape-Codes für Terminalfarben: \033[32m ist Grün, \033[33m ist Gelb und \033[0m setzt auf Standard zurück.

Jedes Skript prüft, ob das aktuelle Verzeichnis ein Git-Repository ist, zählt bereitgestellte und geänderte Dateien und zeigt farbcodierte Indikatoren an:

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')

GREEN='\033[32m'
YELLOW='\033[33m'
RESET='\033[0m'

if git rev-parse --git-dir > /dev/null 2>&1; then
    BRANCH=$(git branch --show-current 2>/dev/null)
    STAGED=$(git diff --cached --numstat 2>/dev/null | wc -l | tr -d ' ')
    MODIFIED=$(git diff --numstat 2>/dev/null | wc -l | tr -d ' ')

    GIT_STATUS=""
    [ "$STAGED" -gt 0 ] && GIT_STATUS="${GREEN}+${STAGED}${RESET}"
    [ "$MODIFIED" -gt 0 ] && GIT_STATUS="${GIT_STATUS}${YELLOW}~${MODIFIED}${RESET}"

    echo -e "[$MODEL] 📁 ${DIR##*/} | 🌿 $BRANCH $GIT_STATUS"
else
    echo "[$MODEL] 📁 ${DIR##*/}"
fi

#!/usr/bin/env python3
import json, sys, subprocess, os

data = json.load(sys.stdin)
model = data['model']['display_name']
directory = os.path.basename(data['workspace']['current_dir'])

GREEN, YELLOW, RESET = '\033[32m', '\033[33m', '\033[0m'

try:
    subprocess.check_output(['git', 'rev-parse', '--git-dir'], stderr=subprocess.DEVNULL)
    branch = subprocess.check_output(['git', 'branch', '--show-current'], text=True).strip()
    staged_output = subprocess.check_output(['git', 'diff', '--cached', '--numstat'], text=True).strip()
    modified_output = subprocess.check_output(['git', 'diff', '--numstat'], text=True).strip()
    staged = len(staged_output.split('\n')) if staged_output else 0
    modified = len(modified_output.split('\n')) if modified_output else 0

    git_status = f"{GREEN}+{staged}{RESET}" if staged else ""
    git_status += f"{YELLOW}~{modified}{RESET}" if modified else ""

    print(f"[{model}] 📁 {directory} | 🌿 {branch} {git_status}")
except:
    print(f"[{model}] 📁 {directory}")

#!/usr/bin/env node
const { execSync } = require('child_process');
const path = require('path');

let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    const model = data.model.display_name;
    const dir = path.basename(data.workspace.current_dir);

    const GREEN = '\x1b[32m', YELLOW = '\x1b[33m', RESET = '\x1b[0m';

    try {
        execSync('git rev-parse --git-dir', { stdio: 'ignore' });
        const branch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
        const staged = execSync('git diff --cached --numstat', { encoding: 'utf8' }).trim().split('\n').filter(Boolean).length;
        const modified = execSync('git diff --numstat', { encoding: 'utf8' }).trim().split('\n').filter(Boolean).length;

        let gitStatus = staged ? `${GREEN}+${staged}${RESET}` : '';
        gitStatus += modified ? `${YELLOW}~${modified}${RESET}` : '';

        console.log(`[${model}] 📁 ${dir} | 🌿 ${branch} ${gitStatus}`);
    } catch {
        console.log(`[${model}] 📁 ${dir}`);
    }
});

Kosten- und Dauer-Verfolgung

Verfolgen Sie die API-Kosten und verstrichene Zeit Ihrer Sitzung. Das cost.total_cost_usd Feld sammelt die geschätzten Kosten aller API-Aufrufe in der aktuellen Sitzung. Das cost.total_duration_ms Feld misst die Gesamtverstrichene Zeit seit Sitzungsbeginn, während cost.total_api_duration_ms nur die Zeit verfolgt, die auf API-Antworten wartet.

Jedes Skript formatiert Kosten als Währung und konvertiert Millisekunden in Minuten und Sekunden:

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
DURATION_MS=$(echo "$input" | jq -r '.cost.total_duration_ms // 0')

COST_FMT=$(printf '$%.2f' "$COST")
DURATION_SEC=$((DURATION_MS / 1000))
MINS=$((DURATION_SEC / 60))
SECS=$((DURATION_SEC % 60))

echo "[$MODEL] 💰 $COST_FMT | ⏱️ ${MINS}m ${SECS}s"

#!/usr/bin/env python3
import json, sys

data = json.load(sys.stdin)
model = data['model']['display_name']
cost = data.get('cost', {}).get('total_cost_usd', 0) or 0
duration_ms = data.get('cost', {}).get('total_duration_ms', 0) or 0

duration_sec = duration_ms // 1000
mins, secs = duration_sec // 60, duration_sec % 60

print(f"[{model}] 💰 ${cost:.2f} | ⏱️ {mins}m {secs}s")

#!/usr/bin/env node
let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    const model = data.model.display_name;
    const cost = data.cost?.total_cost_usd || 0;
    const durationMs = data.cost?.total_duration_ms || 0;

    const durationSec = Math.floor(durationMs / 1000);
    const mins = Math.floor(durationSec / 60);
    const secs = durationSec % 60;

    console.log(`[${model}] 💰 $${cost.toFixed(2)} | ⏱️ ${mins}m ${secs}s`);
});

Mehrere Zeilen anzeigen

Ihr Skript kann mehrere Zeilen ausgeben, um eine reichhaltigere Anzeige zu erstellen.

Dieses Beispiel kombiniert mehrere Techniken: schwellenwertbasierte Farben (Grün unter 70%, Gelb 70-89%, Rot 90%+), einen Fortschrittsbalken und Git-Branch-Informationen. Jede print oder echo Anweisung erstellt eine separate Zeile:

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)
DURATION_MS=$(echo "$input" | jq -r '.cost.total_duration_ms // 0')

CYAN='\033[36m'; GREEN='\033[32m'; YELLOW='\033[33m'; RED='\033[31m'; RESET='\033[0m'

# Pick bar color based on context usage
if [ "$PCT" -ge 90 ]; then BAR_COLOR="$RED"
elif [ "$PCT" -ge 70 ]; then BAR_COLOR="$YELLOW"
else BAR_COLOR="$GREEN"; fi

FILLED=$((PCT / 10)); EMPTY=$((10 - FILLED))
printf -v FILL "%${FILLED}s"; printf -v PAD "%${EMPTY}s"
BAR="${FILL// /█}${PAD// /░}"

MINS=$((DURATION_MS / 60000)); SECS=$(((DURATION_MS % 60000) / 1000))

BRANCH=""
git rev-parse --git-dir > /dev/null 2>&1 && BRANCH=" | 🌿 $(git branch --show-current 2>/dev/null)"

echo -e "${CYAN}[$MODEL]${RESET} 📁 ${DIR##*/}$BRANCH"
COST_FMT=$(printf '$%.2f' "$COST")
echo -e "${BAR_COLOR}${BAR}${RESET} ${PCT}% | ${YELLOW}${COST_FMT}${RESET} | ⏱️ ${MINS}m ${SECS}s"

#!/usr/bin/env python3
import json, sys, subprocess, os

data = json.load(sys.stdin)
model = data['model']['display_name']
directory = os.path.basename(data['workspace']['current_dir'])
cost = data.get('cost', {}).get('total_cost_usd', 0) or 0
pct = int(data.get('context_window', {}).get('used_percentage', 0) or 0)
duration_ms = data.get('cost', {}).get('total_duration_ms', 0) or 0

CYAN, GREEN, YELLOW, RED, RESET = '\033[36m', '\033[32m', '\033[33m', '\033[31m', '\033[0m'

bar_color = RED if pct >= 90 else YELLOW if pct >= 70 else GREEN
filled = pct // 10
bar = '█' * filled + '░' * (10 - filled)

mins, secs = duration_ms // 60000, (duration_ms % 60000) // 1000

try:
    branch = subprocess.check_output(['git', 'branch', '--show-current'], text=True, stderr=subprocess.DEVNULL).strip()
    branch = f" | 🌿 {branch}" if branch else ""
except:
    branch = ""

print(f"{CYAN}[{model}]{RESET} 📁 {directory}{branch}")
print(f"{bar_color}{bar}{RESET} {pct}% | {YELLOW}${cost:.2f}{RESET} | ⏱️ {mins}m {secs}s")

#!/usr/bin/env node
const { execSync } = require('child_process');
const path = require('path');

let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    const model = data.model.display_name;
    const dir = path.basename(data.workspace.current_dir);
    const cost = data.cost?.total_cost_usd || 0;
    const pct = Math.floor(data.context_window?.used_percentage || 0);
    const durationMs = data.cost?.total_duration_ms || 0;

    const CYAN = '\x1b[36m', GREEN = '\x1b[32m', YELLOW = '\x1b[33m', RED = '\x1b[31m', RESET = '\x1b[0m';

    const barColor = pct >= 90 ? RED : pct >= 70 ? YELLOW : GREEN;
    const filled = Math.floor(pct / 10);
    const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);

    const mins = Math.floor(durationMs / 60000);
    const secs = Math.floor((durationMs % 60000) / 1000);

    let branch = '';
    try {
        branch = execSync('git branch --show-current', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
        branch = branch ? ` | 🌿 ${branch}` : '';
    } catch {}

    console.log(`${CYAN}[${model}]${RESET} 📁 ${dir}${branch}`);
    console.log(`${barColor}${bar}${RESET} ${pct}% | ${YELLOW}$${cost.toFixed(2)}${RESET} | ⏱️ ${mins}m ${secs}s`);
});

Anklickbare Links

Dieses Beispiel erstellt einen anklickbaren Link zu Ihrem GitHub-Repository. Halten Sie Cmd (macOS) oder Strg (Windows/Linux) gedrückt und klicken Sie, um den Link in Ihrem Browser zu öffnen.

Jedes Skript ruft die Git-Remote-URL ab, konvertiert das SSH-Format in HTTPS und umhüllt den Repository-Namen mit OSC 8 Escape-Codes. Die Bash-Version verwendet printf '%b', das Backslash-Escapes zuverlässiger interpretiert als echo -e über verschiedene Shells hinweg:

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')

# Convert git SSH URL to HTTPS
REMOTE=$(git remote get-url origin 2>/dev/null | sed 's/git@github.com:/https:\/\/github.com\//' | sed 's/\.git$//')

if [ -n "$REMOTE" ]; then
    REPO_NAME=$(basename "$REMOTE")
    # OSC 8 format: \e]8;;URL\a then TEXT then \e]8;;\a
    # printf %b interprets escape sequences reliably across shells
    printf '%b' "[$MODEL] 🔗 \e]8;;${REMOTE}\a${REPO_NAME}\e]8;;\a\n"
else
    echo "[$MODEL]"
fi

#!/usr/bin/env python3
import json, sys, subprocess, re, os

data = json.load(sys.stdin)
model = data['model']['display_name']

# Get git remote URL
try:
    remote = subprocess.check_output(
        ['git', 'remote', 'get-url', 'origin'],
        stderr=subprocess.DEVNULL, text=True
    ).strip()
    # Convert SSH to HTTPS format
    remote = re.sub(r'^git@github\.com:', 'https://github.com/', remote)
    remote = re.sub(r'\.git$', '', remote)
    repo_name = os.path.basename(remote)
    # OSC 8 escape sequences
    link = f"\033]8;;{remote}\a{repo_name}\033]8;;\a"
    print(f"[{model}] 🔗 {link}")
except:
    print(f"[{model}]")

#!/usr/bin/env node
const { execSync } = require('child_process');
const path = require('path');

let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    const model = data.model.display_name;

    try {
        let remote = execSync('git remote get-url origin', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
        // Convert SSH to HTTPS format
        remote = remote.replace(/^git@github\.com:/, 'https://github.com/').replace(/\.git$/, '');
        const repoName = path.basename(remote);
        // OSC 8 escape sequences
        const link = `\x1b]8;;${remote}\x07${repoName}\x1b]8;;\x07`;
        console.log(`[${model}] 🔗 ${link}`);
    } catch {
        console.log(`[${model}]`);
    }
});

Ratenlimit-Nutzung

Zeigen Sie die Rate-Limit-Nutzung Ihres claude.ai-Abonnements oder Ihre Ausgaben im Verhältnis zum Ausgabenlimit eines Claude-Apps-Gateways in der Statuszeile an. Für Abonnenten kann das rate_limits-Objekt ein rollierendes five_hour-Fenster und ein wöchentliches seven_day-Fenster enthalten. Jedes Fenster bietet used_percentage von 0 bis 100 und resets_at, die Unix-Epochensekunden, zu denen das Fenster zurückgesetzt wird. Hinter einem Gateway lesen Sie das spend_limit-Objekt aus, das unter Felder für Ausgabenlimits beschrieben ist.

Das rate_limits-Objekt ist nur für claude.ai Pro-, Max- und Ultra-Abonnenten oder hinter einem Claude-Apps-Gateway mit Ausgabenlimits vorhanden, und zwar erst nach der ersten API-Antwort. Jedes Skript behandelt die fehlenden Felder problemlos und gibt hinter einem Gateway spend: $314.12 / $500 aus, oder spend: 63%, solange die Dollar-Felder fehlen:

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
# "// empty" produces no output when rate_limits is absent
FIVE_H=$(echo "$input" | jq -r '.rate_limits.five_hour.used_percentage // empty')
WEEK=$(echo "$input" | jq -r '.rate_limits.seven_day.used_percentage // empty')

LIMITS=""
[ -n "$FIVE_H" ] && LIMITS="5h: $(printf '%.0f' "$FIVE_H")%"
[ -n "$WEEK" ] && LIMITS="${LIMITS:+$LIMITS }7d: $(printf '%.0f' "$WEEK")%"

# Behind a Claude apps gateway: dollars when the gateway reports them, else the percentage
SPEND_PCT=$(echo "$input" | jq -r '.rate_limits.spend_limit.used_percentage // empty')
SPEND_USD=$(echo "$input" | jq -r '.rate_limits.spend_limit | select(.used_usd != null) | "$\(.used_usd) / $\(.limit_usd)"')
[ -n "$SPEND_PCT" ] && LIMITS="${LIMITS:+$LIMITS }spend: ${SPEND_USD:-$(printf '%.0f' "$SPEND_PCT")%}"

[ -n "$LIMITS" ] && echo "[$MODEL] | $LIMITS" || echo "[$MODEL]"

#!/usr/bin/env python3
import json, sys

data = json.load(sys.stdin)
model = data['model']['display_name']

parts = []
rate = data.get('rate_limits', {})
five_h = rate.get('five_hour', {}).get('used_percentage')
week = rate.get('seven_day', {}).get('used_percentage')

if five_h is not None:
    parts.append(f"5h: {five_h:.0f}%")
if week is not None:
    parts.append(f"7d: {week:.0f}%")

# Behind a Claude apps gateway: dollars when the gateway reports them, else the percentage
spend = rate.get('spend_limit', {})
if spend.get('used_percentage') is not None:
    if spend.get('used_usd') is not None:
        parts.append(f"spend: ${spend['used_usd']} / ${spend['limit_usd']}")
    else:
        parts.append(f"spend: {spend['used_percentage']:.0f}%")

if parts:
    print(f"[{model}] | {' '.join(parts)}")
else:
    print(f"[{model}]")

#!/usr/bin/env node
let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    const model = data.model.display_name;

    const parts = [];
    const fiveH = data.rate_limits?.five_hour?.used_percentage;
    const week = data.rate_limits?.seven_day?.used_percentage;

    if (fiveH != null) parts.push(`5h: ${Math.round(fiveH)}%`);
    if (week != null) parts.push(`7d: ${Math.round(week)}%`);

    // Behind a Claude apps gateway: dollars when the gateway reports them, else the percentage
    const spend = data.rate_limits?.spend_limit;
    if (spend?.used_percentage != null) {
        parts.push(spend.used_usd != null
            ? `spend: $${spend.used_usd} / $${spend.limit_usd}`
            : `spend: ${Math.round(spend.used_percentage)}%`);
    }

    console.log(parts.length ? `[${model}] | ${parts.join(' ')}` : `[${model}]`);
});

Teure Operationen zwischenspeichern

Ihr Statuszeilen-Skript wird während aktiver Sitzungen häufig ausgeführt. Befehle wie git status oder git diff können langsam sein, besonders in großen Repositories. Dieses Beispiel speichert Git-Informationen in einer temporären Datei und aktualisiert sie nur alle 5 Sekunden.

Der Cache-Dateiname muss über Statuszeilen-Invokationen innerhalb einer Sitzung stabil sein, aber eindeutig über Sitzungen hinweg, damit gleichzeitige Sitzungen in verschiedenen Repositories nicht den Cache-Git-Status des anderen lesen. Prozessbasierte Identifikatoren wie $$, os.getpid() oder process.pid ändern sich bei jeder Invokation und besiegen den Cache. Verwenden Sie stattdessen die session_id aus der JSON-Eingabe: Sie ist stabil für die Lebensdauer einer Sitzung und eindeutig pro Sitzung.

Jedes Skript prüft, ob die Cache-Datei fehlt oder älter als 5 Sekunden ist, bevor Git-Befehle ausgeführt werden:

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')
SESSION_ID=$(echo "$input" | jq -r '.session_id')

CACHE_FILE="/tmp/statusline-git-cache-$SESSION_ID"
CACHE_MAX_AGE=5  # seconds

cache_is_stale() {
    [ ! -f "$CACHE_FILE" ] || \
    # stat -c %Y (Linux) or stat -f %m (macOS) prints the file's last-modified
    # time. The Linux form must run first: on Linux, the macOS form prints a
    # filesystem report to stdout before failing, and that output would be
    # captured by the command substitution and break the arithmetic.
    [ $(($(date +%s) - $(stat -c %Y "$CACHE_FILE" 2>/dev/null || stat -f %m "$CACHE_FILE" 2>/dev/null || echo 0))) -gt $CACHE_MAX_AGE ]
}

if cache_is_stale; then
    if git rev-parse --git-dir > /dev/null 2>&1; then
        BRANCH=$(git branch --show-current 2>/dev/null)
        STAGED=$(git diff --cached --numstat 2>/dev/null | wc -l | tr -d ' ')
        MODIFIED=$(git diff --numstat 2>/dev/null | wc -l | tr -d ' ')
        echo "$BRANCH|$STAGED|$MODIFIED" > "$CACHE_FILE"
    else
        echo "||" > "$CACHE_FILE"
    fi
fi

IFS='|' read -r BRANCH STAGED MODIFIED < "$CACHE_FILE"

if [ -n "$BRANCH" ]; then
    echo "[$MODEL] 📁 ${DIR##*/} | 🌿 $BRANCH +$STAGED ~$MODIFIED"
else
    echo "[$MODEL] 📁 ${DIR##*/}"
fi

#!/usr/bin/env python3
import json, sys, subprocess, os, time

data = json.load(sys.stdin)
model = data['model']['display_name']
directory = os.path.basename(data['workspace']['current_dir'])
session_id = data['session_id']

CACHE_FILE = f"/tmp/statusline-git-cache-{session_id}"
CACHE_MAX_AGE = 5  # seconds

def cache_is_stale():
    if not os.path.exists(CACHE_FILE):
        return True
    return time.time() - os.path.getmtime(CACHE_FILE) > CACHE_MAX_AGE

if cache_is_stale():
    try:
        subprocess.check_output(['git', 'rev-parse', '--git-dir'], stderr=subprocess.DEVNULL)
        branch = subprocess.check_output(['git', 'branch', '--show-current'], text=True).strip()
        staged = subprocess.check_output(['git', 'diff', '--cached', '--numstat'], text=True).strip()
        modified = subprocess.check_output(['git', 'diff', '--numstat'], text=True).strip()
        staged_count = len(staged.split('\n')) if staged else 0
        modified_count = len(modified.split('\n')) if modified else 0
        with open(CACHE_FILE, 'w') as f:
            f.write(f"{branch}|{staged_count}|{modified_count}")
    except:
        with open(CACHE_FILE, 'w') as f:
            f.write("||")

with open(CACHE_FILE) as f:
    branch, staged, modified = f.read().strip().split('|')

if branch:
    print(f"[{model}] 📁 {directory} | 🌿 {branch} +{staged} ~{modified}")
else:
    print(f"[{model}] 📁 {directory}")

#!/usr/bin/env node
const { execSync } = require('child_process');
const fs = require('fs');
const path = require('path');

let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    const model = data.model.display_name;
    const dir = path.basename(data.workspace.current_dir);
    const sessionId = data.session_id;

    const CACHE_FILE = `/tmp/statusline-git-cache-${sessionId}`;
    const CACHE_MAX_AGE = 5; // seconds

    const cacheIsStale = () => {
        if (!fs.existsSync(CACHE_FILE)) return true;
        return (Date.now() / 1000) - fs.statSync(CACHE_FILE).mtimeMs / 1000 > CACHE_MAX_AGE;
    };

    if (cacheIsStale()) {
        try {
            execSync('git rev-parse --git-dir', { stdio: 'ignore' });
            const branch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
            const staged = execSync('git diff --cached --numstat', { encoding: 'utf8' }).trim().split('\n').filter(Boolean).length;
            const modified = execSync('git diff --numstat', { encoding: 'utf8' }).trim().split('\n').filter(Boolean).length;
            fs.writeFileSync(CACHE_FILE, `${branch}|${staged}|${modified}`);
        } catch {
            fs.writeFileSync(CACHE_FILE, '||');
        }
    }

    const [branch, staged, modified] = fs.readFileSync(CACHE_FILE, 'utf8').trim().split('|');

    if (branch) {
        console.log(`[${model}] 📁 ${dir} | 🌿 ${branch} +${staged} ~${modified}`);
    } else {
        console.log(`[${model}] 📁 ${dir}`);
    }
});

Windows-Konfiguration

Unter Windows führt Claude Code Statuszeilen-Befehle über Git Bash aus, wenn Git Bash installiert ist, oder über PowerShell, wenn Git Bash nicht vorhanden ist.

Git Bash behandelt unquotierte Backslashes als Escape-Zeichen, daher erreicht ein Windows-Pfad wie C:\Users\username\script.mjs den Skript-Runner mit entfernten Trennzeichen und der Befehl schlägt ohne sichtbaren Fehler fehl. Schreiben Sie Dateipfade in der command Zeichenkette mit Schrägstrichen, wie in den folgenden Beispielen gezeigt. Die ~ Abkürzung funktioniert auch und wird zu Ihrem Windows-Basisverzeichnis erweitert.

Um ein PowerShell-Skript als Statuszeile auszuführen, rufen Sie es über powershell auf. Dies funktioniert, ob Claude Code den Befehl über Git Bash oder PowerShell leitet:

{
  "statusLine": {
    "type": "command",
    "command": "powershell -NoProfile -File C:/Users/username/.claude/statusline.ps1"
  }
}

$input_json = $input | Out-String | ConvertFrom-Json
$cwd = $input_json.cwd
$model = $input_json.model.display_name
$used = $input_json.context_window.used_percentage
$dirname = Split-Path $cwd -Leaf

if ($used) {
    Write-Host "$dirname [$model] ctx: $used%"
} else {
    Write-Host "$dirname [$model]"
}

Oder führen Sie ein Bash-Skript direkt aus:

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  }
}

#!/usr/bin/env bash
input=$(cat)
cwd=$(echo "$input" | grep -o '"cwd":"[^"]*"' | cut -d'"' -f4)
model=$(echo "$input" | grep -o '"display_name":"[^"]*"' | cut -d'"' -f4)
dirname="${cwd##*[/\\]}"
echo "$dirname [$model]"

Subagent-Statuszeilen

Die subagentStatusLine Einstellung rendert einen benutzerdefinierten Zeilenkörper für jeden Subagenten, der im Agent-Panel unterhalb der Eingabeaufforderung angezeigt wird. Verwenden Sie sie, um die Standard-name · description · token count Zeile durch Ihre eigene Formatierung zu ersetzen.

{
  "subagentStatusLine": {
    "type": "command",
    "command": "~/.claude/subagent-statusline.sh"
  }
}

Der Befehl wird einmal pro Aktualisierungstick ausgeführt und erhält alle sichtbaren Subagenten-Zeilen als einzelnes JSON-Objekt auf stdin. Die Eingabe enthält die Basis-Hook-Felder, ein columns Feld mit der nutzbaren Zeilenbreite und ein tasks Array mit einem Eintrag pro Zeile, beschrieben unter Aufgabenfelder.

Schreiben Sie eine JSON-Zeile auf stdout pro Zeile, die Sie überschreiben möchten, in der Form {"id": "<task id>", "content": "<row body>"}. Der content String wird wie vorhanden gerendert, einschließlich ANSI-Farben und OSC 8 Hyperlinks. Lassen Sie die id einer Aufgabe weg, um die Standard-Rendering für diese Zeile zu behalten; geben Sie einen leeren content String aus, um sie auszublenden.

Die gleichen Vertrauens-, disableAllHooks- und allowManagedHooksOnly Gates, die für statusLine gelten, gelten auch hier. Plugins können eine Standard-subagentStatusLine in ihrer settings.json versenden, aber im Gegensatz zu Hooks werden Plugin-Werte nicht unter allowManagedHooksOnly ausgeführt, auch wenn das Plugin in verwalteten Einstellungen enabledPlugins erzwungen aktiviert ist.

Aufgabenfelder

Jeder Eintrag im tasks Array beschreibt eine Subagenten-Zeile mit den unten aufgeführten Feldern. Als optional gekennzeichnete Felder werden weggelassen, wenn sie keinen Wert haben. Berücksichtigen Sie daher in Ihrem Skript, dass sie fehlen können.

Tipps

• Mit Mock-Eingabe testen: echo '{"model":{"display_name":"Opus"},"workspace":{"current_dir":"/home/user/project"},"context_window":{"used_percentage":25},"session_id":"test-session-abc"}' | ./statusline.sh
• Ausgabe kurz halten: Die Statusleiste hat begrenzte Breite, daher kann lange Ausgabe abgeschnitten oder unangenehm umgebrochen werden
• Langsame Operationen zwischenspeichern: Ihr Skript wird während aktiver Sitzungen häufig ausgeführt, daher können Befehle wie git status zu Verzögerungen führen. Siehe das Caching-Beispiel für die Handhabung.

Community-Projekte wie ccstatusline und starship-claude bieten vorkonfigurierte Konfigurationen mit Designs und zusätzlichen Funktionen.

Fehlerbehebung

Wenn die Statuszeile leer ist, beginnen Sie mit Statuszeile wird nicht angezeigt. Auch ein Ordner, dem Sie nicht vertraut haben, und ein fehlschlagendes Skript führen dazu, dass sie leer bleibt, wie in Workspace-Vertrauen erforderlich und Skriptfehler oder Hängen beschrieben.

Statuszeile wird nicht angezeigt

Wenn Sie eine Statuszeile konfiguriert haben und am unteren Rand der Oberfläche nichts angezeigt wird, gehen Sie diese Prüfungen durch:

• Überprüfen Sie, dass Ihr Skript ausführbar ist: chmod +x ~/.claude/statusline.sh
• Überprüfen Sie, dass Ihr Skript auf stdout ausgibt, nicht auf stderr
• Führen Sie Ihr Skript manuell aus, um zu überprüfen, dass es Ausgabe erzeugt
• Unter Windows mit installiertem Git Bash werden Backslashes im command-Pfad wahrscheinlich als Escape-Zeichen verarbeitet, bevor das Skript ausgeführt wird. Verwenden Sie Schrägstriche im Pfad. Siehe Windows-Konfiguration.
• Wenn disableAllHooks nach Anwendung des Vorrangs der Einstellungen außerhalb verwalteter Einstellungen auf true gesetzt ist, führt Claude Code nur eine statusLine aus verwalteten Einstellungen aus, und ohne verwaltete statusLine ist die Statuszeile deaktiviert. Entfernen Sie die Einstellung oder setzen Sie sie auf false in der Datei, die sie setzt, um sie erneut zu aktivieren. Siehe disableAllHooks.
• Wenn Ihre Organisation allowManagedHooksOnly in verwalteten Einstellungen setzt, verschwindet Ihre benutzerdefinierte Statuszeile ohne Warnung: Sie können nur eine Statuszeile aus einem statusLine-Wert in diesen verwalteten Einstellungen erhalten. Siehe was unter allowManagedHooksOnly ausgeführt wird für das vollständige Verhalten, und fragen Sie Ihren Administrator, ob diese Einstellung für Sie gilt.
• Führen Sie claude --debug aus, um den stderr Ihres Skripts bei jeder Statuszeilen-Invokation zu protokollieren, und seinen Exit-Code bei der ersten Invokation in einer Sitzung
• Bitten Sie Claude, Ihre Einstellungsdatei zu lesen und den statusLine-Befehl direkt auszuführen, um Fehler zu finden

Statuszeile zeigt -- oder leere Werte

Felder können null sein, bevor die erste API-Antwort abgeschlossen ist. Behandeln Sie Null-Werte in Ihrem Skript daher mit Fallbacks wie // 0 in jq. Starten Sie Claude Code neu, wenn Werte nach mehreren Nachrichten leer bleiben.

Kontextprozentsatz zeigt unerwartete Werte

Die Statuszeile meldet die Zählungen aus der letzten API-Antwort, während /context eine Schätzung für seit dieser Antwort hinzugefügte Nachrichten hinzufügt, sodass /context bis zur nächsten Antwort höher angezeigt werden kann. Verwenden Sie used_percentage für den einfachsten genauen Kontextzustand. Die Formel hinter used_percentage finden Sie unter Kontextfenster-Felder.

OSC 8-Links nicht anklickbar

Ob ein Link anklickbar ist, hängt von Ihrem Terminal ab, davon, ob Claude Code darin Hyperlink-Unterstützung erkennt, ob SSH oder tmux die Escape-Sequenz entfernt, und davon, wie Ihr Skript sie ausgibt:

• Überprüfen Sie, dass Ihr Terminal OSC 8-Hyperlinks unterstützt (iTerm2, Kitty, WezTerm)

• Terminal.app unterstützt keine anklickbaren Links

• Wenn Link-Text angezeigt wird, aber nicht anklickbar ist, hat Claude Code möglicherweise keine Hyperlink-Unterstützung in Ihrem Terminal erkannt. Setzen Sie die FORCE_HYPERLINK-Umgebungsvariable, um die Erkennung zu überschreiben, bevor Sie Claude Code starten:

  FORCE_HYPERLINK=1 claude
  

  In PowerShell setzen Sie die Variable zuerst in der aktuellen Sitzung:

  $env:FORCE_HYPERLINK = "1"; claude
  

• SSH- und tmux-Sitzungen können OSC-Sequenzen je nach Konfiguration entfernen

• Wenn Escape-Sequenzen als Literaltext wie \e]8;; angezeigt werden, verwenden Sie printf '%b' anstelle von echo -e für zuverlässigere Escape-Behandlung

Anzeigeglitches mit Escape-Sequenzen

Komplexe Escape-Sequenzen (ANSI-Farben, OSC 8-Links) können gelegentlich zu beschädigter Ausgabe führen, wenn sie mit anderen UI-Aktualisierungen überlappen. Mehrzeilige Statuszeilen mit Escape-Codes sind anfälliger für Rendering-Probleme als einzeilige einfache Texte.

Wenn Sie beschädigten Text sehen, versuchen Sie, Ihr Skript auf einfache Textausgabe zu vereinfachen.

Workspace-Vertrauen erforderlich

Bis Sie den Workspace-Vertrauensdialog akzeptieren, bleibt die Statuszeile leer. Da statusLine einen Shell-Befehl ausführt, führt Claude Code ihn unter der gleichen Workspace-Vertrauensregel wie Hooks in Einstellungsdateien aus. Das Akzeptieren des Dialogs für den Ordner oder für ein übergeordnetes Verzeichnis, dessen Vertrauen sich auf ihn erstreckt, ist ausreichend.

Bis dahin protokolliert claude --debug Status line command skipped: workspace trust not accepted. Starten Sie Claude Code neu und akzeptieren Sie den Vertrauensdialog, um sie zu aktivieren.

Skriptfehler oder Hängen

Claude Code zeigt die Ausgabe Ihres Skripts erst an, nachdem das Skript mit Code 0 beendet wurde:

• Skripte, die mit Nicht-Null-Codes beendet werden oder keine Ausgabe erzeugen, führen dazu, dass die Statuszeile leer wird
• Langsame Skripte blockieren die Statuszeilen-Aktualisierung, bis sie abgeschlossen sind. Halten Sie Skripte schnell, um veraltete Ausgabe zu vermeiden.
• Wenn eine neue Aktualisierung ausgelöst wird, während ein langsames Skript läuft, wird das laufende Skript abgebrochen
• Testen Sie Ihr Skript unabhängig mit Mock-Eingabe, bevor Sie es konfigurieren

Benachrichtigungen teilen sich die Statuszeilen-Zeile

Außerhalb des Vollbildmodus zeigt Claude Code Benachrichtigungen in der gleichen Zeile wie Ihre Statuszeile an. Im Vollbildmodus gibt Claude Code Benachrichtigungen eine eigene Zeile.

• Systembenachrichtigungen wie MCP-Serverfehler und automatische Updates werden auf der rechten Seite der Zeile angezeigt. Vorübergehende Benachrichtigungen wie die Kontext-niedrig-Warnung zirkulieren auch durch diesen Bereich.
• Das Aktivieren des ausführlichen Modus fügt diesem Bereich einen Token-Zähler hinzu, der die Größe Ihres Kontexts so anzeigt, wie die letzte API-Antwort sie gemeldet hat, nicht die Zählung pro Turn neben dem Spinner
• Auf schmalen Terminals können diese Benachrichtigungen Ihre Statuszeilen-Ausgabe abschneiden