brito-cli 0.9.0 → 0.10.1

package/README.md

@@ -10,6 +10,14 @@ Brito is an agent for software development. Use it in the terminal (`brito-cli`
 
 *A real session on a small SvelteKit project: one question, two graph calls (0.1 s and 0.0 s), and an answer that already includes the `.svelte` components depending on the file. The status bar shows the real cost of the turn.*
 
+## What's new in 0.10
+
+- **Read your project inside the desktop app.** Open the **Files** panel → **Project** tab: folder tree plus a reader for Markdown (front matter, task lists, tables, Obsidian callouts, `[[wikilinks]]`), syntax-highlighted code, images, **PDF, Word (.docx) and PowerPoint (.pptx)**. ` ```mermaid ` blocks render as diagrams. Paths the agent mentions in the chat (`src/cli.ts:120`) are clickable. It is read-only, and it only reads inside the project folders you added.
+- **Bring your Claude Code setup.** Run `brito importar claude-code` to see what would come over (skills, subagents, `deny` rules). Nothing is written until you add `--aplicar`. Imported skills start "in trial" and go through the safety lint; `--desfazer` undoes it. Add `--incluir-allow` for `allow` rules and `--memoria` for the project memory. Credentials are never read.
+- **Know which model writes good skills.** Every automatic skill now records its author. `/skills stats` shows, per model (local SLM vs. Claude), created / promoted / archived skills and the promotion rate, so you can decide whether a cheaper model is good enough.
+
+Upgrading from 0.9: `npm i -g brito-cli@latest`, and update the desktop app to the same version (the app warns when it and the CLI are out of sync). Full details in the [CHANGELOG](CHANGELOG.md).
+
 ## Highlights
 
 > **Upgrading to 0.6:** the graph engine changed from Kùzu (discontinued) to LadybugDB. The graph is rebuilt automatically on first use; your old `.brito/graph.kuzu` is kept. Brito asks once whether to copy your notes (memory) to the new graph, or run `brito migrar-notas` any time. Tests run in CI on macOS, Linux and Windows (use 0.6.1 or later on Windows/Linux). See the [CHANGELOG](CHANGELOG.md).
@@ -22,6 +30,9 @@ Brito is an agent for software development. Use it in the terminal (`brito-cli`
 - **Two backends, one interface.** Use an Anthropic API key, or your Claude Code subscription through the `claude` CLI. Brito never reads or sends your subscription token.
 - **Terminal or desktop app.** `npm i -g brito-cli` gives you the `brito` command; the desktop app is a native executable with a window (projects and sessions in a sidebar, chat, permission prompts), no Node or terminal needed. See [Install](#install).
 - **Images.** Drag an image file into the prompt (or paste its path) and it is attached to the turn: PNG, JPEG, GIF or WebP, up to 5 MB.
+- **File preview in the desktop app (read-only).** The Files panel has a "Project" tab: repository tree plus a reader for Markdown (front matter, nested lists, task lists, tables, Obsidian callouts and `[[wikilinks]]`), syntax-highlighted code and images. Mermaid blocks render as diagrams; file paths cited in the chat (`src/cli.ts:120`) open the preview.
+- **Import from Claude Code.** `brito importar claude-code` shows what it would bring (skills as "trial", subagents, `deny` rules; `--incluir-allow` and `--memoria` are opt-in) and writes only with `--aplicar`. `--desfazer` reverts. Credentials are never read.
+- **Measuring the reflection.** Each automatic skill records the model that wrote it; `/skills stats` shows the promotion rate per model (local SLM vs. Claude).
 - **Subagents.** `explore`, `plan` and `general` run in isolated contexts (read-only ones in parallel); add your own in `.brito/agents/*.md`.
 - **MCP server.** `brito mcp-serve` exposes the graph, memory and skills to other MCP clients such as Claude Code. The query tools are marked `alwaysLoad`, so they are not hidden behind tool search.
 
@@ -81,6 +92,7 @@ The lint **rejects** secrets/tokens, absolute user paths, credentials in URLs (`
 - **`digest` tool**: a scout and refiner for long texts. The local model picks the blocks most related to your objective and proposes excerpts; code then checks every quote against the source and drops what is not there, so the main model gets a small markdown draft with verified quotes and page numbers.
 
 - **Fallback when Claude runs out**: chain Claude → `qwen` profile → local SLM, with the full agent loop and tools (same permissions). It is temporary: after a window (the reset time reported by the error, else 10 min, or 60 min for quota/auth; `BRITO_FALLBACK_MINUTES` overrides) the next turn tries Claude again. `/fallback` shows when. A 4B model errs more with tools: use it to keep going, not for big tasks. `BRITO_SLM_FALLBACK=off` removes it from the chain; `BRITO_SLM_CTX` sets its context.
+- **Context compaction on the local SLM**: when the conversation is compacted, the middle is summarized by the local SLM (chunked map-reduce) instead of Claude, saving tokens; on any failure it falls back to Claude. `/context` shows compactions and estimated tokens saved. `BRITO_SLM_COMPACT=off` disables it.
 
 `BRITO_SLM=off` disables it; `BRITO_SLM_MODEL` points to another GGUF (`hf:` URI or file path).
 

package/README.pt-BR.md

@@ -10,6 +10,14 @@ O Brito é um agente para desenvolvimento de software. Use no terminal (`brito-c
 
 *Uma sessão real num pequeno projeto SvelteKit: uma pergunta, duas consultas ao grafo (0,1 s e 0,0 s) e uma resposta que já inclui os componentes `.svelte` que dependem do arquivo. A barra de status mostra o custo real do turno.*
 
+## Novidades da 0.10
+
+- **Leia o seu projeto dentro do app de desktop.** Abra o painel **Arquivos** → aba **Projeto**: árvore de pastas e um leitor de Markdown (frontmatter, tarefas, tabelas, callouts e `[[wikilinks]]` do Obsidian), código com realce e imagens. Blocos ` ```mermaid ` viram diagramas. Os caminhos que o agente cita no chat (`src/cli.ts:120`) são clicáveis. É só leitura, e só lê dentro das pastas que você adicionou como projeto.
+- **Traga a sua configuração do Claude Code.** Rode `brito importar claude-code` para ver o que viria (skills, subagentes, regras `deny`). Nada é gravado até você adicionar `--aplicar`. As skills importadas começam "em teste" e passam pelo lint de segurança; `--desfazer` reverte. Use `--incluir-allow` para as regras `allow` e `--memoria` para a memória do projeto. Credenciais nunca são lidas.
+- **Descubra qual modelo escreve boas skills.** Toda skill automática agora registra o autor. `/skills stats` mostra, por modelo (SLM local × Claude), skills criadas, promovidas e arquivadas e a taxa de promoção, para você decidir se um modelo mais barato basta.
+
+Atualizando da 0.9: `npm i -g brito-cli@latest` e atualize o app de desktop para a mesma versão (o app avisa quando ele e a CLI estão fora de sincronia). Detalhes no [CHANGELOG](CHANGELOG.md).
+
 ## Destaques
 
 > **Atualizando para a 0.6:** o motor do grafo mudou do Kùzu (descontinuado) para o LadybugDB. O grafo é reconstruído sozinho no primeiro uso; o seu `.brito/graph.kuzu` antigo é mantido. O Brito pergunta uma vez se copia as suas notas (memória) para o grafo novo, ou rode `brito migrar-notas` quando quiser. Os testes rodam no CI em macOS, Linux e Windows (use a 0.6.1 ou posterior no Windows/Linux). Veja o [CHANGELOG](CHANGELOG.md).
@@ -22,6 +30,9 @@ O Brito é um agente para desenvolvimento de software. Use no terminal (`brito-c
 - **Dois backends, uma interface.** Use uma chave da API da Anthropic ou a sua assinatura do Claude Code pela CLI `claude`. O Brito nunca lê nem envia o token da sua assinatura.
 - **Terminal ou app de desktop.** `npm i -g brito-cli` instala o comando `brito`; o app de desktop é um executável nativo com janela (projetos e sessões numa barra lateral, chat, pedidos de permissão), sem precisar de Node nem de terminal. Veja [Instalação](#instalação).
 - **Imagens.** Arraste um arquivo de imagem para o prompt (ou cole o caminho) e ele é anexado ao turno: PNG, JPEG, GIF ou WebP, até 5 MB.
+- **Preview de arquivos no desktop (somente leitura).** O painel Arquivos tem a aba "Projeto": árvore do repositório e leitor de Markdown (frontmatter, listas aninhadas, tarefas, tabelas, callouts e `[[wikilinks]]` do Obsidian), código com realce e imagens. Blocos Mermaid viram diagrama; caminhos citados no chat (`src/cli.ts:120`) abrem o preview.
+- **Importar do Claude Code.** `brito importar claude-code` mostra o que traria (skills em teste, subagentes, regras `deny`; `--incluir-allow` e `--memoria` são opcionais) e só grava com `--aplicar`. `--desfazer` reverte. Credenciais nunca são lidas.
+- **Medição da reflexão.** Cada skill automática registra o modelo que a gerou; `/skills stats` mostra a taxa de promoção por modelo (SLM local × Claude).
 - **Subagentes.** `explore`, `plan` e `general` rodam em contextos isolados (os somente-leitura, em paralelo); crie os seus em `.brito/agents/*.md`.
 - **Servidor MCP.** `brito mcp-serve` expõe grafo, memória e skills a outros clientes MCP, como o Claude Code. As tools de consulta são marcadas `alwaysLoad`, para não ficarem escondidas atrás da busca de tools.
 

package/dist/agent/context.js

@@ -1,4 +1,6 @@
 import { providerFor } from "../provider/index.js";
+import { resolveModel } from "../provider/resolve.js";
+import { slmCompactSummary } from "../local/compact.js";
 /** Imagem em base64 tem megabytes, mas custa ~1,6 mil tokens: troca o conteúdo por um marcador antes de medir ou resumir. */
 const stubImages = (_k, v) => (v && typeof v === "object" && (v.type === "image" || v.type === "document") && v.source ? { type: v.type, note: "x".repeat(6400) } : v);
 export const estimateTokens = (msgs) => Math.ceil(JSON.stringify(msgs, stubImages).length / 4);
@@ -20,7 +22,7 @@ export function trimOldToolResults(msgs, keep = 8) {
     });
 }
 /** Fase 2: resume o meio da conversa via LLM, mantendo o início e os últimos turnos. */
