@polymorphism-tech/morph-spec 8.44.0 → 8.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "8.44.0",
+  "version": "8.45.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",
@@ -44,7 +44,7 @@
     "generate:check": "node scripts/generate-refs.js --check && node scripts/generate-ai-pin-props.js --check && node scripts/api-probe/probe.mjs --check",
     "generate-standards": "node scripts/generate-standards-registry.js",
     "generate-standards:check": "node scripts/generate-standards-registry.js --check",
-    "validate": "node scripts/validate-framework.js && node scripts/check-rubric-parity.js",
+    "validate": "node scripts/validate-framework.js",
     "freshness": "node scripts/check-freshness.js",
     "verify": "npm run generate:check && npm run generate-standards:check && npm run validate && npm run freshness && npm test",
     "test": "node scripts/run-tests.mjs",

package/src/commands/e2e/e2e.js

@@ -178,7 +178,7 @@ export async function e2eUpCommand(featureName, options = {}) {
     if (options.json) {
       console.log(JSON.stringify({ status: 'busy', feature: featureName, busy: { reason: err.reason, waitedMs: err.waitedMs } }, null, 2));
     }
-    console.error(chalk.yellow(`\n⏳ e2e up não rodou: ${err.message}. Tente de novo quando liberar (\`morph-spec heavy status\`).\n`));
+    console.error(chalk.yellow(`\n⏳ e2e up não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\`).\n`));
     process.exit(EXIT_BUSY);
   } finally {
     gate.release();

package/src/commands/project/heavy.js

@@ -45,7 +45,7 @@ export function heavyRunCommand(command, options = {}) {
     gate.enter(file);
   } catch (err) {
     if (!(err instanceof HeavyBusyError)) throw err;
-    console.error(chalk.yellow(`\n⏳ ${file} não rodou: ${err.message}. Tente de novo quando liberar (\`morph-spec heavy status\`).\n`));
+    console.error(chalk.yellow(`\n⏳ ${file} não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
     process.exit(EXIT_BUSY);
   }
 

package/src/commands/project/status.js

@@ -64,7 +64,7 @@ function checkPhaseOutputs(phaseKey, feature) {
   const phaseOutputMap = {
     proposal: ['proposal', 'stackScan'],
     uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-    plan: ['spec', 'mandate', 'tasks', 'decisions'],
+    plan: ['spec', 'tasks', 'decisions'],
     implement: ['recap'],
     review: ['reviewReport']
   };
@@ -102,7 +102,7 @@ function formatPhase(phaseKey, currentPhase, feature, options = {}) {
     const phaseOutputMap = {
       proposal: ['proposal', 'stackScan'],
       uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-      plan: ['spec', 'mandate', 'tasks', 'decisions'],
+      plan: ['spec', 'tasks', 'decisions'],
       implement: ['recap'],
       review: ['reviewReport']
     };
@@ -160,7 +160,7 @@ function getNextSteps(feature) {
   // Check for missing outputs in current phase
   const phaseOutputMap = {
     proposal: ['proposal'],
-    plan: ['spec', 'mandate', 'tasks'],
+    plan: ['spec', 'tasks'],
     implement: ['recap'],
     review: ['reviewReport']
   };

package/src/commands/state/approve.js

@@ -5,7 +5,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory, derivePhase } from '../../core/state/state-manager.js';
 import { unmetPrereqs } from '../../core/state/gate-order.js';
-import { evaluatorReportState, COMPOSITE_SCORE_TOKEN } from '../../lib/evaluator-report.js';
+import { evaluatorReportState, VERDICT_TOKEN } from '../../lib/evaluator-report.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 import { uiuxAutoApprovalBlock } from '../../lib/specs/screen-checklist.js';
 import { treeMovedSince } from '../../lib/git/evidence-staleness.js';
@@ -247,18 +247,6 @@ export async function approveCommand(featureName, gateName, options = {}) {
       process.exit(1);
     }
 
-    // Gate 3 evaluator backstop: the composite score of a feature comes from
-    // the INDEPENDENT evaluator (persona `evaluator`, fresh context) dispatched
-    // by morph-review — never from self-assessment by whoever implemented it.
-    // Nothing enforced that. When the dispatch was impossible (observed: a
-    // session instruction forbade sub-agents), the flow still produced a
-    // review-report.md carrying a composite score and a verdict, with a caveat
-    // in prose nobody is obliged to read. A gate that yields a grade without
-    // its evaluator is not a gate.
-    //
-    // The escape hatch is EXPLICIT and RECORDED (`--self-assessed`), never
-    // silent — the silence is the defect. `--force` deliberately does NOT
-    // bypass this: it is the out-of-order recovery flag, a different concern.
     // Gate 3 staleness backstop (D1): a review reviews a TREE, and the tree
     // moves. Observed: review-report.md written at b30ac6e, then T3 landed and
     // inverted the default of a business rule; the report stayed in the repo
@@ -346,25 +334,16 @@ export async function approveCommand(featureName, gateName, options = {}) {
           process.exit(1);
         }
       } else {
-        // `existsSync` puro não bastava: um evaluator-report SEM o token
-        // `**Composite-Score:**` passava aqui E era descartado pelo gate-check
-        // (que então caía no proxy de taskScores). O resultado era um Gate 3
-        // carimbado `approvedBy: "auto"` sobre a média das auto-avaliações de
-        // quem implementou — precisamente o que MORPH.md §5 proíbe. Arquivo
-        // presente sem veredito legível é relatório OCO, não relatório.
         const report = evaluatorReportState(process.cwd(), featureName);
         if (report.status !== 'ok') {
           if (!options.selfAssessed) {
             if (report.status === 'missing') {
               console.error(chalk.red('\n❌ Gate 3 exige o avaliador independente — `4-review/evaluator-report.md` não existe.'));
             } else {
-              console.error(chalk.red('\n❌ Gate 3: o `4-review/evaluator-report.md` existe mas está OCO —'));
-              console.error(chalk.red(`   falta a linha \`${COMPOSITE_SCORE_TOKEN} {n.n}\`, o veredito legível por máquina.`));
-              console.error(chalk.gray('   Sem ela o gate-check não lê o score real e cai na média das auto-avaliações.'));
-              console.error(chalk.gray('   Peça ao avaliador o relatório completo (morph-review §4) ou complete a linha.'));
+              console.error(chalk.red(`\n❌ Gate 3: o \`4-review/evaluator-report.md\` não tem \`${VERDICT_TOKEN} SHIP|FIX\`.`));
+              console.error(chalk.gray('   Peça ao avaliador o relatório completo (morph-review §4) ou retome-o por SendMessage.'));
             }
-            console.error(chalk.gray('   O score composto da feature vem do avaliador (persona `evaluator`, contexto fresco)'));
-            console.error(chalk.gray('   despachado pela morph-review, nunca de auto-avaliação de quem implementou.'));
+            console.error(chalk.gray('   O veredito vem do avaliador (persona `evaluator`, contexto fresco), nunca de quem implementou.'));
             console.error(chalk.gray('   Se o dispatch for impossível nesta sessão, aprove com --self-assessed —'));
             console.error(chalk.gray('   a degradação fica registrada no feature.json e aparece no `list`/`fleet`.\n'));
             process.exit(1);
@@ -372,30 +351,9 @@ export async function approveCommand(featureName, gateName, options = {}) {
           selfAssessed = true;
         }
 
-        // REAVALIAÇÃO VISÍVEL. O `evaluator-report.md` é append-only, então uma
-        // segunda rodada acrescenta um `**Composite-Score:**` ao fim e o arquivo
-        // passa a carregar mais de um veredito. O gate decide pelo ÚLTIMO (o
-        // vigente) — mas aprovar em silêncio um relatório com notas superadas
-        // esconde do humano exatamente o fato que ele precisa ver: a nota MUDOU,
-        // e numa das rodadas medidas em campo ela CAIU (8.9 → 8.3, quando uma
-        // correção abriu um bloqueante).
-        //
-        // Aqui é o lugar: `approve` é a precondição humana do Gate 3 e a única
-        // superfície onde uma pessoa lê o veredito antes de carimbá-lo. Sem este
-        // bloco, `scoreTokens`/`superseded` seriam mitigação inerte — campo que
-        // ninguém lê não mitiga nada.
-        if (report.status === 'ok' && report.scoreTokens > 1) {
-          console.log(chalk.yellow(
-            `
-⚠️  O relatório do avaliador tem ${report.scoreTokens} vereditos (o arquivo é append-only).`
-          ));
-          console.log(chalk.gray(`   Vigente (o que o gate usa): ${report.score}`));
-          console.log(chalk.gray(`   Superado(s), na ordem do arquivo: ${report.superseded.join(', ')}`));
-          if (report.superseded.some((n) => n > report.score)) {
-            console.log(chalk.yellow('   A nota CAIU em relação a uma rodada anterior — confira o que a correção'));
-            console.log(chalk.yellow('   abriu antes de aprovar; o relatório mantém a análise das duas rodadas.'));
-          }
-          console.log('');
+        if (report.status === 'ok' && report.superseded.length > 0) {
+          console.log(chalk.yellow(`\n⚠️  O relatório do avaliador tem ${report.superseded.length + 1} vereditos (append-only).`));
+          console.log(chalk.gray(`   Vigente: ${report.verdict}, ${report.blockers.length} bloqueador(es). Superados: ${report.superseded.join(', ')}\n`));
         }
       }
     }

