@daniellins/power-claude 0.16.3

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

@@ -0,0 +1,531 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-export-hardening.test.cjs — Story SF10.9 (F5): hardening acumulado do `pod-export`.
+ *
+ * HERMÉTICO (sem VPS/rede externa/spawn real). Cada um dos 5 itens tem PAR de testes:
+ *   (adversarial) força o estado degradado/malformado/inválido — FALHA sem o fix;
+ *   (não-regressão) prova que o caminho feliz responde exatamente como antes.
+ *
+ *   AC1 — preflight assere `blessedVetoRels().size > 0`: manifesto (installer/motor-scripts.js)
+ *         ausente/ilegível/sem entradas de veto-checks FALHA ALTO no arranque (antes o Guard B do
+ *         motor apenas degradava MUDO — `blessed.size > 0 && ...` PULA a checagem com Set vazio).
+ *   AC2 — `provision-pod-export.sh` passo 3 exige `installer/motor-scripts.js` (o wrapper carregado
+ *         em RUNTIME pelo motor), não só o `.json`.
+ *   AC3 — `confineToRunDir` confina por REALPATH (padrão do Guard B de command_check): symlink
+ *         DENTRO do runDir apontando para fora é RECUSADO.
+ *   AC4 — `decodeURIComponent` sob try/catch nos 2 call-sites: `%zz` vira 400, nunca `URIError`
+ *         não capturado (o processo continua vivo).
+ *   AC5 — `approveRun` valida `safeRunId` ANTES de qualquer efeito (antes de loadIdentities/
+ *         authorizeApproval e antes de buildApproveArgs/spawn): runId inválido → recusa SEM spawn.
+ *
+ * SF10.15 (F5) — fecha o `FIND-1` do gate de SF10.9 (`docs/qa/gates/sf10.9.yaml`): `safeRunId`
+ *   aceitava `-` na PRIMEIRA posição, então runIds em forma de FLAG chegavam ao argv do executor.
+ *   Bateria própria abaixo (`sf1015FlagShapedRunId`): os 6 vetores do finding, unidade + rota HTTP
+ *   REAL (`POST /approve` com segredo de aprovador VÁLIDO → recusa com spawn=0) + não-regressão.
+ */
+
+const http = require('node:http');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { EventEmitter } = require('node:events');
+
+const svc = require('./pod-export-service.cjs');
+const ui = require('./pod-export-ui.cjs');
+const motor = require('./pc-run-pod.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const VALID_HTML = path.join(REPO_ROOT, 'scripts', '__fixtures__', 'veto-checks', 'slide-ok.html');
+const PROVISION_SH = path.join(REPO_ROOT, 'deploy', 'pod-export', 'provision-pod-export.sh');
+
+let failures = 0;
+function assert(ok, msg) { if (ok) console.log(`[OK   ] ${msg}`); else { console.error(`[FALHA] ${msg}`); failures++; } }
+function throwsFail(fn) { try { fn(); return false; } catch { return true; } }
+function tmpDir(label) { return fs.mkdtempSync(path.join(os.tmpdir(), `sf10.9-${label}-`)); }
+function messageOf(fn) { try { fn(); return ''; } catch (e) { return e.message; } }
+
+// ===========================================================================
+// AC1 — preflight fail-loud quando o manifesto blessed está indisponível/vazio.
+// ===========================================================================
+function ac1PreflightBlessed() {
+  console.log('\n--- AC1: preflight assere blessedVetoRels().size > 0 (manifesto indisponível → fail-loud) ---');
+
+  // (não-regressão) manifesto REAL do checkout: carrega e traz os veto-checks blessed (ADR-007).
+  const real = svc.blessedVetoRels();
+  assert(real.size > 0 && real.has('scripts/veto-checks/html-valid.cjs'),
+    `manifesto REAL carrega o conjunto blessed (${real.size} entradas, inclui html-valid.cjs)`);
+
+  // (não-regressão) fronteira completa com manifesto real → PASSA e reporta blessedCount.
+  const s = svc.assertCommandCheckFrontier({ validHtmlPath: VALID_HTML });
+  assert(s.blessedCount === real.size && s.rejectedNonBlessed && s.rejectedTraversal && s.acceptedBlessed,
+    'caminho feliz: fronteira command_check íntegra (blessedCount>0, não-blessed e traversal recusados, blessed aceito)');
+
+  // (adversarial) manifesto AUSENTE em disco: a carga LANÇA aqui (o motor a faz em catch silencioso).
+  const noManifest = path.join(tmpDir('no-manifest'), 'motor-scripts.js');
+  assert(throwsFail(() => svc.blessedVetoRels({ motorScriptsPath: noManifest })),
+    'manifesto ausente em disco → blessedVetoRels LANÇA (nunca Set vazio silencioso)');
+
+  // (adversarial) fronteira com manifesto ausente → FAIL-LOUD (antes: passava, Guard B degradava mudo).
+  let msg = messageOf(() => svc.assertCommandCheckFrontier({ validHtmlPath: VALID_HTML, motorScriptsPath: noManifest }));
+  assert(/FAIL-LOUD/.test(msg) && /manifesto de scripts blessed INDISPON/i.test(msg),
+    'manifesto INDISPONÍVEL → assertCommandCheckFrontier RECUSA (fail-loud, cita o manifesto)');
+
+  // (adversarial) manifesto ilegível (erro de leitura/parse) → mesma recusa.
+  msg = messageOf(() => svc.assertCommandCheckFrontier({
+    validHtmlPath: VALID_HTML,
+    loadMotorScripts: () => { const e = new Error('Unexpected token'); e.code = 'ERR_INVALID_JSON'; throw e; },
+  }));
+  assert(/FAIL-LOUD/.test(msg), 'manifesto ILEGÍVEL → recusa fail-loud (não é tratado como "sem blessed")');
+
+  // (adversarial) manifesto carrega mas SEM entradas de veto-checks → Set vazio → recusa.
+  msg = messageOf(() => svc.assertCommandCheckFrontier({
+    validHtmlPath: VALID_HTML,
+    loadMotorScripts: () => ({ motorRels: () => ['scripts/pc-run-pod.cjs', 'scripts/pod-memory.cjs'] }),
+  }));
+  assert(/FAIL-LOUD/.test(msg) && /VAZIO/.test(msg),
+    'conjunto blessed VAZIO (estado em que o Guard B do motor é PULADO) → recusa fail-loud');
+
+  // filtro correto: só `scripts/veto-checks/` entra no conjunto.
+  const filtered = svc.blessedVetoRels({ loadMotorScripts: () => ({ motorRels: () => ['scripts/veto-checks/a.cjs', 'scripts/x.cjs'] }) });
+  assert(filtered.size === 1 && filtered.has('scripts/veto-checks/a.cjs'), 'blessedVetoRels filtra por scripts/veto-checks/ (paridade com o motor)');
+
+  // preflight COMPLETO (o arranque real do serviço), com env/chrome injetados.
+  const env = { ANTHROPIC_API_KEY: 'sk-ant-XXX', OPENROUTER_API_KEY: 'sk-or-XXX' };
+  const depsBase = { env, probeChrome: () => '/usr/bin/chromium', evalVeto: motor.evalVeto, validHtmlPath: VALID_HTML };
+  assert(throwsFail(() => svc.preflight({}, { ...depsBase, motorScriptsPath: noManifest })),
+    'preflight RECUSA o arranque do serviço com o manifesto indisponível (nunca sobe degradado)');
+  const okSummary = svc.preflight({}, depsBase);
+  assert(okSummary.frontier.blessedCount > 0 && okSummary.chrome === 'chromium',
+    'não-regressão: preflight com manifesto REAL passa e reporta blessedCount no sumário');
+}
+
+// ===========================================================================
+// AC2 — provision-pod-export.sh passo 3 exige installer/motor-scripts.js.
+// ===========================================================================
+function ac2Provision() {
+  console.log('\n--- AC2: provision-pod-export.sh passo 3 exige installer/motor-scripts.js ---');
+  const text = fs.readFileSync(PROVISION_SH, 'utf8');
+  const m = text.match(/for f in ([\s\S]*?); do/);
+  assert(!!m && /pc-run-pod\.cjs/.test(m[1]), 'passo 3: lista de arquivos obrigatórios localizada no script');
+  const list = m[1].replace(/\\\s*\n/g, ' ').trim().split(/\s+/).filter(Boolean);
+
+  assert(list.includes('installer/motor-scripts.js'),
+    'lista exige installer/motor-scripts.js (o wrapper que o motor carrega em RUNTIME)');
+  assert(list.includes('installer/motor-scripts.json'),
+    'não-regressão: lista continua exigindo installer/motor-scripts.json');
+
+  // Simula o loop do passo 3 (mesma lista, lida do script REAL) contra dois deployments.
+  const missingIn = (dir) => list.filter((f) => !fs.existsSync(path.join(dir, f)));
+  const full = tmpDir('fw-full');
+  for (const f of list) {
+    const p = path.join(full, f);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, 'x');
+  }
+  assert(missingIn(full).length === 0, 'não-regressão: deployment COMPLETO → passo 3 passa (MISSING=0)');
+
+  fs.unlinkSync(path.join(full, 'installer/motor-scripts.js'));
+  const missing = missingIn(full);
+  assert(missing.includes('installer/motor-scripts.js') && missing.length === 1,
+    'deployment SEM installer/motor-scripts.js (só o .json) → passo 3 FALHA (AUSENTE), antes passava');
+}
+
+// ===========================================================================
+// AC3 — confineToRunDir: containment por realpath (symlink interno escapando → recusa).
+// ===========================================================================
+function ac3Realpath() {
+  console.log('\n--- AC3: confineToRunDir confina por REALPATH (symlink dentro do runDir → recusado) ---');
+  const runDir = tmpDir('rundir');
+  fs.mkdirSync(path.join(runDir, 'pieces'), { recursive: true });
+  const piece = path.join(runDir, 'pieces', '1-capa.html');
+  fs.writeFileSync(piece, '<html><body>CAPA</body></html>');
+  const outside = tmpDir('outside');
+  const secret = path.join(outside, 'secret.env');
+  fs.writeFileSync(secret, 'ANTHROPIC_API_KEY=sk-ant-REAL');
+
+  // (não-regressão) peça legítima → MESMO abs lexical de antes (o caller serve o mesmo arquivo).
+  assert(ui.confineToRunDir(runDir, 'pieces/1-capa.html') === path.resolve(runDir, 'pieces', '1-capa.html'),
+    'não-regressão: peça legítima confina e devolve o abs lexical inalterado');
+
+  // (adversarial) symlink de ARQUIVO dentro do runDir apontando para fora.
+  fs.symlinkSync(secret, path.join(runDir, 'pieces', 'leak.html'));
+  assert(ui.confineToRunDir(runDir, 'pieces/leak.html') === null,
+    'symlink de ARQUIVO dentro do runDir → fora do runDir: RECUSADO (antes passava pelo path.resolve)');
+
+  // (adversarial) symlink de DIRETÓRIO dentro do runDir apontando para fora.
+  fs.symlinkSync(outside, path.join(runDir, 'esc'), 'dir');
+  assert(ui.confineToRunDir(runDir, 'esc/secret.env') === null, 'symlink de DIRETÓRIO escapando o runDir: RECUSADO');
+  assert(ui.confineToRunDir(runDir, 'esc/nao-existe.html') === null,
+    'alvo inexistente SOB symlink de diretório escapando: RECUSADO (ancestral existente é resolvido)');
+
+  // (não-regressão) symlink apontando para DENTRO do runDir continua aceito.
+  fs.symlinkSync(piece, path.join(runDir, 'alias.html'));
+  assert(ui.confineToRunDir(runDir, 'alias.html') === path.resolve(runDir, 'alias.html'),
+    'não-regressão: symlink interno (alvo DENTRO do runDir) continua ACEITO');
+
+  // (não-regressão) alvo inexistente sob diretório legítimo: abs (o caller responde 400 no existsSync).
+  assert(ui.confineToRunDir(runDir, 'pieces/nao-existe.html') === path.resolve(runDir, 'pieces', 'nao-existe.html'),
+    'não-regressão: alvo inexistente sob dir legítimo devolve abs (caller responde 400)');
+
+  // (não-regressão) guardas lexicais de SF10.5 intactas.
+  assert(ui.confineToRunDir(runDir, '../../etc/passwd') === null, 'não-regressão: traversal ../../ continua RECUSADO');
+  assert(ui.confineToRunDir(runDir, 'a/../../b') === null, 'não-regressão: traversal disfarçada continua RECUSADA');
+  assert(ui.confineToRunDir(runDir, '') === null && ui.confineToRunDir(runDir, null) === null, 'não-regressão: relPath vazio/não-string → null');
+  assert(ui.confineToRunDir(runDir, 'pieces/a%00.html') === null, 'não-regressão: NUL codificado → RECUSADO');
+}
+
+// ===========================================================================
+// AC4 — decodeURIComponent sob try/catch (nível de função).
+// ===========================================================================
+function ac4DecodeUnit() {
+  console.log('\n--- AC4: decodeURIComponent malformado → recusa, nunca URIError ---');
+  const runDir = tmpDir('uri');
+  let threw = false;
+  let out;
+  try { out = ui.confineToRunDir(runDir, '%zz'); } catch { threw = true; }
+  assert(!threw && out === null, '"%zz" em confineToRunDir → null (sem URIError propagado)');
+  threw = false;
+  try { out = ui.confineToRunDir(runDir, 'pieces/%E0%A4%A.html'); } catch { threw = true; }
+  assert(!threw && out === null, 'percent-encoding TRUNCADO → null (sem URIError)');
+  threw = false;
+  try { out = ui.confineToRunDir(runDir, '%'); } catch { threw = true; }
+  assert(!threw && out === null, '"%" solto → null (sem URIError)');
+
+  // (não-regressão) percent-encoding VÁLIDO continua sendo decodificado.
+  fs.writeFileSync(path.join(runDir, 'com espaço.html'), '<html></html>');
+  assert(ui.confineToRunDir(runDir, 'com%20espa%C3%A7o.html') === path.resolve(runDir, 'com espaço.html'),
+    'não-regressão: percent-encoding VÁLIDO continua decodificando para o arquivo certo');
+}
+
+// ===========================================================================
+// Fixture da UI (queue + runDir + identidades) para os testes HTTP.
+// ===========================================================================
+const SESSION_KEY = 'k'.repeat(48);
+const TEAM_SECRET = 'senha-da-equipe';
+const APPROVER_SECRET = 'segredo-do-aprovador';
+
+function makeFixture() {
+  const root = tmpDir('fix');
+  const queueDir = path.join(root, 'queue');
+  const runsRoot = path.join(root, 'runs');
+  const bundleDir = path.join(root, 'bundle');
+  fs.mkdirSync(bundleDir, { recursive: true });
+  fs.writeFileSync(path.join(bundleDir, 'workflow.yaml'),
+    'steps:\n  - id: montagem\n    checkpoint: { blocking: true, criteria: "7 peças" }\n');
+  const runId = 'pex-hn-carousel-2026';
+  const dirs = svc.ensureQueue(queueDir);
+  fs.writeFileSync(path.join(dirs.awaiting, `${runId}.json`), JSON.stringify({ pod: 'hn-carousel', started_by: 'bob' }));
+  fs.writeFileSync(path.join(dirs.awaiting, `${runId}.result.json`), JSON.stringify({ runId, kind: 'awaiting', started_by: 'bob', awaiting: 'montagem', at: '2026-07-31T10:00:00Z' }));
+  const runDir = path.join(runsRoot, 'hn-carousel', 'wf', runId);
+  fs.mkdirSync(path.join(runDir, 'pieces'), { recursive: true });
+  fs.writeFileSync(path.join(runDir, 'state.json'), JSON.stringify({ run_id: runId, steps: {} }));
+  fs.writeFileSync(path.join(runDir, 'pieces', '1-capa.html'), '<html><body>CAPA</body></html>');
+  // symlink DENTRO do runDir apontando para um segredo FORA (vetor do AC3, exercitado via HTTP).
+  const outside = tmpDir('outside-http');
+  fs.writeFileSync(path.join(outside, 'secret.env'), 'ANTHROPIC_API_KEY=sk-ant-REAL');
+  fs.symlinkSync(path.join(outside, 'secret.env'), path.join(runDir, 'pieces', 'leak.html'));
+  const identitiesFile = path.join(root, 'identities.json');
+  fs.writeFileSync(identitiesFile, JSON.stringify({ identities: [{ id: 'daniel', label: 'Daniel', is_approver: true }, { id: 'alice', label: 'Alice' }] }));
+  const cfg = ui.loadUiConfig({
+    PODEXPORT_QUEUE_DIR: queueDir,
+    PODEXPORT_RUNS_DIR: runsRoot,
+    PODEXPORT_BUNDLE_DIR: bundleDir,
+    PODEXPORT_IDENTITIES: identitiesFile,
+    PODEXPORT_UI_TEAM_HASH: svc.hashApproverSecret(TEAM_SECRET),
+    PODEXPORT_UI_SESSION_KEY: SESSION_KEY,
+    PODEXPORT_APPROVER_SECRET_HASH: svc.hashApproverSecret(APPROVER_SECRET),
+    PODEXPORT_UI_INSECURE: '1',
+  });
+  process.env.PODEXPORT_IDENTITIES = identitiesFile;
+  return { cfg, runId, root };
+}
+
+function request(server, { method = 'GET', pathUrl = '/', cookie, body } = {}) {
+  const { port } = server.address();
+  return new Promise((resolve, reject) => {
+    const headers = { Origin: `http://127.0.0.1:${port}` };
+    if (cookie) headers.Cookie = cookie;
+    if (body != null) { headers['Content-Type'] = 'application/x-www-form-urlencoded'; headers['Content-Length'] = Buffer.byteLength(body); }
+    const req = http.request({ host: '127.0.0.1', port, method, path: pathUrl, headers }, (res) => {
+      let data = ''; res.on('data', (c) => { data += c; });
+      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: data }));
+    });
+    // Timeout curto: se o handler LANÇAR (ex.: URIError não capturado) a resposta nunca vem — sem
+    // isto o teste PENDURA em vez de falhar. Falha explícita > espera infinita.
+    req.setTimeout(5000, () => req.destroy(new Error('timeout: o handler não respondeu (exceção não capturada?)')));
+    req.on('error', reject);
+    if (body != null) req.write(body);
+    req.end();
+  });
+}
+
+// ===========================================================================
+// AC3+AC4 pela rota REAL /preview: 400 (nunca 500/crash), processo VIVO depois.
+// ===========================================================================
+async function ac4HttpPreview() {
+  console.log('\n--- AC3+AC4 via HTTP: /preview com entrada malformada/symlink → 400, servidor VIVO ---');
+  const { cfg, runId } = makeFixture();
+  const server = ui.createServer(cfg, {});
+  await new Promise((r) => server.listen(0, '127.0.0.1', r));
+  const uncaught = [];
+  const onUncaught = (e) => uncaught.push(e);
+  process.on('uncaughtException', onUncaught);
+
+  const login = await request(server, { method: 'POST', pathUrl: '/login', body: new URLSearchParams({ password: TEAM_SECRET }).toString() });
+  const cookie = String((login.headers['set-cookie'] || [''])[0]).match(/pex_ui=([^;]*)/);
+  const jar = cookie ? `pex_ui=${cookie[1]}` : null;
+  assert(!!jar, 'pré-condição: login da equipe devolve cookie de sessão');
+
+  // (não-regressão) peça legítima → 200 com a CSP de sandbox.
+  let res = await request(server, { pathUrl: `/preview/${runId}/pieces/1-capa.html`, cookie: jar });
+  assert(res.status === 200 && /CAPA/.test(res.body) && /sandbox/.test(String(res.headers['content-security-policy'])),
+    'não-regressão: /preview de peça legítima → 200 com CSP sandbox');
+
+  // (adversarial AC4) `%zz` no segmento do runId → 400 (antes: URIError não capturado).
+  res = await request(server, { pathUrl: `/preview/%zz/pieces/1-capa.html`, cookie: jar });
+  assert(res.status === 400, 'runId com "%zz" → 400 (nunca URIError não capturado)');
+
+  // (adversarial AC4) `%zz` no relPath da peça (confineToRunDir) → 400.
+  res = await request(server, { pathUrl: `/preview/${runId}/pieces/%zz`, cookie: jar });
+  assert(res.status === 400, 'relPath com "%zz" → 400');
+
+  // (adversarial AC3) symlink dentro do runDir apontando para segredo FORA → 400, sem vazar conteúdo.
+  res = await request(server, { pathUrl: `/preview/${runId}/pieces/leak.html`, cookie: jar });
+  assert(res.status === 400 && !/sk-ant-REAL/.test(res.body), 'symlink escapando o runDir via /preview → 400, segredo NÃO vazado');
+
+  // (não-regressão) traversal continua barrada e o processo segue vivo/servindo.
+  res = await request(server, { pathUrl: `/preview/${runId}/..%2f..%2f..%2fetc%2fpasswd`, cookie: jar });
+  assert(res.status === 400, 'não-regressão: traversal codificada → 400');
+  res = await request(server, { pathUrl: '/health' });
+  assert(res.status === 200 && res.body === 'ok', 'servidor CONTINUA VIVO após todas as requisições malformadas');
+  assert(uncaught.length === 0, 'nenhuma exceção não capturada durante os ataques (URIError não derruba o processo)');
+
+  process.removeListener('uncaughtException', onUncaught);
+  await new Promise((r) => server.close(r));
+}
+
+// ===========================================================================
+// AC5 — approveRun recusa runId inválido ANTES de qualquer efeito (sem spawn).
+// ===========================================================================
+async function ac5ApproveSafeRunId() {
+  console.log('\n--- AC5: approveRun valida safeRunId ANTES de authorizeApproval/spawn ---');
+  const { cfg, runId } = makeFixture();
+  let spawned = 0;
+  const spySpawn = () => {
+    spawned++;
+    const ch = new EventEmitter();
+    ch.stdout = new EventEmitter();
+    process.nextTick(() => ch.emit('exit', 0));
+    return ch;
+  };
+  // CREDENCIAIS VÁLIDAS de propósito: a ÚNICA razão possível de recusa é o runId. Sem o fix, o
+  // gate de SF10.4 autorizaria e o valor cru chegaria a buildApproveArgs/spawn.
+  const base = {
+    env: process.env,
+    identitiesFile: cfg.identitiesFile,
+    asId: 'daniel',
+    approverSecret: APPROVER_SECRET,
+    approverSecretHash: svc.hashApproverSecret(APPROVER_SECRET),
+    spawn: spySpawn,
+    log: () => {},
+  };
+
+  const bads = ['../../etc/passwd', '..', 'a/b', 'pex/../..', 'pex-ok/../../x', '', '   ', 'x'.repeat(300),
+    'run;rm -rf /', 'run$(id)', 'pex x', 'pex..2026', 'pex\u00002026', null, undefined, 42, {}];
+  let allDenied = true;
+  for (const bad of bads) {
+    const r = await svc.approveRun(cfg, bad, base);
+    if (!(r && r.denied && r.code === 3 && /runId/.test(r.reason))) { allDenied = false; console.error(`  ↳ não recusado: ${JSON.stringify(String(bad))}`); }
+  }
+  assert(allDenied, `todo runId inválido (${bads.length} vetores: traversal, separador, shell metachar, NUL, vazio, longo, não-string) → RECUSADO com razão de runId`);
+  assert(spawned === 0, 'NENHUM spawn ocorreu em nenhuma das recusas (recusa ANTES de qualquer efeito)');
+
+  // A recusa acontece ANTES de loadIdentities/authorizeApproval: com config de identidades ILEGÍVEL
+  // (que faria loadIdentities lançar) a razão devolvida ainda é a do runId.
+  const r2 = await svc.approveRun({ ...cfg, identitiesFile: path.join(cfg.queueDir, 'nao-existe.json') },
+    '../x', { ...base, env: {} });
+  assert(r2.denied && /runId/.test(r2.reason), 'recusa do runId precede loadIdentities/authorizeApproval (razão é a do runId)');
+  assert(spawned === 0, 'ainda sem spawn após o vetor pré-gate');
+
+  // Razão não ecoa o valor recebido (nada de refletir entrada não confiável nos logs/resposta).
+  const r3 = await svc.approveRun(cfg, '../../etc/passwd', base);
+  assert(!/etc\/passwd/.test(JSON.stringify(r3)), 'razão da recusa NÃO ecoa o valor recebido');
+
+  // (não-regressão) runId válido + credenciais válidas → autoriza e INVOCA o executor.
+  const okRes = await svc.approveRun(cfg, runId, base);
+  assert(okRes.code === 0 && !okRes.denied && spawned === 1,
+    'não-regressão: runId válido + credenciais válidas → autorizado, executor invocado (1 spawn)');
+
+  // (não-regressão) o gate de SF10.4 continua recusando identidade/segredo errado com runId VÁLIDO.
+  const notApprover = await svc.approveRun(cfg, runId, { ...base, asId: 'alice' });
+  assert(notApprover.denied && /aprovadora designada/.test(notApprover.reason) && spawned === 1,
+    'não-regressão: identidade não-aprovadora com runId válido → recusa do gate F3 (sem novo spawn)');
+
+  // safeRunId é a MESMA regra na UI e no backend (fonte única).
+  assert(ui.safeRunId === svc.safeRunId && svc.safeRunId('pex-abc-123') && !svc.safeRunId('../x'),
+    'safeRunId é fonte ÚNICA compartilhada por UI e backend');
+}
+
+// ===========================================================================
+// SF10.15 (FIND-1) — runId em forma de FLAG não passa mais pelo predicado nem chega ao spawn.
+//
+// Os 6 vetores são LITERALMENTE os do finding (`docs/qa/gates/sf10.9.yaml`, FIND-1). Cada um tem
+// asserção DEDICADA em 3 níveis: (1) predicado, (2) `approveRun` com credenciais VÁLIDAS (a única
+// razão possível de recusa é o runId), (3) rota HTTP REAL — foi por ela que o QA quebrou (spawn=1
+// com argv deslocado); aqui ela prova spawn=0.
+// ===========================================================================
+const FIND1_VECTORS = ['--runs-root', '--input', '--lock', '--kill-during', '--help', '-rf'];
+
+function spySpawnFactory(counter) {
+  return () => {
+    counter.n++;
+    const ch = new EventEmitter();
+    ch.stdout = new EventEmitter();
+    process.nextTick(() => ch.emit('exit', 0));
+    return ch;
+  };
+}
+
+async function sf1015Predicate() {
+  console.log('\n--- SF10.15/AC1+AC2: runId em forma de FLAG → predicado recusa e approveRun não spawna ---');
+  const { cfg, runId } = makeFixture();
+  const counter = { n: 0 };
+  const base = {
+    env: process.env,
+    identitiesFile: cfg.identitiesFile,
+    asId: 'daniel',
+    approverSecret: APPROVER_SECRET,
+    approverSecretHash: svc.hashApproverSecret(APPROVER_SECRET),
+    spawn: spySpawnFactory(counter),
+    log: () => {},
+  };
+
+  // (1) predicado — asserção DEDICADA por vetor (AC1).
+  for (const v of FIND1_VECTORS) {
+    assert(svc.safeRunId(v) === false, `AC1 · safeRunId(${JSON.stringify(v)}) === false (vetor do FIND-1)`);
+  }
+
+  // (2) approveRun com credenciais VÁLIDAS — recusa antes de qualquer efeito, spawn=0 (AC2).
+  for (const v of FIND1_VECTORS) {
+    const antes = counter.n;
+    const r = await svc.approveRun(cfg, v, base);
+    assert(r && r.denied === true && r.code === 3 && /runId/.test(r.reason) && counter.n === antes,
+      `AC2 · approveRun(${JSON.stringify(v)}) com credenciais VÁLIDAS → denied, code 3, SEM spawn`);
+  }
+  assert(counter.n === 0, 'AC2 · contagem TOTAL de spawn nos 6 vetores do FIND-1 = 0');
+
+  // A razão não ecoa a entrada (regra de SF10.9 mantida sob o predicado novo).
+  const rEcho = await svc.approveRun(cfg, '--runs-root', base);
+  assert(!/runs-root/.test(JSON.stringify(rEcho)), 'AC2 · razão da recusa NÃO ecoa o valor em forma de flag recebido');
+
+  // (3) não-regressão do predicado (AC4): `-` segue aceito FORA da 1ª posição; runId gerado passa.
+  const gerado = svc.genRunId('hn-carousel.json');
+  const legitimos = [gerado, runId, 'pex-abc-123', 'pex-hn-carousel-2026-07-31T10-00-00-000Z', 'a-b', 'run_1.v2', 'x'];
+  for (const ok of legitimos) {
+    assert(svc.safeRunId(ok) === true, `AC4 · runId legítimo segue aceito: ${JSON.stringify(ok)}`);
+  }
+  assert(/^pex-/.test(gerado) && gerado[0] !== '-', 'AC4 · genRunId produz sempre prefixo "pex-" (nenhum runId real começa por "-")');
+
+  // (4) não-regressão do argv montado (decisão sobre (a2), ver Dev Record): buildApproveArgs
+  // continua SEM separador `--` — `parseArgs` do executor (L342-353) não trata `--`, que viraria
+  // POSICIONAL e deslocaria o runId. O fix fica só no predicado.
+  const args = svc.buildApproveArgs(cfg, runId);
+  assert(args[1] === cfg.bundleDir && args[2] === 'approve' && args[3] === runId && !args.includes('--'),
+    'AC4 · buildApproveArgs mantém o argv de SF10.4 (executor INTOCADO, sem separador "--")');
+
+  // (5) fonte ÚNICA do predicado (AC5): a UI reusa a MESMA função e não há 2ª cópia do regex.
+  assert(ui.safeRunId === svc.safeRunId && ui.safeRunId('--runs-root') === false,
+    'AC5 · UI reusa svc.safeRunId — o estreitamento se propaga SEM editar pod-export-ui.cjs');
+  const defsRegex = ['pod-export-service.cjs', 'pod-export-ui.cjs']
+    .map((f) => (fs.readFileSync(path.join(__dirname, f), 'utf8').match(/RUNID_RE\s*=/g) || []).length)
+    .reduce((a, b) => a + b, 0);
+  assert(defsRegex === 1, `AC5 · existe UMA única definição de RUNID_RE nos scripts do pod-export (achadas: ${defsRegex})`);
+}
+
+// ===========================================================================
+// SF10.15/AC3 — rota REAL: POST /approve com segredo de aprovador VÁLIDO → recusa, spawn=0.
+// (Cenário literal do FIND-1, onde o QA observou spawn=1 com argv deslocado.)
+// ===========================================================================
+async function sf1015HttpApprove() {
+  console.log('\n--- SF10.15/AC3: POST /approve com runId em forma de FLAG (rota REAL) → recusa, spawn=0 ---');
+  const { cfg, runId } = makeFixture();
+  const counter = { n: 0 };
+  const chamadas = [];
+  const server = ui.createServer(cfg, {
+    // Delega ao approveRun REAL (guard 0a incluso) — só o `spawn` é espionado, para CONTAR o que
+    // teria virado processo. Rate-limit afrouxado: o alvo aqui é o predicado, não o ADR-004.
+    approveRun: async (c, id, deps) => {
+      chamadas.push(id);
+      return svc.approveRun(c, id, { ...deps, spawn: spySpawnFactory(counter), log: () => {} });
+    },
+    approveLimiter: ui.createRateLimiter(100, 60 * 1000),
+  });
+  await new Promise((r) => server.listen(0, '127.0.0.1', r));
+  const uncaught = [];
+  const onUncaught = (e) => uncaught.push(e);
+  process.on('uncaughtException', onUncaught);
+
+  const form = (obj) => new URLSearchParams(obj).toString();
+  const cookieFrom = (res) => {
+    const sc = res.headers['set-cookie'];
+    const m = sc && String(sc[0]).match(/pex_ui=([^;]*)/);
+    return m ? `pex_ui=${m[1]}` : null;
+  };
+  const sidFrom = (cookie) => {
+    const p = ui.verifySession(cookie.replace('pex_ui=', ''), SESSION_KEY);
+    return p && p.sid;
+  };
+
+  let res = await request(server, { method: 'POST', pathUrl: '/login', body: form({ password: TEAM_SECRET }) });
+  const cookie = cookieFrom(res);
+  assert(!!cookie, 'pré-condição: login da equipe devolve cookie de sessão');
+  res = await request(server, { method: 'POST', pathUrl: '/operator', cookie, body: form({ operator: 'daniel', _csrf: ui.csrfToken(sidFrom(cookie), SESSION_KEY) }) });
+  const cookieDaniel = cookieFrom(res) || cookie;
+  const csrfDaniel = ui.csrfToken(sidFrom(cookieDaniel), SESSION_KEY);
+  assert(res.status === 303, 'pré-condição: operador daniel (APROVADOR) atribuído à sessão');
+
+  // Cenário exato do FIND-1, vetor a vetor: segredo de aprovador VÁLIDO + runId em forma de flag.
+  for (const v of FIND1_VECTORS) {
+    const antes = counter.n;
+    const r = await request(server, {
+      method: 'POST', pathUrl: '/approve', cookie: cookieDaniel,
+      body: form({ run: v, secret: APPROVER_SECRET, _csrf: csrfDaniel }),
+    });
+    assert(r.status === 403 && counter.n === antes,
+      `AC3 · POST /approve run=${JSON.stringify(v)} + segredo VÁLIDO → 403 e ZERO spawn (antes do fix: spawn=1, argv deslocado)`);
+  }
+  assert(counter.n === 0, 'AC3 · contagem TOTAL de spawn pela rota HTTP real nos 6 vetores = 0');
+  assert(chamadas.length === FIND1_VECTORS.length, 'AC3 · as 6 requisições REALMENTE alcançaram approveRun (não foram barradas por CSRF/rate-limit)');
+  assert(ui.listCheckpoints(cfg).length === 1, 'AC3 · o run legítimo continua em awaiting/ (nenhuma aprovação ocorreu)');
+
+  // (não-regressão AC4) o MESMO caminho, com runId legítimo, ainda aprova e spawna 1 vez — prova
+  // que o contador de spawn é sensível (spawn=0 acima significa recusa, não teste cego).
+  res = await request(server, {
+    method: 'POST', pathUrl: '/approve', cookie: cookieDaniel,
+    body: form({ run: runId, secret: APPROVER_SECRET, _csrf: csrfDaniel }),
+  });
+  assert(res.status === 303 && /flash=approved/.test(String(res.headers.location)) && counter.n === 1,
+    'AC4 · não-regressão pela rota real: runId legítimo + segredo válido → aprovado com exatamente 1 spawn');
+
+  res = await request(server, { pathUrl: '/health' });
+  assert(res.status === 200 && res.body === 'ok' && uncaught.length === 0,
+    'AC3 · servidor VIVO e sem exceção não capturada após os 6 vetores em forma de flag');
+
+  process.removeListener('uncaughtException', onUncaught);
+  await new Promise((r) => server.close(r));
+}
+
+// ---------------------------------------------------------------------------
+(async () => {
+  ac1PreflightBlessed();
+  ac2Provision();
+  ac3Realpath();
+  ac4DecodeUnit();
+  await ac4HttpPreview();
+  await ac5ApproveSafeRunId();
+  await sf1015Predicate();
+  await sf1015HttpApprove();
+  console.log(`\n${failures === 0 ? '[SUCESSO]' : '[FALHOU]'} pod-export hardening (SF10.9 + SF10.15): ${failures} falha(s).`);
+  process.exit(failures === 0 ? 0 : 1);
+})().catch((e) => { console.error('[ERRO NO TESTE]', e); process.exit(1); });