brito-cli 0.0.0-stage → 0.3.0

package/dist/tools/delegate.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { defineTool, allTools, execTool } from "./registry.js";
+import { Agent } from "../agent/loop.js";
+import { getAgent, listAgents } from "../agent/agents.js";
+import { buildSubagentPrompt } from "../agent/prompt.js";
+import { ui } from "../ui/ui.js";
+let seq = 0;
+/** Conjunto de tools de um agente; `delegate` nunca é repassada (sem recursão). */
+function toolSet(def) {
+    const names = def.tools === "all" ? allTools().map((t) => t.name) : def.tools;
+    // Sem recursão e sem aprender: criar/alterar skills é papel do agente principal.
+    return new Set(names.filter((n) => !["delegate", "skill_save", "skill_delete", "exit_plan"].includes(n)));
+}
+/** Agente somente-leitura: nenhuma tool dele escreve arquivos ou exige aprovação. */
+function isReadOnly(def) {
+    if (!def)
+        return false;
+    const set = toolSet(def);
+    return allTools().filter((t) => set.has(t.name)).every((t) => !t.dangerous && !t.mutates && t.name !== "remember" && t.name !== "graph_index");
+}
+defineTool({
+    name: "delegate",
+    get description() {
+        return ("Delega uma tarefa a um subagente com contexto ISOLADO (ele não vê esta conversa; ponha tudo que ele precisa em `task`). " +
+            "Só o resultado final volta para você, o que poupa seu contexto. Vários `delegate` de agentes somente-leitura no mesmo turno rodam em paralelo.\n" +
+            "Use `focus` com nomes de símbolos para já entregar ao subagente o subgrafo (quem chama / o que chama / notas) deles.\n" +
+            "Agentes disponíveis:\n" +
+            listAgents().map((a) => `- ${a.name}${isReadOnly(a) ? " (somente leitura)" : ""}: ${a.description}`).join("\n"));
+    },
+    schema: z.object({
+        agent: z.string().describe("nome do agente"),
+        task: z.string().min(10).describe("tarefa autocontida, com objetivo e formato de resposta esperado"),
+        focus: z.array(z.string()).max(5).default([]).describe("símbolos para pré-carregar o subgrafo"),
+    }),
+    concurrent: (i) => isReadOnly(getAgent(i.agent)),
+    async run({ agent, task, focus }, ctx) {
+        const def = getAgent(agent);
+        if (!def)
+            throw new Error(`Agente desconhecido: ${agent}. Disponíveis: ${listAgents().map((a) => a.name).join(", ")}`);
+        const label = `${def.name}#${++seq}`;
+        const log = (s) => ui.sub(label, s);
+        // O subgrafo pré-carregado é a vantagem do grafo: o filho já começa sabendo onde está.
+        let seed = "";
+        for (const sym of focus) {
+            const r = await execTool("graph_context", { symbol: sym }, ctx);
+            seed += `\n\n### graph_context(${sym})\n${r.text}`;
+        }
+        log(`iniciado: ${task.slice(0, 100).replace(/\s+/g, " ")}`);
+        const sub = new Agent(buildSubagentPrompt(ctx.root, def), ctx, {
+            model: def.model,
+            maxSteps: 25,
+            quiet: true,
+            tools: toolSet(def),
+            log,
+        });
+        const text = await sub.send(seed ? `${task}\n\n# Contexto do grafo (pré-carregado)${seed}` : task);
+        const tokens = Math.round((sub.usage.input + sub.usage.output) / 1000);
+        log(`concluído: ${sub.usage.steps} passos, ~${tokens}k tokens`);
+        return `[subagente ${label} · ${sub.usage.steps} passos · ~${tokens}k tokens]\n\n${text.slice(0, 12_000)}`;
+    },
+});