package/src/commands/state/gate-check.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'fs';
 import { getFeature } from '../../core/state/state-manager.js';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { shouldPauseGate, getRiskSignals, classifyE2eSkip } from '../../lib/risk-detector.js';
-import { evaluatorCompositeScore, evaluatorProofState, minProofScore, mediaProofScore } from '../../lib/evaluator-report.js';
+import { evaluatorReportState, evaluatorMediaSection } from '../../lib/evaluator-report.js';
 import { collectScreenChecklist } from '../../lib/specs/screen-checklist.js';
 import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-decision.js';
 import { minimatch } from 'minimatch';
@@ -24,13 +24,8 @@ import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/featu
  *   - standardsViolations / designSystemDivergence: still an LLM's
  *     natural-language read (see the R4 report — no deterministic detector
  *     exists in JS yet).
- *   - evalScore: escape hatch for the TRUE Gate-3 composite score. Since R4
- *     the evaluator-report carries a machine-readable `**Composite-Score:**`
- *     token that this command parses by itself (see evaluatorCompositeScore),
- *     so the override is only needed for legacy reports without the token —
- *     there the taskScores-average proxy is the fallback.
  */
-const OVERRIDABLE_SIGNAL_KEYS = ['standardsViolations', 'designSystemDivergence', 'evalScore'];
+const OVERRIDABLE_SIGNAL_KEYS = ['standardsViolations', 'designSystemDivergence'];
 
 /**
  * Os paths de standard que fazem uma feature ser "de midia".
@@ -96,31 +91,6 @@ function readTasks(featureName) {
   }
 }
 
-/**
- * Composite eval score PROXY: the average of `lastScore` across every task
- * recorded in `feature.taskScores`, rounded to 1 decimal. `lastScore` (not
- * `bestScore`) on purpose — a gate check reports current-state risk, and
- * `bestScore` can be a stale high-water mark from an attempt the code no
- * longer matches. "average" mirrors morph-apply's own Gate-3 risk-signal
- * prose ("Score médio < 9 no review-report" — SKILL.md §5).
- *
- * This is explicitly NOT the true Gate-3 composite score (see
- * OVERRIDABLE_SIGNAL_KEYS doc above) — undefined (key omitted) when no task
- * has been scored yet, so shouldPauseGate's `typeof === 'number'` check
- * naturally skips it instead of pausing on a false 0.
- *
- * @param {object} feature
- * @returns {number|undefined}
- */
-function compositeEvalScore(feature) {
-  const scores = Object.values(feature.taskScores || {})
-    .map((t) => t.lastScore)
-    .filter((n) => typeof n === 'number');
-  if (scores.length === 0) return undefined;
-  const avg = scores.reduce((a, b) => a + b, 0) / scores.length;
-  return Math.round(avg * 10) / 10;
-}
-
 /**
  * "Esta feature mexeu em prompt ou em modelo?" — em duas metades, porque uma só
  * não distingue as duas situações que pedem ações diferentes.
@@ -203,78 +173,25 @@ function collectSignals(featureName, feature, cwd, gateName) {
   if (gateName === 'plan') signals.oversizedTasks = oversizedTasks({ tasks });
 
   // Só onde o checklist decide algo: no fecho do design e no ship. Fato de
-  // disco, fora de OVERRIDABLE_SIGNAL_KEYS como `mutationProof`.
+  // disco, fora de OVERRIDABLE_SIGNAL_KEYS.
   if (gateName === 'uiux' || gateName === 'review') {
     signals.screenChecklist = collectScreenChecklist(cwd, featureName, gateName);
   }
 
-  const evalScore = compositeEvalScore(feature);
-  if (evalScore !== undefined) {
-    signals.evalScore = evalScore;
-    signals.evalScoreSource = 'taskScores-proxy';
-  }
-
-  // No Gate 3, o score verdadeiro do avaliador independente (token
-  // Composite-Score no evaluator-report.md) tem precedência sobre o proxy.
   if (gateName === 'review') {
-    const trueComposite = evaluatorCompositeScore(cwd, featureName);
-    if (trueComposite !== undefined) {
-      signals.evalScore = trueComposite;
-      signals.evalScoreSource = 'evaluator-report';
-    }
-
-    // PROVA DE MUTAÇÃO, derivada do MESMO módulo leitor do relatório. Um score
-    // alto diz o que o avaliador ACHOU; a seção `## Mutações` diz se ele
-    // PROVOU. Sem ela, um Gate 3 auto-passa sobre uma suíte que ninguém mostrou
-    // que morde — o defeito que as rubricas de `evals/proof-rubrics/` existem
-    // para nomear.
-    //
-    // `productionCode` viaja DENTRO do sinal para que risk-detector.js continue
-    // puro sobre fatos já reunidos: a divisão é "gate-check COLETA do disco,
-    // risk-detector DECIDE". Uma feature 100% `docs` não tem o que mutar, e
-    // exigir prova dela seria pedir uma cerimônia vazia — que é como uma regra
-    // vira ruído e depois é desligada.
-    //
-    // Task SEM `group` conta como código de produção: `group` é opcional no
-    // schema e o default documentado é `backend`. O conservador aqui é assumir
-    // que HÁ código — errar para o lado de pedir prova custa uma pausa; errar
-    // para o outro lado devolve o gate cego.
-    //
-    // `tasks` vazio (plano ausente ou ilegível) ⇒ `productionCode: false` ⇒ NÃO
-    // pausa. Fail-open deliberado: sem plano, não há como AFIRMAR que existe
-    // código de produção, e uma regra nova não pode travar feature legada.
-    //
-    // Nada disto entra em OVERRIDABLE_SIGNAL_KEYS: são fatos de disco, como
-    // `gate`/`workType`/`e2e*`. Um `--signals '{"mutationProof":{"section":true}}'`
-    // compraria o Gate 3 exatamente como um `e2eStatus: "pass"` forjado.
-    const proof = evaluatorProofState(cwd, featureName);
-    signals.mutationProof = {
-      section: proof.mutationSection,
-      min: minProofScore(proof.proofScores),
-      productionCode: tasks.some((t) => (t?.group ?? 'backend') !== 'docs'),
-    };
-
-    // PROVA DE MÍDIA, mesmo módulo leitor e mesma disciplina anti-spoof. As
-    // quatro afirmações de uma feature de mídia (custo, revisão humana,
-    // marcação, hot path não bloqueado) são propriedades ESTRUTURAIS, e por isso
-    // `score` limita `architecture` e não `test-coverage` — daí `media` ficar
-    // FORA do `min` acima.
-    //
-    // `featureGeneratesMedia` é determinístico e vem do DISCO, nunca de
-    // julgamento: existe ao menos uma task cujo array `standards` cita um dos
-    // três paths de standard de mídia. É o mesmo formato do `productionCode`
-    // acima e usa um campo que o Gate 2 congelou. Mora numa função exportada
-    // (acima) porque um predicado que decide se um guardrail arma precisa de
-    // canário próprio — e porque o prefixo `framework/` precisa ser normalizado
-    // ali, num lugar só.
-    //
-    // A isenção é automática e é o comportamento certo: a maioria das features
-    // não gera mídia, e exigir a seção delas seria cerimônia vazia — que é como
-    // uma regra vira ruído e depois é desligada. `tasks` vazio ⇒ false ⇒ não
-    // pausa, o mesmo fail-open por ausência do sinal irmão.
+    const report = evaluatorReportState(cwd, featureName);
+    signals.evaluatorVerdict = report.status === 'ok'
+      ? {
+        status: 'ok',
+        verdict: report.verdict,
+        blockers: report.blockers.length,
+        blockerIds: report.blockers.map((b) => b.id),
+        untyped: report.untyped.length,
+        superseded: report.superseded,
+      }
+      : { status: report.status };
     signals.mediaClaims = {
-      section: proof.mediaSection,
-      score: mediaProofScore(proof.proofScores),
+      section: evaluatorMediaSection(cwd, featureName),
       featureGeneratesMedia: featureGeneratesMedia(tasks),
     };
   }
@@ -374,7 +291,7 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
         process.exit(1);
       }
       if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        console.error(chalk.red('\n❌ Invalid --signals: expected a JSON object, e.g. \'{"evalScore":9.2}\'\n'));
+        console.error(chalk.red('\n❌ Invalid --signals: expected a JSON object, e.g. \'{"standardsViolations":[]}\'\n'));
         process.exit(1);
       }
 
@@ -390,13 +307,6 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
         if (key in parsed) overrides[key] = parsed[key];
       }
 
-      // Um `evalScore` vindo de --signals substitui o VALOR mas não a
-      // PROCEDÊNCIA: sem isto o merge cego abaixo deixaria `evalScoreSource`
-      // com o que collectSignals escreveu ('taskScores-proxy'), e o sinal de
-      // auditoria passaria a mentir sobre de onde veio o número. `signals-
-      // override` não está em OVERRIDABLE_SIGNAL_KEYS — o caller não pode
-      // forjá-lo, mesmo anti-spoof de `gate`/`workType`.
-      if ('evalScore' in overrides) overrides.evalScoreSource = 'signals-override';
     }
 
     const cwd = process.cwd();

package/src/commands/state/gate-decision.js

@@ -68,7 +68,7 @@ export async function persistGateDecision(featureName, gateName, { pause, reason
  * [--signals <json>] [--trust <mode>]` — record the trust decision for a gate
  * under `gateDecisions` in the authoritative feature.json.
  *
- * Same philosophy as `morph-spec score`: the timestamp (`decidedAt`) is
+ * The timestamp (`decidedAt`) is
  * stamped server-side and the write is atomic (state-manager). This replaces
  * the manual Edit of feature.json from the skills — which collided with the
  * state-sync hook rewriting the file between the agent's Read and Edit

package/src/commands/state/report-check.js

@@ -35,9 +35,15 @@ import { join } from 'path';
 import { readTelemetryEvents, isFailedToolCall } from '../../../framework/hooks/shared/telemetry-logger.js';
 import { treeState, snapshotTree } from '../../lib/git/tree-state.js';
 import { atomicWriteJson } from '../../core/state/state-manager.js';
+import { minimatch } from 'minimatch';
+import { evaluatorVerdictFromText, VERDICTS } from '../../lib/evaluator-report.js';
+import { evaluatorModelFor } from '../../lib/risk-detector.js';
+import { changedPathsAgainst, detectDefaultBranch } from '../../lib/git/default-branch.js';
+import { readMorphConfig } from '../../lib/tasks/test-runner.js';
+import { featureGeneratesMedia } from './gate-check.js';
 
 /**
- * The four mandatory items of the report contract, as detectable markers.
+ * The mandatory items of the report contract, as detectable markers.
  *
  * HEURISTIC BY CONSTRUCTION, and deliberately loose: the contract asks for
  * content, not for a fixed template, and reports written before this command
@@ -48,10 +54,8 @@ import { atomicWriteJson } from '../../core/state/state-manager.js';
 const REPORT_MARKERS = [
   // (2) files touched — a list line carrying a path or a backticked identifier
   { id: 'files', re: /^\s*[-*]\s+.*[`/\\].*$/m },
-  // (4) self-score 0-10
-  { id: 'score', re: /score[^\n]*?\b(10|\d)(?:[.,]\d+)?\b/i },
-  // (3) problems found (or an explicit "none")
-  { id: 'problems', re: /problema|issue|blocker|nenhum|impedimento/i },
+  // (3) each doneCriteria, met or not, with its evidence
+  { id: 'criteria', re: /crit[ée]rio|doneCriteria|p[óo]s-condi[çc][ãa]o|atendid/i },
 ];
 
 /** (1) "what was done" — prose beyond the structural markers. */
