@polymorphism-tech/morph-spec 8.33.0 → 8.35.0

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

@@ -2,10 +2,12 @@ import chalk from 'chalk';
 import { existsSync, readFileSync } from 'fs';
 import { getFeature } from '../../core/state/state-manager.js';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
-import { shouldPauseGate, getRiskSignals } from '../../lib/risk-detector.js';
-import { evaluatorCompositeScore } from '../../lib/evaluator-report.js';
+import { shouldPauseGate, getRiskSignals, classifyE2eSkip } from '../../lib/risk-detector.js';
+import { evaluatorCompositeScore, evaluatorProofState, minProofScore, mediaProofScore } from '../../lib/evaluator-report.js';
 import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-decision.js';
-import { detectDefaultBranch, getHeadSha, getDiffStat } from '../../lib/git/default-branch.js';
+import { minimatch } from 'minimatch';
+import { detectDefaultBranch, getHeadSha, getDiffStat, changedPathsAgainst } from '../../lib/git/default-branch.js';
+import { readMorphConfig } from '../../lib/tasks/test-runner.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 
 /**
@@ -27,6 +29,59 @@ import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/featu
  */
 const OVERRIDABLE_SIGNAL_KEYS = ['standardsViolations', 'designSystemDivergence', 'evalScore'];
 
