@daniellins/power-claude 0.16.3

package/scripts/migration-manifest.cjs

@@ -0,0 +1,1146 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * migration-manifest.cjs — ESCRITOR ÚNICO do estado de migração squad→pod v0.3
+ * (Story SF3.1; Decisão A.1 do design `*migrate-squad`, ADR-006 ACEITO).
+ *
+ * `docs/migration/MIGRATION-<squad>.yaml` sobrevive à deleção do squad e é o
+ * estado durável da migração (a linha carrega `phase`; não há state file paralelo).
+ * SÓ este script escreve o arquivo — o forge-chief invoca subcomandos, nunca edita
+ * o YAML. Espelha a tese do runner↔state.json: o relato do agente nunca é evidência.
+ *
+ * TRÊS camadas de garantia, com o limite de cada uma DECLARADO:
+ *  1. integrity hash (sha256 do corpo canônico) — tamper-EVIDENTE contra edição
+ *     ACIDENTAL; declaradamente NÃO anti-recomputação (o algoritmo é público). Por
+ *     isso NÃO é a raiz de confiança. Manifest com hash divergente → exit 3.
+ *  2. RAIZ DE CONFIANÇA EM CÓDIGO (fecha G-r2-1.1): os checks de fechamento são
+ *     DERIVADOS pelo helper do TIPO da linha e aplicados aos CAMPOS DE EVIDÊNCIA —
+ *     nunca a comandos gravados no YAML. `verify[]` é só CACHE DE AUDITORIA (o que
+ *     rodou, quando, com que exit); close-line/verify NUNCA o executam como fonte.
+ *     Consequência: `verify: [{cmd: true}]` não compra nada — para passar seria
+ *     preciso fabricar os artefatos em disco (state.json com binding, wf válido).
+ *  3. BINDING de evidência à linha (fecha G-r2-1.2/1.3): run_ids só valem se
+ *     `state.json.workflow`+`.pod` == os da linha; spec_hash conferido contra o
+ *     disco; wf_path RE-EXECUTA validate-pod-workflow.cjs (exit 0 exigido), não
+ *     confere só existência. O barato e determinístico se RE-EXECUTA (close e F3).
+ *
+ * ESCOPO SF3.1: `advance`/`close-line` recebem o contrato de fases e a verificação
+ * de binding/evidência, mas SEM a chamada ao SWEEP (que só existe a partir de SF3.2)
+ * e SEM feature-set/motor_files[]/exit 4 (SF3.2). A assinatura pública é estável o
+ * bastante para SF3.2 apenas ESTENDER (ver Dev Notes da story: hook 'pre-gates-check').
+ *
+ * Subcomandos: init · triage-set · triage-approve · command-close · dispense-close ·
+ *   address-set · open-line · reopen-line · advance · close-line · set-anchor · waiver-set ·
+ *   coverage · verify
+ * Exit: 0 ok · 2 recusa (colisão/binding/spec_hash/fase/evidência forjada/wf inválido)
+ *       · 3 integrity divergente (manifest adulterado) · 1 erro de uso/interno OU
+ *         stale detectado no `verify` (fail-loud: nunca stale silencioso em exit 0).
+ *
+ * Node >= 18, sem dependências externas (reusa parseYaml de validate-pod-workflow.cjs).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const { parseYaml } = require('./validate-pod-workflow.cjs');
+
+const PHASES = ['spec', 'generated', 'distilled', 'linted', 'gates', 'closed'];
+const TRIAGE_DISPOSITIONS = new Set(['migrate', 'dispense', 'command', 'knowledge']);
+const TRIAGE_BASES = new Set(['dado', 'julgamento']);
+
+// Motor pinado (M-r2-4): lista DEFAULT dos arquivos self-contained que o motor de
+// verificação usa (evalVeto/checkTemplateConformance/countListItemsInSection vivem
+// TODOS em pc-run-pod.cjs — conferido no design D.G2). O motor_hash é sha256 sobre a
+// lista; a lista é DADO versionado do manifest, alterável SÓ por decisão de re-âncora
+// (set-anchor). pc-run-pod.cjs aqui é o PÓS-fix da SF3.1 (evalVeto count_gte corrigido).
+const DEFAULT_MOTOR_FILES = [
+  'scripts/pc-run-pod.cjs',
+  'scripts/pod-memory.cjs',
+  'scripts/validate-pod-workflow.cjs',
+  'scripts/smoke-pod-workflow.cjs',
+];
+
+// ---------------------------------------------------------------------------
+// Erros com código de saída dedicado (fail-loud; nunca "conserta" silenciosamente).
+// ---------------------------------------------------------------------------
+class ManifestError extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.name = 'ManifestError';
+    this.exitCode = exitCode;
+  }
+}
+const refuse = (m) => { throw new ManifestError(m, 2); };   // recusa de contrato
+const tamper = (m) => { throw new ManifestError(m, 3); };   // integrity/adulteração
+const usage = (m) => { throw new ManifestError(m, 1); };    // uso/interno
+const reanchor = (m) => { throw new ManifestError(m, 4); }; // re-âncora obrigatória (feature/motor)
+
+function sha256(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+function sha256File(p) {
+  return sha256(fs.readFileSync(p));
+}
+
+// ---------------------------------------------------------------------------
+// Serializador CANÔNICO (subconjunto emitido = subconjunto lido por parseYaml).
+// Chaves ORDENADAS; strings SEMPRE entre aspas (round-trip de tipo garantido);
+// números/booleanos crus. O integrity hash é sobre o TEXTO do corpo (sem depender
+// de round-trip do parser) — robusto contra qualquer quirk de leitura.
+// ---------------------------------------------------------------------------
+function q(s) {
+  return `"${String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function scalar(v) {
+  if (v === null || v === undefined) return '""';
+  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+  const s = String(v);
+  if (/[\r\n]/.test(s)) refuse(`valor de campo com quebra de linha não é permitido no manifest: ${JSON.stringify(s)}`);
+  return q(s);
+}
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function serMap(obj, sp) {
+  const pad = ' '.repeat(sp);
+  const out = [];
+  for (const k of Object.keys(obj).sort()) {
+    const v = obj[k];
+    if (Array.isArray(v)) {
+      if (v.length === 0) { out.push(`${pad}${k}: []`); continue; }
+      out.push(`${pad}${k}:`);
+      for (const item of v) {
+        if (isPlainObject(item)) {
+          const inner = serMap(item, sp + 4).split('\n');
+          out.push(`${' '.repeat(sp + 2)}- ${inner[0].slice(sp + 4)}`);
+          for (let j = 1; j < inner.length; j++) out.push(inner[j]);
+        } else {
+          out.push(`${' '.repeat(sp + 2)}- ${scalar(item)}`);
+        }
+      }
+    } else if (isPlainObject(v)) {
+      if (Object.keys(v).length === 0) { out.push(`${pad}${k}: {}`); continue; }
+      out.push(`${pad}${k}:`);
+      out.push(serMap(v, sp + 2));
+    } else {
+      out.push(`${pad}${k}: ${scalar(v)}`);
+    }
+  }
+  return out.join('\n');
+}
+
+function serializeBody(doc) {
+  const rest = {};
+  for (const k of Object.keys(doc)) if (k !== 'integrity') rest[k] = doc[k];
+  return `${serMap(rest, 0)}\n`;
+}
+
+// ---------------------------------------------------------------------------
+// Leitura/escrita do manifest. O integrity hash é o sha256 do CORPO (tudo menos
+// a última linha `integrity:`). Hand-edit em QUALQUER linha do corpo muda o texto
+// ⇒ hash diverge ⇒ exit 3 (antes mesmo de parsear).
+// ---------------------------------------------------------------------------
+function writeManifest(mfPath, doc) {
+  const body = serializeBody(doc);
+  const integrity = sha256(Buffer.from(body, 'utf8'));
+  fs.mkdirSync(path.dirname(mfPath), { recursive: true });
+  fs.writeFileSync(mfPath, `${body}integrity: ${q(integrity)}\n`, 'utf8');
+  doc.integrity = integrity;
+  return doc;
+}
+
+function readManifest(mfPath) {
+  if (!fs.existsSync(mfPath)) refuse(`manifest inexistente: ${rel(mfPath)} — rode 'init' primeiro`);
+  const text = fs.readFileSync(mfPath, 'utf8');
+  const lines = text.split('\n');
+  let idx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (/^integrity:\s*"[0-9a-f]{64}"\s*$/.test(lines[i])) { idx = i; break; }
+  }
+  if (idx < 0) tamper(`manifest sem campo integrity válido — não foi escrito pelo escritor único (${rel(mfPath)})`);
+  const stored = lines[idx].match(/"([0-9a-f]{64})"/)[1];
+  const body = `${lines.slice(0, idx).join('\n')}\n`;
+  const recomputed = sha256(Buffer.from(body, 'utf8'));
+  if (stored !== recomputed) {
+    tamper(`integrity divergente (stored=${stored.slice(0, 12)}… recomputed=${recomputed.slice(0, 12)}…) — ` +
+      `manifest editado fora do escritor único (${rel(mfPath)}). Nenhuma operação prossegue.`);
+  }
+  let doc;
+  try { doc = parseYaml(body); } catch (e) { tamper(`manifest ilegível: ${e.message}`); }
+  if (!isPlainObject(doc)) tamper('manifest com estrutura de topo inválida');
+  doc.triage = Array.isArray(doc.triage) ? doc.triage : [];
+  doc.lines = Array.isArray(doc.lines) ? doc.lines : [];
+  return doc;
+}
+
+function rel(p) {
+  return path.relative(process.cwd(), p) || p;
+}
+
+// ---------------------------------------------------------------------------
+// Localização da linha / fases.
+// ---------------------------------------------------------------------------
+function findLine(doc, workflow) {
+  return doc.lines.find((l) => l.workflow === workflow) || null;
+}
+function phaseIndex(p) {
+  const i = PHASES.indexOf(p);
+  if (i < 0) usage(`fase desconhecida: "${p}" (esperado: ${PHASES.join('|')})`);
+  return i;
+}
+
+// ---------------------------------------------------------------------------
+// Baseline snapshot (fecha M-r2-2): listagem recursiva + sha256 por arquivo.
+// ---------------------------------------------------------------------------
+function snapshotTree(rootDir) {
+  const out = [];
+  if (!fs.existsSync(rootDir)) return out;
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const abs = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(abs);
+      else if (entry.isFile()) out.push({ path: path.relative(rootDir, abs), sha256: sha256File(abs) });
+    }
+  };
+  walk(rootDir);
+  out.sort((a, b) => a.path.localeCompare(b.path));
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// RAIZ DE CONFIANÇA EM CÓDIGO — verificação de UMA linha fechada. Os checks são
+// DERIVADOS aqui (código), aplicados aos campos de evidência da linha. `verify[]`
+// NÃO é consultado como fonte — só existe como cache de auditoria. Retorna
+// { ok, failures[] }. RE-EXECUTA o determinístico (validate-pod-workflow.cjs).
+// ---------------------------------------------------------------------------
+function verifyLineEvidence(line, opts = {}) {
+  const failures = [];
+  const baseDir = opts.baseDir || process.cwd();
+  const resolve = (p) => (path.isAbsolute(p) ? p : path.resolve(baseDir, p));
+
+  // (1) spec_hash — conferido contra o disco (o que está em specs/ AGORA).
+  if (!line.spec_path || !line.spec_hash) {
+    failures.push('linha sem spec_path/spec_hash — evidência de spec ausente');
+  } else {
+    const specAbs = resolve(line.spec_path);
+    if (!fs.existsSync(specAbs)) failures.push(`spec inexistente em disco: ${line.spec_path}`);
+    else {
+      const now = sha256File(specAbs);
+      if (now !== line.spec_hash) {
+        failures.push(`spec_hash divergente: linha=${String(line.spec_hash).slice(0, 12)}… disco=${now.slice(0, 12)}… (spec mudou após open-line)`);
+      }
+    }
+  }
+
+  // (2) wf_path — RE-EXECUTA validate-pod-workflow.cjs (exit 0), não confere só existência.
+  if (!line.wf_path) {
+    failures.push('linha sem wf_path — evidência de workflow ausente');
+  } else {
+    const wfAbs = resolve(line.wf_path);
+    if (!fs.existsSync(wfAbs)) failures.push(`wf_path inexistente em disco: ${line.wf_path}`);
+    else {
+      const args = [path.join(__dirname, 'validate-pod-workflow.cjs'), wfAbs];
+      if (line.pod_dir) { args.push('--pod-root', resolve(line.pod_dir)); }
+      const r = spawnSync(process.execPath, args, { encoding: 'utf8' });
+      if (r.status !== 0) {
+        failures.push(`validate-pod-workflow re-executado FALHOU (exit ${r.status}) em ${line.wf_path}: ${(r.stderr || r.stdout || '').trim().split('\n').pop()}`);
+      }
+    }
+  }
+
+  // (3) run_ids — existência + BINDING (state.json.workflow+.pod == linha).
+  const runIds = Array.isArray(line.run_ids) ? line.run_ids : [];
+  if (runIds.length === 0) {
+    failures.push('linha sem run_ids — evidência dinâmica (G5) ausente');
+  }
+  for (const rid of runIds) {
+    const ridAbs = resolve(rid);
+    if (!fs.existsSync(ridAbs)) { failures.push(`run_id inexistente (forjado): ${rid}`); continue; }
+    let st;
+    try { st = JSON.parse(fs.readFileSync(ridAbs, 'utf8')); } catch (e) { failures.push(`run_id ilegível: ${rid} (${e.message})`); continue; }
+    if (st.workflow !== line.workflow || st.pod !== line.pod) {
+      failures.push(`run_id sem binding: ${rid} tem workflow="${st.workflow}"/pod="${st.pod}", linha exige "${line.workflow}"/"${line.pod}" (evidência de OUTRA linha)`);
+    } else if (st.spec_hash != null && line.spec_hash != null && st.spec_hash !== line.spec_hash) {
+      // Binding de spec_hash é conferido QUANDO presente no state (forward-compat SF3.2);
+      // o runner atual não emite spec_hash, então ausência não reprova (não se inventa prova).
+      failures.push(`run_id com spec_hash divergente: ${rid} (${String(st.spec_hash).slice(0, 12)}… ≠ ${String(line.spec_hash).slice(0, 12)}…)`);
+    }
+  }
+
+  return { ok: failures.length === 0, failures };
+}
+
+// ---------------------------------------------------------------------------
+// FEATURE-SET + MOTOR PINADO (SF3.2 — Decisão D.G2 / M-r2-1 / M-r2-4).
+// Decisão de MÁQUINA (não lista de palpites): o feature-set é computado
+// deterministicamente do wf-*.yaml; o diff features(wf) ⊄ features_covered dispara
+// re-âncora (exit 4). O motor é pinado por sha256 sobre a lista versionada.
+// ---------------------------------------------------------------------------
+// CALIBRAÇÃO 2026-07-25 (ADR-006 §Consequências, F2 real do wf-money-model-design):
+// `agents_shared` SAIU do tuple de re-âncora. Verificação código-verificada do runner
+// (f3 @ f9b49b7) provou que o motor é AGENT-AGNÓSTICO — `dispatchStep`/`state.steps{}`
+// são keyed por stepId (subagente fresco por etapa), `step.agent` é só rótulo do brief
+// (pc-run-pod.cjs:339) e campo informativo do state (:672); verifyStep/fix_cycle/memória
+// não ramificam por identidade de agente. Logo reuso de agente NÃO exercita caminho de
+// motor não coberto pela âncora — a via correta é calibrar o tuple, não override. Se um
+// refactor futuro fizer o runner ramificar por agente, o `motor_hash` dispara a decisão
+// (a proteção não depende da lista). Tuple remanescente: assertion_types[], dag_shape,
+// checkpoint_positions, fix_loop. Daniel aprovou o LITE com este fundamento.
+function computeFeatureSet(wfDoc) {
+  const steps = Array.isArray(wfDoc.steps) ? wfDoc.steps : [];
+  const assertionTypes = new Set();
+  let fixLoop = false;
+  const fanIn = new Map();          // id -> nº de deps
+  const fanOut = new Map();         // id -> nº de dependentes
+  for (const s of steps) {
+    const as = (s.veto && Array.isArray(s.veto.assertions)) ? s.veto.assertions : [];
+    for (const a of as) if (a && a.type) assertionTypes.add(a.type);
+    const deps = Array.isArray(s.depends_on) ? s.depends_on : [];
+    fanIn.set(s.id, deps.length);
+    for (const d of deps) fanOut.set(d, (fanOut.get(d) || 0) + 1);
+    if (s.fix_loop === true || (s.checkpoint && s.checkpoint.loop === true)) fixLoop = true;
+  }
+  let dagShape = 'linear';
+  for (const s of steps) {
+    if ((fanOut.get(s.id) || 0) > 1 || (fanIn.get(s.id) || 0) > 1) { dagShape = 'branch'; break; }
+  }
+  const positions = new Set();
+  for (const s of steps) {
+    if (s.checkpoint && s.checkpoint.blocking === true) {
+      positions.add((fanOut.get(s.id) || 0) > 0 ? 'mid' : 'final');
+    }
+  }
+  return {
+    assertion_types: [...assertionTypes].sort(),
+    dag_shape: dagShape,
+    checkpoint_positions: [...positions].sort(),
+    fix_loop: fixLoop,
+  };
+}
+
+/** Retorna a lista de features do wf NÃO cobertas pela âncora (vazia ⇒ LITE liberado). */
+function featureDiff(feat, covered) {
+  const c = covered || {};
+  const cAssert = c.assertion_types || [];
+  const cShapes = c.dag_shapes || [];
+  const cPos = c.checkpoint_positions || [];
+  const uncovered = [];
+  for (const t of feat.assertion_types) if (!cAssert.includes(t)) uncovered.push(`assertion_type:${t}`);
+  if (!cShapes.includes(feat.dag_shape)) uncovered.push(`dag_shape:${feat.dag_shape}`);
+  for (const p of feat.checkpoint_positions) if (!cPos.includes(p)) uncovered.push(`checkpoint:${p}`);
+  if (feat.fix_loop && !c.fix_loop) uncovered.push('fix_loop');
+  return uncovered;
+}
+
+/** motor_hash = sha256 sobre "path:sha256(conteúdo)" de cada arquivo, ordenado. */
+function computeMotorHash(files, baseDir) {
+  const parts = [...files].sort().map((f) => {
+    const abs = path.isAbsolute(f) ? f : path.resolve(baseDir, f);
+    if (!fs.existsSync(abs)) refuse(`motor_files[] referencia arquivo inexistente: ${f}`);
+    return `${f}:${sha256File(abs)}`;
+  });
+  return sha256(Buffer.from(parts.join('\n'), 'utf8'));
+}
+
+/** Localiza o wf em disco para uma linha (flag explícita > wf_path da linha > convenção). */
+function resolveWfPath(line, opts, baseDir) {
+  const cand = opts.wfPath || line.wf_path ||
+    (line.pod_dir ? path.join(line.pod_dir, 'workflows', `${line.workflow}.yaml`) : null);
+  if (!cand) return null;
+  const abs = path.isAbsolute(cand) ? cand : path.resolve(baseDir, cand);
+  return fs.existsSync(abs) ? abs : null;
+}
+
+/**
+ * Porta de re-âncora (D.G2): roda no advance→gates (ANTES de pagar runs) e como
+ * BACKSTOP no close-line. Sem `doc.anchor` gravado, é no-op (compat SF3.1). Com âncora:
+ *  - features(wf) ⊄ features_covered ⇒ exit 4 (re-âncora obrigatória);
+ *  - motor_hash atual ≠ pinado ⇒ exit 4, salvo --approved-by (aceitação registrada).
+ */
+function checkReanchorGate(doc, line, opts, baseDir) {
+  const anchor = doc.anchor;
+  if (!anchor) return { skipped: true };
+  const wfAbs = resolveWfPath(line, opts, baseDir);
+  if (!wfAbs) refuse(`re-âncora: wf do workflow "${line.workflow}" não localizado em disco (passe --wf-path) — não se libera LITE sem computar o feature-set`);
+  const wfDoc = parseYaml(fs.readFileSync(wfAbs, 'utf8'));
+  const feat = computeFeatureSet(wfDoc);
+  const uncovered = featureDiff(feat, anchor.features_covered);
+  if (uncovered.length) {
+    reanchor(`RE-ÂNCORA OBRIGATÓRIA (feature-diff) — "${line.workflow}" exercita feature(s) fora de features_covered: ${uncovered.join(', ')}. ` +
+      `Rode este workflow em G5-FULL (não LITE) e atualize features_covered via set-anchor.`);
+  }
+  if (anchor.motor && anchor.motor.files) {
+    const nowHash = computeMotorHash(anchor.motor.files, baseDir);
+    if (nowHash !== anchor.motor.hash) {
+      if (opts.approvedBy) {
+        line.motor_approval = { approved_by: opts.approvedBy, prev_hash: anchor.motor.hash, now_hash: nowHash, at: opts.now || new Date().toISOString() };
+      } else {
+        reanchor(`RE-ÂNCORA OBRIGATÓRIA (motor mudou) — motor_hash atual (${nowHash.slice(0, 12)}…) ≠ pinado (${String(anchor.motor.hash).slice(0, 12)}…). ` +
+          `Qualquer diff recusa LITE: (a) re-âncora de motor (1 FULL, set-anchor) OU (b) --approved-by "<humano>: <justificativa>".`);
+      }
+    }
+  }
+  return { skipped: false, feature_set: feat };
+}
+
+/**
+ * RE-EXECUTA o sweep de injeção (nunca relê o report — A.1.3). Determinístico, ~zero
+ * custo. Só roda se houver cenário sidecar `<wf>.smoke.json` (linha de migração real);
+ * linhas sem cenário (fixtures de contrato SF3.1) são no-op. Report adulterado em disco
+ * NÃO muda o veredito porque o sweep é re-executado, não lido.
+ */
+function reExecuteSweep(line, opts, baseDir) {
+  const wfAbs = resolveWfPath(line, opts, baseDir);
+  if (!wfAbs) return { ran: false };
+  const scenarioPath = wfAbs.replace(/\.ya?ml$/, '.smoke.json');
+  if (!fs.existsSync(scenarioPath)) return { ran: false };
+  const smoke = require('./smoke-pod-workflow.cjs');
+  const scenario = JSON.parse(fs.readFileSync(scenarioPath, 'utf8'));
+  const podRoot = line.pod_dir ? (path.isAbsolute(line.pod_dir) ? line.pod_dir : path.resolve(baseDir, line.pod_dir)) : path.dirname(path.dirname(wfAbs));
+  const specPath = line.spec_path ? (path.isAbsolute(line.spec_path) ? line.spec_path : path.resolve(baseDir, line.spec_path)) : null;
+  const sweep = smoke.runSweep({ workflowPath: wfAbs, podRoot, scenario, specPath });
+  const failures = [];
+  if (sweep.underivable) failures.push(`sweep underivável: ${sweep.underivable.reason}`);
+  else if (!sweep.ok) failures.push(`sweep vazou (blocked:false): ${(sweep.leaked || []).map((l) => `${l.step}/${l.assertion}`).join(', ')}`);
+  // Binding spec_hash (fecha o forward-compat da SF3.1): o report re-executado embute
+  // spec_hash; ele DEVE conferir com o spec_hash da linha.
+  if (!failures.length && line.spec_hash && sweep.report.spec_hash !== line.spec_hash) {
+    failures.push(`sweep spec_hash divergente: report=${sweep.report.spec_hash.slice(0, 12)}… linha=${String(line.spec_hash).slice(0, 12)}…`);
+  }
+  return { ran: true, ok: failures.length === 0, failures, proofs: sweep.report.proofs.length };
+}
+
+// ---------------------------------------------------------------------------
+// SUBCOMANDOS.
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// F0 — INVENTÁRIO determinístico (Decisão B.4/B.5; fecha G5). Scan RECURSIVO do
+// squad INTEIRO (readdir recursivo via snapshotTree, NÃO lista fixa de dirs):
+// classifica cada arquivo numa FAMÍLIA por seu diretório de topo; tudo fora das
+// famílias conhecidas é 'loose'. Grep de COMANDOS embutidos (`\*[a-z-]+`) em cada
+// arquivo de agente legado (B.5 — cada comando legado tem de ter endereço). O
+// inventário é DADO do manifest, escrito pelo escritor único (nunca pelo agente).
+// ---------------------------------------------------------------------------
+const FAMILY_DIRS = ['workflows', 'agents', 'tasks', 'checklists', 'data', 'scripts', 'templates', 'sops', 'config'];
+
+function buildInventory(squadDir, now) {
+  const abs = path.resolve(squadDir);
+  if (!fs.existsSync(abs)) refuse(`squad-dir inexistente para inventário F0: ${squadDir}`);
+  const tree = snapshotTree(abs); // recursivo: [{ path, sha256 }]
+  const items = [];
+  const famSet = new Set();
+  for (const e of tree) {
+    const top = e.path.split(/[\\/]/)[0];
+    const family = FAMILY_DIRS.includes(top) && e.path.includes('/') ? top : 'loose';
+    items.push({ family, path: e.path });
+    famSet.add(family);
+  }
+  // Grep de comandos embutidos nos agentes legados (B.5): padrão `*comando`.
+  const commands = [];
+  for (const it of items) {
+    if (it.family !== 'agents') continue;
+    const content = fs.readFileSync(path.join(abs, it.path), 'utf8');
+    const found = new Set();
+    for (const m of content.matchAll(/(?:^|\s|`)(\*[a-z][a-z-]*)\b/g)) found.add(m[1]);
+    for (const c of [...found].sort()) commands.push({ agent: it.path, command: c });
+  }
+  return {
+    scanned_from: squadDir,
+    scanned_at: now || new Date().toISOString(),
+    families: [...famSet].sort(),
+    items,
+    commands,
+  };
+}
+
+function cmdInit(mfPath, opts) {
+  if (!opts.squad) usage("init exige --squad <nome>");
+  // F0 OBRIGATÓRIO (fix do finding GRAVE do QA sf3.3): --squad-dir é exigido para
+  // que o inventário SEMPRE nasça — `inventory` NUNCA é null. Sem ele não há como
+  // criar o "caminho dormente" que o QA explorou (init sem inventário → gate F1
+  // adormecido). Todo manifest de migração nasce inventariado. Exit 2 (contrato).
+  if (!opts.squadDir) refuse('init exige --squad-dir <dir> — todo manifest de migração nasce inventariado (F0); sem inventário não há gate F1 dormente.');
+  if (fs.existsSync(mfPath)) refuse(`manifest já existe: ${rel(mfPath)} (init não sobrescreve)`);
+  const doc = { squad: opts.squad, created_at: opts.now || new Date().toISOString(), triage: [], lines: [] };
+  doc.inventory = buildInventory(opts.squadDir, opts.now);
+  writeManifest(mfPath, doc);
+  return {
+    action: 'init',
+    squad: opts.squad,
+    path: mfPath,
+    inventory: { families: doc.inventory.families, items: doc.inventory.items.length, commands: doc.inventory.commands.length },
+  };
+}
+
+function cmdTriageSet(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('triage-set exige --workflow <id>');
+  // Colunas de evidência OBRIGATÓRIAS (A.2/M5): sem elas o helper RECUSA.
+  if (!opts.disposition || !TRIAGE_DISPOSITIONS.has(opts.disposition)) {
+    refuse(`triage-set exige --disposition ∈ {${[...TRIAGE_DISPOSITIONS].join(',')}}`);
+  }
+  if (!opts.purpose) refuse('triage-set exige --purpose <citação path:linha> (propósito com evidência)');
+  if (!opts.basis || !TRIAGE_BASES.has(opts.basis)) {
+    refuse(`triage-set exige --basis ∈ {${[...TRIAGE_BASES].join(',')}} (dado citado vs julgamento explícito)`);
+  }
+  const entry = {
+    workflow: opts.workflow,
+    disposition: opts.disposition,
+    purpose: opts.purpose,
+    overlap: opts.overlap || '',
+    basis: opts.basis,
+    set_at: opts.now || new Date().toISOString(),
+  };
+  const i = doc.triage.findIndex((t) => t.workflow === opts.workflow);
+  // Reclassificar preserva a proveniência mínima, mas ZERA aprovação/comando
+  // (mudar de disposição é decisão nova — não herda um "aprovado" antigo).
+  if (i >= 0) doc.triage[i] = entry; else doc.triage.push(entry);
+  writeManifest(mfPath, doc);
+  return { action: 'triage-set', workflow: opts.workflow, disposition: opts.disposition };
+}
+
+// F1 — aprovação humana da triagem (regra 5 do ledger; fecha M5/AC2). SÓ o Daniel
+// aprova; sem esta marca o open-line RECUSA num manifest de migração. Escritor
+// único: a aprovação é DADO do manifest, gravada por este subcomando.
+function cmdTriageApprove(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('triage-approve exige --workflow <id>');
+  if (!opts.approvedBy) refuse('triage-approve exige --approved-by <nome> (aprovação humana registrada — regra 5)');
+  const t = doc.triage.find((x) => x.workflow === opts.workflow);
+  if (!t) refuse(`triage-approve: não há triagem para "${opts.workflow}" — rode triage-set primeiro`);
+  t.approved_by = opts.approvedBy;
+  t.approved_at = opts.now || new Date().toISOString();
+  writeManifest(mfPath, doc);
+  return { action: 'triage-approve', workflow: opts.workflow, disposition: t.disposition, approved_by: t.approved_by };
+}
+
+// VIRAR-COMANDO — regra de fechamento (fecha G6-comando/AC9). A linha de disposição
+// 'command' fica `pendente-comando` e SÓ fecha com os TRÊS, conferidos por CÓDIGO:
+// (a) path do comando em disco; (b) smoke próprio registrado (arquivo de output
+// conferível e não-vazio — regra 1 do ledger, teste real); (c) approved_by. Sem os
+// três, a ÚNICA saída é reclassificar como `dispensar` (triage-set --disposition
+// dispense). "comando" nunca é dispensa com outro nome.
+function cmdCommandClose(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('command-close exige --workflow <id>');
+  const t = doc.triage.find((x) => x.workflow === opts.workflow);
+  if (!t) refuse(`command-close: não há triagem para "${opts.workflow}"`);
+  if (t.disposition !== 'command') refuse(`command-close só aplica a disposição 'command' (atual: '${t.disposition}')`);
+  const missing = [];
+  if (!opts.commandPath) missing.push('--command-path <path do comando em disco>');
+  else if (!fs.existsSync(path.resolve(opts.commandPath))) missing.push(`comando não existe em disco: ${opts.commandPath}`);
+  if (!opts.smoke) missing.push('--smoke <path do output do smoke próprio>');
+  else {
+    const sAbs = path.resolve(opts.smoke);
+    if (!fs.existsSync(sAbs)) missing.push(`smoke próprio não registrado (arquivo inexistente): ${opts.smoke}`);
+    else if (fs.statSync(sAbs).size === 0) missing.push(`smoke próprio vazio (sem output conferível): ${opts.smoke}`);
+  }
+  if (!opts.approvedBy) missing.push('--approved-by <nome> (aprovação do Daniel)');
+  if (missing.length) {
+    refuse(`VIRAR-COMANDO de "${opts.workflow}" permanece pendente-comando — faltam: ${missing.join('; ')}. ` +
+      `Única saída sem os três: reclassificar com triage-set --disposition dispense (regra 5).`);
+  }
+  t.command_status = 'closed';
+  t.command_path = opts.commandPath;
+  t.command_smoke = opts.smoke;
+  // FIX ADR-006 §Consequências (SF5.5): a aprovação do close vai para um campo PRÓPRIO
+  // (`close_approved_by`), NUNCA `t.approved_by = t.approved_by || opts.approvedBy` — esse
+  // `||` deixava a aprovação da F1 (2026-07-24) persistir NO LUGAR da confirmação fresca
+  // da regra 5 exigida no ATO do close. Agora as duas aprovações ficam separadas na trilha:
+  // `approved_by` (F1, disposição) e `close_approved_by` (regra 5, fechamento).
+  t.close_approved_by = opts.approvedBy;
+  t.command_closed_at = opts.now || new Date().toISOString();
+  writeManifest(mfPath, doc);
+  return { action: 'command-close', workflow: opts.workflow, command_status: 'closed', command_path: opts.commandPath };
+}
+
+// DISPENSAR — fechamento AUDITÁVEL da disposição 'dispense' (ADR-006 §Consequências, SF5.5;
+// mesma classe do episódio reopen-line: dispensa era beco sem fechamento re-verificável — o
+// DISPATCH não tinha subcomando dedicado). A dispensa é ADJUDICAÇÃO, não ausência de trabalho:
+// fecha SÓ com (a) triagem 'dispense' aprovada na F1 (regra 5), (b) aprovação FRESCA do close
+// em campo PRÓPRIO (`dispense_close_approved_by`, NUNCA `||` — mesma lição do command-close:544)
+// e (c) `--evidence-ref` (a cobertura que fundamenta a dispensa, path[:linha] existente em disco
+// NO ATO). `verify` re-checa que essa evidência ainda existe — cobertura que sumiu → stale
+// ruidoso, re-adjudicar. Espelha a tese: nenhuma disposição fecha por ausência de mecanismo.
+function cmdDispenseClose(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('dispense-close exige --workflow <id>');
+  const t = doc.triage.find((x) => x.workflow === opts.workflow);
+  if (!t) refuse(`dispense-close: não há triagem para "${opts.workflow}"`);
+  if (t.disposition !== 'dispense') refuse(`dispense-close só aplica a disposição 'dispense' (atual: '${t.disposition}')`);
+  if (!t.approved_by) refuse(`dispense-close: triagem 'dispense' de "${opts.workflow}" sem approved_by — rode triage-approve (F1, regra 5) antes de fechar a dispensa.`);
+  const missing = [];
+  if (!opts.approvedBy) missing.push('--approved-by <nome> (confirmação FRESCA da regra 5 no ato do close)');
+  if (!opts.evidenceRef) missing.push('--evidence-ref <path[:linha]> (a cobertura que fundamenta a dispensa)');
+  else if (!fs.existsSync(path.resolve(String(opts.evidenceRef).split(':')[0]))) {
+    missing.push(`evidência de cobertura inexistente em disco: ${opts.evidenceRef} (a dispensa exige um substituto REAL)`);
+  }
+  if (missing.length) {
+    refuse(`DISPENSA de "${opts.workflow}" permanece pendente — faltam: ${missing.join('; ')}.`);
+  }
+  t.dispense_status = 'closed';
+  // Campo PRÓPRIO (nunca `||`): a confirmação do close não herda nem é herdada pela F1.
+  t.dispense_close_approved_by = opts.approvedBy;
+  t.dispense_evidence_ref = opts.evidenceRef;
+  t.dispense_closed_at = opts.now || new Date().toISOString();
+  writeManifest(mfPath, doc);
+  return { action: 'dispense-close', workflow: opts.workflow, dispense_status: 'closed', evidence_ref: opts.evidenceRef };
+}
+
+// F1 STOP (Decisão A.2; fecha M5/AC2; ENDURECIDO pós-QA sf3.3): o loop F2 NÃO
+// abre linha sem a triagem do workflow ter sido APROVADA pelo Daniel (regra 5 do
+// ledger). A garantia é INCONDICIONAL — não há caminho dormente. O finding GRAVE
+// do QA foi um proxy leaky: a versão anterior condicionava o gate à presença de
+// `inventory`, e um `init` sem `--squad-dir` produzia `inventory:null` → gate
+// adormecido → open-line sem aprovação. Agora: (1) init exige --squad-dir
+// (inventory nunca null); (2) ESTE gate roda SEMPRE, mesmo que `inventory` esteja
+// ausente/null — sem triagem `migrate` aprovada, open-line RECUSA. Nenhuma flag
+// desliga a parada. Os unit tests SF3.1/3.2 usam triagem aprovada SINTÉTICA nos
+// fixtures (nunca gate dormente).
+function assertF1Approved(doc, workflow) {
+  const t = doc.triage.find((x) => x.workflow === workflow);
+  if (!t) refuse(`F1 não executada para "${workflow}": rode triage-set + triage-approve antes de open-line (PARA no Daniel, regra 5).`);
+  if (t.disposition !== 'migrate') refuse(`triagem de "${workflow}" é '${t.disposition}', não 'migrate' — só workflows aprovados para migração abrem linha F2.`);
+  if (!t.approved_by) refuse(`F1 não aprovada para "${workflow}": disposição 'migrate' sem approved_by — rode triage-approve --workflow ${workflow} --approved-by <daniel> (PARA no Daniel).`);
+}
+
+function cmdOpenLine(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('open-line exige --workflow <id>');
+  if (!opts.spec) refuse('open-line exige --spec <specPath>');
+  if (!opts.podDir) refuse('open-line exige --pod-dir <dir>');
+  assertF1Approved(doc, opts.workflow);
+  const specAbs = path.resolve(opts.spec);
+  if (!fs.existsSync(specAbs)) refuse(`spec inexistente: ${opts.spec}`);
+  const specHash = sha256File(specAbs);
+  const owns = (opts.owns || []).map((p) => p.trim()).filter(Boolean);
+
+  const existing = findLine(doc, opts.workflow);
+  if (existing) {
+    // RETOMADA IDEMPOTENTE (fecha G4): mesmo spec_hash + linha não fechada → prossegue
+    // da fase registrada; spec_hash diferente → exige --amend; linha fechada → recusa.
+    if (existing.phase === 'closed') refuse(`linha "${opts.workflow}" já está closed — reabertura só via 'reopen-line --reason reanchor' (decisão de re-âncora registrada, histórico preservado em superseded[])`);
+    if (existing.spec_hash === specHash) {
+      return { action: 'open-line', workflow: opts.workflow, resumed: true, phase: existing.phase };
+    }
+    if (!opts.amend) {
+      refuse(`spec_hash divergente para a linha aberta "${opts.workflow}" ` +
+        `(linha=${existing.spec_hash.slice(0, 12)}… nova=${specHash.slice(0, 12)}…). ` +
+        `Use --amend para reabrir da fase 'spec' e regenerar owns[].`);
+    }
+    // --amend: reabre da fase 'spec' e regenera owns/baseline com a spec nova.
+  }
+
+  // Unicidade de namespace POD-WIDE: owns[] não pode colidir com owns[] de OUTRA linha aberta.
+  for (const other of doc.lines) {
+    if (other.workflow === opts.workflow) continue;
+    if (other.phase === 'closed') continue;
+    const clash = (other.owns || []).filter((p) => owns.includes(p));
+    if (clash.length) {
+      refuse(`colisão de namespace: owns[] {${clash.join(', ')}} já reservado pela linha aberta "${other.workflow}"`);
+    }
+  }
+
+  const podDirAbs = path.resolve(opts.podDir);
+  const line = {
+    workflow: opts.workflow,
+    pod: opts.pod || path.basename(podDirAbs),
+    pod_dir: opts.podDir,
+    phase: 'spec',
+    spec_path: opts.spec,
+    spec_hash: specHash,
+    owns,
+    baseline: snapshotTree(podDirAbs),
+    opened_at: opts.now || new Date().toISOString(),
+    run_ids: [],
+    verify: [],
+  };
+  const i = doc.lines.findIndex((l) => l.workflow === opts.workflow);
+  if (i >= 0) doc.lines[i] = line; else doc.lines.push(line);
+  writeManifest(mfPath, doc);
+  return { action: 'open-line', workflow: opts.workflow, phase: 'spec', spec_hash: specHash, owns: owns.length, baseline: line.baseline.length };
+}
+
+/**
+ * advance — avança a fase da linha (spec→generated→distilled→linted→gates), um passo
+ * por vez, monotônico. 'closed' é exclusivo do close-line.
+ *
+ * CONTRATO ESTÁVEL PARA SF3.2 (Risco 1 da story): o retorno inclui `hook`. Ao avançar
+ * PARA 'gates', hook='pre-gates-check' — este é o ponto EXATO onde SF3.2 insere a
+ * decisão LITE vs FULL (feature-diff → exit 4 ANTES de pagar as runs) e o check de
+ * motor_hash, SEM alterar a assinatura pública de advance (só o corpo do hook).
+ */
+function cmdAdvance(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('advance exige --workflow <id>');
+  if (!opts.to) usage(`advance exige --to <${PHASES.slice(1, -1).join('|')}>`);
+  const line = findLine(doc, opts.workflow);
+  if (!line) refuse(`linha inexistente: "${opts.workflow}" — rode open-line primeiro`);
+  if (line.phase === 'closed') refuse(`linha "${opts.workflow}" está closed — imutável`);
+  const from = phaseIndex(line.phase);
+  const to = phaseIndex(opts.to);
+  if (opts.to === 'closed') refuse("advance não fecha a linha — use close-line (exige binding/re-execução)");
+  if (to <= from) refuse(`avanço não-monotônico: de '${line.phase}' para '${opts.to}' (fase atual ≥ pedida)`);
+  if (to !== from + 1) refuse(`avanço fora de ordem: de '${line.phase}' só se avança para '${PHASES[from + 1]}', não '${opts.to}'`);
+  const hook = opts.to === 'gates' ? 'pre-gates-check' : null;
+  // HOOK pre-gates-check (SF3.2, D.G2/M-r2-1): a decisão LITE vs FULL roda AQUI, ANTES
+  // de pagar as ~570k tokens das runs. feature-diff → exit 4; motor mudou → exit 4
+  // (salvo --approved-by). Sem âncora gravada, é no-op (compat SF3.1).
+  let gate = null;
+  if (hook === 'pre-gates-check') {
+    gate = checkReanchorGate(doc, line, opts, process.cwd());
+    if (gate && gate.feature_set) line.feature_set = gate.feature_set;
+  }
+  line.phase = opts.to;
+  line.advanced_at = opts.now || new Date().toISOString();
+  writeManifest(mfPath, doc);
+  return { action: 'advance', workflow: opts.workflow, from: PHASES[from], to: opts.to, hook };
+}
+
+/**
+ * reopen-line — RE-ADJUDICAÇÃO de uma linha `closed` (ADR-006 §Consequências, gap SF3.4).
+ * Linha fechada era beco sem saída: `open-line` recusa reopen, `advance` recusa closed, e
+ * o `verify` não via drift de feature-set em linha fechada. Reabertura SÓ sob re-âncora,
+ * com justificativa+aprovação REGISTRADAS. A adjudicação anterior NUNCA é apagada — vai
+ * para `superseded[]` (trilha de auditoria). A linha volta à fase pré-gates ('linted') para
+ * o próximo `advance` re-rodar o `pre-gates-check` (feature drift → exit 4 → FULL).
+ * Preserva a identidade da linha (spec_hash/owns/baseline); limpa só a adjudicação viva.
+ */
+function cmdReopenLine(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('reopen-line exige --workflow <id>');
+  const line = findLine(doc, opts.workflow);
+  if (!line) refuse(`linha inexistente: "${opts.workflow}"`);
+  if (line.phase !== 'closed') refuse(`reopen-line exige a linha 'closed' (está em '${line.phase}') — só se re-adjudica o que já foi fechado`);
+  // reanchor é o ÚNICO reason válido; os 4 flags são OBRIGATÓRIOS (decisão rastreável).
+  if (opts.reason !== 'reanchor') refuse("reopen-line exige --reason reanchor (único motivo válido — reabertura é decisão de re-âncora)");
+  if (!opts.feature) refuse('reopen-line exige --feature <feat> (o feature descoberto que obsoleta a adjudicação LITE)');
+  if (!opts.approvedBy) refuse('reopen-line exige --approved-by "<quem>: <justificativa>"');
+  if (!opts.decisionRef) refuse('reopen-line exige --decision-ref <path> (referência à decisão de re-âncora registrada)');
+
+  // SNAPSHOT da adjudicação atual → superseded[] (append; nunca apaga).
+  const ADJUDICATION_FIELDS = ['wf_path', 'run_ids', 'pair', 'closed_at', 'verify', 'feature_set', 'sweep', 'motor_approval', 'advanced_at', 'stale', 'stale_at'];
+  const snapshot = {};
+  for (const f of ADJUDICATION_FIELDS) if (f in line) snapshot[f] = line[f];
+  line.superseded = Array.isArray(line.superseded) ? line.superseded : [];
+  line.superseded.push({
+    superseded_at: opts.now || new Date().toISOString(),
+    reason: opts.reason,
+    feature: opts.feature,
+    approved_by: opts.approvedBy,
+    decision_ref: opts.decisionRef,
+    snapshot,
+  });
+  // Limpa a adjudicação da linha VIVA, preservando identidade (spec_hash/owns/baseline/pod).
+  for (const f of ADJUDICATION_FIELDS) delete line[f];
+  line.run_ids = [];
+  line.verify = [];
+  line.phase = 'linted'; // próximo advance→gates re-roda o pre-gates-check → exit 4 → FULL.
+  line.reopened_at = opts.now || new Date().toISOString();
+  writeManifest(mfPath, doc);
+  return { action: 'reopen-line', workflow: opts.workflow, phase: 'linted', superseded: line.superseded.length };
+}
+
+function cmdCloseLine(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('close-line exige --workflow <id>');
+  const line = findLine(doc, opts.workflow);
+  if (!line) refuse(`linha inexistente: "${opts.workflow}"`);
+  if (line.phase === 'closed') refuse(`linha "${opts.workflow}" já está closed`);
+  if (line.phase !== 'gates') refuse(`close-line exige a linha em 'gates' (está em '${line.phase}') — avance pelos gates primeiro`);
+
+  // Anexa a evidência declarada pelo orquestrador ANTES de verificar por código.
+  if (opts.wfPath) line.wf_path = opts.wfPath;
+  if (opts.runIds && opts.runIds.length) line.run_ids = opts.runIds;
+  if (opts.pair) line.pair = opts.pair;
+  // verify[] é CACHE DE AUDITORIA — registrado, NUNCA executado como fonte (G-r2-1.1).
+  if (opts.verifyNote) {
+    line.verify = Array.isArray(line.verify) ? line.verify : [];
+    line.verify.push({ note: opts.verifyNote, at: opts.now || new Date().toISOString() });
+  }
+
+  // RAIZ DE CONFIANÇA EM CÓDIGO: deriva e aplica os checks aos campos de evidência.
+  const res = verifyLineEvidence(line, { baseDir: process.cwd() });
+  if (!res.ok) {
+    refuse(`close-line RECUSA "${opts.workflow}" — evidência não verifica por código:\n` +
+      res.failures.map((f) => `  - ${f}`).join('\n'));
+  }
+
+  // BACKSTOP de re-âncora (D.G2): nunca fecha LITE com feature descoberto/motor mudado.
+  checkReanchorGate(doc, line, opts, process.cwd());
+
+  // RE-EXECUTA o sweep (A.1.3) — nunca relê o report. Report adulterado em disco não
+  // muda o veredito. Só roda para linha de migração com cenário sidecar.
+  const sw = reExecuteSweep(line, opts, process.cwd());
+  if (sw.ran && !sw.ok) {
+    refuse(`close-line RECUSA "${opts.workflow}" — sweep re-executado FALHOU:\n` +
+      sw.failures.map((f) => `  - ${f}`).join('\n'));
+  }
+  if (sw.ran) line.sweep = { proofs: sw.proofs, reexec_at: opts.now || new Date().toISOString() };
+
+  line.phase = 'closed';
+  line.closed_at = opts.now || new Date().toISOString();
+  writeManifest(mfPath, doc);
+  return { action: 'close-line', workflow: opts.workflow, phase: 'closed' };
+}
+
+/**
+ * set-anchor — grava a decisão de RE-ÂNCORA registrada (M-r2-4): features_covered +
+ * motor pinado (motor_files[] + motor_hash). É o ÚNICO ponto que escreve `motor_files[]`
+ * — alterar a lista fora desta decisão é impossível (só o escritor único grava; hand-edit
+ * do YAML cai no integrity → exit 3). Exige --decision (justificativa da re-âncora).
+ */
+function cmdSetAnchor(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.decision) refuse('set-anchor exige --decision "<justificativa da re-âncora>" (M-r2-4: a lista de motor só muda em decisão registrada)');
+  const baseDir = process.cwd();
+
+  let covered = {
+    assertion_types: [...(opts.assertionTypes || [])],
+    dag_shapes: [...(opts.dagShapes || [])],
+    checkpoint_positions: [...(opts.checkpointPositions || [])],
+    fix_loop: opts.fixLoopCovered === true,
+  };
+  // --from-wf: semeia features_covered com o feature-set de um wf real (a âncora paga).
+  if (opts.fromWf) {
+    const wfAbs = path.resolve(opts.fromWf);
+    if (!fs.existsSync(wfAbs)) refuse(`set-anchor --from-wf inexistente: ${opts.fromWf}`);
+    const feat = computeFeatureSet(parseYaml(fs.readFileSync(wfAbs, 'utf8')));
+    covered.assertion_types = [...new Set([...covered.assertion_types, ...feat.assertion_types])].sort();
+    covered.dag_shapes = [...new Set([...covered.dag_shapes, feat.dag_shape])].sort();
+    covered.checkpoint_positions = [...new Set([...covered.checkpoint_positions, ...feat.checkpoint_positions])].sort();
+    covered.fix_loop = covered.fix_loop || feat.fix_loop;
+  } else {
+    covered.assertion_types.sort(); covered.dag_shapes.sort(); covered.checkpoint_positions.sort();
+  }
+
+  const motorFiles = (opts.motorFiles && opts.motorFiles.length) ? opts.motorFiles : DEFAULT_MOTOR_FILES;
+  const motorHash = computeMotorHash(motorFiles, baseDir);
+  doc.anchor = {
+    features_covered: covered,
+    motor: { files: [...motorFiles], hash: motorHash },
+    decision: opts.decision,
+    set_at: opts.now || new Date().toISOString(),
+  };
+  writeManifest(mfPath, doc);
+  return { action: 'set-anchor', motor_hash: motorHash, motor_files: motorFiles.length, features_covered: covered };
+}
+
+/**
+ * waiver-set — registra o waiver de LEGADO INEXECUTÁVEL (M-r2-3). "Não rodei" não é
+ * evidência de "não roda": exige --transcript de uma TENTATIVA REAL (arquivo em disco)
+ * + --approved-by (Daniel) + --declared (artefatos DECLARADOS do workflow legado, contra
+ * os quais a completude passa a ser comparada quando o par não completa).
+ */
+function cmdWaiverSet(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.workflow) usage('waiver-set exige --workflow <id>');
+  const line = findLine(doc, opts.workflow);
+  if (!line) refuse(`linha inexistente: "${opts.workflow}" — rode open-line primeiro`);
+  if (!opts.transcript) refuse('waiver-set exige --transcript <path> (tentativa real registrada — sem tentativa não há waiver)');
+  const trAbs = path.resolve(opts.transcript);
+  if (!fs.existsSync(trAbs)) refuse(`transcript inexistente: ${opts.transcript} — "não rodei" não é evidência de "não roda" (M-r2-3)`);
+  if (!opts.approvedBy) refuse('waiver-set exige --approved-by "<Daniel>: <justificativa>"');
+  const declared = (opts.declared || []).map((s) => s.trim()).filter(Boolean);
+  if (!declared.length) refuse('waiver-set exige ao menos um --declared <artefato> (a completude compara contra os artefatos DECLARADOS do legado)');
+  line.legacy_waiver = {
+    transcript: opts.transcript,
+    partial_artifacts: [...(opts.partial || [])],
+    approved_by: opts.approvedBy,
+    declared_artifacts: declared,
+    at: opts.now || new Date().toISOString(),
+  };
+  writeManifest(mfPath, doc);
+  return { action: 'waiver-set', workflow: opts.workflow, declared: declared.length };
+}
+
+// address-set — endereço AUDITÁVEL de itens NÃO-workflow (ADR-006 §Consequências, SF5.5).
+// O `coverage` só enxergava owns/spec/wf/triagem — os ~184 itens dos baldes B do design
+// (checklists/tasks/data/scripts/templates) não tinham via de endereço e ficavam eternamente
+// "sem endereço". Escritor único, registro `{path|glob, disposition, endereco, decision_ref,
+// evidence}` em `doc.addresses[]`. Disposições:
+//   destilado|veto|script-do-pod → EXIGEM --endereco existente em disco (destino REAL da
+//                                   capacidade; `verify` re-checa que ele ainda existe);
+//   obito                        → o item MORRE: --endereco é PROIBIDO. Óbito em massa por
+//                                   balde aprovado = UMA entrada com --glob (nunca lista solta).
+// `coverage` SUBTRAI o registrado (F3 = coverage vazio por endereços auditáveis). --glob só
+// vale para óbito-por-balde; endereços individuais usam --path.
+const ADDRESS_DISPOSITIONS = new Set(['destilado', 'veto', 'script-do-pod', 'obito']);
+
+function globToRegex(glob) {
+  let re = String(glob).replace(/[.+^${}()|[\]\\]/g, '\\$&');
+  re = re.replace(/\*\*\//g, '').replace(/\*\*/g, ''); // ** = qualquer profundidade
+  re = re.replace(/\*/g, '[^/]*');                                  // *  = dentro do segmento
+  re = re.replace(//g, '.*');
+  return new RegExp(`^${re}$`);
+}
+
+function cmdAddressSet(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (opts.addrPath && opts.glob) refuse('address-set: --path e --glob são mutuamente exclusivos');
+  const target = opts.addrPath || opts.glob;
+  if (!target) usage('address-set exige --path <arquivo> OU --glob <padrão> (óbito-por-balde)');
+  if (!opts.disposition || !ADDRESS_DISPOSITIONS.has(opts.disposition)) {
+    refuse(`address-set exige --disposition ∈ {${[...ADDRESS_DISPOSITIONS].join(',')}}`);
+  }
+  if (opts.glob && opts.disposition !== 'obito') {
+    refuse("address-set: --glob só se aplica a óbito-por-balde (--disposition obito) — destino de destilado/veto/script é individual (--path)");
+  }
+  if (!opts.decisionRef) refuse('address-set exige --decision-ref <path> (a decisão de balde aprovada — TRIAGE Parte B)');
+  if (opts.disposition === 'obito') {
+    if (opts.endereco) refuse('address-set: óbito NÃO tem endereço (o item morre) — --endereco é proibido para obito');
+  } else {
+    if (!opts.endereco) refuse(`address-set: disposição '${opts.disposition}' exige --endereco <path existente> (destino REAL da capacidade)`);
+    if (!fs.existsSync(path.resolve(opts.endereco))) {
+      refuse(`address-set: endereço inexistente em disco: ${opts.endereco} — destilado/veto/script devem apontar a um destino que EXISTE (senão é fabricação).`);
+    }
+  }
+  const entry = {
+    target_path: opts.addrPath || '',
+    target_glob: opts.glob || '',
+    disposition: opts.disposition,
+    endereco: opts.endereco || '',
+    decision_ref: opts.decisionRef,
+    evidence: opts.evidence || '',
+    set_at: opts.now || new Date().toISOString(),
+  };
+  doc.addresses = Array.isArray(doc.addresses) ? doc.addresses : [];
+  const key = opts.glob ? `glob:${opts.glob}` : `path:${opts.addrPath}`;
+  const idx = doc.addresses.findIndex((a) => (a.target_glob ? `glob:${a.target_glob}` : `path:${a.target_path}`) === key);
+  if (idx >= 0) doc.addresses[idx] = entry; else doc.addresses.push(entry);
+  writeManifest(mfPath, doc);
+  return { action: 'address-set', target: key, disposition: opts.disposition };
+}
+
+function cmdCoverage(mfPath, opts) {
+  const doc = readManifest(mfPath);
+  if (!opts.squadDir) usage('coverage exige --squad-dir <dir>');
+  const squadAbs = path.resolve(opts.squadDir);
+  const files = snapshotTree(squadAbs).map((e) => e.path);
+  // Endereço = arquivo citado em owns[]/spec_path/wf_path de alguma linha, OU em triage.
+  const addressed = new Set();
+  for (const l of doc.lines) {
+    for (const p of l.owns || []) addressed.add(path.basename(p));
+    if (l.spec_path) addressed.add(path.basename(l.spec_path));
+    if (l.wf_path) addressed.add(path.basename(l.wf_path));
+  }
+  for (const t of doc.triage) addressed.add(t.workflow);
+  // + itens endereçados por address-set (SF5.5): --path exato (relativo ao squad-dir) e --glob.
+  const addrPaths = new Set();
+  const addrGlobs = [];
+  for (const a of (doc.addresses || [])) {
+    if (a.target_path) addrPaths.add(a.target_path);
+    if (a.target_glob) addrGlobs.push(globToRegex(a.target_glob));
+  }
+  const unaddressed = files.filter((f) => {
+    const base = path.basename(f);
+    if (addressed.has(base)) return false;
+    // um workflow legado wf-<id>.yaml conta como endereçado se há triage do <id>.
+    const wfId = base.replace(/\.ya?ml$/, '');
+    if (addressed.has(wfId)) return false;
+    if (addrPaths.has(f)) return false;
+    if (addrGlobs.some((re) => re.test(f))) return false;
+    return true;
+  });
+  return { action: 'coverage', total: files.length, unaddressed, clean: unaddressed.length === 0 };
+}
+
+function cmdVerify(mfPath) {
+  const doc = readManifest(mfPath);
+  const closed = doc.lines.filter((l) => l.phase === 'closed');
+  const report = [];
+  let staleFound = false;
+  for (const line of closed) {
+    const res = verifyLineEvidence(line, { baseDir: process.cwd() });
+    const failures = [...res.failures];
+    // F3 RE-EXECUTA o sweep (A.1.3) — determinístico, não relê o report.
+    const sw = reExecuteSweep(line, {}, process.cwd());
+    if (sw.ran && !sw.ok) failures.push(...sw.failures.map((f) => `sweep: ${f}`));
+    // F3 pergunta "esta adjudicação vale HOJE?": feature-set do wf ATUAL em disco vs
+    // features_covered ATUAL da âncora vigente (ADR-006 §Consequências, gap SF3.4). Drift
+    // além do coberto → adjudicação LITE obsoleta → stale ruidoso (mesma via existente).
+    // Comparar contra o covered vigente (não o "da época") evita falso pos/neg: âncora
+    // ampliada depois SANA o drift sem reopen; wf driftado além do coberto o expõe.
+    try {
+      checkReanchorGate(doc, line, {}, process.cwd());
+    } catch (e) {
+      if (e instanceof ManifestError && e.exitCode === 4) {
+        failures.push(`feature drift: ${e.message.split(' — ')[0].replace(/^RE-ÂNCORA OBRIGATÓRIA\s*/, '').trim()} — reabra via reopen-line --reason reanchor`);
+      } else if (e instanceof ManifestError) {
+        failures.push(`re-âncora não verificável: ${e.message}`);
+      } else { throw e; }
+    }
+    const okAll = failures.length === 0;
+    report.push({ workflow: line.workflow, ok: okAll, failures });
+    if (!okAll) { line.phase = 'gates'; line.stale = true; line.stale_at = new Date().toISOString(); staleFound = true; }
+  }
+  // Re-checa as DISPENSAS fechadas (ADR-006 §Consequências, SF5.5): a evidência de cobertura
+  // que fundamentou a dispensa ainda existe em disco? Sumiu → stale ruidoso, re-adjudicar.
+  const dispense = [];
+  for (const t of doc.triage) {
+    if (t.dispense_status !== 'closed') continue;
+    const failures = [];
+    const ev = t.dispense_evidence_ref ? String(t.dispense_evidence_ref).split(':')[0] : null;
+    if (!ev) failures.push('dispensa fechada sem dispense_evidence_ref');
+    else if (!fs.existsSync(path.resolve(ev))) failures.push(`evidência de cobertura sumiu do disco: ${t.dispense_evidence_ref} — re-adjudicar`);
+    const okAll = failures.length === 0;
+    dispense.push({ workflow: t.workflow, ok: okAll, failures });
+    if (!okAll) { t.dispense_status = 'stale'; t.dispense_stale_at = new Date().toISOString(); staleFound = true; }
+  }
+  // Re-checa os ENDEREÇOS dos itens endereçados (SF5.5): destilado/veto/script apontam a um
+  // destino REAL. óbito não tem endereço (nada a re-checar). Endereço sumiu → stale ruidoso.
+  const addresses = [];
+  for (const a of (doc.addresses || [])) {
+    if (a.disposition === 'obito') continue;
+    const failures = [];
+    if (!a.endereco) failures.push('endereço ausente');
+    else if (!fs.existsSync(path.resolve(a.endereco))) failures.push(`endereço sumiu do disco: ${a.endereco} — re-adjudicar`);
+    const target = a.target_glob || a.target_path;
+    const okAll = failures.length === 0;
+    addresses.push({ target, ok: okAll, failures });
+    if (!okAll) { a.stale = true; a.stale_at = new Date().toISOString(); staleFound = true; }
+  }
+  // Re-checa as linhas COMMAND fechadas (ADR-006 §Consequências, SF5.5 QA finding): o comando
+  // em disco (command_path) ainda existe E o smoke próprio (command_smoke) existe e é NÃO-VAZIO
+  // — mesmo padrão de re-verificação do evidence-ref da dispensa. Um close de VIRAR-COMANDO cujo
+  // comando/smoke sumiu vira stale ruidoso, nunca silencioso (fail-loud também em exit code).
+  const command = [];
+  for (const t of doc.triage) {
+    if (t.command_status !== 'closed') continue;
+    const failures = [];
+    if (!t.command_path) failures.push('comando fechado sem command_path');
+    else if (!fs.existsSync(path.resolve(t.command_path))) failures.push(`comando sumiu do disco: ${t.command_path} — re-adjudicar`);
+    if (!t.command_smoke) failures.push('comando fechado sem command_smoke');
+    else {
+      const sAbs = path.resolve(t.command_smoke);
+      if (!fs.existsSync(sAbs)) failures.push(`smoke do comando sumiu do disco: ${t.command_smoke} — re-adjudicar`);
+      else if (fs.statSync(sAbs).size === 0) failures.push(`smoke do comando vazio: ${t.command_smoke} — re-adjudicar`);
+    }
+    const okAll = failures.length === 0;
+    command.push({ workflow: t.workflow, ok: okAll, failures });
+    if (!okAll) { t.command_status = 'stale'; t.command_stale_at = new Date().toISOString(); staleFound = true; }
+  }
+  if (staleFound) writeManifest(mfPath, doc);
+  const staleTotal = report.filter((r) => !r.ok).length + dispense.filter((r) => !r.ok).length
+    + addresses.filter((r) => !r.ok).length + command.filter((r) => !r.ok).length;
+  return { action: 'verify', checked: closed.length, stale: report.filter((r) => !r.ok), report, dispense, addresses, command, staleTotal };
+}
+
+// ---------------------------------------------------------------------------
+// CLI.
+// ---------------------------------------------------------------------------
+function parseArgs(argv) {
+  const opts = { owns: [], runIds: [] };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case '--squad': opts.squad = argv[++i]; break;
+      case '--workflow': opts.workflow = argv[++i]; break;
+      case '--disposition': opts.disposition = argv[++i]; break;
+      case '--purpose': opts.purpose = argv[++i]; break;
+      case '--overlap': opts.overlap = argv[++i]; break;
+      case '--basis': opts.basis = argv[++i]; break;
+      case '--spec': opts.spec = argv[++i]; break;
+      case '--pod-dir': opts.podDir = argv[++i]; break;
+      case '--pod': opts.pod = argv[++i]; break;
+      case '--owns': opts.owns.push(...String(argv[++i]).split(',')); break;
+      case '--amend': opts.amend = true; break;
+      case '--to': opts.to = argv[++i]; break;
+      case '--wf-path': opts.wfPath = argv[++i]; break;
+      case '--run-id': opts.runIds.push(argv[++i]); break;
+      case '--pair': opts.pair = argv[++i]; break;
+      case '--verify-note': opts.verifyNote = argv[++i]; break;
+      case '--squad-dir': opts.squadDir = argv[++i]; break;
+      case '--now': opts.now = argv[++i]; break;
+      // SF3.2 — re-âncora / motor / feature-set / waiver
+      case '--decision': opts.decision = argv[++i]; break;
+      case '--from-wf': opts.fromWf = argv[++i]; break;
+      case '--motor-file': (opts.motorFiles = opts.motorFiles || []).push(argv[++i]); break;
+      case '--assertion-type': (opts.assertionTypes = opts.assertionTypes || []).push(argv[++i]); break;
+      case '--dag-shape': (opts.dagShapes = opts.dagShapes || []).push(argv[++i]); break;
+      case '--checkpoint-pos': (opts.checkpointPositions = opts.checkpointPositions || []).push(argv[++i]); break;
+      case '--fix-loop-covered': opts.fixLoopCovered = argv[++i] === 'true'; break;
+      case '--approved-by': opts.approvedBy = argv[++i]; break;
+      case '--command-path': opts.commandPath = argv[++i]; break;
+      case '--smoke': opts.smoke = argv[++i]; break;
+      case '--transcript': opts.transcript = argv[++i]; break;
+      case '--declared': (opts.declared = opts.declared || []).push(argv[++i]); break;
+      case '--partial': (opts.partial = opts.partial || []).push(argv[++i]); break;
+      // SF3.4 (ADR-006 §Consequências) — re-adjudicação de linha closed
+      case '--reason': opts.reason = argv[++i]; break;
+      case '--feature': opts.feature = argv[++i]; break;
+      case '--decision-ref': opts.decisionRef = argv[++i]; break;
+      // SF5.5 (ADR-006 §Consequências) — dispense-close / address-set
+      case '--evidence-ref': opts.evidenceRef = argv[++i]; break;
+      case '--path': opts.addrPath = argv[++i]; break;
+      case '--glob': opts.glob = argv[++i]; break;
+      case '--endereco': opts.endereco = argv[++i]; break;
+      case '--evidence': opts.evidence = argv[++i]; break;
+      default: rest.push(a);
+    }
+  }
+  return { opts, rest };
+}
+
+const DISPATCH = {
+  init: cmdInit,
+  'triage-set': cmdTriageSet,
+  'triage-approve': cmdTriageApprove,
+  'command-close': cmdCommandClose,
+  'dispense-close': cmdDispenseClose,
+  'address-set': cmdAddressSet,
+  'open-line': cmdOpenLine,
+  'reopen-line': cmdReopenLine,
+  advance: cmdAdvance,
+  'close-line': cmdCloseLine,
+  'set-anchor': cmdSetAnchor,
+  'waiver-set': cmdWaiverSet,
+  coverage: cmdCoverage,
+  verify: (mfPath) => cmdVerify(mfPath),
+};
+
+function main() {
+  const [sub, mfPath, ...rest] = process.argv.slice(2);
+  if (!sub || !mfPath || !DISPATCH[sub]) {
+    console.error('Uso: node scripts/migration-manifest.cjs <subcomando> <manifest.yaml> [flags]');
+    console.error(`Subcomandos: ${Object.keys(DISPATCH).join(' · ')}`);
+    process.exit(1);
+  }
+  const { opts } = parseArgs(rest);
+  try {
+    const out = DISPATCH[sub](path.resolve(mfPath), opts);
+    if (sub === 'coverage') {
+      console.log(`coverage: ${out.total} arquivo(s); ${out.unaddressed.length} sem endereço.`);
+      for (const u of out.unaddressed) console.log(`  ! ${u}`);
+      process.exit(out.clean ? 0 : 2);
+    }
+    if (sub === 'verify') {
+      console.log(`verify: ${out.checked} linha(s) fechada(s) + ${out.dispense.length} dispensa(s) + ${out.command.length} comando(s) + ${out.addresses.length} endereço(s) re-verificado(s) por código.`);
+      for (const r of out.report) console.log(`  ${r.ok ? '✓' : '✗'} line:${r.workflow}${r.ok ? '' : ' — ' + r.failures.join('; ')}`);
+      for (const d of out.dispense) console.log(`  ${d.ok ? '✓' : '✗'} dispense:${d.workflow}${d.ok ? '' : ' — ' + d.failures.join('; ')}`);
+      for (const c of out.command) console.log(`  ${c.ok ? '✓' : '✗'} command:${c.workflow}${c.ok ? '' : ' — ' + c.failures.join('; ')}`);
+      for (const a of out.addresses) console.log(`  ${a.ok ? '✓' : '✗'} address:${a.target}${a.ok ? '' : ' — ' + a.failures.join('; ')}`);
+      // FAIL-LOUD (SF5.5 QA): qualquer stale marcado → exit NÃO-ZERO (1). Stale silencioso em
+      // exit code contradiz a tese fail-loud do helper — o verde de exit 0 é reservado a "tudo íntegro".
+      process.exit(out.staleTotal ? 1 : 0);
+    }
+    console.log(JSON.stringify(out));
+    process.exit(0);
+  } catch (e) {
+    console.error(`[migration-manifest:${sub}] ${e.message}`);
+    process.exit(e instanceof ManifestError ? e.exitCode : 1);
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  cmdInit, cmdTriageSet, cmdTriageApprove, cmdCommandClose, cmdDispenseClose, cmdAddressSet,
+  cmdOpenLine, cmdReopenLine, cmdAdvance, cmdCloseLine,
+  cmdSetAnchor, cmdWaiverSet, cmdCoverage, cmdVerify,
+  readManifest, writeManifest, serializeBody, snapshotTree, verifyLineEvidence, buildInventory,
+  computeFeatureSet, featureDiff, computeMotorHash, checkReanchorGate, reExecuteSweep, globToRegex,
+  ManifestError, PHASES, DEFAULT_MOTOR_FILES, FAMILY_DIRS, ADDRESS_DISPOSITIONS,
+};