-export async function summarizeMiddle(model, msgs, keepTail = 6) {
+export async function summarizeMiddle(model, msgs, keepTail = 6, slmSummary = slmCompactSummary) {
     if (msgs.length <= keepTail + 2)
         return msgs;
     let cut = msgs.length - keepTail;
@@ -32,14 +34,19 @@ export async function summarizeMiddle(model, msgs, keepTail = 6) {
     const head = msgs.slice(0, 1);
     const middle = msgs.slice(1, cut);
     const tail = msgs.slice(cut);
-    // Raciocínio desligado: num endpoint com raciocínio ele comeria o orçamento do resumo.
-    const res = await providerFor(model).send({
-        model,
-        maxTokens: 2000,
-        thinking: false,
-        system: "Resuma a conversa de um agente de programação. Preserve: objetivo, decisões, arquivos/símbolos tocados, erros encontrados, estado atual e próximos passos. Seja denso.",
-        messages: [{ role: "user", content: JSON.stringify(middle, (_k, v) => (v && typeof v === "object" && (v.type === "image" || v.type === "document") && v.source ? { type: v.type, note: "[anexo omitido]" } : v)).slice(0, 150_000) }],
-    });
-    const summary = res.content.map((b) => (b.type === "text" ? b.text : "")).join("");
+    const body = JSON.stringify(middle, (_k, v) => (v && typeof v === "object" && (v.type === "image" || v.type === "document") && v.source ? { type: v.type, note: "[anexo omitido]" } : v)).slice(0, 150_000);
+    // O SLM local resume primeiro (não gasta token do Claude); se o modelo da sessão já é local, não há o que poupar.
+    let summary = resolveModel(model).local ? null : await slmSummary(body);
+    if (!summary) {
+        // Raciocínio desligado: num endpoint com raciocínio ele comeria o orçamento do resumo.
+        const res = await providerFor(model).send({
+            model,
+            maxTokens: 2000,
+            thinking: false,
+            system: "Resuma a conversa de um agente de programação. Preserve: objetivo, decisões, arquivos/símbolos tocados, erros encontrados, estado atual e próximos passos. Seja denso.",
+            messages: [{ role: "user", content: body }],
+        });
+        summary = res.content.map((b) => (b.type === "text" ? b.text : "")).join("");
+    }
     return [...head, { role: "user", content: `[Resumo da conversa anterior]\n${summary}` }, { role: "assistant", content: "Entendido, continuando a partir do resumo." }, ...tail];
 }

package/dist/cli.js

@@ -32,9 +32,11 @@ import "./tools/digest.js";
 import { adviseSkill, approvePending, lintSkill, listBuiltins, listPending, listSkills, rejectPending, skillsIndex, staleRefs } from "./skills/store.js";
 import { applyProposal, autoConsolidate, describeProposal, proposeConsolidation, pruneCandidates } from "./skills/consolidate.js";
 import { defaultComplete, recordOutcomes, reflect, shouldReflect } from "./skills/learn.js";
-import { expireTrials, skillsMode } from "./skills/trial.js";
+import { expireTrials, skillStats, skillsMode } from "./skills/trial.js";
 import { claudeCliComplete } from "./skills/learn-cli.js";
 import { pullModel, removeModel, slmStatus, withSlm } from "./local/slm.js";
+import { slmStatsLine } from "./local/stats.js";
+import { usageCommand } from "./usage/command.js";
 import { buildSystemPrompt, graphStatsLine, memoSystem, systemKey } from "./agent/prompt.js";
 import { allTools } from "./tools/registry.js";
 import { ui, c, fmtTokens } from "./ui/ui.js";
@@ -82,6 +84,53 @@ program
     const lines = sessionLines(rootOf(o));
     console.log(lines.length ? lines.join("\n") : c.muted("nenhuma sessão salva neste projeto"));
 });
