brito-cli 0.4.0 → 0.5.0

package/README.md

@@ -2,9 +2,9 @@
 
 **English** · [Português](README.pt-BR.md)
 
-> A coding-agent CLI that knows your codebase as a **graph** and learns your project's procedures as **skills you review**.
+> A coding agent for your terminal (`brito-cli`) and your desktop (a native app) that knows your codebase as a **graph** and learns your project's procedures as **skills you review**.
 
-Brito is a terminal agent for software development. Instead of grepping and reading files blindly, it keeps a **knowledge graph of your code** (symbols, who calls whom, who imports whom) and answers questions like *"what breaks if I change this?"* straight from the graph, in a fraction of a second. It also keeps **memory notes** and **skills**: reusable procedures learned from your own work, which only become active after **you** approve them.
+Brito is an agent for software development. Use it in the terminal (`brito-cli` on npm) or as a desktop app (an executable for macOS, Windows and Linux): same agent, same graph, same skills. Instead of grepping and reading files blindly, it keeps a **knowledge graph of your code** (symbols, who calls whom, who imports whom) and answers questions like *"what breaks if I change this?"* straight from the graph, in a fraction of a second. It also keeps **memory notes** and **skills**: reusable procedures learned from your own work, which only become active after **you** approve them.
 
 ![Brito answering a question with the code graph](docs/images/answer-with-graph.png)
 
@@ -18,6 +18,8 @@ Brito is a terminal agent for software development. Instead of grepping and read
 - **Safety rails for what gets learned.** A lint rejects secrets, credentials embedded in URLs, `curl | sh` and prompt-injection phrasing, and **warns about destructive commands** (see below).
 - **Permission modes.** manual, auto-edits, plan and "everything allowed" (`Shift+Tab` cycles them). Autonomous skills do not depend on the mode: they are created in trial and judged by results.
 - **Two backends, one interface.** Use an Anthropic API key, or your Claude Code subscription through the `claude` CLI. Brito never reads or sends your subscription token.
