csr-cockpit

Um painel ao lado da conversa do Claude Code com os instrumentos da sessão: quem está trabalhando (os subagentes, quem chamou quem e o que eles conversam), o que foi editado, quanto do contexto e do dinheiro já foi, o que aconteceu em cada turno, onde o Claude está mexendo agora e o que está instalado. Mais uma linha de resumo acima do prompt.

<img src="../../docs/arte/telas/pilulas.svg" width="860" alt="A linha de resumo do csr-cockpit no app Desktop: pílulas com a marca CSR, o cérebro da conversa principal trabalhando, o robô dos 2 agentes em paralelo, o repositório proj no ramo main com 3 arquivos alterados, o contexto em 71%, o custo de US$ 2,21, os limites de 5 horas e de 7 dias, o modelo Opus 5.5 com esforço high e o cache em 99%"> <img src="../../docs/arte/telas/agentes.svg" width="720" alt="A aba Agentes do csr-cockpit no app Desktop: as contagens, o grafo de quem chamou quem com a conversa principal no centro e quatro agentes, a linha do tempo e os cartões dos agentes rodando e concluídos">

[!NOTE] O csr-cockpit só observa. Nenhum dos seus hooks bloqueia, altera ou segura uma chamada de ferramenta nem uma resposta do modelo: todos repassam o que receberam e devolvem o resultado como veio. Ele também não chama o modelo nem acrescenta nada à conversa, então não gasta tokens por conta própria. A única requisição a mais é a do botão Contagem exata, na aba Contexto, e só quando você o aperta.

As telas desta página saem do próprio mod: o script scripts/telas roda o código de verdade do csr-cockpit com uma sessão encenada num projeto de exemplo (uma loja online) e monta o que cada aba desenha, no visual do app Desktop. Os números são inventados; o desenho é o do mod. As bolinhas numeradas não fazem parte do painel: elas apontam o que a lista embaixo de cada tela explica.

No blog, o post Um mod do Claude Code na prática explica o que fica de fora daqui: a diferença entre o repositório e o marketplace, por que uma versão nova só chega quando o version sobe, o que cada camada de teste confere e o que o Claude Code mostra de custo sem o cockpit.

• Requisitos · Instalar e atualizar · Usar
• A linha de resumo
• As abas: Agentes · Diffs · Contexto · Turnos · Árvore · Inventário
• No terminal · O custo de cada agente · Quando algo dá errado · Limites · Privacidade · Desenvolver

Requisitos

• Claude Code 2.1.287 ou mais novo (claude --version). O app Desktop traz a própria cópia do Claude Code: atualize o app também.
• O painel é desenhado no terminal e na aba Code do app Desktop. Na extensão do VS Code e em claude -p, os dados são registrados, mas nada é desenhado.

Instalar e atualizar

claude plugin marketplace add cesarschutz/claude-code-kit

claude plugin install csr-cockpit@cesarschutz

Num marketplace de terceiros, a atualização automática vem desligada. Para pegar a versão nova:

claude plugin marketplace update cesarschutz

claude plugin update csr-cockpit@cesarschutz

A sessão que já estava aberta segue com a versão anterior até um /reload-plugins ou até abrir uma sessão nova.

A opção do plugin

O valor em reais do total geral (aba Contexto) usa uma cotação do dólar que você escolhe: o cockpit não busca nada na internet. Ela vem em R$ 5,22 (a do dólar comercial em 02/10/2026) e muda no /config, na linha Cotação do dólar em reais do csr-cockpit. Com 0, o valor em reais some.

Usar

| Tecla ou comando | O que faz | |---|---| | /cockpit | Abre e fecha o painel | | /cockpit <aba> | Abre o painel numa aba (agentes, diffs, contexto, turnos, arvore, inventario, ou o número); com ele aberto, só troca de aba | | /inventario | Abre o painel na aba Inventário | | <kbd>Esc</kbd> | Fecha o painel | | <kbd>1</kbd> a <kbd>6</kbd> | Trocam de aba, com o painel em foco | | Nome na lista | Abre o detalhe de um agente, de um comando ou de um turno (clique, ou <kbd>Tab</kbd> até ele e <kbd>Enter</kbd>) | | <kbd>v</kbd> | Volta do detalhe para a lista |

