brito-cli 0.7.5 → 0.9.0

package/dist/cli.js

@@ -7,26 +7,35 @@ 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/todo.js";
 import fs from "node:fs";
+import { randomUUID } from "node:crypto";
+import { latestSession, listSessions, repairHistory, saveSession, titleOf } from "./agent/sessions.js";
 import { PLAN_NOTE, perms } from "./permissions.js";
+import { ORCH_NOTE, implStatus, mainTools, orch, orchGuard, restoreOrch } from "./orchestrator.js";
 import { loadProjectAgents, listAgents } from "./agent/agents.js";
 import { GraphLockedError, GraphStore, openGraphAfterClaude } from "./graph/store.js";
 import { indexProject } from "./graph/indexer.js";
 import { Agent } from "./agent/loop.js";
-import { EFFORTS, MODEL_ALIASES, modelHelp, effortLabel, initialEffort, initialModel, loadProfiles, isEffort, loadReasoningDisplay, parseModelArgs, saveEffort, saveModel, saveReasoningDisplay } from "./model.js";
+import { EFFORTS, MODEL_ALIASES, modelHelp, effortLabel, initialEffort, initialModel, loadProfiles, loadSavedOrch, isEffort, loadReasoningDisplay, parseModelArgs, saveEffort, saveImplModel, saveModel, saveOrch, saveReasoningDisplay } from "./model.js";
 import { hasClaudeCli, historyForFallback, ClaudeSession } from "./agent/claude-cli.js";
-import { FALLBACK_PROFILE, NO_ANTHROPIC, fallbackStatus, learnerModel, openEngine } from "./engine.js";
+import { NO_ANTHROPIC, fallbackStatus, learnerModel, openEngine } from "./engine.js";
 import { activateFallback, chooseModel, cliShouldFallBack, fallbackWarning, newFallbackState, onceRestore, renderFallback, retryPrompt } from "./provider/fallback.js";
 import { compactAtFor, contextWindowFor, resolveModel } from "./provider/resolve.js";
 import { startApprovalServer } from "./agent/approval.js";
+import { addRule, loadRules, projectSettingsPath } from "./rules.js";
 import { serveMcp } from "./mcp/server.js";
 import "./tools/skills.js";
-import { approvePending, lintSkill, listPending, listSkills, rejectPending, skillsIndex, staleRefs } from "./skills/store.js";
+import "./tools/digest.js";
+import { adviseSkill, approvePending, lintSkill, listBuiltins, listPending, listSkills, rejectPending, skillsIndex, staleRefs } from "./skills/store.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 { pullModel, removeModel, slmStatus, withSlm } from "./local/slm.js";
+import { buildSystemPrompt, graphStatsLine, memoSystem, systemKey } from "./agent/prompt.js";
 import { allTools } from "./tools/registry.js";
 import { ui, c, fmtTokens } from "./ui/ui.js";
 import { runRepl, switchableBackend } from "./repl.js";
@@ -64,6 +73,55 @@ program
     else
         console.log(`OK: ${r.found} nota(s) no banco antigo, ${r.added} copiada(s), ${r.skipped} já existiam. O .brito/graph.kuzu foi mantido; apague-o quando quiser.`);
 });
+program
+    .command("sessoes")
+    .alias("sessions")
+    .description("Lista as sessões salvas deste projeto (retome com brito --resume <id> ou brito -c)")
+    .option("-d, --dir <dir>", "raiz do projeto")
+    .action((o) => {
+    const lines = sessionLines(rootOf(o));
+    console.log(lines.length ? lines.join("\n") : c.muted("nenhuma sessão salva neste projeto"));
+});
+program
+    .command("slm [acao]")
+    .description("SLM local embutido (llama.cpp): status | pull (baixa o modelo) | rm (apaga). Usado na reflexão de skills; desligue com BRITO_SLM=off")
+    .action(async (acao) => {
+    const st = await slmStatus();
+    if (acao === "pull") {
+        if (!st.lib) {
+            console.error(c.err("node-llama-cpp não está instalado (dependência opcional). Rode: npm install node-llama-cpp"));
+            process.exit(1);
+        }
+        if (st.file) {
+            console.log(c.ok("✦ ") + `modelo já baixado: ${st.file}`);
+            return;
+        }
+        console.log(`baixando ${st.uri} (alguns GB; é retomável com Ctrl+C e rodar de novo)…`);
+        let last = -1;
+        const file = await pullModel((done, total) => {
+            const pct = total ? Math.floor((done / total) * 100) : 0;
+            if (pct >= last + 5 || pct === 100) {
+                last = pct;
+                process.stdout.write(`\r${pct}% (${(done / 1e9).toFixed(2)}/${(total / 1e9).toFixed(2)} GB)`);
+            }
+        });
+        console.log("\n" + c.ok("✦ ") + `pronto: ${file}`);
+        return;
+    }
+    if (acao === "rm") {
+        const f = await removeModel();
+        console.log(f ? c.ok("✦ ") + `removido: ${f}` : c.muted("nenhum modelo baixado"));
+        return;
+    }
+    if (acao && acao !== "status") {
+        console.error(c.err("uso: brito slm [status|pull|rm]"));
+        process.exit(1);
+    }
+    console.log(`  modelo    ${st.uri}`);
+    console.log(`  biblioteca ${st.lib ? c.ok("node-llama-cpp ok") : c.warn("node-llama-cpp ausente (npm install node-llama-cpp)")}`);
+    console.log(`  arquivo   ${st.file ?? c.muted("não baixado: brito slm pull")}`);
+    console.log(`  estado    ${st.disabled ? c.warn("desligado (BRITO_SLM=off)") : st.ready ? c.ok("ativo: a reflexão de skills roda localmente") : c.muted("inativo")}`);
+});
 program
     .command("query <cypher>")
     .description("Executa Cypher no grafo")
