@fontdata/ai-harness 3.2.2 → 3.3.0

package/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "fontdata",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "mcpServers": {
-    "banco_dados": { "command": "npx", "args": ["-y", "@fontdata/ai-harness@3.2.2", "banco-dados-mcp"] }
+    "banco_dados": { "command": "npx", "args": ["-y", "@fontdata/ai-harness@3.3.0", "banco-dados-mcp"] }
   },
   "description": "Harness de engenharia com IA da Fontdata para Claude Code",
   "author": { "name": "Fontdata" },

package/README.md

@@ -162,6 +162,8 @@ projeto, cadastro, limites do filtro, produção, mascaramento e dúvidas freque
 | `memoria [caminho]` | Índice de quem mexeu em cada arquivo (`--arquivo <caminho>`, `--regressao <id>`) |
 | `evento <evento>` | Grava no rastro do trabalho (usado por fluxos e agents) |
 | `conflitos <id>` | Aponta trabalhos em execução que mexem nos mesmos arquivos; `--aguardar` espera liberar (usado pelo `/executar-plan`) |
+| `trabalhos arquivar [caminho]` | Simula e, com `--yes`, move para `docs/trabalhos/_arquivo/` os trabalhos concluídos há mais de 60 dias (`--antes-de <dias>`); `--remover` apaga do disco os que o commit do índice recupera |
+| `trabalhos listar [caminho]` | Uma linha por trabalho, arquivados inclusive (`--busca`, `--tipo`, `--status`, `--limite`, padrão 20) |
 | `banco-dados <subcomando>` | Conexões de banco somente leitura: `adicionar`, `listar`, `testar`, `usar`, `remover` |
 | `banco-dados-mcp` | Servidor MCP de leitura do banco, iniciado pelo Claude Code |
 | `comentarios [caminho]` | Instala o hook do padrão de comentários com a catraca do legado (`--yes`) |
@@ -178,6 +180,8 @@ projeto, cadastro, limites do filtro, produção, mascaramento e dúvidas freque
 | `docs/trabalhos/<id>/DECISOES.md` | Decisões tomadas no planejamento e na execução |
 | `docs/trabalhos/<id>/BLOQUEIOS.md` | Dúvidas que pararam uma task |
 | `docs/trabalhos/<id>/relatorios/TECNICO.md` e `CLIENTE.md` | Relatório para engenharia e para cliente e suporte |
+| `docs/trabalhos/_arquivo/<ano>/<id>/` e `INDICE.jsonl` | Trabalhos arquivados pelo `trabalhos arquivar` e o índice que mantém a memória deles |
+| `.ignore` (raiz) | Linha `docs/trabalhos/_arquivo/`, que tira o histórico do Grep e do Glob dos agentes; o git continua versionando |
 | `docs/eventos/<id>.jsonl` | Rastro de eventos (não versionado por padrão) |
 | `.ai-harness/lock.json` e `config.json` | Lock da instalação e configuração dos hooks (versionar) |
 
@@ -249,7 +253,8 @@ também acionado pelo modelo quando o pedido combina.
 - `/harness` **(skill)** — conduz o setup em etapas (ideia, contexto, ignores, plano do start, scaffold, peças do harness, auto-tag e execução); `/harness <etapa>` roda uma etapa isolada
 
 O padrão de comentários não é um comando: a rule, o hook e a catraca do legado vêm do `init` e do `update`. O
-`update` também o instala em projetos cujo lock é anterior a ele. Para recusar, use `--sem-comentarios` no `init` ou
+`update` também o instala em projetos cujo lock é anterior a ele; um hook próprio que já existe, de versão antiga ou
+adaptado, é mantido e só entra no lock. Para recusar, use `--sem-comentarios` no `init` ou
 no `update`: a escolha fica em `comentarios.instalar: false` no `.ai-harness/config.json`, e o `update` a respeita.
 Para reativar, apague a chave e rode `update --yes` (ou `npx @fontdata/ai-harness comentarios --yes`). Sem o padrão
 e sem a recusa, o `doctor` avisa com `comentarios-ausente`.

package/dist/banco-dados/lgpd/aplicar.js

@@ -106,9 +106,14 @@ function itensDoSelect(sql, dialeto, colunas) {
         contagem: ehContagem(item),
     }));
 }
