Build This Now
Build This Now
Atalhos de TecladoGuia da Status Line
speedy_devvkoen_salo
Blog/Toolkit/Status Line Guide

Guia da Status Line

Configure uma status line no Claude Code para ver o nome do modelo, branch do git, custo da sessão e uso do contexto. Configuração via settings.json, input JSON, scripts em bash, Python e Node.js.

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.

Published Feb 27, 2026Toolkit hub

Configure uma status line personalizada no Claude Code para ver o nome do modelo, branch do git, custo e uso do contexto. Inclui scripts prontos para copiar.

O seu terminal do Claude Code está a perder informação útil. A status line resolve isso ao colocar o nome do modelo, a branch do git, o custo da sessão e o uso do contexto mesmo na base da interface.

Pense nisso como o PS1 para o Claude Code. Se já personalizou um prompt de shell com Oh-my-zsh ou Starship, a ideia é a mesma. Uma linha de informação em tempo real que te mantém orientado enquanto trabalhas.

O Que a Status Line Mostra

A status line fica na base da interface do Claude Code e atualiza sempre que a conversa muda. Pode mostrar tudo o que o teu script imprimir: o modelo atual, em que branch do git estás, quanto gastaste nesta sessão, ou quão cheio está o teu contexto.

Aqui está um exemplo de uma status line configurada:

[Opus] my-project | main | $0.42 | Context: 37%

Essa linha única diz-te o modelo, a pasta do projeto, a branch do git, o custo da sessão até agora e a percentagem da janela de contexto usada. Tudo atualizado automaticamente.

Configuração Rápida com /statusline

O caminho mais rápido para uma status line funcional é o comando /statusline integrado. Escreve-o diretamente no Claude Code e ele gera um script para ti.

/statusline

Claude Code vai criar um script de status line que espelha o teu prompt de terminal por padrão. Mas também podes dar instruções específicas:

/statusline show the model name in orange

/statusline display git branch and session cost

/statusline show context window percentage with color coding

É só isso. Claude Code escreve o script, configura as definições e a status line aparece. Se queres mais controlo, continua a ler para a configuração manual.

Configuração Manual via settings.json

Para controlo total, adiciona uma entrada statusLine no .claude/settings.json do teu projeto (ou no global ~/.claude/settings.json para todos os projetos):

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

Três campos para conhecer:

  • type: Sempre "command" para status lines baseadas em scripts
  • command: Caminho para o script que gera o output da tua status line
  • padding: Número de linhas vazias acima da status line (0 é o típico)

Depois de adicionar isto, cria o ficheiro de script e torna-o executável:

touch ~/.claude/statusline.sh
chmod +x ~/.claude/statusline.sh

O passo chmod +x é importante. Se a tua status line não aparecer, a falta de permissão de execução é quase sempre a razão.

Como Funciona o Motor da Status Line

Entender a mecânica ajuda quando estás a fazer debug ou a criar scripts personalizados:

  • Gatilho de atualização: A status line atualiza sempre que as mensagens da conversa mudam
  • Throttle: As atualizações correm no máximo a cada 300ms para evitar problemas de performance
  • Tratamento do output: Apenas a primeira linha do stdout do teu script se torna no texto da status line
  • Cores: Suporte completo a códigos de cor ANSI para estilizar
  • Input: Claude Code envia um objeto JSON com dados da sessão para o teu script via stdin

Esse último ponto é a chave. O teu script recebe JSON estruturado com o modelo atual, caminhos do workspace, custo da sessão, estatísticas da janela de contexto e mais. Faz o parse, formata e imprime uma linha no stdout.

O Input JSON que o Teu Script Recebe

Sempre que a status line atualiza, o teu script recebe esta estrutura JSON via stdin:

{
  "hook_event_name": "Status",
  "session_id": "abc123...",
  "cwd": "/current/working/directory",
  "model": {
    "id": "claude-opus-4-1",
    "display_name": "Opus"
  },
  "workspace": {
    "current_dir": "/current/working/directory",
    "project_dir": "/original/project/directory"
  },
  "version": "1.0.80",
  "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": 42.5,
    "remaining_percentage": 57.5,
    "current_usage": {
      "input_tokens": 8500,
      "output_tokens": 1200,
      "cache_creation_input_tokens": 5000,
      "cache_read_input_tokens": 2000
    }
  }
}

