@daniellins/power-claude 0.16.3

package/scripts/derive-ready-transitions.cjs

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+'use strict';
+
+// ---------------------------------------------------------------------------
+// derive-ready-transitions — a contagem de `D-Dono-2` (i) se DERIVA do git.
+//
+// `ADR-035` (D1-D8). Instrumento OFFLINE, executado sob demanda, fora do
+// caminho quente de qualquer hook. Ele responde "quantas transições reais
+// `Draft`→`Ready` já existem, e qual veredito a v1 da trava emite sobre cada
+// uma" — sem que o hook precise escrever nada, em nenhuma instalação.
+//
+// Contratos que este arquivo honra, cada um com AC próprio na `SF13.8`:
+//
+//   • D1 — deriva de `git log --no-merges --name-only -- <dir-de-stories>`,
+//     comparando o blob de `<sha>^` com o de `<sha>` para cada `*.story.md`
+//     tocado. O alvo é ARGUMENTO: roda contra qualquer repositório, read-only.
+//   • D2 — FONTE ÚNICA. `extractStatusSection`/`statusToken` vêm de
+//     `enforce-cycle-authority.cjs`; `evaluateReadyOracles`/`loadValidator`
+//     vêm de `enforce-ready-oracles.cjs`. Nenhum predicado é reimplementado
+//     aqui — uma 2ª implementação poderia divergir do hook sobre o que é uma
+//     transição, e a contagem passaria a medir outra coisa que não o hook.
+//   • D3 — reporta AS DUAS leituras de `D-Dono-2`: o total do histórico e o
+//     total desde um marco (`--since`), mais o veredito por transição.
+//   • D4 — NUNCA é trava: `exit 0` SEMPRE, inclusive contra repositório
+//     inexistente. Toda falha vira DIAGNOSTICO impresso, nunca exceção
+//     propagada e nunca silêncio. Quem promove a trava a `deny` é o dono,
+//     lendo o número — nenhuma automação decide por ele.
+//   • D5 — NÃO viaja para instalações (`installer/motor-scripts.json`,
+//     `exclude`). A decisão que ele serve acontece uma vez, no repositório do
+//     framework; instalações são alcançadas de fora, com o alvo como argumento.
+//
+// Segurança (`ADR-035`, seção Segurança): `git` é invocado por `execFileSync`
+// com argumentos em ARRAY — nenhuma variante que interprete shell, nenhuma
+// opção que ligue shell, e o path do repositório-alvo entra como argumento de
+// processo, jamais concatenado em string de comando. Nada do conteúdo lido é
+// executado: o instrumento lê blobs e chama funções puras.
+//
+// Limitação conhecida e DECLARADA (`ADR-035` M7, dívida 1): transição que não
+// chegou a commit é invisível — em particular a classe `<ausente>->ready` (a
+// story nasce `Ready` num commit só). Teto medido: 20 em 90 (22%) no
+// framework. A perda sempre SUBTRAI, nunca infla: para um limiar de "pelo
+// menos 10", errar para baixo é o lado seguro de errar.
+//
+// Uso:
+//   node scripts/derive-ready-transitions.cjs [<repoPath>] [--rev <ref>]
+//        [--since <ref|data>] [--stories-dir <dir>]
+// ---------------------------------------------------------------------------
+
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const HOOKS_DIR = path.join(__dirname, '..', 'template', '.claude', 'hooks');
+const CYCLE_AUTHORITY_PATH = path.join(HOOKS_DIR, 'enforce-cycle-authority.cjs');
+const READY_ORACLES_PATH = path.join(HOOKS_DIR, 'enforce-ready-oracles.cjs');
+
+const DEFAULT_STORIES_DIR = 'docs/stories';
+const STORY_FILE_RE = /\.story\.md$/i;
+const GIT_MAX_BUFFER = 64 * 1024 * 1024;
+
+// Separador de registro no `git log`: um byte que não aparece em sha, data
+// nem path. Evita ter de adivinhar onde termina um commit e começa o próximo.
+const REC_SEP = '\u0001';
+
+function out(line) {
+  process.stdout.write(`${line}\n`);
+}
+
+function diagnostico(msg) {
+  out(`DIAGNOSTICO: ${msg}`);
+}
+
+// --- git ---------------------------------------------------------------
+
+// Toda invocação de git passa por aqui. `args` é sempre array; `repo` entra
+// como argumento de `-C`, jamais interpolado em string de comando.
+function git(repo, args) {
+  return execFileSync('git', ['-C', repo].concat(args), {
+    encoding: 'utf8',
+    maxBuffer: GIT_MAX_BUFFER,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function gitOrNull(repo, args) {
+  try {
+    return git(repo, args);
+  } catch {
+    return null;
+  }
+}
+
+// --- CLI ---------------------------------------------------------------
+
+function parseArgv(argv) {
+  const opts = {
+    repoPath: '.',
+    rev: 'HEAD',
+    since: null,
+    storiesDir: DEFAULT_STORIES_DIR,
+    erro: null,
+  };
+  let posicional = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--rev' || a === '--since' || a === '--stories-dir') {
+      const v = argv[i + 1];
+      if (typeof v !== 'string' || v.startsWith('--')) {
+        opts.erro = `a opção ${a} exige um valor`;
+        return opts;
+      }
+      if (a === '--rev') opts.rev = v;
+      if (a === '--since') opts.since = v;
+      if (a === '--stories-dir') opts.storiesDir = v;
+      i += 1;
+    } else if (a.startsWith('--')) {
+      opts.erro = `opção desconhecida: ${a}`;
+      return opts;
+    } else if (!posicional) {
+      opts.repoPath = a;
+      posicional = true;
+    } else {
+      opts.erro = `argumento posicional em excesso: ${a}`;
+      return opts;
+    }
+  }
+  return opts;
+}
+
+// --- derivação ---------------------------------------------------------
+
+// Quebra a saída de `git log --name-only` em `{ sha, iso, arquivos[] }`.
+// Puro: recebe texto, devolve estrutura — testável sem git.
+function parseLog(texto) {
+  const registros = [];
+  for (const bruto of String(texto || '').split(REC_SEP)) {
+    const bloco = bruto.replace(/^\n+/, '');
+    if (!bloco.trim()) continue;
+    const linhas = bloco.split('\n');
+    const cabecalho = linhas.shift();
+    const barra = cabecalho.indexOf('|');
+    if (barra < 0) continue;
+    const sha = cabecalho.slice(0, barra).trim();
+    const iso = cabecalho.slice(barra + 1).trim();
+    const arquivos = linhas.map((l) => l.trim()).filter((l) => l && STORY_FILE_RE.test(l));
+    if (!sha) continue;
+    registros.push({ sha, iso, arquivos });
+  }
+  return registros;
+}
+
+function main(argv) {
+  const opts = parseArgv(argv);
+  out('derive-ready-transitions — instrumento offline (ADR-035, D1-D8). Nunca trava: exit 0 sempre.');
+  if (opts.erro) {
+    diagnostico(`${opts.erro}. Uso: node scripts/derive-ready-transitions.cjs [<repoPath>] [--rev <ref>] [--since <ref|data>] [--stories-dir <dir>]`);
+    return;
+  }
+
+  // 1. Módulos irmãos (D2). Carregados ANTES de tocar o repositório: sem eles
+  //    não há predicado nenhum, e "0 transições" seria indistinguível de
+  //    "não consegui decidir" — a mesma classe de silêncio que o `ADR-032`
+  //    Emenda 2 recusa no hook.
+  let cycleAuthority;
+  let readyOracles;
+  try {
+    cycleAuthority = require(CYCLE_AUTHORITY_PATH);
+    readyOracles = require(READY_ORACLES_PATH);
+  } catch (err) {
+    diagnostico(`não consegui carregar os módulos do framework (${CYCLE_AUTHORITY_PATH}, ${READY_ORACLES_PATH}): ${err && err.message}`);
+    return;
+  }
+  const faltando = [
+    ['extractStatusSection', cycleAuthority],
+    ['statusToken', cycleAuthority],
+    ['evaluateReadyOracles', readyOracles],
+    ['loadValidator', readyOracles],
+  ].filter(([nome, mod]) => !mod || typeof mod[nome] !== 'function').map(([nome]) => nome);
+  if (faltando.length > 0) {
+    diagnostico(`superfície de export incompleta nos módulos do framework — faltam: ${faltando.join(', ')} (skew de template, ADR-019). Sem eles a derivação não é confiável; não conto nada.`);
+    return;
+  }
+  const secaoStatus = cycleAuthority.extractStatusSection;
+  const token = cycleAuthority.statusToken;
+
+  // 2. Repositório-alvo.
+  const repo = path.resolve(opts.repoPath);
+  const topo = gitOrNull(repo, ['rev-parse', '--show-toplevel']);
+  if (topo === null) {
+    diagnostico(`"${repo}" não é um repositório git acessível (ou o path não existe) — nada a derivar.`);
+    return;
+  }
+  const repoRoot = topo.trim();
+  const revResolvido = gitOrNull(repo, ['rev-parse', '--verify', `${opts.rev}^{commit}`]);
+  if (revResolvido === null) {
+    diagnostico(`o rev "${opts.rev}" não resolve para um commit em "${repoRoot}" — nada a derivar.`);
+    return;
+  }
+  const revSha = revResolvido.trim();
+
+  out(`repo=${repoRoot}`);
+  out(`rev=${revSha} (${opts.rev})`);
+  out(`stories-dir=${opts.storiesDir}`);
+
+  // 3. Pares (commit × story) tocados.
+  const log = gitOrNull(repo, [
+    'log',
+    revSha,
+    '--no-merges',
+    '--name-only',
+    '--pretty=format:%x01%H|%cI',
+    '--',
+    opts.storiesDir,
+  ]);
+  if (log === null) {
+    diagnostico(`git log falhou em "${repoRoot}" para o rev "${opts.rev}" e o diretório "${opts.storiesDir}" — nada a derivar.`);
+    return;
+  }
+  const registros = parseLog(log);
+  const pares = registros.reduce((n, r) => n + r.arquivos.length, 0);
+
+  // 4. Transições: `draft` antes, `ready` depois, pelos MESMOS predicados do
+  //    hook. `<sha>^` não existe no commit-raiz — o blob "antes" é string
+  //    vazia por desenho (a story nasce naquele commit), nunca exceção solta.
+  const transicoes = [];
+  for (const reg of registros) {
+    for (const arquivo of reg.arquivos) {
+      const depoisBruto = gitOrNull(repo, ['show', `${reg.sha}:${arquivo}`]);
+      if (depoisBruto === null) continue; // arquivo removido neste commit
+      if (token(secaoStatus(depoisBruto)) !== 'ready') continue;
+      const antesBruto = gitOrNull(repo, ['show', `${reg.sha}^:${arquivo}`]) || '';
+      if (token(secaoStatus(antesBruto)) !== 'draft') continue;
+      transicoes.push({ sha: reg.sha, iso: reg.iso, arquivo, conteudo: depoisBruto });
+    }
+  }
+
+  out(`commits=${registros.length} pares=${pares}`);
+  out(`total=${transicoes.length}`);
+
+  // 5. Leitura restrita ao marco (D3). Um sha vira RANGE DE ANCESTRALIDADE
+  //    (`<since>..<rev>`) — semântica nativa do git, imune ao erro de
+  //    granularidade de DIA que produziu o `17` corrigido na tabela M3 do
+  //    `ADR-035`. Uma data vira comparação de instante (>=, como `--since`
+  //    do git), nunca comparação de string de data.
+  if (opts.since) {
+    const sinceSha = gitOrNull(repo, ['rev-parse', '--verify', `${opts.since}^{commit}`]);
+    if (sinceSha !== null) {
+      const marco = sinceSha.trim();
+      const rangeBruto = gitOrNull(repo, ['rev-list', `${marco}..${revSha}`]);
+      if (rangeBruto === null) {
+        out(`desde: indisponivel — git rev-list ${marco}..${revSha} falhou`);
+      } else {
+        const noRange = new Set(rangeBruto.split('\n').map((l) => l.trim()).filter(Boolean));
+        const n = transicoes.filter((t) => noRange.has(t.sha)).length;
+        const dataMarco = (gitOrNull(repo, ['log', '-1', '--pretty=format:%cI', marco]) || '').trim();
+        out(`desde=${n} marco=${marco.slice(0, 8)} (${opts.since}, ${dataMarco}) criterio=ancestralidade ${marco.slice(0, 8)}..${revSha.slice(0, 8)}`);
+      }
+    } else {
+      const corte = Date.parse(opts.since);
+      if (Number.isNaN(corte)) {
+        out(`desde: indisponivel — "${opts.since}" não resolve nem para commit nem para data`);
+      } else {
+        const n = transicoes.filter((t) => {
+          const q = Date.parse(t.iso);
+          return !Number.isNaN(q) && q >= corte;
+        }).length;
+        out(`desde=${n} marco=${new Date(corte).toISOString()} criterio=instante>=corte`);
+      }
+    }
+  } else {
+    out('desde: (não solicitado — passe --since <sha|data> para a leitura restrita ao marco de D-Dono-2)');
+  }
+
+  // 6. Replay do veredito da v1 (D2/D3) sobre o conteúdo RESULTANTE de cada
+  //    transição. É possível porque o hook é PURO: o veredito é função total
+  //    do conteúdo, e o conteúdo resultante é o que o git guarda.
+  //    O validador vem do repositório-ALVO — D2 é sobre os PREDICADOS
+  //    (sempre do framework), não sobre o corpus que eles avaliam.
+  const validador = readyOracles.loadValidator(repoRoot);
+  const vereditos = new Map();
+  if (!validador.ok) {
+    out(`replay: indisponivel — scripts/validate-story-acs.cjs ausente ou não carregável em "${validador.path}" (${validador.error && validador.error.message}). O total acima NÃO depende disto.`);
+  } else {
+    let comAsk = 0;
+    const linhasAsk = [];
+    for (const t of transicoes) {
+      let hits;
+      try {
+        hits = readyOracles.evaluateReadyOracles(t.conteudo, validador.mod);
+      } catch (err) {
+        hits = [{ predicate: 'ERRO', id: null, detail: String(err && err.message) }];
+      }
+      const rotulos = (hits || []).map((h) => `${h.predicate}${h.id ? `/${h.id}` : ''}`);
+      vereditos.set(`${t.sha}:${t.arquivo}`, rotulos);
+      if (rotulos.length > 0) {
+        comAsk += 1;
+        linhasAsk.push(`ASK  ${t.iso.slice(0, 10)} ${t.sha.slice(0, 8)} ${path.basename(t.arquivo)} :: ${rotulos.join(', ')}`);
+      }
+    }
+    out(`replay: ask=${comAsk}  silencio=${transicoes.length - comAsk}  (validador=${validador.path})`);
+    for (const l of linhasAsk) out(l);
+  }
+
+  // 7. Cada transição é auditável individualmente — não um total agregado que
+  //    ninguém pode conferir (`ADR-035`, critério 2: falsificabilidade).
+  out('--- transicoes draft->ready (mais recente primeiro): sha data arquivo veredito ---');
+  for (const t of transicoes) {
+    const rotulos = vereditos.get(`${t.sha}:${t.arquivo}`);
+    const veredito = rotulos === undefined ? 'sem-replay' : (rotulos.length > 0 ? `ask(${rotulos.join(', ')})` : 'silencio');
+    out(`${t.sha.slice(0, 8)} ${t.iso.slice(0, 10)} ${t.arquivo} ${veredito}`);
+  }
+}
+
+// D4: `exit 0` SEMPRE. A rede é aqui, e é a única — nenhuma rota interna tem
+// try/catch próprio para a mesma classe de falha, senão esta nunca seria
+// exercitada e viraria letra morta (mesma disciplina de `runWithFailSafe`).
+if (require.main === module) {
+  try {
+    main(process.argv.slice(2));
+  } catch (err) {
+    diagnostico(`exceção não prevista (${err && err.message}) — o instrumento NUNCA trava: seguindo com exit 0.`);
+  }
+  process.exitCode = 0;
+}
+
+module.exports = { parseLog, parseArgv, main };

package/scripts/forge-additive.test.cjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * forge-additive.test.cjs — suíte do TIER AGREGADO + MODO ADITIVO (Story SF3.1).
+ * Cobre, com pods sintéticos em diretório temporário:
+ *   AC1 tier agregado do disco (forge-assess-tier --pod-dir / aggregateSpec).
+ *   AC2 tierOverride: generatePod NÃO re-classifica; forge-upgrade-pod passa o agregado.
+ *   AC3 DoD1: spec de 2 etapas sobre pod COMPLEX → aparato COMPLEX (squad-io + memória).
+ *   AC4 --additive recusa colisão de workflowId/template/step-id fora de owns[] (exit 2).
+ *   AC5 merge por seção do squad-io + guard do memory/README.md (M2).
+ *   AC6 retomada idempotente por spec_hash+owns[]; spec divergente sobre linha aberta.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const at = require('./forge-assess-tier.cjs');
+const g = require('./forge-generate.cjs');
+const { upgradePod } = require('./forge-upgrade-pod.cjs');
+
+const SCRIPTS = __dirname;
+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(name) { return fs.mkdtempSync(path.join(os.tmpdir(), `fa-${name}-`)); }
+// SF12.4a/ADR-030 Bloco O — `generatePod` exige `opts.specOrigin`. Estes testes cobrem
+// mecânica ADITIVA/regeneração (owns[]/merge/idempotência), não o Bloco C — 'derived'
+// (mesma leniência de `*upgrade-pod`/`*harden-learning`) evita acoplar esta suíte aos
+// 3 campos canônicos, que são cobertos à parte pelo Bloco O da suíte SF12.4a.
+const DERIVED = { specOrigin: 'derived' };
+function mkPod(dir, agentNames) {
+  fs.mkdirSync(path.join(dir, 'agents'), { recursive: true });
+  for (const n of agentNames) fs.writeFileSync(path.join(dir, 'agents', `${n}.md`), `# agente ${n}\n`);
+}
+
+// ---------------------------------------------------------------------------
+// AC1 — tier AGREGADO do disco: soma spec + disco.
+// ---------------------------------------------------------------------------
+const podA = tmp('podA');
+mkPod(podA, ['a', 'b', 'c', 'd']); // 4 agentes em disco
+const spec2 = { pod: 'p', agents: ['x', 'y'] }; // 2 etapas → SIMPLE isolado
+ok(at.classifyTier(spec2).tier === 'SIMPLE', 'AC1 spec de 2 etapas ISOLADA classifica SIMPLE (baseline do furo)');
+const disk = at.podDiskCounts(podA);
+ok(disk.agents === 4 && disk.workflows === 0 && disk.handoffs === 0, 'AC1 podDiskCounts lê 4 agentes do disco');
+ok(at.classifyTier(at.aggregateSpec(spec2, podA)).tier === 'STANDARD/COMPLEX',
+  'AC1 tier AGREGADO (spec 2 + disco 4 = 6 agentes) → STANDARD/COMPLEX');
+// squad-io e wf-*.yaml.smoke.json são EXCLUÍDOS da contagem de workflows.
+const podW = tmp('podW');
+mkPod(podW, ['a']);
+fs.mkdirSync(path.join(podW, 'workflows'), { recursive: true });
+fs.writeFileSync(path.join(podW, 'workflows', 'wf-real.yaml'), 'steps:\n');
+fs.writeFileSync(path.join(podW, 'workflows', 'wf-real.smoke.json'), '{}');
+fs.writeFileSync(path.join(podW, 'squad-io.yaml'), 'pod: p\nhandoffs:\n  - from: a\n    to: b\n    artifact: x\n');
+const diskW = at.podDiskCounts(podW);
+ok(diskW.workflows === 1, 'AC1 conta wf-*.yaml e EXCLUI .smoke.json');
+ok(diskW.handoffs === 1, 'AC1 conta handoffs declarados no squad-io.yaml');
+// CLI --pod-dir
+const specFile = path.join(podA, 'spec.json'); fs.writeFileSync(specFile, JSON.stringify(spec2));
+const cli = spawnSync(process.execPath, [path.join(SCRIPTS, 'forge-assess-tier.cjs'), specFile, '--pod-dir', podA], { encoding: 'utf8' });
+ok(/STANDARD\/COMPLEX/.test(cli.stdout), 'AC1 CLI --pod-dir imprime tier agregado STANDARD/COMPLEX');
+
+// ---------------------------------------------------------------------------
+// AC2/AC3 — tierOverride + DoD1 fim-a-fim: aparato COMPLEX gerado.
+// ---------------------------------------------------------------------------
+const outSimple = tmp('outSimple');
+const rNoOverride = g.generatePod(spec2, outSimple, DERIVED); // sem override → SIMPLE
+ok(rNoOverride.tier === 'SIMPLE' && !fs.existsSync(path.join(outSimple, 'squad-io.yaml')),
+  'AC2 sem override: spec de 2 etapas gera SIMPLE (sem squad-io) — comportamento SF1.4 intacto');
+const outCplx = tmp('outCplx');
+const rOverride = g.generatePod(spec2, outCplx, { tierOverride: 'STANDARD/COMPLEX', ...DERIVED });
+ok(rOverride.tier === 'STANDARD/COMPLEX', 'AC2 tierOverride: generatePod NÃO re-classifica (usa o tier recebido)');
+ok(fs.existsSync(path.join(outCplx, 'squad-io.yaml')), 'AC3 DoD1: squad-io.yaml presente (merge de handoff)');
+ok(fs.existsSync(path.join(outCplx, 'memory', 'learnings.consolidated.md')), 'AC3 DoD1: memória operante presente');
+
+// AC2 — forge-upgrade-pod PASSA o assessment agregado como tierOverride.
+const podUp = tmp('podUp');
+mkPod(podUp, ['a', 'b', 'c']); // 3 agentes → agregado STANDARD/COMPLEX
+fs.writeFileSync(path.join(podUp, 'pod-spec.json'), JSON.stringify({ pod: 'up', agents: ['a'] })); // spec do workflow: 1 agente
+// SF6.2/ADR-004 §2: dry-run agora é ZERO escrita — o aparato COMPLEX em disco só existe
+// sob --apply. Verificar disk-state exige apply (o caminho real de escrita); a plano de
+// dry-run (byte-identidade) é coberto em forge.test.cjs. Intenção do AC2 preservada.
+const up = upgradePod(podUp, { apply: true });
+ok(up.tier === 'STANDARD/COMPLEX', 'AC2 upgrade-pod: assessment agregado (3 agentes) = STANDARD/COMPLEX');
+ok(fs.existsSync(path.join(podUp, 'squad-io.yaml')) && fs.existsSync(path.join(podUp, 'memory', 'learnings.consolidated.md')),
+  'AC2 upgrade-pod: aparato COMPLEX gerado sob --apply (spec de 1 agente NÃO rebaixa; tier agregado do disco manda)');
+
+// ---------------------------------------------------------------------------
+// AC4 — modo aditivo: recusa colisão fora de owns[].
+// ---------------------------------------------------------------------------
+const outAdd = tmp('outAdd');
+const base = g.generatePod(spec2, outAdd, { tierOverride: 'STANDARD/COMPLEX', ...DERIVED });
+let collided = false; let code = null; let kind = null;
+try { g.generatePod(spec2, outAdd, { additive: true, tierOverride: 'STANDARD/COMPLEX', owns: [], ...DERIVED }); }
+catch (e) { collided = true; code = e.exitCode; kind = e.collision && e.collision.kind; }
+ok(collided && code === 2, 'AC4 colisão de template/workflowId fora de owns[] → exit 2');
+ok(/template|workflowId|step-id/.test(kind || ''), 'AC4 diagnóstico nomeia a classe de colisão');
+// owned → regenera deterministicamente, SEM exit 2 (não colide contra o próprio trabalho).
+const ownsAll = base.written.map((p) => path.relative(outAdd, p));
+let ownedOk = true;
+try { g.generatePod(spec2, outAdd, { additive: true, tierOverride: 'STANDARD/COMPLEX', owns: ownsAll, ...DERIVED }); }
+catch (e) { ownedOk = false; }
+ok(ownedOk, 'AC4/AC6 artefato em owns[] regenera sem colisão (não recusa o próprio trabalho)');
+
+// ---------------------------------------------------------------------------
+// AC5 — merge por seção do squad-io + guard do memory/README.md.
+// ---------------------------------------------------------------------------
+const outMerge = tmp('outMerge');
+const m1 = g.generatePod(spec2, outMerge, { tierOverride: 'STANDARD/COMPLEX', ...DERIVED });
+const io = path.join(outMerge, 'squad-io.yaml');
+fs.writeFileSync(io, `${fs.readFileSync(io, 'utf8')}\nvetos:\n  - regra_pre_existente\n`);
+// grava conteúdo curado no README de memória, para provar o guard.
+const readme = path.join(outMerge, 'memory', 'README.md');
+fs.writeFileSync(readme, '# README CURADO À MÃO — não sobrescrever\n');
+const spec3 = { pod: 'p', agents: ['x', 'z'] }; // handoff x→z novo
+const rMerge = g.generatePod(spec3, outMerge, { additive: true, tierOverride: 'STANDARD/COMPLEX', owns: m1.written.map((p) => path.relative(outMerge, p)), ...DERIVED });
+const mergedIo = fs.readFileSync(io, 'utf8');
+ok(/vetos:/.test(mergedIo) && /regra_pre_existente/.test(mergedIo), 'AC5 merge preserva seção pré-existente (vetos) do squad-io');
+ok(/to: z/.test(mergedIo) && /to: y/.test(mergedIo), 'AC5 merge UNE handoffs (novo z + original y)');
+ok((rMerge.merged || []).some((p) => p.endsWith('squad-io.yaml')), 'AC5 merge registrado no relatório (não em written)');
+ok(fs.readFileSync(readme, 'utf8').includes('CURADO À MÃO'), 'AC5 guard do memory/README.md: conteúdo curado PRESERVADO (fecha M2)');
+
+// ---------------------------------------------------------------------------
+// AC6 — retomada idempotente vs spec divergente (via manifest open-line).
+// ---------------------------------------------------------------------------
+const mm = require('./migration-manifest.cjs');
+const wd = tmp('resume');
+const podR = path.join(wd, 'pod'); mkPod(podR, ['a']);
+const specR = path.join(wd, 'wf-r.spec.json'); fs.writeFileSync(specR, JSON.stringify(spec2));
+const mf = path.join(wd, 'MIGRATION-r.yaml');
+// Pós-QA sf3.3: init exige --squad-dir; open-line exige triagem 'migrate' aprovada.
+mm.cmdInit(mf, { squad: 'r', squadDir: podR, now: 'T0' });
+mm.cmdTriageSet(mf, { workflow: 'wf-r', disposition: 'migrate', purpose: 'fixture:1', basis: 'dado', now: 'T0' });
+mm.cmdTriageApprove(mf, { workflow: 'wf-r', approvedBy: 'daniel', now: 'T0' });
+mm.cmdOpenLine(mf, { workflow: 'wf-r', spec: specR, podDir: podR, owns: ['templates/x-tmpl.md'], now: 'T1' });
+mm.cmdAdvance(mf, { workflow: 'wf-r', to: 'generated', now: 'T2' });
+const resume = mm.cmdOpenLine(mf, { workflow: 'wf-r', spec: specR, podDir: podR, now: 'T3' });
+ok(resume.resumed === true && resume.phase === 'generated', 'AC6 mesmo spec_hash + linha aberta → RETOMA da fase registrada (nunca exit 2)');
+fs.writeFileSync(specR, JSON.stringify({ pod: 'p', agents: ['x', 'y', 'w'] })); // muda a spec
+let divergeCode = null;
+try { mm.cmdOpenLine(mf, { workflow: 'wf-r', spec: specR, podDir: podR, now: 'T4' }); }
+catch (e) { divergeCode = e.exitCode; }
+ok(divergeCode === 2, 'AC6 spec_hash divergente sobre linha aberta → exit 2 (exige --amend)');
+
+console.log(`\n${passed}/${passed + failures.length} verificações (tier agregado + modo aditivo) passaram.`);
+if (failures.length) {
+  console.error('\nSUÍTE forge-additive (SF3.1) FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('Suíte forge-additive verde (C.1 tier agregado + C.2 aditivo/merge/guard/retomada).');
+process.exit(0);