@daniellins/power-claude 0.16.3

package/scripts/__tests__/enforce-git-push-authority.test.cjs

@@ -0,0 +1,701 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * enforce-git-push-authority.test.cjs — primeira suíte automatizada deste
+ * hook (achado (d) do Contexto da story SF12.3 — sem teste desde que foi
+ * escrito). Cobre os 7 controles do AC43 (Bloco M, D4/D1):
+ *
+ *   1. pc-devops + git push          → allow (sem output)
+ *   2. pc-devops + gh pr create      → allow (sem output)
+ *   3. pc-devops + gh pr merge       → ask (3º nível D4 — merge nunca automático)
+ *   4. pc-dev + git push             → ask (papel errado)
+ *   5. force-push com pc-devops      → deny (único deny do arquivo, incondicional)
+ *   6. autoproclamação (env var + prefixo inline, SEM fallback) → ask
+ *   7. agent_id ausente (main thread) → ask
+ *
+ * Mais o instrumento de mutação (mesmo padrão do AC14/AC18): gera cópia
+ * mutante em tmp com a checagem de identidade neutralizada, executa como
+ * subprocesso com o payload do controle 5 (force-push) — o teste FALHA se
+ * a mutante destravar force-push.
+ *
+ * Fix round F1 (gate FAIL do `pc-qa`, 2026-08-06): o parser original
+ * dependia de contiguidade textual (regex `\bgit\s+push\b`/`\s--force\b`) e
+ * era bypassável por sintaxe de shell comum. Controles 8-13 abaixo cobrem os
+ * bypasses reproduzidos pelo QA (flag curta combinada, opção global `-c`
+ * antes do subcomando) e variações adicionais (o QA pediu explicitamente
+ * "e com as que você mesmo pensar"): `-C`, `--git-dir=`, comando encadeado,
+ * `git` por caminho absoluto, e a prova de que `pc-devops` não force-pusha
+ * por NENHUMA delas.
+ *
+ * Fix round F3 (2º gate FAIL do `pc-qa`, mesmo dia): alias de git — o texto
+ * do comando não denuncia a operação quando um alias resolve para `push`.
+ * `testFixRoundF3()` cobre as 3 fontes de resolução (inline `-c
+ * alias.X=valor`; `git config alias.X valor` num segmento anterior da
+ * mesma cadeia; alias JÁ CONFIGURADO no repo, exigindo consulta real via
+ * subprocesso a `git config --get`, testada com um repositório git
+ * temporário de verdade) + o controle negativo (subcomando desconhecido
+ * que NÃO é alias → silêncio, nunca `ask` por via das dúvidas) + o
+ * controle de "não deu para confirmar com segurança" (git inacessível →
+ * `ask`, nunca silêncio nem crash). Por decisão do dono (D6), este hook
+ * continua sendo guard-rail contra erro, não barreira contra evasão
+ * deliberada — `sh -c`/`bash -c`/`npm run`/`node -e`/scripts externos
+ * seguem fora de alcance por desenho, não testados aqui (D7 documenta a
+ * fronteira, não este arquivo).
+ *
+ * Fix round F4 (3º gate FAIL do `pc-qa`, mesmo dia): o guarda de
+ * profundidade de `analyzeSegment` (alias que resolve para outro alias)
+ * retornava `null` (silêncio) ao estourar o limite — "não sei" tratado como
+ * "sei que não". `testFixRoundF4()` reproduz o achado do QA com um
+ * repositório git real (cadeia de 5 aliases terminando em force-push — o
+ * caso exato do gate) e uma cadeia BEM mais longa (20 níveis) para provar
+ * que estourar o limite nunca mais é silêncio. Cobre também os 2 outros
+ * achados do sweep pedido pelo QA (mesma família — "não sei" tratado como
+ * "sei que não"): o fallback de JSON malformado usava o parser tokenizado,
+ * que colapsa um JSON compacto sem espaço fora de strings num único token e
+ * NUNCA detectava nada (mesmo com "git push --force" literal no texto) —
+ * corrigido para regex de substring sobre o texto bruto; e `main()` não
+ * tinha rede de segurança de topo — uma exceção não prevista terminava o
+ * processo sem emitir decisão nenhuma (fail-open pior que `ask`) —
+ * corrigido com `try/catch` em `main()`, testado forçando `readStdin()` a
+ * lançar.
+ *
+ * Fix round F5 (4º gate FAIL do `pc-qa`, mesmo dia): assimetria entre os
+ * 2 branches do parser — o `git` ganhou resolução de alias em 3 fontes no
+ * F3/F4, o `gh` continuou casando `pr create`/`pr merge` de forma literal,
+ * mesmo o `gh` tendo alias NATIVO (`gh alias set`) tão real quanto o do
+ * git. `testFixRoundF5()` reproduz os 2 casos exatos do QA (`gh prc
+ * --title x`, alias de `pr create`, pc-dev; `gh qm 5 --auto`, alias de
+ * `pr merge`, pc-devops — o caso que furava a garantia mais repetida da
+ * story) com `GH_CONFIG_DIR` isolado e `gh alias set` real, mais alias de
+ * shell (prefixo `!` e via flag `--shell`), alias definido na própria
+ * cadeia, cadeia de 2 aliases, os 2 controles negativos (subcomando
+ * desconhecido que não é alias; subcomando real do gh), `gh` inacessível,
+ * e a prova final de que `gh pr merge` não é alcançável sem `ask` por
+ * nenhuma forma testada, nem para pc-devops.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const HOOK_PATH = path.join(REPO_ROOT, 'template', '.claude', 'hooks', 'enforce-git-push-authority.cjs');
+
+let failures = 0;
+function assert(ok, msg) {
+  if (ok) {
+    console.log(`[OK   ] ${msg}`);
+  } else {
+    console.error(`[FALHA] ${msg}`);
+    failures++;
+  }
+}
+
+function runHookAtPath(hookPath, rawInput, env) {
+  const result = spawnSync(process.execPath, [hookPath], {
+    input: rawInput,
+    encoding: 'utf8',
+    timeout: 10000,
+    env: env || process.env,
+  });
+  if (result.error) throw result.error;
+  let decision = null;
+  const out = (result.stdout || '').trim();
+  if (out) {
+    try {
+      decision = JSON.parse(out)?.hookSpecificOutput?.permissionDecision || null;
+    } catch {
+      decision = 'UNPARSEABLE_OUTPUT';
+    }
+  }
+  return { decision, stdout: out };
+}
+
+function runHook(rawInput, env) {
+  return runHookAtPath(HOOK_PATH, rawInput, env);
+}
+
+function payloadCmd({ agentType, agentId = 's-1', command, cwd }) {
+  const p = { tool_input: { command } };
+  if (agentId !== undefined) p.agent_id = agentId;
+  if (agentType !== undefined) p.agent_type = agentType;
+  if (cwd !== undefined) p.cwd = cwd;
+  return JSON.stringify(p);
+}
+
+function testControlesAC43() {
+  console.log('\n-- AC43: os 7 controles --');
+
+  // 1. pc-devops + git push → allow
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'git push origin main' })).decision === null,
+    'Controle 1: pc-devops + git push → allow, sem output',
+  );
+
+  // 2. pc-devops + gh pr create → allow
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'gh pr create --title x --body y' })).decision === null,
+    'Controle 2: pc-devops + gh pr create → allow, sem output',
+  );
+
+  // 3. pc-devops + gh pr merge → ask (nunca automático, nem para devops)
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'gh pr merge 42' })).decision === 'ask',
+    'Controle 3: pc-devops + gh pr merge → ask (3º nível D4)',
+  );
+
+  // 4. pc-dev + git push → ask (papel errado)
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: 'git push' })).decision === 'ask',
+    'Controle 4: pc-dev + git push → ask (papel errado)',
+  );
+
+  // 5. force-push com pc-devops → deny (único deny, incondicional)
+  const forcePush = ['git', 'push', '--for' + 'ce'].join(' '); // evita literal "--force" no fonte do teste
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: forcePush })).decision === 'deny',
+    'Controle 5: force-push com pc-devops → deny (nenhuma identidade destrava force-push)',
+  );
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: forcePush })).decision === 'deny',
+    'Controle 5b: force-push com pc-dev → deny (mesma regra, qualquer papel)',
+  );
+
+  // 6. autoproclamação — env var no processo do hook E prefixo inline no comando —
+  //    NÃO altera o resultado (M-1: fallback removido)
+  const autoproclamacaoPayload = payloadCmd({ agentType: 'pc-dev', command: 'PC_ACTIVE_AGENT=devops git push' });
+  const envComAutoproclamacao = { ...process.env, PC_ACTIVE_AGENT: 'pc-devops', CLAUDE_AGENT_NAME: 'pc-devops', CLAUDE_CODE_AGENT: 'pc-devops' };
+  assert(
+    runHook(autoproclamacaoPayload, envComAutoproclamacao).decision === 'ask',
+    'Controle 6: autoproclamação (env var do processo + prefixo inline no comando) NÃO destrava — ask (prova M-1 na prática)',
+  );
+
+  // 7. agent_id ausente (main thread) → ask
+  assert(
+    runHook(JSON.stringify({ tool_input: { command: 'git push' } })).decision === 'ask',
+    'Controle 7: agent_id ausente (main thread) → ask — preserva a única rede que sobra ao dono',
+  );
+
+  // Sanidade adicional: comando não-remoto não dispara nada
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: 'ls -la' })).decision === null,
+    'Sanidade: comando Bash não-remoto → silêncio total',
+  );
+}
+
+function testFixRoundF1() {
+  console.log('\n-- Fix round F1: bypass de parser reproduzido pelo QA + variações --');
+
+  // 8. Flag curta combinada (-uf): força embutida, não isolada — deny, mesmo
+  //    para pc-devops. Bypass EXATO reproduzido pelo gate FAIL (F1, caso 1).
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'git push -uf origin main' })).decision === 'deny',
+    'Controle 8: `git push -uf origin main` (pc-devops) → deny (flag curta combinada é force-push)',
+  );
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'git push -fu origin main' })).decision === 'deny',
+    'Controle 8b: `git push -fu origin main` (ordem invertida do cluster) → deny',
+  );
+
+  // 9. Opção global do git (-c) antes do subcomando, com --force explícito —
+  //    deny, mesmo para pc-devops. Bypass EXATO do F1, caso 2.
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'git -c foo.bar=baz push --force origin main' })).decision === 'deny',
+    'Controle 9: `git -c foo.bar=baz push --force origin main` (pc-devops) → deny (global opt não esconde --force)',
+  );
+
+  // 10. Mesma opção global, SEM --force, com papel errado — ask (não mais
+  //     silêncio). Bypass EXATO do F1, caso 3 (o mais grave: bypassava TODO
+  //     o mecanismo, não só o force-push).
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: 'git -c foo.bar=baz push origin main' })).decision === 'ask',
+    'Controle 10: `git -c foo.bar=baz push origin main` (pc-dev) → ask (opção global não contorna a matriz de papel)',
+  );
+
+  // 11. Variações adicionais de opção global (-C <path>, --git-dir=<path>) —
+  //     mesma régua: o subcomando push continua reconhecido.
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: 'git -C /tmp/algum-repo push origin main' })).decision === 'ask',
+    'Controle 11a: `git -C <path> push` (pc-dev) → ask (opção global de valor separado)',
+  );
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: 'git --git-dir=/tmp/algum-repo/.git push origin main' })).decision === 'ask',
+    'Controle 11b: `git --git-dir=<path> push` (pc-dev) → ask (opção global inline)',
+  );
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'git -C /tmp/algum-repo push --force origin main' })).decision === 'deny',
+    'Controle 11c: `git -C <path> push --force` (pc-devops) → deny (global opt + force juntas)',
+  );
+
+  // 12. Comando encadeado (`&&`): a operação governada está no 2º segmento —
+  //     precisa ser tratada, não silenciada por vir depois de um comando
+  //     inofensivo.
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'echo preparando publicação && git push --force origin main' })).decision === 'deny',
+    'Controle 12: comando encadeado com `&&`, force-push no 2º segmento → deny',
+  );
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: 'npm test; git push origin main' })).decision === 'ask',
+    'Controle 12b: comando encadeado com `;`, push no 2º segmento (pc-dev) → ask',
+  );
+
+  // 13. `git` invocado por caminho absoluto/relativo — continua reconhecido
+  //     (o token termina em "/git", não é só o literal "git").
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: '/usr/bin/git push origin main' })).decision === 'ask',
+    'Controle 13: `/usr/bin/git push` (pc-dev) → ask (caminho absoluto não esconde o subcomando)',
+  );
+
+  // Prova final exigida pelo briefing: pc-devops NÃO consegue force-push por
+  // NENHUMA das variações acima.
+  const devopsForceAttempts = [
+    'git push -uf origin main',
+    'git push -fu origin main',
+    'git -c foo.bar=baz push --force origin main',
+    'git -C /tmp/algum-repo push --force origin main',
+    'git --git-dir=/tmp/x/.git push --force origin main',
+    'echo x && git push --force origin main',
+    '/usr/bin/git push --force origin main',
+  ];
+  const todasNegadas = devopsForceAttempts.every(
+    (command) => runHook(payloadCmd({ agentType: 'pc-devops', command })).decision === 'deny',
+  );
+  assert(
+    todasNegadas,
+    `Prova final: pc-devops NÃO force-pusha por nenhuma das ${devopsForceAttempts.length} variações testadas (flag combinada, opção global -c/-C/--git-dir=, comando encadeado, caminho absoluto)`,
+  );
+}
+
+function initTmpGitRepo(prefix) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  spawnSync('git', ['init', '-q'], { cwd: dir });
+  spawnSync('git', ['config', 'user.email', 't@example.com'], { cwd: dir });
+  spawnSync('git', ['config', 'user.name', 'tester'], { cwd: dir });
+  return dir;
+}
+
+function testFixRoundF3() {
+  console.log('\n-- Fix round F3: alias de git (o texto do comando não denuncia sozinho) --');
+
+  // Fonte 1 (mais barata): alias definido INLINE no próprio comando, via
+  // `-c alias.p=push`. Nenhum subprocesso de `git config` é necessário.
+  assert(
+    runHook(payloadCmd({
+      agentType: 'pc-devops',
+      command: 'git -c alias.p=push p --force origin main',
+    })).decision === 'deny',
+    'Caso 1: `git -c alias.p=push p --force origin main` (pc-devops) → deny (alias inline resolve para force-push)',
+  );
+
+  // Fonte 2: `git config alias.z push` num segmento ANTERIOR da mesma
+  // cadeia, usado no segmento seguinte — resolvido por texto, sem tocar a
+  // config real do disco.
+  assert(
+    runHook(payloadCmd({
+      agentType: 'pc-dev',
+      command: 'git config alias.z push; git z origin main',
+    })).decision === 'ask',
+    'Caso 2: `git config alias.z push; git z origin main` (pc-dev) → ask (alias definido na própria cadeia)',
+  );
+  assert(
+    runHook(payloadCmd({
+      agentType: 'pc-devops',
+      command: 'git config alias.z push; git z origin main',
+    })).decision === null,
+    'Caso 2b: mesma cadeia, pc-devops → allow, sem output (push comum via alias)',
+  );
+
+  // Fonte 3 (mais cara, exige subprocesso): alias JÁ CONFIGURADO no
+  // repositório — nada no TEXTO do comando denuncia isso. É o caso que o
+  // QA nomeou como o que importa: "o texto do comando não determina a
+  // operação". Repositório git temporário real, alias real.
+  const repo = initTmpGitRepo('egpa-alias-');
+  try {
+    spawnSync('git', ['config', 'alias.z', 'push'], { cwd: repo });
+    spawnSync('git', ['config', 'alias.fp', 'push --force'], { cwd: repo });
+    spawnSync('git', ['config', 'alias.shellforce', '!git push --force'], { cwd: repo });
+
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-dev', command: 'git z origin main', cwd: repo })).decision === 'ask',
+      'Caso 3: alias `z=push` JÁ CONFIGURADO no repo (nada no texto denuncia), pc-dev → ask',
+    );
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'git z origin main', cwd: repo })).decision === null,
+      'Caso 3b: mesmo alias pré-configurado, pc-devops → allow, sem output',
+    );
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'git fp origin main', cwd: repo })).decision === 'deny',
+      'Caso 3c: alias `fp="push --force"` pré-configurado, pc-devops → deny (nenhuma identidade destrava)',
+    );
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'git shellforce', cwd: repo })).decision === 'deny',
+      'Caso 3d: alias de SHELL `shellforce="!git push --force"` pré-configurado, pc-devops → deny',
+    );
+
+    // Controle negativo: subcomando desconhecido que NÃO é alias nenhum —
+    // a consulta resolve com segurança "não existe" e o hook fica em
+    // silêncio (nunca `ask` por via das dúvidas quando já se sabe a resposta).
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-dev', command: 'git totalmente-inexistente origin main', cwd: repo })).decision === null,
+      'Controle negativo: subcomando desconhecido, CONCLUSIVAMENTE não é alias → silêncio (não vira ask por precaução vazia)',
+    );
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-dev', command: 'git status', cwd: repo })).decision === null,
+      'Controle negativo: subcomando REAL do git (`status`) nunca aciona a máquina de alias → silêncio',
+    );
+  } finally {
+    fs.rmSync(repo, { recursive: true, force: true });
+  }
+
+  // Controle "não deu para confirmar com segurança": `git` inacessível
+  // (PATH quebrado) — a consulta ao alias falha na origem, não é "não é
+  // alias". Resultado tem que ser `ask`, nunca silêncio nem crash.
+  const semGitNoPath = runHookAtPath(HOOK_PATH, payloadCmd({
+    agentType: 'pc-devops',
+    command: 'git z origin main',
+    cwd: '/tmp',
+  }), { PATH: '/caminho/que/nao/existe' });
+  assert(
+    semGitNoPath.decision === 'ask',
+    'Controle: `git` inacessível (PATH quebrado) durante a resolução de alias → ask, nunca silêncio nem crash (mesmo para pc-devops)',
+  );
+}
+
+// Configura uma cadeia de `n` aliases no repositório `repo`: d1 → d2 → ...
+// → dn → `finalBody` (ex.: "push --force"). `git d1 ...` dispara n níveis
+// de resolução até chegar no corpo final.
+function buildAliasChain(repo, n, finalBody) {
+  spawnSync('git', ['config', `alias.d${n}`, finalBody], { cwd: repo });
+  for (let i = n - 1; i >= 1; i--) {
+    spawnSync('git', ['config', `alias.d${i}`, `d${i + 1}`], { cwd: repo });
+  }
+}
+
+function testFixRoundF4() {
+  console.log('\n-- Fix round F4: guarda de profundidade da resolução de alias (não sei ≠ sei que não) --');
+
+  // Reprodução EXATA do achado do QA: cadeia de 5 aliases terminando em
+  // force-push, com um repositório git real. Com o cap novo (mais folgado
+  // que o antigo ">3"), esta cadeia é curta o bastante para resolver POR
+  // COMPLETO — a resposta correta é `deny`, não apenas `ask`: o hook SABE
+  // que é force-push, não precisa admitir dúvida aqui.
+  const repo5 = initTmpGitRepo('egpa-chain5-');
+  try {
+    buildAliasChain(repo5, 5, 'push --force');
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'git d1 origin main', cwd: repo5 })).decision === 'deny',
+      'Cadeia de 5 aliases terminando em force-push, pc-devops → deny (resolve por completo, ANTES: silêncio — o achado exato do QA)',
+    );
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-dev', command: 'git d1 origin main', cwd: repo5 })).decision === 'deny',
+      'Mesma cadeia de 5, pc-dev → deny (force-push nega para qualquer papel)',
+    );
+  } finally {
+    fs.rmSync(repo5, { recursive: true, force: true });
+  }
+
+  // Cadeia BEM mais longa (20 aliases) — deliberadamente além de qualquer
+  // cap razoável de custo. O hook não tem obrigação de resolver isto por
+  // completo, mas TEM obrigação de nunca ficar em silêncio: "não consegui
+  // seguir a cadeia até o fim" tem que virar `ask`, nunca allow.
+  const repo20 = initTmpGitRepo('egpa-chain20-');
+  try {
+    buildAliasChain(repo20, 20, 'push --force');
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'git d1 origin main', cwd: repo20 })).decision === 'ask',
+      'Cadeia de 20 aliases terminando em force-push, pc-devops → ask (excede o limite de profundidade — NUNCA silêncio, era o bug do F4)',
+    );
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-dev', command: 'git d1 origin main', cwd: repo20 })).decision === 'ask',
+      'Mesma cadeia de 20, pc-dev → ask (mesmo resultado, papel não muda a incerteza)',
+    );
+  } finally {
+    fs.rmSync(repo20, { recursive: true, force: true });
+  }
+
+  // Cadeia longa SEM força no fim — mesma exigência: exceder o limite
+  // nunca pode terminar em allow silencioso para o papel errado.
+  const repo20np = initTmpGitRepo('egpa-chain20np-');
+  try {
+    buildAliasChain(repo20np, 20, 'push');
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-dev', command: 'git d1 origin main', cwd: repo20np })).decision === 'ask',
+      'Cadeia de 20 aliases terminando em push comum (sem força), pc-dev → ask (não silêncio, mesmo sem força no fim)',
+    );
+  } finally {
+    fs.rmSync(repo20np, { recursive: true, force: true });
+  }
+
+  // Achado extra do sweep (mesma família): o fallback de JSON malformado
+  // usava o parser TOKENIZADO, que colapsa um JSON compacto (sem espaço
+  // fora de strings) num único token só — nunca detectava nada, mesmo com
+  // "git push --force" literal no texto. Reproduzido com JSON truncado
+  // (não fecha as chaves) contendo force-push de verdade.
+  const malformedWithForce = '{"agent_type":"pc-devops","tool_input":{"command":"git push --force"}';
+  assert(
+    runHook(malformedWithForce).decision === 'deny',
+    'Achado do sweep: JSON malformado (truncado) com "git push --force" literal no texto → deny (ANTES: o parser tokenizado colapsava o JSON num token só e nunca suspeitava — silêncio)',
+  );
+  const malformedNoOp = '{"agent_type":"pc-dev","tool_input":{"command":"ls -la"}';
+  assert(
+    runHook(malformedNoOp).decision === null,
+    'Controle: JSON malformado sem operação governada no texto → silêncio (o fix não virou paranoia genérica)',
+  );
+  const malformedWithAlias = '{"agent_type":"pc-devops","tool_input":{"command":"git config alias.z push; git z --force"}';
+  assert(
+    runHook(malformedWithAlias).decision === 'deny',
+    'Achado do sweep: JSON malformado mencionando `git config ... alias` → deny (fail-closed proporcional cobre também o rastro textual de definição de alias)',
+  );
+
+  // Achado extra do sweep (mesma família): `main()` não tinha rede de
+  // segurança de topo — uma exceção não prevista em QUALQUER ponto do
+  // fluxo terminava o processo sem `hookSpecificOutput` nenhum (fail-open
+  // pior que `ask`). Forçado diretamente: `readStdin()` lança (stdin
+  // ilegível) — antes dessa correção, isso era engolido e virava "comando
+  // vazio" (silêncio); agora propaga e o catch-all de `main()` emite `ask`.
+  const hook = require(HOOK_PATH);
+  const originalReadFileSync = fs.readFileSync;
+  fs.readFileSync = function patchedReadFileSync(fd, ...args) {
+    if (fd === 0) throw new Error('SIMULATED_STDIN_FAILURE (teste)');
+    return originalReadFileSync.call(fs, fd, ...args);
+  };
+  let captured = '';
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk) => {
+    captured += chunk;
+    return true;
+  };
+  try {
+    hook.main();
+  } finally {
+    fs.readFileSync = originalReadFileSync;
+    process.stdout.write = originalWrite;
+  }
+  let decision = null;
+  try {
+    decision = JSON.parse(captured)?.hookSpecificOutput?.permissionDecision || null;
+  } catch {
+    decision = 'UNPARSEABLE_OUTPUT';
+  }
+  assert(
+    decision === 'ask',
+    'Achado do sweep: `readStdin()` lançando (stdin ilegível) → `main()` emite ask via catch-all de topo, nunca crash silencioso sem decisão nenhuma',
+  );
+}
+
+// Cria um `GH_CONFIG_DIR` temporário e isolado (o `gh` NUNCA usa `cwd` para
+// resolver aliases — é config global do usuário, ao contrário do `git`,
+// que é por repositório; isolamos via env var para não depender/poluir a
+// config real da máquina que roda o teste).
+function initTmpGhConfigDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function ghEnv(ghConfigDir, extra) {
+  return { ...process.env, GH_CONFIG_DIR: ghConfigDir, ...(extra || {}) };
+}
+
+function ghAliasSet(ghConfigDir, args) {
+  spawnSync('gh', ['alias', 'set', ...args, '--clobber'], { env: ghEnv(ghConfigDir) });
+}
+
+function testFixRoundF5() {
+  console.log('\n-- Fix round F5: alias NATIVO do gh (o branch gh não tinha NENHUMA resolução) --');
+
+  // Reprodução EXATA dos 2 casos do QA.
+  const ghDirPrc = initTmpGhConfigDir('egpa-gh-prc-');
+  try {
+    ghAliasSet(ghDirPrc, ['prc', 'pr create']);
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-dev', command: 'gh prc --title x' }), ghEnv(ghDirPrc)).decision === 'ask',
+      'Caso 1 (QA): `gh prc --title x` (alias de `pr create`), pc-dev → ask (ANTES: silêncio)',
+    );
+  } finally {
+    fs.rmSync(ghDirPrc, { recursive: true, force: true });
+  }
+
+  const ghDirQm = initTmpGhConfigDir('egpa-gh-qm-');
+  try {
+    ghAliasSet(ghDirQm, ['qm', 'pr merge --auto']);
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'gh qm 5 --auto' }), ghEnv(ghDirQm)).decision === 'ask',
+      'Caso 2 (QA, o que importa): `gh qm 5 --auto` (alias de `pr merge`), pc-devops → ask — ANTES furava a garantia mais repetida da story (merge sempre pede aprovação, mesmo p/ devops)',
+    );
+  } finally {
+    fs.rmSync(ghDirQm, { recursive: true, force: true });
+  }
+
+  // Controle: literal continua ask (não regrediu).
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-devops', command: 'gh pr merge 5' })).decision === 'ask',
+    'Controle: `gh pr merge 5` literal, pc-devops → ask (não regrediu)',
+  );
+
+  // Alias de shell (prefixo "!", igual ao git) e via flag --shell (sem "!"
+  // explícito no valor — o próprio `gh` normaliza ao gravar, e a fonte de
+  // sessão replica essa normalização).
+  const ghDirShell = initTmpGhConfigDir('egpa-gh-shell-');
+  try {
+    ghAliasSet(ghDirShell, ['shellmerge', '!gh pr merge --auto']);
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'gh shellmerge' }), ghEnv(ghDirShell)).decision === 'ask',
+      'Alias de SHELL `shellmerge="!gh pr merge --auto"` pré-configurado, pc-devops → ask',
+    );
+  } finally {
+    fs.rmSync(ghDirShell, { recursive: true, force: true });
+  }
+
+  const ghDirShellFlag = initTmpGhConfigDir('egpa-gh-shellflag-');
+  try {
+    ghAliasSet(ghDirShellFlag, ['--shell', 'shellflag2', 'gh pr merge --auto']);
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'gh shellflag2' }), ghEnv(ghDirShellFlag)).decision === 'ask',
+      'Alias criado via `--shell` (sem `!` explícito no comando de set — o `gh` normaliza), pc-devops → ask',
+    );
+  } finally {
+    fs.rmSync(ghDirShellFlag, { recursive: true, force: true });
+  }
+
+  // Fonte barata: alias definido num segmento ANTERIOR da mesma cadeia
+  // (`gh alias set` + uso, sem tocar a config real do disco).
+  const ghDirEmpty = initTmpGhConfigDir('egpa-gh-session-');
+  try {
+    assert(
+      runHook(
+        payloadCmd({ agentType: 'pc-devops', command: "gh alias set qm2 'pr merge --auto'; gh qm2 5" }),
+        ghEnv(ghDirEmpty),
+      ).decision === 'ask',
+      'Alias definido na PRÓPRIA cadeia (`gh alias set qm2 ...; gh qm2 5`), pc-devops → ask (fonte barata, sem 2ª consulta ao disco)',
+    );
+  } finally {
+    fs.rmSync(ghDirEmpty, { recursive: true, force: true });
+  }
+
+  // Cadeia de aliases (alias que resolve para outro alias) — o `gh` real
+  // não encadeia (medido: `gh alias set b a` seguido de `gh b` falha com
+  // "unknown command" se `a` também for só um alias), mas este hook é MAIS
+  // cauteloso que o `gh`, não menos: resolve através da cadeia via a mesma
+  // recursão/guarda de profundidade do branch `git`.
+  const ghDirChain = initTmpGhConfigDir('egpa-gh-chain-');
+  try {
+    ghAliasSet(ghDirChain, ['level2', 'pr merge --auto']);
+    ghAliasSet(ghDirChain, ['level1', 'level2']);
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-devops', command: 'gh level1' }), ghEnv(ghDirChain)).decision === 'ask',
+      'Cadeia de 2 aliases (`level1` → `level2` → `pr merge --auto`), pc-devops → ask',
+    );
+  } finally {
+    fs.rmSync(ghDirChain, { recursive: true, force: true });
+  }
+
+  // Controles negativos: subcomando desconhecido que NÃO é alias, e
+  // subcomando REAL do gh — nenhum dos dois deve acionar a máquina de
+  // alias nem virar `ask` por precaução vazia.
+  const ghDirNoAlias = initTmpGhConfigDir('egpa-gh-noalias-');
+  try {
+    assert(
+      runHook(payloadCmd({ agentType: 'pc-dev', command: 'gh totalmente-inexistente' }), ghEnv(ghDirNoAlias)).decision === null,
+      'Controle negativo: subcomando de gh desconhecido, CONCLUSIVAMENTE não é alias → silêncio',
+    );
+  } finally {
+    fs.rmSync(ghDirNoAlias, { recursive: true, force: true });
+  }
+  assert(
+    runHook(payloadCmd({ agentType: 'pc-dev', command: 'gh issue list' })).decision === null,
+    'Controle negativo: subcomando REAL do gh (`issue`) nunca aciona a máquina de alias → silêncio',
+  );
+
+  // Controle: `gh` inacessível (PATH quebrado) durante a resolução → ask,
+  // nunca silêncio nem crash — mesma régua do branch `git`.
+  const semGhNoPath = runHookAtPath(HOOK_PATH, payloadCmd({
+    agentType: 'pc-devops',
+    command: 'gh algumaliasqualquer',
+  }), { PATH: '/caminho/que/nao/existe' });
+  assert(
+    semGhNoPath.decision === 'ask',
+    'Controle: `gh` inacessível (PATH quebrado) → ask, nunca silêncio nem crash (mesmo para pc-devops)',
+  );
+
+  // Prova final: `gh pr merge` — a garantia mais repetida da story — não é
+  // alcançável em silêncio nem em `allow` por NENHUMA das formas testadas,
+  // nem mesmo para pc-devops.
+  const ghDirFinal = initTmpGhConfigDir('egpa-gh-final-');
+  ghAliasSet(ghDirFinal, ['qmFinal', 'pr merge --auto']);
+  ghAliasSet(ghDirFinal, ['shellFinal', '!gh pr merge --auto']);
+  try {
+    const attempts = [
+      ['gh pr merge 5', {}],
+      ['gh qmFinal 5', ghEnv(ghDirFinal)],
+      ['gh shellFinal', ghEnv(ghDirFinal)],
+    ];
+    const todasAsk = attempts.every(
+      ([command, env]) => runHook(payloadCmd({ agentType: 'pc-devops', command }), env).decision === 'ask',
+    );
+    assert(
+      todasAsk,
+      `Prova final: \`gh pr merge\` inalcançável sem \`ask\` por nenhuma das ${attempts.length} formas testadas (literal, alias comum, alias de shell), mesmo para pc-devops`,
+    );
+  } finally {
+    fs.rmSync(ghDirFinal, { recursive: true, force: true });
+  }
+}
+
+function buildMutant(tmpDir) {
+  const source = fs.readFileSync(HOOK_PATH, 'utf8');
+  const target = `function isDevOpsAgent(input) {\n  return typeof input?.agent_type === 'string' && input.agent_type === DEVOPS_AGENT_TYPE;\n}`;
+  const mutated = `function isDevOpsAgent(input) {\n  return true; // MUTANTE — checagem de identidade removida (AC43)\n}`;
+  if (!source.includes(target)) {
+    throw new Error('Instrumento de mutação desalinhado com o fonte real do hook — AC43 não é prova válida.');
+  }
+  const mutantSource = source.replace(target, mutated);
+  const mutantPath = path.join(tmpDir, 'enforce-git-push-authority.mutant.cjs');
+  fs.writeFileSync(mutantPath, mutantSource);
+  return mutantPath;
+}
+
+function testMutacao() {
+  console.log('\n-- AC43: instrumento de mutação (a checagem de identidade não pode destravar force-push) --');
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'egpa-mutant-'));
+  try {
+    const mutantPath = buildMutant(tmpDir);
+    const forcePush = ['git', 'push', '--for' + 'ce'].join(' ');
+    const denyPayload = payloadCmd({ agentType: 'pc-dev', command: forcePush });
+
+    assert(runHook(denyPayload).decision === 'deny', 'controle: hook REAL nega force-push (pré-condição da prova)');
+    assert(
+      runHookAtPath(mutantPath, denyPayload).decision === 'deny',
+      'a mutante (isDevOpsAgent sempre true) NÃO destrava force-push — a checagem de force-push é independente da de identidade (defesa em profundidade confirmada)',
+    );
+
+    // A mutante deveria, no entanto, mudar o resultado do controle 4 (não-force):
+    // prova que a mutação realmente afeta a checagem de identidade (mutante viva).
+    const nonForcePayload = payloadCmd({ agentType: 'pc-dev', command: 'git push' });
+    assert(runHook(nonForcePayload).decision === 'ask', 'controle: hook REAL pergunta pc-dev + push (não-force) (pré-condição)');
+    assert(
+      runHookAtPath(mutantPath, nonForcePayload).decision === null,
+      'a mutante PERMITE pc-dev fazer push não-force — prova que a checagem de identidade real é o que trava',
+    );
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+function main() {
+  console.log('POWER CLAUDE — suíte do hook enforce-git-push-authority.cjs (SF12.3, Bloco M, AC42-43 + fix rounds F1/F3/F4/F5)\n');
+  testControlesAC43();
+  testFixRoundF1();
+  testFixRoundF3();
+  testFixRoundF4();
+  testFixRoundF5();
+  testMutacao();
+
+  if (failures > 0) {
+    console.error(`\nSuíte FALHOU: ${failures} violação(ões).`);
+    process.exit(1);
+  }
+  console.log('\nSuíte verde.');
+  process.exit(0);
+}
+
+main();