@daniellins/power-claude 0.16.3

package/scripts/forge.test.cjs

@@ -0,0 +1,609 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * forge.test.cjs — harness de auto-verificação da fábrica v0.3 (Story SF1.4).
+ *
+ * Cobre, com pods sintéticos em diretório temporário, os ACs verificáveis sem o
+ * runner/smoke (SF1.2/SF1.3):
+ *   AC1  gate de proporcionalidade classifica SIMPLE vs STANDARD/COMPLEX (2 casos).
+ *   AC2  SIMPLE não recebe aparato completo (sem squad-io/memória).
+ *   AC3  STANDARD/COMPLEX recebe wf-*.yaml + template/etapa + squad-io + memória.
+ *   AC4  wf-*.yaml gerado passa validate-pod-workflow.cjs (exit 0) sem ajuste.
+ *   AC5  persistência disco-first (artefatos existem em disco após a geração).
+ *   AC6  *upgrade-pod preserva os arquivos de agente (não deleta/sobrescreve).
+ *   AC7  *upgrade-pod gera artefatos ausentes proporcionais ao tier.
+ *   AC8  reconciliação bounded remove auto-sequenciamento; excesso ⇒ recomenda *new.
+ *   AC10 scaffold de memória sem lifecycle (vazio/cabeçalho, sem código).
+ *
+ * AC9/AC11 (gate G6 real + smoke 4/4) dependem de SF1.2/SF1.3 — verificados no
+ * gate do @qa quando prontos; aqui, fora de escopo executável.
+ *
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const SCRIPTS = __dirname;
+const { classifyTier } = require('./forge-assess-tier.cjs');
+const { generatePod } = require('./forge-generate.cjs');
+const { upgradePod, reconcileAgent } = require('./forge-upgrade-pod.cjs');
+// SF2.3 — fábrica gera memória OPERANTE + watcher + ingest M1.
+const { getConsolidatedForBrief } = require('./pod-memory.cjs');
+const { auditAdherence } = require('./watcher-audit.cjs');
+const { ingestExternal } = require('./forge-ingest-memory.cjs');
+
+const results = [];
+function check(label, cond, detail) {
+  results.push({ label, ok: Boolean(cond), detail: detail || '' });
+}
+
+function tmpPod(name) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), `forge-${name}-`));
+}
+
+// SF12.4a/ADR-030 Bloco O/AC53b — `generatePod` agora exige `opts.specOrigin`. Todo
+// call site direto deste arquivo é geração FRESCA (equivalente ao CLI de `*new`) ⇒
+// 'authored', que por sua vez exige os 3 campos canônicos (Bloco C) declarados ou
+// recusados. Estes testes não modelam ritmo/entrada/entregável — RECUSAM os 3.
+const CANON_REFUSED = {
+  nao_se_aplica: true,
+  razao: 'fixture de forge.test.cjs não modela ritmo/entrada parametrizada/entregável',
+  respondido_por: 'forge.test.cjs',
+};
+function withCanon(spec) {
+  return {
+    ritmo: CANON_REFUSED, contrato_entrada: CANON_REFUSED, entregavel: CANON_REFUSED,
+    ...spec,
+  };
+}
+const AUTHORED = { specOrigin: 'authored' };
+
+// ---------------------------------------------------------------------------
+// AC1 — gate de proporcionalidade: 2 casos sintéticos, um de cada lado.
+// ---------------------------------------------------------------------------
+const simpleSpec = { pod: 'ac1-simple', agents: ['solo', 'helper'], workflows: 1, handoffs: 1, dna: false, critical: false };
+const complexSpec = { pod: 'ac1-complex', agents: ['a', 'b', 'c'], workflows: 1, handoffs: 2, dna: false, critical: false };
+check('AC1 SIMPLE (≤2 ag/≤1 wf/≤1 handoff/sem dna/não-crítico)', classifyTier(simpleSpec).tier === 'SIMPLE', classifyTier(simpleSpec).tier);
+check('AC1 STANDARD/COMPLEX (3 agentes cruza o limiar)', classifyTier(complexSpec).tier === 'STANDARD/COMPLEX', classifyTier(complexSpec).tier);
+// Cada gatilho oposto isolado força o superior:
+check('AC1 gatilho DNA força STANDARD/COMPLEX', classifyTier({ agents: ['x'], workflows: 1, handoffs: 0, dna: true }).tier === 'STANDARD/COMPLEX');
+check('AC1 gatilho crítico força STANDARD/COMPLEX', classifyTier({ agents: ['x'], workflows: 1, handoffs: 0, critical: true }).tier === 'STANDARD/COMPLEX');
+
+// ---------------------------------------------------------------------------
+// AC2 — SIMPLE não recebe aparato completo.
+// ---------------------------------------------------------------------------
+{
+  const dir = tmpPod('simple');
+  const r = generatePod(withCanon({ pod: 'ac2', agents: ['solo', 'helper'], workflows: 1, handoffs: 1 }), dir, AUTHORED);
+  check('AC2 tier SIMPLE', r.tier === 'SIMPLE', r.tier);
+  check('AC2 sem squad-io.yaml', !fs.existsSync(path.join(dir, 'squad-io.yaml')));
+  check('AC2 sem memory/', !fs.existsSync(path.join(dir, 'memory')));
+  const wfDir = path.join(dir, 'workflows');
+  // SF12.4a/ADR-030 Bloco I: workflows/ agora também pode conter o sidecar `.smoke.json`
+  // sintetizado — o regex mede só o(s) `wf-*.yaml` (o mínimo que a AC2 verifica).
+  const wfCount = fs.existsSync(wfDir) ? fs.readdirSync(wfDir).filter((f) => /^wf-.*\.ya?ml$/.test(f)).length : 0;
+  check('AC2 no máximo 1 workflow mínimo', wfCount <= 1, `${wfCount} workflow(s)`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+// AC3/AC4/AC5/AC10 — pod STANDARD/COMPLEX completo, validado, disco-first.
+// ---------------------------------------------------------------------------
+{
+  const dir = tmpPod('complex');
+  const spec = { pod: 'ac3', agents: ['discovery', 'build', 'red-team'], handoffs: 2 };
+  const r = generatePod(withCanon(spec), dir, AUTHORED);
+  check('AC3 tier STANDARD/COMPLEX', r.tier === 'STANDARD/COMPLEX', r.tier);
+
+  const wfDir = path.join(dir, 'workflows');
+  const wfs = fs.existsSync(wfDir) ? fs.readdirSync(wfDir).filter((f) => /^wf-.*\.ya?ml$/.test(f)) : [];
+  check('AC3 wf-*.yaml gerado', wfs.length === 1, wfs.join(','));
+
+  const tplDir = path.join(dir, 'templates');
+  const tpls = fs.existsSync(tplDir) ? fs.readdirSync(tplDir).filter((f) => f.endsWith('-tmpl.md')) : [];
+  check('AC3 1 template por etapa (3 etapas)', tpls.length === 3, `${tpls.length} templates`);
+  check('AC3 squad-io.yaml com handoffs', fs.existsSync(path.join(dir, 'squad-io.yaml')) &&
+    fs.readFileSync(path.join(dir, 'squad-io.yaml'), 'utf8').includes('handoffs:'));
+
+  // AC5 disco-first: todos os artefatos existem em disco imediatamente após gerar.
+  check('AC5 disco-first (todos os artefatos em disco)', r.written.every((w) => fs.existsSync(w)));
+
+  // AC10 scaffold de memória sem lifecycle.
+  const jsonl = path.join(dir, 'memory', 'learnings.jsonl');
+  const consolidated = path.join(dir, 'memory', 'learnings.consolidated.md');
+  check('AC10 learnings.jsonl vazio', fs.existsSync(jsonl) && fs.readFileSync(jsonl, 'utf8').trim() === '');
+  const consTxt = fs.existsSync(consolidated) ? fs.readFileSync(consolidated, 'utf8') : '';
+  check('AC10 consolidated só cabeçalho (sem heurística)', consTxt.includes('Nenhuma heurística consolidada'));
+  // Sem lógica executável de lifecycle (só prosa de scaffold; menção a "Fase 2" é ok).
+  check('AC10 memória sem código de lifecycle', !/function\s|=>|require\(|module\.exports|for\s*\(|while\s*\(/.test(consTxt));
+
+  // AC4 — validador estático da SF1.1 sobre o wf gerado, exit 0 na primeira.
+  const wfPath = path.join(wfDir, wfs[0]);
+  const val = spawnSync(process.execPath, [path.join(SCRIPTS, 'validate-pod-workflow.cjs'), wfPath], { encoding: 'utf8' });
+  check('AC4 wf gerado passa validate-pod-workflow.cjs (exit 0)', val.status === 0, `exit ${val.status} :: ${(val.stdout || '') + (val.stderr || '')}`.slice(0, 200));
+
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+// AC6/AC7/AC8 — *upgrade-pod sobre pod sintético existente.
+// ---------------------------------------------------------------------------
+{
+  const dir = tmpPod('upgrade');
+  const agentsDir = path.join(dir, 'agents');
+  fs.mkdirSync(agentsDir, { recursive: true });
+  // 3 agentes pré-existentes ⇒ STANDARD/COMPLEX. Um com auto-sequenciamento;
+  // um limpo; um que EXCEDE o bound (decide sozinho entre caminhos).
+  const agentAutoSeq = `---\nname: alpha\n---\n# alpha\nGere o rascunho X.\nDepois disso, chame o agente beta para revisar.\n`;
+  const agentClean = `---\nname: beta\n---\n# beta\nRevise o rascunho e emita o parecer.\n`;
+  const agentOOB = `---\nname: gamma\n---\n# gamma\nVocê decide sozinho entre os 3 caminhos possíveis do processo e orquestra as etapas.\n`;
+  fs.writeFileSync(path.join(agentsDir, 'alpha.md'), agentAutoSeq);
+  fs.writeFileSync(path.join(agentsDir, 'beta.md'), agentClean);
+  fs.writeFileSync(path.join(agentsDir, 'gamma.md'), agentOOB);
+
+  const beforeAlpha = fs.readFileSync(path.join(agentsDir, 'alpha.md'), 'utf8');
+  const beforeGamma = fs.readFileSync(path.join(agentsDir, 'gamma.md'), 'utf8');
+
+  // ADR-005: a ordem do DAG é dado declarado; upgradePod exige pod-spec.json/--spec.
+  fs.writeFileSync(path.join(dir, 'pod-spec.json'), JSON.stringify(
+    { pod: 'upgrade', workflowId: 'up', agents: ['alpha', 'beta', 'gamma'], handoffs: 2 }, null, 2));
+  const r = upgradePod(dir, { apply: true, handoffs: 2 });
+
+  // AC6 — arquivos de agente preservados (existem; gamma intocado por exceder bound).
+  check('AC6 agentes preservados (arquivos ainda existem)',
+    ['alpha.md', 'beta.md', 'gamma.md'].every((f) => fs.existsSync(path.join(agentsDir, f))));
+  check('AC6 gamma (fora do bound) NÃO sobrescrito', fs.readFileSync(path.join(agentsDir, 'gamma.md'), 'utf8') === beforeGamma);
+  const afterBeta = fs.readFileSync(path.join(agentsDir, 'beta.md'), 'utf8');
+  check('AC6 beta (limpo) NÃO alterado', afterBeta === agentClean);
+
+  // AC7 — artefatos ausentes gerados proporcionais ao tier (STANDARD/COMPLEX).
+  check('AC7 tier STANDARD/COMPLEX', r.tier === 'STANDARD/COMPLEX', r.tier);
+  const wfDir = path.join(dir, 'workflows');
+  check('AC7 workflows/wf-*.yaml gerado', fs.existsSync(wfDir) && fs.readdirSync(wfDir).some((f) => /^wf-.*\.ya?ml$/.test(f)));
+  check('AC7 templates gerados', fs.existsSync(path.join(dir, 'templates')));
+  check('AC7 squad-io.yaml gerado (STANDARD/COMPLEX)', fs.existsSync(path.join(dir, 'squad-io.yaml')));
+
+  // AC8 — reconciliação bounded.
+  const afterAlpha = fs.readFileSync(path.join(agentsDir, 'alpha.md'), 'utf8');
+  check('AC8 auto-sequenciamento removido do alpha',
+    beforeAlpha.includes('chame o agente beta') && !afterAlpha.includes('chame o agente beta'));
+  check('AC8 alpha ganhou nota workflow-aware (output escopado)', afterAlpha.includes('[reconciliação v0.3]'));
+  const gammaRec = r.reconciliation.find((x) => x.agent === 'gamma');
+  check('AC8 gamma detectado como excesso de bound ⇒ recomenda *new',
+    gammaRec && gammaRec.status === 'recommend-new' && r.recommendNew.includes('gamma'), gammaRec && gammaRec.status);
+
+  // Reconciliação unitária pura (função):
+  const pure = reconcileAgent('Gere X. Depois disso, invoque o agente Y.');
+  check('AC8 reconcileAgent remove auto-chamada (unit)', pure.status === 'reconciled' && pure.removed.length === 1);
+  const pureOOB = reconcileAgent('Você escolhe o caminho do fluxo conforme o caso.');
+  check('AC8 reconcileAgent detecta out-of-bound (unit)', pureOOB.status === 'recommend-new');
+
+  // [SF6.1 fix round — CONCERNS-1] FALSO-POSITIVO do `[^.]*` guloso: papel-de-domínio
+  // "Orquestra a criação de ... agentes" (agentes = OBJETO DA CRIAÇÃO) NÃO pode flagrar.
+  // Fixture = a description REAL do forge-chief (o gatilho reproduzido pelo QA).
+  const forgeChiefDesc = '---\nname: forge-chief\ndescription: "Orquestra a criação de novos pods, agentes e skills no padrão POWER CLAUDE. Use para: criar um agente para um problema de negócio."\n---\n# forge-chief\nVocê conduz o pipeline que transforma um pedido em artefato. Você orquestra; a extração de DNA é do mind-extractor.\n';
+  const fpRec = reconcileAgent(forgeChiefDesc);
+  check('AC8 FP: papel-de-domínio "orquestra a criação de agentes" NÃO flagra (clean)',
+    fpRec.status === 'clean', fpRec.status);
+
+  // SEM AFROUXAR: orquestração REAL de fluxo/dispatch continua flagrando (objeto direto).
+  check('AC8 pos: "orquestra as etapas do pipeline" → recommend-new',
+    reconcileAgent('Você orquestra as etapas do pipeline.').status === 'recommend-new');
+  check('AC8 pos: "orquestra os agentes" (dispatch) → recommend-new',
+    reconcileAgent('Você orquestra os agentes conforme a fase.').status === 'recommend-new');
+  check('AC8 pos: "orquestra o fluxo" → recommend-new',
+    reconcileAgent('O agente orquestra o fluxo do processo.').status === 'recommend-new');
+  // Domínio inverso: geração/criação como objeto → clean (não é orquestração de fluxo).
+  check('AC8 FP: "orquestra a geração dos agentes" (domínio) NÃO flagra (clean)',
+    reconcileAgent('Ele orquestra a geração dos agentes finais.').status === 'clean');
+
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ===========================================================================
+// ADR-005 — veto ortogonal + ordem do DAG declarada (7 casos que provam o fix).
+// ===========================================================================
+const { parseYaml } = require('./validate-pod-workflow.cjs');
+const { checkTemplateConformance, evalVeto } = require('./pc-run-pod.cjs');
+const VALIDATOR = path.join(SCRIPTS, 'validate-pod-workflow.cjs');
+const SMOKE = path.join(SCRIPTS, 'smoke-pod-workflow.cjs');
+
+// --- Caso 1 — wf gerado por default: sem section_exists; veto = field_matches confianca;
+// template tem linha `confianca:` NÃO-heading.
+{
+  const dir = tmpPod('adr005-c1');
+  generatePod(withCanon({ pod: 'c1', workflowId: 'c1', agents: ['x1', 'x2', 'x3'], handoffs: 2 }), dir, AUTHORED);
+  const wf = fs.readFileSync(path.join(dir, 'workflows', 'wf-c1.yaml'), 'utf8');
+  check('C1 wf default NÃO usa section_exists', !wf.includes('section_exists'));
+  check('C1 wf default usa field_matches confianca', /type:\s*field_matches/.test(wf) && /field:\s*confianca/.test(wf));
+  const tpl = fs.readFileSync(path.join(dir, 'templates', 'x2-tmpl.md'), 'utf8');
+  const confLine = tpl.split(/\r?\n/).find((l) => /^confianca\s*:/.test(l.trim()));
+  check('C1 template tem linha confianca:', Boolean(confLine), confLine || '(ausente)');
+  check('C1 linha confianca NÃO é heading', confLine && !/^#{2,6}\s/.test(confLine.trim()));
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// --- Caso 2 — validador REPROVA section_exists que duplica heading do template; e
+// PASSA section_exists de seção AUSENTE do template.
+{
+  const dir = tmpPod('adr005-c2');
+  fs.mkdirSync(path.join(dir, 'templates'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'workflows'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'templates', 's-tmpl.md'), '# T\n\n## Contexto\nx\n\n## Output\ny\n');
+  const wfHead = 'state_machine:\n  states: [init, running, complete, failed]\n  initial: init\n  terminal: [complete, failed]\nsteps:\n';
+  const stepFor = (assertion) =>
+    `  - id: s\n    agent: a\n    template: templates/s-tmpl.md\n    inputs: [brief]\n    outputs: [o]\n    depends_on: []\n    checkpoint: null\n    veto:\n      assertions:\n        - ${assertion}\n`;
+  // (a) degenerado: section_exists de "## Output" (heading do template) → FALHA.
+  fs.writeFileSync(path.join(dir, 'workflows', 'wf-degen.yaml'), wfHead + stepFor('{ type: section_exists, section: "## Output" }'));
+  const degen = spawnSync(process.execPath, [VALIDATOR, path.join(dir, 'workflows', 'wf-degen.yaml')], { encoding: 'utf8' });
+  check('C2 validador REPROVA veto não-ortogonal (exit != 0)', degen.status !== 0, `exit ${degen.status}`);
+  check('C2 mensagem cita "não-ortogonal"', /não-ortogonal/.test((degen.stdout || '') + (degen.stderr || '')));
+  // (b) section_exists de seção AUSENTE do template ("## Anexo") → PASSA (adiciona info).
+  fs.writeFileSync(path.join(dir, 'workflows', 'wf-ok.yaml'), wfHead + stepFor('{ type: section_exists, section: "## Anexo" }'));
+  const okv = spawnSync(process.execPath, [VALIDATOR, path.join(dir, 'workflows', 'wf-ok.yaml')], { encoding: 'utf8' });
+  check('C2 section_exists de seção AUSENTE do template PASSA (exit 0)', okv.status === 0, `exit ${okv.status}`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// --- Caso 3 — isolamento das classes com o motor real (checkTemplateConformance vs evalVeto):
+// artefato com todas as seções + confianca inválida → falha SÓ veto [3b];
+// artefato sem uma seção + confianca válida → falha SÓ template [3a].
+{
+  const dir = tmpPod('adr005-c3');
+  fs.mkdirSync(path.join(dir, 'templates'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'templates', 'syn-tmpl.md'), '# T\n\n## Contexto\nx\n\n## Output\ny\n\nconfianca: <alta|media|baixa>\n');
+  const ctx = { podRoot: dir };
+  const step = { template: 'templates/syn-tmpl.md' };
+  const vetoAssertion = { type: 'field_matches', field: 'confianca', pattern: '^(alta|media|baixa)$' };
+  // [3b] todas as seções, confianca: talvez → forma OK, veto FALHA.
+  const art3b = '## Contexto\nx\n\n## Output\ny\n\nconfianca: talvez\n';
+  const t3b = checkTemplateConformance(ctx, step, art3b);
+  const v3b = evalVeto(vetoAssertion, art3b, path.join(dir, 'a.md'), ctx);
+  check('C3 [3b] forma OK e veto FALHA (isolado)', t3b.ok === true && v3b.ok === false, `tconf=${t3b.ok} veto=${v3b.ok}`);
+  // [3a] falta "## Output", confianca: alta → forma FALHA, veto OK.
+  const art3a = '## Contexto\nx\n\nconfianca: alta\n';
+  const t3a = checkTemplateConformance(ctx, step, art3a);
+  const v3a = evalVeto(vetoAssertion, art3a, path.join(dir, 'a.md'), ctx);
+  check('C3 [3a] forma FALHA e veto OK (isolado)', t3a.ok === false && v3a.ok === true, `tconf=${t3a.ok} veto=${v3a.ok}`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// --- Caso 4 — upgradePod sem spec → erro ruidoso citando fontes candidatas; NENHUM artefato escrito.
+{
+  const dir = tmpPod('adr005-c4');
+  fs.mkdirSync(path.join(dir, 'agents'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'agents', 'a.md'), '---\nname: a\n---\n# a\nFaz X.\n');
+  fs.writeFileSync(path.join(dir, 'agents', 'b.md'), '---\nname: b\n---\n# b\nFaz Y.\n');
+  fs.writeFileSync(path.join(dir, 'agents', 'c.md'), '---\nname: c\n---\n# c\nFaz Z.\n');
+  fs.writeFileSync(path.join(dir, 'README.md'), '# pod\nFluxo.\n');
+  let threw = null;
+  try { upgradePod(dir, { apply: true }); } catch (e) { threw = e; }
+  check('C4 upgradePod sem spec LANÇA erro', Boolean(threw), threw ? threw.name : 'não lançou');
+  check('C4 erro é fail-loud exit 2', threw && threw.exitCode === 2);
+  check('C4 mensagem cita fontes candidatas (README)', threw && /candidatas/.test(threw.message) && /README\.md/.test(threw.message));
+  check('C4 NENHUM artefato escrito', !fs.existsSync(path.join(dir, 'workflows')) && !fs.existsSync(path.join(dir, 'templates')) && !fs.existsSync(path.join(dir, 'squad-io.yaml')));
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// --- Caso 5 — spec ordenada [zeta, alfa, media] → steps NESSA ordem (readdir não manda);
+// depends_on/inputs encadeados na ordem da spec.
+{
+  const dir = tmpPod('adr005-c5');
+  fs.mkdirSync(path.join(dir, 'agents'), { recursive: true });
+  // Escritos em ordem alfabética; a spec impõe zeta→alfa→media (readdir daria alfa,media,zeta).
+  for (const n of ['alfa', 'media', 'zeta']) fs.writeFileSync(path.join(dir, 'agents', `${n}.md`), `---\nname: ${n}\n---\n# ${n}\nProduz artefato.\n`);
+  fs.writeFileSync(path.join(dir, 'pod-spec.json'), JSON.stringify({ pod: 'c5', workflowId: 'ord', agents: ['zeta', 'alfa', 'media'], handoffs: 2 }, null, 2));
+  upgradePod(dir, { apply: true });
+  const wf = parseYaml(fs.readFileSync(path.join(dir, 'workflows', 'wf-ord.yaml'), 'utf8'));
+  const ids = wf.steps.map((s) => s.id);
+  check('C5 steps na ordem da spec (zeta, alfa, media)', JSON.stringify(ids) === JSON.stringify(['zeta', 'alfa', 'media']), ids.join(','));
+  check('C5 depends_on encadeado na ordem da spec', JSON.stringify(wf.steps[1].depends_on) === '["zeta"]' && JSON.stringify(wf.steps[2].depends_on) === '["alfa"]', JSON.stringify(wf.steps.map((s) => s.depends_on)));
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// --- Caso 6 — agente na spec sem arquivo → erro; agente em disco fora da spec →
+// not-in-workflow no relatório, ausente dos steps, arquivo intocado.
+{
+  const dir = tmpPod('adr005-c6');
+  fs.mkdirSync(path.join(dir, 'agents'), { recursive: true });
+  for (const n of ['a', 'b', 'extra']) fs.writeFileSync(path.join(dir, 'agents', `${n}.md`), `---\nname: ${n}\n---\n# ${n}\nProduz artefato.\n`);
+  const extraBefore = fs.readFileSync(path.join(dir, 'agents', 'extra.md'), 'utf8');
+  // (a) spec com agente inexistente em disco → erro.
+  fs.writeFileSync(path.join(dir, 'pod-spec.json'), JSON.stringify({ pod: 'c6', workflowId: 'w', agents: ['a', 'ghost'], handoffs: 1 }, null, 2));
+  let threw = null;
+  try { upgradePod(dir, {}); } catch (e) { threw = e; }
+  check('C6 agente na spec sem arquivo → erro', Boolean(threw) && /ghost/.test(threw.message));
+  // (b) spec [a, b] com 'extra' em disco fora da spec → not-in-workflow, ausente dos steps, intocado.
+  fs.writeFileSync(path.join(dir, 'pod-spec.json'), JSON.stringify({ pod: 'c6', workflowId: 'w', agents: ['a', 'b'], handoffs: 1 }, null, 2));
+  const r = upgradePod(dir, { apply: true });
+  check('C6 extra reportado not-in-workflow', r.notInWorkflow.includes('extra'), r.notInWorkflow.join(','));
+  const wf = parseYaml(fs.readFileSync(path.join(dir, 'workflows', 'wf-w.yaml'), 'utf8'));
+  check('C6 extra ausente dos steps', !wf.steps.map((s) => s.id).includes('extra'), wf.steps.map((s) => s.id).join(','));
+  check('C6 arquivo de extra intocado', fs.readFileSync(path.join(dir, 'agents', 'extra.md'), 'utf8') === extraBefore);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// --- Caso 7 (equivalente sintético do hormozi) — pod gerado via spec com veto de domínio
+// (count_gte) + confianca: validador exit 0 (incl. ortogonalidade) e smoke 4/4 exit 0,
+// provando a 3b agora construível. O hormozi REAL é regenerado/provado no second-brain.
+{
+  const dir = tmpPod('adr005-c7');
+  fs.mkdirSync(path.join(dir, 'agents'), { recursive: true });
+  for (const n of ['builder', 'checker', 'writer']) fs.writeFileSync(path.join(dir, 'agents', `${n}.md`), `---\nname: ${n}\n---\n# ${n}\nProduz o artefato da etapa.\n`);
+  const spec = {
+    pod: 'c7', workflowId: 'demo', handoffs: 2,
+    agents: [
+      { name: 'builder', output: 'pkg', sections: ['## Contexto', '## Value Stack', '## Output'], veto: [{ type: 'count_gte', field: 'Value Stack', n: 5 }, { type: 'field_matches', field: 'confianca', pattern: '^(alta|media|baixa)$' }] },
+      { name: 'checker', output: 'review' },
+      { name: 'writer', output: 'copy' },
+    ],
+  };
+  fs.writeFileSync(path.join(dir, 'pod-spec.json'), JSON.stringify(spec, null, 2));
+  upgradePod(dir, { apply: true });
+  const wfPath = path.join(dir, 'workflows', 'wf-demo.yaml');
+  const val = spawnSync(process.execPath, [VALIDATOR, wfPath], { encoding: 'utf8' });
+  check('C7 validador exit 0 (com ortogonalidade)', val.status === 0, `exit ${val.status} :: ${((val.stdout || '') + (val.stderr || '')).slice(0, 160)}`);
+  // Sidecar: target_step = checker (default confianca). 3a = falta seção + confianca válida;
+  // 3b = todas as seções + confianca inválida.
+  const sidecar = {
+    target_step: 'checker',
+    artifacts: {
+      builder: '## Contexto\nc\n\n## Value Stack\n- 1\n- 2\n- 3\n- 4\n- 5\n\n## Output\no\n\nconfianca: alta\n',
+      checker: '## Contexto\nc\n\n## Output\no\n\nconfianca: alta\n',
+      writer: '## Contexto\nc\n\n## Output\no\n\nconfianca: media\n',
+    },
+    template_violation: '## Output\no\n\nconfianca: alta\n',
+    veto_violation: '## Contexto\nc\n\n## Output\no\n\nconfianca: talvez\n',
+  };
+  fs.writeFileSync(path.join(dir, 'workflows', 'wf-demo.smoke.json'), JSON.stringify(sidecar, null, 2));
+  const sm = spawnSync(process.execPath, [SMOKE, wfPath], { encoding: 'utf8' });
+  check('C7 smoke 4/4 exit 0 (3b agora construível)', sm.status === 0, `exit ${sm.status} :: ${((sm.stdout || '') + (sm.stderr || '')).split('\n').filter((l) => /Prova|provas/.test(l)).join(' | ')}`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ===========================================================================
+// SF2.3 — memória OPERANTE proporcional ao tier, watcher de aderência, ingest M1.
+// ===========================================================================
+
+// AC1 — STANDARD/COMPLEX: memória OPERANTE (instalada pelo motor real, não morta).
+{
+  const dir = tmpPod('sf23-operante');
+  const spec = { pod: 'op', agents: ['a', 'b', 'c'], handoffs: 2 };
+  generatePod(withCanon(spec), dir, AUTHORED);
+  const consTxt = fs.readFileSync(path.join(dir, 'memory', 'learnings.consolidated.md'), 'utf8');
+  check('SF2.3 AC1 consolidado no formato do MOTOR (pod-memory.cjs), não scaffold morto',
+    consTxt.includes('Curado por pod-memory.cjs'), consTxt.split('\n')[2] || '');
+  check('SF2.3 AC1 getConsolidatedForBrief lê o path canônico (pod cabeado ao runner)',
+    getConsolidatedForBrief('op', { podDir: dir }).length > 0);
+  check('SF2.3 AC1 marcador de cabeamento (memory/README.md) presente',
+    fs.existsSync(path.join(dir, 'memory', 'README.md')));
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// AC2 — SIMPLE: memória OPCIONAL (default não gera; flag gera; sem virar obrigatória).
+{
+  const spec = { pod: 'simp', agents: ['solo', 'helper'], workflows: 1, handoffs: 1 };
+  const dirOff = tmpPod('sf23-simple-off');
+  generatePod(withCanon(spec), dirOff, AUTHORED);
+  check('SF2.3 AC2 SIMPLE sem flag → sem memory/', !fs.existsSync(path.join(dirOff, 'memory')));
+  fs.rmSync(dirOff, { recursive: true, force: true });
+
+  const dirOn = tmpPod('sf23-simple-on');
+  const r = generatePod(withCanon(spec), dirOn, { withMemory: true, specOrigin: 'authored' });
+  check('SF2.3 AC2 SIMPLE continua SIMPLE (flag não muda o tier)', r.tier === 'SIMPLE', r.tier);
+  check('SF2.3 AC2 SIMPLE --with-memory → memória gerada (opcional, sob pedido)',
+    fs.existsSync(path.join(dirOn, 'memory', 'learnings.consolidated.md')));
+  check('SF2.3 AC2 caminho spec.memoryOpt também habilita',
+    (() => { const d = tmpPod('sf23-simple-opt'); generatePod(withCanon({ ...spec, memoryOpt: true }), d, AUTHORED);
+      const ok = fs.existsSync(path.join(d, 'memory')); fs.rmSync(d, { recursive: true, force: true }); return ok; })());
+  fs.rmSync(dirOn, { recursive: true, force: true });
+}
+
+// AC6 — débito #1: template gerado documenta a forma contável do count_gte.
+{
+  const dir = tmpPod('sf23-countgte');
+  const spec = { pod: 'cg', handoffs: 2, dna: true, agents: [
+    { name: 'builder', output: 'pkg', sections: ['## Contexto', '## Value Stack', '## Output'],
+      veto: [{ type: 'count_gte', field: 'Value Stack', n: 5 }, { type: 'field_matches', field: 'confianca', pattern: '^(alta|media|baixa)$' }] },
+    { name: 'checker', output: 'rev' },
+  ] };
+  generatePod(withCanon(spec), dir, AUTHORED);
+  const tpl = fs.readFileSync(path.join(dir, 'templates', 'builder-tmpl.md'), 'utf8');
+  check('SF2.3 AC6 nota count_gte presente junto à seção-alvo', /count_gte "Value Stack"/.test(tpl));
+  check('SF2.3 AC6 nota prescreve as 3 formas + prosa não conta',
+    /bullets/.test(tpl) && /numeradas/.test(tpl) && /tabela/.test(tpl) && /[Pp]rosa/.test(tpl));
+  check('SF2.3 AC6 seção SEM count_gte não recebe a nota (só a seção contável)',
+    !/## Contexto\n<!-- count_gte/.test(tpl));
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// AC3 — watcher-rubric audita ADERÊNCIA real (não resumo), 3 status determinísticos.
+{
+  check('SF2.3 AC3 heuristic-watcher-rubric.yaml existe no pod squad-forge',
+    fs.existsSync(path.resolve(SCRIPTS, '..', 'template', 'pods', 'squad-forge', 'config', 'heuristic-watcher-rubric.yaml')));
+  const cons = '# Memória\n- **[oferta fraca]** ancore o preço no valor percebido do cliente\n- **[copy generica]** use provas concretas e numeros especificos\n';
+  const applied = auditAdherence(cons, '## Oferta\nreescrevi a oferta fraca: ancore o preço no valor percebido do cliente, não no custo\n## Copy\nadicionei provas concretas e numeros especificos de resultado');
+  check('SF2.3 AC3 heurística com padrão materializado → applied', applied.appliedCount === 2 && applied.notAppliedCount === 0, JSON.stringify(applied.results.map((r) => r.status)));
+  // ANTI-RESUMO: artefato que só MENCIONA o consolidado sem materializar → not-applied.
+  const mention = auditAdherence(cons, '## Oferta\nrevisei a oferta e consultei o learnings.consolidated.md, segui as heurísticas');
+  const ofertaRes = mention.results.find((r) => r.trigger === 'oferta fraca');
+  check('SF2.3 AC3 ANTI-RESUMO: mencionar o consolidado NÃO conta como aplicar → not-applied',
+    ofertaRes.status === 'not-applied', ofertaRes.status);
+  // not-applicable: contexto ausente não vira falha.
+  const na = auditAdherence(cons, '## Introdução\ntexto sobre um assunto totalmente distinto e sem relação');
+  check('SF2.3 AC3 contexto ausente → not-applicable (não é falha do agente)',
+    na.notApplicableCount === 2 && na.notAppliedCount === 0, JSON.stringify(na));
+  check('SF2.3 AC3 aderência = aplicadas/aplicáveis (não conta as não-aplicáveis)', applied.adherenceScore === 1);
+}
+
+// AC4 — *ingest-memory opt-in com dedup M1 (hash+fonte; colisão → merge, não duplica).
+{
+  const dir = tmpPod('sf23-ingest');
+  const e = { trigger: 'oferta fraca', recommendation: 'adicione garantia de risco reverso', source: '$100M Offers p.120', content: 'garantia reverte o risco' };
+  const r1 = ingestExternal(dir, e);
+  const r2 = ingestExternal(dir, e);                       // mesmo conteúdo + mesma fonte
+  const r3 = ingestExternal(dir, { ...e, source: 'outra fonte' }); // fonte diferente
+  check('SF2.3 AC4 1a ingestão → appended', r1.action === 'appended');
+  check('SF2.3 AC4 colisão hash+fonte → MERGE (incrementa ocorrência)', r2.action === 'merged' && r2.occurrences === 2);
+  check('SF2.3 AC4 fonte diferente com mesmo conteúdo → entrada distinta (proveniência)', r3.action === 'appended');
+  const raw = fs.readFileSync(path.join(dir, 'memory', 'learnings.jsonl'), 'utf8').trim().split('\n');
+  check('SF2.3 AC4 merge NÃO duplica linha (2 entradas: 1 merge x2 + 1 nova)', raw.length === 2, `${raw.length} linhas`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+// SF3.4 finding F2 — buildWorkflowYaml PROPAGA checkpoint por-etapa da spec (mid ou
+// final), não só o `final` genérico. Regressão: mid-checkpoint autorado → wf sem ele.
+// ---------------------------------------------------------------------------
+{
+  const { stepsFromSpec, buildWorkflowYaml } = require('./forge-generate.cjs');
+  const { computeFeatureSet } = require('./migration-manifest.cjs');
+  const { parseYaml } = require('./validate-pod-workflow.cjs');
+  const spec = {
+    pod: 'cp', agents: [
+      { name: 'intake', step: 'a', output: 'o1' },
+      { name: 'arquiteto', step: 'mm-arquitetura', output: 'o2', checkpoint: { blocking: true, criteria: 'CP_PHASE_2 arquitetura de monetização aprovada' } },
+      { name: 'fechamento', step: 'c', output: 'o3' },
+    ],
+  };
+  const wf = buildWorkflowYaml('cp', stepsFromSpec(spec));
+  const lines = wf.split('\n');
+  const cpOf = (id) => {
+    const idx = lines.findIndex((l) => l.trim() === `- id: ${id}`);
+    return idx < 0 ? '' : (lines.slice(idx).find((l) => l.trim().startsWith('checkpoint:')) || '');
+  };
+  const cpMid = cpOf('mm-arquitetura');
+  check('SF3.4 F2 checkpoint mid-DAG da spec é PROPAGADO ao wf (não dropado)', /blocking: true/.test(cpMid) && /CP_PHASE_2/.test(cpMid), cpMid);
+  // A REGRESSÃO que o gate pegou: mid-checkpoint declarado NUNCA pode sair null.
+  check('SF3.4 F2 REGRESSÃO — etapa mid com checkpoint declarado NÃO sai null', !/checkpoint:\s*null/.test(cpMid), cpMid);
+  check('SF3.4 F2 etapa sem checkpoint declarado mantém default (null em não-final)', /checkpoint:\s*null/.test(cpOf('a')), cpOf('a'));
+  check('SF3.4 F2 última etapa sem declaração mantém default final bloqueante', /blocking: true/.test(cpOf('c')) && /revisão da etapa final/.test(cpOf('c')), cpOf('c'));
+  const feat = computeFeatureSet(parseYaml(wf));
+  check('SF3.4 F2 computeFeatureSet enxerga checkpoint:mid (gatilho do feature-diff não mais mascarado)', feat.checkpoint_positions.includes('mid'), JSON.stringify(feat.checkpoint_positions));
+}
+
+// ===========================================================================
+// SF6.2 / ADR-004 adendo 2026-07-25 — forma STANDARD-interface + dry-run zero-write.
+// Diretiva de fix (3 fixtures): (a) dev-ia real → STANDARD sem wf/squad-io COM memória
+// e templates; (b) interface:true + handoffs:1 → recusa exit 2; (c) dry-run byte-idêntico.
+// ===========================================================================
+const { InterfaceContractError } = require('./forge-generate.cjs');
+
+// Snapshot recursivo (relpath → conteúdo) de uma árvore, para provar byte-identidade.
+function snapshotTree(root) {
+  const out = {};
+  const walk = (dir) => {
+    for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+      const abs = path.join(dir, ent.name);
+      if (ent.isDirectory()) walk(abs);
+      else out[path.relative(root, abs)] = fs.readFileSync(abs, 'utf8');
+    }
+  };
+  if (fs.existsSync(root)) walk(root);
+  return out;
+}
+
+// --- Fixture (a) — dev-ia REAL: 2 agentes, critical:true, interface:true →
+// tier STANDARD/COMPLEX, SEM wf/squad-io, COM memória e templates. Via generatePod
+// (unit) e via upgradePod (integração, com agents/ + pod-spec.json em disco).
+{
+  // (a.1) generatePod unit
+  const dir = tmpPod('sf62-iface-gen');
+  const spec = { pod: 'dev-ia', agents: ['db-architect', 'ux-architect'], handoffs: 0, critical: true, interface: true };
+  const r = generatePod(withCanon(spec), dir, AUTHORED);
+  check('SF6.2 (a) tier STANDARD/COMPLEX (critical, interface não rebaixa)', r.tier === 'STANDARD/COMPLEX', r.tier);
+  check('SF6.2 (a) SEM workflows/ fabricado', !fs.existsSync(path.join(dir, 'workflows')));
+  check('SF6.2 (a) SEM squad-io.yaml fabricado', !fs.existsSync(path.join(dir, 'squad-io.yaml')));
+  check('SF6.2 (a) skipped combinado wf/squad-io registrado', r.skipped.some((s) => /pod-interface: zero handoff interno/.test(s)), r.skipped.join(' | '));
+  check('SF6.2 (a) COM memória operante (é por POD, agnóstica de workflow)', fs.existsSync(path.join(dir, 'memory', 'learnings.consolidated.md')));
+  const tpls = fs.existsSync(path.join(dir, 'templates')) ? fs.readdirSync(path.join(dir, 'templates')).filter((f) => f.endsWith('-tmpl.md')) : [];
+  check('SF6.2 (a) COM 1 template por especialista (2)', tpls.length === 2, `${tpls.length} templates`);
+  fs.rmSync(dir, { recursive: true, force: true });
+
+  // (a.2) upgradePod integração — pod real em disco.
+  const pd = tmpPod('sf62-iface-up');
+  fs.mkdirSync(path.join(pd, 'agents'), { recursive: true });
+  fs.writeFileSync(path.join(pd, 'agents', 'db-architect.md'), '---\nname: db-architect\n---\n# db-architect\nModela schema, migrations e RLS.\n');
+  fs.writeFileSync(path.join(pd, 'agents', 'ux-architect.md'), '---\nname: ux-architect\n---\n# ux-architect\nDesenha fluxo e revisa UX.\n');
+  fs.writeFileSync(path.join(pd, 'pod-spec.json'), JSON.stringify(
+    { pod: 'dev-ia', agents: ['db-architect', 'ux-architect'], handoffs: 0, critical: true, interface: true }, null, 2));
+  const ru = upgradePod(pd, { apply: true });
+  check('SF6.2 (a) upgradePod tier STANDARD/COMPLEX', ru.tier === 'STANDARD/COMPLEX', ru.tier);
+  check('SF6.2 (a) upgradePod NÃO cria workflows/', !fs.existsSync(path.join(pd, 'workflows')));
+  check('SF6.2 (a) upgradePod NÃO cria squad-io.yaml', !fs.existsSync(path.join(pd, 'squad-io.yaml')));
+  check('SF6.2 (a) upgradePod cria memory/ + templates/', fs.existsSync(path.join(pd, 'memory')) && fs.existsSync(path.join(pd, 'templates')));
+  fs.rmSync(pd, { recursive: true, force: true });
+}
+
+// --- Fixture (b) — interface:true com handoffs:1 → InterfaceContractError exit 2.
+// Fabricar processo onde há acoplamento real é justamente o que a forma proíbe.
+{
+  let threw = null;
+  try { generatePod({ pod: 'bad', agents: ['a', 'b'], handoffs: 1, interface: true }, tmpPod('sf62-bad'), AUTHORED); }
+  catch (e) { threw = e; }
+  check('SF6.2 (b) generatePod interface+handoffs:1 LANÇA', Boolean(threw), threw ? threw.name : 'não lançou');
+  check('SF6.2 (b) é InterfaceContractError exit 2', threw instanceof InterfaceContractError && threw.exitCode === 2, threw && `${threw.name}/${threw.exitCode}`);
+  // Via upgradePod (spec em disco) — o gate vale no caminho de retrofit também.
+  const pd = tmpPod('sf62-bad-up');
+  fs.mkdirSync(path.join(pd, 'agents'), { recursive: true });
+  fs.writeFileSync(path.join(pd, 'agents', 'a.md'), '---\nname: a\n---\n# a\nX.\n');
+  fs.writeFileSync(path.join(pd, 'agents', 'b.md'), '---\nname: b\n---\n# b\nY.\n');
+  fs.writeFileSync(path.join(pd, 'pod-spec.json'), JSON.stringify({ pod: 'bad', agents: ['a', 'b'], handoffs: 1, interface: true }, null, 2));
+  let threw2 = null;
+  try { upgradePod(pd, { apply: true }); } catch (e) { threw2 = e; }
+  check('SF6.2 (b) upgradePod interface+handoffs:1 recusa exit 2', threw2 && threw2.exitCode === 2, threw2 && `${threw2.name}/${threw2.exitCode}`);
+  fs.rmSync(pd, { recursive: true, force: true });
+}
+
+// --- Fixture (c) — dry-run do upgradePod = ZERO escrita (árvore byte-idêntica antes/depois).
+// Prova o bug real do ADR-004 §2 (generatePod chamado incondicionalmente escrevia até em dry-run).
+// Dois casos: pod-interface e pod STANDARD comum (o fix é geral, não só do caminho interface).
+for (const kind of ['interface', 'standard']) {
+  const pd = tmpPod(`sf62-dryrun-${kind}`);
+  fs.mkdirSync(path.join(pd, 'agents'), { recursive: true });
+  if (kind === 'interface') {
+    fs.writeFileSync(path.join(pd, 'agents', 'db-architect.md'), '---\nname: db-architect\n---\n# db-architect\nSchema/RLS.\n');
+    fs.writeFileSync(path.join(pd, 'agents', 'ux-architect.md'), '---\nname: ux-architect\n---\n# ux-architect\nUX.\n');
+    fs.writeFileSync(path.join(pd, 'pod-spec.json'), JSON.stringify({ pod: 'dev-ia', agents: ['db-architect', 'ux-architect'], handoffs: 0, critical: true, interface: true }, null, 2));
+  } else {
+    // pod STANDARD comum COM auto-sequenciamento — a reconciliação TAMBÉM não pode escrever em dry-run.
+    fs.writeFileSync(path.join(pd, 'agents', 'a.md'), '---\nname: a\n---\n# a\nGere X. Depois disso, chame o agente b.\n');
+    fs.writeFileSync(path.join(pd, 'agents', 'b.md'), '---\nname: b\n---\n# b\nRevise.\n');
+    fs.writeFileSync(path.join(pd, 'agents', 'c.md'), '---\nname: c\n---\n# c\nFecha.\n');
+    fs.writeFileSync(path.join(pd, 'pod-spec.json'), JSON.stringify({ pod: 'std', workflowId: 'w', agents: ['a', 'b', 'c'], handoffs: 2 }, null, 2));
+  }
+  const before = snapshotTree(pd);
+  const rd = upgradePod(pd, { apply: false }); // DRY-RUN
+  const after = snapshotTree(pd);
+  check(`SF6.2 (c/${kind}) dry-run árvore byte-idêntica (zero escrita)`,
+    JSON.stringify(before) === JSON.stringify(after),
+    `antes=${Object.keys(before).length} arq, depois=${Object.keys(after).length} arq`);
+  check(`SF6.2 (c/${kind}) dry-run ainda reporta o PLANO (generated[] preenchido)`,
+    Array.isArray(rd.generated) && rd.generated.length > 0, `${rd.generated.length} no plano`);
+  // E o --apply DEPOIS realmente escreve (não quebramos o caminho de escrita).
+  const ra = upgradePod(pd, { apply: true });
+  const applied = snapshotTree(pd);
+  check(`SF6.2 (c/${kind}) --apply após dry-run efetivamente escreve`,
+    Object.keys(applied).length > Object.keys(before).length,
+    `antes=${Object.keys(before).length} → apply=${Object.keys(applied).length}`);
+  void ra;
+  fs.rmSync(pd, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+// Relatório.
+// ---------------------------------------------------------------------------
+console.log('POWER CLAUDE — forge v0.3 (harness SF1.4 + ADR-005 + SF6.2 interface)\n');
+const failures = results.filter((r) => !r.ok);
+for (const r of results) {
+  console.log(`[${r.ok ? 'OK   ' : 'FALHA'}] ${r.label}${r.ok ? '' : ` — ${r.detail}`}`);
+}
+console.log(`\n${results.length - failures.length}/${results.length} verificações passaram.`);
+if (failures.length > 0) {
+  console.error('\nHARNESS FALHOU.');
+  process.exit(1);
+}
+process.exit(0);