@polymorphism-tech/morph-spec 9.1.0 → 9.3.0

package/src/lib/mutation/runner.js

@@ -4,12 +4,13 @@ import { applyRegions, diffOf } from './manifest.js';
 import { blame, parseCompilerErrors, patchFile, switchClassName, switchSource, SWITCH_ENV } from './schemata.js';
 import { md5Of, md5OfFile, openSnapshot, restoreSnapshot, trackGenerated } from './snapshot.js';
 import { parseBuiltDlls } from './commands.js';
-import { firstLines, methodOf } from './trx.js';
+import { firstLines } from './trx.js';
 import { nearestProjectOf } from './dotnet-introspection.js';
 
 const posix = (p) => p.replace(/\\/g, '/');
 const MAX_SCHEMATA_ATTEMPTS = 3;
-const MAX_REPRODUCE = 5;
+
+export const noSubsetReason = (why) => `sem subconjunto utilizável (${why ?? 'nenhum teste da feature nem que cite os tipos mutados'}): a mutação não roda a suíte inteira — prove o cenário por leitura`;
 
 const envWithout = (env) => { const { [SWITCH_ENV]: _drop, ...rest } = env; return rest; };
 const failedNames = (result) => new Set(result.failedTests.map((t) => t.name));
@@ -123,29 +124,15 @@ export async function runMutation(input) {
       .map((name) => [name, md5OfFile(dlls.get(name))]),
   );
 
-  const run = (scope, label, env) => timed(label, () => adapter.runTests({ scope, label, env }));
-
-  const confirmKill = async (id, verdict, env) => {
-    if (!adapter.reproduce) return verdict;
-    const names = [...new Set(verdict.failures.map((f) => f.name))].slice(0, MAX_REPRODUCE);
-    const again = await timed(`${id}-reproduce`, () => adapter.reproduce({ names, label: `${id}-reproduce`, env }));
-    if (again.outcome === 'crash' || !again.executed) {
-      return { state: 'inconclusive', reason: `a falha de ${names[0]} não pôde ser confirmada na repetição (${again.note ?? 'nenhum teste executado'})` };
-    }
-    const wanted = new Set(names.map(methodOf));
-    const held = again.failedTests.filter((t) => wanted.has(methodOf(t.name)));
-    if (held.length > 0) return { ...verdict, reason: reasonOf(held) };
-    const whole = await timed(`${id}-reproduce-full`, () => adapter.runTests({ scope: 'full', label: `${id}-reproduce-full`, env }));
-    if (whole.outcome === 'crash' || !whole.executed) {
-      return { state: 'inconclusive', reason: `a falha de ${names[0]} não pôde ser confirmada na repetição (${whole.note ?? 'nenhum teste executado'})` };
-    }
-    const heldWhole = whole.failedTests.filter((t) => wanted.has(methodOf(t.name)));
-    if (heldWhole.length > 0) return { ...verdict, reason: reasonOf(heldWhole) };
-    const which = names.length === 1 ? names[0] : `${names.length} testes`;
-    return { state: 'survived', reason: `nenhum teste falhou de forma reproduzível: ${which} falhou uma vez e passou isolado e na suíte inteira repetida (instável, não prova o mutante)` };
-  };
+  const run = (label, env) => timed(label, () => adapter.runTests({ label, env }));
 
   const record = (id, patch) => Object.assign(results.get(id), patch);
+  const recordSubset = (id, result) => {
+    const verdict = judge(result, baselineSubset);
+    const base = { scope: 'subset', executed: result.executed, durationMs: result.durationMs };
+    if (verdict.state === 'killed') record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason });
+    else record(id, { ...base, verdict: verdict.state, reason: verdict.reason ?? '' });
+  };
   const applyOnDisk = (id) => {
     const region = byId.get(id);
     writeFileSync(join(root, region.file), applyRegions(originals.get(region.file), [region], (x) => x.replaceText).text);
@@ -154,10 +141,8 @@ export async function runMutation(input) {
   let pristine = new Map();
   let binary = { proof: 'unavailable', projects: [] };
   let baselineSubset = null;
-  let baselineFull = null;
   let subsetLive = adapter.hasSubset;
   let subsetNote = null;
-  const needFullBaseline = [];
   let restoreReport = [];
 
   try {
@@ -238,40 +223,26 @@ export async function runMutation(input) {
     if (subsetLive && (schemataIds.length > 0 || hasRebuild)) {
       const copies = schemataIds.length > 0 ? jobs : 1;
       baselineSubset = mergeBaselines(await Promise.all(Array.from({ length: copies }, (_, i) => (
-        run('subset', i === 0 ? 'baseline-subset' : `baseline-subset-${i + 1}`, envWithout(process.env))))));
+        run(i === 0 ? 'baseline-subset' : `baseline-subset-${i + 1}`, envWithout(process.env))))));
       if (baselineSubset.outcome === 'crash' || baselineSubset.executed === 0) {
         subsetLive = false;
         subsetNote = baselineSubset.executed === 0 ? 'o filtro do subconjunto não selecionou teste algum' : (baselineSubset.note ?? 'a rodada-base do subconjunto não terminou');
       }
     }
