@daniellins/power-claude 0.16.3

package/scripts/migration-manifest-sf3.2.test.cjs

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * migration-manifest-sf3.2.test.cjs — suíte das EXTENSÕES SF3.2 do manifest:
+ *  - AC5: feature-diff decide no advance→gates (exit 4 ANTES de pagar runs); backstop.
+ *  - AC6: motor pinado (motor_files[]/motor_hash); diff de 1 byte → exit 4 até decisão
+ *         registrada (--approved-by) ou re-âncora; alterar motor_files[] fora de decisão
+ *         (hand-edit do YAML) → exit 3 (integrity).
+ *  - AC7: close-line/verify RE-EXECUTAM o sweep (não releem report); report adulterado
+ *         não muda o veredito; re-execução é a fonte de verdade.
+ *  - AC9: waiver de legado inexecutável (tentativa real + declarados + aprovação).
+ *
+ * Arquivo separado da suíte SF3.1 (isola território, evita colisão de expectativa). Roda
+ * a partir da raiz do repo (motor_files[] default são relativos à raiz). Node >= 18.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const M = require('./migration-manifest.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}`); }
+}
+function exitOf(fn) {
+  try { fn(); return 0; } catch (e) { return e instanceof M.ManifestError ? e.exitCode : -1; }
+}
+
+const REPO = process.cwd();
+const FORMS_DIR = path.join(REPO, 'scripts', '__fixtures__', 'sweep-forms');
+const FORMS_WF = path.join(FORMS_DIR, 'workflows', 'wf-forms.yaml');
+const FORMS_SPEC = path.join(FORMS_DIR, 'specs', 'wf-forms.spec.json');
+const sha256File = (p) => crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex');
+
+function tmp() { return fs.mkdtempSync(path.join(os.tmpdir(), 'pc-mm32-')); }
+// Pós-QA sf3.3: init exige --squad-dir (inventory nunca null) e open-line exige
+// triagem 'migrate' APROVADA (sem caminho dormente). Fixtures dão aprovação sintética.
+function initForms(mfv) { return M.cmdInit(mfv, { squad: 'demo', squadDir: FORMS_DIR }); }
+function openForms(mfv) {
+  M.cmdTriageSet(mfv, { workflow: 'wf-forms', disposition: 'migrate', purpose: 'fixture:1', basis: 'dado' });
+  M.cmdTriageApprove(mfv, { workflow: 'wf-forms', approvedBy: 'daniel' });
+  return M.cmdOpenLine(mfv, { workflow: 'wf-forms', spec: FORMS_SPEC, podDir: FORMS_DIR });
+}
+function advanceTo(mf, workflow, phase, extra = {}) {
+  const seq = ['generated', 'distilled', 'linted', 'gates'];
+  for (const p of seq) {
+    M.cmdAdvance(mf, { workflow, to: p, ...(p === phase ? extra : {}) });
+    if (p === phase) return;
+  }
+}
+
+// ===========================================================================
+// AC5 — feature-diff → exit 4 no advance (ANTES de pagar runs).
+// ===========================================================================
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  initForms(mf);
+  // Âncora cobre SÓ count_gte/field_matches (como a âncora r1 real). wf-forms traz
+  // json_schema_valid/section_exists/file_referenced_exists → fora de features_covered.
+  M.cmdSetAnchor(mf, {
+    decision: 'ancora SF1.5 (fixture)', assertionTypes: ['count_gte', 'field_matches'],
+    dagShapes: ['linear'], checkpointPositions: ['final'],
+  });
+  openForms(mf);
+  // advance generated/distilled/linted OK (hook só em gates).
+  M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'generated' });
+  M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'distilled' });
+  M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'linted' });
+  const code = exitOf(() => M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'gates', wfPath: FORMS_WF }));
+  ok(code === 4, `AC5 advance→gates com feature fora de features_covered → exit 4 (obtido ${code})`);
+  // A linha NÃO avançou para gates (exit 4 ANTES de escrever a fase).
+  const doc = M.readManifest(mf);
+  ok(doc.lines[0].phase === 'linted', 'AC5 exit 4 é ANTES de pagar runs: a linha permanece em "linted" (não escreveu gates)');
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// AC5 backstop — checkReanchorGate re-aplicado (close-line usa o MESMO check).
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  initForms(mf);
+  M.cmdSetAnchor(mf, { decision: 'ancora estreita', assertionTypes: ['count_gte'], dagShapes: ['linear'], checkpointPositions: ['final'] });
+  openForms(mf);
+  const doc = M.readManifest(mf);
+  const line = doc.lines[0];
+  const code = exitOf(() => M.checkReanchorGate(doc, line, { wfPath: FORMS_WF }, REPO));
+  ok(code === 4, `AC5 backstop: checkReanchorGate (o check do close-line) também dá exit 4 (obtido ${code})`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// AC5 — CALIBRAÇÃO 2026-07-25 (ADR-006 §Consequências): `agents_shared` SAIU do tuple.
+// Teste INVERTIDO: agente reusado em 2 etapas do MESMO workflow → NÃO dispara re-âncora
+// (o motor é agent-agnóstico, keyed por stepId; prova código-verificada f3@f9b49b7).
+{
+  const dir = tmp();
+  const wfShared = path.join(dir, 'wf-shared.yaml');
+  fs.writeFileSync(wfShared, [
+    'state_machine:', '  states: [init, running, complete, failed]', '  initial: init',
+    '  terminal: [complete, failed]', 'steps:',
+    '  - id: s1', '    agent: shared-agent', '    template: t.md', '    inputs: [x]', '    outputs: [y]',
+    '    depends_on: []', '    checkpoint: null', '    veto:', '      assertions:',
+    '        - {"type":"count_gte","field":"Itens","n":2}',
+    '  - id: s2', '    agent: shared-agent', '    template: t.md', '    inputs: [y]', '    outputs: [z]',
+    '    depends_on: [s1]', '    checkpoint: null', '    veto:', '      assertions:',
+    '        - {"type":"count_gte","field":"Itens","n":2}', '',
+  ].join('\n'));
+  // features do wf-shared: {count_gte, linear, [], fix_loop:false} — TODAS cobertas.
+  const feat = M.computeFeatureSet(require('./validate-pod-workflow.cjs').parseYaml(fs.readFileSync(wfShared, 'utf8')));
+  ok(!('agents_shared' in feat), 'AC5-calibração: computeFeatureSet NÃO emite mais `agents_shared` (tuple: assertion_types, dag_shape, checkpoint_positions, fix_loop)');
+  const doc = { squad: 'x', anchor: { features_covered: { assertion_types: ['count_gte'], dag_shapes: ['linear'], checkpoint_positions: [], fix_loop: false }, motor: { files: M.DEFAULT_MOTOR_FILES, hash: M.computeMotorHash(M.DEFAULT_MOTOR_FILES, REPO) } }, lines: [] };
+  const line = { workflow: 'wf-shared', pod: 'p', pod_dir: dir, wf_path: wfShared };
+  const code = exitOf(() => M.checkReanchorGate(doc, line, { wfPath: wfShared }, REPO));
+  ok(code === 0, `AC5-calibração: agente reusado em 2 etapas → NÃO dispara re-âncora, prossegue LITE (exit ${code})`);
+  // Gatilho remanescente CONTINUA firme: um assertion_type novo (json_schema_valid) → exit 4.
+  const wfNewFeat = path.join(dir, 'wf-json.yaml');
+  fs.writeFileSync(wfNewFeat, [
+    'state_machine:', '  states: [init, running, complete, failed]', '  initial: init',
+    '  terminal: [complete, failed]', 'steps:',
+    '  - id: s1', '    agent: a1', '    template: t.md', '    inputs: [x]', '    outputs: [y]',
+    '    depends_on: []', '    checkpoint: null', '    veto:', '      assertions:',
+    '        - {"type":"json_schema_valid","schema":["k"]}', '',
+  ].join('\n'));
+  const line2 = { workflow: 'wf-json', pod: 'p', pod_dir: dir, wf_path: wfNewFeat };
+  const code2 = exitOf(() => M.checkReanchorGate(doc, line2, { wfPath: wfNewFeat }, REPO));
+  ok(code2 === 4, `AC5-calibração: gatilho remanescente firme — assertion_type novo (json_schema_valid) fora de features_covered → exit 4 (obtido ${code2})`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ===========================================================================
+// AC6 — motor pinado.
+// ===========================================================================
+// (a) motor_files[] default reflete pc-run-pod.cjs PÓS-fix da SF3.1.
+{
+  ok(M.DEFAULT_MOTOR_FILES.includes('scripts/pc-run-pod.cjs'), 'AC6 motor_files[] inclui pc-run-pod.cjs');
+  const runnerSrc = fs.readFileSync(path.join(REPO, 'scripts', 'pc-run-pod.cjs'), 'utf8');
+  ok(/M-r2-5|contagem\s+REAL|caminho\s+`extractField`/.test(runnerSrc),
+    'AC6 pc-run-pod.cjs é o PÓS-fix (marca M-r2-5 do count_gte presente — hash sobre a versão correta)');
+  const h = M.computeMotorHash(M.DEFAULT_MOTOR_FILES, REPO);
+  ok(/^[0-9a-f]{64}$/.test(h), 'AC6 motor_hash = sha256 de 64 hex sobre a lista de motor_files real');
+}
+
+// (b) diff de 1 byte em arquivo de motor_files[] → exit 4 até decisão registrada.
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  const motorFix = path.join(dir, 'motor-fixture.cjs');
+  fs.writeFileSync(motorFix, '// motor fixture v1\n');
+  initForms(mf);
+  // Âncora cobre TODAS as features do wf-forms (via --from-wf) para ISOLAR o check de motor.
+  M.cmdSetAnchor(mf, { decision: 'ancora com motor fixture', fromWf: FORMS_WF, motorFiles: [motorFix] });
+  openForms(mf);
+  M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'generated' });
+  M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'distilled' });
+  M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'linted' });
+  // sem mudança: advance→gates passa (feature coberto + motor íntegro).
+  const okCode = exitOf(() => M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'gates', wfPath: FORMS_WF }));
+  ok(okCode === 0, `AC6 motor íntegro + features cobertas → advance→gates OK (obtido ${okCode})`);
+  // Retrocede reabrindo a linha (nova spec_hash força fase spec) para re-testar advance.
+  // Em vez disso: novo manifest, muta 1 byte ANTES do advance→gates.
+  const dir2 = tmp();
+  const mf2 = path.join(dir2, 'm.yaml');
+  const motorFix2 = path.join(dir2, 'motor.cjs');
+  fs.writeFileSync(motorFix2, '// motor v1\n');
+  initForms(mf2);
+  M.cmdSetAnchor(mf2, { decision: 'ancora', fromWf: FORMS_WF, motorFiles: [motorFix2] });
+  openForms(mf2);
+  M.cmdAdvance(mf2, { workflow: 'wf-forms', to: 'generated' });
+  M.cmdAdvance(mf2, { workflow: 'wf-forms', to: 'distilled' });
+  M.cmdAdvance(mf2, { workflow: 'wf-forms', to: 'linted' });
+  fs.appendFileSync(motorFix2, 'X'); // 1 byte a mais
+  const code = exitOf(() => M.cmdAdvance(mf2, { workflow: 'wf-forms', to: 'gates', wfPath: FORMS_WF }));
+  ok(code === 4, `AC6 diff de 1 byte em motor_files[] → recusa LITE (exit 4) (obtido ${code})`);
+  // decisão registrada: --approved-by libera e REGISTRA a aceitação.
+  const okApproved = exitOf(() => M.cmdAdvance(mf2, { workflow: 'wf-forms', to: 'gates', wfPath: FORMS_WF, approvedBy: 'Daniel: revisei, motor sem mudança de verificação' }));
+  ok(okApproved === 0, `AC6 --approved-by libera o advance após motor diff (obtido ${okApproved})`);
+  const d2 = M.readManifest(mf2);
+  ok(d2.lines[0].motor_approval && /Daniel/.test(d2.lines[0].motor_approval.approved_by),
+    'AC6 aceitação de motor fica REGISTRADA na linha (motor_approval.approved_by)');
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.rmSync(dir2, { recursive: true, force: true });
+}
+
+// (c) alterar motor_files[] fora de decisão de re-âncora (hand-edit do YAML) → exit 3.
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  initForms(mf);
+  M.cmdSetAnchor(mf, { decision: 'ancora', assertionTypes: ['count_gte'], dagShapes: ['linear'] });
+  // hand-edit: injeta um motor_file extra direto no YAML (fora do set-anchor).
+  let text = fs.readFileSync(mf, 'utf8');
+  text = text.replace('"scripts/pc-run-pod.cjs"', '"scripts/pc-run-pod.cjs"\n      - "scripts/INJETADO.cjs"');
+  fs.writeFileSync(mf, text);
+  const code = exitOf(() => M.readManifest(mf));
+  ok(code === 3, `AC6 alterar motor_files[] à mão (fora de set-anchor) → integrity exit 3 (obtido ${code})`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ===========================================================================
+// AC7 — close-line/verify RE-EXECUTAM o sweep; report adulterado não muda veredito.
+// ===========================================================================
+function fakeRunState(dir, workflow, pod) {
+  const p = path.join(dir, 'state.json');
+  fs.writeFileSync(p, JSON.stringify({ workflow, pod, run_id: 'r1', steps: {} }));
+  return p;
+}
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  initForms(mf);
+  // sem âncora → gate de re-âncora é no-op; foco no sweep re-executado.
+  openForms(mf);
+  advanceTo(mf, 'wf-forms', 'gates', { wfPath: FORMS_WF });
+  const runId = fakeRunState(dir, 'wf-forms', 'sweep-forms');
+  // Report ADULTERADO em disco (alegando falha) — close-line NUNCA o lê.
+  fs.writeFileSync(FORMS_WF.replace(/\.yaml$/, '.smoke.report.json'),
+    JSON.stringify({ proofs: [{ step: 's_field', assertion: '0:field_matches', blocked: false }] }));
+  const code = exitOf(() => M.cmdCloseLine(mf, { workflow: 'wf-forms', wfPath: FORMS_WF, runIds: [runId] }));
+  ok(code === 0, `AC7 close-line com sweep re-executado (report adulterado presente, ignorado) → sucesso (obtido ${code})`);
+  const doc = M.readManifest(mf);
+  ok(doc.lines[0].phase === 'closed' && doc.lines[0].sweep && doc.lines[0].sweep.proofs === 9,
+    'AC7 close-line REALMENTE re-executou o sweep (9 provas gravadas) — veredito da re-execução, não do report');
+  // F3 verify re-executa e mantém a linha válida (report adulterado segue inerte).
+  const v = M.cmdVerify(mf);
+  ok(v.stale.length === 0, 'AC7 verify (F3) re-executa o sweep; report adulterado NÃO torna a linha stale');
+  fs.rmSync(FORMS_WF.replace(/\.yaml$/, '.smoke.report.json'), { force: true });
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// AC7 — a re-execução é a FONTE: um sweep que vaza/underivável faz reExecuteSweep recusar.
+{
+  const dir = tmp();
+  fs.mkdirSync(path.join(dir, 'workflows'));
+  fs.mkdirSync(path.join(dir, 'templates'));
+  fs.writeFileSync(path.join(dir, 'templates', 't.md'), '## Sec\n');
+  const wf = ['state_machine:', '  states: [init, running, complete, failed]', '  initial: init',
+    '  terminal: [complete, failed]', 'steps:', '  - id: s1', '    agent: a1', '    template: templates/t.md',
+    '    inputs: [x]', '    outputs: [y]', '    depends_on: []', '    checkpoint: null', '    veto:',
+    '      assertions:', '        - {"type":"field_matches","field":"v","pattern":".*"}', ''].join('\n');
+  const wfPath = path.join(dir, 'workflows', 'wf-u.yaml');
+  fs.writeFileSync(wfPath, wf);
+  fs.writeFileSync(wfPath.replace(/\.yaml$/, '.smoke.json'), JSON.stringify({ target_step: 's1', artifacts: { s1: '## Sec\nv: x\n' } }));
+  const line = { workflow: 'wf-u', pod: path.basename(dir), pod_dir: dir, wf_path: wfPath };
+  const sw = M.reExecuteSweep(line, { wfPath }, REPO);
+  ok(sw.ran === true && sw.ok === false && /underiv/i.test(sw.failures.join(' ')),
+    'AC7 reExecuteSweep é a fonte de verdade: sweep underivável → ran:true, ok:false (recusaria o close)');
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ===========================================================================
+// AC9 — waiver de legado inexecutável (mecanismo).
+// ===========================================================================
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  initForms(mf);
+  openForms(mf);
+  // sem transcript de tentativa → RECUSA ("não rodei" não é "não roda").
+  const noAttempt = exitOf(() => M.cmdWaiverSet(mf, { workflow: 'wf-forms', approvedBy: 'Daniel', declared: ['out.md'] }));
+  ok(noAttempt === 2, `AC9 waiver sem --transcript (tentativa registrada) → recusa exit 2 (obtido ${noAttempt})`);
+  // transcript inexistente → RECUSA.
+  const badTr = exitOf(() => M.cmdWaiverSet(mf, { workflow: 'wf-forms', transcript: path.join(dir, 'nope.txt'), approvedBy: 'Daniel', declared: ['out.md'] }));
+  ok(badTr === 2, `AC9 waiver com transcript inexistente → recusa exit 2 (obtido ${badTr})`);
+  // tentativa real registrada + aprovação + declarados → grava o waiver.
+  const tr = path.join(dir, 'attempt.log');
+  fs.writeFileSync(tr, 'tentativa real do legado full-sdc: 16 personas, sem runner, não completou.\n');
+  M.cmdWaiverSet(mf, { workflow: 'wf-forms', transcript: tr, approvedBy: 'Daniel: precedente full-sdc do ledger', declared: ['offer.md', 'model.md'], partial: [path.join(dir, 'p1.md')] });
+  const doc = M.readManifest(mf);
+  const w = doc.lines[0].legacy_waiver;
+  ok(w && w.approved_by && w.declared_artifacts.length === 2 && w.transcript,
+    'AC9 waiver registrado com tentativa + aprovação + artefatos DECLARADOS (completude passa a comparar contra os declarados)');
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ===========================================================================
+// SF3.4 (ADR-006 §Consequências) — reopen-line + verify vê drift em linha closed.
+// ===========================================================================
+function fakeRun(dir, workflow, pod) {
+  const p = path.join(dir, 'state.json');
+  fs.writeFileSync(p, JSON.stringify({ workflow, pod, run_id: 'r1', steps: {} }));
+  return p;
+}
+function closeWideLine(dir, mf) {
+  initForms(mf);
+  M.cmdSetAnchor(mf, { decision: 'ancora wide (fixture)', fromWf: FORMS_WF });
+  openForms(mf);
+  advanceTo(mf, 'wf-forms', 'gates', { wfPath: FORMS_WF });
+  const runId = fakeRun(dir, 'wf-forms', 'sweep-forms');
+  M.cmdCloseLine(mf, { workflow: 'wf-forms', wfPath: FORMS_WF, runIds: [runId] });
+  return runId;
+}
+
+// (a) RECUSAS — sem approved-by / sem decision-ref / linha não-closed / reason inválido.
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  // linha NÃO-closed → recusa.
+  initForms(mf);
+  M.cmdSetAnchor(mf, { decision: 'w', fromWf: FORMS_WF });
+  openForms(mf);
+  const notClosed = exitOf(() => M.cmdReopenLine(mf, { workflow: 'wf-forms', reason: 'reanchor', feature: 'checkpoint:mid', approvedBy: 'Daniel', decisionRef: 'docs/adr/ADR-006.md' }));
+  ok(notClosed === 2, `SF3.4 reopen recusa linha NÃO-closed → exit 2 (obtido ${notClosed})`);
+  fs.rmSync(dir, { recursive: true, force: true });
+
+  const dir2 = tmp();
+  const mf2 = path.join(dir2, 'm.yaml');
+  closeWideLine(dir2, mf2);
+  const badReason = exitOf(() => M.cmdReopenLine(mf2, { workflow: 'wf-forms', reason: 'porque-sim', feature: 'x', approvedBy: 'D', decisionRef: 'p' }));
+  ok(badReason === 2, `SF3.4 reopen recusa --reason ≠ reanchor → exit 2 (obtido ${badReason})`);
+  const noApprove = exitOf(() => M.cmdReopenLine(mf2, { workflow: 'wf-forms', reason: 'reanchor', feature: 'checkpoint:mid', decisionRef: 'p' }));
+  ok(noApprove === 2, `SF3.4 reopen recusa SEM --approved-by → exit 2 (obtido ${noApprove})`);
+  const noRef = exitOf(() => M.cmdReopenLine(mf2, { workflow: 'wf-forms', reason: 'reanchor', feature: 'checkpoint:mid', approvedBy: 'Daniel' }));
+  ok(noRef === 2, `SF3.4 reopen recusa SEM --decision-ref → exit 2 (obtido ${noRef})`);
+  // após as recusas a linha continua closed (nenhuma escreveu).
+  ok(M.readManifest(mf2).lines[0].phase === 'closed', 'SF3.4 recusas de reopen NÃO mutam a linha (segue closed)');
+  fs.rmSync(dir2, { recursive: true, force: true });
+}
+
+// (b) SUPERSEDED[] preservado byte-a-byte + linha viva limpa + phase=linted.
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  closeWideLine(dir, mf);
+  const before = M.readManifest(mf).lines[0];
+  const snapExpect = {};
+  // mesma lista que cmdReopenLine snapshota (só os campos PRESENTES na linha viva).
+  for (const f of ['wf_path', 'run_ids', 'pair', 'closed_at', 'verify', 'feature_set', 'sweep', 'motor_approval', 'advanced_at', 'stale', 'stale_at']) if (f in before) snapExpect[f] = before[f];
+  const specHashBefore = before.spec_hash; const baselineBefore = before.baseline;
+  M.cmdReopenLine(mf, { workflow: 'wf-forms', reason: 'reanchor', feature: 'checkpoint:mid', approvedBy: 'Daniel: checkpoint mid-DAG regenerado', decisionRef: 'docs/adr/ADR-006.md#consequencias' });
+  const after = M.readManifest(mf).lines[0];
+  ok(after.phase === 'linted', 'SF3.4 reopen devolve a linha à fase pré-gates (linted) para o pre-gates-check re-decidir');
+  ok(Array.isArray(after.superseded) && after.superseded.length === 1, 'SF3.4 reopen faz append em superseded[] (1 entrada)');
+  const sup = after.superseded[0];
+  ok(sup.reason === 'reanchor' && sup.feature === 'checkpoint:mid' && /Daniel/.test(sup.approved_by) && /ADR-006/.test(sup.decision_ref) && sup.superseded_at,
+    'SF3.4 superseded[] registra reason/feature/approved_by/decision_ref/superseded_at');
+  const canon = (o) => JSON.stringify(o, Object.keys(o).sort()); // ordem-insensível no topo
+  ok(canon(sup.snapshot) === canon(snapExpect),
+    'SF3.4 snapshot da adjudicação anterior preservado BYTE-A-BYTE (wf_path/run_ids/closed_at/verify/feature_set/sweep)');
+  ok(!('closed_at' in after) && !('sweep' in after) && !('feature_set' in after) && after.run_ids.length === 0,
+    'SF3.4 linha VIVA limpa da adjudicação (closed_at/sweep/feature_set removidos; run_ids zerado)');
+  ok(after.spec_hash === specHashBefore && JSON.stringify(after.baseline) === JSON.stringify(baselineBefore),
+    'SF3.4 identidade da linha PRESERVADA (spec_hash/baseline intactos) — NUNCA apaga histórico');
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// (c) VERIFY vê drift em linha CLOSED (feature-set do wf ATUAL vs covered ATUAL) → stale ruidoso.
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  closeWideLine(dir, mf); // fechada sob âncora WIDE (cobre tudo).
+  // âncora ESTREITA depois (drift: covered vigente já não cobre field_matches/json/etc do wf).
+  M.cmdSetAnchor(mf, { decision: 're-âncora estreita', assertionTypes: ['count_gte'], dagShapes: ['linear'], checkpointPositions: ['final'] });
+  const v = M.cmdVerify(mf);
+  ok(v.stale.length === 1, 'SF3.4 verify detecta drift de feature-set em linha CLOSED → 1 linha stale (antes era invisível)');
+  const drift = v.report[0].failures.join(' | ');
+  ok(/feature drift/i.test(drift) && /reopen-line/.test(drift),
+    `SF3.4 verify falha RUIDOSA apontando reopen-line ("${drift.slice(0, 70)}…")`);
+  ok(M.readManifest(mf).lines[0].phase === 'gates', 'SF3.4 linha driftada volta a stale via a via existente (phase=gates)');
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// (d) FLUXO reopen→advance→exit 4 (a re-adjudicação roteia para FULL).
+{
+  const dir = tmp();
+  const mf = path.join(dir, 'm.yaml');
+  closeWideLine(dir, mf);
+  M.cmdSetAnchor(mf, { decision: 're-âncora estreita', assertionTypes: ['count_gte'], dagShapes: ['linear'], checkpointPositions: ['final'] });
+  M.cmdReopenLine(mf, { workflow: 'wf-forms', reason: 'reanchor', feature: 'assertion_type:field_matches', approvedBy: 'Daniel', decisionRef: 'docs/adr/ADR-006.md' });
+  const code = exitOf(() => M.cmdAdvance(mf, { workflow: 'wf-forms', to: 'gates', wfPath: FORMS_WF }));
+  ok(code === 4, `SF3.4 reopen→advance→gates com feature descoberto → exit 4 (roteia FULL) (obtido ${code})`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ===========================================================================
+console.log(`\n${passed} asserções OK; ${failures.length} falha(s).`);
+if (failures.length) { for (const f of failures) console.error(`  ✗ ${f}`); process.exit(1); }
+console.log('migration-manifest-sf3.2: feature-diff/exit 4 + motor pinado + sweep re-executado + waiver + reopen/drift provados.');
+process.exit(0);

package/scripts/migration-manifest-sf3.3.test.cjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * migration-manifest-sf3.3.test.cjs — suíte das EXTENSÕES F0/F1/VIRAR-COMANDO da
+ * SF3.3 sobre o escritor único (não reimplementa nada da SF3.1/3.2).
+ * NÃO-fake-green: cada recusa é provada por estado real em disco.
+ * Cobre:
+ *   AC1  F0 inventário: init --squad-dir escaneia TODAS as famílias + grep de comandos.
+ *   AC2  F1 STOP: open-line RECUSA sem triagem aprovada (num manifest de migração);
+ *        gate dormente sem inventory (compat SF3.1).
+ *   AC4  disposição EXPLÍCITA de scripts/checklists (3 destinos) registrada no manifest.
+ *   AC9  VIRAR-COMANDO: sem os 3 → pendente; única saída é dispensar; com os 3 → fecha.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const m = require('./migration-manifest.cjs');
+
+const FIX = path.join(__dirname, '__fixtures__', 'migrate-squad');
+const LEGACY = path.join(FIX, 'legacy-squad');
+const AUTH = path.join(FIX, 'authored');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}`); }
+}
+function refuses(fn, code, label) {
+  let got = null;
+  try { fn(); } catch (e) { got = e.exitCode; }
+  ok(got === code, `${label} (exit ${code}${got === code ? '' : ` — obtido ${got}`})`);
+}
+function tmp(n) { return fs.mkdtempSync(path.join(os.tmpdir(), `mm33-${n}-`)); }
+
+// ---------------------------------------------------------------------------
+// AC1 — F0 inventário determinístico (init --squad-dir).
+// ---------------------------------------------------------------------------
+{
+  const dir = tmp('f0');
+  const mf = path.join(dir, 'MIGRATION-hormozi.yaml');
+  const out = m.cmdInit(mf, { squad: 'hormozi', squadDir: LEGACY, now: 'T0' });
+  const EXPECTED = ['agents', 'checklists', 'config', 'data', 'loose', 'scripts', 'sops', 'tasks', 'templates', 'workflows'];
+  ok(EXPECTED.every((f) => out.inventory.families.includes(f)), 'AC1 inventário cobre TODAS as 10 famílias (workflows..config + loose)');
+  // grep de comandos embutidos no agente legado (B.5).
+  const doc = m.readManifest(mf); // re-lê → prova que a integridade sobrevive ao inventário nested
+  const cmds = doc.inventory.commands.filter((c) => c.agent.includes('hormozi-offer')).map((c) => c.command).sort();
+  ok(JSON.stringify(cmds) === JSON.stringify(['*build-offer', '*diagnose', '*value-stack']), 'AC1 grep \\*[a-z-]+ captura os 3 comandos embutidos do agente legado');
+  // squad-io.yaml / README / HEADLINE na raiz caem em loose.
+  const loose = doc.inventory.items.filter((i) => i.family === 'loose').map((i) => i.path);
+  ok(loose.includes('squad-io.yaml') && loose.includes('README.md') && loose.includes('HEADLINE.md'), 'AC1 arquivos soltos da raiz → família loose');
+  // integridade: re-escrita (triage) sobre o manifest com inventory não corrompe.
+  m.cmdTriageSet(mf, { workflow: 'wf-sample', disposition: 'migrate', purpose: 'legacy/workflows/wf-sample.yaml:1', basis: 'julgamento', now: 'T' });
+  ok(m.readManifest(mf).inventory.families.length === 10, 'AC1 inventário round-trip (integrity) intacto após escrita subsequente');
+}
+
+// ---------------------------------------------------------------------------
+// AC2 — F1 STOP: sem aprovação do Daniel, open-line NÃO abre linha (migração real).
+// ---------------------------------------------------------------------------
+{
+  const dir = tmp('f1');
+  const mf = path.join(dir, 'MIGRATION-hormozi.yaml');
+  const pod = path.join(dir, 'pod'); fs.mkdirSync(pod, { recursive: true });
+  const spec = path.join(AUTH, 'specs', 'wf-sample.spec.json');
+  m.cmdInit(mf, { squad: 'hormozi', squadDir: LEGACY, now: 'T0' });
+
+  // (a) sem triagem → recusa (F1 não executada).
+  refuses(() => m.cmdOpenLine(mf, { workflow: 'wf-sample', spec, podDir: pod, now: 'T' }), 2, 'AC2 open-line sem triagem → RECUSA (PARA no Daniel)');
+
+  // (b) triagem migrate mas NÃO aprovada → recusa.
+  m.cmdTriageSet(mf, { workflow: 'wf-sample', disposition: 'migrate', purpose: 'wf-sample.yaml:1', basis: 'julgamento', now: 'T' });
+  refuses(() => m.cmdOpenLine(mf, { workflow: 'wf-sample', spec, podDir: pod, now: 'T' }), 2, 'AC2 triagem sem approved_by → open-line RECUSA');
+
+  // (c) aprovada pelo Daniel → open-line abre a linha.
+  const appr = m.cmdTriageApprove(mf, { workflow: 'wf-sample', approvedBy: 'daniel', now: 'T' });
+  ok(appr.approved_by === 'daniel', 'AC2 triage-approve registra aprovação humana (regra 5)');
+  const opened = m.cmdOpenLine(mf, { workflow: 'wf-sample', spec, podDir: pod, now: 'T' });
+  ok(opened.phase === 'spec', 'AC2 após aprovação registrada → open-line PROSSEGUE');
+
+  // (d) reclassificar para dispense ZERA a aprovação (mudar de disposição = decisão nova).
+  m.cmdTriageSet(mf, { workflow: 'wf-other', disposition: 'migrate', purpose: 'x:1', basis: 'dado', now: 'T' });
+  m.cmdTriageApprove(mf, { workflow: 'wf-other', approvedBy: 'daniel', now: 'T' });
+  m.cmdTriageSet(mf, { workflow: 'wf-other', disposition: 'dispense', purpose: 'x:1', basis: 'dado', now: 'T' });
+  const doc = m.readManifest(mf);
+  ok(!doc.triage.find((t) => t.workflow === 'wf-other').approved_by, 'AC2 reclassificar disposição ZERA approved_by (sem herdar aprovação antiga)');
+}
+
+// AC2 — REPRODUÇÃO DO ATAQUE DO QA (permanente): não pode existir caminho dormente.
+// O finding GRAVE: `init` sem `--squad-dir` → inventory null → gate F1 adormecido →
+// open-line sem aprovação. Fix ESTRUTURAL provado nos dois pontos:
+{
+  const dir = tmp('attack');
+  const mf = path.join(dir, 'MIGRATION-x.yaml');
+  const pod = path.join(dir, 'pod'); fs.mkdirSync(pod, { recursive: true });
+  const spec = path.join(dir, 'wf.spec.json'); fs.writeFileSync(spec, '{"id":"wf-x"}');
+
+  // (1) init SEM --squad-dir → RECUSA (exit 2). O inventário nunca nasce null.
+  refuses(() => m.cmdInit(mf, { squad: 'x', now: 'T0' }), 2, 'AC2/QA init SEM --squad-dir → RECUSA (inventário nunca null)');
+
+  // (2) mesmo um manifest hand-forjado com inventory AUSENTE (via escritor único,
+  //     integrity válido) NÃO abre o caminho dormente: open-line RECUSA sem triagem
+  //     aprovada — o gate F1 é INCONDICIONAL, não keyed em `inventory`.
+  const mf2 = path.join(dir, 'MIGRATION-noinv.yaml');
+  m.writeManifest(mf2, { squad: 'x', created_at: 'T0', triage: [], lines: [] }); // sem inventory
+  ok(m.readManifest(mf2) && !m.readManifest(mf2).inventory, 'AC2/QA manifest com inventory ausente é legível (integrity válido)');
+  refuses(() => m.cmdOpenLine(mf2, { workflow: 'wf-x', spec, podDir: pod, now: 'T' }), 2, 'AC2/QA inventory ausente + sem triagem → open-line RECUSA (gate incondicional, sem caminho dormente)');
+}
+
+// ---------------------------------------------------------------------------
+// AC4 — disposição EXPLÍCITA de scripts/checklists (nunca prosa; endereço no manifest).
+// ---------------------------------------------------------------------------
+{
+  const dir = tmp('disp');
+  const mf = path.join(dir, 'MIGRATION-hormozi.yaml');
+  m.cmdInit(mf, { squad: 'hormozi', squadDir: LEGACY, now: 'T0' });
+  // Validador Python: disposição entre veto/script-do-pod/óbito (dimensão 5). Aqui: script do pod.
+  m.cmdTriageSet(mf, { workflow: 'scripts/validate-mvn.py', disposition: 'migrate', purpose: 'portado como script executável do pod, referenciado por checkpoint (B.4 dim.5)', basis: 'julgamento', now: 'T' });
+  // Checklists nos 3 destinos.
+  m.cmdTriageSet(mf, { workflow: 'checklists/veto-screen.md', disposition: 'knowledge', purpose: 'redutível → veto.assertions count_gte (B.2 destino 1)', basis: 'dado', now: 'T' });
+  m.cmdTriageSet(mf, { workflow: 'checklists/method-guide.md', disposition: 'knowledge', purpose: 'metodológico → seções de template + knowledge (B.2 destino 2)', basis: 'dado', now: 'T' });
+  m.cmdTriageSet(mf, { workflow: 'checklists/dead-redundant.md', disposition: 'dispense', purpose: 'redundante/morto → DROP com justificativa (B.2 destino 3)', basis: 'dado', now: 'T' });
+  const doc = m.readManifest(mf);
+  const py = doc.triage.find((t) => t.workflow === 'scripts/validate-mvn.py');
+  ok(py && py.purpose.length > 10 && py.disposition === 'migrate', 'AC4 validador Python recebe disposição EXPLÍCITA (não prosa) com endereço');
+  const destinos = new Set(doc.triage.filter((t) => t.workflow.startsWith('checklists/')).map((t) => t.disposition));
+  ok(destinos.has('knowledge') && destinos.has('dispense'), 'AC4 checklists classificados nos 3 destinos (veto/template+knowledge/DROP) registrados');
+}
+
+// ---------------------------------------------------------------------------
+// AC9 — VIRAR-COMANDO: regra de fechamento (fecha G6-comando).
+// ---------------------------------------------------------------------------
+{
+  const dir = tmp('cmd');
+  const mf = path.join(dir, 'MIGRATION-hormozi.yaml');
+  m.cmdInit(mf, { squad: 'hormozi', squadDir: LEGACY, now: 'T0' });
+  m.cmdTriageSet(mf, { workflow: 'wf-growth-decision', disposition: 'command', purpose: 'wf-growth-decision.yaml:1 (135 linhas, árvore de decisão)', basis: 'dado', now: 'T' });
+
+  // (a) sem os 3 → permanece pendente-comando (command-close recusa).
+  refuses(() => m.cmdCommandClose(mf, { workflow: 'wf-growth-decision', now: 'T' }), 2, 'AC9 command-close sem os 3 → RECUSA (permanece pendente-comando)');
+  ok(!(m.readManifest(mf).triage.find((t) => t.workflow === 'wf-growth-decision').command_status === 'closed'), 'AC9 linha NÃO fecha sem os 3 itens');
+
+  // (b) command-close aplica só a disposição 'command'.
+  m.cmdTriageSet(mf, { workflow: 'wf-mig', disposition: 'migrate', purpose: 'x:1', basis: 'dado', now: 'T' });
+  refuses(() => m.cmdCommandClose(mf, { workflow: 'wf-mig', commandPath: mf, smoke: mf, approvedBy: 'daniel', now: 'T' }), 2, 'AC9 command-close em disposição ≠ command → RECUSA');
+
+  // (c) única saída sem os 3: reclassificar como dispensar (sempre disponível).
+  const re = m.cmdTriageSet(mf, { workflow: 'wf-growth-decision', disposition: 'dispense', purpose: 'reclassificado — não virou comando', basis: 'julgamento', now: 'T' });
+  ok(re.disposition === 'dispense', 'AC9 única saída sem os 3 é reclassificar para dispensar (regra 5)');
+
+  // (d) com os 3 (comando em disco + smoke próprio não-vazio + aprovação) → fecha.
+  m.cmdTriageSet(mf, { workflow: 'wf-opportunity', disposition: 'command', purpose: 'wf-opportunity.yaml:1', basis: 'julgamento', now: 'T' });
+  const cmdPath = path.join(dir, 'the-command.md'); fs.writeFileSync(cmdPath, '# comando destino\n');
+  const smokePath = path.join(dir, 'smoke-out.txt'); fs.writeFileSync(smokePath, 'ativação + 1 execução real: OK\n');
+  const closed = m.cmdCommandClose(mf, { workflow: 'wf-opportunity', commandPath: cmdPath, smoke: smokePath, approvedBy: 'daniel', now: 'T' });
+  ok(closed.command_status === 'closed', 'AC9 com os 3 (path em disco + smoke próprio + aprovação) → linha FECHA');
+
+  // (e) smoke vazio (sem output conferível) → recusa (regra 1 do ledger: teste real).
+  m.cmdTriageSet(mf, { workflow: 'wf-empty', disposition: 'command', purpose: 'x:1', basis: 'dado', now: 'T' });
+  const emptySmoke = path.join(dir, 'empty.txt'); fs.writeFileSync(emptySmoke, '');
+  refuses(() => m.cmdCommandClose(mf, { workflow: 'wf-empty', commandPath: cmdPath, smoke: emptySmoke, approvedBy: 'daniel', now: 'T' }), 2, 'AC9 smoke vazio (sem output conferível) → RECUSA');
+}
+
+// ---------------------------------------------------------------------------
+console.log(`\n${passed} verificações OK, ${failures.length} falha(s).`);
+if (failures.length) { for (const f of failures) console.error(`  - ${f}`); process.exit(1); }
+process.exit(0);