brito-cli 0.8.0 → 0.9.0

package/dist/desktop/serve.js

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

package/dist/graph/migrate.js

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

package/dist/mcp/server.js

@@ -5,6 +5,12 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import "../tools/graph.js";
 import "../tools/skills.js";
+// O implementador do modo orquestrador roda aqui e edita/roda comandos; fs e bash só existem para ele (não são expostos).
+import "../tools/fs.js";
+import "../tools/bash.js";
+import { implementIo } from "../tools/implement.js";
+import "../tools/spec.js";
+import { ORCH_ONLY, orch } from "../orchestrator.js";
 import "../tools/digest.js";
 import { allTools, execTool } from "../tools/registry.js";
 import { GraphStore } from "../graph/store.js";
@@ -28,13 +34,16 @@ export const MCP_INSTRUCTIONS = [
  * tools de consulta, que são baratas e de uso frequente. As de escrita e a de aprovação (interna) continuam adiadas.
  */
 export const ALWAYS_LOAD_META = "anthropic/alwaysLoad";
-export const alwaysLoaded = (tool) => /^(graph_|recall$|remember$|skill_load$|digest$)/.test(tool);
+export const alwaysLoaded = (tool) => /^(graph_|recall$|remember$|skill_load$|digest$|implement$)/.test(tool);
 /** Prefixo com que o claude CLI enxerga as tools deste servidor. */
 export const MCP_PREFIX = `mcp__${MCP_NAME}__`;
 /** Tool usada como --permission-prompt-tool: encaminha o pedido ao REPL do Brito. */
 export const APPROVE_TOOL = "approve";
 // fs/bash/delegate o próprio claude já tem (Read/Edit/Bash/Task); aqui vai só o que é do Brito.
-const exposed = () => allTools().filter((t) => /^(graph_|skill_)/.test(t.name) || t.name === "remember" || t.name === "recall" || t.name === "digest");
+/** Tools que o claude enxerga; `implement` e `spec_save` só com o modo orquestrador ligado (BRITO_ORCH=1). */
+export const exposed = () => allTools().filter((t) => /^(graph_|skill_)/.test(t.name) || t.name === "remember" || t.name === "recall" || t.name === "digest" || (ORCH_ONLY.includes(t.name) && orch.on));
+/** Nome do pedido de aprovação de uma ação do implementador (o terminal mostra só a pergunta). */
+export const IMPL_ASK = "BritoImplementer";
 /** Pergunta ao REPL (socket unix) se o claude pode usar a tool; sem socket, nega. */
 function askRepl(toolName, input) {
     const sock = process.env.BRITO_APPROVE_SOCK;
@@ -78,7 +87,28 @@ export async function serveMcp(root) {
                 ...(alwaysLoaded(t.name) ? { _meta: { [ALWAYS_LOAD_META]: true } } : {}),
             }))],
     }));
