brito-cli 0.3.2 → 0.5.0

package/dist/cli.js

@@ -7,27 +7,28 @@ import "./tools/bash.js";
 import "./tools/graph.js";
 import "./tools/delegate.js";
 import "./tools/plan.js";
-import net from "node:net";
-import os from "node:os";
 import fs from "node:fs";
-import { PLAN_NOTE, perms, describeClaudeTool } from "./permissions.js";
+import { PLAN_NOTE, perms } from "./permissions.js";
 import { loadProjectAgents, listAgents } from "./agent/agents.js";
 import { GraphLockedError, GraphStore } from "./graph/store.js";
 import { indexProject } from "./graph/indexer.js";
 import { Agent, MODEL } from "./agent/loop.js";
 import { EFFORTS, MODEL_ALIASES, MODEL_HELP, effortLabel, initialEffort, isEffort, loadReasoningDisplay, parseModelArgs, saveEffort, saveModel, saveReasoningDisplay } from "./model.js";
 import { hasClaudeCli, ClaudeSession } from "./agent/claude-cli.js";
+import { startApprovalServer } from "./agent/approval.js";
 import { serveMcp } from "./mcp/server.js";
 import "./tools/skills.js";
 import { approvePending, lintSkill, listPending, listSkills, rejectPending, skillsIndex, staleRefs } from "./skills/store.js";
-import { applyProposal, describeProposal, proposeConsolidation, pruneCandidates } from "./skills/consolidate.js";
-import { defaultComplete, reflect, shouldReflect } from "./skills/learn.js";
+import { applyProposal, autoConsolidate, describeProposal, proposeConsolidation, pruneCandidates } from "./skills/consolidate.js";
+import { defaultComplete, recordOutcomes, reflect, shouldReflect } from "./skills/learn.js";
+import { expireTrials, skillsMode } from "./skills/trial.js";
 import { claudeCliComplete } from "./skills/learn-cli.js";
 import { buildSystemPrompt, graphStatsLine } from "./agent/prompt.js";
 import { allTools } from "./tools/registry.js";
 import { ui, c, fmtTokens } from "./ui/ui.js";
 import { runRepl } from "./repl.js";
-const program = new Command().name("brito").description("CLI de agentes de desenvolvimento com grafo de conhecimento").enablePositionalOptions();
+const pkgVersion = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+const program = new Command().name("brito").description("CLI de agentes de desenvolvimento com grafo de conhecimento").version(pkgVersion, "-v, --version", "mostra a versão").enablePositionalOptions();
 const rootOf = (o) => path.resolve(o.dir ?? process.cwd());
 program
     .command("index")
@@ -42,6 +43,12 @@ program
     console.log(`OK: ${s.files} arquivos, ${s.symbols} símbolos, ${s.calls} chamadas, ${s.imports} imports | +${s.added} ~${s.changed} -${s.removed} =${s.unchanged} (${Date.now() - t}ms)`);
     await g.close();
 });
+program
+    .command("gui-serve", { hidden: true })
+    .description("Backend do app desktop (JSON por stdio)")
+    .option("-d, --dir <dir>")
+    .option("--resume <id>", "retoma uma conversa do claude")
+    .action(async (o) => { const { serveDesktop } = await import("./desktop/serve.js"); await serveDesktop(rootOf(o), o.resume); });
 program
     .command("query <cypher>")
     .description("Executa Cypher no grafo")
@@ -73,48 +80,6 @@ async function plainAsk(q) {
     return /^(s|y)/i.test(a.trim());
 }
 /** Sem API key: o `claude` oficial (login da assinatura) faz o modelo; grafo/memória/skills chegam via MCP. */
