@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

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

@@ -1,361 +1,179 @@
-/**
- * `morph-spec report-check <feature> [task] [--json]` — the deterministic half
- * of the missing-report protocol (B4).
- *
- * MORPH.md already made the sub-agent's canonical report file the authoritative
- * return value ("o ARQUIVO é o retorno, a última mensagem é cortesia"), but it
- * never said what to do when the file is not there. The naive reading — "no
- * report, so the agent failed" — is wrong and expensive: the agent may have
- * done every bit of the work and lost the means to record it (observed: a
- * worktree removed out from under a running sub-agent).
- *
- * So this command answers the question the orchestrator actually has, and
- * answers it from evidence rather than from the agent's own word: **did the
- * WORK land, independently of whether the REPORT did?**
- *
- *   verdict                          action
- *   ─────────────────────────────    ──────────────────
- *   ok                               proceed
- *   report-incomplete                complete-degraded
- *   work-landed-report-missing       accept-degraded
- *   no-work-no-report                redispatch
- *   report-missing-evidence-unknown  redispatch   (conservative default)
- *
- * Exit 0 only for `ok` — anything needing an action exits non-zero so a caller
- * can branch on it. `--json` always prints the machine-readable verdict.
- *
- * The output also carries `tree` (see tree-state.js): the working tree the
- * orchestrator would otherwise ask git for, call by call, right after the same
- * dispatch. It is information only and never changes the verdict.
- */
+// Judged from observed evidence, never the agent's word: did the WORK land, independently of
+// the REPORT? The `tree` block is information only and never changes the verdict.
 
 import chalk from 'chalk';
 import { existsSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
-import { readTelemetryEvents, isFailedToolCall } from '../../../framework/hooks/shared/telemetry-logger.js';
+import { isFailedToolCall } from '../../../framework/hooks/shared/telemetry-logger.js';
+import { sliceReportPath, inspectReport, REPORT_MARKERS } from '../../../framework/hooks/shared/slice-progress.js';
+import { loadTelemetryAllTrees, dedupeEvents } from '../../lib/telemetry/telemetry-reader.js';
 import { treeState, snapshotTree } from '../../lib/git/tree-state.js';
 import { atomicWriteJson } from '../../core/state/state-manager.js';
 import { minimatch } from 'minimatch';
-import { evaluatorVerdictFromText, VERDICTS } from '../../lib/evaluator-report.js';
-import { evaluatorModelFor } from '../../lib/risk-detector.js';
+import { reviewReports, reviewFileName } from '../../lib/review-reports.js';
+import { verifierModelFor } from '../../lib/risk-detector.js';
 import { changedPathsAgainst, detectDefaultBranch } from '../../lib/git/default-branch.js';
 import { readMorphConfig } from '../../lib/tasks/test-runner.js';
-import { featureGeneratesMedia } from './gate-check.js';
-
-/**
- * The mandatory items of the report contract, as detectable markers.
- *
- * HEURISTIC BY CONSTRUCTION, and deliberately loose: the contract asks for
- * content, not for a fixed template, and reports written before this command
- * existed must still audit cleanly. A false "complete" is the cheap error here
- * (the orchestrator reads the report anyway); a false "incomplete" would send
- * it re-dispatching finished work, which is the expensive one.
- */
-const REPORT_MARKERS = [
-  // (2) files touched — a list line carrying a path or a backticked identifier
-  { id: 'files', re: /^\s*[-*]\s+.*[`/\\].*$/m },
-  // (3) each doneCriteria, met or not, with its evidence
-  { id: 'criteria', re: /crit[ée]rio|doneCriteria|p[óo]s-condi[çc][ãa]o|atendid/i },
-];
-
-/** (1) "what was done" — prose beyond the structural markers. */
-const MIN_PROSE_CHARS = 80;
-
-/**
- * The partial-report marker of the dispatch contract (clause 5, ADR-004): a
- * sub-agent nearing its `maxTurns` ceiling writes `PARCIAL` on the FIRST line.
- * Tolerates heading/bold/quote typography (`# PARCIAL`, `**PARCIAL**`).
- */
-const PARTIAL_MARKER = /^[\s#>*_]*PARCIAL\b/;
-
-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');
-}
-
-/**
- * Inspect one report file: does it exist, and which of the four mandatory
- * items can be found in it.
- */
-export function inspectReport(path) {
-  if (!existsSync(path)) return { exists: false, complete: false, missing: ['what', 'files', 'criteria'] };
-  let body = '';
-  try {
-    body = readFileSync(path, 'utf8');
-  } catch {
-    return { exists: true, complete: false, missing: ['what', 'files', 'criteria'], unreadable: true };
+import { readPlanChecks } from '../../lib/plan/checks.js';
+import { featureGeneratesMedia, collectReviewRequirement } from './gate-check.js';
+
+export { inspectReport, REPORT_MARKERS };
+
+/** Each review report: complete when it carries a readable verdict and is not partial. */
+export function inspectReviewReports(cwd, feature) {
+  const out = {};
+  for (const [role, r] of Object.entries(reviewReports(cwd, feature))) {
+    out[role] = r.status === 'missing'
+      ? { exists: false, complete: false, partial: false, verdict: null }
+      : { exists: true, complete: r.status === 'ok', partial: r.status === 'partial', verdict: r.verdict ?? null };
   }
-
-  const missing = REPORT_MARKERS.filter((m) => !m.re.test(body)).map((m) => m.id);
-  // Prose = the body minus headings and list lines, so a bare file list does
-  // not pass as "what was done".
-  const prose = body
-    .split('\n')
-    .filter((l) => !/^\s*(#|[-*]\s)/.test(l))
-    .join(' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-  if (prose.length < MIN_PROSE_CHARS) missing.unshift('what');
-
-  const firstLine = body.split('\n').find((l) => l.trim() !== '') ?? '';
-  const partial = PARTIAL_MARKER.test(firstLine);
-  if (partial) missing.push('partial');
-
-  return { exists: true, complete: missing.length === 0, missing, partial };
-}
-
-/** The evaluator report is complete when it carries a readable verdict and is not partial. */
-export function inspectEvaluatorReport(path) {
-  if (!existsSync(path)) return { exists: false, complete: false };
-  let body = '';
-  try { body = readFileSync(path, 'utf8'); } catch { return { exists: true, complete: false, unreadable: true }; }
-  const firstLine = body.split('\n').find((l) => l.trim() !== '') ?? '';
-  const partial = PARTIAL_MARKER.test(firstLine);
-  const { verdict } = evaluatorVerdictFromText(body);
-  return { exists: true, complete: !partial && VERDICTS.includes(verdict), partial, verdict: verdict ?? null };
+  return out;
 }
 
-function evaluatorDispatch(cwd, tasks) {
+// The verifier routes to opus on prompt/model or media; security is dispatched only when required.
+function reviewDispatch(cwd, feature, slices) {
   let changedFiles = [];
   try { changedFiles = changedPathsAgainst(detectDefaultBranch(cwd), cwd); } catch { changedFiles = []; }
   const watch = readMorphConfig(cwd)?.project?.evals?.watch;
   const globs = Array.isArray(watch) ? watch.filter((g) => typeof g === 'string' && g.trim()) : [];
-  return evaluatorModelFor({
-    changedFiles,
-    promptModelTouched: changedFiles.some((f) => globs.some((g) => minimatch(f, g))),
-    generatesMedia: featureGeneratesMedia(tasks),
-  });
-}
-
-/** How many of a task's declared outputs actually exist on disk. */
-function outputEvidence(cwd, taskOutputs) {
-  const expected = Array.isArray(taskOutputs) ? taskOutputs : [];
-  const present = expected.filter((rel) => {
-    try {
-      return existsSync(join(cwd, rel));
-    } catch {
-      return false;
-    }
-  }).length;
-  return { outputsExpected: expected.length, outputsPresent: present };
+  let workType;
+  try { workType = JSON.parse(readFileSync(join(cwd, '.morph', 'features', feature, 'feature.json'), 'utf8')).workType; } catch { workType = undefined; }
+  const { required, security } = collectReviewRequirement(cwd, { workType });
+  return {
+    required,
+    verifier: verifierModelFor({
+      promptModelTouched: changedFiles.some((f) => globs.some((g) => minimatch(f, g))),
+      generatesMedia: featureGeneratesMedia(slices),
+    }),
+    reviewer: { model: 'sonnet', reasons: [] },
+    security: { required: security.required, model: 'opus', reasons: security.reasons },
+  };
 }
 
-/**
- * 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.
- */
+// Two clocks: the report mtime comes from the filesystem, the event `ts` from the hook. Two
+// seconds absorb their skew and are far less than any real work done after reporting.
 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(/\/+$/, '');
+const slash = (p) => String(p || '').replace(/\\/g, '/');
+
+function toTreeRelative(target, treePath) {
+  const norm = slash(target);
+  const root = slash(treePath).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.
+  // Case-insensitive prefix: on Windows the same root arrives as `R:/repo` or `r:/repo`.
   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/');
+const reportSuffix = (feature, sliceId) => `.morph/features/${feature}/3-implement/reports/${sliceId}.md`.toLowerCase();
+
+function loadWrites(cwd) {
+  let trees = [];
+  try { trees = loadTelemetryAllTrees(cwd); } catch { trees = []; }
+  const events = [];
+  for (const tree of trees) {
+    for (const e of tree.events) {
+      if (e?.tool !== 'Write' && e?.tool !== 'Edit') continue;
+      if (isFailedToolCall(e)) continue;
+      const ts = Date.parse(e?.ts ?? '');
+      if (!Number.isFinite(ts)) continue;
+      events.push({ ...e, rel: toTreeRelative(e.target, tree.path), tsMs: ts });
+    }
+  }
+  return { available: trees.some((t) => t.events.length > 0), writes: dedupeEvents(events) };
 }
 
-/**
- * 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;
-    if (isFailedToolCall(e)) 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 });
+// The owning dispatch is the latest sub-agent write of the report; a later orchestrator edit
+// does not hide it. Without a report, any write to one of the slice files says the work landed.
+function observedEvidence(telemetry, feature, slice) {
+  if (!telemetry.available) return { available: false };
+  const suffix = reportSuffix(feature, slice.id);
+  const isReport = (w) => slash(w.target).toLowerCase().endsWith(suffix);
+  const declared = new Set((slice.files ?? []).map((f) => slash(f).replace(/^\.\//, '').toLowerCase()));
+  const isSliceFile = (w) => declared.has(w.rel.toLowerCase());
+
+  const reportWrites = telemetry.writes.filter((w) => isReport(w) && w.agentId);
+  const agentId = reportWrites.length ? reportWrites[reportWrites.length - 1].agentId : null;
+  if (!agentId) {
+    return { available: true, agentId: null, sliceWrites: telemetry.writes.filter(isSliceFile).length };
   }
 
-  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))];
-
+  const work = telemetry.writes.filter((w) => w.agentId === agentId && !isReport(w) && !w.rel.includes('.morph/'));
+  const observed = [...new Set(work.map((w) => w.rel))];
+  const observedKeys = new Set(observed.map((f) => f.toLowerCase()));
   return {
     available: true,
+    agentId,
     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)),
+    lastWriteAt: work.length ? new Date(Math.max(...work.map((w) => w.tsMs))).toISOString() : null,
+    undeclared: observed.filter((f) => !declared.has(f.toLowerCase())),
+    unobserved: (slice.files ?? []).filter((f) => !observedKeys.has(slash(f).replace(/^\.\//, '').toLowerCase())),
+    sliceWrites: work.filter(isSliceFile).length,
   };
 }
 
-/** 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;
+  if (!observed?.agentId || !observed.lastWriteAt) return false;
   try {
-    const writtenAt = statSync(reportFsPath).mtimeMs;
-    return writtenAt + STALE_TOLERANCE_MS < Date.parse(observed.lastWriteAt);
+    return statSync(reportFsPath).mtimeMs + 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, stale) {
+function decide(report, observed, 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.
+    // Structural integrity answers "is the report complete?", never "is it
+    // still true?": an agent can write it early, keep working and be cut off.
     return stale
       ? { verdict: 'report-stale', action: 'refresh-from-evidence' }
       : { verdict: 'ok', action: 'proceed' };
   }
-  // A PARCIAL report is an agent that stopped short (turn ceiling): the work
-  // resumes from its last `wip` commit — completing it DEGRADADO would stamp
-  // unfinished work as done.
+  // PARCIAL: the agent stopped short (turn ceiling) and resumes from its last
+  // `wip` commit — completing it DEGRADADO would stamp unfinished work as done.
   if (report.exists && report.partial) return { verdict: 'report-incomplete', action: 'resume' };
   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
-    // sub-agent; silently accepting a phantom completion costs correctness.
-    return { verdict: 'report-missing-evidence-unknown', action: 'redispatch' };
-  }
-  return evidence.outputsPresent > 0
+  if (!observed.available) return { verdict: 'report-missing-evidence-unknown', action: 'redispatch' };
+  return observed.sliceWrites > 0
     ? { verdict: 'work-landed-report-missing', action: 'accept-degraded' }
     : { verdict: 'no-work-no-report', action: 'redispatch' };
 }
 
-function checkTask(cwd, feature, task) {
-  const fsPath = reportPath(cwd, feature, task.id);
-  const report = inspectReport(fsPath);
-  const evidence = outputEvidence(cwd, task.outputs);
-  const observed = observedEvidence(cwd, feature, task);
+function checkSlice(cwd, feature, slice, telemetry) {
+  const fsPath = sliceReportPath(join(cwd, '.morph', 'features', feature), slice.id);
+  const report = inspectReport(fsPath, { covers: slice.covers ?? [] });
+  const observed = observedEvidence(telemetry, feature, slice);
   const stale = report.exists && isReportStale(fsPath, observed);
-  return { task: task.id, report, evidence, observed, ...decide(report, evidence, stale) };
+  return { slice: slice.id, report, observed, ...decide(report, observed, 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.',
-  resume: 'relatório PARCIAL: o sub-agent parou antes do fim (limite de turnos) e a task NÃO está pronta. Não carimbe DEGRADADO nem pontue — retome o MESMO agente por `SendMessage` (cole no recado `tree.dirty` e `tree.commits` desta saída e o que falta) ou re-despache só o que falta, a partir do último commit `wip`.',
-  '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.',
+  'refresh-from-evidence': 'o relatório está COMPLETO mas VELHO: o agente da fatia seguiu escrevendo arquivos depois de gravá-lo, 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 nele a falha de protocolo.',
+  resume: 'relatório PARCIAL: o sub-agent parou antes do fim (limite de turnos) e a fatia NÃO está pronta. Não carimbe DEGRADADO — retome o MESMO agente por `SendMessage` (cole no recado `tree.dirty` e `tree.commits` desta saída e o que falta) ou re-despache só o que falta, a partir do último commit `wip`.',
+  'accept-degraded': 'o TRABALHO entrou — não re-despache. Grave você mesmo o relatório da fatia a partir da mensagem de retorno, carimbado como DEGRADADO, com a falha de protocolo registrada nele.',
+  redispatch: 're-despache a fatia UMA vez com o mesmo prompt. Segunda ausência sem trabalho entregue = falha real: escale ao humano.',
 };
 
 function snapshotPath(cwd, feature) {
   return join(cwd, '.morph', 'features', feature, '4-review', 'tree-before-eval.json');
 }
 
-/**
- * The tree block, compared with the snapshot taken before the evaluator was
- * dispatched when there is one. `beforeEval` takes a new snapshot after the
- * comparison, so the output still shows what changed since the previous one.
- */
-function treeFor(cwd, feature, beforeEval, tasks = []) {
+// `beforeEval` snapshots after comparing, so the output still shows what changed since the last one.
+function treeFor(cwd, feature, beforeEval, slices = []) {
   const path = snapshotPath(cwd, feature);
   let snapshot = null;
   try { if (existsSync(path)) snapshot = JSON.parse(readFileSync(path, 'utf8')); } catch { snapshot = null; }
   const tree = treeState(cwd, { snapshot });
   if (!beforeEval) return { tree };
-  const evaluatorModel = evaluatorDispatch(cwd, tasks);
+  const reviewModels = reviewDispatch(cwd, feature, slices);
   const next = snapshotTree(cwd);
-  if (!next) return { tree, beforeEval: null, evaluatorModel };
+  if (!next) return { tree, beforeEval: null, reviewModels };
   atomicWriteJson(path, next);
-  return { tree, beforeEval: { at: next.at, files: Object.keys(next.files).length }, evaluatorModel };
+  return { tree, beforeEval: { at: next.at, files: Object.keys(next.files).length }, reviewModels };
 }
 
-/**
- * @param {string} feature
- * @param {string|string[]|undefined} taskId - several ids audit a parallel
- *   batch whose tasks are not `done` yet, which the whole-feature mode skips
- * @param {{ json?: boolean, cwd?: string }} [options]
- */
-export function reportCheckCommand(feature, taskId, options = {}) {
+export function reportCheckCommand(feature, sliceIds, options = {}) {
   const cwd = options.cwd || process.cwd();
   const emit = (obj, code) => {
     if (options.json) console.log(JSON.stringify(obj, null, 2));
@@ -363,39 +181,24 @@ export function reportCheckCommand(feature, taskId, options = {}) {
     process.exit(code);
   };
 
-  const tasksPath = join(cwd, '.morph', 'features', feature, '2-plan', 'tasks.json');
-  if (!existsSync(tasksPath)) {
-    emit({ error: `feature "${feature}" não tem 2-plan/tasks.json — nada a auditar`, feature }, 1);
-  }
-
-  let tasks = [];
-  try {
-    const parsed = JSON.parse(readFileSync(tasksPath, 'utf8'));
-    tasks = Array.isArray(parsed.tasks) ? parsed.tasks : [];
-  } catch {
-    emit({ error: `2-plan/tasks.json de "${feature}" está corrompido`, feature }, 1);
+  const { status, checks } = readPlanChecks(cwd, feature);
+  if (!checks) {
+    emit({ error: `feature "${feature}" sem 2-plan/checks.json legível (${status}) — rode morph-spec plan-check ${feature}`, feature }, 1);
   }
-
-  if (Array.isArray(taskId)) {
-    const unknown = taskId.filter((id) => !tasks.some((t) => t.id === id));
-    if (unknown.length) emit({ error: `task(s) ${unknown.join(', ')} não existe(m) em tasks.json`, feature }, 1);
-    const results = taskId.map((id) => checkTask(cwd, feature, tasks.find((t) => t.id === id)));
-    const clean = results.every((r) => r.verdict === 'ok');
-    emit({ feature, results, clean, ...treeFor(cwd, feature, options.beforeEval, tasks) }, clean ? 0 : 1);
-  }
-
-  if (taskId) {
-    const task = tasks.find((t) => t.id === taskId);
-    if (!task) emit({ error: `task "${taskId}" não existe em tasks.json`, feature }, 1);
-    const result = checkTask(cwd, feature, task);
-    emit({ feature, ...result, hint: ACTION_HINT[result.action], ...treeFor(cwd, feature, options.beforeEval, tasks) }, result.verdict === 'ok' ? 0 : 1);
-  }
-
-  // Whole-feature audit: every DONE task owes a report; a pending one does not.
-  const results = tasks.filter((t) => t.status === 'done').map((t) => checkTask(cwd, feature, t));
-  const evaluator = inspectEvaluatorReport(evaluatorPath(cwd, feature));
+  const slices = checks.slices;
+  const ids = Array.isArray(sliceIds) ? sliceIds : sliceIds ? [sliceIds] : [];
+  const unknown = ids.filter((id) => !slices.some((s) => s.id === id));
+  if (unknown.length) emit({ error: `fatia(s) ${unknown.join(', ')} não existe(m) no plano de ${feature}`, feature }, 1);
+
+  const telemetry = loadWrites(cwd);
+  const chosen = ids.length ? ids.map((id) => slices.find((s) => s.id === id)) : slices;
+  const results = chosen.map((s) => {
+    const r = checkSlice(cwd, feature, s, telemetry);
+    return { ...r, hint: ACTION_HINT[r.action] };
+  });
   const clean = results.every((r) => r.verdict === 'ok');
-  emit({ feature, results, evaluator, clean, ...treeFor(cwd, feature, options.beforeEval, tasks) }, clean ? 0 : 1);
+  const reviews = ids.length ? undefined : inspectReviewReports(cwd, feature);
+  emit({ feature, results, ...(reviews ? { reviews } : {}), clean, ...treeFor(cwd, feature, options.beforeEval, slices) }, clean ? 0 : 1);
 }
 
 function printHuman(obj) {
@@ -403,37 +206,30 @@ function printHuman(obj) {
     console.error(chalk.red(`\n❌ ${obj.error}\n`));
     return;
   }
-  const line = (r) => {
+  console.log(chalk.bold(`\n📄 report-check ${obj.feature}`));
+  if (!obj.results.length) console.log(chalk.gray('  nenhuma fatia no plano — nada a auditar'));
+  for (const r of obj.results) {
     const icon = r.verdict === 'ok' ? chalk.green('✓') : chalk.yellow('⚠');
-    const ev = r.evidence.outputsExpected
-      ? `outputs ${r.evidence.outputsPresent}/${r.evidence.outputsExpected}`
-      : 'outputs não declarados';
-    console.log(`  ${icon} ${String(r.task).padEnd(6)} ${r.verdict.padEnd(32)} ${ev}`);
+    const who = r.observed.agentId ? `agente ${String(r.observed.agentId).slice(0, 8)}` : (r.observed.available ? 'sem dispatch' : 'sem telemetria');
+    console.log(`  ${icon} ${String(r.slice).padEnd(5)} ${r.verdict.padEnd(32)} ${who}`);
     if (r.verdict !== 'ok') {
       if (r.report.exists && r.report.missing.length) {
         console.log(chalk.gray(`      faltando no relatório: ${r.report.missing.join(', ')}`));
       }
-      console.log(chalk.gray(`      → ${ACTION_HINT[r.action]}`));
+      console.log(chalk.gray(`      → ${r.hint}`));
     }
-  };
-
-  if (obj.task) {
-    console.log(chalk.bold(`\n📄 report-check ${obj.feature} ${obj.task}`));
-    line(obj);
-    printTree(obj.tree);
-    console.log('');
-    return;
   }
-
-  console.log(chalk.bold(`\n📄 report-check ${obj.feature}`));
-  if (!obj.results.length) console.log(chalk.gray('  nenhuma task done — nada a auditar'));
-  for (const r of obj.results) line(r);
-  if (obj.evaluator) {
+  for (const [role, r] of Object.entries(obj.reviews ?? {})) {
+    if (!r.exists && role === 'security') continue;
     console.log(
-      `  ${obj.evaluator.exists ? chalk.green('✓') : chalk.yellow('⚠')} ${'Gate 3'.padEnd(6)} `
-      + `evaluator-report.md ${obj.evaluator.exists ? (obj.evaluator.complete ? 'íntegro' : obj.evaluator.partial ? 'PARCIAL' : 'incompleto') : 'ausente'}`,
+      `  ${r.complete ? chalk.green('✓') : chalk.yellow('⚠')} ${'Gate 3'.padEnd(6)} `
+      + `${reviewFileName(role)} ${r.exists ? (r.complete ? `íntegro (${r.verdict})` : r.partial ? 'PARCIAL' : 'incompleto') : 'ausente'}`,
     );
   }
+  if (obj.reviewModels) {
+    const m = obj.reviewModels;
+    console.log(chalk.gray(`  dispatch: verifier ${m.verifier.model}, reviewer ${m.reviewer.model}${m.security.required ? `, security ${m.security.model}` : ''}`));
+  }
   printTree(obj.tree);
   console.log('');
 }