brito-cli 0.7.5 → 0.9.0

package/dist/local/slm.js

@@ -0,0 +1,218 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { globalHome } from "../skills/store.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`
+ * (o download é sempre uma decisão explícita) e pode ser desligado com `BRITO_SLM=off`.
+ */
+export const SLM_URI = "hf:unsloth/Qwen3-4B-Instruct-2507-GGUF:Q4_K_M";
+export const slmUri = () => process.env.BRITO_SLM_MODEL?.trim() || SLM_URI;
+export const slmDir = () => path.join(globalHome(), "models");
+export const slmDisabled = () => process.env.BRITO_SLM === "off";
+/** O nome do pacote vai numa variável: o tsc e o bundler não tentam resolver uma dependência opcional. */
+const LIB = "node-llama-cpp";
+let libPromise = null;
+export function loadLib() {
+    return (libPromise ??= import(LIB).catch(() => null));
+}
+/** Arquivo do modelo já baixado (null = ainda não baixou). Um caminho local no BRITO_SLM_MODEL conta direto. */
+export async function modelFile() {
+    const uri = slmUri();
+    if (!uri.startsWith("hf:") && !/^https?:/.test(uri))
+        return fs.existsSync(uri) ? uri : null;
+    const lib = await loadLib();
+    if (!lib)
+        return null;
+    try {
+        const p = await lib.resolveModelFile(uri, { directory: slmDir(), download: false, cli: false });
+        return p && fs.existsSync(p) ? p : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function slmStatus() {
+    const lib = await loadLib();
+    const file = lib ? await modelFile() : null;
+    const disabled = slmDisabled();
+    return { lib: !!lib, file, uri: slmUri(), disabled, ready: !!lib && !!file && !disabled };
+}
+/** Baixa o modelo (retomável). `onProgress` recebe bytes baixados e total. */
+export async function pullModel(onProgress, signal) {
+    const lib = await loadLib();
+    if (!lib)
+        throw new Error("node-llama-cpp não está instalado (é uma dependência opcional). Rode: npm install node-llama-cpp");
+    return lib.resolveModelFile(slmUri(), {
+        directory: slmDir(), download: "auto", cli: false, signal,
+        onProgress: (s) => onProgress?.(s.downloadedSize, s.totalSize),
+    });
+}
+/** Apaga o modelo baixado. Devolve o que foi removido. */
+export async function removeModel() {
+    const f = await modelFile();
+    if (!f || !f.startsWith(slmDir()))
+        return null;
+    fs.rmSync(f, { force: true });
+    return f;
+}
+let loaded = null;
+let idleTimer = null;
+const IDLE_MS = 120_000;
+async function ensureLoaded() {
+    const lib = await loadLib();
+    const file = await modelFile();
+    if (!lib || !file)
+        throw new Error("SLM indisponível: rode `brito slm pull`");
+    loaded ??= (async () => {
+        const llama = await lib.getLlama({ progressLogs: false, logLevel: "error" });
+        const model = await llama.loadModel({ modelPath: file });
+        return { llama, model };
+    })().catch((e) => { loaded = null; throw e; });
+    return loaded;
+}
+/** Libera a memória do modelo depois de um tempo parado (o processo não fica preso por causa disso). */
+function scheduleUnload() {
+    if (idleTimer)
+        clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => void unloadSlm(), IDLE_MS);
+    idleTimer.unref?.();
+}
+export async function unloadSlm() {
+    if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+    }
+    const l = loaded;
+    loaded = null;
+    if (!l)
+        return;
+    try {
+        const { model, llama } = await l;
+        await model.dispose();
+        await llama.dispose();
+    }
+    catch { /* já liberado */ }
+}
+/**
+ * Uma geração isolada (sessão nova a cada chamada, sem histórico). Com `schema`, a saída é forçada a ser JSON
+ * válido por gramática: é o que torna modelos pequenos confiáveis em tarefas estruturadas.
+ */
+export async function slmGenerate(o) {
+    const lib = await loadLib();
+    const { model, llama } = await ensureLoaded();
+    const context = await model.createContext({ contextSize: { max: 8192 } });
+    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 });
+    }
+    finally {
+        await context.dispose();
+        scheduleUnload();
+    }
+}
+// ------------------------------------------------------------------ chat com tools (fallback do Claude)
+/** Contexto do chat do SLM (BRITO_SLM_CTX; o padrão cabe numa GPU/RAM modesta). */
+export const slmChatCtx = () => { const n = Number(process.env.BRITO_SLM_CTX); return n >= 2048 ? Math.floor(n) : 16_384; };
+/** Um passo de chat: devolve o texto e as chamadas de tool pedidas (sem executá-las). */
+export async function slmChat(o) {
+    const lib = await loadLib();
+    const { model } = await ensureLoaded();
+    const context = await model.createContext({ contextSize: { max: slmChatCtx() } });
+    try {
+        const chat = new lib.LlamaChat({ contextSequence: context.getSequence() });
+        const functions = o.functions && Object.keys(o.functions).length
+            ? Object.fromEntries(Object.entries(o.functions).map(([name, f]) => [name, lib.defineChatSessionFunction({ description: f.description, params: f.params, handler: () => "" })]))
+            : undefined;
+        const res = await chat.generateResponse(o.history, {
+            functions, maxTokens: o.maxTokens ?? 2048, temperature: o.temperature ?? 0.3, signal: o.signal,
+            onTextChunk: (t) => { if (t)
+                o.onText?.(t); },
+        });
+        const calls = (res.functionCalls ?? []).map((c) => ({ name: String(c.functionName), input: c.params ?? {} }));
+        return { text: String(res.response ?? ""), calls, truncated: res.metadata?.stopReason === "maxTokens" };
+    }
+    finally {
+        await context.dispose();
+        scheduleUnload();
+    }
+}
+/** Versão síncrona de `slmStatus().ready` (o `fallbackStatus` é síncrono): biblioteca resolvível e um .gguf baixado. */
+export function slmReadySync() {
+    if (slmDisabled())
+        return false;
+    try {
+        createRequire(import.meta.url).resolve(LIB);
+    }
+    catch {
+        return false;
+    }
+    const uri = slmUri();
+    if (!uri.startsWith("hf:") && !/^https?:/.test(uri))
+        return fs.existsSync(uri);
+    try {
+        return fs.readdirSync(slmDir()).some((f) => f.endsWith(".gguf"));
+    }
+    catch {
+        return false;
+    }
+}
+// ------------------------------------------------------------------ reflexão
+const SKILLS_SCHEMA = {
+    type: "object",
+    properties: {
+        skills: {
+            type: "array", maxItems: 2,
+            items: {
+                type: "object",
+                properties: {
+                    name: { type: "string" }, description: { type: "string" }, body: { type: "string" },
+                    refs: { type: "array", items: { type: "string" } }, reason: { type: "string" },
+                },
+                required: ["name", "description", "body", "refs", "reason"],
+            },
+        },
+    },
+    required: ["skills"],
+};
+const JSON_NOTE = `
+
+# Formato da resposta
+Responda SOMENTE com JSON no formato {"skills":[{"name","description","body","refs","reason"}]}. Cada item equivale a uma chamada de skill_save. Se nada vale virar skill, responda {"skills":[]}. O name é kebab-case; o body é markdown com ## Quando usar, ## Passos, ## Armadilhas e ## Verificação.
+Regras do conteúdo: (1) o name descreve o TIPO de tarefa (ex.: "ficha-de-leitura"), nunca um autor, livro, arquivo ou pessoa específicos; troque esses por parâmetros ("o autor", "o capítulo"). (2) Use só caminhos RELATIVOS à raiz do projeto, nunca caminhos absolutos nem nomes de usuário (escreva "a partir da raiz do projeto"). (3) Se a skill já existe na lista de skills existentes, reutilize o MESMO name em vez de criar outra. (4) Cada passo é uma ação concreta; a Verificação diz como saber que terminou.`;
+/** Converte a saída JSON do SLM nos blocos `tool_use` que a reflexão já sabe processar. Tolera lixo: devolve [] se inválido. */
+export function skillsToBlocks(json) {
+    let data;
+    try {
+        data = JSON.parse(json);
+    }
+    catch {
+        return [];
+    }
+    const list = Array.isArray(data?.skills) ? data.skills : [];
+    return list.flatMap((s, i) => s && typeof s.name === "string" && typeof s.description === "string" && typeof s.body === "string"
+        ? [{ type: "tool_use", id: `slm_${i}`, name: "skill_save", input: { name: s.name, description: s.description, body: s.body, refs: Array.isArray(s.refs) ? s.refs.filter((r) => typeof r === "string") : [], reason: typeof s.reason === "string" ? s.reason : "" } }]
+        : []);
+}
+/** `Complete` da reflexão rodando no SLM local. */
+export const slmComplete = async ({ system, user, maxTokens }) => {
+    const text = await slmGenerate({ system: system + JSON_NOTE, user, schema: SKILLS_SCHEMA, maxTokens: Math.min(maxTokens, 2500) });
+    return skillsToBlocks(text);
+};
+/**
+ * Escolhe o `Complete` da reflexão: o SLM local quando está baixado e habilitado; senão o `fallback` (o modelo de
+ * sempre). Se o SLM falhar no meio (memória, binário), cai no `fallback` em vez de perder a reflexão.
+ */
+export function withSlm(fallback) {
+    return async (req) => {
+        if (!slmDisabled() && (await slmStatus()).ready) {
+            try {
+                return await slmComplete(req);
+            }
+            catch { /* cai no modelo de sempre */ }
+        }
+        return fallback(req);
+    };
+}

