VPSలో Claude Code statusline ఎలా సెటప్ చేయాలి

Claude Code statusline చూపేది

Claude Code statusline అనేది prompt కింద కనిపించే ఒక వరుస. మీరు రాసిన script output ను ఇది చూపిస్తుంది. settings.json కు statusLine block ను జోడించి, దానికి ఒక command ను నిర్దేశించాలి. Claude Code ఆ command ను అమలు చేస్తుంది, session state ను JSON రూపంలో standard input ద్వారా దానికి పంపుతుంది, తరువాత ఆ command standard output కు రాసినదాన్ని ప్రదర్శిస్తుంది.

ఇదే మొత్తం ఒప్పందం. మీ script standard input నుంచి JSON ను చదివి, standard output కు text ను రాస్తుంది. ఇది మీ machine పై నడుస్తుంది. ఇది రాసే ఏదీ model కు పంపబడదు. అందువల్ల tokens ఖర్చు కావు.

ఒక project ఉన్న laptop లో ఇది కేవలం అలంకరణ. మూడు servers లో ఇది భద్రతా నియంత్రణగా పనిచేస్తుంది. ప్రతి terminal లో ప్రతి Claude Code session ఒకేలా కనిపిస్తుంది. అందువల్ల labels లేని నాలుగు SSH windows ఉండటం వల్ల migration ను తప్పు server పై అమలు చేసే ప్రమాదం ఉంటుంది. hostname తో ప్రారంభమయ్యే statusline ఈ రకమైన పొరపాటును నివారిస్తుంది.

settings.jsonలో statusLine సెట్టింగ్ ఉన్న స్థానం

దీన్ని మీ user settings లోని ~/.claude/settings.json వద్ద ఉంచండి. ఇది ఆ machine లోని ప్రతి project కు వర్తిస్తుంది. Repository లోని .claude/settings.json వద్ద ఉన్న project settings కూడా పనిచేస్తాయి. ఆ directory కోసం అవే ప్రాధాన్యం పొందుతాయి.

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

type ఎల్లప్పుడూ "command" గా ఉంటుంది. command విలువ shell ద్వారా అమలు అవుతుంది. అందువల్ల ఇది script path లేదా సాధారణ command కావచ్చు. ఏ script రాయడానికి ముందు ఈ wiring పనిచేస్తోందో నిర్ధారించండి:

{
  "statusLine": {
    "type": "command",
    "command": "hostname -s"
  }
}

Claude Code ప్రారంభించి ఒక message పంపండి. ఇప్పుడు prompt కింద ఉన్న bar server యొక్క short hostname ను చూపిస్తుంది. అది ఖాళీగా ఉంటే, సమస్య మీ script లో కాదు; setting లేదా trust dialog లో ఉంది. దిగువన ఉన్న "statusline ఎందుకు ఖాళీగా ఉంటుంది" అనే విభాగాన్ని చదవండి.

August 2026 నాటికి మూడు optional keys ఉన్నాయి. padding characters లో horizontal spacing ను జోడిస్తుంది. దీని default విలువ 0. సాధారణ triggers తో పాటు refreshInterval ప్రతి N seconds కు command ను మళ్లీ అమలు చేస్తుంది. కనీస విలువ 1. Line లో clock లేదా session idle గా ఉన్నప్పుడు మారే సమాచారం ఉన్నప్పుడు మాత్రమే దీన్ని ఉపయోగించండి. మీ స్వంత script ఇప్పటికే vim mode ను చూపిస్తే, built-in -- INSERT -- text ను hideVimModeIndicator దాచేస్తుంది.

statusline script కు ఏ data అందుతుంది?

ఈ పేజీతో సహా ఎక్కడైనా చదివిన field list ను నమ్మవద్దు. మీ version పంపే అసలు object ను capture చేయండి. stdin ను file లో save చేసే తాత్కాలిక script రాయండి:

