Claude Code Status Line - Complete Guide: all fields, config, ready-to-use scripts
A persistent, customizable bar at the bottom of Claude Code that shows real-time session data.
- What Is It?
- Quick Start
- Want Mine?
- Available Data Fields
- Your Script Superpowers
- Ready-to-Use Scripts
- Full JSON Schema
- Tips and Tricks
- All Claude Code Settings
The status line is an info bar pinned to the bottom of your Claude Code window. Think of it like the status bar in VS Code or the bottom of a Google Doc — it just sits there showing you useful stuff while you work.
What can it show?
- Which AI model you're using
- Your project name and git branch
- How much of your conversation memory is used up (context %)
- How much the session has cost so far
- How long you've been working
- Lines of code added / removed
- …and more
How does it work? You tell Claude what you want to see, and it builds the status bar for you. No coding required on your part — just describe it in plain English.
Does it cost anything? Nope. It runs entirely on your machine. Zero API usage.
Just type a /statusline command describing what you want:
/statusline show model name and context percentage with a progress bar
Claude generates the script, saves it, and wires up settings for you. Done.
More examples:
/statusline show repo name, git branch, context bar, and model
/statusline show cost and session duration with model name
/statusline show git branch with colored staged/modified file counts
/statusline two lines: model and branch on top, color-coded context bar with cost on bottom
To remove it:
/statusline clear
Here's the exact status line I use daily. Fully color-coded with icons and a gradient context bar.
What it looks like:
| Element | Example | Color |
|---|---|---|
| Repo name | EasyClaw |
Bold yellow |
| Branch | 🌿 (main) |
Bold cyan |
| Context bar | ⚡ █████████░░░░░░░░░░░ 47% |
True RGB gradient (green → yellow → red) + dynamic emoji |
| Context emoji | 🟢 → ⚡ → 🔥 → 🚨 | Changes at 20% / 70% / 90% |
| Cost | $0.47 |
Yellow |
| Code velocity | +156 -23 |
Green adds, red deletes |
| Model | 🤖 Opus 4.6 |
Magenta |
| Separators | | |
Dim gray |
One command to get it:
/statusline single line, fully color-coded with truecolor RGB gradient: repo name bold yellow, 🌿 leaf icon + git branch in bold cyan with parentheses, 20-block context bar using 24-bit RGB gradient from green(0,200,80) through yellow(220,200,0) to red(220,40,20) with dark gray(60,60,60) empty blocks, dynamic emoji that changes with usage (🟢 under 20%, ⚡ 20-69%, 🔥 70-89%, 🚨 90%+), percentage colored by usage level, session cost in yellow, code velocity showing +lines in green and -lines in red, 🤖 robot icon + model name in magenta, dim gray pipe separators between all elements
Or copy the script directly:
#!/usr/bin/env bash
# Claude Code status line: RGB gradient, dynamic emoji, cost, code velocity
input=$(cat)
# ── Colors ──
CYAN='\033[36m'
GREEN='\033[32m'
YELLOW='\033[33m'
RED='\033[31m'
MAGENTA='\033[35m'
DIM='\033[2m'
BOLD='\033[1m'
RESET='\033[0m'
# ── Truecolor helper ──
rgb() { printf '\033[38;2;%d;%d;%dm' "$1" "$2" "$3"; }
# ── Parse JSON fields ──
model=$(echo "$input" | jq -r '.model.display_name // "Unknown"')
used=$(echo "$input" | jq -r '.context_window.used_percentage // empty')
cost=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
lines_add=$(echo "$input" | jq -r '.cost.total_lines_added // 0')
lines_del=$(echo "$input" | jq -r '.cost.total_lines_removed // 0')
cwd=$(echo "$input" | jq -r '.workspace.current_dir // .cwd // ""')
# ── Git info ──
branch=""
repo=""
if [ -n "$cwd" ]; then
branch=$(git -C "$cwd" --no-optional-locks symbolic-ref --short HEAD 2>/dev/null)
repo=$(basename "$(git -C "$cwd" --no-optional-locks rev-parse --show-toplevel 2>/dev/null)" 2>/dev/null)
fi
# ── Context bar: RGB gradient, full blocks only ──
BAR_WIDTH=20
if [ -n "$used" ]; then
used_int=$(printf '%.0f' "$used")
# Round to nearest block
filled=$(( (used_int * BAR_WIDTH + 50) / 100 ))
bar=""
for (( i=0; i<BAR_WIDTH; i++ )); do
pos=$(( i * 100 / (BAR_WIDTH - 1) ))
if [ "$pos" -le 50 ]; then
r=$(( 0 + 220 * pos / 50 ))
g=200
b=$(( 80 - 80 * pos / 50 ))
else
adj=$(( pos - 50 ))
r=220
g=$(( 200 - 160 * adj / 50 ))
b=$(( 0 + 20 * adj / 50 ))
fi
if [ "$i" -lt "$filled" ]; then
bar="${bar}$(rgb $r $g $b)█"
else
bar="${bar}\033[38;2;60;60;60m░"
fi
done
bar="${bar}${RESET}"
if [ "$used_int" -ge 90 ]; then status_emoji="🚨"
elif [ "$used_int" -ge 70 ]; then status_emoji="🔥"
elif [ "$used_int" -ge 20 ]; then status_emoji="⚡"
else status_emoji="🟢"; fi
if [ "$used_int" -ge 90 ]; then pct_color="$RED"
elif [ "$used_int" -ge 70 ]; then pct_color="$YELLOW"
else pct_color="$GREEN"; fi
ctx_part="${status_emoji} ${bar} ${pct_color}${used_int}%${RESET}"
else
ctx_part="🟢 \033[38;2;60;60;60m░░░░░░░░░░░░░░░░░░░░${RESET} --%"
fi
# ── Cost ──
cost_part="${YELLOW}$(printf '$%.2f' "$cost")${RESET}"
# ── Code velocity ──
velocity="${GREEN}+${lines_add}${RESET} ${RED}-${lines_del}${RESET}"
# ── Single line ──
out=""
[ -n "$repo" ] && out="${BOLD}${YELLOW}${repo}${RESET}"
[ -n "$branch" ] && out="${out:+$out }${BOLD}${CYAN}🌿 (${branch})${RESET}"
out="${out:+$out ${DIM}|${RESET} }${ctx_part}"
out="${out} ${DIM}|${RESET} ${cost_part}"
out="${out} ${DIM}|${RESET} ${velocity}"
out="${out} ${DIM}|${RESET} ${MAGENTA}🤖 ${model}${RESET}"
printf '%b' "$out"Every time your script runs, it receives JSON via stdin. Here is everything you can display.
| Field | What It Shows | Example Value |
|---|---|---|
model.id |
Model identifier | "claude-opus-4-6" |
model.display_name |
Friendly model name | "Opus" |
session_id |
Unique session ID | "abc123..." |
session_name |
Custom name (via /rename) |
"my-feature-work" |
version |
Claude Code version | "2.1.90" |
| Field | What It Shows | Example Value |
|---|---|---|
cwd |
Current working directory | "/Users/me/project" |
workspace.current_dir |
Same as cwd (preferred) |
"/Users/me/project" |
workspace.project_dir |
Where Claude Code was launched | "/Users/me/project" |
workspace.added_dirs |
Extra dirs added via /add-dir |
[] |
workspace.git_worktree |
Git worktree name (if in one) | "feature-xyz" |
| Field | What It Shows | Example |
|---|---|---|
context_window.used_percentage |
% of context used | 30 |
context_window.remaining_percentage |
% of context remaining | 70 |
context_window.context_window_size |
Max tokens (200K or 1M) | 200000 |
context_window.total_input_tokens |
Cumulative input tokens | 15234 |
context_window.total_output_tokens |
Cumulative output tokens | 4521 |
context_window.current_usage.input_tokens |
Input tokens in last API call | 8500 |
context_window.current_usage.output_tokens |
Output tokens from last call | 1200 |
context_window.current_usage.cache_creation_input_tokens |
Tokens written to cache | 5000 |
context_window.current_usage.cache_read_input_tokens |
Tokens read from cache | 2000 |
exceeds_200k_tokens |
Last response exceeded 200K | false |
| Field | What It Shows | Example Value |
|---|---|---|
cost.total_cost_usd |
Total session cost (USD) | 0.01234 |
cost.total_duration_ms |
Wall-clock time since start | 45000 |
cost.total_api_duration_ms |
Time waiting for API responses | 2300 |
cost.total_lines_added |
Lines of code added | 156 |
cost.total_lines_removed |
Lines of code removed | 23 |
| Field | What It Shows | Example Value |
|---|---|---|
rate_limits.five_hour.used_percentage |
5-hour usage % | 23.5 |
rate_limits.five_hour.resets_at |
Reset time (Unix epoch) | 1738425600 |
rate_limits.seven_day.used_percentage |
7-day usage % | 41.2 |
rate_limits.seven_day.resets_at |
Reset time (Unix epoch) | 1738857600 |
| Field | When It Appears | Example Value |
|---|---|---|
vim.mode |
When vim mode is enabled | "NORMAL" or "INSERT" |
output_style.name |
Current output style | "default" |
agent.name |
When using --agent flag |
"security-reviewer" |
worktree.name |
During --worktree sessions |
"my-feature" |
worktree.path |
Worktree directory path | "/path/to/worktree" |
worktree.branch |
Worktree git branch | "worktree-my-feature" |
worktree.original_cwd |
Dir before entering worktree | "/path/to/project" |
worktree.original_branch |
Branch before entering worktree | "main" |
transcript_path |
Path to conversation transcript | "/path/to/transcript" |
Each echo / print creates a separate row:
echo "Line 1: Model and branch info"
echo "Line 2: Context bar and cost"+-----------------------------------------------------------------+
| [Opus] EasyClaw | main |
| [####......] 40% | $0.23 | 12m 5s |
+-----------------------------------------------------------------+
Use escape codes for colored output:
GREEN='\033[32m'
YELLOW='\033[33m'
RED='\033[31m'
CYAN='\033[36m'
RESET='\033[0m'
echo -e "${GREEN}All good${RESET} | ${RED}Warning${RESET}"Use OSC 8 escape sequences (requires iTerm2, Kitty, or WezTerm):
printf '%b' "\e]8;;https://github.com/user/repo\aRepo Name\e]8;;\a"Hold Cmd (macOS) or Ctrl (Windows/Linux) and click to open.
Copy any of these and pass them to /statusline, or just describe what you want in plain English.
[Opus] [###.......] 30%
#!/bin/bash
input=$(cat)
MODEL=$(echo "$input" | jq -r '.model.display_name')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)
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%"EasyClaw (main) [███░░░░░░░] 30% Claude Opus 4
#!/bin/bash
input=$(cat)
model=$(echo "$input" | jq -r '.model.display_name // "Unknown Model"')
used=$(echo "$input" | jq -r '.context_window.used_percentage // empty')
if [ -n "$used" ]; then
used_int=$(printf '%.0f' "$used")
filled=$(( used_int / 10 ))
empty=$(( 10 - filled ))
bar=""
for i in $(seq 1 $filled); do bar="${bar}█"; done
for i in $(seq 1 $empty); do bar="${bar}░"; done
ctx_part="[${bar}] ${used_int}%"
else
ctx_part="[░░░░░░░░░░] --%"
fi
cwd=$(echo "$input" | jq -r '.workspace.current_dir // .cwd // ""')
branch=""
repo=""
if [ -n "$cwd" ]; then
branch=$(git -C "$cwd" --no-optional-locks symbolic-ref --short HEAD 2>/dev/null)
repo=$(basename "$(git -C "$cwd" --no-optional-locks rev-parse --show-toplevel 2>/dev/null)" 2>/dev/null)
fi
out=""
[ -n "$repo" ] && out="$repo"
[ -n "$branch" ] && out="${out:+$out }(${branch})"
out="${out:+$out }${ctx_part} ${model}"
printf '%s' "$out"[Opus] EasyClaw | main +2 ~5
#!/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[Opus] $0.23 | 12m 5s
#!/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"[Opus] EasyClaw | main
[####......] 40% | $0.23 | 12m 5s
Context bar changes color: green < 70% | yellow 70-89% | red 90%+
#!/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'
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"[Opus] 5h: 23% | 7d: 41%
#!/bin/bash
input=$(cat)
MODEL=$(echo "$input" | jq -r '.model.display_name')
FIVE_HR=$(echo "$input" | jq -r '.rate_limits.five_hour.used_percentage // empty')
SEVEN_DAY=$(echo "$input" | jq -r '.rate_limits.seven_day.used_percentage // empty')
out="[$MODEL]"
[ -n "$FIVE_HR" ] && out="$out 5h: $(printf '%.0f' "$FIVE_HR")%"
[ -n "$SEVEN_DAY" ] && out="$out | 7d: $(printf '%.0f' "$SEVEN_DAY")%"
echo "$out"This is the complete JSON your script receives on stdin:
{
"cwd": "/current/working/directory",
"session_id": "abc123...",
"session_name": "my-session",
"transcript_path": "/path/to/transcript.jsonl",
"model": {
"id": "claude-opus-4-6",
"display_name": "Opus"
},
"workspace": {
"current_dir": "/current/working/directory",
"project_dir": "/original/project/directory",
"added_dirs": [],
"git_worktree": "feature-xyz"
},
"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": 15234,
"total_output_tokens": 4521,
"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,
"rate_limits": {
"five_hour": {
"used_percentage": 23.5,
"resets_at": 1738425600
},
"seven_day": {
"used_percentage": 41.2,
"resets_at": 1738857600
}
},
"vim": {
"mode": "NORMAL"
},
"agent": {
"name": "security-reviewer"
},
"worktree": {
"name": "my-feature",
"path": "/path/to/.claude/worktrees/my-feature",
"branch": "worktree-my-feature",
"original_cwd": "/path/to/project",
"original_branch": "main"
}
}Fields that may be absent:
session_name-- only when set via--nameor/renameworkspace.git_worktree-- only inside a linked git worktreevim-- only when vim mode is enabledagent-- only when using--agentworktree-- only during--worktreesessionsrate_limits-- only for Claude.ai Pro/Max after first API response
Fields that may be null:
context_window.current_usage--nullbefore first API callcontext_window.used_percentage-- may benullearly in session
| Tip | Details |
|---|---|
| When does it update? | After each assistant message, permission mode change, or vim mode toggle. Debounced at 300ms. |
| No API tokens used | Status line runs locally -- completely free. |
| Hides during prompts | Temporarily hidden during autocomplete, help menu, and permission prompts. |
| Can use any language | Bash, Python, Node.js -- anything that reads stdin and prints to stdout. |
| Test your script | Pipe sample JSON: `echo '{"model":{"display_name":"Opus"}}' |
Every setting lives in settings.json. There are three levels, loaded in order (later overrides earlier):
| Level | Path | Scope |
|---|---|---|
| User | ~/.claude/settings.json |
All projects on your machine |
| Project | .claude/settings.json (in repo root) |
Everyone on this repo |
| Managed | ~/.claude/settings.managed.json |
Enterprise IT policy (read-only) |
| Setting | Type | Default | What It Does |
|---|---|---|---|
model |
string |
"claude-sonnet-4-6" |
Default model for all sessions |
availableModels |
string[] |
all | Restrict which models users can pick |
effortLevel |
"auto" | "low" | "medium" | "high" |
varies | Opus 4.6 reasoning depth — lower = faster & cheaper |
fastMode |
boolean |
false |
2.5x faster output, higher per-token cost (same model) |
fastModePerSessionOptIn |
boolean |
false |
Require /fast each session instead of persisting |
language |
string |
— | Preferred language for Claude's responses |
outputStyle |
string |
"default" |
Response style: default, Explanatory, Learning, or custom |
alwaysThinkingEnabled |
boolean |
false |
Extended thinking on by default for all sessions |
| Setting | Type | Default | What It Does |
|---|---|---|---|
statusLine.type |
"command" |
— | Must be "command" to enable a custom status line |
statusLine.command |
string |
— | Shell command or script path that reads JSON stdin, prints status to stdout |
statusLine.padding |
number |
0 |
Extra horizontal spacing characters around the status line content |
| Setting | Type | Default | What It Does |
|---|---|---|---|
permissions.defaultMode |
string |
"default" |
Default permission mode: default, plan, bypassPermissions, etc. |
permissions.allow |
string[] |
[] |
Tools always allowed without asking |
permissions.deny |
string[] |
[] |
Tools always denied |
allowManagedPermissionRulesOnly |
boolean |
false |
(Managed only) Block user/project permission rules |
| Setting | Type | Default | What It Does |
|---|---|---|---|
spinnerTipsEnabled |
boolean |
true |
Show tips in the spinner while Claude works |
spinnerTipsOverride |
object |
— | Custom tip messages for the spinner |
spinnerVerbs |
object |
— | Custom verbs shown in spinner progress |
terminalProgressBarEnabled |
boolean |
true |
Progress bar in terminals that support it (Windows Terminal, iTerm2) |
showTurnDuration |
boolean |
true |
Show "Cooked for 1m 6s" after responses |
prefersReducedMotion |
boolean |
false |
Disable UI animations (spinners, shimmer, flash) for accessibility |
companyAnnouncements |
string[] |
— | (Managed only) Startup messages, one picked randomly |
| Setting | Type | Default | What It Does |
|---|---|---|---|
enabledPlugins |
object |
{} |
Map of "plugin@marketplace": true to enable plugins |
extraKnownMarketplaces |
object |
{} |
Additional plugin marketplace sources |
pluginConfigs |
object |
{} |
Per-plugin configuration (MCP user configs, etc.) |
skippedPlugins |
string[] |
[] |
Plugins you declined when prompted |
skippedMarketplaces |
string[] |
[] |
Marketplaces you declined when prompted |
strictKnownMarketplaces |
string[] |
— | (Managed only) Allowlist of permitted marketplaces |
blockedMarketplaces |
string[] |
— | (Managed only) Blocked marketplace sources |
pluginTrustMessage |
string |
— | (Managed only) Custom message on plugin trust warning |
| Setting | Type | Default | What It Does |
|---|---|---|---|
enableAllProjectMcpServers |
boolean |
false |
Auto-approve all MCP servers in the project |
enabledMcpjsonServers |
string[] |
[] |
Approved MCP servers from .mcp.json |
disabledMcpjsonServers |
string[] |
[] |
Rejected MCP servers from .mcp.json |
allowedMcpServers |
string[] |
— | Enterprise allowlist (undefined = allow all) |
deniedMcpServers |
string[] |
— | Enterprise denylist (takes precedence over allow) |
allowManagedMcpServersOnly |
boolean |
false |
(Managed only) Only admin-defined MCP servers apply |
| Setting | Type | Default | What It Does |
|---|---|---|---|
hooks |
object |
{} |
Custom commands before/after tool executions |
disableAllHooks |
boolean |
false |
Kill all hooks and statusLine execution |
allowManagedHooksOnly |
boolean |
false |
(Managed only) Block user/project/plugin hooks |
allowedHttpHookUrls |
string[] |
— | URL patterns HTTP hooks may target (supports * wildcard) |
httpHookAllowedEnvVars |
string[] |
— | Env vars HTTP hooks may use in headers |
| Setting | Type | Default | What It Does |
|---|---|---|---|
respectGitignore |
boolean |
true |
@ file picker respects .gitignore patterns |
autoMemoryEnabled |
boolean |
true |
Auto-save useful context to .claude/memory/ |
claudeMdExcludes |
string[] |
[] |
Glob patterns for CLAUDE.md files to skip loading |
cleanupPeriodDays |
integer |
— | Days to retain chat transcripts (0 = keep forever) |
plansDirectory |
string |
"~/.claude/plans" |
Where plan files are stored |
fileSuggestion |
object |
— | Custom script for @ file autocomplete |
| Setting | Type | Default | What It Does |
|---|---|---|---|
apiKeyHelper |
string |
— | Script path that outputs auth values |
awsCredentialExport |
string |
— | Script that exports AWS credentials |
awsAuthRefresh |
string |
— | Script that refreshes AWS auth |
forceLoginMethod |
"claudeai" | "console" |
— | Force login via Claude Pro/Max or Console billing |
forceLoginOrgUUID |
string |
— | Organization UUID for OAuth login |
otelHeadersHelper |
string |
— | Script that outputs OpenTelemetry headers |
| Setting | Type | Default | What It Does |
|---|---|---|---|
includeGitInstructions |
boolean |
true |
Include git commit/PR workflow instructions in system prompt |
attribution |
object |
— | Customize attribution for git commits and PRs |
autoUpdatesChannel |
"stable" | "latest" |
"latest" |
stable = ~1 week old, skips regressions. latest = newest |
skipWebFetchPreflight |
boolean |
false |
Skip WebFetch blocklist check (enterprise) |
sandbox |
object |
— | Sandbox execution configuration |
teammateMode |
"auto" | "tmux" | "iterm" | "in-process" |
"auto" |
How agent team teammates display |
worktree |
object |
— | Config for --worktree sessions |
env |
object |
{} |
Environment variables for sessions (many hidden settings live here) |
These go inside the "env" object and unlock settings not available as top-level properties:
| Variable | What It Does |
|---|---|
CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY |
Max parallel tool calls (default varies) |
CLAUDE_CODE_DISABLE_AUTO_MEMORY |
1 to disable auto memory |
CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS |
1 to disable git instructions |
CLAUDE_CODE_EFFORT_LEVEL |
Override effort level |
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS |
1 to enable agent teams |
CLAUDE_CODE_ENABLE_TELEMETRY |
1 to enable telemetry |
CLAUDE_CODE_DEBUG_LOG_LEVEL |
verbose for debug logging |
DISABLE_AUTOUPDATER |
1 to disable auto-updates |
ANTHROPIC_MODEL |
Runtime model override |
CLAUDE_CODE_SUBAGENT_MODEL |
Model for subagents |
Hey, I saw you StatusLine, liked it but I needed it in PS1 format for Windows system without WSL, because it can't run bash. I'm going to leave it here if anyone wants it, it's exactly your statusline bar but converted in PowerShell:
`
[Console]::InputEncoding = [System.Text.Encoding]::UTF8
[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
$raw = [Console]::In.ReadToEnd()
if (-not $raw.Trim()) { exit 0 }
$json = $raw | ConvertFrom-Json
$e = [char]27$b) { "$ {e}[38;2;${r};${g};${b}m" }
$DIM = "$ {e}[2m"
$BOLD = "$ {e}[1m"
$RESET = "$ {e}[0m"
function clr($r, $g,
$model = $json.model.display_name; if (-not $model) { $model = "Claude" }
$used = $json.context_window.used_percentage
$cost = $json.cost.total_cost_usd; if (-not $cost) { $cost = 0.0 }
$linesAdd = $json.cost.total_lines_added; if (-not $linesAdd) { $linesAdd = 0 }
$linesDel = $json.cost.total_lines_removed; if (-not $linesDel) { $linesDel = 0 }
$cwd = $json.workspace.current_dir
if (-not $cwd) { $cwd = $json.cwd }
if (-not $cwd) { $cwd = "" }
$branch = ""
$repo = ""
if ($cwd) {
$b = git -C "$cwd" --no-optional-locks symbolic-ref --short HEAD 2>$null
if ($b) { $branch = $b.Trim() }
$t = git -C "$cwd" --no-optional-locks rev-parse --show-toplevel 2>$null
if ($t) { $repo = Split-Path $t.Trim() -Leaf }
}
$W = 20
if ($null -ne $used -and "$used" -ne "") {
$pct = [int][math]::Round([double]$used)
$filled = [int][math]::Round($pct * $W / 100.0)
} else {
$ctxSeg = "🟢 $ (clr 60 60 60)$('░' * 20)${RESET} --%"
}
$costStr = '$' + ('{0:F2}' -f [double]$cost)
$sep = " $ {DIM}|${RESET} "
$parts = @()$parts += "$ {BOLD}$(clr 220 200 0)${repo}${RESET}" }$parts += "$ {BOLD}$(clr 0 180 220)🌿 (${branch})${RESET}" }
$parts += "$ (clr 220 200 0)${costStr}${RESET}"
$parts += "$ (clr 0 200 80)+${linesAdd}${RESET} $(clr 220 40 20)-$ {linesDel}${RESET}"
$parts += "$ (clr 220 80 220)🤖 ${model}${RESET}"
if ($repo) {
if ($branch) {
$parts += $ctxSeg
[Console]::Write($parts -join $sep)
`