@pathbit/agentdevkit 0.0.25 → 0.0.26

package/.pbai4devs/commands/revisar-entrega/COMMAND.md

@@ -8,6 +8,11 @@ Entrada: referência da mudança, spec quando houver e arquivos do escopo.
 Pré-requisitos: implementação pronta e Node.js 24+. Sem spec em uma correção
 urgente, defina critérios próprios AC-001 e registre o motivo.
 
+A coleta automática recusa submódulos, sparse-index, flags que ocultam mudanças
+e filtros Git aplicados; nesses casos, use `--scope` para caminhos comprováveis.
+Split-index e clones parciais são recusados em todos os modos. As consultas Git
+desativam fsmonitor somente no subprocesso; nenhuma configuração é alterada.
+
 1. Siga [atualizar-documentacao][documentacao]
    e [verificar-trabalho](../../skills/projeto/verificar-trabalho/SKILL.md).
 2. Use `executar-script` para `revisar-entrega prepare --id <referencia>`, com
@@ -24,6 +29,13 @@ urgente, defina critérios próprios AC-001 e registre o motivo.
    revisão e `revisar-entrega check <relatorio>` pelo mesmo seletor. Falha,
    critério sem prova ou revisão pendente bloqueiam o commit/merge.
 
+Antes do commit, execute `revisar-entrega check-commit <relatorio>
+[outros-relatorios...]`. A união das revisões seladas deve cobrir todos os
+arquivos preparados, inclusive ambas as pontas de renomeações. O check aceita
+somente arquivos regulares com modo Git `100644` cujos blobs correspondam aos
+bytes revisados. Filtros ou CRLF que mudem esses bytes são recusados.
+Ele não é atômico: repita-o se o índice ou os arquivos mudarem antes do commit.
+
 Antes de um merge fast-forward, na origem, execute `revisar-entrega check-merge
 --destino refs/heads/<destino> <relatorio> [outros-relatorios...]`. A verificação
 exige cobertura do diff e correspondência com o commit revisado. Ela bloqueia

package/.pbai4devs/scripts/revisar-entrega/README.md

@@ -13,6 +13,9 @@ node .pbai4devs/scripts/revisar-entrega/SCRIPT.mjs prepare --id minha-mudanca
 Use `--spec caminho/SPEC.md` para extrair os critérios `AC-001` da spec.
 `--scope arquivo` limita uma revisão; sem ele, o snapshot reúne alterações Git.
 Use `--document arquivo` para incluir PRD, design e outros documentos.
+Na coleta automática, submódulos, índice esparso, flags que ocultam mudanças e
+filtros Git aplicados são bloqueados; use `--scope` quando o escopo for
+conhecido. Índice dividido e clone parcial são recusados em qualquer modo.
 README, AGENTS, CLAUDE e GEMINI versionáveis na raiz entram automaticamente na
 revisão, mesmo sem alterações. Saídas locais ignoradas fora do índice não são
 documentos obrigatórios; documentos rastreados continuam cobertos mesmo quando
@@ -21,6 +24,17 @@ Preencha decisões, resultados e evidências no JSON retornado; peça revisão
 independente, execute `seal <caminho/revisao.json>` e depois
 `check <caminho/revisao.json>` antes de concluir.
 
+`check` valida somente o escopo dos relatórios. Antes de um commit, use
+`check-commit <relatorio> [outros-relatorios...]`: todos os arquivos preparados
+devem estar cobertos por revisões seladas. O comando aceita somente arquivos
+regulares com modo Git `100644` e compara os bytes preparados aos revisados;
+normalizações por filtros ou CRLF que mudem os bytes são bloqueadas. Cada blob
+preparado está limitado a 64 MiB.
+
+Antes de um merge fast-forward, use `check-merge --destino refs/heads/<branch>
+<relatorio> [outros-relatorios...]` na origem. Ele compara o commit e todo o diff
+com as revisões seladas; confirme os hashes retornados antes de integrar.
+
 O check recusa resultados pendentes, evidências ausentes/versionadas e arquivos
 alterados depois da revisão. Relatórios ficam em
 `.agent-tests/<id>/<execução>/`.

package/.pbai4devs/scripts/revisar-entrega/SCRIPT.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createHash } from 'node:crypto';
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { isMain, projectRoot, requireNode } from '../lib/runtime.mjs';
@@ -11,9 +11,13 @@ const portable = value => value.split(sep).join('/');
 const nonempty = value => typeof value === 'string' && value.trim().length > 0;
 const completed = value => nonempty(value) && !/^(?:a definir|pendente|pending|todo|tbd|\.\.\.)[.!]?$/i.test(value.trim());
 const digest = file => createHash('sha256').update(readFileSync(file)).digest('hex');
+const decodeGit = data => {
+  try { return data ? new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(data) : ''; }
+  catch { fail('Caminho ou saida Git nao e UTF-8 valido.'); }
+};
 
 function pathInRoot(root, input) {
-  if (!nonempty(input) || /[\0\r\n]/.test(input)) fail('Caminho invalido.');
+  if (!nonempty(input) || !input.isWellFormed() || /[\0\r\n]/.test(input)) fail('Caminho invalido.');
   const name = portable(relative(root, resolve(root, input)));
   if (!name || name === '..' || name.startsWith('../') || isAbsolute(name) || name.split('/').some(part => part.toLowerCase() === '.git')) fail(`Caminho fora do escopo: ${input}`);
   let current = root;
@@ -25,16 +29,85 @@ function pathInRoot(root, input) {
   return name;
 }
 
-function git(root, args, allowFailure = false) {
-  const result = spawnSync('git', args, { cwd: root, encoding: 'utf8', timeout: 15000, windowsHide: true, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_NO_REPLACE_OBJECTS: '1' } });
+function git(root, args, allowFailure = false, input) {
+  const raw = spawnSync('git', ['-c', 'core.fsmonitor=false', ...args], { cwd: root, input, timeout: 15000, windowsHide: true, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_NO_REPLACE_OBJECTS: '1', GIT_NO_LAZY_FETCH: '1' } });
+  const result = { ...raw, stdout: decodeGit(raw.stdout), stderr: raw.stderr?.toString('utf8') || '' };
   if ((result.error || result.status !== 0) && !allowFailure) fail(`Git: ${result.error?.message || result.stderr?.trim() || 'operacao falhou'}`);
   return result;
 }
 
