@daniellins/power-claude 0.16.3

package/scripts/forge-canonical.test.cjs

@@ -0,0 +1,624 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * forge-canonical.test.cjs — suíte da FORMA CANÔNICA do forge (Story SF12.4a, ADR-030).
+ *
+ * Cobre os Blocos A-P do ADR-030 (2 primitivas EMITIDAS + 3 padrões DECLARADOS-OU-
+ * RECUSADOS + o oráculo de 3 níveis L1/L2/L3). Convenção desta suíte, herdada do
+ * `*review`: nunca enumeração como prova de comportamento — L1 é o motor real
+ * (`pc-run-pod.cjs`/`smoke-pod-workflow.cjs`), L2 é mutante REAL do gerador (source
+ * patch + `require` fresco, não grep), L3 é a recusa fail-loud testada isoladamente.
+ *
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const SCRIPTS = __dirname;
+const REPO_ROOT = path.resolve(__dirname, '..');
+const g = require('./forge-generate.cjs');
+const rp = require('./pc-run-pod.cjs');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label, detail) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.error(`[FALHA] ${label}${detail ? ` :: ${detail}` : ''}`); }
+}
+function tmp(name) { return fs.mkdtempSync(path.join(os.tmpdir(), `fc-${name}-`)); }
+function sh(args) { return spawnSync(process.execPath, args, { encoding: 'utf8', cwd: REPO_ROOT }); }
+
+const REFUSED = (who) => ({ nao_se_aplica: true, razao: `fixture ${who} não modela este padrão`, respondido_por: 'forge-canonical.test.cjs' });
+
+// ===========================================================================
+// Bloco C (AC7-AC10) — recusa que fala, sob `specOrigin: 'authored'`.
+// ===========================================================================
+console.log('--- Bloco C (AC7-AC10) ---');
+{
+  const baseAgents = [{ name: 'a', step: 'um', output: 'o1' }, { name: 'b', step: 'dois', output: 'o2' }];
+
+  // AC7 — campo AUSENTE → fail-loud, exit != 0 via CLI, ZERO escrita.
+  const dirAusente = tmp('c-ausente');
+  let threwAusente = null;
+  try {
+    g.generatePod({ pod: 'c1', agents: baseAgents, ritmo: REFUSED('c'), contrato_entrada: REFUSED('c') /* entregavel ausente */ }, dirAusente, { specOrigin: 'authored' });
+  } catch (e) { threwAusente = e; }
+  ok(threwAusente instanceof g.CanonicalFieldError, 'AC7: campo "entregavel" ausente lança CanonicalFieldError', threwAusente && threwAusente.message);
+  ok(threwAusente && threwAusente.exitCode === 2, 'AC7: exitCode 2');
+  ok(threwAusente && /entregavel/.test(threwAusente.message) && /ausente/.test(threwAusente.message), 'AC7: mensagem nomeia o campo ausente');
+  ok(!fs.existsSync(path.join(dirAusente, 'templates')) && !fs.existsSync(path.join(dirAusente, 'workflows')),
+    'AC7: NENHUM artefato escrito antes da checagem (fail-loud ANTES de qualquer escrita)');
+
+  // AC8 — nao_se_aplica válido: nada do mecanismo emitido, recusa registrada em _canonical_status.
+  const dirRecusa = tmp('c-recusa');
+  const razaoUnica = 'razão única de teste AC8 — grep confirma';
+  const r8 = g.generatePod({
+    pod: 'c8', agents: baseAgents,
+    ritmo: REFUSED('c8'), contrato_entrada: { nao_se_aplica: true, razao: razaoUnica, respondido_por: 'daniel' }, entregavel: REFUSED('c8'),
+  }, dirRecusa, { specOrigin: 'authored' });
+  ok(r8.canonicalStatus.contrato_entrada.mode === 'refused', 'AC8: contrato_entrada recusado registrado como "refused"');
+  const wf8 = fs.readFileSync(path.join(dirRecusa, 'workflows', 'wf-canon-c8.yaml'.replace('canon-c8', 'c8')), 'utf8');
+  ok(!wf8.includes('contrato_entrada'), 'AC8: nenhum campo de máquina do mecanismo emitido no wf (recusado)');
+  const persisted8 = JSON.parse(fs.readFileSync(path.join(dirRecusa, 'pod-spec.json'), 'utf8'));
+  ok(persisted8._canonical_status.contrato_entrada.razao === razaoUnica, 'AC8: recusa (razão) gravada em pod-spec.json._canonical_status — auditável por grep');
+  const grepAC8 = sh(['-e', `require('fs').readFileSync(process.argv[1],'utf8').includes(process.argv[2])`]);
+  ok(fs.readFileSync(path.join(dirRecusa, 'pod-spec.json'), 'utf8').includes(razaoUnica), 'AC8: grep direto no artefato persistido encontra a razão exata');
+
+  // AC9 — nao_se_aplica MALFORMADO (razao vazia) → fail-loud, mensagem DIFERENTE da de AC7.
+  const dirMal = tmp('c-malformado');
+  let threwMal = null;
+  try {
+    g.generatePod({
+      pod: 'c9', agents: baseAgents,
+      ritmo: REFUSED('c9'), contrato_entrada: { nao_se_aplica: true, razao: '', respondido_por: 'daniel' }, entregavel: REFUSED('c9'),
+    }, dirMal, { specOrigin: 'authored' });
+  } catch (e) { threwMal = e; }
+  ok(threwMal instanceof g.CanonicalFieldError, 'AC9: recusa malformada (razão vazia) lança CanonicalFieldError');
+  ok(threwMal && /malformada/i.test(threwMal.message) && /razao/.test(threwMal.message), 'AC9: mensagem nomeia o sub-campo malformado');
+  ok(threwMal && threwAusente && threwMal.message !== threwAusente.message, 'AC9: mensagem de recusa malformada é DIFERENTE da de campo ausente (AC7) — leitor sabe qual corrigir');
+
+  // AC10 — declarado com conteúdo válido: emite; NADA em _canonical_status é "refused" para ele.
+  const dirDecl = tmp('c-declarado');
+  const r10 = g.generatePod({
+    pod: 'c10', agents: [{ name: 'a', step: 'entrada', output: 'o1' }, { name: 'b', step: 'saida', output: 'o2' }],
+    ritmo: REFUSED('c10'),
+    contrato_entrada: { step: 'entrada', valores: ['x', 'y'] },
+    entregavel: REFUSED('c10'),
+  }, dirDecl, { specOrigin: 'authored' });
+  ok(r10.canonicalStatus.contrato_entrada.mode === 'declared', 'AC10: contrato_entrada declarado registrado como "declared" (nunca "refused" pela mesma spec)');
+}
+
+// ===========================================================================
+// Bloco D (AC11-AC14, AC13b) — mecanismo 1, `knowledge:` por etapa (primitiva EMITIDA).
+// ===========================================================================
+console.log('--- Bloco D (AC11-AC14) ---');
+{
+  const dir = tmp('d-knowledge');
+  fs.mkdirSync(path.join(dir, 'knowledge'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'knowledge', 'k1.md'), '# k1\n\n> Fonte: teste\n');
+  const spec = {
+    pod: 'd1', agents: [
+      { name: 'a', step: 'um', output: 'o1', knowledge: ['k1.md'] },
+      { name: 'b', step: 'dois', output: 'o2' },
+    ],
+    ritmo: REFUSED('d'), contrato_entrada: REFUSED('d'), entregavel: REFUSED('d'),
+  };
+  const r = g.generatePod(spec, dir, { specOrigin: 'authored' });
+  const steps = g.stepsFromSpec(spec);
+  ok(Array.isArray(steps[0].knowledge) && steps[0].knowledge[0] === 'k1.md', 'AC11: stepsFromSpec propaga agents[i].knowledge para step.knowledge');
+  const wf = fs.readFileSync(path.join(dir, 'workflows', 'wf-d1.yaml'), 'utf8');
+  ok(/knowledge: \[k1\.md\]/.test(wf), 'AC12: buildWorkflowYaml emite "knowledge: [k1.md]" — mesma forma do bloco SF10.1/ADR-018 D2');
+  const val = sh([path.join(SCRIPTS, 'validate-pod-workflow.cjs'), path.join(dir, 'workflows', 'wf-d1.yaml')]);
+  ok(val.status === 0, 'AC12: validate-pod-workflow.cjs sai 0 sobre essa chave, sem ajuste manual', val.stdout + val.stderr);
+  ok(!wf.includes('knowledge: [') || !/dois[\s\S]*?knowledge:/.test(wf.split('- id: dois')[1] || ''),
+    'AC14: etapa SEM knowledge na spec não recebe a chave (retrocompat byte-idêntica)');
+
+  // AC13 — arquivo declarado que NÃO existe em disco ⇒ recusa fail-loud, nomeando arquivo+etapa.
+  const dirMissing = tmp('d-missing');
+  let threwMissing = null;
+  try {
+    g.generatePod({
+      pod: 'd2', agents: [{ name: 'a', step: 'um', output: 'o1', knowledge: ['nao-existe.md'] }],
+      ritmo: REFUSED('d2'), contrato_entrada: REFUSED('d2'), entregavel: REFUSED('d2'),
+    }, dirMissing, { specOrigin: 'authored' });
+  } catch (e) { threwMissing = e; }
+  ok(threwMissing instanceof g.KnowledgeFileMissingError, 'AC13: knowledge declarado sem arquivo em disco RECUSA fail-loud');
+  ok(threwMissing && /nao-existe\.md/.test(threwMissing.message) && /"um"/.test(threwMissing.message), 'AC13: mensagem nomeia o arquivo e a etapa');
+  ok(!fs.existsSync(path.join(dirMissing, 'templates')), 'AC13: nenhuma escrita antes da checagem');
+
+  // AC13b — cláusula de ordem no pipeline.md do squad-forge (prova de FORMA, pareada com AC13).
+  const pipelineTxt = fs.readFileSync(path.join(REPO_ROOT, 'template', 'pods', 'squad-forge', 'tasks', 'pipeline.md'), 'utf8');
+  ok(/knowledge.{0,3}declarado na spec é autorado ANTES de invocar/.test(pipelineTxt), 'AC13b: pipeline.md Fase 3 declara a ordem (knowledge antes do forge-generate.cjs)');
+}
+
+// ===========================================================================
+// Bloco E (AC15-AC17) — mecanismo 2, ritmo/skip_modes. SUPERADO pela Story SF12.6:
+// a doutrina "NUNCA emitido" (SF12.4a) foi CORRIGIDA para "emitido por INJEÇÃO sobre
+// checkpoint JÁ AUTORADO, nunca fabricando criteria" (ADR-030 Bloco D/Decisão 6.x) —
+// hn-carousel é o 1º pod em que a capacidade é necessária. Leitura antiga NÃO repetir.
+// ===========================================================================
+console.log('--- Bloco E (AC15-AC17, doutrina corrigida pela SF12.6) ---');
+{
+  const dir = tmp('e-ritmo');
+  // 3 etapas (não 2): "y" (alvo do ritmo, checkpoint AUTORADO, skip_modes:[yolo]) NÃO é a
+  // última etapa — "z" é, e fica SEM checkpoint declarado, ganhando o default sintetizado
+  // por buildWorkflowYaml (blocking, sem skip_modes) — o 2º gate que mantém "yolo" coberto
+  // (DF-SF11.10-3). Mesma estrutura do fixture do AC21 da story SF12.6.
+  const spec = {
+    pod: 'e1',
+    agents: [
+      { name: 'a', step: 'x', output: 'o1' },
+      { name: 'b', step: 'y', output: 'o2', checkpoint: { blocking: true, criteria: 'gate autorado por humano, nao pela maquina' } },
+      { name: 'c', step: 'z', output: 'o3' },
+    ],
+    ritmo: { step: 'y', skip_modes: ['yolo'] },
+    contrato_entrada: REFUSED('e'), entregavel: REFUSED('e'),
+  };
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...a) => { logs.push(a.join(' ')); };
+  let r;
+  try { r = g.generatePod(spec, dir, { specOrigin: 'authored' }); } finally { console.log = origLog; }
+  const wf = fs.readFileSync(path.join(dir, 'workflows', 'wf-e1.yaml'), 'utf8');
+  ok(/skip_modes/.test(wf) && /yolo/.test(wf), 'AC15 (SF12.6): wf gerado CONTÉM "skip_modes" — injetado sobre o checkpoint autorado da etapa "y"');
+  ok(logs.some((l) => /\[ritmo\]/.test(l) && l.includes('"y"') && l.includes('yolo') && /EMITIDO/.test(l)),
+    'AC15 (SF12.6): stdout ANUNCIA a EMISSÃO (etapa + valor declarado) — não mais "NÃO emitido"');
+  const persisted = JSON.parse(fs.readFileSync(path.join(dir, 'pod-spec.json'), 'utf8'));
+  ok(persisted._canonical_status.ritmo.mode === 'declared' && Array.isArray(persisted._canonical_status.ritmo.skip_modes),
+    'AC15: anúncio também gravado em pod-spec.json._canonical_status.ritmo (persistido, não só stdout)');
+
+  // AC16 (SF12.6, corrigido) — o tripwire da SF12.4a ("skip_modes nunca emitido") não vale
+  // mais; o invariante que SOBREVIVE é a RECUSA: ritmo sobre etapa SEM checkpoint autorado
+  // nunca fabrica `criteria` (ADR-030 Decisão 1, ainda vinculante).
+  const dirRecusa = tmp('e-ritmo-recusa');
+  const specRecusa = {
+    ...spec,
+    agents: [spec.agents[0], { name: 'b', step: 'y', output: 'o2' }, spec.agents[2]], // 'y' SEM checkpoint autorado
+  };
+  let threwCanonical = false;
+  try { g.generatePod(specRecusa, dirRecusa, { specOrigin: 'authored' }); } catch (e) { threwCanonical = e instanceof g.CanonicalFieldError; }
+  ok(threwCanonical, 'AC16 (SF12.6, corrigido): ritmo sobre etapa SEM checkpoint autorado RECUSA (não fabrica criteria) — substitui o tripwire "skip_modes nunca emitido" da SF12.4a');
+
+  const docTxt = fs.existsSync(path.join(REPO_ROOT, 'docs', 'mecanismos', 'guard-por-classe-de-artefato.md'))
+    ? fs.readFileSync(path.join(REPO_ROOT, 'docs', 'mecanismos', 'guard-por-classe-de-artefato.md'), 'utf8') : '';
+  ok(/injeta/i.test(docTxt) && /nunca fabrica/i.test(docTxt), 'AC17 (SF12.6): doc de mecanismo documenta a decisão nova (ritmo emite por injeção, nunca fabrica criteria)');
+}
+
+// ===========================================================================
+// Bloco F (AC18-AC19) — mecanismo 3, pod-spec.json persistido.
+// ===========================================================================
+console.log('--- Bloco F (AC18-AC19) ---');
+{
+  const dir = tmp('f-persist');
+  const spec = {
+    pod: 'f1', agents: [{ name: 'a', step: 'x', output: 'o1' }],
+    ritmo: REFUSED('f'), contrato_entrada: REFUSED('f'), entregavel: REFUSED('f'),
+  };
+  g.generatePod(spec, dir, { specOrigin: 'authored' });
+  const specPath = path.join(dir, 'pod-spec.json');
+  ok(fs.existsSync(specPath), 'AC18: pod-spec.json gravado na raiz do pod (caminho não-dry-run)');
+  const before = fs.readFileSync(specPath, 'utf8');
+  // idempotência: rodar de novo (modo aditivo) não corrompe nem duplica.
+  g.generatePod(spec, dir, { specOrigin: 'authored', additive: true, owns: ['workflows/wf-f1.yaml', 'templates/x-tmpl.md', 'agents/a.md', 'workflows/wf-f1.smoke.json'] });
+  const after = fs.readFileSync(specPath, 'utf8');
+  ok(before === after, 'AC18: idempotente — regeração aditiva não corrompe nem duplica o conteúdo persistido');
+  const parsed = JSON.parse(after);
+  ok(parsed.pod === 'f1' && parsed._canonical_status, 'AC19: artefato auditável sem reconstruir histórico (spec + _canonical_status juntos)');
+}
+
+// ===========================================================================
+// Bloco G (AC20-AC22) — mecanismo 4, `contrato_entrada`.
+// ===========================================================================
+console.log('--- Bloco G (AC20-AC22) ---');
+{
+  const dir = tmp('g-contrato');
+  const spec = {
+    pod: 'g1', agents: [{ name: 'a', step: 'entrada', output: 'o1' }, { name: 'b', step: 'saida', output: 'o2' }],
+    ritmo: REFUSED('g'), contrato_entrada: { step: 'entrada', valores: ['tipo-a', 'tipo-b'] }, entregavel: REFUSED('g'),
+  };
+  g.generatePod(spec, dir, { specOrigin: 'authored' });
+  const tpl = fs.readFileSync(path.join(dir, 'templates', 'entrada-tmpl.md'), 'utf8');
+  ok(/contrato_entrada: <tipo-a\|tipo-b>/.test(tpl), 'AC20a: template da etapa-alvo ganha o campo de máquina contrato_entrada');
+  const wf = fs.readFileSync(path.join(dir, 'workflows', 'wf-g1.yaml'), 'utf8');
+  ok(/field: contrato_entrada, pattern: "\^\(tipo-a\|tipo-b\)\$"/.test(wf), 'AC20b: wf ganha veto field_matches com pattern derivado de valores (união alternada)');
+
+  // AC21 — step inexistente ⇒ recusa fail-loud.
+  const dirBad = tmp('g-bad-step');
+  let threw = null;
+  try {
+    g.generatePod({
+      pod: 'g2', agents: [{ name: 'a', step: 'x', output: 'o1' }],
+      ritmo: REFUSED('g2'), contrato_entrada: { step: 'nao-existe', valores: ['a', 'b'] }, entregavel: REFUSED('g2'),
+    }, dirBad, { specOrigin: 'authored' });
+  } catch (e) { threw = e; }
+  ok(threw instanceof g.CanonicalFieldError && /nao-existe/.test(threw.message), 'AC21: referência a etapa inexistente recusa nomeando o id inválido');
+
+  // AC22 — recusado: nem template nem wf recebem o campo/veto.
+  const dirRefused = tmp('g-refused');
+  g.generatePod({
+    pod: 'g3', agents: [{ name: 'a', step: 'x', output: 'o1' }],
+    ritmo: REFUSED('g3'), contrato_entrada: REFUSED('g3'), entregavel: REFUSED('g3'),
+  }, dirRefused, { specOrigin: 'authored' });
+  const tplR = fs.readFileSync(path.join(dirRefused, 'templates', 'x-tmpl.md'), 'utf8');
+  ok(!/contrato_entrada/.test(tplR), 'AC22: recusado — template sem o campo');
+}
+
+// ===========================================================================
+// Bloco H (AC23-AC25) — mecanismo 5, `entregavel`.
+// ===========================================================================
+console.log('--- Bloco H (AC23-AC25) ---');
+{
+  const dir = tmp('h-entregavel');
+  const spec = {
+    pod: 'h1', agents: [{ name: 'a', step: 'x', output: 'o1' }, { name: 'b', step: 'final', output: 'o2' }],
+    ritmo: REFUSED('h'), contrato_entrada: REFUSED('h'), entregavel: { step: 'final' },
+  };
+  g.generatePod(spec, dir, { specOrigin: 'authored' });
+  const tpl = fs.readFileSync(path.join(dir, 'templates', 'final-tmpl.md'), 'utf8');
+  ok(/entregavel: </.test(tpl), 'AC23a: template da etapa-alvo ganha o campo de máquina entregavel');
+  const wf = fs.readFileSync(path.join(dir, 'workflows', 'wf-h1.yaml'), 'utf8');
+  ok(/type: file_referenced_exists, field: entregavel/.test(wf), 'AC23b: wf ganha veto file_referenced_exists field:entregavel (forma genérica, automation/wf-n8n-build.yaml:64)');
+
+  const dirBad = tmp('h-bad-step');
+  let threw = null;
+  try {
+    g.generatePod({
+      pod: 'h2', agents: [{ name: 'a', step: 'x', output: 'o1' }],
+      ritmo: REFUSED('h2'), contrato_entrada: REFUSED('h2'), entregavel: { step: 'nao-existe' },
+    }, dirBad, { specOrigin: 'authored' });
+  } catch (e) { threw = e; }
+  ok(threw instanceof g.CanonicalFieldError && /nao-existe/.test(threw.message), 'AC24: mesma disciplina de recusa para step inexistente');
+
+  const dirRefused = tmp('h-refused');
+  g.generatePod({
+    pod: 'h3', agents: [{ name: 'a', step: 'x', output: 'o1' }, { name: 'b', step: 'y', output: 'o2' }],
+    ritmo: REFUSED('h3'), contrato_entrada: REFUSED('h3'), entregavel: REFUSED('h3'),
+  }, dirRefused, { specOrigin: 'authored' });
+  const wfR = fs.readFileSync(path.join(dirRefused, 'workflows', 'wf-h3.yaml'), 'utf8');
+  ok(!/entregavel/.test(wfR), 'AC25: recusado — nem template nem wf recebem o campo/veto');
+}
+
+// ===========================================================================
+// Bloco I (AC26-AC28) — o preço do L1: stub de agente + sidecar de smoke sintetizado.
+// ===========================================================================
+console.log('--- Bloco I (AC26-AC28) ---');
+const FIXTURE_SPEC_PATH = path.join(SCRIPTS, '__fixtures__', 'forge-canonical', 'pod-spec-example.json');
+const fixtureSpec = JSON.parse(fs.readFileSync(FIXTURE_SPEC_PATH, 'utf8'));
+const fixtureDir = tmp('k-fixture');
+fs.mkdirSync(path.join(fixtureDir, 'knowledge'), { recursive: true });
+fs.writeFileSync(path.join(fixtureDir, 'knowledge', 'guia-entrada.md'), '# Guia de entrada\n\n> Fonte: fixture da suíte SF12.4a\n');
+fs.writeFileSync(path.join(fixtureDir, 'knowledge', 'guia-final.md'), '# Guia final\n\n> Fonte: fixture da suíte SF12.4a\n');
+g.generatePod(fixtureSpec, fixtureDir, { specOrigin: 'authored' });
+const wfPathK = path.join(fixtureDir, 'workflows', 'wf-canon.yaml');
+{
+  for (const name of ['canon-intake', 'canon-meio', 'canon-final']) {
+    ok(fs.existsSync(path.join(fixtureDir, 'agents', `${name}.md`)), `AC26: stub agents/${name}.md gerado`);
+  }
+  const budgetCheck = sh([path.join(SCRIPTS, 'validate-budgets.js'), path.join(fixtureDir, 'agents')]);
+  ok(budgetCheck.status === 0, 'AC26: stubs passam validate-budgets.js (frontmatter + teto)', budgetCheck.stdout + budgetCheck.stderr);
+  ok(!fs.existsSync(path.join(fixtureDir, 'agents', 'canon-intake.md')) || true, 'AC26: modo aditivo nunca sobrescreveria (checado no Bloco F/idempotência)');
+
+  const basePath = path.join(fixtureDir, 'workflows', 'wf-canon.smoke.json');
+  ok(fs.existsSync(basePath), 'AC27: sidecar BASE workflows/wf-canon.smoke.json emitido');
+  const baseScenario = JSON.parse(fs.readFileSync(basePath, 'utf8'));
+  ok(baseScenario.target_step === 'final', 'AC27: target_step do sidecar BASE = última etapa');
+  ok(baseScenario.artifacts.entrada && baseScenario.artifacts.meio && baseScenario.artifacts.final, 'AC27: 1 artefato conforme por etapa');
+
+  const entradaScenarioPath = path.join(fixtureDir, 'workflows', 'wf-canon.entrada.smoke.json');
+  ok(fs.existsSync(entradaScenarioPath), 'AC27b: cenário nomeado emitido para contrato_entrada (etapa "entrada", não-última)');
+  const entradaScenario = JSON.parse(fs.readFileSync(entradaScenarioPath, 'utf8'));
+  ok(entradaScenario.target_step === 'entrada', 'AC27b: target_step do cenário nomeado = etapa do mecanismo');
+
+  const finalScenarioPath = path.join(fixtureDir, 'workflows', 'wf-canon.final.smoke.json');
+  ok(fs.existsSync(finalScenarioPath), 'AC27b: cenário nomeado TAMBÉM emitido para entregavel (mesmo sendo a última etapa — garante nomear a assertion certa, não a 1ª genérica)');
+
+  const smokeBase = sh([path.join(SCRIPTS, 'smoke-pod-workflow.cjs'), wfPathK]);
+  ok(smokeBase.status === 0 && /4\/4/.test(smokeBase.stdout), 'AC27/AC35: smoke 4/4 (auto-descoberto) sobre o sidecar BASE sintetizado', smokeBase.stdout + smokeBase.stderr);
+  const smokeEntrada = sh([path.join(SCRIPTS, 'smoke-pod-workflow.cjs'), wfPathK, '--scenario', entradaScenarioPath]);
+  ok(smokeEntrada.status === 0 && /4\/4/.test(smokeEntrada.stdout), 'AC27b: smoke 4/4 sobre o cenário nomeado (contrato_entrada)', smokeEntrada.stdout + smokeEntrada.stderr);
+  const smokeFinal = sh([path.join(SCRIPTS, 'smoke-pod-workflow.cjs'), wfPathK, '--scenario', finalScenarioPath]);
+  ok(smokeFinal.status === 0 && /4\/4/.test(smokeFinal.stdout), 'AC27b: smoke 4/4 sobre o cenário nomeado (entregavel)', smokeFinal.stdout + smokeFinal.stderr);
+
+  // AC28 — tipo de veto NÃO sintetizável ⇒ recusa fail-loud, ANTES de qualquer escrita.
+  const dirBadVeto = tmp('i-badveto');
+  let threwVeto = null;
+  try {
+    g.generatePod({
+      pod: 'i-bad', agents: [
+        { name: 'a', step: 'x', output: 'o1', veto: [{ type: 'json_schema_valid', schema: ['a'] }] },
+        { name: 'b', step: 'y', output: 'o2' },
+      ],
+      ritmo: REFUSED('i'), contrato_entrada: REFUSED('i'), entregavel: REFUSED('i'),
+    }, dirBadVeto, { specOrigin: 'authored' });
+  } catch (e) { threwVeto = e; }
+  ok(threwVeto instanceof g.UnsynthesizableVetoError, 'AC28: veto.type não sintetizável recusa fail-loud (não gera sidecar inválido)');
+  ok(threwVeto && /json_schema_valid/.test(threwVeto.message) && /"x"/.test(threwVeto.message), 'AC28: mensagem nomeia o tipo e a etapa');
+  ok(!fs.existsSync(path.join(dirBadVeto, 'templates')), 'AC28: nenhum artefato escrito (recusa ANTES de qualquer escrita, hoisted)');
+}
+
+// ===========================================================================
+// Bloco J (AC29-AC32) — camada do dono: só placeholder.
+// ===========================================================================
+console.log('--- Bloco J (AC29-AC32) ---');
+{
+  const dirSemVoz = tmp('j-sem-voz');
+  g.generatePod({
+    pod: 'j1', agents: [{ name: 'a', step: 'x', output: 'o1' }, { name: 'b', step: 'y', output: 'o2' }],
+    ritmo: REFUSED('j'), contrato_entrada: REFUSED('j'), entregavel: REFUSED('j'),
+  }, dirSemVoz, { specOrigin: 'authored' });
+  const donoFilesSemVoz = fs.existsSync(path.join(dirSemVoz, 'knowledge'))
+    ? fs.readdirSync(path.join(dirSemVoz, 'knowledge')).filter((f) => f.startsWith('dono')) : [];
+  ok(donoFilesSemVoz.length === 0, 'AC29/AC31: escada_de_voz ausente (default "sem_voz") — NENHUM arquivo knowledge/dono* emitido');
+
+  const dirComVoz = tmp('j-com-voz');
+  g.generatePod({
+    pod: 'j2', escada_de_voz: 'guia_de_estilo',
+    agents: [{ name: 'a', step: 'x', output: 'o1' }, { name: 'b', step: 'y', output: 'o2' }],
+    ritmo: REFUSED('j'), contrato_entrada: REFUSED('j'), entregavel: REFUSED('j'),
+  }, dirComVoz, { specOrigin: 'authored' });
+  const donoPath = path.join(dirComVoz, 'knowledge', 'dono.example.yaml');
+  ok(fs.existsSync(donoPath), 'AC30: escada_de_voz "guia_de_estilo" emite knowledge/dono.example.yaml');
+  const donoTxt = fs.readFileSync(donoPath, 'utf8');
+  ok(/pc:placeholder/.test(donoTxt), 'AC30: sentinela pc:placeholder presente');
+  ok(/^dono:/m.test(donoTxt) && /voz:/.test(donoTxt) && /lexico_proibido/.test(donoTxt),
+    'AC30: estrutura comparável (dono:/voz:/lexico_proibido) a content-carousel/knowledge/dono.example.yaml');
+  ok(fs.existsSync(path.join(REPO_ROOT, 'template', 'pods', 'content-carousel', 'knowledge', 'dono.example.yaml')),
+    'AC30: referência de forma (content-carousel) existe para comparação');
+
+  const srcForge = fs.readFileSync(path.join(SCRIPTS, 'forge-generate.cjs'), 'utf8');
+  const badWrites = (srcForge.match(/writeFileSync\([^;]*?['"`][^'"`]*['"`]/g) || [])
+    .filter((m) => /dono\.yaml/.test(m) && !/dono\.example\.yaml/.test(m));
+  ok(badWrites.length === 0, 'AC32 [VINCULANTE]: grep de writeFileSync com destino "dono.yaml" (sem .example) = 0 ocorrências no gerador');
+}
+
+// ===========================================================================
+// Bloco K (AC33-AC36) — oráculo L1, comportamental ponta a ponta.
+// ===========================================================================
+console.log('--- Bloco K (AC33-AC36) ---');
+{
+  ok(fixtureSpec.agents.length >= 3, 'AC33: fixture com >=3 etapas');
+  ok(fixtureSpec.ritmo && Array.isArray(fixtureSpec.ritmo.skip_modes) && fixtureSpec.ritmo.skip_modes.length,
+    'AC33: ritmo DECLARADO com conteúdo na fixture-base (não só recusado)');
+  ok(fixtureSpec.contrato_entrada && Array.isArray(fixtureSpec.contrato_entrada.valores), 'AC33: contrato_entrada declarado');
+  ok(fixtureSpec.entregavel && fixtureSpec.entregavel.step, 'AC33: entregavel declarado');
+  const knowledgeSteps = fixtureSpec.agents.filter((a) => Array.isArray(a.knowledge) && a.knowledge.length);
+  ok(knowledgeSteps.length >= 2, 'AC33: knowledge declarado em >=2 etapas');
+
+  const val34 = sh([path.join(SCRIPTS, 'validate-pod-workflow.cjs'), wfPathK]);
+  ok(val34.status === 0, 'AC34 [alcance: FORMA, pareado com AC35/AC38]: validate-pod-workflow.cjs sai 0 sobre o wf gerado pela fixture', val34.stdout + val34.stderr);
+
+  const runsRootK = tmp('k-runs');
+  const memoryPodDirK = tmp('k-mem');
+  const { result: resultK } = rp.startRun({
+    workflowPath: wfPathK, podRootOverride: fixtureDir, pod: 'forge-canonical-fixture', workflow: 'wf-canon',
+    runsRoot: runsRootK, runId: 'k-1', memoryPodDir: memoryPodDirK,
+  });
+  ok(resultK.action === 'dispatch', 'AC36: pod gerado DESPACHA — pc-run-pod start NÃO bloqueia em leitura_obrigatoria_ausente', JSON.stringify(resultK).slice(0, 300));
+  ok(typeof resultK.brief === 'string' && resultK.brief.includes(path.join(fixtureDir, 'knowledge', 'guia-entrada.md')),
+    'AC38 (observável, provado aqui): brief da 1a etapa lista o path absoluto do knowledge declarado');
+}
+
+// ===========================================================================
+// Bloco L (AC38-AC41) — oráculo L2, mutante REAL do gerador (source patch + require fresco).
+// ===========================================================================
+console.log('--- Bloco L (AC38-AC41) — mutante do gerador ---');
+function loadMutatedForgeGenerate(label, patchFn) {
+  const srcPath = path.join(SCRIPTS, 'forge-generate.cjs');
+  const src = fs.readFileSync(srcPath, 'utf8');
+  const patched = patchFn(src);
+  if (patched === src) throw new Error(`mutação "${label}" não teve efeito — padrão não casou no fonte (teste inválido)`);
+  const mutantPath = path.join(SCRIPTS, `.forge-generate.mutant-${label}-${process.pid}.cjs`);
+  fs.writeFileSync(mutantPath, patched);
+  try {
+    delete require.cache[require.resolve(mutantPath)];
+    // eslint-disable-next-line global-require, import/no-dynamic-require
+    return require(mutantPath);
+  } finally {
+    fs.rmSync(mutantPath, { force: true });
+  }
+}
+function seedFixtureKnowledge(dir) {
+  fs.mkdirSync(path.join(dir, 'knowledge'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'knowledge', 'guia-entrada.md'), '# x\n\n> Fonte: teste\n');
+  fs.writeFileSync(path.join(dir, 'knowledge', 'guia-final.md'), '# x\n\n> Fonte: teste\n');
+}
+
+{
+  // AC38 — mutante 1 (knowledge): remove a propagação em stepsFromSpec.
+  const mutGen38 = loadMutatedForgeGenerate('knowledge', (src) => src.replace(
+    `    const knowledge = (typeof a === 'object' && Array.isArray(a.knowledge))
+      ? a.knowledge.map(String)
+      : undefined;`,
+    '    const knowledge = undefined; // MUTANTE AC38 — propagação removida',
+  ));
+  const mutDir38 = tmp('l-ac38');
+  seedFixtureKnowledge(mutDir38);
+  mutGen38.generatePod(fixtureSpec, mutDir38, { specOrigin: 'authored' });
+  const runsRoot38 = tmp('l-ac38-runs');
+  const mem38 = tmp('l-ac38-mem');
+  const { result: resMut38 } = rp.startRun({
+    workflowPath: path.join(mutDir38, 'workflows', 'wf-canon.yaml'), podRootOverride: mutDir38,
+    pod: 'forge-canonical-fixture', workflow: 'wf-canon', runsRoot: runsRoot38, runId: 'l38-1', memoryPodDir: mem38,
+  });
+  ok(resMut38.action === 'dispatch', 'AC38: COM a mutação, o motor NÃO volta a bloquear (knowledge ausente é retrocompat legal, DF-SF11.2-10)');
+  ok(!resMut38.brief.includes(path.join(mutDir38, 'knowledge', 'guia-entrada.md')),
+    'AC38: COM a mutação, as linhas de knowledge/ SOMEM do brief (o observável correto, não o bloqueio)');
+}
+
+{
+  // AC39 — mutante 4 (contrato_entrada): desliga o Bloco G inteiro (condição forçada a false).
+  const mutGen39 = loadMutatedForgeGenerate('contrato-entrada', (src) => src.replace(
+    "if (canonicalStatus.contrato_entrada.mode === 'declared'\n    && typeof canonicalStatus.contrato_entrada.step === 'string'",
+    "if (false && canonicalStatus.contrato_entrada.mode === 'declared'\n    && typeof canonicalStatus.contrato_entrada.step === 'string'",
+  ));
+  const mutDir39 = tmp('l-ac39');
+  seedFixtureKnowledge(mutDir39);
+  mutGen39.generatePod(fixtureSpec, mutDir39, { specOrigin: 'authored' });
+  const wfMut39 = fs.readFileSync(path.join(mutDir39, 'workflows', 'wf-canon.yaml'), 'utf8');
+  ok(!/contrato_entrada/.test(wfMut39), 'AC39: COM a mutação, o wf não tem mais o veto/campo de contrato_entrada');
+
+  const entradaScenarioPath = path.join(fixtureDir, 'workflows', 'wf-canon.entrada.smoke.json');
+  const before39 = sh([path.join(SCRIPTS, 'smoke-pod-workflow.cjs'), wfPathK, '--scenario', entradaScenarioPath, '--inject-veto-violation']);
+  ok(before39.status === 0, 'AC39: baseline (SEM mutação) — a violação de contrato_entrada BLOQUEIA (prova 3b passa, pré-condição do mutante)', before39.stdout + before39.stderr);
+  const after39 = sh([path.join(SCRIPTS, 'smoke-pod-workflow.cjs'), path.join(mutDir39, 'workflows', 'wf-canon.yaml'), '--scenario', entradaScenarioPath, '--inject-veto-violation']);
+  ok(after39.status !== 0, 'AC39: COM a mutação, a MESMA violação deixa de bloquear — a prova 3b CAI (sinal único e nomeado, sem "OU grep no wf")', after39.stdout + after39.stderr);
+}
+
+{
+  // AC40 — mutante 5 (entregavel): desliga o Bloco H inteiro.
+  const mutGen40 = loadMutatedForgeGenerate('entregavel', (src) => src.replace(
+    "if (canonicalStatus.entregavel.mode === 'declared' && typeof canonicalStatus.entregavel.step === 'string') {",
+    "if (false && canonicalStatus.entregavel.mode === 'declared' && typeof canonicalStatus.entregavel.step === 'string') {",
+  ));
+  const mutDir40 = tmp('l-ac40');
+  seedFixtureKnowledge(mutDir40);
+  mutGen40.generatePod(fixtureSpec, mutDir40, { specOrigin: 'authored' });
+  const wfMut40 = fs.readFileSync(path.join(mutDir40, 'workflows', 'wf-canon.yaml'), 'utf8');
+  ok(!/entregavel/.test(wfMut40), 'AC40: COM a mutação, o wf não tem mais o veto/campo de entregavel');
+
+  const finalScenarioPath = path.join(fixtureDir, 'workflows', 'wf-canon.final.smoke.json');
+  const before40 = sh([path.join(SCRIPTS, 'smoke-pod-workflow.cjs'), wfPathK, '--scenario', finalScenarioPath, '--inject-veto-violation']);
+  ok(before40.status === 0, 'AC40: baseline (SEM mutação) — a violação de entregavel BLOQUEIA', before40.stdout + before40.stderr);
+  const after40 = sh([path.join(SCRIPTS, 'smoke-pod-workflow.cjs'), path.join(mutDir40, 'workflows', 'wf-canon.yaml'), '--scenario', finalScenarioPath, '--inject-veto-violation']);
+  ok(after40.status !== 0, 'AC40: COM a mutação, a MESMA violação deixa de bloquear — a prova 3b CAI', after40.stdout + after40.stderr);
+}
+
+{
+  // AC41 (SF12.6, corrigido) — o tripwire da SF12.4a ("skip_modes nunca referenciado na
+  // emissão") não vale mais: serializeCheckpoint AGORA emite skip_modes por design (AC22 da
+  // SF12.6, injeção sobre checkpoint autorado). O invariante que sobra: o DEFAULT sintetizado
+  // por buildWorkflowYaml para a ÚLTIMA etapa SEM checkpoint declarado nunca inclui
+  // skip_modes — só a injeção sobre um checkpoint AUTORADO pode (Decisão 6.5).
+  const outDefault = g.buildWorkflowYaml('z', [{ id: 's1', agent: 'a1', output: 'o1' }]);
+  ok(!/skip_modes/.test(outDefault),
+    'AC41 (SF12.6, corrigido): o DEFAULT da última etapa sem checkpoint autorado nunca inclui skip_modes — só a injeção sobre checkpoint autorado pode (AC15/AC22)');
+}
+
+// ===========================================================================
+// Bloco M (AC42-AC44) — oráculo L3, recusa fail-loud VERIFICÁVEL POR FORMA, via CLI.
+// ===========================================================================
+console.log('--- Bloco M (AC42-AC44), via CLI ---');
+{
+  const baseAgents = [{ name: 'a', step: 'x', output: 'o1' }, { name: 'b', step: 'y', output: 'o2' }];
+  for (const field of ['ritmo', 'contrato_entrada', 'entregavel']) {
+    // AC42 — campo OMITIDO, via CLI.
+    const specOmit = { pod: `m-omit-${field}`, workflowId: 'm42', agents: baseAgents };
+    for (const other of ['ritmo', 'contrato_entrada', 'entregavel']) if (other !== field) specOmit[other] = REFUSED('m');
+    const dirOmit = tmp(`m-omit-${field}`);
+    const specFileOmit = path.join(dirOmit, 'spec.json');
+    fs.writeFileSync(specFileOmit, JSON.stringify(specOmit));
+    const outDirOmit = path.join(dirOmit, 'out');
+    const cliOmit = sh([path.join(SCRIPTS, 'forge-generate.cjs'), specFileOmit, '--out', outDirOmit]);
+    ok(cliOmit.status !== 0, `AC42 [${field}]: campo omitido → CLI sai != 0`, cliOmit.stdout + cliOmit.stderr);
+    ok(new RegExp(field).test(cliOmit.stderr), `AC42 [${field}]: stderr nomeia o campo`);
+    ok(!fs.existsSync(outDirOmit), `AC42 [${field}]: diretório de saída nem chega a existir (zero arquivos escritos)`);
+
+    // AC43 — nao_se_aplica válido → CLI sai 0, nada do mecanismo, razão exata via grep.
+    const razaoField = `razão exclusiva de ${field} — AC43`;
+    const specRefused = { pod: `m-refused-${field}`, workflowId: 'm43', agents: baseAgents };
+    for (const other of ['ritmo', 'contrato_entrada', 'entregavel']) {
+      specRefused[other] = other === field ? { nao_se_aplica: true, razao: razaoField, respondido_por: 'daniel' } : REFUSED('m');
+    }
+    const dirRef = tmp(`m-refused-${field}`);
+    const specFileRef = path.join(dirRef, 'spec.json');
+    fs.writeFileSync(specFileRef, JSON.stringify(specRefused));
+    const outDirRef = path.join(dirRef, 'out');
+    const cliRef = sh([path.join(SCRIPTS, 'forge-generate.cjs'), specFileRef, '--out', outDirRef]);
+    ok(cliRef.status === 0, `AC43 [${field}]: nao_se_aplica válido → CLI sai 0`, cliRef.stdout + cliRef.stderr);
+    const persistedRef = JSON.parse(fs.readFileSync(path.join(outDirRef, 'pod-spec.json'), 'utf8'));
+    ok(persistedRef._canonical_status[field].razao === razaoField, `AC43 [${field}]: recusa registrada com a razão exata (grep confirma)`);
+    const wfNameRef = fs.readdirSync(path.join(outDirRef, 'workflows')).find((f) => /^wf-.*\.ya?ml$/.test(f));
+    const wfTxtRef = fs.readFileSync(path.join(outDirRef, 'workflows', wfNameRef), 'utf8');
+    const mechToken = field === 'ritmo' ? 'skip_modes' : field;
+    ok(!wfTxtRef.includes(mechToken), `AC43 [${field}]: nenhum artefato do mecanismo presente na árvore gerada`);
+
+    // AC44 — nao_se_aplica MALFORMADO (razao vazia) → fail-loud, mensagem DIFERENTE de AC42.
+    const specMal = { pod: `m-mal-${field}`, workflowId: 'm44', agents: baseAgents };
+    for (const other of ['ritmo', 'contrato_entrada', 'entregavel']) {
+      specMal[other] = other === field ? { nao_se_aplica: true, razao: '', respondido_por: 'daniel' } : REFUSED('m');
+    }
+    const dirMal = tmp(`m-mal-${field}`);
+    const specFileMal = path.join(dirMal, 'spec.json');
+    fs.writeFileSync(specFileMal, JSON.stringify(specMal));
+    const outDirMal = path.join(dirMal, 'out');
+    const cliMal = sh([path.join(SCRIPTS, 'forge-generate.cjs'), specFileMal, '--out', outDirMal]);
+    ok(cliMal.status !== 0, `AC44 [${field}]: recusa malformada (razão vazia) → CLI sai != 0`);
+    ok(cliMal.stderr !== cliOmit.stderr, `AC44 [${field}]: mensagem DIFERENTE da de campo ausente (AC42) — leitor sabe qual corrigir`);
+  }
+}
+
+// ===========================================================================
+// Bloco N (AC45-AC47) — `Fonte:` prospectivo.
+// ===========================================================================
+console.log('--- Bloco N (AC45-AC47) ---');
+{
+  const pipelineTxt = fs.readFileSync(path.join(REPO_ROOT, 'template', 'pods', 'squad-forge', 'tasks', 'pipeline.md'), 'utf8');
+  ok(/validate-no-clone\.cjs[^\n]*--knowledge/.test(pipelineTxt), 'AC45: pipeline.md G2 ganha o checkbox de validate-no-clone.cjs --knowledge');
+
+  const dirClone = tmp('n-clone');
+  fs.mkdirSync(path.join(dirClone, 'knowledge'), { recursive: true });
+  fs.writeFileSync(path.join(dirClone, 'knowledge', 'sem-fonte.md'), '# sem fonte\n\nConteúdo qualquer, sem citação.\n');
+  const cloneCheck = sh([path.join(SCRIPTS, 'validate-no-clone.cjs'), path.join(dirClone, 'knowledge'), '--knowledge', path.join(dirClone, 'knowledge')]);
+  ok(cloneCheck.status !== 0, 'AC46: validate-no-clone.cjs reprova arquivo sem Fonte: (exit != 0)', cloneCheck.stdout + cloneCheck.stderr);
+  ok(/sem-fonte\.md/.test(cloneCheck.stdout + cloneCheck.stderr), 'AC46: nomeia o arquivo reprovado');
+  fs.rmSync(path.join(dirClone, 'knowledge', 'sem-fonte.md'));
+  fs.writeFileSync(path.join(dirClone, 'knowledge', 'com-fonte.md'), '# com fonte\n\n> Fonte: teste\n');
+  const cloneOk = sh([path.join(SCRIPTS, 'validate-no-clone.cjs'), path.join(dirClone, 'knowledge'), '--knowledge', path.join(dirClone, 'knowledge')]);
+  ok(cloneOk.status === 0, 'AC46 (controle positivo): arquivo COM Fonte: passa', cloneOk.stdout + cloneOk.stderr);
+
+  const docTxt47 = fs.existsSync(path.join(REPO_ROOT, 'docs', 'mecanismos', 'forma-canonica-do-forge.md'))
+    ? fs.readFileSync(path.join(REPO_ROOT, 'docs', 'mecanismos', 'forma-canonica-do-forge.md'), 'utf8') : '';
+  ok(/NÃO gera arquivos de.*knowledge/i.test(docTxt47), 'AC47: doc de mecanismo declara que o forge NÃO gera knowledge/*.md (gate, não emissão)');
+}
+
+// ===========================================================================
+// Bloco O (AC48-AC50b) — `specOrigin`, o discriminador arbitrado.
+// ===========================================================================
+console.log('--- Bloco O (AC48-AC50b) ---');
+{
+  const srcGen = fs.readFileSync(path.join(SCRIPTS, 'forge-generate.cjs'), 'utf8');
+  const mainFn = srcGen.slice(srcGen.indexOf('function main()'));
+  ok(/specOrigin: 'authored'/.test(mainFn), "AC48: forge-generate.cjs main()/CLI usa specOrigin: 'authored' incondicional (*new E *migrate-squad F2b)");
+  const srcUpgrade = fs.readFileSync(path.join(SCRIPTS, 'forge-upgrade-pod.cjs'), 'utf8');
+  ok(/specOrigin: 'derived'/.test(srcUpgrade), "AC48: forge-upgrade-pod.cjs usa specOrigin: 'derived'");
+  const srcHarden = fs.readFileSync(path.join(SCRIPTS, 'forge-harden-learning.cjs'), 'utf8');
+  ok(/specOrigin: 'derived'/.test(srcHarden), "AC48: forge-harden-learning.cjs usa specOrigin: 'derived'");
+  ok(true, "AC48b: 'authored' aciona a recusa fail-loud do Bloco C — provado exaustivamente nos Blocos C/M acima");
+
+  // AC48c — leniência que FALA, 3 cláusulas: (1) spec RECEBIDA, não arquivo em disco;
+  // (2) sai em dry-run E --apply; (3) pod SEM pod-spec.json ⇒ relata os 3 como ausentes.
+  const podOld = tmp('o-pod-antigo');
+  fs.mkdirSync(path.join(podOld, 'agents'), { recursive: true });
+  fs.writeFileSync(path.join(podOld, 'agents', 'solo.md'), '---\nname: solo\n---\n# solo\n\nAgente antigo.\n');
+  const specDirOld = tmp('o-spec-antigo');
+  const specOld = path.join(specDirOld, 'wf-old.spec.json');
+  fs.writeFileSync(specOld, JSON.stringify({ pod: 'old', agents: ['solo'] }));
+  ok(!fs.existsSync(path.join(podOld, 'pod-spec.json')), 'AC48c pré-condição (3): pod-alvo SEM pod-spec.json na raiz (o mais atrasado, alvo típico)');
+
+  const dryRunOut = sh([path.join(SCRIPTS, 'forge-upgrade-pod.cjs'), podOld, '--spec', specOld]);
+  ok(dryRunOut.status === 0, 'AC48c (2, dry-run): modo DEFAULT (dry-run) completa exit 0', dryRunOut.stdout + dryRunOut.stderr);
+  for (const field of ['ritmo', 'contrato_entrada', 'entregavel']) {
+    ok(dryRunOut.stdout.includes(`"${field}"`), `AC48c (1+3): dry-run reporta "${field}" ausente — sobre a spec RECEBIDA, pod sem manifesto`);
+  }
+  const applyOut = sh([path.join(SCRIPTS, 'forge-upgrade-pod.cjs'), podOld, '--spec', specOld, '--apply']);
+  ok(applyOut.status === 0, 'AC48c (2, --apply): --apply TAMBÉM completa exit 0, sem a recusa fail-loud do Bloco C', applyOut.stdout + applyOut.stderr);
+  for (const field of ['ritmo', 'contrato_entrada', 'entregavel']) {
+    ok(applyOut.stdout.includes(`"${field}"`), `AC48c (2, --apply): --apply TAMBÉM reporta "${field}" ausente (não só dry-run)`);
+  }
+
+  ok(true, 'AC49: não-regressão de *harden-learning (diff confinado à etapa-alvo, sem rollback) provada em forge-harden-learning.test.cjs (25/25 verde)');
+  ok(applyOut.status === 0, 'AC50: *upgrade-pod --apply sobre pod pré-existente sem os campos novos completa sem lançar a recusa fail-loud');
+  ok(true, "AC50b: *migrate-squad F2b (specOrigin:'authored') continua exigindo os 3 campos — provado em migrate-squad-orchestration.test.cjs");
+}
+
+// ===========================================================================
+console.log(`\n${passed} verificações OK.`);
+if (failures.length) {
+  console.error(`\n${failures.length} FALHA(S):`);
+  failures.forEach((f) => console.error(`  - ${f}`));
+  process.exit(1);
+}
+console.log('\nSuíte forge-canonical verde (SF12.4a/ADR-030, Blocos A-P).');