@daniellins/power-claude 0.16.3

package/scripts/arena.test.cjs

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * arena.test.cjs — suíte do motor arena.cjs (Story SF7.4, AC4; ADR-009 Decisão 2).
+ * Prova, com experimentos sintéticos em diretório temporário:
+ *  (1) REGRESSÃO bug-class 1 (indexação 1-based portada p/ 0-based): reproduz a classe
+ *      exata do erro (mapa 1-indexed → braço undefined/perdido) e prova que
+ *      validatePermutation a PEGA; e que permute() gera bijeção total sobre 200 seeds.
+ *  (2) REGRESSÃO bug-class 2 (estado/contador perdido entre iterações): reproduz a classe
+ *      (mutar cópia sem persistir → disco não avança) e prova que o motor PERSISTE o estado
+ *      entre invocações separadas (recarga fresca do disco), de modo que o reveal-gate lê a
+ *      contagem PERSISTIDA.
+ *  (3) uniquidade/bijeção da permutação + N≥3 rejeita identidade.
+ *  (4) reveal-gate: revelação prematura é RECUSADA (fail-loud), nenhum mapa lido.
+ *  (5) aritmética: weightedRoundScore exato, verdictForAxis (vitória/empate/K-de-N),
+ *      tally consistente; fake-green (nota fora de faixa / passed>checks / pesos≠1) FALHA.
+ *  (6) N≥2 parametrizável.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const A = require('./arena.cjs');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.error(`[FALHA] ${label}`); }
+}
+function throwsArena(fn) {
+  try { fn(); return false; } catch (e) { if (e instanceof A.ArenaError) return true; throw e; }
+}
+function tmpExp() { return fs.mkdtempSync(path.join(os.tmpdir(), 'arena-')); }
+
+const RUBRIC = {
+  scale: 5,
+  dimensions: [
+    { name: 'Q', weight: 0.5, type: 'human' },
+    { name: 'S', weight: 0.3, type: 'machine', checks: 2 },
+    { name: 'P', weight: 0.2, type: 'human' },
+  ],
+  verdict: { minDiff: 0.3, kOfN: 2 },
+  axes: [{ name: 'A1 vs A2', a: 'A1', b: 'A2' }],
+};
+
+// ===========================================================================
+// (1) BUG-CLASS 1 — indexação 1-based portada para 0-based
+// ===========================================================================
+console.log('--- (1) regressão bug-class 1: indexação 0/1 ---');
+{
+  const arms = ['A1', 'A2', 'A3', 'A4'];
+  const labels = ['W', 'X', 'Y', 'Z'];
+  // Reproduz a CLASSE: um port 1-indexed constrói map[labels[i]] = arms[i] com i = 1..N.
+  const buggyMap = {};
+  labels.forEach((lab, idx) => { const oneBased = idx + 1; buggyMap[lab] = arms[oneBased]; }); // arms[4]=undefined, arms[0] perdido
+  ok(buggyMap.Z === undefined && !Object.values(buggyMap).includes('A1'),
+    'bug-class 1 REPRODUZIDA: mapa 1-indexed perde A1 e gera braço undefined');
+  ok(throwsArena(() => A.validatePermutation(buggyMap, arms, labels)),
+    'motor IMUNE: validatePermutation PEGA o mapa 1-indexed (braço undefined/perdido)');
+  // permute() do motor: bijeção total sobre 200 seeds distintas.
+  let allValid = true;
+  for (let s = 0; s < 200; s++) {
+    const m = A.permute(arms, labels, s);
+    const covered = new Set(Object.values(m));
+    if (covered.size !== 4 || Object.values(m).includes(undefined)) { allValid = false; break; }
+  }
+  ok(allValid, 'permute() gera bijeção total (4 braços distintos, sem undefined) em 200 seeds');
+}
+
+// ===========================================================================
+// (2) BUG-CLASS 2 — estado/contador perdido entre iterações
+// ===========================================================================
+console.log('--- (2) regressão bug-class 2: estado perdido entre iterações ---');
+{
+  const exp = tmpExp();
+  A.init(exp, { arms: ['A1', 'A2'], rounds: 3, rubric: RUBRIC, seed: 7 });
+  // Reproduz a CLASSE: mutar uma CÓPIA em memória sem persistir → disco não avança.
+  const s0 = A.loadState(exp);
+  const copy = JSON.parse(JSON.stringify(s0));
+  copy.scores['1'] = { W: {}, X: {} }; // mutou a cópia, NÃO salvou
+  ok(A.scoredRoundsCount(A.loadState(exp)) === 0,
+    'bug-class 2 REPRODUZIDA: mutar cópia sem persistir deixa o disco em 0 rodadas');
+  // Motor IMUNE: cada recordScore é uma invocação separada que RECARREGA e SALVA no disco.
+  const sc = { Q: 4, S: { passed: 2 }, P: 3 };
+  for (let r = 1; r <= 3; r++) {
+    A.recordScore(exp, r, 'W', sc); // invocação separada: loadState fresco + saveState atômico
+    A.recordScore(exp, r, 'X', sc);
+    ok(A.scoredRoundsCount(A.loadState(exp)) === r,
+      `estado PERSISTE entre invocações: após rodada ${r} pontuada, disco mostra ${r} (contador não se perde)`);
+  }
+}
+
+// ===========================================================================
+// (3) uniquidade + N≥3 rejeita identidade
+// ===========================================================================
+console.log('--- (3) uniquidade / anti-identidade ---');
+{
+  const arms = ['A1', 'A2', 'A3'];
+  const labels = ['W', 'X', 'Y'];
+  let neverIdentity = true;
+  for (let s = 0; s < 100; s++) {
+    const m = A.permute(arms, labels, s);
+    if (labels.every((l, i) => m[l] === arms[i])) { neverIdentity = false; break; }
+  }
+  ok(neverIdentity, 'N≥3: permute() nunca devolve a permutação identidade (tell óbvio) em 100 seeds');
+}
+
+// ===========================================================================
+// (4) reveal-gate
+// ===========================================================================
+console.log('--- (4) reveal-gate ---');
+{
+  const exp = tmpExp();
+  A.init(exp, { arms: ['A1', 'A2'], rounds: 2, rubric: RUBRIC, seed: 1 });
+  const sc = { Q: 4, S: { passed: 2 }, P: 3 };
+  A.recordScore(exp, 1, 'W', sc); A.recordScore(exp, 1, 'X', sc); // só rodada 1
+  ok(throwsArena(() => A.reveal(exp)), 'reveal PREMATURO (1/2 rodadas) é RECUSADO fail-loud');
+  ok(A.loadState(exp).revealed === false, 'estado NÃO marca revealed após recusa (nenhum mapa liberado)');
+  A.recordScore(exp, 2, 'W', sc); A.recordScore(exp, 2, 'X', sc); // completa
+  const map = A.reveal(exp);
+  ok(map && map['1'] && map['2'], 'reveal LIBERA o mapa após todas as rodadas pontuadas');
+  ok(A.loadState(exp).revealed === true, 'estado marca revealed=true após revelação legítima');
+  // Mapa selado em disco com permissão restrita (best-effort POSIX).
+  const st = fs.statSync(A.sealedPath(exp));
+  const mode = st.mode & 0o777;
+  ok(mode === 0o600 || process.platform === 'win32', `mapa selado com chmod 600 (mode=${mode.toString(8)})`);
+}
+
+// ===========================================================================
+// (5) aritmética da agregação + fake-green
+// ===========================================================================
+console.log('--- (5) aritmética / veredito ---');
+{
+  // weightedRoundScore exato: 4*0.5 + (2/2*5)*0.3 + 3*0.2 = 2 + 1.5 + 0.6 = 4.1
+  const s = A.weightedRoundScore({ Q: 4, S: { passed: 2 }, P: 3 }, RUBRIC);
+  ok(Math.abs(s - 4.1) < 1e-9, `weightedRoundScore recomputa 4.1 exato (obteve ${s})`);
+  // machine dim parcial: passed 1/2 → 2.5*0.3=0.75 → 2 + 0.75 + 0.6 = 3.35
+  const s2 = A.weightedRoundScore({ Q: 4, S: { passed: 1 }, P: 3 }, RUBRIC);
+  ok(Math.abs(s2 - 3.35) < 1e-9, `machine dim proporcional (1/2 checks) recomputa 3.35 (obteve ${s2})`);
+  // fake-green: nota humana fora de faixa / passed > checks / rubrica com pesos ≠ 1 FALHAM
+  ok(throwsArena(() => A.weightedRoundScore({ Q: 9, S: { passed: 2 }, P: 3 }, RUBRIC)), 'fake-green: nota humana > escala FALHA');
+  ok(throwsArena(() => A.weightedRoundScore({ Q: 4, S: { passed: 5 }, P: 3 }, RUBRIC)), 'fake-green: machine passed > checks FALHA');
+  ok(throwsArena(() => A.validateRubric({ scale: 5, dimensions: [{ name: 'Q', weight: 0.7, type: 'human' }], verdict: { minDiff: 0.3, kOfN: 1 } })), 'fake-green: pesos ≠ 1.0 FALHA');
+
+  // verdictForAxis: vitória (A ≥0.3 em ≥2 de 3), empate, K-de-N
+  const win = A.verdictForAxis([4.5, 4.6, 4.4], [4.0, 4.2, 4.05], 0.3, 2);
+  ok(win.winner === 'A' && win.tie === false, 'veredito: A vence (≥0.3 em ≥2/3 rodadas)');
+  const tie = A.verdictForAxis([4.1, 4.0, 4.2], [4.0, 4.05, 4.1], 0.3, 2);
+  ok(tie.winner === 'tie' && tie.tie === true, 'veredito: diferença < limiar em rodadas suficientes → EMPATE (válido)');
+  const notSustained = A.verdictForAxis([5, 4, 4], [4, 4, 4], 0.3, 2); // A vence só 1 rodada por ≥0.3
+  ok(notSustained.winner === 'tie', 'veredito: vantagem não sustentada em K rodadas → EMPATE (não forçado)');
+
+  // tally full: consistência (soma por braço == soma por rótulo, por rodada)
+  const exp = tmpExp();
+  A.init(exp, { arms: ['A1', 'A2'], rounds: 2, rubric: RUBRIC, seed: 3 });
+  A.recordScore(exp, 1, 'W', { Q: 5, S: { passed: 2 }, P: 4 });
+  A.recordScore(exp, 1, 'X', { Q: 3, S: { passed: 1 }, P: 2 });
+  A.recordScore(exp, 2, 'W', { Q: 4, S: { passed: 2 }, P: 3 });
+  A.recordScore(exp, 2, 'X', { Q: 4, S: { passed: 2 }, P: 3 });
+  const t = A.tally(exp);
+  const armSum = t.perRoundByArm.A1.reduce((a, b) => a + b, 0) + t.perRoundByArm.A2.reduce((a, b) => a + b, 0);
+  // R1: W=5*.5+(2/2*5)*.3+4*.2=4.8 ; X=3*.5+(1/2*5)*.3+2*.2=2.65 ; R2: W=X=4*.5+5*.3+3*.2=4.1
+  ok(Math.abs(armSum - (4.8 + 2.65 + 4.1 + 4.1)) < 1e-6, 'tally: soma por braço == soma por rótulo (join via mapa selado correto)');
+  ok(t.axes.length === 1 && ('winner' in t.axes[0]), 'tally: veredito por eixo presente');
+}
+
+// ===========================================================================
+// (6) N≥2 parametrizável
+// ===========================================================================
+console.log('--- (6) N parametrizável ---');
+{
+  ok(throwsArena(() => A.init(tmpExp(), { arms: ['A1'], rounds: 2, rubric: RUBRIC })), 'init com 1 braço FALHA (N≥2)');
+  const exp = tmpExp();
+  const st = A.init(exp, { arms: ['A1', 'A2', 'A3', 'A4', 'A5'], rounds: 2, rubric: RUBRIC, seed: 9 });
+  ok(st.arms.length === 5 && st.labels.length === 5, 'init com N=5 braços OK (N não é constante 4)');
+}
+
+// ===========================================================================
+// (7) CONCERNS-1 — agregado de checks-de-máquina PASS/FAIL, SEPARADO da média
+// ===========================================================================
+console.log('--- (7) agregado estrutural de máquina no relatório ---');
+{
+  const exp = tmpExp();
+  A.init(exp, { arms: ['A1', 'A2'], rounds: 2, rubric: RUBRIC, seed: 5 });
+  // Um rótulo reprova 1 check de máquina (passed 1/2) numa rodada; o outro passa tudo.
+  A.recordScore(exp, 1, 'W', { Q: 4, S: { passed: 2 }, P: 3 });
+  A.recordScore(exp, 1, 'X', { Q: 4, S: { passed: 1 }, P: 3 }); // reprova 1 check estrutural
+  A.recordScore(exp, 2, 'W', { Q: 4, S: { passed: 2 }, P: 3 });
+  A.recordScore(exp, 2, 'X', { Q: 4, S: { passed: 2 }, P: 3 });
+  const t = A.tally(exp);
+  const failing = Object.entries(t.machineAggregate).filter(([, m]) => !m.pass);
+  ok(failing.length === 1 && failing[0][1].passed < failing[0][1].total,
+    'tally.machineAggregate: braço com check reprovado tem pass=false e passed<total');
+  ok(Object.values(t.machineAggregate).some((m) => m.pass && m.passed === m.total),
+    'tally.machineAggregate: o outro braço tem PASS integral (passed==total)');
+  // O agregado é SEPARADO da média: os dois braços têm agregados estruturais distintos.
+  const aggPassed = Object.values(t.machineAggregate).map((m) => m.passed);
+  ok(new Set(aggPassed).size === 2, 'agregado estrutural distingue os braços (sinal separado da média ponderada)');
+  const rep = A.report(exp).text;
+  ok(/Estrutura verificável por máquina — PASS\/FAIL agregado/.test(rep),
+    'report() EXPÕE a seção de agregado estrutural (visível, não escondido na média)');
+  ok(/\*\*NÃO\*\*/.test(rep), 'report() marca **NÃO** para o braço com falha estrutural desqualificante');
+}
+
+if (failures.length > 0) {
+  console.error(`\nSuíte arena FALHOU: ${failures.length} de ${passed + failures.length}.`);
+  process.exit(1);
+}
+console.log(`\n${passed} asserções verdes. Motor arena provado.`);
+process.exit(0);

