@daniellins/power-claude 0.16.3

package/scripts/__tests__/enforce-cycle-authority.test.cjs

@@ -0,0 +1,869 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * enforce-cycle-authority.test.cjs — suíte real do hook `PreToolUse` das 2
+ * garantias de autoridade do ciclo (Blocos C+D+E, story SF12.3).
+ *
+ * Cobre: os 2 predicados (Done / gate file / Dev×Draft) × os 3 níveis de
+ * identidade do AC19 (papel exigido, papel do roster errado, ambíguo) ×
+ * controles negativos (AC11/AC17) × a mutação dos AC14/AC18 (mutante gerado
+ * em tmp + executado como subprocesso Node com o mesmo payload de um caso
+ * que deveria negar/perguntar — o teste falha se a mutante permitir).
+ */
+
+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-cycle-authority.cjs');
+
+let failures = 0;
+function assert(ok, msg) {
+  if (ok) {
+    console.log(`[OK   ] ${msg}`);
+  } else {
+    console.error(`[FALHA] ${msg}`);
+    failures++;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fixture: repositório fake com branch resolvível + stories Draft/Ready/Done
+// ---------------------------------------------------------------------------
+
+function makeFixtureRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eca-fixture-'));
+  fs.mkdirSync(path.join(dir, '.git'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'docs', 'stories'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'docs', 'qa', 'gates'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+
+  setBranch(dir, 'feat/9.9-teste');
+
+  fs.writeFileSync(
+    path.join(dir, 'docs', 'stories', '9.9.story.md'),
+    '# Story 9.9\n\n## Status\n\nDraft\n\n## Executor Assignment\n',
+  );
+  fs.writeFileSync(
+    path.join(dir, 'docs', 'stories', '9.8.story.md'),
+    '# Story 9.8\n\n## Status\n\nReady\n\n## Executor Assignment\n',
+  );
+  fs.writeFileSync(
+    path.join(dir, 'docs', 'stories', '9.7.story.md'),
+    '# Story 9.7\n\n## Status\n\nDone\n\n## Dev Agent Record\n\n[AUTO-DECISION] algo\n',
+  );
+  fs.writeFileSync(path.join(dir, 'src', 'foo.js'), 'const a = 1;\n');
+  return dir;
+}
+
+function setBranch(dir, branch) {
+  fs.writeFileSync(path.join(dir, '.git', 'HEAD'), `ref: refs/heads/${branch}\n`);
+}
+
+// ---------------------------------------------------------------------------
+// Execução do hook (real ou mutante) como subprocesso Node, via stdin
+// ---------------------------------------------------------------------------
+
+function runHookAtPath(hookPath, rawInput) {
+  const result = spawnSync(process.execPath, [hookPath], {
+    input: rawInput,
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  if (result.error) throw result.error;
+  let decision = null;
+  const out = (result.stdout || '').trim();
+  if (out) {
+    try {
+      const parsed = JSON.parse(out);
+      decision = parsed?.hookSpecificOutput?.permissionDecision || null;
+    } catch {
+      decision = 'UNPARSEABLE_OUTPUT';
+    }
+  }
+  return { decision, stdout: out, stderr: result.stderr, status: result.status };
+}
+
+function runHook(payload) {
+  return runHookAtPath(HOOK_PATH, JSON.stringify(payload));
+}
+
+function payload({ cwd, agentType, agentId = 's-1', toolName, toolInput }) {
+  const p = { cwd, tool_name: toolName, tool_input: toolInput };
+  if (agentId !== undefined) p.agent_id = agentId;
+  if (agentType !== undefined) p.agent_type = agentType;
+  return p;
+}
+
+// ---------------------------------------------------------------------------
+// Predicado 1 — só QA marca Status: Done (Edit/Write em *.story.md)
+// ---------------------------------------------------------------------------
+
+function testPredicate1(fixtureDir) {
+  console.log('\n-- Predicado 1: Status: Done --');
+  const doneEdit = {
+    cwd: fixtureDir,
+    toolName: 'Edit',
+    toolInput: {
+      file_path: path.join(fixtureDir, 'docs', 'stories', '9.9.story.md'),
+      old_string: 'Draft',
+      new_string: 'Done',
+    },
+  };
+
+  assert(
+    runHook(payload({ ...doneEdit, agentType: 'pc-qa' })).decision === null,
+    'pc-qa marca Done → allow (silêncio)',
+  );
+  assert(
+    runHook(payload({ ...doneEdit, agentType: 'pc-dev' })).decision === 'deny',
+    'pc-dev marca Done → deny (papel do roster errado)',
+  );
+  assert(
+    runHook({ cwd: fixtureDir, tool_name: 'Edit', tool_input: doneEdit.toolInput }).decision === 'ask',
+    'main thread (agent_id ausente) marca Done → ask',
+  );
+  assert(
+    runHook(payload({ ...doneEdit, agentType: 'Explore' })).decision === 'ask',
+    'agent_type fora do roster fechado marca Done → ask',
+  );
+
+  // AC10: honra replace_all e Write de arquivo novo (∅ → Done)
+  const newStoryPath = path.join(fixtureDir, 'docs', 'stories', '9.6.story.md');
+  assert(
+    runHook(
+      payload({
+        cwd: fixtureDir,
+        agentType: 'pc-dev',
+        toolName: 'Write',
+        toolInput: { file_path: newStoryPath, content: '# Story 9.6\n\n## Status\n\nDone\n' },
+      }),
+    ).decision === 'deny',
+    'Write de story NOVA (∅ → Done) dispara o predicado — pc-dev nega',
+  );
+  assert(!fs.existsSync(newStoryPath), 'fixture não deveria ter sido escrita de verdade (hook não grava)');
+
+  // AC11a: outra seção de story já Done não dispara
+  assert(
+    runHook(
+      payload({
+        cwd: fixtureDir,
+        agentType: 'pc-dev',
+        toolName: 'Edit',
+        toolInput: {
+          file_path: path.join(fixtureDir, 'docs', 'stories', '9.7.story.md'),
+          old_string: '[AUTO-DECISION] algo',
+          new_string: '[AUTO-DECISION] algo editado',
+        },
+      }),
+    ).decision === null,
+    'AC11a: editar OUTRA seção de story já Done não dispara o predicado',
+  );
+
+  // AC11b: palavra "Done" em prosa fora da seção de Status não dispara
+  fs.writeFileSync(
+    path.join(fixtureDir, 'docs', 'stories', '9.5.story.md'),
+    '# Story 9.5\n\n## Status\n\nDraft\n\n## Contexto\n\na SF12.2, mencionada aqui\n',
+  );
+  assert(
+    runHook(
+      payload({
+        cwd: fixtureDir,
+        agentType: 'pc-dev',
+        toolName: 'Edit',
+        toolInput: {
+          file_path: path.join(fixtureDir, 'docs', 'stories', '9.5.story.md'),
+          old_string: 'a SF12.2, mencionada aqui',
+          new_string: 'a SF12.2 (já Done), mencionada aqui',
+        },
+      }),
+    ).decision === null,
+    'AC11b: "Done" em prosa fora da seção de Status não dispara o predicado',
+  );
+
+  // replace_all
+  fs.writeFileSync(
+    path.join(fixtureDir, 'docs', 'stories', '9.4.story.md'),
+    '# Story 9.4\n\n## Status\n\nInReview\n\n## X\n',
+  );
+  assert(
+    runHook(
+      payload({
+        cwd: fixtureDir,
+        agentType: 'pc-qa',
+        toolName: 'Edit',
+        toolInput: {
+          file_path: path.join(fixtureDir, 'docs', 'stories', '9.4.story.md'),
+          old_string: 'InReview',
+          new_string: 'Done',
+          replace_all: true,
+        },
+      }),
+    ).decision === null,
+    'replace_all honrado na simulação (pc-qa permitido, sem erro)',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Predicado 2 — só QA escreve docs/qa/gates/*.yaml
+// ---------------------------------------------------------------------------
+
+function testPredicate2(fixtureDir) {
+  console.log('\n-- Predicado 2: gate file --');
+  const gatePath = path.join(fixtureDir, 'docs', 'qa', 'gates', '9.9.yaml');
+  const base = { cwd: fixtureDir, toolName: 'Write', toolInput: { file_path: gatePath, content: 'gate: PASS\n' } };
+
+  assert(runHook(payload({ ...base, agentType: 'pc-qa' })).decision === null, 'pc-qa escreve gate file → allow');
+  assert(runHook(payload({ ...base, agentType: 'pc-po' })).decision === 'deny', 'pc-po escreve gate file → deny');
+  assert(
+    runHook({ cwd: fixtureDir, tool_name: 'Write', tool_input: base.toolInput }).decision === 'ask',
+    'main thread escreve gate file → ask',
+  );
+  assert(
+    runHook(payload({ ...base, agentType: 'Explore' })).decision === 'ask',
+    'agent_type fora do roster escreve gate file → ask',
+  );
+  // sem exceção de conteúdo (AC12): dispara mesmo sem "Status"/"Done" no conteúdo
+  assert(
+    runHook(
+      payload({
+        cwd: fixtureDir,
+        agentType: 'pc-dev',
+        toolName: 'Edit',
+        toolInput: { file_path: gatePath, old_string: 'PASS', new_string: 'FAIL' },
+      }),
+    ).decision === 'deny',
+    'Edit em gate file (qualquer conteúdo) dispara igual — superfície inteira é exclusiva do QA',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Predicado 3 — Dev não edita código com a story associada em Draft
+// ---------------------------------------------------------------------------
+
+function testPredicate3(fixtureDir) {
+  console.log('\n-- Predicado 3: Dev × Draft --');
+  setBranch(fixtureDir, 'feat/9.9-teste'); // story 9.9 = Draft
+  const codeEdit = {
+    cwd: fixtureDir,
+    toolName: 'Edit',
+    toolInput: { file_path: path.join(fixtureDir, 'src', 'foo.js'), old_string: 'a', new_string: 'b' },
+  };
+
+  assert(runHook(payload({ ...codeEdit, agentType: 'pc-dev' })).decision === 'ask', 'pc-dev edita código com story Draft → ask (nunca deny)');
+  assert(runHook(payload({ ...codeEdit, agentType: 'pc-qa' })).decision === null, 'AC17: pc-qa edita código com story Draft → allow (predicado é só do Dev)');
+  assert(runHook(payload({ ...codeEdit, agentType: 'pc-po' })).decision === null, 'AC17: pc-po edita código com story Draft → allow');
+  assert(
+    runHook({ cwd: fixtureDir, tool_name: 'Edit', tool_input: codeEdit.toolInput }).decision === 'ask',
+    'main thread edita código com story Draft → ask',
+  );
+  assert(
+    runHook(payload({ ...codeEdit, agentType: 'Explore' })).decision === 'ask',
+    'agent_type fora do roster edita código com story Draft → ask',
+  );
+
+  // AC17: story Ready/InProgress/InReview/Done → Dev não interferido
+  setBranch(fixtureDir, 'feat/9.8-teste'); // story 9.8 = Ready
+  assert(
+    runHook(payload({ ...codeEdit, agentType: 'pc-dev' })).decision === null,
+    'AC17: pc-dev edita código com story Ready → allow (sem interferência)',
+  );
+
+  // AC16: branch fora do padrão → pass-through
+  setBranch(fixtureDir, 'nonsense-branch-sem-barra');
+  assert(
+    runHook(payload({ ...codeEdit, agentType: 'pc-dev' })).decision === null,
+    'AC16: branch fora do padrão → pass-through silencioso',
+  );
+
+  // AC16: token resolvido mas story inexistente em disco → pass-through
+  setBranch(fixtureDir, 'feat/9.999-inexistente');
+  assert(
+    runHook(payload({ ...codeEdit, agentType: 'pc-dev' })).decision === null,
+    'AC16: story inexistente em disco → pass-through silencioso',
+  );
+
+  // AC16: captura sem prefixo fixo — branch docs/ (contraexemplo vivo desta própria story)
+  setBranch(fixtureDir, 'docs/9.9-nome-qualquer');
+  assert(
+    runHook(payload({ ...codeEdit, agentType: 'pc-dev' })).decision === 'ask',
+    'AC16: captura ^[a-z]+/([^/-]+)- resolve story mesmo em branch docs/ (não só feat/)',
+  );
+  setBranch(fixtureDir, 'feat/9.9-teste');
+
+  // Exclusão: editar a própria story (mesmo com story Draft) cai fora do predicado 3
+  assert(
+    runHook(
+      payload({
+        cwd: fixtureDir,
+        agentType: 'pc-dev',
+        toolName: 'Edit',
+        toolInput: {
+          file_path: path.join(fixtureDir, 'docs', 'stories', '9.9.story.md'),
+          old_string: '## Executor Assignment',
+          new_string: '## Executor Assignment\n\nnota',
+        },
+      }),
+    ).decision === null,
+    'editar a própria story (sem tocar Status) não dispara nem predicado 1 nem 3',
+  );
+
+  // Exclusão: qualquer arquivo sob docs/ cai fora do predicado 3
+  fs.mkdirSync(path.join(fixtureDir, 'docs', 'mecanismos'), { recursive: true });
+  fs.writeFileSync(path.join(fixtureDir, 'docs', 'mecanismos', 'x.md'), 'nota\n');
+  assert(
+    runHook(
+      payload({
+        cwd: fixtureDir,
+        agentType: 'pc-dev',
+        toolName: 'Edit',
+        toolInput: {
+          file_path: path.join(fixtureDir, 'docs', 'mecanismos', 'x.md'),
+          old_string: 'nota',
+          new_string: 'nota editada',
+        },
+      }),
+    ).decision === null,
+    'editar qualquer arquivo sob docs/ (não a story) não dispara o predicado 3',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Alcance declarado (Edit/Write apenas) + input malformado (AC22)
+// ---------------------------------------------------------------------------
+
+function testAlcanceEInputMalformado(fixtureDir) {
+  console.log('\n-- Alcance (Edit/Write) + input malformado --');
+  assert(
+    runHook({
+      cwd: fixtureDir,
+      agent_id: 's',
+      agent_type: 'pc-dev',
+      tool_name: 'Bash',
+      tool_input: { command: `sed -i s/Draft/Done/ ${path.join(fixtureDir, 'docs', 'stories', '9.9.story.md')}` },
+    }).decision === null,
+    'Bash fora do alcance declarado (AC10/AC12/AC15) → silêncio, mesmo tentando marcar Done',
+  );
+  assert(
+    runHook({
+      cwd: fixtureDir,
+      agent_id: 's',
+      agent_type: 'pc-dev',
+      tool_name: 'MultiEdit',
+      tool_input: { edits: [{ file_path: 'x', old_string: 'a', new_string: 'b' }] },
+    }).decision === null,
+    'MultiEdit fora do alcance declarado → silêncio',
+  );
+
+  assert(
+    runHookAtPath(HOOK_PATH, 'isto não é json { Status Done quebrado').decision === 'ask',
+    'AC22: JSON ilegível + texto sugere Status/Done → ask (nunca deny)',
+  );
+  assert(
+    runHookAtPath(HOOK_PATH, 'isto não é json docs/qa/gates/x.yaml quebrado').decision === 'ask',
+    'AC22: JSON ilegível + texto sugere gate file → ask',
+  );
+  assert(
+    runHookAtPath(HOOK_PATH, 'lixo totalmente não relacionado').decision === null,
+    'AC22: JSON ilegível sem sugestão de predicado 1/2 → silêncio total (pred. 3 sempre silêncio no ilegível)',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// AC14/AC18 — instrumento de mutação: gera cópia mutante em tmp, executa
+// como subprocesso com payload que deveria negar/perguntar; o teste FALHA
+// se a mutante permitir a operação.
+// ---------------------------------------------------------------------------
+
+function buildMutant(tmpDir) {
+  const source = fs.readFileSync(HOOK_PATH, 'utf8');
+  const target =
+    `function decide(agentType, agentId, { requiredRole, forbiddenRole, denyOnMismatch }) {\n` +
+    `  if (agentId === undefined) return 'ask'; // main thread — sem identidade de subagente\n` +
+    `  if (typeof agentType !== 'string' || !ROSTER.has(agentType)) return 'ask'; // fora do roster fechado\n\n` +
+    `  const isMatch = requiredRole ? agentType === requiredRole : agentType !== forbiddenRole;\n` +
+    `  if (isMatch) return 'allow';\n` +
+    `  return denyOnMismatch ? 'deny' : 'ask';\n` +
+    `}`;
+  const mutated = `function decide(agentType, agentId, { requiredRole, forbiddenRole, denyOnMismatch }) {\n  return 'allow'; // MUTANTE — checagem de identidade removida (AC14/AC18)\n}`;
+
+  if (!source.includes(target)) {
+    throw new Error('Instrumento de mutação desalinhado com o fonte real do hook — AC14/AC18 não são prova válida.');
+  }
+  const mutantSource = source.replace(target, mutated);
+  const mutantPath = path.join(tmpDir, 'enforce-cycle-authority.mutant.cjs');
+  fs.writeFileSync(mutantPath, mutantSource);
+  return mutantPath;
+}
+
+function testMutacao(fixtureDir) {
+  console.log('\n-- AC14/AC18: instrumento de mutação (mutante deve permitir; original deve negar/perguntar) --');
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'eca-mutant-'));
+  const mutantPath = buildMutant(tmpDir);
+
+  setBranch(fixtureDir, 'feat/9.9-teste');
+
+  // AC14 — predicado 1 (Done): payload que o hook REAL nega (pc-dev)
+  const doneDenyPayload = JSON.stringify(
+    payload({
+      cwd: fixtureDir,
+      agentType: 'pc-dev',
+      toolName: 'Edit',
+      toolInput: { file_path: path.join(fixtureDir, 'docs', 'stories', '9.9.story.md'), old_string: 'Draft', new_string: 'Done' },
+    }),
+  );
+  assert(runHookAtPath(HOOK_PATH, doneDenyPayload).decision === 'deny', 'controle: hook REAL nega pc-dev marcando Done (pré-condição da prova)');
+  assert(
+    runHookAtPath(mutantPath, doneDenyPayload).decision === null,
+    'AC14: mutante (checagem de identidade removida) PERMITE pc-dev marcar Done — prova que a checagem real é o que trava',
+  );
+
+  // AC18 — predicado 3 (Dev × Draft): payload que o hook REAL pergunta (pc-dev editando código com story Draft)
+  const draftAskPayload = JSON.stringify(
+    payload({
+      cwd: fixtureDir,
+      agentType: 'pc-dev',
+      toolName: 'Edit',
+      toolInput: { file_path: path.join(fixtureDir, 'src', 'foo.js'), old_string: 'a', new_string: 'b' },
+    }),
+  );
+  assert(runHookAtPath(HOOK_PATH, draftAskPayload).decision === 'ask', 'controle: hook REAL pergunta para pc-dev editando código com story Draft (pré-condição da prova)');
+  assert(
+    runHookAtPath(mutantPath, draftAskPayload).decision === null,
+    'AC18: mutante (checagem removida) PERMITE pc-dev editar código com story Draft — prova que a checagem real é o que trava',
+  );
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+// SF13.9 — `statusToken`/`doneEvidence` e a ESCADA DE 3 DEGRAUS do predicado 1
+// (`ADR-032` Emenda 3, E3.2/E3.9, com a correção factual da Emenda 4).
+//
+// Duas classes de defeito OPOSTAS, no MESMO `.includes('done')` da linha que
+// decidia o predicado, ambas medidas contra o hook antigo:
+//   (a) falso positivo — `InReview — não está Done ainda` negava uma NEGAÇÃO;
+//   (b) bypass em dois passos — `Ready (aguardando o Done do QA)` → `Done`
+//       passava em silêncio, porque o "antes" já mencionava "done" em prosa.
+// Elas têm testes SEPARADOS de propósito: consertar só o lado `depois` mata
+// (a) e deixa (b) trivial, e o mutante M2 abaixo existe para provar que a
+// suíte percebe exatamente esse conserto parcial.
+// ---------------------------------------------------------------------------
+
+const hookMod = require(HOOK_PATH);
+
+// ---------------------------------------------------------------------------
+// SF13.10 — TRIPWIRE do roster de status (`ADR-032` Emenda 5, E5.5).
+//
+// `template/.claude/rules/authority.md` é a FONTE DA VERDADE do roster. A parte
+// load-bearing, e a razão de "as cópias citam a fonte em prosa" não bastar:
+// **DERIVAR NÃO É TRIPWIRE**. Um teste que usa o conjunto derivado do documento
+// COMO SE FOSSE a expectativa fica verde para QUALQUER documento — inclusive um
+// errado (é a classe "AC nasce verde", medida antes de ser prescrita). O
+// tripwire é a IGUALDADE entre um literal escrito à mão AQUI e o conjunto
+// derivado de LÁ: a divergência entre os dois, nos DOIS sentidos, é o que ele
+// detecta. Esta duplicação é deliberada e É o mecanismo, não o defeito — um
+// teste não lê prosa (E5.5 item 3).
+// ---------------------------------------------------------------------------
+
+const AUTHORITY_PATH = path.join(REPO_ROOT, 'template', '.claude', 'rules', 'authority.md');
+
+// Parser ANCORADO por marcador, NUNCA contagem. Marcador ausente devolve
+// `null` — ignorância declarada, jamais conjunto vazio (que seria indistinguível
+// de "um roster de zero status" e deixaria o controle passar em silêncio).
+function deriveRoster(texto) {
+  const m = /^<!--\s*roster:status\s*-->\s*\n(.+)$/m.exec(String(texto || ''));
+  if (!m) return null;
+  return new Set((m[1].match(/`([^`]+)`/g) || []).map((s) => s.slice(1, -1).toLowerCase()));
+}
+
+function setEq(a, b) {
+  if (!a || !b) return false;
+  if (a.size !== b.size) return false;
+  for (const x of a) if (!b.has(x)) return false;
+  return true;
+}
+
+function fmtSet(s) {
+  return s ? `{${[...s].sort().join(', ')}}` : 'null (âncora ausente)';
+}
+
+function testStatusToken() {
+  console.log('\n-- SF13.9: statusToken (token do `## Status`, positivo e negativo) --');
+
+  // POSITIVOS — os 3 passos, cada um com o caso que responde por ele.
+  const positivos = [
+    ['Ready', 'caso base'],
+    ['Ready (validado pelo PO, 10/10)', 'anotação depois do token — o defeito de FINDING-8'],
+    ['Ready — aguardando dev', 'travessão'],
+    ['**Ready**', 'normalizeStatusText (inalterada) responde por este'],
+    ['Ready.', 'pontuação não é parte do token'],
+    ['`Ready`', 'crase é decoração'],
+  ];
+  for (const [texto, porque] of positivos) {
+    assert(hookMod.statusToken(texto) === 'ready', `statusToken(${JSON.stringify(texto)}) === "ready" — ${porque}`);
+  }
+
+  // NEGATIVOS — pareados na MESMA rodada. Sem eles, `() => 'ready'` passaria.
+  const negativos = [
+    ['~~Ready~~', '', '`~` fora da decoração: riscado é ambíguo (a mesma função alimenta um deny)'],
+    ['Readyish', 'readyish', 'não é o token'],
+    ['Not Ready', 'not', 'negação NUNCA dispara — régua da casa aplicada a uma máquina'],
+    ['ainda nao esta Ready', 'ainda', 'idem'],
+    ['', '', 'string vazia'],
+    ['Draft', 'draft', 'outro token do roster'],
+  ];
+  for (const [texto, esperado, porque] of negativos) {
+    const t = hookMod.statusToken(texto);
+    assert(t === esperado && t !== 'ready', `statusToken(${JSON.stringify(texto)}) === ${JSON.stringify(esperado)} (≠ "ready") — ${porque}`);
+  }
+
+  // `InProgress` — o status MANDATÓRIO que faltava nas tabelas de fronteira
+  // (SF13.10; `ADR-032` Emenda 5, E5.1/E5.6 item 3). É o caso alcançável que
+  // teria pego o defeito do roster antes de ele ser publicado 3 vezes: uma
+  // story fica `InProgress` exatamente ENQUANTO um dev trabalha nela, e o
+  // corpus é fotografado no repouso — um controle que só roda no repouso não
+  // observa os estados que só existem em movimento. Duas rotas de entrada:
+  // o dev começando, e cada `FAIL` do gate devolvendo a story ao loop de fix.
+  const emAndamento = [
+    ['InProgress', 'caso base'],
+    ['**InProgress**', 'normalizeStatusText responde por este'],
+    ['`InProgress`', 'crase é decoração'],
+    ['InProgress (AC-3 em curso)', 'anotação depois do token'],
+    ['InProgress — dev trabalhando', 'travessão'],
+  ];
+  for (const [texto, porque] of emAndamento) {
+    assert(hookMod.statusToken(texto) === 'inprogress', `statusToken(${JSON.stringify(texto)}) === "inprogress" — ${porque}`);
+  }
+  // Negativo pareado na MESMA rodada — sem ele, `() => 'inprogress'` passaria.
+  assert(
+    hookMod.statusToken('Not InProgress') === 'not' && hookMod.statusToken('Not InProgress') !== 'inprogress',
+    'statusToken("Not InProgress") === "not" (≠ "inprogress") — negação NUNCA vira o token, também aqui',
+  );
+
+  // `#` FORA da decoração — restrição NORMATIVA (E3.2 + Emenda 4 E4.1/E4.2).
+  // A fixture é `## Done — …` e não `## QA Results — Done`: medido, com `#` no
+  // strip o segundo caso dá token `qa`, não `done`, e o mutante SOBREVIVERIA.
+  assert(
+    hookMod.statusToken('## Done — selado pelo QA') === '',
+    '`#` fora do conjunto de decoração: statusToken("## Done — selado pelo QA") === "" (contém o vazamento de extractStatusSection estruturalmente)',
+  );
+  assert(
+    hookMod.doneEvidence('## Done — selado pelo QA') === 'mencao',
+    'seção VAZADA vira evidência `mencao` (⇒ ask), nunca `token` (⇒ deny) — é esta a contenção do gatilho T-E3-EXTRATOR',
+  );
+
+  // Corpus REAL — guard que sempre dispara — e o LITERAL do tripwire.
+  //
+  // O `roster` abaixo é escrito à mão e serve a DUAS funções: é o conjunto
+  // aceito pelo controle de corpus, e é o lado INDEPENDENTE da igualdade que
+  // detecta divergência contra `authority.md` (o tripwire, logo abaixo).
+  //
+  // FECHAMENTO do achado que a SF13.9 registrou aqui como "NÃO corrigido"
+  // (SF13.10; `ADR-032` Emenda 5, E5.1/E5.3/E5.5) — o comentário anterior
+  // envelheceu e está REMOVIDO, não só substituído: a enumeração de `ADR-032`
+  // `E3.2`/`E3.12` estava errada nos DOIS sentidos. Omitia `inprogress`, que é
+  // MANDATÓRIO no ciclo, e incluía `blocked`, que nenhum documento do framework
+  // define como status de story — o `blocked` do motor de pod/pipeline e o do
+  // `state.json` de `pc-wave` são OUTRO namespace (fase de execução, não
+  // lifecycle), e nunca devem ser unificados por semelhança de nome. Leitura
+  // SUPERADA, não repetir. O roster vigente tem CINCO status e a sua fonte
+  // deixou de ser o ADR: é `template/.claude/rules/authority.md`.
+  //
+  // Custo declarado de tirar `blocked` daqui: se alguém marcar uma story como
+  // `Blocked`, este controle fica VERMELHO. Esse vermelho é o sinal PRETENDIDO,
+  // não um falso positivo — um status sem dono de transição é exatamente o
+  // evento que este guard existe para detectar (gatilho `T-E5-BLOCKED`: se
+  // `Blocked` for desejado, ele entra em `authority.md` PRIMEIRO).
+  const dir = path.join(REPO_ROOT, 'docs', 'stories');
+  const roster = new Set(['draft', 'ready', 'inprogress', 'inreview', 'done']);
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith('.story.md'));
+  const fora = files.filter((f) => !roster.has(hookMod.statusToken(hookMod.extractStatusSection(fs.readFileSync(path.join(dir, f), 'utf8')))));
+  assert(fora.length === 0, `corpus real (${files.length} stories): todo token cai dentro do roster fechado de 5 (fora: ${fora.length}${fora.length ? ` — ${fora.join(', ')}` : ''})`);
+
+  // TRIPWIRE — POSITIVO: o documento REAL bate com o literal, nos dois sentidos.
+  // É esta asserção que quebra se `authority.md` e este teste divergirem, em
+  // QUALQUER direção (status a mais, a menos, renomeado, ou âncora removida).
+  const derivadoReal = deriveRoster(fs.readFileSync(AUTHORITY_PATH, 'utf8'));
+  assert(
+    setEq(derivadoReal, roster),
+    `TRIPWIRE (positivo): roster derivado de authority.md === literal deste teste — derivado=${fmtSet(derivadoReal)}, literal=${fmtSet(roster)}`,
+  );
+
+  // TRIPWIRE — NEGATIVOS: os mutantes APLICADOS, não apenas nomeados (`Emenda
+  // 4`, E4.4). Sem eles um `assert(true)` disfarçado passaria por tripwire.
+  const DOC_OK = '<!-- roster:status -->\n`Draft` · `Ready` · `InProgress` · `InReview` · `Done`\n';
+  const ROSTER_VELHO_DO_ADR = new Set(['draft', 'ready', 'inreview', 'done', 'blocked']);
+  const mutantes = [
+    ['M1 (doc SEM `InProgress` — o defeito real, publicado 3×)', '<!-- roster:status -->\n`Draft` · `Ready` · `InReview` · `Done`\n', roster],
+    ['M2 (doc COM `Blocked` a mais — o defeito oposto)', '<!-- roster:status -->\n`Draft` · `Ready` · `InProgress` · `InReview` · `Done` · `Blocked`\n', roster],
+    ['M3 (âncora AUSENTE — o estado de authority.md antes da SF13.10)', '# Matriz de Autoridade\n\n`Draft` · `Ready` · `InProgress` · `InReview` · `Done`\n', roster],
+    ['M4 (doc correto × literal VELHO do ADR)', DOC_OK, ROSTER_VELHO_DO_ADR],
+    ['M5 (doc renomeia `InProgress` → `WIP`)', '<!-- roster:status -->\n`Draft` · `Ready` · `WIP` · `InReview` · `Done`\n', roster],
+  ];
+  for (const [nome, doc, literal] of mutantes) {
+    const d = deriveRoster(doc);
+    assert(setEq(d, literal) === false, `TRIPWIRE (negativo) ${nome} ⇒ VERMELHO — derivado=${fmtSet(d)}`);
+  }
+
+  // CASO BASE, pareado com os 5 negativos na MESMA rodada: sem ele, um `setEq`
+  // que devolvesse `false` sempre passaria nos 5 acima e o tripwire seria vácuo.
+  assert(
+    setEq(deriveRoster(DOC_OK), roster) === true,
+    'TRIPWIRE (caso base): doc correto × literal correto ⇒ VERDE — prova que os 5 negativos DISCRIMINAM, não que setEq sempre reprova',
+  );
+
+  // ANTI-PADRÃO, medido e não só afirmado: um checador INGÊNUO (que só verifica
+  // "a âncora existe") fica verde no doc correto E no mutante M1. É a prova de
+  // que DERIVAR SOZINHO NÃO É TRIPWIRE — e a razão de o literal independente
+  // acima ser obrigatório, não decorativo (`ADR-032` Emenda 5, E5.5).
+  const ingenuo = (doc) => deriveRoster(doc) !== null;
+  assert(
+    ingenuo(DOC_OK) === true && ingenuo(mutantes[0][1]) === true,
+    'ANTI-PADRÃO: checador "a âncora existe" NÃO discrimina (verde no doc correto E no M1) — derivar sozinho não é tripwire',
+  );
+}
+
+function testDoneEvidence() {
+  console.log('\n-- SF13.9: doneEvidence (3 valores, cada um com caso alcançável) --');
+
+  for (const t of ['Done', 'Done (gate CONCERNS)', '**Done**', '`Done`', 'Done — selado pelo QA']) {
+    assert(hookMod.doneEvidence(t) === 'token', `doneEvidence(${JSON.stringify(t)}) === "token" (evidência FIRME ⇒ deny-capaz)`);
+  }
+  for (const t of ['Not Done', '~~Done~~', 'QA Done', 'Ready (o QA ainda nao marcou Done)', 'Undone', 'Concluida (Done)']) {
+    assert(hookMod.doneEvidence(t) === 'mencao', `doneEvidence(${JSON.stringify(t)}) === "mencao" (ambígua ⇒ ask, NUNCA deny e NUNCA silêncio)`);
+  }
+  // `InProgress` entra aqui (SF13.10, `ADR-032` Emenda 5, E5.6 item 3): uma
+  // story em andamento NÃO está sendo selada, logo o P1 tem de SILENCIAR sobre
+  // ela — inclusive sob decoração e anotação, que é como o dev de fato escreve.
+  for (const t of ['Ready', 'Draft', '', 'InReview', 'InProgress', '**InProgress**', 'InProgress (AC-3 em curso)', 'InProgress — dev trabalhando']) {
+    assert(hookMod.doneEvidence(t) === 'nenhuma', `doneEvidence(${JSON.stringify(t)}) === "nenhuma" (⇒ silêncio)`);
+  }
+
+  // Corpus REAL: o degrau do meio não acrescenta UMA interrupção sequer sobre
+  // material existente — é o controle de ruído do degrau novo.
+  const dir = path.join(REPO_ROOT, 'docs', 'stories');
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith('.story.md'));
+  const contagem = { token: 0, mencao: 0, nenhuma: 0, outro: 0 };
+  for (const f of files) {
+    const ev = hookMod.doneEvidence(hookMod.extractStatusSection(fs.readFileSync(path.join(dir, f), 'utf8')));
+    if (contagem[ev] === undefined) contagem.outro += 1;
+    else contagem[ev] += 1;
+  }
+  assert(
+    contagem.mencao === 0 && contagem.outro === 0 && contagem.token + contagem.nenhuma === files.length,
+    `corpus real (${files.length} stories): mencao=${contagem.mencao}, fora dos 3 valores=${contagem.outro} — o degrau novo não gera ruído sobre material existente`,
+  );
+}
+
+// Payload de transição de `## Status` por Write, com "antes" real em disco.
+function transicao(dir, antes, depois, agentType) {
+  const p = path.join(dir, 'w.story.md');
+  fs.writeFileSync(p, `## Status\n\n${antes}\n`);
+  const input = { tool_name: 'Write', tool_input: { file_path: p, content: `## Status\n\n${depois}\n` }, cwd: dir };
+  if (agentType !== undefined) {
+    input.agent_type = agentType;
+    input.agent_id = 'sub-1';
+  }
+  return input;
+}
+
+function testEscadaDoPredicado1() {
+  console.log('\n-- SF13.9: predicado 1, a escada de 3 degraus (os 4 desfechos) --');
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eca-escada-'));
+
+  // Degrau 1 — evidência FIRME ⇒ deny-capaz.
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', 'Done', 'pc-dev')) === 'deny', 'Draft→Done com pc-dev ⇒ deny (evidência firme + papel positivamente errado)');
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', 'Done', 'pc-qa')) === 'allow', 'Draft→Done com pc-qa ⇒ allow (silêncio) — o papel exigido não é interrompido');
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', 'Done', undefined)) === 'ask', 'Draft→Done sem identidade (main thread) ⇒ ask — identidade ambígua nunca vira deny');
+
+  // Degrau 2 — evidência AMBÍGUA ⇒ ask. Os 2 casos do dono.
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', 'InReview — nao esta Done ainda', 'pc-dev')) === 'ask', 'FALSO POSITIVO FECHADO: Draft→"InReview — nao esta Done ainda" ⇒ ask, não mais deny');
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', 'Ready (o QA ainda nao marcou Done)', 'pc-dev')) === 'ask', 'Draft→"Ready (o QA ainda nao marcou Done)" ⇒ ask (menção, não token)');
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', '~~Done~~', 'pc-dev')) === 'ask', 'Draft→"~~Done~~" ⇒ ask — riscado é ambíguo, nunca deny');
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', 'QA Done', 'pc-dev')) === 'ask', 'Draft→"QA Done" ⇒ ask — NÃO negar, mas também NUNCA calar (é o bypass que o token puro abriria)');
+
+  // Degrau 3 — ausência de evidência ⇒ silêncio.
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', 'Ready', 'pc-dev')) === null, 'Draft→Ready puro com pc-dev ⇒ silêncio (o predicado 1 não é sobre Ready)');
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Draft', 'InReview', 'pc-dev')) === null, 'Draft→InReview ⇒ silêncio');
+
+  // "Já estava Done" ⇒ silêncio (token no `antes`, e SÓ token).
+  assert(hookMod.evaluatePredicate1(transicao(dir, 'Done', 'Done (gate CONCERNS)', 'pc-dev')) === null, 'Done→Done (gate CONCERNS) ⇒ silêncio — já estava Done, não é transição');
+
+  // O BYPASS EM DOIS PASSOS, fechado. Menção no "antes" NÃO é "já estava Done".
+  assert(
+    hookMod.evaluatePredicate1(transicao(dir, 'Ready (aguardando o Done do QA)', 'Done', 'pc-dev')) === 'deny',
+    'BYPASS FECHADO: "Ready (aguardando o Done do QA)"→Done com pc-dev ⇒ deny (antes era `mencao`, não `token`)',
+  );
+  assert(
+    hookMod.evaluatePredicate1(transicao(dir, 'Not Done', 'Done', 'pc-dev')) === 'deny',
+    'BYPASS FECHADO (2ª forma): "Not Done"→Done com pc-dev ⇒ deny',
+  );
+
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+function testMotivoNomeado() {
+  console.log('\n-- SF13.9: o ask por EVIDÊNCIA ambígua é distinguível do ask por IDENTIDADE ambígua --');
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eca-motivo-'));
+  const RE_AMBIGUA = /evid[eê]ncia amb[ií]gua/i;
+
+  const porEvidencia = runHookAtPath(HOOK_PATH, JSON.stringify(transicao(dir, 'Draft', 'Ready (o QA ainda nao marcou Done)', 'pc-dev')));
+  assert(porEvidencia.decision === 'ask', 'rota real: evidência ambígua ⇒ ask');
+  assert(RE_AMBIGUA.test(porEvidencia.stdout), 'rota real: a razão NOMEIA "evidência ambígua" — decisão nua não distingue os dois motivos');
+
+  const porIdentidade = runHookAtPath(HOOK_PATH, JSON.stringify(transicao(dir, 'Draft', 'Done', undefined)));
+  assert(porIdentidade.decision === 'ask', 'rota real: identidade ambígua (evidência FIRME) ⇒ ask');
+  assert(
+    !RE_AMBIGUA.test(porIdentidade.stdout),
+    'CONTROLE NEGATIVO: o ask por identidade ambígua NÃO diz "evidência ambígua" — senão rotular todo ask passaria',
+  );
+
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+function testPredicate3PorToken(fixtureDir) {
+  console.log('\n-- SF13.9: predicado 3 decide por token (prosa no Status não o cega) --');
+  const storyPath = path.join(fixtureDir, 'docs', 'stories', '9.9.story.md');
+  const original = fs.readFileSync(storyPath, 'utf8');
+  setBranch(fixtureDir, 'feat/9.9-teste');
+  const codigo = { cwd: fixtureDir, tool_name: 'Edit', tool_input: { file_path: path.join(fixtureDir, 'src', 'foo.js') }, agent_type: 'pc-dev', agent_id: 'sub-1' };
+
+  fs.writeFileSync(storyPath, '# Story 9.9\n\n## Status\n\nDraft (aguardando PO)\n');
+  assert(hookMod.evaluatePredicate3(codigo) === 'ask', 'P3: story em "Draft (aguardando PO)" ⇒ ask (a igualdade estrita ficava MUDA aqui)');
+
+  fs.writeFileSync(storyPath, '# Story 9.9\n\n## Status\n\nReady (validado pelo PO)\n');
+  assert(hookMod.evaluatePredicate3(codigo) === null, 'P3: story em "Ready (validado pelo PO)" ⇒ silêncio (controle negativo pareado)');
+
+  fs.writeFileSync(storyPath, '# Story 9.9\n\n## Status\n\nNot Draft\n');
+  assert(hookMod.evaluatePredicate3(codigo) === null, 'P3: "Not Draft" ⇒ silêncio — negação nunca dispara');
+
+  fs.writeFileSync(storyPath, original);
+}
+
+// ---------------------------------------------------------------------------
+// Mutantes de CLASSE da escada. `E3.12` item 12 é explícito: revertido
+// `doneEvidence` para `.includes('done')` nos dois lados, DOIS testes têm de
+// ficar vermelhos — um o falso positivo, outro o bypass. Se só um cair, a
+// escada não está completa.
+// ---------------------------------------------------------------------------
+
+const MARCADOR_EVIDENCIA = [
+  '  const antes = doneEvidence(extractStatusSection(sim.before));',
+  '  const depois = doneEvidence(extractStatusSection(sim.after));',
+].join('\n');
+
+const INCLUDES_ANTES = "  const antes = normalizeStatusText(extractStatusSection(sim.before)).includes('done') ? 'token' : 'nenhuma';";
+const INCLUDES_DEPOIS = "  const depois = normalizeStatusText(extractStatusSection(sim.after)).includes('done') ? 'token' : 'nenhuma';";
+
+function buildVariante(tmpDir, nome, marcador, substituto) {
+  const source = fs.readFileSync(HOOK_PATH, 'utf8');
+  if (!source.includes(marcador)) {
+    throw new Error(`Instrumento de mutação desalinhado com o fonte real (${nome}) — este teste não é prova válida.`);
+  }
+  const p = path.join(tmpDir, `enforce-cycle-authority.${nome}.cjs`);
+  fs.writeFileSync(p, source.split(marcador).join(substituto));
+  return require(p);
+}
+
+function testMutantesDaEscada() {
+  console.log('\n-- SF13.9: mutantes de classe da escada (as 2 direções de erro, separadas) --');
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'eca-escada-mut-'));
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eca-escada-fix-'));
+
+  const falsoPositivo = () => transicao(dir, 'Draft', 'InReview — nao esta Done ainda', 'pc-dev');
+  const bypass = () => transicao(dir, 'Ready (aguardando o Done do QA)', 'Done', 'pc-dev');
+
+  // M1 — `.includes('done')` nos DOIS lados (o predicado superado, inteiro).
+  const m1 = buildVariante(tmpDir, 'M1', MARCADOR_EVIDENCIA, `${INCLUDES_ANTES}\n${INCLUDES_DEPOIS}`);
+  assert(m1.evaluatePredicate1(falsoPositivo()) === 'deny', 'MUTANTE M1 (includes nos 2 lados): ressuscita o FALSO POSITIVO (deny sobre uma negação) — logo o teste do degrau do meio o derruba');
+  assert(m1.evaluatePredicate1(bypass()) === null, 'MUTANTE M1: ressuscita o BYPASS (silêncio) — logo o teste do bypass o derruba. São 2 testes distintos, como o ADR exige');
+
+  // M2 — SÓ o lado `depois` consertado: o conserto parcial que ABRE o bypass.
+  // É o mutante mais importante da story: hoje o passo 1 do bypass é barrado
+  // pelo próprio falso positivo; conserte só o `depois` e os 2 passos ficam
+  // triviais. O falso positivo fica CERTO aqui — só o bypass o denuncia.
+  const m2 = buildVariante(tmpDir, 'M2', MARCADOR_EVIDENCIA, `${INCLUDES_ANTES}\n  const depois = doneEvidence(extractStatusSection(sim.after));`);
+  assert(m2.evaluatePredicate1(falsoPositivo()) === 'ask', 'MUTANTE M2 (só o `depois` consertado): o falso positivo fica CERTO — este teste NÃO o pega, de propósito');
+  assert(m2.evaluatePredicate1(bypass()) === null, 'MUTANTE M2: o BYPASS continua ABERTO (silêncio) — quem o mata é o teste do bypass, e só ele');
+
+  // M3 — só o lado `antes` consertado (a direção oposta de M2).
+  const m3 = buildVariante(tmpDir, 'M3', MARCADOR_EVIDENCIA, `  const antes = doneEvidence(extractStatusSection(sim.before));\n${INCLUDES_DEPOIS}`);
+  assert(m3.evaluatePredicate1(falsoPositivo()) === 'deny', 'MUTANTE M3 (só o `antes` consertado): o FALSO POSITIVO volta — distinto de M2, como o ADR exige');
+
+  // M4 — `#` acrescentado ao strip de decoração (a restrição normativa).
+  const m4 = buildVariante(tmpDir, 'M4', "norm.replace(/^[\\s*_`]+/, '')", "norm.replace(/^[\\s*_`#]+/, '')");
+  assert(m4.statusToken('## Done — selado pelo QA') === 'done', 'MUTANTE M4 (`#` no strip): seção VAZADA passa a produzir token `done` ⇒ deny — logo a asserção de `#`-fora-da-decoração o derruba');
+
+  // M5 — `~` acrescentado ao strip: `~~Done~~` viraria deny sobre riscado.
+  const m5 = buildVariante(tmpDir, 'M5', "norm.replace(/^[\\s*_`]+/, '')", "norm.replace(/^[\\s*_~`]+/, '')");
+  assert(m5.doneEvidence('~~Done~~') === 'token', 'MUTANTE M5 (`~` no strip): `~~Done~~` viraria evidência FIRME ⇒ deny sobre status riscado');
+
+  // M6 — degrau do meio arrancado: menção volta a virar silêncio.
+  const m6 = buildVariante(
+    tmpDir,
+    'M6',
+    "  if (depois === 'mencao' && antes === 'nenhuma') {",
+    '  if (false) {',
+  );
+  assert(m6.evaluatePredicate1(falsoPositivo()) === null, 'MUTANTE M6 (degrau do meio removido): a menção vira SILÊNCIO — trocaria um falso positivo caro por um falso negativo silencioso');
+
+  // M7 — P3 de volta à igualdade estrita.
+  const m7 = buildVariante(tmpDir, 'M7', '  const status = statusToken(extractStatusSection(storyContent));', '  const status = normalizeStatusText(extractStatusSection(storyContent));');
+  const fx = makeFixtureRepo();
+  setBranch(fx, 'feat/9.9-teste');
+  fs.writeFileSync(path.join(fx, 'docs', 'stories', '9.9.story.md'), '## Status\n\nDraft (aguardando PO)\n');
+  assert(
+    m7.evaluatePredicate3({ cwd: fx, tool_name: 'Edit', tool_input: { file_path: path.join(fx, 'src', 'foo.js') }, agent_type: 'pc-dev', agent_id: 'sub-1' }) === null,
+    'MUTANTE M7 (P3 sem token): prosa no Status volta a CEGAR o predicado 3',
+  );
+  fs.rmSync(fx, { recursive: true, force: true });
+
+  // M8 — `buildMessage` nomeia "evidência ambígua" em TODO ask do predicado 1.
+  const m8src = fs.readFileSync(HOOK_PATH, 'utf8');
+  const marcadorMsg = "    if (ev === 'mencao') {";
+  if (!m8src.includes(marcadorMsg)) throw new Error('Instrumento de mutação desalinhado (M8).');
+  const m8path = path.join(tmpDir, 'enforce-cycle-authority.M8.cjs');
+  fs.writeFileSync(m8path, m8src.split(marcadorMsg).join('    if (true) {'));
+  const m8out = runHookAtPath(m8path, JSON.stringify(transicao(dir, 'Draft', 'Done', undefined)));
+  assert(
+    /evid[eê]ncia amb[ií]gua/i.test(m8out.stdout),
+    'MUTANTE M8 (rótulo em todo ask): o ask por IDENTIDADE ambígua passa a dizer "evidência ambígua" — logo o controle negativo o derruba',
+  );
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+
+function main() {
+  console.log('POWER CLAUDE — suíte do hook enforce-cycle-authority.cjs (SF12.3, Blocos C+D+E+L; SF13.9, escada de 3 degraus)\n');
+  const fixtureDir = makeFixtureRepo();
+  try {
+    testPredicate1(fixtureDir);
+    testPredicate2(fixtureDir);
+    testPredicate3(fixtureDir);
+    testAlcanceEInputMalformado(fixtureDir);
+    testMutacao(fixtureDir);
+    testStatusToken();
+    testDoneEvidence();
+    testEscadaDoPredicado1();
+    testMotivoNomeado();
+    testPredicate3PorToken(fixtureDir);
+    testMutantesDaEscada();
+  } finally {
+    fs.rmSync(fixtureDir, { 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();