brito-cli 0.8.0 → 0.10.0

package/dist/skills/store.js

@@ -32,12 +32,13 @@ function parse(text, scope) {
         invoke: meta.invoke === "manual" ? "manual" : "auto",
         model: meta.model ?? "",
         lastLoss: meta.lastLoss ?? "",
+        by: meta.by ?? "",
     };
 }
 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.invoke === "manual" ? { invoke: "manual" } : {}), ...(s.model ? { model: s.model } : {}), ...(s.lastLoss ? { lastLoss: s.lastLoss } : {}) }, 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.by ? { by: s.by } : {}) }, s.body));
 }
 /** Lê uma skill de um escopo específico. */
 export function getSkillIn(root, name, scope) {
@@ -60,7 +61,7 @@ export function getBuiltin(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 };
+    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: "", by: "", builtin: true };
 }
 /** Embutidas ainda não sobrepostas por uma skill do usuário. */
 export function listBuiltins(root) {
@@ -74,6 +75,23 @@ function listScope(root, scope) {
         .filter((d) => d.isDirectory() && !d.name.startsWith("."))
         .flatMap((d) => { const s = getSkillIn(root, d.name, scope); return s ? [s] : []; });
 }
+/** Skills arquivadas (`.trash`), lidas só para estatística: o placar delas é a evidência de que o gerador errou. */
+export function listArchived(root) {
+    return ["project", "global"].flatMap((scope) => {
+        const dir = path.join(dirOf(root, scope), ".trash");
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).flatMap((d) => {
+            try {
+                const sk = parse(fs.readFileSync(path.join(dir, d.name, "SKILL.md"), "utf8"), scope);
+                return sk ? [sk] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    });
+}
 const DAY = 86_400_000;
 export const daysSince = (date, now = Date.now()) => Math.max(0, Math.floor((now - new Date(date).getTime()) / DAY));
 /** Uso conta, mas skill recente também: sem isso, skills novas (uses=0) cairiam do corte do índice. */
@@ -194,6 +212,7 @@ export function saveSkill(root, input, scope, opts = {}) {
         invoke: input.invoke ?? prev?.invoke ?? "auto",
         model: input.model ?? prev?.model ?? "",
         lastLoss: prev?.lastLoss ?? "",
+        by: prev?.by || (opts.auto ? opts.by ?? "" : ""),
     };
     writeSkill(root, skill);
     return { created: !prev, version: skill.version, scope: target };

package/dist/skills/trial.js

@@ -1,4 +1,4 @@
-import { daysSince, deleteSkill, getSkill, lintSkill, listSkills, savePending, saveSkill, writeSkill } from "./store.js";
+import { daysSince, deleteSkill, getSkill, lintSkill, listArchived, listSkills, savePending, saveSkill, writeSkill } from "./store.js";
 export const skillsMode = () => (process.env.BRITO_SKILLS === "ask" || process.env.BRITO_SKILLS === "off" ? process.env.BRITO_SKILLS : "auto");
 /** Usos bem-sucedidos para promover (com no máximo 1 tropeço a cada 3 sucessos). */
 export const PROMOTE_WINS = 3;
@@ -50,7 +50,7 @@ export function expireTrials(root, now = Date.now()) {
  * - conteúdo com comando destrutivo também vai para a fila de revisão;
  * - nova skill respeita o teto diário.
  */
-export function saveAuto(root, input, now = Date.now()) {
+export function saveAuto(root, input, now = Date.now(), by = "") {
     const prev = getSkill(root, input.name);
     if (prev && prev.origin === "manual") {
         const scope = savePending(root, input, prev.scope);
@@ -66,6 +66,35 @@ export function saveAuto(root, input, now = Date.now()) {
         if (created >= DAILY_LIMIT)
             return { saved: false, msg: `skill ${input.name} não criada: teto de ${DAILY_LIMIT} skills automáticas por dia` };
     }
-    const r = saveSkill(root, input, prev?.scope ?? "project", { auto: true });
+    const r = saveSkill(root, input, prev?.scope ?? "project", { auto: true, by });
     return { saved: true, msg: r.created ? `skill ${input.name} criada em teste (project, v1)` : `skill ${input.name} atualizada (${r.scope}, v${r.version})` };
 }
+/**
+ * Qualidade da reflexão por modelo gerador: das skills automáticas, quantas foram promovidas e quantas arquivadas.
+ * Só `origin: auto` entra (as manuais não medem o gerador). Autoria vazia = criada antes do registro.
+ */
+export function skillStats(root) {
+    const rows = new Map();
+    const row = (by) => rows.get(by) ?? (rows.set(by, { by, created: 0, promoted: 0, trial: 0, archived: 0, wins: 0, losses: 0, promotionRate: null }), rows.get(by));
+    const add = (sk, kind) => {
+        const r = row(sk.by || "(sem registro)");
+        r.created++;
+        r.wins += sk.wins;
+        r.losses += sk.losses;
+        if (kind === "active")
+            r.promoted++;
+        else if (kind === "trial")
+            r.trial++;
+        else
+            r.archived++;
+    };
+    for (const s of listSkills(root))
+        if (s.origin === "auto")
+            add(s, s.status === "trial" ? "trial" : "active");
+    for (const s of listArchived(root))
+        if (s.origin === "auto")
+            add(s, "archived");
+    for (const r of rows.values())
+        r.promotionRate = r.promoted + r.archived ? r.promoted / (r.promoted + r.archived) : null;
+    return [...rows.values()].sort((a, b) => b.created - a.created);
+}

package/dist/tools/delegate.js

@@ -7,12 +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.
     // 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)));
+    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) {
@@ -40,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/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/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/usage/command.js

@@ -0,0 +1,20 @@
+import { ui, c, fmtTokens } from "../ui/ui.js";
+import { fetchPlanUsage, renderPlanLines } from "./plan.js";
+/** `/usage` do terminal: limites do plano (como o do Claude Code) + tokens/custo desta sessão. */
+export function usageCommand(session) {
+    return {
+        desc: "consumo do plano (5h/semana) e da sessão",
+        run: async () => {
+            const r = await fetchPlanUsage({ force: true });
+            if (r.ok) {
+                ui.print(`  ${c.soft(`Plano${r.data.plan ? ` ${r.data.plan}` : ""}`)}`);
+                for (const l of renderPlanLines(r.data))
+                    ui.print(`  ${c.muted(l)}`);
+            }
+            else
+                ui.print(`  ${c.muted(`Plano: ${r.reason}`)}`);
+            const s = session();
+            ui.print(`  ${c.soft("Sessão")} ${c.muted(`↑${fmtTokens(s.input)} ↓${fmtTokens(s.output)} · cache ${fmtTokens(s.cacheRead)}${s.costUsd ? ` · US$ ${s.costUsd.toFixed(2)}` : ""}`)}`);
+        },
+    };
+}

package/dist/usage/plan.js

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+/**
+ * Consumo do plano (assinatura Claude): janela de 5h, semana e uso extra, o mesmo que o `/usage` do Claude Code mostra.
+ * Vem de um endpoint interno da Anthropic, autenticado com o token OAuth que o `claude` já guarda (somente leitura:
+ * não renovamos nem gravamos o token). Se o endpoint mudar, devolvemos um erro legível — nunca quebramos o resto.
+ */
+const URL_USAGE = "https://api.anthropic.com/api/oauth/usage";
+const CACHE_MS = 60_000;
+function tokenFromFile(file) {
+    try {
+        const o = JSON.parse(fs.readFileSync(file, "utf8"))?.claudeAiOauth;
+        return o?.accessToken ? { token: o.accessToken, plan: o.subscriptionType, expiresAt: o.expiresAt } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Token do `claude`: ~/.claude/.credentials.json (Windows/Linux) ou o Keychain (macOS). */
+export function readOAuth() {
+    const dir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+    const f = tokenFromFile(path.join(dir, ".credentials.json"));
+    if (f || process.platform !== "darwin")
+        return f;
+    try {
+        const raw = execFileSync("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
+        const o = JSON.parse(raw)?.claudeAiOauth;
+        return o?.accessToken ? { token: o.accessToken, plan: o.subscriptionType, expiresAt: o.expiresAt } : null;
+    }
+    catch {
+        return null;
+    }
+}
+const LABELS = {
+    session: "Sessão (5h)", weekly_all: "Semana (todos os modelos)", weekly_opus: "Semana · Opus", weekly_sonnet: "Semana · Sonnet",
+};
+/** Normaliza a resposta; tolera campos ausentes e ignora o que não reconhece. */
+export function parsePlanUsage(j, plan) {
+    const buckets = [];
+    const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+    if (Array.isArray(j?.limits) && j.limits.length) {
+        for (const l of j.limits) {
+            const p = num(l?.percent);
+            if (p === null)
+                continue;
+            buckets.push({ label: LABELS[l.kind] ?? String(l.kind), percent: p, resetsAt: l.resets_at ?? undefined });
+        }
+    }
+    else {
+        for (const [key, label] of [["five_hour", LABELS.session], ["seven_day", LABELS.weekly_all], ["seven_day_opus", LABELS.weekly_opus], ["seven_day_sonnet", LABELS.weekly_sonnet]]) {
+            const p = num(j?.[key]?.utilization);
+            if (p !== null)
+                buckets.push({ label, percent: p, resetsAt: j[key].resets_at ?? undefined });
+        }
+    }
+    const e = j?.extra_usage;
+    const dec = 10 ** (num(e?.decimal_places) ?? 2);
+    const extra = e?.is_enabled && num(e?.monthly_limit) !== null
+        ? { used: (num(e.used_credits) ?? 0) / dec, limit: e.monthly_limit / dec, percent: num(e.utilization) ?? 0, currency: String(e.currency ?? "") }
+        : undefined;
+    return { plan, buckets, extra };
+}
+let cache = null;
+export async function fetchPlanUsage(opts = {}) {
+    if (!opts.force && cache && Date.now() - cache.at < CACHE_MS)
+        return cache.result;
+    const auth = readOAuth();
+    let result;
+    if (!auth)
+        result = { ok: false, reason: "sem login do Claude por assinatura (rode `claude` e entre com /login); com ANTHROPIC_API_KEY não há limite de plano a mostrar" };
+    else if (auth.expiresAt && auth.expiresAt < Date.now())
+        result = { ok: false, reason: "o login do claude expirou: abra o `claude` uma vez para renová-lo" };
+    else {
+        try {
+            const r = await (opts.fetchImpl ?? fetch)(URL_USAGE, {
+                headers: { Authorization: `Bearer ${auth.token}`, "anthropic-beta": "oauth-2025-04-20", "User-Agent": "brito-cli" },
+                signal: AbortSignal.timeout(8000),
+            });
+            result = r.ok ? { ok: true, data: parsePlanUsage(await r.json(), auth.plan) }
+                : { ok: false, reason: r.status === 401 || r.status === 403 ? "o login do claude não vale mais: abra o `claude` para renová-lo" : `a Anthropic respondeu ${r.status}` };
+        }
+        catch (e) {
+            result = { ok: false, reason: `não consegui consultar o plano (${e?.message ?? e})` };
+        }
+    }
+    if (result.ok)
+        cache = { at: Date.now(), result }; // falhas não ficam em cache
+    return result;
+}
+/** "em 2h 10min" / "em 3d 4h" a partir de um ISO. */
+export function resetIn(iso, now = Date.now()) {
+    const t = iso ? Date.parse(iso) : NaN;
+    if (!Number.isFinite(t))
+        return "";
+    const min = Math.max(0, Math.round((t - now) / 60_000));
+    if (min < 60)
+        return `${min}min`;
+    if (min < 48 * 60)
+        return `${Math.floor(min / 60)}h ${String(min % 60).padStart(2, "0")}min`;
+    return `${Math.floor(min / 1440)}d ${Math.floor((min % 1440) / 60)}h`;
+}
+/** Linhas de texto para o terminal (sem cor; quem chama pinta). */
+export function renderPlanLines(d, now = Date.now()) {
+    const bar = (p) => { const n = Math.round(Math.min(100, Math.max(0, p)) / 5); return "█".repeat(n) + "░".repeat(20 - n); };
+    const out = d.buckets.map((b) => `${b.label.padEnd(28)} [${bar(b.percent)}] ${String(Math.round(b.percent)).padStart(3)}%${b.resetsAt ? `  · reseta em ${resetIn(b.resetsAt, now)}` : ""}`);
+    if (d.extra)
+        out.push(`${"Uso extra (mês)".padEnd(28)} [${bar(d.extra.percent)}] ${String(Math.round(d.extra.percent)).padStart(3)}%  · ${d.extra.used.toFixed(2)} de ${d.extra.limit.toFixed(2)} ${d.extra.currency}`);
+    return out.length ? out : ["(a Anthropic não devolveu limites para esta conta)"];
+}

package/package.json

@@ -1,80 +1,81 @@
-{
-  "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"
-  }
-}
+{
+  "name": "brito-cli",
+  "version": "0.10.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",
+    "release": "node scripts/release.mjs"
+  },
+  "dependencies": {
+    "@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",
+    "tree-sitter-wasms": "^0.1.13",
+    "web-tree-sitter": "0.24.7",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.6",
+    "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"
+  }
+}