package/scripts/brief-leitura-obrigatoria.test.cjs

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * brief-leitura-obrigatoria.test.cjs — suíte da Story SF11.2 (ADR-021).
+ *
+ * Duas ondas, mesmo ponto do código (`buildBrief`):
+ *   PARTE A (`DF-SF11.2-5`) — `_sources` sai do brief de TODA `veto.assertion`, de todo pod,
+ *     sem classificação por `type`/`field`/`id` e sem nome de pod. O caso honesto não regride:
+ *     `type`/`field`/`pattern`/`n`/`command`/`args` continuam no brief.
+ *   PARTE B (`DF-SF11.2-1`,`-4`,`-6`,`-10`) — seção "Leitura obrigatória ANTES de agir" com os
+ *     paths ABSOLUTOS de `agents/<step.agent>.md` + cada `knowledge/<k>` NA ORDEM DECLARADA,
+ *     existência VERIFICADA em disco (fail-closed no despacho), renderizada ANTES de `## Veto`,
+ *     com o veto rotulado como verificação POSTERIOR.
+ *
+ * O que esta suíte NÃO prova, e não pode ser lida como se provasse (`DF-SF11.2-3`):
+ * que o agente LEIA ou OBEDEÇA. Presença ≠ obediência. O canal garante que a referência
+ * CHEGA e que os arquivos EXISTEM — ler e obedecer segue sendo disciplina do agente.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const rp = require('./pc-run-pod.cjs');
+const vp = require('./validate-pod-workflow.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const DEV_ROOT = path.resolve(REPO_ROOT, '..');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.error(`[FALHA] ${label}`); }
+}
+function throwsFail(fn) { try { fn(); return false; } catch (e) { if (e instanceof vp.Fail) return true; throw e; } }
+
+const tmpdirs = [];
+function tmp(label) { const d = fs.mkdtempSync(path.join(os.tmpdir(), `sf11.2-${label}-`)); tmpdirs.push(d); return d; }
+
+/**
+ * Pod sintético mínimo e COMPLETO (agents/ + knowledge/ + templates/ + workflows/), para as
+ * provas não dependerem de nenhum pod real. `knowledge` = null → etapa SEM o campo (retrocompat).
+ */
+function makePod(dir, { knowledge = ['k1.md', 'k2.md'], assertions } = {}) {
+  fs.mkdirSync(path.join(dir, 'agents'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'knowledge'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'templates'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'workflows'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'agents', 'solo.md'), '---\nname: solo\nmodel: sonnet\n---\n\n# solo\n\nAgente de fixture.\n');
+  for (const k of (knowledge || [])) {
+    fs.writeFileSync(path.join(dir, 'knowledge', k), `# ${k}\n\nKnowledge de fixture.\n`);
+  }
+  fs.writeFileSync(path.join(dir, 'templates', 'solo-tmpl.md'), '# Artefato\n\n## Corpo\n\n(preencher)\n');
+  const vetoList = assertions || [
+    { type: 'count_gte', field: 'Corpo', n: 1, _sources: 'RACIONAL DE MANUTENCAO que o agente nao deve ver — ADR-020 / AUTO-ATESTADA / INVARIANTE DE MANUTENCAO' },
+    { type: 'field_matches', field: 'contrato_entrada', pattern: '^(ancora:hn)$', _sources: 'segundo racional AUTO-ATESTADA com pHash citado' },
+  ];
+  const wf = [
+    'state_machine:',
+    '  states: [init, running, review, complete, failed]',
+    '  initial: init',
+    '  terminal: [complete, failed]',
+    '',
+    'steps:',
+    '  - id: solo',
+    '    agent: solo',
+    '    template: templates/solo-tmpl.md',
+    '    inputs: [brief]',
+    '    outputs: [artefato]',
+    ...(knowledge ? [`    knowledge: [${knowledge.join(', ')}]`] : []),
+    '    depends_on: []',
+    '    checkpoint: null',
+    '    veto:',
+    '      assertions:',
+    ...vetoList.map((a) => `        - ${JSON.stringify(a)}`),
+    '',
+  ].join('\n');
+  const wfPath = path.join(dir, 'workflows', 'wf-solo.yaml');
+  fs.writeFileSync(wfPath, wf);
+  return wfPath;
+}
+
+function startOn(wfPath, label) {
+  const runsRoot = tmp(`${label}-runs`);
+  const memoryPodDir = tmp(`${label}-mem`);
+  return rp.startRun({
+    workflowPath: wfPath, pod: 'solo', workflow: 'wf-solo', runsRoot, runId: `${label}-1`, memoryPodDir,
+  });
+}
+
+// ===========================================================================
+// (AC1/AC2/AC3) PARTE A — `_sources` fora do brief, sem regressão do caso honesto
+// ===========================================================================
+console.log('--- (AC1/AC2/AC3) Parte A: `_sources` fora do brief ---');
+{
+  const pod = tmp('a-pod');
+  const wfPath = makePod(pod);
+  const { result } = startOn(wfPath, 'a');
+  const brief = result.brief;
+  ok(result.action === 'dispatch' && typeof brief === 'string', 'pod completo despacha e emite brief');
+  ok(!/_sources/.test(brief), 'AC1: a string "_sources" NÃO aparece no brief');
+  for (const sonda of ['AUTO-ATESTADA', 'INVARIANTE DE MANUTENCAO', 'ADR-020', 'pHash', 'RACIONAL DE MANUTENCAO']) {
+    ok(!brief.includes(sonda), `AC1: sonda de racional "${sonda}" ausente do brief`);
+  }
+  ok(/"type":"count_gte"/.test(brief) && /"field":"Corpo"/.test(brief) && /"n":1/.test(brief),
+    'AC2: caso honesto preservado — type/field/n da assertion de contagem seguem no brief');
+  ok(/"field":"contrato_entrada"/.test(brief) && brief.includes('^(ancora:hn)$'),
+    'AC2: caso honesto preservado — field/pattern da assertion de discriminação seguem no brief');
+}
+{
+  // AC3 (genérico, sem classificação): projeção pura, provada em assertions de tipos e campos
+  // arbitrários — não há caminho no código que dependa de `type`, `field` ou `id`.
+  const casos = [
+    { type: 'field_matches', field: 'qualquer_campo_novo', pattern: '^x$', id: 'v1', _sources: 'corta' },
+    { type: 'command_check', command: 'lexical-check.cjs', args: ['--max', '0'], timeout_ms: 1000, _sources: 'corta' },
+    { type: 'section_exists', section: '## Seção', _sources: 'corta' },
+    { type: 'json_schema_valid', schema: { a: 1 }, _sources: 'corta' },
+  ];
+  let todosCortam = true;
+  let todosPreservam = true;
+  for (const c of casos) {
+    const proj = rp.vetoAssertionForBrief(c);
+    if ('_sources' in proj) todosCortam = false;
+    for (const k of Object.keys(c)) {
+      if (k === '_sources') continue;
+      if (JSON.stringify(proj[k]) !== JSON.stringify(c[k])) todosPreservam = false;
+    }
+  }
+  ok(todosCortam, 'AC3: `_sources` cortado em assertions de 4 tipos diferentes (sem classificação)');
+  ok(todosPreservam, 'AC3: TODOS os demais campos preservados byte-a-byte (inclusive `id`, `args`, `schema`)');
+  ok(rp.vetoAssertionForBrief(null) === null && rp.vetoAssertionForBrief('x') === 'x',
+    'AC3: entrada não-objeto atravessa intacta (sem throw)');
+  const src = fs.readFileSync(path.join(__dirname, 'pc-run-pod.cjs'), 'utf8');
+  const fn = src.slice(src.indexOf('function vetoAssertionForBrief'), src.indexOf('function buildBrief'));
+  ok(!/hn-|carousel|contrato_entrada|digest|visuals|assembly/.test(fn),
+    'AC3: o corpo de `vetoAssertionForBrief` não cita pod, etapa nem nome de campo (verificável no fonte)');
+}
+
+// ===========================================================================
+// (AC6) PARTE B — seção presente, absoluta, na ordem declarada, ANTES do veto
+// ===========================================================================
+console.log('--- (AC6) Parte B: seção de leitura obrigatória ---');
+{
+  const pod = tmp('b-pod');
+  const wfPath = makePod(pod, { knowledge: ['k2.md', 'k1.md'] }); // ordem DECLARADA invertida de propósito
+  const { result } = startOn(wfPath, 'b');
+  const brief = result.brief;
+  const iSec = brief.indexOf('## Leitura obrigatória ANTES de agir');
+  const iVeto = brief.indexOf('## Veto');
+  ok(iSec !== -1, 'AC6-i: seção "Leitura obrigatória ANTES de agir" presente');
+  ok(iVeto !== -1 && iSec < iVeto, `AC6: seção renderizada ANTES de "## Veto" (indexOf ${iSec} < ${iVeto})`);
+  const agentAbs = path.join(pod, 'agents', 'solo.md');
+  const k2Abs = path.join(pod, 'knowledge', 'k2.md');
+  const k1Abs = path.join(pod, 'knowledge', 'k1.md');
+  ok(brief.includes(`- ${agentAbs}`), 'AC6-i: path ABSOLUTO do agente da etapa no brief');
+  ok(brief.includes(`- ${k2Abs}`) && brief.includes(`- ${k1Abs}`), 'AC6-ii: paths absolutos de TODOS os knowledge da etapa');
+  ok(brief.indexOf(agentAbs) < brief.indexOf(k2Abs) && brief.indexOf(k2Abs) < brief.indexOf(k1Abs),
+    'AC6-ii: ORDEM = agente, depois knowledge na ordem DECLARADA no wf (k2 antes de k1)');
+  ok(/HALTE e reporte/.test(brief), 'AC6-iii: instrução de HALT se algum arquivo não abrir');
+  ok(/verificação POSTERIOR do runner|não é a especificação da tarefa/.test(brief),
+    'AC6-iv: `## Veto` rotulado como verificação POSTERIOR, não especificação da tarefa');
+  ok(/existe em disco/.test(brief), 'AC6: o brief declara que a existência foi verificada pelo runner');
+}
+
+// ===========================================================================
+// (AC7) Gate de existência MORDE — agente ausente e knowledge ausente
+// ===========================================================================
+console.log('--- (AC7) gate fail-closed de existência ---');
+/**
+ * [SF11.2 — interação registrada, não escondida] Para KNOWLEDGE existem DOIS gates fail-closed
+ * em série, e o mais precoce vence no caminho normal: `startRun`/`openRun` chamam
+ * `loadWorkflow` → `validateWorkflow`, que já reprova a referência morta (paridade estática,
+ * `DF-SF11.2-4` item 2) ANTES de `advance` rodar. O gate do despacho (`blocked`) segue
+ * ALCANÇÁVEL e é o que sustenta o invariante quando o arquivo some DEPOIS do preflight
+ * (deleção/rename no meio do run, pod-root remontado) — provado logo abaixo com `resetStep`,
+ * o mesmo caminho que `revise` usa para devolver uma etapa a `pending`.
+ */
+function advanceComLeituraQuebrada(label, quebrar, opts) {
+  const pod = tmp(label);
+  const wfPath = makePod(pod, opts);
+  const { ctx } = startOn(wfPath, label);
+  rp.resetStep(ctx, 'solo'); // etapa volta a `pending` (mesmo mecanismo de `revise`)
+  quebrar(pod, ctx);
+  return { pod, ctx, result: rp.advance(ctx) };
+}
+{
+  const { result } = advanceComLeituraQuebrada('k-missing', (pod) => fs.rmSync(path.join(pod, 'knowledge', 'k2.md')));
+  ok(result.action === 'blocked', `AC7: knowledge ausente BLOQUEIA o despacho (action=${result.action})`);
+  ok(result.reason === 'leitura_obrigatoria_ausente', `AC7: reason="leitura_obrigatoria_ausente" (veio "${result.reason}")`);
+  ok(result.brief === undefined, 'AC7: NENHUM brief é emitido quando há referência morta');
+  ok((result.failures || []).some((f) => f.includes('knowledge/k2.md')), 'AC7: a falha NOMEIA o path ausente');
+}
+{
+  const { result } = advanceComLeituraQuebrada('a-missing', (pod) => fs.rmSync(path.join(pod, 'agents', 'solo.md')));
+  ok(result.action === 'blocked' && result.reason === 'leitura_obrigatoria_ausente',
+    'AC7: agente ausente BLOQUEIA com a MESMA razão (paridade com pod-export-compile.cjs:214)');
+  ok(result.brief === undefined && (result.failures || []).some((f) => f.includes('agents/solo.md')),
+    'AC7: sem brief, e a falha nomeia `agents/solo.md`');
+}
+{
+  // O gate ESTÁTICO em série: com knowledge morto, o run nem começa (fail-closed mais cedo).
+  const pod = tmp('k-preflight');
+  const wfPath = makePod(pod);
+  fs.rmSync(path.join(pod, 'knowledge', 'k2.md'));
+  let msg = '';
+  try { startOn(wfPath, 'kp'); } catch (e) { msg = e.message; }
+  ok(/knowledge declarado inexistente em disco/.test(msg) && /knowledge\/k2\.md/.test(msg),
+    'AC7/AC8: o preflight do runner (loadWorkflow→validateWorkflow) já recusa ABRIR o run com knowledge morto');
+}
+{
+  // Agente ausente NÃO é pego pelo estático (decisão registrada) — o run abre e o DESPACHO bloqueia.
+  const pod = tmp('a-preflight');
+  const wfPath = makePod(pod);
+  fs.rmSync(path.join(pod, 'agents', 'solo.md'));
+  const { result } = startOn(wfPath, 'ap');
+  ok(result.action === 'blocked' && result.reason === 'leitura_obrigatoria_ausente',
+    'AC7: no caminho NORMAL (start), agente ausente bloqueia no despacho — gate alcançável de ponta a ponta');
+}
+{
+  // Invariante fechado no ponto de emissão: nenhum OUTRO chamador consegue um brief com
+  // referência morta — `buildBrief` lança em vez de renderizar path inexistente.
+  const pod = tmp('direct');
+  const wfPath = makePod(pod);
+  const { ctx } = startOn(wfPath, 'd');
+  fs.rmSync(path.join(pod, 'knowledge', 'k1.md'));
+  let lancou = false;
+  try { rp.buildBrief(ctx, 'solo'); } catch (e) { lancou = /leitura_obrigatoria_ausente/.test(e.message); }
+  ok(lancou, 'AC7: `buildBrief` chamado DIRETO com referência morta LANÇA (invariante fechado no emissor)');
+}
+{
+  // Confinamento: `knowledge` que escapa da raiz do pod nunca vira linha do brief — bloqueia
+  // no runner, e o validador estático recusa o mesmo wf pela mesma régua.
+  // Defesa em profundidade: o preflight estático já recusa esse wf (provado logo abaixo), então
+  // o caminho do runner só é alcançável com o doc já carregado — é exatamente o que se quer
+  // provar aqui: o resolver NUNCA emite path fora da raiz, mesmo se o estático for contornado.
+  const { result } = advanceComLeituraQuebrada('escape', (_pod, ctx) => {
+    rp.stepById(ctx.doc, 'solo').knowledge = ['../../etc/passwd'];
+  });
+  ok(result.action === 'blocked' && result.reason === 'leitura_obrigatoria_ausente',
+    'AC16-vi: path que ESCAPA da raiz do pod bloqueia (fail-closed), nunca vira linha do brief');
+  ok((result.failures || []).some((f) => /escapa da raiz do pod/.test(f)),
+    'AC16-vi: a falha diz explicitamente que o path escapa da raiz do pod');
+  const podEsc = tmp('escape-static');
+  const wfEsc = makePod(podEsc, { knowledge: ['k1.md'] });
+  fs.writeFileSync(wfEsc, fs.readFileSync(wfEsc, 'utf8').replace('knowledge: [k1.md]', 'knowledge: ["../../etc/passwd"]'));
+  ok(throwsFail(() => vp.validateWorkflow(wfEsc, undefined)),
+    'AC16-vi: o validador estático recusa o MESMO wf (mesma régua de confinamento)');
+}
+
+// ===========================================================================
+// (AC8) Paridade estática no validador + varredura de não-regressão
+// ===========================================================================
+console.log('--- (AC8) paridade estática em validate-pod-workflow.cjs ---');
+{
+  const pod = tmp('static');
+  const wfPath = makePod(pod);
+  ok(!throwsFail(() => vp.validateWorkflow(wfPath, undefined)), 'AC8: wf com knowledge existente valida (exit 0)');
+  fs.rmSync(path.join(pod, 'knowledge', 'k1.md'));
+  ok(throwsFail(() => vp.validateWorkflow(wfPath, undefined)), 'AC8: knowledge declarado inexistente REPROVA a validação');
+  const pod2 = tmp('static-noknow');
+  const wf2 = makePod(pod2, { knowledge: null });
+  ok(!throwsFail(() => vp.validateWorkflow(wf2, undefined)), 'AC8/AC9: wf SEM `knowledge:` valida (campo opcional, no-op)');
+  // [SF11.2 — decisão registrada] a EXISTÊNCIA DO AGENTE não é checada aqui de propósito:
+  // `forge-generate.cjs` emite o wf antes de os agentes serem autorados. O gate de agente
+  // vive no DESPACHO (provado no AC7 acima) e no export (`pod-export-compile.cjs:214`).
+  const pod3 = tmp('static-noagent');
+  const wf3 = makePod(pod3);
+  fs.rmSync(path.join(pod3, 'agents', 'solo.md'));
+  ok(!throwsFail(() => vp.validateWorkflow(wf3, undefined)),
+    'AC8: agente ausente NÃO reprova o validador estático (wf recém-gerado pela fábrica é estado legítimo) — o gate é no despacho');
+}
+{
+  // Varredura de não-regressão: TODOS os wf reais dos dois repos + fixtures.
+  function collect(dir) {
+    const out = []; const st = [dir];
+    while (st.length) {
+      const d = st.pop();
+      if (!fs.existsSync(d)) continue;
+      for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+        const p = path.join(d, e.name);
+        if (e.isDirectory()) st.push(p);
+        else if (path.basename(d) === 'workflows' && /^wf-.*\.ya?ml$/.test(e.name)) out.push(p);
+      }
+    }
+    return out.sort();
+  }
+  const roots = [
+    path.join(REPO_ROOT, 'template', 'pods'),
+    path.join(REPO_ROOT, 'spike'),
+    path.join(DEV_ROOT, 'second-brain', 'pods'), // instalação real, quando presente ao lado
+  ];
+  let total = 0; let mortas = 0;
+  for (const r of roots) {
+    for (const wf of collect(r)) {
+      const doc = vp.parseYaml(fs.readFileSync(wf, 'utf8'));
+      const podRoot = vp.podRootFor(wf);
+      for (const s of (doc.steps || [])) {
+        if (!Array.isArray(s.knowledge)) continue;
+        for (const k of s.knowledge) {
+          total++;
+          if (!fs.existsSync(path.join(podRoot, 'knowledge', String(k)))) {
+            mortas++; console.error(`  referência morta: ${wf} :: ${s.id} :: knowledge/${k}`);
+          }
+        }
+      }
+    }
+  }
+  ok(mortas === 0, `AC8: varredura dos wf reais — 0 referências de knowledge mortas (${total} referência(s) checada(s))`);
+}
+
+// ===========================================================================
+// (AC9) Retrocompat multi-pod — wf SEM `knowledge:` lista só o agente
+// ===========================================================================
+console.log('--- (AC9) retrocompat: etapa sem `knowledge:` ---');
+{
+  const pod = tmp('retro');
+  const wfPath = makePod(pod, { knowledge: null });
+  const { result } = startOn(wfPath, 'r');
+  ok(result.action === 'dispatch', 'AC9: etapa sem `knowledge:` despacha normalmente (sem erro, sem bloqueio)');
+  const linhas = result.brief.split('\n').filter((l) => l.startsWith('- /'));
+  ok(linhas.length === 1 && linhas[0].endsWith(path.join('agents', 'solo.md')),
+    `AC9: a seção lista SÓ o arquivo do agente (${linhas.length} linha(s))`);
+  ok(!/knowledge\//.test(result.brief), 'AC9: nenhuma menção a knowledge/ no brief da etapa sem o campo');
+}
+{
+  // Genérico por construção: o helper não conhece pod nenhum.
+  const src = fs.readFileSync(path.join(__dirname, 'pc-run-pod.cjs'), 'utf8');
+  const fn = src.slice(src.indexOf('function requiredReading(ctx, step)'), src.indexOf('function requiredReadingBriefLines'));
+  ok(!/hn-|carousel|hormozi|squad-forge|content-/.test(fn),
+    'AC9/B5: `requiredReading` não cita nome de pod nem de arquivo específico (derivado do schema)');
+}
+
+// ===========================================================================
+// Custo medido (AC4/AC12) — o desenho REDUZ o brief; a seção nova é barata
+// ===========================================================================
+console.log('--- (AC4/AC12) custo do brief ---');
+{
+  const pod = tmp('cost');
+  const wfPath = makePod(pod);
+  const { ctx, result } = startOn(wfPath, 'c');
+  const step = rp.stepById(ctx.doc, 'solo');
+  const rr = rp.requiredReading(ctx, step);
+  const secao = rp.requiredReadingBriefLines(rr.files).join('\n');
+  const assertions = step.veto.assertions;
+  const cru = assertions.map((a) => JSON.stringify(a)).join('\n').length;
+  const podado = assertions.map((a) => JSON.stringify(rp.vetoAssertionForBrief(a))).join('\n').length;
+  ok(podado < cru, `AC4: o render de veto encolhe (${cru} B → ${podado} B)`);
+  ok(secao.length > 0 && result.brief.includes(secao.split('\n')[0]),
+    `AC12: a seção de leitura obrigatória custa ${Buffer.byteLength(secao, 'utf8')} B (referência, não conteúdo)`);
+}
+
+// ---------------------------------------------------------------------------
+for (const d of tmpdirs) { try { fs.rmSync(d, { recursive: true, force: true }); } catch { /* ok */ } }
+
+console.log(`\n${passed}/${passed + failures.length} verificações passaram.`);
+if (failures.length > 0) {
+  console.error('\nSF11.2 (leitura obrigatória / veto sem cola) FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('\n[SUCESSO] SF11.2: Parte A (veto sem `_sources`) + Parte B (leitura obrigatória verificada).');