Os campos que mais importam para status lines práticas:

  • model.display_name: Nome curto do modelo como "Opus" ou "Sonnet"
  • workspace.current_dir: Onde estás a trabalhar agora
  • cost.total_cost_usd: Custo acumulado da sessão em dólares
  • cost.total_lines_added / total_lines_removed: Rastreia alterações de código
  • context_window.used_percentage: Percentagem de contexto usado pré-calculada (0-100)
  • context_window.context_window_size: Capacidade total da janela de contexto

Scripts de Status Line Prontos para Copiar

Aqui estão scripts completos e executáveis em várias linguagens. Escolhe o que se encaixa no teu setup.

Status Line Simples em Bash

A status line útil mais simples. Mostra o nome do modelo e o diretório atual:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
 
echo "[$MODEL] ${CURRENT_DIR##*/}"

Output: [Opus] my-project

Este script usa jq para fazer o parse do JSON. Se não o tens instalado, corre brew install jq no macOS ou sudo apt install jq no Ubuntu.

Status Line Bash com Suporte a Git

Adiciona a branch do git atual, útil quando estás a gerir várias branches de funcionalidades:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
 
GIT_BRANCH=""
if git rev-parse --git-dir > /dev/null 2>&1; then
    BRANCH=$(git branch --show-current 2>/dev/null)
    if [ -n "$BRANCH" ]; then
        GIT_BRANCH=" | $BRANCH"
    fi
fi
 
echo "[$MODEL] ${CURRENT_DIR##*/}$GIT_BRANCH"

Output: [Opus] my-project | feature/auth

Status Line Bash Completa

Modelo, branch do git, custo e percentagem de contexto tudo numa só linha:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
# Git branch
GIT_BRANCH=""
if git rev-parse --git-dir > /dev/null 2>&1; then
    BRANCH=$(git branch --show-current 2>/dev/null)
    if [ -n "$BRANCH" ]; then
        GIT_BRANCH=" | $BRANCH"
    fi
fi
 
# Format cost to 2 decimal places
COST_FMT=$(printf '%.2f' "$COST")
 
# Round context percentage
PERCENT_INT=$(printf '%.0f' "$PERCENT_USED")
 
echo "[$MODEL] ${CURRENT_DIR##*/}$GIT_BRANCH | \$${COST_FMT} | Ctx: ${PERCENT_INT}%"

Output: [Opus] my-project | main | $0.42 | Ctx: 37%

Bash com Cores ANSI

Output com código de cores torna a informação mais fácil de ler de relance:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
# ANSI colors
ORANGE='\033[38;5;208m'
GREEN='\033[32m'
YELLOW='\033[33m'
RED='\033[31m'
CYAN='\033[36m'
RESET='\033[0m'
 
# Color context percentage based on usage
PERCENT_INT=$(printf '%.0f' "$PERCENT_USED")
if [ "$PERCENT_INT" -lt 50 ]; then
    CTX_COLOR=$GREEN
elif [ "$PERCENT_INT" -lt 80 ]; then
    CTX_COLOR=$YELLOW
else
    CTX_COLOR=$RED
fi
 
COST_FMT=$(printf '%.2f' "$COST")
 
echo -e "${ORANGE}[$MODEL]${RESET} ${CURRENT_DIR##*/} ${CYAN}\$${COST_FMT}${RESET} ${CTX_COLOR}Ctx:${PERCENT_INT}%${RESET}"

A percentagem de contexto fica verde abaixo dos 50%, amarela entre 50-80% e vermelha acima dos 80%. Vês imediatamente quando é hora de gerir a tua janela de contexto.

Abordagem com Funções Auxiliares para Scripts Complexos

Quando o teu script de status line cresce, funções auxiliares mantêm tudo legível:

#!/bin/bash
input=$(cat)
 
# Helper functions for clean extraction
get_model()     { echo "$input" | jq -r '.model.display_name'; }
get_dir()       { echo "$input" | jq -r '.workspace.current_dir'; }
get_cost()      { echo "$input" | jq -r '.cost.total_cost_usd // 0'; }
get_context()   { echo "$input" | jq -r '.context_window.used_percentage // 0'; }
get_added()     { echo "$input" | jq -r '.cost.total_lines_added // 0'; }
get_removed()   { echo "$input" | jq -r '.cost.total_lines_removed // 0'; }
get_version()   { echo "$input" | jq -r '.version'; }
 
MODEL=$(get_model)
DIR=$(get_dir)
COST=$(printf '%.2f' "$(get_cost)")
CTX=$(printf '%.0f' "$(get_context)")
ADDED=$(get_added)
REMOVED=$(get_removed)
 