package/dist/tools/fs.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+import { defineTool } from "./registry.js";
+const abs = (root, p) => {
+    const full = path.resolve(root, p);
+    if (!full.startsWith(path.resolve(root)))
+        throw new Error("Caminho fora do projeto.");
+    return full;
+};
+defineTool({
+    name: "read_file",
+    concurrent: true,
+    description: "Lê um arquivo do projeto, com números de linha. Use offset/limit para arquivos grandes.",
+    schema: z.object({ path: z.string(), offset: z.number().int().min(1).optional(), limit: z.number().int().min(1).optional() }),
+    async run({ path: p, offset = 1, limit = 2000 }, { root }) {
+        const lines = fs.readFileSync(abs(root, p), "utf8").split("\n");
+        return lines.slice(offset - 1, offset - 1 + limit).map((l, i) => `${offset + i}\t${l}`).join("\n");
+    },
+});
+defineTool({
+    name: "write_file",
+    description: "Cria ou sobrescreve um arquivo.",
+    schema: z.object({ path: z.string(), content: z.string() }),
+    dangerous: true,
+    edit: true,
+    mutates: true,
+    describe: (i) => `escrever ${i.path} (${i.content.length} chars)`,
+    async run({ path: p, content }, { root }) {
+        const full = abs(root, p);
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, content);
+        return `Escrito ${p}`;
+    },
+});
+defineTool({
+    name: "edit_file",
+    description: "Substitui old_string por new_string em um arquivo. old_string deve ser único (ou use replace_all).",
+    schema: z.object({ path: z.string(), old_string: z.string(), new_string: z.string(), replace_all: z.boolean().optional() }),
+    dangerous: true,
+    edit: true,
+    mutates: true,
+    describe: (i) => `editar ${i.path}\n  - ${i.old_string.slice(0, 120).replace(/\n/g, "⏎")}\n  + ${i.new_string.slice(0, 120).replace(/\n/g, "⏎")}`,
+    async run({ path: p, old_string, new_string, replace_all }, { root }) {
+        const full = abs(root, p);
+        const src = fs.readFileSync(full, "utf8");
+        const count = src.split(old_string).length - 1;
+        if (count === 0)
+            throw new Error("old_string não encontrado.");
+        if (count > 1 && !replace_all)
+            throw new Error(`old_string aparece ${count}x; torne-o único ou use replace_all.`);
+        fs.writeFileSync(full, replace_all ? src.split(old_string).join(new_string) : src.replace(old_string, () => new_string));
+        return `Editado ${p} (${replace_all ? count : 1} substituição)`;
+    },
+});
+defineTool({
+    name: "glob",
+    concurrent: true,
+    description: "Lista arquivos por padrão glob (ex: src/**/*.ts).",
+    schema: z.object({ pattern: z.string() }),
+    async run({ pattern }, { root }) {
+        const r = await fg(pattern, { cwd: root, ignore: ["**/node_modules/**", "**/.git/**", "**/.brito/**", "**/dist/**"] });
+        return r.slice(0, 500).join("\n") || "(nenhum)";
+    },
+});
+defineTool({
+    name: "grep",
+    concurrent: true,
+    description: "Busca regex em arquivos do projeto. Retorna arquivo:linha:texto.",
+    schema: z.object({ pattern: z.string(), glob: z.string().optional() }),
+    async run({ pattern, glob = "**/*" }, { root }) {
+        const re = new RegExp(pattern);
+        const files = await fg(glob, { cwd: root, ignore: ["**/node_modules/**", "**/.git/**", "**/.brito/**", "**/dist/**"] });
+        const out = [];
+        for (const f of files) {
+            let txt;
+            try {
+                txt = fs.readFileSync(path.join(root, f), "utf8");
+            }
+            catch {
+                continue;
+            }
+            if (txt.includes("\0"))
+                continue;
+            txt.split("\n").forEach((l, i) => { if (re.test(l) && out.length < 300)
+                out.push(`${f}:${i + 1}:${l.slice(0, 200)}`); });
+        }
+        return out.join("\n") || "(sem resultados)";
+    },
+});