Cada aba tem as suas teclas, na seção dela. Os dados são registrados desde o início da sessão, com o painel aberto ou fechado. Se o painel não tiver lugar ao lado da conversa, aparece uma versão compacta acima do prompt, com as mesmas abas.

A linha de resumo

No app Desktop, acima do prompt fica uma fileira de pílulas arredondadas, claras no tema claro e escuras no escuro. O que está vivo vem primeiro:

<img src="../../docs/arte/telas/pilulas-estreitas.svg" width="680" alt="A linha de resumo do csr-cockpit no app Desktop, em duas fileiras de pílulas: a marca CSR, o cérebro da conversa principal trabalhando, o robô dos 2 agentes em paralelo, o repositório proj no ramo main com 3 arquivos alterados, o contexto em 71% com 141,2 mil tokens e mais 8,3 mil do último turno, o custo de 2 dólares e 21 centavos com mais 37 centavos do último turno, o limite de 5 horas em 38%, renovando em 2 horas e 8 minutos, o de 7 dias em 21%, o modelo Opus 5.5 com esforço high e o cache em 99%">

| Pílula | O que mostra | |---|---| | ✦ CSR | A marca do cockpit, cheia no azul do Grêmio | | Cérebro pulsando | A conversa principal está trabalhando neste turno (some quando ela para) | | Robô 2 em paralelo | Subagentes rodando em paralelo, com a luz da antena piscando (só aparece enquanto há algum) | | ⑂ proj │ main │ 3 alterados | Repositório, ramo do git e quantos arquivos estão sem commit. Clicar abre a aba Árvore | | ◔ 71% │ 141,2k +8,3k | Contexto: a pizza, o percentual, os tokens e o que o último turno somou. Clicar abre a aba Contexto | | $ US$ 2,21 +0,37 | Custo da sessão e do último turno | | ◠ 5h 38% │ ⏱ 2h09 e ▦ 7d 21% │ ⏱ 6d | Cada limite de uso e quando renova | | ✦ Opus 5.5 │ high | Modelo e esforço da última resposta da conversa principal | | ⚡ cache 99% | Quanto da entrada da última resposta veio do cache: quanto mais, mais barato o turno |

A cor do contexto segue a distância até a compactação automática (o Claude Code compacta sozinho perto de 97% numa janela de 1M, de 83% numa de 200k): verde longe, âmbar a 15 pontos, vermelha a 5. Só perto aparece o aviso, com quanto falta: compacta em 97% · faltam 52k. Sem largura, as pílulas descem para outra fileira.

No terminal, que não desenha SVG nem canto redondo, a linha é uma fileira de selos de texto (veja No terminal). O "último turno" conta do seu último pedido até agora, com os retornos de agentes em segundo plano incluídos.

As abas

<a href="#1-agentes"><img src="../../docs/arte/aba-1.svg" height="28" alt="1 Agentes"></a> <a href="#2-diffs"><img src="../../docs/arte/aba-2.svg" height="28" alt="2 Diffs"></a> <a href="#3-contexto"><img src="../../docs/arte/aba-3.svg" height="28" alt="3 Contexto"></a> <a href="#4-turnos"><img src="../../docs/arte/aba-4.svg" height="28" alt="4 Turnos"></a> <a href="#5-árvore"><img src="../../docs/arte/aba-5.svg" height="28" alt="5 Árvore"></a> <a href="#6-inventário"><img src="../../docs/arte/aba-6.svg" height="28" alt="6 Inventário"></a>

No alto do painel, ao lado da marca, um resumo da sessão (contexto, turnos, agentes rodando, custo). Cada aba tem um ícone e uma cor; a aberta vira um selo nessa cor. No painel estreito (menos de 84 colunas), as fechadas mostram só o ícone.

As listas trazem o estado à esquerda, como numa lista de CI: azul roda, verde deu certo, vermelho falhou, âmbar foi negado. O texto colorido usa as cores do tema do Claude Code, então se lê no tema claro, no escuro e nos de daltonismo. No app Desktop, as abas ganham gráficos em SVG; no terminal, os mesmos números viram barras de texto.

1 Agentes

Quem está trabalhando agora, em quê, e quem chamou quem?