+program
+    .command("importar [origem]")
+    .alias("import")
+    .description("Importa skills, subagentes, regras de permissão e memória do Claude Code (origem: claude-code). Sem --aplicar só mostra o que faria")
+    .option("-d, --dir <dir>", "raiz do projeto")
+    .option("--aplicar", "grava de verdade (sem isto é só uma prévia)")
+    .option("--incluir-allow", "importa também as regras allow (liberam ações sem perguntar)")
+    .option("--memoria", "importa a memória do Claude Code deste projeto como notas do grafo")
+    .option("--desfazer", "desfaz um import anterior (skills e agentes; regras e notas ficam)")
+    .action(async (origem, o) => {
+    if (origem && origem !== "claude-code") {
+        console.error(c.warn(`origem "${origem}" não suportada: por enquanto só claude-code`));
+        process.exitCode = 1;
+        return;
+    }
+    const root = rootOf(o);
+    const { applyImport, describePlan, planImport, undoImport } = await import("./import/claude-code.js");
+    if (o.desfazer) {
+        const r = undoImport(root);
+        console.log(`OK: ${r.skills} skill(s) e ${r.agents} agente(s) removidos (skills ficam na lixeira .trash).`);
+        return;
+    }
+    const plan = planImport(root, { includeAllow: !!o.incluirAllow, includeMemory: !!o.memoria });
+    for (const l of describePlan(plan))
+        console.log("  " + l);
+    if (!o.aplicar) {
+        console.log(c.muted("\n  prévia: nada foi gravado. Rode de novo com --aplicar."));
+        return;
+    }
+    const r = applyImport(root, plan);
+    if (r.notes.length) {
+        const g = await GraphStore.open(root);
+        try {
+            for (const n of r.notes) {
+                const [{ c: has }] = await g.run("MATCH (x:Note {id:$id}) RETURN count(x) AS c", { id: n.id });
+                if (Number(has) === 0)
+                    await g.run("CREATE (:Note {id:$id, kind:$k, text:$t, refs:$r, ts:$ts})", { id: n.id, k: n.kind, t: n.text, r: [], ts: Date.now() });
+            }
+        }
+        finally {
+            await g.close();
+        }
+    }
+    console.log(c.ok(`OK: ${r.skills} skill(s) em teste, ${r.pending} pendente(s) (/skills pending), ${r.agents} agente(s), ${r.rules} regra(s), ${r.notes.length} nota(s).`));
+    for (const e of r.errors)
+        console.error(c.warn("  falhou: " + e));
+});
 program
     .command("slm [acao]")
     .description("SLM local embutido (llama.cpp): status | pull (baixa o modelo) | rm (apaga). Usado na reflexão de skills; desligue com BRITO_SLM=off")