package/dist/tools/graph.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import crypto from "node:crypto";
+import { defineTool } from "./registry.js";
+import { indexProject } from "../graph/indexer.js";
+import { listSkills } from "../skills/store.js";
+const fmt = (rows, cols) => (rows.length ? rows.map((r) => cols.map((c) => r[c]).join("  ")).join("\n") : "(vazio)");
+defineTool({
+    name: "graph_index",
+    description: "Atualiza o grafo de código. É incremental (só reparseia arquivos alterados) e roda automaticamente após edições; use full=true só para reconstruir do zero.",
+    schema: z.object({ full: z.boolean().optional() }),
+    async run({ full }, { root, graph }) {
+        const s = await indexProject(root, graph, { full });
+        return `Grafo: ${s.files} arquivos, ${s.symbols} símbolos, ${s.calls} chamadas, ${s.imports} imports. (+${s.added} ~${s.changed} -${s.removed} =${s.unchanged})`;
+    },
+});
+defineTool({
+    name: "graph_search",
+    concurrent: true,
+    readsGraph: true,
+    description: "Busca símbolos (funções, classes, métodos…) por nome (substring, case-insensitive). PREFIRA isto a grep para localizar definições.",
+    schema: z.object({ name: z.string(), kind: z.string().optional() }),
+    async run({ name, kind }, { graph }) {
+        const rows = await graph.run(`MATCH (s:Symbol) WHERE lower(s.name) CONTAINS lower($n) ${kind ? "AND s.kind = $k" : ""} RETURN s.kind AS kind, s.name AS name, s.file AS file, s.startLine AS line, s.endLine AS endLine LIMIT 40`, kind ? { n: name, k: kind } : { n: name });
+        return fmt(rows, ["kind", "name", "file", "line", "endLine"]);
+    },
+});
+defineTool({
+    name: "graph_callers",
+    concurrent: true,
+    readsGraph: true,
+    description: "Quem chama o símbolo (transitivo até depth). Use antes de alterar uma função para medir impacto.",
+    schema: z.object({ symbol: z.string(), depth: z.number().int().min(1).max(5).default(2) }),
+    async run({ symbol, depth }, { graph }) {
+        const rows = await graph.run(`MATCH (c:Symbol)-[:CALLS*1..${depth}]->(t:Symbol) WHERE t.name = $n OR t.name ENDS WITH $dn RETURN DISTINCT c.name AS name, c.file AS file, c.startLine AS line LIMIT 60`, { n: symbol, dn: "." + symbol });
+        return fmt(rows, ["name", "file", "line"]);
+    },
+});
+defineTool({
+    name: "graph_callees",
+    concurrent: true,
+    readsGraph: true,
+    description: "O que o símbolo chama (transitivo até depth). Use para entender um fluxo sem ler tudo.",
+    schema: z.object({ symbol: z.string(), depth: z.number().int().min(1).max(5).default(2) }),
+    async run({ symbol, depth }, { graph }) {
+        const rows = await graph.run(`MATCH (s:Symbol)-[:CALLS*1..${depth}]->(c:Symbol) WHERE s.name = $n OR s.name ENDS WITH $dn RETURN DISTINCT c.name AS name, c.file AS file, c.startLine AS line LIMIT 60`, { n: symbol, dn: "." + symbol });
+        return fmt(rows, ["name", "file", "line"]);
+    },
+});
+defineTool({
+    name: "graph_impact",
+    concurrent: true,
+    readsGraph: true,
+    description: "Arquivos que dependem (importam, transitivamente) do arquivo dado. Responde: 'o que pode quebrar se eu mudar este arquivo?'",
+    schema: z.object({ file: z.string(), depth: z.number().int().min(1).max(6).default(3) }),
+    async run({ file, depth }, { graph }) {
+        const rows = await graph.run(`MATCH (a:File)-[:IMPORTS*1..${depth}]->(b:File {path:$f}) RETURN DISTINCT a.path AS path LIMIT 100`, { f: file });
+        return fmt(rows, ["path"]);
+    },
+});
+defineTool({
+    name: "graph_context",
+    concurrent: true,
+    readsGraph: true,
+    description: "Visão completa de um símbolo: onde está, quem chama, o que chama, e notas de memória relacionadas. Use ANTES de ler o arquivo inteiro.",
+    schema: z.object({ symbol: z.string() }),
+    async run({ symbol }, { graph, root }) {
+        const defs = await graph.run(`MATCH (s:Symbol) WHERE s.name = $n OR s.name ENDS WITH $dn RETURN s.id AS id, s.kind AS kind, s.file AS file, s.startLine AS a, s.endLine AS b LIMIT 5`, { n: symbol, dn: "." + symbol });
+        if (!defs.length)
+            return "Símbolo não encontrado. Tente graph_search.";
+        const parts = [];
+        for (const d of defs) {
+            const callers = await graph.run(`MATCH (c:Symbol)-[:CALLS]->(:Symbol {id:$id}) RETURN c.name AS n, c.file AS f, c.startLine AS l LIMIT 15`, { id: d.id });
+            const callees = await graph.run(`MATCH (:Symbol {id:$id})-[:CALLS]->(c:Symbol) RETURN c.name AS n, c.file AS f, c.startLine AS l LIMIT 15`, { id: d.id });
+            const notes = await graph.run(`MATCH (n:Note) WHERE list_contains(n.refs, $name) OR list_contains(n.refs, $file) RETURN n.kind AS k, n.text AS t LIMIT 5`, { name: symbol, file: d.file });
+            parts.push(`## ${d.kind} ${d.id} (linhas ${d.a}-${d.b})\n` +
+                `chamado por:\n${fmt(callers, ["n", "f", "l"])}\n` +
+                `chama:\n${fmt(callees, ["n", "f", "l"])}\n` +
+                `notas:\n${fmt(notes, ["k", "t"])}` +
+                (() => {
+                    const sk = listSkills(root).filter((s) => s.refs.includes(symbol) || s.refs.includes(d.file));
+                    return sk.length ? `\nskills relacionadas (skill_load):\n${sk.map((s) => `${s.name}: ${s.description}`).join("\n")}` : "";
+                })());
+        }
+        return parts.join("\n\n");
+    },
+});
+defineTool({
+    name: "graph_query",
+    concurrent: true,
+    description: "Cypher somente-leitura no grafo. Schema: (File{path,lang})-[:DEFINES]->(Symbol{id,name,kind,file,startLine,endLine}); (Symbol)-[:CALLS]->(Symbol); (File)-[:IMPORTS]->(File); (Note{id,kind,text,refs[],ts}).",
+    schema: z.object({ cypher: z.string() }),
+    async run({ cypher }, { graph }) {
+        if (/\b(CREATE|DELETE|SET|MERGE|DROP|ALTER|COPY|REMOVE)\b/i.test(cypher))
+            throw new Error("Apenas consultas de leitura.");
+        const rows = await graph.run(cypher);
+        return JSON.stringify(rows.slice(0, 100), null, 1);
+    },
+});
+defineTool({
+    name: "remember",
+    description: "Grava uma nota durável no grafo de memória (decisão, bug, convenção, aprendizado), ligada a arquivos/símbolos em refs. Será recuperada em graph_context e recall.",
+    schema: z.object({ kind: z.enum(["decision", "bug", "convention", "learning"]), text: z.string(), refs: z.array(z.string()).default([]) }),
+    async run({ kind, text, refs }, { graph }) {
+        await graph.run("CREATE (:Note {id:$id, kind:$k, text:$t, refs:$r, ts:$ts})", { id: crypto.randomUUID(), k: kind, t: text, r: refs, ts: Date.now() });
+        return "Nota salva.";
+    },
+});
+defineTool({
+    name: "recall",
+    concurrent: true,
+    description: "Busca notas de memória por texto ou por referência (arquivo/símbolo).",
+    schema: z.object({ query: z.string() }),
+    async run({ query }, { graph }) {
+        const rows = await graph.run("MATCH (n:Note) WHERE lower(n.text) CONTAINS lower($q) OR list_contains(n.refs, $q) RETURN n.kind AS kind, n.text AS text, n.refs AS refs ORDER BY n.ts DESC LIMIT 20", { q: query });
+        return rows.length ? rows.map((r) => `[${r.kind}] ${r.text}  (refs: ${r.refs.join(", ")})`).join("\n") : "(nenhuma nota)";
+    },
+});