@@ -282,6 +340,37 @@ function modelCommand(get, set, note, veto = () => null, divert) {
     };
 }
 /** `/skills`: lista, revisa propostas pendentes e consolida a biblioteca. Vale para os dois backends. */
+/** `/permissions` lista as regras; `allow <regra>` / `deny <regra>` grava no `.brito/settings.json` do projeto. */
+const permissionsCommand = (root) => ({
+    desc: "regras de permissão; allow <regra> | deny <regra>",
+    run: async ([sub, ...rest]) => {
+        if (sub === "allow" || sub === "deny") {
+            const rule = rest.join(" ").trim();
+            if (!rule) {
+                ui.print(c.muted(`  uso: /permissions ${sub} bash(npm test:*)  ·  /permissions ${sub} edit_file(src/**)`));
+                return;
+            }
+            try {
+                addRule(root, sub, rule);
+                ui.info(`${sub}: ${rule} → ${path.relative(root, projectSettingsPath(root))}`);
+            }
+            catch (e) {
+                ui.error(e?.message ?? String(e));
+            }
+            return;
+        }
+        const r = loadRules(root);
+        if (!r.allow.length && !r.deny.length) {
+            ui.print(c.muted("  nenhuma regra. Ex.: /permissions allow bash(npm test:*)  ·  /permissions deny bash(git push:*)"));
+            return;
+        }
+        for (const a of r.allow)
+            ui.print(`  ${c.soft("allow")} ${a}`);
+        for (const d of r.deny)
+            ui.print(`  ${c.soft("deny ")} ${d}`);
+        ui.print(c.muted("  ~/.brito/settings.json · .brito/settings.json · .brito/settings.local.json"));
+    },
+});
 const skillsCommand = (root, io, llm) => ({
     desc: "lista skills; pending | approve <nome> | reject <nome> | consolidate",
     run: async ([sub, name]) => {
@@ -331,7 +420,7 @@ const skillsCommand = (root, io, llm) => ({
                     }
                     ui.print(`  ${c.soft(p.name)} ${c.muted(`(${p.scope}) ${p.description}`)}\n${p.body.split("\n").map((l) => `  │ ${l}`).join("\n")}`);
                     // Avisos do lint (ex.: comando destrutivo) ficam à vista de quem aprova, não só de quem propõe.
-                    for (const w of lintSkill(p).warnings)
+                    for (const w of [...lintSkill(p).warnings, ...adviseSkill(p)])
                         ui.print(c.warn(`  ⚠ ${w}`));
                     if (!(await io.ask(`aprovar a skill ${name}?`, { force: true }))) {
                         ui.info("mantida como pendente");
@@ -363,8 +452,10 @@ 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${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(", ")}`) : ""}`);
+            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}✗` : ""}${s.invoke === "manual" ? " · manual (/" + s.name + ")" : ""}${s.model ? ` · modelo: ${s.model}` : ""}${s.lastLoss ? ` · último tropeço: ${s.lastLoss}` : ""} · último uso ${s.lastUsed} · ${s.description}`)}${stale.length ? " " + c.warn(`⚠ refs obsoletas: ${stale.join(", ")}`) : ""}`);
         }
+        for (const s of listBuiltins(root))
+            ui.print(`  ${c.soft("/" + s.name)} ${c.muted(`(embutida) ${s.description}`)}`);
         const prune = pruneCandidates(skills);
         if (prune.length)
             ui.info(`${prune.length} candidata(s) a poda (sem uso há mais de 30 dias): /skills consolidate`);
@@ -413,6 +504,106 @@ function makeLearner(getTurns, ctx, complete, getModel) {
         }
     };
 }
+/**
+ * `/orquestrar [on|off] [modelo <perfil>] [--global]`: o principal planeja e revisa, o perfil implementa pela tool
+ * `implement`. `on`/`off` e `modelo` combinam no mesmo comando; `--global` grava o que foi pedido no config
+ * (`orchestrator` e `implModel`), para valer ao abrir o Brito de novo.
+ */
+function orchestratorCommand(main) {
+    const usage = "  uso: /orquestrar on|off [modelo <perfil>] [--global] · /orquestrar modelo <perfil> [--global]";
+    return {
+        desc: "modo orquestrador: o modelo principal planeja e revisa, um perfil (qwen) implementa",
+        run: async (args) => {
+            const global = args.includes("--global");
+            const words = args.filter((a) => !a.startsWith("--"));
+            const st = () => implStatus(main(), orch.model, process.env);
+            if (!words.length) {
+                const s = st();
+                ui.print(`  ${c.soft("modo")} ${c.muted(`${orch.on ? "ligado" : "desligado"}${loadSavedOrch() ? " · liga ao abrir (salvo)" : ""}`)}`);
+                ui.print(`  ${c.soft("implementador")} ${c.muted(`${orch.model} · ${s.ready ? `${s.label} ✓ pronto` : `✗ ${s.reason}`}`)}`);
+                ui.print(c.muted(usage));
+                return;
+            }
+            const toggle = words.find((w) => w === "on" || w === "off");
+            const mi = words.indexOf("modelo");
+            const name = mi >= 0 ? words[mi + 1] : undefined;
+            const known = new Set([toggle, "modelo", name].filter(Boolean));
+            if ((mi >= 0 && !name) || words.some((w) => !known.has(w)) || words.filter((w) => w === "on" || w === "off").length > 1) {
+                ui.warn(`argumento desconhecido: ${args.join(" ")}`);
+                ui.print(c.muted(usage));
+                return;
+            }
+            // O implementador primeiro: `on modelo X` liga já com o X.
+            if (name) {
+                const key = name.trim().toLowerCase();
+                if (resolveModel(key).kind !== "openai") {
+                    ui.error(`"${name}" não é um perfil de endpoint em providers no ~/.brito/config.json: o implementador é um perfil (ex.: qwen); o principal se troca com /model`);
+                    return;
+                }
+                orch.model = key;
+                if (global)
+                    saveImplModel(key);
+                ui.info(`implementador: ${key}${global ? " (salvo)" : ""}`);
+            }
+            if (toggle === "off") {
+                orch.on = false;
+                if (global)
+                    saveOrch(false);
+                ui.info(`modo orquestrador desligado${global ? " (salvo)" : ""}: o modelo principal volta a editar`);
+                return;
+            }
+            if (toggle === "on") {
+                const s = st();
+                if (!s.ready) {
+                    ui.error(`modo orquestrador não ligou: ${s.reason}`);
+                    return;
+                }
+                orch.on = true;
+                if (global)
+                    saveOrch(true);
+                ui.info(`modo orquestrador ligado${global ? " (salvo: liga ao abrir o Brito)" : ""}: ${main()} planeja e revisa, ${s.label} implementa`);
+                return;
+            }
+            const s = st();
+            if (orch.on && !s.ready) {
+                orch.on = false;
+                ui.warn(`modo orquestrador desligado: ${s.reason}`);
+            }
+        },
+    };
+}
+/** Linhas da listagem de sessões (`brito sessoes`, `/sessions`): id, quando, motor e título. */
+function sessionLines(root, current) {
+    return listSessions(root).slice(0, 20).map((s) => {
+        const when = s.updatedAt.slice(0, 16).replace("T", " ");
+        const mark = s.id === current ? c.accent(" ●") : "";
+        return `  ${c.soft(s.id.slice(0, 8))}  ${c.muted(when)}  ${c.dim(s.engine === "claude" ? "claude" : "api   ")}  ${s.title || c.dim("(sem título)")}${mark}`;
+    });
+}
+const sessionsCommand = (root, current) => ({
+    desc: "sessões salvas deste projeto (retome com brito --resume <id>)",
+    run: async () => {
+        const lines = sessionLines(root, current());
+        if (!lines.length) {
+            ui.print(c.muted("  nenhuma sessão salva ainda"));
+            return;
+        }
+        for (const l of lines)
+            ui.print(l);
+        ui.print(c.muted("  retome com: brito --resume <id>  ·  brito -c retoma a mais recente"));
+    },
+});
+/** `--resume` aceita o id inteiro ou o começo dele (como a listagem mostra). */
+function findSession(root, idOrPrefix) {
+    const all = listSessions(root);
+    const exact = all.find((s) => s.id === idOrPrefix);
+    if (exact)
+        return exact;
+    const hits = all.filter((s) => s.id.startsWith(idOrPrefix));
+    if (hits.length > 1)
+        throw new Error(`o prefixo ${idOrPrefix} casa com ${hits.length} sessões; use mais caracteres`);
+    return hits[0] ?? null;
+}
 /**
  * Monta o loop próprio (`Agent`) e o `ReplBackend` do modo API. Serve à abertura normal e à troca para o qwen quando
  * o claude CLI cai; `perms.mode` é global, então o modo de permissão da sessão segue igual.
@@ -429,20 +620,39 @@ async function buildApiBackend(root, model, io, o = {}) {
     const noteCount = Number(notes);
     const ctx = { root, graph, ask: (q, opts) => io.ask(q, opts), sync, dirty: false, loadedSkills: o.loadedSkills ?? new Set() };
     const fallback = o.fallback ?? newFallbackState(model);
-    // Função: o índice de skills e a contagem do grafo são relidos a cada passo e refletem o que mudou na sessão.
-    const agent = new Agent(() => buildSystemPrompt(root, graphStatsLine(symCount, noteCount, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : ""), ctx, { model, fallback });
+    // Refeito só quando muda o modo plano, o modo orquestrador, o grafo deixa de estar vazio ou o conjunto de skills muda:
+    // um system estável mantém o cache de prompt da conversa (veja memoSystem).
+    const system = memoSystem(() => systemKey(root, perms.mode === "plan", symCount + noteCount === 0) + `|${orch.on}`, () => buildSystemPrompt(root, graphStatsLine(symCount, noteCount, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : "") + (orch.on ? ORCH_NOTE : ""));
+    const agent = new Agent(system, ctx, { model, fallback, tools: mainTools });
     if (o.messages)
         agent.messages = o.messages;
     if (o.effort)
         agent.effort = o.effort;
+    let sessionId = o.session?.id ?? randomUUID();
+    if (o.session?.messages)
+        agent.messages = repairHistory(o.session.messages);
+    if (o.session?.todos)
+        ctx.todos = o.session.todos;
     ctx.model = () => agent.model; // subagentes seguem o modelo vivo
     ui.reasoning = loadReasoningDisplay();
     const learnModel = () => learnerModel(agent.model, process.env);
     loadProjectAgents(root);
     /** Depois de tarefas complexas (ou uso de skill), propõe criar/melhorar skills. */
-    const learn = makeLearner(() => agent.recentTurns, ctx, defaultComplete, learnModel);
+    const learn = makeLearner(() => agent.recentTurns, ctx, withSlm(defaultComplete), learnModel);
+    /** Grava a conversa a cada turno (também nos que falharam): `brito -c` retoma de onde parou. */
+    const persist = () => {
+        if (!agent.messages.length)
+            return;
+        try {
+            saveSession(root, { id: sessionId, engine: "api", model: agent.model, title: titleOf(agent.messages), messages: agent.messages, todos: ctx.todos });
+        }
+        catch (e) {
+            ui.warn(`não consegui salvar a sessão: ${e?.message ?? e}`);
+        }
+    };
     const turn = async (text, signal) => {
         ui.turnStart();
+        orchGuard(agent.model, (m) => ui.warn(m)); // `/model qwen` ou a troca do claude CLI para o qwen
         let ok = true;
         try {
             await agent.send(text, signal);
@@ -453,6 +663,7 @@ async function buildApiBackend(root, model, io, o = {}) {
         }
         finally {
             ui.turnEnd(ok);
+            persist();
         }
         return ok;
     };
@@ -463,18 +674,21 @@ async function buildApiBackend(root, model, io, o = {}) {
     const modelCmd = modelCommand(() => agent.model, (m) => { agent.model = m; chooseModel(fallback, m); }, "(troque com /model; subagentes explore usam BRITO_EXPLORE_MODEL)", noApiKey, o.divert);
     const backend = {
         model: () => agent.model,
+        fallback: () => fallback,
         contextTokens: () => agent.contextTokens,
         usage: () => agent.usage,
         get ctxWindow() { return contextWindowFor(agent.model); },
         cost: () => (Number.isFinite(PRICE_IN) && Number.isFinite(PRICE_OUT) ? (agent.usage.input * PRICE_IN + agent.usage.output * PRICE_OUT) / 1e6 : undefined),
         turn,
         afterTurn: async () => { modelCmd.restoreOnce(fallback.active); await learn(); },
-        reset: () => { agent.messages = []; agent.contextTokens = 0; agent.recentTurns = []; agent.unsentTurns = []; agent.lastTurn = null; },
+        // `/clear` começa outra sessão: a anterior continua salva e pode ser retomada com --resume.
+        reset: () => { agent.messages = []; agent.contextTokens = 0; agent.recentTurns = []; agent.unsentTurns = []; agent.lastTurn = null; ctx.todos = undefined; sessionId = randomUUID(); },
         onShell: () => { ctx.dirty = true; }, // `!cmd` pode ter mudado o código
         commands: {
             "/model": modelCmd.cmd,
             "/fallback": fallbackCommand(fallback, () => agent.model, o.engineLabel ?? ((m) => (resolveModel(m).kind === "openai" ? "endpoint" : "API Anthropic"))),
             "/reasoning": reasoningCommand(() => agent.effort, (e) => { agent.effort = e; }),
+            "/orquestrar": orchestratorCommand(() => agent.model),
             "/tools": { desc: "ferramentas disponíveis", run: async () => { for (const t of allTools())
                     ui.print(`  ${ui.toolLabel(t.name)}${c.dim(t.dangerous ? "  (pede aprovação)" : "")}`); } },
             "/context": {
@@ -487,11 +701,14 @@ async function buildApiBackend(root, model, io, o = {}) {
             },
             "/index": { desc: "reconstrói o grafo do zero", run: async () => { ui.info("reconstruindo grafo…"); ui.print(c.muted(JSON.stringify(await indexProject(root, graph, { full: true })))); } },
             "/learn": { desc: "extrai skills do último turno agora", run: async () => { await learn(true); } },
-            "/skills": skillsCommand(root, io, { complete: defaultComplete, model: learnModel }),
+            "/skills": skillsCommand(root, io, { complete: withSlm(defaultComplete), model: learnModel }),
+            "/permissions": permissionsCommand(root),
+            "/todos": { desc: "lista de tarefas da sessão", run: async () => { ctx.todos?.length ? ui.printTodos(ctx.todos) : ui.print(c.muted("  sem lista de tarefas nesta sessão")); } },
+            "/sessions": sessionsCommand(root, () => sessionId),
         },
         close: async () => { await graph.close(); },
     };
-    return { backend, agent, graph, learn, symbols: () => symCount, notes: noteCount };
+    return { backend, agent, graph, learn, symbols: () => symCount, notes: noteCount, sessionId: () => sessionId };
 }
 /** `--once` não troca de motor: o turno seguinte rodaria no outro motor e a volta exigiria trocar de novo. */
 const onceNoSwitch = (m) => `o ${m} roda no claude CLI: --once não troca de motor; use /model ${m}`;
@@ -501,8 +718,8 @@ let approvalServer = null;
  * Motor claude CLI. `sw` é o backend do REPL: `/model <perfil>` troca para o modo API (com a conversa do claude) e
  * `/model <claude>` lá volta para cá. Também serve ao prompt único, que não troca de motor pelo `/model`.
  */
-async function buildClaudeBackend(root, io, sw, model, openGraph) {
-    approvalServer ??= startApprovalServer({ ask: (q, opts) => io.ask(q, opts) });
+async function buildClaudeBackend(root, io, sw, model, openGraph, resume) {
+    approvalServer ??= startApprovalServer({ ask: (q, opts) => io.ask(q, opts) }, root);
     // O banco aceita um único processo com acesso de escrita: indexa, lê as stats e solta o banco para o servidor MCP.
     // `openGraph`: o do modo API, que é fechado aqui só depois de indexar (se falhar antes, continua aberto para ele).
     const graph = openGraph ?? await GraphStore.open(root);
@@ -517,9 +734,22 @@ async function buildClaudeBackend(root, io, sw, model, openGraph) {
         mcpCommand: { command: process.execPath, args: [...process.execArgv, process.argv[1], "mcp-serve", "-d", root] },
     });
     loadProjectAgents(root);
+    if (resume)
+        session.resume(resume.id);
+    // Só o id fica aqui: a conversa em si o claude CLI guarda, e o `--resume` dele a recupera.
+    let title = resume?.title ?? "";
+    const persist = (text) => {
+        title ||= text.replace(/\s+/g, " ").trim().slice(0, 80);
+        try {
+            saveSession(root, { id: session.sessionId, engine: "claude", model: session.model, title });
+        }
+        catch (e) {
+            ui.warn(`não consegui salvar a sessão: ${e?.message ?? e}`);
+        }
+    };
     // O grafo já foi solto para o servidor MCP; skill_save só usa o store de skills, então `graph` não é tocado.
     const learnCtx = { root, graph: undefined, ask: (q, opts) => io.ask(q, opts), sync: async () => { }, dirty: false, loadedSkills: session.loadedSkills };
-    const learn = makeLearner(() => session.recentTurns, learnCtx, claudeCliComplete, () => process.env.BRITO_LEARN_MODEL ?? ""); // "" = modelo padrão do claude
+    const learn = makeLearner(() => session.recentTurns, learnCtx, withSlm(claudeCliComplete), () => process.env.BRITO_LEARN_MODEL ?? ""); // "" = modelo padrão do claude
     if (model) {
         session.requestedModel = resolveModel(model).wireModel;
         session.model = session.requestedModel;
@@ -568,7 +798,7 @@ async function buildClaudeBackend(root, io, sw, model, openGraph) {
         const api = await openApi(status.name, status.label, { engineLabel: () => "claude CLI · assinatura" });
         if (!api)
             return null;
-        activateFallback(fallback, `${f.kind} (${f.message})`);
+        activateFallback(fallback, `${f.kind} (${f.message})`, Date.now(), undefined, status.name);
         return { api, retry: () => api.backend.turn(retryPrompt(text), signal) };
     };
     /** `/model <perfil>`: perfis de endpoint rodam no loop próprio do Brito, então o motor troca para o modo API. */
@@ -600,12 +830,15 @@ async function buildClaudeBackend(root, io, sw, model, openGraph) {
     const mcpTools = allTools().map((t) => t.name).filter((n) => /^(graph_|skill_)/.test(n) || n === "remember" || n === "recall");
     const backend = {
         model: () => session.model,
+        fallback: () => fallback,
         contextTokens: () => session.contextTokens,
         usage: () => session.usage,
         cost: () => (session.costUsd > 0 ? session.costUsd : undefined),
         get ctxWindow() { return session.contextWindow ?? CTX_WINDOW; },
         turn: async (text, signal) => {
-            if (await session.send(text))
+            const ok = await session.send(text);
+            persist(text);
+            if (ok)
                 return true;
             const fb = await switchToQwen(text, signal);
             if (!fb)
@@ -616,11 +849,12 @@ async function buildClaudeBackend(root, io, sw, model, openGraph) {
         },
         afterTurn: async () => { modelCmd.restoreOnce(); await learn(); },
         abort: () => session.abort(),
-        reset: () => session.reset(),
+        reset: () => { session.reset(); title = ""; },
         commands: {
             "/model": modelCmd.cmd,
             "/fallback": fallbackCommand(fallback, () => session.model, () => "claude CLI · assinatura"),
             "/effort": effortCommand(() => session.effort, (e) => { session.effort = e; }),
+            "/orquestrar": orchestratorCommand(() => session.requestedModel || session.model),
             "/reasoning": reasoningCommand(() => session.effort, (e) => { session.effort = e; }),
             "/tools": { desc: "ferramentas do grafo/memória/skills", run: async () => { for (const n of mcpTools)
                     ui.print(`  ${ui.toolLabel(n)}`); } },
@@ -635,13 +869,15 @@ async function buildClaudeBackend(root, io, sw, model, openGraph) {
             },
             "/context": unavailable,
             "/learn": { desc: "extrai skills do último turno agora", run: async () => { await learn(true); } },
-            "/skills": skillsCommand(root, io, { complete: claudeCliComplete, model: () => process.env.BRITO_LEARN_MODEL ?? "" }),
+            "/skills": skillsCommand(root, io, { complete: withSlm(claudeCliComplete), model: () => process.env.BRITO_LEARN_MODEL ?? "" }),
+            "/permissions": permissionsCommand(root),
+            "/sessions": sessionsCommand(root, () => session.sessionId),
         },
         close: async () => { },
     };
     return { backend, session, learn, switchToQwen, modelCmd, syms: Number(syms), notes: Number(notes), mcpTools };
 }
-async function runViaClaude(root, promptParts, yes, model) {
+async function runViaClaude(root, promptParts, yes, model, resume) {
     const startedAt = Date.now();
     if (yes)
         perms.mode = "bypass";
@@ -652,7 +888,7 @@ async function runViaClaude(root, promptParts, yes, model) {
         await offerNoteMigration(root, (q) => migrationAsk(q), (m) => ui.info(m));
     }
     let sw;
-    const claude = await buildClaudeBackend(root, io, () => sw, model);
+    const claude = await buildClaudeBackend(root, io, () => sw, model, undefined, resume);
     if (promptParts.length) {
         const text = promptParts.join(" ");
         if (await claude.session.send(text)) {
@@ -673,6 +909,7 @@ async function runViaClaude(root, promptParts, yes, model) {
     }
     sw = switchableBackend(claude.backend);
     ui.info("modo claude CLI: usa o login da sua conta; tools do grafo/memória/skills via MCP.");
+    restoreOrch(claude.session.requestedModel || claude.session.model, (m) => ui.warn(m), (m) => ui.info(m));
     await runRepl(sw, {
         root, yes, startedAt, io,
         banner: {
@@ -687,6 +924,8 @@ program
     .option("-d, --dir <dir>", "raiz do projeto")
     .option("-y, --yes", "aprovar edições e comandos automaticamente")
     .option("-m, --model <nome>", "modelo ou perfil de endpoint (ex.: sonnet, qwen)")
+    .option("-c, --continue", "retoma a sessão mais recente deste projeto")
+    .option("-r, --resume <id>", "retoma uma sessão salva (id ou começo dele; veja `brito sessoes`)")
     .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.
@@ -696,17 +935,47 @@ program
     }
     for (const e of loadProfiles().errors)
         ui.warn(e);
-    const startModel = o.model ?? initialModel();
+    let resume = null;
+    if (o.resume || o.continue) {
+        try {
+            resume = o.resume ? findSession(rootOf(o), o.resume) : latestSession(rootOf(o));
+        }
+        catch (e) {
+            console.error(c.err(e?.message ?? String(e)));
+            process.exit(1);
+        }
+        if (!resume) {
+            console.error(c.err(o.resume ? `sessão não encontrada: ${o.resume} (veja \`brito sessoes\`)` : "nenhuma sessão salva neste projeto"));
+            process.exit(1);
+        }
+    }
+    const startModel = o.model ?? (resume?.engine === "api" ? resume.model : undefined) ?? initialModel();
     const engine = openEngine(startModel, process.env, hasClaudeCli);
     if (engine.kind === "error") {
         console.error(c.err(engine.message));
         process.exit(1);
     }
