brito-cli 0.10.1 → 0.11.0

package/README.md

@@ -93,6 +93,7 @@ The lint **rejects** secrets/tokens, absolute user paths, credentials in URLs (`
 
 - **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.
+- **Route decider (shadow mode)**: the local SLM classifies each request as `claude`, `slm` or `tool` after the turn and logs it next to what the turn really needed; it changes nothing yet. `/route` (or `/route all`) shows how much it would delegate and its expensive errors. Logs in `~/.brito/routing/`; `BRITO_ROUTE=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

@@ -88,6 +88,8 @@ O lint **rejeita** segredos/tokens, caminhos absolutos do usuário, credenciais
 - **Tool `digest`**: batedor e refinador de textos longos. O modelo local escolhe os blocos mais ligados ao seu objetivo e propõe trechos; o código confere cada citação contra a fonte e descarta o que não existe, e o modelo principal recebe um rascunho pequeno em markdown com citações verificadas e números de página.
 
 - **Fallback quando o Claude acaba**: cadeia Claude → perfil `qwen` → SLM local, com o loop completo do agente e as tools (mesmas permissões). É temporário: passada a janela (o horário de reset que o erro informa, senão 10 min, ou 60 min para cota/auth; `BRITO_FALLBACK_MINUTES` sobrepõe) o próximo turno tenta o Claude de novo. O `/fallback` mostra quando. Um modelo de 4B erra mais com tools: use para continuar, não para tarefas grandes. `BRITO_SLM_FALLBACK=off` tira o SLM da cadeia; `BRITO_SLM_CTX` define o contexto.
+- **Compactação de contexto no SLM local**: ao compactar a conversa, o meio é resumido pelo SLM local (map-reduce em fatias) em vez do Claude, poupando tokens; em qualquer falha volta ao Claude. O `/context` mostra as compactações e os tokens poupados estimados. `BRITO_SLM_COMPACT=off` desliga.
+- **Decisor de destino (modo sombra)**: o SLM local classifica cada pedido como `claude`, `slm` ou `tool` depois do turno e grava ao lado do que o turno realmente exigiu; ainda não muda nada. `/route` (ou `/route all`) mostra quanto ele delegaria e os erros caros. Registros em `~/.brito/routing/`; `BRITO_ROUTE=off` desliga.
 
 `BRITO_SLM=off` desliga; `BRITO_SLM_MODEL` aponta para outro GGUF (URI `hf:` ou caminho de arquivo).
 

package/dist/cli.js

@@ -36,6 +36,9 @@ 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 { shadowRoute, readRoutes } from "./route/log.js";
+import { renderRouteStats } from "./route/stats.js";
+import { routeEnabled } from "./route/decide.js";
 import { usageCommand } from "./usage/command.js";
 import { buildSystemPrompt, graphStatsLine, memoSystem, systemKey } from "./agent/prompt.js";
 import { allTools } from "./tools/registry.js";
@@ -133,7 +136,7 @@ program
 });
 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")