<img src="../../docs/arte/telas/agentes.svg" width="720" alt="A aba Agentes com cinco marcas numeradas: 1, as contagens de agentes rodando e concluídos; 2, o grafo de quem chamou quem, com o Plan criando o revisor e um Explore, e o Plan e o revisor trocando mensagens; 3, a linha do tempo dos agentes; 4, o cartão de um agente rodando; 5, o link Ver detalhes">

1. As contagens: quantos subagentes estão rodando, quantos terminaram e quantos falharam.

2. Quem chamou quem: a conversa principal, desenhada como um cérebro, e cada agente que ela criou, desenhado como um robozinho. O grafo tem duas formas e escolhe sozinho:

   • Radial, com poucos agentes e todos criados pela conversa principal: o cérebro no centro e os robôs num anel em volta, dos dois lados, mesmo com zoom.
   • Árvore, quando há agentes criando agentes (ou muitos agentes): o cérebro à esquerda, um nível por coluna e uma linha por agente, com cada pai no meio dos filhos (aqui, o Plan criou o revisor). O grafo cresce para baixo e os rótulos não se cruzam. Num painel estreito, a árvore fica recuada, como uma árvore de pastas: um agente por linha, e o nome vai até a borda.

   O desenho ocupa a largura do painel e fica no meio dela. Cada nó mostra a tarefa e, menor embaixo, o tipo (num agente de workflow, a fase: veja Os agentes de um workflow). Enquanto a conversa principal trabalha, o cérebro solta ondas, ganha faíscas em órbita, acende as sinapses e mostra "pensando…"; parado, ele só respira devagar. A cor do robô é o estado: azul enquanto roda (e aí ele balança, digita com os braços, corre os olhos no visor, mostra os três pontinhos de quem está escrevendo e pisca a luz âmbar da antena), verde e sorrindo quando termina (flutuando devagar, piscando de vez em quando), vermelho, caído de lado e de olhos em X quando falha. A borda diz de onde vem a definição do agente: tracejada para os globais (~/.claude/agents, valem em todos os projetos, como o code-reviewer da imagem), cheia para os do projeto (.claude/agents), pontilhada para os de plugin e sem borda para os embutidos (Explore, Plan...). As mensagens do SendMessage, entre a conversa principal e um agente ou entre dois agentes, são curvas tracejadas com seta e quantas foram (✉ 2). O fio entre um agente e quem o criou corre por 8 segundos quando ele nasce e quando devolve a resposta.

   Passando o mouse num agente, um cartão mostra a tarefa, o tipo, de onde vem, o custo e há quanto tempo roda; clicar em qualquer ponto dele abre o detalhe. Os controles, embaixo do título:

   • Ampliar transforma a aba numa vista só do grafo, com a altura do painel (a linha do tempo e os cartões voltam no Reduzir), e mostra até 40 agentes em vez de 16.
   • − 100% + é o zoom: o desenho inteiro, texto e robôs juntos, de 80% a 200%. Ampliado, o zoom começa em 125%.
   • Todos, Rodando e Com falha apagam os outros agentes (e as mensagens deles) para destacar os que importam agora.

   O tamanho e o zoom escolhidos valem para as próximas sessões também. O grafo traz sempre quem criou cada agente mostrado, mesmo que seja antigo; os que ficaram de fora são contados embaixo.

3. A linha do tempo: os 12 agentes mais recentes na mesma régua, uma barra do começo ao fim de cada um. Mostra de relance quem rodou em paralelo e quem demorou. O nome de cada um abre o detalhe. O tempo de quem ainda roda aparece em segundos no primeiro minuto e depois em minutos.

4. Os cartões, no jeito do "Em execução" do Claude Code, só com o essencial: a tarefa e o tipo, o tempo e a situação, o modelo (Haiku 4.5), o tamanho do contexto do próprio agente, quanto ele custou, as chamadas, os tokens e, enquanto roda, a atividade de agora (a última ferramenta e o argumento). O resultado se lê no detalhe.

5. Ver detalhes abre o detalhe do agente; clicar em qualquer ponto do cartão faz o mesmo (num painel estreito do Desktop, o link sai e fica só o cartão).