@@ -372,7 +421,7 @@ const permissionsCommand = (root) => ({
     },
 });
 const skillsCommand = (root, io, llm) => ({
-    desc: "lista skills; pending | approve <nome> | reject <nome> | consolidate",
+    desc: "lista skills; pending | approve <nome> | reject <nome> | consolidate | stats",
     run: async ([sub, name]) => {
         if (sub === "consolidate") {
             ui.info("✦ analisando a biblioteca de skills…");
@@ -449,6 +498,17 @@ const skillsCommand = (root, io, llm) => ({
             }
             return;
         }
+        if (sub === "stats") {
+            const rows = skillStats(root);
+            if (!rows.length) {
+                ui.print(c.muted("  ainda não há skills automáticas para medir."));
+                return;
+            }
+            for (const r of rows)
+                ui.print(`  ${c.soft(r.by)} ${c.muted(`${r.created} criadas · ${r.promoted} promovidas · ${r.trial} em teste · ${r.archived} arquivadas · placar ${r.wins}✓/${r.losses}✗ · promoção ${r.promotionRate === null ? "sem veredito" : Math.round(r.promotionRate * 100) + "%"}`)}`);
+            ui.print(c.muted("  promoção = promovidas ÷ (promovidas + arquivadas); skills em teste ainda não contam."));
+            return;
+        }
         const skills = listSkills(root);
         for (const s of skills) {
             const stale = staleRefs(root, s);
@@ -697,8 +757,12 @@ async function buildApiBackend(root, model, io, o = {}) {
                     const win = contextWindowFor(agent.model);
                     const pct = Math.round((agent.contextTokens / win) * 100);
                     ui.print(`  ${c.soft(`${fmtTokens(agent.contextTokens)} / ${fmtTokens(win)}`)} ${c.muted(`(${pct}%) · ${agent.messages.length} mensagens · compacta em ~${fmtTokens(compactAtFor(agent.model))}`)}`);
+                    const slmLine = slmStatsLine();
+                    if (slmLine)
+                        ui.print(`  ${c.muted(slmLine)}`);
                 },
             },
+            "/usage": usageCommand(() => ({ ...agent.usage, costUsd: backend.cost?.() })),
             "/index": { desc: "reconstrói o grafo do zero", run: async () => { ui.info("reconstruindo grafo…"); ui.print(c.muted(JSON.stringify(await indexProject(root, graph, { full: true })))); } },
             "/learn": { desc: "extrai skills do último turno agora", run: async () => { await learn(true); } },
             "/skills": skillsCommand(root, io, { complete: withSlm(defaultComplete), model: learnModel }),
@@ -868,6 +932,7 @@ async function buildClaudeBackend(root, io, sw, model, openGraph, resume) {
                 },
             },
             "/context": unavailable,
+            "/usage": usageCommand(() => ({ ...session.usage, costUsd: session.costUsd })),
             "/learn": { desc: "extrai skills do último turno agora", run: async () => { await learn(true); } },
             "/skills": skillsCommand(root, io, { complete: withSlm(claudeCliComplete), model: () => process.env.BRITO_LEARN_MODEL ?? "" }),
             "/permissions": permissionsCommand(root),

package/dist/desktop/serve.js

@@ -1,3 +1,4 @@
+import { fetchPlanUsage } from "../usage/plan.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -407,6 +408,8 @@ export async function serveDesktop(root, resumeId) {
                         const skills = [...listBuiltins(root), ...listSkills(root).filter((s) => s.invoke === "manual")].map((s) => ({ name: s.name, description: s.description, kind: "skill" }));
                         data = [...BUILTIN_COMMANDS, ...skills].filter((c) => !arg || c.name.includes(arg));
                     }
+                    else if (m.q === "usage")
+                        data = { plan: await fetchPlanUsage({ force: arg === "force" }), session: engine.stats(), model: engine.model };
                     else if (m.q === "models")
                         data = { aliases: Object.keys(MODEL_ALIASES), profiles: Object.keys(loadProfiles().profiles) };
                 }

package/dist/graph/indexer.js

@@ -223,7 +223,13 @@ async function scan(root, aliases) {
     const files = await sourceFiles(root);
     const out = new Map();
     for (const rel of files) {
-        const src = fs.readFileSync(path.join(root, rel), "utf8");
+        let src;
+        try {
+            src = fs.readFileSync(path.join(root, rel), "utf8");
+        }
+        catch {
+            continue;
+        } // ilegível (OneDrive, travado, permissão): ignora
         if (src.length > 1_000_000)
             continue;
         out.set(rel, { src, hash: crypto.createHash("sha1").update(src).digest("hex") + ":" + INDEXER_VERSION + ":" + aliases.forFile(rel).signature });

package/dist/import/claude-code.js

@@ -0,0 +1,286 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parseRule, addRule, loadRules } from "../rules.js";
+import { NAME_RE, deleteSkill, getSkillIn, lintSkill, listSkills, savePending, validate, writeSkill } from "../skills/store.js";
+import { stringifyFrontmatter } from "../util/frontmatter.js";
+/**
+ * Import do Claude Code: skills, subagentes, regras de permissão e memória. Sempre em duas etapas — `planImport` só lê
+ * e decide (nada é gravado), `applyImport` grava o que o plano marcou como `import`.
+ *
+ * Princípios: nada importado vira ativo sem teste (skills entram "em teste"); credenciais nunca são lidas; `deny` entra
+ * direto (só restringe) mas `allow` exige pedido explícito; tudo importado é reversível (`undoImport`).
+ */
+export const IMPORT_TAG = "import:claude-code";
+export const claudeHome = () => process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+/** Frontmatter YAML simples, aceitando valores em várias linhas (`>`, `|` ou continuação indentada), como nas skills do Claude. */
+export function parseRichFrontmatter(text) {
+    const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m)
+        return null;
+    const meta = {};
+    let key = "";
+    for (const line of m[1].split(/\r?\n/)) {
+        const kv = /^([\w-]+):\s*(.*)$/.exec(line);
+        if (kv) {
+            key = kv[1];
+            meta[key] = /^[>|][+-]?$/.test(kv[2].trim()) ? "" : kv[2].trim().replace(/^(['"])(.*)\1$/, "$2");
+        }
+        else if (key && /^\s+\S/.test(line))
+            meta[key] = `${meta[key]} ${line.trim()}`.trim();
+    }
+    return { meta, body: m[2] };
+}
+const readText = (file) => { try {
+    return fs.readFileSync(file, "utf8");
+}
+catch {
+    return null;
+} };
+const dirsIn = (dir) => { try {
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
+}
+catch {
+    return [];
+} };
+const mdIn = (dir) => { try {
+    return fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+}
+catch {
+    return [];
+} };
+/** Descrição do Claude pode passar de 200 caracteres: corta numa fronteira de frase/palavra. */
+function fitDescription(d) {
+    const t = d.replace(/\s+/g, " ").trim();
+    if (t.length <= 200)
+        return t;
+    const cut = t.slice(0, 197);
+    return cut.slice(0, Math.max(cut.lastIndexOf(" "), 100)) + "…";
+}
+function planSkills(root, home) {
+    const out = [];
+    const sources = [
+        { dir: path.join(root, ".claude", "skills"), scope: "project", label: ".claude/skills" },
+        { dir: path.join(home, "skills"), scope: "global", label: "~/.claude/skills" },
+    ];
+    for (const { dir, scope, label } of sources) {
+        for (const folder of dirsIn(dir)) {
+            const source = `${label}/${folder}`;
+            const text = readText(path.join(dir, folder, "SKILL.md"));
+            const fm = text ? parseRichFrontmatter(text) : null;
+            const name = (fm?.meta.name || folder).trim();
+            const skip = (note) => ({ kind: "skill", name, source, action: "skip", note, scope });
+            if (!fm) {
+                out.push(skip("SKILL.md ausente ou sem frontmatter"));
+                continue;
+            }
+            if (!NAME_RE.test(name)) {
+                out.push(skip(`nome "${name}" fora do padrão kebab-case de 2 a 49 caracteres`));
+                continue;
+            }
+            const description = fitDescription(fm.meta.description ?? "");
+            const body = fm.body.trim();
+            const input = { name, description, body, invoke: fm.meta["disable-model-invocation"] === "true" ? "manual" : "auto" };
+            try {
+                validate(input);
+            }
+            catch (e) {
+                out.push(skip(String(e?.message ?? e)));
+                continue;
+            }
+            if (getSkillIn(root, name, scope)) {
+                out.push(skip("já existe uma skill com esse nome"));
+                continue;
+            }
+            const extras = dirsIn(path.join(dir, folder)).concat(fs.readdirSync(path.join(dir, folder)).filter((f) => f !== "SKILL.md" && !fs.statSync(path.join(dir, folder, f)).isDirectory()));
+            const warnings = lintSkill(input).warnings.filter((w) => w.startsWith("comando destrutivo"));
+            const notes = [extras.length ? `arquivos de apoio não copiados: ${extras.join(", ")}` : "", fm.meta["allowed-tools"] ? "allowed-tools do Claude é ignorado" : "", warnings.length ? "tem comando destrutivo: vai para /skills pending" : ""].filter(Boolean);
+            out.push({ kind: "skill", name, source, action: "import", scope, pending: warnings.length > 0, note: notes.join("; ") || undefined, data: input });
+        }
+    }
+    return out;
+}
+/** Nomes de tool do Claude → do Brito. */
+const TOOL_MAP = { read: "read_file", write: "write_file", edit: "edit_file", multiedit: "edit_file", bash: "bash", glob: "glob", grep: "grep", notebookedit: "edit_file" };
+const mapTool = (t) => TOOL_MAP[t.trim().toLowerCase()];
+const READ_ONLY = ["read_file", "glob", "grep", "graph_search", "graph_callers", "graph_callees", "graph_impact", "graph_context", "graph_query", "recall"];
+function planAgents(root, home) {
+    const out = [];
+    for (const { dir, label } of [{ dir: path.join(root, ".claude", "agents"), label: ".claude/agents" }, { dir: path.join(home, "agents"), label: "~/.claude/agents" }]) {
+        for (const f of mdIn(dir)) {
+            const source = `${label}/${f}`;
+            const fm = parseRichFrontmatter(readText(path.join(dir, f)) ?? "");
+            const name = (fm?.meta.name || f.replace(/\.md$/, "")).trim();
+            const skip = (note) => ({ kind: "agent", name, source, action: "skip", note });
+            if (!fm || !fm.meta.description || !fm.body.trim()) {
+                out.push(skip("precisa de frontmatter com description e de um corpo"));
+                continue;
+            }
+            if (!NAME_RE.test(name)) {
+                out.push(skip(`nome "${name}" fora do padrão kebab-case`));
+                continue;
+            }
+            if (fs.existsSync(path.join(root, ".brito", "agents", `${name}.md`))) {
+                out.push(skip("já existe um agente com esse nome em .brito/agents"));
+                continue;
+            }
+            const raw = (fm.meta.tools ?? "").split(",").map((t) => t.trim()).filter(Boolean);
+            const mapped = [...new Set(raw.map(mapTool).filter((t) => !!t))];
+            const dropped = raw.filter((t) => !mapTool(t));
+            const tools = !raw.length ? "all" : mapped.length ? mapped : READ_ONLY;
+            const model = /^claude-/.test(fm.meta.model ?? "") ? fm.meta.model : "";
+            const notes = [dropped.length ? `tools sem equivalente: ${dropped.join(", ")}` : "", raw.length && !mapped.length ? "nenhuma tool equivalente: ficou somente leitura" : "", fm.meta.model && !model ? `modelo "${fm.meta.model}" não mapeado: usa o padrão do Brito` : ""].filter(Boolean);
+            out.push({ kind: "agent", name, source, action: "import", note: notes.join("; ") || undefined, data: { description: fitDescription(fm.meta.description).replace(/\s+/g, " "), tools, model, body: fm.body.trim() } });
+        }
+    }
+    return out;
+}
+/** `Bash(npm test:*)` → `bash(npm test:*)`; devolve null quando o Brito não tem a tool (WebFetch, mcp__…). */
+export function mapRule(rule) {
+    const r = parseRule(rule);
+    if (!r)
+        return null;
+    const tool = mapTool(r.tool);
+    if (!tool)
+        return null;
+    if (r.pattern === undefined)
+        return tool;
+    const pattern = tool === "bash" ? r.pattern : r.pattern.replace(/^\.\//, "").replace(/^\/\//, "/");
+    return `${tool}(${pattern})`;
+}
+function planRules(root, home, includeAllow) {
+    const out = [];
+    const have = loadRules(root);
+    const files = [path.join(root, ".claude", "settings.json"), path.join(root, ".claude", "settings.local.json"), path.join(home, "settings.json")];
+    const seen = new Set();
+    for (const file of files) {
+        let perms;
+        try {
+            perms = JSON.parse(fs.readFileSync(file, "utf8"))?.permissions;
+        }
+        catch {
+            continue;
+        }
+        const source = file.startsWith(root) ? path.relative(root, file).split(path.sep).join("/") : `~/.claude/${path.basename(file)}`;
+        for (const kind of ["deny", "allow"]) {
+            for (const rule of (Array.isArray(perms?.[kind]) ? perms[kind] : []).filter((x) => typeof x === "string")) {
+                const key = `${kind}:${rule}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const mapped = mapRule(rule);
+                const item = (action, note) => ({ kind, name: rule, source, action, note, data: mapped });
+                if (!mapped)
+                    out.push(item("skip", "o Brito não tem tool equivalente"));
+                else if (have[kind].includes(mapped))
+                    out.push(item("skip", "já existe"));
+                else if (kind === "allow" && !includeAllow)
+                    out.push(item("skip", "libera ações sem perguntar: use --incluir-allow para importar"));
+                else
+                    out.push(item("import", mapped !== rule ? `vira ${mapped}` : undefined));
+            }
+        }
+    }
+    return out;
+}
+/** Memória do Claude Code deste projeto: `~/.claude/projects/<caminho com - no lugar de separadores>/memory/*.md`. */
+export const memoryDirOf = (root, home) => path.join(home, "projects", path.resolve(root).replace(/[^a-zA-Z0-9]/g, "-"), "memory");
+const NOTE_KIND = { feedback: "convention", project: "decision", user: "learning", reference: "learning" };
+function planMemory(root, home) {
+    const dir = memoryDirOf(root, home);
+    return mdIn(dir).filter((f) => f !== "MEMORY.md").flatMap((f) => {
+        const text = readText(path.join(dir, f)) ?? "";
+        const fm = parseRichFrontmatter(text);
+        const body = (fm?.body ?? text).trim();
+        const source = `~/.claude/projects/…/memory/${f}`;
+        if (body.length < 10)
+            return [{ kind: "memory", name: f, source, action: "skip", note: "vazia" }];
+        const type = fm?.meta.type ?? /^\s*type:\s*(\w+)/m.exec(text.slice(0, text.indexOf("\n---", 3) + 1))?.[1] ?? ""; // `type` pode estar aninhado em metadata:
+        const title = fm?.meta.name ?? f.replace(/\.md$/, "");
+        const lint = lintSkill({ name: "x", description: title, body });
+        if (lint.errors.length)
+            return [{ kind: "memory", name: f, source, action: "skip", note: `não importada: ${lint.errors.join("; ")}` }];
+        const id = `cc-${crypto.createHash("sha1").update(f + body).digest("hex").slice(0, 16)}`;
+        return [{ kind: "memory", name: title, source, action: "import", data: { id, kind: NOTE_KIND[type] ?? "learning", text: `[importada do Claude Code] ${title}: ${body}`.slice(0, 2000) } }];
+    });
+}
+export function planImport(root, options = {}) {
+    const home = options.claudeHome ?? claudeHome();
+    const items = [
+        ...planSkills(root, home),
+        ...planAgents(root, home),
+        ...planRules(root, home, !!options.includeAllow),
+        ...(options.includeMemory ? planMemory(root, home) : []),
+    ];
+    const claudeMd = ["CLAUDE.md", path.join(".claude", "CLAUDE.md")].find((f) => fs.existsSync(path.join(root, f)));
+    if (claudeMd)
+        items.push({ kind: "info", name: claudeMd, source: claudeMd, action: "skip", note: "o Brito já lê o CLAUDE.md sozinho; nada a importar" });
+    if (fs.existsSync(path.join(root, ".mcp.json")))
+        items.push({ kind: "info", name: ".mcp.json", source: ".mcp.json", action: "skip", note: "o Brito ainda não conecta a servidores MCP externos; os servidores não foram importados" });
+    return { items, options };
+}
+/** Grava o plano (menos as notas de memória, que precisam do grafo: ficam em `result.notes` para quem tem a conexão). */
+export function applyImport(root, plan) {
+    const res = { skills: 0, agents: 0, rules: 0, pending: 0, notes: [], errors: [] };
+    const today = new Date().toISOString().slice(0, 10);
+    for (const it of plan.items) {
+        if (it.action !== "import")
+            continue;
+        try {
+            if (it.kind === "skill") {
+                const d = it.data;
+                if (it.pending) {
+                    savePending(root, { ...d, reason: `importada do Claude Code (${it.source})` }, it.scope);
+                    res.pending++;
+                    continue;
+                }
+                const skill = { name: d.name, description: d.description, version: 1, uses: 0, created: today, updated: today, lastUsed: today, refs: [], status: "trial", origin: "auto", wins: 0, losses: 0, body: d.body, scope: it.scope ?? "project", invoke: d.invoke, model: "", lastLoss: "", by: IMPORT_TAG };
+                writeSkill(root, skill);
+                res.skills++;
+            }
+            else if (it.kind === "agent") {
+                const d = it.data;
+                const file = path.join(root, ".brito", "agents", `${it.name}.md`);
+                fs.mkdirSync(path.dirname(file), { recursive: true });
+                fs.writeFileSync(file, stringifyFrontmatter({ name: it.name, description: d.description, ...(d.tools !== "all" ? { tools: d.tools.join(", ") } : {}), ...(d.model ? { model: d.model } : {}), imported: IMPORT_TAG }, d.body));
+                res.agents++;
+            }
+            else if (it.kind === "deny" || it.kind === "allow") {
+                addRule(root, it.kind, it.data);
+                res.rules++;
+            }
+            else if (it.kind === "memory") {
+                res.notes.push(it.data);
+            }
+        }
+        catch (e) {
+            res.errors.push(`${it.kind} ${it.name}: ${e?.message ?? e}`);
+        }
+    }
+    return res;
+}
+/** Desfaz o que o import criou: skills (vão para a lixeira do escopo) e agentes marcados. Regras e notas ficam: apague à mão. */
+export function undoImport(root) {
+    let skills = 0, agents = 0;
+    for (const s of listSkills(root))
+        if (s.by === IMPORT_TAG && deleteSkill(root, s.name, s.scope))
+            skills++;
+    const dir = path.join(root, ".brito", "agents");
+    for (const f of mdIn(dir)) {
+        const text = readText(path.join(dir, f)) ?? "";
+        if (parseRichFrontmatter(text)?.meta.imported === IMPORT_TAG) {
+            fs.rmSync(path.join(dir, f));
+            agents++;
+        }
+    }
+    return { skills, agents };
+}
+const LABEL = { skill: "skill", agent: "agente", deny: "deny", allow: "allow", memory: "memória", info: "aviso" };
+/** Relatório legível do plano (antes de gravar) ou do resultado. */
+export function describePlan(plan) {
+    const lines = plan.items.map((i) => `${i.action === "import" ? "+" : "·"} ${LABEL[i.kind]} ${i.name} ← ${i.source}${i.note ? ` (${i.note})` : ""}`);
+    const n = (k) => plan.items.filter((i) => i.kind === k && i.action === "import").length;
+    lines.push(`resumo: ${n("skill")} skill(s), ${n("agent")} agente(s), ${n("deny") + n("allow")} regra(s), ${n("memory")} nota(s) a importar; ${plan.items.filter((i) => i.action === "skip" && i.kind !== "info").length} ignorado(s)`);
+    return lines;
+}

package/dist/local/compact.js

@@ -0,0 +1,66 @@
+import { slmGenerate, slmStatus } from "./slm.js";
+import { slmStats } from "./stats.js";
+export const slmCompactEnabled = () => process.env.BRITO_SLM_COMPACT !== "off";
+/** Tamanho de cada fatia em caracteres (~2,5k tokens de JSON de conversa: cabe com folga junto do prompt e da saída). */
+const CHUNK_CHARS = 9_000;
+/** Teto de reduções encadeadas, para nunca entrar em laço. */
+const MAX_ROUNDS = 3;
+const SYSTEM = "Você resume trechos de uma conversa de um agente de programação. Preserve: objetivo, decisões, arquivos e símbolos tocados (caminhos exatos), erros encontrados, estado atual e próximos passos. Não invente nada que não esteja no texto. Seja denso e use tópicos curtos. Responda só com o resumo.";
+/** Fatia em pedaços de até `size` caracteres, preferindo cortar em quebra de linha ou vírgula. */
+export function chunkText(text, size = CHUNK_CHARS) {
+    const out = [];
+    let i = 0;
+    while (i < text.length) {
+        let end = Math.min(i + size, text.length);
+        if (end < text.length) {
+            const cut = Math.max(text.lastIndexOf("\n", end), text.lastIndexOf(",", end));
+            if (cut > i + size * 0.5)
+                end = cut + 1;
+        }
+        out.push(text.slice(i, end));
+        i = end;
+    }
+    return out;
+}
+/** Resume `text` com o SLM. `null` = não deu (indisponível, erro ou resposta vazia). */
+export async function slmSummarize(text, gen = slmGenerate, signal) {
+    try {
+        let parts = chunkText(text);
+        for (let round = 0; round < MAX_ROUNDS; round++) {
+            const sums = [];
+            for (const p of parts) {
+                const s = (await gen({ system: SYSTEM, user: p, maxTokens: 700, temperature: 0.1, signal })).trim();
+                if (s)
+                    sums.push(s);
+            }
+            if (!sums.length)
+                return null;
+            const joined = sums.join("\n\n");
+            if (joined.length <= CHUNK_CHARS)
+                return joined;
+            parts = chunkText(joined);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resumo da compactação via SLM, ou `null` quando o SLM não está pronto/habilitado ou falhou.
+ * Registra a economia em `slmStats` (tokens que o modelo principal não precisou ler).
+ */
+export async function slmCompactSummary(text, gen = slmGenerate) {
+    if (!slmCompactEnabled())
+        return null;
+    if (gen === slmGenerate && !(await slmStatus()).ready)
+        return null;
+    const s = await slmSummarize(text, gen);
+    if (s === null) {
+        slmStats.compactFallbacks++;
+        return null;
+    }
+    slmStats.compactCalls++;
+    slmStats.tokensSaved += Math.max(0, Math.ceil((text.length - s.length) / 4));
+    return s;
+}

package/dist/local/slm.js

@@ -1,3 +1,4 @@
+import { setReflector } from "../skills/by.js";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
@@ -209,10 +210,13 @@ export function withSlm(fallback) {
     return async (req) => {
         if (!slmDisabled() && (await slmStatus()).ready) {
             try {
-                return await slmComplete(req);
+                const r = await slmComplete(req);
+                setReflector("slm");
+                return r;
             }
             catch { /* cai no modelo de sempre */ }
         }
+        setReflector(req.model || "remoto");
         return fallback(req);
     };
 }

package/dist/local/stats.js

@@ -0,0 +1,17 @@
+/** Contadores da sessão sobre o trabalho delegado ao SLM local (para o `/context` provar a economia). */
+export const slmStats = {
+    /** compactações resumidas pelo SLM */
+    compactCalls: 0,
+    /** vezes que o SLM falhou e o modelo de sempre resumiu */
+    compactFallbacks: 0,
+    /** estimativa: tokens de entrada que o modelo principal deixou de processar (texto original − resumo) */
+    tokensSaved: 0,
+};
+export const resetSlmStats = () => { slmStats.compactCalls = 0; slmStats.compactFallbacks = 0; slmStats.tokensSaved = 0; };
+/** Linha para o `/context`; `null` quando o SLM não fez nada. */
+export function slmStatsLine() {
+    const { compactCalls: c, compactFallbacks: f, tokensSaved: t } = slmStats;
+    if (!c && !f)
+        return null;
+    return `SLM local: ${c} compactaç${c === 1 ? "ão" : "ões"} (~${t.toLocaleString("pt-BR")} tokens poupados)${f ? `, ${f} falha${f === 1 ? "" : "s"} (caiu no Claude)` : ""}`;
+}

package/dist/provider/resolve.js

@@ -7,6 +7,7 @@ const SLM_PROFILE = {
 };
 /** Janela dos modelos Claude quando nada informa outra. */
 const CLAUDE_WINDOW = 200_000;
+const CLAUDE_1M_WINDOW = 1_000_000;
 const COMPACT_DEFAULT = 120_000;
 /** Nome → provedor: perfil configurado (sem diferenciar maiúsculas) > alias do Claude > id cru do Claude. */
 export function resolveModel(name) {
@@ -17,7 +18,8 @@ export function resolveModel(name) {
     if (profile)
         return { kind: "openai", name: key, wireModel: profile.model, label: profile.label, contextWindow: profile.contextWindow, profile };
     const wire = MODEL_ALIASES[key] ?? name.trim();
-    return { kind: "anthropic", name: wire, wireModel: wire, label: wire, contextWindow: CLAUDE_WINDOW };
+    // sufixo [1m] (ex.: claude-sonnet-5-5[1m]) = contexto de 1M tokens
+    return { kind: "anthropic", name: wire, wireModel: wire, label: wire, contextWindow: /\[1m\]/i.test(wire) ? CLAUDE_1M_WINDOW : CLAUDE_WINDOW };
 }
 /** Janela mostrada na barra/`/context`: BRITO_CONTEXT_WINDOW > perfil > padrão do Claude. */
 export function contextWindowFor(name) {

package/dist/skills/by.js

@@ -0,0 +1,7 @@
+/**
+ * Quem gerou a última resposta da reflexão: `slm` (modelo local) ou o id do modelo remoto. Fica num módulo próprio
+ * para `withSlm` (que decide o motor) e `reflect` (que grava a autoria na skill) não dependerem um do outro.
+ */
+let last = "";
+export const setReflector = (by) => { last = by; };
+export const lastReflector = () => last;

package/dist/skills/learn.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { execTool, toApiTools } from "../tools/registry.js";
 import { perms } from "../permissions.js";
 import { getSkill, listPending, listSkills, savePending, staleRefs } from "./store.js";
+import { lastReflector } from "./by.js";
 import { saveAuto, skillsMode, recordOutcome } from "./trial.js";
 import { appendJournal, describeEntry, entryFromTurn, similarEntries } from "./journal.js";
 /** Turno longo sem nenhum outro sinal só vale reflexão a partir deste tamanho. */
@@ -191,12 +192,12 @@ export function buildReflectInput(turn, ctx, previous) {
 }
 const SaveArgs = z.object({ name: z.string(), description: z.string(), body: z.string(), refs: z.array(z.string()).default([]), reason: z.string().default(""), scope: z.enum(["project", "global"]).optional() });
 /** Modo autônomo: grava em teste (ou na fila de revisão, se for arriscado) sem perguntar ao usuário. */
-function stageAuto(input, ctx) {
+function stageAuto(input, ctx, by = "") {
     const parsed = SaveArgs.safeParse(input);
     if (!parsed.success)
         return { saved: false, msg: "skill não salva: input inválido" };
     try {
-        return saveAuto(ctx.root, parsed.data);
+        return saveAuto(ctx.root, parsed.data, Date.now(), by);
     }
     catch (e) {
         return { saved: false, msg: `skill não salva: ${e?.message ?? e}` };
@@ -217,6 +218,7 @@ function stage(input, ctx) {
 /** Roda a reflexão e salva (com aprovação do usuário, via skill_save) as skills propostas. Devolve mensagens de status. */
 export async function reflect(turn, ctx, model, complete = defaultComplete, previous) {
     const content = await complete({ model, maxTokens: 3000, system: SYSTEM, tools: toApiTools(new Set(["skill_save"])), user: buildReflectInput(turn, ctx, previous) });
+    const by = lastReflector() || model;
     const out = [];
     const saved = [];
     let saves = 0;
@@ -226,7 +228,7 @@ export async function reflect(turn, ctx, model, complete = defaultComplete, prev
         saves++;
         const name = String(b.input?.name ?? "");
         if (skillsMode() === "auto") {
-            const r = stageAuto(b.input, ctx);
+            const r = stageAuto(b.input, ctx, by);
             out.push(r.msg);
             if (r.saved)
                 saved.push(name);

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/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,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "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": {