Status line pro Claude Code

Vytvořeno: 11.04.2026 | Aktualizováno: 19.08.2026 08:59

Claude Code umí podle oficiální dokumentace vykreslovat vlastní status line přes externí příkaz. Tohle je moje aktuální konfigurace: hlavní statusLine ukazuje stav top-level session a samostatná subagentStatusLine přidává přehled běžících subagentů v agent panelu.

Co z toho získám

Hlavní status line ukazuje pracovní adresář, model, session ID, využití context window, 5h a 7d limity a absolutní spotřebu tokenů.
Subagent status line ukazuje každého subagenta jako vlastní řádek: agent, model, krátký popis dispatche, živou činnost, stav, zaplnění jeho context window, tokeny, trend tokenů, rychlost tokenů za sekundu, běh od startu a případně pracovní adresář.
Model subagenta se bere z pole model, které Claude Code předává do subagentStatusLine. Název subagent_type v datech samostatně není; pro přehled se proto zapisuje do description.
Popisky subagentů jsou čitelné i při paralelním běhu více agentů.

Zapojení do konfigurace

V ~/.claude/settings.json jsou zapojené dva skripty:

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

Skripty čtou JSON ze standardního vstupu, parsují ho přes jq a vrací barevný výstup přes ANSI sekvence.

Hlavní status line

Hlavní statusLine je vázaná na top-level Claude Code session. Nepřepíná se podle aktivního subagenta a nedostává data o tom, který subagent zrovna běží. K tomu slouží samostatná subagentStatusLine.

Výstup hlavní status line vypadá zhruba takto:

~/project │ Sonnet 4.6 | sid:<id> │ ctx:55% │ 5h:4% ↺ 00:50 │ 7d:45% ↺ Po 08:00 │ 220k/400k

Barvy jsou rozdělené takto:

cwd → cyan + bold
model → magenta
sid → dim
ctx, 5h a 7d → zelená pod 70 %, žlutá od 70 %, červená od 90 %
token counter XYZk/TOTALk → červeně a tučně při překročení 200k, jinak dim

Skript ''statusline-command.sh''

#!/usr/bin/env bash
# Claude Code status line
# Order: cwd | model | context used | 5h limit | 7d limit
 
input=$(cat)
 
# ── helpers ────────────────────────────────────────────────────────────────────
RESET='\033[0m'
BOLD='\033[1m'
DIM='\033[2m'
RED='\033[31m'
YELLOW='\033[33m'
GREEN='\033[32m'
CYAN='\033[36m'
MAGENTA='\033[35m'
WHITE='\033[37m'
 