echo "[$MODEL] ${DIR##*/} | \$$COST | Ctx:${CTX}% | +$ADDED/-$REMOVED"

Output: [Opus] my-project | $0.42 | Ctx:37% | +156/-23

O +156/-23 mostra as linhas adicionadas e removidas na sessão. Uma forma rápida de ver quanto código mudou.

Status Line em Python

Se preferes Python ao bash:

#!/usr/bin/env python3
import json
import sys
import os
import subprocess
 
data = json.load(sys.stdin)
 
model = data["model"]["display_name"]
current_dir = os.path.basename(data["workspace"]["current_dir"])
cost = data.get("cost", {}).get("total_cost_usd", 0)
ctx_pct = data.get("context_window", {}).get("used_percentage", 0)
 
# Get git branch
git_branch = ""
try:
    result = subprocess.run(
        ["git", "branch", "--show-current"],
        capture_output=True, text=True, timeout=2
    )
    if result.returncode == 0 and result.stdout.strip():
        git_branch = f" | {result.stdout.strip()}"
except Exception:
    pass
 
print(f"[{model}] {current_dir}{git_branch} | ${cost:.2f} | Ctx:{ctx_pct:.0f}%")

Status Line em Node.js

Para developers JavaScript:

#!/usr/bin/env node
const fs = require("fs");
const path = require("path");
const { execSync } = require("child_process");
 
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 currentDir = path.basename(data.workspace.current_dir);
  const cost = (data.cost?.total_cost_usd || 0).toFixed(2);
  const ctxPct = Math.round(data.context_window?.used_percentage || 0);
 
  // Get git branch
  let gitBranch = "";
  try {
    const branch = execSync("git branch --show-current", {
      encoding: "utf8",
      timeout: 2000,
    }).trim();
    if (branch) gitBranch = ` | ${branch}`;
  } catch (e) {}
 
  console.log(
    `[${model}] ${currentDir}${gitBranch} | $${cost} | Ctx:${ctxPct}%`,
  );
});

Monitorizar o Uso da Janela de Contexto

Acompanhar a tua janela de contexto é um dos usos mais práticos da status line. Quando o contexto fica cheio, Claude Code compacta a conversa e perdes detalhe. Saber onde estás ajuda-te a decidir quando recomeçar ou compactar estrategicamente.

Abordagem simples usando a percentagem pré-calculada:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
echo "[$MODEL] Context: ${PERCENT_USED}%"

Abordagem avançada com cálculo manual a partir dos contadores de tokens em bruto:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CONTEXT_SIZE=$(echo "$input" | jq -r '.context_window.context_window_size')
USAGE=$(echo "$input" | jq '.context_window.current_usage')
 
if [ "$USAGE" != "null" ]; then
    CURRENT_TOKENS=$(echo "$USAGE" | jq '.input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens')
    PERCENT_USED=$((CURRENT_TOKENS * 100 / CONTEXT_SIZE))
    echo "[$MODEL] Context: ${PERCENT_USED}% (${CURRENT_TOKENS}/${CONTEXT_SIZE} tokens)"
else
    echo "[$MODEL] Context: 0%"
fi

A abordagem manual deixa-te ver os números de tokens em bruto ao lado da percentagem. Útil quando queres saber exatamente quantos tokens tens restantes, especialmente quando escolhes entre modelos com tamanhos de contexto diferentes.

Monitorizar o Custo da Sessão

O campo cost.total_cost_usd atualiza em tempo real. Mostrá-lo na tua status line mantém os gastos visíveis sem precisares de verificar o dashboard:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
COST_FMT=$(printf '%.2f' "$COST")
 
echo "[$MODEL] Session: \$${COST_FMT}"

Se tens um orçamento ou estás a rastrear custos por funcionalidade, isto é imediatamente útil. Combina com estratégias de seleção de modelos para mudar de modelo quando uma tarefa não precisa da opção mais cara.

Resolução de Problemas

A status line não aparece de todo

A causa mais comum é uma permissão de execução em falta no ficheiro de script. Resolve com:

chmod +x ~/.claude/statusline.sh

O script corre mas o output está vazio

O teu script pode estar a escrever para stderr em vez de stdout. A status line só lê a primeira linha do stdout. Adiciona um simples echo "test" para verificar o output, depois constrói a partir daí.

Testar o teu script manualmente

Podes testar sem correr o Claude Code enviando JSON simulado para o teu script:

echo '{"model":{"display_name":"Test"},"workspace":{"current_dir":"/test"},"cost":{"total_cost_usd":0.5},"context_window":{"used_percentage":25}}' | ~/.claude/statusline.sh