package/dist/mcp/server.js

@@ -5,6 +5,13 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import "../tools/graph.js";
 import "../tools/skills.js";
+// O implementador do modo orquestrador roda aqui e edita/roda comandos; fs e bash só existem para ele (não são expostos).
+import "../tools/fs.js";
+import "../tools/bash.js";
+import { implementIo } from "../tools/implement.js";
+import "../tools/spec.js";
+import { ORCH_ONLY, orch } from "../orchestrator.js";
+import "../tools/digest.js";
 import { allTools, execTool } from "../tools/registry.js";
 import { GraphStore } from "../graph/store.js";
 import { INDEXED_EXTENSIONS, indexProject } from "../graph/indexer.js";
@@ -27,13 +34,16 @@ export const MCP_INSTRUCTIONS = [
  * tools de consulta, que são baratas e de uso frequente. As de escrita e a de aprovação (interna) continuam adiadas.
  */
 export const ALWAYS_LOAD_META = "anthropic/alwaysLoad";
-export const alwaysLoaded = (tool) => /^(graph_|recall$|remember$|skill_load$)/.test(tool);
+export const alwaysLoaded = (tool) => /^(graph_|recall$|remember$|skill_load$|digest$|implement$)/.test(tool);
 /** Prefixo com que o claude CLI enxerga as tools deste servidor. */
 export const MCP_PREFIX = `mcp__${MCP_NAME}__`;
 /** Tool usada como --permission-prompt-tool: encaminha o pedido ao REPL do Brito. */
 export const APPROVE_TOOL = "approve";
 // fs/bash/delegate o próprio claude já tem (Read/Edit/Bash/Task); aqui vai só o que é do Brito.
-const exposed = () => allTools().filter((t) => /^(graph_|skill_)/.test(t.name) || t.name === "remember" || t.name === "recall");
+/** Tools que o claude enxerga; `implement` e `spec_save` só com o modo orquestrador ligado (BRITO_ORCH=1). */
+export const exposed = () => allTools().filter((t) => /^(graph_|skill_)/.test(t.name) || t.name === "remember" || t.name === "recall" || t.name === "digest" || (ORCH_ONLY.includes(t.name) && orch.on));
+/** Nome do pedido de aprovação de uma ação do implementador (o terminal mostra só a pergunta). */
+export const IMPL_ASK = "BritoImplementer";
 /** Pergunta ao REPL (socket unix) se o claude pode usar a tool; sem socket, nega. */
 function askRepl(toolName, input) {
     const sock = process.env.BRITO_APPROVE_SOCK;
@@ -77,7 +87,28 @@ export async function serveMcp(root) {
                 ...(alwaysLoaded(t.name) ? { _meta: { [ALWAYS_LOAD_META]: true } } : {}),
             }))],
     }));