-/**
- * Aprovações do claude CLI: o claude chama a tool MCP `approve` (--permission-prompt-tool), que roda no
- * processo do servidor MCP e consulta ESTE processo por um socket unix, onde está o terminal.
- */
-function startApprovalServer(io) {
-    const sock = path.join(os.tmpdir(), `brito-approve-${process.pid}.sock`);
-    try {
-        fs.unlinkSync(sock);
-    }
-    catch { /* não existia */ }
-    const server = net.createServer((conn) => {
-        let buf = "";
-        conn.on("data", async (d) => {
-            buf += d.toString();
-            const nl = buf.indexOf("\n");
-            if (nl < 0)
-                return;
-            let reply;
-            try {
-                const req = JSON.parse(buf.slice(0, nl));
-                const plan = req.tool_name === "ExitPlanMode";
-                const ok = await io.ask(describeClaudeTool(req.tool_name, req.input), { force: plan });
-                if (ok && plan)
-                    perms.mode = "manual";
-                reply = ok ? { allow: true } : { allow: false, message: plan ? "Plano não aprovado pelo usuário. Pergunte o que ajustar." : "O usuário negou a execução." };
-            }
-            catch (e) {
-                reply = { allow: false, message: `erro no pedido de aprovação: ${e?.message ?? e}` };
-            }
-            conn.end(JSON.stringify(reply) + "\n");
-        });
-        conn.on("error", () => { });
-    });
-    server.listen(sock);
-    server.unref();
-    const close = () => { server.close(); try {
-        fs.unlinkSync(sock);
-    }
-    catch { /* já removido */ } };
-    process.on("exit", close);
-    return { path: sock, close };
-}
 /** Menus ↑↓+Enter do `/model`: modelo e depois escopo. null = cancelado. */
 async function pickModel(current) {
     const models = Object.entries(MODEL_ALIASES);
@@ -353,7 +318,7 @@ const skillsCommand = (root, io, llm) => ({
         const skills = listSkills(root);
         for (const s of skills) {
             const stale = staleRefs(root, s);
-            ui.print(`  ${c.soft(s.name)} ${c.muted(`(${s.scope}) v${s.version} · ${s.uses} usos · último uso ${s.lastUsed} · ${s.description}`)}${stale.length ? " " + c.warn(`⚠ refs obsoletas: ${stale.join(", ")}`) : ""}`);
+            ui.print(`  ${c.soft(s.name)} ${c.muted(`(${s.scope}) v${s.version} · ${s.uses} usos${s.origin === "auto" ? ` · ${s.status === "trial" ? "em teste" : "automática"} ${s.wins}✓/${s.losses}✗` : ""} · último uso ${s.lastUsed} · ${s.description}`)}${stale.length ? " " + c.warn(`⚠ refs obsoletas: ${stale.join(", ")}`) : ""}`);
         }
         const prune = pruneCandidates(skills);
         if (prune.length)
@@ -367,6 +332,10 @@ function makeLearner(getTurns, ctx, complete, model) {
     return async (force = false) => {
         const turns = getTurns();
         const turn = turns[turns.length - 1] ?? null;
+        // 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))])
+                ui.print(c.ok("✦ ") + n);
         if (!force && !shouldReflect(turn, ctx)) {
             ctx.loadedSkills?.clear();
             return;
@@ -384,6 +353,13 @@ function makeLearner(getTurns, ctx, complete, model) {
                 ui.print(c.ok("✦ ") + n);
             if (!notes.length)
                 ui.info("✦ nenhuma skill nova");
+            if (skillsMode() === "auto") {
+                try {
+                    for (const n of await autoConsolidate(ctx.root, model, complete))
+                        ui.print(c.ok("✦ ") + n);
+                }
+                catch { /* manutenção é opcional */ }
+            }
         }
         catch (e) {
             ui.turnEnd(false);
@@ -473,6 +449,12 @@ program
     .option("-d, --dir <dir>", "raiz do projeto")
     .option("-y, --yes", "aprovar edições e comandos automaticamente")
     .action(async (promptParts, o) => {
+    // Trava anti-recursão: um brito iniciado por dentro de um claude que o próprio brito lançou (BRITO_DEPTH) pode abrir
+    // outro claude, e assim por diante. Dois níveis bastam; mais que isso é laço de processos.
+    if (Number(process.env.BRITO_DEPTH ?? 0) >= 2) {
+        console.error("brito aninhado demais (BRITO_DEPTH): abortando para evitar laço de processos.");
+        process.exit(1);
+    }
     if (!process.env.ANTHROPIC_API_KEY) {
         if (!hasClaudeCli()) {
             console.error(c.err("Defina ANTHROPIC_API_KEY ou instale o Claude Code e rode `claude` → /login."));
@@ -559,7 +541,8 @@ program
         },
     });
 });
-program.parseAsync().catch((e) => {
+// from: "node" explícito: dentro do Electron (ELECTRON_RUN_AS_NODE) o commander trataria o caminho do script como argumento.
+program.parseAsync(process.argv, { from: "node" }).catch((e) => {
     if (e instanceof GraphLockedError) {
         console.error(c.err("✗ ") + e.message);
         process.exit(1);

package/dist/desktop/serve.js

@@ -0,0 +1,209 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+import "../tools/fs.js";
+import "../tools/bash.js";
+import "../tools/graph.js";
+import "../tools/delegate.js";
+import "../tools/plan.js";
+import "../tools/skills.js";
+import { Agent } from "../agent/loop.js";
+import { ClaudeSession, hasClaudeCli } from "../agent/claude-cli.js";
+import { startApprovalServer } from "../agent/approval.js";
+import { loadProjectAgents } from "../agent/agents.js";
+import { buildSystemPrompt, graphStatsLine } from "../agent/prompt.js";
+import { GraphStore } from "../graph/store.js";
+import { indexProject } from "../graph/indexer.js";
+import { DEFAULT_MODEL, initialEffort, initialModel, isEffort, MODEL_ALIASES } from "../model.js";
+import { PLAN_NOTE, perms } from "../permissions.js";
+import { skillsIndex } from "../skills/store.js";
+/**
+ * Backend do app desktop, controlado por JSON em linhas.
+ * stdin  → {t:"send",text} {t:"abort"} {t:"approve",id,allow} {t:"config",model?,effort?,mode?} {t:"reset"} {t:"quit"}
+ * stdout → linhas "@@{json}" (qualquer outra linha, como logs perdidos, a janela ignora).
+ * Motor: com ANTHROPIC_API_KEY usa a API direta (como o `brito` no terminal); sem ela, o `claude` CLI (assinatura).
+ */
+const MARK = "@@";
+const emit = (ev) => process.stdout.write(MARK + JSON.stringify(ev) + "\n");
+const sink = {
+    turnStart: () => emit({ t: "turnStart" }),
+    turnEnd: (ok = true) => emit({ t: "turnEnd", ok }),
+    text: (text) => emit({ t: "text", text }),
+    textEnd: () => emit({ t: "textEnd" }),
+    thinking: (text) => emit({ t: "thinking", text }),
+    toolStart: (id, name, input) => emit({ t: "toolStart", id, name, input }),
+    toolEnd: (id, isError, output) => emit({ t: "toolEnd", id, isError, output: (output ?? "").slice(0, 4000) }),
+    info: (msg) => emit({ t: "info", msg }),
+    warn: (msg) => emit({ t: "warn", msg }),
+    error: (msg) => emit({ t: "error", msg }),
+};
+const CTX_WINDOW = Number(process.env.BRITO_CONTEXT_WINDOW ?? 200_000);
+export async function serveDesktop(root, resumeId) {
+    const pending = new Map();
+    const ask = (text, opts) => perms.mode === "bypass" && !opts?.force ? Promise.resolve(true) : new Promise((resolve) => {
+        const id = randomUUID();
+        pending.set(id, resolve);
+        emit({ t: "approval", id, text, force: !!opts?.force });
+    });
+    // Na pasta pessoal (projeto "Home") indexar tudo seria enorme e inútil: sem índice ali.
+    const isHome = path.resolve(root) === path.resolve(os.homedir());
+    const useApi = !!process.env.ANTHROPIC_API_KEY;
+    if (!useApi && !hasClaudeCli()) {
+        emit({ t: "error", msg: "Sem acesso ao modelo: defina ANTHROPIC_API_KEY (no seu shell) ou instale o Claude Code e rode `claude` → /login." });
+        process.exit(1);
+    }
+    loadProjectAgents(root);
+    let engine;
+    let syms = 0, notes = 0;
+    let closeApproval = () => { };
+    if (useApi) {
+        // API direta: o grafo fica aberto neste processo (sem servidor MCP), como no `brito` do terminal.
+        // No Home o banco vai para ~/.brito/home-graph, para não criar .brito dentro da pasta pessoal.
+        const graphRoot = isHome ? path.join(os.homedir(), ".brito", "home-graph") : root;
+        fs.mkdirSync(graphRoot, { recursive: true });
+        const graph = await GraphStore.open(graphRoot);
+        const sync = async () => { if (!isHome)
+            syms = (await indexProject(root, graph)).symbols; };
+        emit({ t: "info", msg: "sincronizando grafo…" });
+        try {
+            await sync();
+        }
+        catch (e) {
+            emit({ t: "warn", msg: `grafo indisponível: ${e?.message ?? e}` });
+        }
+        try {
+            notes = Number((await graph.run("MATCH (s:Note) RETURN count(s) AS n"))[0].n);
+        }
+        catch { /* sem notas */ }
+        const ctx = { root, graph, ask, sync, dirty: false, loadedSkills: new Set() };
+        const agent = new Agent(() => buildSystemPrompt(root, graphStatsLine(syms, notes, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : ""), ctx, { model: initialModel(), sink });
+        let ac = null;
+        const id = randomUUID();
+        if (resumeId)
+            emit({ t: "info", msg: "No modo API o histórico da conversa não é retomado ao reabrir; a tela mostra o que já foi dito, mas o modelo recomeça." });
+        engine = {
+            kind: "api", sessionId: id, effort: "",
+            get model() { return agent.model; }, set model(m) { agent.model = m; },
+            setModel: (m) => { agent.model = m; },
+            async send(text) {
+                ac = new AbortController();
+                sink.turnStart();
+                let ok = true;
+                try {
+                    await agent.send(text, ac.signal);
+                }
+                catch (e) {
+                    ok = false;
+                    ac.signal.aborted ? sink.warn("⏹ interrompido") : sink.error(e?.message ?? String(e));
+                }
+                finally {
+                    sink.turnEnd(ok);
+                    ac = null;
+                }
+            },
+            abort: () => ac?.abort(),
+            reset: () => { agent.messages = []; agent.contextTokens = 0; agent.recentTurns = []; agent.lastTurn = null; },
+            stats: () => ({ usage: agent.usage, contextTokens: agent.contextTokens, contextWindow: CTX_WINDOW, costUsd: 0 }),
+            close: async () => { await graph.close(); },
+        };
+    }
+    else {
+        const approval = startApprovalServer({ ask });
+        closeApproval = approval.close;
+        // O kuzu aceita um único processo com escrita: indexa, lê as stats e solta o banco para o servidor MCP.
+        if (!isHome)
+            try {
+                const graph = await GraphStore.open(root);
+                emit({ t: "info", msg: "sincronizando grafo…" });
+                await indexProject(root, graph);
+                syms = Number((await graph.run("MATCH (s:Symbol) RETURN count(s) AS n"))[0].n);
+                notes = Number((await graph.run("MATCH (s:Note) RETURN count(s) AS n"))[0].n);
+                await graph.close();
+            }
+            catch (e) {
+                emit({ t: "warn", msg: `grafo indisponível: ${e?.message ?? e}` });
+            }
+        const session = new ClaudeSession({
+            root, approvalSock: approval.path, stats: graphStatsLine(syms, notes, "start"), sink,
+            mcpCommand: { command: process.execPath, args: [...process.execArgv, process.argv[1], "mcp-serve", "-d", root] },
+            // 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,
+        });
+        if (resumeId)
+            session.resume(resumeId);
+        session.effort = initialEffort();
+        engine = {
+            kind: "claude",
+            get sessionId() { return session.sessionId; },
+            get model() { return session.model; },
+            get effort() { return session.effort; }, set effort(e) { session.effort = e; },
+            setModel: (m) => { session.requestedModel = m; session.model = m || "claude (assinatura)"; },
+            send: async (text) => { await session.send(text); },
+            abort: () => session.abort(),
+            reset: () => session.reset(),
+            stats: () => ({ usage: session.usage, contextTokens: session.contextTokens, contextWindow: session.contextWindow, costUsd: session.costUsd }),
+            close: async () => { },
+        };
+    }
+    let busy = false;
+    const ready = () => emit({ t: "ready", engine: engine.kind, sessionId: engine.sessionId, model: engine.model, effort: engine.effort, mode: perms.mode, symbols: syms, notes, root });
+    ready();
+    const rl = readline.createInterface({ input: process.stdin });
+    const quit = async () => { closeApproval(); try {
+        await engine.close();
+    }
+    catch { /* saindo */ } process.exit(0); };
+    rl.on("close", quit);
+    rl.on("line", async (line) => {
+        let m;
+        try {
+            m = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        switch (m.t) {
+            case "send": {
+                if (busy)
+                    return emit({ t: "warn", msg: "já existe um turno em andamento" });
+                busy = true;
+                try {
+                    await engine.send(String(m.text ?? ""));
+                }
+                finally {
+                    busy = false;
+                    emit({ t: "usage", ...engine.stats(), model: engine.model, sessionId: engine.sessionId });
+                }
+                break;
+            }
+            case "abort":
+                engine.abort();
+                break;
+            case "approve":
+                pending.get(m.id)?.(!!m.allow);
+                pending.delete(m.id);
+                break;
+            case "config": {
+                if (typeof m.model === "string" && m.model)
+                    engine.setModel(MODEL_ALIASES[m.model] ?? m.model);
+                else if (m.model === "")
+                    engine.setModel(engine.kind === "api" ? DEFAULT_MODEL : "");
+                if (m.effort !== undefined)
+                    engine.effort = isEffort(m.effort) ? m.effort : "";
+                if (["manual", "auto", "plan", "bypass"].includes(m.mode))
+                    perms.mode = m.mode;
+                ready();
+                break;
+            }
+            case "reset":
+                engine.reset();
+                ready();
+                break;
+            case "quit":
+                await quit();
+                break;
+        }
+    });
+}

package/dist/graph/indexer.js

@@ -1,5 +1,5 @@
 import Parser from "web-tree-sitter";
-import fg from "fast-glob";
+import { glob as fg } from "tinyglobby";
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";

package/dist/repl.js

@@ -1,3 +1,4 @@
+import { shellFor } from "./util/platform.js";
 import readline from "node:readline";
 import path from "node:path";
 import { exec } from "node:child_process";
@@ -81,7 +82,7 @@ export async function runRepl(b, o) {
         return r;
     };
     // ---------------------------------------------------------------- comandos
-    const shell = (cmd) => new Promise((done) => exec(cmd, { cwd: o.root, maxBuffer: 10 * 1024 * 1024 }, (err, out, errOut) => {
+    const shell = (cmd) => new Promise((done) => exec(cmd, { cwd: o.root, shell: shellFor(), maxBuffer: 10 * 1024 * 1024 }, (err, out, errOut) => {
         ui.print((out + (errOut ? c.err(errOut) : "") + (err && !out && !errOut ? c.err(String(err.message)) : "")).replace(/\n$/, ""));
         done();
     }));

package/dist/setup.js

@@ -0,0 +1,110 @@
+import readline from "node:readline";
+import { hasClaudeCli } from "./agent/claude-cli.js";
+import { DEFAULT_MODEL, MODEL_ALIASES, saveEffort, saveModel, saveReasoningDisplay } from "./model.js";
+import { c } from "./ui/theme.js";
+const out = (s = "") => process.stdout.write(s + "\n");
+/** Menu de setas (↑/↓, j/k, número, Enter). Ctrl+C cancela o assistente. */
+async function select(title, options, current = 0) {
+    const stdin = process.stdin;
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    let idx = current;
+    let drawn = 0;
+    const render = () => {
+        if (drawn)
+            process.stdout.write(`\x1b[${drawn}A\x1b[J`);
+        const lines = [c.bold(title)];
+        options.forEach((o, i) => {
+            const on = i === idx;
+            lines.push(`  ${on ? c.accent("❯") : " "} ${on ? c.light(o.label) : o.label}${o.hint ? c.muted("  " + o.hint) : ""}`);
+        });
+        lines.push(c.muted("  ↑/↓ navegar · Enter confirmar"));
+        process.stdout.write(lines.join("\n") + "\n");
+        drawn = lines.length;
+    };
+    render();
+    return new Promise((resolve) => {
+        const onKey = (_, key) => {
+            if (key.ctrl && key.name === "c") {
+                stdin.setRawMode(false);
+                out();
+                process.exit(130);
+            }
+            if (key.name === "up" || key.name === "k")
+                idx = (idx + options.length - 1) % options.length;
+            else if (key.name === "down" || key.name === "j")
+                idx = (idx + 1) % options.length;
+            else if (key.sequence && /^[1-9]$/.test(key.sequence) && Number(key.sequence) <= options.length)
+                idx = Number(key.sequence) - 1;
+            else if (key.name === "return") {
+                stdin.off("keypress", onKey);
+                stdin.setRawMode(false);
+                stdin.pause();
+                process.stdout.write(`\x1b[${drawn}A\x1b[J`);
+                out(`${c.bold(title)} ${c.ok("✓")} ${c.light(options[idx].label)}`);
+                return resolve(options[idx].value);
+            }
+            render();
+        };
+        stdin.on("keypress", onKey);
+    });
+}
+const step = (n, total, name) => out(`\n${c.accent(`◆ Passo ${n}/${total}`)} ${c.muted("·")} ${c.bold(name)}`);
+export async function runSetup(opts = {}) {
+    const interactive = !!process.stdin.isTTY && !!process.stdout.isTTY && !opts.yes;
+    const total = 4;
+    const hasKey = !!process.env.ANTHROPIC_API_KEY;
+    const hasCli = hasClaudeCli();
+    out();
+    out(c.accent("  ╭─────────────────────────────────────╮"));
+    out(c.accent("  │") + c.bold("   Brito · assistente de configuração".padEnd(37)) + c.accent("│"));
+    out(c.accent("  ╰─────────────────────────────────────╯"));
+    out(c.muted("  Escolhas ficam em ~/.brito/config.json; rode `brito setup` de novo quando quiser mudar."));
+    // 1 · autenticação
+    step(1, total, "Autenticação");
+    out(`  ${hasKey ? c.ok("✓") : c.muted("·")} ANTHROPIC_API_KEY ${hasKey ? "definida" : "não definida"}`);
+    out(`  ${hasCli ? c.ok("✓") : c.muted("·")} Claude Code (claude CLI) ${hasCli ? "encontrado" : "não encontrado"}`);
+    if (!hasKey && !hasCli) {
+        out(c.warn("  Nenhum acesso detectado. Escolha um e depois rode `brito`:"));
+        out(c.muted("    • export ANTHROPIC_API_KEY=sk-ant-…   (chave da API)"));
+        out(c.muted("    • npm i -g @anthropic-ai/claude-code && claude   → /login   (assinatura)"));
+    }
+    let model = DEFAULT_MODEL;
+    let effort;
+    let showReasoning = true;
+    if (interactive) {
+        // 2 · modelo
+        step(2, total, "Modelo padrão");
+        const names = Object.keys(MODEL_ALIASES);
+        const hints = { fable: "mais capaz", opus: "raciocínio profundo", sonnet: "equilíbrio (recomendado)", haiku: "rápido e barato" };
+        model = await select("Qual modelo usar por padrão?", names.map((n) => ({ label: n, hint: hints[n], value: MODEL_ALIASES[n] })), names.indexOf("sonnet"));
+        // 3 · esforço
+        step(3, total, "Esforço de raciocínio");
+        effort = await select("Quanto o modelo deve pensar?", [
+            { label: "padrão", hint: "deixa o claude decidir", value: undefined },
+            { label: "low", hint: "respostas rápidas", value: "low" },
+            { label: "medium", value: "medium" },
+            { label: "high", hint: "tarefas difíceis", value: "high" },
+            { label: "max", hint: "mais lento e caro", value: "max" },
+        ]);
+        // 4 · exibição
+        step(4, total, "Exibição");
+        showReasoning = await select("Mostrar o raciocínio do modelo?", [
+            { label: "sim", hint: "recortado, como no Hermes", value: true },
+            { label: "não", value: false },
+        ]);
+    }
+    else {
+        out(c.muted(`\n  Modo não interativo: usando padrões (${DEFAULT_MODEL}).`));
+    }
+    saveModel(model);
+    saveEffort(effort);
+    saveReasoningDisplay({ show: showReasoning });
+    const row = (k, v) => out(`  ${c.muted(k.padEnd(12))} ${v}`);
+    out(`\n${c.ok("✓")} ${c.bold("Tudo pronto")}`);
+    row("modelo", model);
+    row("esforço", effort ?? "padrão");
+    row("raciocínio", showReasoning ? "visível" : "oculto");
+    out(`\n  Próximo passo: ${c.light("cd seu-projeto && brito")}\n`);
+}

package/dist/skills/consolidate.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import { z } from "zod";
 import { toApiTools } from "../tools/registry.js";
 import { describeSave } from "./describe.js";
@@ -67,10 +69,35 @@ export function describeProposal(root, p, now = Date.now()) {
     return `REMOVER skill ${p.name}${s ? ` (${s.scope}, ${s.uses} usos, último uso há ${daysSince(s.lastUsed, now)} dias; vai para .trash)` : ""}\n  motivo: ${p.reason}`;
 }
 /** Aplica direto no store (o usuário já aprovou; não passa pelo atalho de aprovação do modo bypass). */
-export function applyProposal(root, p) {
+export function applyProposal(root, p, auto = false) {
     if (p.kind === "save") {
-        const r = saveSkill(root, p.input, p.scope);
+        const r = saveSkill(root, p.input, p.scope, { auto });
         return r.created ? `skill ${p.input.name} criada (${r.scope}, v1)` : `skill ${p.input.name} atualizada (${r.scope}, v${r.version})`;
     }
     return deleteSkill(root, p.name) ? `skill ${p.name} removida` : `skill ${p.name} não encontrada`;
 }
+/** Só propostas que tocam skills criadas sozinhas podem ser aplicadas sem o usuário; as demais ficam para `/skills consolidate`. */
+export function autoApplicable(root, proposals) {
+    return proposals.filter((p) => {
+        const s = getSkill(root, p.kind === "save" ? p.input.name : p.name);
+        return p.kind === "save" ? (!s || s.origin === "auto") : s?.origin === "auto";
+    });
+}
+const STAMP = ".last-consolidate";
+const CONSOLIDATE_EVERY_DAYS = 7;
+const CONSOLIDATE_MIN_SKILLS = 6;
+/** Consolidação periódica sem o usuário: no máximo 1x por semana, com ≥6 skills, só sobre skills automáticas. Devolve avisos. */
+export async function autoConsolidate(root, model, complete, now = Date.now()) {
+    if (listSkills(root, now).length < CONSOLIDATE_MIN_SKILLS)
+        return [];
+    const stamp = path.join(root, ".brito", "skills", STAMP);
+    try {
+        if (now - fs.statSync(stamp).mtimeMs < CONSOLIDATE_EVERY_DAYS * 86_400_000)
+            return [];
+    }
+    catch { /* nunca rodou */ }
+    fs.mkdirSync(path.dirname(stamp), { recursive: true });
+    fs.writeFileSync(stamp, new Date(now).toISOString());
+    const proposals = autoApplicable(root, await proposeConsolidation(root, model, complete, now));
+    return proposals.map((p) => applyProposal(root, p, true));
+}

package/dist/skills/learn-cli.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { claudeCommand } from "../util/platform.js";
 import os from "node:os";
 // Backend sem ANTHROPIC_API_KEY: usa o `claude` oficial (login do usuário). Sem tools nem settings: só julga o transcript.
 // O `skill_save` vira saída estruturada ({saves:[…]}) e é convertida de volta em blocos tool_use.
@@ -30,7 +31,8 @@ export const claudeCliComplete = ({ model, system, user }) => new Promise((resol
         "--disable-slash-commands", "--setting-sources", "", "--json-schema", JSON.stringify(SCHEMA)];
     if (model)
         args.push("--model", model);
-    const child = spawn("claude", args, { cwd: os.tmpdir(), stdio: ["pipe", "pipe", "pipe"] });
+    const cmd = claudeCommand(args);
+    const child = spawn(cmd.command, cmd.args, { cwd: os.tmpdir(), stdio: ["pipe", "pipe", "pipe"] });
     let out = "", err = "";
     child.stdout.on("data", (d) => (out += d));
     child.stderr.on("data", (d) => (err += d));

package/dist/skills/learn.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { execTool, toApiTools } from "../tools/registry.js";
 import { perms } from "../permissions.js";
 import { getSkill, listPending, listSkills, savePending, staleRefs } from "./store.js";
+import { saveAuto, skillsMode, recordOutcome } from "./trial.js";
 import { appendJournal, describeEntry, entryFromTurn, similarEntries } from "./journal.js";
 /** Turno longo sem nenhum outro sinal só vale reflexão a partir deste tamanho. */
 const MIN_TOOLS = Number(process.env.BRITO_SKILL_MIN_TOOLS ?? 12);
@@ -76,12 +77,27 @@ export function extractSignals(turn) {
  * `BRITO_LEARN_V2=0` volta ao gatilho antigo (≥6 tools ou skill usada).
  */
 export function shouldReflect(turn, ctx) {
-    if (!turn || !turn.finished)
+    if (!turn || !turn.finished || skillsMode() === "off")
         return false;
     if (process.env.BRITO_LEARN_V2 === "0")
         return turn.toolCalls >= 6 || (ctx.loadedSkills?.size ?? 0) > 0;
     return extractSignals(turn).length > 0 || turn.toolCalls >= MIN_TOOLS;
 }
+/** Resultado do turno para as skills carregadas nele: tropeço (erro→conserto ou correção do usuário) é falha. Abortado = neutro. */
+export function judgeTurn(turn) {
+    if (!turn.finished)
+        return null;
+    return extractSignals(turn).length ? "loss" : "win";
+}
+/** Credita o turno às skills carregadas nele; pode promover ou arquivar skills em teste. Devolve avisos. */
+export function recordOutcomes(turn, ctx) {
+    if (!turn || skillsMode() === "off")
+        return [];
+    const verdict = judgeTurn(turn);
+    if (!verdict)
+        return [];
+    return [...(ctx.loadedSkills ?? [])].flatMap((n) => recordOutcome(ctx.root, n, verdict === "win") ?? []);
+}
 export const defaultComplete = async ({ model, system, user, tools, maxTokens }) => {
     const res = await new Anthropic().messages.create({ model, max_tokens: maxTokens, system, tools, messages: [{ role: "user", content: user }] });
     return res.content;
@@ -172,8 +188,21 @@ export function buildReflectInput(turn, ctx, previous) {
         (previous ? `# Turno anterior (só contexto, não é o que está sendo avaliado)\n${renderPrevious(previous)}\n\n` : "") +
         `# Transcript do turno (${turn.toolCalls} chamadas de tool, ${turn.errors} com erro)\n${renderTranscript(turn)}`);
 }
+const SaveArgs = z.object({ name: z.string(), description: z.string(), body: z.string(), refs: z.array(z.string()).default([]), reason: z.string().default(""), scope: z.enum(["project", "global"]).optional() });
+/** Modo autônomo: grava em teste (ou na fila de revisão, se for arriscado) sem perguntar ao usuário. */
+function stageAuto(input, ctx) {
+    const parsed = SaveArgs.safeParse(input);
+    if (!parsed.success)
+        return { saved: false, msg: "skill não salva: input inválido" };
+    try {
+        return saveAuto(ctx.root, parsed.data);
+    }
+    catch (e) {
+        return { saved: false, msg: `skill não salva: ${e?.message ?? e}` };
+    }
+}
 function stage(input, ctx) {
-    const parsed = z.object({ name: z.string(), description: z.string(), body: z.string(), refs: z.array(z.string()).default([]), reason: z.string().default(""), scope: z.enum(["project", "global"]).optional() }).safeParse(input);
+    const parsed = SaveArgs.safeParse(input);
     if (!parsed.success)
         return `skill não salva: input inválido`;
     try {
@@ -195,6 +224,13 @@ export async function reflect(turn, ctx, model, complete = defaultComplete, prev
             continue;
         saves++;
         const name = String(b.input?.name ?? "");
+        if (skillsMode() === "auto") {
+            const r = stageAuto(b.input, ctx);
+            out.push(r.msg);
+            if (r.saved)
+                saved.push(name);
+            continue;
+        }
         // Em bypass nada pede aprovação: a proposta vai para a fila de revisão em vez de virar instrução ativa.
         if (perms.mode === "bypass") {
             const msg = stage(b.input, ctx);