O grafo e a linha do tempo seguem as ideias do Agent Flow e do View Claude Code. No terminal, o grafo vira uma árvore de texto (├─ ● Plan · Planejar a refatoração), quando há agentes criados por agentes ou mensagens entre eles.

Os agentes de um workflow

<img src="../../docs/arte/telas/agentes-workflow.svg" width="720" alt="A aba Agentes com um workflow rodando, com três marcas: 1, o grafo, em que as fases Pesquisa e Crítica do workflow pesquisa-de-frete são nós entre a conversa principal e os agentes delas; 2, o cartão do workflow, com os agentes, os que rodam e os tokens; 3, a fase Crítica, com quantos agentes terminaram e uma linha por agente">

Os agentes de um workflow (que não passam pela ferramenta Agent) aparecem com o nome que o script lhes deu, a fase, o pedido e o resultado, que o cockpit lê dos arquivos da execução:

1. No grafo, cada fase é um nó, desenhado como uma pilha de cartões, entre a conversa principal e os agentes dela, com quantos terminaram.
2. O cartão do workflow, como no painel de tarefas do Claude Code: o nome, quantos agentes, quantos rodam, os tokens e o tempo.
3. As fases, cada uma com quantos agentes terminaram e um quadradinho na cor de cada um, e uma linha por agente com o nome, o modelo, os tokens, o custo e o tempo. O nome abre o detalhe.

O detalhe de um agente

<img src="../../docs/arte/telas/ficha-agente.svg" width="720" alt="O detalhe do agente Plan, com cinco marcas: 1, os botões Voltar e Reler mensagens; 2, as ferramentas que o agente chamou, em barras; 3, os comandos Bash dele; 4, o pedido que o agente recebeu; 5, a resposta">

No mesmo jeito do detalhe de um turno:

1. Voltar (<kbd>v</kbd>) e Reler mensagens (<kbd>m</kbd>): as mensagens do agente são lidas da transcrição dele ao abrir o detalhe e de novo no botão; não são ao vivo.
2. As ferramentas que o agente chamou, em barras, com quantas vezes cada uma.
3. Os comandos Bash dele, com o estado, o exit code e a duração. Clicar num comando abre o detalhe dele, e o Voltar traz de volta ao agente.
4. O pedido que o agente recebeu, inteiro (num agente de workflow, o texto que o script calculou para ele).
5. A resposta. Num agente de workflow que devolve uma saída estruturada, o resumo e o JSON. O detalhe traz também quem criou o agente (quando foi outro agente), as últimas 40 chamadas com o estado e a duração, o que ele escreveu ao longo do trabalho, os tokens de entrada e de saída, o contexto e o custo dele.

2 Diffs

O que mudou, arquivo por arquivo?

<img src="../../docs/arte/telas/diffs.svg" width="720" alt="A aba Diffs com três marcas: 1, as fontes Sessão, Turno e Git; 2, a lista de arquivos alterados numa árvore, com a letra do status e as linhas somadas; 3, o diff do arquivo escolhido, com números de linha, fundo verde e vermelho e a palavra que mudou em destaque">

1. A fonte, uma de cada vez: Sessão (<kbd>s</kbd>), cada arquivo que o Claude editou nos últimos 10 turnos, com as edições dele em ordem; Turno (<kbd>e</kbd>), o mesmo, só de um turno (<kbd>t</kbd> e <kbd>y</kbd> vão ao anterior e ao seguinte); Git (<kbd>g</kbd>), a árvore de trabalho contra o HEAD, com o que o Claude, os subagentes, os comandos e você mudaram.
2. A lista, como a visão de alterações do VS Code: os arquivos numa árvore (pastas compactas, como src/components), a letra do status na cor do git (M amarelo, A verde, D vermelho), as linhas +N −N e o escolhido na faixa azul da seleção. Os cinco quadradinhos do GitHub (■■■■■) mostram a proporção de linhas que entraram e saíram. <kbd>p</kbd> e <kbd>n</kbd> vão ao arquivo anterior e ao seguinte; clicar no nome abre o diff dele.
3. O diff, no app Desktop desenhado como o diff do próprio Claude Code: fonte monoespaçada, números de linha antes e depois, a linha inteira com fundo verde ou vermelho, a palavra que mudou em destaque, cores de sintaxe e uma faixa com quantas linhas ficaram iguais entre os trechos. No terminal, desenhado pelo Claude Code, com a margem de números e as cores.

