@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/lib/risk-detector.js

@@ -1,95 +1,23 @@
-/**
- * Risk Detector — decides whether a gate should pause execution.
- *
- * In `trust: "auto"` mode (default), gates auto-pass UNLESS one of these
- * risk signals triggers a forced pause. In `trust: "manual"` mode, gates
- * always pause via AskUserQuestion.
- *
- * Signals checked (in order):
- *   - designSystemDivergence: boolean — conflicting design sources detected
- *   - standardsViolations: string[]   — violations of the plan's forbidden patterns
- *   - verificationStatus: string      — último `morph-spec verify` ('fail' pausa, qualquer gate)
- *   - verificationScope + gate: string — presente e != 'feature' pausa SÓ no ship: o
- *     último `verify` foi um recorte de task, não da feature inteira (`null`/ausente
- *     não conta — narrow, nunca widen)
- *   - e2eStatus + e2eReason + gate    — nó e2e do último verify. Um `skip`
- *     cuja razão NÃO seja dispensa legítima pausa SÓ no ship (gate 'review').
- *     Sem escopo (stamp sem o campo) cai do mesmo lado seguro que `unknown`
- *   - verificationStale + gate: bool/str — stamp de um commit cujo código já mudou
- *     (fora de .morph/) pausa SÓ no ship (gate 'review')
- *   - evaluatorVerdict + gate: object — { status, verdict, blockers, untyped } do
- *     evaluator-report.md. No ship, só `SHIP` sem bloqueador libera
- *   - mediaClaims + gate: object      — { section, featureGeneratesMedia }
- *   - screenChecklist + gate: object  — { mockups, legacy, screens, problems, exempt?,
- *     section?, uncovered? } derivado do 1-design/mockups.md. No uiux, checklist
- *     de tela incompleto pausa; no ship, item decidido sem a conferência do
- *     avaliador pausa. Mockup legado é isento nos dois, com a razão listada
- *   - oversizedTasks + gate: array    — tasks acima de MAX_TASK_OUTPUTS outputs;
- *     pausa SÓ no plano (gate 'plan'): a task tem de caber num dispatch
- *   - taskCount: number               — total tasks (pause if > 20)
- */
-
-const SCOPE_TASK_THRESHOLD = 20;
-
-// Caminho alterado que pede o avaliador em opus: o resto da review roda em sonnet.
-const OPUS_PATH_RE = /(^|[/._-])(auth|login|senha|password|token|secret|crypto|permiss|rbac|acl|lgpd|pii|privacy|payment|pagamento|billing|cobranca|invoice|asaas|stripe|migrations?)([/._-]|$)/i;
-
-// 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
-// because risk-detector is the deterministic layer consumed independent of
-// the work-type config object.
+import { MAX_SLICES } from './plan/checks.js';
+import { BLOCKER_TYPES, reviewFileName } from './review-reports.js';
+
+const SECURITY_PATH_RE = /(^|[/._-])(auth|login|senha|password|token|secret|crypto|permiss|rbac|acl|lgpd|pii|privacy|payment|pagamento|billing|cobranca|invoice|asaas|stripe|migrations?)([/._-]|$)/i;
+
+// Espelha `forcedPauseGates` (hotfix.review) de src/core/work-types.js: os dois mudam juntos.
 const FORCED_PAUSE_WORK_TYPES = ['hotfix'];
 
-// As razões literais que `framework/hooks/shared/e2e-check.js` emite quando o
-// nó e2e pula. Casadas por PADRÃO e não por igualdade porque duas delas
-// carregam dado variável (o nome do grupo da task). Ordem irrelevante: os
-// padrões são disjuntos.
+// Razões literais que `e2e-check.js` emite ao pular; casadas por padrão porque algumas carregam dado variável.
 const E2E_SKIP_PATTERNS = [
-  // "docker is not available in this environment — e2e could not run"
-  // (e2e-check.js). A app não foi exercida porque a MÁQUINA não podia.
   [/docker is not available/i, 'environment'],
-  // `--skip-e2e` — o operador pediu para pular.
   [/^requested$/i, 'requested'],
-  // "project does not containerize (no compose file)" — não há app para subir.
   [/does not containerize/i, 'project'],
-  // 'task group "docs" does not touch runtime' — escopo da task, não da app.
-  [/does not touch runtime/i, 'scope'],
 ];
 
