@polymorphism-tech/morph-spec 8.43.0 → 8.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "8.43.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/project/worktree.js

@@ -882,19 +882,21 @@ export async function allocateWorktreeEnv(worktreePath, root, envKey, { morphFea
     } catch { morphFeature = null; }
   }
   try {
-    const { allocateEnvBlock, resolveFleetConfig, buildEnvFileContent } =
+    const { allocateEnvBlock, resolveFleetConfig, buildEnvFileContent, resolvePortAliases } =
       await import('../../lib/worktree/env-allocator.js');
     const common = execSync('git rev-parse --git-common-dir', { cwd: root, stdio: 'pipe' }).toString().trim();
     if (!common) return null;
     const gitCommonDir = resolve(root, common);
     const block = allocateEnvBlock(envKey, { gitCommonDir, ...resolveFleetConfig(root) });
     let stack = '';
+    let aliases = {};
     try {
       const cfg = JSON.parse(readFileSync(join(root, '.morph', 'config', 'config.json'), 'utf8').replace(/^/, ''));
       stack = cfg?.project?.stack || '';
+      aliases = resolvePortAliases(cfg).aliases;
     } catch { /* fail-open — stackless env still carries PORT */ }
     mkdirSync(join(worktreePath, '.morph'), { recursive: true });
-    writeFileSync(envPath, buildEnvFileContent(envKey, block, stack, { morphFeature }), 'utf8');
+    writeFileSync(envPath, buildEnvFileContent(envKey, block, stack, { morphFeature, aliases }), 'utf8');
     excludeWorktreePaths(root, [join('.morph', 'worktree.env')]);
     return block;
   } catch {
@@ -1238,10 +1240,17 @@ export function primaryRootUnexplainedDirt(root, feature, opts = {}) {
 }
 
 /**
- * Clear the root-side `.worktree` registration for a finished feature and commit
- * that cleanup scoped to its own pathspec. Runs whenever the worktree is
- * REMOVED — including `--pr`, where no merge landed — so a stale registration
- * never trips the anti-dupe guard or the next finish's root-clean.
+ * Clear the root-side `.worktree` registration for a finished feature. Runs
+ * whenever the worktree is REMOVED — including `--pr`, where no merge landed —
+ * so a stale registration never trips the anti-dupe guard or the next finish's
+ * root-clean.
+ *
+ * A registration that was committed on the default branch is cleared by a commit
+ * scoped to the feature's own pathspec. An untracked scaffold (what
+ * `create --worktree` leaves at the root) is never committed: the branch owns
+ * the feature, and committing the skeleton would put it on the default next to
+ * the archived copy. When the feature is already archived the skeleton is shed,
+ * backup first, by the same primitive `finish` uses.
  *
  * Written DIRECTLY (never saveState, which re-persists every sibling's
  * feature.json and can dirty the root outside this command's pathspec). The thin
@@ -1250,9 +1259,12 @@ export function primaryRootUnexplainedDirt(root, feature, opts = {}) {
  *
  * @param {string} root
  * @param {string} feature
+ * @param {{ stamp?: string }} [opts] - the caller's backup stamp, for the shed
+ * @returns {Promise<{ shedBackup: string|null }>}
  */
-export async function clearRootWorktreeRegistration(root, feature) {
+export async function clearRootWorktreeRegistration(root, feature, { stamp } = {}) {
   const featPathspec = `.morph/features/${feature}`;
+  const gitOpts = { cwd: root, stdio: 'pipe' };
   try {
     const rootFjPath = join(root, '.morph', 'features', feature, 'feature.json');
     if (existsSync(rootFjPath)) {
@@ -1265,16 +1277,19 @@ export async function clearRootWorktreeRegistration(root, feature) {
     }
   } catch { /* fail-open */ }
 
-  // Clearing that field can itself dirty the root (a committed registration
-  // survives the shed's checkout and the merge). Committing is in contract —
-  // finish already writes commits — and scoped to this feature's path only.
   try {
-    const dirtyAfter = execFileSync('git', ['status', '--porcelain', '--', featPathspec], { cwd: root, stdio: 'pipe' }).toString();
-    if (dirtyAfter.trim() !== '') {
-      execFileSync('git', ['add', '--', featPathspec], { cwd: root, stdio: 'pipe' });
-      execFileSync('git', ['commit', '-m', `morph-spec finish: clear ${feature} worktree registration`, '--', featPathspec], { cwd: root, stdio: 'pipe' });
+    const tracked = execFileSync('git', ['ls-files', '--', featPathspec], gitOpts).toString().trim() !== '';
+    if (!tracked) {
+      if (!existsSync(join(root, '.morph', 'archive', feature))) return { shedBackup: null };
+      return shedRootFeatureScope(root, feature, { stamp });
+    }
+    let unchanged = true;
+    try { execFileSync('git', ['diff', '--quiet', 'HEAD', '--', featPathspec], gitOpts); } catch { unchanged = false; }
+    if (!unchanged) {
+      execFileSync('git', ['commit', '-m', `morph-spec finish: clear ${feature} worktree registration`, '--', featPathspec], gitOpts);
     }
   } catch { /* fail-open — a dirty root is a nuisance, not a reason to fail */ }
+  return { shedBackup: null };
 }
 
 /**
@@ -1423,7 +1438,7 @@ export function pickRemovalFailure(stderrs) {
  * @returns {Promise<{ worktreeRemoved: boolean, ignoredBackup: string|null, discarded: string[],
  *   blockers: string[], ignoredBlocking: string[], shieldable: string[], declineReason: string|null,
  *   relinked: boolean, refused: boolean, infraLeftUnlinked: string[],
- *   removalFailure: {kind: string, detail: string}|null }>}
+ *   removalFailure: {kind: string, detail: string}|null, rootShedBackup: string|null }>}
  */
 export async function teardownWorktree(worktreePath, { root, feature, branch, options = {}, deleteBranch = true, addressByTarget = false, relinkOnFailure = false, stamp }) {
   // Drop the infra junctions FIRST, without following them — this is what makes
@@ -1453,6 +1468,7 @@ export async function teardownWorktree(worktreePath, { root, feature, branch, op
 
   let worktreeRemoved = false;
   let removalFailure = null;
+  let rootShedBackup = null;
   if (canRemove) {
     const attempt = await attemptWorktreeRemoval(worktreePath, root);
     worktreeRemoved = attempt.removed;
@@ -1473,7 +1489,7 @@ export async function teardownWorktree(worktreePath, { root, feature, branch, op
       const common = execSync('git rev-parse --git-common-dir', { cwd: root, stdio: 'pipe' }).toString().trim();
       if (common) releaseEnvBlock(feature, { gitCommonDir: resolve(root, common) });
     } catch { /* fail-open */ }
-    await clearRootWorktreeRegistration(root, feature);
+    ({ shedBackup: rootShedBackup } = await clearRootWorktreeRegistration(root, feature, { stamp }));
   }
 
   // Rollback (A4) — ONLY on a REFUSAL, never on a FAILURE. The two look alike
@@ -1568,6 +1584,7 @@ export async function teardownWorktree(worktreePath, { root, feature, branch, op
     refused,
     infraLeftUnlinked,
     removalFailure,
+    rootShedBackup,
   };
 }
 
@@ -1789,6 +1806,7 @@ export async function runWorktreeRemove(featureArg, options = {}) {
     if (teardown.replicable.length) out.replicatedInRoot = teardown.replicable;
     if (teardown.ignoredBackup) out.ignoredBackup = teardown.ignoredBackup;
     if (teardown.shieldable.length) out.backedUp = teardown.shieldable;
+    if (teardown.rootShedBackup) out.shedBackup = teardown.rootShedBackup;
   } else {
     out.refused = teardown.refused;
     if (teardown.blockers.length) out.reparsePoints = teardown.blockers;

package/src/commands/state/approve.js

@@ -5,9 +5,10 @@ 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';
 
 /**
  * The literal token `review-report.md` carries to declare which tree it
@@ -57,7 +58,7 @@ function reviewStaleness(featureName) {
     // of staleness — say "unstamped" rather than block on a guess.
     return { status: 'unstamped', head };
   }
-  if (reviewed === head) return { status: 'ok', reviewed, head };
+  if (!treeMovedSince(cwd, reviewed, head)) return { status: 'ok', reviewed, head };
 
   let ahead = 0;
   try {
@@ -246,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
@@ -345,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);
@@ -371,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/finish.js

@@ -65,6 +65,8 @@ export function buildPrTitle(feature, fj) {
   return prefix + (raw.length <= room ? raw : `${raw.slice(0, room - 1)}…`);
 }
 
+const MEMORY_NOTE = 'o fechamento desta feature já está registrado no repositório (commit de archive, `decisions.md`, use cases promovidos, `git log`) — memória de sessão só para o que NENHUM deles guarda: decisão do usuário, pendência a observar em produção, custo medido.';
+
 /**
  * `morph-spec finish <feature> --pr|--merge` — the single, symmetric close of a
  * feature's lifecycle, for BOTH the worktree flow and the common flow.
@@ -132,6 +134,8 @@ export async function finishCommand(feature, options = {}) {
   const emit = (obj) => {
     if (resumed) obj = { ...obj, resumed: true };
     if (obj?.finished === true) {
+      // The one path every finished:true takes; the --pr payload is built by hand, outside mergeOutput.
+      obj = { ...obj, memoryNote: MEMORY_NOTE };
       try {
         const common = execFileSync('git', ['rev-parse', '--git-common-dir'], { cwd: root, stdio: 'pipe' }).toString().trim();
         if (common) releaseClaim(feature, { gitCommonDir: resolve(root, common) });

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

@@ -3,11 +3,12 @@ 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';
 import { detectDefaultBranch, getHeadSha, getDiffStat, changedPathsAgainst } from '../../lib/git/default-branch.js';
+import { treeMovedSince } from '../../lib/git/evidence-staleness.js';
 import { readMorphConfig } from '../../lib/tasks/test-runner.js';
 import { oversizedTasks } from '../../lib/tasks/tasks-json-parser.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
@@ -23,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".
@@ -95,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.
@@ -202,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),
     };
   }
@@ -283,7 +201,7 @@ function collectSignals(featureName, feature, cwd, gateName) {
   // stamp com sha null (checkout sem git) ou stamp ausente lê como NOT stale.
   signals.verification = verification;
   if (verification?.status) signals.verificationStatus = verification.status;
-  signals.verificationStale = Boolean(verification?.sha && sha && verification.sha !== sha);
+  signals.verificationStale = treeMovedSince(cwd, verification?.sha, sha);
 
   // O nó e2e, separado do rollup de propósito: um `skip` NÃO reprova
   // `verification.status`, então sem estas duas chaves o gate lê 'pass' tanto
@@ -373,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);
       }
 
@@ -389,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) {