@polymorphism-tech/morph-spec 8.25.0 → 8.27.0

package/framework/templates/docs/onboarding.md

@@ -76,10 +76,10 @@ morph-spec archive <feature>
 morph-spec doctor
 ```
 
-> **Task tracking is native.** During the implement phase Claude tracks its own
-> work with the `TaskCreate`/`TaskUpdate` tools and persists progress by writing
-> `tasks.json` (only the `status`, `outputs`, and `notes` fields). State is synced
-> automatically by the `state-sync` hook — task tracking is native, not a CLI command.
+> **Task tracking lives in `tasks.json`.** During the implement phase Claude records
+> progress by writing `tasks.json` directly (only the `status`, `outputs`, and `notes`
+> fields). State is synced automatically by the `state-sync` hook — there is no CLI
+> command to mark a task done.
 
 ---
 

package/framework/templates/examples/spec-examples.md

@@ -2,7 +2,8 @@
 
 > **Layer:** 3 | **Load:** on-demand | **Keywords:** spec, specification, template
 
-**Use the stack's `.morph/framework/templates/spec.md` as the canonical template.**
+**The canonical template is `docs/spec.md` of the template system** (REGISTRY id `spec`),
+resolved from the installed package — see `framework/templates/README.md`.
 
 This file contains extended examples for each spec section.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "8.25.0",
+  "version": "8.27.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/project/claim.js

@@ -132,7 +132,17 @@ export function claimCommand(feature, options = {}) {
 
   // No feature (or explicit --list): the read-only board, whole or filtered.
   const all = listClaims(gitCommonDir);
-  const rows = feature ? all.filter((c) => c.feature === feature) : all;
+  const scoped = feature ? all.filter((c) => c.feature === feature) : all;
+
+  // Um claim morto NÃO é limpo do registro — ele só para de avisar (o TTL de
+  // 30 min o mata, `live` é computado na leitura). O efeito colateral é que o
+  // board acumula: features encerradas há 20h e 73h apareciam no `--list` como
+  // se fossem informação. Um quadro de avisos onde quase nada é aviso ensina a
+  // não olhar o quadro. Por padrão mostramos só o que ainda avisa; `--all`
+  // devolve o registro inteiro, e o rodapé conta o que ficou de fora para a
+  // omissão nunca ser silenciosa.
+  const rows = options.all ? scoped : scoped.filter((c) => c.live);
+  const hidden = scoped.length - rows.length;
 
   if (options.json) {
     console.log(JSON.stringify(rows));
@@ -141,8 +151,11 @@ export function claimCommand(feature, options = {}) {
 
   if (!rows.length) {
     console.log(chalk.gray(feature
-      ? `Nenhum claim para "${feature}".`
-      : 'Nenhuma feature reclamada — nenhuma sessão registrada.'));
+      ? `Nenhum claim vivo para "${feature}".`
+      : 'Nenhuma feature reclamada — nenhuma sessão viva registrada.'));
+    if (hidden > 0) {
+      console.log(chalk.gray(`(${hidden} claim(s) morto(s) omitido(s) — \`--all\` para ver, \`--release\` para limpar)`));
+    }
     process.exit(0);
   }
 
@@ -155,6 +168,9 @@ export function claimCommand(feature, options = {}) {
       + col(claimAge(c), 12) + col(c.pid, 9) + (c.path || '-'),
     );
   }
+  if (hidden > 0) {
+    console.log(chalk.gray(`\n${hidden} claim(s) morto(s) omitido(s) — \`--all\` para ver.`));
+  }
   console.log(chalk.gray('\nClaims são AVISOS, nunca bloqueios. Claim órfão: `morph-spec claim <f> --release`'));
   process.exit(0);
 }

package/src/commands/state/approve.js