+function indexStatEqual(a, b) {
+  return a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+}
+
+// Inspect the index without asking Git to load it: loading a split index can
+// touch sharedindex metadata even when optional locks are disabled.
+function inspectIndex(root) {
+  const split = git(root, ['config', '--bool', '--get', 'core.splitIndex'], true);
+  if (split.error || ![0, 1].includes(split.status) || (split.status === 0 && !['true', 'false'].includes(split.stdout.trim()))) fail('Nao foi possivel verificar split-index Git.');
+  if (split.status === 0 && split.stdout.trim() === 'true') fail('Split-index Git nao suportado para revisao; preserve a configuracao e consulte o responsavel.');
+  const name = git(root, ['rev-parse', '--git-path', 'index']).stdout.replace(/\r?\n$/, '');
+  if (!name || /[\0\r\n]/.test(name)) fail('Caminho do indice Git nao suportado.');
+  const path = resolve(root, name);
+  let before;
+  try { before = lstatSync(path, { bigint: true }); } catch (error) { if (error.code === 'ENOENT') return { path, missing: true }; throw error; }
+  if (!before.isFile() || before.isSymbolicLink() || before.ino === 0n || before.size > 134217728n) fail('Indice Git nao e arquivo regular suportado.');
+  const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+  let data, after;
+  try {
+    const opened = fstatSync(fd, { bigint: true });
+    if (!opened.isFile() || !indexStatEqual(before, opened)) fail('Indice Git mudou antes da leitura.');
+    data = readFileSync(fd);
+    const finished = fstatSync(fd, { bigint: true }); after = lstatSync(path, { bigint: true });
+    if (!indexStatEqual(opened, finished) || !indexStatEqual(finished, after) || BigInt(data.length) !== before.size) fail('Indice Git mudou durante a leitura.');
+  } finally { closeSync(fd); }
+  if (data.length < 32 || data.toString('ascii', 0, 4) !== 'DIRC') fail('Indice Git invalido.');
+  const hashes = [['sha1', 20], ['sha256', 32]].filter(([algo, size]) => data.length >= size + 12 && createHash(algo).update(data.subarray(0, -size)).digest().equals(data.subarray(-size)));
+  if (hashes.length !== 1) fail('Checksum ou formato do indice Git nao comprovado.');
+  const objectSize = hashes[0][1], end = data.length - objectSize, version = data.readUInt32BE(4), count = data.readUInt32BE(8);
+  if (![2, 3, 4].includes(version)) fail('Versao do indice Git nao suportada.');
+  let offset = 12, submodule = false, hidden = false, sparse = false;
+  for (let i = 0; i < count; i++) {
+    const start = offset, fixed = 42 + objectSize;
+    if (start + fixed > end) fail('Entrada do indice Git truncada.');
+    const mode = data.readUInt32BE(start + 24), flags = data.readUInt16BE(start + 40 + objectSize);
+    if ((mode & 0o170000) === 0o160000) submodule = true;
+    if ((mode & 0o170000) === 0o040000) sparse = true;
+    if (flags & 0x8000) hidden = true;
+    offset = start + fixed;
+    if (flags & 0x4000) {
+      if (version < 3 || offset + 2 > end) fail('Entrada estendida do indice Git invalida.');
+      if (data.readUInt16BE(offset) & 0x4000) hidden = true;
+      offset += 2;
+    }
+    if (version === 4) {
+      let size = 0, byte;
+      do { if (offset >= end || ++size > 10) fail('Caminho comprimido do indice Git invalido.'); byte = data[offset++]; } while (byte & 0x80);
+    }
+    const nul = data.indexOf(0, offset);
+    if (nul < offset || nul >= end) fail('Caminho do indice Git truncado.');
+    offset = version === 4 ? nul + 1 : start + Math.ceil((nul + 1 - start) / 8) * 8;
+    if (offset > end || (version !== 4 && data.subarray(nul, offset).some(byte => byte !== 0))) fail('Entrada do indice Git invalida.');
+  }
+  while (offset < end) {
+    if (offset + 8 > end) fail('Extensao do indice Git truncada.');
+    const signature = data.toString('ascii', offset, offset + 4), size = data.readUInt32BE(offset + 4);
+    if (signature === 'link') fail('Split-index Git nao suportado para revisao; preserve a configuracao e consulte o responsavel.');
+    if (signature === 'sdir') sparse = true;
+    offset += 8 + size;
+    if (offset > end) fail('Extensao do indice Git truncada.');
+  }
+  return { path, stat: after, hash: createHash('sha256').update(data).digest('hex'), submodule, hidden, sparse };
+}
+
 function repository(root) {
+  if (Object.entries(process.env).some(([key, value]) => key.toUpperCase().startsWith('GIT_TRACE') && value && value !== '0')) fail('Variaveis GIT_TRACE ativas nao sao suportadas na revisao.');
+  if (Object.entries(process.env).some(([key, value]) => key.toUpperCase().startsWith('GIT_TEST_') && value)) fail('Variaveis GIT_TEST_ nao sao suportadas na revisao.');
   const canonical = realpathSync(root);
   const top = git(canonical, ['rev-parse', '--show-toplevel']).stdout.trim();
   if (realpathSync(top) !== canonical) fail('Use a raiz do repositorio.');
+  requireCompleteObjects(canonical, 'revisao de entrega');
+  inspectIndex(canonical);
   return canonical;
 }
 
