brito-cli 0.8.0 → 0.10.0

package/dist/desktop/serve.js

@@ -1,13 +1,19 @@
+import { fetchPlanUsage } from "../usage/plan.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
+import { execFileSync } from "node:child_process";
+import { PROTOCOL } from "./protocol.js";
+import { Panels, graphRootFor } from "./panels.js";
 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/implement.js";
+import "../tools/spec.js";
 import "../tools/skills.js";
 import "../tools/digest.js";
 import "../tools/todo.js";
@@ -21,13 +27,14 @@ import { openGraphAfterClaude } from "../graph/store.js";
 import { indexProject } from "../graph/indexer.js";
 import { initialEffort, initialModel, isEffort, loadProfiles, MODEL_ALIASES } from "../model.js";
 import { NO_ANTHROPIC, fallbackStatus, openEngine } from "../engine.js";
-import { activateFallback, chooseModel, cliShouldFallBack, fallbackWarning, newFallbackState, renderFallback, retryPrompt } from "../provider/fallback.js";
+import { engineChip, activateFallback, chooseModel, cliShouldFallBack, fallbackWarning, newFallbackState, renderFallback, retryPrompt } from "../provider/fallback.js";
 import { contextWindowFor, resolveModel } from "../provider/resolve.js";
 import { PLAN_NOTE, perms } from "../permissions.js";