Sem largura para os dois lado a lado (menos de 90 colunas), a lista vai em cima e o diff embaixo. No Write sobre um arquivo que já existia, o conteúdo antigo é lido antes da escrita, para o diff ser o real.

3 Contexto

Quanto do contexto sobra, e quanto já custou?

<img src="../../docs/arte/telas/contexto.svg" width="720" alt="A aba Contexto com seis marcas: 1, o anel com 71% do contexto usado e o que o último turno somou; 2, o custo da sessão e do último turno; 3, os limites de uso de 5 horas e de 7 dias, com quando renovam; 4, o total geral da sessão, a conversa e os subagentes, em tokens, em dólar e em reais; 5, o detalhamento do contexto por categoria; 6, o botão Contagem exata">

1. O uso do contexto: o percentual, os tokens sobre a janela e quanto o último turno somou.
2. O custo da sessão e do último turno.
3. O limite de uso da conta, cada janela com o percentual e quando renova.
4. O total geral, da conversa e de todos os subagentes (os de workflow também), desde o começo da sessão: os tokens de todas as respostas do modelo (entrada, cache e saída) e o custo, em dólar e em reais, cada um com a parte da conversa e a dos subagentes. Uma compactação não zera a soma. O custo é o da sessão, que o Claude Code já informa com os subagentes dentro; a parte de cada um é a repartição do cockpit (veja O custo de cada agente).
5. O detalhamento por categoria (mensagens, prompt de sistema, ferramentas, memória, espaço livre): uma estimativa local, atualizada a cada turno, sem requisição extra.
6. Contagem exata troca a estimativa pela contagem de verdade, que faz uma requisição por ferramenta e por arquivo de memória; por isso só acontece quando o botão é apertado.

4 Turnos

O que aconteceu, na ordem?

<img src="../../docs/arte/telas/turnos.svg" width="720" alt="A aba Turnos com cinco marcas: 1, o gráfico com a duração de cada turno; 2, as ferramentas mais chamadas na sessão; 3, o turno em andamento num cartão; 4, o comando Bash que está rodando agora; 5, o link para ver todos os comandos de um turno">

1. A duração de cada turno, numa barra: roxo concluído, vermelho com falha, azul em andamento. Passando o mouse, a dica abre na hora com o pedido, a duração, o custo e as ferramentas.
2. As ferramentas mais chamadas na sessão.
3. Um registro por pedido, do mais recente ao mais antigo: o começo do pedido, a duração, quanto somou ao contexto, quanto custou, quantas ferramentas, edições e comandos Bash, e as falhas. Cada turno fica no seu cartão, separado do próximo; o ponto do cartão fica azul em andamento e vermelho quando houve falha. Clicar em qualquer ponto do cartão abre o detalhe do turno.
4. Os comandos Bash ficam no turno em que rodaram, com o estado, o exit code e a duração: os três últimos de cada turno, clicáveis, e o que está rodando agora no cartão do turno. A pasta do projeto some dos comandos (find /pasta/do/projeto/src aparece como find src).
5. "… mais N comandos · ver todos" abre o detalhe do turno.

Quando um agente em segundo plano termina, o Claude Code abre um turno sozinho para tratar o retorno. A aba junta esses turnos ao pedido que os gerou: um pedido seu é um turno na lista, com a duração, o custo e as ferramentas de tudo o que ele desencadeou.

O detalhe de um turno

<img src="../../docs/arte/telas/ficha-turno.svg" width="720" alt="O detalhe do turno 4, com cinco marcas: 1, as ferramentas chamadas no turno, em barras; 2, os comandos Bash do turno com o estado e o exit code; 3, o pedido inteiro; 4, os subagentes do turno, com o grafo de quem chamou quem só deles e um cartão por agente, com o pedido que recebeu e a resposta; 5, a resposta">