-    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    /**
+     * O claude aprovou a chamada de `implement`, não cada edição dentro dela: as do implementador pedem aprovação ao
+     * terminal pelo mesmo socket, conforme o modo. O progresso vai como notificação MCP (o stdout daqui é o protocolo).
+     */
+    const runImplement = async (args, extra, token) => {
+        let step = 0;
+        implementIo.log = (msg) => {
+            if (token === undefined) {
+                process.stderr.write(msg + "\n");
+                return;
+            }
+            extra.sendNotification({ method: "notifications/progress", params: { progressToken: token, progress: ++step, message: msg } }).catch(() => { });
+        };
+        const warn = (msg) => implementIo.log(msg);
+        implementIo.sink = { turnStart() { }, turnEnd() { }, text() { }, textEnd() { }, thinking() { }, toolStart() { }, toolEnd() { }, info: warn, warn, error: warn };
+        // Quem chama este servidor é sempre o claude CLI: o principal é um Claude, não o modelo salvo no config.
+        const implCtx = { ...ctx, ask: async (q) => (await askRepl(IMPL_ASK, { question: q })).allow, model: () => "claude" };
+        const r = await execTool("implement", args, implCtx);
+        ctx.dirty = true; // o implementador editou arquivos: a próxima consulta ao grafo reindexa
+        return r.isError ? `[ERRO] ${r.text}` : r.text;
+    };
+    server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
         if (req.params.name === APPROVE_TOOL) {
             const a = (req.params.arguments ?? {});
             const r = await askRepl(String(a.tool_name ?? "?"), a.input ?? {});
@@ -88,6 +118,8 @@ export async function serveMcp(root) {
         if (!exposed().some((t) => t.name === req.params.name)) {
             return { content: [{ type: "text", text: `Tool desconhecida: ${req.params.name}` }], isError: true };
         }
+        if (req.params.name === "implement")
+            return { content: [{ type: "text", text: await runImplement(req.params.arguments ?? {}, extra, req.params._meta?.progressToken) }] };
         const r = await execTool(req.params.name, req.params.arguments ?? {}, ctx);
         return { content: [{ type: "text", text: r.text }], isError: r.isError };
     });

package/dist/model.js

@@ -30,6 +30,27 @@ function saveConfig(patch) {
     writeFileSync(configPath(), JSON.stringify({ ...cfg, ...patch }, null, 2) + "\n");
 }
 export const saveModel = (model) => saveConfig({ model });
