Build This Now
Build This Now
Atalhos de TecladoGuia da Status Line
Extensão Claude Code para VS CodeClaude Code vs Cursor em 2026OpenClaw vs Claude CodeOtimização de SEO e GEO com IAKeybindings do Claude CodeConfiguração da Linha de Status do Claude Code
speedy_devvkoen_salo
Blog/Toolkit/Extensions/Claude Code Status Line Setup

Configuração da Linha de Status do Claude Code

Configure uma linha de status para o Claude Code com modelo, branch do git, custo da sessão e uso do contexto. Config no settings.json, contrato JSON de entrada, scripts em bash, Python e Node.

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.

Published Feb 24, 2026Toolkit hubExtensions index

Problema: O terminal do Claude Code deixa muita informação útil fora do ecrã. Uma linha de status personalizada mostra o nome do modelo, o branch do git, o custo acumulado da sessão e o uso do contexto mesmo abaixo da interface de chat.

Pensa nisto como o PS1 do Claude Code. Se já alguma vez ajustaste um prompt do shell com Oh-my-zsh ou Starship, a ideia é exatamente a mesma. Uma linha de informação ao vivo que te mantém orientado enquanto trabalhas.

O Que a Linha de Status Mostra

A linha de status fica na parte inferior da interface do Claude Code e atualiza sempre que a conversa muda. O que o teu script imprimir é o que aparece: o modelo atual, o branch ativo do git, quanto a sessão custou até agora, ou quão preenchida está a janela de contexto.

Aqui está um exemplo configurado:

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

Uma linha. Modelo, pasta do projeto, branch do git, custo acumulado da sessão e a percentagem da janela de contexto em uso. Todos os campos atualizam sozinhos.

Configuração Rápida com /statusline

O comando /statusline está integrado diretamente na CLI. Escreve-o dentro do Claude Code e ele gera um script para ti.

/statusline

O comportamento padrão cria um script de linha de status que replica o teu prompt do terminal. Também podes passar um pedido específico:

/statusline show the model name in orange

/statusline display git branch and session cost

/statusline show context window percentage with color coding

É tudo. O Claude Code escreve o script, configura o settings, e a linha de status aparece. Para controlo total, segue a rota manual abaixo.

Configuração Manual via settings.json

Para configurar à mão, adiciona uma entrada statusLine ao .claude/settings.json do teu projeto (ou ao ~/.claude/settings.json global, se quiseres em todos os projetos):

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

Três campos a conhecer:

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

Com essa entrada no lugar, cria o ficheiro de script e marca-o como executável:

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

O passo chmod +x é importante. Se a linha de status nunca aparecer, uma permissão de execução em falta é quase sempre a causa.

Como Funciona o Motor da Linha de Status

Conhecer a mecânica compensa no momento em que depuras ou personalias um script:

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

Esse último ponto é a chave. O teu script recebe um payload JSON estruturado no stdin 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 para o stdout.

O JSON que o Teu Script Recebe

Em cada atualização da linha de status, o teu script recebe esta estrutura JSON no 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 fazem o trabalho real numa linha de status prática:

  • 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: Acompanha alterações no código
  • context_window.used_percentage: Uso do contexto pré-calculado (0-100)
  • context_window.context_window_size: Capacidade total da janela de contexto

Scripts de Linha de Status Prontos a Usar

Abaixo estão scripts completos e funcionais em várias linguagens. Pega no que encaixar no teu setup.

Linha de Status Simples em Bash

A linha de status mais pequena que vale a pena usar. Nome do modelo mais 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

Por trás dos panos, este script usa jq para o parsing de JSON. Se jq não estiver instalado, corre brew install jq no macOS ou sudo apt install jq no Ubuntu.

Linha de Status com Suporte a Git

A informação do branch junta-se à linha, o que ajuda quando estás a gerir vários 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

Linha de Status Completa em Bash

Modelo, branch do git, custo da sessão e percentagem de contexto, tudo numa 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

O código de cores torna a linha escaneável num 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}"

