@daniellins/power-claude 0.16.3

package/scripts/__fixtures__/veto-checks/phash/make-fixtures.cjs

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * make-fixtures.cjs — GERADOR determinístico dos PNGs de fixture do veto `phash-gate.cjs`
+ * (Story SF10.8). NÃO é script de produção (vive sob __fixtures__/, excluído do manifesto
+ * ADR-007): existe para que a calibração do limiar seja AUDITÁVEL e REPRODUZÍVEL — o QA
+ * regenera, altera a agressividade da "cópia" e re-mede a margem sem depender de binários
+ * opacos comitados no repo.
+ *
+ * ZERO-DEP: encoder PNG (RGB8, filtro 0) escrito à mão sobre `node:zlib` — nenhuma lib npm.
+ * PRNG determinístico (LCG com semente fixa) ⇒ os bytes gerados são idênticos a cada rodada.
+ *
+ * Uso: node scripts/__fixtures__/veto-checks/phash/make-fixtures.cjs [dir-de-saida]
+ *
+ * Saída (o "cenário" de calibração):
+ *   ref.png       — a REFERÊNCIA (papel da referência Pinterest do run)
+ *   copy.png      — CÓPIA ADVERSARIAL da referência: crop 4% + reescala + rotação de canal
+ *                   (recolor) + brilho + ruído. Um observador razoável diz "é a mesma imagem".
+ *                   DEVE ser VETADA.
+ *   distinct.png  — peça LEGÍTIMA de composição/paleta próprias. DEVE PASSAR.
+ *   distinct2.png — 2ª peça legítima (o par capa+CTA do veredito POR-IMAGEM).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const zlib = require('node:zlib');
+
+const W = 512;
+const H = 640;
+
+// --- PNG (RGB8, sem filtro) --------------------------------------------------
+const CRC_TABLE = (() => {
+  const t = new Int32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+    t[n] = c;
+  }
+  return t;
+})();
+function crc32(buf) {
+  let c = 0xFFFFFFFF;
+  for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xFF] ^ (c >>> 8);
+  return (c ^ 0xFFFFFFFF) >>> 0;
+}
+function chunk(type, data) {
+  const len = Buffer.alloc(4); len.writeUInt32BE(data.length, 0);
+  const td = Buffer.concat([Buffer.from(type, 'ascii'), data]);
+  const crc = Buffer.alloc(4); crc.writeUInt32BE(crc32(td), 0);
+  return Buffer.concat([len, td, crc]);
+}
+/** Codifica pixels RGB (Uint8Array de W*H*3) em PNG. */
+function encodePng(px, w, h) {
+  const raw = Buffer.alloc(h * (1 + w * 3));
+  for (let y = 0; y < h; y++) {
+    raw[y * (1 + w * 3)] = 0; // filtro None
+    px.copy
+      ? px.copy(raw, y * (1 + w * 3) + 1, y * w * 3, (y + 1) * w * 3)
+      : Buffer.from(px.subarray(y * w * 3, (y + 1) * w * 3)).copy(raw, y * (1 + w * 3) + 1);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(w, 0); ihdr.writeUInt32BE(h, 4);
+  ihdr[8] = 8; ihdr[9] = 2; ihdr[10] = 0; ihdr[11] = 0; ihdr[12] = 0; // 8bit, truecolor
+  return Buffer.concat([
+    Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
+    chunk('IHDR', ihdr),
+    chunk('IDAT', zlib.deflateSync(raw, { level: 9 })),
+    chunk('IEND', Buffer.alloc(0)),
+  ]);
+}
+
+// --- desenho ----------------------------------------------------------------
+function canvas(w, h) { return Buffer.alloc(w * h * 3); }
+const clamp = (v) => (v < 0 ? 0 : v > 255 ? 255 : v | 0);
+function setPx(buf, w, x, y, r, g, b) {
+  const i = (y * w + x) * 3;
+  buf[i] = clamp(r); buf[i + 1] = clamp(g); buf[i + 2] = clamp(b);
+}
+function rect(buf, w, x0, y0, x1, y1, c) {
+  for (let y = Math.max(0, y0); y < Math.min(H, y1); y++) {
+    for (let x = Math.max(0, x0); x < Math.min(w, x1); x++) setPx(buf, w, x, y, c[0], c[1], c[2]);
+  }
+}
+function disc(buf, w, cx, cy, r, c) {
+  for (let y = Math.max(0, cy - r); y < Math.min(H, cy + r); y++) {
+    for (let x = Math.max(0, cx - r); x < Math.min(w, cx + r); x++) {
+      const dx = x - cx; const dy = y - cy;
+      if (dx * dx + dy * dy <= r * r) setPx(buf, w, x, y, c[0], c[1], c[2]);
+    }
+  }
+}
+function tri(buf, w, x0, y0, size, c) { // triângulo retângulo (cateto = size)
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size - y; x++) setPx(buf, w, x0 + x, y0 + y, c[0], c[1], c[2]);
+  }
+}
+
+/** PRNG determinístico (LCG) — fixtures byte-idênticas a cada geração. */
+function lcg(seed) {
+  let s = seed >>> 0;
+  return () => { s = (Math.imul(s, 1664525) + 1013904223) >>> 0; return s / 4294967296; };
+}
+
+/** REFERÊNCIA: gradiente escuro + disco claro + barras + triângulo (composição forte). */
+function drawRef() {
+  const buf = canvas(W, H);
+  for (let y = 0; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      const t = y / H;
+      setPx(buf, W, x, y, 20 + 60 * t + (x / W) * 30, 24 + 20 * t, 70 + 120 * (1 - t));
+    }
+  }
+  disc(buf, W, 150, 170, 105, [240, 214, 120]);
+  rect(buf, W, 40, 330, 470, 366, [250, 250, 250]);
+  rect(buf, W, 40, 392, 330, 424, [250, 250, 250]);
+  rect(buf, W, 40, 450, 400, 478, [180, 180, 190]);
+  tri(buf, W, 300, 500, 170, [230, 90, 60]);
+  return buf;
+}
+
+/** PEÇA LEGÍTIMA 1: fundo claro, composição e paleta próprias. */
+function drawDistinct() {
+  const buf = canvas(W, H);
+  for (let y = 0; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      const t = x / W;
+      setPx(buf, W, x, y, 235 - 40 * t, 238 - 20 * (y / H), 228 - 60 * t);
+    }
+  }
+  rect(buf, W, 0, 0, W, 96, [18, 92, 76]);
+  disc(buf, W, 400, 520, 90, [24, 40, 120]);
+  rect(buf, W, 60, 180, 200, 470, [200, 60, 90]);
+  rect(buf, W, 230, 240, 300, 400, [40, 40, 40]);
+  return buf;
+}
+
+/** PEÇA LEGÍTIMA 2: outra composição (o par capa+CTA do veredito por-imagem). */
+function drawDistinct2() {
+  const buf = canvas(W, H);
+  for (let y = 0; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      const d = Math.abs(x - W / 2) / (W / 2);
+      setPx(buf, W, x, y, 40 + 120 * d, 130 - 60 * d, 60 + 30 * (y / H));
+    }
+  }
+  rect(buf, W, 0, 240, W, 300, [255, 255, 255]);
+  rect(buf, W, 0, 340, W, 372, [255, 255, 255]);
+  disc(buf, W, 256, 560, 70, [10, 10, 10]);
+  return buf;
+}
+
+/**
+ * CÓPIA ADVERSARIAL da referência (o ataque que o veto TEM de pegar):
+ * crop de 4% em cada borda + reescala de volta (nearest) + rotação leve de canais (recolor)
+ * + ganho de brilho + ruído determinístico. Nenhum byte em comum; a MESMA imagem aos olhos.
+ */
+function drawCopy(ref) {
+  const out = canvas(W, H);
+  const rnd = lcg(20260731);
+  const mx = Math.round(W * 0.04);
+  const my = Math.round(H * 0.04);
+  const cw = W - 2 * mx;
+  const ch = H - 2 * my;
+  // Ruído em BLOCOS 8×8 (artefato de compressão, não chuvisco por pixel): igualmente eficaz
+  // contra igualdade de bytes e MUITO mais compressível — o PNG de fixture fica leve.
+  const nb = new Float32Array(Math.ceil(W / 8) * Math.ceil(H / 8));
+  for (let i = 0; i < nb.length; i++) nb[i] = (rnd() - 0.5) * 10;
+  for (let y = 0; y < H; y++) {
+    const sy = my + Math.min(ch - 1, Math.floor((y / H) * ch));
+    for (let x = 0; x < W; x++) {
+      const sx = mx + Math.min(cw - 1, Math.floor((x / W) * cw));
+      const i = (sy * W + sx) * 3;
+      const n = nb[(y >> 3) * Math.ceil(W / 8) + (x >> 3)];
+      // recolor: mistura leve entre canais + brilho (preserva a estrutura luminante)
+      const r = ref[i] * 0.92 + ref[i + 2] * 0.08 + 10 + n;
+      const g = ref[i + 1] * 0.94 + ref[i] * 0.06 + 8 + n;
+      const b = ref[i + 2] * 0.90 + ref[i + 1] * 0.10 + 12 + n;
+      setPx(out, W, x, y, r, g, b);
+    }
+  }
+  return out;
+}
+
+function main() {
+  const outDir = process.argv[2] ? path.resolve(process.argv[2]) : __dirname;
+  fs.mkdirSync(outDir, { recursive: true });
+  const ref = drawRef();
+  const files = {
+    'ref.png': ref,
+    'copy.png': drawCopy(ref),
+    'distinct.png': drawDistinct(),
+    'distinct2.png': drawDistinct2(),
+  };
+  for (const [name, px] of Object.entries(files)) {
+    const p = path.join(outDir, name);
+    fs.writeFileSync(p, encodePng(px, W, H));
+    console.log(`escrito: ${p} (${fs.statSync(p).size}B)`);
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = { encodePng, drawRef, drawCopy, drawDistinct, drawDistinct2, W, H };

package/scripts/__fixtures__/veto-checks/slide-ok.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="pt-br"><head><meta charset="utf-8"><title>Slide 1</title>
+<style>
+  *{margin:0;padding:0;box-sizing:border-box}
+  html,body{width:1080px;height:1350px;overflow:hidden;font-family:Arial,Helvetica,sans-serif}
+  .slide{width:1080px;height:1350px;padding:80px;background:#0b1e3a;color:#fff;display:flex;flex-direction:column;justify-content:center}
+  h1{font-size:88px;line-height:1.2;margin-bottom:40px}
+  p{font-size:44px;line-height:1.35;max-width:900px}
+</style></head>
+<body>
+  <div class="slide">
+    <h1>Notícia do dia</h1>
+    <p>Resumo que cabe folgado na moldura de 1080 por 1350, sem estourar nenhuma caixa.</p>
+  </div>
+</body></html>

package/scripts/__fixtures__/veto-checks/slide-overflow.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="pt-br"><head><meta charset="utf-8"><title>Slide quebrado</title>
+<style>
+  *{margin:0;padding:0;box-sizing:border-box}
+  html,body{width:1080px;height:1350px;overflow:hidden;font-family:Arial,Helvetica,sans-serif}
+  .slide{width:1080px;height:1350px;padding:80px;background:#0b1e3a;color:#fff}
+  /* DEFEITO REAL da R5: título numa única linha sem quebra, 2400px de largura → corta na moldura de 1080. */
+  h1{font-size:120px;white-space:nowrap;width:2400px}
+</style></head>
+<body>
+  <div class="slide">
+    <h1>Manchete longa demais que não quebra de linha e estoura a largura</h1>
+  </div>
+</body></html>

package/scripts/__fixtures__/veto-checks/sweep-pod/agents/vc-checker.md

@@ -0,0 +1,13 @@
+---
+name: vc-checker
+description: "Agente de FIXTURE da etapa \"check\" de sweep-pod. Existe para satisfazer a leitura obrigatória da etapa (SF11.2/ADR-021 DF-SF11.2-4): agente declarado no wf tem de existir em disco."
+model: sonnet
+budget_tokens: 200
+---
+
+# vc-checker — agente de fixture (etapa "check")
+
+Fixture de teste, não é agente de produção. O conteúdo é irrelevante para as provas
+que usam este pod; o que importa é que o arquivo EXISTA, porque desde a Story SF11.2
+o runner resolve e verifica `agents/<step.agent>.md` antes de despachar a etapa, e o
+validador estático checa a mesma existência (paridade com `pod-export-compile.cjs:214`).

package/scripts/__fixtures__/veto-checks/sweep-pod/templates/check-tmpl.md

@@ -0,0 +1,6 @@
+# Artefato da etapa `check`
+
+## Body
+
+Conteúdo textual do artefato. A FORMA (este heading `## Body`) é verificada por
+checkTemplateConformance; o veto `command_check` (lexical) roda sobre o texto.

package/scripts/__fixtures__/veto-checks/sweep-pod/workflows/wf-vc.smoke.json

@@ -0,0 +1,10 @@
+{
+  "_comment": "Sidecar do wf-vc (SF7.2). 'artifacts' = conforme por etapa (passa template E veto). 'violations' = fixture de violação por etapa para o command_check (conforme ao template, mas o script blessed bloqueia). Sem 'violations[check]' o sweep é UNDERIVÁVEL fail-loud (ADR-011 Decisão 4).",
+  "target_step": "check",
+  "artifacts": {
+    "check": "## Body\n\nTexto limpo, sem travessao, passa no lexical-check.\n"
+  },
+  "violations": {
+    "check": "## Body\n\nTexto com travessao — aqui — que o lexical-check bloqueia.\n"
+  }
+}

package/scripts/__fixtures__/veto-checks/sweep-pod/workflows/wf-vc.yaml

@@ -0,0 +1,19 @@
+# wf-vc — workflow-fixture do SWEEP de command_check (Story SF7.2/ADR-011 Decisão 4).
+# NÃO é pod de produção. Existe só para provar que o sweep bloqueia por uma fixture de
+# violação DECLARADA no sidecar (scenario.violations), e que a ausência dessa fixture é
+# UNDERIVÁVEL fail-loud. O veto é command_check lexical-check (blessed, Node puro).
+state_machine:
+  states: [init, running, complete, failed]
+  initial: init
+  terminal: [complete, failed]
+steps:
+  - id: check
+    agent: vc-checker
+    template: templates/check-tmpl.md
+    inputs: [pedido]
+    outputs: [artefato]
+    depends_on: []
+    checkpoint: null
+    veto:
+      assertions:
+        - { type: command_check, command: "lexical-check.cjs", args: ["--max", "0"] }

package/scripts/__fixtures__/voz-do-dono/README.md

@@ -0,0 +1,23 @@
+# Fixtures — guarda de voz do dono (SF7.9 / ADR-013)
+
+Provas reproduzíveis da checagem híbrida (veto léxico de máquina + checkpoint de julgamento)
+e da retrocompat do `dono.yaml`.
+
+## Arquivos
+
+- `dono-guia.yaml` — bloco `voz:` ESTRUTURADO (forma nova, ADR-013 Decisão 2). O veto do
+  workflow deriva os args de `voz.lexico_proibido` em tempo de AUTORIA (args literais,
+  ADR-011).
+- `dono-escalar.yaml` — forma ESCALAR antiga (`voz: "primeira pessoa"`), que permanece
+  VÁLIDA: nenhum script do motor parseia `dono.yaml` (dado de instância consumido pelo
+  AGENTE; a golden rule interpreta o escalar como `voz.pessoa: "primeira"` + defaults e
+  oferece upgrade). Retrocompat é por indiferença de máquina + prosa do agente.
+- `peca-com-lexico-proibido.md` — peça VIOLANDO o léxico do guia (contém em-dash). O
+  blessed real bloqueia:
+  `node scripts/veto-checks/lexical-check.cjs scripts/__fixtures__/voz-do-dono/peca-com-lexico-proibido.md --max 0 --pattern "[—–]"` → exit 1.
+- `peca-limpa-1a-pessoa.md` — peça conforme (1ª pessoa, sem tokens banidos) → exit 0.
+- `peca-3a-pessoa.md` — o DEFEITO REAL da R2 do benchmark: cita o dono em 3ª pessoa como
+  fonte externa, SEM nenhum token do léxico proibido. O `lexical-check.cjs` dá exit 0
+  (a máquina NÃO pega — e não deve tentar por regex, ADR-013 Decisão 3/Risco 2): quem pega é
+  a cláusula de voz do CHECKPOINT (julgamento humano) em `wf-content-carousel.yaml`.
+  Este fixture é a prova de que a 3ª pessoa NÃO virou regex.

package/scripts/__fixtures__/voz-do-dono/dono-escalar.yaml

@@ -0,0 +1,9 @@
+# Fixture — dono.yaml na forma ESCALAR antiga (pré-ADR-013). Continua VÁLIDO (retrocompat):
+# o agente interpreta `voz` escalar como `voz.pessoa: "primeira"` com defaults e oferece o
+# upgrade na ativação; nenhum script do motor parseia este arquivo. Dono FICTÍCIO.
+dono:
+  nome: "Alexa Exemplo"
+  handle: "@alexa.exemplo"
+  autoridade: "Automação para pequenos negócios, testada em campo"
+  voz: "primeira pessoa"
+  acao_padrao_cta: "seguir"

package/scripts/__fixtures__/voz-do-dono/dono-guia.yaml

@@ -0,0 +1,10 @@
+# Fixture — dono.yaml com o bloco `voz:` estruturado (ADR-013 Decisão 2). Dono FICTÍCIO.
+dono:
+  nome: "Alexa Exemplo"
+  handle: "@alexa.exemplo"
+  autoridade: "Automação para pequenos negócios, testada em campo"
+  acao_padrao_cta: "seguir"
+  voz:
+    pessoa: "primeira"
+    lexico_proibido: ["—", "–"]
+    tom: "direto, técnico sem jargão, sem hype"

package/scripts/__fixtures__/voz-do-dono/peca-3a-pessoa.md

@@ -0,0 +1,6 @@
+# Slide de exemplo (fixture do DEFEITO R2: 3ª pessoa, SEM token proibido)
+
+Como explica Alexa Exemplo, referência em automação para pequenos negócios, a ferramenta
+resolve o problema quando bem configurada. Para Alexa, o segredo é começar pequeno.
+
+confianca: alta

package/scripts/__fixtures__/voz-do-dono/peca-com-lexico-proibido.md

@@ -0,0 +1,6 @@
+# Slide de exemplo (fixture de VIOLAÇÃO léxica)
+
+Testei essa ferramenta na minha rotina — e o resultado me surpreendeu.
+Ela resolve o problema — mas só se você configurar direito.
+
+confianca: alta

package/scripts/__fixtures__/voz-do-dono/peca-limpa-1a-pessoa.md

@@ -0,0 +1,6 @@
+# Slide de exemplo (fixture CONFORME)
+
+Testei essa ferramenta na minha rotina e o resultado me surpreendeu: ela resolve o problema,
+desde que você configure direito. Minha regra: comece pequeno e meça.
+
+confianca: alta

package/scripts/__tests__/derive-ready-transitions.test.cjs

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * derive-ready-transitions.test.cjs — meta-prova do instrumento offline que
+ * deriva do git a contagem de `D-Dono-2` (i) (`ADR-035`, D7; story `SF13.8`).
+ *
+ * `ADR-035` D7 exige, no MÍNIMO, quatro elementos — e diz por quê: *"sem (b) e
+ * (d), o teste fica verde para um instrumento que conta zero"*. Um detector
+ * cuja classe alvo nunca é provada alcançável passa igual quebrado e correto
+ * (`calibrar-detector-exige-corpus-externo`). Os quatro estão aqui:
+ *
+ *   (a) CORPUS REAL — a derivação roda sobre o histórico DESTE repositório,
+ *       pinado num sha imutável (`force-push` é `deny` para todos os agentes,
+ *       `authority.md`), e exige a âncora estável `6b948efa`/`sf13.1.story.md`
+ *       com o veredito `ask` em `P8`.
+ *   (b) CONTROLE POSITIVO — repositório git sintético e descartável, com uma
+ *       transição `Draft`→`Ready` conhecida, num diretório de stories
+ *       NÃO-padrão (o argumento `--stories-dir` é exercitado de verdade, não
+ *       só declarado na assinatura).
+ *   (c) CONTROLE NEGATIVO — commit que toca a story SEM mudar `## Status` não
+ *       é contado. Sem ele, um instrumento que contasse "toda escrita" também
+ *       ficaria verde em (b).
+ *   (d) FALSO NEGATIVO ASSERTADO — story que NASCE `Ready` não é contada.
+ *       É limitação conhecida e declarada (`ADR-035` M7/dívida 1), no mesmo
+ *       padrão do `~~Ready~~` de `enforce-ready-oracles.test.cjs:595`:
+ *       escrever a limitação em prosa não impede que ela vire outra coisa em
+ *       silêncio — assertá-la trava o comportamento no valor que foi aceito.
+ *
+ * Mais três guardas que decorrem das decisões do ADR e não têm outro dono:
+ * D4 (`exit 0` sempre), D2 (fonte única — nenhum predicado reimplementado) e
+ * a Segurança (`git` por `execFileSync` com array, nunca shell).
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync, spawnSync } = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const SCRIPT = path.join(REPO_ROOT, 'scripts', 'derive-ready-transitions.cjs');
+
+// Sha pinado: o commit mais recente entre as 70 transições do corpus real.
+// Pinar é o que impede o teste de ficar RED meses depois por trabalho legítimo
+// do ciclo (a contagem só cresce a cada `Draft`→`Ready` novo).
+const REV_PINADO = '6ef33f90';
+const MARCO_V1 = 'd6ae744'; // commit em que a v1 do hook passou a existir em `template/`
+const ANCORA_SHA = '6b948efa';
+const ANCORA_ARQUIVO = 'sf13.1.story.md';
+
+let failures = 0;
+function assert(ok, msg) {
+  if (ok) {
+    console.log(`[OK   ] ${msg}`);
+  } else {
+    console.error(`[FALHA] ${msg}`);
+    failures += 1;
+  }
+}
+
+function rodar(args) {
+  const r = spawnSync(process.execPath, [SCRIPT].concat(args), {
+    encoding: 'utf8',
+    cwd: REPO_ROOT,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  return { status: r.status, stdout: r.stdout || '', stderr: r.stderr || '' };
+}
+
+function campo(saida, nome) {
+  const linha = saida.split('\n').find((l) => l.includes(`${nome}=`));
+  if (!linha) return null;
+  const depois = linha.slice(linha.indexOf(`${nome}=`) + nome.length + 1);
+  const m = /^\d+/.test(depois) ? depois.match(/^\d+/) : null;
+  return m ? m[0] : null;
+}
+
+// Repositório git sintético e descartável. Criado por teste, nunca reusado:
+// estado compartilhado entre controles faria um controle mascarar o outro.
+function repoSintetico(prefixo) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefixo));
+  const git = (args) => execFileSync('git', args, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  git(['init', '-q']);
+  git(['config', 'user.email', 'teste@exemplo.invalid']);
+  git(['config', 'user.name', 'teste']);
+  fs.mkdirSync(path.join(dir, 'stories-sinteticas'));
+  return {
+    dir,
+    escrever(nome, conteudo, mensagem) {
+      fs.writeFileSync(path.join(dir, 'stories-sinteticas', nome), conteudo);
+      git(['add', '.']);
+      git(['commit', '-q', '-m', mensagem]);
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// (a) Corpus real — o histórico deste repositório, pinado
+// ---------------------------------------------------------------------------
+
+function testCorpusReal() {
+  console.log('\n--- D7a: corpus real (histórico deste repositório, sha pinado) ---');
+
+  const r = rodar(['.', '--rev', REV_PINADO, '--since', MARCO_V1]);
+  assert(r.status === 0, `D7a: exit 0 sobre o corpus real (status=${r.status})`);
+
+  assert(campo(r.stdout, 'total') === '70', `D7a: total=70 transições draft→ready até ${REV_PINADO} (medido: ${campo(r.stdout, 'total')})`);
+
+  // `desde` é a leitura RESTRITA de `D-Dono-2` (i) — "com a v1". O número é 14,
+  // por ancestralidade `d6ae744..6ef33f90`. A tabela M3 do `ADR-035` publicou
+  // `17` na 1ª versão e foi CORRIGIDA para 14 (a causa era filtro por
+  // granularidade de DIA, que inclui 3 transições anteriores às 15:29:56 em que
+  // a v1 nasceu). Leitura superada, não repetir: quem vir 17 aqui está
+  // copiando a versão superada, não medindo.
+  assert(campo(r.stdout, 'desde') === '14', `D7a: desde=14 no recorte ${MARCO_V1}..${REV_PINADO} (medido: ${campo(r.stdout, 'desde')})`);
+
+  const listaTemAncora = r.stdout.split('\n').some((l) => l.includes(ANCORA_SHA) && l.includes(ANCORA_ARQUIVO));
+  assert(listaTemAncora, `D7a: a âncora ${ANCORA_SHA} (${ANCORA_ARQUIVO}) aparece na lista auditável — cada transição é conferível uma a uma, não é total agregado`);
+
+  // Replay do veredito da v1 (D2/D3): o hook é PURO, logo o veredito é função
+  // total do conteúdo resultante, e o conteúdo resultante é o que o git guarda.
+  assert(campo(r.stdout, 'ask') === '1' && campo(r.stdout, 'silencio') === '69', `D7a: replay da v1 sobre as 70 dá ask=1 silencio=69 (medido: ask=${campo(r.stdout, 'ask')} silencio=${campo(r.stdout, 'silencio')})`);
+
+  const linhaAsk = r.stdout.split('\n').find((l) => l.startsWith('ASK'));
+  assert(
+    !!linhaAsk && linhaAsk.includes(ANCORA_SHA) && linhaAsk.includes(ANCORA_ARQUIVO) && linhaAsk.includes('P8'),
+    `D7a: a única emissão é a já nomeada em ADR-032 (consequência 5): ${ANCORA_SHA}/${ANCORA_ARQUIVO}, predicado P8 (linha: ${linhaAsk || '<ausente>'})`,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// (b) Controle positivo — alcançabilidade da classe
+// ---------------------------------------------------------------------------
+
+function testControlePositivo() {
+  console.log('\n--- D7b: controle positivo (repo git sintético, --stories-dir não-padrão) ---');
+
+  const repo = repoSintetico('derive-positivo-');
+  repo.escrever('z.story.md', '## Status\n\nDraft\n', 'nasce Draft');
+  repo.escrever('z.story.md', '## Status\n\nReady\n', 'Draft -> Ready');
+
+  const r = rodar([repo.dir, '--stories-dir', 'stories-sinteticas']);
+  assert(r.status === 0, `D7b: exit 0 no repo sintético (status=${r.status})`);
+  assert(campo(r.stdout, 'total') === '1', `D7b/controle positivo: a transição conhecida É contada — total=1 (medido: ${campo(r.stdout, 'total')})`);
+  assert(
+    r.stdout.includes('stories-dir=stories-sinteticas') && r.stdout.includes('stories-sinteticas/z.story.md'),
+    'D7b: `--stories-dir` é EXERCITADO de verdade (diretório não-padrão), não só declarado na assinatura',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// (c) Controle negativo — o instrumento não conta "toda escrita"
+// ---------------------------------------------------------------------------
+
+function testControleNegativo() {
+  console.log('\n--- D7c: controle negativo (commit toca a story sem mudar o status) ---');
+
+  const repo = repoSintetico('derive-negativo-');
+  repo.escrever('z.story.md', '## Status\n\nDraft\n', 'nasce Draft');
+  repo.escrever('z.story.md', '## Status\n\nReady\n\n## Acceptance Criteria\n', 'Draft -> Ready');
+  repo.escrever('z.story.md', '## Status\n\nReady\n\n## Acceptance Criteria\n\nAC-1 novo\n', 'toca a story sem mudar Status');
+
+  const r = rodar([repo.dir, '--stories-dir', 'stories-sinteticas']);
+  assert(r.status === 0, `D7c: exit 0 no repo sintético (status=${r.status})`);
+  assert(campo(r.stdout, 'total') === '1', `D7c/controle negativo: Ready→Ready NÃO conta — total continua 1, não sobe para 2 (medido: ${campo(r.stdout, 'total')})`);
+}
+
+// ---------------------------------------------------------------------------
+// (d) Falso negativo DECLARADO — assertado, não só escrito em prosa
+// ---------------------------------------------------------------------------
+
+function testFalsoNegativoDeclarado() {
+  console.log('\n--- D7d: falso negativo <ausente>->ready, assertado ---');
+
+  const repo = repoSintetico('derive-falso-neg-');
+  repo.escrever('nasce-ready.story.md', '## Status\n\nReady\n', 'nasce em Ready, sem Draft anterior');
+
+  const r = rodar([repo.dir, '--stories-dir', 'stories-sinteticas']);
+  assert(r.status === 0, `D7d: exit 0 no repo sintético (status=${r.status})`);
+  assert(
+    campo(r.stdout, 'total') === '0',
+    `D7d: story que NASCE Ready não é contada — total=0. LIMITAÇÃO CONHECIDA e aceita (ADR-035 M7/dívida 1): a classe <ausente>->ready tem teto de 20 em 90 (22%) no framework, e a perda sempre SUBTRAI, nunca infla a contagem que autorizaria um deny. Se este número virar 1, alguém ampliou a detecção — o que pode ser bom, mas é decisão do dono, não efeito colateral (medido: ${campo(r.stdout, 'total')})`,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// D4 — o instrumento NUNCA é trava
+// ---------------------------------------------------------------------------
+
+function testNuncaTrava() {
+  console.log('\n--- D4: exit 0 sempre, com diagnóstico (nunca silêncio, nunca crash) ---');
+
+  const inexistente = path.join(os.tmpdir(), 'derive-alvo-que-nao-existe-4c1f9a');
+  const r = rodar([inexistente]);
+  assert(r.status === 0, `D4: repositório-alvo inexistente ⇒ exit 0 (status=${r.status})`);
+  assert(/DIAGNOSTICO/.test(r.stdout), 'D4: a falha é DECLARADA no stdout — nem silêncio (indistinguível de "zero transições") nem exceção não tratada');
+
+  const semGit = fs.mkdtempSync(path.join(os.tmpdir(), 'derive-sem-git-'));
+  const r2 = rodar([semGit]);
+  assert(r2.status === 0 && /DIAGNOSTICO/.test(r2.stdout), `D4: diretório que existe mas não é repo git ⇒ exit 0 + diagnóstico (status=${r2.status})`);
+
+  const r3 = rodar(['.', '--rev']);
+  assert(r3.status === 0 && /DIAGNOSTICO/.test(r3.stdout), `D4: opção sem valor ⇒ exit 0 + diagnóstico (status=${r3.status})`);
+
+  const r4 = rodar(['.', '--rev', 'ref-que-nao-existe-4c1f9a', '--stories-dir', 'docs/stories']);
+  assert(r4.status === 0 && /DIAGNOSTICO/.test(r4.stdout), `D4: rev irresolvível ⇒ exit 0 + diagnóstico (status=${r4.status})`);
+}
+
+// ---------------------------------------------------------------------------
+// D2 / Segurança — fonte única e invocação sem shell
+// ---------------------------------------------------------------------------
+
+function testFonteUnicaESeguranca() {
+  console.log('\n--- D2 (fonte única) e Segurança (git por array, sem shell) ---');
+
+  const src = fs.readFileSync(SCRIPT, 'utf8');
+
+  assert(/enforce-cycle-authority/.test(src) && /enforce-ready-oracles/.test(src), 'D2: o instrumento REFERENCIA os dois hooks por path — isto é, os carrega em vez de copiá-los');
+  const redefine = /function\s+(extractStatusSection|statusToken|evaluateReadyOracles)\s*\(/.test(src);
+  assert(!redefine, 'D2: nenhum dos 3 predicados (extractStatusSection/statusToken/evaluateReadyOracles) é redefinido aqui — uma 2ª implementação poderia divergir do hook sobre o que É uma transição');
+
+  assert(/execFileSync\(\s*'git'\s*,\s*\[/.test(src), 'Segurança: `git` é invocado por execFileSync com argumentos em ARRAY');
+  assert(!/\bexecSync\(|\bexec\(|shell\s*:\s*true/.test(src), 'Segurança: nenhum `exec`/`execSync`/`shell: true` — o path do alvo nunca é concatenado em string de comando');
+
+  // O instrumento NÃO viaja para instalações (D5). Assertado, não só omitido:
+  // sem isto, a próxima passada "conserta" a ausência do manifesto.
+  const manifesto = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'installer', 'motor-scripts.json'), 'utf8'));
+  assert(
+    !manifesto.scripts.some((s) => s.path === 'scripts/derive-ready-transitions.cjs'),
+    'D5: o instrumento NÃO está em scripts[] do manifesto — a decisão que ele serve acontece uma vez, no repositório do framework',
+  );
+  assert(
+    manifesto.exclude.includes('derive-ready-transitions.cjs'),
+    'D5: o instrumento está no `exclude` do manifesto — a não-distribuição é DECIDIDA, não um esquecimento que o invariante 1 acusaria',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Parser de log — puro, testável sem git
+// ---------------------------------------------------------------------------
+
+function testParseLog() {
+  console.log('\n--- parseLog: puro, sem git ---');
+
+  const { parseLog } = require(SCRIPT);
+  const SEP = '\u0001';
+  const texto = `${SEP}abc123|2026-08-09T02:34:21-04:00\ndocs/stories/a.story.md\ndocs/stories/README.md\n\n${SEP}def456|2026-08-08T10:00:00-04:00\ndocs/stories/b.story.md\n`;
+  const regs = parseLog(texto);
+  assert(regs.length === 2, `parseLog: 2 registros (medido: ${regs.length})`);
+  assert(regs[0].sha === 'abc123' && regs[0].iso === '2026-08-09T02:34:21-04:00', 'parseLog: sha e data do cabeçalho');
+  assert(regs[0].arquivos.length === 1 && regs[0].arquivos[0] === 'docs/stories/a.story.md', 'parseLog: só `*.story.md` entra (README.md do mesmo commit é descartado)');
+  assert(parseLog('').length === 0 && parseLog(null).length === 0, 'parseLog: entrada vazia/nula não vira registro fantasma');
+}
+
+// ---------------------------------------------------------------------------
+
+console.log('=== derive-ready-transitions.test.cjs — ADR-035 D7 (SF13.8) ===');
+testParseLog();
+testControlePositivo();
+testControleNegativo();
+testFalsoNegativoDeclarado();
+testNuncaTrava();
+testFonteUnicaESeguranca();
+testCorpusReal();
+
+if (failures > 0) {
+  console.error(`\n${failures} falha(s).`);
+  process.exit(1);
+}
+console.log('\nTodos os testes passaram.');