brito-cli 0.14.0 → 0.16.0

package/dist/cli.js

@@ -29,6 +29,7 @@ import { addRule, loadRules, projectSettingsPath } from "./rules.js";
 import { serveMcp } from "./mcp/server.js";
 import "./tools/skills.js";
 import "./tools/digest.js";
+import "./tools/vault.js";
 import { adviseSkill, approvePending, lintSkill, listBuiltins, listPending, listSkills, rejectPending, skillsIndex, staleRefs } from "./skills/store.js";
 import { applyProposal, autoConsolidate, describeProposal, proposeConsolidation, pruneCandidates } from "./skills/consolidate.js";
 import { defaultComplete, recordOutcomes, reflect, shouldReflect } from "./skills/learn.js";
@@ -57,7 +58,7 @@ program
     const g = await GraphStore.open(root);
     const t = Date.now();
     const s = await indexProject(root, g, { full: o.full, onProgress: (m) => console.log(m) });
-    console.log(`OK: ${s.files} arquivos, ${s.symbols} símbolos, ${s.calls} chamadas, ${s.imports} imports | +${s.added} ~${s.changed} -${s.removed} =${s.unchanged} (${Date.now() - t}ms)`);
+    console.log(`OK: ${s.files} arquivos, ${s.symbols} símbolos, ${s.calls} chamadas, ${s.imports} imports | +${s.added} ~${s.changed} -${s.removed} =${s.unchanged}${s.docs ? ` | ${s.docs} docs, ${s.secoes} seções, ${s.ligas} ligações, ${s.citas} citações, ${s.linksQuebrados} links sem destino` : ""} (${Date.now() - t}ms)`);
     await g.close();
 });
 program

package/dist/desktop/serve.js

@@ -17,6 +17,7 @@ import "../tools/implement.js";
 import "../tools/spec.js";
 import "../tools/skills.js";
 import "../tools/digest.js";
+import "../tools/vault.js";
 import "../tools/todo.js";
 import { Agent } from "../agent/loop.js";
 import { loadSession, repairHistory, saveSession, titleOf } from "../agent/sessions.js";

package/dist/graph/indexer.js

@@ -8,6 +8,7 @@ import { spawnSync } from "node:child_process";
 import { SFC_EXT, componentName, splitSfc, templateCalleeNames } from "./sfc.js";
 import { Aliases, aliasCandidates } from "./aliases.js";
 import { IDREF_PREFIX, IdIndex, MD_EXT, WIKI_PREFIX, WikiIndex, extractMarkdown } from "./markdown.js";
+import { indexSections } from "./sections.js";
 import { EXTRA_EXT, ProjectIndex, extractLang, isExtraLang } from "./langs.js";
 const require = createRequire(import.meta.url);
 const WASM_DIR = path.dirname(require.resolve("tree-sitter-wasms/package.json")) + "/out";