1. As ferramentas chamadas no turno, em barras.
2. Os comandos Bash do turno, todos. Clicar num comando abre o detalhe dele (o comando inteiro, a descrição, o fim da saída e o erro), e o "Voltar" traz de volta ao turno.
3. O pedido inteiro.
4. Os subagentes que o turno criou: o grafo de quem chamou quem só com eles (e as mensagens entre eles) e um cartão por agente, com o pedido que ele recebeu e a resposta que deu, o que a conversa principal não mostra. "Ver detalhes" (ou clicar no agente do grafo) abre o detalhe do agente, e o "Voltar" traz de volta ao turno.
5. A resposta. Quando houve agentes em segundo plano, vem também o que o Claude respondeu depois do retorno de cada um.

5 Árvore

Onde o Claude está mexendo agora?

<img src="../../docs/arte/telas/arvore.svg" width="720" alt="A aba Árvore com quatro marcas: 1, a linha que explica a aba e o ramo do git; 2, os botões Atualizar, Projeto inteiro, Expandir tudo e Recolher tudo; 3, a lista do que está sendo escrito agora; 4, o arquivo aceso na árvore com o selo editando">

1. O que a aba mostra: os arquivos que a sessão leu ou editou (o loop principal e todos os subagentes, workflows incluídos) e os que o git vê alterados, numa árvore de pastas no estilo do claude-code-filetree. No alto, o ramo, os commits à frente e atrás do remoto e o total das alterações.
2. Os botões: Atualizar (<kbd>g</kbd>) lê o git de novo; Projeto inteiro (<kbd>a</kbd>) alterna entre o projeto todo (as pastas listadas sob demanda, sem node_modules, .git, dist...) e só o que foi tocado ou alterado; Expandir tudo (<kbd>x</kbd>) e Recolher tudo (<kbd>r</kbd>).
3. Agora mesmo: enquanto um Read, Edit, Write, NotebookEdit, um Grep num arquivo ou um comando Bash que lê ou escreve arquivos roda, o arquivo aparece aqui, com quem está mexendo nele. Do Bash, o cockpit lê o próprio texto do comando: cat, head, grep, sed -n leem; sed -i, tee, cp, mv, rm e os redirecionamentos (>, >>) escrevem, e um cd antes conta. Uma escrita esperando a sua permissão fica acesa até você responder.
4. Na árvore, o arquivo acende com o selo editando… (laranja) ou lendo… (roxo) e, quando a ferramenta termina, fica destacado por 8 segundos (editado há 2s). À direita, a letra do git (M, A, ?, D, R) e as linhas +N −N; cada pasta soma o que há embaixo. O que só foi lido fica apagado, com quantas vezes.

As pastas abrem sozinhas quando há algo tocado ou alterado embaixo, e clicar no nome da pasta (ou na setinha) abre e fecha à mão. O git é lido ao abrir a sessão, 1,5 s depois de cada escrita ou comando Bash e no fim de cada turno, sem os hooks do repositório.

6 Inventário

O que este Claude Code tem, e o que está ligado nesta sessão?

<img src="../../docs/arte/telas/inventario.svg" width="720" alt="A aba Inventário com quatro marcas: 1, as seções com as contagens; 2, o filtro; 3, um plugin ativo; 4, um plugin inativo">

1. As seções, com quantos itens estão ativos em cada uma (<kbd>j</kbd> e <kbd>k</kbd> trocam de seção; <kbd>u</kbd> lê tudo de novo).
2. O filtro procura por nome, origem ou descrição dentro da seção.
3. Ativo e 4. inativo: cada peça com a origem, a descrição e o que ela traz.

| Seção | O que mostra | Ativo quer dizer | |---|---|---| | Plugins | Os instalados, com versão, marketplace, descrição e o que cada um traz | Habilitado nas configurações | | Skills | Dos plugins, as suas (~/.claude/skills), as do projeto e as embutidas | O modelo vê a skill nesta sessão | | Comandos | Os comandos de barra: embutidos, de plugins, seus e de MCP | Dá para rodar agora | | Agentes | Os tipos de subagente além dos embutidos | O Agent os oferece nesta sessão | | Hooks | Das configurações e dos plugins: evento, matcher e o comando | Não estão desligados e o plugin está habilitado | | MCP | Os servidores, com as ferramentas de cada um | Conectado | | Outros | Estilo de saída, arquivos de memória (CLAUDE.md) com os tokens, ferramentas embutidas | | | Para instalar | Os plugins dos marketplaces que você adicionou e ainda não instalou | |

