brito-cli 0.7.5 → 0.9.0

package/dist/tools/delegate.js

@@ -7,11 +7,38 @@ import { subagentModel } from "../engine.js";
 import { initialModel } from "../model.js";
 import { ui } from "../ui/ui.js";
 let seq = 0;
-/** Conjunto de tools de um agente; `delegate` nunca é repassada (sem recursão). */
+/** Conjunto de tools de um agente; `delegate` e `implement` nunca são repassadas (sem recursão), nem `spec_save` (a spec é do principal). */
 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)));
+    // A lista de tarefas é do usuário com o agente principal: um subagente não a reescreve.
+    return new Set(names.filter((n) => !["delegate", "implement", "spec_save", "skill_save", "skill_delete", "exit_plan", "todo_write"].includes(n)));
+}
+/**
+ * Roda um subagente em contexto isolado e devolve o texto final com o uso. O subgrafo dos símbolos de `focus` vai junto
+ * da tarefa: é a vantagem do grafo, o filho já começa sabendo onde está.
+ */
+export async function runSubagent(def, task, focus, ctx, opts = {}) {
+    const label = `${def.name}#${++seq}`;
+    const log = opts.log ? (s) => opts.log(`[${label}] ${s}`) : (s) => ui.sub(label, s);
+    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: subagentModel(def, ctx.model?.() ?? initialModel(), process.env),
+        maxSteps: opts.maxSteps ?? 25,
+        quiet: true,
+        tools: toolSet(def),
+        log,
+        sink: opts.sink,
+    });
+    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 { label, text, steps: sub.usage.steps, tokens, model: sub.model };
 }
 /** Agente somente-leitura: nenhuma tool dele escreve arquivos ou exige aprovação. */
 function isReadOnly(def) {
@@ -39,25 +66,7 @@ defineTool({
         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: subagentModel(def, ctx.model?.() ?? initialModel(), process.env),
-            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)}`;
+        const r = await runSubagent(def, task, focus, ctx);
+        return `[subagente ${r.label} · ${r.steps} passos · ~${r.tokens}k tokens]\n\n${r.text.slice(0, 12_000)}`;
     },
 });

package/dist/tools/digest.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import fs from "node:fs";
+import path from "node:path";
+import { defineTool } from "./registry.js";
+import { digest } from "../local/digest.js";
+import { slmDisabled, slmStatus } from "../local/slm.js";
+defineTool({
+    name: "digest",
+    description: "USE ESTA TOOL PRIMEIRO ao pesquisar um assunto dentro de um texto LONGO (livro, PDF extraído, ata; arquivo acima de ~100 KB), em vez de Grep + vários Read: um modelo local pequeno percorre o arquivo e devolve um plano em markdown com só TRECHOS relevantes ao objetivo, com página, conferidos no texto-fonte por código. A seleção pode ser incompleta: use as páginas indicadas para aprofundar com Read e peça mais blocos (max_chunks) se faltar algo. Exige `brito slm pull`. Não use em arquivos curtos.",
+    schema: z.object({
+        path: z.string().describe("arquivo de texto dentro do projeto"),
+        objective: z.string().describe("o que você precisa achar/montar (ex.: 'estrutura em cinco livros do saltério')"),
+        max_chunks: z.number().int().min(1).max(30).optional().describe("blocos a analisar (padrão 8; cada um leva alguns segundos)"),
+    }),
+    async run({ path: p, objective, max_chunks }, ctx) {
+        if (slmDisabled())
+            throw new Error("SLM desligado (BRITO_SLM=off): leia o arquivo com read_file.");
+        const st = await slmStatus();
+        if (!st.ready)
+            throw new Error(`SLM local indisponível${st.lib ? " (modelo não baixado: rode `brito slm pull`)" : " (instale node-llama-cpp)"}: leia o arquivo com read_file.`);
+        const full = path.resolve(ctx.root, p);
+        const rel = path.relative(path.resolve(ctx.root), full);
+        if (rel === ".." || rel.startsWith(".." + path.sep) || path.isAbsolute(rel))
+            throw new Error("Caminho fora do projeto.");
+        const text = fs.readFileSync(full, "utf8");
+        const r = await digest({ text, source: rel.split(path.sep).join("/"), objective, maxChunks: max_chunks });
+        return r.markdown;
+    },
+});

package/dist/tools/fs.js

@@ -12,41 +12,83 @@ const abs = (root, p) => {
         throw new Error("Caminho fora do projeto.");
     return full;
 };
+/** Estado atual do arquivo, ou `undefined` se ele não existe. */
+const stampOf = (full) => {
+    try {
+        const s = fs.statSync(full);
+        return { mtimeMs: s.mtimeMs, size: s.size };
+    }
+    catch {
+        return undefined;
+    }
+};
+const remember = (ctx, full) => {
+    const s = stampOf(full);
+    if (s)
+        (ctx.readFiles ??= new Map()).set(full, s);
+};
+/**
+ * Editar exige ter lido o arquivo nesta sessão e que ele não tenha mudado desde então (por bash, pelo usuário ou por
+ * outro processo). Sem isso o modelo edita de memória e pode desfazer o que mudou. Arquivo novo não precisa de leitura.
+ */
+function staleReason(ctx, p) {
+    let full;
+    try {
+        full = abs(ctx.root, p);
+    }
+    catch {
+        return undefined;
+    } // o run devolve o erro de caminho
+    const now = stampOf(full);
+    if (!now)
+        return undefined;
+    const seen = ctx.readFiles?.get(full);
+    if (!seen)
+        return `${p} ainda não foi lido nesta sessão. Leia com read_file antes de alterar.`;
+    if (seen.mtimeMs !== now.mtimeMs || seen.size !== now.size)
+        return `${p} mudou desde a última leitura (por um comando, pelo usuário ou por outro processo). Leia de novo com read_file antes de alterar.`;
+    return undefined;
+}
 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");
+    async run({ path: p, offset = 1, limit = 2000 }, ctx) {
+        const full = abs(ctx.root, p);
+        const lines = fs.readFileSync(full, "utf8").split("\n");
+        remember(ctx, full);
         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.",
+    description: "Cria ou sobrescreve um arquivo. Para sobrescrever um arquivo existente, leia-o antes com read_file.",
     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);
+    precheck: (i, ctx) => staleReason(ctx, i.path),
+    async run({ path: p, content }, ctx) {
+        const full = abs(ctx.root, p);
         fs.mkdirSync(path.dirname(full), { recursive: true });
         fs.writeFileSync(full, content);
+        remember(ctx, full); // o modelo sabe o conteúdo que acabou de escrever
         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).",
+    description: "Substitui old_string por new_string em um arquivo. old_string deve ser único (ou use replace_all). Leia o arquivo com read_file antes.",
     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);
+    precheck: (i, ctx) => staleReason(ctx, i.path),
+    async run({ path: p, old_string, new_string, replace_all }, ctx) {
+        const full = abs(ctx.root, p);
         const src = fs.readFileSync(full, "utf8");
         const count = src.split(old_string).length - 1;
         if (count === 0)
@@ -54,6 +96,7 @@ defineTool({
         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));
+        remember(ctx, full);
         return `Editado ${p} (${replace_all ? count : 1} substituição)`;
     },
 });

package/dist/tools/implement.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { execFile } from "node:child_process";
+import { defineTool, execTool } from "./registry.js";
+import { runSubagent } from "./delegate.js";
+import { IMPLEMENTER, implStatus, orch } from "../orchestrator.js";
+import { initialModel } from "../model.js";
+/** Saída de um git só de leitura; fora de um repositório (ou sem git), `null`. */
+function git(root, args) {
+    return new Promise((resolve) => {
+        execFile("git", args, { cwd: root, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => resolve(err ? null : stdout.trim()));
+    });
+}
+/** Progresso e avisos do implementador; o servidor MCP troca o destino (o stdout de lá é o protocolo). */
+export const implementIo = {};
+defineTool({
+    name: "implement",
+    description: "Só no modo orquestrador: manda UMA task ao modelo implementador (contexto ISOLADO: ele não vê esta conversa). " +
+        "Ele edita os arquivos e roda a verificação; a tool devolve o relato dele, o git status/diff e a saída do `verify`, " +
+        "rodado aqui, fora do controle dele. Tasks rodam uma por vez.",
+    schema: z.object({
+        task: z.string().min(10).describe("task autocontida: objetivo, contratos que não podem mudar e critério de pronto"),
+        files: z.array(z.string()).max(20).default([]).describe("arquivos que a task deve criar ou alterar"),
+        verify: z.string().optional().describe("comando que prova a task (ex.: npm test -- foo); roda depois do implementador"),
+        focus: z.array(z.string()).max(5).default([]).describe("símbolos para pré-carregar o subgrafo"),
+    }),
+    mutates: true,
+    async run({ task, files, verify, focus }, ctx) {
+        if (!orch.on)
+            return "O modo orquestrador está desligado; implemente você mesmo.";
+        const status = implStatus(ctx.model?.() ?? initialModel(), orch.model, process.env);
+        if (!status.ready)
+            throw new Error(`implementador (${orch.model}) indisponível: ${status.reason}`);
+        let full = task;
+        if (files.length)
+            full += `\n\n# Arquivos\n${files.map((f) => `- ${f}`).join("\n")}`;
+        if (verify)
+            full += `\n\n# Como verificar\n${verify}`;
+        const r = await runSubagent(IMPLEMENTER, full, focus, ctx, { maxSteps: 40, ...implementIo });
+        // Fatos que não dependem do relato do implementador: o que mudou no disco e o que a verificação diz.
+        const st = await git(ctx.root, ["status", "--short"]);
+        const diff = st === null ? null : await git(ctx.root, ["diff", "--stat"]);
+        let out = `[implementador ${r.label} · ${status.label} · ${r.steps} passos · ~${r.tokens}k tokens]\n\n${r.text.slice(0, 8_000)}`;
+        out += st === null ? "\n\n# git\n(não é um repositório git: confira os arquivos lendo-os)" : `\n\n# git status --short\n${st || "(nada mudou)"}\n\n# git diff --stat\n${diff || "(sem diff em arquivos rastreados)"}`;
+        if (verify) {
+            const v = await execTool("bash", { command: verify }, ctx);
+            out += `\n\n# verificação: ${verify}\n${v.isError ? `[não rodou] ${v.text}` : v.text.slice(-6_000)}`;
+        }
+        return out;
+    },
+});