-// Classes de skip que NÃO são dispensa: o e2e não rodou e nada no repositório
-// diz que ele não precisava rodar. `unknown` está aqui de propósito — inclui a
-// razão vazia/nula, e uma dispensa sem motivo é o mesmo no-op silencioso que
-// esta regra existe para eliminar.
+// `unknown` (razão vazia) pausa de propósito: dispensa sem motivo é o no-op silencioso que a regra elimina.
 const E2E_SKIP_CLASSES_THAT_PAUSE = ['environment', 'requested', 'unknown'];
 
-// O ÚNICO escopo de stamp que responde pela feature inteira. `morph-spec verify
-// {f} {task}` carimba `scope: 'task:{id}'`, e o nó e2e de um verify por task
-// pula com a razão do GRUPO daquela task ('task group "docs" does not touch
-// runtime') — uma afirmação sobre UMA task, nunca sobre a app. Sem este teste,
-// a última task de uma feature (tipicamente `group: docs`) compra o Gate 3 da
-// feature que ela mesma acabou de escrever, numa máquina onde a app nunca
-// subiu. Ausente/desconhecido cai do mesmo lado seguro que `unknown`: recusar
-// é barato, aprovar sem prova não é.
-const FEATURE_SCOPE = 'feature';
-
-/**
- * Classifica a razão literal de um `skip` do nó e2e — de QUEM é a ausência de
- * prova. Existe porque `verificationStatus` é o rollup do `verify` e um nó que
- * pula NÃO o reprova: sem classificar a razão, "o e2e rodou e passou" e "o e2e
- * nunca rodou" chegam ao gate como o mesmo `pass`.
- *
- * A assimetria é o ponto: `project`/`scope` descrevem o REPOSITÓRIO dizendo que
- * não há runtime a exercer (dispensa legítima, registrada com motivo);
- * `environment`/`requested` descrevem a MÁQUINA ou o operador, e nenhum dos
- * dois é evidência sobre o código. `unknown` cai no lado seguro pelo mesmo
- * motivo: recusar é barato, aprovar sem prova não é.
- *
- * @param {string|null|undefined} reason - `verification.e2eReason` (a razão
- *   literal que o `morph-spec verify` carimbou). Vazia/ausente ⇒ 'unknown' —
- *   DESCONHECIDO, jamais lido como dispensa.
- * @returns {'environment'|'requested'|'project'|'scope'|'unknown'}
- */
+// `project` diz que o repositório não tem runtime (dispensa legítima); `environment`/`requested` falam
+// da máquina ou do operador, nunca do código. Razão vazia é `unknown`, jamais dispensa.
 export function classifyE2eSkip(reason) {
   const text = typeof reason === 'string' ? reason.trim() : '';
   if (text === '') return 'unknown';
@@ -99,7 +27,6 @@ export function classifyE2eSkip(reason) {
   return 'unknown';
 }
 
-/** Mensagem de pausa por classe — nomeia SEMPRE a razão literal do verify. */
 function e2ePauseReason(klass, reason) {
   const literal = typeof reason === 'string' && reason.trim() !== '' ? reason.trim() : null;
   if (klass === 'environment') {
@@ -116,98 +43,115 @@ function e2ePauseReason(klass, reason) {
   return `e2e pulado por razão não classificada: "${literal}" — sem classificação, não há dispensa`;
 }
 
-/**
- * Mensagem de recusa por ESCOPO do stamp: a razão do skip É uma dispensa
- * legítima (`project`/`scope`), mas quem a carimbou foi um verify que não
- * responde pela feature. Nomeia o escopo real para que o leitor saiba qual
- * comando rodar, em vez de rodar o mesmo de novo.
- */
-function e2eScopeRefusal(klass, scope, reason) {
-  const literal = typeof reason === 'string' && reason.trim() !== '' ? reason.trim() : 'sem motivo registrado';
-  const where = typeof scope === 'string' && scope.trim() !== '' ? scope.trim() : 'ausente';
-  return `dispensa de e2e [${klass}] veio de um verify de escopo "${where}", não da feature:`
-       + ` "${literal}" — um stamp de task responde por UMA task, não pela app inteira;`
-       + ' rode `morph-spec verify {feature}` (sem task) antes do ship';
-}
-
-/** A razão gravada no sinal quando o checklist de tela isenta um mockup legado. */
 export const LEGACY_MOCKUP_EXEMPTION = 'checklist dispensado: mockup no formato antigo';
 
-/** Os dois primeiros itens de uma lista, e quantos ficaram de fora. */
 function firstOf(items) {
   const shown = items.slice(0, 2).join('; ');
   return items.length > 2 ? `${shown} (+${items.length - 2})` : shown;
 }
 
-/**
- * Por que o checklist de tela pausa o Gate uiux, ou null. Exportada porque o
- * `approve`/`advance` com assinatura `auto` recusam pela MESMA regra: uma
- * aprovação automática que passasse onde o gate-check pausa seria o atalho.
- *
- * Mockup ausente (`mockups: false`) não conta — nem toda feature de UI tem
- * tela —, e o legado chega sem problemas: a auditoria o isenta.
- *
- * @param {object|undefined} screenChecklist - o sinal de `collectScreenChecklist`
- * @returns {string|null}
- */
+// Exportada porque approve/advance `auto` recusam pela mesma regra. Sem design de tela não conta,
+// e o legado chega sem problemas: a auditoria o isenta. Checklist
+// completo ainda deve o protótipo e os prints 1280/390 (`prototypes`).
 export function uiuxChecklistPause(screenChecklist) {
   if (screenChecklist?.mockups !== true) return null;
   const problems = screenChecklist.problems ?? [];
-  if (problems.length === 0) return null;
-  return `checklist de tela incompleto em 1-design/mockups.md: ${firstOf(problems)}`
-       + ' — volume, paginação, ordenação, filtro, os três estados, mobile e abas por tela'
-       + ' ("não se aplica" vale, se escrito)';
-}
-
-function blockerList(v) {
-  return firstOf(v.blockerIds ?? []);
+  if (problems.length > 0) {
+    return `checklist de tela incompleto em 1-design/mockups.md: ${firstOf(problems)}`
+         + ' — volume, paginação, ordenação, filtro, os três estados, mobile e abas por tela'
+         + ' ("não se aplica" vale, se escrito)';
+  }
+  const prototypes = screenChecklist.prototypes ?? [];
+  if (prototypes.length === 0) return null;
+  return `protótipo incompleto: ${firstOf(prototypes)}`
+       + ' — cada tela aponta o HTML renderizado e deixa os prints de 1280 e 390 ao lado dele';
 }
 
-/** Por que o veredito do avaliador segura o ship, ou null. */
-export function verdictPause(v) {
-  if (!v || v.status === 'missing') {
-    return 'Gate 3 sem `4-review/evaluator-report.md` — despache o avaliador independente;'
-         + ' auto-avaliação de quem implementou não decide o ship';
-  }
-  if (v.status !== 'ok') {
-    return 'evaluator-report sem `**Verdict:** SHIP|FIX` — o avaliador não seguiu o contrato do relatório';
+const ROLE_PERSONA = { verifier: 'morph-verifier', reviewer: 'morph-reviewer', security: 'morph-security' };
+
+export function reviewPause(signal) {
+  const required = signal?.required ?? ['verifier'];
+  const reports = signal?.reports ?? {};
+  for (const role of required) {
+    const r = reports[role];
+    const file = `4-review/${reviewFileName(role)}`;
+    if (!r || r.status === 'missing') {
+      return `Gate 3 sem \`${file}\` — despache o \`${ROLE_PERSONA[role]}\` (contexto fresco);`
+           + ' auto-avaliação de quem implementou não decide o ship';
+    }
+    if (r.status === 'partial') {
+      return `\`${file}\` está PARCIAL — retome o mesmo agente por SendMessage; parcial não é veredito`;
+    }
+    if (r.status !== 'ok') {
+      return `\`${file}\` sem \`**Verdict:** SHIP|FIX\` — o relatório não seguiu o contrato`;
+    }
   }
-  if ((v.untyped ?? 0) > 0) {
-    return `${v.untyped} bloqueador(es) sem tipo de evidência (uc | teste | regressao | seguranca)`
+  const present = Object.entries(reports).filter(([, r]) => r.status === 'ok');
+  const untyped = present.reduce((n, [, r]) => n + (r.untyped ?? 0), 0);
+  if (untyped > 0) {
+    return `${untyped} bloqueador(es) sem tipo de evidência (${BLOCKER_TYPES.join(' | ')})`
          + ' — sem evidência tipada não é bloqueador: reclassifique como nota ou complete a evidência';
   }
-  if ((v.blockers ?? 0) > 0) return `avaliador abriu ${v.blockers} bloqueador(es): ${blockerList(v)}`;
-  if (v.verdict !== 'SHIP') return 'veredito do avaliador é FIX';
+  for (const [role, r] of present) {
+    if ((r.blockers ?? 0) > 0) return `${role} abriu ${r.blockers} bloqueador(es): ${firstOf(r.blockerIds ?? [])}`;
+  }
+  for (const [role, r] of present) {
+    if (r.verdict !== 'SHIP') return `veredito do ${role} é ${r.verdict}`;
+  }
+  const checks = signal?.checks;
+  if (!checks || checks.status !== 'ok') {
+    return 'sem `2-plan/checks.json` legível — a cobertura dos cenários pelo verificador não é conferível';
+  }
+  const gaps = [
+    ...checks.missing.map((id) => `${id} sem linha`),
+    ...checks.notProven.map(({ id, status }) => `${id} ${status}`),
+  ];
+  if (gaps.length) {
+    return `\`## Checks\` do verificador não prova ${firstOf(gaps)}`
+         + ' — todo cenário precisa de uma linha PROVADO com evidência';
+  }
   return null;
 }
 
-function verdictSummary(v) {
-  if (!v || v.status !== 'ok') return 'Gate 3 sem veredito do avaliador independente';
-  return `veredito ${v.verdict}, ${v.blockers ?? 0} bloqueador(es)`;
+function reviewSummary(signal) {
+  const reports = signal?.reports ?? {};
+  const roles = Object.keys(reports);
+  if (roles.length === 0) return 'Gate 3 sem relatórios de review';
+  const verdicts = roles.map((role) => `${role} ${reports[role].verdict ?? reports[role].status}`).join(', ');
+  const blockers = roles.reduce((n, role) => n + (reports[role].blockers ?? 0), 0);
+  const checks = signal.checks?.status === 'ok'
+    ? `; checks ${signal.checks.total - signal.checks.missing.length - signal.checks.notProven.length}/${signal.checks.total} PROVADO`
+    : '';
+  return `review: ${verdicts}; ${blockers} bloqueador(es)${checks}`;
 }
 
-/**
- * Modelo do avaliador do Gate 3: `opus` quando a feature toca caminho sensível
- * (auth, segredo, permissão, dado pessoal, dinheiro, migration), prompt/modelo
- * ou geração de mídia; `sonnet` no resto.
- *
- * @param {{ changedFiles?: string[], promptModelTouched?: boolean, generatesMedia?: boolean }} input
- * @returns {{ model: 'opus'|'sonnet', reasons: string[] }}
- */
-export function evaluatorModelFor({ changedFiles = [], promptModelTouched = false, generatesMedia = false } = {}) {
+// Caminho sensível não muda o verificador: despacha a persona `security` (`securityReviewFor`).
+export function verifierModelFor({ promptModelTouched = false, generatesMedia = false } = {}) {
   const reasons = [];
-  const risky = changedFiles.filter((f) => OPUS_PATH_RE.test(f.replaceAll('\\', '/')));
-  if (risky.length) reasons.push(`caminho sensível: ${firstOf(risky)}`);
   if (promptModelTouched) reasons.push('prompt/modelo alterado');
   if (generatesMedia) reasons.push('gera mídia');
   return { model: reasons.length ? 'opus' : 'sonnet', reasons };
 }
 
-/**
- * @param {object} config - .morph/config/config.json contents (uses `trust`)
- * @param {object} signals
- * @returns {{ pause: boolean, reason: string }}
- */
+export function securityReviewFor(changedFiles = []) {
+  const risky = changedFiles.filter((f) => SECURITY_PATH_RE.test(f.replaceAll('\\', '/')));
+  return { required: risky.length > 0, reasons: risky.length ? [`caminho sensível: ${firstOf(risky)}`] : [] };
+}
+
+const PLAN_CHECKS_REASONS = {
+  'no-plan': 'sem 2-plan/plan.md',
+  'no-checks': 'sem 2-plan/checks.json',
+  unreadable: '2-plan/checks.json ilegível ou de outra versão',
+  stale: '2-plan/checks.json não corresponde ao plan.md atual',
+};
+
+// Regra única do gate-check (pausa) e do approve/advance automáticos (recusa).
+export function planChecksPause(status) {
+  if (status === undefined || status === 'fresh') return null;
+  const what = PLAN_CHECKS_REASONS[status] ?? `checks.json em estado "${status}"`;
+  return `${what} — rode \`morph-spec plan-check {feature}\` até zero erro antes do gate do plano`;
+}
+
 export function shouldPauseGate(config, signals) {
   const trust = config?.trust ?? 'auto';
 
@@ -233,10 +177,7 @@ export function shouldPauseGate(config, signals) {
     };
   }
 
-  // Verify vermelho no momento do gate = a barreira determinística (build/
-  // testes/validadores) está falhando — código antes do juiz vale também
-  // para a decisão de pausa. Só 'fail' pausa: ausência de stamp não é sinal
-  // (features antigas não têm o campo).
+  // Só 'fail' pausa aqui: features antigas não têm o stamp.
   if (signals.verificationStatus === 'fail') {
     return {
       pause: true,
@@ -244,7 +185,7 @@ export function shouldPauseGate(config, signals) {
     };
   }
 
-  // No ship, ausência de stamp não é "verde": uma feature foi aprovada em campo sem verify nenhum.
+  // No ship, ausência de stamp não é verde.
   if (signals.gate === 'review' && !signals.verificationStatus) {
     return {
       pause: true,
@@ -252,68 +193,16 @@ export function shouldPauseGate(config, signals) {
     };
   }
 
-  // No gate de SHIP: um `verification` PRESENTE cujo escopo não é o da feature
-  // é um recorte parcial — de UMA task, nunca da app inteira. O stamp é
-  // SINGULAR, sobrescrito por qualquer verify de qualquer escopo, e vale
-  // INDEPENDENTE do que os nós individuais dizem: mesmo com e2e 'pass' dentro
-  // daquele recorte, build/tests/validators também rodaram só para a task, não
-  // para a feature. Antes desta regra, um `verify {f} {task}` totalmente verde
-  // comprava o Gate 3 da feature que ele nem tentou verificar por inteiro — já
-  // acontecia manualmente (`--filter`), e o recorte automático de PR B faz
-  // acontecer em TODA task. Por isso corre ANTES do bloco de e2e abaixo: ele
-  // pausa por si só, sem depender de e2eStatus/e2eReason.
-  //
-  // `typeof === 'string'` exclui `null`/ausente (features legadas sem stamp) —
-  // narrow, nunca widen. O caminho de volta é sempre o mesmo, barato e nomeado:
-  // `morph-spec verify {feature}` (suíte inteira) antes do ship.
-  if (signals.gate === 'review'
-      && typeof signals.verificationScope === 'string'
-      && signals.verificationScope !== FEATURE_SCOPE) {
-    return {
-      pause: true,
-      reason: `último morph-spec verify foi de escopo "${signals.verificationScope}" (recorte parcial de task)`
-            + ' — rode `morph-spec verify {feature}` (suíte inteira) antes do ship',
-    };
-  }
-
-  // No gate de SHIP apenas: o nó e2e do último verify PULOU. Um skip não
-  // reprova o rollup, então `verificationStatus` sai 'pass' e o gate ficava
-  // cego — auto-passando um Gate 3 sobre uma app que ninguém subiu. A razão
-  // literal decide: dispensa legítima (o projeto não containeriza; o grupo da
-  // task não toca runtime) passa e fica REGISTRADA nos signals; ausência de
-  // prova (docker indisponível, `--skip-e2e`, razão nenhuma) pausa. É a prosa
-  // do morph-review virando regra — "docker indisponível não é dispensa" — e
-  // é o que dispensa o `gate-decision --pause false` manual que ela mandava
-  // rodar. Só no review: pausar o Gate 1/2 numa máquina sem docker travaria
-  // trabalho legítimo de planejamento.
+  // Skip não reprova o rollup, então só a razão literal separa dispensa de ausência de prova.
+  // Só no ship: pausar plan/uiux numa máquina sem docker travaria planejamento legítimo.
   if (signals.gate === 'review' && signals.e2eStatus === 'skip') {
     const klass = classifyE2eSkip(signals.e2eReason);
     if (E2E_SKIP_CLASSES_THAT_PAUSE.includes(klass)) {
       return { pause: true, reason: e2ePauseReason(klass, signals.e2eReason) };
     }
-    // Segunda pergunta, que a razão sozinha não responde: QUEM carimbou. Um
-    // escopo de TASK (`task:{id}`) já pausou acima, antes deste bloco — o que
-    // sobra a checar aqui é só a ausência de escopo (`null`/indefinido:
-    // feature legada, ou stamp anterior à introdução do campo). Cai do mesmo
-    // lado seguro que `unknown` pelo mesmo motivo de sempre: recusar é barato,
-    // aprovar sem prova de QUEM respondeu pela app não é. O caminho de volta é
-    // o mesmo (rodar `verify {feature}`), e é o que morph-review já manda
-    // fazer antes do Gate 3.
-    if (signals.verificationScope == null) {
-      return {
-        pause: true,
-        reason: e2eScopeRefusal(klass, signals.verificationScope, signals.e2eReason),
-      };
-    }
   }
 
-  // Furo 2: no gate de SHIP (review) apenas, um stamp de verification cujo
-  // sha diverge do HEAD atual significa que código mudou depois do último
-  // `morph-spec verify` — o resultado carimbado não cobre mais o que está
-  // prestes a ser aprovado. Pausa só aqui, nunca em plan/uiux/proposal: essa
-  // é uma regra de ship, não uma regra geral de gate. Stamp AUSENTE não entra
-  // aqui (verificationStale é fail-open para `false` em collectSignals
-  // quando não há stamp) — features legadas sem stamp continuam liberadas.
+  // Regra de ship, não de gate em geral; stamp ausente é fail-open (`false`) em collectSignals.
   if (signals.gate === 'review' && signals.verificationStale === true) {
     return {
       pause: true,
@@ -322,23 +211,13 @@ export function shouldPauseGate(config, signals) {
   }
 
   if (signals.gate === 'review') {
-    const reason = verdictPause(signals.evaluatorVerdict);
+    const reason = reviewPause(signals.reviewReports);
     if (reason) return { pause: true, reason };
   }
 
-  // No gate de SHIP apenas: a feature mexeu num caminho que o PROJETO declarou
-  // como prompt ou modelo, e não há eval verde carimbado. Prompt e modelo são a
-  // única parte do produto cujo comportamento não é lido por build nem por teste
-  // unitário: os dois continuam verdes com o prompt trocado.
-  //
-  // DEPOIS da cláusula de procedência do score, de propósito: quando as duas
-  // valem, "Gate 3 sem score do avaliador independente" continua sendo a razão
-  // reportada — é o defeito mais grave dos dois.
-  //
-  // PAUSA, jamais bloqueia: `approve review` não ganha precondição nova. Uma
-  // segunda precondição dura ali tornaria inaprovável, inclusive por decisão
-  // humana, toda feature legada. Pausa é a severidade certa — o humano lê a
-  // razão e decide.
+  // Prompt e modelo não são lidos por build nem por teste. Depois dos relatórios de review de propósito:
+  // relatório ausente é o defeito mais grave. Pausa, nunca bloqueia: bloquear tornaria inaprovável
+  // toda feature legada.
   if (signals.gate === 'review' && (signals.promptModel?.touched?.length ?? 0) > 0) {
     const touched = signals.promptModel.touched;
     const where = `${touched.slice(0, 3).join(', ')}${touched.length > 3 ? ` (+${touched.length - 3})` : ''}`;
@@ -360,9 +239,7 @@ export function shouldPauseGate(config, signals) {
               + ' — rode `morph-spec verify {feature}` (escopo de feature) antes do ship',
       };
     }
-    // 'fail' cai fora: um eval vermelho já avermelha o rollup e a regra de
-    // `verificationStatus` acima pausou antes daqui. 'pass' com stamp velho
-    // também já pausou, por `verificationStale`.
+    // 'fail' já pausou por `verificationStatus`; 'pass' com stamp velho, por `verificationStale`.
   }
 
   // Feature que gera mídia: custo, revisão humana, marcação e hot path só valem provados na seção.
@@ -371,32 +248,26 @@ export function shouldPauseGate(config, signals) {
       && signals.mediaClaims.section !== true) {
     return {
       pause: true,
-      reason: 'relatório do avaliador sem a seção `## Mídia gerada` — as quatro afirmações de mídia'
+      reason: '`4-review/verifier.md` sem a seção `## Mídia gerada` — as quatro afirmações de mídia'
             + ' (custo, revisão humana, marcação, hot path) não foram provadas'
-            + ' (evals/review-checklist.md, "Feature que gera mídia")',
+            + ' (evals/review-checklist.md, "Verificador")',
     };
   }
 
-  // No fecho do DESIGN: o mockup declara telas sem o checklist de tela
-  // completo. É ele que faz paginação, ordenação, filtro e os três estados
-  // virarem `doneCriteria` — sem ele, uma lista de 2 000 linhas é aprovada
-  // listando tudo, e o implementador entrega exatamente o critério.
+  // Sem o checklist de tela completo, paginação, ordenação, filtro e os três estados não viram cenário.
   if (signals.gate === 'uiux') {
     const reason = uiuxChecklistPause(signals.screenChecklist);
     if (reason) return { pause: true, reason };
   }
 
-  // No SHIP, depois da cláusula de mídia e pela mesma disciplina: o design
-  // decidiu itens de tela e o avaliador não registrou a conferência deles
-  // contra a tela entregue. Cobra-se o item DEVIDO (`uncovered`): tela toda
-  // "não se aplica", mockup legado ou ausente não devem nada.
+  // Cobra-se só o item devido (`uncovered`): tela toda "não se aplica", design legado ou ausente não devem nada.
   if (signals.gate === 'review' && (signals.screenChecklist?.uncovered?.length ?? 0) > 0) {
     const { section, uncovered } = signals.screenChecklist;
     if (section !== true) {
       return {
         pause: true,
-        reason: `relatório do avaliador sem a seção \`## Checklist de tela\` — o design decidiu ${firstOf(uncovered)}`
-              + ' e a avaliação não registrou a conferência contra a tela entregue'
+        reason: `\`4-review/verifier.md\` sem a seção \`## Checklist de tela\` — o design decidiu ${firstOf(uncovered)}`
+              + ' e o verificador não registrou a conferência contra a tela entregue'
               + ' (evals/review-checklist.md, "Contrato de tela")',
       };
     }
@@ -407,28 +278,21 @@ export function shouldPauseGate(config, signals) {
     };
   }
 
-  if (signals.gate === 'plan' && Array.isArray(signals.oversizedTasks) && signals.oversizedTasks.length > 0) {
-    const list = signals.oversizedTasks.map((t) => `${t.id} (${t.outputs})`).join(', ');
-    return {
-      pause: true,
-      reason: `task grande demais para um dispatch: ${list} outputs — fatie por pós-condição`,
-    };
+  if (signals.gate === 'plan') {
+    const reason = planChecksPause(signals.planChecks);
+    if (reason) return { pause: true, reason };
   }
 
-  if (typeof signals.taskCount === 'number' && signals.taskCount > SCOPE_TASK_THRESHOLD) {
+  if (typeof signals.sliceCount === 'number' && signals.sliceCount > MAX_SLICES) {
     return {
       pause: true,
-      reason: `scope of ${signals.taskCount} tasks exceeds threshold ${SCOPE_TASK_THRESHOLD}`,
+      reason: `${signals.sliceCount} fatias, acima de ${MAX_SLICES} — o plano é grande demais para uma feature`,
     };
   }
 
   return { pause: false, reason: '' };
 }
 
-/**
- * Human-readable list of risk signals present (for logging/Gate summary).
- * @returns {string[]}
- */
 export function getRiskSignals(signals) {
   const out = [];
   if (FORCED_PAUSE_WORK_TYPES.includes(signals.workType)) out.push('hotfix (gate humano obrigatório)');
@@ -437,25 +301,19 @@ export function getRiskSignals(signals) {
     out.push(`standards violations: ${signals.standardsViolations.join(', ')}`);
   }
   if (signals.verificationStatus === 'fail') out.push('verify vermelho');
-  // Listado mesmo quando NÃO pausa: uma dispensa que passa silenciosamente é
-  // indistinguível de uma omissão. A classe diz de quem é a ausência de prova.
+  // Listado mesmo quando não pausa: dispensa silenciosa é indistinguível de omissão.
   if (signals.gate === 'review' && signals.e2eStatus === 'skip') {
     const klass = classifyE2eSkip(signals.e2eReason);
     const literal = typeof signals.e2eReason === 'string' && signals.e2eReason.trim() !== ''
       ? signals.e2eReason.trim()
       : 'sem motivo registrado';
-    const where = typeof signals.verificationScope === 'string' && signals.verificationScope.trim() !== ''
-      ? signals.verificationScope.trim()
-      : 'escopo ausente';
-    out.push(`e2e pulado [${klass}] (stamp de ${where}): ${literal}`);
+    out.push(`e2e pulado [${klass}]: ${literal}`);
   }
   if (signals.gate === 'review' && signals.verificationStale === true) {
     out.push('verification stamp desatualizado (stale) no ship');
   }
-  if (signals.gate === 'review') out.push(verdictSummary(signals.evaluatorVerdict));
-  // Listado mesmo quando NÃO pausa, pela mesma razão do e2e: um projeto que não
-  // declara caminho de prompt/modelo é indistinguível, no relatório, de um que
-  // declara e não tocou em nada — e as duas coisas significam coisas diferentes.
+  if (signals.gate === 'review') out.push(reviewSummary(signals.reviewReports));
+  // Listado mesmo quando não pausa, pela mesma razão do e2e.
   if (signals.gate === 'review' && signals.promptModel) {
     const { declared, touched } = signals.promptModel;
     if (!declared) {
@@ -464,23 +322,18 @@ export function getRiskSignals(signals) {
       out.push(`prompt/modelo tocado (${touched.length}) com eval ${signals.evalsStatus ?? 'não declarado'}`);
     }
   }
-  if (signals.gate === 'plan' && Array.isArray(signals.oversizedTasks) && signals.oversizedTasks.length > 0) {
-    out.push(`tasks grandes demais: ${signals.oversizedTasks.map((t) => t.id).join(', ')}`);
+  if (signals.gate === 'plan' && signals.planChecks && signals.planChecks !== 'fresh') {
+    out.push(`checks.json ${signals.planChecks}`);
   }
-  if (typeof signals.taskCount === 'number' && signals.taskCount > SCOPE_TASK_THRESHOLD) {
-    out.push(`${signals.taskCount} tasks (over threshold)`);
+  if (typeof signals.sliceCount === 'number' && signals.sliceCount > MAX_SLICES) {
+    out.push(`${signals.sliceCount} fatias (acima de ${MAX_SLICES})`);
   }
-  // Listado mesmo quando NÃO pausa, pela mesma razão do sinal irmão: a isenção
-  // de uma feature que não gera mídia tem de ser VISÍVEL, senão é
-  // indistinguível de uma omissão.
   if (signals.gate === 'review' && signals.mediaClaims?.featureGeneratesMedia === true) {
     out.push(signals.mediaClaims.section === true
       ? 'prova de mídia registrada'
-      : 'relatório sem a seção `## Mídia gerada` (prova de mídia ausente)');
+      : 'verifier.md sem a seção `## Mídia gerada` (prova de mídia ausente)');
   }
 
-  // Listado mesmo quando NÃO pausa: a isenção (sem mockup, legado, nada
-  // devido) e o checklist conferido precisam ser distinguíveis de uma omissão.
   if ((signals.gate === 'uiux' || signals.gate === 'review') && signals.screenChecklist) {
     const { mockups, legacy, exempt, screens = [], problems = [], section, uncovered = [] } = signals.screenChecklist;
     if (!mockups) {
@@ -491,13 +344,18 @@ export function getRiskSignals(signals) {
       out.push(problems.length > 0
         ? `checklist de tela incompleto (${problems.length} problema(s))`
         : `checklist de tela completo (${screens.length} tela(s))`);
+      const prototypes = signals.screenChecklist.prototypes ?? [];
+      if (screens.length > 0) {
+        out.push(prototypes.length > 0
+          ? `protótipo incompleto em ${prototypes.length} tela(s)`
+          : `protótipo e prints 1280/390 presentes (${screens.length} tela(s))`);
+      }
     } else if (uncovered.length > 0) {
       out.push(section !== true
-        ? 'relatório sem a seção `## Checklist de tela`'
+        ? 'verifier.md sem a seção `## Checklist de tela`'
         : `checklist de tela sem conferência em ${uncovered.length} tela(s)`);
     } else if (screens.length === 0) {
-      // O design passou pela uiux sem tela nenhuma: nada a cobrar no ship, mas
-      // não pode ler igual a uma tela toda "não se aplica".
+      // Sem tela nenhuma: nada a cobrar no ship, mas não pode ler igual a uma tela toda "não se aplica".
       out.push(`checklist de tela: ${firstOf(problems)}`);
     } else if (section === true) {
       out.push(`checklist de tela conferido (${screens.length} tela(s))`);
@@ -510,7 +368,6 @@ export function getRiskSignals(signals) {
 }
 
 export const RISK_CONSTANTS = {
-  SCOPE_TASK_THRESHOLD,
   FORCED_PAUSE_WORK_TYPES,
   E2E_SKIP_CLASSES_THAT_PAUSE,
 };