@@ -247,7 +248,9 @@ const count = async (store, q) => Number((await store.run(q))[0].n);
 export async function indexProject(root, store, opts = {}) {
     const release = await acquireIndexLock(root, opts.onProgress);
     try {
-        return await indexProjectLocked(root, store, opts);
+        const code = await indexProjectLocked(root, store, opts);
+        const md = await indexSections(root, store, opts);
+        return { ...code, docs: md.docs, secoes: md.secoes, ligas: md.ligas, citas: md.citas, linksQuebrados: md.unresolved, mdChanged: md.added + md.changed + md.removed };
     }
     finally {
         release();

package/dist/graph/pathfind.js

@@ -0,0 +1,168 @@
+/**
+ * Algoritmos de grafo em memória para o cofre: Dijkstra, A* com landmarks (ALT) e PageRank personalizado.
+ * Custo da aresta = custo da relação + penalidade de hub (log do grau): o caminho preferido não passa por "Início" ou "Deus".
+ */
+class Heap {
+    k = [];
+    v = [];
+    get size() { return this.k.length; }
+    push(key, val) {
+        let i = this.k.length;
+        this.k.push(key);
+        this.v.push(val);
+        while (i > 0) {
+            const p = (i - 1) >> 1;
+            if (this.k[p] <= this.k[i])
+                break;
+            this.swap(i, p);
+            i = p;
+        }
+    }
+    pop() {
+        const top = [this.k[0], this.v[0]];
+        const lk = this.k.pop(), lv = this.v.pop();
+        if (this.k.length) {
+            this.k[0] = lk;
+            this.v[0] = lv;
+            let i = 0;
+            for (;;) {
+                const l = 2 * i + 1, r = l + 1;
+                let m = i;
+                if (l < this.k.length && this.k[l] < this.k[m])
+                    m = l;
+                if (r < this.k.length && this.k[r] < this.k[m])
+                    m = r;
+                if (m === i)
+                    break;
+                this.swap(i, m);
+                i = m;
+            }
+        }
+        return top;
+    }
+    swap(a, b) { [this.k[a], this.k[b]] = [this.k[b], this.k[a]]; [this.v[a], this.v[b]] = [this.v[b], this.v[a]]; }
+}
+export class WGraph {
+    n;
+    adj;
+    deg;
+    constructor(n, edges, hub = 0.25) {
+        this.n = n;
+        this.adj = Array.from({ length: n }, () => []);
+        this.deg = new Array(n).fill(0);
+        for (const [a, b] of edges) {
+            this.deg[a]++;
+            this.deg[b]++;
+        }
+        for (const [a, b, base] of edges) {
+            const w = base + hub * (Math.log2(1 + this.deg[a]) + Math.log2(1 + this.deg[b]));
+            this.adj[a].push({ to: b, w });
+            this.adj[b].push({ to: a, w });
+        }
+    }
+    dijkstra(s) {
+        const dist = new Float64Array(this.n).fill(Infinity);
+        dist[s] = 0;
+        const h = new Heap();
+        h.push(0, s);
+        while (h.size) {
+            const [d, u] = h.pop();
+            if (d > dist[u])
+                continue;
+            for (const e of this.adj[u]) {
+                const nd = d + e.w;
+                if (nd < dist[e.to]) {
+                    dist[e.to] = nd;
+                    h.push(nd, e.to);
+                }
+            }
+        }
+        return dist;
+    }
+    /** Landmarks por ponto mais distante: distâncias pré-calculadas que dão a heurística admissível do A*. */
+    landmarks(k, from = 0) {
+        const out = [];
+        const mind = new Float64Array(this.n).fill(Infinity);
+        let cur = from;
+        for (let i = 0; i < k && cur >= 0; i++) {
+            const dist = this.dijkstra(cur);
+            out.push(dist);
+            let best = -1, bd = -1;
+            for (let v = 0; v < this.n; v++) {
+                mind[v] = Math.min(mind[v], dist[v]);
+                if (mind[v] !== Infinity && mind[v] > bd) {
+                    bd = mind[v];
+                    best = v;
+                }
+            }
+            cur = best;
+        }
+        return out;
+    }
+    astar(s, t, lm) {
+        const hf = (v) => {
+            let m = 0;
+            for (const d of lm) {
+                const a = d[v], b = d[t];
+                if (a !== Infinity && b !== Infinity)
+                    m = Math.max(m, Math.abs(a - b));
+            }
+            return m;
+        };
+        const g = new Float64Array(this.n).fill(Infinity);
+        const prev = new Int32Array(this.n).fill(-1);
+        g[s] = 0;
+        const h = new Heap();
+        h.push(hf(s), s);
+        const done = new Uint8Array(this.n);
+        let settled = 0;
+        while (h.size) {
+            const [, u] = h.pop();
+            if (done[u])
+                continue;
+            done[u] = 1;
+            settled++;
+            if (u === t) {
+                const path = [t];
+                while (path[0] !== s)
+                    path.unshift(prev[path[0]]);
+                return { cost: g[t], settled, path };
+            }
+            for (const e of this.adj[u]) {
+                const ng = g[u] + e.w;
+                if (ng < g[e.to]) {
+                    g[e.to] = ng;
+                    prev[e.to] = u;
+                    h.push(ng + hf(e.to), e.to);
+                }
+            }
+        }
+        return { cost: Infinity, settled, path: [] };
+    }
+    /** PageRank personalizado: a massa parte das sementes e segue as arestas na proporção de 1/custo. */
+    ppr(seeds, alpha = 0.2, iters = 25) {
+        const tot = [...seeds.values()].reduce((a, b) => a + b, 0) || 1;
+        const p0 = new Float64Array(this.n);
+        for (const [k, v] of seeds)
+            p0[k] = v / tot;
+        const wsum = this.adj.map((l) => l.reduce((a, e) => a + 1 / e.w, 0));
+        let p = Float64Array.from(p0);
+        for (let it = 0; it < iters; it++) {
+            const q = new Float64Array(this.n);
+            for (let u = 0; u < this.n; u++) {
+                if (!p[u])
+                    continue;
+                if (!wsum[u]) {
+                    q[u] += p[u];
+                    continue;
+                }
+                for (const e of this.adj[u])
+                    q[e.to] += (1 - alpha) * p[u] * (1 / e.w) / wsum[u];
+            }
+            for (let i = 0; i < this.n; i++)
+                q[i] += alpha * p0[i];
+            p = q;
+        }
+        return p;
+    }
+}

package/dist/graph/sections.js

@@ -0,0 +1,247 @@
+/**
+ * Markdown como cidadão do grafo: cada .md vira um Doc, cada cabeçalho uma Secao (com texto e linhas), os [[wikilinks]]
+ * viram LIGA entre Docs e as passagens bíblicas viram CITA → Passagem. Parser puro (sem banco) + indexação incremental.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+export const SECTIONS_VERSION = "m1";
+const MD_RE = /\.(md|markdown)$/i;
+/** Formatos que só viram metadado (Doc sem seções): a fonte de verdade é o .md derivado deles. */
+const META_RE = /\.(pdf|epub|docx)$/i;
+const IGNORE_RE = /(^|\/)(node_modules|dist|build|\.git|\.brito|\.venv|target|vendor)(\/|$)|(^|\/)\./;
+const MAX_MD_BYTES = 5_000_000;
+/** Siglas da NAA (e variantes sem acento); só estas valem como livro, para não confundir "Cap 3" com passagem. */
+const LIVROS = new Set(("Gn Êx Ex Lv Nm Dt Js Jz Rt 1Sm 2Sm 1Rs 2Rs 1Cr 2Cr Ed Ne Et Jó Sl Pv Ec Ct Is Jr Lm Ez Dn Os Jl Am Ob Jn Mq Na Hc Sf Ag Zc Ml " +
+    "Mt Mc Lc Jo At Rm 1Co 2Co Gl Ef Fp Cl 1Ts 2Ts 1Tm 2Tm Tt Fm Hb Tg 1Pe 2Pe 1Jo 2Jo 3Jo Jd Ap " +
+    // formas longas e variantes usuais em português (as fichas do cofre usam "1Cor", "Hab" etc.)
+    "Gên Gen Êxo Exo Lev Núm Num Deut Jos Juí Jz Rute 1Sam 2Sam 1Re 2Re 1Cr 2Cr Esd Est Jó Sal Prov Ecl Cant Isa Jer Lam Eze Ezq Dan Ose Joe Amó Abd Jon Miq Naum Hab Sof Ageu Zac Mal " +
+    "Mat Mar Luc Joã Atos Rom 1Cor 2Cor Gál Efé Fil Col 1Tes 2Tes 1Tim 2Tim Tito Filem Heb Tia 1Ped 2Ped 1Joã 2Joã 3Joã Jud Apoc").split(" "));
+/** "Rm 9.13; Rm 3.25-26; Ob 15" → ["Rm 9.13","Rm 3.25","Rm 3.26","Ob 15"]. Intervalo vira um item por versículo (máx. 60). */
+export function parsePassagens(txt) {
+    const out = [];
+    for (const m of txt.normalize("NFC").matchAll(/(?<![\p{L}\d])(\d?[A-Za-zÀ-ÿ]+)\s+(\d+)(?:\.(\d+)(?:-(\d+))?)?(?![\d])/gu)) {
+        const [, livro, cap, v1, v2] = m;
+        if (!LIVROS.has(livro))
+            continue;
+        if (v1 === undefined) {
+            out.push(`${livro} ${cap}`);
+            continue;
+        }
+        for (let v = +v1; v <= +(v2 || v1) && v - +v1 < 60; v++)
+            out.push(`${livro} ${cap}.${v}`);
+    }
+    return [...new Set(out)];
+}
+/** Frontmatter simples (chave: valor, inclusive listas inline). Retorna também quantas linhas ele ocupa. */
+export function splitFrontmatter(txt) {
+    const m = txt.match(/^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
+    if (!m)
+        return { fm: {}, corpo: txt, linhas: 0 };
+    const fm = {};
+    for (const l of m[1].split(/\r?\n/)) {
+        const k = l.match(/^([\p{L}\d_-]+):\s*(.*)$/u);
+        if (k)
+            fm[k[1]] = k[2].replace(/^["']|["']$/g, "");
+    }
+    return { fm, corpo: txt.slice(m[0].length), linhas: m[0].split("\n").length - 1 };
+}
+const wikilinks = (t) => [...t.matchAll(/\[\[([^\]|#]+)(?:[|#][^\]]*)?\]\]/g)].map((m) => m[1].trim()).filter(Boolean);
+/** Tira blocos e trechos de código (os cabeçalhos e [[links]] dentro deles são exemplo, não estrutura). */
+const semCodigo = (t) => t.replace(/^(```|~~~)[\s\S]*?^\1[^\n]*$/gm, "").replace(/`[^`\n]*`/g, "");
+export function parseMarkdown(rel, src) {
+    const { fm, corpo, linhas: offset } = splitFrontmatter(src);
+    const h1 = corpo.match(/^#\s+(.+)$/m);
+    const tipo = (fm.tipo || rel.split("/")[0] || "").toLowerCase();
+    const secoes = [];
+    let atual = { nivel: 0, titulo: "(abertura)", buf: [], start: offset + 1 };
+    let ordem = 0, fence = null;
+    const lines = corpo.split("\n");
+    const fecha = (fim) => {
+        const texto = atual.buf.join("\n").trim();
+        if (texto || atual.nivel)
+            secoes.push({ id: `${rel}#${ordem}`, nivel: atual.nivel, titulo: atual.titulo, ordem: ordem++, texto, startLine: atual.start, endLine: Math.max(atual.start, fim) });
+    };
+    lines.forEach((raw, i) => {
+        const l = raw.replace(/\r$/, "");
+        const f = l.match(/^(```|~~~)/);
+        if (f)
+            fence = fence === null ? f[1] : fence === f[1] ? null : fence;
+        const h = fence === null && !f ? l.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/) : null;
+        if (h) {
+            fecha(offset + i);
+            atual = { nivel: h[1].length, titulo: h[2].trim(), buf: [], start: offset + i + 1 };
+        }
+        else
+            atual.buf.push(l);
+    });
+    fecha(offset + lines.length);
+    const links = [];
+    const modelo = rel.startsWith("Modelos/");
+    if (!modelo) {
+        for (const [k, v] of Object.entries(fm))
+            for (const a of wikilinks(v))
+                links.push({ tipo: k, alvo: a });
+        for (const a of wikilinks(semCodigo(corpo)))
+            links.push({ tipo: "menciona", alvo: a });
+    }
+    let passagens = [];
+    if (!modelo) {
+        if (fm.passagens)
+            passagens = parsePassagens(fm.passagens);
+        if (tipo === "tema") {
+            const bb = secoes.find((s) => /^Base bíblica/i.test(s.titulo));
+            if (bb)
+                passagens = passagens.concat(parsePassagens(bb.texto));
+        }
+    }
+    return {
+        path: rel, tipo, titulo: fm.titulo || h1?.[1].trim() || path.basename(rel).replace(MD_RE, ""),
+        ano: fm.ano || "", status: fm.status || "", tamanho: Buffer.byteLength(src), secoes, links, passagens: [...new Set(passagens)],
+    };
+}
+/** Nome → caminho, comparando em NFC e sem diferenciar caixa (links do macOS vêm decompostos). Nome repetido: vale o 1º por ordem de caminho. */
+export function linkResolver(paths) {
+    const nfc = (s) => s.normalize("NFC").toLowerCase();
+    const map = new Map();
+    const add = (k, p) => { const a = map.get(k) ?? map.set(k, []).get(k); if (!a.includes(p))
+        a.push(p); };
+    for (const p of [...paths].sort()) {
+        const noExt = p.replace(MD_RE, "");
+        add(nfc(p), p);
+        add(nfc(noExt), p);
+        add(nfc(path.posix.basename(p)), p);
+        add(nfc(path.posix.basename(noExt)), p);
+    }
+    return (alvo, de) => {
+        const c = map.get(nfc(alvo));
+        if (!c)
+            return null;
+        const top = de.split("/")[0];
+        return c.find((x) => x.split("/")[0] === top) ?? c[0]; // ambíguo: prefere a mesma pasta raiz
+    };
+}
+function listFiles(root) {
+    if (process.env.BRITO_INDEX_IGNORED !== "1") {
+        const r = spawnSync("git", ["ls-files", "-co", "--exclude-standard", "-z"], { cwd: root, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+        if (!r.error && r.status === 0)
+            return r.stdout.split("\0").filter(Boolean).filter((f) => !IGNORE_RE.test(f) && fs.existsSync(path.join(root, f)));
+    }
+    const out = [];
+    const walk = (dir) => {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (e.name.startsWith(".") || IGNORE_RE.test(e.name))
+                continue;
+            const p = path.join(dir, e.name);
+            if (e.isDirectory())
+                walk(p);
+            else
+                out.push(path.relative(root, p).split(path.sep).join("/"));
+        }
+    };
+    walk(root);
+    return out;
+}
+/** Indexação incremental dos .md (e metadados de pdf/epub/docx): só reparseia o que mudou; as LIGA são recalculadas em memória e aplicadas por diff. */
+export async function indexSections(root, store, opts = {}) {
+    const files = listFiles(root).filter((f) => MD_RE.test(f) || META_RE.test(f));
+    if (!files.length) {
+        const had = Number((await store.run("MATCH (d:Doc) RETURN count(d) AS n"))[0].n);
+        if (had)
+            await store.run("MATCH (d:Doc) DETACH DELETE d");
+        return { docs: 0, secoes: 0, ligas: 0, citas: 0, added: 0, changed: 0, removed: had, unresolved: 0 };
+    }
+    if (opts.full) {
+        await store.run("MATCH (s:Secao) DETACH DELETE s");
+        await store.run("MATCH (d:Doc) DETACH DELETE d");
+        await store.run("MATCH (p:Passagem) DELETE p");
+    }
+    const stored = new Map();
+    for (const r of await store.run("MATCH (d:Doc) RETURN d.path AS p, d.hash AS h"))
+        stored.set(r.p, r.h ?? "");
+    const current = new Map();
+    for (const rel of files) {
+        const abs = path.join(root, rel);
+        try {
+            const st = fs.statSync(abs);
+            if (MD_RE.test(rel)) {
+                if (st.size > MAX_MD_BYTES)
+                    continue;
+                const src = fs.readFileSync(abs, "utf8");
+                current.set(rel, { src, size: st.size, hash: crypto.createHash("sha1").update(src).digest("hex") + ":" + SECTIONS_VERSION });
+            }
+            else
+                current.set(rel, { size: st.size, hash: `meta:${st.size}:${SECTIONS_VERSION}` });
+        }
+        catch { /* ilegível: ignora */ }
+    }
+    const added = [], changed = [], removed = [];
+    for (const [p, { hash }] of current) {
+        const old = stored.get(p);
+        if (old === undefined)
+            added.push(p);
+        else if (old !== hash)
+            changed.push(p);
+    }
+    for (const p of stored.keys())
+        if (!current.has(p))
+            removed.push(p);
+    if (added.length + changed.length + removed.length)
+        opts.onProgress?.(`markdown: +${added.length} ~${changed.length} -${removed.length}`);
+    for (const p of [...removed, ...changed]) {
+        await store.run("MATCH (s:Secao {doc:$p}) DETACH DELETE s", { p });
+        await store.run("MATCH (d:Doc {path:$p}) DETACH DELETE d", { p });
+    }
+    const parsed = new Map();
+    for (const rel of [...added, ...changed]) {
+        const c = current.get(rel);
+        const doc = c.src !== undefined ? parseMarkdown(rel, c.src)
+            : { path: rel, tipo: path.extname(rel).slice(1).toLowerCase(), titulo: path.basename(rel), ano: "", status: "", tamanho: c.size, secoes: [], links: [], passagens: [] };
+        parsed.set(rel, doc);
+        await store.run("CREATE (:Doc {path:$path, tipo:$tipo, titulo:$titulo, ano:$ano, status:$status, tamanho:$tamanho, hash:$hash, links:$links})", { path: rel, tipo: doc.tipo, titulo: doc.titulo, ano: doc.ano, status: doc.status, tamanho: doc.tamanho, hash: c.hash, links: doc.links.map((l) => `${l.tipo}\t${l.alvo}`) });
+        for (const s of doc.secoes) {
+            await store.run("MATCH (d:Doc {path:$doc}) CREATE (d)-[:TEM_SECAO]->(:Secao {id:$id, doc:$doc, nivel:$nivel, titulo:$titulo, ordem:$ordem, texto:$texto, startLine:$sl, endLine:$el})", { doc: rel, id: s.id, nivel: s.nivel, titulo: s.titulo, ordem: s.ordem, texto: s.texto, sl: s.startLine, el: s.endLine });
+        }
+        for (const ref of doc.passagens) {
+            await store.run("MERGE (p:Passagem {ref:$ref})", { ref });
+            await store.run("MATCH (d:Doc {path:$d}), (p:Passagem {ref:$ref}) CREATE (d)-[:CITA]->(p)", { d: rel, ref });
+        }
+        await store.yieldIfWaited();
+    }
+    // LIGA: recalculada em memória a partir dos links crus guardados em cada Doc; aplica só a diferença.
+    const resolve = linkResolver(current.keys());
+    const want = new Set();
+    let unresolved = 0;
+    const raw = new Map();
+    for (const r of await store.run("MATCH (d:Doc) RETURN d.path AS p, d.links AS l"))
+        raw.set(r.p, r.l ?? []);
+    for (const [de, ls] of raw) {
+        for (const l of ls) {
+            const [tipo, alvo] = l.split("\t");
+            const para = resolve(alvo, de);
+            if (!para) {
+                unresolved++;
+                continue;
+            }
+            if (para !== de)
+                want.add([de, para, tipo].join("\t"));
+        }
+    }
+    const have = new Set((await store.run("MATCH (a:Doc)-[r:LIGA]->(b:Doc) RETURN a.path AS a, b.path AS b, r.tipo AS t")).map((r) => [r.a, r.b, r.t].join("\t")));
+    for (const k of have)
+        if (!want.has(k)) {
+            const [a, b, t] = k.split("\t");
+            await store.run("MATCH (x:Doc {path:$a})-[r:LIGA {tipo:$t}]->(y:Doc {path:$b}) DELETE r", { a, b, t });
+        }
+    for (const k of want)
+        if (!have.has(k)) {
+            const [a, b, t] = k.split("\t");
+            await store.run("MATCH (x:Doc {path:$a}), (y:Doc {path:$b}) CREATE (x)-[:LIGA {tipo:$t}]->(y)", { a, b, t });
+        }
+    const n = async (q) => Number((await store.run(q))[0].n);
+    return {
+        docs: current.size, secoes: await n("MATCH (s:Secao) RETURN count(s) AS n"), ligas: want.size, citas: await n("MATCH ()-[r:CITA]->() RETURN count(r) AS n"),
+        added: added.length, changed: changed.length, removed: removed.length, unresolved,
+    };
+}

package/dist/graph/store.js

@@ -149,12 +149,24 @@ export class GraphStore {
             "CREATE REL TABLE IF NOT EXISTS DEFINES(FROM File TO Symbol)",
             "CREATE REL TABLE IF NOT EXISTS CALLS(FROM Symbol TO Symbol)",
             "CREATE REL TABLE IF NOT EXISTS IMPORTS(FROM File TO File)",
+            // Markdown: Doc por arquivo, Secao por cabeçalho, LIGA = [[wikilink]], CITA = passagem bíblica.
+            "CREATE NODE TABLE IF NOT EXISTS Doc(path STRING, tipo STRING, titulo STRING, ano STRING, status STRING, tamanho INT64, PRIMARY KEY(path))",
+            "CREATE NODE TABLE IF NOT EXISTS Secao(id STRING, doc STRING, nivel INT64, titulo STRING, ordem INT64, texto STRING, PRIMARY KEY(id))",
+            "CREATE NODE TABLE IF NOT EXISTS Passagem(ref STRING, PRIMARY KEY(ref))",
+            "CREATE REL TABLE IF NOT EXISTS TEM_SECAO(FROM Doc TO Secao)",
+            "CREATE REL TABLE IF NOT EXISTS CITA(FROM Doc TO Passagem)",
+            "CREATE REL TABLE IF NOT EXISTS LIGA(FROM Doc TO Doc, tipo STRING)",
         ];
         for (const q of ddl)
             await drain(await this.conn.query(q), false);
         // Bancos criados antes do indexador incremental não têm estas colunas.
         for (const col of ["calls", "imports", "bindings"])
             await drain(await this.conn.query(`ALTER TABLE File ADD IF NOT EXISTS ${col} STRING[] DEFAULT []`), false);
+        for (const q of [
+            "ALTER TABLE Doc ADD IF NOT EXISTS hash STRING DEFAULT ''", "ALTER TABLE Doc ADD IF NOT EXISTS links STRING[] DEFAULT []",
+            "ALTER TABLE Secao ADD IF NOT EXISTS startLine INT64 DEFAULT 0", "ALTER TABLE Secao ADD IF NOT EXISTS endLine INT64 DEFAULT 0",
+        ])
+            await drain(await this.conn.query(q), false);
     }
     /** Serializa as queries: leituras paralelas de subagentes dividem uma única Connection. */
     run(cypher, params = {}, forceWrite = false) {

package/dist/graph/vault.js

@@ -0,0 +1,108 @@
+/**
+ * Busca no cofre de Markdown: seções do grafo (Secao) + trechos de livros/aulas do índice SQLite FTS5 (.brito/textos.db,
+ * mantido por Modelos/buscar.py). Cada resultado traz arquivo, linhas ou página e um trecho curto; o 1º também traz os
+ * vizinhos do grafo (LIGA), para o agente seguir o link sem abrir o arquivo.
+ */
+import fs from "node:fs";
+import path from "node:path";
+export const fold = (s) => s.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase();
+const terms = (q) => [...new Set(fold(q).match(/[\p{L}\p{N}]+/gu) ?? [])].filter((t) => t.length > 1 || /\d/.test(t));
+function snippet(texto, ts, width = 220) {
+    const flat = texto.replace(/\s+/g, " ");
+    const f = fold(flat); // fold remove só marcas combinantes: comprimento igual ao de `flat` em texto já em NFC
+    let at = -1;
+    for (const t of ts) {
+        const i = f.indexOf(t);
+        if (i >= 0 && (at < 0 || i < at))
+            at = i;
+    }
+    const a = Math.max(0, (at < 0 ? 0 : at) - 60);
+    return (a ? "… " : "") + flat.slice(a, a + width).trim() + (a + width < flat.length ? " …" : "");
+}
+/** Seções do grafo que contêm TODAS as palavras (sem acento nem caixa). Título pesa mais; frase exata ganha bônus. */
+export async function searchSecoes(graph, query, opts = {}) {
+    const ts = terms(query);
+    if (!ts.length)
+        return [];
+    const rows = await graph.run("MATCH (s:Secao) RETURN s.doc AS doc, s.titulo AS titulo, s.texto AS texto, s.startLine AS a, s.endLine AS b");
+    const em = opts.em ? fold(opts.em) : "";
+    const phrase = ts.join(" ");
+    const hits = [];
+    for (const r of rows) {
+        if (em && !fold(r.doc).includes(em))
+            continue;
+        const f = fold(`${r.titulo}\n${r.texto}`), ft = fold(r.titulo);
+        if (!ts.every((t) => f.includes(t)))
+            continue;
+        let score = 0;
+        for (const t of ts) {
+            score += Math.min(5, f.split(t).length - 1);
+            if (ft.includes(t))
+                score += 5;
+        }
+        if (f.replace(/\s+/g, " ").includes(phrase))
+            score += 6;
+        score /= 1 + Math.log10(1 + f.length / 2000); // não premia seção gigante só por ser longa
+        hits.push({ kind: "md", doc: r.doc, where: `${r.doc}:${r.a}-${r.b}`, title: r.titulo, snippet: snippet(r.texto || r.titulo, ts), score });
+    }
+    return hits.sort((x, y) => y.score - x.score).slice(0, opts.limit ?? 6);
+}
+/** Trechos de livros/aulas (Textos/*.txt) pelo FTS5 do SQLite; vazio se o índice não existe ou o node não tem node:sqlite. */
+export async function searchTextos(root, query, opts = {}) {
+    const file = path.join(root, ".brito", "textos.db");
+    if (!fs.existsSync(file))
+        return [];
+    const ts = terms(query);
+    if (!ts.length)
+        return [];
+    let sqlite;
+    try {
+        sqlite = await import("node:sqlite");
+    }
+    catch {
+        return [];
+    }
+    const db = new sqlite.DatabaseSync(file, { readOnly: true });
+    try {
+        const sql = "SELECT path, loc, snippet(trechos, 2, '«', '»', ' … ', 24) AS t FROM trechos WHERE trechos MATCH ?" + (opts.em ? " AND path LIKE ?" : "") + " ORDER BY rank LIMIT ?";
+        for (const match of [`"${ts.join(" ")}"`, ts.map((t) => `"${t}"`).join(" ")]) { // 1º frase exata, depois todas as palavras
+            const rows = db.prepare(sql).all(...[match, ...(opts.em ? [`%${opts.em}%`] : []), opts.limit ?? 6]);
+            if (rows.length)
+                return rows.map((r, i) => ({ kind: "texto", where: `${r.path.replaceAll("\\", "/")} (${r.loc})`, title: path.basename(r.path).replace(/\.txt$/, ""), snippet: r.t, score: rows.length - i }));
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+    finally {
+        db.close();
+    }
+}
+/** Docs ligados ao documento (entrada e saída), com o tipo da ligação. */
+export async function neighbors(graph, doc, limit = 8) {
+    const out = await graph.run("MATCH (a:Doc {path:$p})-[r:LIGA]->(b:Doc) RETURN b.path AS p, r.tipo AS t LIMIT $n", { p: doc, n: limit });
+    const inn = await graph.run("MATCH (b:Doc)-[r:LIGA]->(a:Doc {path:$p}) RETURN b.path AS p, r.tipo AS t LIMIT $n", { p: doc, n: limit });
+    return [...out.map((r) => `→ ${r.p} (${r.t})`), ...inn.map((r) => `← ${r.p} (${r.t})`)].slice(0, limit);
+}
+export async function vaultSearch(root, graph, query, opts = {}) {
+    const md = await searchSecoes(graph, query, opts);
+    const tx = opts.textos === false ? [] : await searchTextos(root, query, opts);
+    if (!md.length && !tx.length)
+        return "nada encontrado (tente menos palavras ou outra forma da palavra)";
+    const lines = [];
+    if (md.length) {
+        lines.push("## Notas do cofre (.md)");
+        for (const h of md)
+            lines.push(`- ${h.where} | ${h.title} | ${h.snippet}`);
+        const near = await neighbors(graph, md[0].doc);
+        if (near.length)
+            lines.push(`Ligações de ${md[0].doc}:`, ...near.map((n) => `  ${n}`));
+    }
+    if (tx.length) {
+        lines.push("## Livros e aulas (Textos/)");
+        for (const h of tx)
+            lines.push(`- ${h.where} | ${h.snippet}`);
+    }
+    return lines.join("\n");
+}

package/dist/graph/vaultgraph.js

@@ -0,0 +1,89 @@
+/**
+ * O cofre como grafo em memória (Doc + Passagem; arestas LIGA e CITA) para pathfinding e expansão por PageRank.
+ * O corpo (texto das seções) NÃO fica aqui: só os nós e as arestas. Quem mostra o resultado busca o texto no banco.
+ */
+import crypto from "node:crypto";
+import { WGraph } from "./pathfind.js";
+import { fold } from "./vault.js";
+const cache = new WeakMap();
+export const HUB_DEGREE = 40;
+const pair = (a, b) => (a < b ? `${a}|${b}` : `${b}|${a}`);
+export const label = (v, i) => (i < v.nDocs ? v.paths[i] : `[${v.refs[i - v.nDocs]}]`);
+export const relOf = (v, a, b) => v.rel.get(pair(a, b)) ?? "?";
+export async function vaultGraph(store) {
+    const docs = (await store.run("MATCH (d:Doc) RETURN d.path AS p, d.titulo AS t, d.hash AS h ORDER BY p"));
+    const liga = (await store.run("MATCH (a:Doc)-[r:LIGA]->(b:Doc) RETURN a.path AS a, b.path AS b, r.tipo AS t"));
+    const cita = (await store.run("MATCH (d:Doc)-[:CITA]->(p:Passagem) RETURN d.path AS d, p.ref AS r"));
+    const sig = crypto.createHash("sha1").update(docs.map((d) => d.p + d.h).join("\n")).digest("hex") + `:${liga.length}:${cita.length}`;
+    const old = cache.get(store);
+    if (old && old.sig === sig)
+        return old;
+    const idx = new Map(docs.map((d, i) => [d.p, i]));
+    const refIdx = new Map();
+    for (const c of cita)
+        if (!refIdx.has(c.r))
+            refIdx.set(c.r, docs.length + refIdx.size);
+    const edges = new Map();
+    const rel = new Map();
+    const add = (a, b, cost, t) => {
+        const k = pair(a, b);
+        const o = edges.get(k);
+        if (!o || cost < o[2]) {
+            edges.set(k, [a, b, cost]);
+            rel.set(k, t);
+        }
+    };
+    for (const l of liga) {
+        const a = idx.get(l.a), b = idx.get(l.b);
+        if (a !== undefined && b !== undefined && a !== b)
+            add(a, b, l.t === "menciona" ? 1.6 : 1.0, l.t);
+    }
+    for (const c of cita) {
+        const a = idx.get(c.d);
+        if (a !== undefined)
+            add(a, refIdx.get(c.r), 1.2, "cita");
+    }
+    const g = new WGraph(docs.length + refIdx.size, [...edges.values()]);
+    const first = g.deg.findIndex((d) => d > 0);
+    const v = {
+        g, lm: first < 0 ? [] : g.landmarks(8, first), nDocs: docs.length,
+        paths: docs.map((d) => d.p), titles: docs.map((d) => d.t), refs: [...refIdx.keys()], rel, sig,
+    };
+    cache.set(store, v);
+    return v;
+}
+/** Resolve um nome (caminho, título, nome de arquivo ou passagem "Rm 9.13") para nós. Exato primeiro, depois por inclusão. */
+export function resolveEntity(v, q) {
+    const f = fold(q).trim();
+    if (!f)
+        return [];
+    const names = (i) => [fold(v.paths[i]), fold(v.paths[i].replace(/\.\w+$/, "")), fold(v.paths[i].split("/").pop().replace(/\.\w+$/, "")), fold(v.titles[i] ?? "")];
+    const exact = [];
+    for (let i = 0; i < v.nDocs; i++)
+        if (names(i).includes(f))
+            exact.push(i);
+    v.refs.forEach((r, k) => { if (fold(r) === f)
+        exact.push(v.nDocs + k); });
+    if (exact.length)
+        return exact;
+    const part = [];
+    for (let i = 0; i < v.nDocs; i++)
+        if (names(i).some((n) => n.length >= 3 && n.includes(f)))
+            part.push(i);
+    return part.sort((a, b) => v.paths[a].length - v.paths[b].length).slice(0, 5);
+}
+/** Entidades nomeadas na pergunta: títulos de nota que aparecem inteiros no texto (a mais longa vence a que ela contém). */
+export function entitiesIn(v, query) {
+    const clean = (s) => fold(s).replace(/[^\p{L}\p{N}.]+/gu, " ").trim();
+    const q = ` ${clean(query)} `;
+    const hit = [];
+    for (let i = 0; i < v.nDocs; i++) {
+        const t = clean(v.titles[i] ?? "");
+        if (t.length >= 4 && q.includes(` ${t} `))
+            hit.push(i);
+    }
+    const keep = hit.filter((i) => !hit.some((j) => j !== i && clean(v.titles[j]).includes(clean(v.titles[i])) && clean(v.titles[j]).length > clean(v.titles[i]).length));
+    v.refs.forEach((r, k) => { if (q.includes(` ${fold(r)} `))
+        keep.push(v.nDocs + k); });
+    return keep;
+}

package/dist/graph/vaultquery.js

@@ -0,0 +1,103 @@
+import { vaultSearch } from "./vault.js";
+import { searchSecoes } from "./vault.js";
+import { HUB_DEGREE, entitiesIn, label, relOf, resolveEntity, vaultGraph } from "./vaultgraph.js";
+const isNote = (v, i) => i < v.nDocs && v.paths[i].endsWith(".md") && !/^(Diário de estudo|Modelos)\//.test(v.paths[i]) && !v.paths[i].startsWith("00 ");
+const clip = (s, n = 150) => { const f = s.replace(/\s+/g, " ").trim(); return f.length > n ? f.slice(0, n) + " …" : f; };
+async function intro(store, doc) {
+    const rows = await store.run("MATCH (s:Secao {doc:$d}) RETURN s.texto AS x ORDER BY s.ordem LIMIT 6", { d: doc });
+    for (const r of rows) {
+        // pula seções que são só lista de links ou nota de página: pega a primeira com prosa
+        const prose = String(r.x).split("\n").filter((l) => !/^\s*[-*]?\s*(\[\[[^\]]*\]\]\s*)+$/.test(l) && !/^\s*Páginas\s*=/.test(l)).join(" ").replace(/\[\[([^\]|]*)(?:\|[^\]]*)?\]\]/g, "$1");
+        if (prose.replace(/\s+/g, " ").trim().length >= 40)
+            return clip(prose);
+    }
+    return "";
+}
+/** Por que `r` apareceu: ligação direta com uma semente ou um vizinho em comum com ela. */
+function via(v, r, seeds) {
+    const S = new Set(seeds);
+    for (const e of v.g.adj[r])
+        if (S.has(e.to))
+            return `${label(v, e.to)} (${relOf(v, r, e.to)})`;
+    const nbS = new Map();
+    for (const s of seeds)
+        for (const e of v.g.adj[s])
+            if (!nbS.has(e.to))
+                nbS.set(e.to, s);
+    for (const e of v.g.adj[r])
+        if (nbS.has(e.to) && v.g.deg[e.to] <= HUB_DEGREE)
+            return `${label(v, nbS.get(e.to))} → ${label(v, e.to)} (${relOf(v, r, e.to)})`;
+    return "";
+}
+export async function vaultSearchGraph(root, store, query, opts = {}) {
+    const base = await vaultSearch(root, store, query, opts);
+    const v = await vaultGraph(store);
+    if (!v.nDocs)
+        return base;
+    const ents = entitiesIn(v, query);
+    const hits = await searchSecoes(store, query, { em: opts.em, limit: 10 });
+    const hitIdx = [];
+    for (const h of hits) {
+        const i = v.paths.indexOf(h.doc);
+        if (i >= 0 && !hitIdx.includes(i))
+            hitIdx.push(i);
+    }
+    const join = ents.length >= 2;
+    const seeds = join ? ents.slice(0, 4) : [...new Set([...ents, ...hitIdx.slice(0, 3)])];
+    if (!seeds.length)
+        return base;
+    const w = new Map();
+    if (join)
+        seeds.forEach((s) => w.set(s, 1));
+    else {
+        ents.forEach((e) => w.set(e, 2));
+        hitIdx.slice(0, 3).forEach((d, i) => w.set(d, (w.get(d) ?? 0) + 1 / (1 + i)));
+    }
+    const p = v.g.ppr(w);
+    const skip = new Set([...seeds, ...(join ? [] : hitIdx)]);
+    const cand = [];
+    for (let i = 0; i < v.nDocs; i++)
+        if (p[i] > 0 && !skip.has(i) && isNote(v, i) && v.g.deg[i] <= HUB_DEGREE * 2)
+            cand.push(i);
+    cand.sort((a, b) => p[b] - p[a]);
+    const top = cand.slice(0, opts.limit ?? 5);
+    if (!top.length)
+        return base;
+    const head = join ? `## Notas ligadas a ${seeds.map((s) => label(v, s)).join(" e ")} (junção no grafo)` : "## Relacionadas pelo grafo (não citam as palavras, mas se ligam às notas achadas)";
+    const lines = [head];
+    for (const r of top)
+        lines.push(`- ${v.paths[r]} | ${v.titles[r]}${via(v, r, seeds) ? ` | via ${via(v, r, seeds)}` : ""}`);
+    return join ? `${lines.join("\n")}\n\n${base}` : `${base}\n\n${lines.join("\n")}`;
+}
+/** Caminho de menor custo entre duas notas/passagens, com a relação de cada salto e o início do texto de cada nota. */
+export async function vaultPath(store, de, para) {
+    const v = await vaultGraph(store);
+    const A = resolveEntity(v, de), B = resolveEntity(v, para);
+    if (!A.length)
+        return `não achei nada para "${de}" (use título, caminho ou passagem como "Rm 9.13")`;
+    if (!B.length)
+        return `não achei nada para "${para}" (use título, caminho ou passagem como "Rm 9.13")`;
+    const a = A[0], b = B[0];
+    const notes = [];
+    if (A.length > 1)
+        notes.push(`"${de}" casa com ${A.length} itens; usei ${label(v, a)} (outros: ${A.slice(1, 4).map((x) => label(v, x)).join(", ")})`);
+    if (B.length > 1)
+        notes.push(`"${para}" casa com ${B.length} itens; usei ${label(v, b)} (outros: ${B.slice(1, 4).map((x) => label(v, x)).join(", ")})`);
+    if (a === b)
+        return "origem e destino são o mesmo item";
+    const r = v.g.astar(a, b, v.lm);
+    if (!r.path.length)
+        return `sem caminho entre ${label(v, a)} e ${label(v, b)}`;
+    const out = [`Caminho de menor custo (${r.path.length - 1} saltos, custo ${r.cost.toFixed(2)}, ${r.settled} nós visitados):`];
+    for (let k = 0; k < r.path.length; k++) {
+        const n = r.path[k];
+        const text = n < v.nDocs ? await intro(store, v.paths[n]) : "";
+        out.push(`${k + 1}. ${label(v, n)}${n < v.nDocs && v.titles[n] ? ` — ${v.titles[n]}` : ""}${text ? `\n     ${text}` : ""}`);
+        if (k < r.path.length - 1)
+            out.push(`   ↓ ${relOf(v, n, r.path[k + 1])}`);
+    }
+    const hubs = r.path.slice(1, -1).filter((n) => v.g.deg[n] > HUB_DEGREE);
+    if (hubs.length)
+        out.push(`Aviso: o caminho passa por nó muito ligado (${hubs.map((n) => label(v, n)).join(", ")}); a relação pode ser fraca.`);
+    return [...notes, ...out].join("\n");
+}

package/dist/mcp/server.js

@@ -12,6 +12,7 @@ import { implementIo } from "../tools/implement.js";
 import "../tools/spec.js";
 import { ORCH_ONLY, orch } from "../orchestrator.js";
 import "../tools/digest.js";
+import "../tools/vault.js";
 import { allTools, execTool } from "../tools/registry.js";
 import { GraphStore } from "../graph/store.js";
 import { INDEXED_EXTENSIONS, indexProject } from "../graph/indexer.js";
@@ -34,7 +35,7 @@ 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$|implement$)/.test(tool);
+export const alwaysLoaded = (tool) => /^(graph_|recall$|remember$|skill_load$|digest$|implement$|vault_)/.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. */

package/dist/tools/vault.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { defineTool } from "./registry.js";
+import { vaultPath, vaultSearchGraph } from "../graph/vaultquery.js";
+defineTool({
+    name: "vault_search",
+    concurrent: true,
+    readsGraph: true,
+    description: "Busca por palavras num cofre de notas Markdown (sem acento nem caixa, todas as palavras): devolve seções de .md com arquivo e linhas (`arq.md:12-30`), os vizinhos do 1º resultado no grafo ([[links]]) as notas relacionadas pelo grafo (que não citam as palavras mas se ligam às achadas; com 2 entidades na pergunta, as notas ligadas às duas) e, se houver índice, trechos de livros/aulas com página. USE ANTES de abrir arquivos ou PDFs; depois leia só a faixa de linhas indicada.",
+    schema: z.object({
+        query: z.string().describe("palavras ou frase"),
+        em: z.string().optional().describe("limita a caminhos que contêm este texto (ex.: 'Temas/', 'Frame')"),
+        limit: z.number().int().min(1).max(20).optional(),
+    }),
+    async run({ query, em, limit }, { root, graph }) {
+        return vaultSearchGraph(root, graph, query, { em, limit });
+    },
+});
+defineTool({
+    name: "vault_path",
+    concurrent: true,
+    readsGraph: true,
+    description: "Como duas notas ou passagens se ligam: caminho de menor custo no grafo do cofre (A*), com a relação de cada salto (autor, fonte, temas, menciona, cita) e o início do texto de cada nota. Evita nós muito ligados. USE para 'como X se relaciona com Y?'. Aceita título, caminho ou passagem ('Rm 9.13').",
+    schema: z.object({
+        de: z.string().describe("nota ou passagem de origem"),
+        para: z.string().describe("nota ou passagem de destino"),
+    }),
+    async run({ de, para }, { graph }) {
+        return vaultPath(graph, de, para);
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Coding-agent CLI with a code knowledge graph, memory and reviewable skills / CLI de agente de código com grafo de conhecimento, memória e skills revisáveis",
   "type": "module",
   "bin": {