brito-cli 0.7.4 → 0.8.0

package/dist/cli.js

@@ -7,7 +7,10 @@ import "./tools/bash.js";
 import "./tools/graph.js";
 import "./tools/delegate.js";
 import "./tools/plan.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 { loadProjectAgents, listAgents } from "./agent/agents.js";
 import { GraphLockedError, GraphStore, openGraphAfterClaude } from "./graph/store.js";
@@ -15,18 +18,21 @@ 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 { 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 +70,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 +337,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 +417,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 +449,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 +501,38 @@ function makeLearner(getTurns, ctx, complete, getModel) {
         }
     };
 }
+/** 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,18 +549,36 @@ 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 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), () => buildSystemPrompt(root, graphStatsLine(symCount, noteCount, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : ""));
+    const agent = new Agent(system, ctx, { model, fallback });
     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();
         let ok = true;
@@ -453,6 +591,7 @@ async function buildApiBackend(root, model, io, o = {}) {
         }
         finally {
             ui.turnEnd(ok);
+            persist();
         }
         return ok;
     };
@@ -463,13 +602,15 @@ 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,
@@ -487,11 +628,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 +645,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 +661,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 +725,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 +757,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,7 +776,7 @@ 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"),
@@ -635,13 +795,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 +814,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)) {
@@ -687,6 +849,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 +860,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 +911,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 +948,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();

package/dist/desktop/serve.js

@@ -9,15 +9,18 @@ import "../tools/graph.js";
 import "../tools/delegate.js";
 import "../tools/plan.js";
 import "../tools/skills.js";
+import "../tools/digest.js";
+import "../tools/todo.js";
 import { Agent } from "../agent/loop.js";
+import { loadSession, repairHistory, saveSession, titleOf } from "../agent/sessions.js";
 import { ClaudeSession, hasClaudeCli, historyForFallback } from "../agent/claude-cli.js";
 import { startApprovalServer } from "../agent/approval.js";
 import { loadProjectAgents } from "../agent/agents.js";
-import { buildSystemPrompt, graphStatsLine } from "../agent/prompt.js";
+import { buildSystemPrompt, graphStatsLine, memoSystem, systemKey } from "../agent/prompt.js";
 import { openGraphAfterClaude } from "../graph/store.js";
 import { indexProject } from "../graph/indexer.js";
 import { initialEffort, initialModel, isEffort, loadProfiles, MODEL_ALIASES } from "../model.js";
-import { FALLBACK_PROFILE, NO_ANTHROPIC, fallbackStatus, openEngine } from "../engine.js";
+import { NO_ANTHROPIC, fallbackStatus, openEngine } from "../engine.js";
 import { 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";
@@ -89,13 +92,29 @@ 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 agent = new Agent(() => buildSystemPrompt(root, graphStatsLine(syms, notes, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : ""), ctx, { model, sink, fallback });
+        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 });
         if (o.messages)
             agent.messages = o.messages;
         if (o.effort)
             agent.effort = o.effort;
+        if (o.session?.messages)
+            agent.messages = repairHistory(o.session.messages);
+        if (o.session?.todos)
+            ctx.todos = o.session.todos;
         let ac = null;
-        const id = randomUUID();
+        const id = o.session?.id ?? randomUUID();
+        // Depois de uma troca a partir do claude CLI quem guarda a conversa é ele (o id é o dele): nada a salvar aqui.
+        const persist = () => {
+            if (o.back || !agent.messages.length)
+                return;
+            try {
+                saveSession(root, { id, engine: "api", model: agent.model, title: titleOf(agent.messages), messages: agent.messages, todos: ctx.todos });
+            }
+            catch (e) {
+                sink.warn(`não consegui salvar a sessão: ${e?.message ?? e}`);
+            }
+        };
         return {
             kind: "api", effort: "", fallback,
             // Depois da troca o id segue o do claude: a janela o guarda para retomar a conversa ao reabrir.
@@ -136,6 +155,7 @@ export async function serveDesktop(root, resumeId) {
                 finally {
                     sink.turnEnd(ok);
                     ac = null;
+                    persist();
                 }
             },
             abort: () => ac?.abort(),
@@ -152,20 +172,23 @@ export async function serveDesktop(root, resumeId) {
         };
     };
     if (opening.kind !== "claude") {
-        if (resumeId)
-            emit({ t: "info", msg: "No modo API o histórico da conversa não é retomado ao reabrir; a tela mostra o que já foi dito, mas o modelo recomeça." });
+        // O id que a janela guarda é o da sessão salva em .brito/sessions: reabrir retoma o histórico de verdade.
+        const saved = resumeId ? loadSession(root, resumeId) : null;
+        const session = saved?.engine === "api" ? saved : undefined;
+        if (resumeId && !session)
+            emit({ t: "info", msg: "Esta conversa não foi salva no modo API (é de uma versão antiga ou do claude CLI): a tela mostra o que já foi dito, mas o modelo recomeça." });
         if (opening.kind === "fallback") {
             // Claude sem conta nenhuma, com o fallback pronto: a sessão já nasce no qwen (com aviso, nunca em silêncio).
             emit({ t: "warn", msg: `⚠ ${NO_ANTHROPIC} (sem ANTHROPIC_API_KEY e sem o claude CLI) — abrindo no ${opening.label}. Envie /fallback para detalhes.` });
             const fallback = newFallbackState(startModel);
-            activateFallback(fallback, NO_ANTHROPIC);
-            engine = await buildApiEngine(FALLBACK_PROFILE, { fallback, engineLabel: () => NO_ANTHROPIC });
+            activateFallback(fallback, NO_ANTHROPIC, Date.now(), undefined, opening.name);
+            engine = await buildApiEngine(opening.name, { fallback, engineLabel: () => NO_ANTHROPIC, session });
         }
         else
-            engine = await buildApiEngine(startModel);
+            engine = await buildApiEngine(startModel, { session });
     }
     else {
-        const approval = startApprovalServer({ ask });
+        const approval = startApprovalServer({ ask }, root);
         closeApproval = approval.close;
         // O banco aceita um único processo com escrita: indexa, lê as stats e solta o banco para o servidor MCP.
         if (!isHome)
@@ -228,7 +251,7 @@ export async function serveDesktop(root, resumeId) {
                     sink.error(`não consegui abrir o ${status.label}: ${e?.message ?? e}`);
                     return;
                 }
-                activateFallback(fallback, `${f.kind} (${f.message})`);
+                activateFallback(fallback, `${f.kind} (${f.message})`, Date.now(), undefined, status.name);
                 engine = api;
                 ready();
                 await api.send(retryPrompt(text, resumed));

package/dist/engine.js

@@ -1,13 +1,35 @@
 import { MODEL_ALIASES, loadProfiles } from "./model.js";
 import { missingKeyMessage } from "./provider/openai-compat.js";
-import { resolveModel } from "./provider/resolve.js";
-/** O fallback é sempre este perfil de `providers` (não configurável). */
+import { slmReadySync } from "./local/slm.js";
+import { SLM_MODEL, resolveModel } from "./provider/resolve.js";
+/** O primeiro fallback é sempre este perfil de `providers` (não configurável). */
 export const FALLBACK_PROFILE = "qwen";