+    // A sessão é retomada no motor que a gravou: a conversa de uma está guardada onde a outra não alcança.
+    if (resume?.engine === "claude") {
+        if (!hasClaudeCli()) {
+            console.error(c.err("esta sessão foi feita no claude CLI, que não está instalado aqui"));
+            process.exit(1);
+        }
+        ui.info(`retomando: ${resume.title || resume.id}`);
+        await runViaClaude(rootOf(o), promptParts, !!o.yes, o.model, resume);
+        return;
+    }
+    if (resume && engine.kind === "claude") {
+        console.error(c.err(`esta sessão foi feita no modo API (${resume.model}); sem ANTHROPIC_API_KEY ela só abre num perfil de endpoint: brito --resume ${resume.id.slice(0, 8)} --model qwen`));
+        process.exit(1);
+    }
     if (engine.kind === "claude") {
         await runViaClaude(rootOf(o), promptParts, !!o.yes, o.model);
         return;
     }
     const root = rootOf(o);
+    if (resume)
+        ui.info(`retomando: ${resume.title || resume.id} (${resume.messages?.length ?? 0} mensagens)`);
     const startedAt = Date.now();
     {
         const { offerNoteMigration } = await import("./graph/migrate.js");
@@ -717,12 +986,12 @@ program
         perms.mode = "bypass";
     const io = { ask: async (q, _opts) => perms.mode === "bypass" || plainAsk(q) };
     // Claude sem conta nenhuma, com o fallback pronto: a sessão já nasce no qwen (com aviso, nunca em silêncio).
-    let opening = {};
+    let opening = resume ? { session: resume } : {};
     if (engine.kind === "fallback") {
         ui.warn(`⚠ ${NO_ANTHROPIC} (sem ANTHROPIC_API_KEY e sem o claude CLI) — abrindo no ${engine.label}. /fallback para detalhes.`);
         const fallback = newFallbackState(startModel);
-        activateFallback(fallback, NO_ANTHROPIC);
-        opening = { fallback, engineLabel: () => NO_ANTHROPIC };
+        activateFallback(fallback, NO_ANTHROPIC, Date.now(), undefined, engine.name);
+        opening = { ...opening, fallback, engineLabel: () => NO_ANTHROPIC };
     }
     let sw;
     // Sem ANTHROPIC_API_KEY o Claude só roda no claude CLI: `/model <claude>` troca o motor em vez de recusar.
@@ -754,7 +1023,7 @@ program
             await claude.modelCmd.cmd.run([m, `--${scope}`]);
             return true;
         };
