> ## 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**. Dash ao vivo do ChatCLI: grafo de agents, LLM, tools, skills, servidores MCP, padrões do harness, trabalho em background e conexões *** ## 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, provider e modelo, 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) | | **agent** | Todo orquestrador, [squad worker](/pt/features/agent-squad), subagent, membro de [MoA](/pt/features/mixture-of-agents) e run de [task graph](/pt/features/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/features/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/features/coder-security) aparece como `blocked` | | **skill** | Uma [skill](/pt/features/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/features/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/features/quality/overview), cada um com **o que concluiu** (veja abaixo) | | **background** | Jobs do [scheduler](/pt/features/scheduler), processos do `@proc`, o memory worker, 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/features/mcp-server), [ACP](/pt/features/acp)): cada método recebido, e o que o servidor pede ao cliente | | **turn** | Turnos de chat e one-shot | ### Os sete padrões, com desfecho [Self-Refine, CoVe e Reflexion](/pt/features/quality/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/features/quality/react) | cada loop, com os turnos que levou (um park é um desfecho deliberado, não uma falha) | | [Plan-and-Solve](/pt/features/quality/plan-and-solve) | `routed to @taskgraph`, `dry run preview`, `executed N steps` | | [Reflexion](/pt/features/quality/reflexion) | o gatilho e `lesson queued`; depois, do worker em background: `lesson saved`, `no lesson`, `retrying`, `dead letter` | | [RAG + HyDE](/pt/features/quality/rag-hyde) | `augmented retrieval`, `fell back to plain hints` | | [Self-Refine](/pt/features/quality/self-refine) | `rewrote draft`, `kept draft`, `rolled back`, `failed`, com o número de passes | | [CoVe](/pt/features/quality/cove) | `verified clean`, `found discrepancy`, `corrected draft` | | [Reasoning backbone](/pt/features/quality/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 Arraste para mover, role para dar zoom, `0` ou **Ajustar** para enquadrar, `Espaço` ou **Pausar** para congelar, clique num nó para ver detalhes. Os chips no topo mostram e escondem processos; a legenda embaixo mostra e esconde tipos de nó. A página segue o [tema](/pt/features/ui-theme) e o idioma do seu terminal. 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. *** ## 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. Spools de processos mortos são removidos após **24 horas**, no boot e sob demanda: ```bash theme={"system"} /storage prune pulse # simula /storage prune pulse --apply # remove ``` Um processo que ainda está gravando nunca é candidato. 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 | `/config dash` mostra a variável, 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/features/task-graph): gates, vereditos, caminho crítico, custo por task | `/taskgraph dash` | | Tokens, custo e comportamento de cache da sessão | [`/cost`](/pt/features/cost-tracking) | | Métricas no seu backend (Grafana, Datadog, …) | o [exportador OpenTelemetry](/pt/features/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/features/security) (`CHATCLI_AUDIT_LOG_PATH`), que também registra **qual run de agent** fez cada requisição (`caller`) |