@polymorphism-tech/morph-spec 9.7.0 → 10.0.0

package/framework/standards/PROVENANCE.json

@@ -1,119 +0,0 @@
-{
-  "version": "1.0.0",
-  "_note": "Standards distilled from an external source. The source is not a dependency at runtime: it lives in another repository and is not needed to use the framework. The same mechanism covers content distilled into a SKILL — an entry declares `standards`, `skills`, or both, and every declared name must resolve. This file exists so drift is detectable instead of silent. Pin `sourceTree` when distilling, and re-pin deliberately after reviewing what changed. See test/framework/standards-provenance.test.js.",
-  "sources": [
-    {
-      "id": "morph-lp-cinematic",
-      "repo": "morph-HUB",
-      "path": "skills/morph-lp-cinematic",
-      "envVar": "MORPH_HUB",
-      "defaultCheckout": "R:/Polymorphism Tech/repos/morph-HUB",
-      "sourceTree": "2987b44241cae479b1aedc63f689cdcd6ef6fb94",
-      "sourceCommit": "c4c9164",
-      "distilledOn": "2026-08-21",
-      "distilledFrom": [
-        "references/build-stack.md",
-        "references/component-recipes.md",
-        "references/premium-finish.md",
-        "references/seo-and-qa.md",
-        "references/image-prompt.md",
-        "references/seedance-scrub-prompt.md",
-        "references/seedance-loop-prompt.md"
-      ],
-      "notDistilled": [
-        "references/last-mile.md",
-        "references/copy-and-messaging.md",
-        "references/section-blueprint.md"
-      ],
-      "notDistilledReason": "Deliberate split: a standard carries knowledge, a skill carries process. Deploy and copy strategy stay with the skill. `references/gates.md` LEFT this list on 2026-09-09: the reason that kept it out was \"a skill carries process\", and the destination is now a skill — see the \"cinematic-lp\" source below, which distils it into morph-media. Review of 2026-09-29 (source c4c9164): only tool-independent facts were ported (the scrub_frames manifest contract for frame-scrub, chained clips for ai-video-generation); the rest was already in the standards or stays with the skill (ffmpeg-to-media_tool swaps, model prices, SKILL.md, gates.md, assets/).",
-      "standards": [
-        "frontend-scroll-driven-frame-scrub",
-        "frontend-scroll-driven-smooth-scroll",
-        "frontend-scroll-driven-scroll-components",
-        "frontend-design-system-premium-finish",
-        "frontend-design-system-ai-image-generation",
-        "frontend-design-system-ai-video-generation",
-        "frontend-seo-meta-schema-audit"
-      ],
-      "skills": []
-    },
-    {
-      "id": "morph-image",
-      "repo": "morph-HUB",
-      "path": "skills/morph-image",
-      "envVar": "MORPH_HUB",
-      "defaultCheckout": "R:/Polymorphism Tech/repos/morph-HUB",
-      "sourceTree": "e55dcf307278583120601c3c5d55118302335f7b",
-      "sourceCommit": "c4c9164",
-      "distilledOn": "2026-09-09",
-      "distilledFrom": [
-        "SKILL.md"
-      ],
-      "notDistilled": [
-        "skill.json",
-        "evals/"
-      ],
-      "notDistilledReason": "Manifest and eval fixtures of the source skill: packaging of the origin, not knowledge. The MCP tool names of the source were also NOT carried over — morph-media is about the authoring decisions, and a tool table pinned to one MCP server would rot on its own.",
-      "standards": [],
-      "skills": [
-        "morph-media"
-      ]
-    },
-    {
-      "id": "cinematic-lp",
-      "repo": "morph-HUB",
-      "path": "skills/cinematic-lp/references",
-      "envVar": "MORPH_HUB",
-      "defaultCheckout": "R:/Polymorphism Tech/repos/morph-HUB",
-      "sourceTree": "3c557425d649ed477bf6645b9297b6d1d72ae4a3",
-      "sourceCommit": "c4c9164",
-      "distilledOn": "2026-09-09",
-      "distilledFrom": [
-        "gates.md"
-      ],
-      "notDistilled": [
-        "build-stack.md",
-        "component-recipes.md",
-        "copy-and-messaging.md",
-        "image-prompt.md",
-        "last-mile.md",
-        "mcp-setup.md",
-        "premium-finish.md",
-        "section-blueprint.md",
-        "seo-and-qa.md",
-        "video-loop-examples.md",
-        "video-loop-prompt.md",
-        "video-scrub-prompt.md"
-      ],
-      "notDistilledReason": "Only the HITL gate mechanics were distilled: the N-option picker, \"rejection goes back to the same step\", and \"show MOVEMENT, never a still\". The rest is either already a standard (the frame-scrub / smooth-scroll / premium-finish family, from the morph-lp-cinematic source above) or build/deploy strategy that belongs to the calling workflow. Review of 2026-09-29 (source c4c9164): gates.md did not change; the changes were in image-prompt.md and mcp-setup.md, both not distilled. Re-pinned only.",
-      "standards": [],
-      "skills": [
-        "morph-media"
-      ]
-    },
-    {
-      "id": "brand-design",
-      "repo": "morph-HUB",
-      "path": "skills/brand-design/references",
-      "envVar": "MORPH_HUB",
-      "defaultCheckout": "R:/Polymorphism Tech/repos/morph-HUB",
-      "sourceTree": "7b637a08e931d8b7ba5be7fc75b851d89cd6e6f4",
-      "sourceCommit": "c4c9164",
-      "distilledOn": "2026-09-09",
-      "distilledFrom": [
-        "image-generation.md"
-      ],
-      "notDistilled": [
-        "brand-book.md",
-        "checklist.md",
-        "example-identidade-visual.md",
-        "phases.md"
-      ],
-      "notDistilledReason": "Only the image-per-phase map and the \"concept, never the final vector\" rule were distilled. The narrative prompt recipes were NOT copied verbatim: they are bound to one brand pipeline, and morph-media carries the prompt STRUCTURE instead, which survives the model changing. Brand book, checklist and phases are the process of another skill. Review of 2026-09-29 (source c4c9164): the image-per-phase table and the \"concept, never the final vector\" rule are unchanged (the text now says \"image model\" instead of Gemini); what was added is morph-assets call mechanics (project_set, @brand, outputPath, models, variants, dryRun), tool-bound and kept out on purpose. Re-pinned only.",
-      "standards": [],
-      "skills": [
-        "morph-media"
-      ]
-    }
-  ]
-}

