@daniellins/power-claude 0.16.3

package/scripts/smoke-pod-workflow.cjs

@@ -0,0 +1,755 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * smoke-pod-workflow.cjs — SMOKE DINÂMICO de seguibilidade de workflow (Story SF1.3).
+ *
+ * Prova que um `wf-*.yaml` "realmente trava o caminho errado" — não só que "está
+ * presente e bem-formado" (isso é o validador estático da SF1.1). Fronteira do
+ * ADR-002: o estático prova FORMA; este smoke prova FUNCIONAMENTO, DIRIGINDO o
+ * runner real `pc-run-pod` (SF1.2) sobre uma tarefa-canário e medindo 4/4:
+ *
+ *   Prova 1  Ativação        — cada agente do workflow é despachado e recebe um brief
+ *                              que aponta para um template EXISTENTE (não pede arquivo
+ *                              inexistente); o run percorre todos os passos.
+ *   Prova 2  Caminho feliz   — DAG completo com artefatos conformes → todos os passos
+ *                              `done`, artefato final conforme ao template.
+ *   Prova 3a Bloqueio template— injeta artefato que viola a FORMA (seção ausente) na
+ *                              etapa-alvo; o runner NÃO avança, `state.json` para no
+ *                              passo, a etapa seguinte nunca roda.
+ *   Prova 3b Bloqueio veto   — injeta artefato conforme à forma mas que viola uma
+ *                              `veto.assertions`; MESMA garantia, caminho de código
+ *                              DISTINTO do 3a (evalVeto vs checkTemplateConformance).
+ *
+ * 4/4 é ATÔMICO (AC6): qualquer saída errada passando (ex.: um 3a/3b "verde" quando
+ * deveria travar) faz o smoke FALHAR por inteiro (exit != 0), nomeando a prova.
+ *
+ * "Execução real" = runner real (não mock). O papel do SUBAGENTE é plantado
+ * deterministicamente em disco pelo harness (mesma técnica da suíte da SF1.2) —
+ * logo o smoke do canário custa milissegundos, não tokens (ver Dev Notes da story:
+ * roda a cada `npm test`; pods reais SF1.4/SF1.5 rodam no gate G6, ADR-002 dívida).
+ *
+ * Reuso (AC7 / SF1.4-SF1.5): genérico para QUALQUER wf-*.yaml acompanhado de um
+ * cenário `.smoke.json` (sidecar) declarando artefatos conformes por etapa + a
+ * etapa-alvo + as duas injeções. A fábrica gera wf + cenário juntos e reusa este
+ * harness sem reescrever.
+ *
+ * SIDECAR — chave OPCIONAL `aux_files` (Story SF11.11 / ADR-025 `DF-SF11.11-6`):
+ *   "aux_files": { "<step>": { "<caminho relativo ao runDir>": "<conteúdo>" } }
+ * Arquivos plantados no runDir no despacho da etapa, ALÉM do artefato. Existe para que um
+ * `command_check` que verifica o PRODUTO da etapa em disco (e não o texto do artefato) seja
+ * EXERCITADO pelo smoke em vez de ser contornado por ele. Cenário sem a chave = comportamento
+ * byte-idêntico ao anterior.
+ *
+ * Uso:
+ *   node scripts/smoke-pod-workflow.cjs <wf.yaml> [--scenario <json>] [--pod-root <dir>]
+ *   node scripts/smoke-pod-workflow.cjs <wf.yaml> --inject-template-violation   (só 3a)
+ *   node scripts/smoke-pod-workflow.cjs <wf.yaml> --inject-veto-violation       (só 3b)
+ *   (sem flag de injeção: roda as 4 provas, critério atômico 4/4)
+ *
+ * Node >= 18, sem dependências externas. Exit 0 = 4/4 (ou a prova pedida) PASS.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const R = require('./pc-run-pod.cjs');
+const { parseYaml, podRootFor } = require('./validate-pod-workflow.cjs');
+
+// ---------------------------------------------------------------------------
+// Utilidades do harness.
+// ---------------------------------------------------------------------------
+
+/** Planta o artefato de uma etapa despachada (papel do subagente). */
+function plant(ctx, stepId, content) {
+  const rel = ctx.state.steps[stepId].artifact;
+  if (!rel) throw new Error(`etapa "${stepId}" sem artifact atribuído (não foi despachada?)`);
+  const abs = path.resolve(ctx.runDir, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, 'utf8');
+}
+
+/**
+ * Planta ARQUIVOS AUXILIARES da etapa despachada — o que o papel do subagente produziria em
+ * disco ALÉM do artefato (Story SF11.11 / ADR-025 `DF-SF11.11-6`).
+ *
+ * POR QUE ISTO EXISTE: `plant()` escreve SÓ `runDir/artifacts/<step>.md`. Enquanto todo veto
+ * olhava para dentro do artefato, isso bastava. Um `command_check` que verifica o PRODUTO da
+ * etapa em disco (ex.: renderizar os HTMLs que a etapa gerou) achava zero arquivo e derrubava a
+ * prova 2 — e as duas saídas fáceis foram RECUSADAS com motivo no ADR: fazer o script passar
+ * quando não há insumo é a degradação silenciosa da SF11.4b; desligar o veto no teste é o escape
+ * hatch que o `DF-SF11.11-4` proíbe. A saída certa é o smoke aprender a plantar o produto, e
+ * assim EXERCITAR o veto em vez de ficar cego a ele.
+ *
+ * RETROCOMPATÍVEL POR CONSTRUÇÃO: cenário sem `aux_files` (ou sem a chave da etapa) é no-op —
+ * o comportamento é byte-idêntico ao de antes desta função. Mesma regra do `skip_modes`.
+ * Contenção: todo caminho é resolvido sob o `runDir` e recusado fora dele (fail-loud).
+ * Retorna quantos arquivos plantou (0 = cenário não declara nada para esta etapa).
+ */
+function plantAux(ctx, stepId, auxFiles) {
+  if (!auxFiles || typeof auxFiles !== 'object') return 0;
+  const forStep = auxFiles[stepId];
+  if (forStep == null) return 0;
+  if (typeof forStep !== 'object' || Array.isArray(forStep)) {
+    throw new Error(`aux_files["${stepId}"] deve ser um mapa { "caminho/relativo": "conteudo" }`);
+  }
+  const root = path.resolve(ctx.runDir);
+  let n = 0;
+  for (const [rel, content] of Object.entries(forStep)) {
+    const abs = path.resolve(root, rel);
+    if (abs !== root && !abs.startsWith(root + path.sep)) {
+      throw new Error(`aux_files["${stepId}"]["${rel}"] resolve FORA do runDir (${abs}) — recusado`);
+    }
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, String(content), 'utf8');
+    n++;
+  }
+  return n;
+}
+
+/** Ativação: o brief da etapa aponta para um template que EXISTE em disco. */
+function briefReferencesExistingTemplate(brief, ctx, stepId) {
+  const step = R.stepById(ctx.doc, stepId);
+  const tmplAbs = path.resolve(ctx.podRoot, step.template);
+  return fs.existsSync(tmplAbs) && typeof brief === 'string' && brief.includes(tmplAbs);
+}
+
+/**
+ * Dirige UM run do canário até terminar. Planta o artefato conforme do cenário em
+ * cada etapa despachada, EXCETO na etapa `inject.step`, onde planta `inject.content`.
+ * Auto-aprova checkpoints bloqueantes (yolo). Retorna o estado final + trilha de
+ * ativação + o state.json RELIDO DO DISCO (prova de persistência).
+ */
+function driveRun({ workflowPath, podRoot, pod, workflow, scenario, inject, memoryPodDir }) {
+  const runsRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-smoke-'));
+  const { ctx, result } = R.startRun({
+    workflowPath,
+    podRootOverride: podRoot,
+    pod,
+    workflow,
+    mode: 'yolo',
+    taskRef: 'smoke-canary',
+    runsRoot,
+    // SF3.2 (caveat SF2.4 → requisito): no --sweep, memoryPodDir aponta para um dir
+    // ISOLADO (temp) para NÃO appendar learnings sintéticos na memória de produção do
+    // pod. Sem esta flag (modo 4-provas legado), permanece undefined ⇒ default podRoot.
+    memoryPodDir,
+  });
+
+  const activations = [];
+  let res = result;
+  let guard = 0;
+  while (true) {
+    if (++guard > 1000) throw new Error('loop guard: o workflow não terminou (possível ciclo no harness)');
+    if (res.action === 'dispatch') {
+      const stepId = res.step;
+      activations.push({ step: stepId, ok: briefReferencesExistingTemplate(res.brief, ctx, stepId) });
+      const content = (inject && inject.step === stepId)
+        ? inject.content
+        : scenario.artifacts[stepId];
+      if (content == null) {
+        throw new Error(`cenário sem artefato conforme para a etapa "${stepId}" (chave artifacts.${stepId})`);
+      }
+      // SF11.11: auxiliares ANTES do artefato — o veto da etapa roda no `advance` logo abaixo e
+      // precisa achar o produto em disco. Cenário sem `aux_files` = no-op (retrocompatível).
+      plantAux(ctx, stepId, scenario.aux_files);
+      plant(ctx, stepId, content);
+      res = R.advance(ctx);
+      continue;
+    }
+    if (res.action === 'awaiting_approval') {
+      // checkpoint.blocking: auto-approve determinístico (escopo OUT: sem gate humano real)
+      const ap = R.approve(ctx);
+      res = ap.next;
+      continue;
+    }
+    break; // complete | blocked | halt | ...
+  }
+
+  const disk = R.readState(ctx.statePath);
+  return { ctx, order: ctx.order, final: res, activations, disk, runsRoot };
+}
+
+function cleanup(runsRoot) {
+  try {
+    fs.rmSync(runsRoot, { recursive: true, force: true });
+  } catch (_) { /* best-effort */ }
+}
+
+// ---------------------------------------------------------------------------
+// As 4 provas. Cada uma roda seu PRÓPRIO run isolado (não reaproveita state entre
+// provas — Testing da story: uma violação nunca é mascarada pelo resultado anterior).
+// ---------------------------------------------------------------------------
+
+const TEMPLATE_FAIL_RE = /seção obrigatória do template/;
+const VETO_FAIL_RE = /veto\.assertions/;
+
+/** Prova 1 — Ativação de todo agente. */
+function proveActivation(cfg) {
+  const run = driveRun({ ...cfg, inject: null });
+  cleanup(run.runsRoot);
+  const nSteps = run.order.length;
+  const allActivated = run.activations.length === nSteps && run.activations.every((a) => a.ok);
+  const reachedEnd = run.final.action === 'complete';
+  const failed = run.activations.filter((a) => !a.ok).map((a) => a.step);
+  return {
+    pass: allActivated && reachedEnd,
+    detail: allActivated && reachedEnd
+      ? `${nSteps} agente(s) ativados, cada brief aponta template existente; run completou`
+      : `ativação falhou (${failed.join(', ') || 'run não completou: ' + run.final.action})`,
+  };
+}
+
+/** Prova 2 — Caminho feliz ponta a ponta; todos `done`, final conforme. */
+function proveHappyPath(cfg) {
+  const run = driveRun({ ...cfg, inject: null });
+  cleanup(run.runsRoot);
+  const complete = run.final.action === 'complete';
+  const allDone = Object.values(run.disk.steps).every((s) => s.status === 'done');
+  return {
+    pass: complete && allDone,
+    detail: complete && allDone
+      ? `DAG completo: ${run.order.map((id) => `${id}=done`).join(', ')}`
+      : `caminho feliz falhou (final=${run.final.action}; state=${run.order.map((id) => `${id}:${run.disk.steps[id].status}`).join(', ')})`,
+  };
+}
+
+/** Núcleo comum de 3a/3b: injeta na etapa-alvo e exige BLOQUEIO no passo. */
+function proveBlock(cfg, kind) {
+  const target = cfg.scenario.target_step;
+  const content = kind === 'template' ? cfg.scenario.template_violation : cfg.scenario.veto_violation;
+  if (content == null) throw new Error(`cenário sem "${kind === 'template' ? 'template_violation' : 'veto_violation'}"`);
+
+  const run = driveRun({ ...cfg, inject: { step: target, content } });
+  cleanup(run.runsRoot);
+
+  const { order, disk, final } = run;
+  const idx = order.indexOf(target);
+  const failures = Array.isArray(final.failures) ? final.failures : [];
+
+  const blocked = final.action === 'blocked' && final.reason === 'verification_failed';
+  const hasTemplateFail = failures.some((f) => TEMPLATE_FAIL_RE.test(f));
+  const hasVetoFail = failures.some((f) => VETO_FAIL_RE.test(f));
+
+  // Classe de falha DISTINTA por caminho de código:
+  //  3a → falha de forma presente, veto AUSENTE (isola checkTemplateConformance);
+  //  3b → falha de veto presente, forma AUSENTE (isola evalVeto).
+  const classOk = kind === 'template'
+    ? (hasTemplateFail && !hasVetoFail)
+    : (hasVetoFail && !hasTemplateFail);
+
+  // state.json parou EXATAMENTE no passo violado: anteriores done, alvo não-done,
+  // posteriores pending (a etapa seguinte nunca rodou).
+  const beforeDone = order.slice(0, idx).every((id) => disk.steps[id].status === 'done');
+  const targetNotDone = disk.steps[target].status !== 'done';
+  const afterPending = order.slice(idx + 1).every((id) => disk.steps[id].status === 'pending');
+  const stopped = beforeDone && targetNotDone && afterPending;
+
+  const pass = blocked && classOk && stopped;
+  return {
+    pass,
+    detail: pass
+      ? `bloqueou em "${target}" (${disk.steps[target].status}); classe=${kind}; posteriores=pending; falha=${kind === 'template' ? 'forma' : 'veto'}`
+      : `esperado BLOQUEIO ${kind} em "${target}" — blocked=${blocked} classe_isolada=${classOk} parou_no_passo=${stopped} | failures=[${failures.join(' | ')}] | state=${order.map((id) => `${id}:${disk.steps[id].status}`).join(', ')}`,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// SWEEP DE INJEÇÃO EXAUSTIVO (SF3.2 — Decisão D.G3).
+//
+// 3a por TODA etapa (1 seção obrigatória do template removida) + 3b por TODA
+// assertion, derivando a violação MAIS FORTE da semântica POR FORMA (nunca a mais
+// conveniente). A UNDERIVABILIDADE é uma REGRA GERAL de controle de fluxo, não uma
+// lista fechada: cada deriver TENTA construir "o artefato que viola SÓ esta
+// assertion"; se não consegue, devolve {underivable} e o sweep termina exit 1
+// fail-loud. É a underivabilidade que detecta estaticamente a assertion degenerada.
+// ---------------------------------------------------------------------------
+
+class SweepUnderivable extends Error {
+  constructor(reason) { super(reason); this.name = 'SweepUnderivable'; this.underivable = true; }
+}
+
+/** Substitui (ou insere) a linha `field: valor`, preservando prefixo `- `/`**`. */
+function replaceOrSetField(text, field, value) {
+  const esc = String(field).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`^(\\s*(?:[-*]\\s+)?(?:\\*\\*)?${esc}(?:\\*\\*)?\\s*[:=]\\s*).*$`, 'i');
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    if (re.test(lines[i])) { lines[i] = lines[i].replace(re, `$1${value}`); return lines.join('\n'); }
+  }
+  return `${text.replace(/\s*$/, '')}\n${field}: ${value}\n`;
+}
+
+/** Remove toda linha cujo conteúdo trimado seja EXATAMENTE `target`. */
+function removeExactLine(text, target) {
+  const want = String(target).trim();
+  return text.split(/\r?\n/).filter((l) => l.trim() !== want).join('\n');
+}
+
+/** Reconstrói a seção cujo heading CONTÉM `field` para ter EXATAMENTE k itens de lista. */
+function rebuildCountSection(text, field, k) {
+  const lines = text.split(/\r?\n/);
+  const items = Array.from({ length: k }, (_, i) => `- item ${i + 1}`);
+  const isHeading = (l) => /^#{1,6}\s+\S/.test(l.trim());
+  const out = [];
+  let i = 0;
+  let done = false;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!done && isHeading(line) && line.toLowerCase().includes(String(field).toLowerCase())) {
+      out.push(line);          // mantém o heading (forma preservada)
+      out.push(...items);      // k itens reais de lista
+      i++;
+      while (i < lines.length && !isHeading(lines[i])) i++; // descarta corpo antigo
+      done = true;
+      continue;
+    }
+    out.push(line);
+    i++;
+  }
+  if (!done) { out.push(`## ${field}`, ...items); } // heading ausente: cria com k itens
+  return out.join('\n');
+}
+
+/**
+ * Substitui o corpo do 1º bloco cercado ```<fence>``` sob a seção declarada por
+ * `newBody`, preservando TODO o resto do artefato (SF7.8 — espelho de escrita do
+ * `extractFencedBlock` do runner, mesma varredura: âncora na seção, não atravessa
+ * heading, exige fence de fechamento). Retorna o texto mutado ou null se o bloco
+ * não for encontrado/fechado.
+ */
+function replaceFencedBlock(text, section, fence, newBody) {
+  const lines = text.split(/\r?\n/);
+  const want = String(section).trim();
+  let i = 0;
+  if (want) {
+    i = lines.findIndex((l) => l.trim() === want);
+    if (i < 0) return null;
+    i += 1;
+  }
+  const open = new RegExp('^\\s*```' + (fence ? fence : '[A-Za-z0-9_-]*') + '\\s*$');
+  let start = -1;
+  for (; i < lines.length; i++) {
+    if (open.test(lines[i])) { start = i + 1; break; }
+    if (want && /^#{1,6}\s+\S/.test(lines[i].trim())) return null;
+  }
+  if (start < 0) return null;
+  for (let j = start; j < lines.length; j++) {
+    if (/^\s*```\s*$/.test(lines[j])) {
+      return [...lines.slice(0, start), ...String(newBody).split('\n'), ...lines.slice(j)].join('\n');
+    }
+  }
+  return null; // sem fechamento
+}
+
+/** Régua idêntica ao runner: chaves `required` de um json_schema_valid.schema. */
+function requiredKeysOf(schema, podRoot) {
+  if (Array.isArray(schema)) return schema;
+  if (schema && typeof schema === 'object' && Array.isArray(schema.required)) return schema.required;
+  if (typeof schema === 'string') {
+    const scPath = path.resolve(podRoot, schema);
+    if (fs.existsSync(scPath)) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(scPath, 'utf8'));
+        return Array.isArray(parsed) ? parsed : (parsed.required || []);
+      } catch { return []; }
+    }
+    return String(schema).split(',').map((s) => s.trim()).filter(Boolean);
+  }
+  return [];
+}
+
+// Conjunto de sondagem para achar UM valor que NÃO casa o pattern. Se NENHUM candidato
+// viola (pattern universal como `.*`/`[\s\S]*`), o campo é underivável — a regra geral,
+// não uma verificação hardcoded de "pattern === '.*'".
+const PROBE_VALUES = ['', 'x', '0', 'zzz', 'INVALID', '   ', '9', 'a-b_c.d', '{}', 'null', 'FALSE', '@@@', '—', 'valor livre 123'];
+function findNonMatchingValue(pattern) {
+  let re;
+  try { re = new RegExp(String(pattern)); } catch { return { value: 'regex-invalida', ok: true }; }
+  for (const v of PROBE_VALUES) if (!re.test(v)) return { value: v, ok: true };
+  for (let i = 0; i < 128; i++) {
+    const v = `Z${i.toString(36)}_${(i * 2654435761 >>> 0).toString(36)}`;
+    if (!re.test(v)) return { value: v, ok: true };
+  }
+  return { ok: false };
+}
+
+/**
+ * Deriva a violação MAIS FORTE de UMA assertion (regra exata do design §D.G3) a
+ * partir do artefato conforme da etapa. Retorna {artifact} OU lança SweepUnderivable.
+ */
+function deriveViolation(assertion, conforme, template, podRoot) {
+  switch (assertion.type) {
+    case 'count_gte': {
+      // n−1 itens REAIS de lista sob o heading (nunca omissão do heading). n:0 é
+      // degenerada — 0 itens já satisfaz 0>=0, nenhum artefato viola.
+      const n = Number(assertion.n);
+      if (!(n >= 1)) {
+        throw new SweepUnderivable(`count_gte n:${assertion.n} para "${assertion.field}" — 0 itens satisfaz ${n}>=${n}; nenhum artefato viola (assertion degenerada)`);
+      }
+      return { artifact: rebuildCountSection(conforme, assertion.field, n - 1) };
+    }
+    case 'field_matches': {
+      // Campo PRESENTE com valor fora do pattern (nunca campo omitido — omissão
+      // exercita val===null, não o pattern). Pattern universal ⇒ underivável.
+      const nm = findNonMatchingValue(assertion.pattern);
+      if (!nm.ok) {
+        throw new SweepUnderivable(`field_matches "${assertion.field}" /${assertion.pattern}/ — pattern universal: nenhum valor presente o viola (assertion sempre-true)`);
+      }
+      return { artifact: replaceOrSetField(conforme, assertion.field, nm.value) };
+    }
+    case 'section_exists': {
+      // Seção omitida — SE ortogonal. Se a seção já é forçada pelo template (heading
+      // ##+), violá-la é violar a forma ⇒ não-ortogonal ⇒ underivável.
+      const want = String(assertion.section).trim();
+      const tmplHeadings = new Set(
+        template.split(/\r?\n/).map((l) => l.trim()).filter((l) => /^#{2,6}\s+\S/.test(l)),
+      );
+      if (tmplHeadings.has(want)) {
+        throw new SweepUnderivable(`section_exists "${want}" já é forçada pelo template da etapa — não-ortogonal (ADR-005); nenhum artefato viola só o veto sem violar a forma`);
+      }
+      return { artifact: removeExactLine(conforme, want) };
+    }
+    case 'file_referenced_exists': {
+      const missing = `__inexistente__/${assertion.field}-${Date.now()}.missing`;
+      return { artifact: replaceOrSetField(conforme, assertion.field, missing) };
+    }
+    case 'json_schema_valid': {
+      // JSON BEM-FORMADO que viola um `required` (nunca só parse-error). Schema sem
+      // `required` ⇒ só parse-error exercitável ⇒ underivável.
+      const required = requiredKeysOf(assertion.schema, podRoot);
+      if (!required.length) {
+        throw new SweepUnderivable(`json_schema_valid sem chaves 'required' — só parse-error é exercitável; o schema nunca é provado discriminante (assertion degenerada)`);
+      }
+      // SF7.8 (ADR-011 Decisão 1): com `extract:{section,fence}`, a violação é derivada
+      // SOBRE O BLOCO fenced (mesma régua do evalVeto do runner) — extrai, remove a 1ª
+      // chave `required`, e REINSERE o JSON mutado na mesma posição; o resto do artefato
+      // (headings do template, campo `confianca`) permanece intacto, isolando a classe
+      // veto. Sem `extract`, caminho legado bit-a-bit idêntico (artefato inteiro = JSON).
+      if (assertion.extract && typeof assertion.extract === 'object') {
+        const section = assertion.extract.section;
+        const fence = assertion.extract.fence || 'json';
+        const block = R.extractFencedBlock(conforme, section, fence);
+        if (block === null) {
+          throw new SweepUnderivable(`json_schema_valid+extract: bloco \`\`\`${fence}\`\`\` não encontrado na seção "${section}" do artefato conforme — o cenário não exercita a assertion (sidecar incompleto)`);
+        }
+        let obj;
+        try { obj = JSON.parse(block); } catch (e) {
+          throw new SweepUnderivable(`json_schema_valid+extract: bloco extraído do conforme não é JSON parseável (${e.message}) — impossível derivar violação de required bem-formada`);
+        }
+        const drop = required[0];
+        const violated = { ...obj };
+        delete violated[drop];
+        const mutated = replaceFencedBlock(conforme, section, fence, JSON.stringify(violated, null, 2));
+        if (mutated === null) {
+          throw new SweepUnderivable(`json_schema_valid+extract: falha ao reinserir o bloco mutado na seção "${section}" (bloco sem fechamento?)`);
+        }
+        return { artifact: mutated };
+      }
+      let obj;
+      try { obj = JSON.parse(conforme); } catch (e) {
+        throw new SweepUnderivable(`json_schema_valid: artefato conforme da etapa não é JSON parseável (${e.message}) — impossível derivar violação de required bem-formada`);
+      }
+      const drop = required[0];
+      const violated = { ...obj };
+      delete violated[drop];
+      return { artifact: JSON.stringify(violated, null, 2) };
+    }
+    case 'command_check':
+      // SF7.2/ADR-011 Decisão 4: command_check não tem derivação TEXTUAL (validade definida
+      // por processo externo). A violação vem de uma fixture DECLARADA no sidecar
+      // (scenario.violations[step]) — tratada em runSweep antes desta função. Chegar aqui =
+      // sem fixture ⇒ underivável fail-loud (nunca pulado).
+      throw new SweepUnderivable(`command_check exige fixture de violação declarada no sidecar (scenario.violations[step]) — não há derivação textual; sweep não pode provar bloqueio sem ela`);
+    default:
+      throw new SweepUnderivable(`tipo de assertion desconhecido: ${assertion.type} — sem deriver definido (Constitution Art. IV: PARA e escala, não inventa 6ª regra)`);
+  }
+}
+
+/**
+ * Deriva o artefato 3a de uma etapa: o conforme com UMA seção obrigatória do template
+ * removida, escolhida para NÃO colidir com nenhum veto da etapa (isola a classe FORMA).
+ */
+function deriveTemplateViolation(conforme, template, step) {
+  const sections = template.split(/\r?\n/).map((l) => l.trim()).filter((l) => /^#{2,6}\s+\S/.test(l));
+  if (!sections.length) return null; // template sem seções ## → 3a não aplicável a esta etapa
+  const assertions = (step.veto && Array.isArray(step.veto.assertions)) ? step.veto.assertions : [];
+  const loadBearing = new Set();
+  for (const a of assertions) {
+    if (a.type === 'section_exists') loadBearing.add(String(a.section).trim());
+    if (a.type === 'count_gte') {
+      for (const h of sections) if (h.toLowerCase().includes(String(a.field).toLowerCase())) loadBearing.add(h);
+    }
+    // SF7.8: a seção-âncora de um json_schema_valid+extract é load-bearing — removê-la
+    // no 3a também quebraria o veto (bloco não encontrado), impedindo o isolamento de classe.
+    if (a.type === 'json_schema_valid' && a.extract && a.extract.section) {
+      loadBearing.add(String(a.extract.section).trim());
+    }
+  }
+  const inert = sections.find((h) => !loadBearing.has(h));
+  const chosen = inert || sections[0]; // sem inerte: remove a 1ª (bloqueia, sem isolar)
+  return { artifact: removeExactLine(conforme, chosen), section: chosen, isolated: !!inert };
+}
+
+/**
+ * Executa o sweep exaustivo sobre um workflow. Reusável por close-line/F3 (que
+ * RE-EXECUTAM, nunca releem o report). Retorna { ok, report, underivable }.
+ *  - underivable ≠ null  ⇒ ok=false, exit 1 (assertion degenerada — conserte a spec)
+ *  - qualquer proof.blocked=false ⇒ ok=false, exit 1
+ */
+function runSweep({ workflowPath, podRoot, scenario, specPath, blockChecker }) {
+  // blockChecker é uma costura de teste (default = injectAndCheckBlock, o runner real).
+  // Existe SÓ para exercitar a agregação fail-loud "blocked:false ⇒ exit 1" de forma
+  // determinística — a ENFORCEMENT real é provada pelo sweep verde das 5 formas + as
+  // suítes SF1.x do runner. Nunca é passada em produção.
+  const check = blockChecker || injectAndCheckBlock;
+  const doc = parseYaml(fs.readFileSync(workflowPath, 'utf8'));
+  const pod = path.basename(podRoot);
+  const workflow = path.basename(workflowPath).replace(/\.ya?ml$/, '');
+  const specHash = specPath && fs.existsSync(specPath)
+    ? R_sha256File(specPath)
+    : R_sha256File(workflowPath); // fallback documentado: auto-binding ao wf quando não há spec
+  // memoryPodDir ISOLADO: nenhum learning sintético entra na memória de produção.
+  const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-sweep-mem-'));
+
+  const cfgBase = { workflowPath, podRoot, pod, workflow, scenario, memoryPodDir };
+
+  // FASE 1 — DERIVAÇÃO (pura, estática, SEM runner). A underivabilidade é detectada
+  // AQUI, antes de qualquer run: é o detector estático da assertion degenerada (D.G3).
+  // Um wf com assertion underivável (ex.: section_exists não-ortogonal) nem chega a ser
+  // carregado pelo runner — a derivação já falha fail-loud.
+  const injections = [];
+  try {
+    for (const step of doc.steps) {
+      const stepId = step.id;
+      const conforme = scenario.artifacts[stepId];
+      if (conforme == null) throw new Error(`cenário sem artefato conforme para a etapa "${stepId}"`);
+      const tmplPath = path.resolve(podRoot, step.template);
+      const template = fs.existsSync(tmplPath) ? fs.readFileSync(tmplPath, 'utf8') : '';
+
+      // 3a — remoção de seção obrigatória (por etapa). Isola a CLASSE template quando
+      // a seção removida é inerte ao veto (senão exige só bloqueio — sobreposição legítima).
+      const tv = deriveTemplateViolation(conforme, template, step);
+      if (tv) injections.push({ step: stepId, assertion: `__template__(${tv.section})`, artifact: tv.artifact, expectClass: tv.isolated ? 'template' : null });
+
+      // 3b — por assertion, derivação por forma; underivável ⇒ SweepUnderivable.
+      // Isola a CLASSE veto: a violação derivada preserva a forma; só o veto falha.
+      const assertions = (step.veto && Array.isArray(step.veto.assertions)) ? step.veto.assertions : [];
+      assertions.forEach((a, i) => {
+        if (a.type === 'command_check') {
+          // SF7.2/ADR-011 Decisão 4: violação vem de fixture DECLARADA no sidecar; ausente ⇒
+          // UNDERIVÁVEL fail-loud (nunca pulado em silêncio).
+          const viol = scenario.violations && scenario.violations[stepId];
+          if (viol == null) {
+            throw new SweepUnderivable(`etapa "${stepId}" tem command_check[${i}] sem fixture de violação (scenario.violations["${stepId}"]) — sweep não pode provar bloqueio; declare o par passa/viola no sidecar`);
+          }
+          injections.push({ step: stepId, assertion: `${i}:command_check`, artifact: viol, expectClass: 'veto' });
+          return;
+        }
+        const d = deriveViolation(a, conforme, template, podRoot); // pode lançar SweepUnderivable
+        injections.push({ step: stepId, assertion: `${i}:${a.type}`, artifact: d.artifact, expectClass: 'veto' });
+      });
+    }
+  } catch (e) {
+    cleanup(memoryPodDir);
+    if (e instanceof SweepUnderivable) {
+      return { ok: false, underivable: { reason: e.message }, report: { workflow, pod, spec_hash: specHash, proofs: [] } };
+    }
+    throw e;
+  }
+
+  // FASE 2 — DRIVE: injeta cada violação derivada e mede o bloqueio no runner real.
+  const proofs = [];
+  try {
+    for (const inj of injections) {
+      const blocked = check(cfgBase, inj.step, inj.artifact, inj.expectClass);
+      proofs.push({ step: inj.step, assertion: inj.assertion, blocked });
+    }
+  } finally {
+    cleanup(memoryPodDir);
+  }
+
+  const report = { workflow, pod, spec_hash: specHash, proofs };
+  const leaked = proofs.filter((p) => !p.blocked);
+  return { ok: leaked.length === 0, underivable: null, report, leaked };
+}
+
+/**
+ * Injeta o artefato derivado na etapa-alvo e devolve se o runner BLOQUEOU no passo,
+ * COM ISOLAMENTO DE CLASSE (mesmo padrão sem-OR do smoke SF1.3 `proveBlock`): a
+ * violação 3a tem que bloquear POR template (forma presente, veto AUSENTE) e a 3b POR
+ * veto (veto presente, forma AUSENTE). `expectClass=null` ⇒ só exige bloqueio (3a
+ * não-isolável: forma e veto se sobrepõem legitimamente — ex.: `count_gte` cujo campo
+ * É o heading do template; removê-lo quebra as duas classes). Sem o isolamento, um
+ * deriver que regredisse emitindo a CLASSE ERRADA passaria green-falso (finding QA #1).
+ */
+function injectAndCheckBlock(cfg, stepId, content, expectClass) {
+  const run = driveRun({ ...cfg, inject: { step: stepId, content } });
+  cleanup(run.runsRoot);
+  const { order, disk, final } = run;
+  const idx = order.indexOf(stepId);
+  const blockedFinal = final.action === 'blocked' && final.reason === 'verification_failed';
+  const targetNotDone = disk.steps[stepId].status !== 'done';
+  const afterPending = order.slice(idx + 1).every((id) => disk.steps[id].status === 'pending');
+  const failures = Array.isArray(final.failures) ? final.failures : [];
+  const hasTemplateFail = failures.some((f) => TEMPLATE_FAIL_RE.test(f));
+  const hasVetoFail = failures.some((f) => VETO_FAIL_RE.test(f));
+  let classOk = true;
+  if (expectClass === 'template') classOk = hasTemplateFail && !hasVetoFail;
+  else if (expectClass === 'veto') classOk = hasVetoFail && !hasTemplateFail;
+  return blockedFinal && targetNotDone && afterPending && classOk;
+}
+
+const R_sha256File = (p) => require('node:crypto').createHash('sha256').update(fs.readFileSync(p)).digest('hex');
+
+// ---------------------------------------------------------------------------
+// CLI.
+// ---------------------------------------------------------------------------
+
+function argVal(args, flag) {
+  const i = args.indexOf(flag);
+  return i >= 0 ? args[i + 1] : null;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const workflowPath = args[0];
+  if (!workflowPath || workflowPath.startsWith('--')) {
+    console.error('Uso: node scripts/smoke-pod-workflow.cjs <wf.yaml> [--scenario <json>] [--pod-root <dir>] [--inject-template-violation|--inject-veto-violation]');
+    process.exit(2);
+  }
+  if (!fs.existsSync(workflowPath)) {
+    console.error(`[erro] workflow não encontrado: ${workflowPath}`);
+    process.exit(2);
+  }
+
+  const podRootOverride = argVal(args, '--pod-root');
+  const podRoot = podRootFor(workflowPath, podRootOverride);
+  const scenarioPath = argVal(args, '--scenario') ||
+    workflowPath.replace(/\.ya?ml$/, '.smoke.json');
+  if (!fs.existsSync(scenarioPath)) {
+    console.error(`[erro] cenário de smoke não encontrado: ${scenarioPath} (esperado sidecar .smoke.json ao lado do wf, ou --scenario)`);
+    process.exit(2);
+  }
+
+  let scenario;
+  try {
+    scenario = JSON.parse(fs.readFileSync(scenarioPath, 'utf8'));
+  } catch (e) {
+    console.error(`[erro] cenário .smoke.json inválido (${scenarioPath}): ${e.message}`);
+    process.exit(2);
+  }
+
+  const doc = parseYaml(fs.readFileSync(workflowPath, 'utf8'));
+  const pod = path.basename(podRoot);
+  const workflow = path.basename(workflowPath).replace(/\.ya?ml$/, '');
+  const cfg = { workflowPath, podRoot, pod, workflow, scenario };
+
+  // ---- Modo --sweep (SF3.2): prova de bloqueio EXAUSTIVA (3a×etapas + 3b×assertions).
+  if (args.includes('--sweep')) {
+    const specPath = argVal(args, '--spec');
+    const reportPath = argVal(args, '--report');
+    console.log(`# smoke --sweep — ${path.relative(process.cwd(), workflowPath)} (pod=${pod}, workflow=${workflow})`);
+    let sweep;
+    try {
+      sweep = runSweep({ workflowPath, podRoot, scenario, specPath });
+    } catch (e) {
+      console.error(`[erro] sweep abortou: ${e.message}`);
+      process.exit(1);
+    }
+    if (reportPath) fs.writeFileSync(reportPath, JSON.stringify(sweep.report, null, 2));
+    for (const p of sweep.report.proofs) {
+      console.log(`[${p.blocked ? 'BLOQUEOU' : 'VAZOU  '}] ${p.step} · ${p.assertion}`);
+    }
+    if (sweep.underivable) {
+      console.error(`\nSWEEP FALHOU (underivabilidade) — assertion sem violação derivável = degenerada ou não-ortogonal — conserte a spec:\n  ${sweep.underivable.reason}`);
+      process.exit(1);
+    }
+    if (!sweep.ok) {
+      console.error(`\nSWEEP FALHOU — ${sweep.leaked.length} prova(s) VAZARAM (blocked:false): ${sweep.leaked.map((l) => `${l.step}/${l.assertion}`).join(', ')}`);
+      process.exit(1);
+    }
+    console.log(`\nSWEEP VERDE — ${sweep.report.proofs.length} prova(s), TODAS bloquearam (spec_hash=${sweep.report.spec_hash.slice(0, 12)}…).`);
+    process.exit(0);
+  }
+
+  const onlyTemplate = args.includes('--inject-template-violation');
+  const onlyVeto = args.includes('--inject-veto-violation');
+
+  // SF7.7 — ISOLAMENTO DE MEMÓRIA INCONDICIONAL: toda execução do smoke (não só --sweep)
+  // grava learnings sintéticos numa cópia mkdtemp descartável, NUNCA na memória real do pod.
+  // O runner escreve em `memoryPodDir || podRoot` (pc-run-pod.cjs); omitir o parâmetro (como
+  // este caminho fazia, escrito antes do padrão de isolamento do --sweep/SF3.2) contaminava
+  // `memory/learnings.jsonl`. Mesmo padrão de runSweep()/harness-g5-lite.cjs. Cleanup é via
+  // try/finally — process.exit NÃO roda finally, por isso o exit code é COMPUTADO e aplicado
+  // só DEPOIS do finally.
+  cfg.memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-smoke-mem-'));
+
+  console.log(`# smoke-pod-workflow — ${path.relative(process.cwd(), workflowPath)} (pod=${pod}, workflow=${workflow})`);
+  console.log(`# etapa-alvo de injeção: ${scenario.target_step}\n`);
+
+  let exitCode = 0;
+  let proofs = null;
+  try {
+    try {
+      if (onlyTemplate) {
+        proofs = [['Prova 3a (bloqueio template)', proveBlock(cfg, 'template')]];
+      } else if (onlyVeto) {
+        proofs = [['Prova 3b (bloqueio veto)', proveBlock(cfg, 'veto')]];
+      } else {
+        proofs = [
+          ['Prova 1 (ativação)', proveActivation(cfg)],
+          ['Prova 2 (caminho feliz)', proveHappyPath(cfg)],
+          ['Prova 3a (bloqueio template)', proveBlock(cfg, 'template')],
+          ['Prova 3b (bloqueio veto)', proveBlock(cfg, 'veto')],
+        ];
+      }
+    } catch (e) {
+      console.error(`[erro] harness abortou: ${e.message}`);
+      exitCode = 1;
+    }
+
+    if (proofs) {
+      let passed = 0;
+      for (const [label, r] of proofs) {
+        console.log(`[${r.pass ? 'OK   ' : 'FALHA'}] ${label} — ${r.detail}`);
+        if (r.pass) passed++;
+      }
+      const total = proofs.length;
+      console.log(`\n${passed}/${total} provas passaram.`);
+      if (passed !== total) {
+        const failedNames = proofs.filter(([, r]) => !r.pass).map(([l]) => l);
+        console.error(`\nSMOKE FALHOU (não-seguível): ${failedNames.join('; ')}`);
+        exitCode = 1;
+      } else {
+        console.log(total === 4
+          ? 'Smoke verde 4/4 — workflow SEGUÍVEL (ativa, percorre, e trava as DUAS classes de caminho errado).'
+          : 'Prova solicitada verde.');
+      }
+    }
+  } finally {
+    cleanup(cfg.memoryPodDir); // higiene: remove o dir temporário em TODOS os pontos de saída
+  }
+  process.exit(exitCode);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  driveRun,
+  proveActivation,
+  proveHappyPath,
+  proveBlock,
+  plant,
+  plantAux,
+  briefReferencesExistingTemplate,
+  // SF3.2 — sweep exaustivo (reusável por migration-manifest close-line/verify e pelo harness G5-LITE).
+  runSweep,
+  deriveViolation,
+  deriveTemplateViolation,
+  findNonMatchingValue,
+  injectAndCheckBlock,
+  SweepUnderivable,
+};