Nada disso gasta tokens: as listas vêm da própria sessão, das configurações e dos arquivos dos plugins no disco. O inventário é lido ao abrir a sessão, ao abrir a aba, depois de comandos como /plugin, /mcp e /hooks, e no fim de cada turno com a aba em vista. Um plugin habilitado no meio da sessão só carrega as peças depois de /reload-plugins.

No terminal

O mesmo painel, em texto: os gráficos viram barras de blocos, e o grafo de agentes, uma árvore.

<img src="../../docs/arte/telas/agentes-terminal.svg" width="420" alt="A aba Agentes no terminal: as contagens, a árvore de quem chamou quem, com as mensagens entre o Plan e o code-reviewer, e os cartões dos agentes"> <img src="../../docs/arte/telas/turnos-terminal.svg" width="420" alt="A aba Turnos no terminal: as ferramentas mais chamadas em barras de blocos e os turnos com os comandos Bash">

Acima do prompt, a linha de resumo vira selos coloridos. Quando a linha não cabe, ela se ajusta em degraus: a marca encurta, depois os rótulos saem e ficam só os valores, e só então os selos descem para a linha de baixo.

<img src="../../docs/arte/telas/selos-terminal.svg" width="760" alt="A linha de resumo no terminal: os selos CSR, contexto 71% com a barrinha e os tokens, custo, limite e agentes">

O custo de cada agente

O Claude Code informa o custo da sessão inteira, não o de cada subagente. O csr-cockpit reparte esse custo: ao fim de cada resposta do modelo, o que o custo da sessão subiu vai para quem fez a resposta. A soma bate com o total da sessão; se duas respostas terminam no mesmo instante, uma fração pode cair no agente vizinho. O valor em dólar é o do Claude Code, calculado a preço de tabela: para quem paga assinatura, ele não é cobrança, e serve para comparar um agente com outro. O "contexto" de um agente é o tamanho do contexto dele na última resposta; ele tem uma janela própria, que não ocupa a da conversa principal.

Quando algo dá errado

• Painel em branco ou com erro. Se o painel falhar ao desenhar uma aba, ele mostra o erro no lugar dela e o grava em ~/.claude/csr-cockpit-erros.log. O mesmo arquivo recebe os erros dos outros passos do cockpit e os desenhos que passarem de 250 ms. Logo depois de atualizar o plugin com a sessão aberta, rode /reload-plugins ou abra uma sessão nova.
• Botão que só responde no segundo clique. O app do Desktop entrega o clique para o desenho em que ele foi feito; se o painel redesenhou entre o desenho pintado e o clique, o app o recusa (no log do app aparece ui_press not handled). Por isso o painel não acompanha cada chamada de ferramenta: ele desenha a partir de um retrato dos dados, refeito na hora depois de um clique seu e, fora isso, no máximo a cada 2,5 s, e nunca no 1,5 s seguinte a um clique. O tempo de quem roda há mais de um minuto aparece em minutos, então o relógio também quase não redesenha. Se ainda acontecer, rode /cockpit diagnostico, use o painel como de costume e rode /cockpit diagnostico de novo. Enquanto ligado, o mod grava em ~/.claude/csr-cockpit-diagnostico.log cada clique que chega a ele, cada mudança de foco e cada desenho do painel.

Para não pesar no app, o painel só lê o que a aba aberta mostra, e o resumo do topo e as pílulas são recalculados no máximo uma vez por segundo e só redesenhados quando mudam (os números das pílulas, no máximo a cada 3 s). Os gráficos que mudam com o tempo são imagens simples, e o grafo não traz números que mudam a cada resposta (o custo fica na dica e no cartão): assim eles não piscam.

Limites conhecidos

