brito-cli 0.6.4 → 0.7.0

package/dist/cli.js

@@ -10,11 +10,14 @@ import "./tools/plan.js";
 import fs from "node:fs";
 import { PLAN_NOTE, perms } from "./permissions.js";
 import { loadProjectAgents, listAgents } from "./agent/agents.js";
-import { GraphLockedError, GraphStore } from "./graph/store.js";
+import { GraphLockedError, GraphStore, openGraphAfterClaude } from "./graph/store.js";
 import { indexProject } from "./graph/indexer.js";
-import { Agent, MODEL } from "./agent/loop.js";
-import { EFFORTS, MODEL_ALIASES, MODEL_HELP, effortLabel, initialEffort, isEffort, loadReasoningDisplay, parseModelArgs, saveEffort, saveModel, saveReasoningDisplay } from "./model.js";
-import { hasClaudeCli, ClaudeSession } from "./agent/claude-cli.js";
+import { 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 { 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 { serveMcp } from "./mcp/server.js";
 import "./tools/skills.js";
@@ -26,7 +29,7 @@ import { claudeCliComplete } from "./skills/learn-cli.js";
 import { buildSystemPrompt, graphStatsLine } from "./agent/prompt.js";
 import { allTools } from "./tools/registry.js";
 import { ui, c, fmtTokens } from "./ui/ui.js";
-import { runRepl } from "./repl.js";
+import { runRepl, switchableBackend } from "./repl.js";
 const pkgVersion = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 const program = new Command().name("brito").description("CLI de agentes de desenvolvimento com grafo de conhecimento").version(pkgVersion, "-v, --version", "mostra a versão").enablePositionalOptions();
 const rootOf = (o) => path.resolve(o.dir ?? process.cwd());
@@ -102,8 +105,12 @@ async function migrationAsk(q) {
 /** Sem API key: o `claude` oficial (login da assinatura) faz o modelo; grafo/memória/skills chegam via MCP. */
 /** Menus ↑↓+Enter do `/model`: modelo e depois escopo. null = cancelado. */
 async function pickModel(current) {
-    const models = Object.entries(MODEL_ALIASES);
-    const mi = await ui.select("modelo", models.map(([alias, id]) => ({ label: alias, hint: id === current ? `${id} (atual)` : id })), Math.max(0, models.findIndex(([, id]) => id === current)));
+    // Aliases do Claude e perfis de endpoint (o perfil é escolhido pelo nome; o id dele é detalhe do config).
+    const models = [
+        ...Object.entries(MODEL_ALIASES).map(([alias, id]) => [alias, id, id]),
+        ...Object.values(loadProfiles().profiles).map((p) => [p.name, p.name, p.label]),
+    ];
+    const mi = await ui.select("modelo", models.map(([alias, id, hint]) => ({ label: alias, hint: id === current ? `${hint} (atual)` : hint })), Math.max(0, models.findIndex(([, id]) => id === current)));
     if (mi === null)
         return null;
     const scopes = [
@@ -204,17 +211,28 @@ function reasoningCommand(get, set) {
         },
     };
 }
+/** `/fallback` (só leitura): modelo principal, o fallback qwen e o estado da troca. */
+function fallbackCommand(state, live, engine) {
+    return {
+        desc: "mostra o modelo principal e o fallback (qwen)",
+        run: async () => {
+            const primary = state.active ? state.primary : live();
+            for (const l of renderFallback(state, live(), engine(primary), fallbackStatus(primary, process.env)))
+                ui.print(l);
+        },
+    };
+}
 /**
  * `/model [nome|alias] [--global|--session|--once]` (mesma semântica do Hermes). Vale para os dois backends:
  * `get`/`set` leem e trocam o modelo vivo; `--once` devolve o anterior depois do turno (`restoreOnce`).
+ * `divert`: o modelo roda no outro motor (claude CLI ↔ modo API); ele troca o motor e devolve true.
  */
-function modelCommand(get, set, note) {
+function modelCommand(get, set, note, veto = () => null, divert) {
     let restore = null;
     return {
-        restoreOnce: () => { if (restore !== null) {
-            set(restore);
-            restore = null;
-        } },
+        /** `fallbackActive`: a troca automática aconteceu no turno; desfazer o `--once` levaria de volta ao Claude que caiu. */
+        restoreOnce: (fallbackActive = false) => { const r = onceRestore(restore, fallbackActive); restore = null; if (r !== null)
+            set(r); },
         cmd: {
             desc: "mostra/troca o modelo (--global grava, --once só o próximo turno)",
             run: async (args) => {
@@ -226,7 +244,7 @@ function modelCommand(get, set, note) {
                 }
                 if (!req.model) {
                     if (!ui.canSelect) {
-                        ui.print(`  ${c.soft(get())} ${c.muted(note)}\n  ${c.muted(MODEL_HELP)}`);
+                        ui.print(`  ${c.soft(get())} ${c.muted(note)}\n  ${c.muted(modelHelp())}`);
                         return;
                     }
                     const picked = await pickModel(get());
@@ -237,6 +255,13 @@ function modelCommand(get, set, note) {
                     req.model = picked.model;
                     req.scope = picked.scope;
                 }
+                if (divert && await divert(req.model, req.scope))
+                    return;
+                const refused = veto(req.model);
+                if (refused) {
+                    ui.warn(refused);
+                    return;
+                }
                 const old = get();
                 if (req.scope === "once")
                     restore ??= old; // dois --once seguidos devolvem o modelo original, não o intermediário
@@ -265,7 +290,7 @@ const skillsCommand = (root, io, llm) => ({
             ui.turnStart();
             let proposals;
             try {
-                proposals = await proposeConsolidation(root, llm.model, llm.complete);
+                proposals = await proposeConsolidation(root, llm.model(), llm.complete);
                 ui.turnEnd(false);
             }
             catch (e) {
@@ -348,8 +373,9 @@ const skillsCommand = (root, io, llm) => ({
     },
 });
 /** Reflexão pós-turno que propõe skills (gatilho automático ou `/learn`). Independe do backend: só muda a origem do turno e o modelo. */
-function makeLearner(getTurns, ctx, complete, model) {
+function makeLearner(getTurns, ctx, complete, getModel) {
     return async (force = false) => {
+        const model = getModel();
         const turns = getTurns();
         const turn = turns[turns.length - 1] ?? null;
         // O resultado do turno vira evidência para as skills usadas nele (promoção/arquivamento), antes de refletir.
@@ -387,19 +413,99 @@ function makeLearner(getTurns, ctx, complete, model) {
         }
     };
 }
-async function runViaClaude(root, promptParts, yes) {
-    const startedAt = Date.now();
-    if (yes)
-        perms.mode = "bypass";
-    // O REPL troca `io.ask`; em prompt único cai na pergunta simples.
-    const io = { ask: async (q, _opts) => perms.mode === "bypass" || plainAsk(q) };
-    const approval = startApprovalServer({ ask: (q, opts) => io.ask(q, opts) });
+/**
+ * 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.
+ */
+async function buildApiBackend(root, model, io, o = {}) {
+    const graph = o.graph ?? await GraphStore.open(root);
+    // A contagem do prompt acompanha cada sincronização: sem isso o modelo veria "0 símbolos" a sessão inteira
+    // em projeto que começou vazio e nasceu código depois.
+    let symCount = 0;
+    const sync = async () => { symCount = (await indexProject(root, graph)).symbols; };
+    ui.info("sincronizando grafo…");
+    await sync(); // incremental: barato quando nada mudou
+    const [{ n: notes }] = await graph.run("MATCH (s:Note) RETURN count(s) AS n");
+    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 });
+    if (o.messages)
+        agent.messages = o.messages;
+    if (o.effort)
+        agent.effort = o.effort;
+    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 turn = async (text, signal) => {
+        ui.turnStart();
+        let ok = true;
+        try {
+            await agent.send(text, signal);
+        }
+        catch (e) {
+            ok = false;
+            signal.aborted ? ui.warn("⏹ interrompido") : ui.error(e?.message ?? String(e));
+        }
+        finally {
+            ui.turnEnd(ok);
+        }
+        return ok;
+    };
+    // Sem ANTHROPIC_API_KEY o Claude não roda neste loop (sessão aberta no qwen): melhor recusar do que falhar no turno.
+    const noApiKey = (m) => (resolveModel(m).kind === "anthropic" && !process.env.ANTHROPIC_API_KEY?.trim()
+        ? `o ${m} precisa de ANTHROPIC_API_KEY neste modo; sem ela, reabra com \`brito --model ${m}\` para usar o claude CLI`
+        : null);
+    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,
+        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; },
+        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; }),
+            "/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": {
+                desc: "uso da janela de contexto",
+                run: async () => {
+                    const win = contextWindowFor(agent.model);
+                    const pct = Math.round((agent.contextTokens / win) * 100);
+                    ui.print(`  ${c.soft(`${fmtTokens(agent.contextTokens)} / ${fmtTokens(win)}`)} ${c.muted(`(${pct}%) · ${agent.messages.length} mensagens · compacta em ~${fmtTokens(compactAtFor(agent.model))}`)}`);
+                },
+            },
+            "/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 }),
+        },
+        close: async () => { await graph.close(); },
+    };
+    return { backend, agent, graph, learn, symbols: () => symCount, notes: noteCount };
+}
+/** `--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}`;
+/** Um servidor de aprovação por processo (o endereço leva o pid): o claude CLI pode ser aberto de novo na mesma sessão. */
+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) });
     // O banco aceita um único processo com acesso de escrita: indexa, lê as stats e solta o banco para o servidor MCP.
-    {
-        const { offerNoteMigration } = await import("./graph/migrate.js");
-        await offerNoteMigration(root, (q) => migrationAsk(q), (m) => ui.info(m));
-    }
-    const graph = await GraphStore.open(root);
+    // `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);
     ui.info("sincronizando grafo…");
     await indexProject(root, graph);
     const [{ n: syms }] = await graph.run("MATCH (s:Symbol) RETURN count(s) AS n");
@@ -407,23 +513,88 @@ async function runViaClaude(root, promptParts, yes) {
     await graph.close();
     const session = new ClaudeSession({
         // Foto da abertura: o índice é atualizado pelo servidor MCP (outro processo) e este processo não reabre o banco.
-        root, approvalSock: approval.path, stats: graphStatsLine(Number(syms), Number(notes), "start"),
+        root, approvalSock: approvalServer.path, stats: graphStatsLine(Number(syms), Number(notes), "start"),
         mcpCommand: { command: process.execPath, args: [...process.execArgv, process.argv[1], "mcp-serve", "-d", root] },
     });
     loadProjectAgents(root);
     // 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
-    if (promptParts.length) {
-        const ok = await session.send(promptParts.join(" "));
-        if (ok)
-            await learn();
-        else
-            process.exitCode = 1;
-        return;
+    const learn = makeLearner(() => session.recentTurns, learnCtx, claudeCliComplete, () => process.env.BRITO_LEARN_MODEL ?? ""); // "" = modelo padrão do claude
+    if (model) {
+        session.requestedModel = resolveModel(model).wireModel;
+        session.model = session.requestedModel;
     }
-    const modelCmd = modelCommand(() => session.requestedModel || session.model, (m) => { session.requestedModel = m; session.model = m; }, "(assinatura do claude CLI)");
     session.effort = initialEffort();
+    const fallback = newFallbackState(session.requestedModel || session.model);
+    /** Loop próprio do Brito no `name`, com a conversa do claude; `/model <claude>` nele volta para cá. */
+    const openApi = async (name, label, opts = {}) => {
+        let api;
+        try {
+            api = await buildApiBackend(root, name, io, {
+                fallback, effort: session.effort, loadedSkills: session.loadedSkills,
+                messages: historyForFallback(session.allTurns), graph: await openGraphAfterClaude(root), ...opts,
+                divert: async (m, scope) => {
+                    if (resolveModel(m).kind !== "anthropic")
+                        return false;
+                    if (scope === "once") {
+                        ui.warn(onceNoSwitch(m));
+                        return true;
+                    }
+                    sw().swap(backend);
+                    await api.backend.close();
+                    session.handoff(api.agent.unsentTurns.splice(0), api.agent.model);
+                    ui.info("de volta ao claude CLI: o que foi feito no modo API segue no próximo pedido");
+                    await modelCmd.cmd.run([m, `--${scope}`]);
+                    return true;
+                },
+            });
+        }
+        catch (e) {
+            ui.error(`não consegui abrir o ${label}: ${e?.message ?? e}`);
+            return null;
+        }
+        return api;
+    };
+    /**
+     * O turno do claude caiu por conta/capacidade: monta o loop próprio no qwen com a conversa do claude e refaz o pedido
+     * nele. null = a falha não leva ao fallback (ou ele não está pronto); a sessão segue no claude.
+     */
+    const switchToQwen = async (text, signal) => {
+        const status = fallbackStatus(fallback.primary, process.env);
+        const f = session.lastFailure;
+        if (!f || !status.ready || !cliShouldFallBack(f, fallback, status, signal.aborted))
+            return null;
+        ui.warn(fallbackWarning(f.kind, f.message, status.label));
+        const api = await openApi(status.name, status.label, { engineLabel: () => "claude CLI · assinatura" });
+        if (!api)
+            return null;
+        activateFallback(fallback, `${f.kind} (${f.message})`);
+        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. */
+    const toApi = async (m, scope) => {
+        const r = resolveModel(m);
+        if (r.kind !== "openai")
+            return false;
+        if (scope === "once") {
+            ui.warn(`o ${r.label} roda no modo API: --once não troca de motor; use /model ${r.name}`);
+            return true;
+        }
+        const old = session.requestedModel || session.model;
+        const api = await openApi(r.name, r.label);
+        if (!api)
+            return true;
+        modelCmd.restoreOnce(true); // um `--once` pendente devolveria o Claude depois do primeiro turno no outro motor
+        sw().swap(api.backend);
+        ui.print(`  ${c.muted(old)} → ${c.soft(r.name)}`);
+        ui.info(`modo API: o ${r.label} segue a conversa do claude`);
+        if (scope === "global") {
+            saveModel(r.name);
+            ui.print(c.muted("    salvo como padrão (~/.brito/config.json)"));
+        }
+        return true;
+    };
+    const modelCmd = modelCommand(() => session.requestedModel || session.model, (m) => { session.requestedModel = m; session.model = m; chooseModel(fallback, m); }, "(assinatura do claude CLI)", () => null, toApi);
     ui.reasoning = loadReasoningDisplay();
     const unavailable = { desc: "indisponível no modo claude CLI", run: async () => { ui.warn("não está disponível no modo claude CLI"); } };
     const mcpTools = allTools().map((t) => t.name).filter((n) => /^(graph_|skill_)/.test(n) || n === "remember" || n === "recall");
@@ -433,12 +604,22 @@ async function runViaClaude(root, promptParts, yes) {
         usage: () => session.usage,
         cost: () => (session.costUsd > 0 ? session.costUsd : undefined),
         get ctxWindow() { return session.contextWindow ?? CTX_WINDOW; },
-        turn: (text) => session.send(text),
+        turn: async (text, signal) => {
+            if (await session.send(text))
+                return true;
+            const fb = await switchToQwen(text, signal);
+            if (!fb)
+                return false;
+            modelCmd.restoreOnce(true); // um `--once` pendente voltaria ao Claude que acabou de cair
+            sw().swap(fb.api.backend);
+            return fb.retry();
+        },
         afterTurn: async () => { modelCmd.restoreOnce(); await learn(); },
         abort: () => session.abort(),
         reset: () => session.reset(),
         commands: {
             "/model": modelCmd.cmd,
+            "/fallback": fallbackCommand(fallback, () => session.model, () => "claude CLI · assinatura"),
             "/effort": effortCommand(() => session.effort, (e) => { session.effort = e; }),
             "/reasoning": reasoningCommand(() => session.effort, (e) => { session.effort = e; }),
             "/tools": { desc: "ferramentas do grafo/memória/skills", run: async () => { for (const n of mcpTools)
@@ -454,16 +635,49 @@ async function runViaClaude(root, promptParts, yes) {
             },
             "/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: claudeCliComplete, model: () => process.env.BRITO_LEARN_MODEL ?? "" }),
         },
         close: async () => { },
     };
+    return { backend, session, learn, switchToQwen, modelCmd, syms: Number(syms), notes: Number(notes), mcpTools };
+}
+async function runViaClaude(root, promptParts, yes, model) {
+    const startedAt = Date.now();
+    if (yes)
+        perms.mode = "bypass";
+    // O REPL troca `io.ask`; em prompt único cai na pergunta simples.
+    const io = { ask: async (q, _opts) => perms.mode === "bypass" || plainAsk(q) };
+    {
+        const { offerNoteMigration } = await import("./graph/migrate.js");
+        await offerNoteMigration(root, (q) => migrationAsk(q), (m) => ui.info(m));
+    }
+    let sw;
+    const claude = await buildClaudeBackend(root, io, () => sw, model);
+    if (promptParts.length) {
+        const text = promptParts.join(" ");
+        if (await claude.session.send(text)) {
+            await claude.learn();
+            return;
+        }
+        const fb = await claude.switchToQwen(text, new AbortController().signal);
+        if (!fb) {
+            process.exitCode = 1;
+            return;
+        }
+        if (await fb.retry())
+            await fb.api.learn();
+        else
+            process.exitCode = 1;
+        await fb.api.backend.close();
+        return;
+    }
+    sw = switchableBackend(claude.backend);
     ui.info("modo claude CLI: usa o login da sua conta; tools do grafo/memória/skills via MCP.");
-    await runRepl(backend, {
+    await runRepl(sw, {
         root, yes, startedAt, io,
         banner: {
-            dir: root, symbols: Number(syms), notes: Number(notes),
-            tools: ["read_file", "write_file", "edit_file", "glob", "grep", "bash", "delegate", ...mcpTools],
+            dir: root, symbols: claude.syms, notes: claude.notes,
+            tools: ["read_file", "write_file", "edit_file", "glob", "grep", "bash", "delegate", ...claude.mcpTools],
             skills: skillInfo(root), agents: listAgents().map((a) => a.name),
         },
     });
@@ -472,6 +686,7 @@ program
     .argument("[prompt...]", "prompt único (omita para modo interativo)")
     .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)")
     .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.
@@ -479,12 +694,16 @@ program
         console.error("brito aninhado demais (BRITO_DEPTH): abortando para evitar laço de processos.");
         process.exit(1);
     }
-    if (!process.env.ANTHROPIC_API_KEY) {
-        if (!hasClaudeCli()) {
-            console.error(c.err("Defina ANTHROPIC_API_KEY ou instale o Claude Code e rode `claude` → /login."));
-            process.exit(1);
-        }
-        await runViaClaude(rootOf(o), promptParts, !!o.yes);
+    for (const e of loadProfiles().errors)
+        ui.warn(e);
+    const startModel = o.model ?? initialModel();
+    const engine = openEngine(startModel, process.env, hasClaudeCli);
+    if (engine.kind === "error") {
+        console.error(c.err(engine.message));
+        process.exit(1);
+    }
+    if (engine.kind === "claude") {
+        await runViaClaude(rootOf(o), promptParts, !!o.yes, o.model);
         return;
     }
     const root = rootOf(o);
@@ -493,78 +712,60 @@ program
         const { offerNoteMigration } = await import("./graph/migrate.js");
         await offerNoteMigration(root, (q) => migrationAsk(q), (m) => ui.info(m));
     }
-    const graph = await GraphStore.open(root);
-    // A contagem do prompt acompanha cada sincronização: sem isso o modelo veria "0 símbolos" a sessão inteira
-    // em projeto que começou vazio e nasceu código depois.
-    let symCount = 0, noteCount = 0;
-    const sync = async () => { symCount = (await indexProject(root, graph)).symbols; };
-    ui.info("sincronizando grafo…");
-    await sync(); // incremental: barato quando nada mudou
-    const [{ n: notes }] = await graph.run("MATCH (s:Note) RETURN count(s) AS n");
-    noteCount = Number(notes);
     // `io.ask` é substituída pelo REPL (dock); em prompt único cai na pergunta simples.
     if (o.yes)
         perms.mode = "bypass";
     const io = { ask: async (q, _opts) => perms.mode === "bypass" || plainAsk(q) };
-    const ctx = { root, graph, ask: (q, opts) => io.ask(q, opts), sync, dirty: false, loadedSkills: new Set() };
-    // 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);
-    loadProjectAgents(root);
-    /** Depois de tarefas complexas (ou uso de skill), propõe criar/melhorar skills. */
-    const learn = makeLearner(() => agent.recentTurns, ctx, defaultComplete, process.env.BRITO_LEARN_MODEL ?? MODEL);
-    const turn = async (text, signal) => {
-        ui.turnStart();
-        let ok = true;
-        try {
-            await agent.send(text, signal);
-        }
-        catch (e) {
-            ok = false;
-            signal.aborted ? ui.warn("⏹ interrompido") : ui.error(e?.message ?? String(e));
-        }
-        finally {
-            ui.turnEnd(ok);
-        }
-        return ok;
-    };
+    // Claude sem conta nenhuma, com o fallback pronto: a sessão já nasce no qwen (com aviso, nunca em silêncio).
+    let opening = {};
+    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 };
+    }
+    let sw;
+    // Sem ANTHROPIC_API_KEY o Claude só roda no claude CLI: `/model <claude>` troca o motor em vez de recusar.
+    // A conversa feita aqui vai junto (`handoff`); o claude CLI aberto é reaproveitado nas voltas seguintes.
+    let claude = null;
+    if (hasClaudeCli())
+        opening.divert = async (m, scope) => {
+            if (resolveModel(m).kind !== "anthropic" || process.env.ANTHROPIC_API_KEY?.trim())
+                return false;
+            if (scope === "once") {
+                ui.warn(onceNoSwitch(m));
+                return true;
+            }
+            // Indexa com o grafo ainda aberto e só o solta (para o servidor MCP do claude) se tudo deu certo: numa falha,
+            // a sessão segue no modo API com o grafo vivo.
+            if (claude)
+                await api.backend.close();
+            else
+                try {
+                    claude = await buildClaudeBackend(root, io, () => sw, undefined, api.graph);
+                }
+                catch (e) {
+                    ui.error(`não consegui abrir o claude CLI: ${e?.message ?? e}`);
+                    return true;
+                }
+            sw.swap(claude.backend);
+            claude.session.handoff(api.agent.unsentTurns.splice(0), api.agent.model);
+            ui.info("modo claude CLI: usa o login da sua conta; a conversa feita no modo API segue no próximo pedido");
+            await claude.modelCmd.cmd.run([m, `--${scope}`]);
+            return true;
+        };
+    const api = await buildApiBackend(root, engine.kind === "fallback" ? FALLBACK_PROFILE : startModel, io, opening);
     if (promptParts.length) {
-        if (await turn(promptParts.join(" "), new AbortController().signal))
-            await learn();
-        await graph.close();
+        if (await api.backend.turn(promptParts.join(" "), new AbortController().signal))
+            await api.learn();
+        await api.backend.close();
         return;
     }
-    const modelCmd = modelCommand(() => agent.model, (m) => { agent.model = m; }, "(troque com /model; subagentes explore usam BRITO_EXPLORE_MODEL)");
-    const backend = {
-        model: () => agent.model,
-        contextTokens: () => agent.contextTokens,
-        usage: () => agent.usage,
-        ctxWindow: CTX_WINDOW,
-        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(); await learn(); },
-        reset: () => { agent.messages = []; agent.contextTokens = 0; agent.recentTurns = []; agent.lastTurn = null; },
-        onShell: () => { ctx.dirty = true; }, // `!cmd` pode ter mudado o código
-        commands: {
-            "/model": modelCmd.cmd,
-            "/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": {
-                desc: "uso da janela de contexto",
-                run: async () => {
-                    const pct = Math.round((agent.contextTokens / CTX_WINDOW) * 100);
-                    ui.print(`  ${c.soft(`${fmtTokens(agent.contextTokens)} / ${fmtTokens(CTX_WINDOW)}`)} ${c.muted(`(${pct}%) · ${agent.messages.length} mensagens · compacta em ~${fmtTokens(Number(process.env.BRITO_COMPACT_TOKENS ?? 120_000))}`)}`);
-                },
-            },
-            "/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: process.env.BRITO_LEARN_MODEL ?? MODEL }),
-        },
-        close: async () => { await graph.close(); },
-    };
-    await runRepl(backend, {
+    sw = switchableBackend(api.backend);
+    await runRepl(sw, {
         root, yes: !!o.yes, startedAt, io,
         banner: {
-            dir: root, symbols: symCount, notes: noteCount, tools: allTools().map((t) => t.name),
+            dir: root, symbols: api.symbols(), notes: api.notes, tools: allTools().map((t) => t.name),
             skills: skillInfo(root), agents: listAgents().map((a) => a.name),
         },
     });