@daniellins/power-claude 0.16.3

package/scripts/pod-export-executor.test.cjs

@@ -0,0 +1,1341 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-export-executor.test.cjs — suíte HERMÉTICA do executor de produção (Story SF10.2, F2).
+ *
+ * NÃO toca rede: Messages API (Anthropic) e OpenRouter são INJETADAS (callModel/imageTransport);
+ * SSRF/traversal fazem short-circuit antes de qualquer IO. NÃO toca exports/.power-claude reais:
+ * compila content-carousel (fixture de CI, precedente do compile.test) para um bundle em tmp e
+ * dirige o executor de ponta a ponta com o MOTOR real e o COMPILADOR real — só o LLM/imagem/http
+ * são mocks. Cobre AC2 (loop max_tokens), AC3 (modelo pinado), AC4 (write-por-peça), AC5 (read por
+ * path/tamanho), AC6 (contenção das 4 tools), AC7 (whitelist do payload), AC8 (memória isolada),
+ * AC9 (reuso por import), AC16 (coerência de framework_version).
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const tools = require('./pod-export-tools.cjs');
+const exec = require('./pod-export-executor.cjs');
+const motor = require('./pc-run-pod.cjs');
+const compiler = require('./pod-export-compile.cjs');
+const validator = require('./validate-pod-workflow.cjs');
+// Oráculo REAL do veto lexical (SF10.11): a contagem que o command_check blessed usa em produção.
+const lexical = require('./veto-checks/lexical-check.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const FIXTURE_POD = path.join(REPO_ROOT, 'template', 'pods', 'content-carousel');
+
+let failures = 0;
+function assert(ok, msg) {
+  if (ok) console.log(`[OK   ] ${msg}`);
+  else { console.error(`[FALHA] ${msg}`); failures++; }
+}
+function tmpDir(label) { return fs.mkdtempSync(path.join(os.tmpdir(), `sf10.2-${label}-`)); }
+function sha(p) { return crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex'); }
+
+// ---------------------------------------------------------------------------
+// AC6/AC7 — contenção das 4 tools (SSRF, traversal, zero shell) + whitelist do payload.
+// ---------------------------------------------------------------------------
+
+function toolsSecurityTests() {
+  console.log('\n--- AC6/AC7: contenção das tools (SSRF, traversal, whitelist, read por path) ---');
+
+  // isBlockedHost: privados/loopback/metadata → true; público → false.
+  const blocked = ['169.254.169.254', 'localhost', '127.0.0.1', '10.1.2.3', '172.16.0.1', '172.31.255.1', '192.168.0.1', '::1', 'fc00::1', 'foo.internal', '0.0.0.0'];
+  assert(blocked.every((h) => tools.isBlockedHost(h)), `isBlockedHost barra todos os privados/metadata (${blocked.length})`);
+  const allowedHosts = ['news.ycombinator.com', 'hacker-news.firebaseio.com', 'christianselig.com', '8.8.8.8'];
+  assert(allowedHosts.every((h) => !tools.isBlockedHost(h)), 'isBlockedHost NÃO barra hosts públicos');
+  assert(!tools.isBlockedHost('172.32.0.1') && !tools.isBlockedHost('172.15.0.1'), 'isBlockedHost respeita a fronteira 172.16-31 (172.15/172.32 são públicos)');
+
+  // SSRF negado (sem rede — short-circuit): metadata, loopback, privado, host fora da whitelist.
+  return Promise.all([
+    tools.httpFetch('http://169.254.169.254/latest/meta-data/', { whitelistHosts: ['169.254.169.254'] }),
+    tools.httpFetch('http://localhost:8080/x', { whitelistHosts: [] }),
+    tools.httpFetch('http://10.0.0.5/x', { whitelistHosts: [] }),
+    tools.httpFetch('https://evil.example.com/x', { whitelistHosts: ['news.ycombinator.com'] }),
+    tools.httpFetch('ftp://news.ycombinator.com/x', { whitelistHosts: ['news.ycombinator.com'] }),
+  ]).then((rs) => {
+    assert(!rs[0].ok && /bloqueado/.test(rs[0].error), 'SSRF: metadata 169.254.169.254 bloqueado MESMO estando na whitelist (DF2-3)');
+    assert(!rs[1].ok && /bloqueado/.test(rs[1].error), 'SSRF: localhost bloqueado');
+    assert(!rs[2].ok && /bloqueado/.test(rs[2].error), 'SSRF: 10.0.0.5 (RFC1918) bloqueado');
+    assert(!rs[3].ok && /fora da whitelist/.test(rs[3].error), 'SSRF: host fora da whitelist negado');
+    assert(!rs[4].ok && /protocolo/.test(rs[4].error), 'protocolo não-http negado');
+
+    // Positivo: host whitelisted + transport injetado → passa a guarda e chega ao transport.
+    let seen = null;
+    return tools.httpFetch('https://news.ycombinator.com/item?id=1', {
+      whitelistHosts: ['news.ycombinator.com'],
+      transport: (url) => { seen = url; return { ok: true, status: 200, body: 'OK', bytes: 2 }; },
+    }).then((r) => {
+      assert(r.ok && /item\?id=1/.test(seen), 'fetch: host na whitelist chega ao transport (caminho positivo)');
+    });
+  }).then(() => {
+    // write_file traversal / path absoluto NEGADOS; confinado OK.
+    const run = tmpDir('write');
+    let threwTraversal = false; let threwAbs = false;
+    try { tools.writeFile('../escape.txt', 'x', { runDir: run }); } catch { threwTraversal = true; }
+    try { tools.writeFile('/etc/pwn.txt', 'x', { runDir: run }); } catch { threwAbs = true; }
+    assert(threwTraversal, 'write_file: traversal "../escape.txt" NEGADO');
+    assert(threwAbs, 'write_file: path absoluto NEGADO');
+    const w = tools.writeFile('pieces/01-capa.html', '<html></html>', { runDir: run });
+    assert(w.ok && fs.existsSync(path.join(run, 'pieces/01-capa.html')), 'write_file: path confinado ESCREVE');
+
+    // read_image: gerada → path+tamanho (SEM base64); referência → base64; traversal negado.
+    const gen = exec; void gen;
+    const rGen = tools.readImage('pieces/01-capa.html', { runDir: run });
+    assert(rGen.ok && rGen.kind === 'generated' && rGen.base64 === undefined && rGen.bytes > 0,
+      'read_image: imagem GERADA confirmada por path+tamanho, SEM base64 (AC5/Achado 4)');
+    const inputs = tmpDir('inputs');
+    fs.writeFileSync(path.join(inputs, 'ref.png'), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+    const rRef = tools.readImage('inputs:ref.png', { runDir: run, inputsDir: inputs });
+    assert(rRef.ok && rRef.kind === 'reference' && typeof rRef.base64 === 'string', 'read_image: referência pinada devolve base64 (multimodal)');
+    const rTrav = tools.readImage('inputs:../secret.png', { runDir: run, inputsDir: inputs });
+    assert(!rTrav.ok && /fora de inputs/.test(rTrav.error), 'read_image: traversal em inputs: NEGADO');
+
+    // openrouter_image: sem modelo → erro; traversal → erro ANTES da rede; transport → escreve + confirma.
+    return tools.openrouterImage('p', 'assets/cover.png', { runDir: run, model: '', imageTransport: async () => ({}) }).then((e0) => {
+      assert(!e0.ok && /modelo/.test(e0.error), 'openrouter_image: sem modelo pinado → erro');
+      return tools.openrouterImage('p', '../evil.png', { runDir: run, model: 'm', imageTransport: async () => ({}) });
+    }).then((e1) => {
+      assert(!e1.ok && /traversal/.test(e1.error), 'openrouter_image: out_path traversal NEGADO antes da rede');
+      const png1x1 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
+      let usedModel = null;
+      return tools.openrouterImage('desenhe', 'assets/cover.png', {
+        runDir: run, model: 'google/gemini-2.5-flash-image',
+        imageTransport: async (payload) => { usedModel = payload.model; return { choices: [{ message: { images: [{ image_url: { url: png1x1 } }] } }] }; },
+      }).then((r) => {
+        assert(r.ok && r.bytes > 0 && r.base64 === undefined && usedModel === 'google/gemini-2.5-flash-image',
+          'openrouter_image: modelo PINADO usado; PNG escrito; confirmado por path+tamanho, SEM base64');
+      });
+    });
+  }).then(() => {
+    // AC7 — whitelist derivada SÓ do payload declarado (host de URL pinada ∪ fetch_allow_hosts).
+    const wl = tools.computeWhitelist({ fetch_allow_hosts: ['hacker-news.firebaseio.com', 'news.ycombinator.com'], article_url: 'https://christianselig.com/x/y', title: 'not a url', hn_id: 42 });
+    assert(wl.includes('christianselig.com') && wl.includes('news.ycombinator.com') && wl.length === 3,
+      `whitelist = fetch_allow_hosts ∪ host(article_url), ignora não-URLs (${wl.join(', ')})`);
+    const wl2 = tools.computeWhitelist({ evil: 'http://169.254.169.254/' });
+    assert(wl2.includes('169.254.169.254'), 'computeWhitelist inclui o host declarado, mas isBlockedHost o barra em runtime (defesa em profundidade)');
+  });
+}
+
+// ---------------------------------------------------------------------------
+// AC9 — reuso por import, ZERO reimplementação (estático).
+// ---------------------------------------------------------------------------
+
+function reuseTests() {
+  console.log('\n--- AC9: reuso do motor por import, sem reimplementação ---');
+  const src = fs.readFileSync(path.join(__dirname, 'pod-export-executor.cjs'), 'utf8');
+  assert(/require\('\.\/pc-run-pod\.cjs'\)/.test(src), "executor importa './pc-run-pod.cjs' (motor de produção)");
+  const banned = [/function\s+verifyStep\b/, /function\s+evalVeto\b/, /function\s+advance\s*\(/, /function\s+writeState\b/, /function\s+checkTemplateConformance\b/];
+  assert(banned.every((re) => !re.test(src)), 'executor NÃO reimplementa verifyStep/evalVeto/advance/writeState/checkTemplateConformance');
+  const toolsSrc = fs.readFileSync(path.join(__dirname, 'pod-export-tools.cjs'), 'utf8');
+  const shell = [/child_process/, /execSync/, /execFileSync/, /\bspawn\b/, /\bexec\(/];
+  assert(shell.every((re) => !re.test(toolsSrc)) && shell.every((re) => !re.test(src)), 'AC6: ZERO shell em tools/executor (sem child_process/exec/spawn)');
+}
+
+// ---------------------------------------------------------------------------
+// AC16 — coerência fail-loud de framework_version.
+// ---------------------------------------------------------------------------
+
+function coherenceTests() {
+  console.log('\n--- AC16: coerência de framework_version (fail-loud) ---');
+  const engine = exec.engineFrameworkVersion();
+  const dir = tmpDir('lock');
+  const okLock = path.join(dir, 'ok.lock.json');
+  fs.writeFileSync(okLock, JSON.stringify({ framework_version: engine }));
+  const badLock = path.join(dir, 'bad.lock.json');
+  fs.writeFileSync(badLock, JSON.stringify({ framework_version: '0.0.0-mismatch' }));
+  const bundle = { pod: 'x' };
+  let ok = false; try { exec.assertFrameworkCoherence(bundle, okLock, engine); ok = true; } catch { /* */ }
+  assert(ok, `coerência: versões iguais (${engine}) → run permitido`);
+  let mism = false; try { exec.assertFrameworkCoherence(bundle, badLock, engine); } catch (e) { mism = /MISMATCH/.test(e.message); }
+  assert(mism, 'coerência: MISMATCH de framework_version → run RECUSADO (fail-loud)');
+  let noLock = false; try { exec.assertFrameworkCoherence(bundle, path.join(dir, 'ausente.json'), engine); } catch (e) { noLock = /não encontrado/.test(e.message); }
+  assert(noLock, 'coerência: lock ausente → run RECUSADO');
+}
+
+// ---------------------------------------------------------------------------
+// AC2/AC4 — loop de tool-use: max_tokens NÃO descarta tool_use; write-por-peça.
+// ---------------------------------------------------------------------------
+
+async function loopTests() {
+  console.log('\n--- AC2/AC4: loop max_tokens sem descartar tool_use + write-por-peça ---');
+  const run = tmpDir('loop');
+  let tu = 0;
+  const scripted = [];
+  // 7 peças, UMA por turn, TODAS com stop_reason=max_tokens (o bug antigo descartaria a 1ª e pararia).
+  for (let i = 1; i <= 7; i++) {
+    scripted.push({ stop_reason: 'max_tokens', content: [{ type: 'tool_use', id: `tu${++tu}`, name: 'write_file', input: { path: `pieces/0${i}.html`, content: `<html>peca ${i}</html>` } }], usage: { input_tokens: 10, output_tokens: 10 } });
+  }
+  // turn final: artefato + SEM tool_use encerra.
+  scripted.push({ stop_reason: 'max_tokens', content: [{ type: 'tool_use', id: `tu${++tu}`, name: 'write_file', input: { path: 'artifacts/assembly.md', content: '# final' } }], usage: { input_tokens: 5, output_tokens: 5 } });
+  scripted.push({ stop_reason: 'end_turn', content: [{ type: 'text', text: 'pronto' }], usage: { input_tokens: 1, output_tokens: 1 } });
+  let call = 0;
+  const callModel = async () => scripted[call++];
+  const capturedModels = [];
+  const callModelCapturing = async (args) => { capturedModels.push(args.model); return scripted[call++]; };
+  call = 0;
+  const r = await exec.runPhase({ system: 's', userContent: '# RODADA — fase assembly', apiKey: 'k', model: 'claude-sonnet-5', env: { runDir: run }, callModel: callModelCapturing });
+  const pieces = fs.readdirSync(path.join(run, 'pieces')).filter((f) => f.endsWith('.html'));
+  assert(pieces.length === 7, `AC4: 7 peças escritas, UMA por turn (escritas: ${pieces.length})`);
+  assert(fs.existsSync(path.join(run, 'artifacts/assembly.md')), 'AC4: artefato final escrito após as peças');
+  assert(r.iters === 9, `AC2: loop percorreu 9 turns (não parou no 1º max_tokens) — foram ${r.iters}`);
+  assert(capturedModels.every((m) => m === 'claude-sonnet-5'), 'AC3: o modelo pinado é passado ao callModel em todo turn');
+}
+
+// ---------------------------------------------------------------------------
+// AC1/AC8/AC10 — end-to-end HERMÉTICO com o motor + compilador reais (só LLM/imagem mockados).
+// ---------------------------------------------------------------------------
+
+function digestArtifact() {
+  return [
+    '## Noticia', 'Titulo da noticia de teste.',
+    '## Sintese Acessivel', 'Resumo simples.',
+    '## Angulos para Slides', '- angulo 1', '- angulo 2', '- angulo 3', '- angulo 4', '- angulo 5', '- angulo 6',
+    // `contrato_entrada` (Story SF11.6 / ADR-020 DF-SF10.21-3): a etapa `digest` do pod-fixture
+    // ganhou a assertion field_matches ^(ancora:hn)$ — sem esta linha o motor bloqueia a fase.
+    '', 'confianca: alta', 'contrato_entrada: ancora:hn', '',
+  ].join('\n');
+}
+function visualsArtifact() {
+  return [
+    '## Prompt da Capa', 'Prompt da capa gerado.',
+    '## Prompt do CTA', 'Prompt do CTA gerado.',
+    '## Arquivos Gerados', '- assets/cover.png', '- assets/cta.png',
+    '## Conformidade de Referencia', 'Estilo inspirado, composicao propria.',
+    '', 'referencia_copiada: nao', 'confianca: alta', '',
+  ].join('\n');
+}
+// ---------------------------------------------------------------------------
+// LUGAR DAS PEÇAS — `ADR-028 DF-SF12.2-1/-2` (Story SF12.2).
+//
+// Até a SF12.2 este mock escrevia as 7 peças em `pieces/0N.html`. `pieces/` NUNCA foi
+// convenção de runtime: ZERO ocorrências em pod-export-executor/service/compile/ui/tools,
+// em deploy/, installer/ e template/ — era escolha arbitrária deste test double, escrita na
+// SF10.2, antes de o `render-png` existir e antes de o pod declarar qualquer lugar.
+//
+// O pod DECLARA o lugar (knowledge/slides-html.md "Formato base", agents/carousel-builder.md,
+// templates/assembly-tmpl.md): as 7 peças ficam na RAIZ do runDir, porque o veto
+// `command_check render-png.cjs` recebe `--html-dir ".."` como arg LITERAL (ADR-011 proíbe
+// interpolação). O mock passa a modelar um agente que OBEDECE a spec que o bundle lhe entrega
+// — e o caso desobediente NÃO foi apagado: virou o controle negativo `lugarDasPecasTest()`.
+// ---------------------------------------------------------------------------
+const PIECE_NAMES = ['01-capa.html', '02-slide.html', '03-slide.html', '04-slide.html', '05-slide.html', '06-slide.html', '07-cta.html'];
+
+/** Peças na raiz do runDir (caminho obediente) ou sob um subdiretório (controle negativo). */
+function piecePath(i, subdir) {
+  return subdir ? `${subdir}/${PIECE_NAMES[i - 1]}` : PIECE_NAMES[i - 1];
+}
+
+/**
+ * SF12.2/ADR-024 — destrava o gate de TEXTO de `digest` quando ELE NÃO é o objeto do teste.
+ * O pod-template ganhou `digest.checkpoint` bloqueante (`skip_modes: ["yolo"]`) e o executor
+ * chama `startRun` SEM `mode` ⇒ `interactive` ⇒ toda run de export para lá primeiro. Testes cujo
+ * objeto é `visuals`/`assembly` atravessam o gate como o operador do serviço faria (`approve`),
+ * em vez de fingir um modo que o executor nunca usa. Quem TESTA o gate (`endToEndTest`,
+ * `fixerOrderingTest`, `exportHerdaGateDeTextoTest`, `lugarDasPecasTest`) o faz explicitamente.
+ */
+async function driveAlemDoGateDeTexto(ctx, run) {
+  let r = await exec.drive(ctx, run, {});
+  if (r.awaiting === 'digest') { motor.approve(ctx); r = await exec.drive(ctx, run, {}); }
+  return r;
+}
+
+/** HTML mínimo e autocontido de uma peça (o `render-png` mede o PNG, não o conteúdo). */
+function pecaHtml(i, extra = '') {
+  return `<!doctype html>\n<html lang="pt-BR">\n<head><meta charset="utf-8"><title>${PIECE_NAMES[i - 1]}</title>\n`
+    + '<style>html,body{width:1080px;height:1350px;margin:0;background:#101820;color:#fff;font-family:sans-serif}</style>\n'
+    + `</head>\n<body><main>peca ${i}${extra}</main></body>\n</html>\n`;
+}
+
+/**
+ * SF12.2/ADR-028 — próxima peça a escrever, decidida SÓ pela conversa recebida (nunca por contador
+ * externo, para não encenar o resultado). Existe porque a fase `assembly` do pod-template passou a
+ * ter o veto `render-png`: sem as 7 peças NA RAIZ a etapa bloqueia, e mocks conversacionais que só
+ * escreviam o artefato precisam produzir o ENTREGÁVEL antes dele, como o agente real faz.
+ */
+function proximaPeca(convo) {
+  const i = PIECE_NAMES.findIndex((n) => !convo.includes(`escrito: ${n}`));
+  return i < 0 ? null : i + 1;
+}
+
+/** Lista as peças HTML da RAIZ do runDir (nunca recursivo — o lugar é o que se verifica). */
+function rootPieces(runDir) {
+  return fs.readdirSync(runDir, { withFileTypes: true })
+    .filter((e) => e.isFile() && e.name.endsWith('.html'))
+    .map((e) => e.name)
+    .sort();
+}
+
+function assemblyArtifact() {
+  // Sem em-dash/en-dash (lexical-check --pattern [—–] --max 0).
+  // Paths do `## Pacote Final` RELATIVOS À RAIZ (ADR-028): `01-capa.html`, nunca `pieces/01-capa.html`.
+  return [
+    '## Slides Internos', '- slide 1', '- slide 2', '- slide 3', '- slide 4', '- slide 5',
+    '## Slide CTA', 'Chamada final forte.',
+    '## Pacote Final', '- 01-capa.html', '- 07-cta.html',
+    '', 'confianca: alta', '',
+  ].join('\n');
+}
+
+async function endToEndTest() {
+  console.log('\n--- AC1/AC8/AC10: end-to-end hermético (compilador + motor reais, LLM/imagem mock) ---');
+  // 1) Compila content-carousel para um bundle em tmp (rede de endpoint OFF) + lock coerente.
+  const bundleDir = tmpDir('bundle');
+  const lockPath = path.join(tmpDir('lockout'), 'export.lock.json');
+  const { bundleFiles, lock } = await compiler.compile(FIXTURE_POD, { checkEndpoint: false });
+  compiler.writeBundle(bundleDir, bundleFiles);
+  fs.writeFileSync(lockPath, compiler.serializeLock(lock));
+  assert(lock.framework_version === exec.engineFrameworkVersion(), 'bundle fresco: lock.framework_version == motor (coerente)');
+
+  const bundleMemPath = path.join(bundleDir, 'memory', 'learnings.consolidated.md');
+  const memShaBefore = fs.existsSync(bundleMemPath) ? sha(bundleMemPath) : null;
+
+  // 2) Deps injetadas (mock): callModel roteia por fase; openrouter_image devolve PNG mínimo.
+  const png1x1 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
+  const usedImageModels = [];
+  const turnByPhase = {};
+  const capturedAgentModels = [];
+  const callModelInner = async ({ model, messages }) => {
+    capturedAgentModels.push(model);
+    const first = messages[0].content;
+    const m = /fase (\w+)/.exec(typeof first === 'string' ? first : JSON.stringify(first));
+    const phase = m ? m[1] : 'unknown';
+    turnByPhase[phase] = (turnByPhase[phase] || 0) + 1;
+    const t = turnByPhase[phase];
+    const tuId = `${phase}-${t}`;
+    if (phase === 'digest') {
+      if (t === 1) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/digest.md', content: digestArtifact() } }] };
+      return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'digest pronto' }] };
+    }
+    if (phase === 'visuals') {
+      if (t === 1) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'openrouter_image', input: { prompt: 'capa', out_path: 'assets/cover.png' } }] };
+      if (t === 2) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'read_image', input: { ref: 'assets/cover.png' } }] };
+      if (t === 3) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: visualsArtifact() } }] };
+      return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'visuals pronto' }] };
+    }
+    if (phase === 'assembly') {
+      // ADR-028: peças na RAIZ, com os nomes que o pod declara — agente OBEDIENTE à spec do bundle.
+      if (t <= 7) return { stop_reason: 'max_tokens', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: piecePath(t), content: pecaHtml(t) } }] };
+      if (t === 8) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/assembly.md', content: assemblyArtifact() } }] };
+      return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'assembly pronto' }] };
+    }
+    return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'noop' }] };
+  };
+  // Toda resposta carrega usage (DF3-4): o executor acumula por turn (runPhase) e drive soma no run.
+  const callModel = async (args) => { const r = await callModelInner(args); return { ...r, usage: r.usage || { input_tokens: 12, output_tokens: 8 } }; };
+  const imageTransport = async (payload) => { usedImageModels.push(payload.model); return { choices: [{ message: { images: [{ image_url: { url: png1x1 } }] } }] }; };
+
+  // 3) setupRun (AC16 conferida) + startRun (memoryPodDir efêmero) + drive.
+  const runsRoot = tmpDir('runs');
+  const payload = { pod: 'content-carousel', workflow: 'wf-content-carousel', fetch_allow_hosts: [], article_url: 'https://example.com/a' };
+  const logs = [];
+  const run = exec.setupRun({ bundleDir, lockOverride: lockPath, payload, deps: { callModel, imageTransport }, log: (m) => logs.push(m) });
+  assert(run.coherence.engineVersion === run.coherence.lockVersion, 'AC16: setupRun confere coerência antes do run');
+  assert(run.whitelist.includes('example.com'), 'AC7: whitelist do run derivada do payload (host de article_url)');
+
+  const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const { ctx } = motor.startRun({ workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, pod: run.pod, workflow: run.workflow, runsRoot, runId: 'e2e-1', memoryPodDir });
+  // SF12.2/ADR-024: o pod-template ganhou o GATE DE TEXTO em `digest` (`skip_modes: ["yolo"]`).
+  // O executor chama `startRun` SEM `mode` ⇒ `interactive` ⇒ a 1ª parada é `digest`. O serviço já
+  // roteia `awaiting` de QUALQUER fase (`classifyOutcome`), logo isto é herança, não código novo.
+  const r0 = await exec.drive(ctx, run, {});
+  assert(r0.awaiting === 'digest', `SF12.2: 1ª parada do export é o gate de TEXTO em digest (awaiting=${r0.awaiting})`);
+  const apTexto = motor.approve(ctx);
+  assert(apTexto.action === 'approved' && apTexto.step === 'digest', `SF12.2: approve do gate de texto libera a fase cara (${apTexto.action}/${apTexto.step})`);
+
+  const r1 = await exec.drive(ctx, run, {});
+  assert(r1.awaiting === 'assembly', `parou no checkpoint blocking da fase assembly (awaiting=${r1.awaiting})`);
+  // DF3-4 — o executor agora EXPÕE usage REAL no RESULTADO (agregado das fases pelo drive), o campo
+  // que o ledger do serviço consome. Prova que o freio deixa de registrar 0.
+  const usage = {
+    input_tokens: (r0.usage.input_tokens || 0) + (r1.usage.input_tokens || 0),
+    output_tokens: (r0.usage.output_tokens || 0) + (r1.usage.output_tokens || 0),
+    images: (r0.usage.images || 0) + (r1.usage.images || 0),
+  };
+  assert(usage.input_tokens > 0 && usage.output_tokens > 0, `DF3-4: drive expõe usage REAL agregado (tokens somados das fases: in=${usage.input_tokens})`);
+  assert(usage.images >= 1, `DF3-4: usage.images conta imagens OpenRouter geradas com sucesso (${usage.images})`);
+
+  // Artefatos verificados EM DISCO pelo motor real (vetos + template) → provam AC1/AC10.
+  for (const a of ['digest', 'visuals', 'assembly']) {
+    assert(fs.existsSync(path.join(ctx.runDir, 'artifacts', `${a}.md`)), `artefato ${a}.md verificado em disco pelo motor`);
+  }
+  const pieces = rootPieces(ctx.runDir);
+  assert(pieces.length === 7, `AC4 end-to-end: 7 peças HTML escritas uma-por-turn (${pieces.length})`);
+  assert(pieces.join(',') === PIECE_NAMES.join(','), `ADR-028 AC26: as 7 peças estão na RAIZ do runDir, com os nomes do pod (${pieces.join(',')})`);
+
+  // SF12.2/ADR-025 — o VETO `render-png` rodou DENTRO do runtime de export: prova em disco, não
+  // por ausência de bloqueio. Mesma classe de evidência do AC7 (smoke): contagem + IHDR dos 7 PNG.
+  const pngDir = path.join(ctx.runDir, 'png');
+  const pngs = fs.existsSync(pngDir) ? fs.readdirSync(pngDir).filter((f) => f.endsWith('.png')).sort() : [];
+  assert(pngs.length === 7, `AC25/ADR-028: o veto render-png renderizou 7 PNG no runtime de EXPORT (${pngs.length})`);
+  const dims = pngs.map((f) => {
+    const b = fs.readFileSync(path.join(pngDir, f));
+    return `${b.readUInt32BE(16)}x${b.readUInt32BE(20)}`;
+  });
+  assert(dims.every((d) => d === '1080x1350'), `AC25/ADR-028: IHDR de cada PNG do export mede 1080x1350 (${[...new Set(dims)].join(', ')})`);
+  assert(fs.readFileSync(path.join(ctx.runDir, 'artifacts', 'assembly.md'), 'utf8').includes('pc:entregavel-png'),
+    'AC25/ADR-028: o bloco `pc:entregavel-png` foi gravado no artefato do run de EXPORT');
+  assert(usedImageModels.length >= 1 && usedImageModels.every((m) => m === 'google/gemini-2.5-flash-image'), 'AC3 end-to-end: imagem usa o modelo PINADO do bundle');
+  assert(capturedAgentModels.every((m) => m === 'claude-sonnet-5'), 'AC3 end-to-end: agente usa o modelo PINADO do bundle');
+
+  // AC8 — memória do BUNDLE nunca escrita por um run (isolamento mecânico DF2-2).
+  const memShaAfter = fs.existsSync(bundleMemPath) ? sha(bundleMemPath) : null;
+  assert(memShaBefore === memShaAfter, 'AC8: memory/learnings.consolidated.md do BUNDLE inalterado após o run');
+  const bundleRawLog = path.join(bundleDir, 'memory', 'learnings.jsonl');
+  assert(!fs.existsSync(bundleRawLog), 'AC8: nenhum learnings.jsonl escrito dentro do bundle');
+
+  // approve → complete (checkpoint humano; sem identidade nesta fase — F3). O fechamento limpo
+  // grava o padrão-ok NO memoryPodDir efêmero (sink descartável), NUNCA no bundle.
+  const statePath = motor.findStateByRunId(runsRoot, 'e2e-1');
+  const memApprove = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const ctx2 = motor.openRun({ statePath, workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, memoryPodDir: memApprove });
+  const ap = motor.approve(ctx2);
+  assert(ap.action === 'approved' && ap.next && ap.next.action === 'complete', `approve → complete (${ap.action}/${ap.next && ap.next.action})`);
+  assert(fs.existsSync(path.join(memApprove, 'memory')), 'AC8: aprendizado do fechamento foi para o memoryPodDir EFÊMERO (sink), não o bundle');
+  const memShaFinal = fs.existsSync(bundleMemPath) ? sha(bundleMemPath) : null;
+  assert(memShaBefore === memShaFinal, 'AC8: memory do BUNDLE segue inalterado mesmo após o complete/approve');
+  void memoryPodDir;
+}
+
+// ---------------------------------------------------------------------------
+// SF10.11 (AC1/AC5/DF-SF10.11+12-1) — o FIXER roda ENTRE runPhase e motor.advance, end-to-end,
+// com o MOTOR e o VETO REAIS. Prova de ORDEM: o modelo escreve travessões no artefato que o
+// `lexical-check` (--max 0) verifica; se o fixer rodasse DEPOIS do advance (ou não rodasse), a
+// etapa seria BLOQUEADA e a fase re-executaria. Passar na 1ª tentativa só é possível com o fixer
+// como ÚLTIMO ESCRITOR ANTES DA VERIFICAÇÃO.
+// ---------------------------------------------------------------------------
+
+const EM_DASH = '—';
+const EN_DASH = '–';
+
+async function fixerOrderingTest() {
+  console.log('\n--- SF10.11: fixer determinístico ENTRE runPhase e motor.advance (motor/veto reais) ---');
+  const bundleDir = tmpDir('bundle-fix');
+  const lockPath = path.join(tmpDir('lockout-fix'), 'export.lock.json');
+  const { bundleFiles, lock } = await compiler.compile(FIXTURE_POD, { checkEndpoint: false });
+  compiler.writeBundle(bundleDir, bundleFiles);
+  fs.writeFileSync(lockPath, compiler.serializeLock(lock));
+
+  // Artefato de assembly COM a classe mecânica que o veto blessed conta (e que o modelo, no achado
+  // de SF10.7, não removeu em 3 reamostragens caras).
+  const assemblySujo = [
+    '## Slides Internos',
+    `- slide 1 ${EM_DASH} gancho`, `- slide 2 ${EM_DASH} conflito`, '- slide 3', '- slide 4', '- slide 5',
+    '## Slide CTA', `Chamada final ${EM_DASH} forte.`,
+    '## Pacote Final', '- 01-capa.html', '- 07-cta.html',
+    '', 'confianca: alta', '',
+  ].join('\n');
+
+  const png1x1 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
+  const turnByPhase = {};
+  const callModel = async ({ messages }) => {
+    const first = messages[0].content;
+    const m = /fase (\w+)/.exec(typeof first === 'string' ? first : JSON.stringify(first));
+    const phase = m ? m[1] : 'unknown';
+    turnByPhase[phase] = (turnByPhase[phase] || 0) + 1;
+    const t = turnByPhase[phase];
+    const tuId = `${phase}-${t}`;
+    const wrap = (r) => ({ ...r, usage: { input_tokens: 10, output_tokens: 5 } });
+    if (phase === 'digest') {
+      if (t === 1) return wrap({ stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/digest.md', content: digestArtifact() } }] });
+      return wrap({ stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }] });
+    }
+    if (phase === 'visuals') {
+      if (t === 1) return wrap({ stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'openrouter_image', input: { prompt: 'capa', out_path: 'assets/cover.png' } }] });
+      if (t === 2) return wrap({ stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: visualsArtifact() } }] });
+      return wrap({ stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }] });
+    }
+    if (phase === 'assembly') {
+      // As 7 peças HTML (que NENHUM veto do wf inspeciona LEXICALMENTE) também nascem com travessão.
+      // ADR-028: na RAIZ do runDir — o `render-png` as procura ali (arg literal `--html-dir ".."`).
+      if (t <= 7) return wrap({ stop_reason: 'max_tokens', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: piecePath(t), content: pecaHtml(t, ` ${EM_DASH} copy publicada de 2020${EN_DASH}2024`) } }] });
+      if (t === 8) return wrap({ stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/assembly.md', content: assemblySujo } }] });
+      return wrap({ stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }] });
+    }
+    return wrap({ stop_reason: 'end_turn', content: [{ type: 'text', text: 'noop' }] });
+  };
+  const imageTransport = async () => ({ choices: [{ message: { images: [{ image_url: { url: png1x1 } }] } }] });
+
+  const runsRoot = tmpDir('runs-fix');
+  const payload = { pod: 'content-carousel', workflow: 'wf-content-carousel', fetch_allow_hosts: [], article_url: 'https://example.com/a' };
+  const logs = [];
+  const run = exec.setupRun({ bundleDir, lockOverride: lockPath, payload, deps: { callModel, imageTransport }, log: (m) => logs.push(m) });
+  const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const { ctx } = motor.startRun({ workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, pod: run.pod, workflow: run.workflow, runsRoot, runId: 'fixer-1', memoryPodDir });
+  // SF12.2/ADR-024: destrava o gate de TEXTO de `digest` antes de chegar em `assembly` (o objeto
+  // deste teste é a ORDEM fixer × veto na fase `assembly`, não o gate).
+  const rGate = await exec.drive(ctx, run, {});
+  assert(rGate.awaiting === 'digest', `SF12.2: 1ª parada é o gate de texto (awaiting=${rGate.awaiting})`);
+  motor.approve(ctx);
+  const r = await exec.drive(ctx, run, {});
+
+  // O veto lexical (command_check blessed, --max 0) NÃO bloqueou: a etapa avançou ao checkpoint.
+  assert(r.awaiting === 'assembly', `SF10.11: com travessões no artefato, a etapa AVANÇOU até o checkpoint (awaiting=${r.awaiting}) — o fixer correu antes do veto`);
+  assert(turnByPhase.assembly === 9, `SF10.11 (ORDEM): a fase assembly rodou UMA vez só (9 turns; um retry daria 18) — foram ${turnByPhase.assembly}`);
+  assert(!logs.some((l) => /VETO DISPAROU/.test(l)), 'SF10.11: nenhum "VETO DISPAROU" no run — a reprovação evitável deixou de existir');
+
+  const pattern = '[\\u2014\\u2013]';
+  const assemblyDisco = fs.readFileSync(path.join(ctx.runDir, 'artifacts', 'assembly.md'), 'utf8');
+  assert(lexical.countMatches(assemblyDisco, pattern) === 0, 'SF10.11: o artefato VERIFICADO ficou com 0 ocorrência (contador real do lexical-check)');
+  assert(assemblyDisco.includes('- slide 1, gancho'), 'SF10.11: a substituição aprovada pelo dono (vírgula) é a que foi aplicada');
+
+  const pecas = rootPieces(ctx.runDir);
+  const pecasLimpas = pecas.filter((f) => lexical.countMatches(fs.readFileSync(path.join(ctx.runDir, f), 'utf8'), pattern) === 0);
+  assert(pecas.length === 7 && pecasLimpas.length === 7,
+    `SF10.11 (AC1/DF-SF10.11+12-0(a)): as 7 PEÇAS HTML publicadas saíram limpas (${pecasLimpas.length}/7) — nenhum veto do wf as inspeciona`);
+
+  // AC4 — a evidência do fixer sobe no RESULTADO do drive (auditoria do operador na fila).
+  assert(Array.isArray(r.fixes) && r.fixes.some((f) => f.step === 'assembly' && f.attempt === 1 && f.files === 8),
+    `SF10.11 (AC4): o RESULTADO do drive registra o fixer por tentativa (${JSON.stringify(r.fixes)})`);
+  assert(logs.some((l) => /\[fixer\]/.test(l) && /assembly\.md/.test(l)), 'SF10.11 (AC4): a correção nunca é silenciosa no log do run');
+  void memoryPodDir;
+}
+
+// ===========================================================================
+// SF10.12 — CORREÇÃO GUIADA PÓS-VETO (DF-SF10.12-1/-2).
+//
+// O achado que esta story ataca: antes dela, cada retry reconstruía `userContent` do zero e
+// `messages` nascia vazio, então o artefato REPROVADO nunca entrava no contexto — três amostras
+// independentes, não três edições. Aqui a conversa é RETOMADA com o veredito REAL da máquina.
+//
+// O modelo mockado decide o que fazer OLHANDO A CONVERSA QUE RECEBE (nunca um contador global de
+// tentativa). É o que torna a prova portadora de carga: sob o código antigo ele receberia uma
+// conversa vazia, não veria a imagem já gravada e a REGERARIA. Sob o código novo ele a vê.
+// ===========================================================================
+
+/** Artefato de visuals que o veto REPROVA (`referencia_copiada: ^nao$`) e que o fixer TAMBÉM toca. */
+function visualsReprovado() {
+  return [
+    '## Prompt da Capa', `Prompt da capa ${EM_DASH} gerado com estilo inspirado.`,
+    '## Prompt do CTA', 'Prompt do CTA gerado.',
+    '## Arquivos Gerados', '- assets/cover.png',
+    '## Conformidade de Referencia', 'Composicao propria.',
+    '', 'referencia_copiada: sim', 'confianca: alta', '',
+  ].join('\n');
+}
+
+async function compileFixtureBundle(label) {
+  const bundleDir = tmpDir(`bundle-${label}`);
+  const lockPath = path.join(tmpDir(`lockout-${label}`), 'export.lock.json');
+  const { bundleFiles, lock } = await compiler.compile(FIXTURE_POD, { checkEndpoint: false });
+  compiler.writeBundle(bundleDir, bundleFiles);
+  fs.writeFileSync(lockPath, compiler.serializeLock(lock));
+  return { bundleDir, lockPath };
+}
+
+const PNG_1X1 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
+
+async function guidedCorrectionTest() {
+  console.log('\n--- SF10.12 (AC1/AC3/AC4/AC5): correção guiada pós-veto retoma a MESMA conversa ---');
+  const { bundleDir, lockPath } = await compileFixtureBundle('guided');
+
+  const calls = [];          // uma entrada por chamada de modelo (medição, não estimativa)
+  let imageApiCalls = 0;     // ORÁCULO DE DINHEIRO: chamadas REAIS ao transport do OpenRouter
+
+  const callModel = async ({ system, messages }) => {
+    const first = messages[0].content;
+    const m = /fase (\w+)/.exec(typeof first === 'string' ? first : JSON.stringify(first));
+    const phase = m ? m[1] : 'unknown';
+    const convo = JSON.stringify(messages);
+    // MEDIÇÃO do contexto que sobe: bytes REAIS do payload (system + conversa inteira). O proxy
+    // de token é declarado (4 chars/token) e aplicado igual nas duas tentativas, então o DELTA é
+    // uma medida do crescimento real da conversa, não um número inventado.
+    const chars = JSON.stringify({ system, messages }).length;
+    const inTok = Math.ceil(chars / 4);
+    const recebeuCorrecao = /VERIFICAÇÃO DE MÁQUINA REPROVOU/.test(convo);
+    // TEXTO CRU do último turn `user` — é literalmente o que o modelo recebeu. Comparar contra o
+    // `convo` (JSON) esconderia escapes (`\"`) e deixaria a asserção de literalidade frouxa.
+    const ultima = messages[messages.length - 1];
+    const textoRecebido = ultima && ultima.role === 'user' && typeof ultima.content === 'string' ? ultima.content : '';
+    const rec = { phase, msgs: messages.length, chars, inTok, recebeuCorrecao, emitiu: null, convo, textoRecebido };
+    calls.push(rec);
+    const wrap = (name, content) => { rec.emitiu = name; return { stop_reason: 'tool_use', content, usage: { input_tokens: inTok, output_tokens: 8 } }; };
+    const fim = () => ({ stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }], usage: { input_tokens: inTok, output_tokens: 4 } });
+    const tuId = `${phase}-${calls.length}`;
+
+    if (phase === 'digest') {
+      if (!/escrito: artifacts\/digest\.md/.test(convo)) return wrap('write_file', [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/digest.md', content: digestArtifact() } }]);
+      return fim();
+    }
+    if (phase === 'visuals') {
+      // Decisões derivadas SÓ da conversa recebida (posição relativa dos eventos), nunca de estado
+      // externo: é assim que o teste mede o efeito da retomada em vez de encenar o resultado.
+      const iImg = convo.lastIndexOf('imagem salva: assets/cover.png');
+      const iCorr = convo.lastIndexOf('VERIFICAÇÃO DE MÁQUINA REPROVOU');
+      const iWrite = convo.lastIndexOf('escrito: artifacts/visuals.md');
+      if (iImg < 0) return wrap('openrouter_image', [{ type: 'tool_use', id: tuId, name: 'openrouter_image', input: { prompt: 'capa', out_path: 'assets/cover.png' } }]);
+      if (iCorr > iWrite) return wrap('write_file', [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: visualsArtifact() } }]);
+      if (iWrite < 0) return wrap('write_file', [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: visualsReprovado() } }]);
+      return fim();
+    }
+    if (phase === 'assembly') {
+      // ADR-028: as 7 pecas na RAIZ ANTES do artefato (o veto render-png as exige em disco).
+      const nx = proximaPeca(convo);
+      if (nx) return wrap('write_file', [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: piecePath(nx), content: pecaHtml(nx) } }]);
+      if (!/escrito: artifacts\/assembly\.md/.test(convo)) return wrap('write_file', [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/assembly.md', content: assemblyArtifact() } }]);
+      return fim();
+    }
+    return fim();
+  };
+  const imageTransport = async () => { imageApiCalls++; return { choices: [{ message: { images: [{ image_url: { url: PNG_1X1 } }] } }] }; };
+
+  const runsRoot = tmpDir('runs-guided');
+  const payload = { pod: 'content-carousel', workflow: 'wf-content-carousel', fetch_allow_hosts: [], article_url: 'https://example.com/a' };
+  const logs = [];
+  const run = exec.setupRun({ bundleDir, lockOverride: lockPath, payload, deps: { callModel, imageTransport }, log: (msg) => logs.push(msg) });
+  const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const { ctx } = motor.startRun({ workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, pod: run.pod, workflow: run.workflow, runsRoot, runId: 'guided-1', memoryPodDir });
+  const r = await driveAlemDoGateDeTexto(ctx, run);
+
+  // --- AC1: a tentativa 2 CONTINUOU a conversa, não recomeçou ---
+  const visuals = calls.filter((c) => c.phase === 'visuals');
+  const guiada = visuals.filter((c) => c.recebeuCorrecao);
+  assert(visuals[0].msgs === 1, `AC1: a 1ª tentativa de visuals nasce com conversa VAZIA (messages=${visuals[0].msgs})`);
+  assert(guiada.length > 0 && guiada[0].msgs > 1,
+    `AC1: a tentativa guiada RETOMA a conversa (${guiada.length > 0 ? guiada[0].msgs : 0} mensagens, não 1) — messages cresce, não reinicia`);
+  assert(!visuals.some((c) => c.msgs === 1 && c.recebeuCorrecao), 'AC1: nenhuma correção é entregue numa conversa reconstruída do zero');
+
+  // --- AC5: as failures[] REAIS do motor, LITERAIS, chegaram ao modelo (nunca paráfrase) ---
+  const vetoLog = logs.find((l) => /\[visuals\] VETO DISPAROU/.test(l));
+  assert(Boolean(vetoLog), 'AC4: o veto de máquina REPROVOU a 1ª tentativa (referencia_copiada: sim)');
+  const falhaLiteral = vetoLog.slice(vetoLog.indexOf('):') + 3).trim();
+  assert(falhaLiteral.length > 0 && guiada[0].textoRecebido.includes(falhaLiteral),
+    `AC5: a falha REAL do motor viajou LITERAL até o modelo, no texto que ele recebeu ("${falhaLiteral.slice(0, 60)}...")`);
+  assert(/veredito LITERAL da máquina/.test(guiada[0].textoRecebido) && guiada[0].textoRecebido.includes(`- ${falhaLiteral}`),
+    'AC5: a falha aparece como item do veredito da máquina, sem reescrita (nenhuma paráfrase substitui o oráculo)');
+  assert(logs.some((l) => l.includes('entregue ao modelo (literal)') && l.includes(falhaLiteral)),
+    'AC5: o log do run registra, verbatim, a falha entregue ao modelo (auditável depois do fato)');
+  assert(/veto\.assertions\[\d+\]/.test(falhaLiteral), `AC5: o veredito é o do motor, com a forma que ELE emite (${falhaLiteral.slice(0, 40)})`);
+
+  // --- AC1(ii): o diff do FIXER (SF10.11) é insumo da mensagem de correção ---
+  assert(guiada[0].convo.includes('Correções mecânicas JÁ APLICADAS'),
+    'AC1(ii): o diff do fixer da SF10.11 entra na mensagem de correção (senão o modelo reescreve por cima)');
+  assert(Array.isArray(r.fixes) && r.fixes.some((f) => f.step === 'visuals'), `AC1(ii): houve fixer nesta tentativa (${JSON.stringify(r.fixes)})`);
+
+  // --- AC1(iii): ordem de EDITAR, não refazer ---
+  assert(/EDITE, não refaça/.test(guiada[0].convo) && /menor alteração possível/.test(guiada[0].convo),
+    'AC1(iii): a ordem explícita é EDITAR o que existe, não refazer a fase');
+
+  // --- AC3: ZERO openrouter_image na tentativa guiada (três oráculos independentes) ---
+  const trailLogs = logs.filter((l) => /\[visuals\] \d+ turns, tools=/.test(l));
+  assert(trailLogs.length === 2, `AC3: visuals rodou 2 tentativas (${trailLogs.length}) — a 1ª reprovada, a 2ª guiada`);
+  assert(/openrouter_image/.test(trailLogs[0]), `AC3: a 1ª tentativa GEROU a capa (toolTrail: ${trailLogs[0].trim()})`);
+  assert(!/openrouter_image/.test(trailLogs[1]),
+    `AC3 (ORÁCULO toolTrail): ZERO openrouter_image na tentativa GUIADA (toolTrail: ${trailLogs[1].trim()})`);
+  assert(!guiada.some((c) => c.emitiu === 'openrouter_image'), 'AC3: o modelo, vendo a imagem já confirmada na conversa, não pediu para regerá-la');
+  assert(imageApiCalls === 1, `AC3 (ORÁCULO DE DINHEIRO): o transport do OpenRouter foi chamado UMA vez no run inteiro (${imageApiCalls}) — a reamostragem cega chamaria 2`);
+  assert(r.usage.images === 1, `AC3: usage.images agregado pelo drive confirma 1 imagem no run (${r.usage.images})`);
+
+  // --- AC3: DELTA de input tokens MEDIDO (a conversa acumulada sobe; é o custo declarado) ---
+  const base = visuals[0];
+  const guiadaFirst = guiada[0];
+  const deltaChars = guiadaFirst.chars - base.chars;
+  const deltaTok = guiadaFirst.inTok - base.inTok;
+  console.log(`       [MEDIDO] 1ª tentativa: ${base.chars} chars / ~${base.inTok} tok (${base.msgs} msg) | tentativa guiada: ${guiadaFirst.chars} chars / ~${guiadaFirst.inTok} tok (${guiadaFirst.msgs} msg) | DELTA: +${deltaChars} chars / +${deltaTok} tok (${(guiadaFirst.chars / base.chars).toFixed(2)}x)`);
+  assert(deltaChars > 0 && deltaTok > 0, `AC3: o delta de contexto é POSITIVO e medido (+${deltaChars} chars / +${deltaTok} tok) — o custo da retomada não é escondido`);
+  assert(r.usage.input_tokens > 0 && r.usage.output_tokens > 0, `AC3: os turns de edição somam no usage agregado do run (in=${r.usage.input_tokens}, out=${r.usage.output_tokens})`);
+
+  // --- AC4: o veto rodou DE NOVO sobre a tentativa corrigida e é ele quem liberou a fase ---
+  assert(r.awaiting === 'assembly', `AC4: depois da correção guiada o motor VERIFICOU de novo e a fase avançou (awaiting=${r.awaiting})`);
+  const visualsDisco = fs.readFileSync(path.join(ctx.runDir, 'artifacts', 'visuals.md'), 'utf8');
+  assert(/referencia_copiada: nao/.test(visualsDisco), 'AC4: o artefato EM DISCO é o corrigido — quem aprovou foi o veto de máquina, não o modelo');
+  assert(fs.existsSync(path.join(ctx.runDir, 'assets', 'cover.png')), 'AC3: a capa gerada na 1ª tentativa continua em disco (não foi refeita nem perdida)');
+  void memoryPodDir;
+}
+
+// ===========================================================================
+// SF10.12 AC2 — ZERO LIMITES NOVOS (DF-SF10.12-2). Checagem ESTÁTICA: a correção guiada consome
+// o `MAX_RETRY` que já existe; nenhum 4º limite nasceu ao lado de MAX_TOKENS/MAX_ITERS/MAX_RETRY.
+// ===========================================================================
+
+function noNewLimitsTest() {
+  console.log('\n--- SF10.12 (AC2): zero limites novos no executor (DF-SF10.12-2) ---');
+  const src = fs.readFileSync(path.join(__dirname, 'pod-export-executor.cjs'), 'utf8');
+
+  const numericConsts = [...src.matchAll(/^const\s+([A-Z][A-Z0-9_]*)\s*=\s*(\d+)\s*;/gm)].map((m) => `${m[1]}=${m[2]}`);
+  assert(numericConsts.join(',') === 'MAX_TOKENS=8192,MAX_ITERS=30,MAX_RETRY=3',
+    `AC2: as constantes numéricas do arquivo seguem sendo EXATAMENTE as 3 do Adendo F2 (${numericConsts.join(', ')})`);
+
+  const maxIdents = [...new Set([...src.matchAll(/\bMAX_[A-Z0-9_]+\b/g)].map((m) => m[0]))].sort();
+  assert(maxIdents.join(',') === 'MAX_ITERS,MAX_RETRY,MAX_TOKENS', `AC2: nenhum identificador MAX_* novo no arquivo (${maxIdents.join(', ')})`);
+
+  // O laço que governa tentativas é UM só, e o teto dele é o MAX_RETRY existente.
+  const attemptLoops = [...src.matchAll(/for\s*\(\s*let\s+attempt\s*=\s*1;\s*attempt\s*<=\s*MAX_RETRY;/g)];
+  assert(attemptLoops.length === 1, `AC2: um único laço de tentativas, limitado por MAX_RETRY (${attemptLoops.length})`);
+
+  // Nenhuma estrutura de repetição nova no arquivo: a correção guiada é uma MENSAGEM a mais dentro
+  // do laço que já existia, não um laço de refino próprio.
+  const loopStatements = (src.match(/^\s*(for|while)\s*\(/gm) || []).length;
+  assert(loopStatements === 9, `AC2: o arquivo mantém 9 laços de statement (contagem pré-SF10.12) — nenhum laço de refino nasceu (${loopStatements})`);
+
+  // O corpo de `drive` não ganhou contador próprio de edições guiadas.
+  const driveSrc = src.slice(src.indexOf('async function drive('));
+  const driveBody = driveSrc.slice(0, driveSrc.indexOf('\n// ---'));
+  assert(!/\b(guidedCount|refineCount|criticCount|editCount|MAX_[A-Z]+\s*=)/.test(driveBody), 'AC2: `drive` não tem contador nem teto próprio de correções guiadas');
+  assert(/MAX_RETRY - 1|MAX_RETRY-1|attempt < MAX_RETRY/.test(driveBody),
+    'AC2: o número de edições guiadas é DERIVADO de MAX_RETRY (auditável), nunca declarado');
+}
+
+// ===========================================================================
+// SF10.12 AC8 — `resume` CAI no comportamento atual. A conversa guiada vive em MEMÓRIA DE PROCESSO
+// (limite DECLARADO em DF-SF10.12-1, nunca descoberto em produção): depois de um crash, a fase
+// recomeça com `buildUserContent` fresco, sem convergência herdada.
+// ===========================================================================
+
+async function resumeFallbackTest() {
+  console.log('\n--- SF10.12 (AC8): resume cai no comportamento atual (conversa não sobrevive ao processo) ---');
+  const { bundleDir, lockPath } = await compileFixtureBundle('resume');
+  const runsRoot = tmpDir('runs-resume');
+  const payload = { pod: 'content-carousel', workflow: 'wf-content-carousel', fetch_allow_hosts: [], article_url: 'https://example.com/a' };
+
+  // FASE 1 — o processo que morre: visuals reprova em TODAS as tentativas (MAX_RETRY esgotado).
+  const preCrash = [];
+  const callModelFail = async ({ messages }) => {
+    const first = messages[0].content;
+    const phase = (/fase (\w+)/.exec(typeof first === 'string' ? first : JSON.stringify(first)) || [])[1] || 'unknown';
+    const convo = JSON.stringify(messages);
+    preCrash.push({ phase, msgs: messages.length, recebeuCorrecao: /VERIFICAÇÃO DE MÁQUINA REPROVOU/.test(convo) });
+    const usage = { input_tokens: 10, output_tokens: 5 };
+    const tuId = `${phase}-${preCrash.length}`;
+    if (phase === 'digest' && !/escrito: artifacts\/digest\.md/.test(convo)) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/digest.md', content: digestArtifact() } }], usage };
+    if (phase === 'visuals') {
+      const iCorr = convo.lastIndexOf('VERIFICAÇÃO DE MÁQUINA REPROVOU');
+      const iWrite = convo.lastIndexOf('escrito: artifacts/visuals.md');
+      // Teimoso de propósito: mesmo guiado, insiste no artefato reprovado. Esgota o MAX_RETRY.
+      if (iWrite < 0 || iCorr > iWrite) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: visualsReprovado() } }], usage };
+    }
+    return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }], usage };
+  };
+  const imageTransport = async () => ({ choices: [{ message: { images: [{ image_url: { url: PNG_1X1 } }] } }] });
+  const logs1 = [];
+  const run1 = exec.setupRun({ bundleDir, lockOverride: lockPath, payload, deps: { callModel: callModelFail, imageTransport }, log: (m) => logs1.push(m) });
+  const mem1 = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const { ctx } = motor.startRun({ workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, pod: run1.pod, workflow: run1.workflow, runsRoot, runId: 'resume-1', memoryPodDir: mem1 });
+  const r1 = await driveAlemDoGateDeTexto(ctx, run1);
+  assert(r1.blocked === 'visuals', `AC8 (cenário): a fase esgotou MAX_RETRY e ficou bloqueada (${JSON.stringify(r1.blocked)})`);
+  assert(preCrash.some((c) => c.phase === 'visuals' && c.recebeuCorrecao && c.msgs > 1),
+    'AC8 (contraste): DENTRO do processo, as tentativas 2 e 3 receberam correção guiada em conversa retomada');
+  const guiadasPreCrash = preCrash.filter((c) => c.phase === 'visuals' && c.recebeuCorrecao && c.msgs > 1).length;
+  assert(guiadasPreCrash >= 1, `AC2 (derivado): houve edição guiada dentro do teto de MAX_RETRY (${guiadasPreCrash} chamada(s) guiada(s))`);
+
+  // FASE 2 — o CRASH: o processo morre e leva a conversa junto. `resume` abre o state DO DISCO com
+  // um `drive` novinho; nada da conversa anterior existe para ser retomado.
+  const posResume = [];
+  const callModelOk = async ({ messages }) => {
+    const first = messages[0].content;
+    const phase = (/fase (\w+)/.exec(typeof first === 'string' ? first : JSON.stringify(first)) || [])[1] || 'unknown';
+    const convo = JSON.stringify(messages);
+    posResume.push({ phase, msgs: messages.length, first: typeof first === 'string' ? first : '', recebeuCorrecao: /VERIFICAÇÃO DE MÁQUINA REPROVOU/.test(convo) });
+    const usage = { input_tokens: 10, output_tokens: 5 };
+    const tuId = `r-${phase}-${posResume.length}`;
+    if (phase === 'visuals' && !/escrito: artifacts\/visuals\.md/.test(convo)) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: visualsArtifact() } }], usage };
+    if (phase === 'assembly') {
+      // ADR-028: as 7 pecas na RAIZ ANTES do artefato (veto render-png).
+      const nx = proximaPeca(convo);
+      if (nx) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: piecePath(nx), content: pecaHtml(nx) } }], usage };
+      if (!/escrito: artifacts\/assembly\.md/.test(convo)) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/assembly.md', content: assemblyArtifact() } }], usage };
+    }
+    return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }], usage };
+  };
+  const statePath = motor.findStateByRunId(runsRoot, 'resume-1');
+  assert(Boolean(statePath), 'AC8: o state do run sobreviveu em disco (é a única coisa que sobrevive)');
+  const logs2 = [];
+  const run2 = exec.setupRun({ bundleDir, lockOverride: lockPath, payload, deps: { callModel: callModelOk, imageTransport }, log: (m) => logs2.push(m) });
+  const mem2 = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const ctx2 = motor.openRun({ statePath, workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, memoryPodDir: mem2 });
+  const r2 = await exec.drive(ctx2, run2, {});
+
+  const primeiraPosResume = posResume.find((c) => c.phase === 'visuals');
+  assert(Boolean(primeiraPosResume) && primeiraPosResume.msgs === 1,
+    `AC8: depois do resume a fase RECOMEÇA com conversa de 1 mensagem (${primeiraPosResume && primeiraPosResume.msgs}) — nada de conversa retomada`);
+  assert(/^# RODADA — fase visuals/.test(primeiraPosResume.first),
+    'AC8: o conteúdo é o `buildUserContent` FRESCO (contrato da fase), o comportamento pré-SF10.12');
+  assert(!primeiraPosResume.recebeuCorrecao && !/Correções mecânicas JÁ APLICADAS/.test(primeiraPosResume.first),
+    'AC8: nenhuma correção guiada é reconstruída a partir do disco — a promessa NÃO atravessa a retomada');
+  assert(r2.awaiting === 'assembly', `AC8: o resume segue funcionando pelo caminho normal (awaiting=${r2.awaiting})`);
+  assert(!logs2.some((l) => /CORREÇÃO GUIADA/.test(l) && /visuals/.test(l)) || posResume.filter((c) => c.phase === 'visuals')[0].msgs === 1,
+    'AC8: a 1ª tentativa pós-resume não é guiada (a correção só existe depois de um veto NESTE processo)');
+  void mem2;
+}
+
+// ===========================================================================
+// SF10.12 — `appendUserTurn`: a retomada NÃO pode quebrar a alternância de papéis da Messages API
+// (uma fase que para em MAX_ITERS deixa a conversa terminando em `user`/tool_results).
+// ===========================================================================
+
+function appendUserTurnTest() {
+  console.log('\n--- SF10.12: retomada preserva a alternância de papéis da Messages API ---');
+  const base = [{ role: 'user', content: 'contrato' }, { role: 'assistant', content: [{ type: 'text', text: 'pronto' }] }];
+  const a = exec.appendUserTurn(base, 'CORRIJA');
+  assert(a.length === 3 && a[2].role === 'user' && a[2].content === 'CORRIJA', 'conversa terminando em `assistant`: a correção vira um turn `user` novo');
+  assert(base.length === 2, 'appendUserTurn é NÃO-MUTANTE (a conversa anterior é evidência de auditoria)');
+
+  const terminandoEmUser = base.concat([{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'x', content: [{ type: 'text', text: 'escrito' }] }] }]);
+  const b = exec.appendUserTurn(terminandoEmUser, 'CORRIJA');
+  assert(b.length === 3, 'conversa terminando em `user` (tool_results de MAX_ITERS): nenhuma mensagem `user` consecutiva é criada');
+  assert(b[2].role === 'user' && b[2].content.length === 2 && b[2].content[1].text === 'CORRIJA',
+    'a correção entra como bloco DENTRO do turn `user` existente (a API rejeitaria dois `user` seguidos)');
+  assert(terminandoEmUser[2].content.length === 1, 'o turn original não foi mutado');
+
+  const roles = b.map((x) => x.role).join(',');
+  assert(roles === 'user,assistant,user', `alternância preservada (${roles})`);
+}
+
+// ===========================================================================
+// SF10.19 — PROVENIÊNCIA BLOQUEIA AQUI (ADR-018 Adendo F6-b, DF-SF10.19-2/e2 e /e3).
+//
+// A invariante que a SF10.8 fiou como `command_check` no `wf-*.yaml` MUDOU DE HOSPEDEIRO: o mesmo
+// yaml é consumido por dois drivers e o de dev (`pc-run-pod.cjs`) não confina a superfície de
+// tools, logo lá a premissa dela é insatisfazível (DF-SF10.19-0). Ela não perdeu força — passou a
+// ser asserida in-process pelo EXECUTOR, antes de `motor.advance`, com HALT do run.
+//
+// O QUE ESTA SEÇÃO PROVA (é a metade "o export continua bloqueando" da story):
+//   (AC3) o run é RECUSADO quando: imagem em `assets/` fora do ledger; arquivo em `inputs/`
+//         divergente do sha registrado; entrada registrada sumida do disco; fase que declara o
+//         veto sem imagem produzida (não-vacuidade);
+//   (AC3) e isso vale em `run`, em `resume` E na TENTATIVA GUIADA da SF10.12 — os três caminhos;
+//   (AC3) pelo menos um cenário CONTORNA a camada 1 de INTEG-1 (escrita direta com `fs`);
+//   (AC3) HALT NÃO consome `MAX_RETRY`: a fase não é re-executada depois da violação;
+//   (AC4) a mensagem diz o que foi violado, qual arquivo e o que fazer;
+//   (inércia) pod SEM o veto declarado não passa a exigir ledger — nenhuma regressão nos demais.
+// ===========================================================================
+
+/** Cópia do pod-fixture com o `command_check` do phash-gate declarado em `visuals` (wiring REAL). */
+function podWithPhashVeto(label) {
+  const podDir = tmpDir(`pod-${label}`);
+  fs.cpSync(FIXTURE_POD, podDir, { recursive: true });
+  const wfPath = path.join(podDir, 'workflows', 'wf-content-carousel.yaml');
+  const lines = fs.readFileSync(wfPath, 'utf8').split('\n');
+  const i = lines.findIndex((l) => /field: referencia_copiada/.test(l));
+  if (i < 0) throw new Error('fixture inesperada: assertion referencia_copiada não encontrada no wf');
+  lines.splice(i + 1, 0, '        - { type: command_check, command: "phash-gate.cjs", args: ["--refs-dir", "../inputs", "--assets-dir", "../assets"], timeout_ms: 120000, _sources: "fixture SF10.19: reproduz o wiring REAL da etapa visuals do hn-carousel" }');
+  fs.writeFileSync(wfPath, lines.join('\n'));
+  return podDir;
+}
+
+const REF_PNG = path.join(REPO_ROOT, 'scripts', '__fixtures__', 'veto-checks', 'phash', 'ref.png');
+const OTHER_PNG = path.join(REPO_ROOT, 'scripts', '__fixtures__', 'veto-checks', 'phash', 'copy.png');
+
+/** Arranca um run REAL (motor + compilador reais) do pod com o veto declarado, inputs materializados. */
+async function startPhashRun(label, callModel, { runId = `prov-${label}` } = {}) {
+  const podDir = podWithPhashVeto(label);
+  const bundleDir = tmpDir(`bundle-${label}`);
+  const lockPath = path.join(tmpDir(`lockout-${label}`), 'export.lock.json');
+  const { bundleFiles, lock } = await compiler.compile(podDir, { checkEndpoint: false });
+  compiler.writeBundle(bundleDir, bundleFiles);
+  fs.writeFileSync(lockPath, compiler.serializeLock(lock));
+
+  const inputsDir = tmpDir(`inputs-${label}`);
+  fs.copyFileSync(REF_PNG, path.join(inputsDir, 'ref-pinterest.png'));
+
+  const imageTransport = async () => ({ choices: [{ message: { images: [{ image_url: { url: PNG_1X1 } }] } }] });
+  const runsRoot = tmpDir(`runs-${label}`);
+  const payload = { pod: 'content-carousel', workflow: 'wf-content-carousel', fetch_allow_hosts: [], article_url: 'https://example.com/a', inputs_dir: inputsDir };
+  const logs = [];
+  const run = exec.setupRun({ bundleDir, lockOverride: lockPath, payload, deps: { callModel, imageTransport }, log: (m) => logs.push(m) });
+  const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const { ctx } = motor.startRun({ workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, pod: run.pod, workflow: run.workflow, runsRoot, runId, memoryPodDir });
+  exec.materializeInputs({ bundleRoot: run.bundleRoot, inputsDir: run.inputsDir, runDir: ctx.runDir, log: run.log });
+  return { ctx, run, logs, runsRoot, bundleDir, lockPath, inputsDir, payload, imageTransport, runId };
+}
+
+/** Roda `drive` capturando o HALT (a asserção LANÇA — é assim que ela interrompe o run). */
+async function driveCapturandoHalt(ctx, run) {
+  try { const r = await driveAlemDoGateDeTexto(ctx, run); return { erro: null, resultado: r }; }
+  catch (e) { return { erro: e, resultado: null }; }
+}
+
+/** Quantas TENTATIVAS a fase teve (uma linha de toolTrail por tentativa) — oráculo do MAX_RETRY. */
+function tentativasDe(logs, step) {
+  return logs.filter((l) => new RegExp(`\\[${step}\\] \\d+ turns, tools=`).test(l)).length;
+}
+
+/**
+ * Modelo mockado padrão da fase `visuals`: gera a capa, escreve o artefato. `tamper` (opcional) é
+ * chamado ANTES do artefato ser escrito — é onde o cenário adultera o run por fora das tools.
+ */
+function modeloVisuals({ getRunDir, tamper = null, artefato = visualsArtifact, gerarImagem = true, tamperNaGuiada = false }) {
+  return async ({ messages }) => {
+    const first = messages[0].content;
+    const phase = (/fase (\w+)/.exec(typeof first === 'string' ? first : JSON.stringify(first)) || [])[1] || 'unknown';
+    const convo = JSON.stringify(messages);
+    const usage = { input_tokens: 10, output_tokens: 5 };
+    const tuId = `${phase}-${Math.random().toString(36).slice(2, 8)}`;
+    const guiada = /VERIFICAÇÃO DE MÁQUINA REPROVOU/.test(convo);
+    if (phase === 'digest') {
+      if (!/escrito: artifacts\/digest\.md/.test(convo)) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/digest.md', content: digestArtifact() } }], usage };
+      return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }], usage };
+    }
+    if (phase === 'visuals') {
+      if (gerarImagem && !/imagem salva: assets\/cover\.png/.test(convo)) {
+        return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'openrouter_image', input: { prompt: 'capa', out_path: 'assets/cover.png' } }], usage };
+      }
+      const iCorr = convo.lastIndexOf('VERIFICAÇÃO DE MÁQUINA REPROVOU');
+      const iWrite = convo.lastIndexOf('escrito: artifacts/visuals.md');
+      if (iWrite < 0 || iCorr > iWrite) {
+        // ADULTERAÇÃO: escrita DIRETA com `fs`, contornando a camada 1 (denylist das tools). É o
+        // cenário em que a camada 2 tem de segurar sozinha — herdado de INTEG-1.
+        if (tamper && (!tamperNaGuiada || guiada)) tamper(getRunDir());
+        const conteudo = typeof artefato === 'function' ? artefato({ guiada }) : artefato;
+        return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: conteudo } }], usage };
+      }
+      return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }], usage };
+    }
+    if (phase === 'assembly') {
+      // ADR-028: as 7 pecas na RAIZ ANTES do artefato (veto render-png).
+      const nx = proximaPeca(convo);
+      if (nx) return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: piecePath(nx), content: pecaHtml(nx) } }], usage };
+      if (!/escrito: artifacts\/assembly\.md/.test(convo)) {
+        return { stop_reason: 'tool_use', content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/assembly.md', content: assemblyArtifact() } }], usage };
+      }
+    }
+    return { stop_reason: 'end_turn', content: [{ type: 'text', text: 'ok' }], usage };
+  };
+}
+
+function provenanceUnitTests() {
+  console.log('\n--- SF10.19 (AC2): checagem canônica em pod-export-tools.cjs (implementação ÚNICA) ---');
+  const runDir = tmpDir('prov-unit');
+  assert(tools.checkRunProvenance({ runDir }).ok === true,
+    'run vazio, sem ledger: NADA a verificar → passa (a mudança é INERTE para pods sem imagem)');
+
+  fs.mkdirSync(path.join(runDir, 'assets'), { recursive: true });
+  fs.copyFileSync(REF_PNG, path.join(runDir, 'assets', 'intrusa.png')); // por fora das tools
+  const semLedger = tools.checkRunProvenance({ runDir });
+  assert(semLedger.ok === false && /AUSENTE/.test(semLedger.violations.join(' ')),
+    'imagem em assets/ SEM ledger nenhum → violação (nunca "sem ledger, logo tudo bem")');
+
+  tools.recordProvenance(runDir, 'assets', path.join(runDir, 'assets', 'intrusa.png'), { source: 'openrouter_image' });
+  assert(tools.checkRunProvenance({ runDir }).ok === true, 'a mesma imagem, registrada, passa');
+
+  fs.copyFileSync(OTHER_PNG, path.join(runDir, 'assets', 'intrusa.png')); // bytes trocados depois
+  const div = tools.checkRunProvenance({ runDir });
+  assert(div.ok === false && /DIVERGE/.test(div.violations.join(' ')), 'bytes trocados depois do registro → DIVERGE');
+
+  const rd2 = tmpDir('prov-unit2');
+  fs.writeFileSync(tools.provenancePathFor(rd2), '{ quebrado', 'utf8');
+  const ileg = tools.checkRunProvenance({ runDir: rd2 });
+  assert(ileg.ok === false && /ILEGÍVEL/.test(ileg.violations.join(' ')),
+    'ledger que EXISTE e está quebrado → violação mesmo com os diretórios vazios (nunca decidir por cima dele)');
+  fs.writeFileSync(tools.provenancePathFor(rd2), JSON.stringify({ version: 99 }), 'utf8');
+  assert(tools.checkRunProvenance({ runDir: rd2 }).ok === false, 'ledger de versão desconhecida → violação');
+
+  const rd3 = tmpDir('prov-unit3');
+  const vac = tools.checkRunProvenance({ runDir: rd3, requireNonVacuous: true, stepId: 'visuals' });
+  assert(vac.ok === false && /NENHUMA referência/.test(vac.violations.join(' ')) && /visuals/.test(vac.violations.join(' ')),
+    'NÃO-VACUIDADE: fase que declara o veto sem referência materializada → violação nomeando a fase');
+  assert(tools.checkRunProvenance({ runDir: rd3 }).ok === true,
+    'e a MESMA situação, numa fase que NÃO declara o veto, passa (a não-vacuidade é por-fase, não global)');
+
+  let lancou = null;
+  try { tools.assertRunProvenance({ runDir: rd3, requireNonVacuous: true, stepId: 'visuals' }); } catch (e) { lancou = e; }
+  assert(lancou && /PROVENIÊNCIA VIOLADA/.test(lancou.message) && /HALTADO/.test(lancou.message),
+    'AC4: assertRunProvenance LANÇA (o HALT) com a violação nomeada');
+  assert(lancou && /openrouter_image/.test(lancou.message) && /inputs\/" é PROIBIDO|inputs\/. é PROIBIDO/.test(lancou.message),
+    'AC4: a mensagem diz O QUE FAZER (gravar em assets/ com openrouter_image; escrever em inputs/ é proibido)');
+}
+
+async function provenanceHaltRunTest() {
+  console.log('\n--- SF10.19 (AC3/AC4): `run` — asset fora do ledger (camada 1 CONTORNADA) HALTA o run ---');
+  let runDirRef = null;
+  const tamper = (runDir) => { fs.copyFileSync(OTHER_PNG, path.join(runDir, 'assets', 'intrusa.png')); };
+  const h = await startPhashRun('halt-run', modeloVisuals({ getRunDir: () => runDirRef, tamper }));
+  runDirRef = h.ctx.runDir;
+  const { erro, resultado } = await driveCapturandoHalt(h.ctx, h.run);
+
+  assert(Boolean(erro), `AC3: o run foi INTERROMPIDO (não devolveu resultado: ${JSON.stringify(resultado)})`);
+  assert(erro && /PROVENIÊNCIA VIOLADA/.test(erro.message) && /visuals/.test(erro.message),
+    'AC3: o HALT nomeia a invariante e a fase');
+  assert(erro && /intrusa\.png/.test(erro.message) && /NÃO consta do registro/.test(erro.message),
+    `AC4: a mensagem nomeia O ARQUIVO e o que foi violado (${(erro && erro.message || '').slice(0, 120)}…)`);
+  assert(erro && /não altere\s+arquivos do run por fora das tools|openrouter_image/.test(erro.message),
+    'AC4: a mensagem é acionável (o que fazer), nunca erro genérico');
+  assert(fs.existsSync(path.join(h.ctx.runDir, 'assets', 'intrusa.png')),
+    'sanidade: a imagem intrusa REALMENTE entrou por fora das tools (camada 1 contornada com `fs`)');
+  assert(tentativasDe(h.logs, 'visuals') === 1,
+    `AC3/e3: HALT NÃO consome MAX_RETRY — a fase rodou 1 vez, não 3 (${tentativasDe(h.logs, 'visuals')})`);
+  assert(!h.logs.some((l) => /VETO DISPAROU/.test(l)),
+    'AC3/e3: a violação NÃO foi tratada como reprovação de veto (nada de correção guiada sobre adulteração)');
+  const st = motor.readState(h.ctx.statePath);
+  assert(st.steps.visuals.status === 'running',
+    `AC3: a fase NÃO avançou (status=${st.steps.visuals.status}) — o HALT acontece ANTES de motor.advance`);
+}
+
+async function provenanceHaltVariantsTest() {
+  console.log('\n--- SF10.19 (AC3): as demais classes de violação, cada uma HALTANDO ---');
+  // (a) referência em inputs/ trocada por fora das tools → DIVERGE.
+  {
+    let rd = null;
+    const tamper = (runDir) => { fs.copyFileSync(OTHER_PNG, path.join(runDir, 'inputs', 'ref-pinterest.png')); };
+    const h = await startPhashRun('halt-div', modeloVisuals({ getRunDir: () => rd, tamper }));
+    rd = h.ctx.runDir;
+    const { erro } = await driveCapturandoHalt(h.ctx, h.run);
+    assert(erro && /DIVERGE do sha256 registrado/.test(erro.message) && /ref-pinterest\.png/.test(erro.message),
+      'AC3: referência SUBSTITUÍDA depois de materializada → HALT por divergência de sha256 (camada 2 sozinha)');
+  }
+  // (b) entrada registrada apagada do disco → AUSENTE.
+  {
+    let rd = null;
+    const tamper = (runDir) => { fs.rmSync(path.join(runDir, 'assets', 'cover.png')); };
+    const h = await startPhashRun('halt-sumiu', modeloVisuals({ getRunDir: () => rd, tamper }));
+    rd = h.ctx.runDir;
+    const { erro } = await driveCapturandoHalt(h.ctx, h.run);
+    assert(erro && /AUSENTE em disco/.test(erro.message) && /cover\.png/.test(erro.message),
+      'AC3: entrada registrada que SUMIU do disco → HALT (o ledger não pode afirmar o que não existe)');
+  }
+  // (c) NÃO-VACUIDADE: a fase declara o veto e não produziu imagem nenhuma.
+  {
+    const h = await startPhashRun('halt-vacuo', modeloVisuals({ getRunDir: () => null, gerarImagem: false }));
+    const { erro } = await driveCapturandoHalt(h.ctx, h.run);
+    assert(erro && /NENHUMA imagem registrada/.test(erro.message) && /vacuidade/.test(erro.message),
+      'AC3: fase que declara o veto sem imagem produzida → HALT (a não-vacuidade que o exit 3 dava de graça não sumiu)');
+    assert(tentativasDe(h.logs, 'visuals') === 1, 'AC3/e3: também aqui o HALT não consome tentativa');
+  }
+}
+
+async function provenanceHaltGuidedTest() {
+  console.log('\n--- SF10.19 (AC3): TENTATIVA GUIADA (SF10.12) também atravessa a asserção ---');
+  let rd = null;
+  const tamper = (runDir) => { fs.copyFileSync(OTHER_PNG, path.join(runDir, 'assets', 'intrusa.png')); };
+  // 1ª tentativa: artefato REPROVADO pelo veto (referencia_copiada: sim), SEM adulteração.
+  // Tentativa GUIADA: escreve o artefato bom E adultera — a violação nasce dentro do caminho da SF10.12.
+  const h = await startPhashRun('halt-guiada', modeloVisuals({
+    getRunDir: () => rd,
+    tamper,
+    tamperNaGuiada: true,
+    artefato: ({ guiada }) => (guiada ? visualsArtifact() : visualsReprovado()),
+  }));
+  rd = h.ctx.runDir;
+  const { erro } = await driveCapturandoHalt(h.ctx, h.run);
+  assert(h.logs.some((l) => /\[visuals\] VETO DISPAROU/.test(l)),
+    'cenário: a 1ª tentativa foi reprovada pelo veto de conteúdo (é o que produz a tentativa guiada)');
+  assert(h.logs.some((l) => /CORREÇÃO GUIADA/.test(l)), 'cenário: a 2ª tentativa É a guiada (conversa retomada, SF10.12)');
+  assert(erro && /PROVENIÊNCIA VIOLADA/.test(erro.message) && /intrusa\.png/.test(erro.message),
+    'AC3: a adulteração feita NA TENTATIVA GUIADA é pega — o caminho da SF10.12 não escapa da asserção');
+  assert(tentativasDe(h.logs, 'visuals') === 2,
+    `AC3/e3: o run parou na 2ª tentativa; a 3ª (que MAX_RETRY ainda permitia) NÃO rodou (${tentativasDe(h.logs, 'visuals')})`);
+}
+
+async function provenanceHaltResumeTest() {
+  console.log('\n--- SF10.19 (AC3): `resume` — a asserção vale no caminho de retomada ---');
+  // Fase 1: o modelo é teimoso e esgota MAX_RETRY (sem adulterar) → run BLOQUEADO, sem HALT.
+  const h = await startPhashRun('halt-resume', modeloVisuals({ getRunDir: () => null, artefato: () => visualsReprovado() }));
+  const r1 = await driveAlemDoGateDeTexto(h.ctx, h.run);
+  assert(r1.blocked === 'visuals',
+    `cenário: sem violação de proveniência, o veto de conteúdo se comporta como sempre (blocked=${JSON.stringify(r1.blocked)})`);
+  assert(tentativasDe(h.logs, 'visuals') === 3, 'cenário: as 3 tentativas do MAX_RETRY foram gastas (contraste com o HALT)');
+  assert(!h.logs.some((l) => /phash-gate/.test(l) && /bloqueou/i.test(l)),
+    'AC5 no caminho REAL do export: o blessed phash-gate rodou pelo motor e NÃO bloqueou nada');
+
+  // Fase 2: RESUME (openRun + drive novo, conversa não sobrevive) com adulteração.
+  const statePath = motor.findStateByRunId(h.runsRoot, h.runId);
+  const logs2 = [];
+  let rd = null;
+  const tamper = (runDir) => { fs.copyFileSync(OTHER_PNG, path.join(runDir, 'assets', 'intrusa.png')); };
+  const run2 = exec.setupRun({
+    bundleDir: h.bundleDir, lockOverride: h.lockPath, payload: h.payload,
+    deps: { callModel: modeloVisuals({ getRunDir: () => rd, tamper }), imageTransport: h.imageTransport },
+    log: (m) => logs2.push(m),
+  });
+  const mem2 = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+  const ctx2 = motor.openRun({ statePath, workflowPath: path.join(h.bundleDir, 'workflow.yaml'), podRootOverride: h.bundleDir, memoryPodDir: mem2 });
+  rd = ctx2.runDir;
+  exec.materializeInputs({ bundleRoot: run2.bundleRoot, inputsDir: run2.inputsDir, runDir: ctx2.runDir, log: run2.log });
+  const { erro } = await driveCapturandoHalt(ctx2, run2);
+  assert(erro && /PROVENIÊNCIA VIOLADA/.test(erro.message) && /intrusa\.png/.test(erro.message),
+    'AC3: no `resume` a asserção também roda — nenhum comando entrega uma fase sem asserir');
+  assert(tentativasDe(logs2, 'visuals') === 1, 'AC3/e3: HALT no resume também não consome MAX_RETRY');
+}
+
+async function provenanceHappyPathTest() {
+  console.log('\n--- SF10.19 (não-regressão): com o veto declarado e tudo íntegro, o run ANDA ---');
+  const h = await startPhashRun('feliz', modeloVisuals({ getRunDir: () => null }));
+  const r = await driveAlemDoGateDeTexto(h.ctx, h.run);
+  assert(r.awaiting === 'assembly', `o run atravessa visuals e chega ao checkpoint (awaiting=${r.awaiting})`);
+  assert(tentativasDe(h.logs, 'visuals') === 1, 'nenhum falso-positivo: visuals passou na 1ª tentativa');
+  const art = fs.readFileSync(path.join(h.ctx.runDir, 'artifacts', 'visuals.md'), 'utf8');
+  assert(/pc:medida-similaridade:inicio/.test(art) && /NAO verifica PROVENIENCIA/.test(art),
+    'o bloco de MEDIDA do blessed está no artefato e declara o que ele não verifica (AC10, também no export)');
+  const led = JSON.parse(fs.readFileSync(tools.provenancePathFor(h.ctx.runDir), 'utf8'));
+  assert(Object.keys(led.inputs).length === 1 && Object.keys(led.assets).length === 1,
+    'o ledger tem a referência materializada e a imagem gerada (as duas pontas registradas por código)');
+  assert(tools.checkRunProvenance({ runDir: h.ctx.runDir, requireNonVacuous: true, stepId: 'visuals' }).ok === true,
+    'e a checagem canônica confirma o run íntegro (inclusive não-vacuidade)');
+}
+
+// ===========================================================================
+// SF10.19 (AC3/risco 1 da story) — ESTÁTICO: nenhum caminho do executor avança fase sem asserir,
+// e nada escreve entre a asserção e `motor.advance`. É a defesa contra a hipótese do QA de que a
+// asserção fosse contornável por ORDEM DE OPERAÇÕES.
+// ===========================================================================
+
+function provenanceWiringStaticTest() {
+  console.log('\n--- SF10.19 (AC3): a asserção está no ÚNICO funil, e nada escreve depois dela ---');
+  const src = fs.readFileSync(path.join(__dirname, 'pod-export-executor.cjs'), 'utf8');
+
+  const chamadas = [...src.matchAll(/tools\.assertRunProvenance\(/g)].length;
+  assert(chamadas === 1, `a asserção é chamada UMA vez, num funil só (${chamadas}) — nada de cópia por comando`);
+
+  // Ela vive em `execPhase`, que TODA tentativa de TODA fase de TODO comando atravessa.
+  const execStart = src.indexOf('async function execPhase(');
+  const execEnd = src.indexOf('function currentState(');
+  const execBody = src.slice(execStart, execEnd);
+  assert(execBody.includes('tools.assertRunProvenance('), 'a asserção vive em `execPhase` (o funil de execução de fase)');
+  assert(!/try\s*{[^}]*assertRunProvenance/s.test(execBody) && !/assertRunProvenance[\s\S]{0,200}catch/.test(execBody),
+    'a asserção NÃO está dentro de try/catch — lançar é o HALT (fail-loud, sem captura silenciosa)');
+
+  // Entre a asserção (fim de execPhase) e `motor.advance` (em drive) não há escrita nem tool.
+  const depois = execBody.slice(execBody.indexOf('tools.assertRunProvenance('));
+  const driveStart = src.indexOf('async function drive(');
+  const driveBody = src.slice(driveStart, src.indexOf('\n// ---', driveStart));
+  const entre = driveBody.slice(driveBody.indexOf('await execPhase('), driveBody.indexOf('motor.advance(ctx)'));
+  const escritas = /fs\.(write|copy|append|mk|rm|rename)|writeFile|openrouterImage|postProcessAttempt|execTool/;
+  assert(!escritas.test(depois.slice(depois.indexOf(');'))) && !escritas.test(entre),
+    'ORDEM: nenhuma escrita/tool entre a asserção e `motor.advance` — não há janela para gravar depois de asserir');
+
+  // `drive` é o único a chamar `execPhase`, e chama `motor.advance` logo depois.
+  const advanceAntesDeExec = driveBody.indexOf('motor.advance(ctx)') > driveBody.indexOf('await execPhase(');
+  assert(advanceAntesDeExec, '`motor.advance` vem DEPOIS de `execPhase` (a verificação do motor segue sendo a última linha)');
+
+  // O HALT não virou um 4º limite (ADR-018 Adendo F2 / DF-SF10.12-2): nenhuma constante nova.
+  assert(!/HALT|halted?Count|provCount|MAX_PROV/.test(src.replace(/\/\*[\s\S]*?\*\/|\/\/.*$/gm, '')),
+    'AC/DF-SF10.12-2: nenhum contador, constante ou estado de "halt" nasceu no código (só a exceção)');
+}
+
+// ---------------------------------------------------------------------------
+// SF11.10/ADR-024 `DF-SF11.10-7` — o RUNTIME DE EXPORT herda o gate de texto, com ZERO
+// linha alterada em pod-export-executor.cjs / pod-export-compile.cjs.
+//
+// Por que este teste existe mesmo sem diff no executor: um comportamento que ninguém
+// escreveu é exatamente o que ninguém testa — e aqui ele MUDA (o serviço passa a parar
+// duas vezes por rodada). A cadeia inteira é de terceiros: `startRun` é chamado SEM
+// `mode` (executor:618) ⇒ default `interactive` ⇒ o gate vale; o `wf` viaja byte a byte
+// no bundle (compile:340) ⇒ o campo novo chega selado no sha.
+// ---------------------------------------------------------------------------
+
+async function exportHerdaGateDeTextoTest() {
+  console.log('\n--- SF11.10/DF-SF11.10-7: export herda o gate de texto (zero linha no executor) ---');
+
+  // SF12.2/ADR-028: até aqui este teste PATCHAVA `checkpoint: null` do wf do template para
+  // fabricar o gate — porque o template ainda não o tinha. A SF12.2 propagou o gate de verdade
+  // (AC2), então o patch foi REMOVIDO: manter um `.replace('checkpoint: null', ...)` agora
+  // acertaria a etapa `visuals` em silêncio e o teste passaria medindo a etapa errada.
+  const podDir = tmpDir('pod-gate');
+  fs.cpSync(FIXTURE_POD, podDir, { recursive: true });
+  const wfPath = path.join(podDir, 'workflows', 'wf-content-carousel.yaml');
+  const wfSrc = fs.readFileSync(wfPath, 'utf8');
+  const wfDoc = validator.parseYaml(wfSrc);
+  const digestStep = wfDoc.steps.find((s) => s.id === 'digest');
+  assert(digestStep.checkpoint && digestStep.checkpoint.blocking === true
+    && Array.isArray(digestStep.checkpoint.skip_modes) && digestStep.checkpoint.skip_modes.includes('yolo'),
+  'pré-condição (SF12.2 AC2): o wf do pod-template JÁ traz o gate de texto em `digest` com skip_modes: ["yolo"] — sem patch de fixture');
+
+  const bundleDir = tmpDir('bundle-gate');
+  const lockPath = path.join(tmpDir('lockout-gate'), 'export.lock.json');
+  const { bundleFiles, lock } = await compiler.compile(podDir, { checkEndpoint: false });
+  compiler.writeBundle(bundleDir, bundleFiles);
+  fs.writeFileSync(lockPath, compiler.serializeLock(lock));
+
+  // O compilador copia o wf BYTE A BYTE — o campo novo viaja selado, sem mudança no compilador.
+  const bundleWf = fs.readFileSync(path.join(bundleDir, 'workflow.yaml'), 'utf8');
+  assert(bundleWf === wfSrc, 'DF-SF11.10-7: o wf com `skip_modes` viaja BYTE A BYTE para o bundle (zero linha no compilador)');
+
+  const png1x1 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
+  const imagensGeradas = [];
+  const turnByPhase = {};
+  const callModel = async ({ messages }) => {
+    const first = messages[0].content;
+    const m = /fase (\w+)/.exec(typeof first === 'string' ? first : JSON.stringify(first));
+    const phase = m ? m[1] : 'unknown';
+    turnByPhase[phase] = (turnByPhase[phase] || 0) + 1;
+    const t = turnByPhase[phase];
+    const tuId = `${phase}-${t}`;
+    const usage = { input_tokens: 10, output_tokens: 5 };
+    if (phase === 'digest') {
+      if (t === 1) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/digest.md', content: digestArtifact() } }] };
+      return { stop_reason: 'end_turn', usage, content: [{ type: 'text', text: 'digest pronto' }] };
+    }
+    if (phase === 'visuals') {
+      if (t === 1) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'openrouter_image', input: { prompt: 'capa', out_path: 'assets/cover.png' } }] };
+      if (t === 2) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'read_image', input: { ref: 'assets/cover.png' } }] };
+      if (t === 3) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: visualsArtifact() } }] };
+      return { stop_reason: 'end_turn', usage, content: [{ type: 'text', text: 'visuals pronto' }] };
+    }
+    if (phase === 'assembly') {
+      // ADR-028: RAIZ do runDir, nomes do pod (o `render-png` da etapa procura ali).
+      if (t <= 7) return { stop_reason: 'max_tokens', usage, content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: piecePath(t), content: pecaHtml(t) } }] };
+      if (t === 8) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/assembly.md', content: assemblyArtifact() } }] };
+      return { stop_reason: 'end_turn', usage, content: [{ type: 'text', text: 'assembly pronto' }] };
+    }
+    return { stop_reason: 'end_turn', usage, content: [{ type: 'text', text: 'noop' }] };
+  };
+  const imageTransport = async (payload) => { imagensGeradas.push(payload.model); return { choices: [{ message: { images: [{ image_url: { url: png1x1 } }] } }] }; };
+
+  const runsRoot = tmpDir('runs-gate');
+  const payload = { pod: 'content-carousel', workflow: 'wf-content-carousel', fetch_allow_hosts: [], article_url: 'https://example.com/a' };
+  const run = exec.setupRun({ bundleDir, lockOverride: lockPath, payload, deps: { callModel, imageTransport }, log: () => {} });
+  const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+
+  // EXATAMENTE como o executor chama (pod-export-executor.cjs:618): SEM `mode`.
+  const { ctx } = motor.startRun({
+    workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir,
+    pod: run.pod, workflow: run.workflow, runsRoot, runId: 'gate-1', memoryPodDir,
+  });
+  assert(ctx.state.mode === 'interactive', 'DF-SF11.10-7: startRun sem `mode` no executor ⇒ default `interactive` ⇒ o gate vale no export');
+
+  const r1 = await exec.drive(ctx, run, {});
+  assert(r1.awaiting === 'digest', `AC15: a run de EXPORT para no gate de TEXTO (awaiting=${r1.awaiting})`);
+  assert(imagensGeradas.length === 0, `AC15: NENHUMA imagem foi gerada antes do gate (imagens=${imagensGeradas.length}) — é o custo que a story existe para evitar`);
+  const disk1 = motor.readState(ctx.statePath);
+  assert(disk1.steps.visuals.status === 'pending' && disk1.steps.visuals.started_at === null,
+    'AC15: a fase cara segue pending/started_at null no instante da parada do export');
+
+  // Retomada pelo caminho REAL do serviço: `approve` (mesma motor.approve do CLI) + `resume`.
+  const statePath = motor.findStateByRunId(runsRoot, 'gate-1');
+  const ctx2 = motor.openRun({ statePath, workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, memoryPodDir });
+  const ap = motor.approve(ctx2);
+  assert(ap.action === 'approved' && ap.step === 'digest', `AC15: approve do export destrava o gate de texto (${ap.action}/${ap.step})`);
+  const r2 = await exec.drive(ctx2, run, {});
+  assert(r2.awaiting === 'assembly', `AC15: o resume atravessa a fase cara e chega ao gate de FECHAMENTO (awaiting=${r2.awaiting})`);
+  assert(imagensGeradas.length >= 1, 'AC15: a imagem só foi gerada DEPOIS da aprovação do texto');
+
+  // Zero linha no executor/compilador: nenhum dos dois conhece o campo novo.
+  const execSrc = fs.readFileSync(path.join(REPO_ROOT, 'scripts', 'pod-export-executor.cjs'), 'utf8');
+  const compSrc = fs.readFileSync(path.join(REPO_ROOT, 'scripts', 'pod-export-compile.cjs'), 'utf8');
+  assert(!execSrc.includes('skip_modes') && !compSrc.includes('skip_modes'),
+    'DF-SF11.10-7: nem o executor nem o compilador citam `skip_modes` — o comportamento novo é herdado, não codificado');
+}
+
+// ---------------------------------------------------------------------------
+// SF12.2/ADR-028 `DF-SF12.2-2` — CONTROLE NEGATIVO DO LUGAR DAS PEÇAS.
+//
+// Este é o caso `pieces/` que este fixture modelava até a SF12.2. Ele NÃO foi apagado quando o
+// mock passou a obedecer a spec: foi INVERTIDO. Um teste que fica verde removendo o caso difícil
+// é pior que o teste vermelho — o harness tem que ganhar oráculo, nunca ponto cego (mesma régua
+// do `aux_files` no smoke, ADR-025 DF-SF11.11-6).
+//
+// O que se prova aqui, e que NENHUM outro teste prova: um agente que escreve as 7 peças fora do
+// lugar declarado pelo pod NÃO fecha a etapa — `assembly` fica `blocked` com a causa nomeada pelo
+// `render-png`, e `awaiting` NUNCA chega ao checkpoint do dono. E que o oráculo tem dentes: com a
+// assertion `render-png` REMOVIDA do wf, o mesmo cenário desobediente passa direto ao checkpoint.
+// ---------------------------------------------------------------------------
+
+async function lugarDasPecasTest() {
+  console.log('\n--- SF12.2/ADR-028: controle negativo do LUGAR das peças (o caso `pieces/`, invertido) ---');
+
+  const png1x1 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
+
+  // Roda o pod (bundle real, motor real, executor real) com o mock escrevendo as 7 peças em
+  // `subdir` — `null` = raiz. `semRenderPng` compila uma variante do pod SEM a assertion.
+  async function rodar({ subdir, semRenderPng, runId }) {
+    const podDir = tmpDir(`pod-lugar-${runId}`);
+    fs.cpSync(FIXTURE_POD, podDir, { recursive: true });
+    const wfPath = path.join(podDir, 'workflows', 'wf-content-carousel.yaml');
+    if (semRenderPng) {
+      const linhas = fs.readFileSync(wfPath, 'utf8').split('\n');
+      const restantes = linhas.filter((l) => !l.includes('command: "render-png.cjs"'));
+      assert(restantes.length === linhas.length - 1, `pré-condição: removeu EXATAMENTE a linha da assertion render-png (${linhas.length - restantes.length})`);
+      fs.writeFileSync(wfPath, restantes.join('\n'), 'utf8');
+    }
+    const bundleDir = tmpDir(`bundle-lugar-${runId}`);
+    const lockPath = path.join(tmpDir(`lockout-lugar-${runId}`), 'export.lock.json');
+    const { bundleFiles, lock } = await compiler.compile(podDir, { checkEndpoint: false });
+    compiler.writeBundle(bundleDir, bundleFiles);
+    fs.writeFileSync(lockPath, compiler.serializeLock(lock));
+
+    const turnByPhase = {};
+    const callModel = async ({ messages }) => {
+      const first = messages[0].content;
+      const m = /fase (\w+)/.exec(typeof first === 'string' ? first : JSON.stringify(first));
+      const phase = m ? m[1] : 'unknown';
+      turnByPhase[phase] = (turnByPhase[phase] || 0) + 1;
+      const t = turnByPhase[phase];
+      const tuId = `${phase}-${t}`;
+      const usage = { input_tokens: 10, output_tokens: 5 };
+      if (phase === 'digest') {
+        if (t === 1) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/digest.md', content: digestArtifact() } }] };
+        return { stop_reason: 'end_turn', usage, content: [{ type: 'text', text: 'ok' }] };
+      }
+      if (phase === 'visuals') {
+        if (t === 1) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'openrouter_image', input: { prompt: 'capa', out_path: 'assets/cover.png' } }] };
+        if (t === 2) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/visuals.md', content: visualsArtifact() } }] };
+        return { stop_reason: 'end_turn', usage, content: [{ type: 'text', text: 'ok' }] };
+      }
+      if (phase === 'assembly') {
+        if (t <= 7) return { stop_reason: 'max_tokens', usage, content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: piecePath(t, subdir), content: pecaHtml(t) } }] };
+        if (t === 8) return { stop_reason: 'tool_use', usage, content: [{ type: 'tool_use', id: tuId, name: 'write_file', input: { path: 'artifacts/assembly.md', content: assemblyArtifact() } }] };
+        return { stop_reason: 'end_turn', usage, content: [{ type: 'text', text: 'ok' }] };
+      }
+      return { stop_reason: 'end_turn', usage, content: [{ type: 'text', text: 'noop' }] };
+    };
+    const imageTransport = async () => ({ choices: [{ message: { images: [{ image_url: { url: png1x1 } }] } }] });
+
+    const runsRoot = tmpDir(`runs-lugar-${runId}`);
+    const payload = { pod: 'content-carousel', workflow: 'wf-content-carousel', fetch_allow_hosts: [], article_url: 'https://example.com/a' };
+    const logs = [];
+    const run = exec.setupRun({ bundleDir, lockOverride: lockPath, payload, deps: { callModel, imageTransport }, log: (m) => logs.push(m) });
+    const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pex-mem-'));
+    const { ctx } = motor.startRun({ workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, pod: run.pod, workflow: run.workflow, runsRoot, runId, memoryPodDir });
+    await exec.drive(ctx, run, {}); // 1ª parada: gate de texto em `digest`
+    const ctx2 = motor.openRun({ statePath: motor.findStateByRunId(runsRoot, runId), workflowPath: path.join(bundleDir, 'workflow.yaml'), podRootOverride: bundleDir, memoryPodDir });
+    motor.approve(ctx2);
+    const r = await exec.drive(ctx2, run, {});
+    return { r, ctx, logs, disk: motor.readState(ctx.statePath) };
+  }
+
+  // (1) DESOBEDIENTE, com o veto no lugar: BLOQUEIA, e o dono nunca é convocado.
+  const mau = await rodar({ subdir: 'pieces', semRenderPng: false, runId: 'lugar-mau' });
+  assert(mau.r.awaiting == null,
+    `ADR-028 AC27: peças em subdiretório ⇒ o checkpoint do dono NUNCA é alcançado (awaiting=${mau.r.awaiting})`);
+  assert(mau.disk.steps.assembly.status === 'running' && mau.disk.steps.assembly.checkpoint !== 'approved',
+    `ADR-028 AC27: a fase assembly NÃO fecha (status=${mau.disk.steps.assembly.status})`);
+  assert(mau.r.blocked === 'assembly', `ADR-028 AC27: o drive devolve BLOQUEIO na fase assembly (blocked=${mau.r.blocked})`);
+  // A causa é lida da LINHA do veto (não do log inteiro): oráculo frouxo passaria por ruído.
+  const linhaVeto = mau.logs.find((l) => /\[assembly\] VETO DISPAROU/.test(l)) || '';
+  assert(/render-png/.test(linhaVeto),
+    `ADR-028 AC27: a linha do veto NOMEIA o render-png (linha: ${linhaVeto.slice(0, 200) || '(nenhuma linha VETO DISPAROU)'})`);
+  assert(/\b7\b/.test(linhaVeto),
+    'ADR-028 AC27: a linha do veto cita a contagem esperada (--expect 7) — mensagem acionável, não genérica');
+  assert(fs.existsSync(path.join(mau.ctx.runDir, 'pieces', PIECE_NAMES[0])),
+    'ADR-028 AC27: as peças EXISTEM (o agente escreveu 7) — o que reprova é o LUGAR, não a ausência de trabalho');
+
+  // (2) MESMO cenário desobediente, com a assertion REMOVIDA do wf: passa direto ao checkpoint.
+  //     É a prova de que o controle (1) tem dentes — ele mede o veto, não um acaso do harness.
+  const semVeto = await rodar({ subdir: 'pieces', semRenderPng: true, runId: 'lugar-sem-veto' });
+  assert(semVeto.r.awaiting === 'assembly',
+    `ADR-028 AC27: sem a assertion render-png no wf, o MESMO cenário desobediente chega ao checkpoint (awaiting=${semVeto.r.awaiting}) — logo o bloqueio de (1) é do veto`);
+}
+
+// ---------------------------------------------------------------------------
+
+async function main() {
+  console.log('POWER CLAUDE — suíte hermética do pod-export-executor (SF10.2)\n');
+  reuseTests();
+  coherenceTests();
+  await toolsSecurityTests();
+  await loopTests();
+  await endToEndTest();
+  await fixerOrderingTest();
+  noNewLimitsTest();
+  appendUserTurnTest();
+  await guidedCorrectionTest();
+  await resumeFallbackTest();
+  provenanceUnitTests();
+  provenanceWiringStaticTest();
+  await provenanceHappyPathTest();
+  await provenanceHaltRunTest();
+  await provenanceHaltVariantsTest();
+  await provenanceHaltGuidedTest();
+  await provenanceHaltResumeTest();
+  await exportHerdaGateDeTextoTest();
+  await lugarDasPecasTest();
+  if (failures > 0) { console.error(`\nSuíte FALHOU: ${failures} violação(ões).`); process.exit(1); }
+  console.log('\nSuíte verde.');
+  process.exit(0);
+}
+
+main().catch((e) => { console.error('[ERRO NA SUÍTE]', e.stack || e.message); process.exit(1); });