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 unter der Haube passiert, indem Sie manuell eine Statuszeile erstellen, die das aktuelle Modell, das Arbeitsverzeichnis und den Prozentsatz der Kontextfensternutzung anzeigt.

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

#!/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"

chmod +x ~/.claude/statusline.sh

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

Wie Statuszeilen funktionieren

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

Wann es aktualisiert wird

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

• Eine neue Assistentnachricht ankommt
• /compact abgeschlossen ist
• Der Berechtigungsmodus sich ändert
• Der Vim-Modus umgeschaltet wird
• Sie den command in Ihren statusLine-Einstellungen ändern
• Ein refreshInterval-Timer abläuft, falls Sie einen festgelegt haben
• Ein Rate-Limit-Fenster in den Daten, die Ihr Skript zuletzt erhalten hat, seine resets_at-Zeit erreicht
• Ein warmer Prompt-Cache in den Daten, die Ihr Skript zuletzt erhalten hat, seine expires_at-Zeit erreicht

Claude Code entprellt Aktualisierungen bei 300 ms, sodass schnelle Änderungen zusammengefasst werden und Ihr Skript einmal ausgeführt wird, nachdem die Änderungen aufgehört haben. Eine Änderung des 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, werden die Änderungen beim nächsten Mal angezeigt, wenn ein Aktualisierungs-Trigger es erneut ausführt.

Die ereignisgesteuerten Trigger können ruhig werden, wenn die Hauptsitzung untätig ist, beispielsweise während ein Koordinator auf Hintergrund-Subagenten wartet. Um zeitbasierte oder extern bezogene Segmente während untätiger Perioden aktuell zu halten, setzen Sie refreshInterval, um den Befehl auch auf einem festen Timer erneut auszuführen.

Was Ihr Skript ausgeben kann

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

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 sprachgestützte Breitenerkennung die Terminalgröße nicht von innerhalb des Skripts lesen. Lesen Sie stattdessen die Umgebungsvariablen COLUMNS und LINES. Claude Code setzt diese auf die aktuellen Terminaldimensionen, bevor Ihr Skript ausgeführt wird.

Verfügbare Daten

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

{
"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",
"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
}
},
"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"
}
}

Kontextfenster-Felder

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

• Kombinierte Summen (total_input_tokens, total_output_tokens): Token, die sich derzeit im Kontextfenster befinden. total_input_tokens ist die Summe von input_tokens, cache_creation_input_tokens und cache_read_input_tokens; total_output_tokens sind die Ausgabe-Token aus der letzten Antwort. Beide sind 0 vor der ersten API-Antwort.
• Pro-Komponenten-Nutzung (current_usage): die gleichen Token-Zählungen nach Kategorie aufgeschlüsselt. Verwenden Sie dies, wenn Sie Cache-Treffer separat von frischer Eingabe benötigen.

Das current_usage Objekt enthält:

• input_tokens: Eingabe-Token im aktuellen Kontext
• output_tokens: generierte Ausgabe-Token
• cache_creation_input_tokens: Token, die in den Cache geschrieben wurden
• cache_read_input_tokens: Token, die aus dem Cache gelesen wurden

Für die Bedeutung der Cache-Felder und deren Abrechnung siehe Cache-Leistung überprüfen.

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

Wenn Sie den Kontextprozentsatz manuell aus current_usage berechnen, verwenden Sie die gleiche Eingabe-only-Formel, um used_percentage zu entsprechen.

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

Prompt-Cache-Felder

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

Das Objekt erscheint nach der ersten API-Antwort der Hauptkonversation. Claude Code zählt Subagent-Anfragen nicht in diese Statistiken ein. Erfordert Claude Code v2.1.251 oder später.

Die Tabelle listet jedes Feld mit seiner Bedeutung auf. Zeitstempel sind Unix-Epochensekunden, die gleiche Einheit wie rate_limits.*.resets_at. Eine kurze Statuszeile zeigt normalerweise ein oder zwei davon; warm und hit_ratio fassen den Cache-Status am direktesten zusammen.

Claude Code zeigt die gleichen Statistiken im Terminal auf der /usage Befehlszeile Prompt cache (main).

Letzte Miss-Ursache

Das last_miss_cause Objekt meldet, was Claude Code als wahrscheinliche Ursache des letzten Miss identifiziert hat. Sein causes Array enthält einen oder mehrere Ursachennamen, wie tools_changed, system_prompt_changed, ttl_expired_5m oder likely_server_side. Das Objekt ist null, bis der erste Miss der Sitzung auftritt, und erneut, wenn Claude Code keine Ursache für den letzten Miss identifizieren konnte. Erfordert Claude Code v2.1.260 oder später.