-function colunaPessoalCitada(ids, mascarar) {
+/** O SQL não diz de que tabela vem cada identificador, então só a entrada sem tabela de `liberar` vale aqui. */
+function colunaPessoalCitada(ids, mascarar, liberar) {
     const extras = new Set(mascarar.map((r) => r.coluna));
+    const livres = new Set(liberar.filter((r) => r.tabela === null).map((r) => r.coluna));
     for (const id of ids) {
+        const nome = id.toLowerCase();
+        if (livres.has(nome) && !extras.has(nome))
+            continue;
         const categoria = classificarColuna(id);
         if (categoria)
             return { categoria, identificador: id };
@@ -248,7 +253,7 @@ export function mascararResultado(resultado, opcoes) {
     };
     const citacao = (i) => {
         if (!citacoes.has(i)) {
-            citacoes.set(i, colunaPessoalCitada(item(i)?.ids ?? identificadores(opcoes.sql, opcoes.dialeto), mascarar));
+            citacoes.set(i, colunaPessoalCitada(item(i)?.ids ?? identificadores(opcoes.sql, opcoes.dialeto), mascarar, liberar));
         }
         return citacoes.get(i);
     };

package/dist/banco-dados/lgpd/detectar.js

@@ -39,6 +39,8 @@ const COMBINACOES = [
 const PARTES_DE_TRIBUTO = new Set([
     'valor', 'vl', 'vlr', 'percentual', 'perc', 'aliquota', 'aliq', 'bc', 'base', 'retencao', 'ret', 'cst', 'cofins',
 ]);
+/** Com uma destas partes, `documento` é chave interna (`cod_loja_documento`, `id_documento`), não o número do documento. */
+const PARTES_DE_CODIGO = new Set(['cod', 'codigo', 'id', 'seq', 'sequencial']);
 const TERMOS_FORTES = [
     ['cpf', 'cpf'],
     ['cnpj', 'cnpj'],
@@ -73,6 +75,8 @@ export function classificarColuna(nome) {
     const tem = new Set(partes);
     if (partes.some((p) => PARTES_DE_TRIBUTO.has(p)))
         tem.delete('pis');
+    if (partes.some((p) => PARTES_DE_CODIGO.has(p)))
+        tem.delete('documento');
     for (const [categoria, listas] of COMBINACOES) {
         if (listas.every((lista) => lista.some((p) => tem.has(p))))
             return categoria;

package/dist/cli.js

@@ -15,6 +15,7 @@ const RESERVED = new Set([
     'migrar',
     'evento',
     'conflitos',
+    'trabalhos',
     'comentarios',
     'memoria',
     'banco-dados',
@@ -60,6 +61,9 @@ Gerenciar:
   memoria [caminho]  Índice de quem mexeu em cada arquivo (--arquivo <caminho>, --regressao <id do bug>)
   evento <evento>   Grava no rastro do trabalho (--trabalho, --task, --nome, --resultado, --dados '{json}')
   conflitos <id>    Aponta trabalhos em execução que mexem nos mesmos arquivos (--aguardar espera liberar)
+  trabalhos listar [caminho]  Uma linha por trabalho, arquivados inclusive (--busca, --tipo, --status, --limite)
+  trabalhos arquivar [caminho]  Move os concluídos há mais de 60 dias para docs/trabalhos/_arquivo (--yes aplica)
+                    --antes-de <dias> muda o corte; --remover apaga do disco os que o git recupera
   banco-dados <subcomando>  Conexões de banco somente leitura: adicionar, listar, testar, usar, remover
   banco-dados-mcp   Servidor MCP de leitura do banco, usado pelo Claude Code (stdio)
   list            Lista todos os comandos disponíveis no catálogo
@@ -156,6 +160,10 @@ async function main() {
         const { runConflictsCommand } = await import('./trabalhos/conflitos.js');
         process.exit(await runConflictsCommand(argv.slice(1)));
     }
+    if (cmd === 'trabalhos') {
+        const { runWorksCommand } = await import('./trabalhos/command.js');
+        process.exit(await runWorksCommand(argv.slice(1)));
+    }
     if (cmd === 'banco-dados') {
         const { runBancoCommand } = await import('./banco-dados/command.js');
         process.exit(await runBancoCommand(argv.slice(1)));

package/dist/contratos/artefatos.js

@@ -4,6 +4,8 @@ import { parse, YAMLParseError } from 'yaml';
 /** Versão do contrato de artefatos (docs/contratos/ARTEFATOS.md). */
 export const SCHEMA_VERSION = 1;
 export const WORKS_DIR = join('docs', 'trabalhos');
+/** Subpasta de docs/trabalhos/ com os trabalhos arquivados; não é pasta de trabalho. */
+export const ARCHIVE_DIR_NAME = '_arquivo';
 /** Id de trabalho: `AAAA-MM-DD-<slug>` com slug em minúsculas, sem acento. */
 export const WORK_ID = /^\d{4}-\d{2}-\d{2}-[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const DATE = /^\d{4}-\d{2}-\d{2}$/;
@@ -27,7 +29,7 @@ export const STATUS_BY_TYPE = {
 };
 export const WORK_TYPES = ['feature', 'bug', 'investigacao', 'auditoria'];
 export const TASK_STATUS = ['pendente', 'em-andamento', 'concluida', 'bloqueada', 'pulada'];
-const REQUIRED_BY_WORK_TYPE = {
+export const REQUIRED_BY_WORK_TYPE = {
     feature: ['SPEC.md', 'PLAN.md'],
     bug: ['PLAN.md'],
     investigacao: ['relatorios/TECNICO.md'],
@@ -222,7 +224,7 @@ function validateBlocks(file, data) {
     });
 }
 /** Arquivos da pasta do trabalho, relativos a ela, com separador `/`. */
-function listWorkFiles(dir) {
+export function listWorkFiles(dir) {
     return readdirSync(dir, { recursive: true, encoding: 'utf8' })
         .filter((rel) => statSync(join(dir, rel)).isFile())
         .map((rel) => rel.split(sep).join('/'))
@@ -284,7 +286,7 @@ export function validateAllWorks(root) {
     if (!existsSync(dir))
         return [];
     return readdirSync(dir)
-        .filter((name) => statSync(join(dir, name)).isDirectory())
+        .filter((name) => name !== ARCHIVE_DIR_NAME && statSync(join(dir, name)).isDirectory())
         .sort()
         .flatMap((name) => validateWork(root, name));
 }

package/dist/doctor/checks.js

@@ -4,11 +4,15 @@ import { join } from 'node:path';
 import { lerEnvSettingsLocal, lerVariavel, SETTINGS_LOCAL_PATH } from '../banco-dados/ambiente.js';
 import { caminhoCadastro, lerCadastro } from '../banco-dados/cadastro.js';
 import { allCommands, loadCatalog } from '../catalog.js';
+import { COMMENTS_HOOK_PATH } from '../comentarios/instalar.js';
 import { CONFIG_PATH, readConfig } from '../config/config.js';
-import { readArtifact, validateAllWorks, WORKS_DIR } from '../contratos/artefatos.js';
+import { ARCHIVE_DIR_NAME, ARTIFACT_TYPES, listWorkFiles, 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 { planArchive } from '../trabalhos/arquivar.js';
+import { ARCHIVE_DEFAULT_DAYS } from '../trabalhos/command.js';
+import { ARCHIVE_INDEX, readArchiveIndex } from '../trabalhos/indice-arquivo.js';
 import { adoptLegacyInstall } from '../update/legado.js';
 import { checkLegacyDocsCitations, checkMigratedPlansRunning } from './migracao.js';
 const MIN_NODE_MAJOR = 22;
@@ -18,6 +22,8 @@ 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');
+const STALE_DRAFT_PLAN_DAYS = 30;
+const ARCHIVE_SUGGESTION_MIN = 30;
 /** 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) {
@@ -264,6 +270,84 @@ function checkStaleBlocks(root, now, maxDays) {
     }
     return findings;
 }
+function activeWorkFolders(root) {
+    const dir = join(root, WORKS_DIR);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name !== ARCHIVE_DIR_NAME && statSync(join(dir, name)).isDirectory())
+        .sort();
+}
+function checkArchiveIndex(root) {
+    const file = ARCHIVE_INDEX.split('\\').join('/');
+    return readArchiveIndex(root).problemas.map(({ linha, mensagem }) => ({
+        id: 'arquivo-indice-invalido',
+        severidade: 'aviso',
+        mensagem: `${file} (linha ${linha}): ${mensagem}. A linha fica fora da memória e da listagem de trabalhos.`,
+        correcao: `Corrija ou apague a linha ${linha} de ${file}; cada linha é um objeto JSON com \`id\` texto.`,
+    }));
+}
+/** Sem os trabalhos ativos do estado.json, que exigem leitura assíncrona, a contagem é uma estimativa por cima. */
+function checkArchiveSuggestion(root, now) {
+    const count = planArchive(root, { now, dias: ARCHIVE_DEFAULT_DAYS, ativos: [] }).elegiveis.length;
+    if (count < ARCHIVE_SUGGESTION_MIN)
+        return [];
+    return [
+        {
+            id: 'arquivamento-sugerido',
+            severidade: 'aviso',
+            mensagem: `${count} trabalhos concluídos há mais de ${ARCHIVE_DEFAULT_DAYS} dias podem ir para docs/trabalhos/_arquivo/ (estimativa).`,
+            correcao: 'Veja a simulação com `npx @fontdata/ai-harness trabalhos arquivar` e aplique com --yes.',
+        },
+    ];
+}
+function checkStaleDraftPlans(root, now) {
+    const findings = [];
+    for (const work of activeWorkFolders(root)) {
+        const rel = `docs/trabalhos/${work}/PLAN.md`;
+        if (!existsSync(join(root, rel)))
+            continue;
+        const { data } = readArtifact(rel, readFileSync(join(root, rel), 'utf8'));
+        if (data?.status !== 'rascunho' || typeof data.atualizado_em !== 'string')
+            continue;
+        const updated = Date.parse(`${data.atualizado_em}T00:00:00Z`);
+        if (Number.isNaN(updated))
+            continue;
+        const age = Math.floor((now.getTime() - updated) / 86_400_000);
+        if (age <= STALE_DRAFT_PLAN_DAYS)
+            continue;
+        findings.push({
+            id: 'plano-rascunho-antigo',
+            severidade: 'aviso',
+            mensagem: `O ${rel} está em rascunho e não é atualizado há ${age} dias.`,
+            correcao: 'Retome o planejamento com /nova-tarefa ou marque o plano como cancelado.',
+        });
+    }
+    return findings;
+}
+/** Nome que só difere de um artefato pela caixa já é apontado por `contrato-nome-fora-do-padrao`. */
+function isOutsideContract(rel) {
+    if (rel in ARTIFACT_TYPES || rel.startsWith('anexos/'))
+        return false;
+    if (rel.split('/').at(-1)?.startsWith('.'))
+        return false;
+    return !Object.keys(ARTIFACT_TYPES).some((name) => name.toLowerCase() === rel.toLowerCase());
+}
+function checkFilesOutsideContract(root) {
+    return activeWorkFolders(root).flatMap((work) => {
+        const extras = listWorkFiles(join(root, WORKS_DIR, work)).filter(isOutsideContract);
+        if (!extras.length)
+            return [];
+        return [
+            {
+                id: 'arquivo-fora-do-contrato',
+                severidade: 'aviso',
+                mensagem: `docs/trabalhos/${work}/ tem arquivo(s) fora do contrato de artefatos: ${extras.join(', ')}.`,
+                correcao: `Se é relatório, mova o conteúdo para relatorios/TECNICO.md ou o arquivo para anexos/. Contrato: ${CONTRACT_URL}`,
+            },
+        ];
+    });
+}
 function eventLogFiles(root) {
     const dir = join(root, EVENTS_DIR);
     if (!existsSync(dir))
@@ -390,9 +474,14 @@ function checkOldCommentsBlock(root) {
         },
     ];
 }
-/** Lock anterior ao padrão de comentários e sem a recusa no config: o update o instala. */
-function checkComments(lock, config) {
-    if (!config.comentarios.instalar || lock.itens.some((item) => item.tipo === 'hook' && item.id === 'comentarios'))
+/**
+ * Lock anterior ao padrão de comentários e sem a recusa no config: o update o instala. Hook no disco fora do lock é
+ * instalação antiga ou adaptada, que o update só registra no lock.
+ */
+function checkComments(root, lock, config) {
+    if (!config.comentarios.instalar || existsSync(join(root, COMMENTS_HOOK_PATH)))
+        return [];
+    if (lock.itens.some((item) => item.tipo === 'hook' && item.id === 'comentarios'))
         return [];
     return [
         {
@@ -520,7 +609,7 @@ export function runDoctor(root, options = {}) {
     return [
         ...checkNode(options.nodeVersion ?? process.versions.node),
         ...lockFindings,
-        ...(lock ? [...checkFiles(root, lock), ...checkRequiredSkills(root, lock), ...checkComments(lock, config)] : []),
+        ...(lock ? [...checkFiles(root, lock), ...checkRequiredSkills(root, lock), ...checkComments(root, lock, config)] : []),
         ...checkShadowedCommands(root),
         ...checkOldCommentsBlock(root),
         ...checkAgents(root),
@@ -529,6 +618,10 @@ export function runDoctor(root, options = {}) {
         ...checkConfig(configProblems),
         ...checkBanco(root, config),
         ...checkWorks(root),
+        ...checkArchiveIndex(root),
+        ...checkStaleDraftPlans(root, options.now ?? new Date()),
+        ...checkArchiveSuggestion(root, options.now ?? new Date()),
+        ...checkFilesOutsideContract(root),
         ...checkStaleBlocks(root, options.now ?? new Date(), options.staleBlockDays ?? config.bloqueios.dias_para_aviso),
         ...checkEventLogs(root),
         ...checkCompletedTasks(root),

package/dist/install/settings.js

@@ -19,6 +19,7 @@ export const TOOL_PERMISSIONS = ['Read', 'Grep', 'Glob', 'Skill'];
 export const READ_PERMISSIONS = [
     'Bash(npx @fontdata/ai-harness doctor:*)',
     'Bash(npx @fontdata/ai-harness memoria:*)',
+    'Bash(npx @fontdata/ai-harness trabalhos listar:*)',
     'Bash(git status:*)',
     'Bash(git diff:*)',
     'Bash(git log:*)',

package/dist/memoria/indice.js

@@ -4,6 +4,7 @@ import { dirname, join, resolve } from 'node:path';
 import { ARTIFACT_TYPES, readArtifact, WORKS_DIR } from '../contratos/artefatos.js';
 import { suggestFlag } from '../install/flags.js';
 import { acharRaiz } from '../raiz.js';
+import { ARCHIVE_DIR_NAME, ARCHIVE_INDEX, readArchiveIndex } from '../trabalhos/indice-arquivo.js';
 export const INDEX_PATH = join('.ai-harness', 'memoria', 'indice.json');
 export const INDEX_VERSION = 1;
 const BACKSLASH = String.fromCharCode(92);
@@ -34,9 +35,56 @@ function conclusionDate(root, workId) {
     }
     return date;
 }
+/** Resumo de um trabalho ativo a partir dos artefatos; `resumo` é null quando nenhum artefato é legível. */
+export function summarizeWork(root, workId) {
+    const worksDir = join(root, WORKS_DIR);
+    const problemas = [];
+    const summary = { trabalho_tipo: null, titulo: null, status: null, data: null, causa_raiz: null, criado_em: null, arquivos: [], arquivado: false };
+    const files = new Set();
+    let updatedAt = null;
+    let fallbackStatus = null;
+    let readable = false;
+    for (const rel of Object.keys(ARTIFACT_TYPES)) {
+        const path = join(worksDir, workId, rel);
+        if (!existsSync(path))
+            continue;
+        const { data, problems } = readArtifact(`docs/trabalhos/${workId}/${rel}`, readFileSync(path, 'utf8'));
+        if (!data) {
+            problemas.push(...problems.map(({ arquivo, mensagem }) => ({ arquivo, mensagem })));
+            continue;
+        }
+        readable = true;
+        summary.titulo ??= text(data.titulo);
+        summary.trabalho_tipo ??= text(data.trabalho_tipo);
+        if (rel === 'PLAN.md') {
+            summary.status = text(data.status);
+            summary.causa_raiz = text(data.causa_raiz);
+        }
+        fallbackStatus ??= text(data.status);
+        summary.criado_em = earliest(summary.criado_em, text(data.criado_em));
+        updatedAt = latest(updatedAt, text(data.atualizado_em));
+        if (Array.isArray(data.arquivos)) {
+            for (const file of data.arquivos)
+                if (typeof file === 'string')
+                    files.add(normalizePath(file));
+        }
+    }
+    if (!readable)
+        return { resumo: null, problemas };
+    summary.status ??= fallbackStatus;
+    summary.data = conclusionDate(root, workId) ?? updatedAt ?? summary.criado_em;
+    summary.arquivos = [...files].sort();
+    return { resumo: summary, problemas };
+}
+function addWork(index, id, summary) {
+    index.trabalhos[id] = summary;
+    const { trabalho_tipo, titulo, status, data, causa_raiz } = summary;
+    for (const file of summary.arquivos)
+        (index.arquivos[file] ??= []).push({ trabalho: id, trabalho_tipo, titulo, status, data, causa_raiz });
+}
 /**
- * Índice "quem mexeu neste arquivo e por quê", gerado do frontmatter dos trabalhos e do rastro.
- * Não é busca semântica: toda resposta aponta um trabalho que pode ser conferido.
+ * Índice "quem mexeu neste arquivo e por quê", gerado do frontmatter dos trabalhos, do rastro e do
+ * índice dos arquivados. Não é busca semântica: toda resposta aponta um trabalho que pode ser conferido.
  */
 export function buildIndex(root, now = new Date()) {
     const index = { indice_versao: INDEX_VERSION, gerado_em: now.toISOString(), trabalhos: {}, arquivos: {}, problemas: [] };
@@ -44,49 +92,23 @@ export function buildIndex(root, now = new Date()) {
     if (!existsSync(worksDir))
         return index;
     const workIds = readdirSync(worksDir)
-        .filter((name) => statSync(join(worksDir, name)).isDirectory())
+        .filter((name) => name !== ARCHIVE_DIR_NAME && statSync(join(worksDir, name)).isDirectory())
         .sort();
     for (const id of workIds) {
-        const summary = { trabalho_tipo: null, titulo: null, status: null, data: null, causa_raiz: null, criado_em: null, arquivos: [] };
-        const files = new Set();
-        let updatedAt = null;
-        let fallbackStatus = null;
-        let readable = false;
-        for (const rel of Object.keys(ARTIFACT_TYPES)) {
-            const path = join(worksDir, id, rel);
-            if (!existsSync(path))
-                continue;
-            const { data, problems } = readArtifact(`docs/trabalhos/${id}/${rel}`, readFileSync(path, 'utf8'));
-            if (!data) {
-                index.problemas.push(...problems.map(({ arquivo, mensagem }) => ({ arquivo, mensagem })));
-                continue;
-            }
-            readable = true;
-            summary.titulo ??= text(data.titulo);
-            summary.trabalho_tipo ??= text(data.trabalho_tipo);
-            if (rel === 'PLAN.md') {
-                summary.status = text(data.status);
-                summary.causa_raiz = text(data.causa_raiz);
-            }
-            fallbackStatus ??= text(data.status);
-            summary.criado_em = earliest(summary.criado_em, text(data.criado_em));
-            updatedAt = latest(updatedAt, text(data.atualizado_em));
-            if (Array.isArray(data.arquivos)) {
-                for (const file of data.arquivos)
-                    if (typeof file === 'string')
-                        files.add(normalizePath(file));
-            }
-        }
-        if (!readable)
+        const { resumo, problemas } = summarizeWork(root, id);
+        index.problemas.push(...problemas);
+        if (resumo)
+            addWork(index, id, resumo);
+    }
+    const archive = readArchiveIndex(root);
+    const archiveFile = ARCHIVE_INDEX.split(BACKSLASH).join('/');
+    index.problemas.push(...archive.problemas.map(({ linha, mensagem }) => ({ arquivo: archiveFile, mensagem: `linha ${linha}: ${mensagem}` })));
+    for (const entry of archive.trabalhos) {
+        if (workIds.includes(entry.id))
             continue;
-        summary.status ??= fallbackStatus;
-        summary.data = conclusionDate(root, id) ?? updatedAt ?? summary.criado_em;
-        summary.arquivos = [...files].sort();
-        index.trabalhos[id] = summary;
-        for (const file of summary.arquivos) {
-            const { trabalho_tipo, titulo, status, data, causa_raiz } = summary;
-            (index.arquivos[file] ??= []).push({ trabalho: id, trabalho_tipo, titulo, status, data, causa_raiz });
-        }
+        const { trabalho_tipo, titulo, status, criado_em, data, causa_raiz } = entry;
+        const arquivos = [...new Set(entry.arquivos.map(normalizePath))];
+        addWork(index, entry.id, { trabalho_tipo, titulo, status, data, causa_raiz, criado_em, arquivos, arquivado: true });
     }
     for (const entries of Object.values(index.arquivos)) {
         entries.sort((a, b) => (a.data ?? '').localeCompare(b.data ?? '') || a.trabalho.localeCompare(b.trabalho));

package/dist/trabalhos/arquivar.js

@@ -0,0 +1,196 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { ARCHIVE_DIR_NAME, readArtifact, REQUIRED_BY_WORK_TYPE, WORK_ID, WORKS_DIR } from '../contratos/artefatos.js';
+import { summarizeWork } from '../memoria/indice.js';
+import { ARCHIVE_DIR, appendArchiveEntries, readArchiveIndex } from './indice-arquivo.js';
+export const IGNORE_FILE = '.ignore';
+export const IGNORE_LINE = `${toPosix(ARCHIVE_DIR)}/`;
+const CLOSED_PLAN = ['concluido', 'cancelado', 'legado'];
+const REPORTS = ['relatorios/TECNICO.md', 'relatorios/CLIENTE.md'];
+const PLANLESS_TYPES = ['investigacao', 'auditoria'];
+const DAY_MS = 86_400_000;
+function toPosix(path) {
+    return path.split('\\').join('/');
+}
+export function workPath(id) {
+    return toPosix(join(WORKS_DIR, id));
+}
+export function archiveDestination(id) {
+    return toPosix(join(ARCHIVE_DIR, id.slice(0, 4), id));
+}
+function frontmatter(root, id, rel) {
+    const path = join(root, WORKS_DIR, id, rel);
+    if (!existsSync(path))
+        return null;
+    return readArtifact(`${workPath(id)}/${rel}`, readFileSync(path, 'utf8')).data ?? null;
+}
+function hasOpenBlock(data) {
+    if (!data || !Array.isArray(data.bloqueios))
+        return false;
+    return data.bloqueios.some((entry) => typeof entry === 'object' && entry !== null && entry.status === 'aberto');
+}
+function ageInDays(date, now) {
+    const today = Date.parse(`${now.toISOString().slice(0, 10)}T00:00:00Z`);
+    return (today - Date.parse(`${date.slice(0, 10)}T00:00:00Z`)) / DAY_MS;
+}
+/** Motivo de o trabalho ficar onde está, ou null quando ele pode ser arquivado. */
+function reasonToKeep(root, id, options) {
+    if (!WORK_ID.test(id))
+        return 'nome fora do padrão AAAA-MM-DD-<slug>';
+    if (options.ativos.includes(id))
+        return 'trabalho ativo';
+    const { resumo, problemas } = summarizeWork(root, id);
+    if (problemas.length)
+        return `frontmatter ilegível: ${problemas.map((p) => `${p.arquivo}: ${p.mensagem}`).join('; ')}`;
+    if (!resumo)
+        return 'frontmatter ilegível: nenhum artefato do contrato na pasta';
+    if (hasOpenBlock(frontmatter(root, id, 'BLOQUEIOS.md')))
+        return 'bloqueio aberto em BLOQUEIOS.md';
+    const plan = frontmatter(root, id, 'PLAN.md');
+    if (plan) {
+        const status = typeof plan.status === 'string' ? plan.status : 'PLAN.md sem status';
+        if (!CLOSED_PLAN.includes(status))
+            return status;
+    }
+    else {
+        const type = resumo.trabalho_tipo ?? '';
+        const required = PLANLESS_TYPES.includes(type) ? REQUIRED_BY_WORK_TYPE[type] : undefined;
+        if (!required) {
+            return `sem PLAN.md: só investigacao ou auditoria com relatórios final são arquivadas (trabalho_tipo ${resumo.trabalho_tipo ?? 'ausente'})`;
+        }
+        const reports = REPORTS.map((rel) => ({ rel, data: frontmatter(root, id, rel) })).filter((report) => report.data);
+        const missing = required.filter((rel) => !reports.some((report) => report.rel === rel));
+        if (missing.length)
+            return `relatório ausente: ${missing.join(', ')}`;
+        const pending = reports.filter((report) => report.data?.status !== 'final').map((report) => report.rel);
+        if (pending.length)
+            return `relatório ainda não final: ${pending.join(', ')}`;
+    }
+    if (!resumo.data)
+        return 'sem data de conclusão nem de atualização';
+    if (ageInDays(resumo.data, options.now) <= options.dias)
+        return `concluído há menos de ${options.dias} dias`;
+    const destino = archiveDestination(id);
+    if (existsSync(join(root, destino)))
+        return `destino já existe: ${destino}`;
+    return null;
+}
+/** Separa os trabalhos que podem ser arquivados dos que ficam, sem alterar nenhum arquivo. */
+export function planArchive(root, options) {
+    const plan = { elegiveis: [], ignorados: [] };
+    const worksDir = join(root, WORKS_DIR);
+    if (!existsSync(worksDir))
+        return plan;
+    const folders = readdirSync(worksDir)
+        .filter((name) => name !== ARCHIVE_DIR_NAME && statSync(join(worksDir, name)).isDirectory())
+        .sort();
+    for (const id of folders) {
+        const motivo = reasonToKeep(root, id, options);
+        if (motivo)
+            plan.ignorados.push({ id, motivo });
+        else
+            plan.elegiveis.push({ id, destino: archiveDestination(id) });
+    }
+    return plan;
+}
+export function git(root, args) {
+    try {
+        return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    }
+    catch {
+        return null;
+    }
+}
+export function isVersioned(root, path) {
+    return Boolean(git(root, ['ls-files', '--', path])?.trim());
+}
+function recoverableCommit(root, path) {
+    if (!isVersioned(root, path))
+        return null;
+    if (git(root, ['status', '--porcelain', '--', path]) !== '')
+        return null;
+    return git(root, ['rev-parse', 'HEAD'])?.trim() || null;
+}
+function ensureIgnoreLine(root) {
+    const file = join(root, IGNORE_FILE);
+    const current = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const lines = current.split(/\r?\n/).map((line) => line.trim());
+    if (lines.includes(IGNORE_LINE) || lines.includes(`/${IGNORE_LINE}`))
+        return;
+    const prefix = current && !current.endsWith('\n') ? '\n' : '';
+    writeFileSync(file, `${current}${prefix}${IGNORE_LINE}\n`);
+}
+/** Move os elegíveis para `_arquivo/<ano>/<id>/`, registra cada um no índice e completa o `.ignore`. */
+export function applyArchive(root, plan, options) {
+    const archivedAt = options.now.toISOString().slice(0, 10);
+    const archived = [];
+    let movedAny = false;
+    try {
+        for (const { id, destino } of plan.elegiveis) {
+            const caminho = workPath(id);
+            const { resumo } = summarizeWork(root, id);
+            if (!resumo)
+                throw new Error(`Trabalho sem artefato legível, não arquivado: ${caminho}`);
+            if (existsSync(join(root, destino)))
+                throw new Error(`Destino já existe, trabalho não arquivado: ${destino}`);
+            const commit = recoverableCommit(root, caminho);
+            mkdirSync(dirname(join(root, destino)), { recursive: true });
+            const moved = isVersioned(root, caminho) && git(root, ['mv', caminho, destino]) !== null;
+            if (!moved)
+                renameSync(join(root, caminho), join(root, destino));
+            movedAny = true;
+            const { trabalho_tipo, titulo, status, criado_em, data, arquivos, causa_raiz } = resumo;
+            appendArchiveEntries(root, [
+                { v: 1, id, trabalho_tipo, titulo, status, criado_em, data, arquivos, causa_raiz, caminho, commit, arquivado_em: archivedAt },
+            ]);
+            archived.push({ id, commit });
+        }
+    }
+    finally {
+        if (movedAny)
+            ensureIgnoreLine(root);
+    }
+    return archived;
+}
+/** `rev:./path` resolve a partir de `root`, que pode ser subpasta do repositório. */
+function treeOf(root, rev, path) {
+    return git(root, ['rev-parse', '--verify', '--quiet', `${rev}:./${path}`])?.trim() || null;
+}
+function reasonToKeepArchived(root, entry, destino) {
+    if (!entry.commit)
+        return 'sem commit para recuperar';
+    if (git(root, ['rev-parse', '--git-dir']) === null)
+        return 'projeto fora de um repositório git: o commit não tem como recuperar a pasta';
+    const original = treeOf(root, entry.commit, entry.caminho);
+    if (!original)
+        return `o commit ${entry.commit} não recupera ${entry.caminho}`;
+    const current = treeOf(root, 'HEAD', destino);
+    if (!current)
+        return 'arquivado agora: faça commit e rode de novo';
+    if (current !== original)
+        return 'alterada depois do arquivamento';
+    const status = (git(root, ['status', '--porcelain', '--ignored', '--', destino]) ?? '').split('\n').filter(Boolean);
+    if (status.some((line) => !line.startsWith('??') && !line.startsWith('!!')))
+        return 'alterada depois do arquivamento';
+    if (status.length)
+        return 'há arquivos não versionados ou ignorados na pasta';
+    return null;
+}
+/** Apaga com `git rm` as pastas arquivadas que o commit da linha do índice recupera; as demais ficam, com o motivo. */
+export function removeArchived(root) {
+    const result = { removidos: [], mantidos: [] };
+    for (const entry of readArchiveIndex(root).trabalhos) {
+        const destino = archiveDestination(entry.id);
+        if (!existsSync(join(root, destino)))
+            continue;
+        const motivo = reasonToKeepArchived(root, entry, destino);
+        if (motivo)
+            result.mantidos.push({ id: entry.id, motivo });
+        else if (git(root, ['rm', '-r', '-q', '--', destino]) === null)
+            result.mantidos.push({ id: entry.id, motivo: 'git rm falhou' });
+        else
+            result.removidos.push(entry.id);
+    }
+    return result;
+}

package/dist/trabalhos/command.js

@@ -0,0 +1,105 @@
+import { existsSync } from 'node:fs';
+import { EOL } from 'node:os';
+import { resolve } from 'node:path';
+import { suggestFlag } from '../install/flags.js';
+import { buildIndex } from '../memoria/indice.js';
+import { acharRaiz } from '../raiz.js';
+import { loadRastroLib } from '../rastro/command.js';
+import { applyArchive, planArchive, removeArchived } from './arquivar.js';
+import { listWorks } from './listar.js';
+export const ARCHIVE_DEFAULT_DAYS = 60;
+const SUBCOMMANDS = ['arquivar', 'listar'];
+const ARCHIVE_FLAGS = { valued: ['--antes-de'], boolean: ['--remover', '--yes'] };
+const LIST_FLAGS = { valued: ['--busca', '--tipo', '--status', '--limite'], boolean: [] };
+function parseArgs(argv, spec) {
+    let path;
+    const values = new Map();
+    const switches = new Set();
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i] ?? '';
+        if (!token.startsWith('-')) {
+            if (path !== undefined)
+                throw new Error(`Argumento inesperado: ${token}`);
+            path = token;
+        }
+        else if (spec.boolean.includes(token)) {
+            switches.add(token);
+        }
+        else if (spec.valued.includes(token)) {
+            const value = argv[++i];
+            if (value === undefined)
+                throw new Error(`${token} precisa de um valor.`);
+            values.set(token, value);
+        }
+        else {
+            const suggestion = suggestFlag(token, [...spec.valued, ...spec.boolean]);
+            throw new Error(`Flag desconhecida: ${token}.${suggestion ? ` Você quis dizer ${suggestion}?` : ''}`);
+        }
+    }
+    const root = path === undefined ? acharRaiz() : resolve(process.cwd(), path);
+    if (!existsSync(root))
+        throw new Error(`Pasta não encontrada: ${root}`);
+    return { root, values, switches };
+}
+function parseCount(value, min, error) {
+    if (!/^\d+$/.test(value) || Number(value) < min)
+        throw new Error(error);
+    return Number(value);
+}
+async function runArchive(argv) {
+    const { root, values, switches } = parseArgs(argv, ARCHIVE_FLAGS);
+    const rawDays = values.get('--antes-de');
+    const dias = rawDays === undefined ? ARCHIVE_DEFAULT_DAYS : parseCount(rawDays, 1, '--antes-de precisa de um número de dias inteiro e maior que zero.');
+    const now = new Date();
+    const ativos = (await loadRastroLib()).findActiveWorks(root);
+    const plan = planArchive(root, { now, dias, ativos });
+    const lines = [
+        `Elegíveis para arquivar (${plan.elegiveis.length}):`,
+        ...plan.elegiveis.map(({ id, destino }) => `  ${id} -> ${destino}`),
+        `Ignorados (${plan.ignorados.length}):`,
+        ...plan.ignorados.map(({ id, motivo }) => `  ${id}: ${motivo}`),
+    ];
+    if (!switches.has('--yes')) {
+        lines.push('Simulação — nada foi movido. Rode de novo com --yes para arquivar.');
+        console.log(lines.join(EOL));
+        return 0;
+    }
+    const archived = applyArchive(root, plan, { now });
+    lines.push(`Arquivados (${archived.length}):`, ...archived.map(({ id, commit }) => `  ${id}${commit ? ` (commit ${commit.slice(0, 12)})` : ' (sem commit)'}`));
+    if (switches.has('--remover')) {
+        const { removidos, mantidos } = removeArchived(root);
+        lines.push(`Removidos do disco (${removidos.length}):`, ...removidos.map((id) => `  ${id}`), `Mantidos no disco (${mantidos.length}):`, ...mantidos.map(({ id, motivo }) => `  ${id}: ${motivo}`));
+    }
+    console.log(lines.join(EOL));
+    return 0;
+}
+function runList(argv) {
+    const { root, values } = parseArgs(argv, LIST_FLAGS);
+    const options = {};
+    const busca = values.get('--busca');
+    const tipo = values.get('--tipo');
+    const status = values.get('--status');
+    const limite = values.get('--limite');
+    if (busca !== undefined)
+        options.busca = busca;
+    if (tipo !== undefined)
+        options.tipo = tipo;
+    if (status !== undefined)
+        options.status = status;
+    if (limite !== undefined)
+        options.limite = parseCount(limite, 0, '--limite precisa de um número inteiro.');
+    console.log(listWorks(buildIndex(root), options).join(EOL));
+    return 0;
+}
+/** `ai-harness trabalhos arquivar [caminho] [--antes-de <dias>] [--remover] [--yes]` e `trabalhos listar [caminho] [filtros]`. */
+export async function runWorksCommand(argv) {
+    const [subcommand, ...rest] = argv;
+    if (subcommand === 'arquivar')
+        return runArchive(rest);
+    if (subcommand === 'listar')
+        return runList(rest);
+    if (!subcommand)
+        throw new Error(`Informe o subcomando: ${SUBCOMMANDS.join(' ou ')}. Ex.: npx @fontdata/ai-harness trabalhos listar`);
+    const suggestion = suggestFlag(subcommand, SUBCOMMANDS);
+    throw new Error(`Subcomando desconhecido: ${subcommand}.${suggestion ? ` Você quis dizer ${suggestion}?` : ''} Use: ${SUBCOMMANDS.join(', ')}.`);
+}

package/dist/trabalhos/indice-arquivo.js

@@ -0,0 +1,68 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { ARCHIVE_DIR_NAME, WORKS_DIR } from '../contratos/artefatos.js';
+export { ARCHIVE_DIR_NAME };
+export const ARCHIVE_DIR = join(WORKS_DIR, ARCHIVE_DIR_NAME);
+export const ARCHIVE_INDEX = join(ARCHIVE_DIR, 'INDICE.jsonl');
+const text = (value) => (typeof value === 'string' ? value : null);
+function ordered(raw) {
+    return {
+        v: 1,
+        id: raw.id,
+        trabalho_tipo: text(raw.trabalho_tipo),
+        titulo: text(raw.titulo),
+        status: text(raw.status),
+        criado_em: text(raw.criado_em),
+        data: text(raw.data),
+        arquivos: Array.isArray(raw.arquivos) ? raw.arquivos.filter((a) => typeof a === 'string') : [],
+        causa_raiz: text(raw.causa_raiz),
+        caminho: text(raw.caminho) ?? join(WORKS_DIR, raw.id).replaceAll('\\', '/'),
+        commit: text(raw.commit),
+        arquivado_em: text(raw.arquivado_em) ?? '',
+    };
+}
+/** Lê o índice do arquivo; vale a última linha de cada id, e a última linha sem `\n` é ignorada. */
+export function readArchiveIndex(root) {
+    const file = join(root, ARCHIVE_INDEX);
+    if (!existsSync(file))
+        return { trabalhos: [], problemas: [] };
+    const lines = readFileSync(file, 'utf8').split('\n');
+    lines.pop();
+    const byId = new Map();
+    const problemas = [];
+    lines.forEach((line, index) => {
+        if (!line.trim())
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            problemas.push({ linha: index + 1, mensagem: 'linha não é JSON válido' });
+            return;
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || typeof parsed.id !== 'string') {
+            problemas.push({ linha: index + 1, mensagem: 'linha sem `id` texto' });
+            return;
+        }
+        const { v } = parsed;
+        if (typeof v === 'number' && v > 1) {
+            problemas.push({ linha: index + 1, mensagem: `versão ${v} do índice é mais nova que a suportada (1); atualize o ai-harness` });
+            return;
+        }
+        const entry = ordered(parsed);
+        byId.delete(entry.id);
+        byId.set(entry.id, entry);
+    });
+    return { trabalhos: [...byId.values()], problemas };
+}
+/** Acrescenta uma linha por entrada ao índice, sem reescrever as anteriores. */
+export function appendArchiveEntries(root, entries) {
+    if (entries.length === 0)
+        return;
+    const file = join(root, ARCHIVE_INDEX);
+    mkdirSync(dirname(file), { recursive: true });
+    const current = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const prefix = current && !current.endsWith('\n') ? '\n' : '';
+    appendFileSync(file, prefix + entries.map((entry) => `${JSON.stringify(ordered(entry))}\n`).join(''));
+}

package/dist/trabalhos/listar.js

@@ -0,0 +1,37 @@
+export const NO_WORKS_FOUND = 'Nenhum trabalho encontrado.';
+const fold = (value) => value.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase();
+const show = (value) => value ?? '?';
+function compareWorks([idA, a], [idB, b]) {
+    if (a.data !== b.data) {
+        if (!a.data)
+            return 1;
+        if (!b.data)
+            return -1;
+        return a.data < b.data ? 1 : -1;
+    }
+    return idA < idB ? 1 : idA > idB ? -1 : 0;
+}
+/**
+ * Linhas `id | tipo | status | título` dos trabalhos do índice, arquivados incluídos, da data mais recente
+ * para a mais antiga. `busca` casa com id ou título sem diferenciar caixa nem acento; `tipo` e `status`
+ * comparam com o valor cru. Sem resultado, devolve só a linha de nenhum trabalho encontrado.
+ */
+export function listWorks(index, options = {}) {
+    const { busca, tipo, status, limite = 20 } = options;
+    const term = busca ? fold(busca) : null;
+    const lines = Object.entries(index.trabalhos)
+        .filter(([id, work]) => {
+        if (tipo !== undefined && work.trabalho_tipo !== tipo)
+            return false;
+        if (status !== undefined && work.status !== status)
+            return false;
+        return !term || fold(id).includes(term) || (work.titulo !== null && fold(work.titulo).includes(term));
+    })
+        .sort(compareWorks)
+        .slice(0, Math.max(0, limite))
+        .map(([id, work]) => {
+        const workStatus = work.arquivado ? `${show(work.status)} (arquivado)` : show(work.status);
+        return [id, show(work.trabalho_tipo), workStatus, show(work.titulo)].join(' | ');
+    });
+    return lines.length > 0 ? lines : [NO_WORKS_FOUND];
+}

package/dist/update/update.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { allCommands, loadCatalog } from '../catalog.js';
-import { commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
+import { allCommands, loadCatalog, templatesDir } from '../catalog.js';
+import { COMMENTS_HOOK_PATH, commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
 import { CONFIG_PATH, gravarInstalarComentarios, gravarRegistrarMcp, migrarSecaoBanco, readConfig, syncGitignore, temSecaoBancoLegada, writeDefaultConfig, } from '../config/config.js';
 import { applyAtomically } from '../install/atomic.js';
 import { suggestFlag } from '../install/flags.js';
@@ -50,6 +50,12 @@ function legacyPath(root, path) {
             return candidate;
     }
 }
+const COMMENTS_HOOK_TEMPLATE = join(templatesDir, 'hooks', 'comentarios', 'check.mjs');
+/** O hook de comentários existe no projeto com conteúdo diferente do template do pacote. */
+function hookProprio(root) {
+    const local = join(root, COMMENTS_HOOK_PATH);
+    return existsSync(local) && hashContent(readFileSync(local)) !== hashContent(readFileSync(COMMENTS_HOOK_TEMPLATE));
+}
 export function checkUpdate(root, catalog = loadCatalog(), legacy, home, { semBanco = false, semComentarios = false } = {}) {
     const recorded = readLock(root);
     const lock = recorded ?? adoptLegacyInstall(root, legacy);
@@ -139,7 +145,10 @@ export function checkUpdate(root, catalog = loadCatalog(), legacy, home, { semBa
     }
     // O padrão de comentários também chega ao lock anterior a ele, salvo com a recusa no config ou na flag. O hook é a
     // referência: o comando `comentarios` não registra a rule quando o projeto já tem uma própria.
-    const registrarComentarios = !semComentarios && config.comentarios.instalar && (adotada || !trackedItems.has('hook:comentarios'));
+    const querComentarios = !semComentarios && config.comentarios.instalar;
+    const hookNoLock = trackedItems.has('hook:comentarios');
+    const registrarHookComentarios = querComentarios && !hookNoLock && hookProprio(root);
+    const registrarComentarios = querComentarios && !registrarHookComentarios && (adotada || !hookNoLock);
     if (registrarComentarios) {
         addItem('rule', 'comentarios', true);
         addItem('hook', 'comentarios', true);
@@ -159,6 +168,7 @@ export function checkUpdate(root, catalog = loadCatalog(), legacy, home, { semBa
         adotada,
         registrarHooks: adotada && !pluginHooks,
         registrarComentarios,
+        registrarHookComentarios,
         recusarComentarios: semComentarios && config.comentarios.instalar,
         permissaoAusente: permissoesFaltando.length > 0,
         permissoesFaltando,
@@ -281,6 +291,10 @@ export function applyUpdate(root, report, options, pkg, now = new Date()) {
     for (const added of addedItems.values()) {
         itens.push({ ...added, arquivos: added.arquivos.sort((a, b) => a.caminho.localeCompare(b.caminho)) });
     }
+    // Com o hash do template, o arquivo do projeto aparece como modificado-local e nunca é regravado sem --forcar.
+    if (report.registrarHookComentarios) {
+        itens.push({ tipo: 'hook', id: 'comentarios', arquivos: [{ caminho: COMMENTS_HOOK_PATH, sha256: hashContent(readFileSync(COMMENTS_HOOK_TEMPLATE)) }] });
+    }
     writeLock(root, { lock_versao: LOCK_VERSION, pacote: pkg, gerado_em: now.toISOString(), itens });
     return { written: write.map((file) => file.path), removed: remove, kept, renamed, avisos, ajustes };
 }
@@ -321,6 +335,12 @@ export function describeUpdate(report) {
                     `Para recusar, rode com --sem-comentarios, que grava comentarios.instalar: false em ${CONFIG_PATH}.`,
             ]
             : []),
+        ...(report.registrarHookComentarios
+            ? [
+                `O hook de comentários ${COMMENTS_HOOK_PATH} é do projeto (instalado por versão antiga ou adaptado) e não está no lock: ` +
+                    'o --yes o deixa registrado no lock como alterado localmente, sem tocar no arquivo.',
+            ]
+            : []),
         ...(report.recusarComentarios ? [`--sem-comentarios: o --yes grava comentarios.instalar: false em ${CONFIG_PATH} e não instala o padrão de comentários.`] : []),
     ];
     const legadas = report.permissoesLegadas.length
@@ -386,7 +406,7 @@ export function runUpdateCommand(argv) {
     const report = checkUpdate(root, undefined, undefined, undefined, { semBanco: args.semBanco, semComentarios: args.semComentarios });
     console.log(describeUpdate(report));
     // Sem arquivo a atualizar, a adoção ainda grava o lock, e a permissão e o MCP ainda são acrescentados.
-    const pendente = report.adotada || report.permissaoAusente || report.permissoesLegadas.length > 0 || report.mudancaMcp !== null || report.recusarMcp || report.recusarComentarios || report.renomearSecaoBanco;
+    const pendente = report.adotada || report.permissaoAusente || report.permissoesLegadas.length > 0 || report.mudancaMcp !== null || report.recusarMcp || report.recusarComentarios || report.registrarHookComentarios || report.renomearSecaoBanco;
     if (args.check || (!report.changes.length && !pendente))
         return 0;
     if (!args.yes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fontdata/ai-harness",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "description": "Harness de engenharia com IA da Fontdata para Claude Code: roda os slash commands direto na pasta do projeto via npx, sem instalar nada — ou instala-os em .claude/commands.",
   "type": "module",
   "bin": {

package/templates/agents/investigador.md

@@ -14,8 +14,8 @@ ou quando ficou claro que ela ainda é hipótese. Você não corrige o bug.
 2. **Levante hipóteses** e, para cada uma, busque evidência que a confirme ou a descarte:
    - leitura do código envolvido;
    - histórico: `git log -p -S "<trecho>"`, `git log --follow <arquivo>`, `git blame -L <ini>,<fim> <arquivo>`;
-   - trabalhos anteriores que tocaram os mesmos arquivos (`docs/trabalhos/*/` e o campo `arquivos` do
-     frontmatter).
+   - trabalhos anteriores que tocaram os mesmos arquivos: `npx @fontdata/ai-harness memoria --arquivo <caminho>` e
+     `npx @fontdata/ai-harness memoria --regressao <id>`, que incluem os trabalhos arquivados.
 3. **Comprove.** A causa raiz só é `comprovada` quando você mostra a linha ou a condição que produz o sintoma e
    por que a reprodução falha por causa dela. Caso contrário, ela é `hipotese`.
 4. Use `Bash` só para ler, buscar no histórico e reproduzir: você é somente leitura, então não altere arquivos, instale dependências,

package/templates/hooks/comentarios/check.mjs

@@ -170,6 +170,10 @@ const ehTexto = (c) => typeof c === 'string';
 function analisar(caminho, fonte) {
   const ext = extname(caminho);
   const linhas = fonte.split('\n');
+  if (PASCAL.has(ext)) {
+    const fim = linhas.findLastIndex((l) => /^\s*end\.\s*$/i.test(l));
+    if (fim >= 0) linhas.length = fim + 1;
+  }
   const achados = [];
   const marca = (linha, msg) => achados.push({ linha, msg });
   const ehComentario = classificar(linhas, ext);

package/templates/rules/comentarios.md

@@ -46,7 +46,8 @@ Se o porquê não cabe em 3 linhas, **ele não pertence ao código**.
 | Por que a mudança foi feita | mensagem de commit | comentário |
 | Task / fase / plano / spec | `PLAN.md` e `SPEC.md` do trabalho em `docs/trabalhos/<id>/` | comentário |
 | Diagnóstico e correção de um defeito | trabalho do tipo `bug` em `docs/trabalhos/<id>/` | comentário |
-| Investigação, medição, auditoria, paridade, comparação | relatórios do trabalho em `docs/trabalhos/<id>/relatorios/` | comentário |
+| Investigação, medição, auditoria, paridade, comparação | `relatorios/TECNICO.md` do trabalho em `docs/trabalhos/<id>/` | comentário |
+| Documento de apoio do trabalho (imagem, planilha, export, contrato de API) | `anexos/` do trabalho em `docs/trabalhos/<id>/` | comentário |
 | Achado de review | resposta do review, commit | comentário |
 | Decisão de arquitetura | `SPEC.md` | comentário |
 | Armadilha ao editar **aquela linha** | comentário de até 3 linhas | — |
@@ -56,7 +57,9 @@ correção aplicada no código — é trabalho do tipo `bug` (`/resolver-bug`).
 auditoria, paridade com legado, medição, comparação, levantamento, handoff ou follow-up — é
 `auditoria` ou `investigacao`. Se o documento descreve trabalho a fazer, é `feature` (`/nova-tarefa`).
 
-Convenção: uma pasta por trabalho, `docs/trabalhos/<yyyy-mm-dd>-<slug>/`.
+Convenção: uma pasta por trabalho, `docs/trabalhos/<yyyy-mm-dd>-<slug>/`. Relatório não ganha nome livre em
+`relatorios/`: o conteúdo vai para `relatorios/TECNICO.md` e o arquivo de apoio para `anexos/`, senão o `doctor`
+avisa `arquivo-fora-do-contrato`.
 
 ## Antes e depois
 
@@ -154,6 +157,7 @@ function HashApiKey(const APlainKey: string): string;
 - **TypeScript/JavaScript/Java/C#/C++/Go/Rust/PHP:** `/** ... */` no topo do símbolo **público**.
 - **Python:** docstring `"""..."""` curta logo abaixo da assinatura.
 - **Delphi/Pascal:** `///` (XMLDoc) nas rotinas públicas da `interface`; nunca repetir na `implementation`.
+  O que vem depois do último `end.` (o rodapé de histórico, que o compilador ignora) fica fora deste padrão e do hook.
 - **SQL/Shell/YAML:** somente regra de negócio ou pegadinha não evidente.
 
 ## Enforcement

package/templates/skills/evoluir-harness/references/auditoria.md

@@ -100,8 +100,9 @@ cada tipo na sua pasta dentro de `docs/`). Hoje cada trabalho mora em `docs/trab
 
 ## 8. O que criar
 
-Sugira peças novas para dores recorrentes. Busque evidência em `docs/trabalhos/*/DECISOES.md`, `BLOQUEIOS.md`,
-relatórios, achados de review repetidos e `npx @fontdata/ai-harness memoria --arquivo <arquivo>`. Para cada
+Sugira peças novas para dores recorrentes. Comece por `npx @fontdata/ai-harness trabalhos listar` e busque
+evidência em `DECISOES.md`, `BLOQUEIOS.md` e relatórios só dos trabalhos ativos e dos indicados por ele, em achados
+de review repetidos e em `npx @fontdata/ai-harness memoria --arquivo <arquivo>`. Para cada
 sugestão: tipo (`agent`, `skill`, `rule`, `hook`, `code-reviewer`, `design-system`), o que faria, quando seria
 usada e qual **dor recorrente** elimina.
 

package/templates/skills/evoluir-harness/references/skill.md

@@ -5,7 +5,8 @@ Cria uma skill do projeto em `.claude/skills/<nome>/` para um problema **recorre
 ## Leitura
 
 `CLAUDE.md` e `SPEC.md` da raiz, as skills que já existem (do projeto e do harness) e, como evidência de
-recorrência, `DECISOES.md`, `BLOQUEIOS.md` e relatórios em `docs/trabalhos/*/`.
+recorrência, `DECISOES.md`, `BLOQUEIOS.md` e relatórios dos trabalhos: comece por
+`npx @fontdata/ai-harness trabalhos listar` e leia só os trabalhos ativos e os indicados por ele.
 
 ## Skill, rule, agent ou hook?
 

package/templates/skills/memoria/SKILL.md

@@ -8,7 +8,8 @@ argument-hint: "[caminho de arquivo ou id de um bug]"
 
 Pergunta: $ARGUMENTS
 
-A memória é um **índice** gerado a partir do frontmatter dos trabalhos em `docs/trabalhos/` e do rastro de eventos.
+A memória é um **índice** gerado a partir do frontmatter dos trabalhos em `docs/trabalhos/`, arquivados inclusive, e
+do rastro de eventos.
 Não é busca semântica: toda resposta aponta um trabalho e os documentos dele, e pode ser conferida.
 
 ## Passo 1 — Atualizar o índice

package/templates/skills/nova-tarefa/SKILL.md

@@ -18,8 +18,8 @@ uma pergunta durante a execução é falha do plano.
 
 1. Leia o `SPEC.md` e o `CLAUDE.md` da raiz e, se existir, a rule de projeto `.claude/rules/harness-projeto.md`: o
    mapa de agents por domínio e os portões extras entram no plano.
-2. Liste os trabalhos existentes em `docs/trabalhos/` (título, tipo e status no frontmatter) para não duplicar
-   nem contradizer um trabalho em andamento.
+2. Rode `npx @fontdata/ai-harness trabalhos listar --busca <termo do pedido>` (id, tipo, status e título, com os
+   arquivados) para não duplicar nem contradizer um trabalho em andamento.
 3. **Start inicial** (não há trabalho do tipo `feature` ainda, ou o pedido é "start"/"primeira fatia"): derive o
    recorte direto do `SPEC.md` — a primeira fatia vertical. **Nova tarefa:** siga para o Passo 1.
 
@@ -48,7 +48,8 @@ mais conservadora.
 
 ## Passo 3 — Pasta do trabalho e SPEC.md
 
-1. Defina o id `AAAA-MM-DD-<slug>` (data de hoje, slug curto em minúsculas, sem acento).
+1. Defina o id `AAAA-MM-DD-<slug>` (data de hoje, slug curto em minúsculas, sem acento) e confira que
+   `npx @fontdata/ai-harness trabalhos listar --busca <id>` não devolve nenhum trabalho, nem arquivado.
 2. Crie `docs/trabalhos/<id>/SPEC.md` a partir de `templates/SPEC.md`, preenchendo `{{id}}`, `{{titulo}}` e
    `{{data}}`. Os nomes dos arquivos da pasta são sempre em caixa alta.
    A seção **Como vai operar** é obrigatória: é dela que o `/executar-plan` tira o relatório para o cliente e para

package/templates/skills/nova-tarefa/references/isso-ja-existe.md

@@ -10,7 +10,8 @@ Antes de planejar, procure evidência — nunca presuma.
 2. **Pontos de entrada:** rotas e controllers, menus e telas, comandos de CLI, jobs agendados.
 3. **Dados:** tabelas e colunas (migrations, models, scripts SQL) que já guardam o que o pedido precisa.
 4. **Configuração e flags:** a funcionalidade pode existir desligada por configuração ou feature flag.
-5. **Trabalhos anteriores:** `docs/trabalhos/*/SPEC.md` e o campo `arquivos` do frontmatter dos planos e relatórios.
+5. **Trabalhos anteriores:** `npx @fontdata/ai-harness trabalhos listar --busca <termo>` e, para os arquivos que o
+   pedido toca, `npx @fontdata/ai-harness memoria --arquivo <caminho>`; os dois incluem os trabalhos arquivados.
 
 ## Como concluir