@fontdata/ai-harness 2.0.0 → 2.1.0

package/dist/contratos/eventos.js

@@ -0,0 +1,103 @@
+/** Validação do rastro de eventos (docs/contratos/EVENTOS.md). */
+export const EVENT_VERSION = 1;
+export const EVENTS = [
+    'trabalho_iniciado',
+    'trabalho_concluido',
+    'task_iniciada',
+    'task_concluida',
+    'suite_verde',
+    'suite_vermelha',
+    'hook_aviso',
+    'hook_bloqueio',
+    'agent_veredito',
+    'bloqueio_aberto',
+    'bloqueio_fechado',
+    'decisao_registrada',
+    'relatorio_gerado',
+];
+export const EVENT_KEYS = ['v', 'ts', 'trabalho_id', 'evento', 'origem', 'nome', 'task_id', 'modo', 'resultado', 'dados'];
+const ORIGINS = ['hook', 'comando', 'agent', 'cli'];
+const MODES = ['aviso', 'bloqueio', 'desligado'];
+const RESULTS = ['ok', 'aviso', 'bloqueio', 'falha'];
+const TASK_EVENTS = new Set(['task_iniciada', 'task_concluida', 'suite_verde', 'suite_vermelha']);
+const HOOK_EVENTS = new Set(['hook_aviso', 'hook_bloqueio']);
+const TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+const TASK_ID = /^T-\d{2}\.\d{2}$/;
+function validateLine(event, line) {
+    const problems = [];
+    const push = (regra, mensagem) => problems.push({ linha: line, regra, mensagem });
+    const keys = Object.keys(event);
+    const missing = EVENT_KEYS.filter((key) => !(key in event));
+    const extra = keys.filter((key) => !EVENT_KEYS.includes(key));
+    for (const key of missing)
+        push('chave-ausente', `Chave obrigatória ausente: ${key}.`);
+    for (const key of extra)
+        push('chave-extra', `Chave fora do contrato: ${key}.`);
+    if (!missing.length && !extra.length && keys.join() !== EVENT_KEYS.join()) {
+        push('ordem-das-chaves', `As chaves precisam seguir a ordem ${EVENT_KEYS.join(', ')}.`);
+    }
+    if (typeof event.v === 'number' && event.v > EVENT_VERSION) {
+        push('versao-futura', `Versão ${event.v} do formato é mais nova que a suportada (${EVENT_VERSION}).`);
+    }
+    else if ('v' in event && event.v !== EVENT_VERSION) {
+        push('formato-invalido', `v deve ser ${EVENT_VERSION}.`);
+    }
+    if ('evento' in event && !EVENTS.includes(String(event.evento))) {
+        push('evento-desconhecido', `Evento fora do vocabulário: ${String(event.evento)}.`);
+    }
+    if ('ts' in event && (typeof event.ts !== 'string' || !TIMESTAMP.test(event.ts))) {
+        push('formato-invalido', 'ts deve estar em ISO 8601 UTC com milissegundos (AAAA-MM-DDTHH:MM:SS.mmmZ).');
+    }
+    if ('origem' in event && !ORIGINS.includes(String(event.origem))) {
+        push('formato-invalido', `origem inválida: ${String(event.origem)}. Use: ${ORIGINS.join(', ')}.`);
+    }
+    if ('trabalho_id' in event && event.trabalho_id !== null && typeof event.trabalho_id !== 'string') {
+        push('formato-invalido', 'trabalho_id deve ser texto ou null.');
+    }
+    const eventName = String(event.evento);
+    if ('task_id' in event) {
+        if (event.task_id === null) {
+            if (TASK_EVENTS.has(eventName))
+                push('task-ausente', `O evento ${eventName} exige task_id.`);
+        }
+        else if (typeof event.task_id !== 'string' || !TASK_ID.test(event.task_id)) {
+            push('formato-invalido', 'task_id deve seguir o padrão T-SS.NN.');
+        }
+    }
+    if ('modo' in event) {
+        if (event.modo === null) {
+            if (HOOK_EVENTS.has(eventName))
+                push('modo-ausente', `O evento ${eventName} exige modo.`);
+        }
+        else if (!MODES.includes(String(event.modo))) {
+            push('formato-invalido', `modo inválido: ${String(event.modo)}. Use: ${MODES.join(', ')}.`);
+        }
+    }
+    if ('resultado' in event && event.resultado !== null && !RESULTS.includes(String(event.resultado))) {
+        push('formato-invalido', `resultado inválido: ${String(event.resultado)}. Use: ${RESULTS.join(', ')}.`);
+    }
+    if ('dados' in event && event.dados !== null && (typeof event.dados !== 'object' || Array.isArray(event.dados))) {
+        push('formato-invalido', 'dados deve ser um objeto ou null.');
+    }
+    return problems;
+}
+/** Valida o conteúdo de um arquivo de rastro; a última linha sem `\n` é ignorada (escrita em andamento). */
+export function validateEventLog(content) {
+    const complete = content.split('\n').slice(0, -1);
+    return complete.flatMap((text, index) => {
+        const line = index + 1;
+        if (!text.trim())
+            return [];
+        let event;
+        try {
+            event = JSON.parse(text);
+        }
+        catch {
+            return [{ linha: line, regra: 'json-invalido', mensagem: 'A linha não é um JSON válido.' }];
+        }
+        if (typeof event !== 'object' || event === null || Array.isArray(event)) {
+            return [{ linha: line, regra: 'json-invalido', mensagem: 'A linha precisa ser um objeto JSON.' }];
+        }
+        return validateLine(event, line);
+    });
+}

