brito-cli 0.7.5 → 0.8.0

package/dist/local/digest.js

@@ -0,0 +1,202 @@
+import { words } from "../skills/store.js";
+import { slmGenerate } from "./slm.js";
+const PAGE_RE = /^=== PÁGINA (\d+) ===\s*$/m;
+/** Texto comparável: sem hífen de quebra de linha, sem caixa/acentos, espaços colapsados. */
+export const norm = (s) => s.replace(/­\s*/g, "").replace(/-\s*\n\s*/g, "").toLowerCase().normalize("NFD").replace(/\p{M}/gu, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+/** Comparação tolerante a OCR: só letras e dígitos (espaços no meio de palavras, hifenização e pontuação não contam). */
+export const squash = (s) => norm(s).replace(/ /g, "");
+const META_RE = /sum[áa]rio|[íi]ndice (remissivo|geral)|todos os direitos|catalog[aã]{1,2}o|isbn|copyright|ficha t[ée]cnica|dados internacionais|agradecimentos|impresso no brasil/i;
+/**
+ * Tira páginas que não são conteúdo: capa, orelha e elogios (as primeiras páginas de um livro longo) e páginas de
+ * metadados (sumário, ficha catalográfica, direitos). Só age em textos com marcas de página e com 60 páginas ou mais:
+ * num capítulo curto, a primeira página É conteúdo.
+ */
+export function stripFrontMatter(text) {
+    const parts = text.split(/(?=^=== PÁGINA \d+ ===\s*$)/m);
+    const marked = parts.filter((p) => PAGE_RE.test(p));
+    if (marked.length < 60)
+        return { text, removed: 0 };
+    const head = Math.min(8, Math.ceil(marked.length * 0.02));
+    let removed = 0;
+    const kept = parts.filter((p) => {
+        const n = Number(PAGE_RE.exec(p)?.[1] ?? NaN);
+        if (!n)
+            return true;
+        // cue de metadados só vale perto das pontas, para não apagar um capítulo que cita "índice" ou "direitos"
+        const edge = n <= head + 12 || n > marked.length - 6;
+        const drop = n <= head || (edge && p.length < 4000 && META_RE.test(p));
+        if (drop)
+            removed++;
+        return !drop;
+    });
+    return { text: kept.join(""), removed };
+}
+/** Divide em blocos de ~chunkChars, respeitando as marcas "=== PÁGINA N ===" quando existem. */
+export function chunkText(text, chunkChars = 5000) {
+    const parts = text.split(/(?=^=== PÁGINA \d+ ===\s*$)/m);
+    const pages = parts.map((p) => ({ page: Number(PAGE_RE.exec(p)?.[1] ?? NaN) || null, text: p }));
+    const out = [];
+    let cur = [];
+    let size = 0;
+    const flush = () => { if (cur.length)
+        out.push({ text: cur.map((p) => p.text).join("\n"), pages: cur }); cur = []; size = 0; };
+    for (const pg of pages) {
+        // página gigante (ou texto sem marcas): fatia por tamanho
+        if (pg.text.length > chunkChars * 1.5) {
+            flush();
+            for (let i = 0; i < pg.text.length; i += chunkChars) {
+                const t = pg.text.slice(i, i + chunkChars);
+                out.push({ text: t, pages: [{ page: pg.page, text: t }] });
+            }
+            continue;
+        }
+        if (size + pg.text.length > chunkChars)
+            flush();
+        cur.push(pg);
+        size += pg.text.length;
+    }
+    flush();
+    return out;
+}
+/** Afinidade lexical (barata, sem modelo) entre o objetivo e cada bloco: escolhe onde vale gastar o SLM. */
+export function rankChunks(chunks, objective) {
+    const q = [...new Set(words(objective))];
+    return chunks.map((c, index) => {
+        const t = norm(c.text);
+        let score = 0;
+        for (const w of q) {
+            const m = t.split(w).length - 1;
+            score += m ? 1 + Math.log(m) : 0;
+        }
+        return { ...c, score, index };
+    });
+}
+/** Página onde a citação aparece (a primeira página do bloco em que ela cabe inteira; senão a primeira em que começa). */
+function pageOf(c, quoteSq) {
+    for (const p of c.pages)
+        if (squash(p.text).includes(quoteSq))
+            return p.page;
+    const head = quoteSq.slice(0, 40);
+    for (const p of c.pages)
+        if (squash(p.text).includes(head))
+            return p.page;
+    return c.pages[0]?.page ?? null;
+}
+/** Confere as citações propostas contra o texto do bloco. Só passa o que existe literalmente (após normalização). */
+export function verifyExcerpts(c, proposed) {
+    const body = squash(c.text);
+    const kept = [];
+    let discarded = 0;
+    for (const p of proposed) {
+        const quote = typeof p?.quote === "string" ? p.quote.trim() : "";
+        const qn = squash(quote);
+        if (qn.length < 25 || !body.includes(qn)) {
+            discarded++;
+            continue;
+        }
+        kept.push({ quote, topic: typeof p.topic === "string" && p.topic.trim() ? p.topic.trim().slice(0, 80) : "Geral", page: pageOf(c, qn), chunk: c.index });
+    }
+    return { kept, discarded };
+}
+const EXTRACT_SCHEMA = {
+    type: "object",
+    properties: { excerpts: { type: "array", maxItems: 4, items: { type: "object", properties: { quote: { type: "string" }, topic: { type: "string" } }, required: ["quote", "topic"] } } },
+    required: ["excerpts"],
+};
+const OUTLINE_SCHEMA = {
+    type: "object",
+    properties: { sections: { type: "array", maxItems: 8, items: { type: "object", properties: { heading: { type: "string" }, quotes: { type: "array", items: { type: "integer" } } }, required: ["heading", "quotes"] } } },
+    required: ["sections"],
+};
+const parse = (s) => { try {
+    return JSON.parse(s);
+}
+catch {
+    return null;
+} };
+export async function digest(o) {
+    const gen = o.gen ?? slmGenerate;
+    const front = stripFrontMatter(o.text);
+    const ranked = rankChunks(chunkText(front.text, o.chunkChars), o.objective);
+    const chosen = [...ranked].filter((c) => c.score > 0).sort((a, b) => b.score - a.score).slice(0, o.maxChunks ?? 8).sort((a, b) => a.index - b.index);
+    const stats = { chunks: ranked.length, analyzed: chosen.length, proposed: 0, verified: 0, discarded: 0, skippedPages: front.removed };
+    const system = `Você extrai trechos de um texto longo para um objetivo. Responda SOMENTE com JSON {"excerpts":[{"quote","topic"}]}.
+Regras: (1) "quote" é uma cópia EXATA e contínua de 1 a 3 frases do texto dado; nunca parafraseie, resuma nem corrija. (2) Escolha só trechos que ajudam o objetivo; prefira incluir um trecho duvidoso a perder um bom. (3) O texto pode ter erros de OCR (espaços no meio de palavras, hifenização): copie as PALAVRAS exatamente, corrigindo só esses espaços. (4) "topic" é um rótulo curto (2 a 5 palavras) do assunto do trecho. (5) Se nada serve, responda {"excerpts":[]}.`;
+    const found = [];
+    const seen = new Set();
+    let n = 0;
+    for (const c of chosen) {
+        n++;
+        o.onProgress?.(`analisando bloco ${n}/${chosen.length}`);
+        let data = null;
+        try {
+            data = parse(await gen({ system, user: `Objetivo: ${o.objective}\n\nTexto:\n${c.text}`, schema: EXTRACT_SCHEMA, maxTokens: 900, temperature: 0.1, signal: o.signal }));
+        }
+        catch (e) {
+            if (o.signal?.aborted)
+                throw e;
+        }
+        const proposed = Array.isArray(data?.excerpts) ? data.excerpts : [];
+        stats.proposed += proposed.length;
+        const { kept, discarded } = verifyExcerpts(c, proposed);
+        stats.discarded += discarded;
+        for (const k of kept) {
+            const key = squash(k.quote);
+            if (!seen.has(key)) {
+                seen.add(key);
+                found.push(k);
+            }
+        }
+    }
+    stats.verified = found.length;
+    // Plano: o SLM agrupa por número; índices inválidos são ignorados, e o que sobrar cai em "Outros".
+    let sections = [];
+    if (found.length > 1) {
+        o.onProgress?.("montando o plano");
+        const list = found.map((f, i) => `${i}. [${f.topic}] ${f.quote.replace(/\s+/g, " ").slice(0, 160)}`).join("\n");
+        try {
+            const plan = parse(await gen({ system: `Você organiza trechos num plano para o objetivo dado. Responda SOMENTE com JSON {"sections":[{"heading","quotes":[números]}]}. Cada número de trecho aparece em UMA seção; os títulos seguem a ordem lógica do argumento (máx. 8).`, user: `Objetivo: ${o.objective}\n\nTrechos:\n${list}`, schema: OUTLINE_SCHEMA, maxTokens: 700, temperature: 0.1, signal: o.signal }));
+            const used = new Set();
+            for (const s of Array.isArray(plan?.sections) ? plan.sections : []) {
+                const items = (Array.isArray(s?.quotes) ? s.quotes : []).filter((i) => Number.isInteger(i) && i >= 0 && i < found.length && !used.has(i));
+                items.forEach((i) => used.add(i));
+                if (items.length && typeof s.heading === "string")
+                    sections.push({ heading: s.heading.trim().slice(0, 100), items });
+            }
+            const rest = found.map((_, i) => i).filter((i) => !used.has(i));
+            if (rest.length)
+                sections.push({ heading: "Outros trechos", items: rest });
+        }
+        catch (e) {
+            if (o.signal?.aborted)
+                throw e;
+            sections = [];
+        }
+    }
+    if (!sections.length) {
+        const byTopic = new Map();
+        found.forEach((f, i) => byTopic.set(f.topic, [...(byTopic.get(f.topic) ?? []), i]));
+        sections = [...byTopic].map(([heading, items]) => ({ heading, items }));
+    }
+    return { markdown: render(o, found, sections, stats), stats };
+}
+function render(o, found, sections, s) {
+    const cite = (e) => (e.page ? ` (p. ${e.page})` : "");
+    const body = sections.map((sec) => `### ${sec.heading}\n${sec.items.map((i) => `- “${found[i].quote.replace(/\s+/g, " ")}”${cite(found[i])}`).join("\n")}`).join("\n\n");
+    return `---
+tipo: digest
+fonte: ${o.source}
+objetivo: ${o.objective.replace(/\n/g, " ")}
+gerado-por: SLM local
+---
+# Digest: ${o.objective.replace(/\n/g, " ")}
+
+> Rascunho de um modelo pequeno. Os trechos entre aspas foram CONFERIDOS no texto-fonte (mesmas palavras; só espaços e hifenização de OCR foram normalizados; páginas conforme as marcas do arquivo). A SELEÇÃO e o agrupamento podem ser incompletos: foram analisados ${s.analyzed} de ${s.chunks} blocos${s.skippedPages ? ` (${s.skippedPages} página(s) de capa/orelha/metadados ignoradas)` : ""} (os de maior afinidade com o objetivo); ${s.discarded} citação(ões) proposta(s) foram descartadas por não existirem no texto.
+
+## Plano
+${sections.map((sec, i) => `${i + 1}. ${sec.heading} (${sec.items.length})`).join("\n") || "(nenhum trecho verificado)"}
+
+## Trechos
+${body || "(nenhum trecho verificado)"}
+`;
+}

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,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import "../tools/graph.js";
 import "../tools/skills.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 +28,13 @@ 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$)/.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");
+const exposed = () => allTools().filter((t) => /^(graph_|skill_)/.test(t.name) || t.name === "remember" || t.name === "recall" || t.name === "digest");
 /** 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;

package/dist/permissions.js

@@ -19,9 +19,9 @@ export const MODE_LABEL = {
     bypass: { icon: "⚡", name: "tudo liberado", hint: "executa tudo sem perguntar" },
 };
 /** Acrescentado ao system prompt do backend de API enquanto o modo plano está ativo. */
-export const PLAN_NOTE = `
-
-# MODO PLANO ATIVO
+export const PLAN_NOTE = `
+
+# MODO PLANO ATIVO
 Você só pode ler, pesquisar e consultar o grafo. Edições e comandos shell estão bloqueados. Investigue, monte um plano concreto (arquivos, mudanças, riscos, como verificar) e chame exit_plan com ele. Só execute depois que o usuário aprovar.`;
 /** Texto do pedido de permissão para uma tool do claude CLI (Bash, Edit, Write…). Primeira linha = resumo. */
 export function describeClaudeTool(name, input) {

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";