package/src/commands/project/worktree-reap.js

@@ -1,34 +0,0 @@
-import chalk from 'chalk';
-import { reapAgentWorktrees } from '../../lib/worktree/agent-reaper.js';
-
-const label = (item) => item.path ?? item.branch ?? item.hex;
-
-function printReport(out) {
-  const mode = out.dryRun ? ' (simulação)' : '';
-  console.log(chalk.bold(`\nWorktrees de sub-agent${mode} — graça de ${out.graceMinutes} min\n`));
-  if (out.busy) console.log(chalk.yellow('  ⏳ outro reaper está em execução; nada foi feito\n'));
-
-  for (const item of out.wouldReap ?? []) console.log(chalk.cyan(`  → removeria: ${label(item)}`));
-  for (const item of out.reaped) console.log(chalk.green(`  ✓ removido: ${label(item)}${item.backup ? chalk.gray(` (backup: ${item.backup})`) : ''}`));
-  for (const item of out.preserved) {
-    console.log(chalk.yellow(`  ⚠ preservado: ${label(item)} — ${item.reason}${item.detail ? `: ${item.detail}` : ''}`));
-  }
-  if (out.active) console.log(chalk.gray(`  ${out.active} agente(s) ainda ativo(s), intocado(s)`));
-  const nothing = !out.reaped.length && !out.preserved.length && !out.active && !(out.wouldReap ?? []).length;
-  if (nothing && !out.busy) console.log(chalk.green('  ✓ nenhuma worktree de sub-agent sobrando'));
-  console.log();
-}
-
-export async function worktreeReapCommand(options = {}) {
-  const grace = options.grace === undefined ? undefined : Number(options.grace);
-  if (grace !== undefined && !(Number.isFinite(grace) && grace >= 0)) {
-    console.error(chalk.red(`--grace precisa ser um número de minutos >= 0 (recebi "${options.grace}")`));
-    process.exit(2);
-  }
-
-  const out = await reapAgentWorktrees(options.cwd || process.cwd(), { dryRun: options.dryRun === true, graceMinutes: grace });
-  if (options.json) console.log(JSON.stringify(out));
-  else if (out.ok) printReport(out);
-  else console.log(chalk.gray(`  fora de um repositório git — nada a fazer (${out.error})`));
-  return out;
-}