-import { skillsIndex } from "../skills/store.js";
+import { ORCH_NOTE, implStatus, mainTools, orch, orchGuard, restoreOrch } from "../orchestrator.js";
+import { getSkill, listBuiltins, listSkills, 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"}
+ * stdin  → {t:"send",text} {t:"abort"} {t:"approve",id,allow,scope?:"session"|"project"} {t:"config",model?,effort?,mode?,orch?} {t:"reset"} {t:"query"} {t:"action"} {t:"quit"}
  * stdout → linhas "@@{json}" (qualquer outra linha, como logs perdidos, a janela ignora).
  * Motor: perfil de endpoint (ex.: Qwen) ou ANTHROPIC_API_KEY usam o loop próprio (como o `brito` no terminal); sem
  * nada disso, o `claude` CLI (assinatura). Se o Claude cai por conta/capacidade (ou nem há conta), segue no qwen.
@@ -35,6 +42,66 @@ import { skillsIndex } from "../skills/store.js";
  */
 const MARK = "@@";
 const emit = (ev) => process.stdout.write(MARK + JSON.stringify(ev) + "\n");
+/** Selo do motor (☁ nuvem / 🌐 endpoint / 💻 local, ou ⚠ FALLBACK), igual ao da barra de status da CLI. */
+const chipOf = (model, fb) => { try {
+    return engineChip(model, fb).text;
+}
+catch {
+    return model;
+} };
+const BUILTIN_COMMANDS = [
+    { name: "clear", description: "limpa a conversa", kind: "builtin" },
+    { name: "fallback", description: "estado do fallback Claude → modelo local", kind: "builtin" },
+    { name: "help", description: "lista os comandos", kind: "builtin" },
+];
+/** Arquivos do projeto para o `@`: git ls-files (respeita .gitignore); sem git, uma varredura rasa. */
+let fileCache = null;
+function projectFiles(root) {
+    if (fileCache && fileCache.root === root && Date.now() - fileCache.at < 15000)
+        return fileCache.files;
+    let files = [];
+    try {
+        files = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd: root, encoding: "utf8", maxBuffer: 16 << 20, timeout: 5000 }).split("\n").filter(Boolean);
+    }
+    catch {
+        const walk = (dir, depth) => {
+            if (depth > 4 || files.length > 5000)
+                return;
+            for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+                if (e.name.startsWith(".") || e.name === "node_modules")
+                    continue;
+                const rel = path.relative(root, path.join(dir, e.name)).split(path.sep).join("/");
+                e.isDirectory() ? walk(path.join(dir, e.name), depth + 1) : files.push(rel);
+            }
+        };
+        try {
+            walk(root, 0);
+        }
+        catch { /* pasta ilegível */ }
+    }
+    fileCache = { root, at: Date.now(), files };
+    return files;
+}
+/** "Permitir sempre neste projeto": tipos de ação liberados, guardados por pasta em ~/.brito/desktop-allow.json. */
+const allowFile = () => path.join(os.homedir(), ".brito", "desktop-allow.json");
+function loadAllow(root) {
+    try {
+        return JSON.parse(fs.readFileSync(allowFile(), "utf8"))[path.resolve(root)] ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+function saveAllow(root, kinds) {
+    let all = {};
+    try {
+        all = JSON.parse(fs.readFileSync(allowFile(), "utf8"));
+    }
+    catch { /* primeiro uso */ }
+    all[path.resolve(root)] = kinds;
+    fs.mkdirSync(path.dirname(allowFile()), { recursive: true });
+    fs.writeFileSync(allowFile(), JSON.stringify(all, null, 1));
+}
 const sink = {
     turnStart: () => emit({ t: "turnStart" }),
     turnEnd: (ok = true) => emit({ t: "turnEnd", ok }),
@@ -42,7 +109,7 @@ const sink = {
     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) }),
+    toolEnd: (id, isError, output) => emit({ t: "toolEnd", id, isError, output: (output ?? "").slice(0, 20000) }),
     info: (msg) => emit({ t: "info", msg }),
     warn: (msg) => emit({ t: "warn", msg }),
     error: (msg) => emit({ t: "error", msg }),
@@ -50,10 +117,15 @@ const sink = {
 const apiLabel = (m) => (resolveModel(m).kind === "openai" ? "endpoint" : "API Anthropic");
 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) => {
+    /** Tipos de pedido liberados com "permitir nesta sessão" (nunca vale para pedidos `force`, como aprovar plano ou skill). */
+    const projectAllow = new Set(loadAllow(root));
+    const sessionAllow = new Set(projectAllow);
+    emit({ t: "hello", protocol: PROTOCOL });
+    const kindOf = (text) => text.split(/[:\s]/, 1)[0].toLowerCase();
+    const ask = (text, opts) => (perms.mode === "bypass" || sessionAllow.has(kindOf(text))) && !opts?.force ? Promise.resolve(true) : new Promise((resolve) => {
         const id = randomUUID();
-        pending.set(id, resolve);
-        emit({ t: "approval", id, text, force: !!opts?.force });
+        pending.set(id, { resolve, kind: opts?.force ? "" : kindOf(text) });
+        emit({ t: "approval", id, text, force: !!opts?.force, kind: kindOf(text) });
     });
     // Na pasta pessoal (projeto "Home") indexar tudo seria enorme e inútil: sem índice ali.
     const isHome = path.resolve(root) === path.resolve(os.homedir());
@@ -92,8 +164,8 @@ export async function serveDesktop(root, resumeId) {
         catch { /* sem notas */ }
         const ctx = { root, graph, ask, sync, dirty: false, loadedSkills: o.loadedSkills ?? new Set(), model: () => agent.model };
         const fallback = o.fallback ?? newFallbackState(model);
-        const system = memoSystem(() => systemKey(root, perms.mode === "plan", syms + notes === 0), () => buildSystemPrompt(root, graphStatsLine(syms, notes, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : ""));
-        const agent = new Agent(system, ctx, { model, sink, fallback });
+        const system = memoSystem(() => systemKey(root, perms.mode === "plan", syms + notes === 0) + `|${orch.on}`, () => buildSystemPrompt(root, graphStatsLine(syms, notes, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : "") + (orch.on ? ORCH_NOTE : ""));
+        const agent = new Agent(system, ctx, { model, sink, fallback, tools: mainTools });
         if (o.messages)
             agent.messages = o.messages;
         if (o.effort)
@@ -144,6 +216,7 @@ export async function serveDesktop(root, resumeId) {
             async send(text) {
                 ac = new AbortController();
                 sink.turnStart();
+                orchGuard(agent.model, sink.warn); // troca para o qwen (fallback ou modelo escolhido): não há mais a quem delegar
                 let ok = true;
                 try {
                     await agent.send(text, ac.signal);
@@ -264,10 +337,13 @@ export async function serveDesktop(root, resumeId) {
         engine = claude;
     }
     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, fallback: engine.fallback.active });
+    restoreOrch(engine.model, (m) => emit({ t: "warn", msg: m }), (m) => emit({ t: "info", msg: m }));
+    const panels = new Panels(root, graphRootFor(root), isHome);
+    const ready = () => emit({ t: "ready", engine: engine.kind, sessionId: engine.sessionId, model: engine.model, effort: engine.effort, mode: perms.mode, orch: orch.on, symbols: syms, notes, root, fallback: engine.fallback.active, chip: chipOf(engine.model, engine.fallback) });
     ready();
     const rl = readline.createInterface({ input: process.stdin });
     const quit = async () => { closeApproval(); try {
+        await panels.close();
         await engine.close();
     }
     catch { /* saindo */ } process.exit(0); };
@@ -294,23 +370,85 @@ export async function serveDesktop(root, resumeId) {
                     sink.turnEnd(true);
                     return;
                 }
+                // /nome de uma skill: mesma invocação do REPL (skill_load + contexto).
+                let text = String(m.text ?? "");
+                const [cmd, ...args] = text.trim().split(/\s+/);
+                const sk = cmd.startsWith("/") && !cmd.slice(1).includes("/") ? getSkill(root, cmd.slice(1).toLowerCase()) : null;
+                if (sk) {
+                    const ctxText = args.join(" ");
+                    text = `Invoquei a skill ${sk.name}. Chame skill_load("${sk.name}") agora e siga-a.${ctxText ? `\n\nContexto: ${ctxText}` : "\n\n(Sem contexto extra: comece perguntando sobre o que quero trabalhar.)"}`;
+                }
                 busy = true;
                 try {
-                    await engine.send(String(m.text ?? ""));
+                    await engine.send(text);
                 }
                 finally {
                     busy = false;
-                    emit({ t: "usage", ...engine.stats(), model: engine.model, sessionId: engine.sessionId, fallback: engine.fallback.active });
+                    emit({ t: "usage", ...engine.stats(), model: engine.model, sessionId: engine.sessionId, fallback: engine.fallback.active, chip: chipOf(engine.model, engine.fallback) });
                 }
                 break;
             }
             case "abort":
                 engine.abort();
                 break;
-            case "approve":
-                pending.get(m.id)?.(!!m.allow);
+            case "query": {
+                let data = [];
+                try {
+                    const arg = String(m.arg ?? "").toLowerCase();
+                    if (["skills", "skill", "agents", "symbols", "symbol", "notes"].includes(m.q)) {
+                        const raw = String(m.arg ?? "");
+                        data = m.q === "skills" ? panels.skills() : m.q === "skill" ? panels.skill(raw) : m.q === "agents" ? panels.agents()
+                            : m.q === "symbols" ? await panels.symbols(raw) : m.q === "symbol" ? await panels.symbol(raw) : await panels.notes(raw);
+                        emit({ t: "result", id: m.id, data });
+                        break;
+                    }
+                    if (m.q === "files")
+                        data = projectFiles(root).filter((f) => !f.startsWith(".brito/") && (!arg || f.toLowerCase().includes(arg))).sort((a, b) => a.length - b.length).slice(0, 30);
+                    else if (m.q === "commands") {
+                        const skills = [...listBuiltins(root), ...listSkills(root).filter((s) => s.invoke === "manual")].map((s) => ({ name: s.name, description: s.description, kind: "skill" }));
+                        data = [...BUILTIN_COMMANDS, ...skills].filter((c) => !arg || c.name.includes(arg));
+                    }
+                    else if (m.q === "usage")
+                        data = { plan: await fetchPlanUsage({ force: arg === "force" }), session: engine.stats(), model: engine.model };
+                    else if (m.q === "models")
+                        data = { aliases: Object.keys(MODEL_ALIASES), profiles: Object.keys(loadProfiles().profiles) };
+                }
+                catch (e) {
+                    sink.warn(`consulta ${m.q} falhou: ${e?.message ?? e}`);
+                }
+                emit({ t: "result", id: m.id, data });
+                break;
+            }
+            case "action": {
+                try {
+                    const arg = String(m.arg ?? "");
+                    const msg = m.op === "graph.reindex" ? `grafo reindexado (${(await panels.reindex()).symbols} símbolos)`
+                        : m.op === "note.delete" ? await panels.deleteNote(arg)
+                            : panels.skillAction(String(m.op).replace(/^skill\./, ""), arg);
+                    emit({ t: "result", id: m.id, data: { ok: true, msg } });
+                }
+                catch (e) {
+                    emit({ t: "result", id: m.id, data: { ok: false, msg: e?.message ?? String(e) } });
+                }
+                break;
+            }
+            case "approve": {
+                const p = pending.get(m.id);
+                if (p && m.allow && (m.scope === "session" || m.scope === "project") && p.kind) {
+                    sessionAllow.add(p.kind);
+                    if (m.scope === "project")
+                        try {
+                            projectAllow.add(p.kind);
+                            saveAllow(root, [...projectAllow]);
+                        }
+                        catch (e) {
+                            sink.warn(`não consegui salvar a permissão: ${e?.message ?? e}`);
+                        }
+                }
+                p?.resolve(!!m.allow);
                 pending.delete(m.id);
                 break;
+            }
             case "config": {
                 if (typeof m.model === "string")
                     engine.setModel(m.model ? MODEL_ALIASES[m.model] ?? m.model : ""); // vazio = modelo/perfil salvo
@@ -318,6 +456,16 @@ export async function serveDesktop(root, resumeId) {
                     engine.effort = isEffort(m.effort) ? m.effort : "";
                 if (["manual", "auto", "plan", "bypass"].includes(m.mode))
                     perms.mode = m.mode;
+                // "on" liga o modo orquestrador (se o implementador estiver pronto); "" desliga.
+                if (m.orch === "")
+                    orch.on = false;
+                else if (m.orch === "on") {
+                    const s = implStatus(engine.model, orch.model, process.env);
+                    if (s.ready)
+                        orch.on = true;
+                    else
+                        sink.warn(`modo orquestrador não ligou: ${s.reason}`);
+                }
                 ready();
                 break;
             }

package/dist/graph/migrate.js

@@ -3,12 +3,12 @@ import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { GraphStore } from "./store.js";
-const READER = `const k = require("kuzu");
-const db = new k.Database(process.argv[2], 0, true, true);
-const c = new k.Connection(db);
-c.query("MATCH (n:Note) RETURN n.id AS id, n.kind AS kind, n.text AS text, n.refs AS refs, n.ts AS ts").then((r) => r.getAll()).then((rows) => {
-  process.stdout.write(JSON.stringify(rows, (_, v) => (typeof v === "bigint" ? Number(v) : v)));
-  process.exit(0);
+const READER = `const k = require("kuzu");
+const db = new k.Database(process.argv[2], 0, true, true);
+const c = new k.Connection(db);
+c.query("MATCH (n:Note) RETURN n.id AS id, n.kind AS kind, n.text AS text, n.refs AS refs, n.ts AS ts").then((r) => r.getAll()).then((rows) => {
+  process.stdout.write(JSON.stringify(rows, (_, v) => (typeof v === "bigint" ? Number(v) : v)));
+  process.exit(0);
 });`;
 /** Copia as notas (memória) do grafo antigo (.brito/graph.kuzu) para o novo (.brito/graph.lbug).
  *  O Kùzu só é instalado numa pasta temporária, durante esta chamada: o pacote principal não depende mais dele. */

package/dist/import/claude-code.js

@@ -0,0 +1,286 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parseRule, addRule, loadRules } from "../rules.js";
+import { NAME_RE, deleteSkill, getSkillIn, lintSkill, listSkills, savePending, validate, writeSkill } from "../skills/store.js";
+import { stringifyFrontmatter } from "../util/frontmatter.js";
+/**
+ * Import do Claude Code: skills, subagentes, regras de permissão e memória. Sempre em duas etapas — `planImport` só lê
+ * e decide (nada é gravado), `applyImport` grava o que o plano marcou como `import`.
+ *
+ * Princípios: nada importado vira ativo sem teste (skills entram "em teste"); credenciais nunca são lidas; `deny` entra
+ * direto (só restringe) mas `allow` exige pedido explícito; tudo importado é reversível (`undoImport`).
+ */
+export const IMPORT_TAG = "import:claude-code";
+export const claudeHome = () => process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+/** Frontmatter YAML simples, aceitando valores em várias linhas (`>`, `|` ou continuação indentada), como nas skills do Claude. */
+export function parseRichFrontmatter(text) {
+    const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m)
+        return null;
+    const meta = {};
+    let key = "";
+    for (const line of m[1].split(/\r?\n/)) {
+        const kv = /^([\w-]+):\s*(.*)$/.exec(line);
+        if (kv) {
+            key = kv[1];
+            meta[key] = /^[>|][+-]?$/.test(kv[2].trim()) ? "" : kv[2].trim().replace(/^(['"])(.*)\1$/, "$2");
+        }
+        else if (key && /^\s+\S/.test(line))
+            meta[key] = `${meta[key]} ${line.trim()}`.trim();
+    }
+    return { meta, body: m[2] };
+}
+const readText = (file) => { try {
+    return fs.readFileSync(file, "utf8");
+}
+catch {
+    return null;
+} };
+const dirsIn = (dir) => { try {
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
+}
+catch {
+    return [];
+} };
+const mdIn = (dir) => { try {
+    return fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+}
+catch {
+    return [];
+} };
+/** Descrição do Claude pode passar de 200 caracteres: corta numa fronteira de frase/palavra. */
+function fitDescription(d) {
+    const t = d.replace(/\s+/g, " ").trim();
+    if (t.length <= 200)
+        return t;
+    const cut = t.slice(0, 197);
+    return cut.slice(0, Math.max(cut.lastIndexOf(" "), 100)) + "…";
+}
+function planSkills(root, home) {
+    const out = [];
+    const sources = [
+        { dir: path.join(root, ".claude", "skills"), scope: "project", label: ".claude/skills" },
+        { dir: path.join(home, "skills"), scope: "global", label: "~/.claude/skills" },
+    ];
+    for (const { dir, scope, label } of sources) {
+        for (const folder of dirsIn(dir)) {
+            const source = `${label}/${folder}`;
+            const text = readText(path.join(dir, folder, "SKILL.md"));
+            const fm = text ? parseRichFrontmatter(text) : null;
+            const name = (fm?.meta.name || folder).trim();
+            const skip = (note) => ({ kind: "skill", name, source, action: "skip", note, scope });
+            if (!fm) {
+                out.push(skip("SKILL.md ausente ou sem frontmatter"));
+                continue;
+            }
+            if (!NAME_RE.test(name)) {
+                out.push(skip(`nome "${name}" fora do padrão kebab-case de 2 a 49 caracteres`));
+                continue;
+            }
+            const description = fitDescription(fm.meta.description ?? "");
+            const body = fm.body.trim();
+            const input = { name, description, body, invoke: fm.meta["disable-model-invocation"] === "true" ? "manual" : "auto" };
+            try {
+                validate(input);
+            }
+            catch (e) {
+                out.push(skip(String(e?.message ?? e)));
+                continue;
+            }
+            if (getSkillIn(root, name, scope)) {
+                out.push(skip("já existe uma skill com esse nome"));
+                continue;
+            }
+            const extras = dirsIn(path.join(dir, folder)).concat(fs.readdirSync(path.join(dir, folder)).filter((f) => f !== "SKILL.md" && !fs.statSync(path.join(dir, folder, f)).isDirectory()));
+            const warnings = lintSkill(input).warnings.filter((w) => w.startsWith("comando destrutivo"));
+            const notes = [extras.length ? `arquivos de apoio não copiados: ${extras.join(", ")}` : "", fm.meta["allowed-tools"] ? "allowed-tools do Claude é ignorado" : "", warnings.length ? "tem comando destrutivo: vai para /skills pending" : ""].filter(Boolean);
+            out.push({ kind: "skill", name, source, action: "import", scope, pending: warnings.length > 0, note: notes.join("; ") || undefined, data: input });
+        }
+    }
+    return out;
+}
+/** Nomes de tool do Claude → do Brito. */
+const TOOL_MAP = { read: "read_file", write: "write_file", edit: "edit_file", multiedit: "edit_file", bash: "bash", glob: "glob", grep: "grep", notebookedit: "edit_file" };
+const mapTool = (t) => TOOL_MAP[t.trim().toLowerCase()];
+const READ_ONLY = ["read_file", "glob", "grep", "graph_search", "graph_callers", "graph_callees", "graph_impact", "graph_context", "graph_query", "recall"];
+function planAgents(root, home) {
+    const out = [];
+    for (const { dir, label } of [{ dir: path.join(root, ".claude", "agents"), label: ".claude/agents" }, { dir: path.join(home, "agents"), label: "~/.claude/agents" }]) {
+        for (const f of mdIn(dir)) {
+            const source = `${label}/${f}`;
+            const fm = parseRichFrontmatter(readText(path.join(dir, f)) ?? "");
+            const name = (fm?.meta.name || f.replace(/\.md$/, "")).trim();
+            const skip = (note) => ({ kind: "agent", name, source, action: "skip", note });
+            if (!fm || !fm.meta.description || !fm.body.trim()) {
+                out.push(skip("precisa de frontmatter com description e de um corpo"));
+                continue;
+            }
+            if (!NAME_RE.test(name)) {
+                out.push(skip(`nome "${name}" fora do padrão kebab-case`));
+                continue;
+            }
+            if (fs.existsSync(path.join(root, ".brito", "agents", `${name}.md`))) {
+                out.push(skip("já existe um agente com esse nome em .brito/agents"));
+                continue;
+            }
+            const raw = (fm.meta.tools ?? "").split(",").map((t) => t.trim()).filter(Boolean);
+            const mapped = [...new Set(raw.map(mapTool).filter((t) => !!t))];
+            const dropped = raw.filter((t) => !mapTool(t));
+            const tools = !raw.length ? "all" : mapped.length ? mapped : READ_ONLY;
+            const model = /^claude-/.test(fm.meta.model ?? "") ? fm.meta.model : "";
+            const notes = [dropped.length ? `tools sem equivalente: ${dropped.join(", ")}` : "", raw.length && !mapped.length ? "nenhuma tool equivalente: ficou somente leitura" : "", fm.meta.model && !model ? `modelo "${fm.meta.model}" não mapeado: usa o padrão do Brito` : ""].filter(Boolean);
+            out.push({ kind: "agent", name, source, action: "import", note: notes.join("; ") || undefined, data: { description: fitDescription(fm.meta.description).replace(/\s+/g, " "), tools, model, body: fm.body.trim() } });
+        }
+    }
+    return out;
+}
+/** `Bash(npm test:*)` → `bash(npm test:*)`; devolve null quando o Brito não tem a tool (WebFetch, mcp__…). */
+export function mapRule(rule) {
+    const r = parseRule(rule);
+    if (!r)
+        return null;
+    const tool = mapTool(r.tool);
+    if (!tool)
+        return null;
+    if (r.pattern === undefined)
+        return tool;
+    const pattern = tool === "bash" ? r.pattern : r.pattern.replace(/^\.\//, "").replace(/^\/\//, "/");
+    return `${tool}(${pattern})`;
+}
+function planRules(root, home, includeAllow) {
+    const out = [];
+    const have = loadRules(root);
+    const files = [path.join(root, ".claude", "settings.json"), path.join(root, ".claude", "settings.local.json"), path.join(home, "settings.json")];
+    const seen = new Set();
+    for (const file of files) {
+        let perms;
+        try {
+            perms = JSON.parse(fs.readFileSync(file, "utf8"))?.permissions;
+        }
+        catch {
+            continue;
+        }
+        const source = file.startsWith(root) ? path.relative(root, file).split(path.sep).join("/") : `~/.claude/${path.basename(file)}`;
+        for (const kind of ["deny", "allow"]) {
+            for (const rule of (Array.isArray(perms?.[kind]) ? perms[kind] : []).filter((x) => typeof x === "string")) {
+                const key = `${kind}:${rule}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const mapped = mapRule(rule);
+                const item = (action, note) => ({ kind, name: rule, source, action, note, data: mapped });
+                if (!mapped)
+                    out.push(item("skip", "o Brito não tem tool equivalente"));
+                else if (have[kind].includes(mapped))
+                    out.push(item("skip", "já existe"));
+                else if (kind === "allow" && !includeAllow)
+                    out.push(item("skip", "libera ações sem perguntar: use --incluir-allow para importar"));
+                else
+                    out.push(item("import", mapped !== rule ? `vira ${mapped}` : undefined));
+            }
+        }
+    }
+    return out;
+}
+/** Memória do Claude Code deste projeto: `~/.claude/projects/<caminho com - no lugar de separadores>/memory/*.md`. */
+export const memoryDirOf = (root, home) => path.join(home, "projects", path.resolve(root).replace(/[^a-zA-Z0-9]/g, "-"), "memory");
+const NOTE_KIND = { feedback: "convention", project: "decision", user: "learning", reference: "learning" };
+function planMemory(root, home) {
+    const dir = memoryDirOf(root, home);
+    return mdIn(dir).filter((f) => f !== "MEMORY.md").flatMap((f) => {
+        const text = readText(path.join(dir, f)) ?? "";
+        const fm = parseRichFrontmatter(text);
+        const body = (fm?.body ?? text).trim();
+        const source = `~/.claude/projects/…/memory/${f}`;
+        if (body.length < 10)
+            return [{ kind: "memory", name: f, source, action: "skip", note: "vazia" }];
+        const type = fm?.meta.type ?? /^\s*type:\s*(\w+)/m.exec(text.slice(0, text.indexOf("\n---", 3) + 1))?.[1] ?? ""; // `type` pode estar aninhado em metadata:
+        const title = fm?.meta.name ?? f.replace(/\.md$/, "");
+        const lint = lintSkill({ name: "x", description: title, body });
+        if (lint.errors.length)
+            return [{ kind: "memory", name: f, source, action: "skip", note: `não importada: ${lint.errors.join("; ")}` }];
+        const id = `cc-${crypto.createHash("sha1").update(f + body).digest("hex").slice(0, 16)}`;
+        return [{ kind: "memory", name: title, source, action: "import", data: { id, kind: NOTE_KIND[type] ?? "learning", text: `[importada do Claude Code] ${title}: ${body}`.slice(0, 2000) } }];
+    });
+}
+export function planImport(root, options = {}) {
+    const home = options.claudeHome ?? claudeHome();
+    const items = [
+        ...planSkills(root, home),
+        ...planAgents(root, home),
+        ...planRules(root, home, !!options.includeAllow),
+        ...(options.includeMemory ? planMemory(root, home) : []),
+    ];
+    const claudeMd = ["CLAUDE.md", path.join(".claude", "CLAUDE.md")].find((f) => fs.existsSync(path.join(root, f)));
+    if (claudeMd)
+        items.push({ kind: "info", name: claudeMd, source: claudeMd, action: "skip", note: "o Brito já lê o CLAUDE.md sozinho; nada a importar" });
+    if (fs.existsSync(path.join(root, ".mcp.json")))
+        items.push({ kind: "info", name: ".mcp.json", source: ".mcp.json", action: "skip", note: "o Brito ainda não conecta a servidores MCP externos; os servidores não foram importados" });
+    return { items, options };
+}
+/** Grava o plano (menos as notas de memória, que precisam do grafo: ficam em `result.notes` para quem tem a conexão). */
+export function applyImport(root, plan) {
+    const res = { skills: 0, agents: 0, rules: 0, pending: 0, notes: [], errors: [] };
+    const today = new Date().toISOString().slice(0, 10);
+    for (const it of plan.items) {
+        if (it.action !== "import")
+            continue;
+        try {
+            if (it.kind === "skill") {
+                const d = it.data;
+                if (it.pending) {
+                    savePending(root, { ...d, reason: `importada do Claude Code (${it.source})` }, it.scope);
+                    res.pending++;
+                    continue;
+                }
+                const skill = { name: d.name, description: d.description, version: 1, uses: 0, created: today, updated: today, lastUsed: today, refs: [], status: "trial", origin: "auto", wins: 0, losses: 0, body: d.body, scope: it.scope ?? "project", invoke: d.invoke, model: "", lastLoss: "", by: IMPORT_TAG };
+                writeSkill(root, skill);
+                res.skills++;
+            }
+            else if (it.kind === "agent") {
+                const d = it.data;
+                const file = path.join(root, ".brito", "agents", `${it.name}.md`);
+                fs.mkdirSync(path.dirname(file), { recursive: true });
+                fs.writeFileSync(file, stringifyFrontmatter({ name: it.name, description: d.description, ...(d.tools !== "all" ? { tools: d.tools.join(", ") } : {}), ...(d.model ? { model: d.model } : {}), imported: IMPORT_TAG }, d.body));
+                res.agents++;
+            }
+            else if (it.kind === "deny" || it.kind === "allow") {
+                addRule(root, it.kind, it.data);
+                res.rules++;
+            }
+            else if (it.kind === "memory") {
+                res.notes.push(it.data);
+            }
+        }
+        catch (e) {
+            res.errors.push(`${it.kind} ${it.name}: ${e?.message ?? e}`);
+        }
+    }
+    return res;
+}
+/** Desfaz o que o import criou: skills (vão para a lixeira do escopo) e agentes marcados. Regras e notas ficam: apague à mão. */
+export function undoImport(root) {
+    let skills = 0, agents = 0;
+    for (const s of listSkills(root))
+        if (s.by === IMPORT_TAG && deleteSkill(root, s.name, s.scope))
+            skills++;
+    const dir = path.join(root, ".brito", "agents");
+    for (const f of mdIn(dir)) {
+        const text = readText(path.join(dir, f)) ?? "";
+        if (parseRichFrontmatter(text)?.meta.imported === IMPORT_TAG) {
+            fs.rmSync(path.join(dir, f));
+            agents++;
+        }
+    }
+    return { skills, agents };
+}
+const LABEL = { skill: "skill", agent: "agente", deny: "deny", allow: "allow", memory: "memória", info: "aviso" };
+/** Relatório legível do plano (antes de gravar) ou do resultado. */
+export function describePlan(plan) {
+    const lines = plan.items.map((i) => `${i.action === "import" ? "+" : "·"} ${LABEL[i.kind]} ${i.name} ← ${i.source}${i.note ? ` (${i.note})` : ""}`);
+    const n = (k) => plan.items.filter((i) => i.kind === k && i.action === "import").length;
+    lines.push(`resumo: ${n("skill")} skill(s), ${n("agent")} agente(s), ${n("deny") + n("allow")} regra(s), ${n("memory")} nota(s) a importar; ${plan.items.filter((i) => i.action === "skip" && i.kind !== "info").length} ignorado(s)`);
+    return lines;
+}

package/dist/local/compact.js

@@ -0,0 +1,66 @@
+import { slmGenerate, slmStatus } from "./slm.js";
+import { slmStats } from "./stats.js";
+export const slmCompactEnabled = () => process.env.BRITO_SLM_COMPACT !== "off";
+/** Tamanho de cada fatia em caracteres (~2,5k tokens de JSON de conversa: cabe com folga junto do prompt e da saída). */
+const CHUNK_CHARS = 9_000;
+/** Teto de reduções encadeadas, para nunca entrar em laço. */
+const MAX_ROUNDS = 3;
+const SYSTEM = "Você resume trechos de uma conversa de um agente de programação. Preserve: objetivo, decisões, arquivos e símbolos tocados (caminhos exatos), erros encontrados, estado atual e próximos passos. Não invente nada que não esteja no texto. Seja denso e use tópicos curtos. Responda só com o resumo.";
+/** Fatia em pedaços de até `size` caracteres, preferindo cortar em quebra de linha ou vírgula. */
+export function chunkText(text, size = CHUNK_CHARS) {
+    const out = [];
+    let i = 0;
+    while (i < text.length) {
+        let end = Math.min(i + size, text.length);
+        if (end < text.length) {
+            const cut = Math.max(text.lastIndexOf("\n", end), text.lastIndexOf(",", end));
+            if (cut > i + size * 0.5)
+                end = cut + 1;
+        }
+        out.push(text.slice(i, end));
+        i = end;
+    }
+    return out;
+}
+/** Resume `text` com o SLM. `null` = não deu (indisponível, erro ou resposta vazia). */
+export async function slmSummarize(text, gen = slmGenerate, signal) {
+    try {
+        let parts = chunkText(text);
+        for (let round = 0; round < MAX_ROUNDS; round++) {
+            const sums = [];
+            for (const p of parts) {
+                const s = (await gen({ system: SYSTEM, user: p, maxTokens: 700, temperature: 0.1, signal })).trim();
+                if (s)
+                    sums.push(s);
+            }
+            if (!sums.length)
+                return null;
+            const joined = sums.join("\n\n");
+            if (joined.length <= CHUNK_CHARS)
+                return joined;
+            parts = chunkText(joined);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resumo da compactação via SLM, ou `null` quando o SLM não está pronto/habilitado ou falhou.
+ * Registra a economia em `slmStats` (tokens que o modelo principal não precisou ler).
+ */
+export async function slmCompactSummary(text, gen = slmGenerate) {
+    if (!slmCompactEnabled())
+        return null;
+    if (gen === slmGenerate && !(await slmStatus()).ready)
+        return null;
+    const s = await slmSummarize(text, gen);
+    if (s === null) {
+        slmStats.compactFallbacks++;
+        return null;
+    }
+    slmStats.compactCalls++;
+    slmStats.tokensSaved += Math.max(0, Math.ceil((text.length - s.length) / 4));
+    return s;
+}