+- **Terminal or desktop app.** `npm i -g brito-cli` gives you the `brito` command; the desktop app is a native executable with a window (projects and sessions in a sidebar, chat, permission prompts), no Node or terminal needed. See [Install](#install).
+- **Images.** Drag an image file into the prompt (or paste its path) and it is attached to the turn: PNG, JPEG, GIF or WebP, up to 5 MB.
 - **Subagents.** `explore`, `plan` and `general` run in isolated contexts (read-only ones in parallel); add your own in `.brito/agents/*.md`.
 - **MCP server.** `brito mcp-serve` exposes the graph, memory and skills to other MCP clients such as Claude Code. The query tools are marked `alwaysLoad`, so they are not hidden behind tool search.
 
@@ -57,6 +59,8 @@ The lint **rejects** secrets/tokens, absolute user paths, credentials in URLs (`
 
 ## Install
 
+### Terminal (`brito-cli`)
+
 Requires Node >= 20. Developed on macOS; Linux should work. On Windows use `npm i -g brito-cli` (the `install.sh` script needs bash); install Git for Windows so the `bash` tool runs bash commands, otherwise it falls back to `cmd.exe` (override with `BRITO_SHELL`).
 
 ```bash
@@ -81,6 +85,28 @@ export ANTHROPIC_API_KEY=sk-ant-...      # Anthropic API
 # or: install Claude Code, run `claude` and /login — Brito will use your subscription
 ```
 
+### Desktop app (executable)
+
+The same agent in a window: projects and sessions in a sidebar, chat with markdown, collapsible tool calls, permission prompts, and pickers for model, effort and permission mode. It needs neither Node nor a terminal.
+
+![Brito desktop app answering a question with the code graph](docs/images/desktop-app.png)
+
+*The desktop app on a small project: one question, one graph call (the collapsed "ran 1 command" line), and the answer as a table. The sidebar groups sessions by project; the footer shows the backend, the folder, the context size and the cost.*
+
+Download it from the [Releases page](https://github.com/wilsonbrito/brito/releases):
+
+| System | File |
+|---|---|
+| macOS | `Brito-<version>-macos-arm64.dmg` (Apple Silicon) or `-x64.dmg` (Intel): open it and drag Brito to Applications |
+| Windows | `Brito-<version>-windows-x64-setup.exe` |
+| Linux | `Brito-<version>-linux-x64.tar.gz`: extract it and run `./install.sh` (adds Brito to the applications menu) |
+
+The builds are not signed with an Apple Developer ID or a Windows certificate, so macOS ("unidentified developer": right-click, then Open) and Windows SmartScreen warn on the first launch. macOS is the platform exercised the most; the Windows and Linux builds come from CI and have had less testing.
+
+Like the terminal version, it uses `ANTHROPIC_API_KEY` when your shell exports it, otherwise your Claude Code subscription (`claude`, then `/login`). Opened from the Finder, the app reads your login shell to find them.
+
+To build it yourself: `npm run desktop` (development), `npm run desktop:app` (macOS: installs `/Applications/Brito.app`) or `npm run desktop:dmg`.
+
 ## Quick start
 
 ```bash
@@ -144,7 +170,8 @@ Project data lives in `.brito/` (graph, project skills, agents) and global data
 
 ## Limitations
 
-- Early software (v0.3.1), one maintainer.
+- Early software (v0.5.0), one maintainer.
+- The desktop app is new: a single window (no tabs yet), and with an API key (no `claude` CLI) the model does not resume a conversation after you reopen the app, although the screen shows it.
 - **The interface and the agent's default language are Brazilian Portuguese.** Translating them is a welcome contribution.
 - Skill learning is a heuristic: it proposes, you decide. Expect some proposals to be rejected.
 
@@ -166,6 +193,8 @@ npm test             # 190+ tests, including a real MCP server and a real REPL
 | `src/tools/` | graph, memory, skills, filesystem and shell tools |
 | `src/mcp/` | MCP server |
 | `src/repl.ts`, `src/ui/` | terminal interface |
+| `src/desktop/` | `brito gui-serve`: the backend the desktop window talks to (JSON over stdio) |
+| `desktop/` | Electron window and packaging (`package.mjs`); `npm run bundle` builds the single-file backend it uses |
 
 ## License
 

package/README.pt-BR.md

@@ -2,9 +2,9 @@
 
 [English](README.md) · **Português**
 
-> Uma CLI de agente de código que conhece o seu projeto como um **grafo** e aprende os procedimentos dele como **skills que você revisa**.
+> Um agente de código para o seu terminal (`brito-cli`) e para o seu desktop (um app nativo) que conhece o seu projeto como um **grafo** e aprende os procedimentos dele como **skills que você revisa**.
 
-O Brito é um agente de terminal para desenvolvimento de software. Em vez de dar `grep` e ler arquivos às cegas, ele mantém um **grafo de conhecimento do código** (símbolos, quem chama quem, quem importa quem) e responde perguntas como *"o que quebra se eu mudar isto?"* direto do grafo, em uma fração de segundo. Ele também guarda **notas de memória** e **skills**: procedimentos reutilizáveis aprendidos no seu próprio trabalho, que só passam a valer depois que **você** aprova.
+O Brito é um agente para desenvolvimento de software. Use no terminal (`brito-cli` no npm) ou como app de desktop (um executável para macOS, Windows e Linux): o mesmo agente, o mesmo grafo, as mesmas skills. Em vez de dar `grep` e ler arquivos às cegas, ele mantém um **grafo de conhecimento do código** (símbolos, quem chama quem, quem importa quem) e responde perguntas como *"o que quebra se eu mudar isto?"* direto do grafo, em uma fração de segundo. Ele também guarda **notas de memória** e **skills**: procedimentos reutilizáveis aprendidos no seu próprio trabalho, que só passam a valer depois que **você** aprova.
 
 ![Brito respondendo uma pergunta com o grafo de código](docs/images/answer-with-graph.png)
 
@@ -18,6 +18,8 @@ O Brito é um agente de terminal para desenvolvimento de software. Em vez de dar
 - **Proteções sobre o que é aprendido.** Um lint rejeita segredos, credenciais embutidas em URL, `curl | sh` e frases de injeção de prompt, e **avisa sobre comandos destrutivos** (veja abaixo).
 - **Modos de permissão.** manual, auto-edições, plano e "tudo liberado" (`Shift+Tab` alterna). As skills autônomas não dependem do modo: nascem em teste e são julgadas pelo resultado.
 - **Dois backends, uma interface.** Use uma chave da API da Anthropic ou a sua assinatura do Claude Code pela CLI `claude`. O Brito nunca lê nem envia o token da sua assinatura.
+- **Terminal ou app de desktop.** `npm i -g brito-cli` instala o comando `brito`; o app de desktop é um executável nativo com janela (projetos e sessões numa barra lateral, chat, pedidos de permissão), sem precisar de Node nem de terminal. Veja [Instalação](#instalação).
+- **Imagens.** Arraste um arquivo de imagem para o prompt (ou cole o caminho) e ele é anexado ao turno: PNG, JPEG, GIF ou WebP, até 5 MB.
 - **Subagentes.** `explore`, `plan` e `general` rodam em contextos isolados (os somente-leitura, em paralelo); crie os seus em `.brito/agents/*.md`.
 - **Servidor MCP.** `brito mcp-serve` expõe grafo, memória e skills a outros clientes MCP, como o Claude Code. As tools de consulta são marcadas `alwaysLoad`, para não ficarem escondidas atrás da busca de tools.
 
@@ -53,6 +55,8 @@ O lint **rejeita** segredos/tokens, caminhos absolutos do usuário, credenciais
 
 ## Instalação
 
+### Terminal (`brito-cli`)
+
 Requer Node >= 20. Desenvolvido no macOS; no Linux deve funcionar, no Windows não foi testado.
 
 ```bash
@@ -77,6 +81,28 @@ export ANTHROPIC_API_KEY=sk-ant-...      # API da Anthropic
 # ou: instale o Claude Code, rode `claude` e /login — o Brito usa a sua assinatura
 ```
 
+### App de desktop (executável)
+
+O mesmo agente numa janela: projetos e sessões numa barra lateral, chat com markdown, chamadas de ferramenta recolhíveis, pedidos de permissão e seletores de modelo, esforço e modo de permissão. Não precisa de Node nem de terminal.
+
+![App de desktop do Brito respondendo uma pergunta com o grafo de código](docs/images/desktop-app.png)
+
+*O app de desktop num projeto pequeno: uma pergunta, uma chamada ao grafo (a linha recolhida "executou 1 comando") e a resposta em tabela. A barra lateral agrupa as sessões por projeto; o rodapé mostra o backend, a pasta, o tamanho do contexto e o custo.*
+
+Baixe na [página de Releases](https://github.com/wilsonbrito/brito/releases):
+
+| Sistema | Arquivo |
+|---|---|
+| macOS | `Brito-<versão>-macos-arm64.dmg` (Apple Silicon) ou `-x64.dmg` (Intel): abra e arraste o Brito para Aplicativos |
+| Windows | `Brito-<versão>-windows-x64-setup.exe` |
+| Linux | `Brito-<versão>-linux-x64.tar.gz`: extraia e rode `./install.sh` (coloca o Brito no menu de aplicativos) |
+
+Os pacotes não são assinados com Apple Developer ID nem com certificado do Windows, então o macOS ("desenvolvedor não identificado": botão direito, depois Abrir) e o SmartScreen do Windows avisam na primeira abertura. O macOS é a plataforma mais testada; os pacotes de Windows e Linux saem do CI e foram menos exercitados.
+
+Como na versão de terminal, ele usa a `ANTHROPIC_API_KEY` se o seu shell a exporta; senão, a sua assinatura do Claude Code (`claude`, depois `/login`). Aberto pelo Finder, o app lê o seu shell de login para encontrá-las.
+
+Para compilar você mesmo: `npm run desktop` (desenvolvimento), `npm run desktop:app` (macOS: instala `/Applications/Brito.app`) ou `npm run desktop:dmg`.
+
 ## Começando
 
 ```bash
@@ -140,7 +166,8 @@ Os dados do projeto ficam em `.brito/` (grafo, skills do projeto, agentes) e os
 
 ## Limitações
 
-- Software em fase inicial (v0.3.1), um mantenedor.
+- Software em fase inicial (v0.5.0), um mantenedor.
+- O app de desktop é novo: uma janela só (sem abas ainda) e, com chave de API (sem o `claude` CLI), o modelo não retoma a conversa ao reabrir o app, embora a tela a mostre.
 - **A interface e o idioma padrão do agente são português do Brasil.** Traduzi-los é uma contribuição bem-vinda.
 - O aprendizado de skills é heurístico: ele propõe, você decide. Espere rejeitar algumas propostas.
 
@@ -162,6 +189,8 @@ npm test             # 190+ testes, incluindo um servidor MCP real e um REPL rea
 | `src/tools/` | tools de grafo, memória, skills, arquivos e shell |
 | `src/mcp/` | servidor MCP |
 | `src/repl.ts`, `src/ui/` | interface de terminal |
+| `src/desktop/` | `brito gui-serve`: o backend com que a janela do desktop conversa (JSON por stdio) |
+| `desktop/` | janela Electron e empacotamento (`package.mjs`); `npm run bundle` gera o backend em arquivo único que ela usa |
 
 ## Licença
 

package/dist/agent/approval.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { describeClaudeTool, perms } from "../permissions.js";
+/**
+ * Aprovações do claude CLI: o claude chama a tool MCP `approve` (--permission-prompt-tool), que roda no
+ * processo do servidor MCP e consulta ESTE processo por um socket unix, onde está o terminal (ou a janela do app).
+ */
+export function startApprovalServer(io) {
+    // No Windows um socket unix em %TEMP% não é aceito por net.listen: o endereço tem que ser um named pipe.
+    const sock = process.platform === "win32" ? `\\\\.\\pipe\\brito-approve-${process.pid}` : path.join(os.tmpdir(), `brito-approve-${process.pid}.sock`);
+    try {
+        fs.unlinkSync(sock);
+    }
+    catch { /* não existia */ }
+    const server = net.createServer((conn) => {
+        let buf = "";
+        conn.on("data", async (d) => {
+            buf += d.toString();
+            const nl = buf.indexOf("\n");
+            if (nl < 0)
+                return;
+            let reply;
+            try {
+                const req = JSON.parse(buf.slice(0, nl));
+                const plan = req.tool_name === "ExitPlanMode";
+                const ok = await io.ask(describeClaudeTool(req.tool_name, req.input), { force: plan });
+                if (ok && plan)
+                    perms.mode = "manual";
+                reply = ok ? { allow: true } : { allow: false, message: plan ? "Plano não aprovado pelo usuário. Pergunte o que ajustar." : "O usuário negou a execução." };
+            }
+            catch (e) {
+                reply = { allow: false, message: `erro no pedido de aprovação: ${e?.message ?? e}` };
+            }
+            conn.end(JSON.stringify(reply) + "\n");
+        });
+        conn.on("error", () => { });
+    });
+    server.listen(sock);
+    server.unref();
+    const close = () => { server.close(); try {
+        fs.unlinkSync(sock);
+    }
+    catch { /* já removido */ } };
+    process.on("exit", close);
+    return { path: sock, close };
+}

package/dist/agent/claude-cli.js

@@ -1,19 +1,23 @@
+import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { listAgents } from "./agents.js";
 import { buildSystemPrompt } from "./prompt.js";
 import { skillsIndex } from "../skills/store.js";
 import { MCP_NAME, MCP_PREFIX, APPROVE_TOOL } from "../mcp/server.js";
-import { ui } from "../ui/ui.js";
+import { ui as terminalUi } from "../ui/ui.js";
 import { MODE_ENV, perms } from "../permissions.js";
 import { wireEffort } from "../model.js";
 import { claudeCommand } from "../util/platform.js";
+import { fmtBytes, findImages, splitOversize } from "../util/images.js";
 // Backend alternativo: delega ao `claude` oficial, que autentica com o /login do usuário.
 // O brito nunca lê nem envia o token da assinatura. Grafo, memória e skills chegam ao claude via MCP.
 export function hasClaudeCli() {
     const c = claudeCommand(["--version"]);
     return spawnSync(c.command, c.args, { stdio: "ignore" }).status === 0;
 }
+/** Texto de um tool_result (string ou lista de blocos). */
+const resultText = (c) => (typeof c === "string" ? c : Array.isArray(c) ? c.map((b) => (typeof b?.text === "string" ? b.text : "")).join("") : "");
 /** Nome das tools do Brito → nome que o claude enxerga. */
 const CLAUDE_TOOL = { read_file: "Read", glob: "Glob", grep: "Grep", write_file: "Write", edit_file: "Edit", bash: "Bash" };
 const claudeToolName = (n) => CLAUDE_TOOL[n] ?? MCP_PREFIX + n;
@@ -66,9 +70,9 @@ export function recordStreamEvent(turn, ev, loadedSkills) {
  * Config do servidor MCP entregue ao claude. O servidor roda em outro processo: o env leva o socket de aprovação
  * e o modo de permissão do REPL (vale por turno, pois cada turno sobe um claude novo com esta config).
  */
-export function mcpConfig(cmd, approvalSock, mode) {
+export function mcpConfig(cmd, approvalSock, mode, extraEnv = {}) {
     // alwaysLoad: sem isso o claude adia as tools do Brito atrás do ToolSearch e o modelo raramente chega ao grafo.
-    return { mcpServers: { [MCP_NAME]: { type: "stdio", command: cmd.command, args: cmd.args, alwaysLoad: true, env: { BRITO_APPROVE_SOCK: approvalSock, [MODE_ENV]: mode } } } };
+    return { mcpServers: { [MCP_NAME]: { type: "stdio", command: cmd.command, args: cmd.args, alwaysLoad: true, env: { ...extraEnv, BRITO_APPROVE_SOCK: approvalSock, [MODE_ENV]: mode } } } };
 }
 export class ClaudeSession {
     o;
@@ -95,14 +99,17 @@ export class ClaudeSession {
     constructor(o) {
         this.o = o;
     }
+    get sessionId() { return this.id; }
+    /** Retoma uma conversa do claude (--resume) em vez de começar outra. */
+    resume(id) { this.id = id; this.started = true; }
     reset() { this.id = randomUUID(); this.started = false; this.contextTokens = 0; this.recentTurns = []; }
     abort() { if (!this.child)
         return; this.aborted = true; this.child.kill("SIGINT"); }
     /** No Windows `kill("SIGINT")` termina o processo sem sinal nem código 130: lembramos que fomos nós que interrompemos. */
     aborted = false;
-    args(text) {
+    args(text, imageDirs = []) {
         const { root, approvalSock, stats, mcpCommand } = this.o;
-        const mcp = mcpConfig(mcpCommand, approvalSock, perms.mode);
+        const mcp = mcpConfig(mcpCommand, approvalSock, perms.mode, this.o.env);
         const readOnlyMcp = ["graph_search", "graph_callers", "graph_callees", "graph_impact", "graph_context", "graph_query", "graph_index", "remember", "recall", "skill_load"];
         const system = buildSystemPrompt(root, stats, skillsIndex(root)) +
             `\n\n# Nesta sessão\nAs tools do Brito chegam com o prefixo \`${MCP_PREFIX}\` (ex.: ${MCP_PREFIX}graph_context). Use-as como descrito acima. ` +
@@ -111,6 +118,8 @@ export class ClaudeSession {
             "-p", text,
             this.started ? "--resume" : "--session-id", this.id,
             "--output-format", "stream-json", "--verbose",
+            // Pastas das imagens anexadas: o Read do claude as lê sem pedir permissão (cada --add-dir é uma pasta).
+            ...imageDirs.flatMap((d) => ["--add-dir", d]),
             "--append-system-prompt", system,
             "--mcp-config", JSON.stringify(mcp),
             "--agents", JSON.stringify(claudeAgents()),
@@ -130,13 +139,21 @@ export class ClaudeSession {
     }
     /** Roda um turno renderizando o stream-json com a UI do Brito. */
     send(text) {
+        const ui = this.o.sink ?? terminalUi;
         return new Promise((resolve) => {
             ui.turnStart();
-            const cmd = claudeCommand(this.args(text));
+            const { ok: imgs, tooBig } = splitOversize(findImages(text, this.o.root));
+            for (const i of tooBig)
+                ui.warn(`${i.name} passa de 5 MB e não foi anexada`);
+            if (imgs.length)
+                ui.info(`🖼 ${imgs.map((i) => `${i.name} (${fmtBytes(i.bytes)})`).join(", ")} anexada${imgs.length > 1 ? "s" : ""}`);
+            // O claude vê a imagem pela tool Read: o prompt diz quais arquivos são imagens anexadas pelo usuário.
+            const prompt = imgs.length ? `${text}\n\n[O usuário anexou ${imgs.length > 1 ? "estas imagens" : "esta imagem"}; abra com a tool Read para vê-${imgs.length > 1 ? "las" : "la"}:\n${imgs.map((i) => `- ${i.path}`).join("\n")}]` : text;
+            const cmd = claudeCommand(this.args(prompt, [...new Set(imgs.map((i) => path.dirname(i.path)))]));
             const child = (this.child = spawn(cmd.command, cmd.args, {
                 cwd: this.o.root, stdio: ["ignore", "pipe", "pipe"],
                 // `/reasoning none`: o claude desliga o raciocínio com MAX_THINKING_TOKENS=0 (não há `--effort none`)
-                env: wireEffort(this.effort).thinking ? process.env : { ...process.env, MAX_THINKING_TOKENS: "0" },
+                env: { ...process.env, ...this.o.env, BRITO_DEPTH: String(Number(process.env.BRITO_DEPTH ?? 0) + 1), ...(wireEffort(this.effort).thinking ? {} : { MAX_THINKING_TOKENS: "0" }) },
             }));
             let buf = "", stderr = "", ok = true, interrupted = false;
             const names = new Map();
@@ -169,7 +186,7 @@ export class ClaudeSession {
                 else if (ev.type === "user") {
                     for (const b of ev.message?.content ?? [])
                         if (b.type === "tool_result")
-                            ui.toolEnd(b.tool_use_id, !!b.is_error);
+                            ui.toolEnd(b.tool_use_id, !!b.is_error, resultText(b.content));
                 }
                 else if (ev.type === "result") {
                     this.usage.input += (ev.usage?.input_tokens ?? 0) + (ev.usage?.cache_read_input_tokens ?? 0) + (ev.usage?.cache_creation_input_tokens ?? 0);

package/dist/agent/context.js

@@ -1,4 +1,6 @@
-export const estimateTokens = (msgs) => Math.ceil(JSON.stringify(msgs).length / 4);
+/** Imagem em base64 tem megabytes, mas custa ~1,6 mil tokens: troca o conteúdo por um marcador antes de medir ou resumir. */
+const stubImages = (_k, v) => (v && typeof v === "object" && v.type === "image" ? { type: "image", note: "x".repeat(6400) } : v);
+export const estimateTokens = (msgs) => Math.ceil(JSON.stringify(msgs, stubImages).length / 4);
 const MAX_OLD_RESULT = 1500;
 /** Fase 1 (barata): encurta tool_results antigos, preservando as últimas `keep` mensagens. */
 export function trimOldToolResults(msgs, keep = 8) {
@@ -33,7 +35,7 @@ export async function summarizeMiddle(client, model, msgs, keepTail = 6) {
         model,
         max_tokens: 2000,
         system: "Resuma a conversa de um agente de programação. Preserve: objetivo, decisões, arquivos/símbolos tocados, erros encontrados, estado atual e próximos passos. Seja denso.",
-        messages: [{ role: "user", content: JSON.stringify(middle).slice(0, 150_000) }],
+        messages: [{ role: "user", content: JSON.stringify(middle, (_k, v) => (v && typeof v === "object" && v.type === "image" ? { type: "image", note: "[imagem omitida]" } : v)).slice(0, 150_000) }],
     });
     const summary = res.content.map((b) => (b.type === "text" ? b.text : "")).join("");
     return [...head, { role: "user", content: `[Resumo da conversa anterior]\n${summary}` }, { role: "assistant", content: "Entendido, continuando a partir do resumo." }, ...tail];

package/dist/agent/loop.js

@@ -1,8 +1,9 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { toApiTools, execTool, isConcurrent } from "../tools/registry.js";
 import { estimateTokens, summarizeMiddle, trimOldToolResults } from "./context.js";
-import { ui } from "../ui/ui.js";
+import { ui as terminalUi } from "../ui/ui.js";
 import { initialModel } from "../model.js";
+import { fmtBytes, findImages, imageBlock, splitOversize } from "../util/images.js";
 export const MODEL = initialModel();
 const COMPACT_AT = Number(process.env.BRITO_COMPACT_TOKENS ?? 120_000);
 export class Agent {
@@ -21,13 +22,15 @@ export class Agent {
     recentTurns = [];
     maxSteps;
     log;
+    ui;
     constructor(system, ctx, opts = {}) {
         this.system = system;
         this.ctx = ctx;
         this.opts = opts;
         this.model = opts.model ?? MODEL;
         this.maxSteps = opts.maxSteps ?? 40;
-        this.log = opts.log ?? ((s) => ui.info(s));
+        this.ui = opts.sink ?? terminalUi;
+        this.log = opts.log ?? ((s) => this.ui.info(s));
     }
     /** Roda um turno completo (até não haver mais tool_use) e devolve o texto final. */
     async send(userText, signal) {
@@ -56,7 +59,18 @@ export class Agent {
         this.lastTurn = turn;
         this.recentTurns = [...this.recentTurns, turn].slice(-3);
         const push = (m) => { this.messages.push(m); turn.messages.push(m); };
-        push({ role: "user", content: userText });
+        // Imagens arrastadas para o terminal chegam como caminhos no texto: anexa como blocos `image`. O registro do turno
+        // (usado na reflexão) guarda só o texto, para não carregar base64.
+        const { ok, tooBig } = splitOversize(findImages(userText, this.ctx.root));
+        for (const i of tooBig)
+            this.log(`⚠ ${i.name} passa de 5 MB e não foi anexada`);
+        if (ok.length) {
+            this.log(`🖼 ${ok.map((i) => `${i.name} (${fmtBytes(i.bytes)})`).join(", ")} anexada${ok.length > 1 ? "s" : ""}`);
+            this.messages.push({ role: "user", content: [...ok.map(imageBlock), { type: "text", text: userText }] });
+            turn.messages.push({ role: "user", content: userText });
+        }
+        else
+            push({ role: "user", content: userText });
         await this.compactIfNeeded();
         let finalText = "";
         for (let step = 0; step < this.maxSteps; step++) {
@@ -70,7 +84,7 @@ export class Agent {
                 messages: this.messages,
             }, { signal });
             if (!this.opts.quiet)
-                stream.on("text", (t) => ui.text(t));
+                stream.on("text", (t) => this.ui.text(t));
             const msg = await stream.finalMessage();
             this.contextTokens = msg.usage.input_tokens + (msg.usage.cache_read_input_tokens ?? 0) + (msg.usage.cache_creation_input_tokens ?? 0);
             this.usage.input += msg.usage.input_tokens + (msg.usage.cache_read_input_tokens ?? 0) + (msg.usage.cache_creation_input_tokens ?? 0);
@@ -82,7 +96,7 @@ export class Agent {
             if (text)
                 finalText = text;
             if (!this.opts.quiet)
-                ui.textEnd();
+                this.ui.textEnd();
             const uses = msg.content.filter((b) => b.type === "tool_use");
             if (msg.stop_reason !== "tool_use" || uses.length === 0) {
                 turn.finished = true;
@@ -91,13 +105,13 @@ export class Agent {
             const runOne = async (u) => {
                 const t0 = Date.now();
                 if (!this.opts.quiet)
-                    ui.toolStart(u.id, u.name, u.input);
+                    this.ui.toolStart(u.id, u.name, u.input);
                 const denied = this.opts.tools && !this.opts.tools.has(u.name);
                 const r = denied ? { text: `Tool não permitida para este agente: ${u.name}`, isError: true } : await execTool(u.name, u.input, this.ctx);
                 if (this.opts.quiet)
-                    this.log(ui.toolLine(u.name, u.input, Date.now() - t0, r.isError));
+                    this.log(terminalUi.toolLine(u.name, u.input, Date.now() - t0, r.isError));
                 else
-                    ui.toolEnd(u.id, r.isError);
+                    this.ui.toolEnd(u.id, r.isError, r.text);
                 return { type: "tool_result", tool_use_id: u.id, content: r.text.slice(0, 40_000), is_error: r.isError };
             };
             // Leituras puras rodam em paralelo; qualquer escrita/aprovação força execução em série.
@@ -109,7 +123,7 @@ export class Agent {
             push({ role: "user", content: results });
             await this.compactIfNeeded();
         }
-        ui.warn("Limite de passos atingido.");
+        this.ui.warn("Limite de passos atingido.");
         return finalText || "(limite de passos atingido sem resposta final)";
     }
     async compactIfNeeded() {

package/dist/agent/sink.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -7,16 +7,15 @@ import "./tools/bash.js";
 import "./tools/graph.js";
 import "./tools/delegate.js";
 import "./tools/plan.js";
-import net from "node:net";
-import os from "node:os";
 import fs from "node:fs";
-import { PLAN_NOTE, perms, describeClaudeTool } from "./permissions.js";
+import { PLAN_NOTE, perms } from "./permissions.js";
 import { loadProjectAgents, listAgents } from "./agent/agents.js";
 import { GraphLockedError, GraphStore } from "./graph/store.js";
 import { indexProject } from "./graph/indexer.js";
 import { Agent, MODEL } from "./agent/loop.js";
 import { EFFORTS, MODEL_ALIASES, MODEL_HELP, effortLabel, initialEffort, isEffort, loadReasoningDisplay, parseModelArgs, saveEffort, saveModel, saveReasoningDisplay } from "./model.js";
 import { hasClaudeCli, ClaudeSession } from "./agent/claude-cli.js";
+import { startApprovalServer } from "./agent/approval.js";
 import { serveMcp } from "./mcp/server.js";
 import "./tools/skills.js";
 import { approvePending, lintSkill, listPending, listSkills, rejectPending, skillsIndex, staleRefs } from "./skills/store.js";
@@ -44,6 +43,12 @@ program
     console.log(`OK: ${s.files} arquivos, ${s.symbols} símbolos, ${s.calls} chamadas, ${s.imports} imports | +${s.added} ~${s.changed} -${s.removed} =${s.unchanged} (${Date.now() - t}ms)`);
     await g.close();
 });
+program
+    .command("gui-serve", { hidden: true })
+    .description("Backend do app desktop (JSON por stdio)")
+    .option("-d, --dir <dir>")
+    .option("--resume <id>", "retoma uma conversa do claude")
+    .action(async (o) => { const { serveDesktop } = await import("./desktop/serve.js"); await serveDesktop(rootOf(o), o.resume); });
 program
     .command("query <cypher>")
     .description("Executa Cypher no grafo")
@@ -75,49 +80,6 @@ async function plainAsk(q) {
     return /^(s|y)/i.test(a.trim());
 }
 /** Sem API key: o `claude` oficial (login da assinatura) faz o modelo; grafo/memória/skills chegam via MCP. */
-/**
- * Aprovações do claude CLI: o claude chama a tool MCP `approve` (--permission-prompt-tool), que roda no
- * processo do servidor MCP e consulta ESTE processo por um socket unix, onde está o terminal.
- */
-function startApprovalServer(io) {
-    // No Windows um socket unix em %TEMP% não é aceito por net.listen: o endereço tem que ser um named pipe.
-    const sock = process.platform === "win32" ? `\\\\.\\pipe\\brito-approve-${process.pid}` : path.join(os.tmpdir(), `brito-approve-${process.pid}.sock`);
-    try {
-        fs.unlinkSync(sock);
-    }
-    catch { /* não existia */ }
-    const server = net.createServer((conn) => {
-        let buf = "";
-        conn.on("data", async (d) => {
-            buf += d.toString();
-            const nl = buf.indexOf("\n");
-            if (nl < 0)
-                return;
-            let reply;
-            try {
-                const req = JSON.parse(buf.slice(0, nl));
-                const plan = req.tool_name === "ExitPlanMode";
-                const ok = await io.ask(describeClaudeTool(req.tool_name, req.input), { force: plan });
-                if (ok && plan)
-                    perms.mode = "manual";
-                reply = ok ? { allow: true } : { allow: false, message: plan ? "Plano não aprovado pelo usuário. Pergunte o que ajustar." : "O usuário negou a execução." };
-            }
-            catch (e) {
-                reply = { allow: false, message: `erro no pedido de aprovação: ${e?.message ?? e}` };
-            }
-            conn.end(JSON.stringify(reply) + "\n");
-        });
-        conn.on("error", () => { });
-    });
-    server.listen(sock);
-    server.unref();
-    const close = () => { server.close(); try {
-        fs.unlinkSync(sock);
-    }
-    catch { /* já removido */ } };
-    process.on("exit", close);
-    return { path: sock, close };
-}
 /** Menus ↑↓+Enter do `/model`: modelo e depois escopo. null = cancelado. */
 async function pickModel(current) {
     const models = Object.entries(MODEL_ALIASES);
@@ -487,6 +449,12 @@ program
     .option("-d, --dir <dir>", "raiz do projeto")
     .option("-y, --yes", "aprovar edições e comandos automaticamente")
     .action(async (promptParts, o) => {
+    // Trava anti-recursão: um brito iniciado por dentro de um claude que o próprio brito lançou (BRITO_DEPTH) pode abrir
+    // outro claude, e assim por diante. Dois níveis bastam; mais que isso é laço de processos.
+    if (Number(process.env.BRITO_DEPTH ?? 0) >= 2) {
+        console.error("brito aninhado demais (BRITO_DEPTH): abortando para evitar laço de processos.");
+        process.exit(1);
+    }
     if (!process.env.ANTHROPIC_API_KEY) {
         if (!hasClaudeCli()) {
             console.error(c.err("Defina ANTHROPIC_API_KEY ou instale o Claude Code e rode `claude` → /login."));
@@ -573,7 +541,8 @@ program
         },
     });
 });
-program.parseAsync().catch((e) => {
+// from: "node" explícito: dentro do Electron (ELECTRON_RUN_AS_NODE) o commander trataria o caminho do script como argumento.
+program.parseAsync(process.argv, { from: "node" }).catch((e) => {
     if (e instanceof GraphLockedError) {
         console.error(c.err("✗ ") + e.message);
         process.exit(1);

package/dist/desktop/serve.js

@@ -0,0 +1,209 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+import "../tools/fs.js";
+import "../tools/bash.js";
+import "../tools/graph.js";
+import "../tools/delegate.js";
+import "../tools/plan.js";
+import "../tools/skills.js";
+import { Agent } from "../agent/loop.js";
+import { ClaudeSession, hasClaudeCli } from "../agent/claude-cli.js";
+import { startApprovalServer } from "../agent/approval.js";
+import { loadProjectAgents } from "../agent/agents.js";
+import { buildSystemPrompt, graphStatsLine } from "../agent/prompt.js";
+import { GraphStore } from "../graph/store.js";
+import { indexProject } from "../graph/indexer.js";
+import { DEFAULT_MODEL, initialEffort, initialModel, isEffort, MODEL_ALIASES } from "../model.js";
+import { PLAN_NOTE, perms } from "../permissions.js";
+import { skillsIndex } from "../skills/store.js";
+/**
+ * Backend do app desktop, controlado por JSON em linhas.
+ * stdin  → {t:"send",text} {t:"abort"} {t:"approve",id,allow} {t:"config",model?,effort?,mode?} {t:"reset"} {t:"quit"}
+ * stdout → linhas "@@{json}" (qualquer outra linha, como logs perdidos, a janela ignora).
+ * Motor: com ANTHROPIC_API_KEY usa a API direta (como o `brito` no terminal); sem ela, o `claude` CLI (assinatura).
+ */
+const MARK = "@@";
+const emit = (ev) => process.stdout.write(MARK + JSON.stringify(ev) + "\n");
+const sink = {
+    turnStart: () => emit({ t: "turnStart" }),
+    turnEnd: (ok = true) => emit({ t: "turnEnd", ok }),
+    text: (text) => emit({ t: "text", text }),
+    textEnd: () => emit({ t: "textEnd" }),
+    thinking: (text) => emit({ t: "thinking", text }),
+    toolStart: (id, name, input) => emit({ t: "toolStart", id, name, input }),
+    toolEnd: (id, isError, output) => emit({ t: "toolEnd", id, isError, output: (output ?? "").slice(0, 4000) }),
+    info: (msg) => emit({ t: "info", msg }),
+    warn: (msg) => emit({ t: "warn", msg }),
+    error: (msg) => emit({ t: "error", msg }),
+};
+const CTX_WINDOW = Number(process.env.BRITO_CONTEXT_WINDOW ?? 200_000);
+export async function serveDesktop(root, resumeId) {
+    const pending = new Map();
+    const ask = (text, opts) => perms.mode === "bypass" && !opts?.force ? Promise.resolve(true) : new Promise((resolve) => {
+        const id = randomUUID();
+        pending.set(id, resolve);
+        emit({ t: "approval", id, text, force: !!opts?.force });
+    });
+    // Na pasta pessoal (projeto "Home") indexar tudo seria enorme e inútil: sem índice ali.
+    const isHome = path.resolve(root) === path.resolve(os.homedir());
+    const useApi = !!process.env.ANTHROPIC_API_KEY;
+    if (!useApi && !hasClaudeCli()) {
+        emit({ t: "error", msg: "Sem acesso ao modelo: defina ANTHROPIC_API_KEY (no seu shell) ou instale o Claude Code e rode `claude` → /login." });
+        process.exit(1);
+    }
+    loadProjectAgents(root);
+    let engine;
+    let syms = 0, notes = 0;
+    let closeApproval = () => { };
+    if (useApi) {
+        // API direta: o grafo fica aberto neste processo (sem servidor MCP), como no `brito` do terminal.
+        // No Home o banco vai para ~/.brito/home-graph, para não criar .brito dentro da pasta pessoal.
+        const graphRoot = isHome ? path.join(os.homedir(), ".brito", "home-graph") : root;
+        fs.mkdirSync(graphRoot, { recursive: true });
+        const graph = await GraphStore.open(graphRoot);
+        const sync = async () => { if (!isHome)
+            syms = (await indexProject(root, graph)).symbols; };
+        emit({ t: "info", msg: "sincronizando grafo…" });
+        try {
+            await sync();
+        }
+        catch (e) {
+            emit({ t: "warn", msg: `grafo indisponível: ${e?.message ?? e}` });
+        }
+        try {
+            notes = Number((await graph.run("MATCH (s:Note) RETURN count(s) AS n"))[0].n);
+        }
+        catch { /* sem notas */ }
+        const ctx = { root, graph, ask, sync, dirty: false, loadedSkills: new Set() };
+        const agent = new Agent(() => buildSystemPrompt(root, graphStatsLine(syms, notes, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : ""), ctx, { model: initialModel(), sink });
+        let ac = null;
+        const id = randomUUID();
+        if (resumeId)
+            emit({ t: "info", msg: "No modo API o histórico da conversa não é retomado ao reabrir; a tela mostra o que já foi dito, mas o modelo recomeça." });
+        engine = {
+            kind: "api", sessionId: id, effort: "",
+            get model() { return agent.model; }, set model(m) { agent.model = m; },
+            setModel: (m) => { agent.model = m; },
+            async send(text) {
+                ac = new AbortController();
+                sink.turnStart();
+                let ok = true;
+                try {
+                    await agent.send(text, ac.signal);
+                }
+                catch (e) {
+                    ok = false;
+                    ac.signal.aborted ? sink.warn("⏹ interrompido") : sink.error(e?.message ?? String(e));
+                }
+                finally {
+                    sink.turnEnd(ok);
+                    ac = null;
+                }
+            },
+            abort: () => ac?.abort(),
+            reset: () => { agent.messages = []; agent.contextTokens = 0; agent.recentTurns = []; agent.lastTurn = null; },
+            stats: () => ({ usage: agent.usage, contextTokens: agent.contextTokens, contextWindow: CTX_WINDOW, costUsd: 0 }),
+            close: async () => { await graph.close(); },
+        };
+    }
+    else {
+        const approval = startApprovalServer({ ask });
+        closeApproval = approval.close;
+        // O kuzu aceita um único processo com escrita: indexa, lê as stats e solta o banco para o servidor MCP.
+        if (!isHome)
+            try {
+                const graph = await GraphStore.open(root);
+                emit({ t: "info", msg: "sincronizando grafo…" });
+                await indexProject(root, graph);
+                syms = Number((await graph.run("MATCH (s:Symbol) RETURN count(s) AS n"))[0].n);
+                notes = Number((await graph.run("MATCH (s:Note) RETURN count(s) AS n"))[0].n);
+                await graph.close();
+            }
+            catch (e) {
+                emit({ t: "warn", msg: `grafo indisponível: ${e?.message ?? e}` });
+            }
+        const session = new ClaudeSession({
+            root, approvalSock: approval.path, stats: graphStatsLine(syms, notes, "start"), sink,
+            mcpCommand: { command: process.execPath, args: [...process.execArgv, process.argv[1], "mcp-serve", "-d", root] },
+            // Dentro do Electron o executável é o próprio app: este env o faz agir como Node nos filhos (claude → mcp-serve).
+            env: process.versions.electron || process.env.ELECTRON_RUN_AS_NODE ? { ELECTRON_RUN_AS_NODE: "1" } : undefined,
+        });
+        if (resumeId)
+            session.resume(resumeId);
+        session.effort = initialEffort();
+        engine = {
+            kind: "claude",
+            get sessionId() { return session.sessionId; },
+            get model() { return session.model; },
+            get effort() { return session.effort; }, set effort(e) { session.effort = e; },
+            setModel: (m) => { session.requestedModel = m; session.model = m || "claude (assinatura)"; },
+            send: async (text) => { await session.send(text); },
+            abort: () => session.abort(),
+            reset: () => session.reset(),
+            stats: () => ({ usage: session.usage, contextTokens: session.contextTokens, contextWindow: session.contextWindow, costUsd: session.costUsd }),
+            close: async () => { },
+        };
+    }
+    let busy = false;
+    const ready = () => emit({ t: "ready", engine: engine.kind, sessionId: engine.sessionId, model: engine.model, effort: engine.effort, mode: perms.mode, symbols: syms, notes, root });
+    ready();
+    const rl = readline.createInterface({ input: process.stdin });
+    const quit = async () => { closeApproval(); try {
+        await engine.close();
+    }
+    catch { /* saindo */ } process.exit(0); };
+    rl.on("close", quit);
+    rl.on("line", async (line) => {
+        let m;
+        try {
+            m = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        switch (m.t) {
+            case "send": {
+                if (busy)
+                    return emit({ t: "warn", msg: "já existe um turno em andamento" });
+                busy = true;
+                try {
+                    await engine.send(String(m.text ?? ""));
+                }
+                finally {
+                    busy = false;
+                    emit({ t: "usage", ...engine.stats(), model: engine.model, sessionId: engine.sessionId });
+                }
+                break;
+            }
+            case "abort":
+                engine.abort();
+                break;
+            case "approve":
+                pending.get(m.id)?.(!!m.allow);
+                pending.delete(m.id);
+                break;
+            case "config": {
+                if (typeof m.model === "string" && m.model)
+                    engine.setModel(MODEL_ALIASES[m.model] ?? m.model);
+                else if (m.model === "")
+                    engine.setModel(engine.kind === "api" ? DEFAULT_MODEL : "");
+                if (m.effort !== undefined)
+                    engine.effort = isEffort(m.effort) ? m.effort : "";
+                if (["manual", "auto", "plan", "bypass"].includes(m.mode))
+                    perms.mode = m.mode;
+                ready();
+                break;
+            }
+            case "reset":
+                engine.reset();
+                ready();
+                break;
+            case "quit":
+                await quit();
+                break;
+        }
+    });
+}

package/dist/graph/indexer.js

@@ -1,5 +1,5 @@
 import Parser from "web-tree-sitter";
-import fg from "fast-glob";
+import { glob as fg } from "tinyglobby";
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";

package/dist/setup.js

@@ -0,0 +1,110 @@
+import readline from "node:readline";
+import { hasClaudeCli } from "./agent/claude-cli.js";
+import { DEFAULT_MODEL, MODEL_ALIASES, saveEffort, saveModel, saveReasoningDisplay } from "./model.js";
+import { c } from "./ui/theme.js";
+const out = (s = "") => process.stdout.write(s + "\n");
+/** Menu de setas (↑/↓, j/k, número, Enter). Ctrl+C cancela o assistente. */
+async function select(title, options, current = 0) {
+    const stdin = process.stdin;
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    let idx = current;
+    let drawn = 0;
+    const render = () => {
+        if (drawn)
+            process.stdout.write(`\x1b[${drawn}A\x1b[J`);
+        const lines = [c.bold(title)];
+        options.forEach((o, i) => {
+            const on = i === idx;
+            lines.push(`  ${on ? c.accent("❯") : " "} ${on ? c.light(o.label) : o.label}${o.hint ? c.muted("  " + o.hint) : ""}`);
+        });
+        lines.push(c.muted("  ↑/↓ navegar · Enter confirmar"));
+        process.stdout.write(lines.join("\n") + "\n");
+        drawn = lines.length;
+    };
+    render();
+    return new Promise((resolve) => {
+        const onKey = (_, key) => {
+            if (key.ctrl && key.name === "c") {
+                stdin.setRawMode(false);
+                out();
+                process.exit(130);
+            }
+            if (key.name === "up" || key.name === "k")
+                idx = (idx + options.length - 1) % options.length;
+            else if (key.name === "down" || key.name === "j")
+                idx = (idx + 1) % options.length;
+            else if (key.sequence && /^[1-9]$/.test(key.sequence) && Number(key.sequence) <= options.length)
+                idx = Number(key.sequence) - 1;
+            else if (key.name === "return") {
+                stdin.off("keypress", onKey);
+                stdin.setRawMode(false);
+                stdin.pause();
+                process.stdout.write(`\x1b[${drawn}A\x1b[J`);
+                out(`${c.bold(title)} ${c.ok("✓")} ${c.light(options[idx].label)}`);
+                return resolve(options[idx].value);
+            }
+            render();
+        };
+        stdin.on("keypress", onKey);
+    });
+}
+const step = (n, total, name) => out(`\n${c.accent(`◆ Passo ${n}/${total}`)} ${c.muted("·")} ${c.bold(name)}`);
+export async function runSetup(opts = {}) {
+    const interactive = !!process.stdin.isTTY && !!process.stdout.isTTY && !opts.yes;
+    const total = 4;
+    const hasKey = !!process.env.ANTHROPIC_API_KEY;
+    const hasCli = hasClaudeCli();
+    out();
+    out(c.accent("  ╭─────────────────────────────────────╮"));
+    out(c.accent("  │") + c.bold("   Brito · assistente de configuração".padEnd(37)) + c.accent("│"));
+    out(c.accent("  ╰─────────────────────────────────────╯"));
+    out(c.muted("  Escolhas ficam em ~/.brito/config.json; rode `brito setup` de novo quando quiser mudar."));
+    // 1 · autenticação
+    step(1, total, "Autenticação");
+    out(`  ${hasKey ? c.ok("✓") : c.muted("·")} ANTHROPIC_API_KEY ${hasKey ? "definida" : "não definida"}`);
+    out(`  ${hasCli ? c.ok("✓") : c.muted("·")} Claude Code (claude CLI) ${hasCli ? "encontrado" : "não encontrado"}`);
+    if (!hasKey && !hasCli) {
+        out(c.warn("  Nenhum acesso detectado. Escolha um e depois rode `brito`:"));
+        out(c.muted("    • export ANTHROPIC_API_KEY=sk-ant-…   (chave da API)"));
+        out(c.muted("    • npm i -g @anthropic-ai/claude-code && claude   → /login   (assinatura)"));
+    }
+    let model = DEFAULT_MODEL;
+    let effort;
+    let showReasoning = true;
+    if (interactive) {
+        // 2 · modelo
+        step(2, total, "Modelo padrão");
+        const names = Object.keys(MODEL_ALIASES);
+        const hints = { fable: "mais capaz", opus: "raciocínio profundo", sonnet: "equilíbrio (recomendado)", haiku: "rápido e barato" };
+        model = await select("Qual modelo usar por padrão?", names.map((n) => ({ label: n, hint: hints[n], value: MODEL_ALIASES[n] })), names.indexOf("sonnet"));
+        // 3 · esforço
+        step(3, total, "Esforço de raciocínio");
+        effort = await select("Quanto o modelo deve pensar?", [
+            { label: "padrão", hint: "deixa o claude decidir", value: undefined },
+            { label: "low", hint: "respostas rápidas", value: "low" },
+            { label: "medium", value: "medium" },
+            { label: "high", hint: "tarefas difíceis", value: "high" },
+            { label: "max", hint: "mais lento e caro", value: "max" },
+        ]);
+        // 4 · exibição
+        step(4, total, "Exibição");
+        showReasoning = await select("Mostrar o raciocínio do modelo?", [
+            { label: "sim", hint: "recortado, como no Hermes", value: true },
+            { label: "não", value: false },
+        ]);
+    }
+    else {
+        out(c.muted(`\n  Modo não interativo: usando padrões (${DEFAULT_MODEL}).`));
+    }
+    saveModel(model);
+    saveEffort(effort);
+    saveReasoningDisplay({ show: showReasoning });
+    const row = (k, v) => out(`  ${c.muted(k.padEnd(12))} ${v}`);
+    out(`\n${c.ok("✓")} ${c.bold("Tudo pronto")}`);
+    row("modelo", model);
+    row("esforço", effort ?? "padrão");
+    row("raciocínio", showReasoning ? "visível" : "oculto");
+    out(`\n  Próximo passo: ${c.light("cd seu-projeto && brito")}\n`);
+}

package/dist/tools/fs.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import fs from "node:fs";
 import path from "node:path";
-import fg from "fast-glob";
+import { glob as fg } from "tinyglobby";
 import { defineTool } from "./registry.js";
 const abs = (root, p) => {
     const full = path.resolve(root, p);

package/dist/ui/dock.js

@@ -1,3 +1,4 @@
+import { droppedImages } from "../util/images.js";
 import fs from "node:fs";
 import path from "node:path";
 import stringWidth from "string-width";
@@ -7,7 +8,7 @@ const graphemes = (s) => Array.from(seg.segment(s), (x) => x.segment);
 const ANSI = /\x1b\[[0-9;]*[A-Za-z]/y;
 const MAX_INPUT_ROWS = 8;
 const MAX_MENU = 7;
-const PASTE_RE = /\[colado #(\d+): [^\]]*\]/g;
+const PASTE_RE = /\[(?:colado|imagem) #(\d+): [^\]]*\]/g;
 export class Dock {
     opts;
     onSubmit = () => { };
@@ -409,7 +410,14 @@ export class Dock {
     finishPaste() {
         const text = this.pasteBuf.replace(/\r\n?/g, "\n");
         const lines = text.split("\n").length;
-        if (lines >= 2 || text.length > 300) {
+        // Arrastar uma imagem para o terminal cola o caminho dela: vira um marcador curto que volta a ser o caminho no envio.
+        const imgs = droppedImages(text);
+        if (imgs.length) {
+            const n = ++this.pasteN;
+            this.pastes.set(n, imgs.map((i) => (/\s/.test(i.path) ? `"${i.path}"` : i.path)).join(" "));
+            this.insert(`[imagem #${n}: ${imgs.length === 1 ? imgs[0].name : `${imgs.length} imagens`}] `);
+        }
+        else if (lines >= 2 || text.length > 300) {
             const n = ++this.pasteN;
             this.pastes.set(n, text);
             const size = text.length >= 1000 ? `${(text.length / 1000).toFixed(1)}K` : String(text.length);

package/dist/util/images.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const TYPES = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp" };
+const IMG_EXT = /\.(png|jpe?g|gif|webp)$/i;
+/** Limite da API por imagem (5 MB) e teto de anexos por mensagem. */
+export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+export const MAX_IMAGES = 5;
+/** Divide o texto em tokens, respeitando aspas e (fora do Windows) `\ ` como espaço do nome do arquivo. */
+function tokens(text) {
+    const win = process.platform === "win32";
+    const re = win ? /'([^']*)'|"([^"]*)"|(\S+)/g : /'([^']*)'|"([^"]*)"|((?:\\.|\S)+)/g;
+    return [...text.matchAll(re)].map((m) => {
+        if (m[1] !== undefined)
+            return m[1];
+        if (m[2] !== undefined)
+            return m[2];
+        return win ? m[3] : m[3].replace(/\\(.)/g, "$1");
+    });
+}
+function toPath(token, root) {
+    let t = token.trim();
+    if (/^file:\/\//i.test(t)) {
+        try {
+            t = fileURLToPath(t);
+        }
+        catch {
+            return t;
+        }
+    }
+    if (t === "~" || t.startsWith("~/"))
+        t = path.join(os.homedir(), t.slice(1));
+    return path.resolve(root, t);
+}
+/** Imagens existentes citadas no texto (caminhos soltos, entre aspas, escapados ou file://). Sem duplicatas; para em MAX_IMAGES. */
+export function findImages(text, root = process.cwd()) {
+    const seen = new Set();
+    const out = [];
+    for (const tok of tokens(text)) {
+        if (!IMG_EXT.test(tok))
+            continue;
+        const p = toPath(tok, root);
+        if (seen.has(p))
+            continue;
+        try {
+            const st = fs.statSync(p);
+            if (!st.isFile())
+                continue;
+            seen.add(p);
+            out.push({ path: p, name: path.basename(p), mediaType: TYPES[path.extname(p).slice(1).toLowerCase()], bytes: st.size });
+        }
+        catch { /* não existe: era só texto parecido com caminho */ }
+        if (out.length >= MAX_IMAGES)
+            break;
+    }
+    return out;
+}
+/** O texto inteiro é só caminhos de imagem (o que um arrastar-e-soltar produz)? Devolve as imagens, ou [] se tem mais coisa. */
+export function droppedImages(text, root = process.cwd()) {
+    const toks = tokens(text);
+    if (!toks.length || !toks.every((t) => IMG_EXT.test(t)))
+        return [];
+    const imgs = findImages(text, root);
+    return imgs.length === toks.length ? imgs : [];
+}
+export const fmtBytes = (n) => (n >= 1_048_576 ? `${(n / 1_048_576).toFixed(1)} MB` : `${Math.max(1, Math.round(n / 1024))} kB`);
+/** Separa o que dá para enviar do que passa do limite da API. */
+export function splitOversize(imgs) {
+    return { ok: imgs.filter((i) => i.bytes <= MAX_IMAGE_BYTES), tooBig: imgs.filter((i) => i.bytes > MAX_IMAGE_BYTES) };
+}
+/** Bloco `image` da API da Anthropic, com o arquivo em base64. */
+export function imageBlock(img) {
+    return { type: "image", source: { type: "base64", media_type: img.mediaType, data: fs.readFileSync(img.path).toString("base64") } };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Coding-agent CLI with a code knowledge graph, memory and reviewable skills / CLI de agente de código com grafo de conhecimento, memória e skills revisáveis",
   "type": "module",
   "bin": {
@@ -13,21 +13,26 @@
     "test": "tsx --test test/*.test.ts",
     "eval:learn": "tsx test/eval-learn.ts",
     "prepare": "tsc",
-    "prepublishOnly": "npm run typecheck && npm test"
+    "prepublishOnly": "npm run typecheck && npm test",
+    "desktop": "npm run build && npm run bundle && npm --prefix desktop install --no-audit --no-fund && npm --prefix desktop start",
+    "bundle": "node build-bundle.mjs",
+    "desktop:app": "npm run build && npm run bundle && npm --prefix desktop install --no-audit --no-fund && node desktop/package.mjs --install",
+    "desktop:dmg": "npm run build && npm run bundle && npm --prefix desktop install --no-audit --no-fund && node desktop/package.mjs --dmg"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.131.0",
     "@modelcontextprotocol/sdk": "^1.32.0",
     "commander": "latest",
-    "fast-glob": "latest",
     "kuzu": "latest",
     "string-width": "^8.3.0",
+    "tinyglobby": "^0.2.17",
     "tree-sitter-wasms": "latest",
     "web-tree-sitter": "0.24.7",
     "zod": "latest"
   },
   "devDependencies": {
     "@types/node": "latest",
+    "esbuild": "^0.28.2",
     "tsx": "latest",
     "typescript": "latest"
   },
@@ -46,6 +51,7 @@
   },
   "files": [
     "dist",
+    "!dist/cli.bundle.mjs",
     ".brito/agents",
     "README.md",
     "README.pt-BR.md",
@@ -64,5 +70,8 @@
     "svelte",
     "typescript",
     "python"
-  ]
+  ],
+  "overrides": {
+    "tar": "^7.5.22"
+  }
 }