brito-cli 0.3.2 → 0.4.0

package/README.md

@@ -14,9 +14,9 @@ Brito is a terminal agent for software development. Instead of grepping and read
 
 - **Graph-first exploration.** `graph_search`, `graph_context`, `graph_callers`, `graph_callees` and `graph_impact` answer "where is it, who uses it, what breaks" without reading whole files. The graph is embedded ([Kùzu](https://kuzudb.com)), local and incremental.
 - **Wide coverage.** TypeScript/JavaScript, Python and the script blocks of `.svelte`, `.vue` and `.astro` components. Import aliases (`tsconfig` paths, `package.json` imports, SvelteKit's `$lib`) become real edges. Files ignored by `.gitignore` stay out.
-- **Skills that learn, with a human in the loop.** After a complex task Brito reflects on what happened and *proposes* skills. Nothing becomes active until you run `/skills approve`.
+- **Skills that learn on their own, on probation.** After a task that tripped or was corrected, Brito reflects and creates a skill *in trial* without interrupting you. A skill proves itself by use: 3 clean uses promote it, 2 stumbles archive it (recoverable). Anything risky, or any change to a skill you approved, still waits for your `/skills approve`. `BRITO_SKILLS=ask` restores approval-for-everything; `off` disables learning.
 - **Safety rails for what gets learned.** A lint rejects secrets, credentials embedded in URLs, `curl | sh` and prompt-injection phrasing, and **warns about destructive commands** (see below).
-- **Permission modes.** manual, auto-edits, plan and "everything allowed" (`Shift+Tab` cycles them). Even in the last one, skills are queued for review instead of being activated.
+- **Permission modes.** manual, auto-edits, plan and "everything allowed" (`Shift+Tab` cycles them). Autonomous skills do not depend on the mode: they are created in trial and judged by results.
 - **Two backends, one interface.** Use an Anthropic API key, or your Claude Code subscription through the `claude` CLI. Brito never reads or sends your subscription token.
 - **Subagents.** `explore`, `plan` and `general` run in isolated contexts (read-only ones in parallel); add your own in `.brito/agents/*.md`.
 - **MCP server.** `brito mcp-serve` exposes the graph, memory and skills to other MCP clients such as Claude Code. The query tools are marked `alwaysLoad`, so they are not hidden behind tool search.
@@ -29,9 +29,13 @@ flowchart LR
     cg <-->|"graph_search · graph_callers<br/>graph_impact · graph_context"| agent{{"Brito agent"}}
     mem[("Memory<br/>decisions · conventions")] <-->|"recall / remember"| agent
     agent -->|"after a complex task"| learn["Reflection"]
-    learn -->|"proposes"| pending["Pending skills"]
-    pending -->|"/skills approve<br/>you decide"| skills[("Skills<br/>.brito/skills")]
+    learn -->|"creates"| trial["Skill in trial"]
+    trial -->|"3 clean uses"| skills[("Skills<br/>.brito/skills")]
+    trial -->|"2 stumbles or 21 idle days"| trash["Archived (.trash)"]
+    learn -->|"risky or changes yours"| pending["Pending<br/>/skills approve"]
+    pending --> skills
     skills -->|"skill_load"| agent
+    trial -->|"skill_load"| agent
 ```
 
 - **Code graph**: functions, classes, methods and components as nodes; `CALLS` and `IMPORTS` as edges. It re-parses only files whose hash changed and updates itself after edits.
@@ -39,11 +43,12 @@ flowchart LR
 - **Skills**: step-by-step procedures for *your* project (commands, order, traps, how to verify). The agent loads one with `skill_load` before a task it covers.
 - **Journal**: Brito remembers across sessions which tasks repeated, which is the best hint that a procedure is general and worth saving.
 
-## Skills you review, not magic
+## Skills that earn their place
 
 ![Reviewing a pending skill, with a destructive-command warning](docs/images/skills-review.png)
 
-1. A proposal appears in `/skills pending`, flagged when it contains destructive commands.
+0. **Autonomous path (default).** The reflection saves a new skill as *trial*, marked "(em teste)" in the index. Each turn that loads it counts as a win (no error-then-fix, no user correction) or a loss. 3 wins (and at most 1 loss per 3 wins) promote it; 2 losses without more wins, or 21 days unused, archive it to `.brito/skills/.trash`. Brito prints one line per promotion or archive. Limits: at most 3 new automatic skills a day, project scope only, and a weekly automatic consolidation that only touches automatic skills.
+1. **Review path.** Skills with destructive commands, and changes to skills you approved, appear in `/skills pending`, flagged when they contain destructive commands.
 2. `/skills approve <name>` shows the **whole body** and the lint warnings, then asks for confirmation. That confirmation is required even in "everything allowed" mode.
 3. Approved skills are versioned (`history/`), ranked by use, and flagged when the files they cite no longer exist. `/skills consolidate` merges duplicates and prunes unused ones.
 4. A skill can be project-scoped or **global** (valid in every project); `/skills promote` moves one to global.
@@ -52,7 +57,7 @@ The lint **rejects** secrets/tokens, absolute user paths, credentials in URLs (`
 
 ## Install
 
-Requires Node >= 20. Developed on macOS; Linux should work, Windows is untested.
+Requires Node >= 20. Developed on macOS; Linux should work. On Windows use `npm i -g brito-cli` (the `install.sh` script needs bash); install Git for Windows so the `bash` tool runs bash commands, otherwise it falls back to `cmd.exe` (override with `BRITO_SHELL`).
 
 ```bash
 # from npm (the command is `brito`)
@@ -133,7 +138,7 @@ Brito has **no database drivers and connects to nothing on its own**. When it ne
 
 ## Configuration
 
-`BRITO_MODEL`, `BRITO_EFFORT`, `BRITO_EXPLORE_MODEL`, `BRITO_LEARN_MODEL`, `BRITO_HOME` (where global skills and history live), `BRITO_CONFIG`, `BRITO_COLOR`, `BRITO_BANNER` (`compact` or `full`; default: full screen on windows of 95+ columns and 28+ rows), `BRITO_INDEX_IGNORED`, `BRITO_SKILL_MIN_TOOLS` (how long a turn must be to trigger reflection when nothing else does).
+`BRITO_MODEL`, `BRITO_EFFORT`, `BRITO_EXPLORE_MODEL`, `BRITO_LEARN_MODEL`, `BRITO_HOME` (where global skills and history live), `BRITO_CONFIG`, `BRITO_COLOR`, `BRITO_BANNER` (`compact` or `full`; default: full screen on windows of 95+ columns and 28+ rows), `BRITO_INDEX_IGNORED`, `BRITO_SKILL_MIN_TOOLS` (how long a turn must be to trigger reflection when nothing else does), `BRITO_SKILLS` (`auto` default, `ask`, `off`), `BRITO_SHELL` (shell used by the `bash` tool; on Windows defaults to Git Bash when installed).
 
 Project data lives in `.brito/` (graph, project skills, agents) and global data in `~/.brito`. The graph, memory and skills stay on your machine; as with any coding agent, the code the model reads is sent to the model provider you configured.
 

package/README.pt-BR.md

@@ -14,9 +14,9 @@ O Brito é um agente de terminal para desenvolvimento de software. Em vez de dar
 
 - **Exploração guiada pelo grafo.** `graph_search`, `graph_context`, `graph_callers`, `graph_callees` e `graph_impact` respondem "onde está, quem usa, o que quebra" sem ler arquivos inteiros. O grafo é embutido ([Kùzu](https://kuzudb.com)), local e incremental.
 - **Cobertura ampla.** TypeScript/JavaScript, Python e os blocos de script de componentes `.svelte`, `.vue` e `.astro`. Aliases de import (`paths` do tsconfig, `imports` do package.json, `$lib` do SvelteKit) viram arestas de verdade. O que o `.gitignore` ignora fica de fora.
-- **Skills que aprendem, com um humano no circuito.** Depois de uma tarefa complexa o Brito reflete sobre o que aconteceu e *propõe* skills. Nada fica ativo até você rodar `/skills approve`.
+- **Skills que aprendem sozinhas, em período de teste.** Depois de uma tarefa em que algo tropeçou ou foi corrigido, o Brito reflete e cria uma skill *em teste* sem te interromper. A skill se prova pelo uso: 3 usos limpos a promovem, 2 tropeços a arquivam (recuperável). O que é arriscado, ou qualquer mudança numa skill que você aprovou, continua esperando o seu `/skills approve`. `BRITO_SKILLS=ask` volta a pedir aprovação para tudo; `off` desliga o aprendizado.
 - **Proteções sobre o que é aprendido.** Um lint rejeita segredos, credenciais embutidas em URL, `curl | sh` e frases de injeção de prompt, e **avisa sobre comandos destrutivos** (veja abaixo).
-- **Modos de permissão.** manual, auto-edições, plano e "tudo liberado" (`Shift+Tab` alterna). Mesmo no último, as skills vão para a fila de revisão em vez de ficarem ativas.
+- **Modos de permissão.** manual, auto-edições, plano e "tudo liberado" (`Shift+Tab` alterna). As skills autônomas não dependem do modo: nascem em teste e são julgadas pelo resultado.
 - **Dois backends, uma interface.** Use uma chave da API da Anthropic ou a sua assinatura do Claude Code pela CLI `claude`. O Brito nunca lê nem envia o token da sua assinatura.
 - **Subagentes.** `explore`, `plan` e `general` rodam em contextos isolados (os somente-leitura, em paralelo); crie os seus em `.brito/agents/*.md`.
 - **Servidor MCP.** `brito mcp-serve` expõe grafo, memória e skills a outros clientes MCP, como o Claude Code. As tools de consulta são marcadas `alwaysLoad`, para não ficarem escondidas atrás da busca de tools.
@@ -39,11 +39,12 @@ flowchart LR
 - **Skills**: procedimentos passo a passo para o *seu* projeto (comandos, ordem, armadilhas, como verificar). O agente carrega uma com `skill_load` antes de uma tarefa que ela cobre.
 - **Journal**: o Brito lembra entre sessões quais tarefas se repetiram, o melhor indício de que um procedimento é geral e vale guardar.
 
-## Skills que você revisa, sem mágica
+## Skills que merecem o lugar
 
 ![Revisando uma skill pendente, com aviso de comando destrutivo](docs/images/skills-review.png)
 
-1. Uma proposta aparece em `/skills pending`, sinalizada quando contém comandos destrutivos.
+0. **Caminho autônomo (padrão).** A reflexão grava a skill nova como *em teste*, marcada "(em teste)" no índice. Cada turno que a carrega conta como vitória (sem erro→conserto nem correção do usuário) ou falha. 3 vitórias (e no máximo 1 falha a cada 3 vitórias) a promovem; 2 falhas sem mais vitórias, ou 21 dias sem uso, a arquivam em `.brito/skills/.trash`. O Brito imprime uma linha a cada promoção ou arquivamento. Limites: no máximo 3 skills automáticas novas por dia, só no escopo do projeto, e uma consolidação semanal automática que só mexe em skills automáticas.
+1. **Caminho de revisão.** Skills com comandos destrutivos, e mudanças em skills que você aprovou, aparecem em `/skills pending`, sinalizadas quando contêm comandos destrutivos.
 2. `/skills approve <nome>` mostra o **corpo inteiro** e os avisos do lint, e pede confirmação. Essa confirmação é exigida mesmo no modo "tudo liberado".
 3. Skills aprovadas são versionadas (`history/`), ranqueadas por uso e sinalizadas quando os arquivos que citam deixam de existir. `/skills consolidate` junta duplicadas e poda as sem uso.
 4. Uma skill pode ser do projeto ou **global** (vale em todos os projetos); `/skills promote` move uma para global.
@@ -133,7 +134,7 @@ O Brito **não tem drivers de banco e não se conecta a nada sozinho**. Quando p
 
 ## Configuração
 
-`BRITO_MODEL`, `BRITO_EFFORT`, `BRITO_EXPLORE_MODEL`, `BRITO_LEARN_MODEL`, `BRITO_HOME` (onde ficam skills globais e histórico), `BRITO_CONFIG`, `BRITO_COLOR`, `BRITO_BANNER` (`compact` ou `full`; padrão: tela cheia em janelas de 95+ colunas e 28+ linhas), `BRITO_INDEX_IGNORED`, `BRITO_SKILL_MIN_TOOLS` (tamanho mínimo do turno para disparar a reflexão quando nada mais dispara).
+`BRITO_MODEL`, `BRITO_EFFORT`, `BRITO_EXPLORE_MODEL`, `BRITO_LEARN_MODEL`, `BRITO_HOME` (onde ficam skills globais e histórico), `BRITO_CONFIG`, `BRITO_COLOR`, `BRITO_BANNER` (`compact` ou `full`; padrão: tela cheia em janelas de 95+ colunas e 28+ linhas), `BRITO_INDEX_IGNORED`, `BRITO_SKILL_MIN_TOOLS` (tamanho mínimo do turno para disparar a reflexão quando nada mais dispara), `BRITO_SKILLS` (`auto` padrão, `ask`, `off`), `BRITO_SHELL` (shell da tool `bash`; no Windows usa o Git Bash se instalado).
 
 Os dados do projeto ficam em `.brito/` (grafo, skills do projeto, agentes) e os globais em `~/.brito`. O grafo, a memória e as skills ficam na sua máquina; como em qualquer agente de código, o código que o modelo lê é enviado ao provedor de modelo que você configurou.
 

package/dist/agent/claude-cli.js

@@ -7,10 +7,12 @@ import { MCP_NAME, MCP_PREFIX, APPROVE_TOOL } from "../mcp/server.js";
 import { ui } from "../ui/ui.js";
 import { MODE_ENV, perms } from "../permissions.js";
 import { wireEffort } from "../model.js";
+import { claudeCommand } from "../util/platform.js";
 // Backend alternativo: delega ao `claude` oficial, que autentica com o /login do usuário.
 // O brito nunca lê nem envia o token da assinatura. Grafo, memória e skills chegam ao claude via MCP.
 export function hasClaudeCli() {
-    return spawnSync("claude", ["--version"], { stdio: "ignore" }).status === 0;
+    const c = claudeCommand(["--version"]);
+    return spawnSync(c.command, c.args, { stdio: "ignore" }).status === 0;
 }
 /** Nome das tools do Brito → nome que o claude enxerga. */
 const CLAUDE_TOOL = { read_file: "Read", glob: "Glob", grep: "Grep", write_file: "Write", edit_file: "Edit", bash: "Bash" };
@@ -94,7 +96,10 @@ export class ClaudeSession {
         this.o = o;
     }
     reset() { this.id = randomUUID(); this.started = false; this.contextTokens = 0; this.recentTurns = []; }
-    abort() { this.child?.kill("SIGINT"); }
+    abort() { if (!this.child)
+        return; this.aborted = true; this.child.kill("SIGINT"); }
+    /** No Windows `kill("SIGINT")` termina o processo sem sinal nem código 130: lembramos que fomos nós que interrompemos. */
+    aborted = false;
     args(text) {
         const { root, approvalSock, stats, mcpCommand } = this.o;
         const mcp = mcpConfig(mcpCommand, approvalSock, perms.mode);
@@ -127,7 +132,8 @@ export class ClaudeSession {
     send(text) {
         return new Promise((resolve) => {
             ui.turnStart();
-            const child = (this.child = spawn("claude", this.args(text), {
+            const cmd = claudeCommand(this.args(text));
+            const child = (this.child = spawn(cmd.command, cmd.args, {
                 cwd: this.o.root, stdio: ["ignore", "pipe", "pipe"],
                 // `/reasoning none`: o claude desliga o raciocínio com MAX_THINKING_TOKENS=0 (não há `--effort none`)
                 env: wireEffort(this.effort).thinking ? process.env : { ...process.env, MAX_THINKING_TOKENS: "0" },
@@ -197,7 +203,8 @@ export class ClaudeSession {
             child.on("error", (e) => { ok = false; ui.error(`não consegui executar o claude: ${e.message}`); });
             child.on("close", (code, signal) => {
                 this.child = null;
-                interrupted = signal === "SIGINT" || code === 130;
+                interrupted = signal === "SIGINT" || code === 130 || this.aborted;
+                this.aborted = false;
                 if (code !== 0 && !interrupted) {
                     ok = false;
                     if (stderr.trim())

package/dist/agent/prompt.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { shellNote } from "../util/platform.js";
 /**
  * Frase sobre o grafo para o system prompt. "0 símbolos" sem contexto faz o modelo concluir que o grafo é inútil, mas o
  * projeto pode só estar vazio no início (e o grafo se atualiza sozinho a cada edição). Por isso: rótulo do momento da
@@ -37,7 +38,7 @@ export function buildSystemPrompt(root, graphStats, skills = "") {
 
 # Ambiente
 Diretório do projeto: ${root}
-Data: ${new Date().toISOString().slice(0, 10)}${skills ? `\n\n# Skills disponíveis (use skill_load)\n${skills}` : ""}${projectDoc}`;
+Data: ${new Date().toISOString().slice(0, 10)}${shellNote()}${skills ? `\n\n# Skills disponíveis (use skill_load)\n${skills}` : ""}${projectDoc}`;
 }
 import { skillsIndex } from "../skills/store.js";
 export function buildSubagentPrompt(root, def) {

package/dist/cli.js

@@ -20,14 +20,16 @@ import { hasClaudeCli, ClaudeSession } from "./agent/claude-cli.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")
@@ -78,7 +80,8 @@ async function plainAsk(q) {
  * 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`);
+    // No Windows um socket unix em %TEMP% não é aceito por net.listen: o endereço tem que ser um named pipe.
+    const sock = process.platform === "win32" ? `\\\\.\\pipe\\brito-approve-${process.pid}` : path.join(os.tmpdir(), `brito-approve-${process.pid}.sock`);
     try {
         fs.unlinkSync(sock);
     }
@@ -353,7 +356,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 +370,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 +391,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);

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/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);

package/dist/skills/store.js

@@ -22,14 +22,18 @@ function parse(text, scope) {
         updated: meta.updated ?? today(),
         lastUsed: meta.lastUsed ?? meta.updated ?? today(),
         refs: (meta.refs ?? "").split(",").map((r) => r.trim()).filter(Boolean),
+        status: meta.status === "trial" ? "trial" : "active",
+        origin: meta.origin === "auto" ? "auto" : "manual",
+        wins: Number(meta.wins) || 0,
+        losses: Number(meta.losses) || 0,
         body: body.trim(),
         scope,
     };
 }
-function write(root, s) {
+export function writeSkill(root, s) {
     const file = fileOf(root, s.scope, s.name);
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, stringifyFrontmatter({ name: s.name, description: s.description, version: s.version, uses: s.uses, created: s.created, updated: s.updated, lastUsed: s.lastUsed, refs: s.refs.join(", ") }, s.body));
+    fs.writeFileSync(file, stringifyFrontmatter({ name: s.name, description: s.description, version: s.version, uses: s.uses, created: s.created, updated: s.updated, lastUsed: s.lastUsed, refs: s.refs.join(", "), status: s.status, origin: s.origin, wins: s.wins, losses: s.losses }, s.body));
 }
 /** Lê uma skill de um escopo específico. */
 export function getSkillIn(root, name, scope) {
@@ -131,8 +135,12 @@ export function validate(input) {
 export function targetScope(root, name, scope) {
     return scope ?? getSkill(root, name)?.scope ?? "project";
 }
-/** Cria ou atualiza. A versão anterior vai para `history/vN.md`. */
-export function saveSkill(root, input, scope) {
+/**
+ * Cria ou atualiza. A versão anterior vai para `history/vN.md`.
+ * `opts.auto` = gravação sem revisão humana (reflexão autônoma): skill nova nasce em teste; atualizar mantém a origem, e
+ * uma skill em teste zera o placar (conteúdo novo = hipótese nova). Sem `auto`, um humano aprovou: vira ativa e manual.
+ */
+export function saveSkill(root, input, scope, opts = {}) {
     validate(input);
     const target = targetScope(root, input.name, scope);
     const prev = getSkillIn(root, input.name, target);
@@ -150,10 +158,14 @@ export function saveSkill(root, input, scope) {
         updated: today(),
         lastUsed: prev?.lastUsed ?? today(),
         refs: input.refs ?? prev?.refs ?? [],
+        status: opts.auto ? (prev?.status ?? "trial") : "active",
+        origin: opts.auto ? (prev?.origin ?? "auto") : "manual",
+        wins: opts.auto && prev?.status === "trial" ? 0 : prev?.wins ?? 0,
+        losses: opts.auto && prev?.status === "trial" ? 0 : prev?.losses ?? 0,
         body: input.body.trim(),
         scope: target,
     };
-    write(root, skill);
+    writeSkill(root, skill);
     return { created: !prev, version: skill.version, scope: target };
 }
 /** Propostas aguardando revisão (modo bypass): ficam fora do índice, pois `listScope` ignora diretórios com ponto. */
@@ -204,7 +216,7 @@ export function rejectPending(root, name) {
 export function bumpUses(root, name) {
     const s = getSkill(root, name);
     if (s)
-        write(root, { ...s, uses: s.uses + 1, lastUsed: today() });
+        writeSkill(root, { ...s, uses: s.uses + 1, lastUsed: today() });
 }
 /** Move para `.trash` do próprio escopo em vez de apagar. */
 export function deleteSkill(root, name, scope) {
@@ -230,5 +242,5 @@ export function promoteSkill(root, name) {
 /** Índice compacto para o system prompt (divulgação progressiva: o corpo só entra via skill_load). */
 export function skillsIndex(root, max = 40, now = Date.now()) {
     const all = listSkills(root, now).slice(0, max);
-    return all.length ? all.map((s) => `- ${s.name}${s.scope === "global" ? " (global)" : ""}${staleRefs(root, s).length ? " [refs obsoletas]" : ""}: ${s.description}`).join("\n") : "";
+    return all.length ? all.map((s) => `- ${s.name}${s.scope === "global" ? " (global)" : ""}${s.status === "trial" ? " (em teste)" : ""}${staleRefs(root, s).length ? " [refs obsoletas]" : ""}: ${s.description}`).join("\n") : "";
 }

package/dist/skills/trial.js

@@ -0,0 +1,71 @@
+import { daysSince, deleteSkill, getSkill, lintSkill, listSkills, savePending, saveSkill, writeSkill } from "./store.js";
+export const skillsMode = () => (process.env.BRITO_SKILLS === "ask" || process.env.BRITO_SKILLS === "off" ? process.env.BRITO_SKILLS : "auto");
+/** Usos bem-sucedidos para promover (com no máximo 1 tropeço a cada 3 sucessos). */
+export const PROMOTE_WINS = 3;
+/** Falhas que arquivam uma skill em teste sem mais vitórias que falhas. */
+export const ARCHIVE_LOSSES = 2;
+/** Skill em teste que ninguém carregou neste prazo é arquivada. */
+export const TRIAL_DAYS = 21;
+/** Teto de skills novas criadas sozinhas por dia (contido: cada uma vira instrução para o agente). */
+export const DAILY_LIMIT = 3;
+/** Registra o resultado de um turno que usou a skill. Devolve um aviso se ela foi promovida ou arquivada. */
+export function recordOutcome(root, name, win) {
+    const s = getSkill(root, name);
+    if (!s)
+        return null;
+    const next = { ...s, wins: s.wins + (win ? 1 : 0), losses: s.losses + (win ? 0 : 1) };
+    if (s.origin === "auto") {
+        if (s.status === "trial") {
+            if (next.wins >= PROMOTE_WINS && next.wins >= 3 * next.losses) {
+                writeSkill(root, { ...next, status: "active" });
+                return `skill ${name} promovida: ${next.wins} usos bem-sucedidos, ${next.losses} com tropeço`;
+            }
+            if (next.losses >= ARCHIVE_LOSSES && next.losses >= next.wins) {
+                deleteSkill(root, name, s.scope);
+                return `skill ${name} arquivada: ${next.losses} usos com tropeço e ${next.wins} bem-sucedidos (recupere em .brito/skills/.trash)`;
+            }
+        }
+        else if (next.losses >= 3 && next.losses > next.wins) {
+            deleteSkill(root, name, s.scope);
+            return `skill ${name} arquivada: passou a falhar (${next.losses} tropeços, ${next.wins} sucessos)`;
+        }
+    }
+    writeSkill(root, next);
+    return null;
+}
+/** Arquiva as skills em teste que ninguém usou no prazo. */
+export function expireTrials(root, now = Date.now()) {
+    const out = [];
+    for (const s of listSkills(root, now)) {
+        if (s.origin === "auto" && s.status === "trial" && daysSince(s.lastUsed, now) > TRIAL_DAYS && deleteSkill(root, s.name, s.scope)) {
+            out.push(`skill ${s.name} arquivada: em teste há mais de ${TRIAL_DAYS} dias sem uso`);
+        }
+    }
+    return out;
+}
+/**
+ * Grava uma skill proposta pela reflexão sem perguntar ao usuário, mas só quando é seguro:
+ * - sempre escopo do projeto (global exige decisão humana);
+ * - skill de origem manual nunca é reescrita sozinha: a mudança vira proposta pendente;
+ * - conteúdo com comando destrutivo também vai para a fila de revisão;
+ * - nova skill respeita o teto diário.
+ */
+export function saveAuto(root, input, now = Date.now()) {
+    const prev = getSkill(root, input.name);
+    if (prev && prev.origin === "manual") {
+        const scope = savePending(root, input, prev.scope);
+        return { saved: false, msg: `skill ${input.name} (${scope}) é revisada por você: mudança proposta em /skills approve ${input.name}` };
+    }
+    if (lintSkill(input).warnings.some((w) => w.startsWith("comando destrutivo"))) {
+        const scope = savePending(root, input, "project");
+        return { saved: false, msg: `skill ${input.name} (${scope}) tem comando destrutivo: aguardando /skills approve ${input.name}` };
+    }
+    if (!prev) {
+        const today = new Date(now).toISOString().slice(0, 10);
+        const created = listSkills(root, now).filter((s) => s.origin === "auto" && s.created === today).length;
+        if (created >= DAILY_LIMIT)
+            return { saved: false, msg: `skill ${input.name} não criada: teto de ${DAILY_LIMIT} skills automáticas por dia` };
+    }
+    const r = saveSkill(root, input, prev?.scope ?? "project", { auto: true });
+    return { saved: true, msg: r.created ? `skill ${input.name} criada em teste (project, v1)` : `skill ${input.name} atualizada (${r.scope}, v${r.version})` };
+}

package/dist/tools/bash.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { exec } from "node:child_process";
 import { defineTool } from "./registry.js";
+import { shellFor } from "../util/platform.js";
 defineTool({
     name: "bash",
     description: "Executa um comando shell na raiz do projeto (timeout padrão 120s).",
@@ -9,7 +10,7 @@ defineTool({
     mutates: true,
     describe: (i) => i.command,
     run: ({ command, timeout_ms = 120_000 }, { root }) => new Promise((resolve) => {
-        exec(command, { cwd: root, timeout: timeout_ms, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+        exec(command, { cwd: root, shell: shellFor(), timeout: timeout_ms, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
             const out = (stdout + (stderr ? `\n[stderr]\n${stderr}` : "")).trim();
             resolve(`${err ? `[exit ${err.code ?? "?"}] ` : ""}${out.slice(-30_000) || "(sem saída)"}`);
         });

package/dist/tools/fs.js

@@ -5,7 +5,10 @@ import fg from "fast-glob";
 import { defineTool } from "./registry.js";
 const abs = (root, p) => {
     const full = path.resolve(root, p);
-    if (!full.startsWith(path.resolve(root)))
+    // path.relative cobre dois defeitos do startsWith: irmão com mesmo prefixo (/proj vs /proj-x) e, no Windows,
+    // diferença de caixa na letra da unidade ou nos diretórios (C:\ vs c:\), que fazia caminhos válidos serem recusados.
+    const rel = path.relative(path.resolve(root), full);
+    if (rel === ".." || rel.startsWith(".." + path.sep) || path.isAbsolute(rel))
         throw new Error("Caminho fora do projeto.");
     return full;
 };

package/dist/util/platform.js

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+let claudeCache;
+/** Alvo real de um shim npm (`claude.cmd`): `"%dp0%\caminho\cli.js"` ou `...\claude.exe`. */
+export function resolveCmdShim(shimPath, content) {
+    const target = content.match(/"%dp0%\\([^"]+)"/)?.[1];
+    if (!target)
+        return null;
+    const file = path.win32.join(path.win32.dirname(shimPath), target);
+    if (/\.exe$/i.test(file))
+        return { command: file, prefix: [] };
+    if (/\.(c|m)?js$/i.test(file))
+        return { command: process.execPath, prefix: [file] };
+    return null;
+}
+function findClaude() {
+    const found = spawnSync("where", ["claude"], { encoding: "utf8" }).stdout?.split(/\r?\n/).map((l) => l.trim()).filter(Boolean) ?? [];
+    const exe = found.find((f) => /\.exe$/i.test(f));
+    if (exe)
+        return { command: exe, prefix: [] };
+    for (const f of found.filter((x) => /\.cmd$/i.test(x))) {
+        try {
+            const r = resolveCmdShim(f, fs.readFileSync(f, "utf8"));
+            if (r && fs.existsSync(r.prefix[0] ?? r.command))
+                return r;
+        }
+        catch { /* shim ilegível: tenta o próximo */ }
+    }
+    return { command: "claude", prefix: [] };
+}
+/** Comando e argumentos para executar o `claude` com segurança em qualquer sistema. */
+export function claudeCommand(args) {
+    if (process.platform !== "win32")
+        return { command: "claude", args };
+    claudeCache ??= findClaude();
+    return { command: claudeCache.command, args: [...claudeCache.prefix, ...args] };
+}
+let shellCache = null;
+/** Shell para `exec`: `BRITO_SHELL` > Git Bash (só no Windows) > padrão do sistema (undefined). */
+export function shellFor() {
+    if (process.env.BRITO_SHELL)
+        return process.env.BRITO_SHELL;
+    if (process.platform !== "win32")
+        return undefined;
+    if (shellCache !== null)
+        return shellCache;
+    const roots = [process.env.ProgramFiles, process.env["ProgramFiles(x86)"], process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, "Programs")].filter((r) => !!r);
+    shellCache = roots.map((r) => path.join(r, "Git", "bin", "bash.exe")).find((p) => fs.existsSync(p));
+    return shellCache;
+}
+/** Linha para o system prompt dizendo qual shell o comando `bash` usa de fato (só no Windows; nos outros é bash/sh). */
+export function shellNote() {
+    if (process.platform !== "win32")
+        return "";
+    return shellFor() ? "\nShell dos comandos: Git Bash (sintaxe bash)." : "\nShell dos comandos: cmd.exe do Windows (não há bash): use dir/type/findstr e sintaxe do cmd, não ls/cat/grep.";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Coding-agent CLI with a code knowledge graph, memory and reviewable skills / CLI de agente de código com grafo de conhecimento, memória e skills revisáveis",
   "type": "module",
   "bin": {