package/dist/doctor/checks.js

@@ -0,0 +1,424 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { allCommands, loadCatalog } from '../catalog.js';
+import { CONFIG_PATH, readConfig } from '../config/config.js';
+import { readArtifact, validateAllWorks, WORKS_DIR } from '../contratos/artefatos.js';
+import { validateEventLog } from '../contratos/eventos.js';
+import { hashContent, LOCK_PATH, LOCK_VERSION } from '../install/lock.js';
+import { SETTINGS_PATH } from '../install/settings.js';
+import { adoptLegacyInstall } from '../update/legado.js';
+const MIN_NODE_MAJOR = 22;
+const PLUGIN_ID = 'fontdata@ai-harness';
+const HARNESS_HOOKS_DIR = '.claude/hooks/ai-harness/';
+const REINSTALL = 'Restaure com `npx @fontdata/ai-harness update --yes`.';
+const CONTRACT_URL = 'https://github.com/fontdata-tecnologia/ai-harness/blob/master/docs/contratos/ARTEFATOS.md';
+const EVENTS_CONTRACT_URL = 'https://github.com/fontdata-tecnologia/ai-harness/blob/master/docs/contratos/EVENTOS.md';
+const EVENTS_DIR = join('docs', 'eventos');
+/** Regras cuja violação impede ler o artefato ou seguir o plano; as demais são avisos. */
+const CONTRACT_ERRORS = new Set(['yaml-invalido', 'schema-futuro', 'ciclo-dependencia']);
+function checkNode(version) {
+    const major = Number(version.split('.')[0]);
+    if (major >= MIN_NODE_MAJOR)
+        return [];
+    return [
+        {
+            id: 'node-antigo',
+            severidade: 'erro',
+            mensagem: `O Node ${version} está abaixo do mínimo exigido (${MIN_NODE_MAJOR}).`,
+            correcao: `Atualize o Node.js para a versão ${MIN_NODE_MAJOR} ou superior.`,
+        },
+    ];
+}
+function checkLock(root) {
+    const file = join(root, LOCK_PATH);
+    if (!existsSync(file)) {
+        const legacy = adoptLegacyInstall(root);
+        if (legacy) {
+            return {
+                lock: null,
+                findings: [
+                    {
+                        id: 'lock-ausente-legado',
+                        severidade: 'aviso',
+                        mensagem: `Instalação ${legacy.pacote.versao} sem ${LOCK_PATH}: os arquivos em .claude/ não podem ser conferidos nem atualizados.`,
+                        correcao: 'Rode `npx @fontdata/ai-harness update` para ver as mudanças e `update --yes` para migrar para a versão atual.',
+                    },
+                ],
+            };
+        }
+        return {
+            lock: null,
+            findings: [
+                {
+                    id: 'lock-ausente',
+                    severidade: 'aviso',
+                    mensagem: `Nenhuma instalação do ai-harness registrada neste projeto (${LOCK_PATH} não existe).`,
+                    correcao: 'Rode `npx @fontdata/ai-harness init` para instalar. Se você usa só o modo npx ou o plugin global, ignore este aviso.',
+                },
+            ],
+        };
+    }
+    let lock;
+    try {
+        lock = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return {
+            lock: null,
+            findings: [
+                {
+                    id: 'lock-invalido',
+                    severidade: 'erro',
+                    mensagem: `O ${LOCK_PATH} está com JSON inválido.`,
+                    correcao: `Restaure o arquivo pelo git (\`git checkout -- ${LOCK_PATH}\`) ou reinstale com \`npx @fontdata/ai-harness init --yes\`.`,
+                },
+            ],
+        };
+    }
+    if (lock.lock_versao > LOCK_VERSION) {
+        return {
+            lock: null,
+            findings: [
+                {
+                    id: 'lock-futuro',
+                    severidade: 'erro',
+                    mensagem: `O ${LOCK_PATH} foi gerado por uma versão mais nova do ai-harness (lock_versao ${lock.lock_versao}).`,
+                    correcao: 'Atualize o pacote: `npx @fontdata/ai-harness@latest doctor`.',
+                },
+            ],
+        };
+    }
+    return { findings: [], lock };
+}
+function checkFiles(root, lock) {
+    const findings = [];
+    for (const item of lock.itens) {
+        for (const entry of item.arquivos) {
+            const file = join(root, entry.caminho);
+            if (!existsSync(file)) {
+                findings.push({
+                    id: 'arquivo-faltando',
+                    severidade: 'erro',
+                    mensagem: `Arquivo instalado não encontrado: ${entry.caminho} (${item.tipo} ${item.id}).`,
+                    correcao: REINSTALL,
+                });
+            }
+            else if (hashContent(readFileSync(file)) !== entry.sha256) {
+                findings.push({
+                    id: 'arquivo-modificado',
+                    severidade: 'aviso',
+                    mensagem: `Arquivo alterado localmente desde a instalação: ${entry.caminho}.`,
+                    correcao: 'Se a alteração é intencional, mantenha: atualizações não sobrescrevem arquivos alterados sem confirmação.',
+                });
+            }
+        }
+    }
+    return findings;
+}
+function checkRequiredSkills(root, lock) {
+    const installed = new Set(lock.itens.filter((item) => item.tipo === 'comando' || item.tipo === 'skill').map((item) => item.id));
+    const missing = new Map();
+    for (const cmd of allCommands(loadCatalog())) {
+        if (!installed.has(cmd.id))
+            continue;
+        for (const skill of cmd.requiresSkills ?? []) {
+            if (!existsSync(join(root, '.claude', 'skills', skill, 'SKILL.md')) && !missing.has(skill))
+                missing.set(skill, cmd.id);
+        }
+    }
+    return [...missing].map(([skill, cmd]) => ({
+        id: 'skill-exigida-ausente',
+        severidade: 'erro',
+        mensagem: `O comando /${cmd} exige a skill ${skill}, que não está instalada.`,
+        correcao: `Reinstale com \`npx @fontdata/ai-harness init --comandos ${cmd} --sem-harness --conflito sobrescrever --yes\`.`,
+    }));
+}
+function checkAgents(root) {
+    const dir = join(root, '.claude', 'agents');
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith('.md'))
+        .filter((name) => {
+        const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(readFileSync(join(dir, name), 'utf8'))?.[1] ?? '';
+        return !/^tools:\s*\S/m.test(frontmatter);
+    })
+        .map((name) => ({
+        id: 'agent-sem-tools',
+        severidade: 'aviso',
+        mensagem: `O agent .claude/agents/${name} não declara tools: e herda todas as ferramentas da sessão.`,
+        correcao: 'Declare `tools:` só com as ferramentas de que ele precisa (ex.: `tools: Read, Grep, Glob`).',
+    }));
+}
+function hookCommands(hooks) {
+    return Object.values(hooks).flatMap((groups) => (Array.isArray(groups) ? groups : []).flatMap((group) => (group.hooks ?? []).map((hook) => hook.command ?? '')));
+}
+function checkSettings(root) {
+    const file = join(root, SETTINGS_PATH);
+    if (!existsSync(file))
+        return [];
+    let settings;
+    try {
+        settings = JSON.parse(readFileSync(file, 'utf8'));
+        if (typeof settings !== 'object' || settings === null || Array.isArray(settings))
+            throw new Error('não é objeto');
+    }
+    catch {
+        return [
+            {
+                id: 'settings-invalido',
+                severidade: 'erro',
+                mensagem: `O ${SETTINGS_PATH} está com JSON inválido; o Claude Code ignora hooks e permissões dele.`,
+                correcao: 'Corrija o JSON do arquivo (ou restaure pelo git) antes de instalar ou atualizar hooks.',
+            },
+        ];
+    }
+    const findings = [];
+    const commands = hookCommands(settings.hooks ?? {});
+    for (const command of commands) {
+        for (const match of command.matchAll(/[^\s"']*\.claude\/hooks\/[^\s"']+/g)) {
+            const path = match[0].slice(match[0].indexOf('.claude/hooks/'));
+            if (existsSync(join(root, path)))
+                continue;
+            findings.push({
+                id: 'hook-script-ausente',
+                severidade: 'erro',
+                mensagem: `O hook "${command}" aponta para ${path}, que não existe.`,
+                correcao: 'Reinstale os hooks com `npx @fontdata/ai-harness init` ou remova a entrada do settings.json.',
+            });
+        }
+    }
+    const plugins = settings.enabledPlugins;
+    const pluginEnabled = Array.isArray(plugins) ? plugins.includes(PLUGIN_ID) : plugins?.[PLUGIN_ID] === true;
+    if (pluginEnabled && commands.some((command) => command.includes(HARNESS_HOOKS_DIR))) {
+        findings.push({
+            id: 'hooks-duplicados',
+            severidade: 'aviso',
+            mensagem: `O plugin ${PLUGIN_ID} está habilitado e o projeto também registra os hooks do harness no ${SETTINGS_PATH}; cada hook roda duas vezes.`,
+            correcao: `Remova do settings.json os hooks de ${HARNESS_HOOKS_DIR} ou desabilite o plugin neste projeto.`,
+        });
+    }
+    return findings;
+}
+function checkGitIgnore(root) {
+    if (!existsSync(join(root, '.git')))
+        return [];
+    try {
+        // `check-ignore -q` sai com 0 quando o caminho está ignorado e com 1 quando não está.
+        execFileSync('git', ['check-ignore', '-q', LOCK_PATH], { cwd: root, stdio: 'ignore' });
+    }
+    catch {
+        return [];
+    }
+    return [
+        {
+            id: 'ai-harness-ignorado',
+            severidade: 'erro',
+            mensagem: 'A pasta .ai-harness/ está ignorada pelo git, mas o lock e a configuração do harness precisam ser versionados.',
+            correcao: 'Remova .ai-harness/ do .gitignore; só a subpasta .ai-harness/memoria/ pode continuar ignorada.',
+        },
+    ];
+}
+function checkWorks(root) {
+    return validateAllWorks(root).map((problem) => ({
+        id: `contrato-${problem.regra}`,
+        severidade: CONTRACT_ERRORS.has(problem.regra) ? 'erro' : 'aviso',
+        mensagem: `${problem.arquivo}${problem.linha ? ` (linha ${problem.linha})` : ''}: ${problem.mensagem}`,
+        correcao: `Ajuste o artefato conforme o contrato: ${CONTRACT_URL}`,
+    }));
+}
+function checkStaleBlocks(root, now, maxDays) {
+    const dir = join(root, WORKS_DIR);
+    if (!existsSync(dir))
+        return [];
+    const findings = [];
+    for (const work of readdirSync(dir)) {
+        const rel = `docs/trabalhos/${work}/BLOQUEIOS.md`;
+        if (!existsSync(join(root, rel)))
+            continue;
+        const { data } = readArtifact(rel, readFileSync(join(root, rel), 'utf8'));
+        const entries = Array.isArray(data?.bloqueios) ? data.bloqueios : [];
+        for (const entry of entries) {
+            if (typeof entry !== 'object' || entry === null)
+                continue;
+            const { id, status, aberto_em: openedAt } = entry;
+            if (status !== 'aberto' || typeof openedAt !== 'string')
+                continue;
+            const opened = Date.parse(`${openedAt}T00:00:00Z`);
+            if (Number.isNaN(opened))
+                continue;
+            const age = Math.floor((now.getTime() - opened) / 86_400_000);
+            if (age <= maxDays)
+                continue;
+            findings.push({
+                id: 'bloqueio-antigo',
+                severidade: 'aviso',
+                mensagem: `O bloqueio ${String(id)} em ${rel} está aberto há ${age} dias.`,
+                correcao: 'Resolva o bloqueio registrando a decisão em DECISOES.md, ou replaneje a task que ele parou.',
+            });
+        }
+    }
+    return findings;
+}
+function eventLogFiles(root) {
+    const dir = join(root, EVENTS_DIR);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith('.jsonl'))
+        .sort();
+}
+function checkEventLogs(root) {
+    return eventLogFiles(root).flatMap((name) => validateEventLog(readFileSync(join(root, EVENTS_DIR, name), 'utf8')).map((problem) => ({
+        id: `rastro-${problem.regra}`,
+        severidade: problem.regra === 'versao-futura' ? 'erro' : 'aviso',
+        mensagem: `docs/eventos/${name} (linha ${problem.linha}): ${problem.mensagem}`,
+        correcao: `O rastro é append-only: corrija o hook ou comando que gravou a linha. Contrato: ${EVENTS_CONTRACT_URL}`,
+    })));
+}
+/** Arquivos de rastro de um trabalho, incluindo os rotacionados (`<id>.N.jsonl`). */
+function workEventLogs(root, workId) {
+    return eventLogFiles(root).filter((name) => {
+        if (name === `${workId}.jsonl`)
+            return true;
+        const middle = name.slice(workId.length + 1, -'.jsonl'.length);
+        return name.startsWith(`${workId}.`) && /^\d+$/.test(middle);
+    });
+}
+/** R-09: uma task só fecha com suíte verde registrada. Sem rastro nesta máquina, não há como conferir. */
+function checkCompletedTasks(root) {
+    const worksDir = join(root, WORKS_DIR);
+    if (!existsSync(worksDir))
+        return [];
+    const findings = [];
+    for (const workId of readdirSync(worksDir)) {
+        const planRel = `docs/trabalhos/${workId}/PLAN.md`;
+        if (!existsSync(join(root, planRel)))
+            continue;
+        const logs = workEventLogs(root, workId);
+        if (!logs.length)
+            continue;
+        const { data } = readArtifact(planRel, readFileSync(join(root, planRel), 'utf8'));
+        const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
+        const completed = tasks
+            .filter((task) => typeof task === 'object' && task !== null)
+            .filter((task) => task.status === 'concluida' && typeof task.id === 'string')
+            .map((task) => String(task.id));
+        if (!completed.length)
+            continue;
+        const green = new Set();
+        const tracked = new Set();
+        for (const log of logs) {
+            for (const line of readFileSync(join(root, EVENTS_DIR, log), 'utf8').split('\n')) {
+                try {
+                    const event = JSON.parse(line);
+                    if (typeof event.task_id !== 'string')
+                        continue;
+                    if (event.evento === 'suite_verde')
+                        green.add(event.task_id);
+                    if (event.evento === 'task_iniciada' || event.evento === 'task_concluida')
+                        tracked.add(event.task_id);
+                }
+                catch {
+                    // linha vazia ou fora do contrato: já apontada pela validação do rastro.
+                }
+            }
+        }
+        // Task concluída antes de o rastro existir (sem task_iniciada nem task_concluida) não é cobrada.
+        for (const taskId of completed.filter((id) => tracked.has(id) && !green.has(id))) {
+            findings.push({
+                id: 'task-concluida-sem-suite-verde',
+                severidade: 'aviso',
+                mensagem: `A task ${taskId} de ${planRel} está concluída, mas o rastro não registra suite_verde para ela.`,
+                correcao: 'Rode a suíte e registre o resultado (`npx @fontdata/ai-harness evento suite_verde --task <id> ...`) ou reabra a task.',
+            });
+        }
+    }
+    return findings;
+}
+/** Comando e skill com o mesmo nome: o comando vence (D-23) e o fluxo da skill nunca roda. */
+function checkShadowedCommands(root) {
+    const commandsDir = join(root, '.claude', 'commands');
+    if (!existsSync(commandsDir))
+        return [];
+    const findings = [];
+    for (const name of readdirSync(commandsDir).filter((file) => file.endsWith('.md')).sort()) {
+        const id = name.slice(0, -'.md'.length);
+        if (existsSync(join(root, '.claude', 'skills', id, 'SKILL.md'))) {
+            findings.push({
+                id: 'comando-sombreia-skill',
+                severidade: 'erro',
+                mensagem: `.claude/commands/${name} tem o mesmo nome da skill ${id}: o comando vence e o fluxo da skill nunca roda.`,
+                correcao: 'Renomeie ou apague um dos dois. Se o comando veio do harness e foi editado, `npx @fontdata/ai-harness update --yes` o renomeia para <id>-legado.md.',
+            });
+        }
+        if (/-legado(-\d+)?$/.test(id)) {
+            findings.push({
+                id: 'comando-legado',
+                severidade: 'aviso',
+                mensagem: `.claude/commands/${name} é a versão personalizada de um comando que saiu do harness.`,
+                correcao: 'Leve o que for específico do projeto para uma rule em .claude/rules/ e apague o arquivo.',
+            });
+        }
+    }
+    return findings;
+}
+/** O padrão de comentários agora é só a rule, carregada sozinha; o bloco antigo no CLAUDE.md repete o texto e cita as pastas antigas. */
+function checkOldCommentsBlock(root) {
+    const file = join(root, 'CLAUDE.md');
+    if (!existsSync(file))
+        return [];
+    const content = readFileSync(file, 'utf8');
+    const heading = /^##\s+Coment[aá]rios em c[oó]digo\s*$/m.exec(content);
+    if (!heading)
+        return [];
+    const rest = content.slice(heading.index + heading[0].length);
+    const next = rest.search(/^##\s/m);
+    const block = next < 0 ? rest : rest.slice(0, next);
+    if (!/@\.claude\/rules\/comentarios\.md|docs\/(specs|plans|bugs|investigacoes)/.test(block))
+        return [];
+    return [
+        {
+            id: 'bloco-comentarios-antigo',
+            severidade: 'aviso',
+            mensagem: 'O CLAUDE.md tem o bloco "Comentários em código" do /configurar-comentarios antigo, que importa a rule ou cita as pastas antigas.',
+            correcao: 'Apague o bloco: a rule .claude/rules/comentarios.md é carregada sozinha em toda sessão, e o update a mantém atualizada.',
+        },
+    ];
+}
+function checkConfig(problems) {
+    return problems.map((mensagem) => ({
+        id: 'config-invalida',
+        severidade: 'aviso',
+        mensagem,
+        correcao: `Corrija o ${CONFIG_PATH}; enquanto isso, valem os padrões (segurança em bloqueio, demais hooks em aviso).`,
+    }));
+}
+/** Diagnostica a instalação do harness no projeto; nunca altera arquivos. */
+export function runDoctor(root, options = {}) {
+    const { findings: lockFindings, lock } = checkLock(root);
+    const { config, problems: configProblems } = readConfig(root);
+    return [
+        ...checkNode(options.nodeVersion ?? process.versions.node),
+        ...lockFindings,
+        ...(lock ? [...checkFiles(root, lock), ...checkRequiredSkills(root, lock)] : []),
+        ...checkShadowedCommands(root),
+        ...checkOldCommentsBlock(root),
+        ...checkAgents(root),
+        ...checkSettings(root),
+        ...checkGitIgnore(root),
+        ...checkConfig(configProblems),
+        ...checkWorks(root),
+        ...checkStaleBlocks(root, options.now ?? new Date(), options.staleBlockDays ?? config.bloqueios.dias_para_aviso),
+        ...checkEventLogs(root),
+        ...checkCompletedTasks(root),
+    ];
+}
+export function formatFindings(findings) {
+    if (!findings.length)
+        return 'Nenhum problema encontrado.';
+    const errors = findings.filter((finding) => finding.severidade === 'erro').length;
+    const lines = findings.map((finding) => `${finding.severidade === 'erro' ? '✖ erro ' : '⚠ aviso'} [${finding.id}] ${finding.mensagem}\n    → ${finding.correcao}`);
+    return `${lines.join('\n')}\n\n${errors} erro(s), ${findings.length - errors} aviso(s).`;
+}