brito-cli 0.7.5 → 0.9.0

package/dist/desktop/serve.js

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

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

package/dist/local/digest.js

@@ -0,0 +1,202 @@
+import { words } from "../skills/store.js";
+import { slmGenerate } from "./slm.js";
+const PAGE_RE = /^=== PÁGINA (\d+) ===\s*$/m;
+/** Texto comparável: sem hífen de quebra de linha, sem caixa/acentos, espaços colapsados. */
+export const norm = (s) => s.replace(/­\s*/g, "").replace(/-\s*\n\s*/g, "").toLowerCase().normalize("NFD").replace(/\p{M}/gu, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+/** Comparação tolerante a OCR: só letras e dígitos (espaços no meio de palavras, hifenização e pontuação não contam). */
+export const squash = (s) => norm(s).replace(/ /g, "");
+const META_RE = /sum[áa]rio|[íi]ndice (remissivo|geral)|todos os direitos|catalog[aã]{1,2}o|isbn|copyright|ficha t[ée]cnica|dados internacionais|agradecimentos|impresso no brasil/i;
+/**
+ * Tira páginas que não são conteúdo: capa, orelha e elogios (as primeiras páginas de um livro longo) e páginas de
+ * metadados (sumário, ficha catalográfica, direitos). Só age em textos com marcas de página e com 60 páginas ou mais:
+ * num capítulo curto, a primeira página É conteúdo.
+ */
+export function stripFrontMatter(text) {
+    const parts = text.split(/(?=^=== PÁGINA \d+ ===\s*$)/m);
+    const marked = parts.filter((p) => PAGE_RE.test(p));
+    if (marked.length < 60)
+        return { text, removed: 0 };
+    const head = Math.min(8, Math.ceil(marked.length * 0.02));
+    let removed = 0;
+    const kept = parts.filter((p) => {
+        const n = Number(PAGE_RE.exec(p)?.[1] ?? NaN);
+        if (!n)
+            return true;
+        // cue de metadados só vale perto das pontas, para não apagar um capítulo que cita "índice" ou "direitos"
+        const edge = n <= head + 12 || n > marked.length - 6;
+        const drop = n <= head || (edge && p.length < 4000 && META_RE.test(p));
+        if (drop)
+            removed++;
+        return !drop;
+    });
+    return { text: kept.join(""), removed };
+}
+/** Divide em blocos de ~chunkChars, respeitando as marcas "=== PÁGINA N ===" quando existem. */
+export function chunkText(text, chunkChars = 5000) {
+    const parts = text.split(/(?=^=== PÁGINA \d+ ===\s*$)/m);
+    const pages = parts.map((p) => ({ page: Number(PAGE_RE.exec(p)?.[1] ?? NaN) || null, text: p }));
+    const out = [];
+    let cur = [];
+    let size = 0;
+    const flush = () => { if (cur.length)
+        out.push({ text: cur.map((p) => p.text).join("\n"), pages: cur }); cur = []; size = 0; };
+    for (const pg of pages) {
+        // página gigante (ou texto sem marcas): fatia por tamanho
+        if (pg.text.length > chunkChars * 1.5) {
+            flush();
+            for (let i = 0; i < pg.text.length; i += chunkChars) {
+                const t = pg.text.slice(i, i + chunkChars);
+                out.push({ text: t, pages: [{ page: pg.page, text: t }] });
+            }
+            continue;
+        }
+        if (size + pg.text.length > chunkChars)
+            flush();
+        cur.push(pg);
+        size += pg.text.length;
+    }
+    flush();
+    return out;
+}
+/** Afinidade lexical (barata, sem modelo) entre o objetivo e cada bloco: escolhe onde vale gastar o SLM. */
+export function rankChunks(chunks, objective) {
+    const q = [...new Set(words(objective))];
+    return chunks.map((c, index) => {
+        const t = norm(c.text);
+        let score = 0;
+        for (const w of q) {
+            const m = t.split(w).length - 1;
+            score += m ? 1 + Math.log(m) : 0;
+        }
+        return { ...c, score, index };
+    });
+}
+/** Página onde a citação aparece (a primeira página do bloco em que ela cabe inteira; senão a primeira em que começa). */
+function pageOf(c, quoteSq) {
+    for (const p of c.pages)
+        if (squash(p.text).includes(quoteSq))
+            return p.page;
+    const head = quoteSq.slice(0, 40);
+    for (const p of c.pages)
+        if (squash(p.text).includes(head))
+            return p.page;
+    return c.pages[0]?.page ?? null;
+}
+/** Confere as citações propostas contra o texto do bloco. Só passa o que existe literalmente (após normalização). */
+export function verifyExcerpts(c, proposed) {
+    const body = squash(c.text);
+    const kept = [];
+    let discarded = 0;
+    for (const p of proposed) {
+        const quote = typeof p?.quote === "string" ? p.quote.trim() : "";
+        const qn = squash(quote);
+        if (qn.length < 25 || !body.includes(qn)) {
+            discarded++;
+            continue;
+        }
+        kept.push({ quote, topic: typeof p.topic === "string" && p.topic.trim() ? p.topic.trim().slice(0, 80) : "Geral", page: pageOf(c, qn), chunk: c.index });
+    }
+    return { kept, discarded };
+}
+const EXTRACT_SCHEMA = {
+    type: "object",
+    properties: { excerpts: { type: "array", maxItems: 4, items: { type: "object", properties: { quote: { type: "string" }, topic: { type: "string" } }, required: ["quote", "topic"] } } },
+    required: ["excerpts"],
+};
+const OUTLINE_SCHEMA = {
+    type: "object",
+    properties: { sections: { type: "array", maxItems: 8, items: { type: "object", properties: { heading: { type: "string" }, quotes: { type: "array", items: { type: "integer" } } }, required: ["heading", "quotes"] } } },
+    required: ["sections"],
+};
+const parse = (s) => { try {
+    return JSON.parse(s);
+}
+catch {
+    return null;
+} };
+export async function digest(o) {
+    const gen = o.gen ?? slmGenerate;
+    const front = stripFrontMatter(o.text);
+    const ranked = rankChunks(chunkText(front.text, o.chunkChars), o.objective);
+    const chosen = [...ranked].filter((c) => c.score > 0).sort((a, b) => b.score - a.score).slice(0, o.maxChunks ?? 8).sort((a, b) => a.index - b.index);
+    const stats = { chunks: ranked.length, analyzed: chosen.length, proposed: 0, verified: 0, discarded: 0, skippedPages: front.removed };
+    const system = `Você extrai trechos de um texto longo para um objetivo. Responda SOMENTE com JSON {"excerpts":[{"quote","topic"}]}.
+Regras: (1) "quote" é uma cópia EXATA e contínua de 1 a 3 frases do texto dado; nunca parafraseie, resuma nem corrija. (2) Escolha só trechos que ajudam o objetivo; prefira incluir um trecho duvidoso a perder um bom. (3) O texto pode ter erros de OCR (espaços no meio de palavras, hifenização): copie as PALAVRAS exatamente, corrigindo só esses espaços. (4) "topic" é um rótulo curto (2 a 5 palavras) do assunto do trecho. (5) Se nada serve, responda {"excerpts":[]}.`;
+    const found = [];
+    const seen = new Set();
+    let n = 0;
+    for (const c of chosen) {
+        n++;
+        o.onProgress?.(`analisando bloco ${n}/${chosen.length}`);
+        let data = null;
+        try {
+            data = parse(await gen({ system, user: `Objetivo: ${o.objective}\n\nTexto:\n${c.text}`, schema: EXTRACT_SCHEMA, maxTokens: 900, temperature: 0.1, signal: o.signal }));
+        }
+        catch (e) {
+            if (o.signal?.aborted)
+                throw e;
+        }
+        const proposed = Array.isArray(data?.excerpts) ? data.excerpts : [];
+        stats.proposed += proposed.length;
+        const { kept, discarded } = verifyExcerpts(c, proposed);
+        stats.discarded += discarded;
+        for (const k of kept) {
+            const key = squash(k.quote);
+            if (!seen.has(key)) {
+                seen.add(key);
+                found.push(k);
+            }
+        }
+    }
+    stats.verified = found.length;
+    // Plano: o SLM agrupa por número; índices inválidos são ignorados, e o que sobrar cai em "Outros".
+    let sections = [];
+    if (found.length > 1) {
+        o.onProgress?.("montando o plano");
+        const list = found.map((f, i) => `${i}. [${f.topic}] ${f.quote.replace(/\s+/g, " ").slice(0, 160)}`).join("\n");
+        try {
+            const plan = parse(await gen({ system: `Você organiza trechos num plano para o objetivo dado. Responda SOMENTE com JSON {"sections":[{"heading","quotes":[números]}]}. Cada número de trecho aparece em UMA seção; os títulos seguem a ordem lógica do argumento (máx. 8).`, user: `Objetivo: ${o.objective}\n\nTrechos:\n${list}`, schema: OUTLINE_SCHEMA, maxTokens: 700, temperature: 0.1, signal: o.signal }));
+            const used = new Set();
+            for (const s of Array.isArray(plan?.sections) ? plan.sections : []) {
+                const items = (Array.isArray(s?.quotes) ? s.quotes : []).filter((i) => Number.isInteger(i) && i >= 0 && i < found.length && !used.has(i));
+                items.forEach((i) => used.add(i));
+                if (items.length && typeof s.heading === "string")
+                    sections.push({ heading: s.heading.trim().slice(0, 100), items });
+            }
+            const rest = found.map((_, i) => i).filter((i) => !used.has(i));
+            if (rest.length)
+                sections.push({ heading: "Outros trechos", items: rest });
+        }
+        catch (e) {
+            if (o.signal?.aborted)
+                throw e;
+            sections = [];
+        }
+    }
+    if (!sections.length) {
+        const byTopic = new Map();
+        found.forEach((f, i) => byTopic.set(f.topic, [...(byTopic.get(f.topic) ?? []), i]));
+        sections = [...byTopic].map(([heading, items]) => ({ heading, items }));
+    }
+    return { markdown: render(o, found, sections, stats), stats };
+}
+function render(o, found, sections, s) {
+    const cite = (e) => (e.page ? ` (p. ${e.page})` : "");
+    const body = sections.map((sec) => `### ${sec.heading}\n${sec.items.map((i) => `- “${found[i].quote.replace(/\s+/g, " ")}”${cite(found[i])}`).join("\n")}`).join("\n\n");
+    return `---
+tipo: digest
+fonte: ${o.source}
+objetivo: ${o.objective.replace(/\n/g, " ")}
+gerado-por: SLM local
+---
+# Digest: ${o.objective.replace(/\n/g, " ")}
+
+> Rascunho de um modelo pequeno. Os trechos entre aspas foram CONFERIDOS no texto-fonte (mesmas palavras; só espaços e hifenização de OCR foram normalizados; páginas conforme as marcas do arquivo). A SELEÇÃO e o agrupamento podem ser incompletos: foram analisados ${s.analyzed} de ${s.chunks} blocos${s.skippedPages ? ` (${s.skippedPages} página(s) de capa/orelha/metadados ignoradas)` : ""} (os de maior afinidade com o objetivo); ${s.discarded} citação(ões) proposta(s) foram descartadas por não existirem no texto.
+
+## Plano
+${sections.map((sec, i) => `${i + 1}. ${sec.heading} (${sec.items.length})`).join("\n") || "(nenhum trecho verificado)"}
+
+## Trechos
+${body || "(nenhum trecho verificado)"}
+`;
+}