@daniellins/power-claude 0.16.3

package/scripts/pc-run-pipeline.test.cjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pc-run-pipeline.test.cjs — suíte do maestro cross-pod (Story SF9.1, ADR-017).
+ * Prova, com pipeline sintético (pods-fixture 1-step, sem pods reais):
+ *  (AC4) validate-pipeline: golden passa; cada malformação recusa fail-loud.
+ *  (AC2/AC5) E2E golden: as 2 fases concluem; portão GO avança.
+ *  (AC2) SUPERVISOR-NÃO-EXECUTOR: advance com run-filho não-done FALHA (o pipeline não
+ *        executa a fase); e o motor não importa nada além de pc-run-pod (sem child_process/
+ *        rede/LLM) — provado por inspeção da fonte.
+ *  (AC11) portão binário: NO-GO trava e a fase seguinte NUNCA dispara; GO avança; checkpoint
+ *         humano PARA (blocked) e só approve (GO)/reject (NO-GO) resolve.
+ *  (AC3) referência-sem-cópia: o input da fase B é o PATH real do output da fase A (task-ref),
+ *        verificado em disco; nenhuma cópia é criada no runDir da fase B.
+ *  (AC2) baseline: run done mas output ausente em disco → fail-loud.
+ *  retomada: recarga fresca do state → resume do ponto (fase A completed, B pending).
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const pp = require('./pc-run-pipeline.cjs');
+const rpod = require('./pc-run-pod.cjs');
+const vpipe = require('./validate-pipeline.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const FIX = path.join(__dirname, '__fixtures__', 'pipeline');
+const PODS = path.join(FIX, 'pods');
+const CONTRACT = path.join(FIX, 'pipelines', 'pipeline-demo.yaml');
+const CONTRACT_CP = path.join(FIX, 'pipelines', 'pipeline-checkpoint.yaml');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) { if (cond) { passed++; console.log(`[OK   ] ${label}`); } else { failures.push(label); console.error(`[FALHA] ${label}`); } }
+function throwsFail(fn) { try { fn(); return false; } catch (e) { if (e instanceof vpipe.Fail || e instanceof pp.PipelineError) return true; throw e; } }
+function freshSR() { return fs.mkdtempSync(path.join(os.tmpdir(), 'pipe-sr-')); }
+function opts(sr) { return { podsRoot: PODS, stateRoot: sr }; }
+
+/** Ator EXTERNO (operador): completa o run-filho da fase escrevendo o artefato e dirigindo pc-run-pod. */
+function completeChild(sr, id, pid, artFile, body) {
+  const st = pp.loadPipelineState(sr, id).phases[pid];
+  fs.mkdirSync(path.join(st.run_dir, 'artifacts'), { recursive: true });
+  fs.writeFileSync(path.join(st.run_dir, 'artifacts', artFile), body);
+  const ctx = rpod.openRun({
+    statePath: path.join(st.run_dir, 'state.json'),
+    workflowPath: path.join(PODS, st.pod, 'workflows', `${st.workflow}.yaml`),
+    podRootOverride: path.join(PODS, st.pod),
+  });
+  rpod.advance(ctx);
+}
+
+// ===========================================================================
+// (AC4) validate-pipeline
+// ===========================================================================
+console.log('--- (AC4) validate-pipeline ---');
+ok(!throwsFail(() => vpipe.validatePipeline(CONTRACT, PODS)), 'golden: contrato demo válido PASSA');
+function badContract(mutate) {
+  const doc = fs.readFileSync(CONTRACT, 'utf8');
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'pipe-bad-'));
+  const p = path.join(d, 'pipeline-x.yaml');
+  fs.writeFileSync(p, mutate(doc));
+  return p;
+}
+ok(throwsFail(() => vpipe.validatePipeline(badContract((s) => s.replace('id: demo', 'deliverable_only: x')), PODS)), 'fail-loud: id ausente RECUSA');
+ok(throwsFail(() => vpipe.validatePipeline(badContract((s) => s.replace('workflow: wf-b', 'workflow: wf-inexistente')), PODS)), 'fail-loud: pod/workflow inexistente em disco RECUSA');
+ok(throwsFail(() => vpipe.validatePipeline(badContract((s) => s.replace('"<- phase-a.doc"', '"<- phase-z.doc"')), PODS)), 'fail-loud: input → fase não-declarada-antes RECUSA');
+ok(throwsFail(() => vpipe.validatePipeline(badContract((s) => s.replace('"<- phase-a.doc"', '"<- phase-a.inexistente"')), PODS)), 'fail-loud: input → output inexistente da fase-fonte RECUSA');
+ok(throwsFail(() => vpipe.validatePipeline(badContract((s) => s.replace('id: phase-b', 'id: phase-a')), PODS)), 'fail-loud: id de fase duplicado RECUSA');
+// input referenciando fase FUTURA (self/adiante): trocar a referência de B para apontar a si mesma
+ok(throwsFail(() => vpipe.validatePipeline(badContract((s) => s.replace('"<- phase-a.doc"', '"<- phase-b.final"')), PODS)), 'fail-loud: input → própria fase (ciclo) RECUSA');
+// gate malformado (asserção sem forma válida)
+ok(throwsFail(() => vpipe.validatePipeline(badContract((s) => s.replace('{ type: field_matches, field: quality, pattern: "^(alta|media|baixa)$" }', '{ type: inventado, field: x }')), PODS)), 'fail-loud: gate.veto com type inválido RECUSA');
+
+// ===========================================================================
+// (AC2) supervisor-não-executor — o motor não importa nada além de pc-run-pod
+// ===========================================================================
+console.log('--- (AC2) supervisor-não-executor (inspeção da fonte) ---');
+const motorSrc = fs.readFileSync(path.join(__dirname, 'pc-run-pipeline.cjs'), 'utf8');
+ok(!/require\(\s*['"]node:child_process['"]/.test(motorSrc) && !/require\(\s*['"](node:)?(http|https|net)['"]/.test(motorSrc),
+  'motor NÃO importa child_process/http/https/net — não pode spawnar nem chamar rede (não é executor)');
+ok(!/execFileSync|execSync|\bspawn\b/.test(motorSrc), 'motor não usa execFileSync/spawn — só o módulo pc-run-pod (startRun) e leitura de state');
+
+// ===========================================================================
+// E2E golden + (AC3) referência-sem-cópia + (AC2) supervisor-não-executor comportamental
+// ===========================================================================
+console.log('--- E2E golden + referência-sem-cópia ---');
+{
+  const sr = freshSR();
+  pp.init(CONTRACT, opts(sr));
+  let r = pp.advance('demo', opts(sr));
+  ok(r.status === 'started' && r.phase === 'phase-a', 'E2E: advance inicia a fase A (start do run-filho)');
+  ok(throwsFail(() => pp.advance('demo', opts(sr))), 'SUPERVISOR-NÃO-EXECUTOR: advance com run-filho A não-done FALHA (o pipeline não executa a fase)');
+  completeChild(sr, 'demo', 'phase-a', 'make.md', '## Body\nA\nstatus: ok\nquality: alta\n');
+  r = pp.advance('demo', opts(sr));
+  ok(r.status === 'phase-complete' && r.phase === 'phase-a', 'E2E: com filho A done + baseline + portão GO → fase A CONCLUÍDA');
+  r = pp.advance('demo', opts(sr));
+  ok(r.status === 'started' && r.phase === 'phase-b', 'E2E: advance inicia a fase B');
+  // referência-sem-cópia: o task-ref da fase B é o PATH real do output da fase A
+  const stA = pp.loadPipelineState(sr, 'demo').phases['phase-a'];
+  const outA = stA.outputs_resolved.doc;
+  const childB = rpod.readState(path.join(pp.loadPipelineState(sr, 'demo').phases['phase-b'].run_dir, 'state.json'));
+  ok(childB.task_ref && childB.task_ref.includes(outA), 'AC3: task-ref da fase B contém o PATH real do output da fase A (referência)');
+  const bRunDir = pp.loadPipelineState(sr, 'demo').phases['phase-b'].run_dir;
+  ok(!fs.existsSync(path.join(bRunDir, 'artifacts', 'make.md')), 'AC3: nenhuma CÓPIA do output de A foi criada no runDir de B (sem cópia)');
+  // o brief do 1º step de B (buildBrief) mostra "Tarefa:" com o path — canal task-ref
+  const bCtx = rpod.openRun({ statePath: path.join(bRunDir, 'state.json'), workflowPath: path.join(PODS, 'pipe-b', 'workflows', 'wf-b.yaml'), podRootOverride: path.join(PODS, 'pipe-b') });
+  ok(rpod.buildBrief(bCtx, 'use').includes(outA), 'AC3: o brief do 1º step de B injeta o path do output de A via "Tarefa:" (task-ref lido pelo pod)');
+  completeChild(sr, 'demo', 'phase-b', 'use.md', '## Body\nB\nstatus: ok\n');
+  r = pp.advance('demo', opts(sr));
+  ok(r.status === 'phase-complete' && r.phase === 'phase-b', 'E2E: fase B CONCLUÍDA');
+  r = pp.advance('demo', opts(sr));
+  ok(r.status === 'complete', 'E2E: pipeline COMPLETO após as 2 fases');
+}
+
+// ===========================================================================
+// (AC11) portão binário: NO-GO trava; fase seguinte nunca dispara
+// ===========================================================================
+console.log('--- (AC11) portão NO-GO trava ---');
+{
+  const sr = freshSR();
+  pp.init(CONTRACT, opts(sr));
+  pp.advance('demo', opts(sr)); // start A
+  // filho A done, MAS o portão de MÁQUINA (quality) NO-GO: quality inválida
+  completeChild(sr, 'demo', 'phase-a', 'make.md', '## Body\nA\nstatus: ok\nquality: pessima\n');
+  ok(throwsFail(() => pp.advance('demo', opts(sr))), 'portão NO-GO (quality inválida): advance FALHA fail-loud');
+  const s = pp.loadPipelineState(sr, 'demo');
+  ok(s.phases['phase-a'].status === 'failed' && s.phases['phase-b'].status === 'pending',
+    'portão NO-GO: fase A FALHOU e fase B NUNCA disparou (segue pending)');
+}
+
+// ===========================================================================
+// (AC11) checkpoint humano: PARA (blocked); approve=GO avança, reject=NO-GO trava
+// ===========================================================================
+console.log('--- (AC11) checkpoint humano (GO/NO-GO) ---');
+{
+  const sr = freshSR();
+  pp.init(CONTRACT_CP, opts(sr));
+  pp.advance('cp-demo', opts(sr)); // start A
+  completeChild(sr, 'cp-demo', 'phase-a', 'make.md', '## Body\nA\nstatus: ok\nquality: alta\n');
+  const r = pp.advance('cp-demo', opts(sr));
+  ok(r.status === 'blocked', 'checkpoint humano: advance PARA em blocked (sem auto-avanço)');
+  ok(throwsFail(() => pp.advance('cp-demo', opts(sr))), 'checkpoint: advance enquanto blocked FALHA (exige decisão humana)');
+  const ap = pp.approve('cp-demo', { ...opts(sr), note: 'ok com ressalva menor' });
+  ok(ap.status === 'phase-complete', 'checkpoint: approve = GO conclui a fase (ressalva como texto livre num GO)');
+  ok(pp.loadPipelineState(sr, 'cp-demo').phases['phase-a'].note === 'ok com ressalva menor', 'checkpoint: ressalva registrada no state (não é 3º estado de fluxo)');
+}
+{
+  const sr = freshSR();
+  pp.init(CONTRACT_CP, opts(sr));
+  pp.advance('cp-demo', opts(sr));
+  completeChild(sr, 'cp-demo', 'phase-a', 'make.md', '## Body\nA\nstatus: ok\nquality: alta\n');
+  pp.advance('cp-demo', opts(sr)); // blocked
+  ok(throwsFail(() => pp.reject('cp-demo', opts(sr))), 'checkpoint: reject = NO-GO trava (fail-loud)');
+  ok(pp.loadPipelineState(sr, 'cp-demo').phases['phase-b'].status === 'pending', 'checkpoint NO-GO: fase B nunca disparou');
+}
+
+// ===========================================================================
+// (AC2) baseline: run done mas output ausente em disco → fail-loud
+// ===========================================================================
+console.log('--- (AC2) baseline (artefato em disco) ---');
+{
+  const sr = freshSR();
+  pp.init(CONTRACT, opts(sr));
+  pp.advance('demo', opts(sr));
+  completeChild(sr, 'demo', 'phase-a', 'make.md', '## Body\nA\nstatus: ok\nquality: alta\n');
+  // apaga o output DEPOIS do filho fechar done → baseline do pipeline deve pegar (não confia no state)
+  fs.rmSync(path.join(pp.loadPipelineState(sr, 'demo').phases['phase-a'].run_dir, 'artifacts', 'make.md'));
+  ok(throwsFail(() => pp.advance('demo', opts(sr))), 'baseline: run done mas output ausente em disco → advance FALHA (nunca por relato do state)');
+}
+
+// ===========================================================================
+// retomada: recarga fresca do state → resume do ponto
+// ===========================================================================
+console.log('--- retomada ---');
+{
+  const sr = freshSR();
+  pp.init(CONTRACT, opts(sr));
+  pp.advance('demo', opts(sr));
+  completeChild(sr, 'demo', 'phase-a', 'make.md', '## Body\nA\nstatus: ok\nquality: alta\n');
+  pp.advance('demo', opts(sr)); // A completed
+  // "mata" o processo: uma leitura FRESCA do disco vê A completed, B pending
+  const fresh = pp.loadPipelineState(sr, 'demo');
+  ok(fresh.phases['phase-a'].status === 'completed' && fresh.phases['phase-b'].status === 'pending', 'retomada: state persistido em disco mostra A completed, B pending');
+  ok(pp.currentPhaseId(fresh) === 'phase-b', 'retomada: currentPhaseId resume em B (não repete A)');
+  const r = pp.advance('demo', opts(sr));
+  ok(r.status === 'started' && r.phase === 'phase-b', 'retomada: advance continua do ponto (inicia B), não recomeça A');
+}
+
+// ===========================================================================
+// (SF9.2 CONCERNS-1) roteamento de memória: start E next do operador isolam o run de
+// pipeline — o memory REAL do pod fica byte-intocado. Retrocompat: standalone usa podRoot.
+// ===========================================================================
+console.log('--- (SF9.2 CONCERNS-1) roteamento de memória do run ---');
+const crypto = require('node:crypto');
+const sha = (p) => (fs.existsSync(p) ? crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex') : 'ABSENT');
+
+/** Copia os pods-fixture para um pods-root próprio (para checar/semear a memória sem tocar o commit). */
+function copyPods() {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'pipe-pods-'));
+  fs.cpSync(PODS, path.join(d, '.'), { recursive: true });
+  return d;
+}
+{
+  const podsRoot = copyPods();
+  const sr = freshSR();
+  const o = { podsRoot, stateRoot: sr };
+  // semeia a memória REAL do pod pipe-a com conteúdo conhecido
+  const memReal = path.join(podsRoot, 'pipe-a', 'memory');
+  fs.mkdirSync(memReal, { recursive: true });
+  const jsonl = path.join(memReal, 'learnings.jsonl');
+  const cons = path.join(memReal, 'learnings.consolidated.md');
+  fs.writeFileSync(jsonl, '{"seed":"baseline-sf9.2"}\n');
+  fs.writeFileSync(cons, '# consolidado semeado\n');
+  const before = { jsonl: sha(jsonl), cons: sha(cons) };
+  // contrato apontando para o pods-root copiado
+  const contract = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'pipe-c-')), 'pipeline-demo.yaml');
+  fs.writeFileSync(contract, fs.readFileSync(CONTRACT, 'utf8'));
+  pp.init(contract, o);
+  pp.advance('demo', o); // start fase A (persiste memory_pod_dir=tmp no state do filho)
+  // OPERADOR completa a fase via pc-run-pod SEM memoryPodDir (o fluxo CLI real que causava o bug):
+  const stA = pp.loadPipelineState(sr, 'demo').phases['phase-a'];
+  fs.mkdirSync(path.join(stA.run_dir, 'artifacts'), { recursive: true });
+  fs.writeFileSync(path.join(stA.run_dir, 'artifacts', 'make.md'), '## Body\nA\nstatus: ok\nquality: alta\n');
+  const ctxA = rpod.openRun({ statePath: path.join(stA.run_dir, 'state.json'), workflowPath: path.join(podsRoot, 'pipe-a', 'workflows', 'wf-a.yaml'), podRootOverride: path.join(podsRoot, 'pipe-a') });
+  rpod.advance(ctxA); // completa o run → recordLearning dispara; DEVE ir para o tmp, não para o memory real
+  const after = { jsonl: sha(jsonl), cons: sha(cons) };
+  ok(before.jsonl === after.jsonl && before.cons === after.cons,
+    'CONCERNS-1: após start + next do operador, o memory REAL do pod fica BYTE-INTOCADO (roteamento honrado pelo state)');
+  // e o learning FOI escrito — só que no dir isolado gravado no state do run
+  const routed = rpod.readState(path.join(stA.run_dir, 'state.json')).memory_pod_dir;
+  ok(routed && routed.startsWith(os.tmpdir()) && fs.existsSync(path.join(routed, 'memory', 'learnings.jsonl')),
+    'CONCERNS-1: o learning do run foi para o dir ISOLADO gravado no state (memory_pod_dir), não para o pod');
+}
+// retrocompat: run STANDALONE (sem memoryPodDir) escreve no podRoot — comportamento intacto
+{
+  const podsRoot = copyPods();
+  const podA = path.join(podsRoot, 'pipe-a');
+  const runsRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pipe-standalone-'));
+  const { ctx } = rpod.startRun({ workflowPath: path.join(podA, 'workflows', 'wf-a.yaml'), podRootOverride: podA, pod: 'pipe-a', workflow: 'wf-a', runsRoot, runId: 'r1' });
+  const st = rpod.readState(path.join(ctx.runDir, 'state.json'));
+  ok(!('memory_pod_dir' in st), 'retrocompat: run standalone (sem memoryPodDir) NÃO grava memory_pod_dir no state');
+  fs.mkdirSync(path.join(ctx.runDir, 'artifacts'), { recursive: true });
+  fs.writeFileSync(path.join(ctx.runDir, 'artifacts', 'make.md'), '## Body\nA\nstatus: ok\n');
+  const ctx2 = rpod.openRun({ statePath: path.join(ctx.runDir, 'state.json'), workflowPath: path.join(podA, 'workflows', 'wf-a.yaml'), podRootOverride: podA });
+  ok(ctx2.memoryPodDir === podA, 'retrocompat: openRun de run sem memory_pod_dir resolve memoryPodDir = podRoot (comportamento atual intacto)');
+}
+
+if (failures.length > 0) {
+  console.error(`\nSuíte pc-run-pipeline FALHOU: ${failures.length} de ${passed + failures.length}.`);
+  process.exit(1);
+}
+console.log(`\n${passed} asserções verdes. Maestro cross-pod pc-run-pipeline (SF9.1) provado.`);
+process.exit(0);

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

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pc-run-pod-countgte.test.cjs — suíte DEDICADA do FIX do bypass `count_gte`
+ * (Story SF3.1, M-r2-5 / DoD 4). Arquivo separado do counter/runner de propósito
+ * (isola o território SF3.1 sobre evalVeto, evita colisão de merge com a suíte SF2.3).
+ *
+ * O furo (verificado no código antes do fix): `evalVeto` tentava `extractField`
+ * PRIMEIRO — um artefato com a linha `Value Stack: 99` passava o veto SEM nenhum
+ * item de lista (número auto-declarado vencia a contagem real). Prova de bloqueio
+ * "integral" era formalmente falsa. Fix: campo auto-declarado NUNCA satisfaz
+ * count_gte; a contagem real de itens de lista é a ÚNICA fonte (heading presente OU
+ * ausente ⇒ contagem 0 ⇒ bloqueia).
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const path = require('node:path');
+const { evalVeto } = require('./pc-run-pod.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 roots = { podRoot: __dirname, runDir: __dirname };
+const A = (text) => evalVeto({ type: 'count_gte', field: 'Value Stack', n: 5 }, text, path.join(__dirname, 'a.md'), roots);
+
+// --- FIXTURE LITERAL do design (linha 135/226): `Value Stack: 99` + ZERO itens → BLOQUEIA ---
+ok(A('## Value Stack\nValue Stack: 99\n').ok === false,
+  'DoD4 `Value Stack: 99` declarado + ZERO itens de lista → veto BLOQUEIA (declaração não compra prova)');
+
+// Campo declarado mesmo ACIMA do limite, sem itens → BLOQUEIA (não há bypass declarativo).
+ok(A('## Value Stack\nValue Stack: 999\ntexto em prosa, nada de itens\n').ok === false,
+  'M-r2-5 `Value Stack: 999` sem itens de lista → BLOQUEIA (contagem real 0 vence o número declarado)');
+
+// Heading AUSENTE ⇒ contagem 0 ⇒ BLOQUEIA.
+ok(A('Nenhum heading aqui, só prosa.\n').ok === false,
+  'DoD4 heading ausente ⇒ contagem 0 ⇒ BLOQUEIA');
+
+// Campo declarado presente MAS itens reais insuficientes (3 < 5) → BLOQUEIA (conta os reais).
+ok(A('## Value Stack\nValue Stack: 99\n- a\n- b\n- c\n').ok === false,
+  'M-r2-5 `Value Stack: 99` + 3 itens reais (< 5) → BLOQUEIA (conta os 3 reais, ignora o 99)');
+
+// 5 itens REAIS de lista → PASSA (a contagem real é a fonte legítima).
+ok(A('## Value Stack\n- a\n- b\n- c\n- d\n- e\n').ok === true,
+  'contagem real de 5 itens de lista → PASSA (fonte legítima, não afrouxada)');
+
+// 5 itens reais MESMO com um número declarado baixo → PASSA (a contagem real vence).
+ok(A('## Value Stack\nValue Stack: 1\n- a\n- b\n- c\n- d\n- e\n').ok === true,
+  'contagem real de 5 vence o `Value Stack: 1` declarado → PASSA');
+
+// Tabela conta como itens reais (semântica SF2.3 preservada) → 5 linhas de dados → PASSA.
+ok(A('## Value Stack\n| Item | Preço |\n|---|---|\n| a | 1 |\n| b | 2 |\n| c | 3 |\n| d | 4 |\n').ok === true,
+  'itens reais em TABELA (cabeçalho + 4 dados = 5) → PASSA (semântica do contador intacta)');
+
+console.log(`\n${passed}/${passed + failures.length} asserções do fix count_gte passaram.`);
+if (failures.length) {
+  console.error('\nSUÍTE count_gte (SF3.1) FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('Suíte count_gte verde (M-r2-5 fechado — bypass declarativo eliminado, contagem real é a única fonte).');
+process.exit(0);