@@ -5,6 +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';
 
 /**
  * The literal token `review-report.md` carries to declare which tree it
@@ -303,10 +304,23 @@ export async function approveCommand(featureName, gateName, options = {}) {
           process.exit(1);
         }
       } else {
-        const evaluatorReport = join(process.cwd(), '.morph', 'features', featureName, '4-review', 'evaluator-report.md');
-        if (!existsSync(evaluatorReport)) {
+        // `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) {
-            console.error(chalk.red('\n❌ Gate 3 exige o avaliador independente — `4-review/evaluator-report.md` não existe.'));
+            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.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('   Se o dispatch for impossível nesta sessão, aprove com --self-assessed —'));

package/src/commands/state/finish.js

@@ -518,7 +518,7 @@ async function integrateMerge({ emit, root, feature, expectedBranch, defaultBran
   }
   tryGit(['branch', '-d', expectedBranch], root);
   // The root index (gitignored) was already updated by the archive (same cwd).
-  emit({ finished: true, mode: 'merge', feature, merged: expectedBranch, into: defaultBranch, worktreeRemoved: false, nextStep: null, ...ucNote });
+  emit({ finished: true, mode: 'merge', feature, merged: expectedBranch, into: defaultBranch, worktreeRemoved: false, nextStep: MERGE_NEXT_STEP, ...ucNote });
   process.exit(0);
 }
 
@@ -596,6 +596,15 @@ function promotedNote(arch) {
   };
 }
 
+/**
+ * O comando se chama `finish`, e no modo `--merge` ele NÃO publica nada: o
+ * merge é local, o remoto continua sem a feature. Quem lê "finished: true"
+ * conclui o contrário — foi pegadinha repetida em sessões diferentes. O modo
+ * `--pr` empurra e abre o PR; o `--merge` deixa o push para o humano, e é isso
+ * que esta linha diz em voz alta.
+ */
+const MERGE_NEXT_STEP = 'integração LOCAL — nada foi publicado. Rode `git push` para levar ao remoto.';
+
 function mergeOutput({ feature, branch, worktreePath, teardown, shedBackup }) {
   return {
     finished: true,
@@ -603,6 +612,7 @@ function mergeOutput({ feature, branch, worktreePath, teardown, shedBackup }) {
     feature,
     merged: branch,
     worktreeRemoved: teardown.worktreeRemoved,
+    nextStep: MERGE_NEXT_STEP,
     ...(shedBackup ? { shedBackup } : {}),
     ...teardownExtras(teardown, worktreePath, branch, true),
   };

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

@@ -3,6 +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 } from '../../lib/risk-detector.js';
+import { evaluatorCompositeScore } from '../../lib/evaluator-report.js';
 import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-decision.js';
 import { detectDefaultBranch, getHeadSha, getDiffStat } from '../../lib/git/default-branch.js';
 
@@ -61,26 +62,6 @@ function compositeEvalScore(feature) {
   return Math.round(avg * 10) / 10;
 }
 
-/**
- * Parse the machine-readable `**Composite-Score:** N.N` token out of
- * evaluator-report.md — the mirror of approve.js's `**Reviewed-SHA:**`
- * pattern. This is the TRUE Gate-3 composite (written by the independent
- * evaluator, per morph-review's dispatch contract), preferred over the
- * taskScores-average proxy whenever present. Returns undefined when the
- * report or the token is absent (legacy report) — the proxy stays the
- * fallback, `--signals evalScore` still overrides both.
- */
-function evaluatorCompositeScore(cwd, featureName) {
-  try {
-    const p = getAbsoluteOutputPath(cwd, featureName, 'evaluatorReport');
-    if (!existsSync(p)) return undefined;
-    const m = readFileSync(p, 'utf8').match(/\*\*Composite-Score:\*\*\s*([0-9]+(?:\.[0-9]+)?)/);
-    return m ? Number(m[1]) : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * Collect every signal `shouldPauseGate()` (risk-detector.js) is documented
  * to consume, straight off disk — the deterministic call site risk-detector
@@ -198,6 +179,14 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
       for (const key of OVERRIDABLE_SIGNAL_KEYS) {
         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/report-check.js

@@ -26,8 +26,9 @@
  */
 
 import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
+import { readTelemetryEvents } from '../../../framework/hooks/shared/telemetry-logger.js';
 
 /**
  * The four mandatory items of the report contract, as detectable markers.
@@ -54,6 +55,22 @@ function reportPath(cwd, feature, taskId) {
   return join(cwd, '.morph', 'features', feature, '3-implement', 'reports', `${taskId}.md`);
 }
 
+/**
+ * `.morph/logs/task-times.json` — `{ [feature]: { [taskId]: {status,start,end} } }`,
+ * escrito pelo hook `trace-autogen` nas transições de status da task. É a
+ * janela temporal de cada task; sem ela não há como recortar quais writes do
+ * `events.jsonl` pertencem a qual task.
+ */
+function readTaskTimes(cwd) {
+  try {
+    const p = join(cwd, '.morph', 'logs', 'task-times.json');
+    if (!existsSync(p)) return null;
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
 function evaluatorPath(cwd, feature) {
   return join(cwd, '.morph', 'features', feature, '4-review', 'evaluator-report.md');
 }
@@ -98,9 +115,140 @@ function outputEvidence(cwd, taskOutputs) {
   return { outputsExpected: expected.length, outputsPresent: present };
 }
 
+/**
+ * Folga entre o `mtime` do relatório e o `ts` do último write observado.
+ *
+ * São DOIS RELÓGIOS: `mtime` vem do filesystem, `ts` vem de
+ * `new Date().toISOString()` dentro do hook de telemetria. O write do próprio
+ * relatório e o evento que o registra caem a milissegundos de distância, com
+ * arredondamentos diferentes — sem folga, um relatório perfeitamente fresco
+ * seria acusado de velho. Dois segundos são muito mais que o skew real e muito
+ * menos que qualquer trabalho de verdade feito depois de relatar.
+ */
+export const STALE_TOLERANCE_MS = 2000;
+
+/**
+ * Traz o target do evento para a MESMA forma que `task.outputs`.
+ *
+ * Os dois lados chegam em convenções diferentes, e cruzá-los crus não casa
+ * nunca: `event.target` é o `file_path` como a ferramenta o recebeu, e
+ * `Write`/`Edit` exigem caminho ABSOLUTO (`telemetry-log.js` só normaliza as
+ * barras, não relativiza); `task.outputs` é relativo à raiz — é assim que
+ * `outputEvidence` o resolve, com `join(cwd, rel)`. Sem este passo,
+ * `undeclared`/`unobserved` listariam TUDO em toda task, e um sinal que sempre
+ * grita é um sinal que se aprende a ignorar.
+ *
+ * Um target que não fica sob a raiz (outra árvore) volta como veio, em vez de
+ * virar `../../..` — fora da árvore ele é evidência legítima de escrita alheia,
+ * não um output que faltou declarar.
+ */
+function toRepoRelative(target, cwd) {
+  const norm = String(target || '').replace(/\\/g, '/');
+  const root = String(cwd || '').replace(/\\/g, '/').replace(/\/+$/, '');
+  if (!root) return norm;
+  // Prefixo comparado sem caixa: no Windows a mesma raiz chega como `R:/repo`
+  // ou `r:/repo` conforme quem chamou o comando.
+  return norm.toLowerCase().startsWith(`${root.toLowerCase()}/`) ? norm.slice(root.length + 1) : norm;
+}
+
+/**
+ * Arquivos que NÃO contam como "trabalho feito depois do relatório".
+ *
+ * Sem este recorte o veredito vira máquina de falso positivo, e um aviso que
+ * dispara à toa é um aviso que se aprende a ignorar:
+ *   - o próprio relatório: gravá-lo É um Write, e ele cai na janela da task por
+ *     construção — todo relatório bem-comportado pareceria stale;
+ *   - qualquer coisa sob `.morph/`: `tasks.json`, `feature.json`, `recap.md`,
+ *     `decisions.md` são escritas do ORQUESTRADOR, depois que o sub-agent
+ *     terminou. São o fluxo normal, não trabalho não relatado.
+ *
+ * `includes` e não `startsWith`, de propósito: o alvo já vem relativizado, mas
+ * um write no `.morph/` de OUTRA árvore não fica sob esta raiz e continua
+ * absoluto — `startsWith('.morph/')` deixaria esse passar como trabalho. Não há
+ * código-fonte sob `.morph/` para o `includes` pegar por engano: a pasta é
+ * estado, por design.
+ */
+function isBookkeepingWrite(target, reportRel) {
+  if (!target) return true;
+  if (target === reportRel) return true;
+  return target.includes('.morph/');
+}
+
+/**
+ * Evidência OBSERVADA: arquivos que a task de fato escreveu, segundo a
+ * telemetria — não segundo o que o agente declarou em `outputs`.
+ *
+ * A distinção é o ponto todo. `outputs` é auto-declarado pelo agente, e
+ * `trace-autogen` lê a MESMA lista — as duas checagens que pareciam
+ * independentes eram a mesma afirmação lida duas vezes. `events.jsonl` registra
+ * cada `Write`/`Edit` no momento em que aconteceu, com `ts`; `task-times.json`
+ * dá a janela `[start, end]` da task. Cruzando os dois sai o que de fato foi
+ * tocado, sem depender da palavra de ninguém.
+ *
+ * Fail-open: sem telemetria (projeto legado, hook desligado) devolve
+ * `{ available: false }` e o comando volta ao comportamento anterior.
+ */
+function observedEvidence(cwd, feature, task) {
+  const times = readTaskTimes(cwd)?.[feature]?.[task.id];
+  if (!times?.start) return { available: false };
+
+  const events = readTelemetryEvents(cwd);
+  if (!events.length) return { available: false };
+
+  const startMs = Date.parse(times.start);
+  // Janela aberta à direita quando a task não fechou: uma task ainda em
+  // andamento tem trabalho observável, e recusar auditá-la esconde exatamente
+  // o caso do relatório escrito cedo demais.
+  const endMs = times.end ? Date.parse(times.end) : Number.POSITIVE_INFINITY;
+  if (!Number.isFinite(startMs)) return { available: false };
+
+  const reportRel = `.morph/features/${feature}/3-implement/reports/${task.id}.md`;
+  const writes = [];
+  for (const e of events) {
+    if (e?.tool !== 'Write' && e?.tool !== 'Edit') continue;
+    const ts = Date.parse(e?.ts ?? '');
+    if (!Number.isFinite(ts) || ts < startMs || ts > endMs) continue;
+    const target = toRepoRelative(e.target, cwd);
+    if (isBookkeepingWrite(target, reportRel)) continue;
+    writes.push({ target, ts });
+  }
+
+  const declared = new Set((Array.isArray(task.outputs) ? task.outputs : [])
+    .map((p) => String(p).replace(/\\/g, '/')));
+  const observed = [...new Set(writes.map((w) => w.target))];
+
+  return {
+    available: true,
+    observed,
+    lastWriteAt: writes.length ? new Date(Math.max(...writes.map((w) => w.ts))).toISOString() : null,
+    undeclared: observed.filter((p) => !declared.has(p)),
+    unobserved: [...declared].filter((p) => !observed.includes(p)),
+  };
+}
+
+/** O relatório é mais velho que o último trabalho observado da própria task? */
+function isReportStale(reportFsPath, observed) {
+  if (!observed?.available || !observed.lastWriteAt) return false;
+  try {
+    const writtenAt = statSync(reportFsPath).mtimeMs;
+    return writtenAt + STALE_TOLERANCE_MS < Date.parse(observed.lastWriteAt);
+  } catch {
+    return false;
+  }
+}
+
 /** Combine report state + evidence into a verdict and the action it implies. */
-function decide(report, evidence) {
-  if (report.exists && report.complete) return { verdict: 'ok', action: 'proceed' };
+function decide(report, evidence, stale) {
+  if (report.exists && report.complete) {
+    // A integridade estrutural (os 4 itens presentes) responde "o relatório
+    // está completo?", nunca "o relatório ainda é verdade?". Caso real: um
+    // sub-agent gravou o esqueleto dizendo "teste ainda não escrito — em
+    // andamento", seguiu trabalhando, escreveu os 9 testes e foi cortado. O
+    // arquivo ficou completo e MENTINDO, e saía `ok` aqui.
+    return stale
+      ? { verdict: 'report-stale', action: 'refresh-from-evidence' }
+      : { verdict: 'ok', action: 'proceed' };
+  }
   if (report.exists) return { verdict: 'report-incomplete', action: 'complete-degraded' };
   if (evidence.outputsExpected === 0) {
     // No declared outputs means no evidence either way. Re-dispatching costs a
@@ -113,13 +261,17 @@ function decide(report, evidence) {
 }
 
 function checkTask(cwd, feature, task) {
-  const report = inspectReport(reportPath(cwd, feature, task.id));
+  const fsPath = reportPath(cwd, feature, task.id);
+  const report = inspectReport(fsPath);
   const evidence = outputEvidence(cwd, task.outputs);
-  return { task: task.id, report, evidence, ...decide(report, evidence) };
+  const observed = observedEvidence(cwd, feature, task);
+  const stale = report.exists && isReportStale(fsPath, observed);
+  return { task: task.id, report, evidence, observed, ...decide(report, evidence, stale) };
 }
 
 const ACTION_HINT = {
   proceed: 'relatório íntegro — siga o fluxo normal.',
+  'refresh-from-evidence': 'o relatório está COMPLETO mas VELHO: a task seguiu escrevendo arquivos depois que ele foi gravado, então ele descreve um estado já ultrapassado. NÃO re-despache e não confie no texto — confira os arquivos em `observed` (evidência real, não auto-declarada) e atualize o relatório a partir deles.',
   'complete-degraded': 'complete os itens faltantes a partir da mensagem de retorno do sub-agent, carimbe o relatório como DEGRADADO e registre a falha de protocolo no recap.',
   'accept-degraded': 'o TRABALHO entrou — não re-despache. Grave você mesmo o relatório canônico a partir da mensagem de retorno, carimbado como DEGRADADO, e registre a falha de protocolo no recap e nas `notes` da task.',
   redispatch: 're-despache a task UMA vez com o mesmo prompt. Segunda ausência sem trabalho entregue = falha real: escale ao humano.',

package/src/lib/evaluator-report.js

@@ -0,0 +1,72 @@
+/**
+ * Leitura do `4-review/evaluator-report.md` — o relatório BRUTO do avaliador
+ * independente despachado pela `morph-review` no Gate 3.
+ *
+ * Existe como módulo próprio porque DOIS comandos dependem do mesmo arquivo por
+ * razões diferentes, e antes o liam de maneiras diferentes:
+ *
+ *   - `gate-check` lê o token `**Composite-Score:**` para saber o score REAL da
+ *     feature (em vez do proxy de médias de auto-avaliação);
+ *   - `approve` exige o arquivo como precondição do Gate 3.
+ *
+ * A divergência era concreta: `approve.js` montava o path à mão com `join(...)`
+ * enquanto `gate-check.js` resolvia por `getAbsoluteOutputPath`. Dois caminhos
+ * para o mesmo arquivo é a receita de drift silencioso (a lição A5), e a
+ * checagem por `existsSync` puro do `approve` aceitava um relatório SEM o token
+ * que o `gate-check` então descartava — o Gate 3 passava carimbado `auto` sobre
+ * uma média de auto-avaliação, exatamente o que MORPH.md §5 proíbe.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { getAbsoluteOutputPath } from '../core/paths/output-schema.js';
+
+/**
+ * O token machine-readable que o avaliador grava por contrato (`morph-review`
+ * §4). Espelho de `REVIEWED_SHA_TOKEN` do approve.js — mesma ideia: um relatório
+ * de LLM só é auditável por máquina se carregar um campo que a máquina lê.
+ */
+export const COMPOSITE_SCORE_TOKEN = '**Composite-Score:**';
+
+const COMPOSITE_SCORE_RE = /\*\*Composite-Score:\*\*\s*([0-9]+(?:\.[0-9]+)?)/;
+
+/** Path canônico do evaluator-report da feature. Fonte única para os dois comandos. */
+export function evaluatorReportPath(cwd, featureName) {
+  return getAbsoluteOutputPath(cwd, featureName, 'evaluatorReport');
+}
+
+/**
+ * Score composto REAL da feature, do token gravado pelo avaliador independente.
+ *
+ * @returns {number|undefined} undefined quando o relatório não existe, não é
+ *   legível, ou existe sem o token (relatório legado ou oco). `undefined` é
+ *   deliberado e não 0: quem chama distingue "sem veredito" de "veredito ruim".
+ */
+export function evaluatorCompositeScore(cwd, featureName) {
+  try {
+    const p = evaluatorReportPath(cwd, featureName);
+    if (!existsSync(p)) return undefined;
+    const m = readFileSync(p, 'utf8').match(COMPOSITE_SCORE_RE);
+    return m ? Number(m[1]) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Estado do relatório para a precondição do Gate 3.
+ *
+ * Três valores em vez de booleano PORQUE AS TRÊS SITUAÇÕES PEDEM MENSAGENS
+ * DIFERENTES: arquivo ausente é "despache o avaliador"; arquivo sem token é
+ * "o avaliador rodou mas o relatório está oco — ele não seguiu o contrato";
+ * e só o terceiro caso é aprovável.
+ *
+ * @returns {{ status: 'ok'|'missing'|'untokenized', score?: number, path: string }}
+ */
+export function evaluatorReportState(cwd, featureName) {
+  const path = evaluatorReportPath(cwd, featureName);
+  if (!existsSync(path)) return { status: 'missing', path };
+  const score = evaluatorCompositeScore(cwd, featureName);
+  return score === undefined
+    ? { status: 'untokenized', path }
+    : { status: 'ok', score, path };
+}

package/src/lib/risk-detector.js

@@ -11,6 +11,8 @@
  *   - verificationStatus: string      — último `morph-spec verify` ('fail' pausa, qualquer gate)
  *   - verificationStale + gate: bool/str — stamp com sha != HEAD pausa SÓ no
  *     ship (gate 'review') — código mudou depois do último verify
+ *   - evalScoreSource + gate: str     — no ship, score que NÃO veio do avaliador
+ *     independente pausa (auto-avaliação não decide o Gate 3)
  *   - evalScore: number               — morph-eval score (pause if < 9)
  *   - taskCount: number               — total tasks (pause if > 20)
  */
@@ -18,6 +20,13 @@
 const SCOPE_TASK_THRESHOLD = 20;
 const MIN_EVAL_SCORE = 9;
 
+// A ÚNICA procedência de `evalScore` que pode decidir o gate de ship. Escrita
+// por gate-check.js quando o token `**Composite-Score:**` foi lido do
+// evaluator-report.md — o veredito do avaliador independente em contexto
+// fresco. Toda outra procedência (proxy de taskScores, override de --signals,
+// ou nenhuma) é auto-avaliação ou palavra de quem já estava no contexto.
+const TRUSTED_EVAL_SOURCE = 'evaluator-report';
+
 // Work types whose ship gate (review) always pauses for a human, regardless
 // of trust mode — a type policy, not a per-feature risk signal. Mirrors
 // `forcedPauseGates` in src/core/work-types.js (hotfix.review); kept here too
@@ -80,6 +89,28 @@ export function shouldPauseGate(config, signals) {
     };
   }
 
+  // No gate de SHIP, um `evalScore` que não veio do avaliador independente NÃO
+  // é sinal de qualidade da feature — é sinal de qualidade das tasks, dado por
+  // quem as implementou. Observado em campo: 7 tasks com auto-score 9.0-9.3
+  // levaram o gate-check a imprimir "auto-pass, nenhum sinal de risco" sobre um
+  // produto que o avaliador independente pontuou 7.2 e reprovou com 3 P1.
+  //
+  // O predicado é por AUSÊNCIA da fonte confiável, não por presença do proxy,
+  // porque há três maneiras de chegar aqui sem avaliador e todas devem pausar:
+  // proxy de taskScores; override manual via --signals; e nenhuma fonte (sem
+  // task pontuada e sem relatório, `evalScore` é OMITIDO e a regra de score
+  // abaixo nem chega a rodar).
+  //
+  // Fora do review não vale: em plan/uiux/proposal o proxy é exatamente o sinal
+  // certo — não existe avaliador independente antes de haver implementação.
+  if (signals.gate === 'review' && signals.evalScoreSource !== TRUSTED_EVAL_SOURCE) {
+    return {
+      pause: true,
+      reason: `Gate 3 sem score do avaliador independente (fonte: ${signals.evalScoreSource ?? 'nenhuma'})`
+            + ' — auto-avaliação de quem implementou não decide o ship',
+    };
+  }
+
   if (typeof signals.evalScore === 'number' && signals.evalScore < MIN_EVAL_SCORE) {
     return {
       pause: true,
@@ -112,6 +143,9 @@ export function getRiskSignals(signals) {
   if (signals.gate === 'review' && signals.verificationStale === true) {
     out.push('verification stamp desatualizado (stale) no ship');
   }
+  if (signals.gate === 'review' && signals.evalScoreSource !== TRUSTED_EVAL_SOURCE) {
+    out.push(`score do Gate 3 sem avaliador independente (fonte: ${signals.evalScoreSource ?? 'nenhuma'})`);
+  }
   if (typeof signals.evalScore === 'number' && signals.evalScore < MIN_EVAL_SCORE) {
     out.push(`eval score ${signals.evalScore}/10`);
   }
@@ -125,4 +159,5 @@ export const RISK_CONSTANTS = {
   SCOPE_TASK_THRESHOLD,
   MIN_EVAL_SCORE,
   FORCED_PAUSE_WORK_TYPES,
+  TRUSTED_EVAL_SOURCE,
 };