package/src/commands/state/handoff.js

@@ -1,65 +0,0 @@
-import chalk from 'chalk';
-import { buildHandoff, writeHandoff } from '../../lib/generators/handoff-generator.js';
-import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
-
-// With a live worktree the root copy is a stale birth skeleton: build and write in the
-// owning tree (`resolveFeatureTree`) unless `--here` forces the cwd.
-export function handoffCommand(featureName, options = {}) {
-  const cwd = process.cwd();
-
-  const owner = options.here ? { source: 'cwd', tree: cwd, branch: null, worktree: null } : resolveFeatureTree(featureName, cwd);
-
-  if (owner.source === 'none') {
-    if (options.json) {
-      console.log(JSON.stringify({ error: 'feature-not-found', feature: featureName }));
-    } else {
-      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
-    }
-    process.exit(1);
-  }
-
-  if (owner.source === 'branch-only') {
-    // The handoff points at files on disk; a truth materialized in no tree is refused.
-    const hint = `morph-spec worktree setup ${featureName}  (ou: git checkout ${owner.branch})`;
-    if (options.json) {
-      console.log(JSON.stringify({ error: 'feature-not-in-tree', feature: featureName, branch: owner.branch, hint }));
-    } else {
-      console.error(chalk.red(`\n❌ "${featureName}" está commitada em \`${owner.branch}\`, mas não está materializada em árvore nenhuma.`));
-      console.error(chalk.gray(`   ${hint}\n`));
-    }
-    process.exit(1);
-  }
-
-  const tree = owner.tree;
-  const result = buildHandoff(featureName, tree, { worktree: owner.worktree });
-  if (!result) {
-    if (options.json) {
-      console.log(JSON.stringify({ error: 'feature-not-found', feature: featureName, tree }));
-    } else {
-      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
-    }
-    process.exit(1);
-  }
-
-  const path = writeHandoff(featureName, tree, { worktree: owner.worktree });
-  if (!path) {
-    if (options.json) {
-      console.log(JSON.stringify({ error: 'write-failed', feature: featureName, tree }));
-    } else {
-      console.error(chalk.red(`\n❌ Could not write handoff.md for ${featureName}\n`));
-    }
-    process.exit(1);
-  }
-
-  if (options.json) {
-    console.log(JSON.stringify({ path, feature: featureName, tree, source: owner.source, ...result.meta }));
-    return;
-  }
-
-  console.log(chalk.green(`\n✅ Handoff gerado: ${path}`));
-  if (tree !== cwd) {
-    console.log(chalk.yellow(`   resolvido para ${tree} — a cópia da raiz é esqueleto de nascimento, não a verdade.`));
-  }
-  console.log(chalk.gray(`   fase ${result.meta.phase} · fatias ${result.meta.slicesDone}/${result.meta.slicesTotal} · ${result.meta.generatedAt}`));
-  console.log(chalk.gray('   A próxima sessão lê este documento antes de continuar (ponteiros, não cópias).\n'));
-}