cat > ~/.claude/statusline-capture.sh <<'EOF'
#!/bin/bash
cat > /tmp/statusline-input.json
echo "captured"
EOF
chmod +x ~/.claude/statusline-capture.sh

statusLine.command ను ఆ file కు point చేసి, ఒక session ప్రారంభించి, ఒక message పంపండి. bar captured ను చదువుతుంది. ఇప్పుడు వచ్చిన data ను చూడండి:

jq . /tmp/statusline-input.json

మీ build కు సరిపోయే ఖచ్చితమైన structure మీకు లభిస్తుంది. ఏదైనా update తర్వాత structure మారితే ఇదే విధానాన్ని మళ్లీ ఉపయోగించవచ్చు.

August 2026 నాటి documentation ప్రకారం స్థిరంగా ఉండే భాగాలు flat keys కాకుండా nested objects గా ఉంటాయి. model లో id మరియు display_name ఉంటాయి. workspace లో current_dir మరియు project_dir ఉంటాయి: session ప్రస్తుతం ఎక్కడ ఉందో current_dir చూపిస్తుంది, session ప్రారంభించిన స్థలాన్ని project_dir చూపిస్తుంది. Session మధ్యలో working directory మారిన తర్వాత ఈ రెండింటి విలువలు వేర్వేరుగా ఉంటాయి. top-level cwd లో workspace.current_dir కు సమానమైన విలువ ఉంటుంది. context_window token counts తో పాటు ముందుగానే లెక్కించిన used_percentage ను కలిగి ఉంటుంది. cost లో total_cost_usd మరియు duration counters ఉంటాయి. Session మొత్తం కాలానికి session_id స్థిరంగా ఉంటుంది. అన్ని sessions మధ్య అది unique గా ఉంటుంది, కాబట్టి తరువాత caching చేసేటప్పుడు ఇది ముఖ్యమైనది.

Schema మారినప్పటికీ script పనిచేస్తూ ఉండేందుకు ఈ మూడు నియమాలు ఉపయోగపడతాయి.

కొన్ని keys null కాకుండా పూర్తిగా ఉండవు. సంబంధిత feature active గా ఉన్నప్పుడు మాత్రమే vim, agent, pr, worktree మరియు effort కనిపిస్తాయి. vim mode off లో ఉన్నప్పుడు jq -r తో .vim.mode చదివితే literal string null ముద్రించబడుతుంది. అప్పుడు reader కు bar null చూపిస్తుంది. ప్రతి selector కు // empty ను జోడించండి. అప్పుడు key లేకపోతే ఏ output ఉండదు.

కొన్ని values ప్రారంభంలో null గా ఉంటాయి. మొదటి API response రాకముందు context_window.used_percentage మరియు context_window.current_usage null గా ఉంటాయి. /compact తర్వాత, తదుపరి call దానిని మళ్లీ నింపే వరకు current_usage null గా మారుతుంది. అందువల్ల bar పై context percentage చూపించాలంటే // 0 అవసరం. లేకపోతే ప్రతి session ప్రారంభంలోని మొదటి కొన్ని seconds కు అది null ను చదువుతుంది. ఆ సంఖ్యను bar పై ఉంచే ముందు context window వాస్తవంగా ఎలా నిండుతుందో తెలుసుకోవడం ఉపయోగకరం.

git branch JSON లో ఉండదు. ఏ field కూడా దాన్ని report చేయదు. మీ bar పై కనిపించే branch ఏదైనా, మీ script స్వయంగా git ను run చేయడం ద్వారా పొందుతుంది.

విఫలం కాకుండా, లోపం వచ్చినప్పుడు సరళమైన ఫలితానికి మారే statusline script

ఇది నేరుగా copy-paste చేయగల వెర్షన్. ఇది hostname, working directory, git branch మరియు model name ను చూపిస్తుంది. ప్రతి field కు fallback ఉంది. అందువల్ల ఖాళీ JSON object ఉన్నప్పటికీ ఉపయోగించగల line ఉత్పత్తి అవుతుంది.