package/dist/tools/registry.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { perms } from "../permissions.js";
+import { decide, loadRules } from "../rules.js";
 const registry = new Map();
 export function defineTool(t) {
     registry.set(t.name, t);
@@ -29,10 +30,18 @@ export async function execTool(name, input, ctx) {
     const parsed = tool.schema.safeParse(input);
     if (!parsed.success)
         return { text: `Input inválido: ${z.prettifyError(parsed.error)}`, isError: true };
+    // `deny` vale em qualquer modo, inclusive "tudo liberado"; `allow` só dispensa a pergunta.
+    const decision = decide(loadRules(ctx.root), tool.name, parsed.data, ctx.root);
+    if (decision === "deny")
+        return { text: `${tool.name} bloqueada por uma regra deny das permissões (.brito/settings.json). Não tente contornar; peça ao usuário se precisar.`, isError: true };
+    // Antes da aprovação: não faz sentido o usuário aprovar uma chamada que vai falhar.
+    const problem = tool.precheck?.(parsed.data, ctx);
+    if (problem)
+        return { text: problem, 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 skip = perms.mode === "bypass" || (perms.mode === "auto" && tool.edit) || decision === "allow";
         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 };

package/dist/tools/skills.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineTool } from "./registry.js";
-import { bumpUses, deleteSkill, getSkill, listPending, saveSkill, validate } from "../skills/store.js";
+import { bumpUses, deleteSkill, getSkill, listPending, saveSkill, suggestSkills, validate } from "../skills/store.js";
 import { saveAuto } from "../skills/trial.js";
 import { describeSave } from "../skills/describe.js";
 import { perms } from "../permissions.js";
@@ -10,11 +10,13 @@ defineTool({
     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}`);
+        if (!s) {
+            const sug = suggestSkills(ctx.root, name.replace(/[-_]/g, " "));
+            throw new Error(`Skill não encontrada: ${name}.${sug.length ? ` Parecidas: ${sug.map((x) => `${x.skill.name} (${x.skill.description})`).join("; ")}` : ""}`);
+        }
         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.)`;
+        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}${s.model ? `\n(Modelo recomendado: ${s.model}.)` : ""}${s.lastLoss ? `\n(Atenção: o último uso com tropeço falhou em: ${s.lastLoss})` : ""}\n\n${s.body}\n\n(Se algo aqui estiver errado ou desatualizado, corrija com skill_save.)`;
     },
 });
 defineTool({
@@ -27,15 +29,17 @@ defineTool({
         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)"),
+        invoke: z.enum(["auto", "manual"]).optional().describe("manual = só roda quando o usuário digita /nome (fica fora do índice)"),
+        model: z.string().optional().describe("modelo recomendado para seguir a skill (dica)"),
     }),
     dangerous: true,
     describe: (i, ctx) => describeSave(ctx.root, i),
-    async run({ name, description, body, refs, scope, reason }, ctx) {
+    async run({ name, description, body, refs, scope, reason, invoke, model }, ctx) {
         validate({ name, description, body });
         // Em bypass nada pede aprovação: usa a mesma política segura da reflexão autônoma (em teste; o arriscado vai para a fila de revisão).
         if (perms.mode === "bypass")
             return saveAuto(ctx.root, { name, description, body, refs, reason }).msg;
-        const r = saveSkill(ctx.root, { name, description, body, refs }, scope);
+        const r = saveSkill(ctx.root, { name, description, body, refs, invoke, model }, scope);
         return r.created ? `Skill ${name} criada (${r.scope}, v1).` : `Skill ${name} atualizada (${r.scope}, v${r.version}); a anterior ficou em history/.`;
     },
 });

package/dist/tools/spec.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import fs from "node:fs";
+import path from "node:path";
+import { defineTool } from "./registry.js";
+import { orch } from "../orchestrator.js";
+/** Pasta, na raiz do projeto, onde o orquestrador grava a spec e as tasks de cada feature para o usuário avaliar. */
+export const SPEC_DIR = "spec";
+export const SPEC_FILES = ["spec.md", "tasks.md"];
+/**
+ * Única escrita do principal no modo orquestrador: só `spec/<feature>/spec.md` e `tasks.md`, nada de código. O caminho
+ * é montado aqui (slug + nome fixo), então não há como escapar da pasta.
+ */
+defineTool({
+    name: "spec_save",
+    description: "Só no modo orquestrador: grava (cria ou sobrescreve) a spec ou a lista de tasks de uma feature em " +
+        "spec/<feature>/spec.md ou spec/<feature>/tasks.md, para o usuário avaliar e para o implementador ler. " +
+        "Mande o arquivo inteiro em `content`.",
+    schema: z.object({
+        feature: z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "use um slug: minúsculas, números e hífens (ex.: login-sso)").describe("slug da feature: nome da pasta em spec/"),
+        file: z.enum(SPEC_FILES).describe("spec.md (o quê e por quê) ou tasks.md (lista numerada de tasks)"),
+        content: z.string().min(10).describe("conteúdo completo do arquivo em markdown"),
+    }),
+    dangerous: true,
+    edit: true,
+    mutates: true,
+    describe: (i) => `gravar ${SPEC_DIR}/${i.feature}/${i.file} (${i.content.length} chars)`,
+    async run({ feature, file, content }, { root }) {
+        if (!orch.on)
+            return "O modo orquestrador está desligado; spec_save só existe nele.";
+        const rel = `${SPEC_DIR}/${feature}/${file}`;
+        const full = path.join(root, SPEC_DIR, feature, file);
+        const data = content.endsWith("\n") ? content : content + "\n";
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        // Cria com "wx" (falha se já existir) em vez de existsSync + write: checagem e escrita numa operação só, sem TOCTOU.
+        let existed = false;
+        try {
+            fs.writeFileSync(full, data, { flag: "wx" });
+        }
+        catch (e) {
+            if (e.code !== "EEXIST")
+                throw e;
+            existed = true;
+            fs.writeFileSync(full, data);
+        }
+        return `${existed ? "Atualizado" : "Criado"} ${rel}`;
+    },
+});

package/dist/tools/todo.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { defineTool } from "./registry.js";
+import { renderTodos } from "../util/todos.js";
+defineTool({
+    name: "todo_write",
+    description: "Mantém a lista de tarefas visível para o usuário. Use em tarefas com 3+ passos ou quando o usuário pede várias coisas: " +
+        "crie a lista no início, marque um item in_progress antes de começar e completed logo ao terminar (não acumule). " +
+        "Mande sempre a lista inteira; ela substitui a anterior. Não use para tarefas de um passo.",
+    schema: z.object({
+        todos: z.array(z.object({
+            content: z.string().min(1).describe("o que fazer, no imperativo"),
+            status: z.enum(["pending", "in_progress", "completed"]),
+        })).max(50),
+    }),
+    async run({ todos }, ctx) {
+        ctx.todos = todos;
+        const done = todos.filter((t) => t.status === "completed").length;
+        const doing = todos.filter((t) => t.status === "in_progress").length;
+        const note = doing > 1 ? "\n(aviso: mais de um item in_progress; mantenha um por vez)" : "";
+        return `${renderTodos(todos)}\n\n${done}/${todos.length} concluídas${note}`;
+    },
+});

package/dist/ui/ui.js

@@ -1,6 +1,7 @@
 import { BOLD, CODE, ITALIC, OFF, c, cols, palette, useColor } from "./theme.js";
 import { renderBanner } from "./banner.js";
 import { renderTable } from "./table.js";
+import { todoLine } from "../util/todos.js";
 import stringWidth from "string-width";
 export const NAME = "Brito";
 const isTTY = !!process.stdout.isTTY;
@@ -405,6 +406,15 @@ class UI {
         this.running.delete(id);
         this.textEnd();
         this.print(this.toolLine(r.name, r.input, Date.now() - r.t0, isError));
+        if (r.name === "todo_write" && !isError)
+            this.printTodos(r.input?.todos ?? []);
+    }
+    /** A lista do `todo_write`, logo abaixo da linha da tool: em andamento destacado, concluído apagado. */
+    printTodos(todos) {
+        for (const t of todos) {
+            const line = todoLine(t);
+            this.print(`  ${t.status === "in_progress" ? c.bold(c.soft(line)) : t.status === "completed" ? c.dim(line) : c.muted(line)}`);
+        }
     }
     /** Só o prefixo + emoji + nome, sem argumento nem tempo. */
     toolLabel(name) { return `${c.accent("┊")} ${emojiOf(name)} ${c.soft(name)}`; }
@@ -461,6 +471,7 @@ class UI {
             ...(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))],
+            ...(s.engine ? [[s.engine.fallback ? 0 : 1, s.engine.fallback ? c.bold(c.rgb(palette.warn)(s.engine.text)) : c.muted(s.engine.text)]] : []),
             [0, label("contexto") + c.muted(`${fmtTokens(s.ctxTokens)}/${fmtTokens(s.ctxWindow)}`) + ` [${bar}] ${colour(`${pct}%`)}`],
             ...(hit !== undefined ? [[2, label("cache") + hitColour(`◎ ${Math.round(hit)}%`)]] : []),
             [3, label("tokens") + c.muted(`↑${fmtTokens(s.input)} ↓${fmtTokens(s.output)}`)],
@@ -486,6 +497,7 @@ class UI {
             ["cache", "% do prompt reaproveitado do cache (◎). Alto (verde) = respostas mais rápidas e baratas. Some enquanto não há dado."],
             ["tokens", "total da sessão: ↑ enviados ao modelo (inclui cache) · ↓ gerados por ele."],
             ["custo", "gasto estimado da sessão em dólares."],
+            ["motor", "de onde vêm as respostas: ☁ nuvem (Claude), 🌐 endpoint (ex.: qwen) ou 💻 local (SLM). ⚠ FALLBACK = troca automática ativa, com a hora em que o Claude é tentado de novo."],
             ["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."],

package/dist/util/todos.js

@@ -0,0 +1,4 @@
+export const TODO_MARK = { pending: "☐", in_progress: "◐", completed: "☑" };
+export const todoLine = (t) => `${TODO_MARK[t.status]} ${t.content}`;
+/** Lista em texto puro (resultado da tool, app de desktop); o terminal colore a mesma coisa. */
+export const renderTodos = (todos) => (todos.length ? todos.map(todoLine).join("\n") : "(lista vazia)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.7.5",
+  "version": "0.9.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": {
@@ -17,12 +17,13 @@
     "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"
+    "desktop:dmg": "npm run build && npm run bundle && npm --prefix desktop install --no-audit --no-fund && node desktop/package.mjs --dmg",
+    "release": "node scripts/release.mjs"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.137.0",
-    "@ladybugdb/core": "0.21.2",
-    "@modelcontextprotocol/sdk": "^1.32.0",
+    "@anthropic-ai/sdk": "^1.5.0",
+    "@ladybugdb/core": "^0.22.3",
+    "@modelcontextprotocol/sdk": "^1.32.2",
     "commander": "^14.0.3",
     "string-width": "^8.3.0",
     "tinyglobby": "^0.2.17",
@@ -31,7 +32,7 @@
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@types/node": "latest",
+    "@types/node": "^26.6.6",
     "esbuild": "^0.28.2",
     "tsx": "latest",
     "typescript": "latest"
@@ -73,5 +74,8 @@
   ],
   "overrides": {
     "tar": "^7.5.22"
+  },
+  "optionalDependencies": {
+    "node-llama-cpp": "^3.22.3"
   }
 }

package/dist/setup.js

@@ -1,110 +0,0 @@
-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`);
-}