Se isso imprimir o output esperado, o script funciona. Se não funcionar, o problema está no parsing.

jq não encontrado

Instala com o teu gestor de pacotes:

# macOS
brew install jq
 
# Ubuntu/Debian
sudo apt install jq
 
# Windows (via scoop)
scoop install jq

Ideias Criativas para a Status Line

Quando tiveres o básico a funcionar, aqui ficam algumas ideias para tornar a tua status line mais útil:

  • Contador de linhas alteradas: Mostra +adicionadas/-removidas para monitorizar a produtividade da sessão
  • Duração da sessão: Calcula o tempo decorrido a partir de total_duration_ms
  • Mostrar ID completo do modelo: Mostra o identificador completo do modelo quando testares diferentes configurações
  • Diretório do projeto vs diretório atual: Mostra ambos quando Claude Code navega para subdiretórios
  • Custo por minuto: Divide total_cost_usd por total_duration_ms para ver a taxa de consumo
  • Barra da janela de contexto: Substitui a percentagem por uma barra visual como [========--]
  • Avisos condicionais: Mostra uma cor quando o contexto ultrapassa 80% ou o custo passa um limite

A status line corre um script que tu controlas. Se consegues escrevê-lo em bash, Python ou Node.js, consegues mostrá-lo. Se preferes saltar a parte de scripting, o Code Kit do ClaudeFast inclui um statusline-monitor.mjs pré-construído que mostra o uso do contexto, orçamento de API e estado de backup de fábrica.

O Que Experimentar a Seguir

A tua status line está configurada. Aqui ficam os próximos passos naturais:

  • Gere o contexto proativamente: Usa o teu display de percentagem de contexto junto com estratégias de gestão do buffer de contexto
  • Configura o ambiente de terminal: Aprende técnicas de controlo de terminal para um workspace completo do Claude Code
  • Configura as definições do projeto: Garante que as tuas configurações básicas estão sólidas para que cada sessão comece com o contexto certo

More in Toolkit

  • Atalhos de Teclado
    Configure o keybindings.json do Claude Code: 17 contextos, sintaxe de teclas, sequências de acordes, combinações de modificadores e como desvincular qualquer atalho padrão instantaneamente.
  • Otimização de SEO e GEO com IA
    Um resumo sobre Generative Engine Optimization: como fazer com que o teu conteúdo seja citado dentro das respostas do ChatGPT, Claude e Perplexity, em vez de apenas aparecer no Google.
  • Claude Code vs Cursor em 2026
    Uma comparação lado a lado entre Claude Code e Cursor em 2026: modelos de agente, janelas de contexto, planos de preço e como cada ferramenta se encaixa em diferentes fluxos de trabalho.
  • Extensão Claude Code para VS Code
    A extensão VS Code da Anthropic coloca Claude Code dentro da barra lateral do editor como um painel com ícone Spark, com diffs inline, modo de plano, subagentes e suporte MCP.
  • Keybindings do Claude Code
    Reconfigura os atalhos do Claude Code via keybindings.json. 17 contextos, sintaxe de teclas, sequências de acordes, stacks de modificadores, como remover padrões, configurações prontas a usar.
  • OpenClaw vs Claude Code
    OpenClaw vs Claude Code: um assistente de vida ligado a apps de mensagens versus um agente de código em terminal que lê o seu repositório. Quando cada um merece um lugar no seu workflow.

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.

Atalhos de Teclado

Configure o keybindings.json do Claude Code: 17 contextos, sintaxe de teclas, sequências de acordes, combinações de modificadores e como desvincular qualquer atalho padrão instantaneamente.

Guia de Hooks

Hooks do Claude Code do princípio ao fim: exit codes, output JSON, comandos assíncronos, endpoints HTTP, matchers PreToolUse e PostToolUse, padrões para produção.

On this page

O Que a Status Line Mostra
Configuração Rápida com /statusline
Configuração Manual via settings.json
Como Funciona o Motor da Status Line
O Input JSON que o Teu Script Recebe
Scripts de Status Line Prontos para Copiar
Status Line Simples em Bash
Status Line Bash com Suporte a Git
Status Line Bash Completa
Bash com Cores ANSI
Abordagem com Funções Auxiliares para Scripts Complexos
Status Line em Python
Status Line em Node.js
Monitorizar o Uso da Janela de Contexto
Monitorizar o Custo da Sessão
Resolução de Problemas
Ideias Criativas para a Status Line
O Que Experimentar a Seguir

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.