+/** Cadeia: Claude → qwen → SLM local (último recurso, sem rede nem conta). */
+export const FALLBACK_CHAIN = [FALLBACK_PROFILE, SLM_MODEL];
 /**
  * Pronto só se o perfil existe, é válido, tem a chave no ambiente e o principal não é ele mesmo. Relê o config a
  * cada chamada, como os perfis.
  */
-export function fallbackStatus(primary, env) {
+export function fallbackStatus(primary, env, skip = []) {
+    const q = skip.includes(FALLBACK_PROFILE) ? { ready: false, reason: "o qwen já foi usado nesta troca" } : qwenStatus(primary, env);
+    if (q.ready)
+        return q;
+    const slm = slmFallbackStatus(primary, env, skip);
+    return slm.ready ? slm : q;
+}
+/** O SLM local como fallback: baixado (`brito slm pull`), habilitado e não é o próprio principal. */
+function slmFallbackStatus(primary, env, skip) {
+    if (skip.includes(SLM_MODEL))
+        return { ready: false, reason: "o SLM já foi usado nesta troca" };
+    if (primary.trim().toLowerCase() === SLM_MODEL)
+        return { ready: false, reason: "o modelo principal já é o SLM" };
+    if (env.BRITO_SLM_FALLBACK === "off")
+        return { ready: false, reason: "BRITO_SLM_FALLBACK=off" };
+    if (!slmReadySync())
+        return { ready: false, reason: "SLM local indisponível (rode `brito slm pull`)" };
+    return { ready: true, name: SLM_MODEL, label: resolveModel(SLM_MODEL).label };
+}
+function qwenStatus(primary, env) {
     const { profiles, errors, rejected } = loadProfiles();
     const p = profiles[FALLBACK_PROFILE];
     const label = p?.label;
@@ -36,6 +58,8 @@ export function pickEngine(model, env, hasCli) {
         const why = loadProfiles().errors.find((e) => e.toLowerCase().includes(`"${name}"`)) ?? "";
         return { kind: "error", message: `o perfil "${name}" em ~/.brito/config.json está inválido (${why}); corrija antes de usar` };
     }
+    if (r.local)
+        return slmReadySync() ? { kind: "api" } : { kind: "error", message: "o SLM local não está pronto: rode `brito slm pull`" };
     if (r.kind === "openai")
         return env[r.profile.apiKeyEnv]?.trim() ? { kind: "api" } : { kind: "error", message: missingKeyMessage(r.profile) };
     if (env.ANTHROPIC_API_KEY)
@@ -56,7 +80,7 @@ export function openEngine(model, env, hasCli) {
     if (e.kind !== "error" || resolveModel(model).kind !== "anthropic" || loadProfiles().rejected.includes(model.trim().toLowerCase()))
         return e;
     const s = fallbackStatus(model, env);
-    return s.ready ? { kind: "fallback", label: s.label } : { kind: "error", message: `${e.message}\nFallback (qwen) indisponível: ${s.reason}.` };
+    return s.ready ? { kind: "fallback", label: s.label, name: s.name } : { kind: "error", message: `${e.message}\nFallback (qwen) indisponível: ${s.reason}.` };
 }
 /**
  * Modelo de um subagente. BRITO_EXPLORE_MODEL manda no `explore`. Com o agente principal num endpoint, subagente

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. */