brito-cli 0.7.4 → 0.8.0

package/dist/skills/store.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parseFrontmatter, stringifyFrontmatter } from "../util/frontmatter.js";
+import { BUILTIN_SKILLS } from "./builtin.js";
 export const NAME_RE = /^[a-z0-9][a-z0-9-]{1,48}$/;
 const today = () => new Date().toISOString().slice(0, 10);
 /** Skills globais valem para todos os projetos. `BRITO_HOME` troca o local (útil em testes). */
@@ -28,12 +29,15 @@ function parse(text, scope) {
         losses: Number(meta.losses) || 0,
         body: body.trim(),
         scope,
+        invoke: meta.invoke === "manual" ? "manual" : "auto",
+        model: meta.model ?? "",
+        lastLoss: meta.lastLoss ?? "",
     };
 }
 export function writeSkill(root, s) {
     const file = fileOf(root, s.scope, s.name);
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, stringifyFrontmatter({ name: s.name, description: s.description, version: s.version, uses: s.uses, created: s.created, updated: s.updated, lastUsed: s.lastUsed, refs: s.refs.join(", "), status: s.status, origin: s.origin, wins: s.wins, losses: s.losses }, s.body));
+    fs.writeFileSync(file, stringifyFrontmatter({ name: s.name, description: s.description, version: s.version, uses: s.uses, created: s.created, updated: s.updated, lastUsed: s.lastUsed, refs: s.refs.join(", "), status: s.status, origin: s.origin, wins: s.wins, losses: s.losses, ...(s.invoke === "manual" ? { invoke: "manual" } : {}), ...(s.model ? { model: s.model } : {}), ...(s.lastLoss ? { lastLoss: s.lastLoss } : {}) }, s.body));
 }
 /** Lê uma skill de um escopo específico. */
 export function getSkillIn(root, name, scope) {
@@ -48,7 +52,19 @@ export function getSkillIn(root, name, scope) {
 }
 /** Resolve por nome: a skill do projeto sobrepõe a global de mesmo nome. */
 export function getSkill(root, name) {
-    return getSkillIn(root, name, "project") ?? getSkillIn(root, name, "global");
+    return getSkillIn(root, name, "project") ?? getSkillIn(root, name, "global") ?? getBuiltin(name);
+}
+/** Skills embutidas: disponíveis em qualquer projeto sem gravar nada em disco. */
+export function getBuiltin(name) {
+    const b = BUILTIN_SKILLS.find((x) => x.name === name);
+    if (!b)
+        return null;
+    const d = "2026-11-07";
+    return { name: b.name, description: b.description, version: 1, uses: 0, created: d, updated: d, lastUsed: d, refs: [], status: "active", origin: "manual", wins: 0, losses: 0, body: b.body, scope: "global", invoke: "manual", model: b.model ?? "", lastLoss: "", builtin: true };
+}
+/** Embutidas ainda não sobrepostas por uma skill do usuário. */
+export function listBuiltins(root) {
+    return BUILTIN_SKILLS.flatMap((b) => (getSkillIn(root, b.name, "project") ?? getSkillIn(root, b.name, "global") ? [] : [getBuiltin(b.name)]));
 }
 function listScope(root, scope) {
     const dir = dirOf(root, scope);
@@ -118,6 +134,17 @@ export function lintSkill(input) {
     const destructive = DESTRUCTIVE_RULES.filter((r) => r.re.test(text)).map((r) => `comando destrutivo (${r.msg}): só mantenha se houver guarda (backup, cópia/ambiente de teste ou confirmação)`);
     return { errors, warnings: [...urls, ...destructive] };
 }
+/** Limite suave: skills longas pioram a qualidade do agente ("dumb zone"); acima disso, sugerimos dividir. */
+export const SOFT_BODY_LIMIT = 3000;
+/** Dicas de qualidade (não bloqueiam nem entram em `lintSkill`): tamanho e critério de término/verificação. */
+export function adviseSkill(input) {
+    const tips = [];
+    if (input.body.length > SOFT_BODY_LIMIT)
+        tips.push(`body com ${input.body.length} chars (> ${SOFT_BODY_LIMIT}): considere dividir em skills menores`);
+    if (!/verifica|crit[ée]rio de (t[ée]rmino|sa[ií]da|pronto)|done when|pronto quando/i.test(input.body))
+        tips.push("sem seção '## Verificação' ou critério de término: diga como saber que acabou");
+    return tips;
+}
 export function validate(input) {
     if (!NAME_RE.test(input.name))
         throw new Error("name deve ser kebab-case (a-z, 0-9, hífen), 2–49 chars.");
@@ -164,6 +191,9 @@ export function saveSkill(root, input, scope, opts = {}) {
         losses: opts.auto && prev?.status === "trial" ? 0 : prev?.losses ?? 0,
         body: input.body.trim(),
         scope: target,
+        invoke: input.invoke ?? prev?.invoke ?? "auto",
+        model: input.model ?? prev?.model ?? "",
+        lastLoss: prev?.lastLoss ?? "",
     };
     writeSkill(root, skill);
     return { created: !prev, version: skill.version, scope: target };
@@ -215,13 +245,13 @@ export function rejectPending(root, name) {
 }
 export function bumpUses(root, name) {
     const s = getSkill(root, name);
-    if (s)
+    if (s && !s.builtin)
         writeSkill(root, { ...s, uses: s.uses + 1, lastUsed: today() });
 }
 /** Move para `.trash` do próprio escopo em vez de apagar. */
 export function deleteSkill(root, name, scope) {
     const s = scope ? getSkillIn(root, name, scope) : getSkill(root, name);
-    if (!s)
+    if (!s || s.builtin)
         return false;
     const base = dirOf(root, s.scope);
     fs.mkdirSync(path.join(base, ".trash"), { recursive: true });
@@ -239,8 +269,34 @@ export function promoteSkill(root, name) {
     fs.mkdirSync(path.dirname(dest), { recursive: true });
     fs.renameSync(path.join(dirOf(root, "project"), name), dest);
 }
-/** Índice compacto para o system prompt (divulgação progressiva: o corpo só entra via skill_load). */
-export function skillsIndex(root, max = 40, now = Date.now()) {
-    const all = listSkills(root, now).slice(0, max);
-    return all.length ? all.map((s) => `- ${s.name}${s.scope === "global" ? " (global)" : ""}${s.status === "trial" ? " (em teste)" : ""}${staleRefs(root, s).length ? " [refs obsoletas]" : ""}: ${s.description}`).join("\n") : "";
+/** Quantas skills vão para o índice do system prompt; o resto é achado por `skill_load` (sugestões) ou `/skills suggest`. */
+export const INDEX_MAX = 25;
+/** Índice compacto para o system prompt (divulgação progressiva: o corpo só entra via skill_load). Skills `manual` ficam de fora. */
+export function skillsIndex(root, max = INDEX_MAX, now = Date.now()) {
+    const eligible = listSkills(root, now).filter((s) => s.invoke !== "manual");
+    const all = eligible.slice(0, max);
+    if (!all.length)
+        return "";
+    const rest = eligible.length - all.length;
+    return all.map((s) => `- ${s.name}${s.scope === "global" ? " (global)" : ""}${s.status === "trial" ? " (em teste)" : ""}${staleRefs(root, s).length ? " [refs obsoletas]" : ""}: ${s.description}`).join("\n")
+        + (rest > 0 ? `\n(+${rest} skills não listadas: chame skill_load com uma palavra da tarefa para receber sugestões)` : "");
+}
+const STOP = new Set(["para", "como", "com", "uma", "que", "the", "and", "uso", "usar", "skill", "fazer", "esta", "isso", "nos", "nas", "dos", "das", "por"]);
+export const words = (t) => (t.toLowerCase().normalize("NFD").replace(/\p{M}/gu, "").match(/[a-z0-9]{3,}/g) ?? []).filter((w) => !STOP.has(w));
+/** Skills (incluindo manuais e embutidas) ordenadas por afinidade lexical com o texto. Nome pesa mais que descrição. */
+export function suggestSkills(root, text, limit = 5) {
+    const q = new Set(words(text));
+    if (!q.size)
+        return [];
+    return [...listSkills(root), ...listBuiltins(root)]
+        .map((skill) => {
+        const nm = new Set(words(skill.name)), ds = new Set(words(skill.description)), bd = new Set(words(skill.body));
+        let score = 0;
+        for (const w of q)
+            score += (nm.has(w) ? 3 : 0) + (ds.has(w) ? 2 : 0) + (bd.has(w) ? 0.5 : 0);
+        return { skill, score };
+    })
+        .filter((x) => x.score > 0)
+        .sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name))
+        .slice(0, limit);
 }

package/dist/skills/trial.js

@@ -9,11 +9,11 @@ export const TRIAL_DAYS = 21;
 /** Teto de skills novas criadas sozinhas por dia (contido: cada uma vira instrução para o agente). */
 export const DAILY_LIMIT = 3;
 /** Registra o resultado de um turno que usou a skill. Devolve um aviso se ela foi promovida ou arquivada. */
-export function recordOutcome(root, name, win) {
+export function recordOutcome(root, name, win, loss) {
     const s = getSkill(root, name);
-    if (!s)
+    if (!s || s.builtin)
         return null;
-    const next = { ...s, wins: s.wins + (win ? 1 : 0), losses: s.losses + (win ? 0 : 1) };
+    const next = { ...s, wins: s.wins + (win ? 1 : 0), losses: s.losses + (win ? 0 : 1), lastLoss: win ? s.lastLoss : (loss ?? s.lastLoss).replace(/\s+/g, " ").slice(0, 200) };
     if (s.origin === "auto") {
         if (s.status === "trial") {
             if (next.wins >= PROMOTE_WINS && next.wins >= 3 * next.losses) {

package/dist/tools/delegate.js

@@ -11,7 +11,8 @@ let seq = 0;
 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", "skill_save", "skill_delete", "exit_plan", "todo_write"].includes(n)));
 }
 /** Agente somente-leitura: nenhuma tool dele escreve arquivos ou exige aprovação. */
 function isReadOnly(def) {

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/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,7 @@
 import { z } from "zod";
 import { defineTool } from "./registry.js";
-import { bumpUses, deleteSkill, getSkill, listPending, savePending, 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";
 defineTool({
@@ -9,16 +10,18 @@ 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({
     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.",
+    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 entra em teste (se for segura) ou vira proposta pendente (comando destrutivo, ou mudança numa skill aprovada pelo usuário). 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)"),
@@ -26,18 +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, 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);
+        // 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, 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/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,77 +1,80 @@
-{
-  "name": "brito-cli",
-  "version": "0.7.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": {
-    "brito": "dist/cli.js"
-  },
-  "scripts": {
-    "dev": "tsx src/cli.ts",
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "test": "tsx --test test/*.test.ts",
-    "eval:learn": "tsx test/eval-learn.ts",
-    "prepare": "tsc",
-    "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.137.0",
-    "@ladybugdb/core": "0.21.2",
-    "@modelcontextprotocol/sdk": "^1.32.0",
-    "commander": "^14.0.3",
-    "string-width": "^8.3.0",
-    "tinyglobby": "^0.2.17",
-    "tree-sitter-wasms": "^0.1.13",
-    "web-tree-sitter": "0.24.7",
-    "zod": "^4.6.5"
-  },
-  "devDependencies": {
-    "@types/node": "latest",
-    "esbuild": "^0.28.2",
-    "tsx": "latest",
-    "typescript": "latest"
-  },
-  "license": "PolyForm-Noncommercial-1.0.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/wilsonbrito/brito.git"
-  },
-  "homepage": "https://github.com/wilsonbrito/brito#readme",
-  "bugs": {
-    "url": "https://github.com/wilsonbrito/brito/issues"
-  },
-  "author": "Wilson Brito",
-  "engines": {
-    "node": ">=20"
-  },
-  "files": [
-    "dist",
-    "!dist/cli.bundle.mjs",
-    ".brito/agents",
-    "README.md",
-    "README.pt-BR.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "cli",
-    "agent",
-    "coding-agent",
-    "llm",
-    "knowledge-graph",
-    "code-graph",
-    "mcp",
-    "claude",
-    "tree-sitter",
-    "svelte",
-    "typescript",
-    "python"
-  ],
-  "overrides": {
-    "tar": "^7.5.22"
-  }
-}
+{
+  "name": "brito-cli",
+  "version": "0.8.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": {
+    "brito": "dist/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test test/*.test.ts",
+    "eval:learn": "tsx test/eval-learn.ts",
+    "prepare": "tsc",
+    "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.137.0",
+    "@ladybugdb/core": "0.21.2",
+    "@modelcontextprotocol/sdk": "^1.32.0",
+    "commander": "^14.0.3",
+    "string-width": "^8.3.0",
+    "tinyglobby": "^0.2.17",
+    "tree-sitter-wasms": "^0.1.13",
+    "web-tree-sitter": "0.24.7",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "esbuild": "^0.28.2",
+    "tsx": "latest",
+    "typescript": "latest"
+  },
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wilsonbrito/brito.git"
+  },
+  "homepage": "https://github.com/wilsonbrito/brito#readme",
+  "bugs": {
+    "url": "https://github.com/wilsonbrito/brito/issues"
+  },
+  "author": "Wilson Brito",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "!dist/cli.bundle.mjs",
+    ".brito/agents",
+    "README.md",
+    "README.pt-BR.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "cli",
+    "agent",
+    "coding-agent",
+    "llm",
+    "knowledge-graph",
+    "code-graph",
+    "mcp",
+    "claude",
+    "tree-sitter",
+    "svelte",
+    "typescript",
+    "python"
+  ],
+  "overrides": {
+    "tar": "^7.5.22"
+  },
+  "optionalDependencies": {
+    "node-llama-cpp": "^3.22.3"
+  }
+}