@fontdata/ai-harness 2.1.0 → 2.3.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "fontdata",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Harness de engenharia com IA da Fontdata para Claude Code",
   "author": { "name": "Fontdata" },
   "commands": ["./templates/commands"],

package/README.md

@@ -108,11 +108,12 @@ duas vezes.
 | Subcomando | O que faz |
 |---|---|
 | `init [caminho]` | Instala comandos, skills, agents e hooks no projeto |
-| `doctor [caminho]` | Diagnostica instalação, contrato dos documentos, rastro, bloqueios antigos e versão do Node |
+| `doctor [caminho]` | Diagnostica instalação, contrato dos documentos, rastro, bloqueios antigos, citações às pastas antigas de `docs/` no código e versão do Node |
 | `update [caminho]` | Atualiza o que foi instalado sem sobrescrever alterações locais (`--check`, `--yes`, `--forcar`) |
-| `migrar [caminho]` | Move os documentos do layout anterior para `docs/trabalhos/<id>/` (`--yes`) |
+| `migrar [caminho]` | Move os documentos do layout anterior para `docs/trabalhos/<id>/` (`--yes`); `--reclassificar` corrige planos migrados que ficaram em execução |
 | `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`) |
 | `comentarios [caminho]` | Instala o hook do padrão de comentários com a catraca do legado (`--yes`) |
 | `list` | Lista o catálogo |
 

package/dist/cli.js