-    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    /**
+     * O claude aprovou a chamada de `implement`, não cada edição dentro dela: as do implementador pedem aprovação ao
+     * terminal pelo mesmo socket, conforme o modo. O progresso vai como notificação MCP (o stdout daqui é o protocolo).
+     */
+    const runImplement = async (args, extra, token) => {
+        let step = 0;
+        implementIo.log = (msg) => {
+            if (token === undefined) {
+                process.stderr.write(msg + "\n");
+                return;
+            }
+            extra.sendNotification({ method: "notifications/progress", params: { progressToken: token, progress: ++step, message: msg } }).catch(() => { });
+        };
+        const warn = (msg) => implementIo.log(msg);
+        implementIo.sink = { turnStart() { }, turnEnd() { }, text() { }, textEnd() { }, thinking() { }, toolStart() { }, toolEnd() { }, info: warn, warn, error: warn };
+        // Quem chama este servidor é sempre o claude CLI: o principal é um Claude, não o modelo salvo no config.
+        const implCtx = { ...ctx, ask: async (q) => (await askRepl(IMPL_ASK, { question: q })).allow, model: () => "claude" };
+        const r = await execTool("implement", args, implCtx);
+        ctx.dirty = true; // o implementador editou arquivos: a próxima consulta ao grafo reindexa
+        return r.isError ? `[ERRO] ${r.text}` : r.text;
+    };
+    server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
         if (req.params.name === APPROVE_TOOL) {
             const a = (req.params.arguments ?? {});
             const r = await askRepl(String(a.tool_name ?? "?"), a.input ?? {});
@@ -87,6 +118,8 @@ export async function serveMcp(root) {
         if (!exposed().some((t) => t.name === req.params.name)) {
             return { content: [{ type: "text", text: `Tool desconhecida: ${req.params.name}` }], isError: true };
         }
+        if (req.params.name === "implement")
+            return { content: [{ type: "text", text: await runImplement(req.params.arguments ?? {}, extra, req.params._meta?.progressToken) }] };
         const r = await execTool(req.params.name, req.params.arguments ?? {}, ctx);
         return { content: [{ type: "text", text: r.text }], isError: r.isError };
     });