• Custo por agente e por turno. É uma repartição do custo da sessão, não um valor informado pelo Claude Code (veja O custo de cada agente).
• Exit code do Bash. O resultado da ferramenta não traz o código como campo. Em falha, ele é lido do texto de erro; em sucesso, a linha mostra só a marca de concluído e a duração.
• Comando em segundo plano. A chamada volta na hora; o fim real não chega ao mod. A linha fica como "em segundo plano".
• Mensagens do agente. São relidas ao abrir o detalhe e no botão, não ao vivo. O raciocínio interno do agente não vem na transcrição.
• Primeiro turno. Não mostra quanto somou ao contexto: antes da primeira resposta do modelo ainda não há medida de onde partir.
• Cliques nos gráficos do Desktop. Os nós do grafo e as pílulas do repositório e do contexto são clicáveis por um botão invisível posto em cima deles; a posição é calculada, e pode sair um pouco deslocada num tamanho de fonte diferente.
• Versão compacta. <kbd>Esc</kbd> não a fecha; use /cockpit.
• Tamanho. Guarda 100 agentes, 100 comandos, 60 turnos, 200 mensagens entre agentes, 10 turnos de diffs com 60 edições cada e 400 linhas por diff.
• API em evolução. A API de mods pode mudar entre versões do Claude Code.

Privacidade

O csr-cockpit não faz chamada de rede. Os únicos comandos que roda na sua máquina são de leitura do git (git rev-parse, git status e git diff, para as abas Árvore e Diffs), e as únicas pastas que lista são as que você abre na árvore inteira, além das pastas de plugins, skills e agentes que a aba Inventário lê e, com um workflow rodando, a pasta da sessão em ~/.claude/projects, de onde lê o nome, o pedido e o resultado dos agentes do workflow. Do inventário fica só o nome, a origem e a descrição de cada peça: nada de variáveis de ambiente ou segredos das configurações.

Ele grava dois arquivos, só na sua máquina: ~/.claude/csr-cockpit-erros.log, quando algo falha, e ~/.claude/csr-cockpit-diagnostico.log, só com o diagnóstico de cliques ligado. O resto fica no estado da sessão, na memória do Claude Code, e some com ela: caminhos de arquivos, comandos e o fim da saída deles, diffs, o pedido e a resposta de cada turno, e o pedido, as chamadas e o resultado de cada subagente. Para conferir o que o mod chama antes de instalar, clone o repositório e rode:

claude plugin validate ./plugins/csr-cockpit

Desenvolver

claude --plugin-dir ./plugins/csr-cockpit

claude plugin validate ./plugins/csr-cockpit --strict

claude plugin test ./plugins/csr-cockpit

Os testes rodam cada aba e cada detalhe nas superfícies terminal e desktop, a linha de resumo, os agentes de workflow, os arquivos que o Bash lê e escreve, uma sessão longa e bagunçada e o tempo de desenho de cada aba. Para refazer as telas desta página (pede o claude e o Google Chrome):

python3 scripts/telas/telas.py

.claude-plugin/plugin.json   manifesto
hooks/hooks.json             aponta o módulo
hooks/register.tsx           hooks, comandos, ações dos botões e o que cada aba lê
hooks/dados.ts               transformações do estado
hooks/telas.tsx              topo, abas Agentes, Contexto e Turnos, grafo e linha do tempo
hooks/fichas.tsx             detalhe de agente, comando e turno
hooks/pilulas.ts             as pílulas da linha de resumo no Desktop
hooks/graficos.ts            gráficos em SVG do Desktop (anel, barras, grafo, linha do tempo, dicas)
hooks/desenhos.ts            o cérebro, os robôs e os ícones deles nas pílulas
hooks/workflows.ts           os agentes de workflow, lidos dos arquivos da execução
hooks/caminhos-do-bash.ts    os arquivos que um comando Bash lê e escreve
hooks/diff.ts                diff por linhas
hooks/diff-svg.ts            o diff desenhado em SVG no Desktop
hooks/diffs-lista.ts         aba Diffs: arquivos por fonte, árvore, texto do diff
hooks/diffs-tela.tsx         aba Diffs: lista à esquerda, diff à direita
hooks/arvore.ts              aba Árvore: git, toques ao vivo, montagem da árvore
hooks/arvore-tela.tsx        aba Árvore: desenho
hooks/inventario.ts          aba Inventário: o que ler e de onde
hooks/inventario-tela.tsx    aba Inventário: desenho
hooks/formato.ts             números, durações e barras em pt-BR
hooks/cores.ts               a paleta
hooks/pecas.tsx              selos, títulos de seção, cartões, estados, barras
types/index.d.ts             contrato do estado
tests/                       testes