@daniellins/power-claude 0.16.3

package/scripts/harness-g5-lite.cjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * harness-g5-lite.cjs — HARNESS DE PARIDADE G5-LITE (Story SF3.2, item h; ADR-006
+ * Decisão 2). Empacota, como FUNÇÃO/COMANDO reusável, o nível LITE de paridade que
+ * SF3.4 (piloto) vai invocar sobre `wf-money-model-design` sem reinventar sob pressão.
+ *
+ * LITE corta SÓ a repetição estatística — nunca a prova de bloqueio (integral nos dois
+ * níveis). Três etapas, todas obrigatórias:
+ *   (1) VALIDADOR ESTÁTICO + smoke `--sweep` COMPLETO (idêntico ao FULL: prova integral
+ *       de que ESTE dado trava o caminho errado).
+ *   (2) G5(a) reduzido: N=2 runs — conformidade 100% + DAG monotônico em AMBAS; SEM
+ *       estatística de variância (invariante do motor, provado na âncora).
+ *   (3) G5(b): 1 par lado-a-lado (2ª run do pod vs 1 run do squad, mesma tarefa) —
+ *       completude ≥ squad E conformidade ≥ squad são BLOQUEANTES; custo REGISTRADO
+ *       sem critério de bloqueio (única dimensão dispensada, Daniel 2026-07-24).
+ *
+ * PROTOCOLO DE LEGADO INEXECUTÁVEL (M-r2-3): quando `waiver` está presente, a completude
+ * passa a ser comparada contra os artefatos DECLARADOS do legado (não contra uma run do
+ * squad que não existe) — o waiver pressupõe tentativa real registrada (validada pelo
+ * `migration-manifest.cjs waiver-set`, não aqui).
+ *
+ * ASSINATURA (para SF3.4 herdar sem arqueologia de código):
+ *   runG5Lite({
+ *     workflowPath,      // abs: <pod>/workflows/wf-<id>.yaml
+ *     podRoot,           // abs: raiz do pod
+ *     specPath,          // abs: spec (spec_hash binding no sweep) — opcional
+ *     scenarioPath,      // abs: default <wf>.smoke.json
+ *     squadArtifacts,    // string[]: artefatos do lado SQUAD (par lado-a-lado)
+ *     artifactMapPath,   // abs: mapa artefato-a-artefato (yaml|json) — via para pods
+ *                        //   CONSOLIDADOS vs squad GRANULAR (design §D/M1); ver artifactMap
+ *     artifactMap,       // [] inline: {squad_artifact, pod_output, section?, evidence?}
+ *                        //   OU dispensa registrada: {squad_artifact, disposition:'dispensed',
+ *                        //   approved_by, evidence} — sai de missing SÓ com approved_by
+ *     squadConformance,  // 0..1: conformidade do lado squad (default 1)
+ *     waiver,            // { declared_artifacts:[] } | null — compara completude
+ *                        //   contra DECLARADOS quando o par squad não completa
+ *   }) -> {
+ *     static:{ok,failures[]}, sweep:{ok,proofs,spec_hash,reason?},
+ *     runs:[{run,conformance,monotonic,complete}],  // N=2
+ *     pair:{podArtifacts[],squadArtifacts[],missing[],completeness_ok,conformance_ok,blocked,
+ *           basis, map_path, mapped, unmapped[], dispensed[], sections_verified, warning},
+ *     cost:{runs,steps,note},  // registrado, SEM bloqueio
+ *     blocked, ok
+ *   }
+ *
+ * COMPLETUDE POR TABELA (design §D/M1): com --artifact-map, cada artefato do squad
+ * precisa de ENTRADA no mapa cujo pod_output existe nos outputs do wf e cuja `section`
+ * (se declarada) EXISTE no artefato em disco da run 2 — mapping falso não passa. Sem
+ * mapa, completude estrita por identidade de nome (com aviso).
+ *
+ * Node >= 18. CLI exit 0 = ok && !blocked; 1 caso contrário.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const smoke = require('./smoke-pod-workflow.cjs');
+const { parseYaml, validateWorkflow, podRootFor } = require('./validate-pod-workflow.cjs');
+
+const N_RUNS = 2; // G5(a) reduzido: 2 runs (invariante do motor, sem variância estatística).
+
+/** Métricas de conformidade/monotonia de UMA run já dirigida. */
+function runMetrics(run) {
+  const steps = Object.values(run.disk.steps);
+  const done = steps.filter((s) => s.status === 'done').length;
+  const conformance = steps.length ? done / steps.length : 0;
+  const complete = run.final.action === 'complete';
+  // DAG monotônico: cada etapa concluída DEPOIS de suas dependências (a ordem em que o
+  // runner despachou == ordem topológica; run completa ⇒ nenhuma etapa fora de ordem).
+  const monotonic = complete && conformance === 1;
+  return { conformance, monotonic, complete };
+}
+
+/** Dirige UMA run do pod. Com `retain`, NÃO limpa (o caller inspeciona os artefatos
+ * em disco para verificar seções mapeadas) e devolve {run, memoryPodDir, cleanup}. */
+function driveConformRun(cfg, retain) {
+  const memoryPodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-g5lite-mem-'));
+  const run = smoke.driveRun({ ...cfg, inject: null, memoryPodDir });
+  const cleanup = () => {
+    try { fs.rmSync(run.runsRoot, { recursive: true, force: true }); } catch { /* best-effort */ }
+    try { fs.rmSync(memoryPodDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  };
+  if (retain) return { ...runMetrics(run), run, cleanup };
+  cleanup();
+  return runMetrics(run);
+}
+
+/** Carrega o mapa de artefatos (yaml|json): lista de {squad_artifact, pod_output, section?, evidence?}. */
+function loadArtifactMap(p) {
+  const raw = fs.readFileSync(p, 'utf8');
+  let parsed;
+  try { parsed = JSON.parse(raw); } catch { parsed = parseYaml(raw); }
+  const entries = Array.isArray(parsed) ? parsed
+    : (parsed && Array.isArray(parsed.entries) ? parsed.entries
+      : (parsed && Array.isArray(parsed.map) ? parsed.map : null));
+  if (!entries) throw new Error(`artifact-map inválido (${p}): esperado lista de entradas ou {entries|map:[…]}`);
+  return entries;
+}
+
+/** Seção existe no artefato (heading trim-igual OU token presente) — mapping falso não passa. */
+function sectionInText(text, section) {
+  const want = String(section).trim();
+  return text.split(/\r?\n/).some((l) => l.trim() === want) || text.includes(want);
+}
+
+function runG5Lite(opts) {
+  const workflowPath = path.resolve(opts.workflowPath);
+  const podRoot = opts.podRoot ? path.resolve(opts.podRoot) : podRootFor(workflowPath);
+  const scenarioPath = opts.scenarioPath ? path.resolve(opts.scenarioPath) : workflowPath.replace(/\.ya?ml$/, '.smoke.json');
+  const specPath = opts.specPath ? path.resolve(opts.specPath) : null;
+  const doc = parseYaml(fs.readFileSync(workflowPath, 'utf8'));
+  const pod = path.basename(podRoot);
+  const workflow = path.basename(workflowPath).replace(/\.ya?ml$/, '');
+  const scenario = JSON.parse(fs.readFileSync(scenarioPath, 'utf8'));
+  const cfg = { workflowPath, podRoot, pod, workflow, scenario };
+
+  // ---- (1) ESTÁTICO + SWEEP COMPLETO ---------------------------------------
+  const staticRes = { ok: true, failures: [] };
+  try { validateWorkflow(workflowPath, podRoot); }
+  catch (e) { staticRes.ok = false; staticRes.failures.push(e.message); }
+  const sweepRaw = smoke.runSweep({ workflowPath, podRoot, scenario, specPath });
+  const sweep = {
+    ok: sweepRaw.ok && !sweepRaw.underivable,
+    proofs: sweepRaw.report.proofs.length,
+    spec_hash: sweepRaw.report.spec_hash,
+    reason: sweepRaw.underivable ? sweepRaw.underivable.reason
+      : (sweepRaw.leaked && sweepRaw.leaked.length ? `vazou: ${sweepRaw.leaked.map((l) => `${l.step}/${l.assertion}`).join(', ')}` : null),
+  };
+
+  // ---- (2) N=2 RUNS: conformidade 100% + DAG monotônico em AMBAS -----------
+  // Run 1 descartável; run 2 RETIDA (é o lado "pod" do par — seus artefatos em disco
+  // são a fonte da verificação de CONTEÚDO das seções mapeadas).
+  const runs = [{ run: 1, ...driveConformRun(cfg) }];
+  const r2 = driveConformRun(cfg, true);
+  runs.push({ run: 2, conformance: r2.conformance, monotonic: r2.monotonic, complete: r2.complete });
+  const runsOk = runs.every((r) => r.conformance === 1 && r.monotonic);
+
+  // Texto em disco de cada output do wf (via a run 2 retida) — para verificar seções.
+  const outputText = {};
+  for (const s of doc.steps) {
+    const rel = r2.run.disk.steps[s.id] && r2.run.disk.steps[s.id].artifact;
+    const text = (rel && fs.existsSync(path.resolve(r2.run.ctx.runDir, rel)))
+      ? fs.readFileSync(path.resolve(r2.run.ctx.runDir, rel), 'utf8') : '';
+    for (const o of (Array.isArray(s.outputs) ? s.outputs : [])) outputText[o] = text;
+  }
+  r2.cleanup();
+
+  // ---- (3) 1 PAR LADO-A-LADO: completude ≥ squad (por TABELA) E conformidade ≥ squad ----
+  const podArtifacts = [...new Set(doc.steps.flatMap((s) => Array.isArray(s.outputs) ? s.outputs : []))].sort();
+  const basis = opts.waiver ? 'declared' : 'squad-run'; // M-r2-3: waiver ⇒ compara contra declarados.
+  const squadArtifacts = [...new Set(
+    (opts.waiver && Array.isArray(opts.waiver.declared_artifacts)) ? opts.waiver.declared_artifacts
+      : (opts.squadArtifacts || []),
+  )].sort();
+  const podConformance = runsOk ? 1 : (runs[runs.length - 1] || {}).conformance || 0;
+  const squadConformance = typeof opts.squadConformance === 'number' ? opts.squadConformance : 1;
+
+  // Completude POR TABELA artefato-a-artefato (design §D / M1): pod consolidado (3
+  // artefatos) vs squad granular (21) NÃO é identidade ingênua de nome — cada artefato
+  // do squad precisa de ENTRADA no mapa, com pod_output existente e (se `section`) a
+  // seção presente NO ARTEFATO em disco da run 2 (mapping falso não passa).
+  let missing = [];
+  const unmapped = [];
+  const dispensed = [];
+  let sections_verified = 0;
+  let warning = null;
+  const mapEntries = opts.artifactMap || (opts.artifactMapPath ? loadArtifactMap(path.resolve(opts.artifactMapPath)) : null);
+  const map_path = opts.artifactMapPath ? path.resolve(opts.artifactMapPath) : null;
+  if (mapEntries && squadArtifacts.length) {
+    for (const sa of squadArtifacts) {
+      const e = mapEntries.find((m) => m && m.squad_artifact === sa);
+      if (!e) { unmapped.push(sa); missing.push(sa); continue; }        // sem entrada → missing
+      // DISPENSA registrada (decisão do Daniel): entregável fora do design (ex.: loop de
+      // USO pós-entrega) sai de missing SÓ com approved_by — dispensa não-registrada NÃO
+      // vale (bloqueia). Auditável em pair.dispensed[].
+      if (e.disposition === 'dispensed') {
+        if (!e.approved_by) { missing.push(sa); continue; } // dispensa sem aprovação → bloqueia
+        dispensed.push({ squad_artifact: sa, approved_by: e.approved_by, evidence: e.evidence || null });
+        continue;
+      }
+      if (!podArtifacts.includes(e.pod_output)) { missing.push(sa); continue; } // pod_output inexistente
+      if (e.section) {
+        if (!sectionInText(outputText[e.pod_output] || '', e.section)) { missing.push(sa); continue; } // anti-fake-mapping
+        sections_verified++;
+      }
+    }
+  } else {
+    // Sem --artifact-map: comportamento ESTRITO atual (identidade de nome) mantido.
+    missing = squadArtifacts.filter((a) => !podArtifacts.includes(a));
+    if (squadArtifacts.length) warning = 'sem --artifact-map: completude por identidade de nome (estrito); use a tabela artefato-a-artefato para pods consolidados vs squad granular';
+  }
+  const mapped = squadArtifacts.length - unmapped.length;
+  const completeness_ok = missing.length === 0;
+  const conformance_ok = podConformance >= squadConformance;
+  const pairBlocked = !completeness_ok || !conformance_ok;
+  const pair = { podArtifacts, squadArtifacts, missing, completeness_ok, conformance_ok, blocked: pairBlocked, basis, map_path, mapped, unmapped, dispensed, sections_verified, warning };
+
+  // ---- CUSTO: registrado, SEM critério de bloqueio (Daniel 2026-07-24) -----
+  const cost = { runs: N_RUNS + 1, steps: doc.steps.length * (N_RUNS + 1), note: 'registrado sem critério de bloqueio (única dimensão dispensada)' };
+
+  const blocked = !staticRes.ok || !sweep.ok || !runsOk || pairBlocked;
+  return { static: staticRes, sweep, runs, pair, cost, blocked, ok: !blocked };
+}
+
+// ---------------------------------------------------------------------------
+// CLI.
+// ---------------------------------------------------------------------------
+function argVal(args, flag) { const i = args.indexOf(flag); return i >= 0 ? args[i + 1] : null; }
+function argAll(args, flag) { const out = []; for (let i = 0; i < args.length; i++) if (args[i] === flag) out.push(args[i + 1]); return out; }
+
+function main() {
+  const args = process.argv.slice(2);
+  const workflowPath = args[0];
+  if (!workflowPath || workflowPath.startsWith('--')) {
+    console.error('Uso: node scripts/harness-g5-lite.cjs <wf.yaml> [--pod-root <dir>] [--spec <spec>] [--squad-artifact <a> ...] [--artifact-map <path>] [--squad-conformance <0..1>] [--report <out.json>]');
+    process.exit(2);
+  }
+  const res = runG5Lite({
+    workflowPath,
+    podRoot: argVal(args, '--pod-root'),
+    specPath: argVal(args, '--spec'),
+    scenarioPath: argVal(args, '--scenario'),
+    squadArtifacts: argAll(args, '--squad-artifact'),
+    artifactMapPath: argVal(args, '--artifact-map'),
+    squadConformance: args.includes('--squad-conformance') ? Number(argVal(args, '--squad-conformance')) : undefined,
+  });
+  const reportPath = argVal(args, '--report');
+  if (reportPath) fs.writeFileSync(reportPath, JSON.stringify(res, null, 2));
+  console.log(`# G5-LITE — ${path.basename(workflowPath)}`);
+  console.log(`(1) estático=${res.static.ok ? 'OK' : 'FALHA'} · sweep=${res.sweep.ok ? `OK (${res.sweep.proofs} provas)` : 'FALHA'}${res.sweep.reason ? ' — ' + res.sweep.reason : ''}`);
+  console.log(`(2) N=${res.runs.length} runs — conformidade/monotonia: ${res.runs.map((r) => `run${r.run}=${(r.conformance * 100).toFixed(0)}%${r.monotonic ? '↑' : '✗'}`).join(', ')}`);
+  const mapNote = (res.pair.map_path || res.pair.dispensed.length) ? ` [tabela: ${res.pair.mapped}/${res.pair.squadArtifacts.length} mapeados, ${res.pair.sections_verified} seç. verif.${res.pair.dispensed.length ? ', dispensed=' + res.pair.dispensed.map((d) => d.squad_artifact).join(',') : ''}${res.pair.unmapped.length ? ', unmapped=' + res.pair.unmapped.join(',') : ''}]` : (res.pair.warning ? ' [identidade de nome — sem --artifact-map]' : '');
+  console.log(`(3) par [${res.pair.basis}] completude${res.pair.completeness_ok ? '≥' : '<'}squad conformidade${res.pair.conformance_ok ? '≥' : '<'}squad${res.pair.missing.length ? ' faltando=' + res.pair.missing.join(',') : ''}${mapNote} (BLOQUEANTE)`);
+  console.log(`custo: ${res.cost.runs} runs / ${res.cost.steps} etapas — ${res.cost.note}`);
+  console.log(res.ok ? '\nG5-LITE VERDE — paridade LITE satisfeita (prova de bloqueio integral, repetição estatística cortada).' : '\nG5-LITE BLOQUEADO.');
+  process.exit(res.ok ? 0 : 1);
+}
+
+if (require.main === module) main();
+
+module.exports = { runG5Lite, N_RUNS, loadArtifactMap, sectionInText };

package/scripts/harness-g5-lite.test.cjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * harness-g5-lite.test.cjs — suíte do HARNESS G5-LITE (Story SF3.2, AC8; ADR-006
+ * Decisão 2). Prova as 3 etapas + os bloqueios:
+ *  (1) estático + sweep completo; (2) N=2 runs 100%/monotônico sem variância;
+ *  (3) par lado-a-lado: completude≥squad E conformidade≥squad BLOQUEANTES, custo
+ *  registrado SEM bloqueio; waiver ⇒ completude comparada contra DECLARADOS (M-r2-3).
+ *
+ * Node >= 18.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { runG5Lite, N_RUNS } = require('./harness-g5-lite.cjs');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}`); }
+}
+
+const FORMS = path.join(__dirname, '__fixtures__', 'sweep-forms');
+const WF = path.join(FORMS, 'workflows', 'wf-forms.yaml');
+const SPEC = path.join(FORMS, 'specs', 'wf-forms.spec.json');
+const base = { workflowPath: WF, podRoot: FORMS, specPath: SPEC };
+
+// --- Caminho verde: par cuja completude ⊆ pod, conformidade squad ≤ pod ---
+const green = runG5Lite({ ...base, squadArtifacts: ['a_field', 'a_count'], squadConformance: 1 });
+ok(green.ok === true && green.blocked === false, 'AC8 G5-LITE VERDE quando estático+sweep+2 runs+par passam');
+ok(green.static.ok === true, 'AC8 (1) validador estático OK');
+ok(green.sweep.ok === true && green.sweep.proofs === 9, 'AC8 (1) sweep COMPLETO (9 provas) — idêntico ao FULL');
+ok(green.runs.length === N_RUNS && N_RUNS === 2, 'AC8 (2) N=2 runs (sem variância estatística)');
+ok(green.runs.every((r) => r.conformance === 1 && r.monotonic), 'AC8 (2) conformidade 100% + DAG monotônico em AMBAS');
+ok(green.pair.completeness_ok && green.pair.conformance_ok && green.pair.blocked === false, 'AC8 (3) par: completude≥squad E conformidade≥squad');
+ok(green.cost && typeof green.cost.runs === 'number' && !('blocked' in green.cost), 'AC8 (3) custo REGISTRADO sem critério de bloqueio');
+
+// --- BLOQUEIO por completude < squad (squad produziu artefato que o pod não tem) ---
+const lessComplete = runG5Lite({ ...base, squadArtifacts: ['a_field', 'a_EXCLUSIVO_DO_SQUAD'], squadConformance: 1 });
+ok(lessComplete.ok === false && lessComplete.pair.blocked === true, 'AC8 (3) completude < squad → BLOQUEIA');
+ok(lessComplete.pair.missing.includes('a_EXCLUSIVO_DO_SQUAD'), 'AC8 (3) nomeia o artefato faltante (completude é BLOQUEANTE)');
+
+// --- BLOQUEIO por conformidade < squad ---
+const lessConform = runG5Lite({ ...base, squadArtifacts: ['a_field'], squadConformance: 1.5 });
+ok(lessConform.ok === false && lessConform.pair.conformance_ok === false, 'AC8 (3) conformidade < squad → BLOQUEIA (conformidade é BLOQUEANTE)');
+
+// --- WAIVER (M-r2-3): completude comparada contra os DECLARADOS do legado ---
+const wv = runG5Lite({ ...base, waiver: { declared_artifacts: ['a_field', 'a_json'] } });
+ok(wv.pair.basis === 'declared', 'AC8/M-r2-3 waiver presente ⇒ base de completude = artefatos DECLARADOS (não run do squad)');
+ok(wv.ok === true && wv.pair.completeness_ok, 'AC8/M-r2-3 waiver: completude ⊇ declarados ⇒ passa');
+const wvBlock = runG5Lite({ ...base, waiver: { declared_artifacts: ['a_field', 'a_DECLARADO_AUSENTE'] } });
+ok(wvBlock.ok === false && wvBlock.pair.missing.includes('a_DECLARADO_AUSENTE'),
+  'AC8/M-r2-3 waiver: declarado não coberto pelo pod → BLOQUEIA');
+
+// ===========================================================================
+// COMPLETUDE POR TABELA artefato-a-artefato (design §D/M1) — pod CONSOLIDADO (poucos
+// outputs) vs squad GRANULAR: identidade ingênua de nome reprova sempre; o mapa resolve.
+// wf-forms run2 em disco: a_field⇐"## Meta\nstatus: ok", a_count⇐"## Value Stack\n…\n## Notas".
+// ===========================================================================
+// (a) mapa COMPLETO + seções REAIS (verificadas em disco) → pass; sections_verified conta.
+const mapOk = runG5Lite({ ...base,
+  squadArtifacts: ['sq-oferta', 'sq-preco', 'sq-stack'],
+  artifactMap: [
+    { squad_artifact: 'sq-oferta', pod_output: 'a_field', section: '## Meta', evidence: 'phase authoring' },
+    { squad_artifact: 'sq-preco', pod_output: 'a_count', section: '## Value Stack' },
+    { squad_artifact: 'sq-stack', pod_output: 'a_count', section: '## Notas' },
+  ] });
+ok(mapOk.ok === true && mapOk.pair.completeness_ok, 'TABELA mapa completo + seções reais em disco → completude OK (consolidado vs granular resolvido)');
+ok(mapOk.pair.mapped === 3 && mapOk.pair.sections_verified === 3 && mapOk.pair.unmapped.length === 0,
+  'TABELA report auditável: mapped=3, sections_verified=3, unmapped=[]');
+
+// (b) 1 squad artifact SEM entrada no mapa → missing (bloqueia); unmapped[] o nomeia.
+const mapGap = runG5Lite({ ...base,
+  squadArtifacts: ['sq-oferta', 'sq-orfao'],
+  artifactMap: [{ squad_artifact: 'sq-oferta', pod_output: 'a_field' }] });
+ok(mapGap.ok === false && mapGap.pair.missing.includes('sq-orfao') && mapGap.pair.unmapped.includes('sq-orfao'),
+  'TABELA squad artifact SEM entrada no mapa → missing/unmapped (BLOQUEIA)');
+
+// (c) mapa apontando seção INEXISTENTE → blocked (anti-fake-mapping: conteúdo em disco).
+const mapFake = runG5Lite({ ...base,
+  squadArtifacts: ['sq-oferta'],
+  artifactMap: [{ squad_artifact: 'sq-oferta', pod_output: 'a_field', section: '## SECAO_QUE_NAO_EXISTE' }] });
+ok(mapFake.ok === false && mapFake.pair.missing.includes('sq-oferta'),
+  'TABELA anti-fake-mapping: seção declarada inexistente no artefato de disco → BLOQUEIA');
+
+// (c2) mapa apontando pod_output inexistente no wf → blocked.
+const mapBadOut = runG5Lite({ ...base,
+  squadArtifacts: ['sq-x'],
+  artifactMap: [{ squad_artifact: 'sq-x', pod_output: 'a_INEXISTENTE' }] });
+ok(mapBadOut.ok === false && mapBadOut.pair.missing.includes('sq-x'),
+  'TABELA pod_output inexistente nos outputs do wf → BLOQUEIA');
+
+// (d) SEM --artifact-map com squadArtifacts → comportamento estrito atual + aviso.
+const strict = runG5Lite({ ...base, squadArtifacts: ['a_field'] });
+ok(strict.ok === true && strict.pair.map_path === null && /artifact-map/.test(strict.pair.warning || ''),
+  'SEM mapa: completude estrita por identidade de nome mantida, com aviso apontando a tabela');
+
+// (f) DISPENSA registrada (decisão do Daniel): disposition:dispensed COM approved_by →
+// sai de missing, entra em pair.dispensed[] auditável; SEM approved_by → blocked.
+const disp = runG5Lite({ ...base,
+  squadArtifacts: ['sq-oferta', 'sq-die-framework'],
+  artifactMap: [
+    { squad_artifact: 'sq-oferta', pod_output: 'a_field', section: '## Meta' },
+    { squad_artifact: 'sq-die-framework', disposition: 'dispensed', approved_by: 'Alexa Exemplo (2026-07-25)', evidence: 'entregável do loop de uso pós-entrega, fora do design' },
+  ] });
+ok(disp.ok === true && disp.pair.completeness_ok, 'DISPENSA com approved_by → sai de missing (completude OK)');
+// SF12.1/AC8: a asserção conferia o NOME dentro de `approved_by`. O valor virou a identidade
+// fictícia canônica do repo (`scripts/owner-layer.cjs` → FICTIONAL_IDENTITY); o slot continua
+// sendo mecanismo, só o valor é que era personalização.
+ok(disp.pair.dispensed.length === 1 && disp.pair.dispensed[0].squad_artifact === 'sq-die-framework' && /Alexa Exemplo/.test(disp.pair.dispensed[0].approved_by) && disp.pair.dispensed[0].evidence,
+  'DISPENSA registrada em pair.dispensed[] auditável (squad_artifact/approved_by/evidence)');
+ok(!disp.pair.missing.includes('sq-die-framework'), 'DISPENSA aprovada NÃO consta em missing');
+
+const dispNoApprove = runG5Lite({ ...base,
+  squadArtifacts: ['sq-die-framework'],
+  artifactMap: [{ squad_artifact: 'sq-die-framework', disposition: 'dispensed', evidence: 'sem aprovação' }] });
+ok(dispNoApprove.ok === false && dispNoApprove.pair.missing.includes('sq-die-framework') && dispNoApprove.pair.dispensed.length === 0,
+  'DISPENSA SEM approved_by → BLOQUEIA (dispensa não-registrada não vale)');
+
+// (e) --artifact-map via ARQUIVO (loadArtifactMap + JSON) → pass.
+const mdir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-map-'));
+const mapFile = path.join(mdir, 'map.json');
+fs.writeFileSync(mapFile, JSON.stringify([{ squad_artifact: 'sq1', pod_output: 'a_json' }]));
+const fromFile = runG5Lite({ ...base, squadArtifacts: ['sq1'], artifactMapPath: mapFile });
+ok(fromFile.ok === true && fromFile.pair.map_path === mapFile && fromFile.pair.mapped === 1,
+  'TABELA --artifact-map via arquivo (loadArtifactMap json) → mapeia e passa');
+fs.rmSync(mdir, { recursive: true, force: true });
+
+console.log(`\n${passed} asserções OK; ${failures.length} falha(s).`);
+if (failures.length) { for (const f of failures) console.error(`  ✗ ${f}`); process.exit(1); }
+console.log('harness-g5-lite: 3 etapas + bloqueios de par + waiver provados (invocável, reusável por SF3.4).');
+process.exit(0);

package/scripts/hn-carousel-contrato-entrada.test.cjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * hn-carousel-contrato-entrada.test.cjs — tabela-verdade do pattern do veto
+ * `field_matches contrato_entrada` do pod `hn-carousel`, depois que a Story SF11.7
+ * (ADR-026 `DF-SF11.7-8`, oráculo 1) alargou o conjunto de pares implementados de
+ * `^(ancora:hn)$` para `^(ancora:hn|roteiro:proprio)$`.
+ *
+ * POR QUE ESTE TESTE EXISTE, e o que ele NÃO é (honestidade obrigatória):
+ * o sidecar do smoke do pod planta UM único digest conforme, com `ancora:hn`. Com o
+ * pattern alargado, o smoke continua provando (i) que `ancora:hn` passa e (ii) que valor
+ * fora do conjunto bloqueia — mas ele JAMAIS exercita positivamente o caminho `roteiro`
+ * (`ADR-026 DF-SF11.7-8`, ponto cego declarado). Este teste é o oráculo determinístico
+ * que fecha essa metade; o outro é a run real na instalação, que a story registra.
+ * Ele NÃO prova proveniência (o campo é auto-atestado pelo agente — ADR-015) e NÃO prova
+ * fidelidade ao roteiro (não há veto de máquina sobre isso, `DF-SF11.7-4`).
+ *
+ * DUPLICAÇÃO DECLARADA: o valor LITERAL do pattern vive no `wf` da instalação
+ * (`second-brain/pods/hn-carousel/workflows/wf-hn-carousel.yaml`), que não é arquivo
+ * deste repo. Aqui ele é REPETIDO de propósito, para o teste ser determinístico e sem
+ * fixture de pod (`DF-SF11.7-8`). Se os dois divergirem, este teste continua verde e
+ * mente: a guarda contra isso é a INVARIANTE DE MANUTENÇÃO escrita no `_sources` da
+ * própria assertion + a matriz §0.3 do knowledge, auditadas pelo `*review`.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const path = require('node:path');
+const { evalVeto } = require('./pc-run-pod.cjs');
+
+// Espelho do pattern do `wf` (ver DUPLICAÇÃO DECLARADA acima).
+const PATTERN = '^(ancora:hn|roteiro:proprio)$';
+const ASSERTION = { type: 'field_matches', field: 'contrato_entrada', pattern: PATTERN };
+
+const roots = { podRoot: __dirname, runDir: __dirname };
+const evalOn = (artifactText) =>
+  evalVeto(ASSERTION, artifactText, path.join(__dirname, 'digest.md'), roots);
+
+// Artefato mínimo no formato real do fecho do digest (campo fora dos headings, ADR-005 A).
+const digest = (contratoLine) =>
+  ['## Noticia', 'texto', '', '## Angulos para Slides', '- a', '', 'confianca: alta']
+    .concat(contratoLine === null ? [] : [contratoLine])
+    .join('\n') + '\n';
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}`); }
+}
+
+// --- Tabela-verdade do DF-SF11.7-8 (5 casos, binária) ---
+ok(evalOn(digest('contrato_entrada: ancora:hn')).ok === true,
+  '`ancora:hn` → PASSA (M1 preservado: o alargamento é superset por construção)');
+
+ok(evalOn(digest('contrato_entrada: roteiro:proprio')).ok === true,
+  '`roteiro:proprio` → PASSA (par implementado pela §1b, Story SF11.7)');
+
+ok(evalOn(digest('contrato_entrada: roteiro:outro')).ok === false,
+  '`roteiro:outro` → BLOQUEIA (modo implementado, fonte que não existe)');
+
+ok(evalOn(digest('contrato_entrada: ancora:x')).ok === false,
+  '`ancora:x` → BLOQUEIA (fonte fora do conjunto implementado)');
+
+ok(evalOn(digest(null)).ok === false,
+  'campo AUSENTE → BLOQUEIA (fail-closed: sem declaração de entrada não há artefato válido)');
+
+// --- Guardas de borda: o alargamento não pode ter virado pattern frouxo ---
+ok(evalOn(digest('contrato_entrada: ancora:hn|roteiro:proprio')).ok === false,
+  'valor com o próprio `|` literal → BLOQUEIA (a alternância é do regex, não do campo)');
+
+ok(evalOn(digest('contrato_entrada: xancora:hn')).ok === false,
+  'prefixo espúrio → BLOQUEIA (âncoras ^ e $ intactas)');
+
+ok(evalOn(digest('contrato_entrada: roteiro:proprio ')).ok === true,
+  'espaço à direita → PASSA (extractField apara a borda; comportamento pré-existente do motor)');
+
+// --- AC-B4 item 3 (ADR-026 Emenda 3, DF-SF11.7-26): VIOLABILIDADE do pattern alargado ---
+// A guarda SF10.18 protege "a assertion que você alargou continua VIOLÁVEL". O instrumento que o
+// harness usa para isso é `findNonMatchingValue` — usado aqui DIRETAMENTE (não um proxy), sem tocar
+// uma linha de `smoke-pod-workflow.cjs`. O `--sweep` deste pod está vermelho por defeito de OUTRA
+// etapa (o `command_check` de MEDIDA de `visuals`, que por design nunca bloqueia); isso não diz nada
+// sobre esta assertion, e é exatamente a distinção que esta asserção mantém viva.
+const { findNonMatchingValue } = require('./smoke-pod-workflow.cjs');
+const violador = findNonMatchingValue(PATTERN);
+ok(violador.ok === true && evalOn(digest(`contrato_entrada: ${violador.value}`)).ok === false,
+  `pattern alargado continua VIOLÁVEL — findNonMatchingValue derivou ${violador.value === '' ? '<string vazia>' : `"${violador.value}"`} e o veto BLOQUEIA (não virou pattern universal)`);
+
+ok(evalOn(digest('contrato_entrada: valor-que-nenhum-modo-declara')).ok === false,
+  'valor arbitrário fora do conjunto → BLOQUEIA (2ª evidência de não-universalidade)');
+
+console.log(`\n${passed}/${passed + failures.length} asserções da tabela-verdade de \`contrato_entrada\` passaram.`);
+if (failures.length) {
+  console.error('FALHAS:\n  - ' + failures.join('\n  - '));
+  process.exit(1);
+}