package/dist/tools/plan.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { defineTool } from "./registry.js";
+import { perms } from "../permissions.js";
+defineTool({
+    name: "exit_plan",
+    description: "Só no modo plano: apresenta o plano final ao usuário e pede aprovação para sair do modo plano e executar.",
+    schema: z.object({ plan: z.string().min(10).describe("plano completo em markdown: arquivos, mudanças, riscos, verificação") }),
+    async run({ plan }, ctx) {
+        if (perms.mode !== "plan")
+            return "Você não está no modo plano; siga com a tarefa.";
+        const ok = await ctx.ask(`plano proposto — aprovar e sair do modo plano?\n${plan}`, { force: true });
+        if (!ok)
+            return "Plano não aprovado. Pergunte o que o usuário quer ajustar e revise o plano.";
+        perms.mode = "manual";
+        return "Plano aprovado. Modo manual ativo: execute o plano (edições e comandos pedem aprovação).";
+    },
+});

package/dist/tools/registry.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { perms } from "../permissions.js";
+const registry = new Map();
+export function defineTool(t) {
+    registry.set(t.name, t);
+    return t;
+}
+export const allTools = () => [...registry.values()];
+export function toApiTools(allow) {
+    return allTools().filter((t) => !allow || allow.has(t.name)).map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: z.toJSONSchema(t.schema),
+    }));
+}
+export function isConcurrent(name, input) {
+    const t = registry.get(name);
+    if (!t || t.dangerous || t.mutates || !t.concurrent)
+        return false;
+    if (typeof t.concurrent === "boolean")
+        return t.concurrent;
+    const parsed = t.schema.safeParse(input);
+    return parsed.success && t.concurrent(parsed.data);
+}
+export async function execTool(name, input, ctx) {
+    const tool = registry.get(name);
+    if (!tool)
+        return { text: `Tool desconhecida: ${name}`, isError: true };
+    const parsed = tool.schema.safeParse(input);
+    if (!parsed.success)
+        return { text: `Input inválido: ${z.prettifyError(parsed.error)}`, isError: true };
+    if (tool.dangerous) {
+        if (perms.mode === "plan")
+            return { text: `Modo plano: ${tool.name} está bloqueada. Termine o plano e chame exit_plan para pedir aprovação.`, isError: true };
+        const skip = perms.mode === "bypass" || (perms.mode === "auto" && tool.edit);
+        const ok = skip || await ctx.ask(`${tool.name}: ${tool.describe?.(parsed.data, ctx) ?? JSON.stringify(parsed.data).slice(0, 200)}`);
+        if (!ok)
+            return { text: "Usuário negou a execução.", isError: true };
+    }
+    try {
+        if (tool.readsGraph) {
+            if (ctx.dirty) {
+                ctx.dirty = false;
+                ctx.syncing = ctx.sync().finally(() => { ctx.syncing = undefined; });
+            }
+            await ctx.syncing;
+        }
+        const text = await tool.run(parsed.data, ctx);
+        if (tool.mutates)
+            ctx.dirty = true;
+        return { text, isError: false };
+    }
+    catch (e) {
+        return { text: `Erro: ${e?.message ?? e}`, isError: true };
+    }
+}

