@daniellins/power-claude 0.16.3

package/scripts/__tests__/enforce-ready-oracles.test.cjs

@@ -0,0 +1,745 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * enforce-ready-oracles.test.cjs — suíte da trava de `Ready` (story SF13.2,
+ * `ADR-032` com as Emendas 1 e 2).
+ *
+ * Cobre os blocos A-F da story (AC-1 a AC-19, incluindo AC-2b/AC-5b/AC-6b/
+ * AC-18b) e acrescenta 4 MUTANTES de classe. Os mutantes não são enfeite: o
+ * `*review` desta story mediu que, sem eles, arrancar a trava de `runMain`
+ * deixava **18 de 18** ACs verdes, remover a checagem de orçamento deixava
+ * **19 de 19**, e desembrulhar `main()` do `runWithFailSafe` deixava **18 de
+ * 18**. Um teste que sobrevive à remoção do mecanismo que ele afirma testar
+ * não é teste — é decoração.
+ *
+ * TÉCNICA NORMATIVA DE FIXTURE — "cópia instalada" (Dev Notes da SF13.2,
+ * Emenda 2 item 5): `template/.claude/hooks/` tem profundidade DIFERENTE da
+ * cópia instalada. No framework o hook mora 3 segmentos abaixo da raiz; numa
+ * instalação real (`template/` some na cópia) mora 2 — e a âncora do hook é
+ * `path.resolve(__dirname, '..', '..')`, correta para a instalação. Logo:
+ * nenhum teste que precise de `loadValidator`/`loadCycleAuthority` bem
+ * sucedidos pode rodar o hook "no lugar" dentro de `template/`; sempre copiar
+ * para `<tmp>/.claude/hooks/` (+ `<tmp>/scripts/`). Testes que NÃO alcançam
+ * os loaders (matcher, `file_path`, JSON ilegível) podem rodar no lugar.
+ *
+ * Todo mutante usa substituição de string sobre o FONTE REAL, com falha dura
+ * se o marcador não existir ("instrumento de mutação desalinhado") — nunca
+ * falso-passa quando o código muda de forma (precedente literal de
+ * `enforce-cycle-authority.test.cjs`).
+ */
+
+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_SRC = path.join(REPO_ROOT, 'template', '.claude', 'hooks', 'enforce-ready-oracles.cjs');
+const SIBLING_SRC = path.join(REPO_ROOT, 'template', '.claude', 'hooks', 'enforce-cycle-authority.cjs');
+const VALIDATOR_SRC = path.join(REPO_ROOT, 'scripts', 'validate-story-acs.cjs');
+
+const hook = require(HOOK_SRC);
+const cycleAuthority = require(SIBLING_SRC);
+const validator = require(VALIDATOR_SRC);
+
+let failures = 0;
+const tmpDirs = [];
+
+function assert(ok, msg) {
+  if (ok) {
+    console.log(`[OK   ] ${msg}`);
+  } else {
+    console.error(`[FALHA] ${msg}`);
+    failures++;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function f(lines) {
+  return lines.join('\n');
+}
+
+function mkTmp(prefix) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+/**
+ * Cópia INSTALADA: `<tmp>/.claude/hooks/` (profundidade 2), como numa
+ * instalação real. `opts.hookSource` permite instalar um mutante.
+ */
+function mkInstalledCopy(opts) {
+  const o = opts || {};
+  const dir = mkTmp('ero-installed-');
+  fs.mkdirSync(path.join(dir, '.claude', 'hooks'), { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, '.claude', 'hooks', 'enforce-ready-oracles.cjs'),
+    o.hookSource || fs.readFileSync(HOOK_SRC, 'utf8'),
+  );
+  if (o.sibling !== false) {
+    fs.copyFileSync(SIBLING_SRC, path.join(dir, '.claude', 'hooks', 'enforce-cycle-authority.cjs'));
+  }
+  if (o.validator !== false) {
+    fs.mkdirSync(path.join(dir, 'scripts'), { recursive: true });
+    fs.copyFileSync(VALIDATOR_SRC, path.join(dir, 'scripts', 'validate-story-acs.cjs'));
+  }
+  return dir;
+}
+
+function hookPathOf(dir) {
+  return path.join(dir, '.claude', 'hooks', 'enforce-ready-oracles.cjs');
+}
+
+function writeStory(dir, name, content) {
+  const p = path.join(dir, name);
+  fs.writeFileSync(p, content);
+  return p;
+}
+
+function runHook(hookPath, payload) {
+  const r = spawnSync(process.execPath, [hookPath], {
+    input: typeof payload === 'string' ? payload : JSON.stringify(payload),
+    encoding: 'utf8',
+    timeout: 15000,
+  });
+  let decision = null;
+  let reason = '';
+  try {
+    const j = JSON.parse(r.stdout);
+    decision = j.hookSpecificOutput.permissionDecision;
+    reason = j.hookSpecificOutput.permissionDecisionReason;
+  } catch {
+    // stdout vazio ou não-JSON — silêncio, ou crash
+  }
+  return { raw: r, stdout: String(r.stdout || '').trim(), decision, reason };
+}
+
+function editPayload(filePath, oldString, newString) {
+  return { tool_name: 'Edit', tool_input: { file_path: filePath, old_string: oldString, new_string: newString } };
+}
+
+const STORY_LIMPA = f([
+  '## Status', '', 'Draft', '', '## Acceptance Criteria', '',
+  '**AC-Y.** descricao', '```oraculo', 'test -f package.json', '```', '',
+]);
+
+const STORY_COM_P8 = f([
+  '## Status', '', 'Draft', '', '## Acceptance Criteria', '',
+  '**AC-X.** descricao', '```oraculo', 'grep -c zzz-termo-inexistente-xyz package.json', '```', '',
+]);
+
+// ---------------------------------------------------------------------------
+// Instrumento de mutação — falha dura se o marcador sumir do fonte real.
+// ---------------------------------------------------------------------------
+
+function mutate(source, marcador, substituto, nome) {
+  if (!source.includes(marcador)) {
+    throw new Error(`instrumento de mutação desalinhado com o fonte real do hook (mutante ${nome}) — este teste não é prova válida`);
+  }
+  return source.split(marcador).join(substituto);
+}
+
+const MARCADOR_EMISSAO = "  if (!hits || hits.length === 0) return;\n  emitDecision('ask', buildHitsMessage(filePath, hits));";
+const MARCADOR_ORCAMENTO = '  if (budgetExceeded(startedAtMs, now())) {';
+const MARCADOR_WRAPPER = 'function main() {\n  runWithFailSafe(() => {';
+const MARCADOR_LOAD_VALIDATOR = [
+  'function loadValidator(repoRoot) {',
+  "  const p = path.join(repoRoot, 'scripts', 'validate-story-acs.cjs');",
+  '  try {',
+  '    return { ok: true, mod: require(p), path: p };',
+  '  } catch (err) {',
+  '    return { ok: false, error: err, path: p };',
+  '  }',
+  '}',
+].join('\n');
+
+// ---------------------------------------------------------------------------
+// Bloco A — detecção da transição, sem eleição (AC-1, AC-2, AC-2b)
+// ---------------------------------------------------------------------------
+
+function testDeteccaoDaTransicao() {
+  console.log('\n--- Bloco A: detecção da transição (AC-1, AC-2, AC-2b) ---');
+
+  const dir = mkTmp('ero-ac1-');
+  const p = path.join(dir, 'x.story.md');
+  const mk = (s) => `## Status\n\n${s}\n\n## Acceptance Criteria\n`;
+
+  // AC-1 — 6 casos. Os 2 últimos (`Ready`→`Ready`, `InReview`→`Ready`) são os
+  // que o `*review` mediu faltando: sem eles, `after === 'ready'` (que ignora
+  // o "antes") passa, e o hook vira guard que interrompe TODA edição de uma
+  // story já `Ready`.
+  fs.writeFileSync(p, mk('Draft'));
+  const r1 = hook.detectDraftToReady(editPayload(p, 'Draft', 'Ready'), cycleAuthority);
+  const r2 = hook.detectDraftToReady(editPayload(p, 'Draft', 'Draft'), cycleAuthority);
+  fs.writeFileSync(p, mk('Ready'));
+  const r3 = hook.detectDraftToReady(editPayload(p, 'Ready', 'Done'), cycleAuthority);
+  fs.writeFileSync(p, mk('Draft'));
+  const r4 = hook.detectDraftToReady(editPayload(p, 'Draft', 'InReview'), cycleAuthority);
+  fs.writeFileSync(p, mk('Ready'));
+  const r5 = hook.detectDraftToReady(editPayload(p, 'nota qualquer', 'nota editada'), cycleAuthority);
+  fs.writeFileSync(p, mk('InReview'));
+  const r6 = hook.detectDraftToReady(editPayload(p, 'InReview', 'Ready'), cycleAuthority);
+
+  assert(r1 === true, 'AC-1: Draft→Ready ⇒ verdadeiro');
+  assert(r2 !== true, 'AC-1: Draft→Draft ⇒ falso');
+  assert(r3 !== true, 'AC-1: Ready→Done ⇒ falso');
+  assert(r4 !== true, 'AC-1: Draft→InReview ⇒ falso');
+  assert(r5 !== true, 'AC-1: edição numa story Ready que nem toca ## Status ⇒ falso');
+  assert(r6 !== true, 'AC-1: InReview→Ready ⇒ falso (o "antes" tem de ser Draft)');
+
+  // AC-2 — ordem: o gate por TRANSIÇÃO vem antes do gate por CONTEÚDO.
+  // Roda "no lugar" de propósito: esta rota sai antes de precisar do validador.
+  const dir2 = mkTmp('ero-ac2-');
+  const storyReady = writeStory(dir2, 'x.story.md', f([
+    '## Status', '', 'Ready', '', '## Acceptance Criteria', '',
+    '**AC-X.** d', '```oraculo', 'grep -c zzz-termo-inexistente-xyz package.json', '```',
+  ]));
+  const rAc2 = runHook(HOOK_SRC, editPayload(storyReady, 'Ready', 'Done'));
+  assert(
+    rAc2.raw.status === 0 && rAc2.stdout === '',
+    'AC-2: Ready→Done sobre story com AC no-op ⇒ silêncio (predicados nem são avaliados)',
+  );
+
+  // AC-2b — a rota real, de ponta a ponta, com controle negativo pareado.
+  const inst = mkInstalledCopy();
+  const pSujo = writeStory(inst, 'dirty.story.md', STORY_COM_P8);
+  const rSujo = runHook(hookPathOf(inst), editPayload(pSujo, 'Draft', 'Ready'));
+  assert(rSujo.decision === 'ask', 'AC-2b: Draft→Ready sobre story com P8 ⇒ ask (a trava interrompe de fato)');
+  assert(/P8/.test(rSujo.reason), 'AC-2b: a mensagem do ask cita o predicado P8');
+  assert(/pode ser no-op/i.test(rSujo.reason), 'AC-2b: a mensagem reproduz o hedge do instrumento, não afirma mais que ele');
+
+  const pLimpo = writeStory(inst, 'clean.story.md', STORY_LIMPA);
+  const rLimpo = runHook(hookPathOf(inst), editPayload(pLimpo, 'Draft', 'Ready'));
+  assert(rLimpo.stdout === '', 'AC-2b (controle negativo): a MESMA rota sobre story limpa ⇒ silêncio (não é guard que sempre dispara)');
+}
+
+// ---------------------------------------------------------------------------
+// Bloco B — silêncio o mais cedo possível (AC-3, AC-4)
+// ---------------------------------------------------------------------------
+
+function testSilencioCedo() {
+  console.log('\n--- Bloco B: silêncio cedo (AC-3, AC-4) ---');
+
+  const rBash = runHook(HOOK_SRC, { tool_name: 'Bash', tool_input: { command: 'echo oi' } });
+  assert(rBash.raw.status === 0 && rBash.stdout === '', 'AC-3: tool_name fora de Edit|Write ⇒ silêncio total');
+
+  const dir = mkTmp('ero-ac4-');
+  const p = writeStory(dir, 'nota.md', '## Status\n\nDraft\n');
+  const rNota = runHook(HOOK_SRC, editPayload(p, 'Draft', 'Ready'));
+  assert(rNota.raw.status === 0 && rNota.stdout === '', 'AC-4: file_path que não casa \\.story\\.md$ ⇒ silêncio total');
+}
+
+// ---------------------------------------------------------------------------
+// Bloco C — fonte única (AC-5, AC-5b, AC-6, AC-6b)
+// ---------------------------------------------------------------------------
+
+function testFonteUnica() {
+  console.log('\n--- Bloco C: fonte única e pureza (AC-5, AC-5b, AC-6, AC-6b) ---');
+
+  const src = fs.readFileSync(HOOK_SRC, 'utf8');
+
+  // AC-5/AC-6 — tripwires de contagem. Guardas de regressão, não provas
+  // sozinhas: só pegam cópia com o MESMO nome. AC-5b é a prova forte.
+  // SF13.9/N-5: `statusToken`/`doneEvidence` entraram na lista. Medido pelo
+  // revisor: sem elas, uma 2ª implementação DESSES nomes dentro deste hook
+  // passava despercebida (`npm test` continuava verde) — e são justamente as
+  // funções que a SF13.9 fez este hook consumir do irmão.
+  const redefineIrmao = /function\s+(simulateResult|extractStatusSection|normalizeStatusText|statusToken|doneEvidence)\b/.test(src);
+  assert(!redefineIrmao, 'AC-5: o hook não redefine simulateResult/extractStatusSection/normalizeStatusText/statusToken/doneEvidence');
+  const redefineValidador = /function\s+(parseAcs|wouldBeRefused|looksLikeNaiveCounting|parseEspera|extractAcSection)\b/.test(src);
+  assert(!redefineValidador, 'AC-6: o hook não redefine parseAcs/wouldBeRefused/looksLikeNaiveCounting/parseEspera/extractAcSection');
+  assert(/enforce-cycle-authority/.test(src), 'AC-5 (pareado): o hook referencia o irmão por path, isto é, o carrega em vez de copiá-lo');
+  assert(/validate-story-acs/.test(src), 'AC-6 (pareado): o hook referencia o validador por path');
+
+  // AC-6b — a pureza é ESTRUTURAL. Se algum predicado passar a executar, esta
+  // asserção reprova sozinha. Leitura honesta (não-bloqueante 2 do `*review`):
+  // o tripwire pega a forma ingênua; a prova real da pureza é o AC-2b.
+  const semSubprocesso = !/child_process|spawnSync|execSync|execFile|\.runOracle\(|\.validateStory\(/.test(src);
+  assert(semSubprocesso, 'AC-6b: o fonte do hook não contém nenhuma forma de subprocesso (hook PURO)');
+  // GATILHO DA PROMOÇÃO (`ADR-035` D6). Esta é a linha que quem promover a
+  // trava de `Ready` a `deny` é OBRIGADO a editar — por isso a condição de
+  // entrada mora aqui, na mensagem, e não numa disciplina que alguém precise
+  // lembrar. A CONDIÇÃO booleana abaixo é byte-idêntica à original: só o texto
+  // mudou (D6/D8 — o hook e a lógica do teste ficam intocados).
+  assert(!/'deny'/.test(src), "AC-6b: o fonte do hook não contém o literal 'deny' — negar é estruturalmente impossível. GATILHO DA PROMOÇÃO (ADR-035 D6): apagar ou afrouxar esta asserção É promover a trava de Ready de ask para deny, e a condição de entrada é D-Dono-2 (ADR-032), CONJUNTIVA — (i) 10 transições reais Draft→Ready registradas com a v1 E (ii) parseGuarda consertado. (ii) está PAGA (SF13.7). (i) se mede com: node scripts/derive-ready-transitions.cjs . --rev 6ef33f90 --since d6ae744 (instrumento offline, exit 0 sempre, ADR-035; leia total= e desde= e decida — nenhuma automação promove por você).");
+
+  // AC-5b — irmão ausente ⇒ falha DECLARADA, nunca silêncio nem crash mudo.
+  const semIrmao = mkInstalledCopy({ sibling: false });
+  const p1 = writeStory(semIrmao, 'x.story.md', '## Status\n\nDraft\n\n## Acceptance Criteria\n');
+  const rSemIrmao = runHook(hookPathOf(semIrmao), editPayload(p1, 'Draft', 'Ready'));
+  assert(rSemIrmao.decision === 'ask', 'AC-5b: irmão enforce-cycle-authority.cjs ausente ⇒ ask (5ª rota, Emenda 2)');
+  assert(
+    /enforce-cycle-authority/.test(rSemIrmao.reason),
+    'AC-5b: a mensagem NOMEIA a dependência ausente (falha declarada, não genérica)',
+  );
+
+  // Controle negativo pareado, na MESMA rodada (fecha o não-bloqueante 3 do
+  // `*review`): a MESMA fixture COM o irmão presente e story limpa ⇒ silêncio.
+  const comIrmao = mkInstalledCopy();
+  const p2 = writeStory(comIrmao, 'x.story.md', STORY_LIMPA);
+  const rComIrmao = runHook(hookPathOf(comIrmao), editPayload(p2, 'Draft', 'Ready'));
+  assert(rComIrmao.stdout === '', 'AC-5b (controle negativo): irmão presente + story limpa ⇒ silêncio');
+}
+
+// ---------------------------------------------------------------------------
+// Bloco D — os 5 predicados puros (AC-7 a AC-11)
+// ---------------------------------------------------------------------------
+
+function testPredicados() {
+  console.log('\n--- Bloco D: os 5 predicados puros (AC-7 a AC-11) ---');
+
+  // AC-7 / P1 — fence órfã.
+  const p1Pos = f([
+    '## Acceptance Criteria', '',
+    '**AC1.** header sem hifen (fora da convencao)', '```oraculo', 'test -f package.json', '```', '',
+    '**AC-1.** header correto, mesma fence', '```oraculo', 'test -f package.json', '```',
+  ]);
+  const p1Neg = f(['## Acceptance Criteria', '', '**AC-1.** so a forma correta', '```oraculo', 'test -f package.json', '```']);
+  const orfaPos = hook.evaluateFenceOrfa(p1Pos, validator);
+  assert(orfaPos && orfaPos.predicate === 'P1', 'AC-7: 2 fences / 1 AC atribuído ⇒ hit P1');
+  assert(hook.evaluateFenceOrfa(p1Neg, validator) === null, 'AC-7 (negativo): 1 fence / 1 AC ⇒ sem hit');
+
+  const semFence = f(['## Acceptance Criteria', '', '**AC-1.** sem oráculo nenhum']);
+  assert(hook.evaluateFenceOrfa(semFence, validator) === null, 'AC-7 (fronteira): fences === 0 ⇒ silêncio declarado, fora do alcance');
+
+  const casos = [
+    {
+      ac: 'AC-8', pred: 'P4',
+      pos: ['# espera: stdout-vazia', 'test -f package.json'],
+      neg: ['test -f package.json'],
+      rotulo: '# espera: não reconhecido',
+    },
+    {
+      ac: 'AC-9', pred: 'P5',
+      pos: [],
+      neg: ['test -f package.json'],
+      rotulo: 'fence vazia',
+    },
+    {
+      ac: 'AC-10', pred: 'P6',
+      pos: ['awk BEGIN{print 1}'],
+      neg: ['test -f package.json'],
+      rotulo: 'oráculo recusado pela allow-list',
+    },
+    {
+      ac: 'AC-11', pred: 'P8',
+      pos: ['grep -c zzz-termo-inexistente-xyz package.json'],
+      neg: ['# espera: stdout-nao-vazio', 'grep -c zzz-termo-inexistente-xyz package.json'],
+      rotulo: 'contagem ingênua sob exit0',
+    },
+  ];
+
+  for (const c of casos) {
+    const conteudoPos = f(['## Acceptance Criteria', '', '**AC-X.** d', '```oraculo', ...c.pos, '```']);
+    const conteudoNeg = f(['## Acceptance Criteria', '', '**AC-X.** d', '```oraculo', ...c.neg, '```']);
+    const hitsPos = hook.evaluatePerAcPredicates(conteudoPos, validator);
+    const hitsNeg = hook.evaluatePerAcPredicates(conteudoNeg, validator);
+    const achado = hitsPos.find((h) => h.predicate === c.pred && h.id === 'AC-X');
+    assert(Boolean(achado), `${c.ac}: ${c.rotulo} ⇒ hit ${c.pred} no AC-X`);
+    assert(!hitsNeg.some((h) => h.predicate === c.pred), `${c.ac} (negativo): forma correta ⇒ sem hit ${c.pred}`);
+  }
+
+  // AC-11 — o hedge é normativo: a mensagem nunca afirma mais que o instrumento.
+  const p8 = hook.evaluatePerAcPredicates(
+    f(['## Acceptance Criteria', '', '**AC-X.** d', '```oraculo', 'grep -c zzz package.json', '```']),
+    validator,
+  ).find((h) => h.predicate === 'P8');
+  assert(p8 && /pode ser no-op/i.test(p8.detail), 'AC-11: o detalhe do P8 reproduz o hedge do instrumento ("pode ser no-op")');
+}
+
+// ---------------------------------------------------------------------------
+// Bloco E — os corpus reais (AC-12 a AC-15)
+// ---------------------------------------------------------------------------
+
+function testCorpusReais() {
+  console.log('\n--- Bloco E: corpus reais (AC-12 a AC-15) ---');
+
+  const lerStory = (nome) => fs.readFileSync(path.join(REPO_ROOT, 'docs', 'stories', nome), 'utf8');
+
+  // Corpus A — `sf13.1.story.md` está `Done` em `main` e não deve mais mudar.
+  // Se algum fix futuro a editar, esta medição precisa ser refeita (mesma
+  // disciplina de "medição datada" do `ADR-032`).
+  const hitsA = hook.evaluateReadyOracles(lerStory('sf13.1.story.md'), validator);
+  const p8Ids = hitsA.filter((h) => h.predicate === 'P8').map((h) => h.id).sort();
+  const outros = hitsA.filter((h) => h.predicate !== 'P8');
+  assert(
+    JSON.stringify(p8Ids) === JSON.stringify(['AC-2', 'AC-23', 'AC-30', 'AC-31']),
+    'AC-12 (Corpus A): sf13.1 dispara exatamente os 4 P8 verdadeiros',
+  );
+  assert(outros.length === 0, 'AC-12 (Corpus A): nenhum P1/P4/P5/P6 e nenhum falso positivo da família [Guarda] (fora da v1)');
+
+  assert(hook.evaluateReadyOracles(lerStory('sf12.6.story.md'), validator).length === 0,
+    'AC-13 (Corpus B): sf12.6 (37 oráculos, convenção correta) ⇒ zero hits');
+  assert(hook.evaluateReadyOracles(lerStory('sf11.7.story.md'), validator).length === 0,
+    'AC-14 (Corpus C): sf11.7 (sem bloco oraculo) ⇒ zero hits, por fences === 0, não por leitura de relatório');
+
+  // AC-15 (Corpus D) — RECOMBINADO, com procedência: cabeçalho sem hífen real
+  // (`sf12.3.story.md:195`) + fence real (`sf13.1.story.md:159-161`). Nenhuma
+  // story real tem as duas coisas juntas hoje — é recombinação, não invenção.
+  const corpusD = f([
+    '## Acceptance Criteria', '',
+    '**AC1. [REESCRITO — fix round, *review 2026-08-06]** header da convencao antiga (sf12.3.story.md:195)',
+    '```oraculo', 'test -f docs/mecanismos/validador-de-acs-do-ciclo.md', '```', '',
+    '**AC-1.** header corrigido, mesma fence (sf13.1.story.md:159-161)',
+    '```oraculo', 'test -f docs/mecanismos/validador-de-acs-do-ciclo.md', '```',
+  ]);
+  const corpusDNeg = f([
+    '## Acceptance Criteria', '', '**AC-1.** so a forma correta',
+    '```oraculo', 'test -f docs/mecanismos/validador-de-acs-do-ciclo.md', '```',
+  ]);
+  const dHit = hook.evaluateFenceOrfa(corpusD, validator);
+  assert(dHit && dHit.predicate === 'P1', 'AC-15 (Corpus D): cabeçalho fora da convenção + fence real ⇒ P1');
+  assert(hook.evaluateFenceOrfa(corpusDNeg, validator) === null, 'AC-15 (Corpus D, negativo): a MESMA fence sob cabeçalho correto ⇒ sem hit');
+}
+
+// ---------------------------------------------------------------------------
+// Bloco F — as rotas de fail-safe (AC-16 a AC-19)
+// ---------------------------------------------------------------------------
+
+function testFailSafe() {
+  console.log('\n--- Bloco F: rotas de fail-safe (AC-16 a AC-19) ---');
+
+  const src = fs.readFileSync(HOOK_SRC, 'utf8');
+
+  // AC-16 (Corpus E) — validador ausente, real.
+  const semValidador = mkInstalledCopy({ validator: false });
+  const pv = writeStory(semValidador, 'x.story.md', '## Status\n\nDraft\n\n## Acceptance Criteria\n');
+  const rReal = runHook(hookPathOf(semValidador), editPayload(pv, 'Draft', 'Ready'));
+  assert(rReal.decision === 'ask', 'AC-16: validador ausente ⇒ ask (nunca silêncio)');
+  assert(
+    /scripts\/validate-story-acs\.cjs ausente/.test(rReal.reason),
+    'AC-16: a mensagem é ACIONÁVEL — nomeia o arquivo ausente e o comando de conserto',
+  );
+
+  // AC-16, metade MUTANTE — `loadValidator` sem a captura própria. A defesa em
+  // profundidade (`runWithFailSafe` externo) ainda produz `ask`, mas a mensagem
+  // vira GENÉRICA: prova que a mensagem acionável depende da captura
+  // específica, e não é subproduto da rede externa.
+  const srcSemCaptura = mutate(
+    src,
+    MARCADOR_LOAD_VALIDATOR,
+    "function loadValidator(repoRoot) {\n  const p = path.join(repoRoot, 'scripts', 'validate-story-acs.cjs');\n  return { ok: true, mod: require(p), path: p }; // MUTANTE\n}",
+    'loadValidator sem captura',
+  );
+  const mutA = mkInstalledCopy({ validator: false, hookSource: srcSemCaptura });
+  const pmA = writeStory(mutA, 'x.story.md', '## Status\n\nDraft\n\n## Acceptance Criteria\n');
+  const rMutA = runHook(hookPathOf(mutA), editPayload(pmA, 'Draft', 'Ready'));
+  assert(rMutA.decision === 'ask', 'AC-16 (mutante): sem a captura de loadValidator, a rede externa ainda produz ask');
+  assert(
+    /lan[cç]ou uma exce[cç][aã]o/.test(rMutA.reason) && !/scripts\/validate-story-acs\.cjs ausente/.test(rMutA.reason),
+    'AC-16 (mutante): a mensagem degrada para GENÉRICA — a acionável depende da captura específica',
+  );
+
+  // MUTANTE M2 — `main()` desembrulhado do `runWithFailSafe`, sobre o mesmo
+  // cenário do mutante acima: agora NADA é emitido. É a medição que prova qual
+  // camada produz o `ask` — e é a classe de defeito que esta story existe para
+  // matar (hook que lança não emite decisão e a ferramenta passa).
+  // A substituição troca `runWithFailSafe` por um executor IDENTIDADE — invoca
+  // a mesma função, sem try/catch. Trocar por `(() => {` sem invocar seria um
+  // mutante VAZIO (a arrow nunca rodaria, nada lançaria, e o teste passaria
+  // por não executar o código — falso conforto, não medição).
+  const srcSemRede = mutate(srcSemCaptura, MARCADOR_WRAPPER, 'function main() {\n  ((fn) => fn())(() => {', 'main sem runWithFailSafe');
+  const mutB = mkInstalledCopy({ validator: false, hookSource: srcSemRede });
+  const pmB = writeStory(mutB, 'x.story.md', '## Status\n\nDraft\n\n## Acceptance Criteria\n');
+  const rMutB = runHook(hookPathOf(mutB), editPayload(pmB, 'Draft', 'Ready'));
+  assert(
+    rMutB.stdout === '' && rMutB.raw.status !== 0,
+    'MUTANTE M2: sem runWithFailSafe em main(), o hook morre MUDO — nenhuma decisão emitida (fail-open silencioso)',
+  );
+
+  // AC-17 — o fluxo REAL protegido, e o controle negativo pelo MESMO caminho.
+  const inst = mkInstalledCopy();
+  const p17 = writeStory(inst, 'x.story.md', '## Status\n\nDraft\n\n## Acceptance Criteria\n');
+  const h17 = require(hookPathOf(inst));
+  const input17 = editPayload(p17, 'Draft', 'Ready');
+  const explode = () => { throw new Error('boom-ac17'); };
+
+  let asked = null;
+  const origWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (s) => {
+    try {
+      asked = JSON.parse(s).hookSpecificOutput.permissionDecision;
+    } catch { /* saída não-JSON */ }
+    return true;
+  };
+  h17.runWithFailSafe(() => h17.runMain(input17, { evaluateReadyOracles: explode }));
+  process.stdout.write = origWrite;
+
+  let propagou = false;
+  try {
+    h17.runMain(input17, { evaluateReadyOracles: explode });
+  } catch {
+    propagou = true;
+  }
+  assert(asked === 'ask', 'AC-17: etapa genuína de runMain lançando ⇒ runWithFailSafe emite ask');
+  assert(propagou === true, 'AC-17 (controle negativo): o MESMO runMain sem o wrapper propaga a exceção — é o wrapper que protege');
+
+  // AC-18 — orçamento, função pura.
+  assert(hook.budgetExceeded(1000, 3001) === true, 'AC-18: 2001 ms > 2000 ⇒ estourado');
+  assert(hook.budgetExceeded(1000, 2999) === false, 'AC-18: 1999 ms ⇒ não estourado');
+
+  // AC-18b — `runMain` de fato USA o orçamento, e ele vence o silêncio.
+  const p18 = writeStory(inst, 'limpa.story.md', STORY_LIMPA);
+  const input18 = editPayload(p18, 'Draft', 'Ready');
+  let asked18 = null;
+  let msg18 = '';
+  let chamadas = 0;
+  const relogioQueSalta = () => {
+    chamadas += 1;
+    return chamadas === 1 ? 1000 : 5001;
+  };
+  process.stdout.write = (s) => {
+    try {
+      const j = JSON.parse(s);
+      asked18 = j.hookSpecificOutput.permissionDecision;
+      msg18 = j.hookSpecificOutput.permissionDecisionReason;
+    } catch { /* saída não-JSON */ }
+    return true;
+  };
+  h17.runMain(input18, { now: relogioQueSalta });
+  process.stdout.write = origWrite;
+  assert(asked18 === 'ask', 'AC-18b: orçamento estourado ⇒ runMain emite ask MESMO sobre story limpa');
+  assert(/2000/.test(msg18), 'AC-18b: a mensagem nomeia o orçamento de 2000 ms');
+
+  // Controle negativo do AC-18b: relógio parado ⇒ a MESMA story limpa cala.
+  let asked18neg = null;
+  process.stdout.write = (s) => {
+    try {
+      asked18neg = JSON.parse(s).hookSpecificOutput.permissionDecision;
+    } catch { /* saída não-JSON */ }
+    return true;
+  };
+  h17.runMain(input18, { now: () => 1000 });
+  process.stdout.write = origWrite;
+  assert(asked18neg === null, 'AC-18b (controle negativo): sem estouro, a MESMA story limpa ⇒ silêncio');
+
+  // AC-19 — JSON ilegível, fail-closed PROPORCIONAL.
+  const rRuidoRelevante = runHook(HOOK_SRC, '{ nao e json valido, mas fala de Status e Ready');
+  const rRuidoIrrelevante = runHook(HOOK_SRC, '{ nao e json valido, garbage total sem nada relevante');
+  assert(rRuidoRelevante.decision === 'ask', 'AC-19: texto bruto ilegível aparentando Status/Ready ⇒ ask');
+  assert(rRuidoIrrelevante.stdout === '', 'AC-19: texto bruto ilegível sem esses termos ⇒ silêncio total');
+}
+
+// ---------------------------------------------------------------------------
+// Mutantes da TRAVA e do ORÇAMENTO — os dois que sobreviviam a 18/18 e 19/19.
+// ---------------------------------------------------------------------------
+
+function testMutantesDaTrava() {
+  console.log('\n--- Mutantes de classe: a trava e o orçamento ---');
+
+  const src = fs.readFileSync(HOOK_SRC, 'utf8');
+
+  // M6 — a emissão por predicado arrancada de `runMain`. O `*review` mediu
+  // 18/18 ACs sobrevivendo a este mutante antes do AC-2b existir.
+  const srcSemTrava = mutate(
+    src,
+    MARCADOR_EMISSAO,
+    '  if (!hits || hits.length === 0) return;\n  return; // MUTANTE M6',
+    'M6 trava arrancada',
+  );
+  const m6 = mkInstalledCopy({ hookSource: srcSemTrava });
+  const p6 = writeStory(m6, 'dirty.story.md', STORY_COM_P8);
+  const r6 = runHook(hookPathOf(m6), editPayload(p6, 'Draft', 'Ready'));
+  assert(r6.stdout === '', 'MUTANTE M6: com a trava arrancada o hook fica mudo sobre story com P8 — logo o AC-2b o derruba');
+
+  // M1 — a checagem de orçamento removida. `*review`: 19/19 sobreviviam.
+  const srcSemOrcamento = mutate(src, MARCADOR_ORCAMENTO, '  if (false) { // MUTANTE M1', 'M1 orçamento removido');
+  const m1dir = mkInstalledCopy({ hookSource: srcSemOrcamento });
+  const p1story = writeStory(m1dir, 'limpa.story.md', STORY_LIMPA);
+  const h1 = require(hookPathOf(m1dir));
+  let asked = null;
+  const origWrite = process.stdout.write.bind(process.stdout);
+  let chamadas = 0;
+  process.stdout.write = (s) => {
+    try {
+      asked = JSON.parse(s).hookSpecificOutput.permissionDecision;
+    } catch { /* saída não-JSON */ }
+    return true;
+  };
+  h1.runMain(editPayload(p1story, 'Draft', 'Ready'), {
+    now: () => {
+      chamadas += 1;
+      return chamadas === 1 ? 1000 : 5001;
+    },
+  });
+  process.stdout.write = origWrite;
+  assert(asked === null, 'MUTANTE M1: sem a checagem de orçamento, o estouro passa em silêncio — logo o AC-18b o derruba');
+}
+
+// ---------------------------------------------------------------------------
+// SF13.9 — a transição passa a ser detectada por TOKEN; a superfície de export
+// do irmão é CHECADA (não presumida); P2/P3/P7 entram na escada de 2 degraus.
+// ---------------------------------------------------------------------------
+
+function testTransicaoPorToken() {
+  console.log('\n--- SF13.9: detectDraftToReady por TOKEN, nos dois lados ---');
+
+  const dir = mkTmp('ero-sf139-tok-');
+  const p = path.join(dir, 'z.story.md');
+  function det(antes, depois) {
+    fs.writeFileSync(p, `## Status\n\n${antes}\n`);
+    return hook.detectDraftToReady(
+      { tool_name: 'Write', tool_input: { file_path: p, content: `## Status\n\n${depois}\n` } },
+      cycleAuthority,
+    );
+  }
+
+  // POSITIVO — o defeito de FINDING-8, nos DOIS lados de uma vez.
+  assert(det('Draft (aguardando PO)', 'Ready (validado pelo PO)') === true, 'SF13.9: "Draft (aguardando PO)"→"Ready (validado pelo PO)" DISPARA (a igualdade estrita ficava muda nos dois lados)');
+  assert(det('Draft', 'Ready — aguardando dev') === true, 'SF13.9: prosa com travessão no lado `depois` dispara');
+  assert(det('Draft', '`Ready`') === true, 'SF13.9: decoração de crase no lado `depois` dispara');
+
+  // NEGATIVOS pareados — os 3 primeiros são regressão que NÃO pode quebrar.
+  assert(det('Ready', 'Ready') === false, 'SF13.9/regressão: Ready→Ready NÃO dispara (senão o PO é interrompido a cada escrita numa story já Ready)');
+  assert(det('InReview (fix round 1)', 'Ready') === false, 'SF13.9/regressão: InReview→Ready NÃO dispara (não vem de Draft)');
+  assert(det('Draft', 'Not Ready') === false, 'SF13.9: Draft→"Not Ready" NÃO dispara — negação nunca dispara');
+  assert(det('Draft', '~~Ready~~') === false, 'SF13.9: Draft→"~~Ready~~" NÃO dispara — falso negativo DECLARADO e aceito (gatilho T-E3-RISCADO), preço de manter `~` fora da decoração por causa do deny do irmão');
+}
+
+function testSkewDoIrmao() {
+  console.log('\n--- SF13.9: skew da superfície de export do irmão (construído, não presumido) ---');
+
+  // O skew é CONSTRUÍDO: a cópia do irmão em tmp perde `statusToken` do bloco
+  // de exports. Copiar os arquivos ATUAIS do repo não constrói skew nenhum
+  // depois do fix — um AC assim só fica verde com implementação ERRADA
+  // (`ADR-032` Emenda 4, E4.3).
+  const dir = mkInstalledCopy({});
+  const irmao = path.join(dir, '.claude', 'hooks', 'enforce-cycle-authority.cjs');
+  const src = fs.readFileSync(irmao, 'utf8');
+  const semExport = src.replace(/^\s*statusToken,\s*$/m, '');
+  if (semExport === src) throw new Error('instrumento de skew desalinhado: `statusToken,` não está no bloco de exports do irmão — este teste não é prova válida');
+  fs.writeFileSync(irmao, semExport);
+  assert(typeof require(irmao).statusToken !== 'function', 'pré-condição: a cópia do irmão de fato PERDEU statusToken (skew real, não presumido)');
+
+  const sp = writeStory(dir, 'x.story.md', '## Status\n\nDraft\n');
+  const r = runHook(hookPathOf(dir), { tool_name: 'Write', tool_input: { file_path: sp, content: '## Status\n\nReady\n' }, cwd: dir });
+  assert(r.decision === 'ask', 'SF13.9: irmão em SKEW ⇒ ask (o caminho de degradação FALA; silêncio seria indistinguível de "não é a transição")');
+  assert(/statusToken/.test(r.reason), 'SF13.9: a razão NOMEIA a função ausente — `ask` genérico nasceria verde e não distinguiria skew de qualquer outra rota');
+
+  // CONTROLE DE SILÊNCIO, pareado (o par é o que mata a implementação que
+  // "fala em toda transição" para deixar o teste de skew verde): irmão
+  // ÍNTEGRO + story sem defeito de forma ⇒ stdout VAZIO, nas duas redações do
+  // Status. É a propriedade central da trava (`DF-SF13.2-1`).
+  const limpo = mkInstalledCopy({});
+  const base = f([
+    '## Status', '', 'Draft', '', '## Acceptance Criteria', '',
+    '**AC-1.** teste', '```oraculo', '# espera: exit0', 'test -f package.json', '```', '',
+  ]);
+  const sp2 = writeStory(limpo, 'x.story.md', base);
+  const puro = runHook(hookPathOf(limpo), { tool_name: 'Write', tool_input: { file_path: sp2, content: base.replace('Draft', 'Ready') }, cwd: limpo });
+  const anotado = runHook(hookPathOf(limpo), { tool_name: 'Write', tool_input: { file_path: sp2, content: base.replace('Draft', 'Ready (validado pelo PO, 10/10)') }, cwd: limpo });
+  assert(puro.stdout === '', 'SF13.9/CONTROLE: irmão íntegro + story limpa, Draft→Ready puro ⇒ SILÊNCIO absoluto');
+  assert(anotado.stdout === '', 'SF13.9/CONTROLE: idem com Status anotado ⇒ SILÊNCIO absoluto (falar aqui seria pior que o defeito que a story conserta)');
+
+  // MUTANTE M12 — a checagem de superfície removida: o skew passa a seguir o
+  // caminho feliz e o hook CALA sobre uma story que ele não sabe ler.
+  const mutSrc = mutate(
+    fs.readFileSync(HOOK_SRC, 'utf8'),
+    '  const faltando = REQUIRED_SIBLING_EXPORTS.filter((nome) => !mod || typeof mod[nome] !== \'function\');',
+    '  const faltando = [];',
+    'M12',
+  );
+  const dirM12 = mkInstalledCopy({ hookSource: mutSrc });
+  fs.writeFileSync(path.join(dirM12, '.claude', 'hooks', 'enforce-cycle-authority.cjs'), semExport);
+  const spM12 = writeStory(dirM12, 'x.story.md', '## Status\n\nDraft\n');
+  const rM12 = runHook(hookPathOf(dirM12), { tool_name: 'Write', tool_input: { file_path: spM12, content: '## Status\n\nReady\n' }, cwd: dirM12 });
+  assert(rM12.stdout === '', 'MUTANTE M12 (checagem de superfície removida): o skew vira SILÊNCIO — logo o teste de skew acima é quem o mata');
+}
+
+function testGuardaP2P3P7() {
+  console.log('\n--- SF13.9: P2/P3/P7 ligados ao hook (escada de 2 degraus, ask-only) ---');
+
+  const comDefeitos = f([
+    '## Acceptance Criteria', '',
+    '**AC-1.** teste. [Guarda] (banana)', '```oraculo', 'test -f package.json', '```', '',
+    '**AC-2.** teste. [Guarda] (prova: AC-INEXISTENTE)', '```oraculo', 'test -f package.json', '```', '',
+    '**AC-3.** teste. [Guarda] (sem irmao)', '```oraculo', '# espera: exit0', 'test -f package.json', '```', '',
+  ]);
+  const preds = new Set(hook.evaluateReadyOracles(comDefeitos, validator).map((h) => h.predicate));
+  assert(preds.has('P2'), 'SF13.9/P2: `[Guarda] (banana)` — forma não reconhecida — é VISTO pelo hook');
+  assert(preds.has('P3'), 'SF13.9/P3: `[Guarda] (prova: AC-INEXISTENTE)` — irmão que não existe — é VISTO pelo hook');
+  assert(preds.has('P7'), 'SF13.9/P7: `[Guarda] (sem irmao)` sem asserção de AUSÊNCIA é VISTO pelo hook');
+
+  // CONTROLE NEGATIVO pareado — as MESMAS 3 formas, aplicadas corretamente,
+  // não disparam. Sem este par, "sempre empurrar P2/P3/P7" passaria.
+  const semDefeitos = f([
+    '## Acceptance Criteria', '',
+    '**AC-1.** teste. [Guarda] (prova: AC-2)', '```oraculo', 'test -f package.json', '```', '',
+    '**AC-2.** teste', '```oraculo', 'test -f package.json', '```', '',
+    '**AC-3.** teste. [Guarda] (sem irmao — ausência declarada)', '```oraculo', '# espera: stdout-vazio', 'grep -w zzz-inexistente package.json', '```', '',
+    '**AC-4.** teste. [Guarda] (citação de fato pré-existente, não prova de trabalho)', '```oraculo', 'test -f package.json', '```', '',
+  ]);
+  const limpos = hook.evaluateReadyOracles(semDefeitos, validator).filter((h) => ['P2', 'P3', 'P7'].includes(h.predicate));
+  assert(limpos.length === 0, `SF13.9/controle negativo: guardas BEM formados não disparam P2/P3/P7 (disparos: ${limpos.length})`);
+
+  // A escada continua a de 2 degraus: `ask` e nada mais. A negativa é
+  // ESTRUTURAL — o literal da decisão negativa não existe no arquivo (já
+  // coberto por AC-6b), e os 3 novos não abrem exceção a isso.
+  const dir = mkInstalledCopy({});
+  const sp = writeStory(dir, 'x.story.md', f(['## Status', '', 'Draft', '', ...comDefeitos.split('\n')]));
+  const r = runHook(hookPathOf(dir), { tool_name: 'Write', tool_input: { file_path: sp, content: f(['## Status', '', 'Ready', '', ...comDefeitos.split('\n')]) }, cwd: dir });
+  assert(r.decision === 'ask', 'SF13.9: os 3 predicados novos emitem `ask` pela rota real — nunca `deny` (D-Dono-2 não está pago)');
+  assert(/P2|P3|P7/.test(r.reason), 'SF13.9: a razão nomeia os predicados novos');
+
+  // MUTANTE N-6 — o bloco de `[Guarda]` deslocado para DEPOIS do `continue`
+  // de `!hasOraculo`: ACs sem oráculo, mas com guarda malformado, ficam
+  // invisíveis em silêncio. A fixture acima (3 ACs, todos COM oráculo) NÃO
+  // pegaria isso — por isso a fixture abaixo tem um AC SEM oráculo.
+  const semOraculo = f([
+    '## Acceptance Criteria', '',
+    '**AC-1.** teste sem oraculo nenhum. [Guarda] (banana)', '',
+    '**AC-2.** teste', '```oraculo', 'test -f package.json', '```', '',
+  ]);
+  const realP2 = hook.evaluateReadyOracles(semOraculo, validator).filter((h) => h.predicate === 'P2');
+  assert(realP2.length === 1, 'SF13.9/N-6: AC SEM oráculo e COM guarda malformado é visto (o bloco roda ANTES do `continue`)');
+
+  const mutSrc = mutate(fs.readFileSync(HOOK_SRC, 'utf8'), '    if (ac.guarda) {', '    if (ac.guarda && ac.hasOraculo) {', 'N-6');
+  const mutPath = path.join(mkTmp('ero-n6-'), 'mutante.cjs');
+  fs.writeFileSync(mutPath, mutSrc);
+  const mutP2 = require(mutPath).evaluateReadyOracles(semOraculo, validator).filter((h) => h.predicate === 'P2');
+  assert(mutP2.length === 0, 'MUTANTE N-6 (bloco depois do `continue`): o mesmo AC fica INVISÍVEL — logo a asserção acima é quem o mata');
+
+  // Corpus REAL — zero disparo NOVO. Pareado com a prova de que estão ligados
+  // (acima): sem esse par, "zero disparo" passaria por vacuidade.
+  const dirStories = path.join(REPO_ROOT, 'docs', 'stories');
+  const files = fs.readdirSync(dirStories).filter((n) => n.endsWith('.story.md'));
+  let novos = 0;
+  for (const n of files) {
+    const c = fs.readFileSync(path.join(dirStories, n), 'utf8');
+    novos += hook.evaluateReadyOracles(c, validator).filter((h) => ['P2', 'P3', 'P7'].includes(h.predicate)).length;
+  }
+  assert(novos === 0, `SF13.9: zero disparo NOVO de P2/P3/P7 sobre as ${files.length} stories reais (disparos: ${novos})`);
+}
+
+// ---------------------------------------------------------------------------
+
+function main() {
+  console.log('POWER CLAUDE — suíte da trava de Ready (enforce-ready-oracles.cjs, SF13.2 + SF13.9)');
+  try {
+    testDeteccaoDaTransicao();
+    testSilencioCedo();
+    testFonteUnica();
+    testPredicados();
+    testCorpusReais();
+    testFailSafe();
+    testMutantesDaTrava();
+    testTransicaoPorToken();
+    testSkewDoIrmao();
+    testGuardaP2P3P7();
+  } finally {
+    for (const d of tmpDirs) fs.rmSync(d, { recursive: true, force: true });
+  }
+
+  if (failures > 0) {
+    console.error(`\nSuíte FALHOU: ${failures} violação(ões).`);
+    process.exit(1);
+  }
+  console.log('\nSuíte verde.');
+  process.exit(0);
+}
+
+main();