-    if (!subsetLive && schemataIds.length > 0) baselineFull = await run('full', 'baseline-full', envWithout(process.env));
-
-    const scopeOf = subsetLive ? 'subset' : 'full';
-    const scopeBaseline = () => (subsetLive ? baselineSubset : baselineFull);
     const routed = [];
-    const scopeJobs = subsetLive ? jobs : 1;
-    workerCount = schemataIds.length > 0 ? scopeJobs : 1;
-    const outcomes = new Map();
-    await pool(schemataIds, scopeJobs, async (id) => {
-      outcomes.set(id, await run(scopeOf, `${id}-${scopeOf}`, { ...process.env, [SWITCH_ENV]: id }));
-    });
-    for (const id of schemataIds) {
-      const result = outcomes.get(id);
-      const first = judge(result, scopeBaseline());
-      const verdict = first.state === 'killed' && scopeOf === 'full' ? await confirmKill(id, first, { ...process.env, [SWITCH_ENV]: id }) : first;
-      const base = { scope: scopeOf, executed: result.executed, durationMs: result.durationMs };
-      if (verdict.state === 'killed') {
-        record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason });
-      } else if (scopeOf === 'subset' && verdict.state === 'survived') {
-        record(id, { ...base, verdict: 'survived', reason: '' });
-      } else {
-        record(id, { ...base, verdict: null, reason: verdict.reason ?? '' });
-        routed.push({ id, needs: 'full' });
-      }
+    workerCount = subsetLive && schemataIds.length > 0 ? jobs : 1;
+    if (subsetLive) {
+      const outcomes = new Map();
+      await pool(schemataIds, jobs, async (id) => {
+        outcomes.set(id, await run(`${id}-subset`, { ...process.env, [SWITCH_ENV]: id }));
+      });
+      for (const id of schemataIds) recordSubset(id, outcomes.get(id));
+      for (const r of results.values()) if (r.mode === 'rebuild') routed.push(r.id);
+    } else {
+      for (const r of results.values()) record(r.id, { verdict: 'inconclusive', scope: null, reason: noSubsetReason(subsetNote) });
     }
-    for (const r of results.values()) if (r.mode === 'rebuild') routed.push({ id: r.id, needs: subsetLive ? 'subset' : 'full' });
 
-    for (const { id, needs } of routed) {
+    for (const id of routed) {
       applyOnDisk(id);
       try {
         if (adapter.buildCommands.length > 0) {
@@ -282,21 +253,7 @@ export async function runMutation(input) {
             continue;
           }
         }
-        if (needs === 'subset') {
-          const sub = await run('subset', `${id}-subset`, envWithout(process.env));
-          const verdict = judge(sub, baselineSubset);
-          const base = { scope: 'subset', executed: sub.executed, durationMs: sub.durationMs };
-          if (verdict.state === 'killed') record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason });
-          else record(id, { ...base, verdict: verdict.state, reason: verdict.reason ?? '' });
-          continue;
-        }
-        const full = await run('full', `${id}-full`, envWithout(process.env));
-        const first = judge(full, baselineFull);
-        const verdict = first.state === 'killed' ? await confirmKill(id, first, envWithout(process.env)) : first;
-        const base = { scope: 'full', executed: full.executed, durationMs: full.durationMs };
-        if (verdict.state === 'inconclusive') record(id, { ...base, verdict: 'inconclusive', reason: verdict.reason });
-        else if (verdict.state === 'survived') record(id, { ...base, verdict: 'survived', reason: verdict.reason ?? '' });
-        else { record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason }); if (!baselineFull) needFullBaseline.push({ id, full }); }
+        recordSubset(id, await run(`${id}-subset`, envWithout(process.env)));
       } finally {
         restoreSnapshot(snapshot);
       }
@@ -310,14 +267,6 @@ export async function runMutation(input) {
       binary = proveBinary({ pristine, dlls: last.dlls, restoredAt, hashes: dllHashes(last.dlls) });
     }
 