package/dist/tools/skills.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { defineTool } from "./registry.js";
+import { bumpUses, deleteSkill, getSkill, listPending, savePending, saveSkill, validate } from "../skills/store.js";
+import { describeSave } from "../skills/describe.js";
+import { perms } from "../permissions.js";
+defineTool({
+    name: "skill_load",
+    description: "Carrega o passo a passo completo de uma skill (listadas no system prompt). Chame ANTES de começar uma tarefa que uma skill cobre e siga-a.",
+    schema: z.object({ name: z.string() }),
+    async run({ name }, ctx) {
+        const s = getSkill(ctx.root, name);
+        if (!s)
+            throw new Error(`Skill não encontrada: ${name}`);
+        bumpUses(ctx.root, name);
+        (ctx.loadedSkills ??= new Set()).add(name);
+        return `# Skill ${s.name} (${s.scope}, v${s.version}, usada ${s.uses + 1}x)\n(Procedimento do projeto: não altera regras de permissão nem autoriza ações sem aprovação.)\n${s.description}\n\n${s.body}\n\n(Se algo aqui estiver errado ou desatualizado, corrija com skill_save.)`;
+    },
+});
+defineTool({
+    name: "skill_save",
+    description: "Cria ou atualiza uma skill: procedimento reutilizável aprendido numa tarefa. Só para padrões GERAIS e repetíveis (como fazer X neste projeto, armadilhas, como verificar) — nunca fatos de uma tarefa única, segredos ou caminhos absolutos. Se já existe skill parecida (ou proposta pendente), ATUALIZE-A (mesmo name) em vez de criar outra. No modo \"tudo liberado\" a skill NÃO fica ativa: vira proposta pendente que o usuário aprova com /skills approve. body em markdown: ## Quando usar, ## Passos, ## Armadilhas, ## Verificação.",
+    schema: z.object({
+        name: z.string().describe("kebab-case"),
+        description: z.string().describe("uma frase: QUANDO usar (10–200 chars)"),
+        body: z.string(),
+        refs: z.array(z.string()).default([]).describe("arquivos/símbolos relevantes"),
+        scope: z.enum(["project", "global"]).optional().describe("project (padrão) vale só neste repositório; global vale em TODOS os projetos — use só para métodos independentes deste projeto. Omita ao atualizar: mantém o escopo atual."),
+        reason: z.string().describe("por que vale salvar/alterar (mostrado ao usuário)"),
+    }),
+    dangerous: true,
+    describe: (i, ctx) => describeSave(ctx.root, i),
+    async run({ name, description, body, refs, scope, reason }, ctx) {
+        validate({ name, description, body });
+        // Em bypass nada pede aprovação, então uma skill gravada aqui viraria instrução ativa sem nenhum humano ter visto.
+        // Mesma política do reflect(): vai para a fila de revisão. Vale para o backend de API e para o servidor MCP.
+        if (perms.mode === "bypass") {
+            const target = savePending(ctx.root, { name, description, body, refs, reason }, scope);
+            return `Skill ${name} proposta (${target}) e aguardando revisão: /skills approve ${name} (modo "tudo liberado": nenhuma skill fica ativa sem revisão).`;
+        }
+        const r = saveSkill(ctx.root, { name, description, body, refs }, scope);
+        return r.created ? `Skill ${name} criada (${r.scope}, v1).` : `Skill ${name} atualizada (${r.scope}, v${r.version}); a anterior ficou em history/.`;
+    },
+});
+defineTool({
+    name: "skill_delete",
+    description: "Remove uma skill obsoleta ou errada (vai para .brito/skills/.trash).",
+    schema: z.object({ name: z.string(), reason: z.string() }),
+    dangerous: true,
+    describe: (i) => `REMOVER skill ${i.name} — ${i.reason}`,
+    async run({ name }, ctx) {
+        if (!deleteSkill(ctx.root, name)) {
+            if (listPending(ctx.root).some((p) => p.name === name))
+                throw new Error(`"${name}" é uma proposta pendente, não uma skill ativa: o usuário a descarta com /skills reject ${name}.`);
+            throw new Error(`Skill não encontrada: ${name}`);
+        }
+        return `Skill ${name} removida.`;
+    },
+});

