@fontdata/ai-harness 2.1.0 → 2.2.0

package/.claude-plugin/plugin.json

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

package/README.md

@@ -113,6 +113,7 @@ duas vezes.
 | `migrar [caminho]` | Move os documentos do layout anterior para `docs/trabalhos/<id>/` (`--yes`) |
 | `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',
@@ -50,6 +51,7 @@ Gerenciar:
   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 +141,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/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/trabalhos/conflitos.js

@@ -0,0 +1,115 @@
+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 };
+}
+/**
+ * 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) {
+            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.2.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/lib/rastro.mjs

@@ -60,33 +60,47 @@ 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`. 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);
   });
-  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