@daniellins/power-claude 0.16.3

package/scripts/forge-harden-learning.test.cjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * forge-harden-learning.test.cjs — fixture PONTA-A-PONTA do caso motivador (SF7.6/AC6):
+ * a heurística "evitar travessões" de um pod-canário, consolidada na memória, é promovida
+ * a veto físico `command_check` (lexical-check.cjs, SF7.2) — e o teste PROVA:
+ *
+ *   POSITIVA: antes do hardening, um artefato COM travessão passa o workflow inteiro
+ *             (smoke happy-path verde) — a heurística em prosa NÃO impede (o caso R5).
+ *   NEGATIVA: depois do hardening, o MESMO artefato bloqueia na etapa-alvo (smoke falha).
+ *
+ * Mais: aprovação obrigatória (--approved-by, exit 2 sem ela), spec/wf com diff confinado
+ * à etapa-alvo, marcação append-only type:"hardening" (log intacto), 🔒 no consolidado e
+ * demoção do top-N ativo, idempotência (re-promover recusa).
+ */
+
+const assert = require('node:assert');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const podMemory = require('./pod-memory.cjs');
+const { generatePod } = require('./forge-generate.cjs');
+const { splitWfBlocks } = require('./forge-harden-learning.cjs');
+
+const REPO = path.resolve(__dirname, '..');
+const HARDEN = path.join(REPO, 'scripts', 'forge-harden-learning.cjs');
+const SMOKE = path.join(REPO, 'scripts', 'smoke-pod-workflow.cjs');
+const VALIDATE = path.join(REPO, 'scripts', 'validate-pod-workflow.cjs');
+
+let passed = 0;
+function ok(label, cond) {
+  if (!cond) {
+    console.error(`[FALHOU] ${label}`);
+    process.exit(1);
+  }
+  passed += 1;
+  console.log(`[OK   ] ${label}`);
+}
+
+function sh(args) {
+  return spawnSync(process.execPath, args, { encoding: 'utf8', cwd: REPO });
+}
+
+// ── setup: pod-canário gerado pela fábrica real ───────────────────────────────
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'harden-fixture-'));
+const podDir = path.join(tmp, 'canario-hard');
+const spec = {
+  pod: 'canario-hard',
+  workflowId: 'canario-hard',
+  handoffs: 1,
+  memoryOpt: true,
+  agents: [
+    { name: 'redator', step: 'redacao', output: 'texto', sections: ['## Texto'] },
+    { name: 'revisor', step: 'revisao', output: 'parecer', sections: ['## Parecer'] },
+  ],
+};
+fs.mkdirSync(podDir, { recursive: true });
+fs.writeFileSync(path.join(podDir, 'pod-spec.json'), `${JSON.stringify(spec, null, 2)}\n`);
+// SF12.4a/ADR-030 Bloco O — bootstrap do fixture (pod pré-existente antes do hardening);
+// 'derived' também preserva o comportamento pré-SF12.4a de NÃO emitir agents/*.md aqui
+// (o teste os autora logo abaixo, simulando o forge-chief).
+generatePod(spec, podDir, { withMemory: true, specOrigin: 'derived' });
+
+const wfPath = path.join(podDir, 'workflows', 'wf-canario-hard.yaml');
+ok('setup: wf gerado pela fábrica', fs.existsSync(wfPath));
+
+// [SF11.2/DF-SF11.2-4] `forge-generate.cjs` escreve workflows/templates/squad-io/memory, mas
+// NÃO escreve `agents/*.md` (autorados depois, pela skill do forge). Desde a SF11.2 o runner
+// resolve e VERIFICA `agents/<step.agent>.md` antes de despachar — pod sem o agente em disco
+// é `blocked: leitura_obrigatoria_ausente` e o smoke não roda. O mesmo já valia para o export
+// (`pod-export-compile.cjs:214` falha pela mesma causa). Aqui o fixture completa o pod.
+fs.mkdirSync(path.join(podDir, 'agents'), { recursive: true });
+for (const a of ['redator', 'revisor']) {
+  fs.writeFileSync(path.join(podDir, 'agents', `${a}.md`),
+    `---\nname: ${a}\ndescription: "Agente de fixture do pod-canário desta suíte."\nmodel: sonnet\nbudget_tokens: 200\n---\n\n# ${a}\n\nFixture de teste.\n`);
+}
+
+// sidecar canônico (baseline LIMPO — sem travessão) usado pelo próprio harden
+const cleanScenario = {
+  target_step: 'redacao',
+  artifacts: {
+    redacao: '## Texto\nTexto limpo, com virgulas e dois-pontos no lugar do tell de IA.\n\nconfianca: alta\n',
+    revisao: '## Parecer\nParecer conforme sobre o texto.\n\nconfianca: alta\n',
+  },
+  template_violation: 'confianca: alta\n',
+  veto_violation: '## Texto\nTexto presente mas campo de maquina fora do dominio.\n\nconfianca: incerta\n',
+};
+const cleanPath = wfPath.replace(/\.yaml$/, '.smoke.json');
+fs.writeFileSync(cleanPath, JSON.stringify(cleanScenario, null, 2));
+
+// cenário do CASO MOTIVADOR: artefato da etapa-alvo COM travessão (em-dash U+2014)
+const dashScenario = {
+  ...cleanScenario,
+  artifacts: {
+    ...cleanScenario.artifacts,
+    redacao: '## Texto\nTexto que regride — com travessão de IA — apesar da heurística.\n\nconfianca: alta\n',
+  },
+};
+const dashPath = path.join(podDir, 'workflows', 'dash.smoke.json');
+fs.writeFileSync(dashPath, JSON.stringify(dashScenario, null, 2));
+
+// ── memória: a heurística do caso real, consolidada no top-N ─────────────────
+const e1 = podMemory.append('canario-hard', {
+  trigger: 'travessoes no texto final',
+  recommendation: 'nunca usar travessao (em/en-dash); prefira virgula ou dois-pontos',
+  source_run_id: 'r1',
+}, { podDir });
+podMemory.append('canario-hard', {
+  trigger: 'travessoes no texto final',
+  recommendation: 'nunca usar travessao (em/en-dash); prefira virgula ou dois-pontos',
+  source_run_id: 'r4',
+}, { podDir });
+podMemory.consolidate('canario-hard', { podDir });
+const memPaths = podMemory.memoryPaths('canario-hard', { podDir });
+const consolidatedBefore = fs.readFileSync(memPaths.consolidated, 'utf8');
+ok('memória: heurística no top-N do consolidado',
+  consolidatedBefore.includes('**[travessoes no texto final]**') && !consolidatedBefore.includes('🔒'));
+
+// ── PROVA POSITIVA (pré-hardening): artefato com travessão PASSA ─────────────
+const smokeDashBefore = sh([SMOKE, wfPath, '--scenario', dashPath]);
+ok('caso R5 reproduzido: smoke 4/4 verde COM travessão no artefato (heurística em prosa não bloqueia)',
+  smokeDashBefore.status === 0);
+
+// ── aprovação obrigatória: sem --approved-by ⇒ exit 2, nada aplicado ─────────
+const specBytes = fs.readFileSync(path.join(podDir, 'pod-spec.json'), 'utf8');
+const wfBytes = fs.readFileSync(wfPath, 'utf8');
+const assertionJson = JSON.stringify({ type: 'command_check', command: 'lexical-check.cjs', args: ['--max', '0'] });
+const noApproval = sh([HARDEN, podDir, '--learning', e1.entry.id, '--step', 'redacao', '--assertion', assertionJson]);
+ok('sem --approved-by: recusa exit 2', noApproval.status === 2);
+ok('sem --approved-by: spec e wf INTOCADOS',
+  fs.readFileSync(path.join(podDir, 'pod-spec.json'), 'utf8') === specBytes &&
+  fs.readFileSync(wfPath, 'utf8') === wfBytes);
+
+// ── QA CONCERNS-2: ROLLBACK automático pós-regen (fixture dedicada) ──────────
+// Asserção de FORMA válida (passa checkAssertionShape e o estático) que o artefato
+// conforme NÃO satisfaz ⇒ o smoke PÓS-regen reprova (prova 2 bloqueia) ⇒ o motor
+// restaura spec/wf/templates BYTE-IDÊNTICOS, sai exit 2 e NÃO marca a memória.
+// Kill-test coberto: sabotar a restauração (ou o pós-gate) torna isto VERMELHO.
+const tmplPaths = ['redacao', 'revisao'].map((s) => path.join(podDir, 'templates', `${s}-tmpl.md`));
+const tmplBytesBefore = tmplPaths.map((p) => fs.readFileSync(p, 'utf8'));
+const rawBytesBeforeRollback = fs.readFileSync(memPaths.raw, 'utf8');
+const badAssertion = JSON.stringify({ type: 'field_matches', field: 'campo_inexistente', pattern: '^presente$' });
+const rb = sh([HARDEN, podDir, '--learning', e1.entry.id, '--step', 'revisao',
+  '--assertion', badAssertion, '--approved-by', 'daniel']);
+ok('rollback: pós-smoke vermelho ⇒ comando sai ≠0 (exit 2)', rb.status === 2);
+ok('rollback: recusa nomeia pós-gate vermelho + ROLLBACK aplicado',
+  /pós-gate vermelho/.test(rb.stderr) && /ROLLBACK aplicado/.test(rb.stderr));
+ok('rollback: pod-spec.json BYTE-IDÊNTICO ao baseline',
+  fs.readFileSync(path.join(podDir, 'pod-spec.json'), 'utf8') === specBytes);
+ok('rollback: wf BYTE-IDÊNTICO ao baseline', fs.readFileSync(wfPath, 'utf8') === wfBytes);
+ok('rollback: templates BYTE-IDÊNTICOS ao baseline',
+  tmplPaths.every((p, i) => fs.readFileSync(p, 'utf8') === tmplBytesBefore[i]));
+ok('rollback: memória INTOCADA (log cru byte-idêntico, sem registro hardening, sem 🔒)',
+  fs.readFileSync(memPaths.raw, 'utf8') === rawBytesBeforeRollback &&
+  !fs.readFileSync(memPaths.raw, 'utf8').includes('"type":"hardening"') &&
+  !fs.readFileSync(memPaths.consolidated, 'utf8').includes('🔒'));
+
+// ── promoção aprovada ────────────────────────────────────────────────────────
+const rawLinesBefore = fs.readFileSync(memPaths.raw, 'utf8').split('\n').filter(Boolean);
+const promote = sh([HARDEN, podDir, '--learning', e1.entry.id, '--step', 'redacao',
+  '--assertion', assertionJson, '--approved-by', 'daniel']);
+ok(`promoção aprovada: exit 0 (${promote.status})${promote.status !== 0 ? `\n${promote.stdout}${promote.stderr}` : ''}`,
+  promote.status === 0);
+
+// spec: asserção aplicada SÓ na etapa-alvo, com rastreabilidade
+const specAfter = JSON.parse(fs.readFileSync(path.join(podDir, 'pod-spec.json'), 'utf8'));
+const vetoRedacao = specAfter.agents[0].veto || [];
+ok('spec: command_check aplicado à etapa-alvo com _sources de hardening',
+  vetoRedacao.some((a) => a.type === 'command_check' && a.command === 'lexical-check.cjs' &&
+    String(a._sources || '').includes('promovido a enforcement por daniel')) &&
+  !(specAfter.agents[1].veto || []).some((a) => a.type === 'command_check'));
+
+// wf: diff confinado à etapa-alvo
+const wfAfter = fs.readFileSync(wfPath, 'utf8');
+const b = splitWfBlocks(wfBytes);
+const a = splitWfBlocks(wfAfter);
+ok('wf: etapa-alvo ganhou o command_check',
+  a.blocks.get('redacao').join('\n').includes('command_check') &&
+  a.blocks.get('redacao').join('\n').includes('lexical-check.cjs'));
+ok('wf: etapa NÃO-alvo byte-idêntica (preservação)',
+  b.blocks.get('revisao').join('\n') === a.blocks.get('revisao').join('\n') &&
+  b.header === a.header);
+
+// estático continua verde sobre o wf regenerado
+ok('validate-pod-workflow exit 0 no wf regenerado', sh([VALIDATE, wfPath]).status === 0);
+
+// smoke 4/4 continua verde no cenário LIMPO (preservação funcional)
+ok('smoke 4/4 verde pós-hardening no cenário limpo', sh([SMOKE, wfPath, '--scenario', cleanPath]).status === 0);
+
+// ── PROVA NEGATIVA (pós-hardening): o MESMO artefato com travessão BLOQUEIA ──
+const smokeDashAfter = sh([SMOKE, wfPath, '--scenario', dashPath]);
+ok('enforcement real: smoke com travessão agora FALHA (bloqueio físico na etapa-alvo)',
+  smokeDashAfter.status !== 0);
+
+// ── memória: append-only + 🔒 + demoção do top-N ─────────────────────────────
+const rawLinesAfter = fs.readFileSync(memPaths.raw, 'utf8').split('\n').filter(Boolean);
+ok('log cru: linhas originais INTACTAS + 1 registro hardening apendado',
+  rawLinesAfter.length === rawLinesBefore.length + 1 &&
+  rawLinesAfter.slice(0, rawLinesBefore.length).join('\n') === rawLinesBefore.join('\n'));
+const hardRecord = JSON.parse(rawLinesAfter[rawLinesAfter.length - 1]);
+ok('registro hardening no formato ADR-012 (type/ref/target/approved_by/timestamp)',
+  hardRecord.type === 'hardening' &&
+  hardRecord.ref === podMemory.dedupKey(e1.entry) &&
+  hardRecord.target.workflowId === 'canario-hard' &&
+  hardRecord.target.step === 'redacao' &&
+  hardRecord.target.assertion.type === 'command_check' &&
+  hardRecord.approved_by === 'daniel' &&
+  typeof hardRecord.timestamp === 'string');
+
+const consolidatedAfter = fs.readFileSync(memPaths.consolidated, 'utf8');
+// SF11.4/ADR-022 (DF-SF11.4-1): o consolidado (artefato INJETADO) traz a referência
+// AGREGADA; o detalhe íntegro — asserção, aprovador, momento — vive na trilha auditável
+// `memory/learnings.hardened.md`, append-only e fora do caminho de injeção.
+const hardenedDetailAfter = fs.readFileSync(memPaths.hardenedDetail, 'utf8');
+ok('consolidado: referência AGREGADA 🔒 → veto command_check em redacao (1)',
+  consolidatedAfter.includes('## Endurecidas (🔒 → enforcement)') &&
+  consolidatedAfter.includes('veto command_check em redacao (1)') &&
+  consolidatedAfter.includes(podMemory.HARDENED_DETAIL_REL));
+ok('trilha auditável: detalhe íntegro da endurecida (asserção, aprovador, momento)',
+  hardenedDetailAfter.includes('🔒 **[travessoes no texto final]**') &&
+  hardenedDetailAfter.includes('endurecida → veto command_check em redacao') &&
+  hardenedDetailAfter.includes('(por daniel,'), hardenedDetailAfter);
+const topNSection = consolidatedAfter.split('## Endurecidas')[0];
+ok('consolidado: heurística DEMOVIDA do top-N ativo (não compete por injeção)',
+  !topNSection.includes('**[travessoes no texto final]**'));
+
+// consolidate idempotente mantém a marcação
+const again = podMemory.consolidate('canario-hard', { podDir });
+ok('consolidate idempotente: hardenedCount=1, referência 🔒 preservada e trilha byte-idêntica',
+  again.hardenedCount === 1 &&
+  fs.readFileSync(memPaths.consolidated, 'utf8').includes('veto command_check em redacao (1)') &&
+  fs.readFileSync(memPaths.hardenedDetail, 'utf8') === hardenedDetailAfter);
+
+// ── idempotência da promoção: repetir recusa (exit 2) ────────────────────────
+const repeat = sh([HARDEN, podDir, '--learning', e1.entry.id, '--step', 'redacao',
+  '--assertion', assertionJson, '--approved-by', 'daniel']);
+ok('re-promover a mesma heurística: recusa exit 2 (já endurecida)', repeat.status === 2);
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log(`\n${passed}/${passed} verificações passaram.`);