package/scripts/migrate-squad-orchestration.test.cjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * migrate-squad-orchestration.test.cjs — smoke de ORQUESTRAÇÃO F0→F3 fim-a-fim
+ * sobre o squad de fixture (Story SF3.3, Testing) + ACs estáticos.
+ * Prova que o comando ENCADEIA os motores existentes (migration-manifest +
+ * forge-generate --additive + validate-no-clone) nas fases — sem execução de LLM
+ * (isso é SF3.4). NÃO-fake-green: artefatos reais em disco.
+ * Cobre:
+ *   AC3  spec AUTORADA: redutível→veto.assertions c/ _sources; aritmético→checkpoint
+ *        (nunca veto); tarefa-canário + .smoke.json na mesma etapa.
+ *   AC4  forge-generate --additive + tierOverride invocado no loop (reuso SF3.1).
+ *   AC6  pod-critic.md G6 tem a dimensão anti-persona (item 12) — leitura do arquivo.
+ *   AC7  ZERO ingestão automática de memória no código do comando.
+ *   AC8  ZERO `git rm`/deleção no código do comando; F3 só PROPÕE ao Daniel.
+ *   E2E  F0→F1→F2(spec/gen/lint)→F3(coverage) encadeado uma vez.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const m = require('./migration-manifest.cjs');
+const g = require('./forge-generate.cjs');
+const clone = require('./validate-no-clone.cjs');
+
+const ROOT = path.join(__dirname, '..');
+const FIX = path.join(__dirname, '__fixtures__', 'migrate-squad');
+const LEGACY = path.join(FIX, 'legacy-squad');
+const AUTH = path.join(FIX, 'authored');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}`); }
+}
+function tmp(n) { return fs.mkdtempSync(path.join(os.tmpdir(), `mig-${n}-`)); }
+
+// ---------------------------------------------------------------------------
+// AC3 — spec AUTORADA com o mapeamento veto/checkpoint por machine-redutibilidade.
+// ---------------------------------------------------------------------------
+{
+  const spec = JSON.parse(fs.readFileSync(path.join(AUTH, 'specs', 'wf-sample.spec.json'), 'utf8'));
+  ok(Array.isArray(spec._sources) && spec._sources.some((s) => s.includes('wf-sample.yaml')), 'AC3 spec cita o legado em _sources (ADR-005, nunca parse automático)');
+  const intake = spec.agents.find((a) => a.step === 'mm-intake');
+  const redu = intake.veto.find((v) => v.type === 'count_gte');
+  ok(redu && redu._sources, 'AC3 veto_condition machine-redutível (count_gte) → veto.assertions COM _sources');
+  const build = spec.agents.find((a) => a.step === 'mm-build');
+  ok(build.checkpoint && build.checkpoint.blocking && /LTV:CAC/.test(build.checkpoint.criteria), 'AC3 condição aritmética (LTV:CAC≥3) → checkpoint.blocking');
+  const allVeto = JSON.stringify(spec.agents.map((a) => a.veto || []));
+  ok(!/LTV|CAC/.test(allVeto), 'AC3 aritmético NUNCA vira veto.assertion (fronteira ADR-002)');
+  const smokePath = path.join(AUTH, 'specs', 'wf-sample.smoke.json');
+  const smoke = JSON.parse(fs.readFileSync(smokePath, 'utf8'));
+  ok(smoke._authored_with === 'specs/wf-sample.spec.json' && smoke.happy_path['mm-intake'], 'AC3 tarefa-canário + .smoke.json AUTORADOS na mesma etapa que a spec');
+}
+
+// ---------------------------------------------------------------------------
+// E2E F0→F1→F2(gen/lint)→F3 encadeado + AC4 (forge-generate --additive+tierOverride).
+// ---------------------------------------------------------------------------
+{
+  const dir = tmp('e2e');
+  const mf = path.join(dir, 'MIGRATION-hormozi.yaml');
+  const pod = path.join(dir, 'pod');
+  const specPath = path.join(AUTH, 'specs', 'wf-sample.spec.json');
+  const spec = JSON.parse(fs.readFileSync(specPath, 'utf8'));
+
+  // F0
+  const inv = m.cmdInit(mf, { squad: 'hormozi', squadDir: LEGACY, now: 'T0' });
+  ok(inv.inventory.families.length === 10, 'E2E F0 inventário das 10 famílias');
+
+  // F1: triagem + aprovação (PARA no Daniel; sem ela F2 não abre).
+  m.cmdTriageSet(mf, { workflow: 'wf-sample', disposition: 'migrate', purpose: 'wf-sample.yaml:1', overlap: '', basis: 'julgamento', now: 'T' });
+  m.cmdTriageApprove(mf, { workflow: 'wf-sample', approvedBy: 'daniel', now: 'T' });
+
+  // F2b: pod PRÉ-EXISTENTE (aditivo preserva). Gera base, depois --additive.
+  // SF12.4a/ADR-030 Bloco O — pod PRÉ-EXISTENTE (bootstrap do fixture) — 'derived'.
+  g.generatePod({ pod: 'hormozi-method-fixture', workflowId: 'existing', agents: [{ name: 'legacy-keeper', output: 'kept' }] }, pod, { tierOverride: 'STANDARD/COMPLEX', specOrigin: 'derived' });
+  const baseWf = path.join(pod, 'workflows', 'wf-existing.yaml');
+  ok(fs.existsSync(baseWf), 'E2E base pod gerado (workflow pré-existente)');
+
+  // F2a: open-line (só após aprovação).
+  m.cmdOpenLine(mf, { workflow: 'wf-sample', spec: specPath, podDir: pod, pod: 'hormozi-method-fixture', owns: ['workflows/wf-sample.yaml', 'agents/mm-intake.md', 'agents/offer-engineer.md'], now: 'T' });
+
+  // F2b: geração ADITIVA + tierOverride agregado (reuso SF3.1; AC4).
+  // SF12.4a/ADR-030 Bloco O (AC48/AC50b) — F2b É o call site real de `*migrate-squad`:
+  // 'authored' (mesmo com --additive) — Frente 5 passa por aqui, tem que seguir com gate.
+  const CANON_REFUSED_MSQ = { nao_se_aplica: true, razao: 'fixture E2E de *migrate-squad não modela ritmo/entrada/entregável', respondido_por: 'migrate-squad-orchestration.test.cjs' };
+  g.generatePod({ ...spec, ritmo: CANON_REFUSED_MSQ, contrato_entrada: CANON_REFUSED_MSQ, entregavel: CANON_REFUSED_MSQ }, pod, { additive: true, tierOverride: 'STANDARD/COMPLEX', owns: ['workflows/wf-sample.yaml', 'agents/mm-intake.md', 'agents/offer-engineer.md'], specOrigin: 'authored' });
+  ok(fs.existsSync(path.join(pod, 'workflows', 'wf-sample.yaml')), 'AC4 forge-generate --additive gerou wf-sample.yaml (novo)');
+  ok(fs.existsSync(baseWf), 'AC4 modo aditivo PRESERVOU o workflow pré-existente');
+  const wfGen = fs.readFileSync(path.join(pod, 'workflows', 'wf-sample.yaml'), 'utf8');
+  ok(/count_gte/.test(wfGen) && /Value Stack/.test(wfGen), 'AC4 veto redutível da spec propagado ao wf-*.yaml gerado');
+
+  // F2d: lint regra 3 sobre os artefatos autorados do pod → limpo; legado → reprova.
+  const cleanAgent = clone.run([path.join(AUTH, 'agents', 'offer-engineer.md'), '--squad-source', LEGACY]);
+  ok(cleanAgent.violations.length === 0, 'F2d validate-no-clone limpo no agente capability-based autorado');
+  const dirtyAgent = clone.run([path.join(LEGACY, 'agents', 'hormozi-offer.md'), '--squad-source', LEGACY]);
+  ok(dirtyAgent.violations.length > 0, 'F2d validate-no-clone reprova o agente legado (lint wired ao loop)');
+
+  // F3: coverage (diff squad×manifest). Sem endereçar tudo, há resíduo → gate barra.
+  const cov = m.cmdCoverage(mf, { squadDir: LEGACY });
+  ok(cov.total > 0 && !cov.clean, 'AC8/F3 coverage computa diff squad×manifest (resíduo barra fechamento até endereçar tudo)');
+}
+
+// ---------------------------------------------------------------------------
+// AC6 — pod-critic.md G6 estendido com a dimensão anti-persona (leitura do arquivo).
+// ---------------------------------------------------------------------------
+{
+  const pc = fs.readFileSync(path.join(ROOT, 'template', 'pods', 'squad-forge', 'agents', 'pod-critic.md'), 'utf8');
+  ok(/\(12\)\s*\*\*anti-persona/.test(pc), 'AC6 pod-critic G6 contém o item (12) anti-persona');
+  ok(/tabela 16→N do manifest/.test(pc), 'AC6 dimensão usa o par exato da tabela 16→N do manifest (B.5)');
+  ok(/dos 7 falhando/.test(pc), 'AC6 contador do gate atualizado (6→7 com o item (13) anti-autoatestado, SF7.11)');
+  const budgets = fs.statSync(path.join(ROOT, 'template', 'pods', 'squad-forge', 'agents', 'pod-critic.md')).size;
+  ok(Math.ceil(budgets / 4) <= 1200, 'AC6 pod-critic dentro do budget (≤1200 tokens) após a extensão');
+}
+
+// ---------------------------------------------------------------------------
+// AC7 — ZERO ingestão automática de memória no código do comando.
+// ---------------------------------------------------------------------------
+{
+  const mmCode = fs.readFileSync(path.join(ROOT, 'scripts', 'migration-manifest.cjs'), 'utf8');
+  ok(!/forge-ingest-memory/.test(mmCode), 'AC7 migration-manifest.cjs NUNCA chama forge-ingest-memory (zero automação)');
+  const pipeline = fs.readFileSync(path.join(ROOT, 'template', 'pods', 'squad-forge', 'tasks', 'pipeline.md'), 'utf8');
+  ok(/NUNCA ingeridos automaticamente/.test(pipeline), 'AC7 pipeline F0-F3 declara learnings como candidatos (nunca ingestão automática)');
+  // forge-chief: ingest só na linha *ingest-memory, não na de *migrate-squad.
+  const fc = fs.readFileSync(path.join(ROOT, 'template', 'pods', 'squad-forge', 'agents', 'forge-chief.md'), 'utf8');
+  const migrateLine = fc.split('\n').find((l) => l.includes('*migrate-squad'));
+  ok(migrateLine && !/forge-ingest-memory/.test(migrateLine), 'AC7 a linha *migrate-squad NÃO invoca ingestão de memória');
+}
+
+// ---------------------------------------------------------------------------
+// AC8 — ZERO `git rm`/deleção no código do comando; F3 só PROPÕE ao Daniel.
+// ---------------------------------------------------------------------------
+{
+  const mmCode = fs.readFileSync(path.join(ROOT, 'scripts', 'migration-manifest.cjs'), 'utf8');
+  ok(!/git\s+rm|rmSync|unlinkSync|rmdirSync/.test(mmCode), 'AC8 migration-manifest.cjs não executa git rm nem deleção de arquivos do squad');
+  const pipeline = fs.readFileSync(path.join(ROOT, 'template', 'pods', 'squad-forge', 'tasks', 'pipeline.md'), 'utf8');
+  ok(/nunca deleta.*git rm.*pc-devops/is.test(pipeline), 'AC8 pipeline F3: comando nunca deleta — proposta ao Daniel, git rm é exclusivo do pc-devops');
+}
+
+console.log(`\n${passed} verificações OK, ${failures.length} falha(s).`);
+if (failures.length) { for (const f of failures) console.error(`  - ${f}`); process.exit(1); }
+process.exit(0);