-    if (needFullBaseline.length > 0) {
-      baselineFull = await run('full', 'baseline-full', envWithout(process.env));
-      for (const { id, full } of needFullBaseline) {
-        const verdict = judge(full, baselineFull);
-        if (verdict.state === 'killed') record(id, { killers: verdict.failures.length, reason: verdict.reason });
-        else record(id, { verdict: 'survived', killers: 0, reason: '' });
-      }
-    }
   } finally {
     restoreReport = restoreSnapshot(snapshot, { rewrite: false });
     gate?.release();
@@ -338,7 +287,6 @@ export async function runMutation(input) {
     mutants,
     baseline: {
       subset: baselineSubset ? { executed: baselineSubset.executed, failed: baselineSubset.failed } : null,
-      full: baselineFull ? { executed: baselineFull.executed, failed: baselineFull.failed } : null,
     },
     binary,
     restore: {

package/src/lib/mutation/trx.js

@@ -43,7 +43,6 @@ export function parseTrx(xml) {
   };
 }
 
-export const methodOf = (testName) => String(testName).replace(/\s*\(.*$/s, '').trim();
 
 export function firstLines(message, max = 2, width = 240) {
   const lines = String(message).split(/\r?\n/).map((l) => l.trim()).filter(Boolean).slice(0, max).join(' ⏎ ');

package/src/lib/next-step.js

@@ -0,0 +1,10 @@
+import { collectNextSignals, decideNext } from '../../framework/hooks/shared/next-step.js';
+import { treeMovedSince } from './git/evidence-staleness.js';
+
+/** The CLI collector: the hook-readable facts plus verify staleness (git). Null without feature.json. */
+export function nextStepFor(featureName, tree) {
+  const signals = collectNextSignals(featureName, tree);
+  if (!signals) return null;
+  signals.verificationStale = treeMovedSince(tree, signals.verification?.sha);
+  return { ...decideNext(signals), phase: signals.phase, failStreak: signals.failStreak };
+}

package/src/lib/plan/checks.js

@@ -3,8 +3,9 @@ import { existsSync, readFileSync } from 'fs';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { frozenBody } from '../../../framework/hooks/shared/errata.js';
 import { readAgentsJson } from '../specs/screen-checklist.js';
+import { getFeature } from '../../../framework/hooks/shared/state-reader.js';
 import { findArtifactTerms } from './artifact-vocabulary.js';
-import { PROOF_KINDS, REUSE_VERDICTS, ADR_SCOPES, SECTIONS, CONFLICTS_HEADING } from './plan-parser.js';
+import { PROOF_KINDS, RISK_KINDS, REUSE_VERDICTS, ADR_SCOPES, SECTIONS, CONFLICTS_HEADING } from './plan-parser.js';
 
 export const CHECKS_VERSION = 1;
 export const MAX_SLICE_FILES = 8;
@@ -83,7 +84,19 @@ export function parallelGroups(slices) {
   return groups;
 }
 
-export function validatePlan(plan, { personas = null, surfaces = null } = {}) {
+// A frozen body already extracted under older rules cannot gain a `risco:` line, so it is not demanded.
+export function planRuleOptions(cwd, featureName) {
+  return {
+    workType: getFeature(featureName, cwd)?.workType ?? null,
+    riskRules: readPlanChecks(cwd, featureName).status !== 'fresh',
+  };
+}
+
+const foldRisk = (s) => s.normalize('NFD').replace(/\p{M}/gu, '').replace(/`/g, '').toLowerCase().trim();
+const RISK_BY_FOLD = new Map(RISK_KINDS.map((r) => [foldRisk(r), r]));
+const REGRESSION_WORK_TYPES = ['bug', 'hotfix'];
+
+export function validatePlan(plan, { personas = null, surfaces = null, workType = null, riskRules = true } = {}) {
   const errors = [];
   const warnings = [];
   const at = (line) => (line ? ` (linha ${line})` : '');
@@ -114,12 +127,26 @@ export function validatePlan(plan, { personas = null, surfaces = null } = {}) {
     } else if (!PROOF_KINDS.includes(c.proof.toLowerCase())) {
       errors.push(`${c.id}: prova "${c.proof}" fora de ${PROOF_KINDS.join(' | ')}${at(c.line)}`);
     }
+    const proof = c.proof?.toLowerCase();
+    const risk = c.risk === null ? null : RISK_BY_FOLD.get(foldRisk(c.risk)) ?? false;
+    if (risk === false) {
+      errors.push(`${c.id}: risco "${c.risk}" fora de ${RISK_KINDS.join(' | ')}${at(c.line)}`);
+    } else if (riskRules && proof === 'teste' && risk === null) {
+      errors.push(`${c.id}: "prova: teste" sem "risco:" (${RISK_KINDS.join(' | ')}) — sem risco, a prova é "leitura" ou "e2e"${at(c.line)}`);
+    } else if (risk && proof === 'leitura') {
+      warnings.push(`${c.id}: risco "${risk}" provado só por leitura${at(c.line)}`);
+    }
     const terms = findArtifactTerms(c.text);
     if (terms.length > 0 && !c.artifactWhy) {
       errors.push(`${c.id} descreve artefato ("${terms.join(', ')}") sem "> Por que artefato:" — reescreva como efeito observável ou justifique${at(c.line)}`);
     }
   }
 
+  const isRegression = (c) => ['teste', 'e2e'].includes(c.proof?.toLowerCase()) && c.risk !== null && RISK_BY_FOLD.get(foldRisk(c.risk)) === 'regressão';
+  if (riskRules && REGRESSION_WORK_TYPES.includes(workType) && plan.scenarios.length > 0 && !plan.scenarios.some(isRegression)) {
+    errors.push(`${workType} sem cenário de regressão — o sintoma do bug real vira um Cn com "prova: teste" e "risco: regressão"`);
+  }
+
   const scenarioIds = new Set(plan.scenarios.map((c) => c.id));
   const sliceIds = new Set(plan.slices.map((s) => s.id));
   const covered = new Set();

package/src/lib/plan/plan-parser.js

@@ -2,7 +2,8 @@ import { tableCells, isTableLine, SEPARATOR_ROW_RE } from '../specs/gfm-table.js
 import { ARTIFACT_MARKER_RE } from './artifact-vocabulary.js';
 import { markdownLines } from '../../../framework/hooks/shared/errata.js';
 
-export const PROOF_KINDS = ['teste', 'e2e', 'eval', 'manual'];
+export const PROOF_KINDS = ['teste', 'e2e', 'eval', 'manual', 'leitura'];
+export const RISK_KINDS = ['regra', 'dinheiro', 'contrato', 'concorrência', 'dado', 'regressão'];
 export const REUSE_VERDICTS = ['REUSAR', 'ESTENDER', 'CRIAR'];
 export const ADR_SCOPES = ['feature', 'projeto'];
 
@@ -36,6 +37,7 @@ const SCENARIO_RE = new RegExp(String.raw`^[-*]\s+\*\*(C\d+)\*\*${DASH}(.+)$`);
 const ADR_RE = new RegExp(String.raw`^###\s+(ADR-\d+)${DASH}(.+?)\s*$`);
 const SLICE_RE = new RegExp(String.raw`^###\s+(F\d+)${DASH}(.+?)\s*$`);
 const PROOF_RE = /^\s*prova\s*:\s*(.*?)\s*$/i;
+const RISK_RE = /^\s*risco\s*:\s*(.*?)\s*$/i;
 const WHY_RE = new RegExp(String.raw`^\s*>\s*` + ARTIFACT_MARKER_RE.source + String.raw`\s*(.*?)\s*$`, 'i');
 const SCOPE_RE = /^\s*\*\*Alcance:\*\*\s*(.*?)\s*$/i;
 const SLICE_LINE_RE = /^\s*[-*]\s+([\p{L}]+)\s*:\s*(.*?)\s*$/u;
@@ -69,7 +71,7 @@ function parseScenarios(lines) {
     if (line.fenced) { current = null; continue; }
     const m = SCENARIO_RE.exec(line.raw);
     if (m) {
-      current = { id: m[1], text: m[2].trim(), proof: null, artifactWhy: null, line: line.n };
+      current = { id: m[1], text: m[2].trim(), proof: null, risk: null, artifactWhy: null, line: line.n };
       scenarios.push(current);
       continue;
     }
@@ -79,6 +81,8 @@ function parseScenarios(lines) {
     if (why) { current.artifactWhy = why[1] || ''; continue; }
     const proof = PROOF_RE.exec(line.raw);
     if (proof && current.proof === null) { current.proof = proof[1]; continue; }
+    const risk = RISK_RE.exec(line.raw);
+    if (risk && current.risk === null) { current.risk = risk[1]; continue; }
     if (/^\s*>/.test(line.raw)) continue;
     current.text = `${current.text} ${line.raw.trim()}`;
   }

package/src/lib/review-reports.js

@@ -27,10 +27,11 @@ const CHECKS_SECTION_RE = sectionRe('Checks');
 const MEDIA_SECTION_RE = /^##\s+M[íi]dia\s+gerada\s*$/m;
 const SCREEN_CHECKLIST_SECTION_RE = sectionRe('Checklist\\s+de\\s+tela');
 
-/** Hotfix: só o verificador, escrito pelo orquestrador sem dispatch. */
+/** Hotfix: só o verificador, escrito pelo orquestrador sem dispatch. Chore: só o revisor (review leve). */
 export function requiredReviewRoles({ workType, securityRequired = false } = {}) {
   if (workType === 'hotfix') return ['verifier'];
-  return securityRequired ? ['verifier', 'reviewer', 'security'] : ['verifier', 'reviewer'];
+  const base = workType === 'chore' ? ['reviewer'] : ['verifier', 'reviewer'];
+  return securityRequired ? [...base, 'security'] : base;
 }
 
 function sectionBodies(text, re) {
@@ -172,7 +173,9 @@ export function reviewSignal(reports, { required, checkIds }) {
         superseded: r.superseded,
       };
   }
-  out.checks = checkIds === null
+  out.checks = !required.includes('verifier')
+    ? { status: 'not-required', missing: [], notProven: [] }
+    : checkIds === null
     ? { status: 'no-checks', missing: [], notProven: [] }
     : { status: 'ok', total: checkIds.length, ...checksCoverage(checkIds, reports.verifier.checks) };
   return out;

package/src/lib/risk-detector.js

@@ -11,6 +11,7 @@ const E2E_SKIP_PATTERNS = [
   [/docker is not available/i, 'environment'],
   [/^requested$/i, 'requested'],
   [/does not containerize/i, 'project'],
+  [/^not applicable:/i, 'not-applicable'],
 ];
 
 // `unknown` (razão vazia) pausa de propósito: dispensa sem motivo é o no-op silencioso que a regra elimina.
@@ -99,6 +100,7 @@ export function reviewPause(signal) {
     if (r.verdict !== 'SHIP') return `veredito do ${role} é ${r.verdict}`;
   }
   const checks = signal?.checks;
+  if (checks?.status === 'not-required') return null;
   if (!checks || checks.status !== 'ok') {
     return 'sem `2-plan/checks.json` legível — a cobertura dos cenários pelo verificador não é conferível';
   }
@@ -156,23 +158,25 @@ export function shouldPauseGate(config, signals) {
   const trust = config?.trust ?? 'auto';
 
   if (trust === 'manual') {
-    return { pause: true, reason: 'trust mode is manual' };
+    return { pause: true, signal: 'trust-manual', reason: 'trust mode is manual' };
   }
 
   if (FORCED_PAUSE_WORK_TYPES.includes(signals.workType)) {
     return {
       pause: true,
+      signal: 'hotfix',
       reason: 'hotfix: aprovação humana obrigatória no ship (política de tipo — ignora trust:auto)',
     };
   }
 
   if (signals.designSystemDivergence) {
-    return { pause: true, reason: 'design-system divergence detected' };
+    return { pause: true, signal: 'design-system', reason: 'design-system divergence detected' };
   }
 
   if (Array.isArray(signals.standardsViolations) && signals.standardsViolations.length > 0) {
     return {
       pause: true,
+      signal: 'standards',
       reason: `standards violations detected: ${signals.standardsViolations.join(', ')}`,
     };
   }
@@ -181,6 +185,7 @@ export function shouldPauseGate(config, signals) {
   if (signals.verificationStatus === 'fail') {
     return {
       pause: true,
+      signal: 'verify-red',
       reason: 'último morph-spec verify está VERMELHO — rode verify e corrija antes de aprovar o gate',
     };
   }
@@ -189,6 +194,7 @@ export function shouldPauseGate(config, signals) {
   if (signals.gate === 'review' && !signals.verificationStatus) {
     return {
       pause: true,
+      signal: 'verify-missing',
       reason: 'nenhum `morph-spec verify` carimbado nesta feature — rode `morph-spec verify {feature}` antes do ship',
     };
   }
@@ -198,7 +204,7 @@ export function shouldPauseGate(config, signals) {
   if (signals.gate === 'review' && signals.e2eStatus === 'skip') {
     const klass = classifyE2eSkip(signals.e2eReason);
     if (E2E_SKIP_CLASSES_THAT_PAUSE.includes(klass)) {
-      return { pause: true, reason: e2ePauseReason(klass, signals.e2eReason) };
+      return { pause: true, signal: 'e2e-skip', reason: e2ePauseReason(klass, signals.e2eReason) };
     }
   }
 
@@ -206,13 +212,14 @@ export function shouldPauseGate(config, signals) {
   if (signals.gate === 'review' && signals.verificationStale === true) {
     return {
       pause: true,
+      signal: 'verify-stale',
       reason: 'verification stamp desatualizado (o código mudou depois do commit do stamp) — rode `morph-spec verify` de novo antes do ship',
     };
   }
 
   if (signals.gate === 'review') {
     const reason = reviewPause(signals.reviewReports);
-    if (reason) return { pause: true, reason };
+    if (reason) return { pause: true, signal: 'review-reports', reason };
   }
 
   // Prompt e modelo não são lidos por build nem por teste. Depois dos relatórios de review de propósito:
@@ -227,6 +234,7 @@ export function shouldPauseGate(config, signals) {
     if (signals.evalsStatus === null || signals.evalsStatus === undefined) {
       return {
         pause: true,
+        signal: 'prompt-model-no-eval',
         reason: `mudou prompt/modelo (${where}) e o projeto não declara nó de eval`
               + ' — nenhum build ou teste unitário fica vermelho por um prompt trocado;'
               + ' declare um `runner: "evals"` em project.tests[] ou registre a dispensa com `morph-spec gate-decision`',
@@ -235,6 +243,7 @@ export function shouldPauseGate(config, signals) {
     if (signals.evalsStatus === 'skip') {
       return {
         pause: true,
+        signal: 'prompt-model-eval-skip',
         reason: `mudou prompt/modelo (${where}) e o eval não foi executado neste verify`
               + ' — rode `morph-spec verify {feature}` (escopo de feature) antes do ship',
       };
@@ -248,6 +257,7 @@ export function shouldPauseGate(config, signals) {
       && signals.mediaClaims.section !== true) {
     return {
       pause: true,
+      signal: 'media-claims',
       reason: '`4-review/verifier.md` sem a seção `## Mídia gerada` — as quatro afirmações de mídia'
             + ' (custo, revisão humana, marcação, hot path) não foram provadas'
             + ' (evals/review-checklist.md, "Verificador")',
@@ -257,7 +267,7 @@ export function shouldPauseGate(config, signals) {
   // Sem o checklist de tela completo, paginação, ordenação, filtro e os três estados não viram cenário.
   if (signals.gate === 'uiux') {
     const reason = uiuxChecklistPause(signals.screenChecklist);
-    if (reason) return { pause: true, reason };
+    if (reason) return { pause: true, signal: 'uiux-checklist', reason };
   }
 
   // Cobra-se só o item devido (`uncovered`): tela toda "não se aplica", design legado ou ausente não devem nada.
@@ -266,6 +276,7 @@ export function shouldPauseGate(config, signals) {
     if (section !== true) {
       return {
         pause: true,
+        signal: 'screen-checklist',
         reason: `\`4-review/verifier.md\` sem a seção \`## Checklist de tela\` — o design decidiu ${firstOf(uncovered)}`
               + ' e o verificador não registrou a conferência contra a tela entregue'
               + ' (evals/review-checklist.md, "Contrato de tela")',
@@ -273,6 +284,7 @@ export function shouldPauseGate(config, signals) {
     }
     return {
       pause: true,
+      signal: 'screen-checklist',
       reason: `a seção \`## Checklist de tela\` não confere ${firstOf(uncovered)}`
             + ' — uma linha por item decidido de cada tela, mesmo quando não verificável',
     };
@@ -280,17 +292,18 @@ export function shouldPauseGate(config, signals) {
 
   if (signals.gate === 'plan') {
     const reason = planChecksPause(signals.planChecks);
-    if (reason) return { pause: true, reason };
+    if (reason) return { pause: true, signal: 'plan-checks', reason };
   }
 
   if (typeof signals.sliceCount === 'number' && signals.sliceCount > MAX_SLICES) {
     return {
       pause: true,
+      signal: 'slice-count',
       reason: `${signals.sliceCount} fatias, acima de ${MAX_SLICES} — o plano é grande demais para uma feature`,
     };
   }
 
-  return { pause: false, reason: '' };
+  return { pause: false, signal: null, reason: '' };
 }
 
 export function getRiskSignals(signals) {

package/src/lib/stack/stack-scan.js

@@ -99,7 +99,19 @@ function auditDotnet(files, read) {
   const otherDb = has(/^(Microsoft\.EntityFrameworkCore\.SqlServer|Pomelo\.EntityFrameworkCore\.MySql|MySql\.|MySqlConnector|Microsoft\.Data\.SqlClient|System\.Data\.SqlClient)/);
   rows.push({ layer: 'ORM', detected: ef.length > 0 ? 'EF Core' : (packages.has('Dapper') ? 'Dapper' : 'ausente'), expected: 'EF Core', ok: ef.length > 0 });
   rows.push({ layer: 'Banco', detected: npgsql.length > 0 ? 'Postgres (Npgsql)' : (otherDb.join(', ') || 'ausente'), expected: 'Neon (Postgres)', ok: npgsql.length > 0 && otherDb.length === 0 });
-  rows.push({ layer: 'IA', detected: has(/^Microsoft\.(Agents\.AI|Extensions\.AI)/).join(', ') || 'ausente', expected: 'MAF quando houver agentes', ok: true });
+  const semanticKernel = has(/^Microsoft\.SemanticKernel/);
+  const kernelFunction = grepFiles(source, read, /\[KernelFunction\b/);
+  const hostedAgents = has(/^Azure\.AI\.(Projects|Agents\.Persistent)\b/);
+  const floatingAi = has(/^(Microsoft\.Agents\.AI|Microsoft\.Extensions\.AI|OpenAI$|Google\.GenAI$|ModelContextProtocol)/)
+    .filter((p) => /\*|^[[(]/.test(packages.get(p) ?? ''));
+  rows.push({ layer: 'IA', detected: has(/^Microsoft\.(Agents\.AI|Extensions\.AI|SemanticKernel)/).join(', ') || 'ausente', expected: 'MAF quando houver agentes', ok: semanticKernel.length === 0 && kernelFunction.length === 0 && hostedAgents.length === 0 });
+  const antiPatterns = '`morph-spec standards --show ai-agents-setup#7-what-not-to-do-anti-patterns`';
+  if (semanticKernel.length > 0 || kernelFunction.length > 0) {
+    add('Alto', `Semantic Kernel em vez de MAF (${semanticKernel.join(', ') || '`[KernelFunction]`'})`, [...(semanticKernel.length > 0 ? projects : []), ...kernelFunction],
+      `\`Microsoft.Agents.AI\` (\`agent.RunAsync()\`, tool por \`AIFunctionFactory.Create()\`); ${antiPatterns}`);
+  }
+  if (hostedAgents.length > 0) add('Alto', `Serviço de agente hospedado (${hostedAgents.join(', ')})`, projects, `modelo direto por \`IChatClient\`; ${antiPatterns}`);
+  for (const p of floatingAi) add('Médio', `Versão flutuante de SDK de IA (${p} ${packages.get(p)})`, [], 'versão exata, a do pin (`morph-spec doctor --ai`)');
   rows.push({ layer: 'Jobs', detected: has(/^Hangfire/).length > 0 ? 'Hangfire' : 'ausente', expected: 'Hangfire só com razão real', ok: true });
   if (packages.has('Dapper') && ef.length === 0) add('Bloqueante', 'ORM diferente (Dapper puro sem EF Core)', projects, 'migrar o acesso a dados para EF Core');
   if (otherDb.length > 0) add('Bloqueante', `Banco diferente (${otherDb.join(', ')})`, projects, 'migrar para Neon (Postgres, Npgsql)');

package/src/lib/telemetry/metrics.js

@@ -4,6 +4,7 @@
 import { ingestedBytes } from './telemetry-reader.js';
 import { producerOf } from '../../../framework/hooks/shared/command-tokens.js';
 import { isFailedToolCall } from '../../../framework/hooks/shared/telemetry-logger.js';
+import { GATE_EVENT, GATE_STEPS } from '../../../framework/hooks/shared/gate-event.js';
 
 export const RERUN_WINDOW_MS = 10 * 60 * 1000;
 
@@ -122,6 +123,43 @@ function reuseStateOf(e) {
   return { state: 'absent', reason: null };
 }
 
+const newGateSlot = () => ({ decisions: 0, paused: 0, autoPassed: 0, approvedAfterPause: 0, reworkedAfterPause: 0, unapproved: 0, bySignal: {} });
+
+// A pause stays open until the next approve or a decision that no longer pauses on the same signal:
+// re-running gate-check over the same unchanged pause is not rework.
+function trackGate(gates, open, e) {
+  if (!e.gate || !GATE_STEPS.includes(e.step)) return;
+  const slot = gates[e.gate] ||= newGateSlot();
+  const key = `${e.feature || ''}\u0000${e.gate}`;
+  const pending = open.get(key);
+  const bySignal = (signal) => slot.bySignal[signal || 'desconhecido'] ||= { paused: 0, approvedAfterPause: 0, reworkedAfterPause: 0 };
+  const credit = (field) => {
+    slot[field] += 1;
+    bySignal(pending.signal)[field] += 1;
+  };
+
+  if (e.step === 'unapprove') {
+    slot.unapproved += 1;
+    return;
+  }
+  if (e.step === 'approve') {
+    if (pending) credit('approvedAfterPause');
+    open.delete(key);
+    return;
+  }
+  slot.decisions += 1;
+  if (pending && e.pause && e.signal === pending.signal) return;
+  if (pending) credit(e.source === 'manual' && !e.pause ? 'approvedAfterPause' : 'reworkedAfterPause');
+  if (e.pause) {
+    slot.paused += 1;
+    bySignal(e.signal).paused += 1;
+    open.set(key, { signal: e.signal });
+  } else {
+    slot.autoPassed += 1;
+    open.delete(key);
+  }
+}
+
 /** The returned shape is documented in framework/docs/CLI.md, "cost --metrics". */
 export function computeMetrics(events, opts = {}) {
   const top = Number.isInteger(opts.top) && opts.top > 0 ? opts.top : 10;
@@ -140,6 +178,8 @@ export function computeMetrics(events, opts = {}) {
   const lastFingerprint = new Map();
   const unchangedRepeats = {};
   const reuse = { runs: 0, byTree: {}, skipReasons: {} };
+  const gates = {};
+  const openPauses = new Map();
   let v2 = 0;
   let legacy = 0;
   let turnsObserved = false;
@@ -166,6 +206,11 @@ export function computeMetrics(events, opts = {}) {
       continue;
     }
 
+    if (e.event === GATE_EVENT) {
+      trackGate(gates, openPauses, e);
+      continue;
+    }
+
     if (e.event === 'Verify') {
       if (e.fingerprint && e.persisted !== false) {
         if (lastFingerprint.get(fkey) === e.fingerprint) {
@@ -291,6 +336,7 @@ export function computeMetrics(events, opts = {}) {
     },
     dotnetFullSuite: fullSuite,
     reuse,
+    gates,
     features: featureRows,
   };
 }

package/src/lib/tests-audit/audit.js

@@ -0,0 +1,96 @@
+import { execFileSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { basename, join } from 'path';
+import { isTestPath } from '../graph/sanitize.js';
+
+export const PROSE_MIN_HITS = 3;
+export const FAMILY_MIN_SIZE = 4;
+
+const TEST_FILE = /\.(cs|[cm]?[jt]sx?)$/i;
+const CS_CASE = /\[\s*\w*(Fact|Theory)\b/g;
+const JS_CASE = /^\s*(?:it|test)(?:\.each\s*\([\s\S]*?\))?\s*\(\s*['"`]/gm;
+const READS_DOC = /(ReadAll\w*|readFileSync)\s*\([^)]*\.(md|txt)\b/;
+const PROSE_ASSERT = /(?:Assert\.(?:Contains|DoesNotContain)\(\s*"|\.(?:toContain|toMatch)\(\s*['"`])([^"'`]{20,})/g;
+const CONSTANT_ASSERT = /Assert\.Equal\(\s*"[^"]*"\s*,\s*[A-Z]\w*(?:\.[A-Z]\w*)+\s*\)|expect\(\s*[A-Z][A-Z0-9_]+(?:\.[A-Z0-9_]+)*\s*\)\.toBe\(\s*['"`]/g;
+const CS_METHOD = /\[\s*\w*Fact\b[^\]]*\][\s\S]*?(?:void|Task)\s+(\w+)\s*\(/g;
+const LAYER = /^(\w+?)(Handler|Endpoints?|EndpointIntegration|Integration)Tests$/;
+
+function trackedTestFiles(root) {
+  try {
+    return execFileSync('git', ['ls-files', '-z'], { cwd: root, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 256 * 1024 * 1024 })
+      .toString().split('\0').filter((f) => f && TEST_FILE.test(f) && isTestPath(f));
+  } catch {
+    return null;
+  }
+}
+
+const lineOf = (text, index) => text.slice(0, index).split('\n').length;
+const countOf = (text, re) => (text.match(re) ?? []).length;
+
+function factFamilies(text) {
+  const byStem = new Map();
+  for (const m of text.matchAll(CS_METHOD)) {
+    const name = m[1];
+    const cut = name.lastIndexOf('_');
+    if (cut <= 0) continue;
+    const stem = name.slice(0, cut);
+    byStem.set(stem, [...(byStem.get(stem) ?? []), name]);
+  }
+  return [...byStem].filter(([, names]) => names.length >= FAMILY_MIN_SIZE).map(([stem, names]) => ({ stem, size: names.length }));
+}
+
+/** Read-only heuristics over the tracked test files: candidates to delete or merge, never verdicts. */
+export function auditTests(root) {
+  const files = trackedTestFiles(root);
+  if (files === null) return { ok: false, reason: 'git ls-files não respondeu — a auditoria lê só arquivos rastreados' };
+
+  const perFile = [];
+  const prose = [];
+  const constants = [];
+  const families = [];
+  const layers = new Map();
+  for (const file of files) {
+    let text;
+    try { text = readFileSync(join(root, file), 'utf8'); } catch { continue; }
+    const cases = /\.cs$/i.test(file) ? countOf(text, CS_CASE) : countOf(text, JS_CASE);
+    if (cases === 0) continue;
+    perFile.push({ file, cases });
+
+    const proseHits = [...text.matchAll(PROSE_ASSERT)].filter((m) => /\s/.test(m[1]));
+    if (READS_DOC.test(text) || proseHits.length >= PROSE_MIN_HITS) {
+      prose.push({ file, readsDoc: READS_DOC.test(text), literalAsserts: proseHits.length });
+    }
+    for (const m of text.matchAll(CONSTANT_ASSERT)) constants.push({ file, line: lineOf(text, m.index) });
+    for (const family of factFamilies(text)) families.push({ file, ...family });
+
+    const layer = LAYER.exec(basename(file).replace(/\.\w+$/, ''));
+    if (layer) layers.set(layer[1], [...(layers.get(layer[1]) ?? []), file]);
+  }
+
+  perFile.sort((a, b) => b.cases - a.cases);
+  return {
+    ok: true,
+    files: perFile.length,
+    cases: perFile.reduce((n, f) => n + f.cases, 0),
+    largest: perFile.slice(0, 10),
+    prose,
+    constants,
+    families,
+    layers: [...layers].filter(([, f]) => f.length > 1).map(([subject, f]) => ({ subject, files: f })),
+  };
+}
+
+export function renderTestsAudit(result) {
+  if (!result.ok) return `tests audit: ${result.reason}`;
+  const out = [`${result.cases} casos em ${result.files} arquivos de teste`, ''];
+  const section = (title, rows) => {
+    if (rows.length === 0) return;
+    out.push(`${title} (${rows.length})`, ...rows.map((r) => `  ${r}`), '');
+  };
+  section('Maiores arquivos', result.largest.map((f) => `${f.cases}  ${f.file}`));
+  section('Fixam texto ou leem doc — candidatos a apagar', result.prose.map((p) => `${p.file}${p.readsDoc ? ' (lê .md/.txt)' : ''}${p.literalAsserts ? ` — ${p.literalAsserts} asserts de frase` : ''}`));
+  section('Constante contra o próprio literal — candidatos a apagar', result.constants.map((c) => `${c.file}:${c.line}`));
+  section(`Famílias de [Fact] (≥ ${FAMILY_MIN_SIZE} com o mesmo prefixo) — candidatas a [Theory]`, result.families.map((f) => `${f.file} — ${f.stem}_* ×${f.size}`));
+  section('Mesmo assunto em mais de uma camada — mantenha a mais barata que morde', result.layers.map((l) => `${l.subject}: ${l.files.join(', ')}`));
+  return out.join('\n').trimEnd();
+}