@daniellins/power-claude 0.16.3

package/scripts/pod-export-queue-race.test.cjs

@@ -0,0 +1,865 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-export-queue-race.test.cjs — Story SF10.16 (F5): concorrência CROSS-PROCESSO da fila do
+ * serviço-irmão (fecha `NOTE-2`; ADR-018 Adendo F5-b, DF-SF10.16-1..DF-SF10.16-4).
+ *
+ * HERMÉTICO (sem VPS, sem rede externa, sem LLM) e PORTÁTIL (macOS + Linux/CI) — nenhuma dependência
+ * de `flock(1)`, que não existe no macOS. A concorrência é REAL: `child_process` de verdade
+ * (`node <script>.cjs`), importando os módulos de PRODUÇÃO, disputando o MESMO diretório de fila,
+ * sincronizados por uma barreira de relógio (busy-spin até `START_AT`) — nunca stubs de `fs`.
+ *
+ * Os quatro efeitos MEDIDOS no `*assess` (cada um com um teste que força a corrida real):
+ *   E1  pickup disputado em `pending/` — o perdedor lançava `ENOENT` e o `serve` inteiro caía por UM
+ *       item (`main().catch` → exit 1 → `StartLimitBurst` → unit em `failed` PERMANENTE).
+ *   E2  `reject` × `reject` em `awaiting/` — o perdedor lançava DENTRO do handler async do node:http
+ *       → *unhandled rejection* → o processo da UI MORRIA (superfície de aprovação inteira fora).
+ *   E3  `approve` × `approve` no mesmo `runId` — sem reivindicação, DOIS `spawn` do executor sobre o
+ *       MESMO `runDir`: dois escritores no `state.json` e **gasto de LLM em dobro**.
+ *   E4  publicação NÃO-atômica em `pending/` — o nome ficava visível ao `readdir` antes do conteúdo;
+ *       o payload era despachado VAZIO e o ledger gravava `started_by: null`: o gate fail-loud de
+ *       identidade de DF3-3 era contornado EM SILÊNCIO (o mais grave, porque é mudo).
+ * Mais: lock de instância (`O_EXCL`) com recusa acionável, tomada de lock órfão após `SIGKILL`,
+ * liberação em `SIGTERM`, e relato de órfãos de `processing/` SEM requeue automático.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const http = require('node:http');
+const path = require('node:path');
+const { spawn, spawnSync } = require('node:child_process');
+
+const svc = require('./pod-export-service.cjs');
+const ui = require('./pod-export-ui.cjs');
+
+const SVC_PATH = path.join(__dirname, 'pod-export-service.cjs');
+const UI_PATH = path.join(__dirname, 'pod-export-ui.cjs');
+
+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.16-${label}-`)); }
+function messageOf(fn) { try { fn(); return ''; } catch (e) { return e.message; } }
+const IS_ROOT = typeof process.getuid === 'function' && process.getuid() === 0;
+
+// ---------------------------------------------------------------------------
+// Infra de processos REAIS: escreve o script do filho, dispara, coleta código de saída e saídas.
+// A barreira é um instante de relógio compartilhado (`START_AT`): cada filho ocupa a CPU até o
+// instante combinado e só então age — a sincronização mais apertada possível sem instrumentar o
+// código de produção (que é justamente o que não se pode fazer num teste de corrida honesto).
+// ---------------------------------------------------------------------------
+
+const BARRIER = `
+function barrier() { const t = Number(process.env.START_AT || 0); while (Date.now() < t) { /* spin */ } }
+function waitFile(p, ms) { const d = Date.now() + ms; while (!fs.existsSync(p)) { if (Date.now() > d) { console.error('timeout esperando ' + p); process.exit(9); } } }
+`;
+
+function writeChild(dir, name, body) {
+  const p = path.join(dir, name);
+  fs.writeFileSync(p, `'use strict';\nconst fs = require('node:fs');\nconst path = require('node:path');\n${BARRIER}\n${body}\n`);
+  return p;
+}
+
+function runChild(script, env, { detached = false } = {}) {
+  const child = spawn(process.execPath, [script], { env: { ...process.env, ...env }, stdio: ['ignore', 'pipe', 'pipe'] });
+  let out = ''; let err = '';
+  child.stdout.on('data', (d) => { out += d.toString(); });
+  child.stderr.on('data', (d) => { err += d.toString(); });
+  const done = new Promise((resolve) => child.on('exit', (code, signal) => resolve({ code, signal, out: () => out, err: () => err })));
+  return detached ? { child, done, out: () => out, err: () => err } : done;
+}
+
+/** Instante da barreira: folga suficiente para todos os filhos estarem carregados e girando. */
+function startAt(ms = 700) { return String(Date.now() + ms); }
+
+function waitFor(predicate, timeoutMs, label) {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve, reject) => {
+    const tick = () => {
+      let v = false;
+      try { v = predicate(); } catch { v = false; }
+      if (v) return resolve(true);
+      if (Date.now() > deadline) return reject(new Error(`timeout: ${label}`));
+      return setTimeout(tick, 15);
+    };
+    tick();
+  });
+}
+
+const readJson = (p) => JSON.parse(fs.readFileSync(p, 'utf8'));
+const markersIn = (dir) => (fs.existsSync(dir) ? fs.readdirSync(dir).filter((f) => f.endsWith('.json') && !f.endsWith('.result.json')) : []);
+
+// ===========================================================================
+// E1 — pickup disputado em pending/: 4 PROCESSOS REAIS sobre o MESMO payload.
+// Sem o fix: o `renameSync` de `processOne` lança `ENOENT` nos 3 perdedores → *unhandled rejection*
+// → exit 1 (em produção: `main().catch` derruba o worker inteiro por UM item).
+// Com o fix: 1 reivindica, 3 devolvem `{claimed:false}` e SEGUEM TRABALHANDO (cada filho processa em
+// seguida um item próprio) — provar "não lança" não bastaria; o requisito é continuar servindo.
+// ===========================================================================
+async function e1PickupDisputado() {
+  console.log('\n--- E1: pickup de pending/ disputado por 4 processos REAIS (1 vence, 3 seguem servindo) ---');
+  const root = tmpDir('e1');
+  const queueDir = path.join(root, 'queue');
+  const spawnLog = path.join(root, 'spawnlog');
+  fs.mkdirSync(spawnLog, { recursive: true });
+  const dirs = svc.ensureQueue(queueDir);
+  const contested = path.join(dirs.pending, 'contested.json');
+  fs.writeFileSync(contested, JSON.stringify({ pod: 'demo', started_by: 'alice', n: 0 }));
+
+  const N = 4;
+  const script = writeChild(root, 'e1-worker.cjs', `
+const svc = require(process.env.SVC);
+const cfg = { queueDir: process.env.QUEUE, bundleDir: null, runsRoot: process.env.RUNS, pollMs: 1 };
+const deps = {
+  log: () => {},
+  // Cada invocação do executor deixa um rastro em disco: é assim que se conta, entre processos,
+  // quantas vezes o executor REALMENTE foi disparado (o que em produção custa LLM).
+  runExecutor: async (c, processingPath, runId) => {
+    fs.writeFileSync(path.join(process.env.SPAWNLOG, runId + '.' + process.env.IDX), processingPath);
+    return { code: 0, result: { complete: true } };
+  },
+};
+(async () => {
+  barrier();
+  // SEM try/catch: espelha produção (o loop \`serve\` não protege \`processOne\`; um throw aqui vira
+  // unhandled rejection e mata o processo, exatamente como o worker real morria).
+  const contested = await svc.processOne(cfg, process.env.CONTESTED, deps);
+  const own = await svc.processOne(cfg, process.env.OWN, deps);
+  fs.writeFileSync(process.env.OUT, JSON.stringify({ contested, own }));
+})();
+`);
+
+  const START_AT = startAt();
+  const results = await Promise.all(Array.from({ length: N }, (_, i) => {
+    const own = path.join(dirs.pending, `own-${i}.json`);
+    fs.writeFileSync(own, JSON.stringify({ pod: 'demo', started_by: 'alice', n: i + 1 }));
+    return runChild(script, {
+      SVC: SVC_PATH, QUEUE: queueDir, RUNS: path.join(root, 'runs'), SPAWNLOG: spawnLog,
+      CONTESTED: contested, OWN: own, OUT: path.join(root, `out-${i}.json`), IDX: String(i), START_AT,
+    });
+  }));
+
+  const alive = results.filter((r) => r.code === 0).length;
+  assert(alive === N, `os ${N} processos SOBREVIVERAM à disputa (exit 0 em todos) — perder a corrida não derruba o worker`);
+  if (alive !== N) console.error(results.map((r) => r.err()).join('\n'));
+  const outs = Array.from({ length: N }, (_, i) => path.join(root, `out-${i}.json`)).filter(fs.existsSync).map(readJson);
+  const winners = outs.filter((o) => o.contested && o.contested.claimed === true);
+  const losers = outs.filter((o) => o.contested && o.contested.claimed === false);
+  assert(winners.length === 1, `EXATAMENTE 1 processo reivindicou o payload disputado (${winners.length})`);
+  assert(losers.length === N - 1 && losers.every((o) => o.contested.reason === 'claim-lost'),
+    `os outros ${N - 1} receberam \`claimed:false\` (ENOENT sancionado = "outro ator ganhou"), sem exceção`);
+  assert(outs.length === N && outs.every((o) => o.own && o.own.claimed === true && o.own.kind === 'done'),
+    'todo processo que PERDEU a disputa continuou trabalhando em seguida (processou o item próprio até done/)');
+  assert(markersIn(dirs.done).length === N + 1, `o item disputado foi processado UMA vez e nenhum sumiu (${N + 1} marcadores em done/)`);
+  assert(fs.readdirSync(spawnLog).length === N + 1, `o executor foi disparado EXATAMENTE ${N + 1}x (1 pelo item disputado + ${N} próprios) — zero duplicação`);
+  assert(svc.listPending(queueDir).length === 0 && markersIn(dirs.processing).length === 0, 'pending/ e processing/ ficaram vazios (nenhum item perdido no caminho)');
+}
+
+// ===========================================================================
+// E1b — o LOOP `serve` segue servindo depois de perder um item para OUTRO PROCESSO REAL.
+// O ladrão (escritor de trigger/operador — mutador sancionado por DF2-5) rouba o 2º item do snapshot
+// enquanto o worker executa o 1º. O worker precisa: pular o item, COMPLETAR os ciclos e sair 0.
+// ===========================================================================
+async function e1bServeSegueServindo() {
+  console.log('\n--- E1b: o loop `serve` perde um item para outro processo REAL e SEGUE servindo ---');
+  const root = tmpDir('e1b');
+  const queueDir = path.join(root, 'queue');
+  const stolenDir = path.join(root, 'stolen');
+  fs.mkdirSync(stolenDir, { recursive: true });
+  const dirs = svc.ensureQueue(queueDir);
+  fs.writeFileSync(path.join(dirs.pending, 'a-first.json'), JSON.stringify({ pod: 'demo', started_by: 'alice' }));
+  const target = path.join(dirs.pending, 'b-stolen.json');
+  fs.writeFileSync(target, JSON.stringify({ pod: 'demo', started_by: 'bob' }));
+
+  const stealNow = path.join(root, 'steal-now');
+  const stolen = path.join(root, 'stolen.flag');
+
+  const worker = writeChild(root, 'e1b-worker.cjs', `
+const svc = require(process.env.SVC);
+const cfg = { queueDir: process.env.QUEUE, bundleDir: null, runsRoot: process.env.RUNS, pollMs: 1 };
+svc.serve(cfg, {
+  log: () => {}, warn: () => {},
+  env: { ANTHROPIC_API_KEY: 'x', OPENROUTER_API_KEY: 'y' },
+  probeChrome: () => '/usr/bin/chromium',
+  sleep: async () => {}, stopAfter: 2,
+  runExecutor: async (c, processingPath) => {
+    if (processingPath.includes('a-first')) {
+      // O item 'b-stolen' JÁ está no snapshot deste ciclo. Enquanto processamos o 1º, um processo
+      // REAL rouba o 2º e confirma — a corrida acontece de fato, não é simulada.
+      fs.writeFileSync(process.env.STEAL_NOW, '1');
+      waitFile(process.env.STOLEN, 20000);
+    }
+    return { code: 0, result: { complete: true } };
+  },
+}).then((res) => { fs.writeFileSync(process.env.OUT, JSON.stringify({ cycles: res.cycles, processed: res.processed.length })); });
+`);
+  const thief = writeChild(root, 'e1b-thief.cjs', `
+waitFile(process.env.STEAL_NOW, 20000);
+fs.renameSync(process.env.TARGET, path.join(process.env.STOLEN_DIR, 'b.json')); // reivindicação REAL de outro processo
+fs.writeFileSync(process.env.STOLEN, '1');
+`);
+
+  const env = { SVC: SVC_PATH, QUEUE: queueDir, RUNS: path.join(root, 'runs'), STEAL_NOW: stealNow, STOLEN: stolen, OUT: path.join(root, 'out.json'), TARGET: target, STOLEN_DIR: stolenDir };
+  const [w, t] = await Promise.all([runChild(worker, env), runChild(thief, env)]);
+  assert(w.code === 0, 'o worker SOBREVIVEU (exit 0) à perda do item para outro processo');
+  if (w.code !== 0) console.error(w.err());
+  assert(t.code === 0, 'o ladrão (processo real) concluiu o roubo por rename');
+  const out = fs.existsSync(path.join(root, 'out.json')) ? readJson(path.join(root, 'out.json')) : null;
+  assert(out && out.cycles === 2, 'o loop COMPLETOU os 2 ciclos após a perda — segue servindo, não apenas "não lança"');
+  assert(out && out.processed === 1, 'exatamente 1 item processado (o roubado não foi processado duas vezes nem sumiu)');
+  assert(fs.existsSync(path.join(stolenDir, 'b.json')) && !fs.existsSync(target), 'o item roubado ficou com o ladrão (a fila não o reprocessou)');
+}
+
+// ===========================================================================
+// E2 — `reject` × `reject`: 4 PROCESSOS REAIS sobre o MESMO checkpoint.
+// Sem o fix (`existsSync` → `renameSync`, TOCTOU), o perdedor lança `ENOENT`; na UI real isso ocorre
+// dentro de um handler `async` do node:http → *unhandled rejection* → o processo MORRE.
+// ===========================================================================
+async function e2RejectDisputado() {
+  console.log('\n--- E2: reject × reject por 4 processos REAIS (1 rejeita, 3 recebem `gone`, ninguém morre) ---');
+  const root = tmpDir('e2');
+  const queueDir = path.join(root, 'queue');
+  const dirs = svc.ensureQueue(queueDir);
+  const runId = 'pex-hn-carousel-e2';
+  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', awaiting: 'montagem' }));
+
+  const N = 4;
+  const script = writeChild(root, 'e2-rejecter.cjs', `
+const uimod = require(process.env.UI);
+const cfg = { queueDir: process.env.QUEUE, runsRoot: process.env.RUNS };
+barrier();
+// SEM try/catch: no servidor real este código roda dentro de um handler async — um throw aqui é
+// *unhandled rejection* e mata o processo (foi o que o *assess* mediu).
+const r = uimod.rejectRun(cfg, process.env.RUNID, { reason: 'motivo ' + process.env.IDX, rejectedBy: 'daniel' });
+fs.writeFileSync(process.env.OUT, JSON.stringify(r));
+`);
+  const START_AT = startAt();
+  const results = await Promise.all(Array.from({ length: N }, (_, i) => runChild(script, {
+    UI: UI_PATH, QUEUE: queueDir, RUNS: path.join(root, 'runs'), RUNID: runId, OUT: path.join(root, `out-${i}.json`), IDX: String(i), START_AT,
+  })));
+  assert(results.every((r) => r.code === 0), `os ${N} processos SOBREVIVERAM ao reject disputado (exit 0) — a superfície de aprovação não cai`);
+  if (!results.every((r) => r.code === 0)) console.error(results.map((r) => r.err()).join('\n'));
+  const outs = Array.from({ length: N }, (_, i) => path.join(root, `out-${i}.json`)).filter(fs.existsSync).map(readJson);
+  assert(outs.filter((o) => o.ok === true).length === 1, 'EXATAMENTE 1 reject teve efeito (o item é reivindicado por rename antes de qualquer escrita)');
+  assert(outs.filter((o) => o.ok === false && o.gone === true).length === N - 1, `os outros ${N - 1} receberam \`gone\` (o estado que a UI já sabe renderizar: "já tratado")`);
+  assert(markersIn(dirs.blocked).length === 1 && markersIn(dirs.awaiting).length === 0, 'o checkpoint terminou em blocked/ UMA vez e saiu de awaiting/');
+  const res = readJson(path.join(dirs.blocked, `${runId}.result.json`));
+  assert(res.rejected === true && /motivo \d/.test(res.reason), 'o motivo registrado é o do vencedor (um único result.json, sem escrita concorrente)');
+  assert(!fs.existsSync(path.join(dirs.awaiting, `${runId}.result.json`)), 'o companion de awaiting/ foi removido pelo dono do item (nenhum checkpoint fantasma)');
+}
+
+// ===========================================================================
+// E2b — a UI REAL (servidor node:http em processo PRÓPRIO) responde `flash=gone` a um reject cuja
+// disputa foi perdida para OUTRO PROCESSO, e CONTINUA VIVA e atendendo.
+// (Premissa medida no *assess*, reverificada aqui: uma exceção em handler async do node:http mata o
+//  processo — é por isso que absorver `ENOENT` por errno, e só ele, é o que mantém a UI de pé.)
+// ===========================================================================
+function uiFixture(root) {
+  const queueDir = path.join(root, 'queue');
+  const runsRoot = path.join(root, 'runs');
+  const dirs = svc.ensureQueue(queueDir);
+  const runId = 'pex-hn-carousel-e2b';
+  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', awaiting: 'montagem', started_by: 'bob' }));
+  const runDir = path.join(runsRoot, 'hn-carousel', 'wf', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, 'state.json'), JSON.stringify({ run_id: runId, steps: {} }));
+  const identitiesFile = path.join(root, 'identities.json');
+  fs.writeFileSync(identitiesFile, JSON.stringify({ identities: [{ id: 'daniel', label: 'Daniel', is_approver: true }, { id: 'alice', label: 'Alice' }] }));
+  return { queueDir, runsRoot, runId, identitiesFile, dirs };
+}
+
+function httpReq(port, { method = 'GET', pathUrl = '/', cookie, body } = {}) {
+  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 }));
+    });
+    req.on('error', reject);
+    if (body != null) req.write(body);
+    req.end();
+  });
+}
+const cookieOf = (res) => { const sc = res.headers['set-cookie']; const m = sc && String(sc[0]).match(/pex_ui=([^;]*)/); return m ? `pex_ui=${m[1]}` : null; };
+
+async function e2bUiRealNaoMorre() {
+  console.log('\n--- E2b: UI REAL (processo próprio) perde a disputa → `flash=gone` e SEGUE ATENDENDO ---');
+  const root = tmpDir('e2b');
+  const fx = uiFixture(root);
+  const SESSION_KEY = 'k'.repeat(48);
+  const TEAM_SECRET = 'senha-da-equipe';
+  const portFile = path.join(root, 'port');
+
+  const server = writeChild(root, 'e2b-ui.cjs', `
+const uimod = require(process.env.UI);
+const svcmod = require(process.env.SVC);
+const cfg = uimod.loadUiConfig({
+  PODEXPORT_QUEUE_DIR: process.env.QUEUE, PODEXPORT_RUNS_DIR: process.env.RUNS,
+  PODEXPORT_IDENTITIES: process.env.IDS, PODEXPORT_UI_TEAM_HASH: process.env.TEAM_HASH,
+  PODEXPORT_UI_SESSION_KEY: process.env.SESSION_KEY, PODEXPORT_APPROVER_SECRET_HASH: process.env.APPROVER_HASH,
+  PODEXPORT_UI_INSECURE: '1',
+});
+process.env.PODEXPORT_IDENTITIES = process.env.IDS;
+const s = uimod.createServer(cfg, {});
+s.listen(0, '127.0.0.1', () => { fs.writeFileSync(process.env.PORT_FILE, String(s.address().port)); });
+`);
+  const teamHash = svc.hashApproverSecret(TEAM_SECRET);
+  const approverHash = svc.hashApproverSecret('segredo-do-aprovador');
+  const handle = runChild(server, {
+    UI: UI_PATH, SVC: SVC_PATH, QUEUE: fx.queueDir, RUNS: fx.runsRoot, IDS: fx.identitiesFile,
+    TEAM_HASH: teamHash, SESSION_KEY, APPROVER_HASH: approverHash, PORT_FILE: portFile,
+  }, { detached: true });
+  try {
+    await waitFor(() => fs.existsSync(portFile) && fs.readFileSync(portFile, 'utf8').length > 0, 10000, 'UI subir');
+    const port = Number(fs.readFileSync(portFile, 'utf8'));
+
+    let res = await httpReq(port, { method: 'POST', pathUrl: '/login', body: new URLSearchParams({ password: TEAM_SECRET }).toString() });
+    const cookie = cookieOf(res);
+    const sid = ui.verifySession(cookie.replace('pex_ui=', ''), SESSION_KEY).sid;
+    res = await httpReq(port, { method: 'POST', pathUrl: '/operator', cookie, body: new URLSearchParams({ operator: 'daniel', _csrf: ui.csrfToken(sid, SESSION_KEY) }).toString() });
+    const cookieOp = cookieOf(res) || cookie;
+    const csrf = ui.csrfToken(sid, SESSION_KEY);
+
+    // OUTRO PROCESSO REAL (o serviço, aprovando) reivindica o marcador antes do reject chegar.
+    const claimer = writeChild(root, 'e2b-claimer.cjs', `
+const svcmod = require(process.env.SVC);
+const r = svcmod.claimApproveMarker({ queueDir: process.env.QUEUE }, process.env.RUNID, {});
+fs.writeFileSync(process.env.OUT, JSON.stringify(r));
+`);
+    const c = await runChild(claimer, { SVC: SVC_PATH, QUEUE: fx.queueDir, RUNID: fx.runId, OUT: path.join(root, 'claim.json') });
+    assert(c.code === 0 && readJson(path.join(root, 'claim.json')).claimed === true, 'outro processo REAL reivindicou o checkpoint (awaiting/ → processing/)');
+
+    res = await httpReq(port, { method: 'POST', pathUrl: '/reject', cookie: cookieOp, body: new URLSearchParams({ run: fx.runId, reason: 'chegou tarde', _csrf: csrf }).toString() });
+    assert(res.status === 303 && /flash=gone/.test(res.headers.location || ''), 'reject que PERDEU a disputa → 303 `flash=gone` (a UI já sabe renderizar esse estado)');
+
+    const health = await httpReq(port, { pathUrl: '/health' });
+    assert(health.status === 200 && health.body === 'ok', 'a UI CONTINUA VIVA e atendendo depois da disputa perdida (antes: unhandled rejection → processo morto)');
+    const list = await httpReq(port, { pathUrl: '/?flash=gone', cookie: cookieOp });
+    assert(list.status === 200 && /já foi tratado por outra pessoa/.test(list.body), 'a lista renderiza a mensagem honesta de item já tratado');
+    assert(markersIn(fx.dirs.blocked).length === 0, 'o reject perdedor NÃO produziu efeito colateral em blocked/ (não escreveu motivo sobre item alheio)');
+  } finally {
+    handle.child.kill('SIGKILL');
+    await handle.done;
+  }
+
+  // Premissa de DF-SF10.16-1 reverificada NESTE runtime: exceção em handler async do node:http mata o
+  // processo. É o que tornava LETAL o `ENOENT` do reject — e o que a sanção por errno evita.
+  const boom = writeChild(root, 'e2b-unhandled.cjs', `
+const http = require('node:http');
+const s = http.createServer(async () => { throw new Error('ENOENT simulado em handler async'); });
+s.listen(0, '127.0.0.1', () => {
+  http.get({ host: '127.0.0.1', port: s.address().port, path: '/' }, () => {}).on('error', () => {});
+});
+setTimeout(() => process.exit(0), 5000);
+`);
+  const r = await runChild(boom, {});
+  assert(r.code === 1, 'premissa (DF-SF10.16-1): um throw em handler async do node:http DERRUBA o processo (exit 1) — daí a letalidade do ENOENT não sancionado');
+}
+
+// ===========================================================================
+// E3 — `approve` × `approve` no mesmo runId: 3 PROCESSOS REAIS. O gasto de LLM é o dano.
+// Sem o fix: 3 spawns do executor sobre o MESMO runDir. Com o fix: EXATAMENTE 1.
+// ===========================================================================
+async function e3ApproveDisputado() {
+  console.log('\n--- E3: approve × approve por 3 processos REAIS → EXATAMENTE 1 spawn do executor ---');
+  const root = tmpDir('e3');
+  const queueDir = path.join(root, 'queue');
+  const spawnLog = path.join(root, 'spawnlog');
+  fs.mkdirSync(spawnLog, { recursive: true });
+  const dirs = svc.ensureQueue(queueDir);
+  const runId = 'pex-hn-carousel-e3';
+  fs.writeFileSync(path.join(dirs.awaiting, `${runId}.json`), JSON.stringify({ pod: 'hn-carousel', started_by: 'bob' }));
+  const secretHash = svc.hashApproverSecret('correct horse');
+
+  const N = 3;
+  const script = writeChild(root, 'e3-approver.cjs', `
+const { EventEmitter } = require('node:events');
+const svcmod = require(process.env.SVC);
+const cfg = { queueDir: process.env.QUEUE, bundleDir: '/opt/bundle', runsRoot: process.env.RUNS, pollMs: 1 };
+const idModel = { identities: [{ id: 'daniel', is_approver: true }], approver: { id: 'daniel', is_approver: true }, byId: { daniel: { id: 'daniel', is_approver: true } } };
+// spawn INJETADO que deixa RASTRO EM DISCO: é o contador cross-processo de invocações do executor
+// (cada uma seria, em produção, uma execução de LLM paga).
+const fakeSpawn = (bin, args) => {
+  fs.writeFileSync(path.join(process.env.SPAWNLOG, 'spawn-' + process.env.IDX), args.join(' '));
+  const ch = new EventEmitter(); ch.stdout = new EventEmitter();
+  setTimeout(() => { ch.stdout.emit('data', Buffer.from('RESULTADO: {"approved":true}\\n')); ch.emit('exit', 0); }, 120);
+  return ch;
+};
+(async () => {
+  barrier();
+  const r = await svcmod.approveRun(cfg, process.env.RUNID, {
+    spawn: fakeSpawn, log: () => {},
+    identityModel: idModel, asId: 'daniel', approverSecret: 'correct horse', approverSecretHash: process.env.SECRET_HASH,
+    findStateByRunId: () => null, // run ainda em progresso → nada a reconciliar (marcador volta a awaiting/)
+  });
+  fs.writeFileSync(process.env.OUT, JSON.stringify(r));
+})();
+`);
+  const START_AT = startAt();
+  const results = await Promise.all(Array.from({ length: N }, (_, i) => runChild(script, {
+    SVC: SVC_PATH, QUEUE: queueDir, RUNS: path.join(root, 'runs'), RUNID: runId, SPAWNLOG: spawnLog,
+    SECRET_HASH: secretHash, OUT: path.join(root, `out-${i}.json`), IDX: String(i), START_AT,
+  })));
+  assert(results.every((r) => r.code === 0), `os ${N} processos de approve terminaram sem crash`);
+  const spawns = fs.readdirSync(spawnLog);
+  assert(spawns.length === 1, `EXATAMENTE 1 spawn do executor entre ${N} approves concorrentes (${spawns.length}) — duplo gasto de LLM fechado`);
+  const outs = Array.from({ length: N }, (_, i) => path.join(root, `out-${i}.json`)).filter(fs.existsSync).map(readJson);
+  assert(outs.filter((o) => o.code === 0 && !o.denied).length === 1, 'exatamente 1 approve teve efeito');
+  const gone = outs.filter((o) => o.denied === true && o.gone === true);
+  assert(gone.length === N - 1 && gone.every((o) => /reivindicado/.test(o.reason)), `os outros ${N - 1} foram recusados como disputa perdida (\`gone\`), não como erro de segredo`);
+  assert(markersIn(dirs.awaiting).length === 1 && markersIn(dirs.processing).length === 0,
+    'sem reconciliação, o marcador VOLTOU a awaiting/ (checkpoint segue retomável; nada preso em processing/)');
+}
+
+// ===========================================================================
+// E3b — §4a do gate: a reivindicação NÃO regride o gate de autorização de DF3-3 (SF10.4).
+// Ela vem estritamente DEPOIS da decisão de auth e é CONDICIONAL ao marcador existir.
+// ===========================================================================
+async function e3bGateDeAutorizacaoIntacto() {
+  console.log('\n--- E3b: a reivindicação não autoriza o que o segredo recusaria, nem recusa o que ele autorizaria ---');
+  const root = tmpDir('e3b');
+  const queueDir = path.join(root, 'queue');
+  const dirs = svc.ensureQueue(queueDir);
+  const runId = 'pex-gate-1';
+  fs.writeFileSync(path.join(dirs.awaiting, `${runId}.json`), JSON.stringify({ pod: 'hn' }));
+  const cfg = { queueDir, bundleDir: '/opt/bundle', runsRoot: path.join(root, 'runs'), pollMs: 1 };
+  const idModel = { identities: [{ id: 'daniel', is_approver: true }, { id: 'alice' }], approver: { id: 'daniel', is_approver: true }, byId: { daniel: { id: 'daniel', is_approver: true }, alice: { id: 'alice' } } };
+  const secretHash = svc.hashApproverSecret('correct horse');
+  let spawns = 0;
+  const { EventEmitter } = require('node:events');
+  const fakeSpawn = () => {
+    spawns++;
+    const ch = new EventEmitter(); ch.stdout = new EventEmitter();
+    setImmediate(() => { ch.stdout.emit('data', Buffer.from('RESULTADO: {"approved":true}\n')); ch.emit('exit', 0); });
+    return ch;
+  };
+  const base = { spawn: fakeSpawn, log: () => {}, identityModel: idModel, asId: 'daniel', approverSecret: 'correct horse', approverSecretHash: secretHash, findStateByRunId: () => null };
+
+  const wrongSecret = await svc.approveRun(cfg, runId, { ...base, approverSecret: 'chute' });
+  assert(wrongSecret.denied && /segredo do aprovador inválido/.test(wrongSecret.reason) && spawns === 0, 'segredo ERRADO → recusa do gate DF3-3 (sem spawn)');
+  assert(markersIn(dirs.awaiting).length === 1 && markersIn(dirs.processing).length === 0, 'recusa por segredo NÃO reivindica o marcador (ele fica intocado em awaiting/)');
+
+  const notApprover = await svc.approveRun(cfg, runId, { ...base, asId: 'alice' });
+  assert(notApprover.denied && /aprovadora designada/.test(notApprover.reason) && spawns === 0, 'identidade NÃO-aprovadora → recusa do gate DF3-3 (sem spawn)');
+  assert(markersIn(dirs.awaiting).length === 1, 'recusa por identidade NÃO consome o marcador');
+
+  const badId = await svc.approveRun(cfg, '../etc/passwd', base);
+  assert(badId.denied && badId.code === 3 && spawns === 0 && markersIn(dirs.awaiting).length === 1, 'runId inválido (SF10.9/AC5) continua recusado ANTES de qualquer efeito de fila');
+
+  const ok = await svc.approveRun(cfg, runId, base);
+  assert(ok.code === 0 && !ok.denied && spawns === 1, 'autorização VÁLIDA → aprova normalmente (a reivindicação não recusa quem o segredo autoriza)');
+  assert(markersIn(dirs.awaiting).length === 1 && markersIn(dirs.processing).length === 0, 'após o approve sem reconciliação, o marcador volta a awaiting/ (estado observável idêntico ao pré-SF10.16)');
+
+  // Approve FORA-DA-FILA (run que nunca teve marcador): comportamento INALTERADO — a reivindicação é
+  // condicional à existência do marcador, nunca um novo motivo de recusa.
+  const outOfQueue = await svc.approveRun(cfg, 'pex-sem-marcador', base);
+  assert(outOfQueue.code === 0 && !outOfQueue.denied && spawns === 2, 'approve de run SEM marcador na fila segue funcionando (reivindicação condicional, não é novo gate)');
+  const claim = svc.claimApproveMarker(cfg, 'pex-sem-marcador');
+  assert(claim.claimed === false && claim.absent === true, 'claimApproveMarker distingue AUSENTE (fora-da-fila) de OCUPADO (disputa perdida)');
+}
+
+// ===========================================================================
+// E4 — publicação atômica: um payload NUNCA é observado meio-publicado em pending/.
+// Publicador e observador são PROCESSOS REAIS e simultâneos; os payloads são grandes de propósito
+// (a janela de escrita de `writeFileSync` direto no destino era exatamente o defeito).
+// ===========================================================================
+async function e4PublicacaoAtomica() {
+  console.log('\n--- E4: publicação em pending/ é atômica (observador REAL nunca vê payload parcial) ---');
+  const root = tmpDir('e4');
+  const queueDir = path.join(root, 'queue');
+  const dirs = svc.ensureQueue(queueDir);
+  const idsFile = path.join(root, 'identities.json');
+  fs.writeFileSync(idsFile, JSON.stringify({ identities: [{ id: 'daniel', is_approver: true }, { id: 'alice' }] }));
+  // payload gordo (~2MB): alarga a escrita e torna a janela da publicação não-atômica observável.
+  const srcDir = path.join(root, 'src');
+  fs.mkdirSync(srcDir, { recursive: true });
+  const K = 5;
+  for (let i = 0; i < K; i++) {
+    fs.writeFileSync(path.join(srcDir, `p${i}.json`), JSON.stringify({ pod: 'demo', started_by: 'alice', filler: 'x'.repeat(2 * 1024 * 1024) }));
+  }
+
+  const publisher = writeChild(root, 'e4-publisher.cjs', `
+const svcmod = require(process.env.SVC);
+const cfg = { queueDir: process.env.QUEUE, identitiesFile: process.env.IDS };
+barrier();
+for (let i = 0; i < Number(process.env.K); i++) svcmod.enqueue(cfg, path.join(process.env.SRC, 'p' + i + '.json'));
+fs.writeFileSync(process.env.PUB_DONE, '1');
+`);
+  const observer = writeChild(root, 'e4-observer.cjs', `
+const pend = path.join(process.env.QUEUE, 'pending');
+const seen = new Set();
+const first = [];
+barrier();
+const deadline = Date.now() + 20000;
+let polls = 0;
+// Espia como o SERVIÇO espia: \`readdir\` em laço e, no INSTANTE em que um nome aparece (o instante
+// em que \`processOne\` o reivindicaria), afere o item. A publicação não-atômica torna o nome visível
+// no \`open(O_CREAT|O_TRUNC)\`, ANTES do conteúdo: o \`stat\` de primeira visão flagra 0 byte — e era
+// esse payload vazio que o executor recebia, com \`started_by: null\` no ledger.
+while (Date.now() < deadline) {
+  polls++;
+  let files = [];
+  try { files = fs.readdirSync(pend).filter((f) => f.endsWith('.json')); } catch { files = []; }
+  for (const f of files) {
+    if (seen.has(f)) continue;
+    seen.add(f);
+    let size = -1;
+    try { size = fs.statSync(path.join(pend, f)).size; } catch { size = -1; }
+    let raw = ''; let parsed = false; let startedBy = null;
+    try { raw = fs.readFileSync(path.join(pend, f), 'utf8'); } catch { raw = ''; }
+    try { const o = JSON.parse(raw); parsed = true; startedBy = o.started_by || null; } catch { parsed = false; }
+    first.push({ f, size, parsed, startedBy });
+  }
+  if (fs.existsSync(process.env.PUB_DONE) && seen.size >= Number(process.env.K)) break;
+}
+const partial = first.filter((x) => x.size <= 0 || !x.parsed || x.startedBy === null);
+fs.writeFileSync(process.env.OUT, JSON.stringify({ polls, seen: seen.size, partialCount: partial.length, partial: partial.slice(0, 5) }));
+`);
+  const START_AT = startAt();
+  const env = { SVC: SVC_PATH, QUEUE: queueDir, IDS: idsFile, SRC: srcDir, K: String(K), PUB_DONE: path.join(root, 'pub-done'), START_AT };
+  const [p, o] = await Promise.all([
+    runChild(publisher, env),
+    runChild(observer, { ...env, OUT: path.join(root, 'obs.json') }),
+  ]);
+  assert(p.code === 0, 'o publicador (processo real) enfileirou os payloads sem erro');
+  if (p.code !== 0) console.error(p.err());
+  assert(o.code === 0, 'o observador (processo real) rodou até o fim');
+  const obs = readJson(path.join(root, 'obs.json'));
+  assert(obs.seen === K, `o observador viu os ${K} payloads publicados (${obs.seen})`);
+  assert(obs.polls > 50, `o observador amostrou a fila em laço apertado durante as publicações (${obs.polls} varreduras) — a janela, se existisse, seria vista`);
+  assert(obs.partialCount === 0, `NENHUMA observação parcial em ${K} publicações concorrentes (${obs.partialCount}) — o item existe COMPLETO ou não existe`);
+  if (obs.partialCount > 0) console.error(JSON.stringify(obs.partial, null, 2));
+  assert(svc.listPending(queueDir).length === K, 'pending/ contém exatamente os payloads publicados');
+  assert(fs.existsSync(path.join(queueDir, svc.TMP_SUBDIR)) && fs.readdirSync(path.join(queueDir, svc.TMP_SUBDIR)).length === 0,
+    '`.tmp/` existe (criado por ensureQueue) e NÃO acumula lixo após as publicações');
+  assert(!svc.listPending(queueDir).some((p2) => p2.includes(svc.TMP_SUBDIR)), 'listPending continua lendo SÓ pending/ (a área temporária está fora do caminho de dados)');
+}
+
+// ===========================================================================
+// E4b — o gate `started_by` de DF3-3 deixa de ser evadível: um payload meio-publicado (o estado
+// EXATO medido no *assess*: nome visível, conteúdo vazio) NUNCA é despachado ao executor.
+// ===========================================================================
+async function e4bPayloadParcialNaoEDespachado() {
+  console.log('\n--- E4b: payload meio-publicado NUNCA é despachado (gate started_by de DF3-3 não é evadível) ---');
+  const root = tmpDir('e4b');
+  const queueDir = path.join(root, 'queue');
+  const dirs = svc.ensureQueue(queueDir);
+  const cfg = { queueDir, bundleDir: null, runsRoot: path.join(root, 'runs'), pollMs: 1 };
+  // Estado exato do defeito: `open(O_CREAT|O_TRUNC)` tornou o nome visível; o conteúdo ainda não foi
+  // escrito. `listPending` JÁ o enxerga.
+  const partial = path.join(dirs.pending, 'meio-publicado.json');
+  fs.closeSync(fs.openSync(partial, 'w'));
+  assert(svc.listPending(queueDir).length === 1, 'um arquivo recém-criado e VAZIO já é visível ao readdir do serviço (a janela existe)');
+
+  let dispatched = 0;
+  const r = await svc.processOne(cfg, partial, { log: () => {}, runExecutor: async () => { dispatched++; return { code: 0, result: { complete: true } }; } });
+  assert(dispatched === 0, 'o executor NÃO foi disparado com payload vazio (nenhum gasto de LLM sobre lixo)');
+  assert(r.kind === 'failed' && r.rejectedPayload === true, 'o item foi roteado a failed/ com o motivo explícito (fail-loud, não silêncio)');
+  const res = readJson(r.resultPath);
+  assert(/ILEG[IÍ]VEL|incompleto/i.test(res.error) && res.started_by === null && res.ok === false, 'o result.json registra a causa; nenhum run anônimo foi "concluído"');
+  assert(!fs.existsSync(svc.usageLogPath(cfg)), 'o ledger de uso NÃO recebeu registro anônimo (antes: `started_by: null` gravado em silêncio)');
+  assert(markersIn(dirs.failed).length === 1 && markersIn(dirs.pending).length === 0, 'o item saiu de pending/ e ficou visível em failed/ para triagem');
+
+  // Não-regressão: payload legado SEM started_by (drop direto sancionado por DF2-5) continua sendo
+  // processado, registrando started_by null — a tolerância que já existia NÃO foi endurecida.
+  const legacy = path.join(dirs.pending, 'legado.json');
+  fs.writeFileSync(legacy, JSON.stringify({ pod: 'demo' }));
+  const r2 = await svc.processOne(cfg, legacy, { log: () => {}, runExecutor: async () => ({ code: 0, result: { complete: true } }) });
+  assert(r2.kind === 'done' && r2.claimed === true, 'não-regressão: payload JSON válido sem started_by continua sendo processado (tolerância de DF2-5 preservada)');
+}
+
+// ===========================================================================
+// AC4 — lock de instância (`O_EXCL`): recusa acionável, tomada de órfão após SIGKILL, liberação em
+// SIGTERM. Restrição dominante: NENHUM caminho pode imobilizar o serviço permanentemente.
+// ===========================================================================
+function serveChildScript(root) {
+  return writeChild(root, 'serve-forever.cjs', `
+const svcmod = require(process.env.SVC);
+const cfg = { queueDir: process.env.QUEUE, bundleDir: null, runsRoot: process.env.RUNS, pollMs: 5 };
+svcmod.serve(cfg, {
+  log: (m) => console.log(m), warn: (m) => console.error(m),
+  env: { ANTHROPIC_API_KEY: 'x', OPENROUTER_API_KEY: 'y' },
+  probeChrome: () => '/usr/bin/chromium',
+  stopAfter: Number(process.env.STOP_AFTER || 0) || undefined,
+  runExecutor: async () => ({ code: 0, result: { complete: true } }),
+}).then(() => process.exit(0)).catch((e) => { console.error(e.message); process.exit(1); });
+`);
+}
+
+async function ac4LockDeInstancia() {
+  console.log('\n--- AC4: lock O_EXCL de instância única do `serve` (processos REAIS: recusa, SIGTERM, órfão de SIGKILL) ---');
+  const root = tmpDir('lock');
+  const queueDir = path.join(root, 'queue');
+  svc.ensureQueue(queueDir);
+  const lockPath = svc.serviceLockPath(queueDir);
+  const script = serveChildScript(root);
+  const env = { SVC: SVC_PATH, QUEUE: queueDir, RUNS: path.join(root, 'runs') };
+
+  // (1) 1º serve toma o lock.
+  const a = runChild(script, env, { detached: true });
+  await waitFor(() => fs.existsSync(lockPath), 10000, 'lock criado pelo 1º serve');
+  const held = readJson(lockPath);
+  assert(held.pid === a.child.pid && typeof held.startedAt === 'string' && held.host === os.hostname(),
+    'o 1º `serve` gravou {pid, host, startedAt} em <queue>/.service.lock');
+
+  // (2) 2º serve na MESMA fila → RECUSA fail-loud com mensagem acionável.
+  const b = await runChild(script, env);
+  assert(b.code === 1, 'um SEGUNDO `serve` na mesma fila é RECUSADO (exit != 0) — a invariante deixou de ser pressuposta');
+  const msg = b.err() + b.out();
+  assert(/FAIL-LOUD/.test(msg) && new RegExp(`pid ${a.child.pid}`).test(msg) && /systemctl stop|remova/.test(msg) && msg.includes(lockPath),
+    'a recusa é ACIONÁVEL: cita pid, desde quando, o arquivo e como limpar');
+
+  // (3) SIGTERM libera o lock (sem isso, todo `systemctl stop` deixaria órfão).
+  a.child.kill('SIGTERM');
+  await a.done;
+  await waitFor(() => !fs.existsSync(lockPath), 10000, 'lock liberado no SIGTERM');
+  assert(!fs.existsSync(lockPath), 'SIGTERM (o sinal do `systemctl stop`) LIBERA o lock');
+
+  // (4) e o serviço sobe de novo normalmente depois disso (nada ficou imobilizado).
+  const c = await runChild(script, { ...env, STOP_AFTER: '1' });
+  assert(c.code === 0, 'após a liberação, um novo `serve` sobe normalmente');
+  assert(!fs.existsSync(lockPath), 'saída limpa também libera o lock');
+
+  // (5) SIGKILL deixa lock órfão → o serviço seguinte TOMA POSSE com aviso alto (autocura).
+  const d = runChild(script, env, { detached: true });
+  await waitFor(() => fs.existsSync(lockPath), 10000, 'lock do 3º serve');
+  const orphanPid = readJson(lockPath).pid;
+  d.child.kill('SIGKILL');
+  await d.done;
+  assert(fs.existsSync(lockPath), 'SIGKILL deixa o lock para trás (é o caso que a tomada de posse cobre)');
+  const e = await runChild(script, { ...env, STOP_AFTER: '1' });
+  const emsg = e.err() + e.out();
+  assert(e.code === 0, 'após SIGKILL do dono, o serviço SOBE SOZINHO (o lock nunca causa indisponibilidade permanente)');
+  assert(/AVISO ALTO/.test(emsg) && /[óo]rf[ãa]o/i.test(emsg) && emsg.includes(String(orphanPid)),
+    'a tomada de posse é ANUNCIADA alto (órfão + pid morto), nunca silenciosa');
+}
+
+// ===========================================================================
+// LOCK-1 (achado do gate `pc-qa`) — o lock TEM QUE SERIALIZAR ARRANQUES CONCORRENTES.
+// Defeito medido pelo QA: `openSync(lockPath,'wx')` criava o arquivo VAZIO e só depois o preenchia;
+// nessa janela o 2º arranque lia vazio, concluía "órfão/corrompido" e REMOVIA o lock VIVO do
+// vencedor — 2 donos em 20/20 (N=2, órfão) e 4-5 donos em 15/15 (N=6, fresco). É o MESMO defeito que
+// esta story fecha em `pending/` (nome visível antes do conteúdo), não aplicado ao próprio lock.
+// Aqui os DOIS cenários do QA rodam com processos REAIS, no N e nas iterações que ele exigiu.
+// ===========================================================================
+async function lock1ArranquesConcorrentes() {
+  console.log('\n--- LOCK-1: arranques REAIS concorrentes → EXATAMENTE 1 dono (cenários do gate) ---');
+  const root = tmpDir('lock1');
+  const script = writeChild(root, 'lock1-acquire.cjs', `
+const svc = require(process.env.SVC);
+const cfg = { queueDir: process.env.QUEUE };
+barrier();
+// Sem try/catch: adquirir OU recusar fail-loud (a recusa é uma exceção, e sair != 0 é o esperado
+// para quem perde). Quem adquire grava um arquivo PRÓPRIO — a contagem de donos é feita em disco.
+let handle = null;
+try {
+  handle = svc.acquireServiceLock(cfg, { log: () => {}, warn: () => {} });
+} catch (e) {
+  fs.writeFileSync(path.join(process.env.OUTDIR, 'recusa-' + process.env.IDX), String(e.message).slice(0, 400));
+  process.exit(3);
+}
+fs.writeFileSync(path.join(process.env.OUTDIR, 'dono-' + process.env.IDX), JSON.stringify(handle));
+// O vencedor PERMANECE VIVO até todos os concorrentes terem arbitrado (SF10.19, correção de
+// premissa do harness — nenhuma asserção mudou). Sem isto, o vencedor saía em milissegundos e um
+// perdedor lento encontrava o lock com pid MORTO: o produto então toma posse como ÓRFÃO, que é o
+// comportamento ESPECIFICADO (e asserido pelo cenário 1 logo abaixo) — e a contagem via 2 donos
+// sob carga, sem nenhum defeito real. Um serviço de verdade não morre 5 ms depois de subir; a
+// disputa que LOCK-1 mede é entre arranques VIVOS. Espera ADAPTATIVA (custo ~0 quando rápido).
+const deadline = Date.now() + 5000;
+const esperados = Number(process.env.NPEERS || 0);
+while (fs.readdirSync(process.env.OUTDIR).length < esperados && Date.now() < deadline) { /* spin */ }
+process.exit(0);
+`);
+
+  // --- Cenário 1 do QA: lock ÓRFÃO (pid morto) + N=2, 20 iterações ---
+  const dead = spawnSync(process.execPath, ['-e', 'process.exit(0)']);
+  let donos1 = []; let recusas1 = [];
+  for (let it = 0; it < 20; it++) {
+    const queueDir = path.join(root, `orfao-${it}`);
+    const dirs = svc.ensureQueue(queueDir);
+    const outDir = path.join(queueDir, 'out'); fs.mkdirSync(outDir, { recursive: true });
+    // órfão COMPLETO (como o mecanismo passa a publicar): pid comprovadamente morto.
+    fs.writeFileSync(svc.serviceLockPath(queueDir), JSON.stringify({ pid: dead.pid, host: os.hostname(), startedAt: '2026-08-01T00:00:00Z' }));
+    const START_AT = startAt(220);
+    await Promise.all([0, 1].map((i) => runChild(script, { SVC: SVC_PATH, QUEUE: queueDir, OUTDIR: outDir, IDX: String(i), START_AT, NPEERS: '2' })));
+    donos1.push(fs.readdirSync(outDir).filter((f) => f.startsWith('dono-')).length);
+    recusas1.push(fs.readdirSync(outDir).filter((f) => f.startsWith('recusa-')).length);
+    void dirs;
+  }
+  assert(donos1.every((d) => d === 1), `ÓRFÃO, N=2, 20 iterações → EXATAMENTE 1 dono em todas (distribuição: ${JSON.stringify(donos1)})`);
+  assert(recusas1.every((r) => r === 1), 'o perdedor RECUSA fail-loud (nunca dois donos, nunca dois silêncios)');
+
+  // --- Cenário 2 do QA: arranque FRESCO (sem lock) + N=6, 15 iterações ---
+  const N = 6;
+  let donos2 = [];
+  for (let it = 0; it < 15; it++) {
+    const queueDir = path.join(root, `fresco-${it}`);
+    svc.ensureQueue(queueDir);
+    const outDir = path.join(queueDir, 'out'); fs.mkdirSync(outDir, { recursive: true });
+    const START_AT = startAt(260);
+    await Promise.all(Array.from({ length: N }, (_, i) => runChild(script, { SVC: SVC_PATH, QUEUE: queueDir, OUTDIR: outDir, IDX: String(i), START_AT, NPEERS: String(N) })));
+    donos2.push(fs.readdirSync(outDir).filter((f) => f.startsWith('dono-')).length);
+  }
+  assert(donos2.every((d) => d === 1), `FRESCO, N=${N}, 15 iterações → EXATAMENTE 1 dono em todas (distribuição: ${JSON.stringify(donos2)})`);
+
+  // A causa-raiz, em teste direto: o arquivo de lock NUNCA existe vazio/incompleto.
+  const q = path.join(root, 'atomicidade');
+  const d = svc.ensureQueue(q);
+  const h = svc.acquireServiceLock({ queueDir: q }, { log: () => {}, warn: () => {} });
+  const conteudo = fs.readFileSync(svc.serviceLockPath(q), 'utf8');
+  assert(conteudo.length > 0 && JSON.parse(conteudo).pid === process.pid,
+    'o lock é publicado COMPLETO (tmp + link), nunca criado vazio para preencher depois');
+  assert(fs.readdirSync(d.tmp).length === 0, 'a publicação do lock não deixa lixo em .tmp/');
+  svc.releaseServiceLock(h, { warn: () => {} });
+}
+
+function ac4ArbitragemUnitaria() {
+  console.log('\n--- AC4: arbitragem do lock (ilegível, host estrangeiro, EPERM=vivo, ESRCH=morto) ---');
+  const queueDir = tmpDir('arb');
+  svc.ensureQueue(queueDir);
+  const cfg = { queueDir };
+  const lockPath = svc.serviceLockPath(queueDir);
+  const quiet = { log: () => {}, warn: () => {} };
+
+  // Liveness: EPERM (pid 1, sem permissão de sinalizar) conta como VIVO; pid morto → ESRCH → falso.
+  const dead = spawnSync(process.execPath, ['-e', 'process.exit(0)']);
+  assert(svc.pidAlive(process.pid) === true, 'pidAlive: o próprio processo está VIVO');
+  assert(svc.pidAlive(dead.pid) === false, 'pidAlive: pid comprovadamente morto (ESRCH) → morto');
+  assert(svc.pidAlive(1) === true, 'pidAlive: pid 1 (EPERM para não-root) conta como VIVO — EPERM NUNCA é lido como morto');
+
+  // (a) lock ilegível → assume órfão, avisa alto e TOMA POSSE (jamais imobiliza).
+  fs.writeFileSync(lockPath, 'lixo{corrompido');
+  const warns = [];
+  const h1 = svc.acquireServiceLock(cfg, { log: () => {}, warn: (m) => warns.push(m) });
+  assert(h1 && readJson(lockPath).pid === process.pid, 'lock ILEGÍVEL → tomada de posse (um lock corrompido não pode travar o serviço)');
+  assert(warns.some((w) => /AVISO ALTO/.test(w) && /ileg[ií]vel|corrompido/i.test(w)), 'a tomada de posse de lock ilegível é avisada ALTO');
+  assert(svc.releaseServiceLock(h1, quiet) === true && !fs.existsSync(lockPath), 'releaseServiceLock remove o lock do próprio dono');
+
+  // (b) host diferente → RECUSA fail-loud (a fila é local por contrato).
+  fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, host: 'outro-host', startedAt: 'x' }));
+  const m = messageOf(() => svc.acquireServiceLock(cfg, quiet));
+  assert(/FAIL-LOUD/.test(m) && /outro-host/.test(m), 'lock de OUTRO HOST → recusa fail-loud citando o host');
+
+  // (c) pid VIVO no mesmo host → RECUSA acionável.
+  fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, host: os.hostname(), startedAt: '2026-08-01T00:00:00Z' }));
+  const m2 = messageOf(() => svc.acquireServiceLock(cfg, quiet));
+  assert(/FAIL-LOUD/.test(m2) && new RegExp(`pid ${process.pid}`).test(m2) && /systemctl stop/.test(m2), 'pid VIVO → recusa com pid, desde quando e como limpar');
+
+  // (d) pid MORTO no mesmo host → toma posse com aviso.
+  fs.writeFileSync(lockPath, JSON.stringify({ pid: dead.pid, host: os.hostname(), startedAt: '2026-08-01T00:00:00Z' }));
+  const warns2 = [];
+  const h2 = svc.acquireServiceLock(cfg, { log: () => {}, warn: (m3) => warns2.push(m3) });
+  assert(h2 && readJson(lockPath).pid === process.pid && warns2.some((w) => /AVISO ALTO/.test(w)), 'pid MORTO (ESRCH) → tomada de posse anunciada');
+  svc.releaseServiceLock(h2, quiet);
+
+  // (e) release NÃO remove lock de outro dono (nunca desarma o sucessor).
+  fs.writeFileSync(lockPath, JSON.stringify({ pid: 999999, host: os.hostname(), startedAt: 'x' }));
+  assert(svc.releaseServiceLock({ path: lockPath, pid: process.pid }, quiet) === false && fs.existsSync(lockPath),
+    'release NÃO remove um lock que pertence a outro pid (não desarma o sucessor)');
+  fs.unlinkSync(lockPath);
+
+  // (f) a UI NÃO toma lock (ela não reivindica pending/; duas UIs já colidem na porta).
+  const uiFns = Object.keys(ui);
+  assert(!uiFns.some((k) => /lock/i.test(k)), 'a UI não expõe nenhum mecanismo de lock (DF-SF10.16-3: só o `serve` assere instância única)');
+}
+
+// ===========================================================================
+// AC5 — órfãos de processing/ são RELATADOS no arranque; requeue automático é PROIBIDO.
+// ===========================================================================
+async function ac5OrfaosRelatadosSemRequeue() {
+  console.log('\n--- AC5: órfãos de processing/ relatados no arranque, SEM requeue automático ---');
+  const root = tmpDir('orfaos');
+  const queueDir = path.join(root, 'queue');
+  const dirs = svc.ensureQueue(queueDir);
+  fs.writeFileSync(path.join(dirs.processing, 'pex-orfao-1.json'), JSON.stringify({ pod: 'hn' }));
+  fs.writeFileSync(path.join(dirs.processing, 'pex-orfao-2.json'), JSON.stringify({ pod: 'hn' }));
+  fs.writeFileSync(path.join(dirs.processing, 'pex-orfao-1.result.json'), JSON.stringify({ runId: 'pex-orfao-1' }));
+
+  const warns = [];
+  const orphans = svc.reportProcessingOrphans({ queueDir }, { warn: (m) => warns.push(m) });
+  assert(orphans.length === 2 && orphans.every((o) => typeof o.ageMs === 'number'), 'os 2 marcadores órfãos são listados com idade (o `.result.json` companion não conta como item)');
+  assert(warns.some((w) => /AVISO ALTO/.test(w) && /REQUEUE AUTOM[ÁA]TICO N[ÃA]O/.test(w)), 'o relato é ALTO e diz explicitamente que não houve requeue');
+  assert(markersIn(dirs.processing).length === 2 && svc.listPending(queueDir).length === 0,
+    'PROIBIDO requeue automático: os itens continuam em processing/ e pending/ segue vazio (o run pode ter gasto LLM e escrito runDir parcial)');
+
+  // No arranque REAL do serviço (processo próprio), o mesmo relato aparece no log e nada se move.
+  const script = serveChildScript(root);
+  const r = await runChild(script, { SVC: SVC_PATH, QUEUE: queueDir, RUNS: path.join(root, 'runs'), STOP_AFTER: '1' });
+  assert(r.code === 0, 'o serviço SOBE normalmente com órfãos em processing/ (relato não bloqueia o arranque)');
+  assert(/AVISO ALTO/.test(r.err()) && /processing\//.test(r.err()), 'o arranque real LOGA os órfãos (antes: silêncio absoluto — nem reprocessava nem avisava)');
+  assert(markersIn(dirs.processing).length === 2, 'após o arranque real, os órfãos continuam onde estavam (triagem é ação de operador)');
+}
+
+// ===========================================================================
+// §4b do gate — `ENOENT` é o ÚNICO errno absorvido: nada de catch-all disfarçado.
+// ===========================================================================
+function ac2SancaoPorErrno() {
+  console.log('\n--- AC2/§4b: só ENOENT é absorvido no rename de reivindicação; todo o resto falha ALTO ---');
+  const root = tmpDir('errno');
+  const src = path.join(root, 'src.json');
+  fs.writeFileSync(src, '{}');
+
+  assert(svc.claimByRename(path.join(root, 'nao-existe.json'), path.join(root, 'dest.json')) === false,
+    'ENOENT (item já reivindicado por outro ator) → false, sem lançar — o caminho normal da disputa');
+  assert(svc.claimByRename(src, path.join(root, 'dest.json')) === true && fs.existsSync(path.join(root, 'dest.json')),
+    'rename bem-sucedido → true (a reivindicação É a autorização de agir)');
+
+  // ENOTDIR: destino cujo "diretório" pai é um ARQUIVO. Determinístico e independente de uid/SO.
+  const file = path.join(root, 'sou-um-arquivo');
+  fs.writeFileSync(file, 'x');
+  const src2 = path.join(root, 'src2.json'); fs.writeFileSync(src2, '{}');
+  let err = null;
+  try { svc.claimByRename(src2, path.join(file, 'dest.json')); } catch (e) { err = e; }
+  assert(err && err.code === 'ENOTDIR', `errno ENOTDIR RELANÇADO (${err && err.code}) — nunca engolido junto com o ENOENT`);
+  assert(fs.existsSync(src2), 'o item permanece intocado quando o rename falha por errno não sancionado');
+
+  // EACCES: diretório de destino sem permissão de escrita (root ignora modos — pulado nesse caso).
+  if (!IS_ROOT) {
+    const locked = path.join(root, 'sem-permissao');
+    fs.mkdirSync(locked);
+    fs.chmodSync(locked, 0o500);
+    let err2 = null;
+    try { svc.claimByRename(src2, path.join(locked, 'dest.json')); } catch (e) { err2 = e; }
+    assert(err2 && (err2.code === 'EACCES' || err2.code === 'EPERM'), `errno ${err2 && err2.code} (permissão) RELANÇADO — fail-loud preservado`);
+    fs.chmodSync(locked, 0o700);
+  } else {
+    console.log('[INFO ] EACCES pulado: rodando como root (modos de permissão não se aplicam); ENOTDIR já cobre o relançamento.');
+  }
+
+  // AC1 — nenhum `existsSync`+ação sobreviveu nos TRÊS pontos de mutação (o padrão TOCTOU que a
+  // story existe para eliminar). Guarda de regressão sobre o código de produção.
+  const svcSrc = fs.readFileSync(SVC_PATH, 'utf8');
+  const uiSrc = fs.readFileSync(UI_PATH, 'utf8');
+  assert(!/if \(fs\.existsSync\(p\)\) processed\.push/.test(svcSrc), 'o loop `serve` não reconfere `existsSync` antes do pickup (a única autorização é o rename)');
+  const rejectBody = uiSrc.slice(uiSrc.indexOf('function rejectRun'), uiSrc.indexOf('// HTTP helpers'));
+  assert(/svc\.claimByRename\(src,/.test(rejectBody) && !/existsSync\(src\)/.test(rejectBody), '`rejectRun` reivindica por rename e não consulta `existsSync` do marcador');
+  const approveBody = svcSrc.slice(svcSrc.indexOf('function approveRun'), svcSrc.indexOf('// Loop de serviço'));
+  assert(approveBody.indexOf('authorizeApproval') < approveBody.indexOf('claimApproveMarker')
+    && approveBody.indexOf('claimApproveMarker') < approveBody.indexOf('spawnFn('),
+    'em `approveRun` a ordem é AUTORIZAR → reivindicar → spawn (a reivindicação nunca precede a decisão de auth)');
+  // §4b — nenhum catch cego (`catch {}` / `catch (e) {}` vazio) no caminho da fila.
+  assert(!/catch\s*(\([^)]*\))?\s*\{\s*\}/.test(svcSrc) && !/catch\s*(\([^)]*\))?\s*\{\s*\}/.test(uiSrc),
+    'nenhum `catch {}` cego (sem corpo) sobrevive no serviço nem na UI');
+}
+
+// ---------------------------------------------------------------------------
+(async () => {
+  await e1PickupDisputado();
+  await e1bServeSegueServindo();
+  await e2RejectDisputado();
+  await e2bUiRealNaoMorre();
+  await e3ApproveDisputado();
+  await e3bGateDeAutorizacaoIntacto();
+  await e4PublicacaoAtomica();
+  await e4bPayloadParcialNaoEDespachado();
+  await ac4LockDeInstancia();
+  await lock1ArranquesConcorrentes();
+  ac4ArbitragemUnitaria();
+  await ac5OrfaosRelatadosSemRequeue();
+  ac2SancaoPorErrno();
+  console.log(`\n${failures === 0 ? '[SUCESSO]' : '[FALHOU]'} pod-export fila cross-processo (SF10.16): ${failures} falha(s).`);
+  process.exit(failures === 0 ? 0 : 1);
+})().catch((e) => { console.error('[ERRO NO TESTE]', e); process.exit(1); });