@daniellins/power-claude 0.16.3

package/scripts/__tests__/pc-run-pod.test.cjs

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pc-run-pod.test.cjs — suíte PRÓPRIA do motor pc-run-pod (Story SF1.2, DoD 1b).
+ *
+ * É o componente MAIS testado da fase por exigência do ADR-001: o núcleo do
+ * enforcement não pode ser o menos testado. Dirige o motor com `state.json` REAL
+ * escrito em disco entre chamadas (não mock), plantando/omitindo artefatos para
+ * simular o subagente. Prova o não-fake-green NO MOTOR: `done` só com verificação
+ * em disco passando; artefato ausente / veto violado / template não-conforme NÃO
+ * avançam. Cobre start/resume/next/approve/revise/abort/status + retomada topológica.
+ *
+ * Node >= 18, sem dependências externas. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const R = require('../pc-run-pod.cjs');
+const PM = require('../pod-memory.cjs');
+
+const FIXT = path.resolve(__dirname, '..', '__fixtures__', 'pod-run');
+const WF = path.join(FIXT, 'workflows', 'wf-min.yaml');
+
+// SF2.2: o lifecycle de memória grava em `<podRoot>/memory/`. Os casos SF1.2 usam FIXT
+// como podRoot; sem isolamento isso cairia no fixture versionado. Limpamos antes e depois
+// para manter o fixture limpo e os testes determinísticos — os casos novos (SF2.2) usam
+// um podDir temporário isolado via `memoryPodDir`, sem tocar o repo.
+function wipeFixtureMemory() {
+  fs.rmSync(path.join(FIXT, 'memory'), { recursive: true, force: true });
+}
+wipeFixtureMemory();
+
+// --- micro-harness -------------------------------------------------------
+let passed = 0;
+const failures = [];
+function check(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}`); }
+}
+function throws(fn, label) {
+  let threw = false;
+  try { fn(); } catch (e) { threw = true; }
+  check(threw, label);
+}
+
+function tmpRunsRoot() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pc-run-pod-'));
+}
+function start(runsRoot, runId) {
+  return R.startRun({
+    workflowPath: WF,
+    podRootOverride: FIXT,
+    pod: 'test-pod',
+    workflow: 'wf-min',
+    mode: 'interactive',
+    taskRef: 'canário',
+    runsRoot,
+    runId,
+  });
+}
+function plant(ctx, stepId, content) {
+  const rel = ctx.state.steps[stepId].artifact;
+  const abs = path.resolve(ctx.runDir, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, 'utf8');
+}
+const BUILD_OK = '## Escopo\n## Contexto\nstatus: rascunho\n';
+const BUILD_VETO_BAD = '## Escopo\n## Contexto\nstatus: final\n';   // template OK, veto falha
+const BUILD_TMPL_BAD = '## Escopo\nstatus: rascunho\n';             // veto OK, template falha (sem ## Contexto)
+const GATE_OK = '## Veredito\nveredito: GO\n';
+const GATE_VETO_BAD = '## Veredito\nveredito: MAYBE\n';
+const FINAL_OK = '## Escopo\n## Contexto\nconfianca: alta\n';  // ADR-005: veto ortogonal `confianca`
+
+// =========================================================================
+// AC2 — start grava state.json no schema exato + primeiro dispatch (AC3 brief).
+// =========================================================================
+(function testStartSchema() {
+  const rr = tmpRunsRoot();
+  const { ctx, result } = start(rr, '2026-07-24T18-00-00Z');
+  check(result.action === 'dispatch' && result.step === 'build', 'AC3 start despacha a 1a etapa (build)');
+
+  const disk = R.readState(ctx.statePath);
+  const topKeys = ['pod', 'workflow', 'run_id', 'mode', 'task_ref', 'steps', 'updated_at'];
+  check(topKeys.every((k) => k in disk), 'AC2 state.json tem todos os campos de topo do schema §B1');
+  check(/^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}Z$/.test(disk.run_id), 'AC2 run_id é timestamp ISO sanitizado (padrão SPEC)');
+  const stepKeys = ['status', 'agent', 'artifact', 'template', 'checkpoint', 'started_at', 'verified_at'];
+  const okStepShape = Object.values(disk.steps).every((s) => stepKeys.every((k) => k in s));
+  check(okStepShape, 'AC2 cada step tem os 7 campos do schema §B1');
+  check(disk.steps.gate.checkpoint === 'blocking', 'AC2 checkpoint bloqueante refletido no state');
+  check(disk.steps.build.status === 'running' && disk.steps.gate.status === 'pending' &&
+        disk.steps.finalize.status === 'pending', 'AC2 só a 1a etapa fica running após start');
+
+  const brief = result.brief;
+  check(brief.includes(path.resolve(ctx.runDir, 'artifacts', 'build.md')), 'AC3 brief inclui path exato do artefato');
+  check(brief.includes(path.resolve(FIXT, 'templates', 'build-tmpl.md')), 'AC3 brief inclui path do template');
+  check(brief.includes('field_matches') && brief.includes('status'), 'AC3 brief inclui o veto da etapa');
+  check(brief.includes('≤15 linhas'), 'AC3 brief instrui retorno ≤15 linhas');
+})();
+
+// =========================================================================
+// AC4a — artefato AUSENTE → done NÃO setado, próximo passo NÃO roda.
+// =========================================================================
+(function testNoFakeGreenAbsent() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  const res = R.advance(ctx); // build running, sem artefato plantado
+  check(res.action === 'blocked' && res.reason === 'verification_failed', 'AC4a artefato ausente → blocked');
+  check(res.failures.some((f) => /ausente/.test(f)), 'AC4a falha nomeia artefato ausente');
+  check(ctx.state.steps.build.status !== 'done', 'AC4a build NÃO vira done');
+  check(ctx.state.steps.gate.status === 'pending', 'AC4a próxima etapa (gate) NÃO roda');
+})();
+
+// =========================================================================
+// AC4b — veto VIOLADO (template conforme) → done NÃO setado.
+// =========================================================================
+(function testNoFakeGreenVeto() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  plant(ctx, 'build', BUILD_VETO_BAD);
+  const res = R.advance(ctx);
+  check(res.action === 'blocked', 'AC4b veto violado → blocked');
+  check(res.failures.some((f) => /veto\.assertions/.test(f)), 'AC4b falha é do veto (não do template)');
+  check(!res.failures.some((f) => /seção obrigatória do template/.test(f)), 'AC4b template estava conforme (isola o veto)');
+  check(ctx.state.steps.build.status !== 'done' && ctx.state.steps.gate.status === 'pending', 'AC4b não avança');
+})();
+
+// =========================================================================
+// AC4c — template NÃO-CONFORME (veto passaria) → done NÃO setado.
+// =========================================================================
+(function testNoFakeGreenTemplate() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  plant(ctx, 'build', BUILD_TMPL_BAD);
+  const res = R.advance(ctx);
+  check(res.action === 'blocked', 'AC4c template não-conforme → blocked');
+  check(res.failures.some((f) => /seção obrigatória do template/.test(f)), 'AC4c falha é de conformidade de template');
+  check(ctx.state.steps.build.status !== 'done' && ctx.state.steps.gate.status === 'pending', 'AC4c não avança');
+})();
+
+// =========================================================================
+// Caminho feliz build → done → dispatch gate; verified_at gravado.
+// =========================================================================
+(function testHappyBuild() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  plant(ctx, 'build', BUILD_OK);
+  const res = R.advance(ctx);
+  check(ctx.state.steps.build.status === 'done', 'build verificado vira done');
+  check(!!ctx.state.steps.build.verified_at, 'verified_at gravado no done');
+  check(res.action === 'dispatch' && res.step === 'gate', 'gate liberado só após build done');
+})();
+
+// =========================================================================
+// AC5 — checkpoint.blocking para o runner; approve avança até complete.
+// =========================================================================
+(function testCheckpointApprove() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  plant(ctx, 'build', BUILD_OK); R.advance(ctx);        // gate running
+  plant(ctx, 'gate', GATE_OK);
+  const res = R.advance(ctx);
+  check(res.action === 'awaiting_approval' && res.step === 'gate', 'AC5 checkpoint.blocking interrompe o runner');
+  check(ctx.state.steps.gate.status === 'awaiting_approval' && !!ctx.state.steps.gate.verified_at, 'AC5 gate verificado, aguardando aprovação');
+  check(ctx.state.steps.finalize.status === 'pending', 'AC5 finalize NÃO roda sem aprovação');
+
+  const ap = R.approve(ctx);
+  check(ctx.state.steps.gate.status === 'done', 'AC5 approve marca gate done');
+  check(ap.next.action === 'dispatch' && ap.next.step === 'finalize', 'AC5 approve libera finalize');
+
+  plant(ctx, 'finalize', FINAL_OK);
+  const done = R.advance(ctx);
+  check(done.action === 'complete', 'workflow completa após última etapa verificada');
+  check(R.firstNonDone(ctx) === null, 'nenhum passo não-done ao completar');
+})();
+
+// =========================================================================
+// AC5 — revise devolve a etapa (e o fix_cycle.to) a pending para reexecução.
+// =========================================================================
+(function testCheckpointRevise() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  plant(ctx, 'build', BUILD_OK); R.advance(ctx);
+  plant(ctx, 'gate', GATE_OK); R.advance(ctx);          // awaiting_approval
+  const rv = R.revise(ctx);
+  check(rv.action === 'revised' && rv.loop_to === 'build', 'AC5 revise honra fix_cycle (loop_to=build)');
+  check(ctx.state.steps.gate.fix_iterations === 1, 'AC5 revise incrementa fix_iterations');
+  check(rv.next.action === 'dispatch' && rv.next.step === 'build', 'AC5 revise reexecuta a partir do fix_cycle.to (build)');
+})();
+
+// =========================================================================
+// AC6 — resume topológico: continua do 1o não-done, não repete done.
+// =========================================================================
+(function testResumeTopological() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  // simula build já concluído em disco, gate/finalize pendentes
+  ctx.state.steps.build.status = 'done';
+  ctx.state.steps.build.artifact = 'artifacts/build.md';
+  ctx.state.steps.build.verified_at = new Date().toISOString();
+  ctx.state.steps.gate.status = 'pending';
+  R.writeState(ctx.statePath, ctx.state);
+
+  const found = R.findStateByRunId(rr, ctx.state.run_id);
+  check(found === ctx.statePath, 'AC6 findStateByRunId localiza o state.json pelo run-id');
+
+  const ctx2 = R.openRun({ statePath: found, workflowPath: WF, podRootOverride: FIXT });
+  check(R.firstNonDone(ctx2) === 'gate', 'AC6 primeiro não-done é gate (build done não repete)');
+  const res = R.advance(ctx2);
+  check(res.action === 'dispatch' && res.step === 'gate', 'AC6 resume despacha gate, não build');
+  check(ctx2.state.steps.build.status === 'done', 'AC6 build permanece done na retomada');
+})();
+
+// =========================================================================
+// fix_cycle — max_iterations excedido → halt (não fica em loop infinito).
+// =========================================================================
+(function testFixCycleMax() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  function toAwaiting() {
+    plant(ctx, 'build', BUILD_OK); R.advance(ctx);
+    plant(ctx, 'gate', GATE_OK); R.advance(ctx);
+  }
+  toAwaiting(); check(R.revise(ctx).action === 'revised', 'fix_cycle iter 1 ok');
+  toAwaiting(); check(R.revise(ctx).action === 'revised', 'fix_cycle iter 2 ok (== max)');
+  toAwaiting();
+  const halt = R.revise(ctx);
+  check(halt.action === 'halt', 'fix_cycle iter 3 (> max=2) → halt');
+  check(ctx.state.steps.gate.status === 'failed', 'fix_cycle excedido marca a etapa failed');
+})();
+
+// =========================================================================
+// abort — pendências viram failed; status resume o run.
+// =========================================================================
+(function testAbortStatus() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  const summ = R.statusSummary(ctx);
+  check(/build: running/.test(summ) && /próximo não-done/.test(summ), 'status resume o run');
+  R.abort(ctx);
+  check(ctx.state.steps.build.status === 'failed' && ctx.state.steps.gate.status === 'failed', 'abort marca pendências como failed');
+})();
+
+// =========================================================================
+// Risco 4 — state.json corrompido/ inválido → HALT explícito (nunca "conserta").
+// =========================================================================
+(function testCorruptState() {
+  const rr = tmpRunsRoot();
+  const { ctx } = start(rr);
+  const p = ctx.statePath;
+  fs.writeFileSync(p, '{ not json', 'utf8');
+  throws(() => R.readState(p), 'Risco4 JSON inválido → throw (não conserta silenciosamente)');
+  fs.writeFileSync(p, JSON.stringify({ pod: 'x', workflow: 'y', run_id: 'z', mode: 'm', updated_at: 't' }), 'utf8');
+  throws(() => R.readState(p), 'Risco4 schema sem steps → throw');
+  fs.writeFileSync(p, JSON.stringify({
+    pod: 'x', workflow: 'y', run_id: 'z', mode: 'm', updated_at: 't',
+    steps: { a: { status: 'bogus' } },
+  }), 'utf8');
+  throws(() => R.readState(p), 'Risco4 status desconhecido → throw');
+})();
+
+// =========================================================================
+// Preflight reusa o validador da SF1.1 (Risco 2): contrato inválido → não inicia.
+// =========================================================================
+(function testPreflightReuse() {
+  const bad = path.resolve(__dirname, '..', '__fixtures__', 'pod-workflow', 'invalid-cycle.yaml');
+  throws(() => R.loadWorkflow(bad, path.dirname(path.dirname(bad))), 'Risco2 preflight reusa validate-pod-workflow (ciclo → não inicia)');
+})();
+
+// =========================================================================
+// SF1.2 finding #1 (resolvido na SF1.3) — makeRunId é único mesmo no MESMO segundo.
+// Dois `start` no mesmo segundo NÃO podem colidir no path do state.json.
+// =========================================================================
+(function testRunIdUnique() {
+  const fixed = new Date('2026-07-24T18:00:00.000Z');
+  const a = R.makeRunId(fixed);
+  const b = R.makeRunId(fixed);
+  check(a !== b, 'finding#1 makeRunId gera ids distintos para o MESMO instante');
+  check(a.startsWith('2026-07-24T18-00-00Z'), 'finding#1 run-id preserva o timestamp legível da SPEC como prefixo');
+
+  // Prova de ponta: dois starts no mesmo runsRoot/pod/workflow → dois state.json distintos.
+  const rr = tmpRunsRoot();
+  const r1 = start(rr); // runId default (makeRunId)
+  const r2 = start(rr);
+  check(r1.ctx.statePath !== r2.ctx.statePath, 'finding#1 dois starts no mesmo segundo → paths de state.json distintos (sem colisão)');
+})();
+
+// =========================================================================
+// SF2.2 — lifecycle de memória do pod (ADR-003 / SPEC §G1).
+// Isolamento: podDir temporário via `memoryPodDir` (nunca toca o fixture/repo).
+// =========================================================================
+
+function tmpPodDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pc-run-mem-'));
+}
+function memFile(podDir, name) {
+  return path.join(podDir, 'memory', name);
+}
+function readJsonl(podDir) {
+  const p = memFile(podDir, 'learnings.jsonl');
+  if (!fs.existsSync(p)) return [];
+  return fs.readFileSync(p, 'utf8').split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l));
+}
+function startMem(runsRoot, podDir, runId) {
+  return R.startRun({
+    workflowPath: WF, podRootOverride: FIXT, pod: 'test-pod', workflow: 'wf-min',
+    mode: 'interactive', taskRef: 'canário', runsRoot, runId, memoryPodDir: podDir,
+  });
+}
+
+// AC1 — blocked/verification_failed appenda candidato estruturado (tier normal).
+(function testMemAppendOnFailure() {
+  const rr = tmpRunsRoot();
+  const pd = tmpPodDir();
+  const { ctx } = startMem(rr, pd);
+  R.advance(ctx); // build running, sem artefato → blocked/verification_failed
+  const entries = readJsonl(pd);
+  check(entries.length === 1, 'AC1 verification_failed appenda exatamente 1 candidato');
+  const e = entries[0] || {};
+  check(/verification_failed/.test(e.trigger || ''), 'AC1 trigger nomeia verification_failed');
+  check(/etapa "build"/.test(e.trigger || ''), 'AC1 trigger identifica a etapa bloqueada');
+  check(e.tier === 'normal', 'AC1 entrada é tier normal (runner nunca marca critical)');
+  check(e.evidence && e.evidence.step === 'build' && Array.isArray(e.evidence.veto) && e.evidence.veto.length > 0,
+    'AC1 evidence estruturada carrega etapa + veto violado (dos failures)');
+  check(/corrigir/.test(e.recommendation || ''), 'AC1 recommendation derivada dos failures');
+})();
+
+// AC2 + AC5 — complete appenda padrão-ok e dispara consolidate.
+(function testMemAppendOnComplete() {
+  const rr = tmpRunsRoot();
+  const pd = tmpPodDir();
+  const { ctx } = startMem(rr, pd);
+  plant(ctx, 'build', BUILD_OK); R.advance(ctx);       // gate running
+  plant(ctx, 'gate', GATE_OK); R.advance(ctx);         // awaiting_approval
+  R.approve(ctx);                                      // finalize running
+  plant(ctx, 'finalize', FINAL_OK);
+  const done = R.advance(ctx);
+  check(done.action === 'complete', 'AC2 run chega a complete (pré-condição)');
+  const entries = readJsonl(pd);
+  const ok = entries.find((x) => /completou sem bloqueio/.test(x.trigger || ''));
+  check(!!ok, 'AC2 complete appenda registro de padrão-ok');
+  check(ok && ok.tier === 'normal', 'AC2 padrão-ok é tier normal');
+  check(ok && ok.evidence && typeof ok.evidence.steps_done === 'number', 'AC2 evidence carrega steps_done');
+  check(fs.existsSync(memFile(pd, 'learnings.consolidated.md')), 'AC5 complete dispara consolidate (consolidado escrito)');
+})();
+
+// AC6 — K=20 appends dispara consolidate mesmo sem complete.
+(function testMemConsolidateEveryK() {
+  const rr = tmpRunsRoot();
+  const pd = tmpPodDir();
+  const { ctx } = startMem(rr, pd); // dispatch inicial não appenda
+  const consPath = memFile(pd, 'learnings.consolidated.md');
+  for (let i = 0; i < PM.CONSOLIDATE_K - 1; i++) {
+    R.recordLearning(ctx, R.buildFailureLearning(ctx, `s${i}`, [`falha ${i}`]));
+  }
+  check(readJsonl(pd).length === PM.CONSOLIDATE_K - 1, 'AC6 pré-condição: 19 appends acumulados');
+  check(!fs.existsSync(consPath), 'AC6 consolidate NÃO disparou antes de K=20');
+  R.recordLearning(ctx, R.buildFailureLearning(ctx, 's19', ['falha 19'])); // 20º
+  check(fs.existsSync(consPath), 'AC6 20º append (K=20) dispara consolidate sem complete');
+})();
+
+// AC3 — brief injeta seção de memória só quando o consolidado tem conteúdo real.
+(function testMemBriefInjection() {
+  const rr = tmpRunsRoot();
+  const pd = tmpPodDir();
+  const { ctx } = startMem(rr, pd);
+  const briefAbsent = R.buildBrief(ctx, 'build');
+  check(!/Memória consolidada/.test(briefAbsent), 'AC3 sem consolidado → seção de memória omitida');
+
+  // consolidado só com cabeçalho (sem heurística) → ainda omitido.
+  fs.mkdirSync(path.join(pd, 'memory'), { recursive: true });
+  fs.writeFileSync(memFile(pd, 'learnings.consolidated.md'),
+    '# Memória consolidada — test-pod\n\n## Heurísticas (top-N)\n\n_Nenhuma heurística consolidada ainda._\n');
+  check(!/Memória consolidada \(aplique/.test(R.buildBrief(ctx, 'build')), 'AC3 consolidado só-cabeçalho (vazio) → seção omitida');
+
+  // consolidado com heurística real → seção injetada com o conteúdo.
+  fs.writeFileSync(memFile(pd, 'learnings.consolidated.md'),
+    '# Memória consolidada — test-pod\n\n## Heurísticas (top-N)\n\n- **[etapa build]** valide o status antes de finalizar _(x3)_\n');
+  const briefWith = R.buildBrief(ctx, 'build');
+  check(/## Memória consolidada \(aplique estas heurísticas\)/.test(briefWith), 'AC3 consolidado com conteúdo → seção injetada');
+  check(/valide o status antes de finalizar/.test(briefWith), 'AC3 conteúdo real da heurística chega ao brief');
+})();
+
+// AC4 — brief NUNCA lê nem menciona o log cru learnings.jsonl (teste negativo).
+(function testMemBriefNeverRaw() {
+  const rr = tmpRunsRoot();
+  const pd = tmpPodDir();
+  const { ctx } = startMem(rr, pd);
+  // gera o consolidado REAL via motor — cujo cabeçalho contém a string "learnings.jsonl".
+  PM.append('test-pod', {
+    trigger: 'etapa build', recommendation: 'valide o status antes de finalizar', tier: 'normal',
+  }, { podDir: pd });
+  PM.consolidate('test-pod', { podDir: pd });
+  const rawConsolidated = fs.readFileSync(memFile(pd, 'learnings.consolidated.md'), 'utf8');
+  check(/learnings\.jsonl/.test(rawConsolidated), 'AC4 pré-condição: o consolidado cru do motor MENCIONA learnings.jsonl no cabeçalho');
+
+  const brief = R.buildBrief(ctx, 'build');
+  check(/valide o status antes de finalizar/.test(brief), 'AC4 a heurística real foi injetada no brief');
+  check(!/learnings\.jsonl/.test(brief), 'AC4 brief NUNCA contém a string "learnings.jsonl" (cabeçalho de disclaimer descartado)');
+  check(!brief.includes(memFile(pd, 'learnings.jsonl')), 'AC4 brief NUNCA contém o path do log cru');
+})();
+
+// =========================================================================
+// SF11.10/ADR-024 — gate de texto antes do custo: `checkpoint.skip_modes`.
+// O smoke roda em `yolo` e por construção NUNCA visita um gate que o `yolo` pula;
+// estes casos são o oráculo que ele não dá (DF-SF11.10-9).
+// =========================================================================
+
+const WF_SKIP = path.join(FIXT, 'workflows', 'wf-skip-modes.yaml');
+const SCRIPT_OK = '## Escopo\n## Contexto\nstatus: rascunho\n';
+const FINAL_GATE_OK = '## Veredito\nveredito: GO\n';
+
+function startSkip(runsRoot, mode, podDir) {
+  return R.startRun({
+    workflowPath: WF_SKIP, podRootOverride: FIXT, pod: 'test-pod', workflow: 'wf-skip-modes',
+    mode, taskRef: 'canário-skip-modes', runsRoot, memoryPodDir: podDir,
+  });
+}
+
+// AC6 — TABELA-VERDADE de isBlocking(step, mode). A enumeração é NEGATIVA de propósito:
+// o desconhecido BLOQUEIA (fail-closed). Inverter isso trocaria fail-closed por fail-open
+// no único gate humano do sistema.
+(function testIsBlockingTruthTable() {
+  const semSkip = { checkpoint: { blocking: true, criteria: 'x' } };
+  const comSkip = { checkpoint: { blocking: true, skip_modes: ['yolo'], criteria: 'x' } };
+  const naoBloq = { checkpoint: { blocking: false, criteria: 'x' } };
+  const semCp = { checkpoint: null };
+
+  check(R.isBlocking(semSkip, 'interactive') === true && R.isBlocking(semSkip, 'yolo') === true,
+    'AC6(a) skip_modes AUSENTE ⇒ bloqueia em interactive E em yolo (retrocompat byte-idêntica)');
+  check(R.isBlocking(comSkip, 'interactive') === true && R.isBlocking(comSkip, 'yolo') === false,
+    'AC6(b) skip_modes ["yolo"] ⇒ bloqueia em interactive, NÃO bloqueia em yolo');
+  check(R.isBlocking(comSkip, 'modo-que-nao-existe') === true && R.isBlocking(comSkip, undefined) === true,
+    'AC6(c) modo NÃO listado (typo/undefined) ⇒ BLOQUEIA — fail-closed');
+  check(R.isBlocking(naoBloq, 'interactive') === false && R.isBlocking(semCp, 'interactive') === false,
+    'AC6(d) blocking:false / checkpoint:null ⇒ nunca bloqueia, em modo nenhum');
+  check(Array.isArray(R.RUN_MODES) && R.RUN_MODES.join(',') === 'interactive,yolo',
+    'AC6 conjunto fechado de ritmos vem do validador (fonte única): interactive, yolo');
+})();
+
+// AC7/AC10 (forma sintética) — em `interactive` a run PARA no gate de texto e a etapa CARA
+// não é despachada. É o oposto do 1 ms medido hoje entre digest.verified_at e visuals.started_at.
+(function testSkipModesInteractiveParaAntesDaEtapaCara() {
+  const rr = tmpRunsRoot();
+  const pd = tmpPodDir();
+  const { ctx, result } = startSkip(rr, 'interactive', pd);
+  check(result.action === 'dispatch' && result.step === 'script', 'SF11.10 interactive: start despacha `script`');
+  plant(ctx, 'script', SCRIPT_OK);
+  const r2 = R.advance(ctx);
+  check(r2.action === 'awaiting_approval' && r2.step === 'script',
+    'AC10 interactive: advance PARA em awaiting_approval no gate de texto (não despacha a etapa cara)');
+
+  const disk = R.readState(ctx.statePath);
+  check(disk.steps.script.checkpoint === 'blocking', 'AC7 interactive: state grava checkpoint "blocking" no gate de texto');
+  check(disk.steps.costly.status === 'pending' && disk.steps.costly.started_at === null,
+    'AC10 interactive: a etapa CARA continua pending com started_at null no instante da parada');
+
+  // `revise` sem fix_cycle devolve SÓ a própria etapa e re-despacha — zero custo na etapa cara.
+  const rev = R.revise(ctx);
+  check(rev.action === 'revised' && rev.step === 'script' && rev.next.action === 'dispatch' && rev.next.step === 'script',
+    'AC10 revise no gate de texto devolve SÓ `script` a pending e re-despacha');
+  const afterRev = R.readState(ctx.statePath);
+  check(afterRev.steps.costly.status === 'pending' && afterRev.steps.costly.started_at === null &&
+        afterRev.steps.final.status === 'pending',
+    'AC10 revise NÃO toca a etapa cara nem o gate de fechamento');
+
+  // approve libera a etapa cara; a run segue até o gate de fechamento.
+  plant(ctx, 'script', SCRIPT_OK);
+  const r3 = R.advance(ctx);
+  check(r3.action === 'awaiting_approval', 'AC10 re-execução do `script` volta ao mesmo gate');
+  const ap = R.approve(ctx);
+  check(ap.action === 'approved' && ap.next.action === 'dispatch' && ap.next.step === 'costly',
+    'AC10 approve no gate de texto libera a etapa cara');
+  plant(ctx, 'costly', SCRIPT_OK);
+  const r4 = R.advance(ctx);
+  check(r4.action === 'dispatch' && r4.step === 'final', 'AC10 etapa cara roda sem regressão e despacha o fechamento');
+  plant(ctx, 'final', FINAL_GATE_OK);
+  const r5 = R.advance(ctx);
+  check(r5.action === 'awaiting_approval' && r5.step === 'final',
+    'AC10 a run chega ao gate de FECHAMENTO como antes desta story');
+})();
+
+// AC7/AC11 — PROVA NEGATIVA: em `yolo` o gate de texto não existe, e ninguém o aprova.
+(function testSkipModesYoloPulaSemAprovar() {
+  const rr = tmpRunsRoot();
+  const pd = tmpPodDir();
+  const { ctx, result } = startSkip(rr, 'yolo', pd);
+  check(result.action === 'dispatch' && result.step === 'script', 'SF11.10 yolo: start despacha `script`');
+
+  const atStart = R.readState(ctx.statePath);
+  check(atStart.steps.script.checkpoint === null,
+    'AC7 yolo: state.json grava checkpoint null no gate pulado (a auditoria diz a verdade)');
+  check(atStart.steps.final.checkpoint === 'blocking',
+    'AC7 yolo: o gate de FECHAMENTO segue "blocking" (sem skip_modes ⇒ bloqueia em todo modo)');
+
+  plant(ctx, 'script', SCRIPT_OK);
+  const r2 = R.advance(ctx);
+  check(r2.action === 'dispatch' && r2.step === 'costly',
+    'AC11 yolo: a run atravessa o gate de texto sem parar (vai direto à etapa seguinte)');
+  const afterScript = R.readState(ctx.statePath);
+  check(afterScript.steps.script.status === 'done',
+    'AC11 yolo: `script` chega a done SEM jamais passar por awaiting_approval');
+
+  plant(ctx, 'costly', SCRIPT_OK);
+  const r3 = R.advance(ctx);
+  check(r3.action === 'dispatch' && r3.step === 'final', 'AC11 yolo: etapa cara roda e despacha o fechamento');
+  plant(ctx, 'final', FINAL_GATE_OK);
+  const r4 = R.advance(ctx);
+  check(r4.action === 'awaiting_approval' && r4.step === 'final',
+    'AC11 yolo ESTACIONA no gate de fechamento — nenhum approve foi executado pelo modo autônomo');
+  // Prova NEGATIVA em disco: a run não terminou; o gate de fechamento continua esperando humano.
+  const disk = R.readState(ctx.statePath);
+  check(disk.steps.final.status === 'awaiting_approval' && disk.steps.script.checkpoint === null,
+    'AC11 disco: fechamento em awaiting_approval e gate de texto com checkpoint null (pular ≠ aprovar)');
+})();
+
+// AC8 — `mode` é conjunto FECHADO, validado no start, com os valores válidos na mensagem.
+(function testModoForaDoConjuntoFechado() {
+  const rr = tmpRunsRoot();
+  let msg = '';
+  try {
+    R.startRun({
+      workflowPath: WF_SKIP, podRootOverride: FIXT, pod: 'test-pod', workflow: 'wf-skip-modes',
+      mode: 'YOLO', taskRef: 'canário', runsRoot: rr, memoryPodDir: tmpPodDir(),
+    });
+  } catch (e) { msg = e.message; }
+  check(/modo de run inválido/.test(msg) && /YOLO/.test(msg),
+    'AC8 --mode fora do conjunto fechado é RECUSADO no start (não vira deadlock silencioso)');
+  check(/interactive/.test(msg) && /yolo/.test(msg), 'AC8 a mensagem NOMEIA os valores válidos');
+})();
+
+// AC8 — capabilityGaps enxerga chave desconhecida sob `checkpoint` (skew para frente).
+(function testCapabilityGapCheckpointDesconhecido() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-skew-'));
+  const wf = path.join(dir, 'wf-futuro.yaml');
+  fs.writeFileSync(wf, [
+    'state_machine:',
+    '  states: [init, running, complete, failed]',
+    '  initial: init',
+    '  terminal: [complete, failed]',
+    'steps:',
+    '  - id: gate',
+    '    agent: pod-critic',
+    '    template: templates/gate-tmpl.md',
+    '    inputs: [brief]',
+    '    outputs: [verdict]',
+    '    depends_on: []',
+    '    checkpoint: { blocking: true, criteria: "x", futuro_desconhecido: 1 }',
+    '    veto:',
+    '      assertions:',
+    '        - { type: field_matches, field: veredito, pattern: "^(GO|NO-GO)$" }',
+    '',
+  ].join('\n'), 'utf8');
+
+  const gaps = R.capabilityGaps(wf);
+  check(gaps.some((g) => /checkpoint\.futuro_desconhecido/.test(g) && /não existe neste motor/.test(g)),
+    'AC8 capabilityGaps NOMEIA a chave de checkpoint que este motor não conhece');
+
+  // E o preflight do runner atribui a falha à INSTALAÇÃO, não ao wf (ADR-019 DF-SF10.20-4).
+  let annotated = '';
+  try { R.loadWorkflow(wf, FIXT); } catch (e) { annotated = e.message; }
+  check(/ATRIBUIÇÃO/.test(annotated) && /checkpoint\.futuro_desconhecido/.test(annotated),
+    'AC8 a falha do preflight vira diagnóstico de skew (instalação defasada), não acusação ao wf');
+  fs.rmSync(dir, { recursive: true, force: true });
+})();
+
+wipeFixtureMemory();
+
+// --- relatório -----------------------------------------------------------
+console.log(`\n${passed}/${passed + failures.length} asserções passaram.`);
+if (failures.length > 0) {
+  console.error('\nSUÍTE pc-run-pod FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('Suíte pc-run-pod verde (motor: não-fake-green provado).');
+process.exit(0);