+/**
+ * Os paths de standard que fazem uma feature ser "de midia".
+ *
+ * Escritos aqui, uma vez, e lidos do campo `standards[]` das tasks — que o Gate
+ * 2 congelou. Nao ha julgamento envolvido: ou a task pinou o standard, ou nao
+ * pinou. Um sinal derivado de opiniao seria sobrescrivivel na pratica ainda que
+ * nao estivesse em OVERRIDABLE_SIGNAL_KEYS.
+ *
+ * A forma dos valores e a de `tasks.json` (`standards/...`), nao a do disco
+ * (`framework/standards/...`): e o vocabulario que o plano usa.
+ */
+export const MEDIA_STANDARD_PATHS = [
+  'standards/ai-agents/modalities-image-gen.md',
+  'standards/ai-agents/media-video.md',
+  'standards/ai-agents/media-pipeline.md',
+];
+
+/**
+ * Uma feature "gera midia" quando ALGUMA task pinou um dos tres standards de
+ * midia no seu array `standards[]`.
+ *
+ * Isto e uma FUNCAO EXPORTADA, e nao uma expressao dentro de `collectSignals`,
+ * porque um predicado que decide se um guardrail arma tem de ser testavel
+ * sozinho — o irmao `productionCode` tem quatro casos, e este nao tinha nenhum.
+ * Um predicado que sempre devolve `false` desarma a clausula em silencio, e
+ * silencio e o defeito que esta epic catalogou sete vezes.
+ *
+ * **O prefixo `framework/` e normalizado, e essa e a razao de existir da
+ * funcao.** O vocabulario do plano e `standards/...` (o exemplo do
+ * `tasks.schema.json`, e a unica forma medida hoje nos `standards[]` desta
+ * arvore), mas o disco e `framework/standards/...` — e a mesma prosa das skills
+ * cita as duas formas. Um plano que escrevesse a forma do disco desarmaria o
+ * guardrail sem erro nenhum: `standards --find`, `validate` e o proprio Gate 3
+ * continuariam verdes. Aceitar as duas grafias custa uma linha; recusar uma
+ * delas em silencio custa o gate.
+ *
+ * Fail-open por AUSENCIA (nao por opiniao): lista vazia, `standards` ausente ou
+ * de tipo errado ⇒ `false` ⇒ nao pausa. Sem plano legivel nao ha como AFIRMAR
+ * que a feature gera midia, e uma regra nova nao trava feature legada.
+ *
+ * @param {Array<object>} tasks - `tasks.json` → `tasks[]` (qualquer coisa nao-array vira []).
+ * @returns {boolean} true se ao menos uma task pinou um standard de midia.
+ */
+export function featureGeneratesMedia(tasks) {
+  if (!Array.isArray(tasks)) return false;
+
+  return tasks.some((t) =>
+    Array.isArray(t?.standards) &&
+    t.standards.some((s) =>
+      typeof s === 'string' &&
+      MEDIA_STANDARD_PATHS.includes(s.replace(/^framework\//, ''))));
+}
+
 /** Read tasks.json's task list for a feature; [] if missing/corrupt. Mirrors verify.js's readTasks(). */
 function readTasks(featureName) {
   try {
@@ -63,6 +118,41 @@ function compositeEvalScore(feature) {
   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.
+ *
+ * `declared: false` é "o projeto não declara caminho algum de prompt/modelo" —
+ * a regra é inerte por construção e a razão registrada diz isso. `declared:
+ * true` com `touched: []` é "declara, e nada foi tocado" — a regra rodou e não
+ * viu nada. Colapsar os dois num array vazio faria um projeto que nunca
+ * configurou `watch[]` parecer um projeto que foi verificado.
+ *
+ * O predicado NÃO é invenção deste framework: o repositório de referência já
+ * roda exatamente ele em produção, disparando publicação por `paths:` sobre os
+ * mesmos globs e decidindo o escopo com `git diff --name-only`.
+ *
+ * COLETA, NUNCA DECIDE. Nada aqui julga se o que foi tocado deveria pausar um
+ * gate — política escrita no coletor cria duas fontes para o mesmo fato.
+ *
+ * @param {string} cwd
+ * @param {string|null} defaultBranch
+ * @returns {{declared: boolean, watch: string[], touched: string[]}}
+ */
+function collectPromptModel(cwd, defaultBranch) {
+  const watch = readMorphConfig(cwd)?.project?.evals?.watch;
+  const globs = Array.isArray(watch) ? watch.filter((g) => typeof g === 'string' && g.trim()) : [];
+
+  if (globs.length === 0) return { declared: false, watch: [], touched: [] };
+
+  const changed = changedPathsAgainst(defaultBranch, cwd);
+  return {
+    declared: true,
+    watch: globs,
+    touched: changed.filter((path) => globs.some((glob) => minimatch(path, glob))),
+  };
+}
+
 /**
  * Collect every signal `shouldPauseGate()` (risk-detector.js) is documented
  * to consume, straight off disk — the deterministic call site risk-detector
@@ -72,9 +162,15 @@ function compositeEvalScore(feature) {
  * política adicionada em risk-detector.js no fecho do R4, qualquer gate).
  * `verificationStale` também alimenta uma regra própria, mas só no ship
  * (`gate === 'review'`) — sha do stamp divergindo do HEAD atual. `gate` em si
- * é o que permite risk-detector.js diferenciar as duas. `verification`
- * completo, diffstat e sha seguem como contexto de auditoria persistido, sem
- * regra própria.
+ * é o que permite risk-detector.js diferenciar as duas. `e2eStatus`/`e2eReason`
+ * alimentam a regra da dispensa de e2e (também só no ship): um nó e2e que
+ * PULOU não reprova o rollup, logo `verificationStatus` sai 'pass' e a razão
+ * literal é o único fato que distingue dispensa legítima de ausência de prova.
+ * `verificationScope` é o quarto sinal da mesma regra: um `verify {f} {task}`
+ * carimba `scope: 'task:{id}'` e o e2e dele pula com a razão do GRUPO daquela
+ * task, que risk-detector.js recusa como dispensa da feature.
+ * `verification` completo, `e2eSkipClass`, diffstat e sha seguem como contexto
+ * de auditoria persistido, sem regra própria.
  *
  * @param {string} featureName
  * @param {object} feature
@@ -113,6 +209,61 @@ function collectSignals(featureName, feature, cwd, gateName) {
       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.
+    signals.mediaClaims = {
+      section: proof.mediaSection,
+      score: mediaProofScore(proof.proofScores),
+      featureGeneratesMedia: featureGeneratesMedia(tasks),
+    };
   }
 
   // verificationStatus alimenta a regra "verify vermelho pausa"; o resto do
@@ -121,6 +272,39 @@ function collectSignals(featureName, feature, cwd, gateName) {
   signals.verification = verification;
   if (verification?.status) signals.verificationStatus = verification.status;
   signals.verificationStale = Boolean(verification?.sha && sha && 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
+  // quando o e2e rodou e passou quanto quando ele nunca rodou. `null` aqui é
+  // DESCONHECIDO (stamp ausente, ou anterior ao nó e2e), nunca 'skip'.
+  // `e2eSkipClass` é DERIVADO pela fonte única (classifyE2eSkip, em
+  // risk-detector.js) e persistido só como auditoria — quem decide continua
+  // sendo shouldPauseGate, aqui não há política.
+  //
+  // Nenhuma das três entra em OVERRIDABLE_SIGNAL_KEYS: descrevem O QUE
+  // ACONTECEU no disco, como `gate`/`workType`, não uma opinião que o chamador
+  // possa afirmar. Um `--signals '{"e2eStatus":"pass"}'` compraria o Gate 3.
+  signals.e2eStatus = verification?.nodes?.e2e ?? null;
+  signals.e2eReason = verification?.e2eReason ?? null;
+  signals.e2eSkipClass = signals.e2eStatus === 'skip' ? classifyE2eSkip(signals.e2eReason) : null;
+  // De QUEM é o carimbo. `verify {f} {task}` grava 'task:{id}'; só 'feature'
+  // responde pela app inteira, e é por isso que este sinal existe: a razão
+  // 'task group "docs" does not touch runtime' é dispensa legítima do que
+  // AQUELA task verificou, e sem o escopo ela dispensaria o Gate 3 da feature.
+  // Fato de disco como os outros três — jamais sobrescrevível por --signals.
+  signals.verificationScope = verification?.scope ?? null;
+
+  // O nó de eval, separado do rollup pela mesma razão que o e2e: um eval que
+  // PULOU (escopo de task) não avermelha `verification.status`, então o gate
+  // leria 'pass' tanto para "o eval rodou e passou" quanto para "o eval nunca
+  // rodou". `null` aqui é "este projeto não declara nó de eval" — DISTINTO de
+  // 'skip', que é "declara, e esta corrida não o executou".
+  signals.evalsStatus = verification?.nodes?.evals ?? null;
+  // O que a feature TOCOU, contra os globs que o projeto declarou como
+  // prompt/modelo. Fato de disco: `declared` vem do config commitado, `touched`
+  // do git. Nenhuma política mora aqui — quem decide é shouldPauseGate.
+  signals.promptModel = collectPromptModel(cwd, defaultBranch);
+
   signals.diffstat = getDiffStat(defaultBranch, cwd);
   signals.sha = sha;
 

package/src/commands/state/score.js

@@ -7,8 +7,28 @@ import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/featu
 /** Fixed --dims order: a,c,q,t (mirrors the morph-eval dimension weights). */
 const DIM_KEYS = ['architecture', 'contracts', 'codeQuality', 'testCoverage'];
 
+/**
+ * taskScores keys are pinned to `^T\d+$` by feature.schema.json, and tasks.schema.json
+ * pins the same shape for the task ids themselves. Anything else — a dotted `T3.2`
+ * above all — is split on the dot by `updateFeature` and lands as a NESTED key that
+ * neither the schema nor the gate-check proxy can see.
+ */
+const TASK_ID_PATTERN = /^T\d+$/;
+
+const USAGE_LINE = 'Usage: morph-spec score <feature> <task> <score> [--dims a,c,q,t]   e.g. morph-spec score my-feature T1 9.2 --dims "9,10,9,9"';
+
 function parseScoreValue(raw, label) {
-  const value = Number(raw);
+  // `Number('')` and `Number('   ')` are 0 — finite and inside 0-10, so the range check
+  // below waves them through and a blank value gets recorded as a real zero. Refuse the
+  // empty shape BEFORE Number() so no score can ever be fabricated.
+  const text = raw === undefined || raw === null ? '' : String(raw).trim();
+  if (text === '') {
+    const got = raw === undefined ? 'no value was passed' : `got "${raw}"`;
+    console.error(chalk.red(`\n❌ Missing ${label}: ${got} — a blank value is refused, never recorded as 0`));
+    console.error(chalk.gray(`   ${USAGE_LINE}\n`));
+    process.exit(1);
+  }
+  const value = Number(text);
   if (!Number.isFinite(value) || value < 0 || value > 10) {
     console.error(chalk.red(`\n❌ Invalid ${label}: "${raw}" — expected a number between 0 and 10\n`));
     process.exit(1);
@@ -16,6 +36,18 @@ function parseScoreValue(raw, label) {
   return value;
 }
 
+function assertTaskIdShape(taskId) {
+  const id = taskId === undefined || taskId === null ? '' : String(taskId);
+  if (TASK_ID_PATTERN.test(id)) return;
+  console.error(chalk.red(`\n❌ Invalid task id: "${id}" — expected the pattern T<n> (T1, T7, T12)`));
+  console.error(chalk.gray(
+    `   taskScores keys are pinned by feature.schema.json (propertyNames.pattern "^T\\d+$").\n` +
+    `   A dotted id is split on the "." and written as a nested key, invisible to the gate-check proxy.\n` +
+    `   ${USAGE_LINE}\n`
+  ));
+  process.exit(1);
+}
+
 /**
  * `morph-spec score <feature> <task> <score> [--dims a,c,q,t]` — record a
  * task eval score under `taskScores` in the authoritative feature.json.
@@ -26,6 +58,9 @@ function parseScoreValue(raw, label) {
  */
 export async function scoreCommand(featureName, taskId, scoreArg, options = {}) {
   try {
+    // Argument validation runs before any state read or write: a refusal must never
+    // leave a fabricated or nested taskScores entry behind.
+    assertTaskIdShape(taskId);
     const score = parseScoreValue(scoreArg, 'score');
 
     const feature = getFeature(featureName);

package/src/commands/validation/verify.js

@@ -3,9 +3,10 @@ import { existsSync, readFileSync } from 'fs';
 import { resolve, join } from 'path';
 import { getFeature, updateFeature } from '../../core/state/state-manager.js';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
-import { runVerify } from '../../lib/validators/verify-runner.js';
+import { runVerify, VerifyUsageError } from '../../lib/validators/verify-runner.js';
 import { resolvePrimaryRoot } from '../project/worktree.js';
 import { getHeadSha } from '../../lib/git/default-branch.js';
+import { EVAL_RUNNER } from '../../lib/tasks/eval-node.js';
 
 /** ✓ pass · ✗ fail · – skip */
 function statusIcon(status) {
@@ -29,6 +30,11 @@ function formatVerifyResult(result) {
   lines.push('');
   lines.push(result.status === 'pass' ? chalk.green.bold('✓ PASS') : chalk.red.bold('✗ FAIL'));
   lines.push('');
+  const env = result.nodes.tests?.environment;
+  if (env) {
+    lines.push(chalk.cyan(`environment: ${env.kind} (${env.image})`));
+    lines.push('');
+  }
   lines.push('Nodes:');
   for (const [name, node] of Object.entries(result.nodes)) {
     const icon = statusIcon(node.status);
@@ -112,6 +118,54 @@ function decidePersistence({ cwd, featureName, noPersist }) {
   return { persist: false, reason: 'unregistered-worktree' };
 }
 
+/**
+ * The per-node status map, in the shape `feature.schema.json` fixes for BOTH
+ * writers of it — the per-scope history entry (`verifications.*`) and the
+ * singular gate stamp (`verification.nodes`). One function because they were
+ * two literal copies twenty-five lines apart: a fifth node meant remembering
+ * both, and a stamp missing a node the history has is precisely the kind of
+ * half-truth the gate reads as fact.
+ *
+ * @param {{ nodes: Record<string, { status: string }> }} result - runVerify() output
+ * @returns {{ build: string, tests: string, validators: string, e2e: string }}
+ */
+function nodeStatuses(result) {
+  return {
+    build: result.nodes.build.status,
+    tests: result.nodes.tests.status,
+    validators: result.nodes.validators.status,
+    e2e: result.nodes.e2e.status,
+    evals: evalsStatusOf(result),
+  };
+}
+
+/**
+ * The status of the eval suites, pulled OUT of the tests rollup.
+ *
+ * The rollup cannot answer the question Gate 3 asks. A red eval and a red unit
+ * test both arrive as `tests: 'fail'`, and — worse — an eval node that was
+ * SKIPPED (task scope) leaves the rollup green, so a gate reading `tests` alone
+ * cannot tell "the eval ran and passed" from "the eval never ran".
+ *
+ * Four values, and the distinction between the last two is the whole point:
+ *   - `'pass'` / `'fail'`: every declared eval node agreed, or at least one did
+ *     not. Same pessimistic rollup rule the tests node already uses;
+ *   - `'skip'`: eval nodes ARE declared, but this run did not execute them;
+ *   - `null`: this project declares NO eval node. Not a skip — there is nothing
+ *     to skip. `risk-detector.js` pauses on the two for different reasons,
+ *     because they call for different actions.
+ *
+ * @param {{nodes: {tests: {runs?: Array}}}} result - runVerify() output
+ * @returns {'pass'|'fail'|'skip'|null}
+ */
+function evalsStatusOf(result) {
+  const runs = (result.nodes.tests?.runs || []).filter((run) => run.runner === EVAL_RUNNER);
+  if (runs.length === 0) return null;
+  if (runs.some((run) => run.status === 'fail')) return 'fail';
+  if (runs.some((run) => run.status === 'pass')) return 'pass';
+  return 'skip';
+}
+
 /** Read tasks.json's task list for a feature; [] if missing/corrupt. */
 function readTasks(featureName) {
   try {
@@ -129,10 +183,20 @@ function readTasks(featureName) {
  * for the node cadence; this command wraps it with CLI ergonomics
  * (human/JSON output, exit codes) and context-aware persistence.
  *
- * Exit codes: 0 = pass (including all-skip) · 1 = fail (>=1 red node) ·
- * 2 = usage error (unknown feature or task — the task's `group` decides the
- * rubric, so an unknown task id is a hard usage error here, unlike the
- * advisory warning `morph-spec score` gives for the same situation).
+ * Exit codes: 0 = pass (including all-skip) · 1 = fail (>=1 red node, or a
+ * `--record-baseline` the run refused to write) · 2 = usage error.
+ *
+ * Exit 2 is "the command cannot mean what you typed", and there are four
+ * 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);
+ *   - `--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`);
+ *   - `--linux` without Docker.
+ * The last three arrive as `VerifyUsageError` from the runner.
  */
 export async function verifyCommand(featureName, taskId, options = {}) {
   let feature;
@@ -154,21 +218,40 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     }
   }
 
-  const result = await runVerify(process.cwd(), featureName, taskId || null, {
-    rubric: options.rubric,
-    timeout: options.timeout,
-    skipTests: options.skipTests,
-    skipBuild: options.skipBuild,
-    skipE2e: options.skipE2e,
-    freshE2e: options.freshE2e,
-  });
+  let result;
+  try {
+    result = await runVerify(process.cwd(), featureName, taskId || null, {
+      rubric: options.rubric,
+      timeout: options.timeout,
+      skipTests: options.skipTests,
+      skipBuild: options.skipBuild,
+      skipE2e: options.skipE2e,
+      freshE2e: options.freshE2e,
+      filter: options.filter,
+      recordBaseline: options.recordBaseline,
+      refreshCache: options.refreshCache,
+      linux: options.linux,
+      linuxImage: options.linuxImage,
+    });
+  } catch (err) {
+    // A wrong invocation is exit 2, like an unknown feature or task — never a
+    // verdict. `--filter` that selects nothing must not print green (or red):
+    // there is no verification to report, only a command to fix.
+    if (err instanceof VerifyUsageError) {
+      console.error(chalk.red(`\n❌ ${err.message}\n`));
+      process.exit(2);
+    }
+    throw err;
+  }
 
   const scopeKey = taskId ? `taskVerifications.${taskId}` : 'verifications.feature';
-  const { persist, reason } = decidePersistence({
-    cwd: process.cwd(),
-    featureName,
-    noPersist: options.noPersist,
-  });
+  // `--record-baseline` is config maintenance, not gate evidence: it measures
+  // the suite in order to write `expectedCount`. Persisting a `verification`
+  // stamp from it would let a maintenance run stand in for the proof a gate
+  // asks for — the same class of confusion as a hand-typed baseline.
+  const { persist, reason } = options.recordBaseline
+    ? { persist: false, reason: 'record-baseline' }
+    : decidePersistence({ cwd: process.cwd(), featureName, noPersist: options.noPersist });
 
   let compact = null;
   if (persist) {
@@ -176,12 +259,7 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     const now = new Date().toISOString();
     compact = {
       status: result.status,
-      nodes: {
-        build: result.nodes.build.status,
-        tests: result.nodes.tests.status,
-        validators: result.nodes.validators.status,
-        e2e: result.nodes.e2e.status,
-      },
+      nodes: nodeStatuses(result),
       score: result.nodes.validators.score ?? null,
       attempts: (prevEntry?.attempts ?? 0) + 1,
       updatedAt: now,
@@ -195,8 +273,19 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     // `**Reviewed-SHA:**` token lets approve.js detect a stale review. null
     // in a non-git checkout (or before the first commit) — fail-open, never
     // blocks persistence.
+    //
+    // `nodes` + `e2eReason` são acréscimo de campo, não mudança de forma: o
+    // rollup `status` continua onde estava. Existem porque um nó e2e que PULA
+    // não reprova o rollup — sem o status do nó e a razão LITERAL do skip, o
+    // gate-check lê 'pass' tanto quando o e2e rodou e passou quanto quando ele
+    // nunca rodou, e não tem como separar dispensa legítima ("o projeto não
+    // containeriza") de ausência de prova ("docker indisponível"). `e2eReason`
+    // é null quando o nó não pulou — e um null NUM SKIP é lido como dispensa
+    // sem motivo, que risk-detector.js recusa.
     const stamp = {
       status: result.status,
+      nodes: nodeStatuses(result),
+      e2eReason: result.nodes.e2e.status === 'skip' ? (result.nodes.e2e.reason ?? null) : null,
       sha: getHeadSha(process.cwd()),
       ts: now,
       scope: taskId ? `task:${taskId}` : 'feature',
@@ -204,11 +293,26 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     await updateFeature(featureName, 'verification', stamp);
   }
 
+  // The refusal always goes to stderr, so it survives --json (whose stdout has
+  // to stay parseable) and is never something the reader has to go looking for.
+  if (result.baseline && !result.baseline.recorded) {
+    console.error(chalk.red(`
+❌ baseline não gravada: ${result.baseline.reason}
+`));
+  }
+
   if (options.json) {
     const output = { ...result, persisted: persist, ...(persist ? {} : { reason }) };
     console.log(JSON.stringify(output, null, 2));
   } else {
     console.log(formatVerifyResult(result));
+    if (result.baseline?.recorded) {
+      for (const u of result.baseline.updates) {
+        console.log(chalk.green(`  baseline ${u.id}: ${u.from ?? '—'} → ${u.to}`));
+      }
+      console.log(chalk.gray(`Gravada em ${result.baseline.path}
+`));
+    }
     if (persist) {
       console.log(chalk.gray(`Persisted: ${scopeKey} (attempts: ${compact.attempts})\n`));
     } else {
@@ -216,5 +320,10 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     }
   }
 
-  process.exit(result.status === 'pass' ? 0 : 1);
+  // A recording the user asked for and did not get is a failure of the
+  // invocation even when the run itself was green (a filtered run is green and
+  // unrecordable): exiting 0 there would report success for something that did
+  // not happen.
+  const baselineRefused = Boolean(result.baseline && !result.baseline.recorded);
+  process.exit(result.status === 'pass' && !baselineRefused ? 0 : 1);
 }

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

@@ -12,7 +12,15 @@ import { getAllOutputPaths, getOutputPath } from '../paths/output-schema.js';
 const STATE_FILE_NAME = '.morph/state.json';
 const FEATURES_DIR_NAME = '.morph/features';
 const FEATURE_FILE_NAME = 'feature.json';
-const CONFIG_FILE_NAME = '.morph/config/config.json';
+/**
+ * The one spelling of the committed project config's location, relative to a
+ * project root. Exported because three modules used to write it out by hand
+ * (`readProjectFromConfig` here, `readMorphConfig` and `morphConfigPath` in
+ * src/lib/tasks/) — and `morphConfigPath`'s own JSDoc promised the reader that
+ * the writer and the reader "can never disagree about which file is meant",
+ * a guarantee three copies of a string cannot give. Now they can't.
+ */
+export const CONFIG_FILE_NAME = '.morph/config/config.json';
 
 // The on-disk state version. NOTE: this tracks the *feature-object* schema, which
 // is unchanged by the per-feature storage split — features are now persisted to