---
title: "csr-cockpit"
url: "https://claudemods.dev/ko/builds/csr-cockpit-8ce02a"
source: "https://github.com/cesarschutz/claude-code-kit/tree/main/plugins/csr-cockpit"
source_type: "github"
repo: "https://github.com/cesarschutz/claude-code-kit/tree/main/plugins/csr-cockpit"
author: "cesarschutz"
author_handle: "cesarschutz"
stars: 19
category: "대시보드 및 HUD"
categories: ["hud"]
tags: ["agents", "claude-code", "context", "cost", "dashboard", "git", "plugin"]
permission_level: 2
scan_complete: true
install: "claude plugin marketplace add cesarschutz/claude-code-kit\nclaude plugin install csr-cockpit@cesarschutz"
added: "2026-10-05T01:57:27.355Z"
updated: "2026-10-11T17:19:07Z"
locale: "ko"
content_locale: "ko"
---

# csr-cockpit

Claude Code 대화 옆에 에이전트·diff·컨텍스트·턴·파일 트리·인벤토리를 담은 세션 패널과 프롬프트 위 요약 줄을 추가합니다.

## Description

csr-cockpit은 Claude Code 플러그인으로 Agents(서브에이전트, 호출 그래프, SendMessage), Diffs(세션, 턴, Git), Context(사용량, 비용, 제한, 정확한 카운트), Turns, Tree(읽고 편집한 파일과 Git 변경), Inventory 탭이 있는 사이드 패널을 엽니다. 컨텍스트, 비용, 제한, 모델, effort와 캐시 요약 줄도 표시합니다. 훅은 관찰만 하며 차단하거나 자체 token을 사용하지 않습니다. 설치: claude plugin install csr-cockpit@cesarschutz。

## Install

```
claude plugin marketplace add cesarschutz/claude-code-kit
claude plugin install csr-cockpit@cesarschutz
```

## Original README

# csr-cockpit

[![versão](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcesarschutz%2Fclaude-code-kit%2Fmain%2Fplugins%2Fcsr-cockpit%2F.claude-plugin%2Fplugin.json&query=%24.version&label=vers%C3%A3o&color=d77757&labelColor=262626&style=flat-square)](.claude-plugin/plugin.json)
[![Claude Code 2.1.287 ou mais novo](https://img.shields.io/badge/Claude%20Code-%E2%89%A5%202.1.287-b1b9f9?labelColor=262626&style=flat-square&logo=claude&logoColor=d77757)](https://code.claude.com/docs)
[![licença MIT](https://img.shields.io/badge/licen%C3%A7a-MIT-6e6e6e?labelColor=262626&style=flat-square)](../../LICENSE)

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`](../../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](https://blog.cesarschutz.com.br/posts/claude-code-csr-cockpit/)
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](#requisitos) · [Instalar e atualizar](#instalar-e-atualizar) · [Usar](#usar)
- [A linha de resumo](#a-linha-de-resumo)
- As abas: [Agentes](#1-agentes) · [Diffs](#2-diffs) · [Contexto](#3-contexto) ·
  [Turnos](#4-turnos) · [Árvore](#5-árvore) · [Inventário](#6-inventário)
- [No terminal](#no-terminal) · [O custo de cada agente](#o-custo-de-cada-agente) ·
  [Quando algo dá errado](#quando-algo-dá-errado) · [Limites](#limites-conhecidos) ·
  [Privacidade](#privacidade) · [Desenvolver](#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

```bash
claude plugin marketplace add cesarschutz/claude-code-kit
```

```bash
claude plugin install csr-cockpit@cesarschutz
```

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

```bash
claude plugin marketplace update cesarschutz
```

```bash
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](#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](#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](https://github.com/patoles/agent-flow)
e do [View Claude Code](https://www.npmjs.com/package/viewcc). 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](#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](https://github.com/data-goblin/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](#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:

```bash
claude plugin validate ./plugins/csr-cockpit
```

## Desenvolver

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

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

```bash
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):

```bash
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
```