+/** Perfil que implementa as tasks no modo orquestrador (`implModel` no config). */
+export function loadSavedImplModel() {
+    try {
+        const m = JSON.parse(readFileSync(configPath(), "utf8"))?.implModel;
+        return typeof m === "string" && m.trim() ? m.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const saveImplModel = (implModel) => saveConfig({ implModel });
+/** Modo orquestrador ligado ao abrir o Brito (`orchestrator: true` no config, gravado por `/orquestrar on --global`). */
+export function loadSavedOrch() {
+    try {
+        return JSON.parse(readFileSync(configPath(), "utf8"))?.orchestrator === true;
+    }
+    catch {
+        return false;
+    }
+}
+export const saveOrch = (orchestrator) => saveConfig({ orchestrator });
 /**
  * Escada de esforço do Hermes (EFFORT_LADDER, do mais fraco ao mais forte). `none` desliga o raciocínio;
  * `minimal` e `ultra` são internos: o claude CLI não os aceita, então `clampEffort` os mapeia.

package/dist/orchestrator.js

@@ -0,0 +1,131 @@
+import { allTools } from "./tools/registry.js";
+import { loadProfiles, loadSavedImplModel, loadSavedOrch } from "./model.js";
+import { missingKeyMessage } from "./provider/openai-compat.js";
+import { resolveModel } from "./provider/resolve.js";
+// Modo orquestrador: o modelo principal (Claude) planeja e revisa; um perfil de endpoint (o qwen) implementa cada task
+// pela tool `implement`. Estado global da sessão, como o `perms`.
+/** Prioridade: BRITO_IMPL_MODEL > config global (`implModel`) > qwen. */
+export const initialImplModel = () => process.env.BRITO_IMPL_MODEL?.trim() || loadSavedImplModel() || "qwen";
+/** No servidor MCP (outro processo) o modo vem ligado pelo env; no REPL e no app começa desligado. */
+export const orch = { on: process.env.BRITO_ORCH === "1", model: initialImplModel() };
+/** Edição de arquivo fica só com o implementador; o principal lê, delega e verifica (bash continua para os testes). */
+export const ORCH_BLOCKED = ["write_file", "edit_file"];
+/** Tools que só existem com o modo ligado: a delegação e a gravação da spec/tasks em spec/. */
+export const ORCH_ONLY = ["implement", "spec_save"];
+/**
+ * Tools do agente principal. Desligado: todas menos as do modo (`implement`, `spec_save`). Ligado: sem as de edição. Função: o modo muda no meio
+ * da sessão e o loop relê a lista a cada passo.
+ */
+export function mainTools() {
+    const hidden = orch.on ? ORCH_BLOCKED : ORCH_ONLY;
+    return new Set(allTools().map((t) => t.name).filter((n) => !hidden.includes(n)));
+}
+/**
+ * O implementador está pronto? Só um perfil de endpoint válido, com a chave no ambiente, e diferente do principal
+ * (o qwen orquestrando o qwen não ganha nada). Relê o config a cada chamada, como os perfis.
+ */
+export function implStatus(main, impl, env) {
+    const name = impl.trim().toLowerCase();
+    if (main.trim().toLowerCase() === name)
+        return { ready: false, reason: `o modelo principal já é o ${impl}` };
+    const { profiles, errors, rejected } = loadProfiles();
+    if (rejected.includes(name)) {
+        const why = errors.find((e) => e.toLowerCase().includes(`"${name}"`)) ?? "";
+        return { ready: false, reason: `o perfil "${name}" em ~/.brito/config.json está inválido (${why})` };
+    }
+    const p = profiles[name];
+    if (!p || resolveModel(name).kind !== "openai")
+        return { ready: false, reason: `sem perfil "${name}" em providers no ~/.brito/config.json` };
+    if (!env[p.apiKeyEnv]?.trim())
+        return { ready: false, reason: missingKeyMessage(p) };
+    return { ready: true, label: p.label };
+}
+/**
+ * Desliga o modo quando o implementador deixa de estar pronto para o principal `main` (fallback ou `/model` para o
+ * próprio qwen, chave removida…). Nunca em silêncio: o motivo vai para `warn`.
+ */
+export function orchGuard(main, warn) {
+    if (!orch.on)
+        return;
+    const s = implStatus(main, orch.model, process.env);
+    if (s.ready)
+        return;
+    orch.on = false;
+    warn(`modo orquestrador desligado: ${s.reason}`);
+}
+/**
+ * Ao abrir o REPL ou o app: liga o modo se ele foi salvo com `/orquestrar on --global`. Se o implementador não estiver
+ * pronto para o principal `main`, fica desligado e o motivo vai para `warn`. O servidor MCP não usa: lá o modo vem do env.
+ */
+export function restoreOrch(main, warn, info) {
+    if (orch.on || !loadSavedOrch())
+        return;
+    const s = implStatus(main, orch.model, process.env);
+    if (!s.ready) {
+        warn(`modo orquestrador salvo como ligado, mas não ligou: ${s.reason}`);
+        return;
+    }
+    orch.on = true;
+    info(`modo orquestrador ligado (salvo): ${main} planeja e revisa, ${s.label} implementa`);
+}
+/** O servidor MCP roda em outro processo (subido pelo claude CLI a cada turno): o modo e o perfil chegam pelo env. */
+export const ORCH_ENV = "BRITO_ORCH";
+/** Env do servidor MCP: liga a tool `implement` lá e diz qual perfil implementa. */
+export const orchEnv = () => (orch.on ? { [ORCH_ENV]: "1", BRITO_IMPL_MODEL: orch.model } : {});
+/** Uma task do implementador leva minutos: o timeout padrão do claude CLI para tools MCP cortaria no meio (30 min). */
+export const ORCH_MCP_TIMEOUT = "1800000";
+/** Tools nativas do claude CLI que editam arquivos: bloqueadas com o modo ligado. */
+export const CLAUDE_EDIT_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit"];
+/** Acrescentado ao system prompt do agente principal enquanto o modo está ligado. */
+export const ORCH_NOTE = `
+
+# MODO ORQUESTRADOR ATIVO
+Você planeja e revisa; quem implementa é outro modelo, pela tool implement. Você não tem write_file nem edit_file: sua única escrita é spec_save, que grava em spec/<feature>/.
+- Divida o pedido em tasks pequenas e independentes e mande UMA por chamada de implement, em ordem.
+- Antes da primeira chamada de implement, grave com spec_save (feature = slug curto do pedido):
+  - spec.md: objetivo, contexto, requisitos, contratos que não podem mudar, fora de escopo e riscos;
+  - tasks.md: lista numerada de tasks como checklist (\`- [ ] 1. título\`), cada uma com objetivo, arquivos, critério de pronto e comando de verificação.
+  Depois mostre ao usuário o caminho dos dois arquivos e um resumo da lista, e encerre a resposta pedindo aprovação. Só delegue depois que ele aprovar, seguindo o tasks.md aprovado.
+- Se o usuário pedir mudanças, ou se for preciso mudar a lista no meio do caminho (task nova, ordem diferente), atualize spec.md/tasks.md com spec_save e peça aprovação de novo antes de seguir. Não precisa pedir de novo se o usuário acabou de aprovar um plano com essas mesmas tasks (modo plano).
+- Ao mandar uma task ao implement, cite o caminho da spec (spec/<feature>/spec.md) para ele consultar, mas mantenha a task autocontida.
+- Quando uma task passar na sua revisão, marque-a como feita no tasks.md (\`- [x]\`) com spec_save; se ficar pendente, anote o motivo embaixo dela.
+- O implementador não vê esta conversa: cada task precisa trazer objetivo, arquivos e símbolos envolvidos, contratos que não podem mudar, critério de pronto e o comando de verificação (\`verify\`). Passe \`focus\` com os símbolos centrais.
+- O resultado traz o relato do implementador, o git status/diff e a saída da verificação, rodada pela própria tool. Julgue pelo diff e pela verificação, não pelo relato: leia os trechos alterados quando precisar.
+- Se a task ficou errada ou incompleta, chame implement de novo com o que está errado e o que fazer. No máximo 2 reenvios por task; depois disso, explique ao usuário o que falta.
+- Ao final, resuma o que foi feito, o que a verificação provou e o que ficou pendente, e aponte o tasks.md atualizado.`;
+/** Complemento do ORCH_NOTE no claude CLI, onde os nomes das tools são outros. */
+export const ORCH_NOTE_CLAUDE = `
+- Nesta sessão as tools chegam como mcp__brito__implement e mcp__brito__spec_save; Edit, Write, MultiEdit e NotebookEdit estão bloqueadas. Não use Bash para escrever arquivos: isso também é trabalho do implementador.`;
+/** Prompt do subagente que implementa: escopo fechado, verificação obrigatória e uma resposta que dá para conferir. */
+const IMPLEMENTER_PROMPT = `Você implementa UMA task, descrita no pedido. Você não vê a conversa do orquestrador: tudo que precisa está no pedido.
+
+# Escopo
+- Faça só o que a task pede. Não refatore, não renomeie e não "melhore" código fora dela.
+- Não invente arquivo, classe, API ou requisito. Se algo do pedido não existir no projeto, pare e diga isso em PENDENTE.
+- Não mude contratos existentes (assinaturas, rotas, formato de resposta) sem que o pedido mande.
+- Não apague nem enfraqueça testes para a verificação passar.
+
+# Como trabalhar
+- Comece pelo grafo (graph_context / graph_callers) dos símbolos citados; leia só as linhas apontadas.
+- Antes de criar um arquivo novo, abra um arquivo existente do mesmo tipo e siga a estrutura dele.
+- Comportamento novo ganha teste, no estilo dos testes que já existem.
+
+# Verificação
+- Rode o comando de verificação do pedido (ou o de testes do projeto). Pronto é o que ele prova.
+- Se falhar por causa do código: leia só a parte relevante do erro, corrija e rode de novo. No máximo 3 tentativas.
+- Se falhar por ambiente (serviço fora do ar, porta ocupada), não tente consertar: registre e siga.
+
+# Resposta final
+Responda só com:
+FEITO: arquivos criados ou alterados, um por linha
+VERIFICAÇÃO: comando rodado e resultado (passou / falhou / não rodou e por quê)
+PENDENTE: o que faltou, ou "nada"`;
+/** Fora do registro de agentes: não aparece no `delegate` nem vira subagente do claude CLI; só a tool `implement` o usa. */
+export const IMPLEMENTER = {
+    name: "implementer",
+    description: "Implementa uma task bem especificada (edita arquivos e roda a verificação).",
+    tools: "all",
+    get model() { return orch.model; },
+    prompt: IMPLEMENTER_PROMPT,
+    source: "builtin",
+};

package/dist/permissions.js

@@ -19,9 +19,9 @@ export const MODE_LABEL = {
     bypass: { icon: "⚡", name: "tudo liberado", hint: "executa tudo sem perguntar" },
 };
 /** Acrescentado ao system prompt do backend de API enquanto o modo plano está ativo. */
-export const PLAN_NOTE = `
-
-# MODO PLANO ATIVO
+export const PLAN_NOTE = `
+
+# MODO PLANO ATIVO
 Você só pode ler, pesquisar e consultar o grafo. Edições e comandos shell estão bloqueados. Investigue, monte um plano concreto (arquivos, mudanças, riscos, como verificar) e chame exit_plan com ele. Só execute depois que o usuário aprovar.`;
 /** Texto do pedido de permissão para uma tool do claude CLI (Bash, Edit, Write…). Primeira linha = resumo. */
 export function describeClaudeTool(name, input) {
@@ -34,6 +34,10 @@ export function describeClaudeTool(name, input) {
         case "MultiEdit": return `editar ${i.file_path} (${(i.edits ?? []).length} trocas)`;
         case "NotebookEdit": return `editar notebook ${i.notebook_path}`;
         case "ExitPlanMode": return `plano proposto — aprovar e sair do modo plano?\n${String(i.plan ?? "")}`;
+        // Ação do implementador do modo orquestrador (servidor MCP): a pergunta já vem montada pelo Brito.
+        case "BritoImplementer": return `implementador · ${String(i.question ?? "")}`;
+        case "mcp__brito__spec_save": return `gravar spec/${String(i.feature ?? "?")}/${String(i.file ?? "?")} (${String(i.content ?? "").length} chars)`;
+        case "mcp__brito__implement": return `delegar ao implementador: ${one(i.task, 300)}${i.verify ? `\n  verificação: ${one(i.verify)}` : ""}`;
         default: return `${name}: ${one(JSON.stringify(i), 200)}`;
     }
 }

package/dist/repl.js

@@ -20,6 +20,7 @@ const userName = () => {
 import { listPending, listSkills, listBuiltins, getSkill, suggestSkills, deleteSkill, promoteSkill, globalHome } from "./skills/store.js";
 import { listAgents } from "./agent/agents.js";
 import { perms, cycleMode, MODE_LABEL } from "./permissions.js";
+import { orch } from "./orchestrator.js";
 /**
  * Backend com o motor substituível no meio da sessão (claude CLI → qwen): o REPL monta o menu uma vez, então os
  * comandos ficam estáveis e o que o motor atual não tem responde "indisponível". `usage`/`cost` somam todos os
@@ -93,7 +94,10 @@ export async function runRepl(b, o) {
         ...Object.entries(COMMON).map(([name, desc]) => ({ name, desc })),
     ].sort((x, y) => x.name.localeCompare(y.name));
     const modeColor = { manual: c.muted, auto: c.ok, plan: c.warn, bypass: c.err };
-    const modeChip = () => { const m = MODE_LABEL[perms.mode]; return modeColor[perms.mode](`${m.icon} ${m.name}`); };
+    const modeChip = () => {
+        const m = MODE_LABEL[perms.mode];
+        return modeColor[perms.mode](`${m.icon} ${m.name}`) + (orch.on ? c.ok(` ⚙ →${orch.model}`) : "");
+    };
     const status = () => ui.statusLine({
         project: path.basename(o.root),
         mode: modeChip(),