package/src/commands/validation/mutate.js

@@ -1,263 +0,0 @@
-import chalk from 'chalk';
-import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { discoverDotnetBuildTargets } from '../../lib/tasks/test-runner.js';
-import { dotnetTestMode } from '../../lib/mutation/dotnet-introspection.js';
-import { dotnetBuildCommands } from '../../lib/mutation/commands.js';
-import { resolveTestNodes } from '../../lib/tasks/test-nodes.js';
-import { changedPathsAgainst, detectDefaultBranch, getHeadSha } from '../../lib/git/default-branch.js';
-import { createHeavyGate, HeavyBusyError } from '../../lib/heavy/gate.js';
-import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
-import { resolveGitCommonDir } from '../../../framework/hooks/shared/git-paths.js';
-import { BACKSLASH_TOKEN, ManifestError } from '../../lib/mutation/manifest.js';
-import { groupByNode, loadPlan } from '../../lib/mutation/plan.js';
-import { dotnetSubset, jsSubset, mutatedTypesOf, testFilesCiting, testProjectDirsOf } from '../../lib/mutation/subset.js';
-import { isFinished } from '../../dashboard/scanner/feature-status.js';
-import { dotnetAdapter, genericAdapter, spawnExec } from '../../lib/mutation/adapters.js';
-import { noSubsetReason, runMutation } from '../../lib/mutation/runner.js';
-import { renderSection, summarize } from '../../lib/mutation/report.js';
-import { readJournal, restoreSnapshot } from '../../lib/mutation/snapshot.js';
-
-const EXIT = { ok: 0, failed: 1, usage: 2, busy: 3, unsafe: 4 };
-const KEEP_RUNS = 2;
-const DEFAULT_JOBS = 2;
-
-// One heavy slot per worker: the first waits, the others are taken only if free now,
-// so a busy machine degrades to sequential instead of queueing.
-export function workerGate({ root, feature, jobs }) {
-  const config = readHeavyConfig(root);
-  const gates = [createHeavyGate({ projectPath: root, label: 'mutate', feature, config })];
-  const quiet = { ...config, waitTimeoutSec: 0, warnings: [] };
-  for (let i = 1; i < jobs; i++) {
-    const { MORPH_HEAVY_LEASE: _inherited, ...env } = process.env;
-    gates.push(createHeavyGate({ projectPath: root, label: 'mutate', feature, config: quiet, env }));
-  }
-  let acquired = 0;
-  return {
-    get jobs() { return acquired; },
-    enter(node) {
-      gates[0].enter(node);
-      acquired = 1;
-      for (const gate of gates.slice(1)) {
-        try { gate.enter(node); acquired += 1; } catch (err) {
-          if (!(err instanceof HeavyBusyError)) throw err;
-          break;
-        }
-      }
-    },
-    release() {
-      for (const gate of [...gates].reverse()) gate.release();
-      acquired = 0;
-    },
-  };
-}
-
-const gitOut = (cwd, args) => execFileSync('git', args, { cwd, stdio: 'pipe', encoding: 'utf8', windowsHide: true });
-
-function workRoot(root) {
-  const common = resolveGitCommonDir(root);
-  return common ? join(common, 'morph-spec', 'mutation') : join(root, '.morph', 'tmp', 'mutation');
-}
-
-function pruneOldRuns(base, keep) {
-  if (!existsSync(base)) return;
-  const runs = readdirSync(base).sort();
-  for (const name of runs.slice(0, Math.max(0, runs.length - keep))) {
-    const done = ['g0', 'g1', 'g2', 'g3'].every((g) => {
-      const journal = readJournal(join(base, name, g, 'snapshot'));
-      return journal === null || journal.state === 'restored';
-    });
-    if (done) rmSync(join(base, name), { recursive: true, force: true });
-  }
-}
-
-function fail(message, code) {
-  console.error(chalk.red(message));
-  process.exitCode = code;
-  return null;
-}
-
-export function restoreLatest(root, out = console) {
-  const base = workRoot(root);
-  if (!existsSync(base)) { out.log('nada a restaurar: nenhuma rodada de mutação registrada'); return []; }
-  const restored = [];
-  for (const run of readdirSync(base).sort()) {
-    for (const group of readdirSync(join(base, run))) {
-      const journal = readJournal(join(base, run, group, 'snapshot'));
-      if (!journal || journal.state === 'restored') continue;
-      const report = restoreSnapshot(journal);
-      restored.push({ run, group, files: report });
-      out.log(`${run}/${group}: ${report.every((r) => r.ok) ? 'restaurado' : 'FALHOU'} — ${report.map((r) => `${r.file} ${r.ok ? 'ok' : 'md5 diverge'}`).join(', ')}`);
-    }
-  }
-  if (restored.length === 0) out.log('nada a restaurar: toda rodada registrada já foi restaurada');
-  return restored;
-}
-
-function testDirsOf(node, root, { projectsOnly = false } = {}) {
-  const cwd = resolve(root, node.cwd || '.');
-  const targets = discoverDotnetBuildTargets(node, cwd);
-  return testProjectDirsOf(root, projectsOnly ? targets.filter((t) => !/\.slnx?$/i.test(t)) : targets, cwd);
-}
-
-function subsetFor({ node, group, root }) {
-  const mutatedFiles = group.regions.map((r) => r.file);
-  if (node.runner === 'dotnet') {
-    const base = detectDefaultBranch(root);
-    const changed = base ? changedPathsAgainst(base, root) : [];
-    return dotnetSubset({ root, testProjectDirs: testDirsOf(node, root), mutatedFiles, changed });
-  }
-  return jsSubset({ runner: node.runner, command: node.command, root, mutatedFiles });
-}
-
-function e2eManualProtocol(feature, node) {
-  const f = feature ?? '<feature>';
-  const round = `eval "$(morph-spec env ${f} --with-secrets)" && morph-spec e2e up ${f} && morph-spec heavy run -- ${node.command}`;
-  return 'mutate só recompila localmente, e a suíte que alcança esse código testa o container do compose: o mutante sairia sobrevivente em falso. ' +
-    `Prove à mão pelo nó "${node.id}", cada passo numa linha só e encadeado por \`&&\` (nunca \`;\`: um passo que falha não pode deixar a suíte rodar sobre o código original; ` +
-    'e o env da feature se perde entre chamadas de Bash): ' +
-    `(1) base verde antes do 1º mutante: \`${round}\`; ` +
-    `(2) por mutante: edite a linha && \`${round}\`; ` +
-    `(3) restaure, confirme com \`git diff --quiet -- <arquivo>\` e suba a stack de novo (\`eval "$(morph-spec env ${f} --with-secrets)" && morph-spec e2e up ${f}\`). ` +
-    'Registre cada mutante em 4-review (expect, resultado, teste que o matou).';
-}
-
-// A .cs file belongs to every dotnet suite, by runner, not by project reference: a unit suite
-// "owns" code only an e2e suite executes. With an e2e node declared, a unit suite with no test
-// naming a type of the mutated file is not evidence, so the run is refused.
-function uncitedUnderE2e({ root, groups, nodes }) {
-  const e2e = nodes.filter((n) => n.e2e);
-  if (e2e.length === 0) return [];
-  const e2eDirs = new Set(e2e.filter((n) => n.runner === 'dotnet').flatMap((n) => testDirsOf(n, root)));
-  const uncited = [];
-  for (const { node, regions } of groups.filter((g) => g.node.runner === 'dotnet')) {
-    const direct = new Set(testDirsOf(node, root, { projectsOnly: true }));
-    const dirs = testDirsOf(node, root).filter((d) => direct.has(d) || !e2eDirs.has(d));
-    for (const region of regions) {
-      const types = mutatedTypesOf(root, [region.file]);
-      if (testFilesCiting({ root, testProjectDirs: dirs, types, exclude: [region.file] }).length === 0) uncited.push({ region, node, types, e2e });
-    }
-  }
-  return uncited;
-}
-
-function soleActiveFeature(root) {
-  const dir = join(root, '.morph', 'features');
-  let names;
-  try { names = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name); } catch { return null; }
-  const active = names.filter((name) => {
-    try { return !isFinished(JSON.parse(readFileSync(join(dir, name, 'feature.json'), 'utf8'))); } catch { return false; }
-  });
-  return active.length === 1 ? active[0] : null;
-}
-
-export async function mutateCommand(featureArg, options = {}) {
-  const root = resolve(options.cwd ?? process.cwd());
-  if (options.restore) { restoreLatest(root); return null; }
-
-  const feature = featureArg ?? soleActiveFeature(root);
-  if (!feature && !options.plan) return fail('sem feature: passe <feature> (nenhuma, ou mais de uma, em andamento) ou o manifesto por --plan.', EXIT.usage);
-  const planPath = resolve(root, options.plan ?? join('.morph', 'features', feature, '4-review', 'mutants.json'));
-  if (!existsSync(planPath)) return fail(`manifesto não encontrado: ${planPath}\nEscreva-o com a ferramenta Write, se você a tem; só com Bash, heredoc de delimitador entre aspas simples, com a barra invertida do código como ${BACKSLASH_TOKEN} — formato em .morph/framework/CLI.md, seção "### mutate".`, EXIT.usage);
-
-  let regions;
-  try {
-    regions = loadPlan({ root, planPath });
-  } catch (err) {
-    if (err instanceof ManifestError) return fail(err.message, EXIT.usage);
-    if (err instanceof SyntaxError) return fail(`${err.message}\nSe o manifesto tem barra invertida, o transporte do Bash pode tê-la alterado: escreva cada uma como ${BACKSLASH_TOKEN}, que a ferramenta expande.`, EXIT.usage);
-    throw err;
-  }
-
-  const { nodes } = resolveTestNodes(root);
-  const { groups, orphans, stackOnly } = groupByNode(regions, nodes, root);
-  if (orphans.length > 0) {
-    return fail(`nenhuma suíte declarada roda: ${orphans.map((o) => `${o.id} (${o.file})`).join(', ')}\nDeclare o nó em project.tests[] (.morph/config/config.json).`, EXIT.usage);
-  }
-  if (stackOnly.length > 0) {
-    const named = stackOnly.map(({ region, node }) => `${region.id} (${region.file}) → nó "${node.id}"`).join(', ');
-    return fail(`só uma suíte e2e: true cobre: ${named}\nProve a guarda por um teste de unidade, ou: ${e2eManualProtocol(feature, stackOnly[0].node)}`, EXIT.usage);
-  }
-  const mtp = groups.find((g) => g.node.runner === 'dotnet' && dotnetTestMode(resolve(root, g.node.cwd || '.')) === 'mtp');
-  if (mtp) return fail(`a suíte "${mtp.node.id}" roda no Microsoft.Testing.Platform (global.json): o TRX do VSTest, de onde o veredito e o motivo saem, não existe nela. Suporte a MTP ainda não há — rode a mutação com a suíte inteira à mão.`, EXIT.usage);
-  const uncompilable = groups.find((g) => g.node.runner === 'dotnet' && dotnetBuildCommands(g.node, root).length === 0);
-  if (uncompilable) return fail(`a suíte "${uncompilable.node.id}" não deixa descobrir o que compilar: o comando não nomeia .sln/.slnx/.csproj e o diretório alvo não tem uma única solution (ou um único projeto). Sem isso, todo mutante rodaria sobre o binário antigo e sairia "sobrevivente". Nomeie a solution no comando ou declare o campo build no nó (config.json, project.tests[]).`, EXIT.usage);
-  const preDecided = groups.find((g) => g.node.status);
-  if (preDecided) return fail(`a suíte "${preDecided.node.id}" já vem decidida como ${preDecided.node.status}: ${preDecided.node.reason ?? ''}`, EXIT.usage);
-  const uncited = uncitedUnderE2e({ root, groups, nodes });
-  if (uncited.length > 0) {
-    const named = uncited.map(({ region, node, types }) => `${region.id} (${region.file}; tipos: ${types.join(', ') || 'nenhum legível'}) → nenhum teste da suíte "${node.id}" os cita`).join('\n');
-    const e2eIds = uncited[0].e2e.map((n) => `"${n.id}"`).join(', ');
-    return fail(`${named}\nNó e2e: true declarado: ${e2eIds}. ${e2eManualProtocol(feature, uncited[0].e2e[0])}`, EXIT.usage);
-  }
-
-  const subsets = groups.map((group) => subsetFor({ node: group.node, group, root }));
-  const noSubset = subsets.findIndex((s) => !s.usable);
-  if (noSubset >= 0) {
-    return fail(`suíte "${groups[noSubset].node.id}": ${noSubsetReason(subsets[noSubset].reason)}.`, EXIT.usage);
-  }
-
-  if (!options.allowDirty) {
-    const dirty = gitOut(root, ['status', '--porcelain', '--', ...new Set(regions.map((r) => r.file))]).trim();
-    if (dirty) return fail(`há alteração não commitada nos arquivos a mutar:\n${dirty}\nCommite o fix ANTES de mutar (ou use --allow-dirty sabendo que o snapshot é o único caminho de volta).`, EXIT.usage);
-  }
-
-  const runId = `mut-${Date.now().toString(36)}`;
-  const base = workRoot(root);
-  pruneOldRuns(base, KEEP_RUNS);
-  const git = { porcelain: () => gitOut(root, ['status', '--porcelain', '--', '.', ':(exclude).morph']), head: () => getHeadSha(root) };
-  const jobs = Math.max(1, Number.isInteger(options.jobs) ? options.jobs : DEFAULT_JOBS);
-  const gate = workerGate({ root, feature: feature ?? null, jobs });
-  const exec = options.exec ?? spawnExec;
-
-  const merged = { wallMs: 0, mutants: [], timings: [], restore: { files: [], ok: true, treeClean: true }, binary: { proof: 'unavailable', projects: [] }, baseline: {}, method: { schemata: 0, rebuild: 0, subset: {} } };
-  try {
-    for (const [index, group] of groups.entries()) {
-      const workDir = join(base, runId, `g${index}`);
-      mkdirSync(workDir, { recursive: true });
-      const subset = subsets[index];
-      const timeoutMs = options.timeoutMs ?? group.node.timeoutMs ?? 900_000;
-      const make = group.node.runner === 'dotnet' ? dotnetAdapter : genericAdapter;
-      const adapter = make({ node: group.node, root, workDir, exec, subset, timeoutMs });
-      const result = await runMutation({ root, node: group.node, regions: group.regions, workDir, runId, exec, adapter, gate, git, options: { timeoutMs, jobs }, log: (m) => options.json || console.error(chalk.gray(m)) });
-      merged.mutants.push(...result.mutants);
-      merged.timings.push(...result.timings);
-      merged.wallMs += result.wallMs;
-      merged.restore.files.push(...result.restore.files);
-      merged.restore.ok &&= result.restore.ok;
-      merged.restore.treeClean &&= result.restore.treeClean;
-      merged.restore.porcelainAfter = result.restore.porcelainAfter;
-      if (result.binary.proof !== 'unavailable') merged.binary = ['mismatch', 'unlocated'].includes(merged.binary.proof) ? merged.binary : result.binary;
-      merged.baseline = { ...merged.baseline, ...Object.fromEntries(Object.entries(result.baseline).filter(([, v]) => v)) };
-      merged.method.schemata += result.method.schemata;
-      merged.method.rebuild += result.method.rebuild;
-      merged.method.subset = result.method.subset;
-      merged.method.jobs = Math.max(merged.method.jobs ?? 1, result.method.jobs);
-    }
-  } catch (err) {
-    if (err instanceof HeavyBusyError) return fail(`suíte não rodou: ${err.message}. A fila já esperou o prazo dela: não repita em laço — registre a mutação como não executada (morph-spec heavy status).`, EXIT.busy);
-    if (err.code === 'baseline-build-failed') return fail(`${err.message}\n${String(err.output ?? '').split('\n').slice(-12).join('\n')}`, EXIT.failed);
-    throw err;
-  }
-
-  const order = new Map(regions.map((r, i) => [r.id, i]));
-  merged.mutants.sort((a, b) => order.get(a.id) - order.get(b.id));
-  const section = renderSection(merged, { head: git.head(), date: new Date().toISOString().slice(0, 10), subset: subsets[0] ?? null });
-  const outRel = options.out ?? (feature ? join('.morph', 'features', feature, '4-review', 'mutation-section.md') : null);
-  const outPath = outRel ? resolve(root, outRel) : null;
-  if (outPath) {
-    mkdirSync(join(outPath, '..'), { recursive: true });
-    writeFileSync(outPath, section);
-  }
-
-  const tally = summarize(merged);
-  if (options.json) console.log(JSON.stringify({ ...merged, tally, section: outPath }, null, 2));
-  else {
-    console.log(section);
-    console.log(chalk.gray(outPath ? `seção gravada em ${outPath}` : 'seção não gravada: sem feature nem --out'));
-    console.log(`${chalk.green(`${tally.killed} mortos`)} · ${tally.survived ? chalk.yellow(`${tally.survived} sobreviveram`) : '0 sobreviveram'} · ${tally['build-error']} não compilaram · ${tally.inconclusive} inconclusivos`);
-  }
-  if (!merged.restore.ok || ['mismatch', 'unlocated'].includes(merged.binary.proof) || !merged.restore.treeClean) process.exitCode = EXIT.unsafe;
-  return { ...merged, tally, section: outPath };
-}