# ── 1) cwd ─────────────────────────────────────────────────────────────────────
cwd=$(echo "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // ""')
# Show path relative to home dir
home_dir="$HOME"
if [[ "$cwd" == "$home_dir" ]]; then
  short_cwd="~"
elif [[ "$cwd" == "$home_dir/"* ]]; then
  short_cwd="~/${cwd#$home_dir/}"
else
  short_cwd="$cwd"
fi
[ "$short_cwd" = "/" ] && short_cwd="/"
 
# ── 2) model ───────────────────────────────────────────────────────────────────
model_name=$(echo "$input" | jq -r '.model.display_name // .model.id // ""')
session_id=$(echo "$input" | jq -r '.session_id // .conversation_id // empty')
 
# ── rate limit helpers ─────────────────────────────────────────────────────────
five_pct=$(echo "$input" | jq -r '.rate_limits.five_hour.used_percentage  // empty')
five_rst=$(echo "$input" | jq -r '.rate_limits.five_hour.resets_at        // empty')
week_pct=$(echo "$input" | jq -r '.rate_limits.seven_day.used_percentage  // empty')
week_rst=$(echo "$input" | jq -r '.rate_limits.seven_day.resets_at        // empty')
 
fmt_reset_short() {
  local v="$1"
  [ -z "$v" ] && return
  # Try as epoch first, then as ISO-8601 string
  if [[ "$v" =~ ^[0-9]+$ ]]; then
    date -d "@$v" +%H:%M 2>/dev/null || date -r "$v" +%H:%M 2>/dev/null || echo "?"
  else
    date -d "$v" +%H:%M 2>/dev/null || echo "?"
  fi
}
 
fmt_reset_long() {
  local v="$1"
  [ -z "$v" ] && return
  if [[ "$v" =~ ^[0-9]+$ ]]; then
    date -d "@$v" +"%a %H:%M" 2>/dev/null || date -r "$v" +"%a %H:%M" 2>/dev/null || echo "?"
  else
    date -d "$v" +"%a %H:%M" 2>/dev/null || echo "?"
  fi
}
 
# Choose colour based on used %
pct_color_used() {
  local used="$1"
  [ -z "$used" ] && echo "$WHITE" && return
  local u
  u=$(printf "%.0f" "$used")
  if   [ "$u" -ge 90 ]; then echo "$RED"
  elif [ "$u" -ge 70 ]; then echo "$YELLOW"
  else echo "$GREEN"
  fi
}
 
# ── 3) context used ────────────────────────────────────────────────────────────
ctx_used_tokens=$(echo "$input" | jq -r '.context_window.total_input_tokens // empty')
ctx_window_size=$(echo "$input" | jq -r '.context_window.context_window_size // empty')
ctx_pct=$(echo "$input" | jq -r '.context_window.used_percentage // empty')
ctx_str=""
if [ -n "$ctx_pct" ]; then
  ctx_int=$(printf "%.0f" "$ctx_pct")
  if   [ "$ctx_int" -ge 90 ]; then
    ctx_str="$(printf "${RED}${BOLD}ctx:%s%%!${RESET}" "$ctx_int")"
  elif [ "$ctx_int" -ge 70 ]; then
    ctx_str="$(printf "${YELLOW}ctx:%s%%${RESET}" "$ctx_int")"
  else
    ctx_str="$(printf "${GREEN}ctx:%s%%${RESET}" "$ctx_int")"
  fi
fi
 
# ── assemble line ──────────────────────────────────────────────────────────────
parts=()
 
# 1) cwd
parts+=("$(printf "${CYAN}${BOLD}%s${RESET}" "$short_cwd")")
 
# 2) model + session id
if [ -n "$model_name" ] || [ -n "$session_id" ]; then
  parts+=("$(printf "${MAGENTA}%s${RESET}" "$model_name")${session_id:+ $(printf "${DIM}| sid:%s${RESET}" "$session_id")}")
fi
 
# 3) context used (always shown when data available)
[ -n "$ctx_str" ] && parts+=("$ctx_str")
 
# 4) 5h rate limit (only when data is available)
if [ -n "$five_pct" ]; then
  five_int=$(printf "%.0f" "$five_pct")
  col=$(pct_color_used "$five_pct")
  rst=$(fmt_reset_short "$five_rst")
  parts+=("$(printf "${col}5h:%s%%%s${RESET}" "$five_int" "${rst:+ ↺ $rst}")")
fi
 
# 5) 7d rate limit (only when data is available)
if [ -n "$week_pct" ]; then
  week_int=$(printf "%.0f" "$week_pct")
  col=$(pct_color_used "$week_pct")
  rst=$(fmt_reset_long "$week_rst")
  parts+=("$(printf "${col}7d:%s%%%s${RESET}" "$week_int" "${rst:+ ↺ $rst}")")
fi
 
# 6) token counter — červeně od 200k
if [ -n "$ctx_used_tokens" ] && [ -n "$ctx_window_size" ] && [ "$ctx_window_size" -gt 0 ]; then
  ctx_used_k=$(python3 -c "print(round($ctx_used_tokens / 1000))")
  ctx_total_k=$(python3 -c "print(round($ctx_window_size / 1000))")
  if [ "$ctx_used_tokens" -gt 200000 ]; then
    parts+=("$(printf "${RED}${BOLD}%sk/%sk${RESET}" "$ctx_used_k" "$ctx_total_k")")
  else
    parts+=("$(printf "${DIM}%sk/%sk${RESET}" "$ctx_used_k" "$ctx_total_k")")
  fi
fi
 
# ── print ──────────────────────────────────────────────────────────────────────
# Join with separator " │ "
sep="$(printf "${DIM} │ ${RESET}")"
out=""
for p in "${parts[@]}"; do
  [ -z "$out" ] && out="$p" || out="${out}${sep}${p}"
done
 
printf "%b\n" "$out"

Subagent status line

subagentStatusLine dostává pole tasks a pro každý task musí vypsat jeden JSON řádek ve tvaru:

{"id":"<task id>","content":"<řádek s ANSI>"}

V reálných datech task obsahuje zejména pole cwd, description, id, label, startTime, status, tokenCount, tokenSamples, type, model a contextWindowSize. Pole type je jen obecná hodnota typu local_agent, nikoli název použitého subagenta. Pole model obsahuje skutečně použitý model, například claude-haiku-4-5-20251001.

Pro název subagenta se používá konvence v description:

<subagent_type> · <short description>

Příklad:

elite-prompt-architect · rešerše pricing

Skript model přečte z model a popisek rozparsuje. Výsledek vypadá například takto:

elite-prompt-architect │ haiku │ rešerše pricing │ Reading subagent-statusline.sh │ running │ ctx:2% │ tok:8.1k ▁▄█ 579/s │ 14s

Instrukce pro ''CLAUDE.md''

Aby byl agent panel čitelný, musí každý dispatch subagenta v Claude Code předat v parametru description název použitého typu subagenta a krátký účel. Status line z description čte identitu; skutečný model čte samostatně z pole model.

Do CLAUDE.md lze vložit tuto instrukci:

## Popisky subagentů pro status line (Claude Code)
 
Když spouštíš subagenta v Claude Code, nastav parametr `description` přesně ve tvaru:
 
```
<subagent_type> · <short description>
```
 
Příklad: `researcher · ověření limitů API`
 
- Jako oddělovač použij mezeru, prostřední tečku a mezeru: ` · `.
- Do `description` nepiš model. Status line použije skutečný model z dat úlohy.
- Popis drž krátký, protože se v úzkém terminálu zkracuje.
- Tento formát platí jen pro Claude Code. V jiných nástrojích použij běžný přirozený popis.

Starší tříčlenné popisky <subagent_type> · <model> · <description> skript ještě rozpozná, ale pro nové dispatchy se používá dvoudílný tvar.

Skript ''subagent-statusline.sh''

#!/usr/bin/env bash
# Claude Code subagent status line
# Renders one custom row per active subagent in the agent panel.
# Row: <type> │ <status> │ tok:<n> <sparkline> <rate> │ <elapsed> │ [cwd] │ <label|desc>
# Input (stdin): { cwd, columns, tasks:[ {id,name,type,status,description,label,startTime,tokenCount,tokenSamples,cwd}, ... ] }
# Output (stdout): one JSON line per task -> {"id":"<id>","content":"<row w/ ANSI>"}
 
input=$(cat)
 
# ── DEBUG (volitelne): SUBAGENT_SL_DEBUG_DIR=/nejaka/slozka -> dump stdin ──────
if [ -n "$SUBAGENT_SL_DEBUG_DIR" ] && [ -d "$SUBAGENT_SL_DEBUG_DIR" ]; then
  printf '%s\n' "$input" >> "$SUBAGENT_SL_DEBUG_DIR/raw.jsonl" 2>/dev/null
fi
 
# ── ANSI ────────────────────────────────────────────────────────────────────────
RESET='\033[0m'; BOLD='\033[1m'; DIM='\033[2m'
RED='\033[31m'; YELLOW='\033[33m'; GREEN='\033[32m'; CYAN='\033[36m'; MAGENTA='\033[35m'; WHITE='\033[37m'; BLUE='\033[34m'
 
now=$(date +%s)
main_cwd=$(echo "$input" | jq -r '.cwd // .workspace.current_dir // empty')
columns=$(echo "$input" | jq -r '.columns // 0')
US=$'\x1f'   # interní oddělovač pro rozklad "agent · model · popis"
 
status_color() {
  case "$1" in
    running|in_progress|active) echo "$CYAN" ;;
    completed|done|success)     echo "$GREEN" ;;
    failed|error)               echo "$RED" ;;
    pending|queued|waiting)     echo "$YELLOW" ;;
    *)                          echo "$WHITE" ;;
  esac
}
 
