Build This Now
Build This Now
Atalhos de TecladoGuia da Status Line
Extensão Claude Code para VS CodeClaude Code vs Cursor em 2026Claude Code vs Cursor vs Copilot 2026OpenClaw vs Claude CodeOpenCode vs Claude CodeGemini CLI vs Claude CodeOtimização de SEO e GEO com IAClaude Code vs GitHub Copilot in 2026Keybindings do Claude CodeConfiguração da Linha de Status do Claude CodeClaude Code vs Windsurf in 2026Claude Code vs Lovable: Terminal Agent vs App BuilderClaude Code vs Bolt.new: Which Should You Use?
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 Bolt.new: Which Should You Use?
    Bolt.new prototypes in 28 minutes with zero setup. Claude Code takes 90 minutes but ships production-ready code. Here is how to pick the right tool.
  • Claude Code vs Cursor vs Copilot 2026
    Side-by-side feature matrix and decision blocks for the three AI coding tools most developers shortlist this year, with verified pricing as of May 2026.
  • 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.
  • Claude Code vs GitHub Copilot in 2026
    Copilot Pro costs $10/month and has a real free tier. Claude Code starts at $20/month and scores 80.8% on SWE-bench. Here's when each one wins.
  • Claude Code vs Lovable: Terminal Agent vs App Builder
    Claude Code and Lovable solve different problems: one commits code to your repo, the other deploys a live URL. Here's how to pick the right tool.

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.

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.

Claude Code vs Windsurf in 2026

Both cost $20/month now. The difference is what they do: Claude Code runs autonomous sessions in your terminal. Windsurf gives you inline completions in an IDE.

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.