package/src/commands/validation/scout-check.js

@@ -1,28 +0,0 @@
-import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
-import { resolve } from 'path';
-import { checkScoutMap, resolveScoutRoot } from '../../lib/scout/scout-check.js';
-
-export function scoutCheckCommand(mapPath, options = {}) {
-  const file = resolve(mapPath);
-  if (!existsSync(file)) {
-    if (options.json) console.log(JSON.stringify({ ok: false, error: 'map-not-found', map: file }));
-    else console.error(chalk.red(`scout-check: mapa não encontrado: ${file}`));
-    process.exit(2);
-  }
-  const result = { map: file, ...checkScoutMap(readFileSync(file, 'utf8'), { root: resolveScoutRoot(options.root) }) };
-
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else if (result.ok) {
-    console.log(chalk.green(`✓ scout-check: ${result.citations.length} citações conferidas contra ${result.root}`));
-  } else {
-    console.log(chalk.red(`✗ scout-check: ${result.failures.length} falha(s) em ${file} (raiz ${result.root})`));
-    for (const f of result.failures) {
-      const where = f.line ? `L${f.line}` : '—';
-      console.log(`  ${where} ${chalk.yellow(f.kind)} ${f.citation ?? ''} ${f.detail}`);
-    }
-    console.log(chalk.gray('  Mapa reprovado: descarte e re-despache o scout UMA vez com estas falhas no prompt (MORPH.md §6).'));
-  }
-  process.exit(result.ok ? 0 : 1);
-}