# Rozpozná model v prefixu popisku (konvence "model · popis" / "model | popis").
# Vrací barvu, nebo prázdno když prefix není známý model.
model_color() {
  case "$(echo "$1" | tr '[:upper:]' '[:lower:]')" in
    haiku*)  echo "$GREEN"   ;;
    sonnet*) echo "$CYAN"    ;;
    opus*)   echo "$MAGENTA" ;;
    fable*)  echo "$BLUE"    ;;
    *)       echo ""         ;;
  esac
}
 
# Model z pole `.model` (např. "claude-haiku-4-5-20251001") -> rodina "haiku".
# Toto je autoritativní zdroj; konvence v description je jen fallback.
model_family() {
  case "$(echo "$1" | tr '[:upper:]' '[:lower:]')" in
    *haiku*)  echo "haiku"  ;;
    *sonnet*) echo "sonnet" ;;
    *opus*)   echo "opus"   ;;
    *fable*)  echo "fable"  ;;
    *)        echo ""       ;;
  esac
}
 
# Segment v description, který jen duplikuje/zastupuje model → zahodit,
# ať neteče do popisu ("session", "inherit", "dedeno" = model param vynechán).
is_model_slot() {
  [ -n "$(model_color "$1")" ] && return 0
  case "$(echo "$1" | tr '[:upper:]' '[:lower:]')" in
    session|inherit|dedeno|zdeděno|zdedeno|default) return 0 ;;
    *) return 1 ;;
  esac
}
 
