> ## Documentation Index
> Fetch the complete documentation index at: https://chatcli.edilsonfreitas.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Dash ao Vivo
> Acompanhe em tempo real o que cada processo chatcli da sua máquina está fazendo, como um grafo que acende enquanto as coisas acontecem: agents, requisições de LLM, tools, skills, servidores MCP, os sete padrões do harness, trabalho em background e conexões de saída.
`/dash` abre no navegador um grafo ao vivo do runtime. Cada agent, cada requisição de LLM, cada chamada de tool, cada skill que ativa, cada servidor MCP, cada padrão do harness que dispara, cada job em background e cada conexão de saída é um nó; uma aresta pulsa toda vez que algo acontece nela.
É telemetria de ponta a ponta sem configuração: sem collector, sem agente, sem conta. Vem **desligada por padrão e não custa nada enquanto está desligada**.
***
## Como abrir
| Comando | O que faz |
| - | - |
| `/dash` | Sobe a dash e abre no navegador |
| `/dash url` | Sobe e só imprime o endereço |
| `/dash status` | Mostra se este processo está gravando e quais processos reportam |
| `/dash off` | Encerra |
| `chatcli dash` | Serve a dash de um terminal próprio, até `Ctrl+C` |
`/dash` funciona **com um turno rodando** (digite no meio da execução) e **via ACP**, onde o endereço volta para o chat da IDE.
O navegador só abre a partir de um terminal interativo. De um daemon, de um pipe ou de uma IDE, o endereço é impresso.
***
## Ela enxerga todos os processos, não só este
Abrir a dash faz **todo processo chatcli da máquina** começar a reportar: o REPL onde você digitou `/dash`, um segundo terminal, o daemon do gateway, o agent ACP dentro da sua IDE, o servidor MCP que outro cliente está dirigindo, o daemon do scheduler. Cada um é uma faixa na página.
É para isso que existe o `chatcli dash`: o agent ACP, o servidor MCP e os daemons não têm prompt onde digitar `/dash`, e o stdout deles é um stream de protocolo. Uma dash em outro terminal é a única janela para dentro deles.
### Como a gravação liga e desliga
1. Quem serve uma dash mantém renovado um pequeno arquivo de **lease** em `~/.chatcli/pulse/`.
2. Todo processo chatcli confere esse lease a cada dois segundos. Enquanto ele não expira, o processo grava no próprio spool.
3. O lease só é renovado **enquanto um navegador está de fato consultando**. Feche a aba e, cerca de 30 segundos depois, todos os processos voltam ao silêncio sozinhos. Nada fica ligado por acidente.
Para gravar desde o boot sem esperar uma dash (útil nas superfícies sem prompt), defina:
```bash theme={"system"}
export CHATCLI_DASH=1
```
Ela é lida ao vivo: mudar no `.env` passa a valer no `/reload`.
***
## O que você vê
Sessões e agents são **um nó cada**, ligados pelo pai real, então um dispatch multi-agent aparece como árvore. Todo o resto é um **hub agregado por nome** (a tool `@coder`, o servidor MCP `github`, o padrão `self-refine`) mostrando chamadas, quantas estão ativas agora, erros e latência média. O grafo fica estável e *dispara*, em vez de explodir em um nó por chamada.
| Tipo de nó | O que é reportado |
| - | - |
| **session** | O processo: superfície (`repl`, `acp`, `gateway`, `mcp`, `daemon`, `tool`, …), pid, o **par que atende a próxima requisição** e o que o decidiu (`route`: `session`, `override` depois de [`@model use`](/pt/agents/model-routing), ou `skill` por hint de modelo de uma skill; `via`: `@model use`, `/switch`, `/provider`, `run start`, `gateway`, …), o **custo** acumulado da sessão, tokens e requisições, e **o quanto da janela de contexto está ocupado** (`ctx 37%`, a mesma projeção que o rodapé do turno imprime; acima de 100% significa que o próximo turno compacta). Toda troca de par vira uma linha própria no feed (`modelo → PROVIDER:modelo · override · @model use`) e o card guarda as últimas trocas |
| **agent** | Todo orquestrador, [squad worker](/pt/agents/agent-squad), subagent, membro de [MoA](/pt/agents/mixture-of-agents) e run de [task graph](/pt/agents/task-graph): turno `3/30`, chamadas de tool, ação atual, desfecho |
| **llm** | Um hub por `PROVIDER:modelo`. Cada requisição fica pendurada **no agent que a fez**, com tamanho do payload, tamanho do histórico e quantidade de tools. Cada relatório de usage acrescenta o que a chamada consumiu (tokens de entrada, saída, leitura e escrita de cache), a lane em que rodou (main, worker, background) e o acumulado do modelo em tokens, requisições e **custo**: os números que o [`/cost`](/pt/providers/cost-tracking) mostra, conforme mudam |
| **tool** | Toda execução de tool: o loop do orquestrador, os squad workers e o caminho RPC / `chatcli tool`. Uma chamada recusada pela [policy de segurança](/pt/coder/coder-security) aparece como `blocked` |
| **skill** | Uma [skill](/pt/tools/builtin-skills) conta como ativada quando é de fato entregue ao modelo (depois do match de trigger, do dedup e do cooldown): no início do run, no meio do loop ou num turno de chat. Envelhecer e sair da janela aparece como `collapsed` |
| **mcp** | Um nó por [servidor MCP](/pt/extensions/mcp-integration) com seu estado (`starting`, `connected`, `failed`, `disconnected`, `stopped`, `auth required`) e a contagem de tools; cada `tools/call` é um span cronometrado com o nome da tool |
| **pattern** | Os [sete padrões do harness](/pt/agents/harness/overview), cada um com **o que concluiu** (veja abaixo) |
| **background** | Jobs do [scheduler](/pt/tools/scheduler), processos do `@proc`, o memory worker, a **auto-evolução de skills** (`skill-evolution`: candidatos, depois `1 authored · 2 evolved`, `3 suggested`, `no change`; cada skill escrita é um ponto no próprio nó, `created` ou `evolved`), a compaction do histórico, language servers, a sessão do `@browser`, o staging do auto-update |
| **conn** | HTTP de saída por **hostname**: método, status, latência, bytes. Um stream de tokens aparece como uma conexão viva com a duração real |
| **rpc** | O chatcli atuando como servidor ([servidor MCP](/pt/server/mcp-server), [ACP](/pt/server/acp)): cada método recebido, e o que o servidor pede ao cliente |
| **turn** | Turnos de chat em toda superfície — REPL, [web UI](/pt/usage/web-ui), MCP, ACP e gateway — e turnos one-shot. O filho `chatcli web` que o `/web` inicia é um processo próprio e ganha janela própria, rotulada `web` |
### Os sete padrões, com desfecho
[Self-Refine, CoVe e Reflexion](/pt/agents/harness/overview) rodam em silêncio: reescrevem a saída de um worker, marcam uma discrepância ou enfileiram uma lição sem imprimir uma linha. A dash mostra não só que o padrão disparou, mas o que ele concluiu.
| Padrão | Desfecho mostrado |
| - | - |
| [ReAct](/pt/agents/harness/react) | cada loop, com os turnos que levou (um park é um desfecho deliberado, não uma falha) |
| [Plan-and-Solve](/pt/agents/harness/plan-and-solve) | `routed to @taskgraph`, `dry run preview`, `executed N steps` |
| [Reflexion](/pt/agents/harness/reflexion) | o gatilho e `lesson queued`; depois, do worker em background: `lesson saved`, `no lesson`, `retrying`, `dead letter` |
| [RAG + HyDE](/pt/agents/harness/rag-hyde) | `augmented retrieval`, `fell back to plain hints` |
| [Self-Refine](/pt/agents/harness/self-refine) | `rewrote draft`, `kept draft`, `rolled back`, `failed`, com o número de passes |
| [CoVe](/pt/agents/harness/cove) | `verified clean`, `found discrepancy`, `corrected draft` |
| [Reasoning backbone](/pt/agents/harness/reasoning-backbone) | o nível de esforço que anexou, e a qual agent |
Um padrão desligado, ou cujos guards rejeitam o resultado, não fez nada e fica apagado.
Os rótulos de desfecho são fixos e em inglês: são escolhidos pelo código, nunca são saída do modelo.
### Coisas fáceis de não perceber sem ela
* **Uma compaction parece um travamento.** A compaction do histórico resume a conversa com uma chamada de LLM própria e segura o turno pelo tempo que isso levar. Na dash ela é um span `compaction` que termina com `applied` ou `skipped`.
* **Um diálogo de permissão que ninguém respondeu.** Via ACP/MCP ele aparece como uma chamada `client:session/request_permission` que não termina.
* **O dev server que você subiu há uma hora.** Os processos do `@proc` são reapresentados quando a dash abre, então aparecem mesmo tendo começado muito antes.
* **Qual worker gastou as requisições.** Cada requisição de LLM fica pendurada no agent que a fez.
### Usando a página
**Cada processo é uma janela própria.** Arraste-a pela barra de título para pô-la onde quiser: ela fica onde você soltar, então três processos que você quer acompanhar juntos podem ficar lado a lado, e as janelas que você não tocou se empilham pelo tamanho real e contornam as que você posicionou. Janelas podem se sobrepor; a tocada por último fica por cima e é dona dos cliques. Duplo clique na barra de título devolve a janela à pilha. **Arraste qualquer nó para posicioná-lo** onde quiser: ele fica ali, as arestas acompanham, o resto da coluna se fecha e a janela do processo se estica para continuar abraçando o nó, empurrando a janela seguinte para baixo em vez de cobri-la. Para mover **um tipo inteiro de uma vez** (todas as skills, todas as tools), arraste o cabeçalho dele, o rótulo `⠿ SKILL` acima do primeiro card, ou use Shift+arrastar em qualquer card do tipo; os cards que aparecerem depois entram no grupo onde você o deixou. Os cards nunca se sobrepõem: o que você moveu por último fica no lugar e o que estiver no caminho desce. Dê duplo clique num card posicionado ou num cabeçalho movido para devolvê-lo ao layout automático, ou use **Reorganizar** para fazer isso com tudo. Arraste o fundo para mover a vista, role para dar zoom, `0` ou **Ajustar** para enquadrar, `Espaço` ou **Pausar** para congelar, clique num nó para ver detalhes. Funciona com mouse, toque e caneta. Os chips no topo mostram e escondem processos; a legenda embaixo mostra e esconde tipos de nó.
**O visual é uma escolha deliberada**: um terminal escuro, a paleta da apresentação do ChatCLI (âmbar, ciano, violeta e verde sobre um fundo quase preto, mono do início ao fim). O cabeçalho é a barra de título de um terminal do macOS com uma linha fina de atividade; cada processo é uma janela de terminal própria; o feed é um `$ tail -f` do log. Só um [tema](/pt/usage/ui-theme) de terminal **claro** reveste o chrome de outro jeito, porque um terminal claro precisa de uma página clara; um tema escuro mantém a paleta da apresentação. O idioma segue o do seu terminal.
**De relance.** Seis tiles somam o que os processos exibidos reportam: custo da sessão, requisições, nós ativos, a janela de contexto mais cheia, erros (com o último minuto ao lado) e eventos por segundo com sparkline. A barra de título de cada janela carrega o próprio custo, requisições, ocupação do contexto e contagem de erros.
**Achando as coisas.** `/` foca a busca: todo nó que não casa esmaece, os que casam brilham (um agent casa pelo nome ou pela ação atual). `e`, o tile de erros ou **Só erros** restringe o feed a erros; o seletor de kind restringe a um tipo. Kinds escondidos e filtros do feed ficam lembrados por navegador. Todo hub de modelo mostra o **acerto do prompt cache** da última requisição (`cache 84%`), no card e no popover. As marcações de fase que um agent deixa com [`@dash mark`](#dirigindo-pelo-agent) aparecem como linhas `◆`. **Exportar** baixa os eventos dos processos exibidos como NDJSON, o que um relato de bug precisa.
Uma dash aberta no meio de uma execução começa pelo **que está vivo agora** (agents rodando, servidores MCP conectados, processos em background), e não do vazio.
***
## Dirigindo pelo agent
O agent tem o mesmo controle da dash que o `/dash`, e mais um jeito de ler o que ela vê, pela tool **`@dash`**, registrada nos modos agent e coder como [`@model`](/pt/agents/model-routing) e [`@agents`](/pt/agents/agent-squad):
| `cmd` | O que faz |
| - | - |
| `status` | Se este processo grava, o endereço da dash se houver uma servida, quais processos chatcli reportam |
| `open` / `url` | Sobe a dash (uma por sessão), toma o lease e devolve o endereço para o usuário; `open` também abre o navegador, só em terminal interativo, nunca desassistido |
| `off` | Para; os processos silenciam conforme o lease expira |
| `summary` (`all: true` para todo processo vivo) | O grafo reduzido, em texto: par da sessão, rota e custo, agents com turno e tools, requisições de LLM por modelo com tokens e custo, tools, skills, servidores MCP, padrões, trabalho em background, conexões e os erros recentes, os mesmos números que a página mostra |
| `events` (`limit`, `kind`, `status`, `all`) | Os eventos crus mais recentes, só metadados, restritos a um kind e um status |
| `mark` (`note`) | Um rótulo curto de fase (uma linha, 80 caracteres) na linha do tempo deste processo, uma linha `◆` no feed |
```
```
`summary` e `events` leem o mesmo spool que a página consulta, então dizem quando nada está gravando e como ligar. Tudo o que devolvem é metadado, como a própria telemetria. `status`, `url`, `summary` e `events` são somente leitura para a [política de segurança](/pt/coder/coder-security); `open`, `off` e `mark` rodam em série. A tool funciona em toda superfície, `chatcli tool @dash status` incluído; `CHATCLI_AGENT_DASH_TOOL=false` a desregistra.
***
## Privacidade e segurança
**Os eventos levam só metadados**: nomes, tamanhos, durações, status, contagens de tokens. O que segue nunca sai do processo, e há teste garantindo cada item:
* texto de prompt, a task dada a um agent, saída do modelo, texto de erro
* argumentos e saída de tool, argumentos e resultados de chamada MCP
* caminhos de arquivo tocados por uma tool
* **caminho e query string** de URL (onde viajam chaves de API e tokens de bot): só o hostname é mostrado
* a **linha de comando** de um processo: só o nome do programa, e só quando a primeira palavra é um programa e não uma atribuição `VAR=valor`
* a URL do browser ou qualquer coisa de uma página; o payload, a mensagem ou a saída de um job agendado
**O servidor é local, mas não é aberto.** Ele sobe em `127.0.0.1` numa porta efêmera e, além disso:
* toda chamada de API exige um token aleatório gerado no start. Ele chega à página pelo endereço uma única vez, vai para a memória e some da barra de endereço;
* toda requisição precisa trazer o `Host` exato em que o servidor subiu, o que fecha DNS rebinding a partir de uma página web;
* só `GET`, Content-Security-Policy estrita, sem CDN, sem chamadas de rede.
A dash é um **observador somente leitura**: lê o spool do disco e não guarda estado. Fechar, recarregar ou abrir uma segunda aba nunca afeta uma sessão em andamento.
***
## Custo
Com a dash desligada, cada ponto instrumentado custa **um load atômico**, e o processo faz um `stat` a cada dois segundos para conferir o lease. Nenhum span é montado, nenhum corpo é embrulhado.
Gravando, emitir **nunca bloqueia**: fila cheia descarta o evento e conta o descarte, e um consumidor lento perde eventos em vez de atrasar os outros. `/dash status` e `/config dash` mostram publicados e descartados.
***
## Armazenamento
Cada processo grava em `~/.chatcli/pulse//` em segmentos rotacionados por tamanho, limitados a cerca de **16 MB por processo**, com um heartbeat que separa processos vivos de mortos. A varredura automática do boot remove os spools de processos mortos há mais de **24 horas**. Sob demanda, `/storage prune pulse` remove na hora o spool de **todo processo que já não está rodando**:
```bash theme={"system"}
/storage prune pulse # simula
/storage prune pulse --apply # remove
```
Um processo que ainda está gravando nunca é candidato, nem o arquivo de lease. Um processo que saiu sem fechar o spool aparece como vivo por até 20 segundos (a janela do heartbeat): um prune nessa janela o pula e o seguinte o remove. Veja `/storage` na [referência de comandos](/pt/reference/command-reference).
***
## Configuração
| Variável | Padrão | Descrição |
| - | - | - |
| `CHATCLI_DASH` | não definida | `1` / `true` / `on` / `yes` grava desde o boot, sem esperar o lease de uma dash. Recarregável |
| `CHATCLI_AGENT_DASH_TOOL` | `true` | Registra a tool `@dash` nos modos agent/coder. `false` / `0` / `off` a desregistra |
`/config dash` mostra as duas variáveis, se este processo está gravando, o diretório do spool e os contadores de eventos.
***
## Relação com o resto da observabilidade
| Você quer | Use |
| - | - |
| **Acompanhar o runtime ao vivo**, em grafo, entre processos | **`/dash`** (esta página) |
| Acompanhar a fundo um run de [task graph](/pt/agents/task-graph): gates, vereditos, caminho crítico, custo por task | `/taskgraph dash` |
| Tokens, custo e comportamento de cache da sessão | [`/cost`](/pt/providers/cost-tracking) |
| Métricas no seu backend (Grafana, Datadog, …) | o [exportador OpenTelemetry](/pt/server/server-mode#exportação-opentelemetry-otlp) (`OTEL_EXPORTER_OTLP_ENDPOINT`) |
| Um registro à prova de adulteração de cada requisição de LLM | a [trilha de auditoria](/pt/security/overview) (`CHATCLI_AUDIT_LOG_PATH`), que também registra **qual run de agent** fez cada requisição (`caller`) |
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.