@daniellins/power-claude 0.16.3

package/template/.claude/hooks/enforce-git-push-authority.cjs

@@ -0,0 +1,925 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * POWER CLAUDE — PreToolUse hook: autoridade de publicação remota (git/GitHub).
+ *
+ * Regras (D4, 3 níveis de autoridade — story SF12.3, Bloco M):
+ *  1. Force-push é SEMPRE negado, para qualquer agente, incondicionalmente
+ *     (guardrail do ambiente — a única operação irreversível deste hook).
+ *  2. `git push` (sem `--force`) / `gh pr create`:
+ *     - permitidos, sem output, se `input.agent_type === "pc-devops"`;
+ *     - caso contrário, exigem aprovação humana explícita ("ask").
+ *  3. `gh pr merge`: **`ask` sempre, para TODO agente, sem exceção — inclusive
+ *     devops.** Merge em `main` espera aprovação humana explícita como regra
+ *     permanente (decisão do dono, D4); isto NÃO muda com este hook.
+ *  4. Identidade: `input.agent_type`, o `subagent_type` literal do despacho
+ *     (ex. "pc-devops") — MEDIDO (não deduzido), ver AC41 da story SF12.3.
+ *     SEM fallback a variáveis de ambiente: `PC_ACTIVE_AGENT` /
+ *     `CLAUDE_AGENT_NAME` / `CLAUDE_CODE_AGENT` não existem no produto (0
+ *     ocorrências no binário da plataforma) e `.claude/settings.json` tem
+ *     chave `env` que alcança subprocessos — mantê-las como fonte
+ *     reabriria a autoproclamação que este hook existe para fechar (o
+ *     `@dev` que edita `settings.json` poderia se autoproclamar devops).
+ *     `agent_type` não é escrevível pelo agente. `input.agent_id` ausente
+ *     (não vazio) identifica o main thread — tratado como identidade
+ *     ambígua, nunca como devops.
+ *  5. Input malformado bloqueia apenas comandos que aparentem ser de push,
+ *     não qualquer Bash (fail-closed proporcional).
+ *  6. Robustez: `input.agent_type` pode estar AUSENTE (main thread) — nenhum
+ *     método de string é chamado sobre ele sem checar presença antes; um
+ *     `TypeError` faria o hook não emitir decisão nenhuma (fail-open
+ *     silencioso, pior que qualquer `ask`).
+ *
+ * Reconhecimento de comando (fix round F1, story SF12.3 — gate FAIL do
+ * `pc-qa` em 2026-08-06): o desenho ANTERIOR enumerava sintaxe por regex de
+ * contiguidade textual (`\bgit\s+push\b[^|;&]*\s--force\b` etc.) — bypassável
+ * por sintaxe de shell corriqueira e não-adversarial: flags curtas
+ * combinadas (`-uf`) e opções globais do git antes do subcomando
+ * (`git -c user.name=x push`). Enumeração de sintaxe shell não converge (
+ * sempre existe uma variante a mais). Este arquivo RECONHECE A OPERAÇÃO em
+ * vez de enumerar formas perigosas: tokeniza o comando (respeitando aspas),
+ * separa comandos encadeados (`;`, `&&`, `||`, `|`, quebra de linha) em
+ * segmentos independentes, localiza o token `git`/`gh` (ou `.../git`,
+ * `.../gh` — caminho absoluto/relativo), pula as opções GLOBAIS conhecidas
+ * do git (`-c`, `-C`, `--git-dir[=]`, `--work-tree[=]`, `--namespace[=]`,
+ * `--exec-path[=]`, `--super-prefix[=]`, `--config-env[=]`, e flags globais
+ * sem argumento) até achar o SUBCOMANDO real, e só então classifica as
+ * flags do subcomando. Para força: `--force`/`--force-with-lease`/
+ * `--force-if-includes` (com ou sem `=valor`) OU qualquer flag curta em
+ * CLUSTER que contenha `f` isolado (`-uf`, `-fu`, `-f`, ...) — a única
+ * forma de errar para o lado seguro é tratar cedo demais como força, nunca
+ * tarde demais.
+ *
+ * ALIAS de git (fix round F3, story SF12.3 — gate FAIL do `pc-qa` em
+ * 2026-08-06): um subcomando de git pode ser um ALIAS configurado — o texto
+ * do comando sozinho não denuncia isso (`git z origin main` não parece push
+ * nenhum se `alias.z = push` estiver na config do repo, estado EXTERNO ao
+ * comando). Quando o subcomando encontrado não é um subcomando conhecido do
+ * git (`KNOWN_GIT_SUBCOMMANDS`), este hook tenta resolvê-lo como alias, em
+ * 3 fontes, da mais barata para a mais cara: (1) `-c alias.<nome>=<valor>`
+ * no PRÓPRIO comando; (2) `git config alias.<nome> <valor>` num segmento
+ * ANTERIOR do mesmo comando encadeado; (3) `git config --get alias.<nome>`
+ * consultando a config real do repositório (`input.cwd`), via subprocesso
+ * síncrono com timeout curto — só chamado quando as 2 fontes baratas não
+ * resolveram, e nunca para subcomandos já reconhecidos (custo comum ~0).
+ * O valor resolvido é reexpandido e reanalisado (alias de alias tem um
+ * limite de profundidade). Alias de shell (`!git push --force`) é resolvido
+ * antes de classificar. **Se a consulta em si falhar** (não confundir com
+ * "não é alias" — `git config --get` retorna exit 1 quando a chave não
+ * existe, e isto É uma resposta conclusiva, não uma falha) — timeout,
+ * `git` ausente, erro inesperado — o resultado é `ask`, nunca silêncio.
+ *
+ * Limitação DECLARADA, não implícita (mesma régua do AC10/AC12/AC15 —
+ * "um AC nunca promete mais do que o instrumento entrega", D7 do dono):
+ * este hook é guard-rail contra ERRO, não barreira contra evasão
+ * deliberada. Ele NÃO resolve substituição de comando (`$(...)`, crase),
+ * expansão de variável cujo valor contém o comando (`$CMD` onde
+ * `CMD="git push --force"`), nem indireção por `sh -c`/`bash -c`/
+ * `eval`/`npm run`/`node -e`/scripts externos (`./deploy.sh`) que por sua
+ * vez rodem git — qualquer um desses contorna o hook por desenho, decisão
+ * do dono (perseguir essas variantes não converge e não é o problema que
+ * este hook resolve). Comandos encadeados por `;`/`&&`/`||`/`|` OU por
+ * quebra de linha SÃO tratados (cada segmento é analisado de forma
+ * independente). Dentro do que este hook SE PROPÕE a cobrir (a forma
+ * direta de `git`/`gh`, incluindo alias), na dúvida ele nunca decide por
+ * silêncio: ou reconhece a operação (e classifica), ou não reconhece nada
+ * (silêncio é aceitável SÓ quando não há `git`/`gh` reconhecível no
+ * comando, ou quando um subcomando desconhecido foi CONCLUSIVAMENTE
+ * resolvido como "não é alias").
+ *
+ * Fix round F4 (story SF12.3 — 3º gate FAIL do `pc-qa`, mesmo dia do F3):
+ * o guarda de profundidade da resolução de alias (`ALIAS_MAX_DEPTH`)
+ * retornava `null` (silêncio) ao estourar o limite — "não consegui
+ * resolver a cadeia" tratado como se fosse "sei que não é push", a MESMA
+ * classe de defeito de F1 (regex não cobria sintaxe) e da falha de
+ * identidade que motivou o design deste hook: confiança indevida
+ * disfarçada de resposta conclusiva. Corrigido para `{kind:
+ * 'unresolved-alias'}` → `ask`. Nesta rodada, TODO caminho de saída
+ * silenciosa do arquivo foi varrido e classificado (ver Dev Agent Record
+ * da story para a lista completa); 2 outros achados da MESMA família
+ * foram corrigidos no mesmo round: (1) o fallback de JSON malformado
+ * (`rawTextSuspectsGovernedOperation`) reusava o parser tokenizado, que
+ * colapsa um JSON compacto (sem espaço fora de strings) num único token —
+ * o fallback NUNCA detectava nada, mesmo com "git push --force" literal
+ * no texto; corrigido para regex de substring sobre o texto bruto; (2)
+ * `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 emitir
+ * `hookSpecificOutput` nenhum, que a plataforma trata como fail-open
+ * (pior que `ask`); adicionado `try/catch` em `main()` que converte
+ * QUALQUER exceção não tratada em `ask`. `readStdin()` deixou de engolir
+ * sua própria exceção (antes disfarçava falha de leitura como "comando
+ * vazio" = silêncio) — agora propaga para essa rede de segurança.
+ *
+ * ALIAS de `gh` (fix round F5, story SF12.3 — 4º gate FAIL do `pc-qa`,
+ * mesmo dia): assimetria entre os 2 branches — 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 (medido: `gh alias set qm 'pr merge
+ * --auto'` faz `gh qm` executar `pr merge --auto`; `gh alias set --shell`
+ * embute shell da mesma forma que o `!` do git). O branch `gh` agora usa a
+ * MESMA disciplina do `git`, com a lógica de expansão/recursão/guarda de
+ * profundidade COMPARTILHADA entre os 2 branches (`expandResolvedAliasAndRecurse`)
+ * — só a forma de CONSULTAR alias difere, porque as ferramentas diferem:
+ * o `git` tem consulta por nome exata (`git config --get alias.<nome>`,
+ * exit 1 = "não existe", resposta conclusiva por chave); o `gh` só expõe
+ * `gh alias list` (lista tudo, sem consulta por nome) — este hook chama
+ * essa lista NO MÁXIMO 1 VEZ por invocação (cacheada em `ctx.ghAliasCache`,
+ * mesmo com múltiplos subcomandos desconhecidos na mesma cadeia) e procura
+ * o nome no resultado; qualquer código de saída ≠ 0 (config corrompida,
+ * `gh` ausente, timeout) é tratado como "não deu para confirmar" → `ask` —
+ * a lista de `gh` não tem o mesmo sinal limpo de "exit 1 = não existe" que
+ * o `git config --get` tem (medido: config corrompida também sai com
+ * exit 1), então SÓ exit 0 com saída parseável conta como resposta
+ * conclusiva. 2 fontes (não 3): não existe equivalente do `-c
+ * alias.X=valor` inline do git para `gh` (a ferramenta não tem esse
+ * mecanismo — assimetria INERENTE, declarada, não uma lacuna) — mas
+ * `gh alias set <nome> <valor> [--shell]` num segmento ANTERIOR da mesma
+ * cadeia é capturado (fonte barata), e a consulta real via `gh alias list`
+ * fecha o resto. Verificado empiricamente e DESCARTADO como risco: `gh`
+ * recusa criar alias com nome de comando real ("already a gh command or
+ * extension") — não há como um alias sombrear `pr`/`issue`/etc., mesma
+ * garantia já confirmada para o `git`.
+ *
+ * Sem dependências externas além do próprio `git`/`gh` (só chamados para
+ * resolver alias — roda em qualquer instalação limpa mesmo sem `git`/`gh`
+ * no PATH: nesse caso a consulta falha e o resultado é `ask`, não crash).
+ */
+
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const DEVOPS_AGENT_TYPE = 'pc-devops';
+
+// Opções GLOBAIS do git que tomam um valor em token SEPARADO (quando não
+// usadas na forma `--opcao=valor`). Fonte: `git help` (seção OPTIONS).
+const GIT_GLOBAL_OPTS_WITH_ARG = new Set([
+  '-c',
+  '-C',
+  '--exec-path',
+  '--git-dir',
+  '--work-tree',
+  '--namespace',
+  '--super-prefix',
+  '--config-env',
+  '--html-path',
+  '--man-path',
+  '--info-path',
+]);
+
+// gh: opções globais mais comuns que tomam valor em token separado.
+const GH_GLOBAL_OPTS_WITH_ARG = new Set(['-R', '--repo', '--hostname']);
+
+// Subcomandos REAIS do git (porcelana + os plumbing mais comuns) — lista de
+// custo, não de correção: um subcomando fora desta lista dispara a
+// resolução de alias (barata primeiro, subprocesso só se preciso); um
+// subcomando real que falte aqui só custa 1 consulta extra de config (que
+// resolve "não é alias" e segue em silêncio), nunca um resultado errado.
+const KNOWN_GIT_SUBCOMMANDS = new Set([
+  'add', 'am', 'apply', 'archive', 'bisect', 'blame', 'branch', 'bundle',
+  'cat-file', 'checkout', 'cherry-pick', 'citool', 'clean', 'clone', 'commit',
+  'config', 'count-objects', 'describe', 'diff', 'difftool', 'fetch',
+  'filter-branch', 'format-patch', 'fsck', 'gc', 'grep', 'gui', 'help',
+  'init', 'instaweb', 'log', 'ls-files', 'ls-remote', 'ls-tree',
+  'maintenance', 'merge', 'mergetool', 'mv', 'notes', 'pull', 'push',
+  'range-diff', 'rebase', 'reflog', 'remote', 'repack', 'replace',
+  'request-pull', 'reset', 'restore', 'rev-list', 'rev-parse', 'revert',
+  'rm', 'send-email', 'shortlog', 'show', 'sparse-checkout', 'stash',
+  'status', 'submodule', 'switch', 'tag', 'update-index', 'var',
+  'verify-commit', 'verify-tag', 'version', 'whatchanged', 'worktree',
+]);
+
+// Subcomandos REAIS do `gh` (fonte: `gh --help`, seções CORE/GITHUB
+// ACTIONS/ADDITIONAL COMMANDS + `help`) — mesma régua de custo do
+// `KNOWN_GIT_SUBCOMMANDS`: um subcomando fora desta lista dispara a
+// resolução de alias; um subcomando real que falte aqui só custa 1
+// consulta extra a `gh alias list` (que resolve "não é alias" e segue em
+// silêncio), nunca um resultado errado. `co` (o alias nativo que o `gh`
+// já vem com por padrão) NÃO entra aqui de propósito — é um alias, não um
+// subcomando, e precisa cair no caminho de resolução.
+const KNOWN_GH_SUBCOMMANDS = new Set([
+  'auth', 'browse', 'codespace', 'discussion', 'gist', 'issue', 'org', 'pr',
+  'project', 'release', 'repo', 'skill', 'cache', 'run', 'workflow',
+  'agent-task', 'alias', 'api', 'attestation', 'completion', 'config',
+  'copilot', 'extension', 'gpg-key', 'label', 'licenses', 'preview',
+  'ruleset', 'search', 'secret', 'ssh-key', 'status', 'variable', 'help',
+]);
+
+// Sem try/catch aqui de propósito (fix round F4): se a leitura de stdin
+// falhar, isso é "não sei o que o comando é", não "não há comando" — a
+// exceção propaga e é pega pelo catch-all de `main()`, que emite `ask`.
+// Engolir o erro aqui e devolver '' faria `parseInput` produzir `{}`
+// (JSON válido, vazio) em vez de sinalizar falha — silêncio disfarçado de
+// "não há operação", exatamente o padrão que este round existe para fechar.
+function readStdin() {
+  return fs.readFileSync(0, 'utf8');
+}
+
+function parseInput(rawInput) {
+  try {
+    const parsed = JSON.parse(rawInput || '{}');
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// Separa comandos encadeados por `;`, `&&`, `||`, `|` e quebra de linha,
+// respeitando aspas (não separa dentro de uma string entre aspas).
+function splitSegments(command) {
+  const segments = [];
+  let current = '';
+  let quote = null;
+  const str = String(command || '');
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    const next = str[i + 1];
+    if (quote) {
+      current += ch;
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === '\n' || ch === '\r') {
+      segments.push(current);
+      current = '';
+      continue;
+    }
+    if (ch === ';') {
+      segments.push(current);
+      current = '';
+      continue;
+    }
+    if (ch === '&' && next === '&') {
+      segments.push(current);
+      current = '';
+      i++;
+      continue;
+    }
+    if (ch === '|' && next === '|') {
+      segments.push(current);
+      current = '';
+      i++;
+      continue;
+    }
+    if (ch === '|') {
+      segments.push(current);
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+  segments.push(current);
+  return segments;
+}
+
+// Tokeniza um segmento por espaço em branco, respeitando aspas (o conteúdo
+// entre aspas vira 1 token, sem as aspas em si). Não expande `\` como
+// escape — suficiente para localizar subcomando e flags, não para executar.
+function tokenize(segment) {
+  const tokens = [];
+  let current = '';
+  let quote = null;
+  let has = false;
+  const str = String(segment || '');
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      has = true;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      has = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (has) {
+        tokens.push(current);
+        current = '';
+        has = false;
+      }
+      continue;
+    }
+    current += ch;
+    has = true;
+  }
+  if (has) tokens.push(current);
+  return tokens;
+}
+
+function isGitToken(tok) {
+  return tok === 'git' || tok.endsWith('/git');
+}
+
+function isGhToken(tok) {
+  return tok === 'gh' || tok.endsWith('/gh');
+}
+
+// A partir do índice do token "git", pula as opções GLOBAIS conhecidas e
+// retorna { subcommand, index } do primeiro token que não é uma opção
+// global — ou null se só houver opções/nada depois de "git". Se
+// `inlineAliases` (Map) for passado, toda opção `-c alias.<nome>=<valor>`
+// encontrada no caminho é registrada nele — fonte MAIS BARATA de resolução
+// de alias, o próprio comando já carrega a definição.
+function findGitSubcommand(tokens, gitIndex, inlineAliases) {
+  let i = gitIndex + 1;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (!tok.startsWith('-')) {
+      return { subcommand: tok, index: i };
+    }
+    const eqIdx = tok.indexOf('=');
+    const base = eqIdx === -1 ? tok : tok.slice(0, eqIdx);
+    if (GIT_GLOBAL_OPTS_WITH_ARG.has(base)) {
+      // `--opcao=valor` consome só este token; `-c valor`/`-C valor` (forma
+      // separada) consome este token + o próximo.
+      let value;
+      if (eqIdx === -1) {
+        value = tokens[i + 1];
+        i += 2;
+      } else {
+        value = tok.slice(eqIdx + 1);
+        i += 1;
+      }
+      if (base === '-c' && inlineAliases && typeof value === 'string') {
+        const aliasMatch = /^alias\.([^=\s]+)=([\s\S]*)$/.exec(value);
+        if (aliasMatch) inlineAliases.set(aliasMatch[1], aliasMatch[2]);
+      }
+      continue;
+    }
+    // Qualquer outra flag (global conhecida sem argumento, ou desconhecida)
+    // é tratada como flag isolada — nunca interrompe a busca do subcomando.
+    i += 1;
+  }
+  return null;
+}
+
+// Ache o PRÓXIMO token não-flag em `tokens` a partir de `fromIndex`
+// (exclusivo), pulando as opções GLOBAIS conhecidas do `gh`
+// (`GH_GLOBAL_OPTS_WITH_ARG`) — espelha `findGitSubcommand`, mas devolve
+// só 1 token por vez (chamado 2x em sequência p/ achar "pr" + o verbo, ou
+// 2x p/ achar "alias" + "set" — ver `analyzeSegment`/`collectGhSessionAliases`).
+function findNextGhToken(tokens, fromIndex) {
+  let i = fromIndex + 1;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (!tok.startsWith('-')) {
+      return { token: tok, index: i };
+    }
+    const eqIdx = tok.indexOf('=');
+    const base = eqIdx === -1 ? tok : tok.slice(0, eqIdx);
+    if (GH_GLOBAL_OPTS_WITH_ARG.has(base)) {
+      i += eqIdx === -1 ? 2 : 1;
+      continue;
+    }
+    i += 1;
+  }
+  return null;
+}
+
+const FORCE_LONG_FLAGS = new Set(['--force', '--force-with-lease', '--force-if-includes']);
+
+// Token de flag do subcomando `push` que representa força — forma longa
+// (com ou sem `=valor`) ou cluster de flags curtas contendo `f` isolado
+// (`-uf`, `-fu`, `-f`; nunca `-4`/`--foo`, que não são clusters de letras).
+function isForceFlagToken(tok) {
+  if (!tok.startsWith('-')) return false;
+  if (tok.startsWith('--')) {
+    const eqIdx = tok.indexOf('=');
+    const base = eqIdx === -1 ? tok : tok.slice(0, eqIdx);
+    return FORCE_LONG_FLAGS.has(base);
+  }
+  const rest = tok.slice(1);
+  if (rest.length > 0 && /^[a-zA-Z]+$/.test(rest)) {
+    return rest.includes('f');
+  }
+  return false;
+}
+
+// Consulta `git config --get alias.<nome>` no repositório de `cwd` — a
+// fonte MAIS CARA de resolução de alias do `git` (subprocesso síncrono),
+// só chamada quando as 2 fontes baratas (inline `-c`, `git config alias.X`
+// num segmento anterior) não resolveram. Timeout curto, sem stdin aberto.
+//
+// Retorna:
+//   { status: 'found', value }  — alias existe, `value` é o corpo (pode
+//                                 começar com "!" — alias de shell).
+//   { status: 'not-alias' }     — CONCLUSIVO: `git config --get` rodou e
+//                                 respondeu "chave não existe" (exit 1).
+//                                 Isto não é falha de consulta, é resposta.
+//   { status: 'error' }         — a consulta em si não pôde ser feita com
+//                                 segurança (git ausente, timeout, exit
+//                                 code inesperado) — NÃO É "não é alias".
+function resolveGitAliasFromDisk(name, cwd) {
+  try {
+    const result = spawnSync('git', ['config', '--get', `alias.${name}`], {
+      cwd: cwd || process.cwd(),
+      encoding: 'utf8',
+      timeout: 800,
+      input: '',
+    });
+    if (result.error) {
+      return { status: 'error' };
+    }
+    if (result.status === 0) {
+      const value = (result.stdout || '').replace(/\r?\n$/, '');
+      return value ? { status: 'found', value } : { status: 'not-alias' };
+    }
+    if (result.status === 1) {
+      // `git config --get` retorna 1 quando a chave não existe — resolvido
+      // COM SEGURANÇA que NÃO é alias, mesmo fora de um repositório git
+      // (medido: mesmo comportamento dentro/fora de repo, sem stderr).
+      return { status: 'not-alias' };
+    }
+    // Qualquer outro código de saída (config corrompida, permissão etc.) —
+    // não deu para confirmar com segurança.
+    return { status: 'error' };
+  } catch {
+    return { status: 'error' };
+  }
+}
+
+// Varre TODOS os segmentos do comando encadeado procurando
+// `git config alias.<nome> <valor...>` (ou `--global`/`--local`/etc. antes
+// da chave) — a 2ª fonte barata: o comando pode definir o alias num
+// segmento e usá-lo no seguinte (`git config alias.z push; git z origin
+// main`), sem que a config real do disco precise ser consultada.
+function collectSessionAliases(segments) {
+  const aliases = new Map();
+  for (const segment of segments) {
+    const tokens = tokenize(segment);
+    const gitIndex = tokens.findIndex(isGitToken);
+    if (gitIndex === -1) continue;
+    const found = findGitSubcommand(tokens, gitIndex, aliases /* também captura -c alias.* */);
+    if (!found || found.subcommand !== 'config') continue;
+    const rest = tokens.slice(found.index + 1);
+    let idx = 0;
+    while (idx < rest.length && rest[idx].startsWith('-')) idx++;
+    const keyTok = rest[idx];
+    if (!keyTok) continue;
+    const eqIdx = keyTok.indexOf('=');
+    const keyBase = eqIdx === -1 ? keyTok : keyTok.slice(0, eqIdx);
+    const aliasMatch = /^alias\.([^\s]+)$/.exec(keyBase);
+    if (!aliasMatch) continue;
+    const aliasName = aliasMatch[1];
+    const value = eqIdx !== -1 ? keyTok.slice(eqIdx + 1) : rest.slice(idx + 1).join(' ');
+    if (aliasName && value) aliases.set(aliasName, value);
+  }
+  return aliases;
+}
+
+// Parseia a saída de `gh alias list` (`<nome>: <valor>\n`, um por linha;
+// valores de alias de shell vêm entre aspas simples, ex.: `x: '!gh pr
+// merge'` — medido em `gh version 2.96.0`). Desembrulha as aspas só quando
+// o conteúdo interno começa com `!` (o único caso em que o `gh` as usa).
+function parseGhAliasListOutput(text) {
+  const map = new Map();
+  const lines = String(text || '').split(/\r?\n/);
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const idx = line.indexOf(': ');
+    if (idx === -1) continue;
+    const name = line.slice(0, idx);
+    let value = line.slice(idx + 2);
+    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+      const inner = value.slice(1, -1);
+      if (inner.startsWith('!')) value = inner;
+    }
+    if (name) map.set(name, value);
+  }
+  return map;
+}
+
+// Consulta `gh alias list` — a fonte MAIS CARA de resolução de alias do
+// `gh` (subprocesso síncrono). Diferente do `git config --get` (consulta
+// por CHAVE exata, com exit 1 = "não existe" como sinal limpo), o `gh` só
+// expõe "listar tudo" — então este hook lista 1 VEZ por invocação inteira
+// (cacheada em `cache`, um objeto `{ loaded, map, failed }` que vive em
+// `ctx` e é reaproveitado por QUALQUER subcomando desconhecido encontrado
+// na mesma cadeia, mesmo através de recursão de alias) e procura o nome no
+// resultado. Medido: config corrompida do `gh` também sai com exit ≠ 0 —
+// sem o sinal limpo do git, então aqui SÓ exit 0 com saída parseável conta
+// como resposta conclusiva; qualquer outro desfecho é "não deu para
+// confirmar", nunca "não é alias".
+function resolveGhAliasFromDisk(name, cwd, cache) {
+  if (!cache.loaded) {
+    cache.loaded = true;
+    try {
+      const result = spawnSync('gh', ['alias', 'list'], {
+        cwd: cwd || process.cwd(),
+        encoding: 'utf8',
+        timeout: 800,
+        input: '',
+      });
+      if (result.error || result.status !== 0) {
+        cache.failed = true;
+      } else {
+        cache.map = parseGhAliasListOutput(result.stdout);
+      }
+    } catch {
+      cache.failed = true;
+    }
+  }
+  if (cache.failed || !cache.map) {
+    return { status: 'error' };
+  }
+  return cache.map.has(name) ? { status: 'found', value: cache.map.get(name) } : { status: 'not-alias' };
+}
+
+// Varre TODOS os segmentos do comando encadeado procurando `gh alias set
+// <nome> <valor...> [--shell|-s]` — a única fonte barata do `gh` (não há
+// equivalente do `-c alias.X=valor` inline do git; a ferramenta não tem
+// esse mecanismo — assimetria INERENTE entre as 2 ferramentas, não uma
+// lacuna deste hook). `--shell`/`-s` sem `!` explícito no valor é
+// normalizado para `!<valor>` — o próprio `gh` faz essa normalização ao
+// gravar (medido: `gh alias set --shell x 'gh pr merge'` grava `x: '!gh pr
+// merge'`), então replicamos aqui para a fonte de sessão bater com a fonte
+// de disco.
+function collectGhSessionAliases(segments) {
+  const aliases = new Map();
+  for (const segment of segments) {
+    const tokens = tokenize(segment);
+    const ghIndex = tokens.findIndex(isGhToken);
+    if (ghIndex === -1) continue;
+    const first = findNextGhToken(tokens, ghIndex);
+    if (!first || first.token !== 'alias') continue;
+    const second = findNextGhToken(tokens, first.index);
+    if (!second || second.token !== 'set') continue;
+    const rest = tokens.slice(second.index + 1);
+    let nameIdx = -1;
+    for (let i = 0; i < rest.length; i++) {
+      if (!rest[i].startsWith('-')) {
+        nameIdx = i;
+        break;
+      }
+    }
+    if (nameIdx === -1) continue;
+    const aliasName = rest[nameIdx];
+    let isShell = false;
+    const valueParts = [];
+    for (const tok of rest.slice(nameIdx + 1)) {
+      if (tok === '--shell' || tok === '-s') {
+        isShell = true;
+        continue;
+      }
+      if (tok.startsWith('-')) continue; // outras flags (ex.: --clobber) ignoradas
+      valueParts.push(tok);
+    }
+    let value = valueParts.join(' ').trim();
+    if (!value) continue;
+    if (isShell && !value.startsWith('!')) value = `!${value}`;
+    if (aliasName) aliases.set(aliasName, value);
+  }
+  return aliases;
+}
+
+// Limite de profundidade de resolução de alias (alias que resolve para
+// outro alias, encadeado). NÃO é uma medida de segurança — é um limite de
+// CUSTO (cada nível não resolvido por fonte barata paga 1 subprocesso). Uma
+// cadeia real de aliases encadeados raramente passa de 2-3 níveis; 8 é
+// generoso o bastante para nunca incomodar uso legítimo, e qualquer cadeia
+// que o exceda é tratada como "não sei", nunca como "não é" (fix round F4
+// — ver `analyzeSegment`).
+const ALIAS_MAX_DEPTH = 8;
+
+// Expande um alias RESOLVIDO (`resolvedValue`, o corpo — pode começar com
+// "!" para alias de shell) + os tokens que seguiam o nome do alias no
+// comando original (`trailingTokens`), e reanalisa recursivamente —
+// COMPARTILHADO entre o branch `git` e o branch `gh` (fix round F5: antes
+// desta unificação, só o `git` tinha esta lógica, e o `gh` não tinha
+// NENHUMA resolução de alias — a assimetria que o F5 corrige). `tool` é
+// `'git'` ou `'gh'`, usado só para reconstruir o prefixo do comando quando
+// o alias NÃO é de shell (`git <corpo> <trailing>` / `gh <corpo>
+// <trailing>`); alias de shell já é um comando completo, sem prefixo.
+function expandResolvedAliasAndRecurse(tool, resolvedValue, trailingTokens, ctx, currentDepth) {
+  const body = String(resolvedValue).trim();
+  const expandedCommand = body.startsWith('!')
+    ? `${body.slice(1)} ${trailingTokens.join(' ')}`
+    : `${tool} ${body} ${trailingTokens.join(' ')}`;
+  return analyzeSegment(expandedCommand, ctx, currentDepth + 1);
+}
+
+// Analisa um único segmento (já sem `;`/`&&`/`||`/`|`) e retorna a operação
+// reconhecida, ou null se nenhuma operação governada for encontrada.
+// `ctx` = { cwd, gitSessionAliases, ghSessionAliases, ghAliasCache } —
+// construído 1x por `findGovernedOperation` e reaproveitado por TODOS os
+// segmentos e níveis de recursão da mesma invocação (é isto que garante
+// que `gh alias list` seja chamado no máximo 1 vez por invocação inteira,
+// não 1x por subcomando desconhecido encontrado).
+//   { kind: 'force-push' }
+//   { kind: 'git-push' }
+//   { kind: 'gh-pr-create' }
+//   { kind: 'gh-pr-merge' }
+//   { kind: 'unresolved-alias' } — subcomando (git OU gh) desconhecido, e a
+//                                  tentativa de resolvê-lo como alias não
+//                                  pôde ser concluída com segurança (ver
+//                                  AC/D6), OU a cadeia de alias excedeu o
+//                                  limite de profundidade (fix round F4 —
+//                                  "não sei o que isto resolve" também é
+//                                  `unresolved-alias`, NUNCA silêncio).
+function analyzeSegment(segment, ctx, depth) {
+  const currentDepth = depth || 0;
+  if (currentDepth > ALIAS_MAX_DEPTH) {
+    // Fix round F4 (gate FAIL do `pc-qa`): ANTES retornava `null` aqui —
+    // silêncio, ou seja, allow. Estourar o limite de profundidade é "não
+    // sei o que a cadeia de alias resolve", não "sei que não é push" — as
+    // 2 únicas categorias em que silêncio é aceitável (comando sem
+    // `git`/`gh`, ou subcomando CONCLUSIVAMENTE resolvido como "não é
+    // alias"). Isto não é nenhuma das duas. Vale para os 2 branches.
+    return { kind: 'unresolved-alias' };
+  }
+
+  const tokens = tokenize(segment);
+
+  const gitIndex = tokens.findIndex(isGitToken);
+  if (gitIndex !== -1) {
+    const inlineAliases = new Map();
+    const found = findGitSubcommand(tokens, gitIndex, inlineAliases);
+    if (found) {
+      if (found.subcommand === 'push') {
+        const isForce = tokens.slice(found.index + 1).some(isForceFlagToken);
+        return { kind: isForce ? 'force-push' : 'git-push' };
+      }
+      if (!KNOWN_GIT_SUBCOMMANDS.has(found.subcommand)) {
+        const trailing = tokens.slice(found.index + 1);
+        let resolved = inlineAliases.has(found.subcommand)
+          ? inlineAliases.get(found.subcommand)
+          : ctx.gitSessionAliases.get(found.subcommand);
+
+        if (resolved === undefined) {
+          const lookup = resolveGitAliasFromDisk(found.subcommand, ctx.cwd);
+          if (lookup.status === 'found') {
+            resolved = lookup.value;
+          } else if (lookup.status === 'not-alias') {
+            return null; // resolvido com segurança: não é alias, não é push
+          } else {
+            return { kind: 'unresolved-alias' }; // não deu para confirmar
+          }
+        }
+
+        return expandResolvedAliasAndRecurse('git', resolved, trailing, ctx, currentDepth);
+      }
+    }
+  }
+
+  const ghIndex = tokens.findIndex(isGhToken);
+  if (ghIndex !== -1) {
+    const first = findNextGhToken(tokens, ghIndex);
+    if (first) {
+      if (first.token === 'pr') {
+        const second = findNextGhToken(tokens, first.index);
+        if (second && second.token === 'create') return { kind: 'gh-pr-create' };
+        if (second && second.token === 'merge') return { kind: 'gh-pr-merge' };
+        // "pr" seguido de outro verbo conhecido (checkout, view, ...) —
+        // não governado; cai para o `return null` no fim da função.
+      } else if (!KNOWN_GH_SUBCOMMANDS.has(first.token)) {
+        // Fix round F5: mesma disciplina do branch `git` — subcomando de
+        // `gh` desconhecido pode ser alias nativo (`gh alias set`).
+        const trailing = tokens.slice(first.index + 1);
+        let resolved = ctx.ghSessionAliases.get(first.token);
+
+        if (resolved === undefined) {
+          const lookup = resolveGhAliasFromDisk(first.token, ctx.cwd, ctx.ghAliasCache);
+          if (lookup.status === 'found') {
+            resolved = lookup.value;
+          } else if (lookup.status === 'not-alias') {
+            return null; // resolvido com segurança: não é alias
+          } else {
+            return { kind: 'unresolved-alias' }; // não deu para confirmar
+          }
+        }
+
+        return expandResolvedAliasAndRecurse('gh', resolved, trailing, ctx, currentDepth);
+      }
+    }
+  }
+
+  return null;
+}
+
+// Analisa o comando inteiro (podendo ter vários comandos encadeados) e
+// retorna a operação de MAIOR severidade encontrada em qualquer segmento
+// (force-push > merge > alias não resolvido > push/pr create), para não
+// deixar passar em silêncio um comando composto que contenha uma operação
+// governada em qualquer posição da cadeia.
+const SEVERITY = {
+  'force-push': 4,
+  'gh-pr-merge': 3,
+  'unresolved-alias': 2,
+  'git-push': 1,
+  'gh-pr-create': 1,
+};
+
+function findGovernedOperation(command, cwd) {
+  const segments = splitSegments(command);
+  const ctx = {
+    cwd,
+    gitSessionAliases: collectSessionAliases(segments),
+    ghSessionAliases: collectGhSessionAliases(segments),
+    ghAliasCache: { loaded: false, map: null, failed: false },
+  };
+  let best = null;
+  for (const segment of segments) {
+    const found = analyzeSegment(segment, ctx, 0);
+    if (!found) continue;
+    if (!best || SEVERITY[found.kind] > SEVERITY[best.kind]) {
+      best = found;
+    }
+  }
+  return best;
+}
+
+// Identidade lida EXCLUSIVAMENTE de `input.agent_type` (payload do
+// PreToolUse) — nunca do ambiente do processo, nunca do texto do comando.
+// Guarda explícita: `agent_type` ausente (main thread) não é string vazia,
+// é `undefined` — não chame método de string sobre ele sem checar antes.
+function isDevOpsAgent(input) {
+  return typeof input?.agent_type === 'string' && input.agent_type === DEVOPS_AGENT_TYPE;
+}
+
+function agentLabel(input) {
+  return typeof input?.agent_type === 'string' && input.agent_type
+    ? input.agent_type
+    : 'desconhecido (main thread ou identidade ausente)';
+}
+
+function emitDecision(permissionDecision, permissionDecisionReason) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision,
+      permissionDecisionReason,
+    },
+  }));
+}
+
+const OPERATION_LABEL = {
+  'git-push': 'git push',
+  'gh-pr-create': 'gh pr create',
+  'gh-pr-merge': 'gh pr merge',
+};
+
+function decideAndEmit(operation, input) {
+  if (operation.kind === 'force-push') {
+    emitDecision(
+      'deny',
+      'Force-push é proibido neste ambiente para qualquer agente, inclusive devops (regra de ouro: push somente fast-forward). Use push fast-forward.',
+    );
+    return;
+  }
+
+  if (operation.kind === 'unresolved-alias') {
+    // Subcomando de git OU gh desconhecido que PODE ser alias — ou a
+    // consulta (`git config --get`/`gh alias list`) não pôde ser concluída
+    // com segurança, ou a cadeia de alias (alias que resolve para outro
+    // alias) excedeu o limite de profundidade (fix round F4/F5). Nunca
+    // silêncio aqui: ask sempre, mesmo identidade conhecida — não sabemos
+    // se isto é force-push, push/PR comum, `pr merge`, ou nada.
+    emitDecision(
+      'ask',
+      `O comando usa um subcomando de git/gh não reconhecido, que pode ser um alias, e não foi possível confirmar com segurança o que ele resolve (consulta à config malsucedida, ou cadeia de alias longa demais para resolver com segurança). Aprovação humana necessária. Agente atual: ${agentLabel(input)}.`,
+    );
+    return;
+  }
+
+  if (operation.kind === 'gh-pr-merge') {
+    // gh pr merge: ask SEMPRE, mesmo para devops — D4, decisão do dono.
+    emitDecision(
+      'ask',
+      `gh pr merge exige aprovação humana explícita, sempre — inclusive para o papel devops (regra permanente do dono sobre merge em main). Agente atual: ${agentLabel(input)}.`,
+    );
+    return;
+  }
+
+  // git-push / gh-pr-create
+  if (isDevOpsAgent(input)) {
+    return; // allow, sem output
+  }
+
+  emitDecision(
+    'ask',
+    `${OPERATION_LABEL[operation.kind]} é exclusivo do papel devops. Agente atual: ${agentLabel(input)}. Aprovação humana necessária para prosseguir.`,
+  );
+}
+
+// Fallback de texto bruto para JSON ilegível — achado do sweep do fix
+// round F4 (mesma família de defeito: confiança indevida disfarçada de
+// "não é"). O `tokenize()` usado pelo parser principal separa tokens por
+// ESPAÇO EM BRANCO fora de aspas — mas um JSON compacto típico (o formato
+// real que a plataforma envia, sem indentação) só tem espaço em branco
+// DENTRO dos valores de string; fora deles, `{`/`"`/`:`/`}` ficam colados
+// sem separador. Resultado medido: `tokenize()` sobre
+// `{"tool_input":{"command":"git push --force"}}` produz **1 token só**
+// (todo o JSON vira uma string colada, incluindo o espaço de "git push"
+// preservado ilesamente DENTRO da aspas aberta), e `isGitToken`/`isGhToken`
+// (que comparam o token inteiro a `"git"`/`"gh"`) NUNCA bate — ou seja,
+// reusar `findGovernedOperation` aqui (tokenizado) fazia este fallback
+// retornar "não suspeito" (silêncio) para TODO JSON malformado, mesmo com
+// "git push --force" literalmente no texto. Corrigido para regex de
+// SUBSTRING sobre o texto bruto (não sobre tokens) — aqui a imprecisão é
+// aceitável e desejada: falso positivo custa 1 `deny` a mais num caso já
+// raro (JSON ilegível); falso negativo custa silêncio numa operação que
+// podia ser força. `\bgit\s+push\b` etc. acham a substring onde quer que
+// ela esteja no blob, independente de chaves/aspas/dois-pontos ao redor.
+const RAW_TEXT_GOVERNED_PATTERNS = [
+  /\bgit\s+push\b/i,
+  /\bgh\s+pr\s+create\b/i,
+  /\bgh\s+pr\s+merge\b/i,
+  /\bgit\s+config\b[\s\S]{0,80}\balias\b/i,
+  // Fix round F5: mesma régua de paranoia do padrão acima, agora para o
+  // rastro textual de definição de alias do `gh` (`gh alias set ...`).
+  /\bgh\s+alias\b/i,
+];
+
+function rawTextSuspectsGovernedOperation(rawText) {
+  const text = String(rawText || '');
+  return RAW_TEXT_GOVERNED_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+function runMain() {
+  const rawInput = readStdin();
+  const input = parseInput(rawInput);
+
+  if (!input) {
+    // Fail-closed proporcional: sem JSON válido, só bloqueia se o texto bruto
+    // aparentar conter uma operação remota governada.
+    if (rawTextSuspectsGovernedOperation(rawInput)) {
+      emitDecision(
+        'deny',
+        'O hook não conseguiu interpretar o input do PreToolUse e o comando aparenta ser uma operação remota. Bloqueado por segurança.',
+      );
+    }
+    return;
+  }
+
+  const command = input?.tool_input?.command || '';
+  const cwd = typeof input?.cwd === 'string' && input.cwd ? input.cwd : undefined;
+  const operation = findGovernedOperation(command, cwd);
+  if (!operation) {
+    return;
+  }
+
+  decideAndEmit(operation, input);
+}
+
+// Rede de segurança de topo (fix round F4, sweep): qualquer exceção NÃO
+// prevista em qualquer ponto do fluxo acima — inclusive `readStdin()` sem
+// try/catch próprio agora (decisão deliberada, ver comentário da função) —
+// é, por definição, um caso "não sei", nunca "sei que não". Um hook que
+// lança sem emitir `hookSpecificOutput` não é silêncio-como-decisão: é
+// ausência de decisão nenhuma, que a plataforma trata como fail-open (sem
+// restrição) — pior do que qualquer `ask`. Este catch garante que ISSO
+// NUNCA acontece: toda saída do processo, mesmo diante do inesperado, emite
+// uma decisão explícita.
+function main() {
+  try {
+    runMain();
+  } catch (err) {
+    emitDecision(
+      'ask',
+      `Erro interno inesperado no hook de autoridade de push/PR (${err && err.message ? err.message : 'erro desconhecido'}). Aprovação humana necessária — o hook não pôde concluir a análise do comando.`,
+    );
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  DEVOPS_AGENT_TYPE,
+  KNOWN_GIT_SUBCOMMANDS,
+  KNOWN_GH_SUBCOMMANDS,
+  ALIAS_MAX_DEPTH,
+  tokenize,
+  splitSegments,
+  isGitToken,
+  isGhToken,
+  findGitSubcommand,
+  findNextGhToken,
+  isForceFlagToken,
+  resolveGitAliasFromDisk,
+  resolveGhAliasFromDisk,
+  parseGhAliasListOutput,
+  collectSessionAliases,
+  collectGhSessionAliases,
+  expandResolvedAliasAndRecurse,
+  analyzeSegment,
+  findGovernedOperation,
+  rawTextSuspectsGovernedOperation,
+  isDevOpsAgent,
+  agentLabel,
+  readStdin,
+  runMain,
+  main,
+};