@polymorphism-tech/morph-spec 8.47.0 → 9.0.0

package/src/lib/risk-detector.js

@@ -9,30 +9,28 @@
  *   - 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`
+ *     cuja razão NÃO seja dispensa legítima pausa SÓ no ship (gate 'review')
  *   - 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
+ *   - reviewReports + gate: object    — `reviewSignal` (review-reports.js): os
+ *     relatórios exigidos e a cobertura dos Cn. No ship, só SHIP sem bloqueador
+ *     em todo exigido, com todo Cn PROVADO, 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)
+ *     verificador pausa. Mockup legado é isento nos dois, com a razão listada
+ *   - planChecks + gate: string       — `readPlanChecks(...).status`: os checks
+ *     extraídos contra o plano; no gate do plano, tudo que não é `fresh` pausa
+ *   - sliceCount: number              — fatias extraídas (pausa acima de MAX_SLICES)
  */
 
-const SCOPE_TASK_THRESHOLD = 20;
+import { MAX_SLICES } from './plan/checks.js';
+import { BLOCKER_TYPES, reviewFileName } from './review-reports.js';
 
-// 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;
+// Caminho alterado que pede a revisão de segurança (persona `security`, opus).
+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;
 
 // 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
@@ -53,8 +51,6 @@ const E2E_SKIP_PATTERNS = [
   [/^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
@@ -63,23 +59,13 @@ const E2E_SKIP_PATTERNS = [
 // esta regra existe para eliminar.
 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
+ * A assimetria é o ponto: `project` descreve 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
@@ -88,7 +74,7 @@ const FEATURE_SCOPE = 'feature';
  * @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'}
+ * @returns {'environment'|'requested'|'project'|'unknown'}
  */
 export function classifyE2eSkip(reason) {
   const text = typeof reason === 'string' ? reason.trim() : '';
@@ -116,20 +102,6 @@ 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';
 
@@ -159,50 +131,115 @@ export function uiuxChecklistPause(screenChecklist) {
        + ' ("não se aplica" vale, se escrito)';
 }
 
-function blockerList(v) {
-  return firstOf(v.blockerIds ?? []);
-}
-
-/** 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' };
+
+/** Por que os relatórios de review seguram o ship, ou null. */
+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.
+ * Modelo do verificador: `opus` quando a feature mexe em prompt/modelo ou
+ * gera mídia; `sonnet` no resto. Caminho sensível não muda o verificador:
+ * despacha a persona `security` ({@link securityReviewFor}).
  *
- * @param {{ changedFiles?: string[], promptModelTouched?: boolean, generatesMedia?: boolean }} input
+ * @param {{ promptModelTouched?: boolean, generatesMedia?: boolean }} input
  * @returns {{ model: 'opus'|'sonnet', reasons: string[] }}
  */
-export function evaluatorModelFor({ changedFiles = [], promptModelTouched = false, generatesMedia = false } = {}) {
+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 };
 }
 
+/**
+ * A revisão de segurança é exigida quando o diff toca auth, segredo,
+ * permissão, dado pessoal, pagamento ou migration.
+ *
+ * @param {string[]} changedFiles
+ * @returns {{ required: boolean, reasons: 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',
+};
+
+/**
+ * Por que o gate do plano não fecha sem pessoa: os checks extraídos são o que
+ * o apply despacha, o report-check confere e a review cobra — um plano sem
+ * eles, ou com os de outra versão do plano, aprovaria critérios que ninguém
+ * extraiu.
+ * Regra única do gate-check (pausa) e do approve/advance automáticos (recusa).
+ *
+ * @param {string|undefined} status - `readPlanChecks(...).status`
+ * @returns {string|null}
+ */
+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`;
+}
+
 /**
  * @param {object} config - .morph/config/config.json contents (uses `trust`)
  * @param {object} signals
@@ -252,35 +289,11 @@ 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
+  // literal decide: dispensa legítima (o projeto não containeriza) 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
@@ -291,26 +304,12 @@ export function shouldPauseGate(config, signals) {
     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
+  // prestes a ser aprovado. Pausa só aqui, nunca em plan/uiux: 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.
@@ -322,7 +321,7 @@ 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 };
   }
 
@@ -331,9 +330,8 @@ export function shouldPauseGate(config, signals) {
   // ú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.
+  // DEPOIS dos relatórios de review, de propósito: relatório ausente é o
+  // defeito mais grave dos dois e é a razão reportada.
   //
   // PAUSA, jamais bloqueia: `approve review` não ganha precondição nova. Uma
   // segunda precondição dura ali tornaria inaprovável, inclusive por decisão
@@ -371,23 +369,23 @@ 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.
+  // virarem cenário do plano — sem ele, uma lista de 2 000 linhas é aprovada
+  // listando tudo, e o implementador entrega exatamente o 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
+  // decidiu itens de tela e o verificador 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.
   if (signals.gate === 'review' && (signals.screenChecklist?.uncovered?.length ?? 0) > 0) {
@@ -395,8 +393,8 @@ export function shouldPauseGate(config, signals) {
     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,18 +405,15 @@ 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`,
     };
   }
 
@@ -444,15 +439,12 @@ export function getRiskSignals(signals) {
     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));
+  if (signals.gate === 'review') out.push(reviewSummary(signals.reviewReports));
   // 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.
@@ -464,11 +456,11 @@ 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 é
@@ -476,7 +468,7 @@ export function getRiskSignals(signals) {
   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
@@ -493,7 +485,7 @@ export function getRiskSignals(signals) {
         : `checklist de tela completo (${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
@@ -510,7 +502,6 @@ export function getRiskSignals(signals) {
 }
 
 export const RISK_CONSTANTS = {
-  SCOPE_TASK_THRESHOLD,
   FORCED_PAUSE_WORK_TYPES,
   E2E_SKIP_CLASSES_THAT_PAUSE,
 };

package/src/lib/specs/adr-index.js

@@ -1,36 +1,25 @@
 /**
  * The index of the ADRs that still hold across the project:
- * `.morph/specs/adrs/`, one file per ADR, committed next to the use-case acervo.
- *
- * Every feature writes ADRs into its own `decisions.md`, and most of them only
- * matter inside that feature. The index keeps the few that set a project-wide
- * rule, so brainstorming and plan read one folder instead of every archived
- * `decisions.md` — those stay as history, not as instruction.
- *
- * One file per ADR (`{feature}--ADR-{nnn}.md`), like the use-case acervo:
- * parallel features that index different ADRs never touch the same file, so
- * their archive commits merge cleanly — a single shared page conflicted on the
- * second merge.
- *
- * Maintained by finish/archive alone, inside the archive commit:
- *   - enters: an ADR of the closing feature whose block carries `**Alcance:** projeto`;
- *   - leaves: an ADR the closing feature's `spec.md` revokes in full (file deleted);
+ * `.morph/specs/adrs/`, one file per ADR, maintained by finish/archive alone,
+ * inside the archive commit, from the closing feature's `2-plan/plan.md`:
+ *   - enters: an ADR of `## Decisões` with `**Alcance:** projeto`;
+ *   - leaves: an ADR its `### Conflitos com o acervo` revokes in full (file deleted);
  *   - narrows: one it revokes in part keeps its file, with `scope:` where it still holds.
- * Nothing to add or revoke → nothing is touched (nor created).
+ * One file per ADR so parallel features that index different ADRs merge cleanly.
  */
 
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { basename, join } from 'path';
+import { readFrontmatterField, setFrontmatterField } from './frontmatter.js';
+import { parseRevocations } from './revocations.js';
+import { parsePlan } from '../plan/plan-parser.js';
 import { OUTPUT_SCHEMA } from '../../core/paths/output-schema.js';
