brito-cli 0.6.1 → 0.6.4

package/README.md

@@ -27,6 +27,10 @@ Brito is an agent for software development. Use it in the terminal (`brito-cli`
 
 ## How it works
 
+![Indexing once, then answering from the graph instead of grep and file reads](docs/images/graph-vs-grep.svg)
+
+*The graph is built once and updated incrementally; a question like "what breaks if I change this?" becomes one or two graph calls.*
+
 ```mermaid
 flowchart LR
     code["Your project<br/>.ts · .js · .py · .java · .kt · .go · .rb · .php · .cs · .rs · .svelte · .vue · .astro"] -->|"tree-sitter<br/>incremental"| cg[("Code graph<br/>symbols · calls · imports")]
@@ -47,8 +51,18 @@ flowchart LR
 - **Skills**: step-by-step procedures for *your* project (commands, order, traps, how to verify). The agent loads one with `skill_load` before a task it covers.
 - **Journal**: Brito remembers across sessions which tasks repeated, which is the best hint that a procedure is general and worth saving.
 
+### Architecture at a glance
+
+![Brito architecture: context, permissions, tools and subagents around the model](docs/images/architecture.svg)
+
+*Everything the model sees or can do is one of eight components, grouped by role. The mono-spaced text is the real file or command; the pill says when it fires.*
+
 ## Skills that earn their place
 
+![Skill lifecycle: task, reflection, trial or pending, active or archived](docs/images/skill-lifecycle.svg)
+
+*The two paths a skill can take. Safe ones prove themselves in trial; risky ones wait for your approval.*
+
 ![Reviewing a pending skill, with a destructive-command warning](docs/images/skills-review.png)
 
 0. **Autonomous path (default).** The reflection saves a new skill as *trial*, marked "(em teste)" in the index. Each turn that loads it counts as a win (no error-then-fix, no user correction) or a loss. 3 wins (and at most 1 loss per 3 wins) promote it; 2 losses without more wins, or 21 days unused, archive it to `.brito/skills/.trash`. Brito prints one line per promotion or archive. Limits: at most 3 new automatic skills a day, project scope only, and a weekly automatic consolidation that only touches automatic skills.
@@ -133,7 +147,7 @@ OK: 20 arquivos, 66 símbolos, 54 chamadas, 17 imports | +0 ~0 -0 =20 (28ms)
 |---|---|
 | `/help` | list commands |
 | `/model`, `/effort`, `/reasoning` | choose model, reasoning effort and thinking (session, global or once) |
-| `/modo` or `Shift+Tab` | switch permission mode: manual → auto-edits → plan |
+| `/modo` or `Shift+Tab` | switch permission mode: manual → auto-edits → plan → bypass ("everything allowed") |
 | `/skills` | list skills · `pending` · `approve <name>` · `reject <name>` · `consolidate` · `rm <name>` · `promote <name>` |
 | `/learn` | extract skills from the last turn now |
 | `/agents`, `/tools`, `/index`, `/context` | inspect subagents, tools, the index and the context window |

package/README.pt-BR.md

@@ -27,6 +27,10 @@ O Brito é um agente para desenvolvimento de software. Use no terminal (`brito-c
 
 ## Como funciona
 
+![Indexação uma vez, depois respostas vindas do grafo em vez de grep e leitura de arquivos](docs/images/graph-vs-grep.pt-BR.svg)
+
+*O grafo é construído uma vez e atualizado de forma incremental; uma pergunta como "o que quebra se eu mudar isto?" vira uma ou duas chamadas ao grafo.*
+
 ```mermaid
 flowchart LR
     code["Seu projeto<br/>.ts · .js · .py · .java · .kt · .go · .rb · .php · .cs · .rs · .svelte · .vue · .astro"] -->|"tree-sitter<br/>incremental"| cg[("Grafo de código<br/>símbolos · chamadas · imports")]
@@ -43,8 +47,18 @@ flowchart LR
 - **Skills**: procedimentos passo a passo para o *seu* projeto (comandos, ordem, armadilhas, como verificar). O agente carrega uma com `skill_load` antes de uma tarefa que ela cobre.
 - **Journal**: o Brito lembra entre sessões quais tarefas se repetiram, o melhor indício de que um procedimento é geral e vale guardar.
 
+### Arquitetura em uma imagem
+
+![Arquitetura do Brito: contexto, permissões, ferramentas e subagentes ao redor do modelo](docs/images/architecture.pt-BR.svg)
+
+*Tudo o que o modelo vê ou pode fazer é um dos oito componentes, agrupados por papel. O texto em monoespaçado é o arquivo ou comando real; a etiqueta diz quando ele entra em ação.*
+
 ## Skills que merecem o lugar
 
+![Ciclo de vida da skill: tarefa, reflexão, teste ou pendente, ativa ou arquivada](docs/images/skill-lifecycle.pt-BR.svg)
+
+*Os dois caminhos de uma skill. As seguras se provam em teste; as arriscadas esperam a sua aprovação.*
+
 ![Revisando uma skill pendente, com aviso de comando destrutivo](docs/images/skills-review.png)
 
 0. **Caminho autônomo (padrão).** A reflexão grava a skill nova como *em teste*, marcada "(em teste)" no índice. Cada turno que a carrega conta como vitória (sem erro→conserto nem correção do usuário) ou falha. 3 vitórias (e no máximo 1 falha a cada 3 vitórias) a promovem; 2 falhas sem mais vitórias, ou 21 dias sem uso, a arquivam em `.brito/skills/.trash`. O Brito imprime uma linha a cada promoção ou arquivamento. Limites: no máximo 3 skills automáticas novas por dia, só no escopo do projeto, e uma consolidação semanal automática que só mexe em skills automáticas.
@@ -129,7 +143,7 @@ OK: 20 arquivos, 66 símbolos, 54 chamadas, 17 imports | +0 ~0 -0 =20 (28ms)
 |---|---|
 | `/help` | lista os comandos |
 | `/model`, `/effort`, `/reasoning` | escolhem modelo, esforço de raciocínio e thinking (sessão, global ou uma vez) |
-| `/modo` ou `Shift+Tab` | troca o modo de permissão: manual → auto-edições → plano |
+| `/modo` ou `Shift+Tab` | troca o modo de permissão: manual → auto-edições → plano → tudo liberado |
 | `/skills` | lista skills · `pending` · `approve <nome>` · `reject <nome>` · `consolidate` · `rm <nome>` · `promote <nome>` |
 | `/learn` | extrai skills do último turno agora |
 | `/agents`, `/tools`, `/index`, `/context` | inspecionam subagentes, tools, o índice e a janela de contexto |

package/dist/agent/claude-cli.js

@@ -144,11 +144,11 @@ export class ClaudeSession {
             ui.turnStart();
             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`);