-    const api = await buildApiBackend(root, engine.kind === "fallback" ? FALLBACK_PROFILE : startModel, io, opening);
+    const api = await buildApiBackend(root, engine.kind === "fallback" ? engine.name : startModel, io, opening);
     if (promptParts.length) {
         if (await api.backend.turn(promptParts.join(" "), new AbortController().signal))
             await api.learn();
@@ -762,6 +1031,7 @@ program
         return;
     }
     sw = switchableBackend(api.backend);
+    restoreOrch(api.agent.model, (m) => ui.warn(m), (m) => ui.info(m));
     await runRepl(sw, {
         root, yes: !!o.yes, startedAt, io,
         banner: {

package/dist/desktop/panels.js

@@ -0,0 +1,93 @@
+import os from "node:os";
+import path from "node:path";
+import { listAgents } from "../agent/agents.js";
+import { GraphStore } from "../graph/store.js";
+import { indexProject } from "../graph/indexer.js";
+import { approvePending, deleteSkill, getSkill, listBuiltins, listPending, listSkills, promoteSkill, rejectPending } from "../skills/store.js";
+/**
+ * Dados dos painéis do app (Skills, Agentes, Grafo, Memória). O GraphStore só segura o banco enquanto há consulta
+ * (leitura abre somente leitura), então um segundo handle aqui convive com o do motor e com o servidor MCP do claude.
+ */
+export class Panels {
+    root;
+    graphRoot;
+    isHome;
+    graph = null;
+    constructor(root, graphRoot, isHome) {
+        this.root = root;
+        this.graphRoot = graphRoot;
+        this.isHome = isHome;
+    }
+    async g() { return (this.graph ??= await GraphStore.open(this.graphRoot)); }
+    async close() { await this.graph?.close(); this.graph = null; }
+    skills() {
+        const root = this.root;
+        const active = [...listBuiltins(root), ...listSkills(root)].map((s) => ({
+            name: s.name, description: s.description, scope: s.scope, status: s.status, invoke: s.invoke, uses: s.uses, builtin: !!s.builtin, origin: s.origin,
+        }));
+        const pending = listPending(root).map((p) => ({ name: p.name, description: p.description, reason: p.reason, scope: p.scope }));
+        return { active, pending };
+    }
+    skill(name) {
+        const s = getSkill(this.root, name);
+        return s ? { name: s.name, description: s.description, body: s.body, refs: s.refs, scope: s.scope, model: s.model, wins: s.wins, losses: s.losses } : null;
+    }
+    skillAction(op, name) {
+        const root = this.root;
+        switch (op) {
+            case "approve":
+                approvePending(root, name);
+                return `skill ${name} aprovada`;
+            case "reject": return rejectPending(root, name) ? `proposta ${name} descartada` : `sem proposta ${name}`;
+            case "delete": return deleteSkill(root, name) ? `skill ${name} removida (foi para .trash)` : `não foi possível remover ${name}`;
+            case "promote":
+                promoteSkill(root, name);
+                return `skill ${name} agora é global`;
+            default: throw new Error(`ação desconhecida: ${op}`);
+        }
+    }
+    agents() {
+        return listAgents().map((a) => ({ name: a.name, description: a.description, tools: a.tools === "all" ? "todas" : a.tools.join(", "), model: a.model ?? "", source: a.source }));
+    }
+    async symbols(q) {
+        const g = await this.g();
+        const rows = q
+            ? await g.run("MATCH (s:Symbol) WHERE toLower(s.name) CONTAINS $q RETURN s.id AS id, s.name AS name, s.kind AS kind, s.file AS file, s.startLine AS line ORDER BY s.name LIMIT 40", { q: q.toLowerCase() })
+            : await g.run("MATCH (s:Symbol) RETURN s.id AS id, s.name AS name, s.kind AS kind, s.file AS file, s.startLine AS line ORDER BY s.file, s.startLine LIMIT 40");
+        const stats = await this.stats();
+        return { rows, stats };
+    }
+    async stats() {
+        const g = await this.g();
+        const n = async (c) => Number((await g.run(c))[0]?.n ?? 0);
+        return { symbols: await n("MATCH (s:Symbol) RETURN count(s) AS n"), files: await n("MATCH (f:File) RETURN count(f) AS n"), notes: await n("MATCH (s:Note) RETURN count(s) AS n") };
+    }
+    async symbol(id) {
+        const g = await this.g();
+        const cols = "x.id AS id, x.name AS name, x.kind AS kind, x.file AS file, x.startLine AS line";
+        const callers = await g.run(`MATCH (x:Symbol)-[:CALLS]->(s:Symbol {id: $id}) RETURN ${cols} LIMIT 30`, { id });
+        const callees = await g.run(`MATCH (s:Symbol {id: $id})-[:CALLS]->(x:Symbol) RETURN ${cols} LIMIT 30`, { id });
+        return { callers, callees };
+    }
+    async reindex() {
+        if (this.isHome)
+            return { symbols: 0, skipped: true };
+        const g = await this.g();
+        const r = await indexProject(this.root, g);
+        return { symbols: r.symbols };
+    }
+    async notes(q) {
+        const g = await this.g();
+        const base = "MATCH (n:Note) ";
+        const rows = q
+            ? await g.run(base + "WHERE toLower(n.text) CONTAINS $q OR toLower(n.kind) CONTAINS $q RETURN n.id AS id, n.kind AS kind, n.text AS text, n.refs AS refs, n.ts AS ts ORDER BY n.ts DESC LIMIT 100", { q: q.toLowerCase() })
+            : await g.run(base + "RETURN n.id AS id, n.kind AS kind, n.text AS text, n.refs AS refs, n.ts AS ts ORDER BY n.ts DESC LIMIT 100");
+        return rows.map((r) => ({ ...r, ts: Number(r.ts), refs: r.refs ?? [] }));
+    }
+    async deleteNote(id) {
+        const g = await this.g();
+        await g.run("MATCH (n:Note {id: $id}) DELETE n", { id });
+        return "nota removida";
+    }
+}
+export const graphRootFor = (root) => (path.resolve(root) === path.resolve(os.homedir()) ? path.join(os.homedir(), ".brito", "home-graph") : root);

package/dist/desktop/protocol.js

@@ -0,0 +1,5 @@
+/**
+ * Contrato entre o app desktop e `brito gui-serve` (JSON em linhas; stdout leva o prefixo "@@").
+ * A janela compara `PROTOCOL` com o `hello` do backend e avisa se o app e a CLI estão desalinhados.
+ */
+export const PROTOCOL = 2;