+    .description("Modelo nativo embutido (llama.cpp, roda na sua máquina, sem tokens): status | pull (baixa) | rm (apaga). Faz reflexão de skills, compactação e digest; desligue com BRITO_SLM=off")
     .action(async (acao) => {
     const st = await slmStatus();
     if (acao === "pull") {
@@ -523,12 +526,24 @@ const skillsCommand = (root, io, llm) => ({
             ui.info(`${pending.length} proposta(s) pendente(s): /skills pending`);
     },
 });
+/** `/route [all]`: o que o decisor de destino (claude/slm/tool) teria feito nos turnos já registrados, em modo sombra. */
+const routeCommand = (root) => ({
+    desc: "decisor claude/slm/tool em modo sombra: estatísticas dos turnos (all = todos os repositórios)",
+    run: async (args) => {
+        const all = args[0] === "all";
+        for (const l of renderRouteStats(readRoutes(all ? undefined : root), all ? "todos os repositórios" : "este repositório", routeEnabled()))
+            ui.print(c.muted(`  ${l}`));
+    },
+});
 /** Reflexão pós-turno que propõe skills (gatilho automático ou `/learn`). Independe do backend: só muda a origem do turno e o modelo. */
 function makeLearner(getTurns, ctx, complete, getModel) {
     return async (force = false) => {
         const model = getModel();
         const turns = getTurns();
         const turn = turns[turns.length - 1] ?? null;
+        // Modo sombra do decisor de destino: registra o que ele escolheria e o que o turno exigiu. Não bloqueia o REPL.
+        if (!force)
+            void shadowRoute(ctx.root, turn);
         // O resultado do turno vira evidência para as skills usadas nele (promoção/arquivamento), antes de refletir.
         if (!force)
             for (const n of [...recordOutcomes(turn, ctx), ...(skillsMode() === "off" ? [] : expireTrials(ctx.root))])
@@ -572,7 +587,7 @@ function makeLearner(getTurns, ctx, complete, getModel) {
 function orchestratorCommand(main) {
     const usage = "  uso: /orquestrar on|off [modelo <perfil>] [--global] · /orquestrar modelo <perfil> [--global]";
     return {
-        desc: "modo orquestrador: o modelo principal planeja e revisa, um perfil (qwen) implementa",
+        desc: "modo orquestrador: o modelo principal planeja e revisa; um perfil de endpoint (qwen) escreve o código, poupando tokens do Claude",
         run: async (args) => {
             const global = args.includes("--global");
             const words = args.filter((a) => !a.startsWith("--"));
@@ -765,6 +780,7 @@ async function buildApiBackend(root, model, io, o = {}) {
             "/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); } },
+            "/route": routeCommand(root),
             "/skills": skillsCommand(root, io, { complete: withSlm(defaultComplete), model: learnModel }),
             "/permissions": permissionsCommand(root),
             "/todos": { desc: "lista de tarefas da sessão", run: async () => { ctx.todos?.length ? ui.printTodos(ctx.todos) : ui.print(c.muted("  sem lista de tarefas nesta sessão")); } },
@@ -934,6 +950,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); } },
+            "/route": routeCommand(root),
             "/skills": skillsCommand(root, io, { complete: withSlm(claudeCliComplete), model: () => process.env.BRITO_LEARN_MODEL ?? "" }),
             "/permissions": permissionsCommand(root),
             "/sessions": sessionsCommand(root, () => session.sessionId),

package/dist/desktop/serve.js

@@ -1,4 +1,5 @@
 import { fetchPlanUsage } from "../usage/plan.js";
+import { slmUsage } from "../local/stats.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -26,12 +27,18 @@ import { buildSystemPrompt, graphStatsLine, memoSystem, systemKey } from "../age
 import { openGraphAfterClaude } from "../graph/store.js";
 import { indexProject } from "../graph/indexer.js";
 import { initialEffort, initialModel, isEffort, loadProfiles, MODEL_ALIASES } from "../model.js";
-import { NO_ANTHROPIC, fallbackStatus, openEngine } from "../engine.js";
+import { NO_ANTHROPIC, fallbackStatus, learnerModel, openEngine } from "../engine.js";
 import { engineChip, activateFallback, chooseModel, cliShouldFallBack, fallbackWarning, newFallbackState, renderFallback, retryPrompt } from "../provider/fallback.js";
 import { contextWindowFor, resolveModel } from "../provider/resolve.js";
 import { PLAN_NOTE, perms } from "../permissions.js";
 import { ORCH_NOTE, implStatus, mainTools, orch, orchGuard, restoreOrch } from "../orchestrator.js";
-import { getSkill, listBuiltins, listSkills, skillsIndex } from "../skills/store.js";
+import { getSkill, listBuiltins, listPending, listSkills, skillsIndex } from "../skills/store.js";
+import { defaultComplete, recordOutcomes, reflect, shouldReflect } from "../skills/learn.js";
+import { claudeCliComplete } from "../skills/learn-cli.js";
+import { autoConsolidate } from "../skills/consolidate.js";
+import { expireTrials, skillsMode } from "../skills/trial.js";
+import { withSlm } from "../local/slm.js";
+import { shadowRoute } from "../route/log.js";
 /**
  * Backend do app desktop, controlado por JSON em linhas.
  * stdin  → {t:"send",text} {t:"abort"} {t:"approve",id,allow,scope?:"session"|"project"} {t:"config",model?,effort?,mode?,orch?} {t:"reset"} {t:"query"} {t:"action"} {t:"quit"}
@@ -53,6 +60,7 @@ const BUILTIN_COMMANDS = [
     { name: "clear", description: "limpa a conversa", kind: "builtin" },
     { name: "fallback", description: "estado do fallback Claude → modelo local", kind: "builtin" },
     { name: "help", description: "lista os comandos", kind: "builtin" },
+    { name: "learn", description: "extrai skills do último turno agora", kind: "builtin" },
 ];
 /** Arquivos do projeto para o `@`: git ls-files (respeita .gitignore); sem git, uma varredura rasa. */
 let fileCache = null;
@@ -114,6 +122,50 @@ const sink = {
     warn: (msg) => emit({ t: "warn", msg }),
     error: (msg) => emit({ t: "error", msg }),
 };
+/**
+ * Reflexão pós-turno que propõe skills (gatilho automático ou `/learn`), igual à do terminal, mas avisando a janela
+ * com eventos `skill` (refletindo → resultado + nº de propostas pendentes) em vez de imprimir.
+ */
+function makeLearner(getTurns, ctx, complete, getModel) {
+    let seen = null; // turno já analisado: um turno abortado/falho não reanalisa o anterior
+    const done = (notes) => emit({ t: "skill", phase: "done", notes, pending: listPending(ctx.root).length });
+    return async (force = false) => {
+        const turns = getTurns();
+        const turn = turns[turns.length - 1] ?? null;
+        if (!force && turn === seen)
+            return;
+        if (!force)
+            void shadowRoute(ctx.root, turn); // modo sombra do decisor de destino; não bloqueia
+        const model = getModel();
+        try {
+            const outcomes = force ? [] : [...recordOutcomes(turn, ctx), ...(skillsMode() === "off" ? [] : expireTrials(ctx.root))];
+            if (!force && !shouldReflect(turn, ctx)) {
+                seen = turn;
+                ctx.loadedSkills?.clear();
+                if (outcomes.length)
+                    done(outcomes);
+                return;
+            }
+            if (!turn) {
+                emit({ t: "skill", phase: "done", notes: ["Nada para refletir ainda."], pending: listPending(ctx.root).length });
+                return;
+            }
+            seen = turn;
+            emit({ t: "skill", phase: "reflecting" });
+            const notes = await reflect(turn, ctx, model, complete, turns[turns.length - 2]);
+            if (skillsMode() === "auto") {
+                try {
+                    notes.push(...await autoConsolidate(ctx.root, model, complete));
+                }
+                catch { /* manutenção é opcional */ }
+            }
+            done([...outcomes, ...(notes.length ? notes : ["nenhuma skill nova"])]);
+        }
+        catch (e) {
+            emit({ t: "skill", phase: "error", notes: [`reflexão falhou: ${e?.message ?? e}`], pending: listPending(ctx.root).length });
+        }
+    };
+}
 const apiLabel = (m) => (resolveModel(m).kind === "openai" ? "endpoint" : "API Anthropic");
 export async function serveDesktop(root, resumeId) {
     const pending = new Map();
@@ -175,6 +227,7 @@ export async function serveDesktop(root, resumeId) {
         if (o.session?.todos)
             ctx.todos = o.session.todos;
         let ac = null;
+        const learn = makeLearner(() => agent.recentTurns, ctx, withSlm(defaultComplete), () => learnerModel(agent.model, process.env));
         const id = o.session?.id ?? randomUUID();
         // Depois de uma troca a partir do claude CLI quem guarda a conversa é ele (o id é o dele): nada a salvar aqui.
         const persist = () => {
@@ -188,7 +241,7 @@ export async function serveDesktop(root, resumeId) {
             }
         };
         return {
-            kind: "api", effort: "", fallback,
+            kind: "api", effort: "", fallback, learn,
             // Depois da troca o id segue o do claude: a janela o guarda para retomar a conversa ao reabrir.
             get sessionId() { return o.back?.engine.sessionId ?? id; },
             get model() { return agent.model; }, set model(m) { agent.model = m; },
@@ -282,6 +335,9 @@ export async function serveDesktop(root, resumeId) {
             // Dentro do Electron o executável é o próprio app: este env o faz agir como Node nos filhos (claude → mcp-serve).
             env: process.versions.electron || process.env.ELECTRON_RUN_AS_NODE ? { ELECTRON_RUN_AS_NODE: "1" } : undefined,
         });
+        // O grafo fica com o servidor MCP; skill_save só usa o store de skills, então `graph` não é tocado.
+        const learnCtx = { root, graph: undefined, ask, sync: async () => { }, dirty: false, loadedSkills: session.loadedSkills };
+        const learn = makeLearner(() => session.recentTurns, learnCtx, withSlm(claudeCliComplete), () => process.env.BRITO_LEARN_MODEL ?? "");
         if (resumeId)
             session.resume(resumeId);
         let resumed = !!resumeId; // até o primeiro reset
@@ -290,7 +346,7 @@ export async function serveDesktop(root, resumeId) {
         /** Fechamento do grafo do modo API na volta para cá (ver `back.release`). */
         let graphReleased = Promise.resolve();
         const claude = {
-            kind: "claude", fallback,
+            kind: "claude", fallback, learn,
             get sessionId() { return session.sessionId; },
             get model() { return session.model; },
             get effort() { return session.effort; }, set effort(e) { session.effort = e; },
@@ -380,11 +436,16 @@ export async function serveDesktop(root, resumeId) {
                 }
                 busy = true;
                 try {
-                    await engine.send(text);
+                    if (cmd === "/learn")
+                        await engine.learn(true);
+                    else {
+                        await engine.send(text);
+                        await engine.learn();
+                    }
                 }
                 finally {
                     busy = false;
-                    emit({ t: "usage", ...engine.stats(), model: engine.model, sessionId: engine.sessionId, fallback: engine.fallback.active, chip: chipOf(engine.model, engine.fallback) });
+                    emit({ t: "usage", ...engine.stats(), slm: slmUsage(), model: engine.model, sessionId: engine.sessionId, fallback: engine.fallback.active, chip: chipOf(engine.model, engine.fallback) });
                 }
                 break;
             }
@@ -409,7 +470,7 @@ export async function serveDesktop(root, resumeId) {
                         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 };
+                        data = { plan: await fetchPlanUsage({ force: arg === "force" }), session: engine.stats(), slm: slmUsage(), model: engine.model };
                     else if (m.q === "models")
                         data = { aliases: Object.keys(MODEL_ALIASES), profiles: Object.keys(loadProfiles().profiles) };
                 }

package/dist/local/slm.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { globalHome } from "../skills/store.js";
+import { recordSlmCall } from "./stats.js";
 /**
  * SLM embutido (llama.cpp via `node-llama-cpp`, dependência OPCIONAL): roda dentro do processo, sem servidor.
  * Hoje serve às tarefas auxiliares (reflexão que propõe skills). Só entra em ação depois de `brito slm pull`
@@ -104,12 +105,16 @@ export async function slmGenerate(o) {
     const lib = await loadLib();
     const { model, llama } = await ensureLoaded();
     const context = await model.createContext({ contextSize: { max: 8192 } });
+    const t0 = Date.now();
+    let out = "";
     try {
         const session = new lib.LlamaChatSession({ contextSequence: context.getSequence(), systemPrompt: o.system });
         const grammar = o.schema ? await llama.createGrammarForJsonSchema(o.schema) : undefined;
-        return await session.prompt(o.user, { grammar, maxTokens: o.maxTokens ?? 1500, temperature: o.temperature ?? 0.2, signal: o.signal });
+        out = await session.prompt(o.user, { grammar, maxTokens: o.maxTokens ?? 1500, temperature: o.temperature ?? 0.2, signal: o.signal });
+        return out;
     }
     finally {
+        recordSlmCall(o.system.length + o.user.length, out.length, Date.now() - t0);
         await context.dispose();
         scheduleUnload();
     }
@@ -122,6 +127,8 @@ export async function slmChat(o) {
     const lib = await loadLib();
     const { model } = await ensureLoaded();
     const context = await model.createContext({ contextSize: { max: slmChatCtx() } });
+    const t0 = Date.now();
+    let outChars = 0;
     try {
         const chat = new lib.LlamaChat({ contextSequence: context.getSequence() });
         const functions = o.functions && Object.keys(o.functions).length
@@ -133,9 +140,11 @@ export async function slmChat(o) {
                 o.onText?.(t); },
         });
         const calls = (res.functionCalls ?? []).map((c) => ({ name: String(c.functionName), input: c.params ?? {} }));
+        outChars = String(res.response ?? "").length + JSON.stringify(calls).length;
         return { text: String(res.response ?? ""), calls, truncated: res.metadata?.stopReason === "maxTokens" };
     }
     finally {
+        recordSlmCall(JSON.stringify(o.history).length + (o.functions ? JSON.stringify(o.functions).length : 0), outChars, Date.now() - t0);
         await context.dispose();
         scheduleUnload();
     }

package/dist/local/stats.js

@@ -6,8 +6,34 @@ export const slmStats = {
     compactFallbacks: 0,
     /** estimativa: tokens de entrada que o modelo principal deixou de processar (texto original − resumo) */
     tokensSaved: 0,
+    /** TODA geração feita no SLM local (compactação, digest, reflexão, roteador, fallback): é o "gasto" local */
+    calls: 0,
+    /** estimativa (~4 caracteres/token) do que o SLM leu e escreveu */
+    tokensIn: 0,
+    tokensOut: 0,
+    ms: 0,
 };
-export const resetSlmStats = () => { slmStats.compactCalls = 0; slmStats.compactFallbacks = 0; slmStats.tokensSaved = 0; };
+export const resetSlmStats = () => {
+    slmStats.compactCalls = 0;
+    slmStats.compactFallbacks = 0;
+    slmStats.tokensSaved = 0;
+    slmStats.calls = 0;
+    slmStats.tokensIn = 0;
+    slmStats.tokensOut = 0;
+    slmStats.ms = 0;
+};
+const est = (chars) => Math.ceil(chars / 4);
+/** Registra uma geração do SLM (chamada por `slmGenerate`/`slmChat`; mesmo se falhar, o custo local existiu). */
+export function recordSlmCall(inChars, outChars, ms) {
+    slmStats.calls++;
+    slmStats.tokensIn += est(inChars);
+    slmStats.tokensOut += est(outChars);
+    slmStats.ms += ms;
+}
+/** Resumo do gasto local para a barra de status/painel; `null` enquanto o SLM não foi usado. */
+export function slmUsage() {
+    return slmStats.calls ? { calls: slmStats.calls, tokensIn: slmStats.tokensIn, tokensOut: slmStats.tokensOut, ms: slmStats.ms, tokensSaved: slmStats.tokensSaved } : null;
+}
 /** Linha para o `/context`; `null` quando o SLM não fez nada. */
 export function slmStatsLine() {
     const { compactCalls: c, compactFallbacks: f, tokensSaved: t } = slmStats;

package/dist/provider/fallback.js

@@ -176,7 +176,7 @@ const hhmm = (ms) => { const d = new Date(ms); return `${String(d.getHours()).pa
  */
 export function engineChip(model, fb) {
     const r = resolveModel(model);
-    const where = r.kind === "anthropic" ? "☁ nuvem" : r.local ? "💻 local" : "🌐 endpoint";
+    const where = r.kind === "anthropic" ? "☁ Claude (nuvem, usa tokens)" : r.local ? "💻 nativo (na sua máquina, sem tokens)" : "🌐 endpoint (servidor próprio)";
     const text = `${where} · ${r.label}`;
     if (!fb?.active)
         return { text, fallback: false };

package/dist/repl.js

@@ -6,6 +6,7 @@ import { randomBytes } from "node:crypto";
 import { Dock } from "./ui/dock.js";
 import os from "node:os";
 import { ui, c, fmtTokens } from "./ui/ui.js";
+import { slmUsage } from "./local/stats.js";
 import { cols } from "./ui/theme.js";
 import { engineChip } from "./provider/fallback.js";
 /** Nome do usuário da máquina (fallback para variáveis de ambiente). */
@@ -103,7 +104,7 @@ export async function runRepl(b, o) {
         mode: modeChip(),
         engine: engineChip(b.model(), b.fallback?.()),
         model: b.model(), ctxTokens: b.contextTokens(), ctxWindow: b.ctxWindow,
-        input: b.usage().input, output: b.usage().output, cacheRead: b.usage().cacheRead, startedAt: o.startedAt, cost: b.cost?.(),
+        input: b.usage().input, output: b.usage().output, cacheRead: b.usage().cacheRead, startedAt: o.startedAt, cost: b.cost?.(), slm: slmUsage(),
         extra: `${skillCount} ${skillCount === 1 ? "skill" : "skills"}`,
     });
     if (interactive && process.stdout.isTTY)

package/dist/route/decide.js

@@ -0,0 +1,42 @@
+import { slmGenerate, slmStatus } from "../local/slm.js";
+export const ROUTE_NAMES = ["slm", "claude", "tool"];
+export const ROUTE_DESC = {
+    slm: "Condensar, resumir, extrair, traduzir, reformatar ou rotular um texto que já veio no pedido (log, diff, saída de comando), sem raciocinar sobre o código nem alterá-lo",
+    claude: "Raciocinar, depurar, projetar, implementar, refatorar ou revisar código; decisões de arquitetura; tarefas de várias etapas",
+    tool: "Consultar o projeto ou executar um comando direto: localizar símbolos, quem chama quem, listar ou abrir arquivos, rodar testes, build ou git",
+};
+/** `BRITO_ROUTE=off` desliga o registro em modo sombra. */
+export const routeEnabled = () => process.env.BRITO_ROUTE !== "off";
+const SCHEMA = { type: "object", properties: { route: { enum: [...ROUTE_NAMES] } }, required: ["route"] };
+const SYSTEM = `Você é um roteador. Escolha o destino de um pedido feito a um agente de programação.\n${ROUTE_NAMES.map((r) => `- ${r}: ${ROUTE_DESC[r]}`).join("\n")}\nResponda só com o JSON {"route": "..."}.`;
+/** O pedido é só classificado: o começo basta e protege a janela do SLM. */
+const MAX_CHARS = 1500;
+/** Lê a saída do SLM; qualquer coisa fora do enum vira `null`. */
+export function parseRoute(out) {
+    try {
+        const r = JSON.parse(out)?.route;
+        return ROUTE_NAMES.includes(r) ? r : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Decide o destino. `ready` e `gen` são injetáveis para teste; por padrão usa o SLM local se ele estiver baixado e
+ * habilitado. Nunca lança: o pior caso é `{ route: "claude", source: "default" }`.
+ */
+export async function decideRoute(text, opts = {}) {
+    const t0 = performance.now();
+    const dflt = () => ({ route: "claude", source: "default", ms: Math.round(performance.now() - t0) });
+    try {
+        const ready = await (opts.ready ?? (async () => (await slmStatus()).ready))();
+        if (!ready)
+            return dflt();
+        const out = await (opts.gen ?? slmGenerate)({ system: SYSTEM, user: text.slice(0, MAX_CHARS), schema: SCHEMA, maxTokens: 20, temperature: 0 });
+        const route = parseRoute(out);
+        return route ? { route, source: "qwen", ms: Math.round(performance.now() - t0) } : dflt();
+    }
+    catch {
+        return dflt();
+    }
+}

package/dist/route/log.js

@@ -0,0 +1,118 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { globalHome } from "../skills/store.js";
+import { decideRoute, routeEnabled } from "./decide.js";
+const TEXT_MAX = 400;
+// ------------------------------------------------------------------ rótulo implícito
+/** Tools que, se usadas, mostram que o pedido exigia o Claude. */
+const CLAUDE_TOOLS = new Set(["write_file", "edit_file", "implement", "delegate", "skill_save", "skill_delete", "spec_save", "exit_plan", "todo_write"]);
+/** Comandos de shell que equivalem a uma consulta/execução direta (ler estado, rodar testes/build). */
+const DIRECT_BASH = /^\s*(git\s+(status|log|diff|branch|show|rev-parse|remote)|ls|cat|head|tail|pwd|wc|node\s+(-v|--version)|npm\s+(test|run\s+(test|build|typecheck|lint)|ls|view)|npx\s+(tsc|tsx\s+--test)|tsc|yarn\s+(test|build|typecheck)|pnpm\s+(test|build|typecheck))\b/;
+/** Chamadas de tool do turno, na ordem. */
+export function toolUses(turn) {
+    const out = [];
+    for (const m of turn.messages) {
+        if (m.role !== "assistant" || typeof m.content === "string")
+            continue;
+        for (const b of m.content)
+            if (b.type === "tool_use")
+                out.push({ name: String(b.name), input: b.input });
+    }
+    return out;
+}
+/** Texto do pedido do usuário (primeira mensagem do turno). */
+export function turnText(turn) {
+    const m = turn.messages.find((x) => x.role === "user");
+    if (!m)
+        return "";
+    if (typeof m.content === "string")
+        return m.content;
+    return m.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join(" ");
+}
+export function implicitLabel(uses) {
+    if (!uses.length)
+        return "none";
+    for (const u of uses) {
+        if (CLAUDE_TOOLS.has(u.name))
+            return "claude";
+        if (u.name === "bash") {
+            const cmd = String(u.input?.command ?? "");
+            if (!DIRECT_BASH.test(cmd) || /[;&|><]/.test(cmd.replace(/2>&1/g, "")))
+                return "claude";
+        }
+    }
+    return "tool";
+}
+// ------------------------------------------------------------------ arquivo
+export const routeDir = () => path.join(globalHome(), "routing");
+/** Um arquivo por repositório: nome legível + hash do caminho (dois projetos com o mesmo nome não se misturam). */
+export function routeFile(root) {
+    const slug = path.basename(root).replace(/[^\w.-]+/g, "_") || "repo";
+    return path.join(routeDir(), `${slug}-${crypto.createHash("sha1").update(path.resolve(root)).digest("hex").slice(0, 8)}.jsonl`);
+}
+export function appendRoute(root, e) {
+    fs.mkdirSync(routeDir(), { recursive: true });
+    fs.appendFileSync(routeFile(root), JSON.stringify(e) + "\n");
+}
+function parseLines(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    return raw.split("\n").flatMap((l) => {
+        if (!l.trim())
+            return [];
+        try {
+            return [JSON.parse(l)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+/** Entradas de um repositório, ou de todos (`root` indefinido). */
+export function readRoutes(root) {
+    if (root)
+        return parseLines(routeFile(root));
+    let files;
+    try {
+        files = fs.readdirSync(routeDir()).filter((f) => f.endsWith(".jsonl"));
+    }
+    catch {
+        return [];
+    }
+    return files.flatMap((f) => parseLines(path.join(routeDir(), f)));
+}
+// ------------------------------------------------------------------ modo sombra
+/**
+ * Registra a decisão sombra de um turno já concluído. Roda DEPOIS do turno (não atrasa a resposta) e nunca lança.
+ * Turno sem texto ou interrompido (não finalizado) é ignorado: não há rótulo confiável.
+ */
+const logged = new WeakSet();
+export async function shadowRoute(root, turn, decide = decideRoute) {
+    try {
+        if (!routeEnabled() || !turn?.finished || logged.has(turn))
+            return null;
+        logged.add(turn);
+        const text = turnText(turn).replace(/\s+/g, " ").trim();
+        // Comandos do próprio REPL e mensagens vazias não são pedidos ao agente.
+        if (!text || text.startsWith("/"))
+            return null;
+        const d = await decide(text);
+        const uses = toolUses(turn);
+        const entry = {
+            ts: new Date().toISOString(), repo: path.basename(path.resolve(root)), text: text.slice(0, TEXT_MAX),
+            decision: d.route, source: d.source, ms: d.ms, implicit: implicitLabel(uses),
+            tools: [...new Set(uses.map((u) => u.name))].slice(0, 12), errors: turn.errors,
+        };
+        appendRoute(root, entry);
+        return entry;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/route/stats.js

@@ -0,0 +1,53 @@
+const zero = (keys) => Object.fromEntries(keys.map((k) => [k, 0]));
+const R = ["slm", "claude", "tool"];
+const I = ["slm", "claude", "tool", "none"];
+export function summarize(entries) {
+    const dec = entries.filter((e) => e.source === "qwen");
+    const s = {
+        total: entries.length, decided: dec.length, byDecision: zero(R), byImplicit: zero(I),
+        matrix: Object.fromEntries(R.map((r) => [r, zero(I)])),
+        risky: 0, wasted: 0, labeled: 0, hits: 0, comparable: 0, delegable: 0, msMedian: 0,
+    };
+    for (const e of dec) {
+        s.byDecision[e.decision]++;
+        s.byImplicit[e.implicit]++;
+        s.matrix[e.decision][e.implicit]++;
+        if (e.decision !== "claude")
+            s.delegable++;
+        if (e.implicit !== "none")
+            s.labeled++;
+        if (e.decision !== "claude" && e.implicit === "claude")
+            s.risky++;
+        if (e.decision === "claude" && e.implicit === "tool")
+            s.wasted++;
+        // `slm` não tem rótulo implícito (resumir texto dado não deixa rastro nas tools): fica fora da taxa de acerto
+        if (e.decision !== "slm" && e.implicit !== "none") {
+            s.comparable++;
+            if (e.decision === e.implicit)
+                s.hits++;
+        }
+    }
+    const ms = dec.map((e) => e.ms).sort((a, b) => a - b);
+    s.msMedian = ms.length ? ms[Math.floor(ms.length / 2)] : 0;
+    return s;
+}
+const pct = (a, b) => (b ? `${Math.round((a / b) * 100)}%` : "—");
+/** Linhas do `/route`. */
+export function renderRouteStats(entries, scope, enabled) {
+    const s = summarize(entries);
+    const head = `modo sombra ${enabled ? "ligado" : "desligado (BRITO_ROUTE=off)"} · ${scope}: nada aqui muda o que o Brito faz`;
+    if (!s.total)
+        return [head, "  sem turnos registrados ainda"];
+    const out = [head, `  turnos registrados  ${s.total}  (decididos pelo SLM: ${s.decided}${s.total - s.decided ? `; sem SLM pronto: ${s.total - s.decided}` : ""})`];
+    if (!s.decided)
+        return [...out, "  rode `brito slm pull` para o decisor entrar em ação"];
+    out.push(`  teria mandado       claude ${s.byDecision.claude} · tool ${s.byDecision.tool} · slm ${s.byDecision.slm}   (delegaria ${pct(s.delegable, s.decided)})`);
+    out.push(`  o turno exigiu      claude ${s.byImplicit.claude} · só consulta ${s.byImplicit.tool} · sem tools ${s.byImplicit.none}`);
+    out.push(`  erro caro           ${s.risky} turno(s) que o decisor delegaria mas escreveram/planejaram/delegaram${s.decided - s.byDecision.claude ? ` (${pct(s.risky, s.delegable)} do que ele delegaria)` : ""}`);
+    out.push(`  custo sem ganho     ${s.wasted} turno(s) que foram ao Claude mas só consultaram`);
+    out.push(`  acerto estimado     ${pct(s.hits, s.comparable)} em ${s.comparable} turnos comparáveis (slm não tem rótulo implícito)`);
+    out.push(`  latência mediana    ${s.msMedian} ms por decisão`);
+    const need = 30 - s.decided;
+    out.push(need > 0 ? `  amostra pequena: faltam ~${need} decisões para a taxa ser confiável` : "  amostra suficiente para avaliar se o decisor pode passar a agir");
+    return out;
+}

package/dist/ui/ui.js

@@ -475,6 +475,7 @@ class UI {
             [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)}`)],
+            ...(s.slm ? [[3, c.light("💻 ") + label("slm") + c.muted(`${s.slm.calls}× ↑${fmtTokens(s.slm.tokensIn)} ↓${fmtTokens(s.slm.tokensOut)}`)]] : []),
             ...(s.cost !== undefined ? [[1, label("custo") + c.muted(`$${s.cost.toFixed(2)}`)]] : []),
             ...(this.activeSkill ? [[1, c.light("🎓 ") + label("skill") + c.bold(c.soft(this.activeSkill))]] : []),
             [4, label("tempo") + c.muted(mins < 1 ? "<1m" : `${mins}m`) + (active >= 1000 ? c.dim(` (ativo ${fmtDur(active)})`) : "")],
@@ -496,8 +497,9 @@ class UI {
             ["contexto", "tokens que o modelo está lendo agora / tamanho máximo da janela. Perto de 100% a conversa precisa ser compactada."],
             ["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."],
+            ["custo", "gasto estimado da sessão em dólares (só o Claude; o SLM local roda de graça no seu computador)."],
+            ["slm", "💻 trabalho feito pelo modelo local: nº de chamadas × tokens lidos ↑ e gerados ↓ (estimativa). Não gasta plano nem dinheiro. Só aparece depois do primeiro uso."],
+            ["motor", "quem está respondendo: 💻 nativo = modelo embutido que roda na sua máquina (sem tokens, sem custo); ☁ Claude = nuvem, consome tokens; 🌐 endpoint = servidor seu (ex.: Qwen). ⚠ 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/usage/command.js

@@ -1,4 +1,5 @@
 import { ui, c, fmtTokens } from "../ui/ui.js";
+import { slmUsage } from "../local/stats.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) {
@@ -15,6 +16,8 @@ export function usageCommand(session) {
                 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)}` : ""}`)}`);
+            const l = slmUsage();
+            ui.print(`  ${c.soft("SLM local")} ${c.muted(l ? `${l.calls} chamadas · ↑${fmtTokens(l.tokensIn)} ↓${fmtTokens(l.tokensOut)} (estimado) · ${(l.ms / 1000).toFixed(1)}s · sem custo` : "não usado nesta sessão")}`);
         },
     };
 }

package/package.json

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