package/dist/ui/banner.js

@@ -0,0 +1,106 @@
+import fs from "node:fs";
+import stringWidth from "string-width";
+import { c, cols, mix, palette, stripAnsi, truncAnsi } from "./theme.js";
+const LOGO = [
+    "████  ████  █████ █████  ███ ",
+    "█   █ █   █   █     █   █   █",
+    "████  ████    █     █   █   █",
+    "█   █ █  █    █     █   █   █",
+    "████  █   █ █████   █    ███ ",
+];
+/** Arte do lado esquerdo: um pequeno grafo, a identidade do Brito. */
+const HERO = [
+    "   ◉───────◉───────◉   ",
+    "   │ \\   / │ \\   / │   ",
+    "   │  ◉────◉───◉  │   ",
+    "   │ /   \\ │ /   \\ │   ",
+    "   ◉───────◉───────◉   ",
+];
+const GROUPS = [
+    ["arquivos", (n) => ["read_file", "write_file", "edit_file", "glob", "grep"].includes(n)],
+    ["shell", (n) => n === "bash"],
+    ["grafo", (n) => n.startsWith("graph_")],
+    ["memória", (n) => n === "remember" || n === "recall"],
+    ["agentes", (n) => n === "delegate"],
+    ["skills", (n) => n.startsWith("skill_")],
+];
+const pad = (s, w) => s + " ".repeat(Math.max(0, w - stringWidth(stripAnsi(s))));
+const version = () => {
+    try {
+        return JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+    }
+    catch {
+        return "0.0.0";
+    }
+};
+const fmtK = (n) => (n >= 1000 ? `${Math.round(n / 1000)}K` : String(n));
+function listLine(label, items, width) {
+    const head = c.muted(`${label}: `);
+    const room = Math.max(10, width - label.length - 2);
+    let used = 0;
+    const shown = [];
+    for (const it of items) {
+        const add = it.length + (shown.length ? 2 : 0);
+        if (used + add > room - 5)
+            break;
+        shown.push(it);
+        used += add;
+    }
+    const rest = items.length - shown.length;
+    return head + c.soft(shown.join(", ")) + (rest > 0 ? c.dim(`  +${rest}`) : "");
+}
+export function renderBanner(i) {
+    const total = Math.min(cols(), 110);
+    const wide = total >= 95;
+    const inner = total - 4;
+    const home = process.env.HOME ?? "\0";
+    const context = [
+        `${c.soft(i.model)} ${c.dim("·")} ${c.muted(`${fmtK(i.ctxWindow)} ctx`)}`,
+        c.muted(i.dir.replace(home, "~")),
+        c.dim(`sessão ${i.session}`),
+    ];
+    const leftW = wide ? Math.max(LOGO[0].length, HERO[0].length) + 2 : inner;
+    const rightW = wide ? inner - leftW - 3 : inner;
+    const left = [];
+    if (wide) {
+        LOGO.forEach((l, k) => left.push(c.rgb(mix(palette.accent, palette.soft, k / (LOGO.length - 1)))(l)));
+        left.push("");
+        HERO.forEach((l) => left.push(l.replace(/[◉]/g, (m) => c.light(m)).replace(/[─│\\/]/g, (m) => c.accent(m))));
+        left.push("");
+    }
+    left.push(...context);
+    const right = [c.bold(c.light("Ferramentas disponíveis"))];
+    for (const [label, test] of GROUPS) {
+        const names = i.tools.filter(test);
+        if (names.length)
+            right.push(listLine(label, names, rightW));
+    }
+    right.push("", c.bold(c.light("Subagentes")), c.soft(i.agents.join(", ") || "—"));
+    right.push("", c.bold(c.light("Skills")));
+    if (i.skills.length) {
+        const project = i.skills.filter((s) => s.scope === "project").map((s) => s.name);
+        const global = i.skills.filter((s) => s.scope === "global").map((s) => s.name);
+        if (project.length)
+            right.push(listLine("projeto", project, rightW));
+        if (global.length)
+            right.push(listLine("global", global, rightW));
+    }
+    else
+        right.push(c.dim("nenhuma ainda · nascem sozinhas após tarefas complexas"));
+    right.push("", c.dim(`${i.tools.length} tools · ${i.skills.length} ${i.skills.length === 1 ? "skill" : "skills"} · ${i.symbols} símbolos · ${i.notes} notas · /help`));
+    const body = [];
+    if (wide) {
+        const n = Math.max(left.length, right.length);
+        for (let k = 0; k < n; k++)
+            body.push(pad(left[k] ?? "", leftW) + "   " + (right[k] ?? ""));
+    }
+    else
+        body.push(...left, "", ...right);
+    const title = ` ${i.name} v${version()} `;
+    const top = c.accent("╭─") + c.bold(c.light(title)) + c.accent("─".repeat(Math.max(1, total - title.length - 3)) + "╮");
+    const row = (raw) => {
+        const txt = stringWidth(stripAnsi(raw)) > inner ? truncAnsi(raw, inner) : raw;
+        return c.accent("│ ") + pad(txt, inner) + c.accent(" │");
+    };
+    return [top, ...body.map(row), c.accent("╰" + "─".repeat(total - 2) + "╯")].join("\n");
+}