@@ -11,6 +11,7 @@ const RESERVED = new Set([
     'update',
     'migrar',
     'evento',
+    'conflitos',
     'comentarios',
     'memoria',
     'list',
@@ -47,9 +48,11 @@ Gerenciar:
   doctor [caminho]  Diagnostica a instalação (arquivos, lock, skills, agents, hooks, Node)
   update [caminho]  Atualiza o que foi instalado: --check só lista, --yes aplica, --forcar sobrescreve conflitos
   migrar [caminho]  Move docs/specs, plans, bugs e investigacoes para docs/trabalhos/<id>/ (--yes aplica)
+                    --reclassificar: planos já migrados em em-execucao viram concluido ou legado
   comentarios [caminho]  Instala o hook de comentários e a catraca do legado (--yes aplica)
   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)
   list            Lista todos os comandos disponíveis no catálogo
 
 Init sem perguntas (CI):
@@ -139,6 +142,10 @@ async function main() {
         const { runEventCommand } = await import('./rastro/command.js');
         process.exit(await runEventCommand(argv.slice(1)));
     }
+    if (cmd === 'conflitos') {
+        const { runConflictsCommand } = await import('./trabalhos/conflitos.js');
+        process.exit(await runConflictsCommand(argv.slice(1)));
+    }
     if (cmd === 'update') {
         const { runUpdateCommand } = await import('./update/update.js');
         process.exit(runUpdateCommand(argv.slice(1)));

package/dist/config/config.js

@@ -73,13 +73,14 @@ export function writeDefaultConfig(root) {
 const BLOCK_START = '# ai-harness (gerenciado pelo harness; não edite entre estas linhas)';
 const BLOCK_END = '# /ai-harness';
 /**
- * Mantém no .gitignore um bloco próprio: a memória gerada é sempre ignorada e o
- * rastro só quando `rastro.versionar` é false. Linhas fora do bloco não são tocadas.
+ * Mantém no .gitignore um bloco próprio: a memória gerada e o estado local da sessão
+ * (`estado.json`) são sempre ignorados, e o rastro só quando `rastro.versionar` é false.
+ * Linhas fora do bloco não são tocadas.
  */
 export function syncGitignore(root, config) {
     const file = join(root, '.gitignore');
     const current = existsSync(file) ? readFileSync(file, 'utf8') : '';
-    const entries = ['.ai-harness/memoria/', ...(config.rastro.versionar ? [] : ['docs/eventos/'])];
+    const entries = ['.ai-harness/memoria/', '.ai-harness/estado.json', ...(config.rastro.versionar ? [] : ['docs/eventos/'])];
     const block = [BLOCK_START, ...entries, BLOCK_END].join('\n');
     const start = current.indexOf(BLOCK_START);
     const end = start === -1 ? -1 : current.indexOf(BLOCK_END, start);

package/dist/contratos/artefatos.js

@@ -19,7 +19,7 @@ export const ARTIFACT_TYPES = {
 };
 export const STATUS_BY_TYPE = {
     spec: ['rascunho', 'aguardando-aprovacao', 'aprovado', 'substituido'],
-    plano: ['rascunho', 'aguardando-aprovacao', 'em-execucao', 'concluido', 'cancelado'],
+    plano: ['rascunho', 'aguardando-aprovacao', 'em-execucao', 'concluido', 'cancelado', 'legado'],
     decisoes: ['ativo'],
     bloqueios: ['aberto', 'resolvido'],
     relatorio_tecnico: ['rascunho', 'final'],

package/dist/doctor/checks.js

@@ -8,6 +8,7 @@ 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';
+import { checkLegacyDocsCitations, checkMigratedPlansRunning } from './migracao.js';
 const MIN_NODE_MAJOR = 22;
 const PLUGIN_ID = 'fontdata@ai-harness';
 const HARNESS_HOOKS_DIR = '.claude/hooks/ai-harness/';
@@ -413,6 +414,8 @@ export function runDoctor(root, options = {}) {
         ...checkStaleBlocks(root, options.now ?? new Date(), options.staleBlockDays ?? config.bloqueios.dias_para_aviso),
         ...checkEventLogs(root),
         ...checkCompletedTasks(root),
+        ...checkMigratedPlansRunning(root),
+        ...checkLegacyDocsCitations(root),
     ];
 }
 export function formatFindings(findings) {

package/dist/doctor/migracao.js

@@ -0,0 +1,97 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { extname, join } from 'node:path';
+import { readArtifact, WORKS_DIR } from '../contratos/artefatos.js';
+/** As mesmas extensões e pastas ignoradas do hook de comentários (templates/hooks/comentarios/check.mjs). */
+const CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.java', '.cs', '.php', '.pas', '.dpr', '.sql', '.sh']);
+const SKIPPED_DIRS = new Set(['node_modules', 'dist', 'build', 'coverage', 'out', 'vendor', 'generated', '__generated__']);
+const MAX_FILE_BYTES = 1_000_000;
+const LEGACY_CITATION = /\b[Dd]ocs\/(?:specs|plans|bugs|investigacoes)\//g;
+const TEST_FILE = /\.(test|spec)\.[jt]sx?$/;
+const COMMENT_LINE = /^\s*(\*|\(\*|\{(?!\$))/;
+const COMMENT_MARKER = /\/\/|\/\*|#|--/;
+const EXAMPLES_SHOWN = 5;
+function codeFiles(root, dir = '', found = []) {
+    let entries;
+    try {
+        entries = readdirSync(join(root, dir), { withFileTypes: true });
+    }
+    catch {
+        return found;
+    }
+    for (const entry of entries) {
+        const rel = dir ? `${dir}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            if (!entry.name.startsWith('.') && !SKIPPED_DIRS.has(entry.name))
+                codeFiles(root, rel, found);
+        }
+        else if (entry.isFile() && CODE_EXTENSIONS.has(extname(entry.name)) && !entry.name.endsWith('.d.ts') && !TEST_FILE.test(entry.name)) {
+            found.push(rel);
+        }
+    }
+    return found;
+}
+/**
+ * O `migrar` reescreve os links dos documentos, mas não toca no código: a citação às pastas antigas num comentário
+ * vira caminho quebrado, e a rule de comentários já proíbe citar docs/ no código.
+ */
+export function checkLegacyDocsCitations(root) {
+    const places = [];
+    let total = 0;
+    for (const rel of codeFiles(root).sort()) {
+        const file = join(root, rel);
+        if (statSync(file).size > MAX_FILE_BYTES)
+            continue;
+        const lines = readFileSync(file, 'utf8').split('\n');
+        lines.forEach((line, index) => {
+            // Só a citação em comentário: a mesma string num literal de código é dado, não rastreabilidade.
+            const inComment = COMMENT_LINE.test(line)
+                ? [...line.matchAll(LEGACY_CITATION)]
+                : [...line.matchAll(LEGACY_CITATION)].filter((match) => COMMENT_MARKER.test(line.slice(0, match.index)));
+            const count = inComment.length;
+            if (!count)
+                return;
+            total += count;
+            places.push(`${rel}:${index + 1}`);
+        });
+    }
+    if (!total)
+        return [];
+    const files = new Set(places.map((place) => place.slice(0, place.lastIndexOf(':')))).size;
+    const examples = places.slice(0, EXAMPLES_SHOWN).join(', ');
+    const more = places.length > EXAMPLES_SHOWN ? ` e mais ${places.length - EXAMPLES_SHOWN}` : '';
+    return [
+        {
+            id: 'citacao-docs-em-codigo',
+            severidade: 'aviso',
+            mensagem: `${total} citação(ões) em ${files} arquivo(s) de código apontam para docs/specs, docs/plans, docs/bugs ou ` +
+                `docs/investigacoes, pastas que o migrar substituiu por docs/trabalhos/: ${examples}${more}.`,
+            correcao: 'Remova a citação do comentário (o vínculo fica no commit ou em docs/trabalhos/), como pede a rule ' +
+                '.claude/rules/comentarios.md. Arquivo tolerado pela catraca pode ser limpo aos poucos.',
+        },
+    ];
+}
+/** Planos migrados antes da 2.3.0 ficaram `em-execucao` e aparecem como ativos em todo `conflitos`. */
+export function checkMigratedPlansRunning(root) {
+    const dir = join(root, WORKS_DIR);
+    if (!existsSync(dir))
+        return [];
+    const stuck = readdirSync(dir).filter((id) => {
+        const rel = `docs/trabalhos/${id}/PLAN.md`;
+        if (!existsSync(join(root, rel)))
+            return false;
+        const { data } = readArtifact(rel, readFileSync(join(root, rel), 'utf8'));
+        const arquivos = Array.isArray(data?.arquivos) ? data.arquivos : [];
+        return data?.migrado === true && data.status === 'em-execucao' && !arquivos.length;
+    });
+    if (!stuck.length)
+        return [];
+    return [
+        {
+            id: 'plano-migrado-em-execucao',
+            severidade: 'aviso',
+            mensagem: `${stuck.length} plano(s) migrado(s) do layout antigo estão como em-execucao sem declarar arquivos: ${stuck.slice(0, EXAMPLES_SHOWN).join(', ')}${stuck.length > EXAMPLES_SHOWN ? ' …' : ''}.`,
+            correcao: 'Rode `npx @fontdata/ai-harness migrar --reclassificar --yes`: plano sem caixa aberta vira concluido, e o ' +
+                'restante vira legado, que não conta como trabalho ativo.',
+        },
+    ];
+}

package/dist/install/plan.js

@@ -7,7 +7,7 @@ import { buildLockItem, LOCK_VERSION, readLock, writeLock } from './lock.js';
 import { HOOKS_ITEM_ID, PROJECT_HOOKS_DIR, projectHooksConfig } from './hooks.js';
 import { neededSkillsFor, resolveSelection } from './selection.js';
 import { COMMENTS_RULE_PATH, commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
-import { combineHooks, EVENT_PERMISSION, mergeSettings } from './settings.js';
+import { combineHooks, HARNESS_PERMISSIONS, mergeSettings } from './settings.js';
 /** Rule de convenção com o que é específico do projeto (D-38): é do projeto, então fica fora do lock. */
 export const PROJECT_RULE_PATH = '.claude/rules/harness-projeto.md';
 /** Esqueleto da rule de projeto; os comandos `-legado` renomeados pelo update entram na última seção. */
@@ -162,7 +162,7 @@ export function executePlan(root, plan, pkg, now = new Date()) {
     const permission = needsEventPermission(plan);
     const hooks = combineHooks(plan.registerHooks ? projectHooksConfig() : {}, plan.registerComments ? commentsHooksConfig() : {});
     if (Object.keys(hooks).length || permission)
-        mergeSettings(root, { hooks, allow: permission ? [EVENT_PERMISSION] : [] }, now);
+        mergeSettings(root, { hooks, allow: permission ? HARNESS_PERMISSIONS : [] }, now);
     if (plan.registerComments)
         ensureCommentsBaseline(root);
     const items = new Map();
@@ -201,7 +201,7 @@ export function describePlan(plan) {
     if (plan.registerHooks)
         lines.push('Hooks do harness registrados em .claude/settings.json (sem duplicar os existentes).');
     if (needsEventPermission(plan))
-        lines.push(`Permissão ${EVENT_PERMISSION} em .claude/settings.json, para o rastro não pedir aprovação.`);
+        lines.push(`Permissões ${HARNESS_PERMISSIONS.join(' e ')} em .claude/settings.json, para o rastro e a checagem de conflitos não pedirem aprovação.`);
     if (plan.registerComments) {
         lines.push('Padrão de comentários: rule carregada em toda sessão, hook que bloqueia a violação e catraca do legado (gerada só na primeira instalação).');
     }

package/dist/install/settings.js

@@ -3,6 +3,10 @@ import { join } from 'node:path';
 export const SETTINGS_PATH = join('.claude', 'settings.json');
 /** As skills de fluxo e os agents registram o rastro por este comando; sem a regra, cada evento pede aprovação. */
 export const EVENT_PERMISSION = 'Bash(npx @fontdata/ai-harness evento:*)';
+/** O /executar-plan checa (e aguarda) conflito de arquivos com outros trabalhos por este comando. */
+export const CONFLICTS_PERMISSION = 'Bash(npx @fontdata/ai-harness conflitos:*)';
+/** Regras de `permissions.allow` que o init e o update gravam para as skills e os agents do harness. */
+export const HARNESS_PERMISSIONS = [EVENT_PERMISSION, CONFLICTS_PERMISSION];
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/migrar/migrar.js

@@ -179,6 +179,10 @@ function rootCauseOf(body) {
         return 'hipotese';
     return UNCONFIRMED.test(body.slice(label.index, label.index + 600)) ? 'hipotese' : 'comprovada';
 }
+/** Plano antigo com caixa aberta não está necessariamente em execução: `legado` não conta como trabalho ativo. */
+function legacyPlanStatus(body) {
+    return OPEN_BOX.test(body) ? 'legado' : 'concluido';
+}
 const TASK_HEADING = /^(#{2,6})\s*(?:(?:task|tarefa)\s+|T-?)(\d+)\.(\d+)\b\s*[—–:.-]*\s*(.*)$/i;
 const TASK_ITEM = /^\s*[-*]\s+\[([ xX])\]\s+\*{0,2}(?:(?:task|tarefa)\s+|T-?)(\d+)\.(\d+)\b\s*[—–:.-]*\s*(.*)$/i;
 const ANY_HEADING = /^(#{1,6})\s/;
@@ -256,7 +260,7 @@ function contractFrontmatter(content, move, today) {
     const existing = typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : {};
     const body = match ? content.slice(match[0].length) : content;
     const heading = /^#\s+(.+)$/m.exec(body)?.[1]?.trim();
-    const status = move.tipo === 'spec' ? 'aprovado' : move.tipo === 'plano' ? (OPEN_BOX.test(body) ? 'em-execucao' : 'concluido') : 'final';
+    const status = move.tipo === 'spec' ? 'aprovado' : move.tipo === 'plano' ? legacyPlanStatus(body) : 'final';
     const data = {
         schema_versao: SCHEMA_VERSION,
         tipo: move.tipo,
@@ -366,18 +370,83 @@ export function applyMigration(root, plan) {
     for (const dir of SOURCE_DIRS)
         removeLegacyDir(root, `docs/${dir}`, git);
 }
-const MIGRATION_FLAGS = ['--yes', '-y', '--sim'];
+const FRONTMATTER = /^\uFEFF?---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+/**
+ * Planos migrados antes da 2.3.0 ficaram `em-execucao` quando tinham caixa aberta. Os que não declaram `arquivos`
+ * ganham o status que a migração daria hoje; quem preencheu `arquivos` está trabalhando neles e fica como está.
+ */
+export function planReclassification(root) {
+    const dir = join(root, 'docs', 'trabalhos');
+    if (!existsSync(dir))
+        return [];
+    const found = [];
+    for (const id of readdirSync(dir).sort()) {
+        const file = join(dir, id, 'PLAN.md');
+        if (!existsSync(file))
+            continue;
+        const content = readFileSync(file, 'utf8');
+        const match = FRONTMATTER.exec(content);
+        if (!match)
+            continue;
+        let data;
+        try {
+            data = parse(match[1] ?? '');
+        }
+        catch {
+            continue;
+        }
+        if (typeof data !== 'object' || data === null)
+            continue;
+        const { migrado, status, arquivos } = data;
+        if (migrado !== true || status !== 'em-execucao' || (Array.isArray(arquivos) && arquivos.length))
+            continue;
+        found.push({ id, de: status, para: legacyPlanStatus(content.slice(match[0].length)) });
+    }
+    return found;
+}
+/** Troca só a linha `status:` do frontmatter, para não reformatar o resto do arquivo. */
+export function applyReclassification(root, changes) {
+    for (const change of changes) {
+        const file = join(root, 'docs', 'trabalhos', change.id, 'PLAN.md');
+        const content = readFileSync(file, 'utf8');
+        const match = FRONTMATTER.exec(content);
+        if (!match)
+            continue;
+        const frontmatter = match[0].replace(/^status:[ \t]*['"]?em-execucao['"]?[ \t]*$/m, `status: ${change.para}`);
+        writeFileSync(file, frontmatter + content.slice(match[0].length));
+    }
+}
+function runReclassification(root, yes) {
+    const changes = planReclassification(root);
+    if (!changes.length) {
+        console.log('Nenhum plano migrado sem `arquivos` está como em-execucao: nada a reclassificar.');
+        return 0;
+    }
+    console.log([`Planos migrados a reclassificar (${changes.length}):`, ...changes.map((change) => `  ${change.id}: ${change.de} → ${change.para}`)].join('\n'));
+    if (!yes) {
+        console.log('\nSimulação — nada foi alterado. Rode de novo com --yes para reclassificar.');
+        return 0;
+    }
+    applyReclassification(root, changes);
+    console.log(`\nReclassificados: ${changes.length} plano(s).`);
+    return 0;
+}
+const MIGRATION_FLAGS = ['--yes', '-y', '--sim', '--reclassificar'];
 const REFERENCES_SHOWN = 40;
-/** `ai-harness migrar [caminho] [--yes]`; sem `--yes` só simula. */
+/** `ai-harness migrar [caminho] [--reclassificar] [--yes]`; sem `--yes` só simula. */
 export function runMigrationCommand(argv) {
     let path;
     let yes = false;
+    let reclassify = false;
     for (const token of argv) {
         if (!token.startsWith('-')) {
             if (path !== undefined)
                 throw new Error(`Argumento inesperado: ${token}`);
             path = token;
         }
+        else if (token === '--reclassificar') {
+            reclassify = true;
+        }
         else if (MIGRATION_FLAGS.includes(token)) {
             yes = true;
         }
@@ -389,6 +458,8 @@ export function runMigrationCommand(argv) {
     const root = resolve(process.cwd(), path ?? '.');
     if (!existsSync(root))
         throw new Error(`Pasta não encontrada: ${root}`);
+    if (reclassify)
+        return runReclassification(root, yes);
     const plan = planMigration(root);
     if (!plan.moves.length && !plan.conflicts.length) {
         const ignored = plan.ignored.length ? `\nIgnorados: ${plan.ignored.join(', ')}` : '';

package/dist/trabalhos/conflitos.js

@@ -0,0 +1,117 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { readArtifact } from '../contratos/artefatos.js';
+import { suggestFlag } from '../install/flags.js';
+import { loadRastroLib } from '../rastro/command.js';
+const FINISHED = new Set(['concluido', 'cancelado']);
+const normalize = (path) => path.trim().replace(/^\.\//, '').replace(/\/+$/, '');
+/** Mesmo arquivo, ou um dos caminhos é uma pasta que contém o outro. */
+function overlaps(a, b) {
+    return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+function readPlan(root, workId) {
+    const rel = `docs/trabalhos/${workId}/PLAN.md`;
+    const file = join(root, rel);
+    if (!existsSync(file))
+        return null;
+    const { data } = readArtifact(rel, readFileSync(file, 'utf8'));
+    if (!data)
+        return null;
+    const listed = Array.isArray(data.arquivos) ? data.arquivos : [];
+    const arquivos = listed.filter((entry) => typeof entry === 'string').map(normalize).filter(Boolean);
+    return { status: String(data.status ?? ''), arquivos, migrado: data.migrado === true };
+}
+/**
+ * Trabalhos em execução (PLAN.md `em-execucao` ou listados no estado.json) que declaram arquivos em comum
+ * com o plano do trabalho informado. Várias sessões executam trabalhos na mesma pasta; dois trabalhos
+ * mexendo no mesmo código ao mesmo tempo quebram os testes um do outro.
+ */
+export async function findConflicts(root, workId) {
+    const own = readPlan(root, workId);
+    if (!own)
+        throw new Error(`Não há docs/trabalhos/${workId}/PLAN.md com frontmatter legível.`);
+    const listed = new Set((await loadRastroLib()).findActiveWorks(root));
+    const report = { arquivos: own.arquivos, conflitos: [], semArquivos: [] };
+    for (const id of readdirSync(join(root, 'docs', 'trabalhos'))) {
+        if (id === workId)
+            continue;
+        const plan = readPlan(root, id);
+        if (!plan || FINISHED.has(plan.status) || (plan.status !== 'em-execucao' && !listed.has(id)))
+            continue;
+        if (!plan.arquivos.length) {
+            // Plano migrado do layout antigo não diz o que tocou; só avisa quando alguém o está executando de fato.
+            if (!plan.migrado || listed.has(id))
+                report.semArquivos.push(id);
+            continue;
+        }
+        const shared = own.arquivos.filter((a) => plan.arquivos.some((b) => overlaps(a, b)));
+        if (shared.length)
+            report.conflitos.push({ trabalho: id, arquivos: shared });
+    }
+    return report;
+}
+export function formatConflicts(workId, report) {
+    const lines = [];
+    if (!report.arquivos.length) {
+        lines.push(`O PLAN.md de ${workId} não declara arquivos em \`arquivos\`: sem eles não há como detectar conflito com outros trabalhos.`);
+    }
+    for (const id of report.semArquivos) {
+        lines.push(`O trabalho ${id} está em execução, mas o PLAN.md dele não declara arquivos: não há como comparar com ele.`);
+    }
+    if (!report.conflitos.length) {
+        lines.push(`Nenhum trabalho em execução mexe nos arquivos de ${workId}.`);
+        return lines.join('\n');
+    }
+    lines.push(`${workId} mexe em arquivos que estão em uso por outro trabalho em execução:`, ...report.conflitos.map((conflict) => `  - ${conflict.trabalho}: ${conflict.arquivos.join(', ')}`), `Aguarde a conclusão (npx @fontdata/ai-harness conflitos ${workId} --aguardar). Se um desses trabalhos foi ` +
+        'abandonado, troque o status do PLAN.md dele para `cancelado`.');
+    return lines.join('\n');
+}
+/** Espera até nenhum trabalho em execução mexer nos mesmos arquivos. */
+export async function waitForFreeFiles(root, workId, options) {
+    const wait = options.wait ?? sleep;
+    let previous = '';
+    for (;;) {
+        const report = await findConflicts(root, workId);
+        if (!report.conflitos.length)
+            return report;
+        const holders = report.conflitos.map((conflict) => conflict.trabalho).join(', ');
+        if (holders !== previous)
+            options.log(`Aguardando ${holders} concluir para liberar os arquivos de ${workId}...`);
+        previous = holders;
+        await wait(options.intervalMs);
+    }
+}
+const FLAGS = ['--aguardar', '--intervalo'];
+/** `ai-harness conflitos <id> [--aguardar] [--intervalo <segundos>]` — sai com 1 quando há conflito sem --aguardar. */
+export async function runConflictsCommand(argv, root = process.cwd()) {
+    const [workId, ...rest] = argv;
+    if (!workId || workId.startsWith('-')) {
+        throw new Error('Informe o id do trabalho. Ex.: npx @fontdata/ai-harness conflitos 2026-09-18-login --aguardar');
+    }
+    let waitMode = false;
+    let intervalMs = 30_000;
+    for (let i = 0; i < rest.length; i++) {
+        const flag = rest[i] ?? '';
+        if (flag === '--aguardar')
+            waitMode = true;
+        else if (flag === '--intervalo') {
+            const seconds = Number(rest[++i]);
+            if (!Number.isFinite(seconds) || seconds <= 0)
+                throw new Error('--intervalo precisa de um número de segundos maior que zero.');
+            intervalMs = seconds * 1000;
+        }
+        else {
+            const suggestion = suggestFlag(flag, FLAGS);
+            throw new Error(`Flag desconhecida: ${flag}.${suggestion ? ` Você quis dizer ${suggestion}?` : ''}`);
+        }
+    }
+    if (!waitMode) {
+        const report = await findConflicts(root, workId);
+        console.log(formatConflicts(workId, report));
+        return report.conflitos.length ? 1 : 0;
+    }
+    const report = await waitForFreeFiles(root, workId, { intervalMs, log: (line) => console.log(line) });
+    console.log(formatConflicts(workId, report));
+    return 0;
+}

package/dist/update/update.js

@@ -9,7 +9,7 @@ import { HOOKS_ITEM_ID, isHarnessPluginEnabled, projectHooksConfig } from '../in
 import { hashContent, LOCK_PATH, LOCK_VERSION, readLock, writeLock } from '../install/lock.js';
 import { itemSources, packageInfo, PROJECT_RULE_PATH, projectRuleContent } from '../install/plan.js';
 import { neededSkillsFor } from '../install/selection.js';
-import { combineHooks, EVENT_PERMISSION, hasAllowRule, mergeSettings } from '../install/settings.js';
+import { combineHooks, HARNESS_PERMISSIONS, hasAllowRule, mergeSettings } from '../install/settings.js';
 import { adoptLegacyInstall } from './legado.js';
 /** `<id>-legado.md`, com sufixo numérico quando o nome já está em uso. */
 function legacyPath(root, path) {
@@ -115,7 +115,7 @@ export function checkUpdate(root, catalog = loadCatalog(), legacy, home) {
         adotada,
         registrarHooks: adotada && !pluginHooks,
         registrarComentarios: adotada,
-        permissaoAusente: !hasAllowRule(root, EVENT_PERMISSION),
+        permissaoAusente: !HARNESS_PERMISSIONS.every((rule) => hasAllowRule(root, rule)),
     };
 }
 /**
@@ -154,7 +154,7 @@ export function applyUpdate(root, report, options, pkg, now = new Date()) {
         return { de: path, para };
     });
     const hooks = combineHooks(report.registrarHooks ? projectHooksConfig() : {}, report.registrarComentarios ? commentsHooksConfig() : {});
-    mergeSettings(root, { hooks, allow: [EVENT_PERMISSION] }, now);
+    mergeSettings(root, { hooks, allow: HARNESS_PERMISSIONS }, now);
     if (report.registrarComentarios)
         ensureCommentsBaseline(root);
     if (report.adotada) {
@@ -220,7 +220,7 @@ export function describeUpdate(report) {
                 'a rule de projeto e a permissão do `ai-harness evento`.',
         ]
         : [];
-    const permission = report.permissaoAusente && !report.adotada ? [`Falta a permissão ${EVENT_PERMISSION} em .claude/settings.json; o --yes a acrescenta.`] : [];
+    const permission = report.permissaoAusente && !report.adotada ? [`Faltam permissões do harness (${HARNESS_PERMISSIONS.join(', ')}) em .claude/settings.json; o --yes as acrescenta.`] : [];
     if (!report.changes.length) {
         const status = adopted.length || permission.length ? 'Nenhum arquivo a atualizar.' : 'A instalação está em dia: nenhum arquivo a atualizar.';
         return [...adopted, ...permission, status].join('\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fontdata/ai-harness",
-  "version": "2.1.0",
+  "version": "2.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/auditor-plano.md

@@ -22,6 +22,8 @@ ninguém pergunte nada no meio. Você não edita o plano: aponta o que precisa m
 4. **Critérios de aceite binários:** cada critério pode ser verificado com sim ou não, por comando ou observação.
 5. **Dependências:** toda task que usa algo criado por outra declara `depende_de`; sem ciclos.
 6. **Paralelismo:** tasks `paralelizavel: true` da mesma fase não alteram os mesmos arquivos.
+   O `arquivos` do frontmatter lista tudo o que as tasks vão criar ou alterar: é por ele que o `/executar-plan`
+   impede dois trabalhos em paralelo de mexerem no mesmo código. Lista vazia num plano com código é BLOQUEANTE.
 7. **Tamanho:** cada task cabe numa sessão de trabalho; task grande demais é dividida.
 8. **Legado e riscos:** áreas de código legado tocadas estão identificadas, com o padrão local a preservar.
 

package/templates/hooks/comentarios/check.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'node:fs';
-import { extname, relative, join, dirname } from 'node:path';
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, openSync, closeSync, renameSync, rmSync, statSync } from 'node:fs';
+import { extname, relative, join, dirname, sep } from 'node:path';
 
 const MAX_BLOCO = Number(process.env.COMENTARIOS_MAX_BLOCO ?? 3);
 const MAX_DOCSTRING = Number(process.env.COMENTARIOS_MAX_DOCSTRING ?? 5);
@@ -21,14 +21,18 @@ const IGNORAR = [
 ];
 
 const CABECALHO_PERMITIDO =
-  /eslint|ts-nocheck|ts-ignore|prettier|@license|copyright|spdx|jshint|globals|^#!|use (strict|client|server)/i;
+  /eslint|ts-nocheck|ts-check|ts-ignore|prettier|@license|copyright|spdx|jshint|globals|^#!|use (strict|client|server)/i;
 
 const BANNER = /^[-=─-╿_*#~+]{3,}|[-=─-╿_*#~+]{3,}$/;
 
+// Só a palavra ignora caixa: com a flag `i`, o romano casaria o "i" de "specialty".
+const semCaixa = (texto) => texto.replace(/\p{L}/gu, (c) => `[${c.toLowerCase()}${c.toUpperCase()}]`);
+const PROCESSO = new RegExp(`\\b(${semCaixa('task|tarefa|fase|etapa|plano|spec|sprint|epico|épico')})\\s*(\\d|[IVX]+\\b)`, 'u');
+
 const RASTREIO = [
-  [/\b(task|tarefa|fase|etapa|plano|spec|sprint|epico|épico)\s*[\dIVX]/i, 'referência a task/fase/plano/spec'],
+  [PROCESSO, 'referência a task/fase/plano/spec'],
   [/\bT\d+(\.\d+)+\b/, 'referência a task (T0.0)'],
-  [/docs\/(plans|specs|bugs|investigacoes)\//i, 'caminho de docs/ dentro do código'],
+  [/docs\/(plans|specs|bugs|investigacoes|trabalhos)\//i, 'caminho de docs/ dentro do código'],
   [/\bachado d[oe]\b/i, 'achado de review no código'],
   [/@[\w-]*(reviewer|auditor|orquestrador|agent)\b/i, 'menção a agent no código'],
   [/\b(commit|sha|hash)\s+[0-9a-f]{7,40}\b/i, 'hash de commit'],
@@ -121,12 +125,47 @@ function analisar(caminho, fonte) {
   return { achados, comentadas, uteis, densidade: uteis ? comentadas / uteis : 0 };
 }
 
+const raiz = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const BASELINE = join(raiz, '.claude', 'hooks', 'comentarios', 'baseline.json');
+
+// Pasta oculta na raiz (.claude, .ai-harness, .vscode...) é de ferramenta, não do projeto.
+function emPastaOculta(caminho) {
+  const rel = relative(raiz, caminho);
+  if (!rel || rel.startsWith('..')) return false;
+  return rel.split(sep).slice(0, -1).some((parte) => parte.startsWith('.'));
+}
+
 function elegivel(caminho) {
-  return EXTENSOES.has(extname(caminho)) && !IGNORAR.some((re) => re.test(caminho));
+  return EXTENSOES.has(extname(caminho)) && !IGNORAR.some((re) => re.test(caminho)) && !emPastaOculta(caminho);
 }
 
-const raiz = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const BASELINE = join(raiz, '.claude', 'hooks', 'comentarios', 'baseline.json');
+function gravarAtomico(arquivo, conteudo) {
+  const temp = `${arquivo}.${process.pid}.tmp`;
+  writeFileSync(temp, conteudo);
+  renameSync(temp, arquivo);
+}
+
+const esperar = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+
+// Vários agents editam em paralelo: a trava serializa o reler-e-gravar, e cada um mexe só na própria chave.
+function atualizarBaseline(chave, valor) {
+  const trava = `${BASELINE}.lock`;
+  let travado = false;
+  for (let tentativa = 0; tentativa < 300 && !travado; tentativa++) {
+    try { closeSync(openSync(trava, 'wx')); travado = true; } catch {
+      try { if (Date.now() - statSync(trava).mtimeMs > 10_000) rmSync(trava, { force: true }); } catch {}
+      if (!travado) esperar(10);
+    }
+  }
+  try {
+    const atual = JSON.parse(readFileSync(BASELINE, 'utf8'));
+    if (valor === 0) delete atual[chave];
+    else atual[chave] = Math.min(valor, atual[chave] ?? valor);
+    gravarAtomico(BASELINE, `${JSON.stringify(atual, null, 2)}\n`);
+  } catch {} finally {
+    if (travado) rmSync(trava, { force: true });
+  }
+}
 
 function varrer(dir, saida = []) {
   let itens;
@@ -134,7 +173,7 @@ function varrer(dir, saida = []) {
   for (const item of itens) {
     const cheio = join(dir, item.name);
     if (item.isDirectory()) {
-      if (item.name === 'node_modules' || item.name === '.git') continue;
+      if (item.name === 'node_modules' || item.name.startsWith('.')) continue;
       if (IGNORAR.some((re) => re.test(`${cheio}/`))) continue;
       varrer(cheio, saida);
     } else if (elegivel(cheio)) saida.push(cheio);
@@ -153,7 +192,7 @@ if (process.argv.includes('--gerar-baseline')) {
     if (achados.length > 0) { mapa[relative(raiz, f)] = achados.length; arquivos++; violacoes += achados.length; }
   }
   if (!existsSync(dirname(BASELINE))) mkdirSync(dirname(BASELINE), { recursive: true });
-  writeFileSync(BASELINE, `${JSON.stringify(mapa, null, 2)}\n`);
+  gravarAtomico(BASELINE, `${JSON.stringify(mapa, null, 2)}\n`);
   console.log(`[comentarios] baseline gravado: ${arquivos} arquivos legados, ${violacoes} violações toleradas.`);
   console.log('[comentarios] arquivo novo responde ao padrão cheio; legado só não pode piorar.');
   process.exit(0);
@@ -179,9 +218,7 @@ const tolerado = baseline?.[chave] ?? 0;
 
 if (achados.length <= tolerado) {
   if (baseline && tolerado > 0 && achados.length < tolerado) {
-    if (achados.length === 0) delete baseline[chave];
-    else baseline[chave] = achados.length;
-    try { writeFileSync(BASELINE, `${JSON.stringify(baseline, null, 2)}\n`); } catch {}
+    atualizarBaseline(chave, achados.length);
     console.error(`[comentarios] ${rel}: ${tolerado} → ${achados.length} violações. Catraca desceu — não pode mais subir.`);
   } else if (achados.length === 0 && densidade > DENSIDADE_ALVO) {
     console.error(`[comentarios] aviso: ${rel} tem ${(densidade * 100).toFixed(0)}% de linhas de comentário (${comentadas}/${uteis}), alvo <= ${DENSIDADE_ALVO * 100}%.`);

package/templates/hooks/lib/rastro.mjs

@@ -60,33 +60,50 @@ export function buildEvent(fields) {
 }
 
 /**
- * Trabalho ativo: o `trabalho_ativo` do .ai-harness/estado.json ou, sem ele,
- * o único PLAN.md com `status: em-execucao`. Ambíguo ou ausente, retorna null.
+ * Trabalhos ativos: os `trabalhos_ativos` do .ai-harness/estado.json (ou o `trabalho_ativo` do formato
+ * anterior) ou, sem eles, os PLAN.md com `status: em-execucao` (menos os migrados sem `arquivos`). Várias sessões podem executar
+ * trabalhos diferentes na mesma pasta, então a lista pode ter mais de um id.
  * @param {string} root
- * @returns {string | null}
+ * @returns {string[]}
  */
-export function findActiveWork(root) {
+export function findActiveWorks(root) {
   const statePath = join(root, '.ai-harness', 'estado.json');
   if (existsSync(statePath)) {
     try {
-      const active = JSON.parse(readFileSync(statePath, 'utf8')).trabalho_ativo;
-      if (typeof active === 'string' && active) return active;
+      const state = JSON.parse(readFileSync(statePath, 'utf8'));
+      /** @type {unknown[]} */
+      const listed = Array.isArray(state.trabalhos_ativos) ? state.trabalhos_ativos : [state.trabalho_ativo];
+      const active = [...new Set(listed.filter(/** @returns {id is string} */ (id) => typeof id === 'string' && id !== ''))];
+      if (active.length) return active;
     } catch {
       // estado ilegível: segue para os planos.
     }
   }
 
   const worksDir = join(root, 'docs', 'trabalhos');
-  if (!existsSync(worksDir)) return null;
+  if (!existsSync(worksDir)) return [];
 
-  const running = readdirSync(worksDir).filter((id) => {
+  return readdirSync(worksDir).filter((id) => {
     const plan = join(worksDir, id, 'PLAN.md');
     if (!existsSync(plan)) return false;
     const frontmatter = /^\s*---\r?\n([\s\S]*?)\r?\n---/.exec(readFileSync(plan, 'utf8'))?.[1] ?? '';
     // Só o status do plano, na coluna zero; os status das tasks ficam indentados.
-    return /^status:\s*['"]?em-execucao['"]?\s*$/m.test(frontmatter);
+    if (!/^status:\s*['"]?em-execucao['"]?\s*$/m.test(frontmatter)) return false;
+    // Plano migrado do layout antigo sem `arquivos` ficou em-execucao pela migração, não por alguém executá-lo.
+    const migradoSemArquivos = /^migrado:\s*true\s*$/m.test(frontmatter) && !/^arquivos:[ \t]*(\[[ \t]*[^\]\s]|\r?\n[ \t]*-\s)/m.test(frontmatter);
+    return !migradoSemArquivos;
   });
-  return running.length === 1 ? (running[0] ?? null) : null;
+}
+
+/**
+ * O trabalho ao qual atribuir um evento sem `--trabalho`: o único ativo. Com nenhum ou vários, retorna
+ * null e o evento vai para _geral.jsonl, para não cair no rastro do trabalho errado.
+ * @param {string} root
+ * @returns {string | null}
+ */
+export function findActiveWork(root) {
+  const active = findActiveWorks(root);
+  return active.length === 1 ? (active[0] ?? null) : null;
 }
 
 /**

package/templates/hooks/proteger-contratos.mjs

@@ -1,13 +1,14 @@
 // @ts-check
-// Hook PreToolUse (Edit/Write): durante a execução de um trabalho, SPEC, PLAN e CLAUDE.md não são reescritos.
+// Hook PreToolUse (Edit/Write): durante a execução de um trabalho, o SPEC e o PLAN dele não são reescritos,
+// nem o CLAUDE.md e o SPEC.md da raiz enquanto houver algum trabalho em execução.
 // Atualizar só o status das tasks (e a data de atualização) continua permitido.
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { runHook } from './lib/hook.mjs';
-import { findActiveWork } from './lib/rastro.mjs';
 import { relativeToRoot, workEvents } from './lib/trabalho.mjs';
 
-const PROTECTED = [/^CLAUDE\.md$/, /^SPEC\.md$/, /^docs\/trabalhos\/[^/]+\/(SPEC|PLAN)\.md$/];
+const WORK_CONTRACT = /^docs\/trabalhos\/([^/]+)\/(SPEC|PLAN)\.md$/;
+const PROTECTED = [/^CLAUDE\.md$/, /^SPEC\.md$/, WORK_CONTRACT];
 const ALLOWED_LINE = /^\s*(-\s+)?(status|atualizado_em):/;
 
 /** @param {unknown} text */
@@ -18,6 +19,30 @@ function withoutAllowedLines(text) {
     .join('\n');
 }
 
+/**
+ * O trabalho tem task iniciada no rastro e ainda não foi concluído?
+ * @param {string} root
+ * @param {string} workId
+ */
+function isRunning(root, workId) {
+  const events = workEvents(root, workId);
+  return events !== null && events.some((event) => event.evento === 'task_iniciada') && !events.some((event) => event.evento === 'trabalho_concluido');
+}
+
+/**
+ * Trabalhos em execução afetados pelo arquivo: o dono do SPEC/PLAN pelo caminho ou, para os contratos
+ * da raiz, todos os que estão em execução.
+ * @param {string} root
+ * @param {string} rel
+ */
+function runningWorks(root, rel) {
+  const owner = WORK_CONTRACT.exec(rel)?.[1];
+  if (owner) return isRunning(root, owner) ? [owner] : [];
+  const worksDir = join(root, 'docs', 'trabalhos');
+  if (!existsSync(worksDir)) return [];
+  return readdirSync(worksDir).filter((id) => isRunning(root, id));
+}
+
 /**
  * A edição só troca linhas de status e data?
  * @param {string} root
@@ -41,16 +66,15 @@ await runHook('proteger-contratos', (input, { root }) => {
   const rel = relativeToRoot(root, String(input.tool_input?.file_path ?? ''));
   if (!rel || !PROTECTED.some((pattern) => pattern.test(rel))) return null;
 
-  const active = findActiveWork(root);
-  const events = active ? workEvents(root, active) : null;
-  const running =
-    events !== null && events.some((event) => event.evento === 'task_iniciada') && !events.some((event) => event.evento === 'trabalho_concluido');
-  if (!active || !running || onlyStatusChange(root, rel, input)) return null;
+  const running = runningWorks(root, rel);
+  if (!running.length || onlyStatusChange(root, rel, input)) return null;
 
+  const works = running.join(', ');
+  const decisions = `docs/trabalhos/${running.length === 1 ? works : '<id>'}/DECISOES.md`;
   return {
     motivo:
-      `${rel} é contrato do trabalho ${active}, que está em execução, e não deve ser reescrito agora. ` +
-      `Registre a mudança de escopo em docs/trabalhos/${active}/DECISOES.md (ou abra um bloqueio em BLOQUEIOS.md); ` +
+      `${rel} é contrato ${running.length === 1 ? `do trabalho ${works}, que está` : `dos trabalhos ${works}, que estão`} em execução, ` +
+      `e não deve ser reescrito agora. Registre a mudança de escopo em ${decisions} (ou abra um bloqueio em BLOQUEIOS.md); ` +
       'no PLAN.md, só o status das tasks pode ser atualizado.',
   };
 });

package/templates/skills/executar-plan/SKILL.md

@@ -20,6 +20,19 @@ mantém o estado em disco. **Sempre relate no chat qual agent está ativo**, pri
    depois de `revisor-testes` e `qa` e passe aos gates o comando da suíte declarado.
 3. Confirme que o plano pode ser executado: `auditoria_plano: aprovado` no frontmatter e nenhum achado `contrato-*`
    deste trabalho em `npx @fontdata/ai-harness doctor`. Sem isso, pare e sugira `/nova-tarefa`.
+4. Outras sessões podem estar executando outros trabalhos nesta mesma pasta. Confira se algum deles mexe nos
+   mesmos arquivos:
+
+   ```bash
+   npx @fontdata/ai-harness conflitos <id>
+   ```
+
+   - Se o plano não declara `arquivos`, preencha a lista no frontmatter do `PLAN.md` com os arquivos que as tasks
+     vão tocar (tirados da prosa do plano) e rode a checagem de novo.
+   - Com conflito (saída com código 1), **não comece**: avise o usuário que este trabalho aguarda os trabalhos
+     citados concluírem e rode `npx @fontdata/ai-harness conflitos <id> --aguardar` em segundo plano. Ele só
+     termina quando os arquivos ficam livres; aí siga para o Passo 1. Se o usuário disser que o outro trabalho
+     foi abandonado, oriente a trocar o status do `PLAN.md` dele para `cancelado`.
 
 ## Passo 1 — Retomada
 
@@ -34,8 +47,10 @@ abertos e eventos do rastro. Apresente ao usuário:
 ## Passo 2 — Iniciar
 
 1. No `PLAN.md`, troque apenas a linha `status:` do plano para `em-execucao` (e `atualizado_em`).
-2. Grave `.ai-harness/estado.json` com `{"trabalho_ativo": "<id>"}` — é por ele que os hooks e o rastro sabem
-   qual trabalho está em curso.
+2. Acrescente `<id>` à lista `trabalhos_ativos` de `.ai-harness/estado.json` (crie o arquivo com
+   `{"trabalhos_ativos": ["<id>"]}` se ele não existir) — é por ele que os hooks e o rastro sabem quais trabalhos
+   estão em curso. Outras sessões podem estar executando outros trabalhos na mesma pasta: leia o arquivo logo
+   antes de gravar e preserve os ids que já estão lá.
 
 ## Passo 3 — Executar fase por fase
 
@@ -101,7 +116,8 @@ portões extras (com os achados IMPORTANTE e SUGESTÃO do `code-reviewer`), esta
    npx @fontdata/ai-harness evento trabalho_concluido --trabalho <id> --nome executar-plan
    ```
 
-2. Grave `{"trabalho_ativo": null}` em `.ai-harness/estado.json`.
+2. Retire `<id>` da lista `trabalhos_ativos` de `.ai-harness/estado.json`, lendo o arquivo logo antes de gravar
+   e preservando os ids das outras sessões.
 3. Com bloqueios abertos, apresente cada um ao usuário. Cada resposta vira decisão em `DECISOES.md`
    (`decisao_registrada`), o bloqueio é fechado (`bloqueio_fechado`) e a task volta para `pendente` numa nova
    rodada desta skill.

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

@@ -61,6 +61,8 @@ Crie `docs/trabalhos/<id>/PLAN.md` a partir de `templates/PLAN.md`, seguindo `re
 - as tasks aparecem **no frontmatter** (`tasks`) e na prosa, com os mesmos ids;
 - toda task de código tem pelo menos 2 testes críticos concretos e critério de aceite binário;
 - tasks paralelizáveis da mesma fase não tocam os mesmos arquivos;
+- `arquivos` do frontmatter lista todos os arquivos (ou pastas) que as tasks vão criar ou alterar — é por ele que
+  o `/executar-plan` impede dois trabalhos de mexerem no mesmo código ao mesmo tempo;
 - **plano condensado:** com 1 sprint e 1 fase, use `condensado: true` e omita os títulos de sprint e fase — o
   contrato das tasks continua completo.
 

package/templates/skills/nova-tarefa/references/regras-do-plano.md

@@ -20,6 +20,8 @@ Um plano aprovado precisa poder ser executado sem que ninguém pergunte nada no
 5. `depende_de` declara toda dependência real; a ordem das fases respeita essas dependências.
 6. Use os nomes de módulos do `SPEC.md` — sem nomenclatura nova.
 7. Uma task cabe numa sessão de trabalho; task grande é dividida.
+8. `arquivos` no frontmatter lista todos os arquivos (ou pastas) que as tasks vão criar ou alterar. Trabalhos
+   executados em paralelo na mesma pasta são barrados quando essas listas se cruzam.
 
 ## Plano condensado