@@ -60,9 +64,6 @@ const MIN_PROSE_CHARS = 80;
 /**
  * The partial-report marker of the dispatch contract (clause 5, ADR-004): a
  * sub-agent nearing its `maxTurns` ceiling writes `PARCIAL` on the FIRST line.
- * Read on purpose, never inferred from a missing score: the score marker above
- * is loose by design, and a partial saying "auto-score: pendente (0-10 no
- * final)" matches it — with the other items present it would audit as `ok`.
  * Tolerates heading/bold/quote typography (`# PARCIAL`, `**PARCIAL**`).
  */
 const PARTIAL_MARKER = /^[\s#>*_]*PARCIAL\b/;
@@ -96,12 +97,12 @@ function evaluatorPath(cwd, feature) {
  * items can be found in it.
  */
 export function inspectReport(path) {
-  if (!existsSync(path)) return { exists: false, complete: false, missing: ['what', 'files', 'problems', 'score'] };
+  if (!existsSync(path)) return { exists: false, complete: false, missing: ['what', 'files', 'criteria'] };
   let body = '';
   try {
     body = readFileSync(path, 'utf8');
   } catch {
-    return { exists: true, complete: false, missing: ['what', 'files', 'problems', 'score'], unreadable: true };
+    return { exists: true, complete: false, missing: ['what', 'files', 'criteria'], unreadable: true };
   }
 
   const missing = REPORT_MARKERS.filter((m) => !m.re.test(body)).map((m) => m.id);
@@ -122,6 +123,29 @@ export function inspectReport(path) {
   return { exists: true, complete: missing.length === 0, missing, partial };
 }
 
+/** The evaluator report is complete when it carries a readable verdict and is not partial. */
+export function inspectEvaluatorReport(path) {
+  if (!existsSync(path)) return { exists: false, complete: false };
+  let body = '';
+  try { body = readFileSync(path, 'utf8'); } catch { return { exists: true, complete: false, unreadable: true }; }
+  const firstLine = body.split('\n').find((l) => l.trim() !== '') ?? '';
+  const partial = PARTIAL_MARKER.test(firstLine);
+  const { verdict } = evaluatorVerdictFromText(body);
+  return { exists: true, complete: !partial && VERDICTS.includes(verdict), partial, verdict: verdict ?? null };
+}
+
+function evaluatorDispatch(cwd, tasks) {
+  let changedFiles = [];
+  try { changedFiles = changedPathsAgainst(detectDefaultBranch(cwd), cwd); } catch { changedFiles = []; }
+  const watch = readMorphConfig(cwd)?.project?.evals?.watch;
+  const globs = Array.isArray(watch) ? watch.filter((g) => typeof g === 'string' && g.trim()) : [];
+  return evaluatorModelFor({
+    changedFiles,
+    promptModelTouched: changedFiles.some((f) => globs.some((g) => minimatch(f, g))),
+    generatesMedia: featureGeneratesMedia(tasks),
+  });
+}
+
 /** How many of a task's declared outputs actually exist on disk. */
 function outputEvidence(cwd, taskOutputs) {
   const expected = Array.isArray(taskOutputs) ? taskOutputs : [];
@@ -312,16 +336,17 @@ function snapshotPath(cwd, feature) {
  * dispatched when there is one. `beforeEval` takes a new snapshot after the
  * comparison, so the output still shows what changed since the previous one.
  */
-function treeFor(cwd, feature, beforeEval) {
+function treeFor(cwd, feature, beforeEval, tasks = []) {
   const path = snapshotPath(cwd, feature);
   let snapshot = null;
   try { if (existsSync(path)) snapshot = JSON.parse(readFileSync(path, 'utf8')); } catch { snapshot = null; }
   const tree = treeState(cwd, { snapshot });
   if (!beforeEval) return { tree };
+  const evaluatorModel = evaluatorDispatch(cwd, tasks);
   const next = snapshotTree(cwd);
-  if (!next) return { tree, beforeEval: null };
+  if (!next) return { tree, beforeEval: null, evaluatorModel };
   atomicWriteJson(path, next);
-  return { tree, beforeEval: { at: next.at, files: Object.keys(next.files).length } };
+  return { tree, beforeEval: { at: next.at, files: Object.keys(next.files).length }, evaluatorModel };
 }
 
 /**
@@ -356,21 +381,21 @@ export function reportCheckCommand(feature, taskId, options = {}) {
     if (unknown.length) emit({ error: `task(s) ${unknown.join(', ')} não existe(m) em tasks.json`, feature }, 1);
     const results = taskId.map((id) => checkTask(cwd, feature, tasks.find((t) => t.id === id)));
     const clean = results.every((r) => r.verdict === 'ok');
-    emit({ feature, results, clean, ...treeFor(cwd, feature, options.beforeEval) }, clean ? 0 : 1);
+    emit({ feature, results, clean, ...treeFor(cwd, feature, options.beforeEval, tasks) }, clean ? 0 : 1);
   }
 
   if (taskId) {
     const task = tasks.find((t) => t.id === taskId);
     if (!task) emit({ error: `task "${taskId}" não existe em tasks.json`, feature }, 1);
     const result = checkTask(cwd, feature, task);
-    emit({ feature, ...result, hint: ACTION_HINT[result.action], ...treeFor(cwd, feature, options.beforeEval) }, result.verdict === 'ok' ? 0 : 1);
+    emit({ feature, ...result, hint: ACTION_HINT[result.action], ...treeFor(cwd, feature, options.beforeEval, tasks) }, result.verdict === 'ok' ? 0 : 1);
   }
 
   // Whole-feature audit: every DONE task owes a report; a pending one does not.
   const results = tasks.filter((t) => t.status === 'done').map((t) => checkTask(cwd, feature, t));
-  const evaluator = inspectReport(evaluatorPath(cwd, feature));
+  const evaluator = inspectEvaluatorReport(evaluatorPath(cwd, feature));
   const clean = results.every((r) => r.verdict === 'ok');
-  emit({ feature, results, evaluator, clean, ...treeFor(cwd, feature, options.beforeEval) }, clean ? 0 : 1);
+  emit({ feature, results, evaluator, clean, ...treeFor(cwd, feature, options.beforeEval, tasks) }, clean ? 0 : 1);
 }
 
 function printHuman(obj) {

package/src/commands/validation/mutate.js

@@ -176,7 +176,7 @@ export async function mutateCommand(feature, options = {}) {
       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}. Tente de novo quando liberar (morph-spec heavy status).`, EXIT.busy);
+    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;
   }

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

@@ -0,0 +1,28 @@
+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);
+}

package/src/commands/validation/validate-feature.js

@@ -84,28 +84,6 @@ const OUTPUT_SECTIONS = {
       ['Performance', 'Desempenho'],
     ],
   },
-  // morph-plan (mandate.md) emits: Stack, Standards obrigatórios,
-  // Patterns proibidos, Verificação de runtime, Checklist de done.
-  'mandate.md': {
-    required: [
-      'Stack',
-      ['Standards', 'Padrões', 'Padroes'],
-      ['Done', 'Pronto', 'Checklist', 'Critérios de done', 'Definition of Done'],
-    ],
-    recommended: [
-      ['Patterns proibidos', 'Padrões proibidos', 'Padroes proibidos', 'Forbidden Patterns', 'Forbidden', 'Proibido'],
-      // Recommended rather than required on purpose: mandate.md freezes after
-      // Gate 2 (protect-spec-files blocks Write AND Edit), so promoting this to
-      // `required` would fail every in-flight feature with no way to fix it.
-      // New mandates get the section from morph-plan §4; the enforcement that
-      // actually matters is verify's e2e node, not this heading check.
-      ['Verificação de runtime', 'Verificacao de runtime', 'Runtime', 'E2E'],
-    ],
-    optional: [
-      ['Riscos', 'Risks'],
-      ['Acesso a dados', 'Data Access', 'Repository', 'Repositório'],
-    ],
-  },
   // decisions.md follows the ADR convention: an `### ADR-NNN` heading with
   // `**Status:** / **Context:** / **Decision:**` line-start bold labels.
   'decisions.md': {
@@ -123,19 +101,14 @@ const OUTPUT_SECTIONS = {
       ['Custos', 'Costs'],
     ],
   },
-  // morph-review emits: Scores por dimensão, Bloqueantes, Melhorias,
-  // Recomendação final.
   'review-report.md': {
     required: [
-      ['Scores', 'Score', 'Pontuação', 'Pontuacao', 'Scoring'],
-      ['Recomendação', 'Recomendacao', 'Recommendation'],
+      ['Veredito', 'Verdict'],
     ],
     recommended: [
-      ['Bloqueantes', 'Bloqueante', 'Blockers'],
-    ],
-    optional: [
-      ['Melhorias', 'Improvements', 'Recomendadas'],
+      ['Bloqueadores', 'Bloqueantes', 'Blockers'],
     ],
+    optional: [],
   },
 };
 
@@ -145,13 +118,13 @@ const OUTPUT_SECTIONS = {
 const PHASE_OUTPUTS = {
   proposal: ['proposal.md'],
   uiux: ['design-system.md', 'mockups.md', 'components.md', 'flows.md'],
-  plan: ['spec.md', 'mandate.md', 'tasks.json'],
+  plan: ['spec.md', 'tasks.json'],
   implement: ['recap.md'],
   review: ['review-report.md'],
 };
 
 // Work types whose plan phase (see src/core/work-types.js) skips proposal.md/
-// spec.md/mandate.md — chore and hotfix stamp proposal+plan gates at birth
+// spec.md — chore and hotfix stamp proposal+plan gates at birth
 // (policy-approved, no human deliberation over those docs) and go straight to
 // tasks.json. Validating the full plan doc set against a feature that was
 // never asked to write those docs would be a false failure, not a real gap.

package/src/commands/validation/verify.js

@@ -203,8 +203,7 @@ const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'],
  * paths to it — never a verdict, because a verdict about nothing is worse
  * than a refusal:
  *   - unknown feature, or unknown task id (the task's `group` decides the
- *     rubric, so it is a hard usage error here, unlike the advisory warning
- *     `morph-spec score` gives for the same situation);
+ *     rubric, so it is a hard usage error here);
  *   - `--filter` that matches no declared node (a filtered-to-empty run is
  *     green and proves nothing);
  *   - `--record-baseline` with nowhere to write (no `config.json`), or with a
@@ -263,7 +262,7 @@ export async function verifyCommand(featureName, taskId, options = {}) {
       process.exit(2);
     }
     // Ocupado não é veredito: nada foi verificado, então não há stamp nem
-    // evento, e o exit 3 diz "tente de novo", nunca "vermelho".
+    // evento, e o exit 3 nunca é "vermelho".
     if (err instanceof HeavyBusyError) {
       if (options.json) {
         const holders = err.holders.map(({ pid, label, feature, node, since }) => ({ pid, label, feature, node, since }));
@@ -271,7 +270,7 @@ export async function verifyCommand(featureName, taskId, options = {}) {
           status: 'busy', persisted: false, busy: { reason: err.reason, holders, freeGb: err.freeGb, waitedMs: err.waitedMs },
         }, null, 2));
       }
-      console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — tente de novo quando liberar (\`morph-spec heavy status\`).\n`));
+      console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
       process.exit(3);
     }
     throw err;

package/src/core/paths/output-schema.js

@@ -46,7 +46,6 @@ export const OUTPUT_SCHEMA = {
 
   // 2-plan/
   spec:           { filename: 'spec.md',               phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
-  mandate:        { filename: 'mandate.md',            phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
   tasks:          { filename: 'tasks.json',            phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan', mutableFields: ['status', 'outputs', 'notes'] },
   decisions:      { filename: 'decisions.md',          phaseDir: '2-plan',      phase: 'plan',      protected: false },
   // Veredito REUSAR/ESTENDER/CRIAR por conceito que a feature introduz, com a
@@ -55,7 +54,6 @@ export const OUTPUT_SCHEMA = {
   // como decisions.md: é registro vivo — o implementador que descobre um alvo
   // melhor no meio da task precisa poder anotar, e congelá-lo transformaria a
   // correção num bloqueio de gate.
-  reuseMap:       { filename: 'reuse-map.md',          phaseDir: '2-plan',      phase: 'plan',      protected: false },
   // N files, one per system use case — the behaviour layer the plan distils
   // BEFORE spec.md/tasks.json. Deliberately NOT protected: editing a use case
   // after Gate 2 is the supported way to change behaviour and re-run implement;

package/src/core/state/state-manager.js

@@ -581,7 +581,6 @@ export async function createFeature(featureName, options = {}) {
       review: { approved: false, timestamp: null, approvedBy: null }
     },
     gateDecisions: {},
-    taskScores: {},
     tasks: {
       total: 0,
       completed: 0,
@@ -782,7 +781,7 @@ function findClosestMatch(inputType, validTypes) {
 /**
  * Mark output as created
  * @param {string} featureName - Feature name
- * @param {string} outputType - Output type (proposal, spec, mandate, etc.)
+ * @param {string} outputType - Output type (proposal, spec, tasks, etc.)
  */
 export async function markOutput(featureName, outputType) {
   await ensureFeature(featureName);