package/dist/model.js

@@ -30,6 +30,27 @@ function saveConfig(patch) {
     writeFileSync(configPath(), JSON.stringify({ ...cfg, ...patch }, null, 2) + "\n");
 }
 export const saveModel = (model) => saveConfig({ model });
+/** Perfil que implementa as tasks no modo orquestrador (`implModel` no config). */
+export function loadSavedImplModel() {
+    try {
+        const m = JSON.parse(readFileSync(configPath(), "utf8"))?.implModel;
+        return typeof m === "string" && m.trim() ? m.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const saveImplModel = (implModel) => saveConfig({ implModel });
+/** Modo orquestrador ligado ao abrir o Brito (`orchestrator: true` no config, gravado por `/orquestrar on --global`). */
+export function loadSavedOrch() {
+    try {
+        return JSON.parse(readFileSync(configPath(), "utf8"))?.orchestrator === true;
+    }
+    catch {
+        return false;
+    }
+}
+export const saveOrch = (orchestrator) => saveConfig({ orchestrator });
 /**
  * Escada de esforço do Hermes (EFFORT_LADDER, do mais fraco ao mais forte). `none` desliga o raciocínio;
  * `minimal` e `ultra` são internos: o claude CLI não os aceita, então `clampEffort` os mapeia.

package/dist/orchestrator.js

@@ -0,0 +1,131 @@
+import { allTools } from "./tools/registry.js";
+import { loadProfiles, loadSavedImplModel, loadSavedOrch } from "./model.js";
+import { missingKeyMessage } from "./provider/openai-compat.js";
+import { resolveModel } from "./provider/resolve.js";
+// Modo orquestrador: o modelo principal (Claude) planeja e revisa; um perfil de endpoint (o qwen) implementa cada task
+// pela tool `implement`. Estado global da sessão, como o `perms`.
+/** Prioridade: BRITO_IMPL_MODEL > config global (`implModel`) > qwen. */
+export const initialImplModel = () => process.env.BRITO_IMPL_MODEL?.trim() || loadSavedImplModel() || "qwen";
+/** No servidor MCP (outro processo) o modo vem ligado pelo env; no REPL e no app começa desligado. */
+export const orch = { on: process.env.BRITO_ORCH === "1", model: initialImplModel() };
+/** Edição de arquivo fica só com o implementador; o principal lê, delega e verifica (bash continua para os testes). */
+export const ORCH_BLOCKED = ["write_file", "edit_file"];
+/** Tools que só existem com o modo ligado: a delegação e a gravação da spec/tasks em spec/. */
+export const ORCH_ONLY = ["implement", "spec_save"];
+/**
+ * Tools do agente principal. Desligado: todas menos as do modo (`implement`, `spec_save`). Ligado: sem as de edição. Função: o modo muda no meio
+ * da sessão e o loop relê a lista a cada passo.
+ */
+export function mainTools() {
+    const hidden = orch.on ? ORCH_BLOCKED : ORCH_ONLY;
+    return new Set(allTools().map((t) => t.name).filter((n) => !hidden.includes(n)));
+}
+/**
+ * O implementador está pronto? Só um perfil de endpoint válido, com a chave no ambiente, e diferente do principal
+ * (o qwen orquestrando o qwen não ganha nada). Relê o config a cada chamada, como os perfis.
+ */
+export function implStatus(main, impl, env) {
+    const name = impl.trim().toLowerCase();
+    if (main.trim().toLowerCase() === name)
+        return { ready: false, reason: `o modelo principal já é o ${impl}` };
+    const { profiles, errors, rejected } = loadProfiles();
+    if (rejected.includes(name)) {
+        const why = errors.find((e) => e.toLowerCase().includes(`"${name}"`)) ?? "";
+        return { ready: false, reason: `o perfil "${name}" em ~/.brito/config.json está inválido (${why})` };
+    }
+    const p = profiles[name];
+    if (!p || resolveModel(name).kind !== "openai")
+        return { ready: false, reason: `sem perfil "${name}" em providers no ~/.brito/config.json` };
+    if (!env[p.apiKeyEnv]?.trim())
+        return { ready: false, reason: missingKeyMessage(p) };
+    return { ready: true, label: p.label };
+}
+/**
+ * Desliga o modo quando o implementador deixa de estar pronto para o principal `main` (fallback ou `/model` para o
+ * próprio qwen, chave removida…). Nunca em silêncio: o motivo vai para `warn`.
+ */
+export function orchGuard(main, warn) {
+    if (!orch.on)
+        return;
+    const s = implStatus(main, orch.model, process.env);
+    if (s.ready)
+        return;
+    orch.on = false;
+    warn(`modo orquestrador desligado: ${s.reason}`);
+}
+/**
+ * Ao abrir o REPL ou o app: liga o modo se ele foi salvo com `/orquestrar on --global`. Se o implementador não estiver
+ * pronto para o principal `main`, fica desligado e o motivo vai para `warn`. O servidor MCP não usa: lá o modo vem do env.
+ */
+export function restoreOrch(main, warn, info) {
+    if (orch.on || !loadSavedOrch())
+        return;
+    const s = implStatus(main, orch.model, process.env);
+    if (!s.ready) {
+        warn(`modo orquestrador salvo como ligado, mas não ligou: ${s.reason}`);
+        return;
+    }
+    orch.on = true;
+    info(`modo orquestrador ligado (salvo): ${main} planeja e revisa, ${s.label} implementa`);
+}
+/** O servidor MCP roda em outro processo (subido pelo claude CLI a cada turno): o modo e o perfil chegam pelo env. */
+export const ORCH_ENV = "BRITO_ORCH";
+/** Env do servidor MCP: liga a tool `implement` lá e diz qual perfil implementa. */
+export const orchEnv = () => (orch.on ? { [ORCH_ENV]: "1", BRITO_IMPL_MODEL: orch.model } : {});
+/** Uma task do implementador leva minutos: o timeout padrão do claude CLI para tools MCP cortaria no meio (30 min). */
+export const ORCH_MCP_TIMEOUT = "1800000";
+/** Tools nativas do claude CLI que editam arquivos: bloqueadas com o modo ligado. */
+export const CLAUDE_EDIT_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit"];
+/** Acrescentado ao system prompt do agente principal enquanto o modo está ligado. */
+export const ORCH_NOTE = `
+
+# MODO ORQUESTRADOR ATIVO
+Você planeja e revisa; quem implementa é outro modelo, pela tool implement. Você não tem write_file nem edit_file: sua única escrita é spec_save, que grava em spec/<feature>/.
+- Divida o pedido em tasks pequenas e independentes e mande UMA por chamada de implement, em ordem.
+- Antes da primeira chamada de implement, grave com spec_save (feature = slug curto do pedido):
+  - spec.md: objetivo, contexto, requisitos, contratos que não podem mudar, fora de escopo e riscos;
+  - tasks.md: lista numerada de tasks como checklist (\`- [ ] 1. título\`), cada uma com objetivo, arquivos, critério de pronto e comando de verificação.
+  Depois mostre ao usuário o caminho dos dois arquivos e um resumo da lista, e encerre a resposta pedindo aprovação. Só delegue depois que ele aprovar, seguindo o tasks.md aprovado.
+- Se o usuário pedir mudanças, ou se for preciso mudar a lista no meio do caminho (task nova, ordem diferente), atualize spec.md/tasks.md com spec_save e peça aprovação de novo antes de seguir. Não precisa pedir de novo se o usuário acabou de aprovar um plano com essas mesmas tasks (modo plano).
+- Ao mandar uma task ao implement, cite o caminho da spec (spec/<feature>/spec.md) para ele consultar, mas mantenha a task autocontida.
+- Quando uma task passar na sua revisão, marque-a como feita no tasks.md (\`- [x]\`) com spec_save; se ficar pendente, anote o motivo embaixo dela.
+- O implementador não vê esta conversa: cada task precisa trazer objetivo, arquivos e símbolos envolvidos, contratos que não podem mudar, critério de pronto e o comando de verificação (\`verify\`). Passe \`focus\` com os símbolos centrais.
+- O resultado traz o relato do implementador, o git status/diff e a saída da verificação, rodada pela própria tool. Julgue pelo diff e pela verificação, não pelo relato: leia os trechos alterados quando precisar.
+- Se a task ficou errada ou incompleta, chame implement de novo com o que está errado e o que fazer. No máximo 2 reenvios por task; depois disso, explique ao usuário o que falta.
+- Ao final, resuma o que foi feito, o que a verificação provou e o que ficou pendente, e aponte o tasks.md atualizado.`;
+/** Complemento do ORCH_NOTE no claude CLI, onde os nomes das tools são outros. */
+export const ORCH_NOTE_CLAUDE = `
+- Nesta sessão as tools chegam como mcp__brito__implement e mcp__brito__spec_save; Edit, Write, MultiEdit e NotebookEdit estão bloqueadas. Não use Bash para escrever arquivos: isso também é trabalho do implementador.`;
+/** Prompt do subagente que implementa: escopo fechado, verificação obrigatória e uma resposta que dá para conferir. */
+const IMPLEMENTER_PROMPT = `Você implementa UMA task, descrita no pedido. Você não vê a conversa do orquestrador: tudo que precisa está no pedido.
+
+# Escopo
+- Faça só o que a task pede. Não refatore, não renomeie e não "melhore" código fora dela.
+- Não invente arquivo, classe, API ou requisito. Se algo do pedido não existir no projeto, pare e diga isso em PENDENTE.
+- Não mude contratos existentes (assinaturas, rotas, formato de resposta) sem que o pedido mande.
+- Não apague nem enfraqueça testes para a verificação passar.
+
+# Como trabalhar
+- Comece pelo grafo (graph_context / graph_callers) dos símbolos citados; leia só as linhas apontadas.
+- Antes de criar um arquivo novo, abra um arquivo existente do mesmo tipo e siga a estrutura dele.
+- Comportamento novo ganha teste, no estilo dos testes que já existem.
+
+# Verificação
+- Rode o comando de verificação do pedido (ou o de testes do projeto). Pronto é o que ele prova.
+- Se falhar por causa do código: leia só a parte relevante do erro, corrija e rode de novo. No máximo 3 tentativas.
+- Se falhar por ambiente (serviço fora do ar, porta ocupada), não tente consertar: registre e siga.
+
+# Resposta final
+Responda só com:
+FEITO: arquivos criados ou alterados, um por linha
+VERIFICAÇÃO: comando rodado e resultado (passou / falhou / não rodou e por quê)
+PENDENTE: o que faltou, ou "nada"`;
+/** Fora do registro de agentes: não aparece no `delegate` nem vira subagente do claude CLI; só a tool `implement` o usa. */
+export const IMPLEMENTER = {
+    name: "implementer",
+    description: "Implementa uma task bem especificada (edita arquivos e roda a verificação).",
+    tools: "all",
+    get model() { return orch.model; },
+    prompt: IMPLEMENTER_PROMPT,
+    source: "builtin",
+};

package/dist/permissions.js

@@ -34,6 +34,10 @@ export function describeClaudeTool(name, input) {
         case "MultiEdit": return `editar ${i.file_path} (${(i.edits ?? []).length} trocas)`;
         case "NotebookEdit": return `editar notebook ${i.notebook_path}`;
         case "ExitPlanMode": return `plano proposto — aprovar e sair do modo plano?\n${String(i.plan ?? "")}`;
+        // Ação do implementador do modo orquestrador (servidor MCP): a pergunta já vem montada pelo Brito.
+        case "BritoImplementer": return `implementador · ${String(i.question ?? "")}`;
+        case "mcp__brito__spec_save": return `gravar spec/${String(i.feature ?? "?")}/${String(i.file ?? "?")} (${String(i.content ?? "").length} chars)`;
+        case "mcp__brito__implement": return `delegar ao implementador: ${one(i.task, 300)}${i.verify ? `\n  verificação: ${one(i.verify)}` : ""}`;
         default: return `${name}: ${one(JSON.stringify(i), 200)}`;
     }
 }

package/dist/provider/anthropic-params.js

@@ -0,0 +1,32 @@
+import { clampEffort, isEffort } from "../model.js";
+/** Modelos com raciocínio adaptativo e `output_config.effort` (4.6 em diante). Os mais antigos seguem sem raciocínio. */
+const ADAPTIVE = /claude-(fable|mythos)-|claude-(opus|sonnet|haiku)-5|claude-opus-4-[678]|claude-sonnet-4-6/;
+/** Não aceitam desligar o raciocínio: o mínimo é esforço `low`. */
+const ALWAYS_THINKS = /claude-(fable|mythos)-|claude-opus-5-5/;
+/** Desligar é `between_tools` (`disabled` dá 400). */
+const BETWEEN_TOOLS = /claude-sonnet-5-5/;
+/** Os 4.6 não têm `xhigh`. */
+const NO_XHIGH = /claude-(opus|sonnet)-4-6/;
+/**
+ * Traduz o esforço do Brito (`/reasoning`) nos parâmetros da API da Anthropic para o modelo dado.
+ * `thinking: false` (ou esforço `none`) desliga o raciocínio onde o modelo permite; vazio = padrão do modelo.
+ */
+export function thinkingParams(wireModel, effort, thinking = true) {
+    if (!ADAPTIVE.test(wireModel))
+        return {};
+    const off = !thinking || effort === "none";
+    if (off) {
+        if (ALWAYS_THINKS.test(wireModel))
+            return { thinking: { type: "adaptive" }, output_config: { effort: "low" } };
+        if (BETWEEN_TOOLS.test(wireModel))
+            return { thinking: { type: "between_tools" } };
+        return { thinking: { type: "disabled" } };
+    }
+    if (!isEffort(effort))
+        return { thinking: { type: "adaptive" } };
+    const supported = NO_XHIGH.test(wireModel) ? ["low", "medium", "high", "max"] : ["low", "medium", "high", "xhigh", "max"];
+    return { thinking: { type: "adaptive" }, output_config: { effort: clampEffort(effort, supported) } };
+}
+/** Raciocinar e responder dividem o `max_tokens`: com raciocínio ligado, um teto pequeno cortaria a resposta. */
+export const THINKING_MIN_TOKENS = 16_000;
+export const maxTokensFor = (p, requested) => p.thinking?.type === "adaptive" ? Math.max(requested, THINKING_MIN_TOKENS) : requested;

package/dist/provider/anthropic.js

@@ -1,25 +1,29 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { resolveModel } from "./resolve.js";
+import { maxTokensFor, thinkingParams } from "./anthropic-params.js";
 /** API da Anthropic, exatamente como o Brito sempre chamou (system em cache, streaming quando há quem leia o texto). */
 export class AnthropicProvider {
     kind = "anthropic";
     client = new Anthropic();
     async send(req, hooks = {}) {
+        const wireModel = resolveModel(req.model).wireModel; // aliases (sonnet, opus…) viram o id real
+        const thinking = thinkingParams(wireModel, req.effort, req.thinking ?? true);
         const params = {
-            model: resolveModel(req.model).wireModel, // aliases (sonnet, opus…) viram o id real
-            max_tokens: req.maxTokens,
+            model: wireModel,
+            max_tokens: maxTokensFor(thinking, req.maxTokens),
+            // Dois pontos de cache: o system (estável na sessão) e, pelo `cache_control` do topo, o fim da conversa.
+            // Sem o segundo, cada passo do loop pagaria o histórico inteiro de novo.
+            cache_control: { type: "ephemeral" },
             system: [{ type: "text", text: req.system, cache_control: { type: "ephemeral" } }],
             ...(req.tools?.length ? { tools: req.tools } : {}),
+            ...thinking,
             messages: req.messages,
         };
-        let msg;
-        if (hooks.onText) {
-            const stream = this.client.messages.stream(params, { signal: hooks.signal });
+        // Sempre em streaming: com `max_tokens` alto, o SDK recusa (ou deixa estourar o timeout de) uma chamada simples.
+        const stream = this.client.messages.stream(params, { signal: hooks.signal });
+        if (hooks.onText)
             stream.on("text", (t) => hooks.onText(t));
-            msg = await stream.finalMessage();
-        }
-        else
-            msg = await this.client.messages.create(params, { signal: hooks.signal });
+        const msg = await stream.finalMessage();
         const u = msg.usage;
         const content = msg.content.flatMap((b) => b.type === "text" ? [{ type: "text", text: b.text }] : b.type === "tool_use" ? [{ type: "tool_use", id: b.id, name: b.name, input: b.input }] : []);
         const stopReason = msg.stop_reason === "end_turn" || msg.stop_reason === "tool_use" || msg.stop_reason === "max_tokens" ? msg.stop_reason : "other";

package/dist/provider/fallback.js

@@ -1,5 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
-import { FALLBACK_PROFILE } from "../engine.js";
+import { FALLBACK_CHAIN } from "../engine.js";
+import { SLM_MODEL, resolveModel } from "./resolve.js";
 export const triggersFallback = (k) => k !== "other";
 /**
  * Classifica um erro da API da Anthropic (já depois dos retries do SDK). Na dúvida, `other`: melhor não trocar do que
@@ -100,15 +101,57 @@ export function chooseModel(s, model) {
     s.active = false;
     s.reason = undefined;
     s.at = undefined;
+    s.until = undefined;
+    s.using = undefined;
 }
 /** A troca automática aconteceu. */
-export function activateFallback(s, reason, at = Date.now()) {
+export function activateFallback(s, reason, at = Date.now(), until, using) {
     s.active = true;
     s.reason = reason;
     s.at = at;
+    if (until !== undefined)
+        s.until = until;
+    if (using !== undefined)
+        s.using = using;
+}
+/** Minutos de fallback por tipo de falha (BRITO_FALLBACK_MINUTES sobrepõe): cota/auth demoram mais a voltar que sobrecarga. */
+const WINDOW_MIN = { quota: 60, auth: 60, rate_limit: 10, overloaded: 10, network: 10, other: 10 };
+/**
+ * Até quando o fallback vale. Usa o horário de reset que o erro informa ("resets 3pm", "resets at 15:30") quando existe
+ * (no futuro e em até 12h); senão a janela por tipo de falha.
+ */
+export function fallbackUntil(kind, why, env = process.env, now = Date.now()) {
+    const m = /resets?(?: at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i.exec(why);
+    if (m) {
+        let h = Number(m[1]);
+        const min = Number(m[2] ?? 0);
+        const ap = m[3]?.toLowerCase();
+        if (ap === "pm" && h < 12)
+            h += 12;
+        if (ap === "am" && h === 12)
+            h = 0;
+        if (h <= 23 && min <= 59) {
+            const d = new Date(now);
+            d.setHours(h, min, 0, 0);
+            if (d.getTime() <= now)
+                d.setDate(d.getDate() + 1);
+            if (d.getTime() - now <= 12 * 3_600_000)
+                return d.getTime() + 60_000;
+        }
+    }
+    const custom = Number(env.BRITO_FALLBACK_MINUTES);
+    return now + (custom > 0 ? custom : WINDOW_MIN[kind]) * 60_000;
+}
+/** A janela do fallback acabou: o próximo turno deve tentar o Claude de novo. */
+export const fallbackExpired = (s, now = Date.now()) => s.active && s.until !== undefined && now >= s.until;
+/** Volta ao modelo principal (sem apagar o motivo da última troca: o aviso o usa). */
+export function returnToPrimary(s) {
+    s.active = false;
+    s.until = undefined;
+    s.using = undefined;
 }
 /** Aviso impresso na troca (modo API e claude CLI): a troca nunca é silenciosa. */
-export const fallbackWarning = (kind, why, label) => `⚠ Claude falhou (${kind}: ${why}) — seguindo com ${label}. /fallback para detalhes, /model <claude> para voltar.`;
+export const fallbackWarning = (kind, why, label, until) => `⚠ Claude falhou (${kind}: ${why}) — seguindo com ${label}${until ? `; tento o Claude de novo às ${hhmm(until)}` : ""}. /fallback para detalhes, /model <claude> para voltar.`;
 /**
  * O turno do claude CLI que falhou deve ser refeito no qwen? Só com falha de conta/capacidade, fallback pronto e
  * ainda não usado na sessão. Interrupção não deixa `failure` (a sessão filtra), mas o `aborted` fica de garantia.
@@ -127,6 +170,19 @@ export const retryPrompt = (text, resumed = false) => `${RETRY_NOTE}${resumed ?
  */
 export const onceRestore = (restore, fallbackActive) => (fallbackActive ? null : restore);
 const hhmm = (ms) => { const d = new Date(ms); return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`; };
+/**
+ * Selo do motor para a barra de status: de onde vêm as respostas agora (nuvem, endpoint ou local) e se é fallback.
+ * `fallback` = true quando a troca automática está ativa (o selo vira aviso e diz quando o Claude é tentado de novo).
+ */
+export function engineChip(model, fb) {
+    const r = resolveModel(model);
+    const where = r.kind === "anthropic" ? "☁ nuvem" : r.local ? "💻 local" : "🌐 endpoint";
+    const text = `${where} · ${r.label}`;
+    if (!fb?.active)
+        return { text, fallback: false };
+    const back = fb.until ? `; Claude volta ${hhmm(fb.until)}` : "; /model para voltar";
+    return { text: `⚠ FALLBACK ${text}${back}`, fallback: true };
+}
 /**
  * Linhas do `/fallback`. Principal = o modelo vivo, salvo com o fallback ativo (aí é o principal original e o qwen
  * aparece em uso). `status` vem de `fallbackStatus(state.primary, env)`; `engineLabel` é o motor do principal.
@@ -134,12 +190,15 @@ const hhmm = (ms) => { const d = new Date(ms); return `${String(d.getHours()).pa
 export function renderFallback(state, liveModel, engineLabel, status) {
     const primary = state.active ? state.primary : liveModel;
     const name = status.label ?? "—";
-    const self = !state.active && primary.trim().toLowerCase() === FALLBACK_PROFILE;
-    const fb = state.active ? `${name}  qwen · ~/.brito/config.json  ● em uso`
-        : status.ready ? `${name}  qwen · ~/.brito/config.json  ✓ pronto`
-            : self ? `${name}  — o modelo principal já é o qwen`
+    const self = !state.active && !status.ready && FALLBACK_CHAIN.includes(primary.trim().toLowerCase());
+    const using = state.using === SLM_MODEL ? "SLM local" : "qwen";
+    const src = (state.active ? state.using : status.ready ? ("name" in status ? status.name : "") : "") === SLM_MODEL ? "local · brito slm" : "qwen · ~/.brito/config.json";
+    const fb = state.active ? `${name}  ${src}  ● em uso`
+        : status.ready ? `${name}  ${src}  ✓ pronto`
+            : self ? `${name}  — o modelo principal já é o ${primary.trim().toLowerCase() === SLM_MODEL ? "SLM" : "qwen"}`
                 : `${name}  ✗ ${status.reason}`;
-    const estado = state.active ? `ATIVO desde ${hhmm(state.at ?? Date.now())} — Claude falhou: ${state.reason ?? "?"}. /model <claude> para voltar`
+    const volta = state.until ? ` — o Claude é tentado de novo às ${hhmm(state.until)}` : "";
+    const estado = state.active ? `ATIVO desde ${hhmm(state.at ?? Date.now())}${state.using ? ` (${using})` : ""} — Claude falhou: ${state.reason ?? "?"}${volta}. /model <claude> para voltar${state.until ? " agora" : ""}`
         : status.ready ? "inativo — troca automática se o Claude falhar por limite, crédito, auth ou sobrecarga"
             : self ? "não se aplica"
                 : "indisponível — sem troca automática nesta sessão";