Zwei Ursachen fügen Zählungen zum Objekt hinzu:

• tools_added und tools_removed: mit tools_changed, wie viele Tools zur Anfrage hinzugefügt oder aus ihr entfernt wurden
• system_char_delta: mit 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 Ratenlimit-Nutzung des Claude.ai-Abonnements in der Statuszeile an. Das rate_limits Objekt enthält ein rollierendes five_hour Fenster und ein wöchliches seven_day Fenster. Jedes Fenster bietet used_percentage (0 bis 100) und resets_at (Unix-Epochensekunden, wenn das Fenster zurückgesetzt wird).

Hinter einem Claude-Apps-Gateway mit Ausgabenlimits enthält rate_limits spend_limit mit den gleichen zwei Feldern für das Ausgabenlimit, das für Sie gilt, außer dass sein used_percentage über 100 gehen kann, sobald Sie das Limit überschreiten. Erfordert Claude Code v2.1.251 oder später.

Das rate_limits Objekt ist nur für Claude.ai Pro und Max Abonnenten oder hinter einem Claude-Apps-Gateway mit Ausgabenlimits vorhanden und nur nach der ersten API-Antwort. Jedes Skript behandelt das fehlende Feld elegant:

#!/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")%"

[ -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}%")

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)}%`);

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 mit allen sichtbaren Subagenten-Zeilen ausgeführt, die als einzelnes JSON-Objekt auf stdin übergeben werden. Die Eingabe enthält die Basis-Hook-Felder, ein columns Feld mit der nutzbaren Zeilenbreite und ein tasks Array. Jede Aufgabe hat id, name, type, status, description, label, startTime, model, effort, contextWindowSize, tokenCount, tokenSamples und cwd.

Das model Feld pro Aufgabe ist die aufgelöste Modell-ID, auf der die Aufgabe ausgeführt wird. contextWindowSize ist das Kontextfenster dieses Modells in Token, berechnet auf die gleiche Weise wie das context_window.context_window_size der Hauptstatuszeile, sodass Sie einen Prozentsatz pro Zeile aus tokenCount rendern können. Beide Felder erfordern Claude Code v2.1.205 oder später und werden für eine Aufgabe weggelassen, deren Modell noch nicht aufgelöst ist.

Das effort Feld pro Aufgabe ist der Reasoning-Aufwand, der für diesen Subagenten festgelegt ist, in seiner Definition Frontmatter oder beim einzelnen Aufruf. Der Wert ist entweder einer der Aufwand-Level-Strings low, medium, high, xhigh oder max, oder ein numerisches Token-Budget. Das Feld meldet den konfigurierten Wert wie geschrieben: Wenn das Modell diesen Level nicht unterstützt, kann sich der Aufwand, den Claude Code tatsächlich anwendet, unterscheiden. Das Feld erfordert Claude Code v2.1.214 oder später und fehlt, wenn der Subagent den Aufwand-Level der Sitzung erbt.

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.

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

Statuszeile wird nicht angezeigt

• Ü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 der Einstellungspriorität 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 Exit-Code und stderr aus der ersten Statuszeilen-Invokation in einer Sitzung zu protokollieren
• 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 mit Fallbacks wie // 0 in jq
• Starten Sie Claude Code neu, wenn Werte nach mehreren Nachrichten leer bleiben

Kontextprozentsatz zeigt unerwartete Werte

• Verwenden Sie used_percentage für den einfachsten genauen Kontextzustand
• Der Kontextprozentsatz kann sich von der /context-Ausgabe unterscheiden, je nachdem, wann jeder berechnet wird

OSC 8-Links nicht anklickbar

• Ü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
• Wenn Sie beschädigten Text sehen, versuchen Sie, Ihr Skript auf einfache Textausgabe zu vereinfachen
• Mehrzeilige Statuszeilen mit Escape-Codes sind anfälliger für Rendering-Probleme als einzeilige einfache Texte

Workspace-Vertrauen erforderlich

• 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 bleibt die Statuszeile leer, und claude --debug protokolliert Status line command skipped: workspace trust not accepted. Starten Sie Claude Code neu und akzeptieren Sie den Vertrauensdialog, um ihn zu aktivieren.

Skriptfehler oder Hängen

• 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 einen Token-Zähler zu diesem Bereich hinzu
• Auf schmalen Terminals können diese Benachrichtigungen Ihre Statuszeilen-Ausgabe abschneiden