brito-cli 0.8.0 → 0.9.0

package/dist/agent/claude-cli.js

@@ -7,6 +7,7 @@ import { skillsIndex } from "../skills/store.js";
 import { MCP_NAME, MCP_PREFIX, APPROVE_TOOL } from "../mcp/server.js";
 import { ui as terminalUi } from "../ui/ui.js";
 import { MODE_ENV, perms } from "../permissions.js";
+import { CLAUDE_EDIT_TOOLS, ORCH_MCP_TIMEOUT, ORCH_NOTE, ORCH_NOTE_CLAUDE, orch, orchEnv } from "../orchestrator.js";
 import { DEFAULT_MODEL, wireEffort } from "../model.js";
 import { subagentModel } from "../engine.js";
 import { claudeCommand } from "../util/platform.js";
@@ -211,11 +212,13 @@ export class ClaudeSession {
     aborted = false;
     args(text, imageDirs = []) {
         const { root, approvalSock, stats, mcpCommand } = this.o;
-        const mcp = mcpConfig(mcpCommand, approvalSock, perms.mode, this.o.env);
+        // O modo orquestrador vale por turno, como o de permissão: o servidor MCP do turno sobe com ele no env.
+        const mcp = mcpConfig(mcpCommand, approvalSock, perms.mode, { ...this.o.env, ...orchEnv() });
         const readOnlyMcp = ["graph_search", "graph_callers", "graph_callees", "graph_impact", "graph_context", "graph_query", "graph_index", "remember", "recall", "skill_load", "digest"];
         const system = buildSystemPrompt(root, stats, skillsIndex(root)) +
             `\n\n# Nesta sessão\nAs tools do Brito chegam com o prefixo \`${MCP_PREFIX}\` (ex.: ${MCP_PREFIX}graph_context). Use-as como descrito acima. ` +
-            `read_file/grep/glob/edit_file/bash correspondem a Read/Grep/Glob/Edit/Bash, e \`delegate\` corresponde à tool Agent/Task com os subagentes configurados (explore, plan, general e os do projeto).`;
+            `read_file/grep/glob/edit_file/bash correspondem a Read/Grep/Glob/Edit/Bash, e \`delegate\` corresponde à tool Agent/Task com os subagentes configurados (explore, plan, general e os do projeto).` +
+            (orch.on ? ORCH_NOTE + ORCH_NOTE_CLAUDE : "");
         const args = [
             "-p", text,
             this.started ? "--resume" : "--session-id", this.id,
@@ -234,6 +237,8 @@ export class ClaudeSession {
         // O modo vale por turno: Shift+Tab no REPL muda o próximo turno.
         const mode = { manual: "default", auto: "acceptEdits", plan: "plan", bypass: "bypassPermissions" }[perms.mode];
         args.push("--permission-mode", mode);
+        if (orch.on)
+            args.push("--disallowedTools", ...CLAUDE_EDIT_TOOLS);
         if (perms.mode !== "bypass") {
             args.push("--allowedTools", ...readOnlyMcp.map((n) => MCP_PREFIX + n), "--permission-prompt-tool", `${MCP_PREFIX}${APPROVE_TOOL}`);
         }
@@ -255,7 +260,8 @@ export class ClaudeSession {
             const child = (this.child = spawn(cmd.command, cmd.args, {
                 cwd: this.o.root, stdio: ["ignore", "pipe", "pipe"],
                 // `/reasoning none`: o claude desliga o raciocínio com MAX_THINKING_TOKENS=0 (não há `--effort none`)
-                env: { ...process.env, ...this.o.env, BRITO_DEPTH: String(Number(process.env.BRITO_DEPTH ?? 0) + 1), ...(wireEffort(this.effort).thinking ? {} : { MAX_THINKING_TOKENS: "0" }) },
+                env: { ...process.env, ...this.o.env, BRITO_DEPTH: String(Number(process.env.BRITO_DEPTH ?? 0) + 1),
+                    ...(orch.on && !process.env.MCP_TOOL_TIMEOUT ? { MCP_TOOL_TIMEOUT: ORCH_MCP_TIMEOUT } : {}), ...(wireEffort(this.effort).thinking ? {} : { MAX_THINKING_TOKENS: "0" }) },
             }));
             let buf = "", stderr = "", ok = true, interrupted = false;
             const failure = { stderr: "", code: null };

package/dist/agent/loop.js

@@ -7,6 +7,7 @@ import { compactAtFor, resolveModel } from "../provider/resolve.js";
 import { fallbackStatus } from "../engine.js";
 import { activateFallback, classifyAnthropicError, fallbackExpired, fallbackUntil, fallbackWarning, returnToPrimary, shortError, triggersFallback } from "../provider/fallback.js";
 import { fmtBytes, findImages, imageBlock, splitOversize } from "../util/images.js";
+import { orchGuard } from "../orchestrator.js";
 export const MODEL = initialModel();
 export class Agent {
     system;
@@ -117,7 +118,8 @@ export class Agent {
                 const t0 = Date.now();
                 if (!this.opts.quiet)
                     this.ui.toolStart(u.id, u.name, u.input);
-                const denied = this.opts.tools && !this.opts.tools.has(u.name);
+                const allow = this.allowed();
+                const denied = allow && !allow.has(u.name);
                 const r = denied ? { text: `Tool não permitida para este agente: ${u.name}`, isError: true } : await execTool(u.name, u.input, this.ctx);
                 if (this.opts.quiet)
                     this.log(terminalUi.toolLine(u.name, u.input, Date.now() - t0, r.isError));
@@ -152,7 +154,7 @@ export class Agent {
                 // write_file grande não é mais cortado no meio.
                 maxTokens: target.kind === "openai" ? (thinking ? 16_384 : 8192) : 32_000,
                 system: typeof this.system === "function" ? this.system() : this.system,
-                tools: toApiTools(this.opts.tools),
+                tools: toApiTools(this.allowed()),
                 messages: this.messages,
                 thinking,
                 effort: this.effort,
@@ -179,10 +181,14 @@ export class Agent {
             this.ui.warn(fallbackWarning(kind, why, status.label, until));
             activateFallback(fb, `${kind} (${why})`, Date.now(), until, status.name);
             this.model = status.name;
+            orchGuard(this.model, (m) => this.ui.warn(m)); // o qwen virou o principal: não há mais a quem delegar
             await this.compactIfNeeded();
             return this.callModel(hooks);
         }
     }
+    allowed() {
+        return typeof this.opts.tools === "function" ? this.opts.tools() : this.opts.tools;
+    }
     /**
      * Fallback temporário: passada a janela, o próximo turno tenta o Claude de novo (se falhar, `callModel` reativa o
      * fallback com uma janela nova). Só com ANTHROPIC_API_KEY: sem ela o Claude não roda neste loop (volta via /model).

package/dist/agent/prompt.js

@@ -23,22 +23,22 @@ export function buildSystemPrompt(root, graphStats, skills = "") {
             break;
         }
     }
-    return `Você é Brito, um agente de engenharia de software que trabalha em CLI. Responda em português do Brasil, de forma direta.
-
-# Como trabalhar
-- Você tem um GRAFO DE CONHECIMENTO do projeto (símbolos, chamadas, imports) e uma MEMÓRIA em grafo (notas). ${graphStats}
-- Para entender código: comece por graph_search / graph_context / graph_callers / graph_callees / graph_impact. Só leia arquivos (read_file) nas linhas que o grafo apontou. Use grep apenas para texto que não é símbolo.
-- Antes de alterar uma função ou arquivo, rode graph_callers / graph_impact e considere o que pode quebrar.
-- Após editar muitos arquivos, rode graph_index para atualizar o grafo.
-- Ao tomar uma decisão não óbvia, descobrir um bug ou uma convenção, grave com remember (com refs para arquivos/símbolos). Consulte recall no início de tarefas relevantes.
-- Edições e comandos shell pedem aprovação do usuário. Prefira edit_file a write_file. Verifique seu trabalho (typecheck/testes) via bash quando existir.
-- Para investigações amplas ou sub-tarefas grandes, use delegate: o subagente trabalha em contexto isolado e devolve só o resultado. Vários delegate somente-leitura (explore/plan) no mesmo turno rodam em paralelo. Passe \`focus\` com os símbolos relevantes. Não delegue o que resolve com 1–2 chamadas de graph_*.
-- SKILLS: procedimentos reutilizáveis aprendidos neste projeto. Se alguma se aplica à tarefa, chame skill_load ANTES de começar e siga-a. Se ela estiver errada ou incompleta, corrija com skill_save. Ao terminar tarefas complexas, o sistema pode propor novas skills; não crie skill para fatos de uma tarefa única.
-- Em tarefas com 3+ passos, mantenha a lista com todo_write: um item in_progress por vez, marcado completed assim que terminar. Leia um arquivo (read_file) antes de editá-lo; se ele mudou desde a leitura, leia de novo.
-- Seja conciso. Não repita conteúdo de arquivos na resposta.
-
-# Ambiente
-Diretório do projeto: ${root}
+    return `Você é Brito, um agente de engenharia de software que trabalha em CLI. Responda em português do Brasil, de forma direta.
+
+# Como trabalhar
+- Você tem um GRAFO DE CONHECIMENTO do projeto (símbolos, chamadas, imports) e uma MEMÓRIA em grafo (notas). ${graphStats}
+- Para entender código: comece por graph_search / graph_context / graph_callers / graph_callees / graph_impact. Só leia arquivos (read_file) nas linhas que o grafo apontou. Use grep apenas para texto que não é símbolo.
+- Antes de alterar uma função ou arquivo, rode graph_callers / graph_impact e considere o que pode quebrar.
+- Após editar muitos arquivos, rode graph_index para atualizar o grafo.
+- Ao tomar uma decisão não óbvia, descobrir um bug ou uma convenção, grave com remember (com refs para arquivos/símbolos). Consulte recall no início de tarefas relevantes.
+- Edições e comandos shell pedem aprovação do usuário. Prefira edit_file a write_file. Verifique seu trabalho (typecheck/testes) via bash quando existir.
+- Para investigações amplas ou sub-tarefas grandes, use delegate: o subagente trabalha em contexto isolado e devolve só o resultado. Vários delegate somente-leitura (explore/plan) no mesmo turno rodam em paralelo. Passe \`focus\` com os símbolos relevantes. Não delegue o que resolve com 1–2 chamadas de graph_*.
+- SKILLS: procedimentos reutilizáveis aprendidos neste projeto. Se alguma se aplica à tarefa, chame skill_load ANTES de começar e siga-a. Se ela estiver errada ou incompleta, corrija com skill_save. Ao terminar tarefas complexas, o sistema pode propor novas skills; não crie skill para fatos de uma tarefa única.
+- Em tarefas com 3+ passos, mantenha a lista com todo_write: um item in_progress por vez, marcado completed assim que terminar. Leia um arquivo (read_file) antes de editá-lo; se ele mudou desde a leitura, leia de novo.
+- Seja conciso. Não repita conteúdo de arquivos na resposta.
+
+# Ambiente
+Diretório do projeto: ${root}
 Data: ${new Date().toISOString().slice(0, 10)}${shellNote()}${skills ? `\n\n# Skills disponíveis (use skill_load)\n${skills}` : ""}${projectDoc}`;
 }
 import { listSkills, skillsIndex } from "../skills/store.js";
@@ -68,14 +68,14 @@ export function systemKey(root, planMode, graphEmpty) {
     return `${planMode}|${graphEmpty}|${skills}`;
 }
 export function buildSubagentPrompt(root, def) {
-    return `${def.prompt}
-
-# Regras de subagente
-- Você foi chamado por outro agente e NÃO vê a conversa dele: tudo que precisa está na tarefa.
-- Use o grafo antes de ler arquivos: graph_search, graph_context, graph_callers, graph_callees, graph_impact. Leia só as linhas que ele apontar.
-- Sua última mensagem é a única coisa que o chamador recebe. Seja objetivo e use caminhos \`arquivo:linha\`; sem preâmbulo.
-
-# Ambiente
-Diretório do projeto: ${root}
+    return `${def.prompt}
+
+# Regras de subagente
+- Você foi chamado por outro agente e NÃO vê a conversa dele: tudo que precisa está na tarefa.
+- Use o grafo antes de ler arquivos: graph_search, graph_context, graph_callers, graph_callees, graph_impact. Leia só as linhas que ele apontar.
+- Sua última mensagem é a única coisa que o chamador recebe. Seja objetivo e use caminhos \`arquivo:linha\`; sem preâmbulo.
+
+# Ambiente
+Diretório do projeto: ${root}
 Data: ${new Date().toISOString().slice(0, 10)}${skillsIndex(root) ? `\n\n# Skills disponíveis (use skill_load)\n${skillsIndex(root)}` : ""}`;
 }

package/dist/cli.js

@@ -7,16 +7,19 @@ import "./tools/bash.js";
 import "./tools/graph.js";
 import "./tools/delegate.js";
 import "./tools/plan.js";
+import "./tools/implement.js";
+import "./tools/spec.js";
 import "./tools/todo.js";
 import fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import { latestSession, listSessions, repairHistory, saveSession, titleOf } from "./agent/sessions.js";
 import { PLAN_NOTE, perms } from "./permissions.js";
+import { ORCH_NOTE, implStatus, mainTools, orch, orchGuard, restoreOrch } from "./orchestrator.js";
 import { loadProjectAgents, listAgents } from "./agent/agents.js";
 import { GraphLockedError, GraphStore, openGraphAfterClaude } from "./graph/store.js";
 import { indexProject } from "./graph/indexer.js";
 import { Agent } from "./agent/loop.js";
-import { EFFORTS, MODEL_ALIASES, modelHelp, effortLabel, initialEffort, initialModel, loadProfiles, isEffort, loadReasoningDisplay, parseModelArgs, saveEffort, saveModel, saveReasoningDisplay } from "./model.js";
+import { EFFORTS, MODEL_ALIASES, modelHelp, effortLabel, initialEffort, initialModel, loadProfiles, loadSavedOrch, isEffort, loadReasoningDisplay, parseModelArgs, saveEffort, saveImplModel, saveModel, saveOrch, saveReasoningDisplay } from "./model.js";
 import { hasClaudeCli, historyForFallback, ClaudeSession } from "./agent/claude-cli.js";
 import { NO_ANTHROPIC, fallbackStatus, learnerModel, openEngine } from "./engine.js";
 import { activateFallback, chooseModel, cliShouldFallBack, fallbackWarning, newFallbackState, onceRestore, renderFallback, retryPrompt } from "./provider/fallback.js";
@@ -501,6 +504,74 @@ function makeLearner(getTurns, ctx, complete, getModel) {
         }
     };
 }
+/**
+ * `/orquestrar [on|off] [modelo <perfil>] [--global]`: o principal planeja e revisa, o perfil implementa pela tool
+ * `implement`. `on`/`off` e `modelo` combinam no mesmo comando; `--global` grava o que foi pedido no config
+ * (`orchestrator` e `implModel`), para valer ao abrir o Brito de novo.
+ */
+function orchestratorCommand(main) {
+    const usage = "  uso: /orquestrar on|off [modelo <perfil>] [--global] · /orquestrar modelo <perfil> [--global]";
+    return {
+        desc: "modo orquestrador: o modelo principal planeja e revisa, um perfil (qwen) implementa",
+        run: async (args) => {
+            const global = args.includes("--global");
+            const words = args.filter((a) => !a.startsWith("--"));
+            const st = () => implStatus(main(), orch.model, process.env);
+            if (!words.length) {
+                const s = st();
+                ui.print(`  ${c.soft("modo")} ${c.muted(`${orch.on ? "ligado" : "desligado"}${loadSavedOrch() ? " · liga ao abrir (salvo)" : ""}`)}`);
+                ui.print(`  ${c.soft("implementador")} ${c.muted(`${orch.model} · ${s.ready ? `${s.label} ✓ pronto` : `✗ ${s.reason}`}`)}`);
+                ui.print(c.muted(usage));
+                return;
+            }
+            const toggle = words.find((w) => w === "on" || w === "off");
+            const mi = words.indexOf("modelo");
+            const name = mi >= 0 ? words[mi + 1] : undefined;
+            const known = new Set([toggle, "modelo", name].filter(Boolean));
+            if ((mi >= 0 && !name) || words.some((w) => !known.has(w)) || words.filter((w) => w === "on" || w === "off").length > 1) {
+                ui.warn(`argumento desconhecido: ${args.join(" ")}`);
+                ui.print(c.muted(usage));
+                return;
+            }
+            // O implementador primeiro: `on modelo X` liga já com o X.
+            if (name) {
+                const key = name.trim().toLowerCase();
+                if (resolveModel(key).kind !== "openai") {
+                    ui.error(`"${name}" não é um perfil de endpoint em providers no ~/.brito/config.json: o implementador é um perfil (ex.: qwen); o principal se troca com /model`);
+                    return;
+                }
+                orch.model = key;
+                if (global)
+                    saveImplModel(key);
+                ui.info(`implementador: ${key}${global ? " (salvo)" : ""}`);
+            }
+            if (toggle === "off") {
+                orch.on = false;
+                if (global)
+                    saveOrch(false);
+                ui.info(`modo orquestrador desligado${global ? " (salvo)" : ""}: o modelo principal volta a editar`);
+                return;
+            }
+            if (toggle === "on") {
+                const s = st();
+                if (!s.ready) {
+                    ui.error(`modo orquestrador não ligou: ${s.reason}`);
+                    return;
+                }
+                orch.on = true;
+                if (global)
+                    saveOrch(true);
+                ui.info(`modo orquestrador ligado${global ? " (salvo: liga ao abrir o Brito)" : ""}: ${main()} planeja e revisa, ${s.label} implementa`);
+                return;
+            }
+            const s = st();
+            if (orch.on && !s.ready) {
+                orch.on = false;
+                ui.warn(`modo orquestrador desligado: ${s.reason}`);
+            }
+        },
+    };
+}
 /** Linhas da listagem de sessões (`brito sessoes`, `/sessions`): id, quando, motor e título. */
 function sessionLines(root, current) {
     return listSessions(root).slice(0, 20).map((s) => {
@@ -549,10 +620,10 @@ 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);
-    // 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 });
+    // Refeito só quando muda o modo plano, o modo orquestrador, o grafo deixa de estar vazio ou o conjunto de skills muda:
+    // um system estável mantém o cache de prompt da conversa (veja memoSystem).
+    const system = memoSystem(() => systemKey(root, perms.mode === "plan", symCount + noteCount === 0) + `|${orch.on}`, () => buildSystemPrompt(root, graphStatsLine(symCount, noteCount, "now"), skillsIndex(root)) + (perms.mode === "plan" ? PLAN_NOTE : "") + (orch.on ? ORCH_NOTE : ""));
+    const agent = new Agent(system, ctx, { model, fallback, tools: mainTools });
     if (o.messages)
         agent.messages = o.messages;
     if (o.effort)
@@ -581,6 +652,7 @@ async function buildApiBackend(root, model, io, o = {}) {
     };
     const turn = async (text, signal) => {
         ui.turnStart();
+        orchGuard(agent.model, (m) => ui.warn(m)); // `/model qwen` ou a troca do claude CLI para o qwen
         let ok = true;
         try {
             await agent.send(text, signal);
@@ -616,6 +688,7 @@ async function buildApiBackend(root, model, io, o = {}) {
             "/model": modelCmd.cmd,
             "/fallback": fallbackCommand(fallback, () => agent.model, o.engineLabel ?? ((m) => (resolveModel(m).kind === "openai" ? "endpoint" : "API Anthropic"))),
             "/reasoning": reasoningCommand(() => agent.effort, (e) => { agent.effort = e; }),
+            "/orquestrar": orchestratorCommand(() => agent.model),
             "/tools": { desc: "ferramentas disponíveis", run: async () => { for (const t of allTools())
                     ui.print(`  ${ui.toolLabel(t.name)}${c.dim(t.dangerous ? "  (pede aprovação)" : "")}`); } },
             "/context": {
@@ -781,6 +854,7 @@ async function buildClaudeBackend(root, io, sw, model, openGraph, resume) {
             "/model": modelCmd.cmd,
             "/fallback": fallbackCommand(fallback, () => session.model, () => "claude CLI · assinatura"),
             "/effort": effortCommand(() => session.effort, (e) => { session.effort = e; }),
+            "/orquestrar": orchestratorCommand(() => session.requestedModel || session.model),
             "/reasoning": reasoningCommand(() => session.effort, (e) => { session.effort = e; }),
             "/tools": { desc: "ferramentas do grafo/memória/skills", run: async () => { for (const n of mcpTools)
                     ui.print(`  ${ui.toolLabel(n)}`); } },
@@ -835,6 +909,7 @@ async function runViaClaude(root, promptParts, yes, model, resume) {
     }
     sw = switchableBackend(claude.backend);
     ui.info("modo claude CLI: usa o login da sua conta; tools do grafo/memória/skills via MCP.");
+    restoreOrch(claude.session.requestedModel || claude.session.model, (m) => ui.warn(m), (m) => ui.info(m));
     await runRepl(sw, {
         root, yes, startedAt, io,
         banner: {
@@ -956,6 +1031,7 @@ program
         return;
     }
     sw = switchableBackend(api.backend);
+    restoreOrch(api.agent.model, (m) => ui.warn(m), (m) => ui.info(m));
     await runRepl(sw, {
         root, yes: !!o.yes, startedAt, io,
         banner: {

package/dist/desktop/panels.js

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

package/dist/desktop/protocol.js

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