#!/bin/bash
# ~/.claude/statusline.sh
input=$(cat)

# Read one field. Prints nothing when the key is missing or null.
field() { printf '%s' "$input" | jq -r "$1 // empty" 2>/dev/null; }

HOST=$(hostname -s 2>/dev/null)
[ -z "$HOST" ] && HOST="host"

DIR=$(field '.workspace.current_dir')
[ -z "$DIR" ] && DIR=$(field '.cwd')
[ -z "$DIR" ] && DIR="$PWD"

MODEL=$(field '.model.display_name')
[ -z "$MODEL" ] && MODEL="claude"

SHORT="$DIR"
if [ -n "$HOME" ]; then
  case "$DIR" in
    "$HOME") SHORT="~" ;;
    "$HOME"/*) SHORT="~/${DIR#"$HOME"/}" ;;
  esac
fi

BRANCH=""
if git -C "$DIR" rev-parse --git-dir >/dev/null 2>&1; then
  BRANCH=$(git -C "$DIR" branch --show-current 2>/dev/null)
  [ -z "$BRANCH" ] && BRANCH="detached"
fi

CYAN=$'\033[36m'
YELLOW=$'\033[33m'
DIM=$'\033[2m'
RESET=$'\033[0m'

LINE="${CYAN}${HOST}${RESET} ${SHORT}"
[ -n "$BRANCH" ] && LINE="${LINE} ${YELLOW}${BRANCH}${RESET}"
LINE="${LINE} ${DIM}${MODEL}${RESET}"

printf '%s\n' "$LINE"

ప్రతి read field ద్వారా జరుగుతుంది. ఇది // empty ను జోడిస్తుంది. అందువల్ల పేరు మార్చిన లేదా తొలగించిన key ఖాళీ string ను ఇస్తుంది. తరువాతి line default విలువను అందిస్తుంది. Directory కోసం వరుసగా workspace.current_dir, cwd, $PWD fallbackలుగా ఉపయోగించబడతాయి. Branch ను సాధారణ git ద్వారా కాకుండా git -C "$DIR" ద్వారా తీసుకుంటారు. అందువల్ల branch, bar చూపిస్తున్న directory కు ఎల్లప్పుడూ సరిపోతుంది.

దీనిని save చేసి, executable గా మార్చండి:

chmod +x ~/.claude/statusline.sh

Execute bit తప్పనిసరి. Claude Code ఈ command ను shell ద్వారా నడుపుతుంది. కాబట్టి +x లేని script, Permission denied తో విఫలమవుతుంది. stdout ఏదీ ఉత్పత్తి కాదు. కనిపించే error లేకుండానే row ఖాళీగా ఉంటుంది.

jq command line లో JSON ను parse చేస్తుంది. కొత్తగా ఏర్పాటు చేసిన Ubuntu server లో ఇది సాధారణంగా install అయి ఉండదు:

sudo apt update && sudo apt install -y jq

తరువాత, పైభాగంలోని మొదటి settings.json block ను ఉపయోగించి setting ను ఈ script కు point చేయండి.

నమ్మే ముందు script ను పరీక్షించండి

దాన్ని చేతితో రెండుసార్లు అమలు చేయండి. ముందుగా సాధారణ session object తో:

echo '{"model":{"display_name":"Opus"},"workspace":{"current_dir":"/srv/api"},"session_id":"t1"}' | ~/.claude/statusline.sh

మొదట hostname, తరువాత /srv/api, ఆపై Opus కనిపిస్తాయి. ఏ branch కూడా కనిపించదు, ఎందుకంటే మీ మెషీన్‌లోని /srv/api సాధారణంగా git repository అయి ఉండకపోవచ్చు.

రెండవది degradation పరీక్ష. సాధారణంగా వదిలివేయబడేది ఇదే:

echo '{}' | ~/.claude/statusline.sh

Schema మార్పు మీకు అందించగల అత్యంత చెత్త పరిస్థితి empty object. ఆ line ఇప్పటికీ hostname, $PWD నుంచి వచ్చిన ప్రస్తుత directory, అలాగే model name కనిపించాల్సిన స్థానంలో claude అనే పదాన్ని ముద్రిస్తుంది. ఏదీ crash అవదు. null కూడా ఏదీ ముద్రించదు. ఈ పరీక్షలో ఉత్తీర్ణమయ్యే script, ఒక field పేరు మార్చబడిన పరిస్థితిని తట్టుకుంటుంది. ఎందుకంటే మీ script దృష్టిలో పేరు మార్చబడిన field మరియు లేని field ఒకే సంఘటన.

మీరు చూడాల్సింది

statusline, built-in footer badges పైన ప్రత్యేక వరుసలో render అవుతుంది. ఇది వాటిని భర్తీ చేయదు. సరిగ్గా పనిచేసే setup లో ఇది ఒకే వరుసగా ఉంటుంది: మొదట cyan రంగులో short hostname, తరువాత home directory ను ~ గా సంక్షిప్తం చేసిన working directory, ఆ directory git repository అయితే yellow రంగులో branch name, చివర dimmed చేసిన model name కనిపిస్తాయి. ఈ నాలుగు భాగాలకు రంగులు ఇచ్చిన web-01 ~/api main Opus కు దగ్గరగా ఉండే రూపం కనిపిస్తుంది.

Session ప్రారంభమైనప్పుడు, resume సహా, కొత్త assistant message వచ్చినప్పుడు, /compact పూర్తయిన తరువాత, permission mode మారినప్పుడు, vim mode toggle అయినప్పుడు, అలాగే మీరు refreshInterval tick సెట్ చేసి ఉంటే ఆ వ్యవధి ముగిసినప్పుడు మీ script మళ్లీ run అవుతుంది. Updates 300 ms పాటు debounce అవుతాయి. అందువల్ల మార్పులు వరుసగా వచ్చినా script ఒక్కసారి మాత్రమే run అవుతుంది. Autocomplete, help menu, permission prompts సమయంలో bar దాగి ఉంటుంది. తరువాత మళ్లీ కనిపిస్తుంది.

హోస్ట్‌నేమ్‌కు మొదటి స్థానం ఎందుకు ఇవ్వాలి

మీరు ఒకటి కంటే ఎక్కువ సర్వర్లపై agents నడుపుతున్నప్పుడు, మీరు ఎక్కడ ఉన్నారో terminal మాత్రమే తెలియజేస్తుంది. అయితే terminals తప్పుదారి పట్టించవచ్చు. tmux pane లోపల నుంచి రెండో ssh connection తెరిస్తే, window title తరచుగా పాత పేరునే చూపిస్తుంది. ఎందుకంటే title ను సెట్ చేసిన shell తాను వేరే స్థానానికి మారిందని తెలుసుకోలేదు. VPSలో detached tmux sessionలో Claude Codeను నడుపుతూ ఒక రోజు తర్వాత మళ్లీ attach అయితే, screen పై build server మరియు production box మధ్య తేడా కనిపించదు.

Statusline భిన్నంగా ఉంటుంది. ఇది ప్రతి session కోసం Claude Code స్వయంగా render చేస్తుంది. ఆ session వద్ద ఉన్న data ఆధారంగా ఇది రూపొందుతుంది. తప్పు pane నుంచి ఇది inherit కాదు. Refresh కాని shell prompt వల్ల పాత విలువగా కూడా మిగిలిపోదు. ఇది చూపించేది agent files రాస్తున్న box.

ప్రతి serverకు ప్రత్యేక రంగు ఇవ్వండి. చదవకముందే దాన్ని గుర్తించగలుగుతారు. LINE= assignment కు ముందు ఈ రెండు lines చేర్చండి:

CODE=$(printf '%s' "$HOST" | cksum | cut -d' ' -f1)
HOST_COLOR=$(printf '\033[%dm' "$((31 + CODE % 6))")

తర్వాత ${CYAN} స్థానంలో ${HOST_COLOR} ఉపయోగించండి. cksum hostname యొక్క checksum ను ప్రింట్ చేస్తుంది. అందువల్ల ఒకే పేరు ఎల్లప్పుడూ 31 నుంచి 36 పరిధిలోని ఒకే రంగుకు map అవుతుంది. ఈ పరిధిలో red నుంచి cyan వరకు రంగులు ఉంటాయి. అదే script ను ప్రతి boxకు copy చేయండి. అప్పుడు ప్రతి box తన label ను తానే చూపిస్తుంది.

అదే కారణంతో directory కూడా statuslineలో ఉండాలి. ssh commandలో /srv/api మరియు /srv/api-staging మధ్య ఒక keystroke మాత్రమే తేడా ఉంటుంది. కానీ వాటి ప్రభావం మాత్రం పూర్తి incident స్థాయిలో వేరు. Model మరియు branch కూడా statuslineలో స్థానం పొందాలి. Model ద్వారా మీరు resume చేసిన session ఏదో తెలుస్తుంది. Agent main పై commit చేయబోతుందా లేదా అన్నది branch ద్వారా తెలుస్తుంది.

చిన్న screenపై ఇవన్నీ మరింత ముఖ్యంగా మారతాయి. ఎందుకంటే fallbackగా ఉపయోగించడానికి window title ఉండదు. మీ setup ఇదే అయితే, ఫోన్ నుంచి Claude Codeను నియంత్రించడం చూడండి.

స్క్రిప్ట్‌ను వేగంగా ఉంచండి

మీ స్క్రిప్ట్ ప్రతి assistant సందేశంపై అమలవుతుంది. కొత్త update వచ్చినప్పుడు Claude Code అమలులో ఉన్న run ను రద్దు చేస్తుంది. అందువల్ల స్క్రిప్ట్ నెమ్మదిగా ఉంటే పాత text కనిపించవచ్చు లేదా ఎలాంటి text కనిపించకపోవచ్చు.

ప్రతి jq call కు కొన్ని milliseconds మాత్రమే పడతాయి. నెమ్మదిగా మారేది git: cache ఖాళీగా ఉన్నప్పుడు పెద్ద repository లో git status కు వందల milliseconds పడుతుంది. పై స్క్రిప్ట్ ఉద్దేశపూర్వకంగా git status ను నివారించి, git branch --show-current ను call చేస్తుంది. ఇది .git/HEAD ను చదివి వెంటనే తిరిగి వస్తుంది.

మీరు మరింత భారమైన పని జోడిస్తే, దాని ఫలితాన్ని file లో cache చేసి ప్రతి కొన్ని seconds కు refresh చేయండి. ఆ file కు session ఆధారంగా key ఇవ్వండి:

CACHE="/tmp/statusline-$(field '.session_id')"

$$ కు బదులుగా session_id ను ఉపయోగించండి. $$ అనేది మీ స్క్రిప్ట్ యొక్క process ID. ఇది ప్రతి invocation లో మారుతుంది. అందువల్ల దానిపై ఆధారపడి cache key రూపొందిస్తే cache ఎప్పుడూ hit కాదు. ప్రతి సారి పూర్తి ఖర్చు చెల్లించాల్సి వస్తుంది. session_id మొత్తం sessionలో స్థిరంగా ఉంటుంది, sessions మధ్య వేరుగా ఉంటుంది. అందువల్ల వేర్వేరు repositories లో నడుస్తున్న రెండు Claude Code sessions ఒకదాని cached branch name ను మరొకటి చదవలేవు.

తెలుసుకోవాల్సిన మరో పరిమితి ఉంది: statusline script లో tput cols పనిచేయదు. Claude Code output ను capture చేస్తుంది; మీ script ను terminal కు attach చేయదు. అందువల్ల width detection కోసం కొలవాల్సినది ఏదీ ఉండదు. command అమలు చేయడానికి ముందు, v2.1.153 మరియు తరువాతి versions లో Claude Code COLUMNS మరియు LINES environment variables ను set చేస్తుంది. కాబట్టి ఎంత output ముద్రించాలో నిర్ణయించాల్సినప్పుడు $COLUMNS ను చదవండి.

స్థితి పంక్తి ఖాళీగా ఎందుకు ఉంటుంది

ఏదీ కనిపించదు. ls -l ~/.claude/statusline.sh తో execute bit ను తనిఖీ చేయండి. తరువాత పై mock input తో script ను చేతితో run చేయండి. Shell లో ఒక పంక్తి print అవుతూ, Claude Code లో కనిపించకపోతే claude --debug తో ప్రారంభించండి. ఇది session లో statusline మొదటిసారి run అయినప్పుడు exit code మరియు stderr ను log చేస్తుంది.

Debug log లో Status line command skipped: workspace trust not accepted అని ఉంది. Statusline ఒక shell command ను execute చేస్తుంది. అందువల్ల ఇది hooks కు వర్తించే workspace trust gate లోనే ఉంటుంది. ఆ directory కోసం trust dialog ను accept చేసే వరకు command run కాదు. VPS లో ఇది సాధారణం. ప్రతి కొత్త clone ను Claude Code ఇంతకుముందు చూడని directory గా పరిగణిస్తుంది. ఆ directory లో Claude Code ను restart చేసి dialog ను accept చేయండి.

అన్నీ ఖాళీగా ఉన్నాయి మరియు disableAllHooks set అయింది. settings.json లోని "disableAllHooks": true statusline ను కూడా disable చేస్తుంది. కారణం, ఇది అదే shell-execution gate ను ఉపయోగిస్తుంది. దాన్ని తొలగించండి లేదా false గా set చేయండి.

Row null ను print చేస్తుంది. jq selector లేని లేదా null అయిన key ను చేరుకుంది. jq -r null ను null అనే నాలుగు characters గా print చేస్తుంది. Text కోసం // empty ను, numbers కోసం // 0 ను జోడించండి.

Script ను edit చేసిన వెంటనే row ఖాళీగా మారుతుంది. Non-zero తో exit అయ్యే command లేదా ఏమీ print చేయని command row ను ఖాళీ చేస్తుంది. సాధారణ కారణం [ -n "$BRANCH" ] && LINE="..." వంటి చివరి line. Branch ఖాళీగా ఉన్నప్పుడు ఇది 1 తో exit అవుతుంది, దాంతో మొత్తం script యొక్క exit code కూడా అదే అవుతుంది. printf ను చివరిగా ఉంచండి లేదా exit 0 ను జోడించండి.

Escape codes bar పై literal text గా కనిపిస్తాయి, ఉదాహరణకు \e]8;;. echo -e కు బదులుగా printf '%b' ను ఉపయోగించండి. Clickable OSC 8 links కు కూడా వాటిని support చేసే terminal అవసరం. tmux లేదా SSH ఈ sequences ను తొలగించవచ్చు. అందువల్ల remote box పై plain colour సురక్షితమైన ఎంపిక.

Row యొక్క కుడి వైపు కత్తిరించబడుతుంది. System notifications మరియు verbose-mode token counter రెండూ ఆ row లో కుడి వైపు నుంచి స్థలాన్ని పంచుకుంటాయి. Narrow terminal లో అవి ఒకదానిపై ఒకటి overlap అవుతాయి. Output ను చిన్నగా ఉంచండి. Bar పై కనిపించే సంఖ్యకు బదులుగా usage ను ఖచ్చితంగా లెక్కించడానికి Claude Code tokens ను ఎలా లెక్కిస్తుంది చూడండి.

FAQ

Claude Code statusline setting ఎక్కడ ఉంటుంది?

ఇది settings.json లో statusLine block గా ఉంటుంది. అందులో type విలువను "command" గా, command విలువను script path లేదా shell command గా సెట్ చేయాలి. User settings ~/.claude/settings.json లో ఉంటాయి. అవి ఆ machine లోని ప్రతి project కు వర్తిస్తాయి. Project settings repository లోని .claude/settings.json వద్ద ఉంటాయి. ఆ directory కోసం ఇవే ప్రాధాన్యం పొందుతాయి. Settings స్వయంగా reload అవుతాయి. అయితే మార్పు తదుపరి update trigger వచ్చినప్పుడు మాత్రమే కనిపిస్తుంది. ఉదాహరణకు, మీ తదుపరి message సమయంలో అది కనిపిస్తుంది.

నా Claude Code statusline ఖాళీగా ఎందుకు ఉంది?

దాదాపు అన్ని సందర్భాలను నాలుగు కారణాలు వివరిస్తాయి. Script కు execute bit లేకపోవడంతో shell Permission denied ను తిరిగి ఇస్తుంది. అందువల్ల stdout కు ఏదీ చేరదు. Workspace trust dialog ను ఎప్పుడూ అంగీకరించకపోతే claude --debug, Status line command skipped: workspace trust not accepted ను log చేస్తుంది. disableAllHooks అనేది true కావడం వల్ల అదే gate కింద statusline నిలిపివేయబడుతుంది. లేదా script non-zero తో exit అయితే row ఖాళీగా కనిపిస్తుంది. ముందుగా దీన్ని చేతితో పరీక్షించండి: echo '{}' | ~/.claude/statusline.sh ఏదో ఒక output ను print చేయాలి.

Statusline JSON లో git branch ఉంటుందా?

ఉండదు. JSON లో model, workspace directories, context window సంఖ్యలు, cost వంటి session state ఉంటుంది. git గురించి అది ఏ సమాచారాన్నీ ఇవ్వదు. మీ bar లో కనిపించే branch ను మీ script git branch --show-current ను call చేసి సృష్టిస్తుంది. JSON నుంచి directory ను git -C "$DIR" తో pass చేయండి. అప్పుడు bar చూపిస్తున్న directory కి branch ఎల్లప్పుడూ సరిపోతుంది.

Statusline tokens ఖర్చు చేస్తుందా లేదా session ను నెమ్మదింపజేస్తుందా?

Tokens ఖర్చు కావు. Script locally నడుస్తుంది, దాని output model కు ఎప్పుడూ పంపబడదు. వేగం మీ బాధ్యత. ప్రతి assistant message సమయంలో command నడుస్తుంది, అలాగే 300 ms debounce ఉంటుంది. కొత్త update వచ్చినప్పుడు Claude Code ప్రస్తుతం నడుస్తున్న run ను cancel చేస్తుంది. అందువల్ల script పూర్తి కావడానికి ఒక second పడితే stale text కనిపిస్తుంది. పెద్ద repositories లో git status ను నివారించండి. నెమ్మదిగా జరిగే పనుల ఫలితాలను session_id ఆధారంగా పేరుపెట్టిన file లో cache చేయండి.

ప్రతి serverలో వేర్వేరు statusline ను ఎలా చూపించాలి?

ఒకే script ను ఉంచి, అది machine వివరాలను చదివేలా చేయండి. పై script $HOSTNAME ను print చేస్తుంది. fallback గా hostname -s ను ఉపయోగిస్తుంది. అందువల్ల ప్రతి box కు అదే file ను copy చేసినా, అది ప్రతిదానిని సరిగ్గా label చేస్తుంది. checksum colour విధానం ప్రతి hostname కు ప్రత్యేక రంగును ఇస్తుంది. ఒక server కు వేర్వేరు layout అవసరమైతే, ఆ box లో మీరు పనిచేసే repository యొక్క project settings లో statusLine block ఉంచండి. ఆ directory కోసం project settings కు user settings కంటే ప్రాధాన్యం ఉంటుంది.