-import { readFrontmatterField, setFrontmatterField } from './usecase-promoter.js';
 
 /** Project-relative path of the index folder (git pathspec-ready). */
 export const ADR_INDEX_PATHSPEC = join('.morph', 'specs', 'adrs');
 
-const ADR_HEADING_RE = /^(#{2,6})\s+(ADR-\d+)\b[\s:—–-]*(.*?)\s*$/;
-const ANY_HEADING_RE = /^(#{1,6})\s/;
-/** `**Alcance:** projeto` — also `**Alcance**: projeto`. */
-const PROJECT_SCOPE_RE = /^\s*\*\*Alcance:?\*\*:?\s*projeto\b/i;
+const PLAN = OUTPUT_SCHEMA.plan;
+const INDEX_LABEL = '.morph/specs/adrs/';
 const INDEX_FILE_RE = /^([a-z0-9][a-z0-9-]*)--(ADR-\d+)\.md$/;
 
 /** `admin/ADR-001` ↔ `admin--ADR-001.md`. */
@@ -40,50 +29,19 @@ const refOf = (name) => {
   return m ? `${m[1]}/${m[2]}` : null;
 };
 
-/**
- * The ADRs of one `decisions.md` marked as project-wide, each with its block.
- *
- * @param {string} content
- * @returns {Array<{ adr: string, title: string, body: string }>}
- */
-export function projectAdrs(content) {
-  const out = [];
-  let current = null; // { adr, title, level, marked, lines }
-  const close = () => {
-    if (current?.marked) out.push({ adr: current.adr, title: current.title, body: current.lines.join('\n').trim() });
-    current = null;
-  };
-
-  for (const line of String(content ?? '').split(/\r?\n/)) {
-    const adr = ADR_HEADING_RE.exec(line);
-    if (adr) {
-      close();
-      current = { adr: adr[2], title: adr[3], level: adr[1].length, marked: false, lines: [] };
-      continue;
-    }
-    const heading = ANY_HEADING_RE.exec(line);
-    if (current && heading && heading[1].length <= current.level) { close(); continue; }
-    if (!current) continue;
-    if (PROJECT_SCOPE_RE.test(line)) current.marked = true;
-    current.lines.push(line);
-  }
-  close();
-  return out;
-}
-
 function renderAdrFile({ ref, title, body }, feature) {
-  const decisions = `.morph/archive/${feature}/${OUTPUT_SCHEMA.decisions.phaseDir}/${OUTPUT_SCHEMA.decisions.filename}`;
+  const source = `.morph/archive/${feature}/${PLAN.phaseDir}/${PLAN.filename}`;
   return [
     '---',
     `adr: ${ref}`,
     `title: ${JSON.stringify(title)}`,
-    `source: ${decisions}`,
+    `source: ${source}`,
     '---',
     '',
     `# ${ref}: ${title}`,
     '',
-    '> Mantido pelo `morph-spec finish` — não edite à mão. Vale no projeto até que o `spec.md` de uma',
-    '> feature o revogue: por inteiro, e este arquivo sai; em parte, e `scope:` diz onde ele ainda vale.',
+    '> Mantido pelo `morph-spec finish` — não edite à mão. Vale no projeto até que o `plan.md` de uma',
+    '> feature o revogue em `### Conflitos com o acervo`: por inteiro, e este arquivo sai; em parte, e `scope:` diz onde ele ainda vale.',
     '',
     body,
     '',
@@ -112,29 +70,29 @@ export function readAdrIndex(cwd) {
 }
 
 /**
- * Apply a closing feature to the index: its project-wide ADRs enter, and the
- * ADR revocations its `spec.md` declared delete a file (total) or narrow it
- * (parcial).
+ * Apply a closing feature's plan to the index: its project-wide ADRs enter, and
+ * the ADRs its conflicts table revokes are deleted (total) or narrowed (parcial).
+ * An unreadable or absent plan touches nothing.
  *
  * @param {string} cwd
  * @param {string} featureDir - the feature folder (already archived, at close time)
- * @param {Array<{ id: string, change: 'total'|'parcial', scope: string|null }>} revocations - ADR entries of `parseRevocations`
  * @returns {{ changed: boolean, added: string[], revoked: string[], narrowed: string[],
- *   problems: Array<{ id: string, reason: string, message: string }> }}
+ *   problems: Array<{ id: string|null, reason: string, message: string }> }}
  */
-export function updateAdrIndex(cwd, featureDir, revocations = []) {
+export function updateAdrIndex(cwd, featureDir) {
   const result = { changed: false, added: [], revoked: [], narrowed: [], problems: [] };
   const feature = basename(featureDir);
   const dir = join(cwd, ADR_INDEX_PATHSPEC);
 
-  let marked = [];
+  let plan = null;
   try {
-    const decisions = join(featureDir, OUTPUT_SCHEMA.decisions.phaseDir, OUTPUT_SCHEMA.decisions.filename);
-    if (existsSync(decisions)) marked = projectAdrs(readFileSync(decisions, 'utf8'));
-  } catch { /* unreadable decisions.md — nothing enters */ }
+    const planPath = join(featureDir, PLAN.phaseDir, PLAN.filename);
+    if (existsSync(planPath)) plan = parsePlan(readFileSync(planPath, 'utf8'));
+  } catch { /* unreadable plan.md — nothing enters or leaves */ }
+  if (!plan) return result;
 
-  for (const { adr, title, body } of marked) {
-    const ref = `${feature}/${adr}`;
+  for (const { id, title, body } of plan.adrs.filter((a) => a.scope === 'projeto')) {
+    const ref = `${feature}/${id}`;
     const path = join(dir, adrFileName(ref));
     const next = renderAdrFile({ ref, title, body }, feature);
     const existed = existsSync(path);
@@ -145,13 +103,15 @@ export function updateAdrIndex(cwd, featureDir, revocations = []) {
     if (!existed) result.added.push(ref);
   }
 
+  const { entries: revocations, problems } = parseRevocations(plan.conflicts?.text);
+  result.problems.push(...problems);
   for (const rev of revocations) {
     const path = join(dir, adrFileName(rev.id));
     if (!existsSync(path)) {
       result.problems.push({
         id: rev.id,
         reason: 'adr-not-indexed',
-        message: `${rev.id} não está no índice de ADRs ativos (${ADR_INDEX_PATHSPEC.replace(/\\/g, '/')}/) — nada a retirar; o decisions.md arquivado segue como história`,
+        message: `${rev.id} não está no índice de ADRs ativos (${INDEX_LABEL}) — nada a retirar; o plan.md arquivado segue como história`,
       });
       continue;
     }
@@ -167,3 +127,24 @@ export function updateAdrIndex(cwd, featureDir, revocations = []) {
 
   return result;
 }
+
+/**
+ * What the finish would fail to apply from a plan's revocation table, reported
+ * while the plan can still change.
+ *
+ * @param {string} cwd
+ * @param {ReturnType<typeof parsePlan>} plan
+ * @returns {string[]}
+ */
+export function revocationWarnings(cwd, plan) {
+  const { entries, problems } = parseRevocations(plan.conflicts?.text);
+  const warnings = problems.map((p) => `### Conflitos com o acervo: ${p.message}`);
+  if (entries.length === 0) return warnings;
+  const indexed = new Set(readAdrIndex(cwd).map((a) => a.ref));
+  for (const e of entries) {
+    if (!indexed.has(e.id)) {
+      warnings.push(`### Conflitos com o acervo: ${e.id} não está no índice de ADRs ativos (${INDEX_LABEL}) — o finish não terá o que retirar`);
+    }
+  }
+  return warnings;
+}