Abaixo de 50%, a percentagem de contexto fica verde. Entre 50-80%, amarelo. Acima de 80%, vermelho. Um sinal visual rápido de que está na hora de gerir a janela de contexto.

Abordagem com Funções Auxiliares para Scripts Complexos

Quando um script de linha de status cresce, funções auxiliares mantêm-no 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 no fim acompanha linhas adicionadas e removidas na sessão. Uma leitura rápida de quanto código mudou de facto.

Linha de Status em Python

Para quem prefere Python em vez de 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}%")

Linha de Status em Node.js

Para quem trabalha com 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

Ter os olhos postos na janela de contexto é uma das razões mais práticas para usar uma linha de status. Quando fica cheia, o Claude Code compacta a conversa e os detalhes perdem-se. Ver onde estás ajuda-te a decidir quando recomeçar ou compactar nos teus próprios termos.

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 versão avançada expõe os números de tokens em bruto ao lado da percentagem. Útil quando queres saber o orçamento exato de tokens restantes, especialmente ao escolher entre modelos com diferentes tamanhos de contexto.

Monitorizar o Custo da Sessão

cost.total_cost_usd atualiza em tempo real. Mostrá-lo na linha de status mantém os gastos visíveis sem ir ao 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}"

Para quem tem orçamento ou acompanha custo por funcionalidade, essa visibilidade compensa logo. Combina com estratégias de seleção de modelo e trocas de modelo assim que uma tarefa fica abaixo do nível de exigência do Opus.

Resolução de Problemas

A linha de status não aparece de todo

Uma permissão de execução em falta no ficheiro de script é o culpado habitual. Corrige com:

chmod +x ~/.claude/statusline.sh

O script corre mas o output fica vazio

O teu script pode estar a escrever para stderr em vez de stdout. Apenas a primeira linha do stdout chega à linha de status. Adiciona um echo "test" rápido para confirmar o output, depois constrói a partir daí.

Testar o script manualmente

Podes testar sem lançar o Claude Code passando JSON simulado diretamente para o 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 a linha esperada, o script está bem. Se não sair nada, o problema está no parsing.

jq não encontrado

Instala pelo teu gestor de pacotes:

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

Ideias Criativas para a Linha de Status

Quando o básico funciona, algumas ideias para ir mais longe com a linha de status:

  • Rastreador de linhas alteradas: Imprime +adicionadas/-removidas para acompanhar a produtividade da sessão
  • Duração da sessão: Deriva o tempo decorrido a partir de total_duration_ms
  • Exibição do ID do modelo: Mostra o identificador completo do modelo ao testar diferentes configurações
  • Diretório do projeto vs. atual: Mostra ambos quando o Claude Code entra em subdiretórios
  • Custo por minuto: Divide total_cost_usd por total_duration_ms e vê o ritmo de gasto real
  • Barra de janela de contexto: Troca a percentagem por uma barra visual como [========--]
  • Avisos condicionais: Muda cores quando o contexto passa 80% ou o custo ultrapassa um limite

A linha de status corre qualquer script que lhe deres. Bash, Python, Node.js, tudo o que conseguires escrever aparece no ecrã.

O Que Experimentar a Seguir

A tua linha de status está ativa. Próximos passos naturais:

  • Gerir o contexto de forma proativa: Usa a percentagem de contexto ao lado de estratégias de gestão de buffer de contexto
  • Configurar o ambiente de terminal: Aprende técnicas de controlo do terminal para um workspace completo do Claude Code
  • Configurar definições do projeto: Define as bases da configuração para que cada sessão comece com o contexto certo

Continue in Extensions

  • 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.

More from 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.
  • 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.
  • Hooks de Setup do Claude Code
    Combina scripts, agentes e documentação em hooks de setup do Claude Code. Um comando corre um script determinístico, passa o output para um agente de diagnóstico, e regista documentação viva.
  • Hooks de Backup de Contexto para o Claude Code
    Um hook de backup de contexto do Claude Code baseado em StatusLine. Escreve snapshots estruturados a cada 10K tokens para que a compactação automática nunca apague erros, assinaturas nem decisões.

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.

On this page

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

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.