+                ui.warn(`${i.name} passa do limite da API e não foi anexado`);
             if (imgs.length)
-                ui.info(`🖼 ${imgs.map((i) => `${i.name} (${fmtBytes(i.bytes)})`).join(", ")} anexada${imgs.length > 1 ? "s" : ""}`);
+                ui.info(`📎 ${imgs.map((i) => `${i.name} (${fmtBytes(i.bytes)})`).join(", ")} anexado${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 prompt = imgs.length ? `${text}\n\n[O usuário anexou ${imgs.length > 1 ? "estes arquivos" : "este arquivo"}; 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"],

package/dist/agent/context.js

@@ -1,5 +1,5 @@
 /** 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);
+const stubImages = (_k, v) => (v && typeof v === "object" && (v.type === "image" || v.type === "document") && v.source ? { type: v.type, 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. */
@@ -35,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, (_k, v) => (v && typeof v === "object" && v.type === "image" ? { type: "image", note: "[imagem omitida]" } : v)).slice(0, 150_000) }],
+        messages: [{ role: "user", content: JSON.stringify(middle, (_k, v) => (v && typeof v === "object" && (v.type === "image" || v.type === "document") && v.source ? { type: v.type, note: "[anexo omitido]" } : 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

@@ -63,9 +63,9 @@ export class Agent {
         // (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`);
+            this.log(`⚠ ${i.name} passa do limite da API e não foi anexado`);
         if (ok.length) {
-            this.log(`🖼 ${ok.map((i) => `${i.name} (${fmtBytes(i.bytes)})`).join(", ")} anexada${ok.length > 1 ? "s" : ""}`);
+            this.log(`📎 ${ok.map((i) => `${i.name} (${fmtBytes(i.bytes)})`).join(", ")} anexado${ok.length > 1 ? "s" : ""}`);
             this.messages.push({ role: "user", content: [...ok.map(imageBlock), { type: "text", text: userText }] });
             turn.messages.push({ role: "user", content: userText });
         }

package/dist/permissions.js

@@ -6,8 +6,8 @@ export const perms = { mode: "manual" };
  */
 export const MODE_ENV = "BRITO_PERMS_MODE";
 export const modeFromEnv = (v) => ["manual", "auto", "plan", "bypass"].find((m) => m === v);
-const CYCLE = ["manual", "auto", "plan"];
-/** Próximo modo do ciclo; `bypass` (de --yes ou "tudo") volta para manual. */
+export const CYCLE = ["manual", "auto", "plan", "bypass"];
+/** Próximo modo do ciclo; depois de `bypass` (tudo liberado) volta para manual. */
 export function cycleMode() {
     perms.mode = CYCLE[(CYCLE.indexOf(perms.mode) + 1) % CYCLE.length];
     return perms.mode;

package/dist/repl.js

@@ -39,11 +39,14 @@ export async function runRepl(b, o) {
     const modeColor = { manual: c.muted, auto: c.ok, plan: c.warn, bypass: c.err };
     const modeChip = () => { const m = MODE_LABEL[perms.mode]; return modeColor[perms.mode](`${m.icon} ${m.name}`); };
     const status = () => ui.statusLine({
+        project: path.basename(o.root),
         mode: modeChip(),
         model: b.model(), ctxTokens: b.contextTokens(), ctxWindow: b.ctxWindow,
         input: b.usage().input, output: b.usage().output, cacheRead: b.usage().cacheRead, startedAt: o.startedAt, cost: b.cost?.(),
         extra: `${skillCount} ${skillCount === 1 ? "skill" : "skills"}`,
     });
+    if (interactive && process.stdout.isTTY)
+        process.stdout.write(`\x1b]0;brito · ${path.basename(o.root)}\x07`);
     const dock = interactive ? new Dock({ status, commands: menu, historyFile: path.join(globalHome(), "history") }) : null;
     if (dock) {
         await dock.start();
@@ -90,7 +93,7 @@ export async function runRepl(b, o) {
         "/help": () => {
             for (const m of menu)
                 ui.print(`  ${c.soft(m.name.padEnd(12))} ${c.muted(m.desc)}`);
-            ui.print(`  ${c.soft("Shift+Tab".padEnd(12))} ${c.muted("alterna modo: manual → auto-edições → plano")}`);
+            ui.print(`  ${c.soft("Shift+Tab".padEnd(12))} ${c.muted("alterna modo: manual → auto-edições → plano → tudo liberado")}`);
             ui.print(`  ${c.soft("!comando".padEnd(12))} ${c.muted("roda no shell, sem chamar o modelo")}`);
             ui.print(c.dim("  Enter envia · Alt+Enter nova linha · ↑↓ histórico · Tab completa · Ctrl+C interrompe"));
         },
@@ -106,13 +109,13 @@ export async function runRepl(b, o) {
         "/indicadores": () => { for (const l of ui.statusLegend())
             ui.print(l); },
         "/modo": ([m]) => {
-            const pick = { manual: "manual", auto: "auto", plano: "plan", plan: "plan" };
+            const pick = { manual: "manual", auto: "auto", plano: "plan", plan: "plan", tudo: "bypass", bypass: "bypass" };
             if (m && pick[m]) {
                 perms.mode = pick[m];
                 dock?.repaint();
             }
             else if (m) {
-                ui.warn("use: /modo manual | auto | plano");
+                ui.warn("use: /modo manual | auto | plano | tudo");
                 return;
             }
             const i = MODE_LABEL[perms.mode];
@@ -150,13 +153,13 @@ export async function runRepl(b, o) {
     const echo = (text) => {
         const lines = text.split("\n");
         const shown = lines.length > 4 ? [...lines.slice(0, 3), c.dim(`… (+${lines.length - 3} linhas)`)] : lines;
-        // balão do usuário: mesmo formato da caixa do Brito, em vermelho e com o nome de usuário da máquina
+        // balão do usuário (sem borda lateral, para copiar limpo): mesmo formato da caixa do Brito, em vermelho e com o nome de usuário da máquina
         const label = ` ${userName()} `;
-        const room = Math.max(10, cols() - 2);
+        const room = Math.max(10, cols() - 1);
         const body = shown.flatMap((l) => (l.length <= room ? [l] : l.match(new RegExp(`.{1,${room}}`, "gs")) ?? [l]));
-        ui.print("\n" + c.err("╭─") + c.bold(c.err(label)) + c.err("─".repeat(Math.max(2, cols() - label.length - 2))) + "\n" +
-            body.map((l) => c.err("│ ") + c.bold(c.err(l))).join("\n") + "\n" +
-            c.err("╰" + "─".repeat(cols() - 1)));
+        ui.print("\n" + c.err("──") + c.bold(c.err(label)) + c.err("─".repeat(Math.max(2, cols() - label.length - 2))) + "\n" +
+            body.map((l) => c.bold(c.err(l))).join("\n") + "\n" +
+            c.err("─".repeat(cols())));
     };
     const shutdown = async () => {
         if (closing)
@@ -185,15 +188,16 @@ export async function runRepl(b, o) {
             await shutdown();
             return;
         }
-        if (line.startsWith("/")) {
-            const run = common[key] ?? b.commands[key]?.run;
-            if (!run) {
-                ui.warn(`comando desconhecido: ${cmd}. Digite /help.`);
-                return;
-            }
+        const run = line.startsWith("/") ? common[key] ?? b.commands[key]?.run : undefined;
+        if (run) {
             await run(args);
             return;
         }
+        // "/Users/x/arquivo.pdf" é caminho, não comando: segue como mensagem ao agente
+        if (line.startsWith("/") && !cmd.slice(1).includes("/")) {
+            ui.warn(`comando desconhecido: ${cmd}. Digite /help.`);
+            return;
+        }
         const ac = (running = new AbortController());
         dock?.setBusy(true);
         try {

package/dist/ui/dock.js

@@ -8,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|imagem) #(\d+): [^\]]*\]/g;
+const PASTE_RE = /\[(?:colado|imagem|anexo) #(\d+): [^\]]*\]/g;
 export class Dock {
     opts;
     onSubmit = () => { };
@@ -415,7 +415,7 @@ export class Dock {
         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`}] `);
+            this.insert(`[anexo #${n}: ${imgs.length === 1 ? imgs[0].name : `${imgs.length} arquivos`}] `);
         }
         else if (lines >= 2 || text.length > 300) {
             const n = ++this.pasteN;

package/dist/ui/table.js

@@ -0,0 +1,102 @@
+import stringWidth from "string-width";
+import { c } from "./theme.js";
+/** Separa as células de uma linha `| a | b |` (aceita `\|` dentro da célula). */
+function cells(line) {
+    let s = line.trim();
+    if (s.startsWith("|"))
+        s = s.slice(1);
+    if (s.endsWith("|") && !s.endsWith("\\|"))
+        s = s.slice(0, -1);
+    return s.split(/(?<!\\)\|/).map((x) => x.replace(/\\\|/g, "|").trim());
+}
+const isSep = (row) => row.length > 0 && row.every((x) => /^:?-{1,}:?$/.test(x.replace(/\s/g, "")));
+/** Tira a marcação inline (**negrito**, *itálico*, `código`) — a tabela é desenhada sem ela. */
+const plain = (s) => s.replace(/\*\*(.+?)\*\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/(^|[^\w*])\*(?!\s)(.+?)\*(?!\w)/g, "$1$2").replace(/`([^`]*)`/g, "$1").replace(/<br\s*\/?>/gi, " ");
+/** Quebra o texto em linhas de no máximo `w` colunas (palavra longa demais é cortada). */
+function wrap(text, w) {
+    const out = [];
+    let cur = "";
+    const push = (word) => {
+        while (stringWidth(word) > w) {
+            if (cur) {
+                out.push(cur);
+                cur = "";
+            }
+            let piece = "";
+            for (const ch of word) {
+                if (stringWidth(piece + ch) > w)
+                    break;
+                piece += ch;
+            }
+            out.push(piece);
+            word = word.slice(piece.length);
+        }
+        if (!cur)
+            cur = word;
+        else if (stringWidth(cur) + 1 + stringWidth(word) <= w)
+            cur += " " + word;
+        else {
+            out.push(cur);
+            cur = word;
+        }
+    };
+    for (const word of text.split(/\s+/).filter(Boolean))
+        push(word);
+    if (cur || !out.length)
+        out.push(cur);
+    return out;
+}
+const pad = (s, w, align) => {
+    const gap = Math.max(0, w - stringWidth(s));
+    if (align === "r")
+        return " ".repeat(gap) + s;
+    if (align === "c")
+        return " ".repeat(Math.floor(gap / 2)) + s + " ".repeat(Math.ceil(gap / 2));
+    return s + " ".repeat(gap);
+};
+/**
+ * Desenha uma tabela markdown como grade com bordas (┌─┬─┐ / │ / ├─┼─┤ / └─┴─┘), como o Claude Code.
+ * Cabe em `width` colunas: as colunas mais largas encolhem e o texto quebra dentro delas.
+ * Devolve null se as linhas não formam uma tabela (falta a linha `|---|---|`).
+ */
+export function renderTable(lines, width) {
+    if (lines.length < 2)
+        return null;
+    const head = cells(lines[0]);
+    const sepRow = cells(lines[1]);
+    if (!isSep(sepRow))
+        return null;
+    const n = head.length;
+    const align = Array.from({ length: n }, (_, i) => {
+        const s = (sepRow[i] ?? "").replace(/\s/g, "");
+        return s.startsWith(":") && s.endsWith(":") ? "c" : s.endsWith(":") ? "r" : "l";
+    });
+    const norm = (r) => Array.from({ length: n }, (_, i) => plain(r[i] ?? ""));
+    const rows = [norm(head), ...lines.slice(2).map(cells).map(norm)];
+    const w = Array.from({ length: n }, (_, i) => Math.max(1, ...rows.map((r) => stringWidth(r[i]))));
+    const room = Math.max(n, width - (3 * n + 1));
+    // encolhe sempre a coluna mais larga até caber (mínimo de 8 colunas, ou menos se não houver espaço)
+    const min = Math.max(1, Math.min(8, Math.floor(room / n)));
+    while (w.reduce((a, b) => a + b, 0) > room) {
+        const i = w.indexOf(Math.max(...w));
+        if (w[i] <= min)
+            break;
+        w[i]--;
+    }
+    const border = (l, m, r) => c.accent(l + w.map((x) => "─".repeat(x + 2)).join(m) + r);
+    const bar = c.accent("│");
+    const out = [border("┌", "┬", "┐")];
+    rows.forEach((r, ri) => {
+        const wrapped = r.map((cell, i) => wrap(cell, w[i]));
+        const h = Math.max(...wrapped.map((x) => x.length));
+        for (let k = 0; k < h; k++) {
+            const body = wrapped.map((x, i) => {
+                const cell = pad(x[k] ?? "", w[i], ri === 0 ? "c" : align[i]);
+                return " " + (ri === 0 ? c.bold(cell) : cell) + " ";
+            });
+            out.push(bar + body.join(bar) + bar);
+        }
+        out.push(ri === rows.length - 1 ? border("└", "┴", "┘") : border("├", "┼", "┤"));
+    });
+    return out;
+}

package/dist/ui/ui.js

@@ -1,5 +1,6 @@
 import { BOLD, CODE, ITALIC, OFF, c, cols, palette, useColor } from "./theme.js";
 import { renderBanner } from "./banner.js";
+import { renderTable } from "./table.js";
 import stringWidth from "string-width";
 export const NAME = "Brito";
 const isTTY = !!process.stdout.isTTY;
@@ -159,6 +160,70 @@ class UI {
     skip = false; // descarta o resto da linha do ``` (nome da linguagem)
     bol = true; // só espaços até agora nesta linha
     prev = " "; // último caractere resolvido
+    // tabelas markdown: linhas que começam com `|` são guardadas inteiras e desenhadas alinhadas no fim da tabela
+    rawBol = true; // início de linha no texto bruto do modelo
+    lead = ""; // espaços no início da linha, antes de decidir se é tabela
+    tblLine = null; // linha de tabela em andamento
+    tbl = []; // linhas completas da tabela atual
+    /** Primeira etapa do streaming: separa as linhas de tabela; o resto segue para o markdown. */
+    raw(ch) {
+        if (this.tblLine !== null) {
+            if (ch === "\n") {
+                this.tbl.push(this.tblLine);
+                this.tblLine = null;
+                this.rawBol = true;
+            }
+            else
+                this.tblLine += ch;
+            return;
+        }
+        if (this.rawBol && !this.st.fence) {
+            if (ch === " " || ch === "\t") {
+                this.lead += ch;
+                return;
+            }
+            if (ch === "|") {
+                this.tblLine = "|";
+                this.lead = "";
+                return;
+            }
+        }
+        this.flushTable();
+        if (this.lead) {
+            for (const x of this.lead)
+                this.feed(x);
+            this.lead = "";
+        }
+        this.rawBol = ch === "\n";
+        this.feed(ch);
+    }
+    /** Fecha a tabela pendente: desenha alinhada ou, se não for tabela de verdade, devolve as linhas como texto. */
+    flushTable() {
+        if (this.tblLine !== null) {
+            this.tbl.push(this.tblLine);
+            this.tblLine = null;
+        }
+        if (!this.tbl.length)
+            return;
+        const lines = this.tbl;
+        this.tbl = [];
+        const drawn = renderTable(lines, cols() - 1);
+        if (!drawn) {
+            for (const l of lines)
+                for (const x of l + "\n")
+                    this.feed(x);
+            return;
+        }
+        this.emitWord();
+        if (!this.lineStart)
+            this.out("\n");
+        for (const l of drawn)
+            this.out(l + "\n");
+        this.lineStart = true;
+        this.lineW = 0;
+        this.prev = "\n";
+        this.bol = true;
+    }
     seq() {
         const { b, i, k, fence } = this.st;
         return k || fence ? CODE : (i ? ITALIC : "") + (b ? BOLD : "");
@@ -178,6 +243,10 @@ class UI {
         this.skip = false;
         this.bol = true;
         this.prev = " ";
+        this.rawBol = true;
+        this.lead = "";
+        this.tblLine = null;
+        this.tbl = [];
     }
     /** Descarrega a palavra em andamento, quebrando a linha antes dela se não couber. */
     emitWord() {
@@ -190,11 +259,8 @@ class UI {
             this.lineStart = true;
             this.lineW = 0;
         }
-        if (this.lineStart) {
-            this.out(c.accent("│ "));
-            this.lineStart = false;
-        }
-        // o estilo é reaplicado por palavra: a borda e os espaços não herdam a cor
+        this.lineStart = false; // sem borda lateral: copiar o texto do terminal sai limpo
+        // o estilo é reaplicado por palavra: os espaços não herdam a cor
         this.out(this.wordStart + this.word + (this.active() ? OFF : ""));
         this.lineW += w;
         this.word = "";
@@ -269,16 +335,13 @@ class UI {
                 this.st.i = false;
             } // linha em branco encerra ênfase aberta
             this.wordStart = this.seq();
-            this.out((this.lineStart ? c.accent("│") : "") + "\n");
+            this.out("\n");
             this.lineStart = true;
             this.lineW = 0;
         }
         else if (ch === " ") {
             this.emitWord();
-            if (this.lineStart) {
-                this.out(c.accent("│ "));
-                this.lineStart = false;
-            }
+            this.lineStart = false;
             if (this.lineW + 1 > cols() - 2) {
                 this.out("\n");
                 this.lineStart = true;
@@ -299,7 +362,7 @@ class UI {
         if (!this.textOpen) {
             this.clear();
             const label = ` ${NAME} `;
-            this.out(c.accent("╭─") + c.bold(c.light(label)) + c.accent("─".repeat(Math.max(2, cols() - label.length - 2))) + "\n");
+            this.out(c.accent("──") + c.bold(c.light(label)) + c.accent("─".repeat(Math.max(2, cols() - label.length - 2))) + "\n");
             this.textOpen = true;
             this.lineStart = true;
             this.lineW = 0;
@@ -307,18 +370,24 @@ class UI {
             this.resetStyle();
         }
         for (const ch of chunk)
-            this.feed(ch);
+            this.raw(ch);
     }
     textEnd() {
         if (!this.textOpen)
             return;
+        this.flushTable();
+        if (this.lead) {
+            for (const x of this.lead)
+                this.feed(x);
+            this.lead = "";
+        }
         if (this.run.n)
             this.resolve("\n"); // marcador no fim da resposta: fecha se havia abertura, senão fica literal
         this.emitWord();
         this.resetStyle();
         if (!this.lineStart)
             this.out("\n");
-        this.out(c.accent("╰" + "─".repeat(cols() - 1)) + "\n");
+        this.out(c.accent("─".repeat(cols())) + "\n");
         this.textOpen = false;
         this.draw();
     }
@@ -355,17 +424,17 @@ class UI {
             return;
         this.textEnd();
         const w = cols();
-        const wrapped = body.split("\n").flatMap((l) => wrapLine(l.trimEnd(), w - 4));
+        const wrapped = body.split("\n").flatMap((l) => wrapLine(l.trimEnd(), w - 1));
         const MAX = 10;
         const cut = !this.reasoning.full && wrapped.length > MAX;
         const lines = cut ? wrapped.slice(0, MAX) : wrapped;
         const label = " raciocínio ";
-        this.print(c.dim(`┌─${label}${"─".repeat(Math.max(0, w - 3 - label.length))}┐`));
+        this.print(c.dim(`──${label}${"─".repeat(Math.max(0, w - 2 - label.length))}`));
         for (const l of lines)
-            this.print(c.dim(`│ ${l}`));
+            this.print(c.dim(l));
         if (cut)
-            this.print(c.dim(`│ … +${wrapped.length - MAX} linhas (/reasoning full mostra tudo)`));
-        this.print(c.dim(`└${"─".repeat(w - 2)}┘`));
+            this.print(c.dim(`… +${wrapped.length - MAX} linhas (/reasoning full mostra tudo)`));
+        this.print(c.dim("─".repeat(w)));
     }
     info(msg) { this.textEnd(); this.print(c.muted(msg)); }
     warn(msg) { this.textEnd(); this.print(c.rgb(palette.warn)(msg)); }
@@ -389,6 +458,7 @@ class UI {
         const hitColour = hit === undefined ? c.muted : hit >= 70 ? c.ok : hit >= 40 ? c.warn : c.err;
         // [prioridade (maior = descarta primeiro), texto]
         const segs = [
+            ...(s.project ? [[0, c.light("📁 ") + c.bold(c.soft(s.project))]] : []),
             ...(s.mode ? [[0, s.mode]] : []),
             [0, c.light("⬢ ") + c.bold(c.soft(s.model))],
             [0, label("contexto") + c.muted(`${fmtTokens(s.ctxTokens)}/${fmtTokens(s.ctxWindow)}`) + ` [${bar}] ${colour(`${pct}%`)}`],
@@ -417,6 +487,7 @@ class UI {
             ["tokens", "total da sessão: ↑ enviados ao modelo (inclui cache) · ↓ gerados por ele."],
             ["custo", "gasto estimado da sessão em dólares."],
             ["tempo", "há quanto tempo a sessão está aberta · (ativo) soma do tempo gasto em todos os turnos."],
+            ["📁", "projeto (pasta) em que o Brito está trabalhando — também aparece no título da janela do terminal."],
             ["skill", "skill carregada (skill_load) no turno em andamento."],
         ].map(([k, v]) => `  ${c.soft(k.padEnd(9))} ${c.muted(v)}`);
     }

package/dist/util/images.js

@@ -2,10 +2,13 @@ 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. */
+const TYPES = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", pdf: "application/pdf" };
+const IMG_EXT = /\.(png|jpe?g|gif|webp|pdf)$/i;
+/** Limite da API por imagem (5 MB), por PDF (32 MB) e teto de anexos por mensagem. */
 export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+export const MAX_PDF_BYTES = 32 * 1024 * 1024;
+export const limitOf = (i) => (i.mediaType === "application/pdf" ? MAX_PDF_BYTES : MAX_IMAGE_BYTES);
+export const isPdf = (i) => i.mediaType === "application/pdf";
 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) {
@@ -67,9 +70,11 @@ export function droppedImages(text, root = process.cwd()) {
 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) };
+    return { ok: imgs.filter((i) => i.bytes <= limitOf(i)), tooBig: imgs.filter((i) => i.bytes > limitOf(i)) };
 }
-/** Bloco `image` da API da Anthropic, com o arquivo em base64. */
+/** Bloco `image` (ou `document`, para PDF) da API da Anthropic, com o arquivo em base64. */
 export function imageBlock(img) {
+    if (isPdf(img))
+        return { type: "document", source: { type: "base64", media_type: "application/pdf", data: fs.readFileSync(img.path).toString("base64") } };
     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.6.1",
+  "version": "0.6.4",
   "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": {