package/scripts/forge-ingest-memory.cjs

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * forge-ingest-memory.cjs — ingest EXTERNO OPT-IN de conhecimento para a memória de um
+ * pod, com dedup M1 (Story SF2.3, SPEC §M1).
+ *
+ * RESTRIÇÃO DO DANIEL (reafirmada, Risco 4): a memória v1 é aprendizado-DO-USO; ingest
+ * de fonte EXTERNA é SEMPRE OPT-IN MANUAL — só existe como invocação explícita do
+ * comando `*ingest-memory` do forge-chief. Este script NUNCA é chamado por outro fluxo
+ * automático (em particular, NÃO é importado por pc-run-pod.cjs). Verificável por grep.
+ *
+ * DEDUP M1: chave = `sha256(conteúdo normalizado) :: fonte normalizada`. Se a chave já
+ * existe no log cru → MERGE (incrementa a ocorrência via evidence.count) EM VEZ DE
+ * DUPLICAR a linha. Fonte diferente com o MESMO conteúdo = chave diferente = entrada
+ * distinta (a proveniência importa). O merge reescreve UMA linha do log cru — é operação
+ * SEPARADA do append-only (como rotate()), não uma quebra do contrato do motor.
+ *
+ * Uso:
+ *   node scripts/forge-ingest-memory.cjs <podDir> --source "<fonte citada>" \
+ *        --trigger "<gatilho>" --recommendation "<recomendação>" [--content-file <arq>]
+ *   (--content-file: hash do conteúdo do arquivo; senão hash da recomendação)
+ *
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const podMemory = require('./pod-memory.cjs');
+
+function normalizeContent(s) {
+  return String(s == null ? '' : s)
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/** Chave de dedup M1: hash do conteúdo normalizado + fonte normalizada. */
+function ingestKey(content, source) {
+  const hash = crypto.createHash('sha256').update(normalizeContent(content)).digest('hex').slice(0, 16);
+  return `${hash}::${normalizeContent(source)}`;
+}
+
+// A chave M1 viaja em `source_run_id` (campo que pod-memory.append PRESERVA — ele
+// descarta campos desconhecidos, então não usamos um campo próprio). Prefixo estável.
+const KEY_PREFIX = 'ingest::';
+
+/**
+ * Ingesta uma lição externa na memória do pod com dedup M1.
+ * @param podDir diretório do pod (contém memory/)
+ * @param entry { trigger, recommendation, source, content? } — content hashado (senão a recomendação)
+ * @returns { action: 'appended'|'merged', key, occurrences }
+ */
+function ingestExternal(podDir, entry, opts = {}) {
+  if (!entry || !entry.trigger || !entry.recommendation || !entry.source) {
+    throw new Error('ingest-memory: exige { trigger, recommendation, source } (fonte citada é obrigatória — M1)');
+  }
+  const content = entry.content != null ? entry.content : entry.recommendation;
+  const key = ingestKey(content, entry.source);
+  const runIdKey = KEY_PREFIX + key;
+  const paths = podMemory.memoryPaths('_', { podDir });
+  fs.mkdirSync(paths.dir, { recursive: true });
+
+  // lê o log cru e procura a chave M1 já ingerida (carregada em source_run_id)
+  const lines = fs.existsSync(paths.raw)
+    ? fs.readFileSync(paths.raw, 'utf8').split('\n').filter((l) => l.trim())
+    : [];
+  const records = lines.map((l) => { try { return JSON.parse(l); } catch { return null; } });
+
+  let hitIdx = -1;
+  for (let i = 0; i < records.length; i++) {
+    if (records[i] && records[i].source_run_id === runIdKey) { hitIdx = i; break; }
+  }
+
+  if (hitIdx >= 0) {
+    // MERGE — incrementa ocorrência, NÃO duplica a linha (M1).
+    const rec = records[hitIdx];
+    const prev = (rec.evidence && typeof rec.evidence.count === 'number') ? rec.evidence.count : 1;
+    rec.evidence = { count: prev + 1 };
+    rec.ts = Date.now();
+    lines[hitIdx] = JSON.stringify(rec);
+    fs.writeFileSync(paths.raw, lines.join('\n') + '\n');
+    return { action: 'merged', key, occurrences: rec.evidence.count };
+  }
+
+  // NOVA entrada — via o motor (append-only, tier normal; ingest externo NUNCA é
+  // critical: attributed_by de critical exige human/deterministic_rule upstream). A
+  // chave M1 viaja em source_run_id (campo que o motor PRESERVA).
+  const record = {
+    trigger: entry.trigger,
+    recommendation: entry.recommendation,
+    evidence: { count: 1 },
+    tier: 'normal',
+    source_run_id: runIdKey,
+  };
+  podMemory.append('_', record, { podDir });
+  return { action: 'appended', key, occurrences: 1 };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  let podDir = null;
+  const o = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--source') o.source = args[++i];
+    else if (args[i] === '--trigger') o.trigger = args[++i];
+    else if (args[i] === '--recommendation') o.recommendation = args[++i];
+    else if (args[i] === '--content-file') o.contentFile = args[++i];
+    else podDir = args[i];
+  }
+  if (!podDir || !o.source || !o.trigger || !o.recommendation) {
+    console.error('Uso: node scripts/forge-ingest-memory.cjs <podDir> --source "<fonte>" --trigger "<gatilho>" --recommendation "<rec>" [--content-file <arq>]');
+    process.exit(2);
+  }
+  const content = o.contentFile ? fs.readFileSync(path.resolve(o.contentFile), 'utf8') : o.recommendation;
+  const r = ingestExternal(path.resolve(podDir), { trigger: o.trigger, recommendation: o.recommendation, source: o.source, content });
+  console.log(`${r.action}: chave M1 ${r.key} (ocorrências: ${r.occurrences})`);
+  // consolida para refletir a ingestão no artefato lido pelo agente.
+  // SF11.4b/ADR-023 (DF-SF11.4b-1, DEBT-SF11.4b-B autorizado pelo dono): o retorno
+  // PARA DE SER DESCARTADO — era o último dos 4 chamadores cegos ao que a consolidação
+  // deixou de fora (QA-4 do gate da SF11.4). Ingerir conhecimento externo é justamente
+  // o ato que empurra a cauda para fora: ingerir e não ver o que saiu é o sub-relato de
+  // C2 num quarto lugar. Mesmo padrão dos outros 3 emissores: ledger do motor, total
+  // primeiro, quebra por causa depois. Aviso não derruba a ingestão (já gravada).
+  const resolvedPodDir = path.resolve(podDir);
+  const res = podMemory.consolidate('_', { podDir: resolvedPodDir });
+  const ledger = podMemory.formatEvictionLedger(path.basename(resolvedPodDir), res);
+  if (ledger) console.error(ledger);
+  process.exit(0);
+}
+
+if (require.main === module) main();
+
+module.exports = { ingestExternal, ingestKey, normalizeContent };