@@ -53,20 +126,45 @@ function tracked(root, file) {
 
 function ignoredPaths(root, files) {
   if (!files.length) return new Set();
-  const result = spawnSync('git', ['check-ignore', '--no-index', '--stdin', '-z'], { cwd: root, input: files.join('\0') + '\0', encoding: 'utf8', timeout: 15000, windowsHide: true, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_NO_REPLACE_OBJECTS: '1' } });
+  const raw = spawnSync('git', ['-c', 'core.fsmonitor=false', 'check-ignore', '--no-index', '--stdin', '-z'], { cwd: root, input: Buffer.from(files.join('\0') + '\0'), timeout: 15000, windowsHide: true, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_NO_REPLACE_OBJECTS: '1', GIT_NO_LAZY_FETCH: '1' } });
+  const result = { ...raw, stdout: decodeGit(raw.stdout), stderr: raw.stderr?.toString('utf8') || '' };
   if (result.error || ![0, 1].includes(result.status)) fail(`Git: ${result.error?.message || result.stderr?.trim() || 'falha ao conferir ignores'}`);
   return new Set(result.stdout.split('\0').filter(Boolean));
 }
 
 function stagedDeletions(root) {
-  return new Set(git(root, ['diff', '--cached', '--diff-filter=D', '--no-renames', '--name-only', '-z', '--']).stdout.split('\0').filter(Boolean));
+  return new Set(git(root, ['diff', '--cached', '--diff-filter=D', '--no-renames', '--ignore-submodules=none', '--name-only', '-z', '--']).stdout.split('\0').filter(Boolean));
+}
+
+function ensureNoAppliedFilters(root, indexed) {
+  const configured = git(root, ['config', '--get-regexp', '^filter\\.'], true);
+  if (configured.error || ![0, 1].includes(configured.status)) fail('Nao foi possivel verificar filtros Git.');
+  if (configured.status !== 0 || !indexed) return;
+  const paths = new Set(indexed.split('\0').filter(Boolean));
+  const result = git(root, ['check-attr', '-z', '--stdin', '--all'], false, Buffer.from(indexed));
+  const fields = result.stdout.split('\0');
+  if (fields.pop() !== '' || fields.length % 3) fail('Resposta ambigua dos atributos Git.');
+  for (let i = 0; i < fields.length; i += 3) {
+    if (!paths.has(fields[i])) fail('Caminho inesperado nos atributos Git.');
+    if (fields[i + 1] === 'filter') fail('Coleta automatica nao suporta filtro Git aplicado; use --scope para revisar caminhos especificos.');
+  }
 }
 
 function changedFiles(root) {
-  const baseline = head(root);
-  const versioned = git(root, baseline ? ['diff', '--name-only', '-z', 'HEAD', '--'] : ['ls-files', '-z']).stdout;
-  const untracked = git(root, ['ls-files', '--others', '--exclude-standard', '-z']).stdout;
-  return [...new Set((versioned + '\0' + untracked).split('\0').filter(Boolean))].sort();
+  const before = inspectIndex(root);
+  if (before.submodule || before.sparse || before.hidden) fail('Coleta automatica nao suporta submodulo, sparse-index ou flags que ocultam alteracoes; use --scope.');
+  const indexed = git(root, ['ls-files', '-z']).stdout;
+  ensureNoAppliedFilters(root, indexed);
+  const status = git(root, ['status', '--porcelain=v1', '-z', '--no-renames', '--untracked-files=all', '--ignore-submodules=none']).stdout;
+  const entries = status.split('\0');
+  if (entries.pop() !== '') fail('Status Git incompleto.');
+  const names = entries.map(entry => {
+    if (entry.length < 4 || entry[2] !== ' ' || !/^[ MADRCUT?!]{2}$/.test(entry.slice(0, 2)) || entry.slice(0, 2) === '!!') fail('Status Git ambiguo.');
+    return entry.slice(3);
+  });
+  const after = inspectIndex(root);
+  if (before.path !== after.path || !!before.missing !== !!after.missing || (!before.missing && (!indexStatEqual(before.stat, after.stat) || before.hash !== after.hash))) fail('Indice Git mudou durante a coleta; resultado descartado.');
+  return [...new Set(names)].sort();
 }
 
 function snapshot(root, mode, paths, documents = [], spec = null) {
@@ -100,11 +198,25 @@ function expectedDocuments(root, state, extra = []) {
   return [...new Set([...candidates.filter(file => !local.has(file) || versioned.has(file)), ...extra.map(file => pathInRoot(root, file))])].sort();
 }
 
+function requireCompleteObjects(root, operation) {
+  const partial = git(root, ['config', '--get-regexp', '^(extensions\\.partialclone|remote\\..*\\.promisor)$'], true);
+  if (partial.error || ![0, 1].includes(partial.status)) fail('Nao foi possivel verificar clone parcial.');
+  if (partial.status === 0) fail(`Clone parcial ou remote promisor nao suportado para ${operation}.`);
+}
+
+function stagedBlobDigest(root, object, path) {
+  if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(object)) fail(`Objeto preparado invalido: ${path}`);
+  const blob = spawnSync('git', ['-c', 'core.fsmonitor=false', 'cat-file', 'blob', object], { cwd: root, timeout: 15000, windowsHide: true, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_NO_REPLACE_OBJECTS: '1', GIT_NO_LAZY_FETCH: '1' } });
+  if (blob.error || blob.status !== 0 || !blob.stdout) fail(`Blob preparado indisponivel ou muito grande: ${path}`);
+  return createHash('sha256').update(blob.stdout).digest('hex');
+}
+
 function checkIndex(root, state) {
-  const staged = new Set(git(root, ['diff', '--cached', '--name-only', '-z', '--']).stdout.split('\0').filter(Boolean));
+  const staged = new Set(git(root, ['diff', '--cached', '--name-only', '-z', '--no-renames', '--ignore-submodules=none', '--']).stdout.split('\0').filter(Boolean));
   const deleted = stagedDeletions(root);
   const indexed = new Set(git(root, ['ls-files', '-z']).stdout.split('\0').filter(Boolean));
   const local = ignoredPaths(root, state.files.filter(file => file.indexAction === 'untrack').map(file => file.path));
+  let checkedObjects = false;
   for (const file of state.files) {
     if (file.indexAction === 'untrack') {
       if (!staged.has(file.path) || !deleted.has(file.path) || indexed.has(file.path) || file.sha256 === null || !existsSync(join(root, file.path)) || !local.has(file.path)) fail(`Acao de desindexacao mudou: ${file.path}`);
@@ -112,9 +224,19 @@ function checkIndex(root, state) {
     }
     if (file.indexAction !== undefined) fail(`Acao de indice invalida: ${file.path}`);
     if (!staged.has(file.path)) continue;
+    // Diff can hide mismatches behind index flags or a clean filter. Compare
+    // the raw staged blob to the reviewed bytes without running either.
+    const flags = git(root, ['--literal-pathspecs', 'ls-files', '-v', '--stage', '-z', '--', file.path]).stdout.split('\0').filter(Boolean);
+    if (flags.length !== (indexed.has(file.path) ? 1 : 0)) fail(`Flags do indice Git ambiguas: ${file.path}`);
     const deletedButPresent = !indexed.has(file.path) && file.sha256 !== null;
-    const differs = git(root, ['--literal-pathspecs', 'diff', '--quiet', '--no-ext-diff', '--', file.path], true);
-    if (deletedButPresent || differs.error || differs.status !== 0) fail(`Indice Git difere do arquivo testado: ${file.path}`);
+    if (deletedButPresent) fail(`Indice Git difere do arquivo testado: ${file.path}`);
+    if (!flags.length) continue;
+    const match = /^([A-Za-z]) (\d{6}) ([a-f0-9]+) ([0-3])\t([\s\S]+)$/.exec(flags[0]);
+    if (!match || match[5] !== file.path || match[4] !== '0') fail(`Flags do indice Git ambiguas: ${file.path}`);
+    if (match[1] === 'S' || /^[a-z]$/.test(match[1])) fail(`Arquivo preparado usa assume-unchanged ou skip-worktree: ${file.path}`);
+    if (!['100644', '100755'].includes(match[2])) fail(`Tipo de arquivo preparado nao comprovado: ${file.path}`);
+    if (!checkedObjects) { requireCompleteObjects(root, 'revisao de indice'); checkedObjects = true; }
+    if (stagedBlobDigest(root, match[3], file.path) !== file.sha256) fail(`Indice Git difere dos bytes testados: ${file.path} (confira filtros e CRLF).`);
   }
 }
 
@@ -216,6 +338,49 @@ function validateReview(file, { root = projectRoot, requireSeal = true } = {}) {
 
 export function checkReview(file, { root = projectRoot } = {}) { return validateReview(file, { root, requireSeal: true }).result; }
 
+// A review may cover only part of a project. A commit includes the entire index,
+// so every staged path must be covered by a sealed review before committing.
+export function checkCommit(reports, { root = projectRoot } = {}) {
+  requireNode(); root = repository(root);
+  if (!Array.isArray(reports) || !reports.length) fail('Informe um ou mais relatorios selados, sem repeticao.');
+  reports = reports.map(file => pathInRoot(root, file));
+  if (new Set(reports).size !== reports.length) fail('Informe relatorios selados sem repeticao.');
+  const baselineHead = head(root);
+  const staged = () => git(root, ['diff', '--cached', '--raw', '-z', '--no-abbrev', '--no-renames', '--no-ext-diff', '--no-textconv', '--ignore-submodules=none', '--']).stdout;
+  const before = staged();
+  if (!before) fail('Nenhuma alteracao preparada para commit.');
+  const reviews = reports.map(file => validateReview(file, { root, requireSeal: true }));
+  if (head(root) !== baselineHead || staged() !== before) fail('HEAD ou indice preparado mudou durante a verificacao.');
+  const fields = before.split('\0');
+  if (fields.pop() !== '' || fields.length % 2) fail('Diff preparado incompleto ou ambiguo.');
+  const paths = new Map();
+  for (let i = 0; i < fields.length; i += 2) {
+    const match = /^:(\d{6}) (\d{6}) ([a-f0-9]+) ([a-f0-9]+) ([AMD])$/.exec(fields[i]);
+    if (!match) fail('Tipo de alteracao preparada nao suportado.');
+    const [, oldMode, newMode, , object, action] = match, path = pathInRoot(root, fields[i + 1]);
+    const valid = action === 'A' ? oldMode === '000000' && newMode === '100644'
+      : action === 'D' ? oldMode === '100644' && newMode === '000000'
+        : oldMode === '100644' && newMode === '100644';
+    if (!valid || paths.has(path) || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(object)) fail(`Tipo ou modo preparado nao comprovado: ${path}`);
+    paths.set(path, { action, object });
+  }
+  const covered = new Map(reviews.flatMap(review => review.snapshot.files.map(file => [file.path, file])));
+  const missing = [...paths.keys()].filter(path => !covered.has(path));
+  if (missing.length) fail(`Arquivos preparados sem revisao selada: ${missing.join(', ')}`);
+  requireCompleteObjects(root, 'check-commit');
+  for (const [path, entry] of paths) {
+    if (entry.action === 'D') {
+      const reviewed = covered.get(path);
+      if (reviewed.sha256 !== null && reviewed.indexAction !== 'untrack') fail(`Exclusao preparada difere do arquivo revisado: ${path}`);
+      continue;
+    }
+    if (stagedBlobDigest(root, entry.object, path) !== covered.get(path).sha256) fail(`Blob preparado difere dos bytes revisados: ${path}`);
+  }
+  for (const file of reports) validateReview(file, { root, requireSeal: true });
+  if (head(root) !== baselineHead || staged() !== before) fail('HEAD ou indice preparado mudou durante a verificacao.');
+  return { status: 'passed', head: baselineHead, reports: reports.length, staged: paths.size, stagedSha256: createHash('sha256').update(before).digest('hex') };
+}
+
 // This deliberately permits only a fast-forward and regular non-executable
 // files. Existing review snapshots do not record modes or merge results.
 export function checkMerge(reports, destination, { root = projectRoot } = {}) {
@@ -240,11 +405,11 @@ export function checkMerge(reports, destination, { root = projectRoot } = {}) {
   if (head(root) !== source) fail('HEAD diverge da branch de origem.');
   if (git(root, ['merge-base', '--is-ancestor', target, source], true).status !== 0) fail('Apenas fast-forward comprovado e suportado; revise o resultado integrado para historico divergente.');
   const bytes = args => {
-    const result = spawnSync('git', args, { cwd: root, timeout: 15000, windowsHide: true, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_NO_REPLACE_OBJECTS: '1' } });
+    const result = spawnSync('git', ['-c', 'core.fsmonitor=false', ...args], { cwd: root, timeout: 15000, windowsHide: true, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_NO_REPLACE_OBJECTS: '1', GIT_NO_LAZY_FETCH: '1' } });
     if (result.error || result.status !== 0) fail(`Git: ${result.error?.message || result.stderr?.toString().trim() || 'operacao falhou'}`);
     return result.stdout;
   };
-  const decode = data => { try { return new TextDecoder('utf-8', { fatal: true }).decode(data); } catch { fail('Caminho Git nao e UTF-8 valido.'); } };
+  const decode = data => { try { return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(data); } catch { fail('Caminho Git nao e UTF-8 valido.'); } };
   const raw = bytes(['diff', '--raw', '-z', '--no-abbrev', '--no-renames', '--no-ext-diff', '--no-textconv', '--ignore-submodules=none', target, source, '--']);
   const parts = decode(raw).split('\0');
   if (parts.pop() !== '' || parts.length % 2) fail('Diff Git incompleto ou ambiguo.');
@@ -292,12 +457,13 @@ export function sealReview(file, options) {
   return checkReview(file, options);
 }
 
-const usage = 'Uso: revisar-entrega prepare --id <slug> [--execution <slug>] [--spec <arquivo>] [--scope <arquivo>] [--document <arquivo>] [--output <artefato>]; seal|check <revisao.json>; check-merge --destino refs/heads/<branch> <revisao.json> [...]';
+const usage = 'Uso: revisar-entrega prepare --id <slug> [--execution <slug>] [--spec <arquivo>] [--scope <arquivo>] [--document <arquivo>] [--output <artefato>]; seal|check <revisao.json>; check-commit <revisao.json> [...]; check-merge --destino refs/heads/<branch> <revisao.json> [...]';
 export function main(args = process.argv.slice(2)) {
   requireNode(); const [mode, ...rest] = args;
   if (!mode || ['--help', '-h'].includes(mode)) { console.log(usage); return 0; }
   if (mode === 'check' && rest.length === 1) { console.log(JSON.stringify(checkReview(rest[0]))); return 0; }
   if (mode === 'seal' && rest.length === 1) { console.log(JSON.stringify(sealReview(rest[0]))); return 0; }
+  if (mode === 'check-commit' && rest.length) { console.log(JSON.stringify(checkCommit(rest))); return 0; }
   if (mode === 'check-merge' && rest.length >= 3 && rest[0] === '--destino') { console.log(JSON.stringify(checkMerge(rest.slice(2), rest[1]))); return 0; }
   if (mode !== 'prepare') fail(usage);
   const options = { scope: [], documents: [] };

package/.pbai4devs/scripts/revisar-entrega/tests/TEST.mjs

@@ -1,9 +1,10 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, utimesSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { checkMerge, checkReview, prepareReview, sealReview, specCriteria } from '../SCRIPT.mjs';
+import { pathToFileURL } from 'node:url';
+import { checkCommit, checkMerge, checkReview, prepareReview, sealReview, specCriteria } from '../SCRIPT.mjs';
 import { projectRoot } from '../../lib/runtime.mjs';
 
 function fixture(t) {
@@ -166,6 +167,460 @@ test('indice Git precisa corresponder ao codigo testado antes de commit', t => {
   assert.equal(checkReview(f.file, { root: f.root }).status, 'passed');
 });
 
+test('prepare, seal, check e check-commit preservam indice com stat defasado', t => {
+  const f = fixture(t);
+  f.git('add', '.');
+  f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=disabled-hooks', 'commit', '-q', '-m', 'test: base');
+  f.put('src/main.mjs', 'export const value=2;\n'); f.git('add', 'src/main.mjs');
+  const path = join(f.root, 'src/main.mjs'), index = join(f.root, '.git/index');
+  const stale = () => { const info = statSync(path); utimesSync(path, info.atime, new Date(info.mtimeMs - 120000)); };
+  const preserved = call => { stale(); const before = readFileSync(index); const result = call(); assert.deepEqual(readFileSync(index), before); return result; };
+  const made = preserved(() => prepareReview({ root: f.root, id: 'stat-cache', execution: 'case' }));
+  for (const item of made.report.documentation) Object.assign(item, { decision: 'no-impact', reason: 'Documento examinado na fixture.' });
+  const proof = '.agent-tests/stat-cache/case/proof.txt'; f.put(proof, 'Prova sintetica.\n');
+  for (const item of made.report.validation) Object.assign(item, { method: 'fixture', prerequisite: 'Git local', assertion: 'Blob revisado', evidence: [proof], status: 'passed' });
+  made.report.review = { status: 'approved', reviewer: 'simulacao de teste', findings: [] };
+  f.put(made.file, JSON.stringify(made.report));
+  assert.equal(preserved(() => sealReview(made.file, { root: f.root })).status, 'passed');
+  assert.equal(preserved(() => checkReview(made.file, { root: f.root })).status, 'passed');
+  assert.equal(preserved(() => checkCommit([made.file], { root: f.root })).status, 'passed');
+});
+
+test('coleta automatica inclui staged cancelado e ambas pontas de renomeacao', async t => {
+  for (const name of ['cancelado', 'renomeado']) await t.test(name, t => {
+    const f = fixture(t);
+    f.git('add', '.');
+    f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=disabled-hooks', 'commit', '-q', '-m', 'test: base');
+    if (name === 'cancelado') {
+      f.put('src/main.mjs', 'export const value=2;\n'); f.git('add', 'src/main.mjs');
+      f.put('src/main.mjs', 'export const value=1;\n');
+    } else f.git('mv', 'src/main.mjs', 'src/new name.mjs');
+    const index = readFileSync(join(f.root, '.git/index'));
+    const made = prepareReview({ root: f.root, id: 'coleta', execution: 'case' });
+    const paths = made.report.snapshot.files.map(file => file.path);
+    assert.ok(paths.includes('src/main.mjs'));
+    if (name === 'renomeado') assert.ok(paths.includes('src/new name.mjs'));
+    assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+  });
+});
+
+test('coleta automatica recusa nome com quebra de linha sem tocar indice', t => {
+  if (process.platform === 'win32') return t.skip('Quebras de linha nao sao nomes de arquivo validos no Windows.');
+  const f = fixture(t); f.put('line\nbreak.txt', 'conteudo\n'); f.git('add', 'line\nbreak.txt');
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => prepareReview({ root: f.root, id: 'newline', execution: 'case' }), /Caminho invalido/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+  assert.equal(existsSync(join(f.root, '.agent-tests/newline')), false);
+});
+
+test('coleta permite filtro global configurado sem atributo aplicado', t => {
+  const f = fixture(t); f.git('add', 'src/main.mjs');
+  f.put('.agent-tests/global-git-config', '');
+  const globalConfig = join(f.root, '.agent-tests/global-git-config');
+  f.git('config', '--file', globalConfig, 'filter.fixture.clean', 'false');
+  const previous = process.env.GIT_CONFIG_GLOBAL;
+  process.env.GIT_CONFIG_GLOBAL = globalConfig;
+  t.after(() => { if (previous === undefined) delete process.env.GIT_CONFIG_GLOBAL; else process.env.GIT_CONFIG_GLOBAL = previous; });
+  const index = readFileSync(join(f.root, '.git/index'));
+  const made = prepareReview({ root: f.root, id: 'global-filter', execution: 'case' });
+  assert.ok(made.report.snapshot.files.some(file => file.path === 'src/main.mjs'));
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('coleta automatica recusa filtro aplicado sem executa-lo e scope continua disponivel', t => {
+  const f = fixture(t); f.git('add', '.');
+  f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=disabled-hooks', 'commit', '-q', '-m', 'test: base');
+  const executable = process.execPath.replaceAll('\\', '/');
+  const clean = `"${executable}" -e "require('fs').writeFileSync('filter-marker','hit');process.stdin.pipe(process.stdout)"`;
+  f.git('config', 'filter.fixture.clean', clean);
+  f.put('.git/info/attributes', 'src/main.mjs filter=fixture\n');
+  f.put('src/main.mjs', 'export const value=2;\n');
+  const marker = join(f.root, 'filter-marker'), index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => prepareReview({ root: f.root, id: 'filtro', execution: 'auto' }), /filtro Git aplicado.*--scope/);
+  assert.equal(existsSync(marker), false);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+  const made = prepareReview({ root: f.root, id: 'filtro', execution: 'scope', scope: ['src/main.mjs'] });
+  assert.ok(made.report.snapshot.files.some(file => file.path === 'src/main.mjs'));
+  assert.equal(existsSync(marker), false);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('gate recusa split-index sem alterar indice ou sharedindex', t => {
+  const f = fixture(t); f.git('add', 'src/main.mjs'); f.git('update-index', '--split-index');
+  const sharedPath = f.git('rev-parse', '--shared-index-path').trim();
+  assert.ok(sharedPath);
+  const shared = resolve(f.root, sharedPath), before = statSync(shared, { bigint: true });
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => prepareReview({ root: f.root, id: 'split', execution: 'case', scope: ['src/main.mjs'] }), /Split-index Git nao suportado/);
+  const after = statSync(shared, { bigint: true });
+  assert.equal(after.mtimeNs, before.mtimeNs); assert.equal(after.ctimeNs, before.ctimeNs);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('coleta automatica recusa flags ocultas sem modifica-las', async t => {
+  for (const flag of ['--assume-unchanged', '--skip-worktree']) await t.test(flag, t => {
+    const f = fixture(t); f.git('add', 'src/main.mjs'); f.git('update-index', flag, 'src/main.mjs');
+    f.put('src/main.mjs', 'export const value=2;\n');
+    const index = readFileSync(join(f.root, '.git/index'));
+    assert.throws(() => prepareReview({ root: f.root, id: 'hidden', execution: 'case' }), /flags que ocultam alteracoes.*--scope/);
+    assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+  });
+});
+
+test('gate recusa flags que ocultam diferencas entre indice e arquivo', async t => {
+  for (const [name, options] of [
+    ['assume-unchanged', ['--assume-unchanged']],
+    ['skip-worktree', ['--skip-worktree']],
+    ['ambas', ['--assume-unchanged', '--skip-worktree']],
+  ]) await t.test(name, t => {
+    const f = approved(t, {}, f => {
+      f.git('add', 'src/main.mjs');
+      for (const option of options) f.git('update-index', option, 'src/main.mjs');
+      f.put('src/main.mjs', 'export const value=2;\n');
+    }, false);
+    // Git itself reports equality here even though staged and working differ.
+    f.git('--literal-pathspecs', 'diff', '--quiet', '--no-ext-diff', '--', 'src/main.mjs');
+    const index = readFileSync(join(f.root, '.git/index'));
+    const flags = f.git('-c', 'core.fsmonitor=false', 'ls-files', '-v', '--', 'src/main.mjs');
+    const staged = f.git('show', ':src/main.mjs');
+    assert.notEqual(staged, readFileSync(join(f.root, 'src/main.mjs'), 'utf8'));
+    assert.throws(() => sealReview(f.file, { root: f.root }), /assume-unchanged ou skip-worktree/);
+    assert.throws(() => checkReview(f.file, { root: f.root }), /assume-unchanged ou skip-worktree/);
+    assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+    assert.equal(f.git('-c', 'core.fsmonitor=false', 'ls-files', '-v', '--', 'src/main.mjs'), flags);
+    assert.equal(f.git('show', ':src/main.mjs'), staged);
+  });
+});
+
+test('gate aceita delecao preparada sem entrada no indice', t => {
+  const f = approved(t, {}, f => {
+    f.git('add', '.');
+    f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-q', '-m', 'test: base');
+    f.git('rm', '-q', 'src/main.mjs');
+  }, false);
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.equal(sealReview(f.file, { root: f.root }).status, 'passed');
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('gate recusa multiplas entradas de indice em conflito', t => {
+  const f = approved(t, {}, f => {
+    const commit = message => f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-q', '-m', message);
+    f.git('add', '.'); commit('test: base');
+    const base = f.git('symbolic-ref', '--short', 'HEAD').trim();
+    f.git('checkout', '-q', '-b', 'fixture-conflict');
+    f.put('src/main.mjs', 'export const value=2;\n'); f.git('add', 'src/main.mjs'); commit('test: feature');
+    f.git('checkout', '-q', base);
+    f.put('src/main.mjs', 'export const value=3;\n'); f.git('add', 'src/main.mjs'); commit('test: target');
+    const merge = spawnSync('git', ['-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'merge', '--no-commit', 'fixture-conflict'], { cwd: f.root, encoding: 'utf8' });
+    assert.equal(merge.status, 1, merge.stderr);
+  }, false);
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => sealReview(f.file, { root: f.root }), /Flags do indice Git ambiguas/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('gate recusa nomes Git UTF-8 invalidos antes de aprovar ou gerar relatorio', t => {
+  if (process.platform === 'win32') return t.skip('Nomes Git arbitrarios em bytes nao sao representaveis no filesystem Windows.');
+  const f = approved(t, {}, () => {}, false);
+  f.put('collision\ufffd.txt', 'arquivo humano valido\n'); f.git('add', 'collision\ufffd.txt');
+  const blob = spawnSync('git', ['hash-object', '-w', '--stdin'], { cwd: f.root, input: 'arquivo de teste\n', encoding: 'utf8' });
+  assert.equal(blob.status, 0, blob.stderr);
+  const invalidName = Buffer.concat([Buffer.from('collision'), Buffer.from([0xff]), Buffer.from('.txt')]);
+  const entry = Buffer.concat([Buffer.from(`100644 ${blob.stdout.trim()}\t`), invalidName, Buffer.from([0])]);
+  const update = spawnSync('git', ['update-index', '-z', '--index-info'], { cwd: f.root, input: entry });
+  assert.equal(update.status, 0, update.stderr?.toString());
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => prepareReview({ root: f.root, id: 'invalido', execution: 'case' }), /UTF-8 valido/);
+  assert.equal(existsSync(join(f.root, '.agent-tests/invalido')), false);
+  assert.throws(() => sealReview(f.file, { root: f.root }), /UTF-8 valido/);
+  assert.throws(() => checkReview(f.file, { root: f.root }), /UTF-8 valido/);
+  assert.throws(() => checkCommit([f.file], { root: f.root }), /UTF-8 valido/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('caminho com surrogate isolado nao e convertido em outro arquivo', t => {
+  const f = fixture(t); f.put('collision\ufffd.txt', 'arquivo humano\n');
+  assert.throws(() => prepareReview({ root: f.root, id: 'invalido', scope: ['collision\ud800.txt'] }), /Caminho invalido/);
+  assert.equal(readFileSync(join(f.root, 'collision\ufffd.txt'), 'utf8'), 'arquivo humano\n');
+});
+
+test('nome iniciado por BOM e preservado em staged e na consulta de ignores', async t => {
+  await t.test('staged', t => {
+    const name = '\ufeffbom.txt';
+    const f = approved(t, { scope: [name] }, f => {
+      f.put(name, 'conteudo revisado\n');
+      f.put('bom.txt', 'outro arquivo humano\n');
+      f.git('add', '--', name);
+    }, false);
+    const index = readFileSync(join(f.root, '.git/index'));
+    assert.ok(f.report.snapshot.files.some(file => file.path === name));
+    assert.equal(sealReview(f.file, { root: f.root }).status, 'passed');
+    assert.equal(checkCommit([f.file], { root: f.root }).status, 'passed');
+    assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+    assert.equal(readFileSync(join(f.root, 'bom.txt'), 'utf8'), 'outro arquivo humano\n');
+  });
+  await t.test('ignorado', t => {
+    const f = fixture(t), name = '\ufeffignored.md';
+    f.put('.gitignore', `/.agent-tests/\n/${name}\n`);
+    f.put(name, '# Ignorado\n');
+    f.put('ignored.md', '# Documento versionavel\n');
+    const made = prepareReview({ root: f.root, id: 'bom', execution: 'case', scope: [name, 'ignored.md'] });
+    assert.ok(!made.report.documentation.some(file => file.path === name));
+    assert.ok(made.report.documentation.some(file => file.path === 'ignored.md'));
+  });
+});
+
+test('check-commit bloqueia staged humano fora da revisao sem altera-lo', t => {
+  const f = approved(t, {}, f => {
+    f.git('add', 'src/main.mjs');
+    f.put('humano extra.txt', 'arquivo preparado por outra pessoa\n');
+    f.git('add', 'humano extra.txt');
+  }, false);
+  sealReview(f.file, { root: f.root });
+  assert.equal(checkReview(f.file, { root: f.root }).status, 'passed');
+  const index = readFileSync(join(f.root, '.git/index'));
+  const content = readFileSync(join(f.root, 'humano extra.txt'));
+  assert.throws(() => checkCommit([f.file], { root: f.root }), /Arquivos preparados sem revisao selada: humano extra\.txt/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+  assert.deepEqual(readFileSync(join(f.root, 'humano extra.txt')), content);
+});
+
+test('check-commit aceita cobertura unida de relatorios selados', t => {
+  const f = approved(t, {}, f => {
+    f.git('add', 'src/main.mjs'); f.put('extra.txt', 'conteudo\n'); f.git('add', 'extra.txt');
+  }, false);
+  sealReview(f.file, { root: f.root });
+  const extra = prepareReview({ root: f.root, id: 'extra', execution: 'exec', scope: ['extra.txt'] });
+  for (const item of extra.report.documentation) Object.assign(item, { decision: 'no-impact', reason: 'Documento examinado na fixture.' });
+  const proof = '.agent-tests/extra/exec/proof.txt'; f.put(proof, 'Prova sintetica complementar.\n');
+  for (const item of extra.report.validation) Object.assign(item, { method: 'fixture', prerequisite: 'Git local', assertion: 'Conteudo revisado', evidence: [proof], status: 'passed' });
+  extra.report.review = { status: 'approved', reviewer: 'simulacao de teste', findings: [] };
+  f.put(extra.file, JSON.stringify(extra.report)); sealReview(extra.file, { root: f.root });
+  const index = readFileSync(join(f.root, '.git/index'));
+  const result = checkCommit([f.file, extra.file], { root: f.root });
+  assert.equal(result.status, 'passed'); assert.equal(result.reports, 2); assert.equal(result.staged, 2);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+  assert.throws(() => checkCommit([f.file, `./${f.file}`], { root: f.root }), /sem repeticao/);
+});
+
+test('check-commit na CLI aplica a mesma protecao de staged extra', t => {
+  const f = approved(t, {}, f => f.git('add', 'src/main.mjs'), false);
+  sealReview(f.file, { root: f.root });
+  const script = '.pbai4devs/scripts/revisar-entrega/SCRIPT.mjs', runtime = '.pbai4devs/scripts/lib/runtime.mjs';
+  for (const file of [script, runtime]) { mkdirSync(dirname(join(f.root, file)), { recursive: true }); cpSync(join(projectRoot, file), join(f.root, file)); }
+  const args = [join(f.root, script), 'check-commit', f.file];
+  let run = spawnSync(process.execPath, args, { cwd: f.root, encoding: 'utf8' });
+  assert.equal(run.status, 0, run.stderr); assert.equal(JSON.parse(run.stdout).status, 'passed');
+  f.put('extra.txt', 'preparado\n'); f.git('add', 'extra.txt');
+  const index = readFileSync(join(f.root, '.git/index'));
+  run = spawnSync(process.execPath, args, { cwd: f.root, encoding: 'utf8' });
+  assert.equal(run.status, 1); assert.match(run.stderr, /sem revisao selada: extra\.txt/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('check-commit recusa nome preparado com quebra de linha', t => {
+  if (process.platform === 'win32') return t.skip('Quebras de linha nao sao nomes de arquivo validos no Windows.');
+  const f = approved(t, {}, f => f.git('add', 'src/main.mjs'), false);
+  sealReview(f.file, { root: f.root });
+  f.put('line\nbreak.txt', 'conteudo humano\n'); f.git('add', 'line\nbreak.txt');
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => checkCommit([f.file], { root: f.root }), /Caminho invalido/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('check-commit exige as duas pontas de renomeacao preparada', async t => {
+  for (const [name, scope, expected] of [
+    ['cobertura completa', ['src/main.mjs', 'src/new name.mjs'], true],
+    ['origem ausente', ['src/new name.mjs'], false],
+  ]) await t.test(name, t => {
+    const f = approved(t, { scope }, f => {
+      f.git('add', '.');
+      f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-q', '-m', 'test: base');
+      f.git('mv', 'src/main.mjs', 'src/new name.mjs');
+    }, false);
+    sealReview(f.file, { root: f.root });
+    const index = readFileSync(join(f.root, '.git/index'));
+    if (expected) assert.equal(checkCommit([f.file], { root: f.root }).staged, 2);
+    else assert.throws(() => checkCommit([f.file], { root: f.root }), /sem revisao selada: src\/main\.mjs/);
+    assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+  });
+});
+
+test('check-commit rejeita modo executavel staged apos o selo', t => {
+  const f = approved(t, {}, f => {
+    f.git('add', '.');
+    f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-q', '-m', 'test: base');
+  }, false);
+  sealReview(f.file, { root: f.root });
+  f.git('config', 'core.filemode', 'false');
+  f.git('update-index', '--chmod=+x', 'src/main.mjs');
+  assert.equal(checkReview(f.file, { root: f.root }).status, 'passed');
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => checkCommit([f.file], { root: f.root }), /modo preparado nao comprovado: src\/main\.mjs/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('gate rejeita blob transformado por clean filter sem executar filtro na verificacao', t => {
+  const f = approved(t, {}, f => {
+    f.git('add', '.');
+    f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-q', '-m', 'test: base');
+    f.put('src/main.mjs', 'export const value=2;\n');
+  }, false);
+  sealReview(f.file, { root: f.root });
+  const executable = process.execPath.replaceAll('\\', '/');
+  const clean = `"${executable}" -e "require('fs').writeFileSync('filter-marker','hit');process.stdin.on('data',x=>process.stdout.write(x.toString().toUpperCase()))"`;
+  f.git('config', 'filter.fixture.clean', clean);
+  f.put('.git/info/attributes', 'src/main.mjs filter=fixture\n');
+  f.git('add', 'src/main.mjs');
+  const marker = join(f.root, 'filter-marker'); assert.equal(existsSync(marker), true); rmSync(marker);
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => checkReview(f.file, { root: f.root }), /Indice Git difere dos bytes testados.*filtros e CRLF/);
+  assert.throws(() => checkCommit([f.file], { root: f.root }), /Indice Git difere dos bytes testados.*filtros e CRLF/);
+  assert.equal(existsSync(marker), false);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('gate aceita blob identico com clean filter configurado sem executar filtro', t => {
+  const f = approved(t, {}, f => {
+    const executable = process.execPath.replaceAll('\\', '/');
+    const clean = `"${executable}" -e "require('fs').writeFileSync('filter-marker','hit');process.stdin.pipe(process.stdout)"`;
+    f.git('config', 'filter.fixture.clean', clean);
+    f.put('.git/info/attributes', 'src/main.mjs filter=fixture\n');
+    f.git('add', 'src/main.mjs');
+  }, false);
+  const marker = join(f.root, 'filter-marker'); assert.equal(existsSync(marker), true); rmSync(marker);
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.equal(sealReview(f.file, { root: f.root }).status, 'passed');
+  assert.equal(checkCommit([f.file], { root: f.root }).status, 'passed');
+  assert.equal(existsSync(marker), false);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('gate bloqueia staged CRLF normalizado quando difere dos bytes revisados', t => {
+  const f = approved(t, {}, f => {
+    f.git('add', '.');
+    f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-q', '-m', 'test: base');
+    f.put('src/main.mjs', 'export const value=2;\r\n');
+  }, false);
+  sealReview(f.file, { root: f.root });
+  f.put('.git/info/attributes', 'src/main.mjs text eol=crlf\n'); f.git('add', 'src/main.mjs');
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => checkCommit([f.file], { root: f.root }), /Indice Git difere dos bytes testados.*CRLF/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('gate recusa promisor antes de ler blob preparado', t => {
+  const f = approved(t, {}, f => f.git('add', 'src/main.mjs'), false);
+  f.git('config', 'remote.fixture.promisor', 'true');
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => sealReview(f.file, { root: f.root }), /Clone parcial ou remote promisor/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('consultas do gate nao executam hook fsmonitor configurado', t => {
+  const f = fixture(t);
+  f.git('add', 'src/main.mjs');
+  f.put('.git/fsmonitor-hook', "#!/bin/sh\nprintf hit > .git/fsmonitor-marker\nprintf 'builtin:fake\\0'\n");
+  f.git('config', 'core.fsmonitor', 'sh .git/fsmonitor-hook');
+  f.git('ls-files', '-z');
+  const marker = join(f.root, '.git/fsmonitor-marker');
+  assert.equal(existsSync(marker), true, 'controle deve executar o hook'); rmSync(marker);
+  const index = readFileSync(join(f.root, '.git/index'));
+  const made = prepareReview({ root: f.root, id: 'monitor', execution: 'case', scope: ['src/main.mjs'] });
+  for (const item of made.report.documentation) Object.assign(item, { decision: 'no-impact', reason: 'Documento examinado na fixture.' });
+  const proof = '.agent-tests/monitor/case/proof.txt'; f.put(proof, 'Prova sintetica.\n');
+  for (const item of made.report.validation) Object.assign(item, { method: 'fixture', prerequisite: 'Git local', assertion: 'Blob revisado', evidence: [proof], status: 'passed' });
+  made.report.review = { status: 'approved', reviewer: 'simulacao de teste', findings: [] };
+  f.put(made.file, JSON.stringify(made.report));
+  assert.equal(sealReview(made.file, { root: f.root }).status, 'passed');
+  assert.equal(checkReview(made.file, { root: f.root }).status, 'passed');
+  assert.equal(checkCommit([made.file], { root: f.root }).status, 'passed');
+  assert.equal(existsSync(marker), false);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+  assert.equal(f.git('config', '--get', 'core.fsmonitor').trim(), 'sh .git/fsmonitor-hook');
+});
+
+test('diff do gate nao executa hook fsmonitor de submodulo', t => {
+  const f = fixture(t);
+  const commit = message => f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=disabled-hooks', 'commit', '-q', '-m', message);
+  f.git('add', '.'); commit('test: base');
+  const source = join(f.root, '.agent-tests/submodule-source'); mkdirSync(source, { recursive: true });
+  const env = { ...process.env, GIT_ALLOW_PROTOCOL: 'file', GIT_TERMINAL_PROMPT: '0' };
+  const git = (cwd, args) => {
+    const run = spawnSync('git', args, { cwd, env, encoding: 'utf8', timeout: 30000, windowsHide: true });
+    assert.equal(run.status, 0, run.stderr); return run.stdout;
+  };
+  git(source, ['init', '-q']); writeFileSync(join(source, 'data.txt'), 'original\n'); git(source, ['add', '.']);
+  git(source, ['-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=disabled-hooks', 'commit', '-q', '-m', 'test: submodule']);
+  git(f.root, ['-c', 'protocol.file.allow=always', 'submodule', 'add', '-q', pathToFileURL(source).href, 'nested']);
+  f.git('add', '.gitmodules', 'nested'); commit('test: add submodule');
+  f.put('nested/monitor.sh', "#!/bin/sh\nprintf hit > monitor-marker\nprintf 'builtin:fake\\0'\n");
+  f.git('-C', 'nested', 'config', 'core.fsmonitor', 'sh monitor.sh');
+  f.git('config', 'diff.ignoreSubmodules', 'none');
+  f.git('-C', 'nested', 'ls-files', '-z');
+  const marker = join(f.root, 'nested/monitor-marker');
+  assert.equal(existsSync(marker), true, 'controle deve executar o hook do submodulo'); rmSync(marker);
+  f.put('nested/data.txt', 'alterado\n');
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => prepareReview({ root: f.root, id: 'nested', execution: 'case' }), /Coleta automatica nao suporta submodulo.*use --scope/);
+  assert.equal(existsSync(marker), false);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
+test('todos os gates recusam partial clone antes de buscar objetos', t => {
+  mkdirSync(join(projectRoot, '.agent-tests'), { recursive: true });
+  const base = mkdtempSync(join(projectRoot, '.agent-tests/partial-gate-'));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  const source = join(base, 'source'), remote = join(base, 'remote.git'), target = join(base, 'clone');
+  mkdirSync(source);
+  const emptyConfig = join(base, 'empty-git-config'); writeFileSync(emptyConfig, '');
+  const env = { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: emptyConfig, GIT_ALLOW_PROTOCOL: 'file', GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0' };
+  const git = (cwd, args) => {
+    const run = spawnSync('git', args, { cwd, env, encoding: 'utf8', timeout: 30000, windowsHide: true });
+    assert.equal(run.status, 0, run.stderr); return run.stdout;
+  };
+  git(source, ['init', '-q']);
+  writeFileSync(join(source, 'README.md'), '# Fixture\n'); writeFileSync(join(source, 'data.txt'), 'original\n');
+  git(source, ['add', '.']);
+  git(source, ['-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=disabled-hooks', 'commit', '-q', '-m', 'test: base']);
+  git(base, ['clone', '--bare', '--quiet', source, remote]);
+  git(base, ['--git-dir', remote, 'config', 'uploadpack.allowFilter', 'true']);
+  git(base, ['clone', '--quiet', '--no-checkout', '--filter=tree:0', '--no-local', pathToFileURL(remote).href, target]);
+  writeFileSync(join(target, '.gitignore'), '/.agent-tests/\n'); writeFileSync(join(target, 'data.txt'), 'working\n');
+  const packDir = join(target, '.git/objects/pack');
+  const packs = () => Object.fromEntries(readdirSync(packDir).sort().map(name => [name, readFileSync(join(packDir, name))]));
+  const before = packs(), index = join(target, '.git/index'), hadIndex = existsSync(index);
+  const moduleUrl = new URL('../SCRIPT.mjs', import.meta.url).href;
+  const code = `import {prepareReview,sealReview,checkReview,checkCommit,checkMerge} from ${JSON.stringify(moduleUrl)};
+    const root=${JSON.stringify(target)}, file='.agent-tests/no/revisao.json';
+    const calls=[()=>prepareReview({root,id:'parcial',execution:'prova',scope:['data.txt']}),()=>sealReview(file,{root}),()=>checkReview(file,{root}),()=>checkCommit([file],{root}),()=>checkMerge([file],'refs/heads/main',{root})];
+    process.stdout.write(JSON.stringify(calls.map(call=>{try{call();return 'passed'}catch(error){return error.message}})));`;
+  const run = spawnSync(process.execPath, ['--input-type=module', '-e', code], { cwd: target, env, encoding: 'utf8', timeout: 30000, windowsHide: true });
+  assert.equal(run.status, 0, run.stderr);
+  const messages = JSON.parse(run.stdout);
+  assert.equal(messages.length, 5);
+  for (const message of messages) assert.match(message, /Clone parcial ou remote promisor/);
+  assert.deepEqual(packs(), before);
+  assert.equal(existsSync(index), hadIndex);
+  assert.equal(existsSync(join(target, '.agent-tests/parcial')), false);
+});
+
+test('check-commit nao oculta submodulo por configuracao Git', t => {
+  const f = approved(t, {}, f => {
+    f.git('add', '.');
+    f.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-q', '-m', 'test: base');
+    f.put('src/main.mjs', 'export const value=2;\n'); f.git('add', 'src/main.mjs');
+  }, false);
+  sealReview(f.file, { root: f.root });
+  const object = f.git('rev-parse', 'HEAD').trim();
+  f.git('update-index', '--add', '--cacheinfo', `160000,${object},vendor`);
+  f.git('config', 'diff.ignoreSubmodules', 'all');
+  const index = readFileSync(join(f.root, '.git/index'));
+  assert.throws(() => checkCommit([f.file], { root: f.root }), /modo preparado nao comprovado: vendor/);
+  assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+});
+
 test('alterar evidencia apos a aprovacao invalida o selo', t => {
   const f = approved(t); f.put(f.proof, 'TESTE FALHOU\n');
   assert.throws(() => checkReview(f.file, { root: f.root }), /apos selar/);
@@ -205,6 +660,10 @@ test('desindexação real registra ação e hash físico sem exigir documento lo
     assert.ok(existsSync(join(f.root, 'generated.md')));
     assert.equal(f.git('ls-files', 'generated.md'), '');
     assert.equal(checkReview(f.file, { root: f.root }).status, 'passed');
+    const index = readFileSync(join(f.root, '.git/index')), content = readFileSync(join(f.root, 'generated.md'));
+    assert.equal(checkCommit([f.file], { root: f.root }).status, 'passed');
+    assert.deepEqual(readFileSync(join(f.root, '.git/index')), index);
+    assert.deepEqual(readFileSync(join(f.root, 'generated.md')), content);
   });
 });
 

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

@@ -9,8 +9,10 @@ Confira status, diff, alterações previamente preparadas e identidades efetivas
 com `git var GIT_AUTHOR_IDENT` e `git var GIT_COMMITTER_IDENT`. Siga a regra
 compartilhada `.pbai4devs/rules/git/RULE.md` para identidade, mensagem e assinatura.
 Prepare somente arquivos autorizados e avaliados na revisão da entrega. Após
-preparar o índice, execute `revisar-entrega check` para alterações de implementação;
-o índice deve corresponder aos arquivos testados. Crie o commit somente com
-critérios, documentação e revisão aprovados. Confira autor, committer e mensagem;
+preparar o índice, execute `revisar-entrega check-commit <relatorio>
+[outros-relatorios...]`: todos os arquivos staged devem ter revisão selada.
+Se falhar ou o índice mudar, interrompa e refaça a verificação. Crie o commit
+somente com critérios, documentação e revisão aprovados. Confira autor,
+committer e mensagem;
 não inclua trabalho
 incompleto ou alterações alheias.

package/.pbai4devs/skills/projeto/atualizar-documentacao/SKILL.md

@@ -15,7 +15,9 @@ Reutilize nomes, formatos, decisões, links e estrutura existentes; um documento
 como `ARCHITECTURE.md` pode cumprir o papel de design sem ser renomeado.
 Organize primeiro por índices e links. Não apague, mova ou substitua arquivos
 para padronizá-los. Acrescente apenas fatos comprovados e preserve o conteúdo
-anterior; trate contradições com o usuário antes de editar.
+anterior. Se houver contradição relevante sem solução nas instruções ou
+evidências disponíveis, apresente os fatos e pergunte ao usuário; aguarde a
+resposta antes de editar o documento afetado. Continue tarefas independentes.
 
 Use o [catálogo](../../../templates/README.md) como lista de lacunas, nunca como
 substituto de um documento existente. Crie somente o que a fase e o pedido

package/CHANGELOG.md

@@ -4,6 +4,14 @@ description: Alterações verificáveis por versão do AgentDevKit.
 
 # Changelog
 
+## 0.0.26 — 2026-11-14
+
+- Preserva os bytes do índice nas consultas do gate para os casos suportados e
+  recusa configurações que não consegue verificar com segurança.
+- Exige cobertura e comparação dos arquivos preparados em `check-commit`;
+  bloqueia flags, nomes, modos e transformações não comprovados.
+- Aguarda a decisão antes de editar documentos com contradições não resolvidas.
+
 ## 0.0.25 — 2026-11-14
 
 - Verifica a cobertura e o conteúdo revisado antes de um merge fast-forward;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pathbit/agentdevkit",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "Shared skills, specifications and workflows for AI coding agents.",
   "type": "module",
   "license": "MIT",