# elapsed seconds from startTime (epoch-s, epoch-ms, or ISO-8601) -> "2m10s"
elapsed_str() {
  local v="$1" start=""
  { [ -z "$v" ] || [ "$v" = "null" ]; } && return
  if [[ "$v" =~ ^[0-9]+$ ]]; then
    if [ "${#v}" -ge 13 ]; then start=$(( v / 1000 )); else start="$v"; fi
  else
    start=$(date -d "$v" +%s 2>/dev/null) || return
  fi
  local d=$(( now - start )); [ "$d" -lt 0 ] && d=0
  if   [ "$d" -ge 3600 ]; then printf "%dh%dm" $(( d/3600 )) $(( (d%3600)/60 ))
  elif [ "$d" -ge 60 ];   then printf "%dm%02ds" $(( d/60 )) $(( d%60 ))
  else printf "%ds" "$d"; fi
  return
}
elapsed_secs() {
  local v="$1" start=""
  { [ -z "$v" ] || [ "$v" = "null" ]; } && { echo 0; return; }
  if [[ "$v" =~ ^[0-9]+$ ]]; then
    if [ "${#v}" -ge 13 ]; then start=$(( v / 1000 )); else start="$v"; fi
  else
    start=$(date -d "$v" +%s 2>/dev/null) || { echo 0; return; }
  fi
  local d=$(( now - start )); [ "$d" -lt 0 ] && d=0; echo "$d"
}
 
num_fmt() { # 39731 -> 39.7k
  local t="$1"
  [ "$t" -ge 1000 ] 2>/dev/null && python3 -c "print(f'{$t/1000:.1f}k')" 2>/dev/null || echo "$t"
}
 
# sparkline + rate from tokenSamples (defensive: čísla i objekty)
# stdout: "<sparkline>\t<rate_per_s or empty>"
spark_and_rate() {
  python3 - "$1" 2>/dev/null <<'PY'
import sys, json
raw = sys.argv[1] if len(sys.argv) > 1 else "[]"
try:
    d = json.loads(raw)
except Exception:
    print("\t"); sys.exit(0)
vals, times = [], []
def num(x):
    if isinstance(x,(int,float)): return float(x)
    if isinstance(x,dict):
        for k in ('tokens','tokenCount','count','value','v','y'):
            if isinstance(x.get(k),(int,float)): return float(x[k])
    return None
def tim(x):
    if isinstance(x,dict):
        for k in ('t','time','ts','timestamp','at'):
            if isinstance(x.get(k),(int,float)): return float(x[k])
    return None
if isinstance(d, list):
    for x in d:
        v = num(x)
        if v is not None:
            vals.append(v); times.append(tim(x))
spark = ""
if len(vals) >= 2:
    blocks = "▁▂▃▄▅▆▇█"
    w = vals[-14:]
    lo, hi = min(w), max(w); rng = (hi - lo) or 1
    spark = "".join(blocks[min(7, int(round((v-lo)/rng*7)))] for v in w)
rate = ""
if len(vals) >= 2 and all(t is not None for t in times) and (times[-1]-times[0]) > 0:
    dt = times[-1]-times[0]
    if dt > 10_000_000_000: dt = dt/1000.0   # ms guard
    r = (vals[-1]-vals[0])/dt
    if r > 0:
        rate = f"{r/1000:.1f}k/s" if r >= 1000 else f"{r:.0f}/s"
print(f"{spark}\t{rate}")
PY
}
 
