@daniellins/power-claude 0.16.3

package/scripts/pod-export-release.cjs

@@ -0,0 +1,473 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-export-release.cjs — MECANISMO de release + selo de paridade do épico pod-export
+ * (F4, Story SF10.6). É o PRIMEIRO componente que ORQUESTRA os 4 juntos e sela o lock:
+ *
+ *   compile (F1, import) → executor (F2, import — lado EXPORT) → G5-determinístico (NOVO)
+ *   → pc-arena (ADR-009, import — reveal-gate reusado) → selo aditivo no export.lock.json
+ *
+ * Invariante-mãe de F4 (ADR-018 Adendo F4): o selo `release: sealed` só existe quando DOIS
+ * vereditos independentes são VERDE — o G5-determinístico (máquina) E a arena cega (humano) —
+ * sobre o MESMO `pod_sha` em inputs pinados. Qualquer ausência/incompletude/divergência =
+ * VERMELHO fail-loud que NÃO escreve o selo e sai não-zero.
+ *
+ * CLI (seção "Arquitetura" de sf10.6.story.md):
+ *   node scripts/pod-export-release.cjs release <pod> --pod-dir <dir> \
+ *        [--if-changed] --baseline-dir <dir> --arena-dir <expDir> \
+ *        [--payload <file>] [--no-endpoint-check] [--sealed-by <id>] [--lock <path>]
+ *
+ * Gatilhos (DF4-4):
+ *   MANUAL  = `release <pod>` (sem --if-changed): dono refresca; roda (a)-(d), sela se VERDE.
+ *   AUTO    = `release <pod> --if-changed`: recompila fresco, compara pod_sha vs o do lock
+ *             comitado. IGUAL → no-op (exit 0, nada resela). DIFERENTE → DETECTA-e-BLOQUEIA
+ *             (exit != 0), sinaliza "reselagem de paridade humana necessária" — NUNCA sela
+ *             unattended (a arena exige julgamento humano cego — DF4-4 supersede a Decisão 5).
+ *
+ * FRONTEIRAS (Escopo OUT de SF10.6): `pod-export-compile.cjs`, `pod-export-executor.cjs`,
+ * `arena.cjs` e `pc-run-pod.cjs` são consumidos SÓ por import/invocação — nenhum tem lógica
+ * interna tocada. NÃO gera o baseline (ação humana/operacional de SF10.7), NÃO roda a sessão
+ * de arena (só LÊ o experimento já revelado), NÃO julga conteúdo. Sem git push/PR (pc-devops).
+ *
+ * Node >= 18, zero dependências externas. Rede/execução INJETÁVEL (deps) → CI hermética.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const compileMod = require('./pod-export-compile.cjs');
+const executorMod = require('./pod-export-executor.cjs');
+const arena = require('./arena.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+// Contrato F0/DF4-2/DF4-3 (constantes, nunca hardcode espalhado).
+const ARTIFACT_COUNT = 7;                 // inventário de 7 peças (DF4-2 crit 1).
+const ARM_EXPORT = 'EXPORT';              // arms fixados por contrato (DF4-3), exatamente os do F0.
+const ARM_BASELINE = 'BASELINE';
+const RELEASE_STATUS_SEALED = 'sealed';
+
+class ReleaseError extends Error {}
+function fail(msg) { throw new ReleaseError(msg); }
+
+function sha256(buf) { return crypto.createHash('sha256').update(buf).digest('hex'); }
+function sha256File(p) { return sha256(fs.readFileSync(p)); }
+
+/** Serialização canônica (chaves ordenadas recursivamente) → comparação estável de modelo pinado. */
+function stableStringify(v) {
+  if (Array.isArray(v)) return `[${v.map(stableStringify).join(',')}]`;
+  if (v && typeof v === 'object') {
+    return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(v[k])}`).join(',')}}`;
+  }
+  return JSON.stringify(v);
+}
+function sameModel(a, b) { return stableStringify(a) === stableStringify(b); }
+
+// ---------------------------------------------------------------------------
+// (b) G5-determinístico — comparador NOVO (DF4-2). NÃO reusa harness-g5-lite (semântica
+// diferente: aquele DIRIGE runs próprios; este COMPARA dois conjuntos JÁ produzidos).
+// Compara o manifesto EXPORT (saída do executor) × baseline.manifest.json sobre campos de
+// máquina. Qualquer divergência = VERMELHO com o CAMPO que divergiu na mensagem.
+// ---------------------------------------------------------------------------
+
+/**
+ * @param exportManifest { pod_sha, modelo_pinado, artifacts:[], complete }  (lado EXPORT — do executor)
+ * @param baseline       { pod_sha, modelo_pinado, artifacts:[7], vetos:{}, complete } (baseline.manifest.json)
+ * @param sealedPodSha   pod_sha da recompilação fresca (o que se vai selar)
+ * @param lockModel      lock.modelo_pinado da recompilação fresca (3ª ponta do binding de modelo)
+ * @returns { verdict:'green'|'red', divergence?:string, checks:{...} }
+ */
+function compareG5(exportManifest, baseline, sealedPodSha, lockModel) {
+  const red = (field, msg) => ({ verdict: 'red', divergence: field, message: msg });
+
+  // (4) binding de versão (DF4-5): baseline.pod_sha == sealed_pod_sha == export.pod_sha.
+  if (baseline.pod_sha !== sealedPodSha) {
+    return red('pod_sha', `binding de versão: baseline.pod_sha (${short(baseline.pod_sha)}) != sealed_pod_sha (${short(sealedPodSha)}) — o baseline foi gerado de OUTRA versão do pod (DF4-2 crit 4). VERMELHO.`);
+  }
+  if (exportManifest.pod_sha !== sealedPodSha) {
+    return red('pod_sha', `binding de versão: export.pod_sha (${short(exportManifest.pod_sha)}) != sealed_pod_sha (${short(sealedPodSha)}) — o run EXPORT não é da versão que se sela. VERMELHO.`);
+  }
+
+  // (1) inventário: conjunto de nomes == e contagem 7 em ambos.
+  const expSet = new Set(exportManifest.artifacts || []);
+  const baseSet = new Set(baseline.artifacts || []);
+  if (baseSet.size !== ARTIFACT_COUNT) {
+    return red('inventario', `inventário: BASELINE tem ${baseSet.size} peça(s), esperado ${ARTIFACT_COUNT} (DF4-2 crit 1). VERMELHO.`);
+  }
+  if (expSet.size !== ARTIFACT_COUNT) {
+    return red('inventario', `inventário: EXPORT tem ${expSet.size} peça(s), esperado ${ARTIFACT_COUNT}. VERMELHO.`);
+  }
+  const onlyExport = [...expSet].filter((x) => !baseSet.has(x));
+  const onlyBase = [...baseSet].filter((x) => !expSet.has(x));
+  if (onlyExport.length || onlyBase.length) {
+    return red('inventario', `inventário: conjuntos de peças divergem — só no EXPORT: [${onlyExport.join(', ')}]; só no BASELINE: [${onlyBase.join(', ')}]. VERMELHO.`);
+  }
+
+  // (2) vetos: 3 fases VERDES em AMBOS os lados. EXPORT: a run atingiu `complete`.
+  //     BASELINE: `vetos` todos green + complete:true no manifesto.
+  if (exportManifest.complete !== true) {
+    return red('vetos', 'vetos: a run EXPORT NÃO atingiu `complete` no motor (alguma fase bloqueou/veto vermelho). VERMELHO.');
+  }
+  if (baseline.complete !== true) {
+    return red('vetos', 'vetos: BASELINE não está `complete:true` no manifesto. VERMELHO.');
+  }
+  const baseVetos = baseline.vetos || {};
+  const notGreen = Object.entries(baseVetos).filter(([, v]) => v !== 'green').map(([k]) => k);
+  if (Object.keys(baseVetos).length === 0) {
+    return red('vetos', 'vetos: BASELINE sem campo `vetos` — impossível confirmar 3 fases verdes. VERMELHO.');
+  }
+  if (notGreen.length) {
+    return red('vetos', `vetos: fase(s) não-verde(s) no BASELINE: [${notGreen.join(', ')}]. VERMELHO.`);
+  }
+
+  // (3) modelo pinado: EXPORT == lock == BASELINE.
+  if (!sameModel(exportManifest.modelo_pinado, lockModel)) {
+    return red('modelo_pinado', 'modelo pinado: o modelo efetivamente usado na run EXPORT != lock.modelo_pinado. VERMELHO.');
+  }
+  if (!sameModel(baseline.modelo_pinado, lockModel)) {
+    return red('modelo_pinado', 'modelo pinado: baseline.modelo_pinado != lock.modelo_pinado. VERMELHO.');
+  }
+
+  return {
+    verdict: 'green',
+    checks: {
+      pod_sha: sealedPodSha,
+      inventario: [...expSet].sort(),
+      vetos: baseVetos,
+      modelo_pinado: lockModel,
+    },
+  };
+}
+function short(sha) { return sha ? String(sha).slice(0, 8) : '(vazio)'; }
+
+// ---------------------------------------------------------------------------
+// (c) Insumo pc-arena (DF4-3) — consumido por diretório do experimento + IMPORT de arena.cjs.
+// Reveal-gate REUSADO como anti-selo-no-escuro; veredito por verdictForAxis(BASELINE, EXPORT).
+// Ausência/incompleto/não-revelado/BASELINE-vence = VERMELHO. NUNCA default-verde.
+// ---------------------------------------------------------------------------
+
+function arenaVerdict(arenaDir) {
+  const red = (msg) => ({ verdict: 'red', message: msg });
+  if (!arenaDir) return red('arena: --arena-dir ausente — selo no escuro proibido (DF4-3). VERMELHO.');
+  let state;
+  try {
+    state = arena.loadState(arenaDir);
+  } catch (e) {
+    // Dir/arquivos ausentes ou state corrompido: bloqueia (nunca trata como passe).
+    return red(`arena: experimento ausente/ilegível em ${arenaDir} (${e.message}). VERMELHO.`);
+  }
+  // Reveal-gate reusado: exige revelado E todas as rodadas pontuadas.
+  const scored = arena.scoredRoundsCount(state);
+  if (scored !== state.rounds) {
+    return red(`arena: experimento INCOMPLETO (${scored}/${state.rounds} rodadas pontuadas). VERMELHO.`);
+  }
+  if (state.revealed !== true) {
+    return red('arena: experimento NÃO revelado (reveal-gate) — o release não muta o arena; sele só o já-revelado. VERMELHO.');
+  }
+  const arms = state.arms || [];
+  if (!arms.includes(ARM_EXPORT) || !arms.includes(ARM_BASELINE)) {
+    return red(`arena: arms devem ser exatamente {${ARM_EXPORT}, ${ARM_BASELINE}} (DF4-3); achei [${arms.join(', ')}]. VERMELHO.`);
+  }
+  const verdictCfg = (state.rubric && state.rubric.verdict) || {};
+  const minDiff = verdictCfg.minDiff;
+  const kOfN = verdictCfg.kOfN;
+  if (typeof minDiff !== 'number' || !Number.isInteger(kOfN)) {
+    return red('arena: rubric.verdict.{minDiff,kOfN} ausente/inválido no experimento. VERMELHO.');
+  }
+  let t;
+  try {
+    t = arena.tally(arenaDir);
+  } catch (e) {
+    return red(`arena: falha ao agregar (tally): ${e.message}. VERMELHO.`);
+  }
+  const perBaseline = t.perRoundByArm[ARM_BASELINE];
+  const perExport = t.perRoundByArm[ARM_EXPORT];
+  // verdictForAxis(A=BASELINE, B=EXPORT): winner 'A'=BASELINE vence → VERMELHO;
+  // 'B'=EXPORT vence → verde; 'tie'=paridade → verde (export em paridade-ou-melhor).
+  let v;
+  try {
+    v = arena.verdictForAxis(perBaseline, perExport, minDiff, kOfN);
+  } catch (e) {
+    return red(`arena: veredito indefinido: ${e.message}. VERMELHO.`);
+  }
+  const sealedMapSha = sha256File(arena.sealedPath(arenaDir));
+  const base = {
+    winner: v.winner, means: { [ARM_EXPORT]: v.meanB, [ARM_BASELINE]: v.meanA },
+    minDiff, kOfN, rounds: state.rounds, sealed_map_sha256: sealedMapSha,
+  };
+  if (v.winner === 'A') {
+    return { ...base, verdict: 'red', message: `arena: BASELINE SUPERA o EXPORT (>= ${minDiff} em >= ${kOfN} rodada(s)) — regressão de conteúdo. VERMELHO.` };
+  }
+  // 'B' (EXPORT vence) ou 'tie' (paridade) → não-vermelho.
+  return { ...base, verdict: 'green' };
+}
+
+// ---------------------------------------------------------------------------
+// (d) Selo (DF4-1) — ADITIVO: recompila fresco (já feito), serializa o lock canônico de F1 e
+// ACRESCENTA a chave de topo `release`. Voláteis (`at`/`sealed_by`) FORA de qualquer hash
+// (coerente com AC4/F1: pod_sha e bundle_hashes já vêm calculados no lock, nunca do arquivo).
+// ---------------------------------------------------------------------------
+
+function buildReleaseField({ trigger, sealedPodSha, frameworkVersion, sealedBy, at, g5, g5EvidenceRel, g5Sha, arenaDir, av }) {
+  return {
+    status: RELEASE_STATUS_SEALED,
+    at,                              // VOLÁTIL — metadado de auditoria (fora de qualquer hash).
+    trigger,                         // 'manual' (AUTO nunca sela — DF4-4).
+    sealed_pod_sha: sealedPodSha,    // DEVE == lock.pod_sha (asserido no selar).
+    framework_version: frameworkVersion,
+    sealed_by: sealedBy,             // VOLÁTIL.
+    evidence: {
+      g5: { verdict: g5.verdict, path: g5EvidenceRel, sha256: g5Sha },
+      arena: {
+        verdict: av.verdict,
+        arena_dir: arenaDir,
+        sealed_map_sha256: av.sealed_map_sha256,
+        means: av.means, minDiff: av.minDiff, kOfN: av.kOfN, rounds: av.rounds,
+      },
+    },
+  };
+}
+
+/** Escreve a evidência G5 e devolve { rel, abs, sha256 } (o selo referencia por path+sha256). */
+function writeG5Evidence(exportsPodDir, sealedPodSha, payload) {
+  const dir = path.join(exportsPodDir, 'release-evidence');
+  fs.mkdirSync(dir, { recursive: true });
+  const rel = path.join('release-evidence', `g5-${short(sealedPodSha)}.json`);
+  const abs = path.join(exportsPodDir, rel);
+  fs.writeFileSync(abs, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  return { rel, abs, sha256: sha256File(abs) };
+}
+
+/** Serializa o lock FRESCO + `release` acrescentado ao final (aditivo). Reusa serializeLock de F1. */
+function serializeSealedLock(freshLock, releaseField) {
+  const out = { ...freshLock, release: releaseField };
+  return compileMod.serializeLock(out);
+}
+
+// ---------------------------------------------------------------------------
+// (a) Lado EXPORT — produzido pelo executor de F2. Injetável (deps.runExport): em CI é um
+// stub hermético; em produção (SF10.7) drive-a o bundle real contra o payload pinado.
+// ---------------------------------------------------------------------------
+
+/**
+ * Default: drive REAL do bundle via executor de F2 (import — INTOCADO). Só é exercido com
+ * --payload + chaves reais (SF10.7 — execução real). Devolve o manifesto EXPORT.
+ * Em CI a suíte injeta `deps.runExport`, jamais este default (sem API real — SF10.6 hermético).
+ */
+async function defaultRunExport({ pod, podDir, freshLock, bundleFiles, payloadPath, runsRoot, deps = {}, log }) {
+  if (!payloadPath) {
+    fail('execução real do bundle EXPORT requer --payload <file> (cenário pinado) — o wiring do payload/mapa de 7 peças do pod real é SF10.7. Em CI, injete deps.runExport.');
+  }
+  // Bundle+lock frescos em dir efêmero (o executor lê o bundle e confere coerência de versão).
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `pex-rel-${pod}-`));
+  const bundleDir = path.join(tmp, 'bundle');
+  compileMod.writeBundle(bundleDir, bundleFiles);
+  const lockPath = path.join(tmp, 'export.lock.json');
+  fs.writeFileSync(lockPath, compileMod.serializeLock(freshLock), 'utf8');
+  const payload = JSON.parse(fs.readFileSync(path.resolve(payloadPath), 'utf8'));
+  payload.__dir = path.dirname(path.resolve(payloadPath));
+  const run = executorMod.setupRun({ bundleDir, lockOverride: lockPath, payload, deps, log });
+  const motor = require('./pc-run-pod.cjs');
+  const runId = `rel-${Date.now()}`;
+  const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const { ctx } = motor.startRun({ workflowPath: `${run.bundleRoot}/workflow.yaml`, podRootOverride: run.bundleRoot, pod: run.pod, workflow: run.workflow, runsRoot, runId, memoryPodDir });
+  const r = await executorMod.drive(ctx, run, {});
+  return extractExportManifest(ctx.runDir, freshLock, { complete: r.complete === true });
+}
+
+/**
+ * Extrai o manifesto EXPORT de um runDir completo: inventário (peças escritas em `artifacts/`),
+ * modelo pinado (do lock — o que o bundle usou) e pod_sha (do lock fresco). `complete` vem do drive.
+ * Genérico; o mapa exato das 7 peças do pod real é confirmado em SF10.7.
+ */
+function extractExportManifest(runDir, freshLock, { complete }) {
+  const artDir = path.join(runDir, 'artifacts');
+  const artifacts = fs.existsSync(artDir)
+    ? fs.readdirSync(artDir).filter((f) => fs.statSync(path.join(artDir, f)).isFile()).sort()
+    : [];
+  return {
+    pod_sha: freshLock.pod_sha,
+    modelo_pinado: freshLock.modelo_pinado,
+    artifacts,
+    complete: complete === true,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Orquestração — release(pod, opts). O MESMO code-path de (a)-(d) serve MANUAL e a reselagem
+// humana do AUTO; a ÚNICA diferença de --if-changed é a checagem de diff ANTES de entrar nele.
+// ---------------------------------------------------------------------------
+
+/**
+ * @returns {status:'noop'|'blocked'|'red'|'sealed', ...}. NÃO chama process.exit (o CLI decide).
+ */
+async function release(pod, opts = {}) {
+  const log = opts.log || ((m) => console.log(m));
+  const repoRoot = opts.repoRoot || REPO_ROOT;
+  const exportsPodDir = path.join(repoRoot, 'exports', pod);
+  const lockPath = opts.lockPath || path.join(exportsPodDir, 'export.lock.json');
+  if (!opts.podDir) fail('release: --pod-dir <dir> obrigatório (path do pod-fonte v0.3 a recompilar) — o compilador não resolve pod por nome (contrato F1).');
+
+  // --- Recompilação FRESCA (import de F1 — nunca reimplementa o compilador). DF4-1. ---
+  const { lock: freshLock, bundleFiles } = await compileMod.compile(opts.podDir, {
+    pinsPath: opts.pinsPath,
+    checkEndpoint: opts.checkEndpoint !== false,
+    fetchImpl: opts.fetchImpl,
+    apiKey: opts.apiKey,
+  });
+  const sealedPodSha = freshLock.pod_sha;
+  log(`[compile] pod "${pod}" recompilado fresco — pod_sha=${sealedPodSha}`);
+
+  // --- (e) Gatilho AUTO (--if-changed): DETECTA-e-BLOQUEIA. NUNCA sela unattended (DF4-4). ---
+  if (opts.ifChanged) {
+    if (!fs.existsSync(lockPath)) {
+      fail(`--if-changed: lock comitado ausente (${path.relative(repoRoot, lockPath)}) — nada com que comparar. Rode o release MANUAL para selar a 1ª vez.`);
+    }
+    const committed = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    if (committed.pod_sha === sealedPodSha) {
+      log(`[auto] SEM mudança — pod_sha idêntico ao do lock comitado (${short(sealedPodSha)}). No-op: nada resela.`);
+      return { status: 'noop', changed: false, pod_sha: sealedPodSha };
+    }
+    // Mudou: o insumo arena exige julgamento humano cego → AUTO não pode selar sozinho.
+    log(`[auto] MUDANÇA detectada — pod_sha fresco (${short(sealedPodSha)}) != lock comitado (${short(committed.pod_sha)}).`);
+    log('[auto] BLOQUEIO: reselagem de PARIDADE HUMANA necessária (baseline fresco + sessão pc-arena). Nada foi selado (DF4-4).');
+    return { status: 'blocked', changed: true, pod_sha: sealedPodSha, committed_pod_sha: committed.pod_sha,
+      message: 'pod alterado desde o último selo — rode o release MANUAL humano (baseline + arena) antes de embarcar.' };
+  }
+
+  // --- MANUAL / reselagem humana: caminho completo (a)-(d). ---
+  if (!opts.baselineDir) fail('release MANUAL: --baseline-dir <dir> obrigatório (o baseline vem de fora — SF10.7; o release nunca o gera).');
+  if (!opts.arenaDir) fail('release MANUAL: --arena-dir <expDir> obrigatório (experimento pc-arena já revelado) — selo no escuro proibido.');
+
+  const baseline = loadBaselineManifest(opts.baselineDir);
+
+  // (a) lado EXPORT (executor de F2, ou stub hermético injetado).
+  const runExport = (opts.deps && opts.deps.runExport) || defaultRunExport;
+  const exportManifest = await runExport({
+    pod, podDir: opts.podDir, freshLock, bundleFiles,
+    payloadPath: opts.payloadPath,
+    runsRoot: opts.runsRoot || path.join(repoRoot, '.power-claude', 'pod-export-runs'),
+    deps: (opts.deps && opts.deps.executor) || {}, log,
+  });
+
+  // (b) G5-determinístico.
+  const g5 = compareG5(exportManifest, baseline, sealedPodSha, freshLock.modelo_pinado);
+  log(`[g5] veredito ${g5.verdict.toUpperCase()}${g5.divergence ? ` (divergência: ${g5.divergence})` : ''}`);
+
+  // (c) veredito pc-arena.
+  const av = arenaVerdict(opts.arenaDir);
+  log(`[arena] veredito ${av.verdict.toUpperCase()}${av.winner ? ` (winner: ${av.winner})` : ''}`);
+
+  // (d) selo condicional — SÓ quando (b) E (c) NÃO-vermelhos. VERMELHO não escreve/altera o lock.
+  if (g5.verdict === 'red' || av.verdict === 'red') {
+    const why = [g5.verdict === 'red' ? `G5: ${g5.message}` : null, av.verdict === 'red' ? `ARENA: ${av.message}` : null].filter(Boolean).join('\n  ');
+    return { status: 'red', g5, arena: av, sealed: false, message: why };
+  }
+
+  // VERDE nos dois: grava evidência G5, monta o campo `release` e ACRESCENTA ao lock fresco.
+  const frameworkVersion = freshLock.framework_version;
+  const g5Ev = writeG5Evidence(exportsPodDir, sealedPodSha, {
+    pod, sealed_pod_sha: sealedPodSha,
+    export: { artifacts: exportManifest.artifacts, complete: exportManifest.complete, modelo_pinado: exportManifest.modelo_pinado },
+    baseline: { pod_sha: baseline.pod_sha, artifacts: baseline.artifacts, vetos: baseline.vetos, complete: baseline.complete, modelo_pinado: baseline.modelo_pinado },
+    verdict: g5.verdict, checks: g5.checks,
+  });
+  const at = opts.now || new Date().toISOString();
+  const sealedBy = opts.sealedBy || 'Daniel';
+  const releaseField = buildReleaseField({
+    trigger: 'manual', sealedPodSha, frameworkVersion, sealedBy, at,
+    g5, g5EvidenceRel: g5Ev.rel, g5Sha: g5Ev.sha256, arenaDir: opts.arenaDir, av,
+  });
+  fs.mkdirSync(exportsPodDir, { recursive: true });
+  fs.writeFileSync(lockPath, serializeSealedLock(freshLock, releaseField), 'utf8');
+  log(`[selo] SEALED — ${path.relative(repoRoot, lockPath)} (release aditivo; hashes de conteúdo intocados). evidência: ${g5Ev.rel}`);
+  return { status: 'sealed', sealed: true, pod_sha: sealedPodSha, release: releaseField, g5, arena: av };
+}
+
+function loadBaselineManifest(baselineDir) {
+  const p = path.join(baselineDir, 'baseline.manifest.json');
+  if (!fs.existsSync(p)) fail(`baseline.manifest.json ausente em ${baselineDir} (schema DF4-2) — o release NÃO gera baseline (SF10.7). VERMELHO por ausência de insumo.`);
+  let m;
+  try { m = JSON.parse(fs.readFileSync(p, 'utf8')); } catch (e) { fail(`baseline.manifest.json inválido (${p}): ${e.message}`); }
+  for (const k of ['pod_sha', 'modelo_pinado', 'artifacts', 'vetos', 'complete']) {
+    if (!(k in m)) fail(`baseline.manifest.json sem campo obrigatório "${k}" (schema DF4-2).`);
+  }
+  return m;
+}
+
+// ---------------------------------------------------------------------------
+// CLI.
+// ---------------------------------------------------------------------------
+
+function parseArgs(argv) {
+  const flags = {}; const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--if-changed') flags.ifChanged = true;
+    else if (a === '--no-endpoint-check') flags.noEndpoint = true;
+    else if (a === '--pod-dir') flags.podDir = argv[++i];
+    else if (a === '--baseline-dir') flags.baselineDir = argv[++i];
+    else if (a === '--arena-dir') flags.arenaDir = argv[++i];
+    else if (a === '--payload') flags.payload = argv[++i];
+    else if (a === '--sealed-by') flags.sealedBy = argv[++i];
+    else if (a === '--lock') flags.lock = argv[++i];
+    else if (a === '--pins') flags.pins = argv[++i];
+    else positionals.push(a);
+  }
+  return { flags, positionals };
+}
+
+async function main() {
+  const { flags, positionals } = parseArgs(process.argv.slice(2));
+  const sub = positionals[0];
+  const pod = positionals[1];
+  if (sub !== 'release' || !pod) {
+    console.error('Uso: node scripts/pod-export-release.cjs release <pod> --pod-dir <dir> [--if-changed] [--baseline-dir <dir>] [--arena-dir <expDir>] [--payload <file>] [--no-endpoint-check] [--sealed-by <id>] [--lock <path>]');
+    process.exit(2);
+  }
+  try {
+    const r = await release(pod, {
+      podDir: flags.podDir,
+      ifChanged: Boolean(flags.ifChanged),
+      baselineDir: flags.baselineDir,
+      arenaDir: flags.arenaDir,
+      payloadPath: flags.payload,
+      sealedBy: flags.sealedBy,
+      lockPath: flags.lock ? path.resolve(flags.lock) : undefined,
+      pinsPath: flags.pins ? path.resolve(flags.pins) : undefined,
+      checkEndpoint: !flags.noEndpoint,
+    });
+    // Códigos de saída: sealed/noop = 0; red/blocked = 1 (bloqueia o embarque, fail-loud).
+    if (r.status === 'sealed') { console.log('[OK] paridade selada — bundle liberado para embarque.'); process.exit(0); }
+    if (r.status === 'noop') { console.log('[OK] sem mudança — nenhuma reselagem necessária.'); process.exit(0); }
+    if (r.status === 'blocked') { console.error(`[BLOQUEADO] ${r.message}`); process.exit(1); }
+    console.error(`[VERMELHO] paridade REPROVADA — selo NÃO escrito:\n  ${r.message}`); process.exit(1);
+  } catch (e) {
+    if (e instanceof ReleaseError || e instanceof compileMod.CompileError) {
+      console.error(`[FALHA] ${e.message}`); process.exit(1);
+    }
+    throw e;
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  release,
+  compareG5,
+  arenaVerdict,
+  buildReleaseField,
+  serializeSealedLock,
+  writeG5Evidence,
+  extractExportManifest,
+  loadBaselineManifest,
+  stableStringify,
+  sameModel,
+  parseArgs,
+  ARTIFACT_COUNT,
+  ARM_EXPORT,
+  ARM_BASELINE,
+  ReleaseError,
+};