> ## 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.

# UI Compacta (Modo Compact)

> Modo de exibicao minimalista para o coder mode: indicadores inline de ferramentas, zero verbosidade.

O modo **compact** é uma opção de renderização ultra-minimalista para os modos `/coder` e `/agent`, inspirada em ferramentas como [Claude Code](https://claude.ai/claude-code) e [aru](https://github.com/estevaofon/aru). Em vez de cards com bordas (`╭──╰`), todas as operações são exibidas como linhas inline compactas.

<Info>
  **A partir da v1.119, `CHATCLI_CODER_UI` afeta os DOIS modos** (`/coder` e `/agent`). Antes ela só valia no `/coder`. O nome da variável é mantido por compatibilidade. Quem já tinha `CHATCLI_CODER_UI=compact` no `.env` vai ver o `/agent` ficar compacto também.
</Info>

***

## Comparacao Visual

<Tabs>
  <Tab title="Full (padrão)">
    ```
    ╭── 🧠 RACIOCINIO
    │  Vou analisar o código e fazer as alterações...
    │  Plano:
    │  1. Ler o arquivo main.go
    │  2. Modificar a função handleRequest
    │  3. Atualizar os testes
    ╰──────────────────────────────────────────────

    ╭── 🔨 EXECUTAR ACAO (1/3)
    │  Ferramenta: @coder
    │  Comando: {"cmd":"read","args":{"file":"main.go"}}
    ╰──────────────────────────────────────────────

    ╭── ✅ SUCESSO
    │  1  package main
    │  2  import ( ...
    │  ... [200 linhas] ...
    ╰──────────────────────────────────────────────

    Let me now modify the function...

    ╭── 🔨 EXECUTAR ACAO (2/3)
    │  ...
    ╰──────────────────────────────────────────────
    ```
  </Tab>

  <Tab title="Compact">
    ```
      ● PLANO
        1. Ler main.go
        2. Modificar handleRequest
        3. Atualizar testes

      ↻ Read(main.go)
      ✓ Read(main.go) 0.8s
      ↻ Patch(main.go)
      ✓ Patch(main.go) 0.3s
      ↻ Exec(go test ./...)
      ✓ Exec(go test ./...) 2.1s

      ✓ 3/3 concluidas

      ◆  Timeout param adicionado. Testes passando.
    ```
  </Tab>
</Tabs>

***

## Ativação

Configure a variável de ambiente `CHATCLI_CODER_UI`:

```bash theme={"system"}
# Modo compact (ultra-minimalista)
export CHATCLI_CODER_UI=compact

# Modo minimal (cards menores, sem streaming)
export CHATCLI_CODER_UI=minimal

# Modo full (padrão, cards completos com output)
export CHATCLI_CODER_UI=full
```

Ou diretamente na invocação:

```bash theme={"system"}
CHATCLI_CODER_UI=compact chatcli
```

***

## Modos de Exibicao

| Modo        | Variável                           | Descrição                                                      |
| ----------- | ---------------------------------- | -------------------------------------------------------------- |
| **full**    | `CHATCLI_CODER_UI=full` (ou vazio) | Cards completos com bordas, output streaming, narracao visivel |
| **minimal** | `CHATCLI_CODER_UI=minimal`         | Cards menores com texto compacto, sem streaming de output      |
| **compact** | `CHATCLI_CODER_UI=compact`         | Zero cards. Indicadores inline: `✓ Read(main.go) 0.8s`         |

***

## O que Muda no Modo Compact

### Raciocinio / Plano

| Full                                        | Compact                                      |
| ------------------------------------------- | -------------------------------------------- |
| Card `╭── 🧠 RACIOCINIO` com texto completo | `● PLANO` + linhas indentadas (max 5 linhas) |

### Tool Calls

| Full                              | Compact                                  |
| --------------------------------- | ---------------------------------------- |
| Card `╭── 🔨 EXECUTAR ACAO (1/3)` | `↻ Read(main.go)` (spinner cyan)         |
| Card `╭── ✅ SUCESSO` com output   | `✓ Read(main.go) 0.8s` (checkmark verde) |
| Card `╭── ❌ FALHA` com erro       | `✗ Patch(file.go) 0.2s` (X amarelo)      |

### Erros de Segurança / Policy

| Full                  | Compact                                 |
| --------------------- | --------------------------------------- |
| Card com box completo | `✗ ACAO BLOQUEADA (Regra de Segurança)` |

### Batch Summary

| Full                            | Compact            |
| ------------------------------- | ------------------ |
| Banner `═══ LOTE CONCLUIDO ═══` | `✓ 4/4 concluidas` |

### Multi-Agent Dispatch

| Full                         | Compact                                       |
| ---------------------------- | --------------------------------------------- |
| Cards por agent com detalhes | `● AGENTS 3 agents` + `✓ coder(5 calls) 3.2s` |

### Streaming de Output

| Full                                         | Compact                                               |
| -------------------------------------------- | ----------------------------------------------------- |
| Output visivel em tempo real (`│  linha...`) | Suprimido (agent recebe tudo, user ve só o resultado) |

***

## Labels Inteligentes

O modo compact gera labels automáticos para cada tool call:

| Subcommand   | Label                   |
| ------------ | ----------------------- |
| `read`       | `Read(main.go)`         |
| `write`      | `Write(pkg/handler.go)` |
| `patch`      | `Patch(main.go)`        |
| `exec`       | `Exec(go test ./...)`   |
| `search`     | `Search(TODO)`          |
| `tree`       | `Tree(.)`               |
| `test`       | `Test(auto)`            |
| `git-status` | `GitStatus(.)`          |
| `git-diff`   | `GitDiff(.)`            |

Os labels são extraidos dos argumentos JSON ou CLI do tool call, truncados a 60 caracteres.

***

## Anti-Verbosidade

O modo compact inclui **regras de anti-verbosidade** no system prompt do `/coder`. Essas regras se aplicam a **todos os modos de UI** (full, minimal, compact):

* A IA não narra ações: zero "Let me...", "I will...", "Now I'll..."
* Tool calls são emitidos diretamente após o `<reasoning>` block
* Texto de saída só aparece no resultado final (1-3 frases)

<Info>
  As regras de anti-verbosidade estão no `CoderSystemPrompt` e `CoderFormatInstructions`, aplicadas a todos os modos UI. O modo compact apenas torna o efeito mais visivel por não ter cards que "disfarcem" a verbosidade.
</Info>

***

## Independencia do Function Calling

O modo compact e **independente** do método de function calling:

| Provider           | Function Calling           | UI Compact |
| ------------------ | -------------------------- | ---------- |
| Claude (Anthropic) | Nativo (API)               | ✓          |
| OpenAI             | Nativo (API)               | ✓          |
| Ollama             | XML fallback               | ✓          |
| GitHub Models      | Nativo (via OpenAI-compat) | ✓          |
| StackSpot          | XML fallback               | ✓          |

A detecção de function calling nativo e automática via `ToolAwareClient`. O modo compact funciona com qualquer provider.

***

## Próximos Passos

<CardGroup cols={2}>
  <Card title="Modo Coder" icon="code" href="/pt/core-concepts/coder-mode">
    Entenda o ciclo completo de engenharia
  </Card>

  <Card title="Tool Use Nativo" icon="wrench" href="/pt/features/native-tool-use">
    Como funciona o function calling nativo
  </Card>

  <Card title="Multi-Agent" icon="users" href="/pt/features/multi-agent-orchestration">
    Orquestracao paralela de agents especializados
  </Card>

  <Card title="Coder Security" icon="shield" href="/pt/features/coder-security">
    Politicas de segurança e aprovação
  </Card>
</CardGroup>