@pathbit/agentdevkit 0.0.21 → 0.0.23

package/.pbai4devs/scripts/testar-maturidade/tests/TEST.mjs

@@ -1,7 +1,8 @@
 import assert from 'node:assert/strict';
-import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { spawnSync } from 'node:child_process';
+import childProcess, { spawnSync } from 'node:child_process';
+import { syncBuiltinESMExports } from 'node:module';
 import { createHash } from 'node:crypto';
 import test from 'node:test';
 import { projectRoot, requireNode } from '../../lib/runtime.mjs';
@@ -55,21 +56,61 @@ test('copia recursos e configurações, excluindo payloads, caches e segredos',
   assert.deepEqual(result.roots, ['.pbai4devs', '.codex', '.github', '.agents', '.agent', '.gemini', '.vscode']);
 });
 
-test('regeneração preserva pastas alheias e recusa sobrescrevê-las', t => {
+test('destino explícito existente é recusado sem alterar projetos humanos ou gerados', t => {
   const { root, put, outputRoot } = fixture(t);
   put('examples/generated/anotacoes/keep.txt', 'preservado');
   put('examples/README.md', 'Guia humano.');
   const options = { sourceRoot: root, outputRoot, scenarios: [SCENARIOS[0]], initializeGit: false };
-  prepareExamples(options); prepareExamples(options);
+  assert.throws(() => prepareExamples(options), /saída já existe/);
   assert.equal(readFileSync(join(outputRoot, 'anotacoes/keep.txt'), 'utf8'), 'preservado');
   assert.equal(readFileSync(join(root, 'examples/README.md'), 'utf8'), 'Guia humano.');
-  put('examples/generated/descoberta/keep.txt', 'humano');
-  assert.throws(() => prepareExamples({ ...options, scenarios: [SCENARIOS[1]] }), /não é gerenciado/);
-  assert.equal(readFileSync(join(outputRoot, 'descoberta/keep.txt'), 'utf8'), 'humano');
-  assert.throws(() => prepareExamples({ ...options, scenarios: [{ ...SCENARIOS[0], id: '../outside' }] }), /IDs únicos e seguros/);
+  const output = join(outputRoot, 'nova-execucao');
+  const [example] = prepareExamples({ ...options, outputRoot: output });
+  writeFileSync(join(example.root, 'anotacao-humana.txt'), 'não apagar');
+  const report = readFileSync(join(output, 'REPORT.json'));
+  assert.throws(() => prepareExamples({ ...options, outputRoot: output, scenarios: [SCENARIOS[1]] }), /saída já existe/);
+  assert.throws(() => prepareExamples({ ...options, outputRoot: join(example.root, 'nova'), scenarios: [SCENARIOS[1]] }), /execução anterior/);
+  assert.deepEqual(readFileSync(join(output, 'REPORT.json')), report);
+  assert.equal(readFileSync(join(example.root, 'anotacao-humana.txt'), 'utf8'), 'não apagar');
+  assert.throws(() => prepareExamples({ ...options, outputRoot: join(outputRoot, 'invalid'), scenarios: [{ ...SCENARIOS[0], id: '../outside' }] }), /IDs únicos e seguros/);
+  assert.equal(existsSync(join(outputRoot, 'invalid')), false);
 });
 
-test('destino padrão redefine apenas relatório próprio e mantém resultados fora do Git', t => {
+test('troca de ancestral por symlink antes da criação não escreve no destino externo', t => {
+  const { root, outputRoot } = fixture(t);
+  const outside = mkdtempSync(join(dirname(root), 'maturity-outside-'));
+  t.after(() => rmSync(outside, { recursive: true, force: true }));
+  mkdirSync(outputRoot, { recursive: true });
+  const externalSentinel = join(outside, 'sentinel.txt');
+  writeFileSync(externalSentinel, 'externo preservado\n');
+  const linkProbe = join(root, 'probe-link');
+  try { symlinkSync(outside, linkProbe, process.platform === 'win32' ? 'junction' : 'dir'); }
+  catch (error) { if (['EPERM', 'EACCES'].includes(error.code)) { t.skip('Sem permissão para links simbólicos.'); return; } throw error; }
+  unlinkSync(linkProbe);
+  const canonical = realpathSync(outputRoot);
+  const original = childProcess.spawnSync;
+  let injected = false;
+  childProcess.spawnSync = function (file, args, options) {
+    if (!injected && file === process.execPath && args?.[0] === '-e' && options?.cwd === canonical) {
+      injected = true;
+      renameSync(outputRoot, `${outputRoot}-original`);
+      symlinkSync(outside, outputRoot, process.platform === 'win32' ? 'junction' : 'dir');
+    }
+    return original.call(this, file, args, options);
+  };
+  syncBuiltinESMExports();
+  try {
+    assert.throws(() => prepareExamples({ sourceRoot: root, outputRoot: join(outputRoot, 'nova'), scenarios: [SCENARIOS[0]], initializeGit: false }), /diretório exclusivo|ancestral|link simbólico/i);
+    assert.equal(injected, true);
+    assert.deepEqual(readdirSync(outside), ['sentinel.txt']);
+    assert.equal(readFileSync(externalSentinel, 'utf8'), 'externo preservado\n');
+  } finally {
+    childProcess.spawnSync = original;
+    syncBuiltinESMExports();
+  }
+});
+
+test('cada destino padrão é exclusivo, preserva provas anteriores e permanece ignorado', t => {
   const { root, outputRoot } = fixture(t);
   const git = (...args) => {
     const result = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8', shell: false });
@@ -77,48 +118,58 @@ test('destino padrão redefine apenas relatório próprio e mantém resultados f
   };
   git('init', '--template=', '--quiet');
   const options = { sourceRoot: root, scenarios: [SCENARIOS[0]], initializeGit: false };
-  const examples = prepareExamples(options);
-  assert.equal(examples[0].root, join(outputRoot, SCENARIOS[0].id));
-  const reportFile = join(outputRoot, 'REPORT.json');
-  writeFileSync(reportFile, JSON.stringify({ owner: 'testar-maturidade', status: 'passed', results: [{ stale: true }] }));
-  prepareExamples(options);
-  assert.deepEqual(JSON.parse(readFileSync(reportFile)), { owner: 'testar-maturidade', version: 1,
-    status: 'prepared', scenarios: [SCENARIOS[0].id], results: [] });
-  assert.match(git('check-ignore', '--verbose', 'examples/generated/REPORT.json'), /examples\/generated\/\.gitignore:2:\*/);
-  assert.match(git('check-ignore', '--verbose', 'examples/generated/somente-agentes/README.md'), /examples\/generated\/\.gitignore:2:\*/);
-  const human = JSON.stringify({ owner: 'human', notes: 'preservar' });
-  writeFileSync(reportFile, human);
-  assert.throws(() => prepareExamples(options), /Relatório.*não pertence/);
-  assert.equal(readFileSync(reportFile, 'utf8'), human);
+  const [first] = prepareExamples(options);
+  const firstOutput = dirname(first.root);
+  assert.equal(dirname(firstOutput), outputRoot);
+  const human = 'Prova humana que não pode ser apagada.\n';
+  writeFileSync(join(first.root, 'human.txt'), human);
+  const reportFile = join(firstOutput, 'REPORT.json');
+  const oldReport = readFileSync(reportFile);
+  const [second] = prepareExamples(options);
+  assert.notEqual(dirname(second.root), firstOutput);
+  assert.equal(readFileSync(join(first.root, 'human.txt'), 'utf8'), human);
+  assert.deepEqual(readFileSync(reportFile), oldReport);
+  for (const file of [join(firstOutput, 'REPORT.json'), join(first.root, 'README.md'), join(second.root, 'README.md')]) {
+    git('check-ignore', '--quiet', '--', file);
+  }
 });
 
-test('preserva ignore humano e continua aceitando destinos legados', t => {
+test('preserva ignore humano em pastas ancestrais e aceita destinos novos permitidos', t => {
   const { root, put } = fixture(t);
   const options = { sourceRoot: root, scenarios: [SCENARIOS[0]], initializeGit: false };
   put('examples/generated/.gitignore', '!README.md\n');
-  assert.throws(() => prepareExamples(options), /Ignore.*não pertence/);
+  put('examples/generated/.maturity-suite.json', '{"owner":"testar-maturidade"}\n');
+  put('examples/generated/somente-agentes/.maturity-case.json', '{"owner":"testar-maturidade","id":"somente-agentes"}\n');
+  put('examples/generated/somente-agentes/anotacao.txt', 'Conteúdo humano anterior.\n');
+  put('examples/generated/REPORT.json', '{"resultado":"anterior"}\n');
+  const [generated] = prepareExamples(options);
+  assert.equal(dirname(dirname(generated.root)), join(root, 'examples/generated'));
   assert.equal(readFileSync(join(root, 'examples/generated/.gitignore'), 'utf8'), '!README.md\n');
-  for (const target of ['tmp/examples', '.agent-tests/cases']) {
+  assert.equal(readFileSync(join(root, 'examples/generated/somente-agentes/anotacao.txt'), 'utf8'), 'Conteúdo humano anterior.\n');
+  assert.equal(readFileSync(join(root, 'examples/generated/REPORT.json'), 'utf8'), '{"resultado":"anterior"}\n');
+  for (const target of ['tmp/examples/caso-novo', '.agent-tests/cases']) {
     const outputRoot = join(root, target);
     const [example] = prepareExamples({ ...options, outputRoot });
     assert.equal(example.root, join(outputRoot, SCENARIOS[0].id));
   }
 });
 
-test('preparação interrompida não conserva resultado anterior nem declara sucesso', t => {
+test('preparação interrompida não altera resultado anterior nem declara sucesso', t => {
   const { root, put, outputRoot } = fixture(t);
   const options = { sourceRoot: root, scenarios: [SCENARIOS[0]], initializeGit: false };
-  prepareExamples(options);
-  const report = join(outputRoot, 'REPORT.json');
-  const index = join(outputRoot, 'README.md');
-  writeFileSync(report, JSON.stringify({ owner: 'testar-maturidade', status: 'passed', results: [{}] }));
-  writeFileSync(index, readFileSync(index, 'utf8').replaceAll('prepared', 'passed'));
+  const [first] = prepareExamples(options);
+  const firstOutput = dirname(first.root);
+  const report = join(firstOutput, 'REPORT.json');
+  const previous = readFileSync(report);
   put('.pbai4devs/state/agentdevkit.json', JSON.stringify({ blocks: null }));
   assert.throws(() => prepareExamples(options), /Estado da instalação/);
-  assert.equal(existsSync(report), false);
+  assert.deepEqual(readFileSync(report), previous);
+  const failed = readdirSync(outputRoot).filter(name => join(outputRoot, name) !== firstOutput);
+  assert.equal(failed.length, 1);
+  const index = join(outputRoot, failed[0], 'README.md');
   assert.match(readFileSync(index, 'utf8'), /status: preparing/);
+  assert.equal(existsSync(join(outputRoot, failed[0], 'REPORT.json')), false);
   assert.doesNotMatch(readFileSync(index, 'utf8'), /status: passed|\| passed \|/);
-  assert.doesNotMatch(readFileSync(index, 'utf8'), /\n{3,}/);
 });
 
 test('usa entradas distribuídas do hub e mantém fallback legado', t => {
@@ -216,6 +267,38 @@ test('localiza apontamentos pelo formato de cada tipo e por overrides nativos',
   ]);
 });
 
+test('respeita tipo sem espelho e o formato TOML nativo dos comandos Gemini', t => {
+  const { root, put } = fixture(t);
+  put('.pbai4devs/espelhos.conf', [
+    'agente|.agents|agrupado',
+    'agente|.codex|agrupado', 'formato|.codex|skills|nenhum',
+    'agente|.gemini|agrupado', 'formato|.gemini|commands|arquivo',
+  ].join('\n') + '\n');
+  const skill = resourceTargets(root, '.pbai4devs/skills/projeto/demo/SKILL.md');
+  assert.deepEqual(skill, ['.agents/skills/projeto/demo/SKILL.md', '.gemini/skills/projeto/demo/SKILL.md']);
+  assert.ok(!skill.some(target => target.startsWith('.codex/')));
+  const command = resourceTargets(root, '.pbai4devs/commands/projeto/demo/COMMAND.md', 'commands');
+  assert.ok(command.includes('.codex/commands/projeto/demo/COMMAND.md'));
+  assert.ok(command.includes('.gemini/commands/projeto/demo.toml'));
+  assert.ok(!command.includes('.gemini/commands/projeto/demo.md'));
+});
+
+test('identifica o fallback Codex apenas para a skill cuja rota primária está obstruída', t => {
+  const { root, put } = fixture(t);
+  put('.pbai4devs/espelhos.conf', [
+    'agente|.agents|agrupado', 'agente|.codex|agrupado',
+    'formato|.codex|skills|nenhum', 'fallback|.codex|.agents|skills',
+  ].join('\n') + '\n');
+  const blocked = '.pbai4devs/skills/projeto/demo/SKILL.md';
+  const available = '.pbai4devs/skills/projeto/outra/SKILL.md';
+  const target = join(root, '.agents/skills/projeto/demo/SKILL.md');
+  mkdirSync(target, { recursive: true });
+  assert.deepEqual(resourceTargets(root, blocked), ['.codex/skills/projeto/demo/SKILL.md']);
+  assert.deepEqual(resourceTargets(root, available), ['.agents/skills/projeto/outra/SKILL.md']);
+  rmSync(target, { recursive: true });
+  assert.deepEqual(resourceTargets(root, blocked), ['.agents/skills/projeto/demo/SKILL.md']);
+});
+
 test('checkout de fontes sem manifesto deriva clientes em memória', t => {
   const { root, put } = fixture(t);
   const manifest = join(root, '.pbai4devs/espelhos.conf');
@@ -277,6 +360,47 @@ test('oito cópias exercitam os seis níveis e preservam layouts legado/monorepo
   assert.equal(existsSync(join(monorepo.root, 'src')), false);
 });
 
+test('cenários configurados completam fixtures ausentes sem alterar a origem ou arquivos copiados', t => {
+  const { root, put, outputRoot } = fixture(t);
+  const files = ['.gitignore', '.gitattributes', '.editorconfig'];
+  const source = Object.fromEntries(files.map(file => [file, `# configuração própria de ${file}\n`]));
+  // As duas fontes ausentes reproduzem uma instalação distribuída; o arquivo
+  // existente prova que a preparação não substitui configurações copiadas.
+  rmSync(join(root, '.gitattributes'));
+  rmSync(join(root, '.editorconfig'));
+  put('.gitignore', source['.gitignore']);
+  const scenarios = SCENARIOS.filter(example => ['app-configurada', 'manutencao', 'app-inicial'].includes(example.id));
+  const examples = prepareExamples({ sourceRoot: root, outputRoot: join(outputRoot, 'parcial'), scenarios, initializeGit: false });
+  assert.equal(readFileSync(join(root, '.gitignore'), 'utf8'), source['.gitignore']);
+  for (const file of ['.gitattributes', '.editorconfig']) assert.equal(existsSync(join(root, file)), false, file);
+  for (const example of examples) {
+    assert.equal(readFileSync(join(example.root, '.gitignore'), 'utf8'), source['.gitignore']);
+    if (!example.configured) {
+      for (const file of ['.gitattributes', '.editorconfig']) assert.equal(existsSync(join(example.root, file)), false, file);
+      continue;
+    }
+    for (const file of ['.gitattributes', '.editorconfig']) assert.ok(readFileSync(join(example.root, file), 'utf8').trim(), file);
+    const inspected = spawnSync(process.execPath, ['.pbai4devs/scripts/inspecionar-projeto/SCRIPT.mjs', '--check'], { cwd: example.root, encoding: 'utf8' });
+    assert.ifError(inspected.error);
+    assert.equal(inspected.status, 0, inspected.stderr || inspected.stdout);
+    assert.equal(JSON.parse(inspected.stdout).contract.complete, true, example.id);
+  }
+  // Retest with every file absent, as in the released npm tarball.
+  rmSync(join(root, '.gitignore'));
+  const configured = scenarios.find(example => example.id === 'app-configurada');
+  const missing = prepareExamples({ sourceRoot: root, outputRoot: join(outputRoot, 'ausentes'), scenarios: [configured], initializeGit: false })[0];
+  for (const file of files) {
+    assert.equal(existsSync(join(root, file)), false, file);
+    assert.ok(readFileSync(join(missing.root, file), 'utf8').trim(), file);
+  }
+  for (const file of files) put(file, source[file]);
+  const preserved = prepareExamples({ sourceRoot: root, outputRoot: join(outputRoot, 'presentes'), scenarios: [configured], initializeGit: false })[0];
+  for (const file of files) {
+    assert.equal(readFileSync(join(root, file), 'utf8'), source[file]);
+    assert.equal(readFileSync(join(preserved.root, file), 'utf8'), source[file]);
+  }
+});
+
 test('fixtures padrão, legado e monorepo executam HTTP real e encerram', t => {
   const { root, outputRoot } = fixture(t);
   const scenarios = SCENARIOS.filter(example => ['app-inicial', 'legado', 'monorepo'].includes(example.id));

package/.pbai4devs/scripts/verificar-configuracao/README.md

@@ -0,0 +1,22 @@
+---
+description: Confere os indicadores registrados antes da implementação.
+---
+
+# Verificar configuração
+
+```sh
+node .pbai4devs/scripts/executar-script/SCRIPT.mjs verificar-configuracao
+```
+
+Somente leitura: retorna `1` se o estado estiver ausente, inacessível,
+ambíguo ou com preparação ou configuração pendente. Retorna `0` e
+`verificar-evidencias` quando ambos os indicadores registram `concluido`.
+Para evitar ambiguidades, recusa chaves complexas e tags, âncoras, aliases ou
+mesclagens no topo do cabeçalho. Links simbólicos detectados são recusados;
+a leitura não é uma trava
+atômica contra mudanças simultâneas de caminhos.
+Não valida o YAML inteiro, a infraestrutura ou as provas; confira-os antes de
+escrever código. O comando não bloqueia alterações de quem ignore seu resultado.
+
+O estado legado é reconhecido sem migração; estados em conflito são recusados.
+Erros de uso retornam `2`.

package/.pbai4devs/scripts/verificar-configuracao/SCRIPT.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { lstatSync, readFileSync, realpathSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { isMain, projectRoot, requireNode } from '../lib/runtime.mjs';
+import { stateDirectory } from '../lib/state-path.mjs';
+
+const limit = 'O estado não comprova evidências nem impede um agente de escrever.';
+const blocked = motivo => ({ status: 'bloqueado', motivo, limite: limit });
+
+// Read only the two indicators; never print arbitrary state content.
+export function verifyConfiguration(root = projectRoot) {
+  requireNode();
+  try {
+    root = realpathSync(resolve(root));
+    const parts = `${stateDirectory(root)}/configuracao/ESTADO.md`.split('/');
+    let current = root; let info;
+    for (let index = 0; index < parts.length; index++) {
+      current = join(current, parts[index]);
+      info = lstatSync(current);
+      if (info.isSymbolicLink() || (index < parts.length - 1 && !info.isDirectory())) return blocked('estado-inseguro');
+    }
+    if (!info.isFile() || info.size > 1024 * 1024) return blocked('estado-invalido');
+    const text = readFileSync(current, 'utf8').replaceAll('\r\n', '\n');
+    const header = text.match(/^---\n([\s\S]*?)\n---(?:\n|$)/)?.[1];
+    if (header === undefined) return blocked('estado-invalido');
+    const values = {};
+    for (const line of header.split('\n')) {
+      if (!line.trim() || line.trimStart().startsWith('#') || /^[ \t]/.test(line)) continue;
+      // Explicit mapping keys and merge keys may hide duplicate indicators.
+      if (/^(?:\?|<<\s*:)/.test(line)) return blocked('estado-invalido');
+      const match = line.match(/^("(?:[^"\\]|\\.)*"|'(?:[^']|'')*'|[a-zA-Z_][a-zA-Z0-9_.-]*)[ \t]*:(.*)$/);
+      if (!match) return blocked('estado-invalido');
+      if (/^[!&*]/.test(match[2].trim())) return blocked('estado-invalido');
+      let key = match[1];
+      if (key.startsWith('"')) {
+        try { key = JSON.parse(key); } catch { return blocked('estado-invalido'); }
+      } else if (key.startsWith("'")) key = key.slice(1, -1).replaceAll("''", "'");
+      if (!['preparacao', 'configuracao_tecnica'].includes(key)) continue;
+      if (Object.hasOwn(values, key)) return blocked('estado-invalido');
+      const value = match[2].trim().match(/^(?:concluido|pendente|'(?:concluido|pendente)'|"(?:concluido|pendente)")(?:[ \t]+#.*)?$/)?.[0];
+      if (!value) return blocked('estado-invalido');
+      values[key] = value.replace(/[ \t]+#.*$/, '').replace(/^['"]|['"]$/g, '');
+    }
+    if (!Object.hasOwn(values, 'preparacao') || !Object.hasOwn(values, 'configuracao_tecnica')) return blocked('estado-invalido');
+    if (values.preparacao !== 'concluido' || values.configuracao_tecnica !== 'concluido') return blocked('configuracao-pendente');
+    return { status: 'verificar-evidencias', estado: values, limite: limit };
+  } catch (error) {
+    if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return blocked('estado-ausente');
+    return blocked('estado-inacessivel-ou-inseguro');
+  }
+}
+
+export function main(args = process.argv.slice(2)) {
+  if (args.length) throw new Error('Uso: verificar-configuracao sem argumentos.');
+  const report = verifyConfiguration();
+  console.log(JSON.stringify(report));
+  return report.status === 'bloqueado' ? 1 : 0;
+}
+
+if (isMain(import.meta.url)) {
+  try { process.exitCode = main(); }
+  catch (error) { console.error(error.message); process.exitCode = 2; }
+}

package/.pbai4devs/scripts/verificar-configuracao/tests/TEST.mjs

@@ -0,0 +1,145 @@
+import assert from 'node:assert/strict';
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import test from 'node:test';
+import { projectRoot } from '../../lib/runtime.mjs';
+import { verifyConfiguration } from '../SCRIPT.mjs';
+
+function fixture(t) {
+  const base = join(projectRoot, '.agent-tests'); mkdirSync(base, { recursive: true });
+  const root = mkdtempSync(join(base, 'config-gate-'));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  const write = (file, content) => {
+    const destination = join(root, file); mkdirSync(dirname(destination), { recursive: true });
+    writeFileSync(destination, content);
+  };
+  for (const file of ['lib/runtime.mjs', 'lib/state-path.mjs', 'lib/script-config.mjs', 'executar-script/SCRIPT.mjs', 'verificar-configuracao/SCRIPT.mjs']) {
+    const destination = join(root, '.pbai4devs/scripts', file);
+    mkdirSync(dirname(destination), { recursive: true });
+    copyFileSync(join(projectRoot, '.pbai4devs/scripts', file), destination);
+  }
+  const state = (body, folder = 'state') => write(`.pbai4devs/${folder}/configuracao/ESTADO.md`, body);
+  const run = (...args) => {
+    const file = join(root, '.pbai4devs/scripts/verificar-configuracao/SCRIPT.mjs');
+    const result = spawnSync(process.execPath, [file, ...args], { encoding: 'utf8' });
+    assert.ifError(result.error);
+    return { ...result, report: result.stdout ? JSON.parse(result.stdout) : null };
+  };
+  return { root, state, write, run };
+}
+
+const document = (preparation, configuration) => `---\npreparacao: ${preparation}\nconfiguracao_tecnica: ${configuration}\ndocumentos:\n  prd: docs/PRD.md\n---\n\n# Estado\n`;
+
+test('bloqueia antes do código quando o estado está ausente ou pendente', t => {
+  const { root, state, run } = fixture(t);
+  assert.deepEqual(run().report.motivo, 'estado-ausente');
+  assert.equal(run().status, 1);
+  for (const [preparation, configuration] of [['pendente', 'pendente'], ['concluido', 'pendente'], ['pendente', 'concluido']]) {
+    state(document(preparation, configuration));
+    const result = run(); assert.equal(result.status, 1);
+    assert.equal(result.report.motivo, 'configuracao-pendente');
+    assert.equal(existsSync(join(root, 'src')), false);
+  }
+});
+
+test('aceita o modelo real e mantém provas da aplicação como verificação separada', t => {
+  const { root, state, run } = fixture(t);
+  const template = readFileSync(join(projectRoot, '.pbai4devs/templates/configuracao/TEMPLATE.md'), 'utf8');
+  state(template); assert.equal(run().report.motivo, 'configuracao-pendente');
+  state(template.replace('preparacao: pendente', 'preparacao: concluido')
+    .replace('configuracao_tecnica: pendente', 'configuracao_tecnica: concluido'));
+  assert.equal(run().report.status, 'verificar-evidencias');
+  assert.equal(existsSync(join(root, 'src')), false);
+});
+
+test('indicadores concluídos exigem revisão adicional de evidências e não alteram Git', t => {
+  const { root, state, write, run } = fixture(t);
+  state(document('"concluido" # aprovado', "'concluido'"));
+  write('.gitignore', 'node_modules/\n'); write('AGENTS.md', '# Instruções humanas\n');
+  assert.equal(spawnSync('git', ['init', '--quiet', root]).status, 0);
+  assert.equal(spawnSync('git', ['-C', root, 'add', '.gitignore', 'AGENTS.md']).status, 0);
+  const index = readFileSync(join(root, '.git/index'));
+  const statePath = join(root, '.pbai4devs/state/configuracao/ESTADO.md');
+  const original = readFileSync(statePath), ignore = readFileSync(join(root, '.gitignore'));
+  const result = run(); assert.equal(result.status, 0);
+  assert.equal(result.report.status, 'verificar-evidencias');
+  assert.match(result.report.limite, /não comprova evidências/);
+  assert.deepEqual(readFileSync(statePath), original);
+  assert.deepEqual(readFileSync(join(root, '.git/index')), index);
+  assert.deepEqual(readFileSync(join(root, '.gitignore')), ignore);
+  assert.equal(existsSync(join(root, 'src')), false);
+});
+
+test('recusa indicadores ausentes, desconhecidos, duplicados e não expõe valores', t => {
+  const { state, run } = fixture(t);
+  const secret = 'SENSITIVE_VALUE_47849';
+  for (const value of [
+    'preparacao: concluido',
+    'preparacao: concluido\nconfiguracao_tecnica: ausente',
+    'preparacao: concluido\npreparacao: pendente\nconfiguracao_tecnica: concluido',
+    'preparacao: concluido\nconfiguracao_tecnica: concluido\n"configuracao_tecnica": pendente',
+    "'preparacao': concluido\npreparacao: pendente\nconfiguracao_tecnica: concluido",
+    'preparacao: concluido\n"prepara\\u0063ao": pendente\nconfiguracao_tecnica: concluido',
+    'preparacao: concluido\nconfiguracao_tecnica: concluido\n!!str configuracao_tecnica: pendente',
+    'preparacao: concluido\nconfiguracao_tecnica: concluido\npadrao: &base { configuracao_tecnica: pendente }',
+    'preparacao: concluido\nconfiguracao_tecnica: concluido\npadrao: *base',
+    'preparacao: concluido\nconfiguracao_tecnica: concluido\npadrao: !!str valor',
+    'preparacao: concluido\nconfiguracao_tecnica: concluido\n<<: *base',
+    'preparacao: concluido\nconfiguracao_tecnica: concluido\n? configuracao_tecnica\n: pendente',
+    `preparacao: concluido\nconfiguracao_tecnica: ${secret}`,
+    'preparacao: concluido\nconfiguracao_tecnica: true',
+  ]) {
+    state(`---\n${value}\n---\n# Estado\n`);
+    const result = run(); assert.equal(result.status, 1);
+    assert.equal(result.report.motivo, 'estado-invalido');
+    assert.ok(!result.stdout.includes(secret)); assert.ok(!result.stderr.includes(secret));
+  }
+  state('preparacao: concluido\nconfiguracao_tecnica: concluido\n');
+  assert.equal(run().report.motivo, 'estado-invalido');
+  state('---\n"preparacao": concluido\n\'configuracao_tecnica\': concluido\n---\n# Estado\n');
+  assert.equal(run().report.status, 'verificar-evidencias');
+});
+
+test('aceita estado legado e recusa coexistência de árvores de estado', t => {
+  const { state, run } = fixture(t);
+  state(document('concluido', 'concluido'), 'estado');
+  assert.equal(run().report.status, 'verificar-evidencias');
+  state(document('concluido', 'concluido'));
+  const result = run(); assert.equal(result.status, 1);
+  assert.equal(result.report.motivo, 'estado-inacessivel-ou-inseguro');
+});
+
+test('não segue link humano em arquivo ou pasta de estado', t => {
+  const { root, state, run } = fixture(t);
+  const outside = join(root, 'fora'); mkdirSync(outside);
+  const target = join(outside, 'ESTADO.md'); writeFileSync(target, document('concluido', 'concluido'));
+  const directory = join(root, '.pbai4devs/state/configuracao'); mkdirSync(directory, { recursive: true });
+  try { symlinkSync(target, join(directory, 'ESTADO.md')); }
+  catch (error) { if (['EPERM', 'EACCES', 'ENOSYS'].includes(error.code)) { t.skip('Sem permissão para links.'); return; } throw error; }
+  assert.equal(run().report.motivo, 'estado-inseguro');
+  assert.equal(readFileSync(target, 'utf8'), document('concluido', 'concluido'));
+  unlinkSync(join(directory, 'ESTADO.md')); rmdirSync(directory);
+  symlinkSync(outside, directory, process.platform === 'win32' ? 'junction' : 'dir');
+  assert.equal(run().report.motivo, 'estado-inseguro');
+  assert.equal(readFileSync(target, 'utf8'), document('concluido', 'concluido'));
+});
+
+test('exige Node e rejeita argumentos extras sem ler outro projeto', t => {
+  const { root, run } = fixture(t);
+  const result = run('--root', root); assert.equal(result.status, 2);
+  assert.match(result.stderr, /sem argumentos/);
+  assert.equal(verifyConfiguration(root).status, 'bloqueado');
+});
+
+test('seletor de scripts propaga bloqueio e exige revisão de evidências', t => {
+  const { root, state } = fixture(t);
+  const selector = join(root, '.pbai4devs/scripts/executar-script/SCRIPT.mjs');
+  const execute = () => spawnSync(process.execPath, [selector, 'verificar-configuracao'], { cwd: root, encoding: 'utf8' });
+  state(document('concluido', 'pendente'));
+  const pending = execute(); assert.ifError(pending.error); assert.equal(pending.status, 1);
+  assert.match(pending.stdout, /"motivo":"configuracao-pendente"/);
+  state(document('concluido', 'concluido'));
+  const recorded = execute(); assert.ifError(recorded.error); assert.equal(recorded.status, 0);
+  assert.match(recorded.stdout, /"status":"verificar-evidencias"/);
+});

package/.pbai4devs/scripts/verificar-recursos/SCRIPT.mjs

@@ -49,9 +49,20 @@ function ownership(root) {
   if (checkedStat(root, derivedFile)) {
     const derived = readState(derivedFile);
     if (derived?.schemaVersion !== 1 || !validMap(derived.entries) || Object.keys(derived.entries).some(path => !canonicalEntrypoint(path))
-      || !validMap(derived.files ?? {}) || !validMap(derived.blocks ?? {})
+      || !validMap(derived.files ?? {}) || !validMap(derived.blocks ?? {}) || !validMap(derived.removedFiles ?? {})
       || !Array.isArray(derived.removedBlocks ?? []) || (derived.removedBlocks ?? []).some(path => typeof path !== 'string')
       || !validMap(derived.outputs ?? {}) || Object.keys(derived.outputs ?? {}).some(path => !/^\.[a-z0-9][a-z0-9-]*\/(?:skills|rules|agents)\.json$/.test(path))) fail('Estado de entradas derivadas invalido.');
+    for (const [path, hash] of Object.entries(derived.removedFiles ?? {})) {
+      const [nativeRoot, scope] = path.split('/');
+      if (!/^\.[A-Za-z0-9][A-Za-z0-9._-]*$/.test(nativeRoot) || ['.git', '.pbai4devs', '.agent-tests'].includes(nativeRoot.toLowerCase())
+        || !scope || [...auxiliary, 'workflows'].includes(scope.toLowerCase()) || ['readme.md', 'instructions.md'].includes(basename(path).toLowerCase())
+        || !(/\.(?:md|mdc)$/i.test(path) || path.startsWith('.gemini/commands/') && path.endsWith('.toml'))) fail('Registro de arquivos removidos invalido.');
+      const location = checkedPath(root, path);
+      if (state.files[path] && state.files[path] !== hash) fail(`Registro de arquivos removidos divergente: ${path}`);
+      if (state.files[path] !== hash || derived.files?.[path] || derived.blocks?.[path] || derived.entries?.[path]) continue;
+      if (checkedStat(root, location)) fail(`Arquivo removido foi recriado; revise o conteúdo: ${path}`);
+      delete files[path];
+    }
     Object.assign(files, derived.entries, derived.outputs, derived.files);
     for (const [path, hash] of Object.entries({ ...derived.entries, ...derived.files })) {
       const location = checkedPath(root, path);

package/.pbai4devs/scripts/verificar-recursos/tests/TEST.mjs

@@ -196,6 +196,28 @@ test('instalação também protege manifestos registrados em derived.outputs', t
   assert.throws(() => verify(root), /Arquivo gerenciado ausente: .agents\/skills.json/);
 });
 
+test('remoções derivadas exigem hash compatível e não ocultam arquivo humano recriado', t => {
+  const { root, file, generated } = installedFixture(t);
+  const statePath = join(root, '.pbai4devs/state/agentdevkit.json');
+  const state = JSON.parse(readFileSync(statePath, 'utf8'));
+  const hash = state.files[generated], derivedPath = '.pbai4devs/state/derived.json';
+  rmSync(join(root, generated));
+  const record = removedFiles => file(derivedPath, JSON.stringify({ schemaVersion: 1, entries: {}, removedFiles }));
+  record({ [generated]: hash });
+  assert.doesNotThrow(() => verify(root));
+  file(generated, document('# Conteúdo recriado pelo usuário\n'));
+  const recreated = readFileSync(join(root, generated));
+  assert.throws(() => verify(root), /Arquivo removido foi recriado/);
+  assert.deepEqual(readFileSync(join(root, generated)), recreated);
+  rmSync(join(root, generated));
+  record({ [generated]: 'f'.repeat(64) });
+  assert.throws(() => verify(root), /Registro de arquivos removidos divergente/);
+  record({ [generated]: 'invalido' });
+  assert.throws(() => verify(root), /Estado de entradas derivadas invalido/);
+  record({ '.pbai4devs/skills/exemplo/SKILL.md': hash });
+  assert.throws(() => verify(root), /Registro de arquivos removidos invalido/);
+});
+
 test('catalogo derivado cobre recursos e detecta JSON editado sem reescrever', t => {
   const { root, file } = resourceFixture(t);
   file('.pbai4devs/commands/inspecionar/COMMAND.md', document('# Inspecionar\n\n[Script](../../scripts/inspecionar/SCRIPT.mjs).\n'));

package/.pbai4devs/skills/desenvolvimento/implementar-backend/SKILL.md

@@ -5,9 +5,21 @@ description: Implementa mudanças de backend com contratos, dados e provas de co
 
 # Implementar backend
 
-Siga a spec e o plano aprovados, os contratos e a stack existentes. Esclareça
-dúvidas sobre entradas, saídas, persistência,
-compatibilidade e falhas antes de decidir. Altere somente o escopo atribuído.
+Siga o escopo aprovado, os contratos e a stack existentes. Ao implementar uma
+spec, confirme spec e plano aprovados e, antes de alterar código, execute
+`node .pbai4devs/scripts/executar-script/SCRIPT.mjs verificar-configuracao`.
+Se o estado estiver ausente, inválido ou pendente, ou faltar prova obrigatória,
+pare e informe o responsável. Saída zero ainda exige conferir as evidências.
+Siga a ordem e as pré-condições já acordadas em
+[implementar-spec](../../specs/implementar-spec/SKILL.md), sem reiniciar o fluxo
+nem pedir novamente aprovações já dadas.
+
+Em correção avulsa autorizada de projeto existente, preserve suas decisões e
+use `preparar-dev` quando necessário, sem inventar spec ou estado. Uma tarefa
+que cite uma spec ou esteja coberta por seu escopo é tarefa de spec, mesmo
+sendo correção pontual; não a trate como avulsa. Esclareça dúvidas sobre
+entradas, saídas, persistência, compatibilidade e falhas antes de decidir.
+Altere somente o escopo atribuído.
 
 Verifique validação de entrada, autorização por recurso e isolamento de dados.
 Considere limites, concorrência, repetição, timeout, migração e recuperação

package/.pbai4devs/skills/desenvolvimento/implementar-frontend/SKILL.md

@@ -5,9 +5,21 @@ description: Implementa interfaces web conforme a spec, o design e as provas de
 
 # Implementar frontend
 
-Siga a spec e o plano aprovados, o design e os componentes existentes.
-Esclareça comportamento, conteúdo e acessibilidade
-quando faltarem decisões; não escolha framework nem crie telas fora do escopo.
+Siga o escopo aprovado, o design e os componentes existentes. Ao implementar
+uma spec, confirme spec e plano aprovados e, antes de alterar código, execute
+`node .pbai4devs/scripts/executar-script/SCRIPT.mjs verificar-configuracao`.
+Se o estado estiver ausente, inválido ou pendente, ou faltar prova obrigatória,
+pare e informe o responsável. Saída zero ainda exige conferir as evidências.
+Siga a ordem e as pré-condições já acordadas em
+[implementar-spec](../../specs/implementar-spec/SKILL.md), sem reiniciar o fluxo
+nem pedir novamente aprovações já dadas.
+
+Em correção avulsa autorizada de projeto existente, preserve suas decisões e
+use `preparar-dev` quando necessário, sem inventar spec ou estado. Uma tarefa
+que cite uma spec ou esteja coberta por seu escopo é tarefa de spec, mesmo
+sendo correção pontual; não a trate como avulsa. Esclareça comportamento,
+conteúdo e acessibilidade quando faltarem decisões; não escolha framework nem
+crie telas fora do escopo.
 
 Considere estados de carregamento, vazio, erro e sucesso; navegação por teclado,
 semântica acessível e diferentes tamanhos de tela. Preserve contratos com o

package/.pbai4devs/skills/git/git-diff/SKILL.md

@@ -6,4 +6,6 @@ description: Examina e resume alterações Git.
 # git-diff
 
 Examine os diffs preparados e não preparados conforme o pedido, incluindo
-arquivos não rastreados quando relevantes. Não altere arquivos.
+arquivos não rastreados quando relevantes. Execute consultas com
+`GIT_OPTIONAL_LOCKS=0` no ambiente do subprocesso para evitar atualizar o índice;
+não altere arquivos.

package/.pbai4devs/skills/git/git-status/SKILL.md

@@ -6,4 +6,5 @@ description: Inspeciona o estado do repositório e das branches locais e remotas
 # git-status
 
 Mostre branch, alterações preparadas e não preparadas, arquivos não rastreados e
-divergência do upstream. Não altere arquivos.
+divergência do upstream. Execute a consulta com `GIT_OPTIONAL_LOCKS=0` no
+ambiente do subprocesso para evitar atualizar o índice; não altere arquivos.