short_dir() {
  local d="$1"
  { [ -z "$d" ] || [ "$d" = "null" ]; } && return
  if [ "$d" = "$HOME" ]; then echo "~";
  elif [[ "$d" == "$HOME/"* ]]; then echo "~/${d#$HOME/}";
  else echo "$d"; fi
}
 
# ── build one row per task ───────────────────────────────────────────────────────
echo "$input" | jq -c '.tasks[]?' | while read -r task; do
  id=$(echo "$task" | jq -r '.id // empty'); [ -z "$id" ] && continue
  # Identita agenta se čte VÝHRADNĚ z `description` (konvence
  # "<subagent_type> · <popis>"); `subagent_type` ve schématu není.
  # POZOR: `label` NENÍ štítek dispatche. Claude Code ho počítá jako
  # `progress.summary || description` a pro `type == "local_agent"` do
  # `progress.summary` průběžně (à 30 s) zapisuje LLM-generované shrnutí
  # aktuální činnosti ("Reading runAgent.ts"). Jakmile se první shrnutí
  # objeví, `label` přepíše description a jméno agenta by z něj zmizelo.
  # Proto: description = identita, label = živá činnost. Nikdy naopak.
  descr=$(echo "$task"   | jq -r '.description // ""')
  label=$(echo "$task"   | jq -r '.label // ""')
  name=$(echo "$task"    | jq -r '.name // ""')
  primary="$descr"; [ -z "$primary" ] && primary="$name"
  activity=""
  if [ -n "$label" ] && [ "$label" != "$descr" ] && [ "$label" != "$name" ]; then
    activity="$label"
  fi
  # Typy bez description (local_bash: label = příkaz) → label slouží jako štítek.
  [ -z "$primary" ] && { primary="$activity"; activity=""; }
  [ -z "$primary" ] && primary="agent"
  # `type` je hrubá kategorie ("local_agent"); ukázat jen když nese info.
  type=$(echo "$task"    | jq -r '.type // ""')
  status=$(echo "$task"  | jq -r '.status // ""')
  tokens=$(echo "$task"  | jq -r '.tokenCount // ""')
  start=$(echo "$task"   | jq -r '.startTime // ""')
  tcwd=$(echo "$task"    | jq -r '.cwd // ""')
  samples=$(echo "$task" | jq -c '.tokenSamples // []')
  rawmodel=$(echo "$task" | jq -r '.model // ""')
  ctxsize=$(echo "$task" | jq -r '.contextWindowSize // ""')
 
  sc=$(status_color "$status")
 
  # Model: primárně z pole `.model` (Claude Code ho posílá), teprve pak z konvence.
  _model=$(model_family "$rawmodel")
 
  # Konvence "agent · popis" (historicky i "agent · model · popis"; oddělovač
  # " · " nebo " | "). Model-slot v popisku se zahodí, když model už známe.
  agentseg=""; modelseg=""
  _tmp="${primary// · /$US}"; _tmp="${_tmp// | /$US}"
  IFS="$US" read -ra _segs <<< "$_tmp"
  _agent=""; _popis=""
  _n=${#_segs[@]}
  if [ "$_n" -ge 2 ]; then
    _agent="${_segs[0]}"; _start=1
    # druhý díl je model-slot ("haiku", "session", "inherit"…) → přeskoč ho,
    # ale jen když víme model odjinud nebo je to skutečně platný model
    if is_model_slot "${_segs[1]}"; then
      [ -z "$_model" ] && _model=$(model_family "${_segs[1]}")
      _start=2
    fi
    for ((i=_start; i<_n; i++)); do
      _popis="${_popis:+$_popis · }${_segs[$i]}"
    done
  else
    _popis="$primary"
  fi
  # jednodílný popisek, který je sám o sobě model → ber jako model, ne jako agenta
  if [ "$_n" -eq 1 ] && [ -z "$_model" ] && [ -n "$(model_color "$primary")" ]; then
    _model=$(model_family "$primary"); _popis=""
  fi
  if [ -n "$_model" ]; then
    _mcol=$(model_color "$_model")
    [ -n "$_mcol" ] && modelseg=$(printf "%b%b%s%b" "$_mcol" "$BOLD" "$_model" "$RESET")
  fi
  [ -n "$_agent" ] && agentseg=$(printf "%b%s%b" "$BOLD" "$_agent" "$RESET")
  primary="$_popis"
 
  # tokens: count + zaplneni okna + sparkline + rate
  # ctx: zaplneni kontextoveho okna subagenta. `tokenCount` je aktualni obsazeni
  # okna (ne kumulativni utrata), takze procento je primo pomer k `contextWindowSize`.
  # Format i barvy zamerne shodne s hlavni statusLine (ctx:55% / ctx:93%!).
  ctxseg=""; ctxpct=""
  if [ -n "$tokens" ] && [ "$tokens" != "null" ] \
     && [ -n "$ctxsize" ] && [ "$ctxsize" != "null" ] && [ "$ctxsize" -gt 0 ] 2>/dev/null; then
    ctxpct=$(( tokens * 100 / ctxsize ))
    if   [ "$ctxpct" -ge 90 ]; then ctxseg=$(printf "%b%bctx:%s%%!%b" "$RED" "$BOLD" "$ctxpct" "$RESET")
    elif [ "$ctxpct" -ge 70 ]; then ctxseg=$(printf "%bctx:%s%%%b" "$YELLOW" "$ctxpct" "$RESET")
    else ctxseg=$(printf "%bctx:%s%%%b" "$GREEN" "$ctxpct" "$RESET")
    fi
  fi
 
  tokseg=""
  if [ -n "$tokens" ] && [ "$tokens" != "null" ]; then
    disp=$(num_fmt "$tokens")
    # Varovnou roli nese ctx segment; tok zustava neutralni absolutni cislo.
    # Bez `contextWindowSize` (starsi Claude Code) plati puvodni pevny prah.
    if [ -n "$ctxpct" ]; then tcol="$DIM"
    elif [ "$tokens" -ge 100000 ] 2>/dev/null; then tcol="${RED}${BOLD}"
    else tcol="$DIM"; fi
    IFS=$'\t' read -r spark rate < <(spark_and_rate "$samples")
    # fallback rate: průměr od startu, když samples nenesou čas
    if [ -z "$rate" ]; then
      es=$(elapsed_secs "$start")
      [ "$es" -gt 0 ] 2>/dev/null && rate=$(python3 -c "r=$tokens/$es; print(f'{r/1000:.1f}k/s' if r>=1000 else f'{r:.0f}/s')" 2>/dev/null)
    fi
    tokseg=$(printf "%btok:%s%b" "$tcol" "$disp" "$RESET")
    [ -n "$spark" ] && tokseg="$tokseg $(printf "%b%s%b" "$CYAN" "$spark" "$RESET")"
    [ -n "$rate" ]  && tokseg="$tokseg $(printf "%b%s%b" "$DIM" "$rate" "$RESET")"
  fi
 
  el=$(elapsed_str "$start")
 
  # cwd jen když se liší od hlavní session
  dirseg=""
  if [ -n "$tcwd" ] && [ "$tcwd" != "null" ] && [ "$tcwd" != "$main_cwd" ]; then
    dirseg=$(printf "%b%s%b" "$YELLOW" "$(short_dir "$tcwd")" "$RESET")
  fi
 
  # ořez popisku a živé činnosti podle columns (heuristika: fixní část ~ 55
  # sloupců — status + ctx + tok/sparkline/rate + elapsed). Popis dispatche má
  # přednost (odlišuje paralelní agenty téhož typu), činnost bere zbytek.
  if [ "$columns" -gt 0 ] 2>/dev/null; then
    budget=$(( columns - 55 )); [ "$budget" -lt 12 ] && budget=12
    if [ -n "$activity" ]; then
      pbudget=$(( budget * 2 / 5 )); [ "$pbudget" -lt 10 ] && pbudget=10
    else
      pbudget="$budget"
    fi
    if [ -n "$primary" ] && [ "${#primary}" -gt "$pbudget" ]; then primary="${primary:0:$((pbudget-1))}…"; fi
    if [ -n "$activity" ]; then
      abudget=$(( budget - ${#primary} - 3 )); [ "$abudget" -lt 8 ] && abudget=8
      if [ "${#activity}" -gt "$abudget" ]; then activity="${activity:0:$((abudget-1))}…"; fi
    fi
  fi
  actseg=""
  [ -n "$activity" ] && actseg=$(printf "%b%s%b" "$WHITE" "$activity" "$RESET")
 
  # type badge jen když není běžná lokální kategorie
  typeseg=""
  case "$type" in
    ""|local_agent|agent) : ;;
    *) typeseg=$(printf "%b%s%b" "$DIM" "$type" "$RESET") ;;
  esac
 
  parts=()
  if [ -n "$agentseg" ]; then
    parts+=("$agentseg")
    [ -n "$modelseg" ] && parts+=("$modelseg")
    [ -n "$primary" ] && parts+=("$(printf "%b%s%b" "$DIM" "$primary" "$RESET")")
  else
    [ -n "$modelseg" ] && parts+=("$modelseg")
    parts+=("$(printf "%b%b%s%b" "$MAGENTA" "$BOLD" "$primary" "$RESET")")
  fi
  [ -n "$actseg" ] && parts+=("$actseg")
  [ -n "$status" ]  && parts+=("$(printf "%b%s%b" "$sc" "$status" "$RESET")")
  [ -n "$ctxseg" ]  && parts+=("$ctxseg")
  [ -n "$tokseg" ]  && parts+=("$tokseg")
  [ -n "$el" ]      && parts+=("$(printf "%b%s%b" "$DIM" "$el" "$RESET")")
  [ -n "$dirseg" ]  && parts+=("$dirseg")
  [ -n "$typeseg" ] && parts+=("$typeseg")
 
  sep="$(printf "%b │ %b" "$DIM" "$RESET")"
  content=""
  for p in "${parts[@]}"; do
    [ -z "$content" ] && content="$p" || content="${content}${sep}${p}"
  done
 
  content_bytes=$(printf "%b" "$content")
  jq -cn --arg id "$id" --arg content "$content_bytes" '{id:$id, content:$content}'
done

Poznámky k chování

Hlavní statusLine a subagentStatusLine jsou oddělené. Hlavní řádek zůstává pro top-level session, subagenti se zobrazují v agent panelu.
subagentStatusLine dostává skutečný model v poli model, ale nedostává subagent_type. Proto description používá dvoudílný tvar <subagent_type> · <short description>.
V aktuálním Claude Code je label pro local_agent živá činnost, ne identita dispatche: odpovídá progress.summary || description. AgentSummary přibližně každých 30 sekund zapisuje do progress.summary krátké LLM-generované shrnutí činnosti. Identita se proto vždy čte z description, zatímco label se vypisuje jen jako samostatný sloupec s činností.
Starší tříčlenné popisky <subagent_type> · <model> · <description> zůstávají podporované. Prostřední modelový segment se ignoruje ve prospěch hodnoty z model; nově se ale zapisuje dvoudílný tvar.
contextWindowSize spolu s tokenCount určuje ctx — procento obsazení context window subagenta. Pod 70 % je zelené, od 70 % žluté a od 90 % červené. tokenCount je aktuální obsazení okna, ne kumulativní spotřeba.
tokenSamples se používá pro sparkline trendu tokenů. Když vzorky neobsahují čas, rychlost se dopočítá jako průměr od startTime.
columns se používá pro ořez popisku, aby se řádky v úzkém terminálu nelámaly.
cwd se zobrazí jen tehdy, když se liší od hlavní session.
Pro diagnostiku lze nastavit proměnnou prostředí SUBAGENT_SL_DEBUG_DIR na existující adresář. Skript do něj zapíše zachycené JSON vstupy do raw.jsonl.
Skripty vyžadují jq, python3 a běžné unixové date.

Zdroje

Claude Code – Customize your status line (oficiální dokumentace)