@polymorphism-tech/morph-spec 9.8.0 → 10.1.1

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

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { getFeature } from '../../core/state/state-manager.js';
-import { shouldPauseGate, getRiskSignals, classifyE2eSkip, planChecksPause, securityReviewFor } from '../../lib/risk-detector.js';
+import { shouldPauseGate, getRiskSignals, classifyE2eSkip, planChecksPause, securityReviewFor, pausingRungs, migrationsTouched, contractsTouched, humanApprover, rungPause, planCritiquePause } from '../../lib/risk-detector.js';
+import { readPlanCritique } from '../../lib/plan/critique.js';
 import { reviewReports, reviewSignal, requiredReviewRoles, verifierMediaSection } from '../../lib/review-reports.js';
 import { collectScreenChecklist } from '../../lib/specs/screen-checklist.js';
 import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-decision.js';
@@ -9,33 +10,22 @@ import { detectDefaultBranch, getHeadSha, getDiffStat, changedPathsAgainst } fro
 import { treeMovedSince } from '../../lib/git/evidence-staleness.js';
 import { readMorphConfig } from '../../lib/tasks/test-runner.js';
 import { readPlanChecks } from '../../lib/plan/checks.js';
+import { featureGeneratesMedia } from '../../lib/plan/media.js';
+import { readFileSync, existsSync } from 'fs';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 
+export { featureGeneratesMedia, MEDIA_STANDARD_IDS, standardIdOf } from '../../lib/plan/media.js';
+
 // Only signals NOT derivable from disk may be overridden: overriding a disk fact (e.g. `workType`
 // away from hotfix) would silently defeat the policy this command makes deterministic.
 const OVERRIDABLE_SIGNAL_KEYS = ['standardsViolations', 'designSystemDivergence'];
 
-export const MEDIA_STANDARD_IDS = [
-  'ai-agents-modalities-image-gen',
-  'ai-agents-media-video',
-  'ai-agents-media-pipeline',
-];
-
-// O plano escreve o standard pelo id ou pelo caminho (com ou sem `framework/`/`standards/`).
-export function standardIdOf(value) {
-  return String(value ?? '').trim().replace(/\\/g, '/')
-    .replace(/^(\.morph\/)?(framework\/)?(standards\/)?/, '')
-    .replace(/\.md$/, '')
-    .replace(/\//g, '-');
+function readPlanText(cwd, featureName) {
+  const path = getAbsoluteOutputPath(cwd, featureName, 'plan');
+  try { return existsSync(path) ? readFileSync(path, 'utf8') : ''; } catch { return ''; }
 }
 
-// Decide se um guardrail arma: um predicado que sempre devolve `false` desarma em silêncio a
-// pausa de mídia da review e a rota opus.
-export function featureGeneratesMedia(slices) {
-  if (!Array.isArray(slices)) return false;
-  return slices.some((s) => Array.isArray(s?.standards)
-    && s.standards.some((id) => MEDIA_STANDARD_IDS.includes(standardIdOf(id))));
-}
 
 // `declared: false` (nenhum caminho declarado: regra inerte) e `touched: []` (declarou, nada
 // tocado) não podem colapsar num array vazio. COLETA, NUNCA DECIDE: política no coletor cria
@@ -69,8 +59,12 @@ export function collectReviewSignal(cwd, featureName, feature, planChecks = read
 }
 
 /** Why an automatic signature may not close the plan gate: the rule that makes gate-check pause it. */
-export function planAutoApprovalBlock(cwd, featureName) {
-  const reason = planChecksPause(readPlanChecks(cwd, featureName).status);
+export function planAutoApprovalBlock(cwd, featureName, feature) {
+  const planChecks = readPlanChecks(cwd, featureName);
+  const workType = feature?.workType || 'feature';
+  const reason = planChecksPause(planChecks.status)
+    ?? planCritiquePause(readPlanCritique(cwd, featureName, { workType, planChecks }))
+    ?? rungPause({ gate: 'plan', rungs: pausingRungs(planChecks.checks) })?.reason;
   return reason ? reason.replace('{feature}', featureName) : null;
 }
 
@@ -79,7 +73,6 @@ export function planAutoApprovalBlock(cwd, featureName) {
 // waiver from missing proof.
 export function collectSignals(featureName, feature, cwd, gateName) {
   const planChecks = readPlanChecks(cwd, featureName);
-  const slices = planChecks.checks?.slices ?? null;
   const defaultBranch = detectDefaultBranch(cwd);
   const sha = getHeadSha(cwd);
   const verification = feature.verification || null;
@@ -88,12 +81,15 @@ export function collectSignals(featureName, feature, cwd, gateName) {
     // Disk-derived, never overridable: a caller cannot spoof which gate is being decided.
     gate: gateName,
     workType: feature.workType || 'feature',
-    sliceCount: slices ? slices.length : null,
     standardsViolations: [],
     designSystemDivergence: false,
   };
 
-  if (gateName === 'plan') signals.planChecks = planChecks.status;
+  if (gateName === 'plan') {
+    signals.planChecks = planChecks.status;
+    signals.planCritique = readPlanCritique(cwd, featureName, { workType: signals.workType, planChecks });
+  }
+  if (gateName === 'plan' || gateName === 'review') signals.rungs = pausingRungs(planChecks.checks);
 
   // Só onde o checklist decide algo: no fecho do design e no ship.
   if (gateName === 'uiux' || gateName === 'review') {
@@ -104,13 +100,20 @@ export function collectSignals(featureName, feature, cwd, gateName) {
     signals.reviewReports = collectReviewSignal(cwd, featureName, feature, planChecks);
     signals.mediaClaims = {
       section: verifierMediaSection(cwd, featureName),
-      featureGeneratesMedia: featureGeneratesMedia(slices),
+      featureGeneratesMedia: featureGeneratesMedia(readPlanText(cwd, featureName)),
     };
+    let changed = [];
+    try { changed = changedPathsAgainst(defaultBranch, cwd); } catch { changed = []; }
+    signals.migrationsTouched = migrationsTouched(changed);
+    signals.contractsTouched = contractsTouched(changed);
+    signals.planApprovedByHuman = feature.approvalGates?.plan?.approved === true
+      && humanApprover(feature.approvalGates.plan.approvedBy);
   }
 
   // verificationStale é fail-open: stamp sem sha (checkout sem git) ou ausente lê como NOT stale.
   signals.verification = verification;
   if (verification?.status) signals.verificationStatus = verification.status;
+  signals.failStreak = feature.verifications?.feature?.failStreak ?? 0;
   signals.verificationStale = treeMovedSince(cwd, verification?.sha, sha);
 
   // Separado do rollup: um `skip` NÃO reprova `verification.status`. `null` é DESCONHECIDO, nunca
@@ -189,10 +192,12 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
     const computed = shouldPauseGate({ trust }, signals);
     const manual = feature.gateDecisions?.[gateName];
     const manualPause = manual?.source === 'manual' && manual.pause === true;
-    const { pause, reason, signal } = manualPause ? { pause: true, reason: manual.reason, signal: 'manual' } : computed;
+    const { pause, reason, signal, resolver } = manualPause
+      ? { pause: true, reason: manual.reason, signal: 'manual', resolver: 'human' }
+      : computed;
 
     const entry = await persistGateDecision(featureName, gateName, {
-      pause, reason, signal, signals, trust, cwd, source: manualPause ? 'manual' : 'gate-check',
+      pause, reason, signal, resolver, signals, trust, cwd, source: manualPause ? 'manual' : 'gate-check',
     });
 
     if (options.json) {
@@ -201,9 +206,11 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
     }
 
     const allSignals = getRiskSignals(signals);
-    console.log(entry.pause
-      ? chalk.yellow(`\n⏸️  Gate "${gateName}" — PAUSE (${featureName})`)
-      : chalk.green(`\n▶️  Gate "${gateName}" — auto-pass (${featureName})`));
+    console.log(!entry.pause
+      ? chalk.green(`\n▶️  Gate "${gateName}" — auto-pass (${featureName})`)
+      : entry.resolver === 'session'
+        ? chalk.yellow(`\n🔧 Gate "${gateName}" — PAUSE, resolver: session (${featureName}): do what the reason says and run gate-check again`)
+        : chalk.yellow(`\n⏸️  Gate "${gateName}" — PAUSE, resolver: human (${featureName})`));
     console.log(chalk.gray(`   reason: ${entry.reason} | trust: ${entry.trust} | decidedAt: ${entry.decidedAt}`));
     if (manualPause) {
       console.log(chalk.gray(`   pausa manual mantida (sinais calculados: ${computed.reason}); só \`morph-spec gate-decision ${featureName} ${gateName} --pause false\` a libera`));

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

@@ -32,9 +32,10 @@ export function readTrustFromConfig() {
  * The ONE write path of `gateDecisions.{gate}`, shared by `gate-decision` and `gate-check`.
  * Does not validate `gateName`. A uiux decision records the `mockupsHash` it saw.
  */
-export async function persistGateDecision(featureName, gateName, { pause, reason, signal, signals = {}, trust, cwd = process.cwd(), source } = {}) {
+export async function persistGateDecision(featureName, gateName, { pause, reason, signal, resolver, signals = {}, trust, cwd = process.cwd(), source } = {}) {
   const entry = {
     pause,
+    resolver: pause ? resolver ?? 'human' : null,
     reason: reason || (pause ? 'risco detectado' : 'nenhum sinal de risco'),
     signals,
     trust: trust || readTrustFromConfig(),
@@ -44,7 +45,7 @@ export async function persistGateDecision(featureName, gateName, { pause, reason
   };
 
   await updateFeature(featureName, `gateDecisions.${gateName}`, entry);
-  recordGateEvent(cwd, { feature: featureName, gate: gateName, step: 'decision', pause, signal, source });
+  recordGateEvent(cwd, { feature: featureName, gate: gateName, step: 'decision', pause, signal, source, resolver: entry.resolver });
   return entry;
 }
 

package/src/commands/state/next.js

@@ -20,5 +20,6 @@ export function nextCommand(featureName, options = {}) {
     return;
   }
   console.log(formatNext(next));
+  for (const line of next.how ?? []) console.log(`   ${line}`);
   if (owner.tree !== process.cwd()) console.log(chalk.gray(`   árvore dona: ${owner.tree}`));
 }

package/src/commands/state/recap.js

@@ -0,0 +1,67 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { buildRecap, changeSummary, recapScenes, renderRecapHtml } from '../../lib/recap/recap.js';
+import { narrateWithPiper, resolvePiper } from '../../lib/recap/piper.js';
+
+export const RECAP_FILES = { html: 'recap.html', data: 'recap.json' };
+
+/** Writes `recap.html` + `recap.json` into `targetDir` from the live feature folder. Never throws. */
+export function writeRecap(featureDir, targetDir, feature, { cwd }) {
+  try {
+    const data = buildRecap(featureDir, feature, { changes: changeSummary(cwd) });
+    writeFileSync(join(targetDir, RECAP_FILES.data), JSON.stringify(data, null, 2));
+    writeFileSync(join(targetDir, RECAP_FILES.html), renderRecapHtml(data));
+    return { ok: true, path: join(targetDir, RECAP_FILES.html) };
+  } catch (err) {
+    return { ok: false, reason: err.message };
+  }
+}
+
+// Active feature: rebuilt from its folder and the branch diff. Archived: the data the finish froze,
+// since the archive keeps neither the reports nor the branch.
+export function recapCommand(feature, options = {}) {
+  const cwd = options.path || process.cwd();
+  const active = join(cwd, '.morph', 'features', feature);
+  const archived = join(cwd, '.morph', 'archive', feature);
+  let data;
+  let dir;
+  if (existsSync(active)) {
+    dir = active;
+    data = buildRecap(active, feature, { changes: changeSummary(cwd) });
+    writeFileSync(join(dir, RECAP_FILES.data), JSON.stringify(data, null, 2));
+  } else if (existsSync(join(archived, RECAP_FILES.data))) {
+    dir = archived;
+    data = JSON.parse(readFileSync(join(archived, RECAP_FILES.data), 'utf8'));
+  } else {
+    const payload = { ok: false, reason: existsSync(archived) ? 'archived-without-recap' : 'feature-not-found' };
+    if (options.json) console.log(JSON.stringify(payload));
+    else console.error(chalk.yellow(`\n○ ${payload.reason === 'feature-not-found' ? `Feature "${feature}" não existe.` : `"${feature}" foi arquivada antes do recap existir.`}\n`));
+    process.exit(1);
+  }
+
+  let narration = 'sistema';
+  let path = join(dir, RECAP_FILES.html);
+  let note = null;
+  if (options.piper) {
+    const piper = resolvePiper();
+    const audio = piper.ok ? narrateWithPiper(recapScenes(data), piper) : null;
+    if (audio) {
+      // Audio is megabytes: it goes to a temp file, never into the committed archive.
+      path = join(tmpdir(), `morph-recap-${feature}.html`);
+      writeFileSync(path, renderRecapHtml(data, { audio }));
+      narration = 'piper';
+    } else {
+      note = piper.ok ? 'o piper falhou numa cena — ficou a voz do sistema' : piper.reason;
+    }
+  }
+  if (narration === 'sistema') writeFileSync(path, renderRecapHtml(data));
+
+  if (options.json) {
+    console.log(JSON.stringify({ ok: true, path, narration, note }));
+    return;
+  }
+  console.log(chalk.green(`\n✅ Recap de ${feature}: ${path}`));
+  console.log(chalk.gray(`   narração: ${narration === 'piper' ? 'Piper (áudio embutido)' : 'voz do sistema, pelo navegador'}${note ? ` — ${note}` : ''}\n`));
+}

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

@@ -1,12 +1,7 @@
-// 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 { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-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 { implementProgress, parseReport, reportPath } from '../../../framework/hooks/shared/report-progress.js';
 import { treeState, snapshotTree } from '../../lib/git/tree-state.js';
 import { atomicWriteJson } from '../../core/state/state-manager.js';
 import { minimatch } from 'minimatch';
@@ -16,9 +11,9 @@ import { changedPathsAgainst, detectDefaultBranch } from '../../lib/git/default-
 import { readMorphConfig } from '../../lib/tasks/test-runner.js';
 import { readPlanChecks } from '../../lib/plan/checks.js';
 import { isTestPath } from '../../lib/graph/sanitize.js';
-import { featureGeneratesMedia, collectReviewRequirement } from './gate-check.js';
-
-export { inspectReport, REPORT_MARKERS };
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+import { collectReviewRequirement } from './gate-check.js';
+import { featureGeneratesMedia } from '../../lib/plan/media.js';
 
 /** Each review report: complete when it carries a readable verdict and is not partial. */
 export function inspectReviewReports(cwd, feature) {
@@ -31,8 +26,12 @@ export function inspectReviewReports(cwd, feature) {
   return out;
 }
 
+function readOrEmpty(path) {
+  try { return existsSync(path) ? readFileSync(path, 'utf8') : ''; } catch { return ''; }
+}
+
 // The verifier routes to opus on prompt/model or media; security is dispatched only when required.
-function reviewDispatch(cwd, feature, slices) {
+function reviewDispatch(cwd, feature) {
   let changedFiles = [];
   try { changedFiles = changedPathsAgainst(detectDefaultBranch(cwd), cwd); } catch { changedFiles = []; }
   const watch = readMorphConfig(cwd)?.project?.evals?.watch;
@@ -44,172 +43,45 @@ function reviewDispatch(cwd, feature, slices) {
     required,
     verifier: verifierModelFor({
       promptModelTouched: changedFiles.some((f) => globs.some((g) => minimatch(f, g))),
-      generatesMedia: featureGeneratesMedia(slices),
+      generatesMedia: featureGeneratesMedia(readOrEmpty(getAbsoluteOutputPath(cwd, feature, 'plan'))),
     }),
     reviewer: { model: 'sonnet', reasons: [] },
     security: { required: security.required, model: 'opus', reasons: security.reasons },
   };
 }
 
-// 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;
-
 const slash = (p) => String(p || '').replace(/\\/g, '/');
-
-function toTreeRelative(target, treePath) {
-  const norm = slash(target);
-  const root = slash(treePath).replace(/\/+$/, '');
-  if (!root) return norm;
-  // 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;
-}
-
-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) };
-}
-
-// 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 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: 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,
-  };
-}
-
-function isReportStale(reportFsPath, observed) {
-  if (!observed?.agentId || !observed.lastWriteAt) return false;
-  try {
-    return statSync(reportFsPath).mtimeMs + STALE_TOLERANCE_MS < Date.parse(observed.lastWriteAt);
-  } catch {
-    return false;
-  }
-}
-
-function decide(report, observed, stale) {
-  if (report.exists && report.complete) {
-    // 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' };
-  }
-  // 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.blocked) return { verdict: 'report-blocked', action: 'ask-human' };
-  if (report.exists && report.partial) return { verdict: 'report-incomplete', action: 'resume' };
-  if (report.exists) return { verdict: 'report-incomplete', action: 'complete-degraded' };
-  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' };
-}
-
 const isTestRef = (p) => isTestPath(p) || /\.(test|spec)\.[a-z]+$|Tests?\.cs$/i.test(p);
 
-/** Cn whose `**Checks:**` entry cites tests in more than one file, as `{ id, files }`. */
-export function checksSpread(body) {
-  const lines = String(body ?? '').split(/\r?\n/);
-  const start = lines.findIndex((l) => /^\s*(?:[-*]\s*)?\*\*checks\s*:?\*\*/i.test(l));
-  if (start < 0) return [];
-  const block = [lines[start].replace(/^.*?\*\*checks\s*:?\*\*\s*:?/i, '')];
-  for (const l of lines.slice(start + 1)) {
-    if (/^\s*(\*\*|#)/.test(l)) break;
-    block.push(l);
+/** Cn whose evidence in the report cites tests in more than one file, as `{ id, files }`. */
+export function checksSpread(reportText) {
+  const spread = [];
+  for (const [id, { evidence }] of parseReport(reportText)) {
+    const files = [...new Set((evidence.match(/[\w@./\\-]+\.[A-Za-z]+/g) ?? []).map(slash).filter(isTestRef))];
+    if (files.length > 1) spread.push({ id, files });
   }
-  const filesByCn = new Map();
-  let current = null;
-  for (const piece of block.join('\n').split(/[;\n]/)) {
-    const lead = /^\s*(?:[-*]\s*)?\(?(C\d+)\b/.exec(piece);
-    if (lead) current = lead[1];
-    if (!current) continue;
-    const refs = (piece.match(/[\w@.\/\\-]+\.[A-Za-z]+/g) ?? []).map(slash).filter(isTestRef);
-    if (!filesByCn.has(current)) filesByCn.set(current, new Set());
-    for (const f of refs) filesByCn.get(current).add(f);
-  }
-  return [...filesByCn].filter(([, files]) => files.size > 1).map(([id, files]) => ({ id, files: [...files] }));
+  return spread;
 }
 
-function spreadWarnings(fsPath) {
-  let body = '';
-  try { body = readFileSync(fsPath, 'utf8'); } catch { return []; }
-  return checksSpread(body).map(({ id, files }) =>
-    `${id} cita testes em ${files.length} arquivos (${files.join(', ')}): um teste por Cn, na camada mais baixa que o prova`);
-}
-
-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);
-  const warnings = report.exists ? spreadWarnings(fsPath) : [];
-  return { slice: slice.id, report, observed, warnings, ...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: 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`.',
-  'ask-human': 'relatório BLOQUEADO: o sub-agent parou numa decisão que não é dele (requisito que contradiz o plano ou um ADR, escolha do humano) e o relatório traz a pergunta e as opções. NÃO re-despache — a mesma pergunta volta. Se o plano ou um ADR já decide, decida você e registre no relatório; senão, faça a pergunta por `AskUserQuestion`. Depois retome o MESMO agente por `SendMessage` com a resposta.',
-  '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');
 }
 
 // `beforeEval` snapshots after comparing, so the output still shows what changed since the last one.
-function treeFor(cwd, feature, beforeEval, slices = []) {
+function treeFor(cwd, feature, beforeEval) {
   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 reviewModels = reviewDispatch(cwd, feature, slices);
+  const reviewModels = reviewDispatch(cwd, feature);
   const next = snapshotTree(cwd);
   if (!next) return { tree, beforeEval: null, reviewModels };
   atomicWriteJson(path, next);
   return { tree, beforeEval: { at: next.at, files: Object.keys(next.files).length }, reviewModels };
 }
 
-export function reportCheckCommand(feature, sliceIds, options = {}) {
+export function reportCheckCommand(feature, options = {}) {
   const cwd = options.cwd || process.cwd();
   const emit = (obj, code) => {
     if (options.json) console.log(JSON.stringify(obj, null, 2));
@@ -221,20 +93,15 @@ export function reportCheckCommand(feature, sliceIds, options = {}) {
   if (!checks) {
     emit({ error: `feature "${feature}" sem 2-plan/checks.json legível (${status}) — rode morph-spec plan-check ${feature}`, feature }, 1);
   }
-  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');
-  const reviews = ids.length ? undefined : inspectReviewReports(cwd, feature);
-  emit({ feature, results, ...(reviews ? { reviews } : {}), clean, ...treeFor(cwd, feature, options.beforeEval, slices) }, clean ? 0 : 1);
+  const featureDir = join(cwd, '.morph', 'features', feature);
+  const progress = implementProgress(featureDir);
+  const warnings = checksSpread(readOrEmpty(reportPath(featureDir))).map(({ id, files }) =>
+    `${id} cita testes em ${files.length} arquivos (${files.join(', ')}): um teste por Cn, na camada mais baixa que o prova`);
+  const implement = progress
+    ? { total: progress.total, done: progress.done, pending: progress.checks.filter((c) => c.status === 'pendente').map((c) => c.id),
+      blocked: progress.checks.filter((c) => c.status === 'bloqueado').map((c) => c.id), legacy: progress.legacy, warnings }
+    : null;
+  emit({ feature, implement, reviews: inspectReviewReports(cwd, feature), ...treeFor(cwd, feature, options.beforeEval) }, 0);
 }
 
 function printHuman(obj) {
@@ -243,18 +110,12 @@ function printHuman(obj) {
     return;
   }
   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 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(`      → ${r.hint}`));
-    }
-    for (const w of r.warnings ?? []) console.log(chalk.yellow(`      ⚠ ${w}`));
+  const impl = obj.implement;
+  if (impl) {
+    const open = [...impl.pending, ...impl.blocked];
+    console.log(`  ${open.length ? chalk.yellow('⚠') : chalk.green('✓')} report.md ${impl.done}/${impl.total} cenários feitos`
+      + `${impl.pending.length ? ` · pendentes: ${impl.pending.join(', ')}` : ''}${impl.blocked.length ? ` · bloqueados: ${impl.blocked.join(', ')}` : ''}`);
+    for (const w of impl.warnings) console.log(chalk.yellow(`      ⚠ ${w}`));
   }
   for (const [role, r] of Object.entries(obj.reviews ?? {})) {
     if (!r.exists && role === 'security') continue;
@@ -280,9 +141,6 @@ function printTree(tree) {
   console.log(`  árvore ${tree.branch ?? '-'}@${tree.head ?? '-'}: ${tree.dirtyCount} arquivo(s) não commitado(s) fora de .morph/${stat}`);
   for (const d of tree.dirty.slice(0, 10)) console.log(chalk.gray(`      ${d.status.padEnd(2)} ${d.path}`));
   if (tree.dirtyCount > 10) console.log(chalk.gray(`      … e mais ${tree.dirtyCount - 10}`));
-  if (tree.markers.length) {
-    console.log(chalk.yellow(`  ⚠ marcador de mutação esquecido: ${tree.markers.map((m) => `${m.file}:${m.line}`).join(', ')}`));
-  }
   if (tree.commits?.length) console.log(chalk.gray(`  commits sobre a default: ${tree.commits.join(' · ')}`));
   const since = tree.sinceBeforeEval;
   if (since) {

package/src/commands/validation/plan-check.js

@@ -1,16 +1,17 @@
 import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { atomicWriteJson } from '../../core/state/state-manager.js';
 import { isGateApproved } from '../../../framework/hooks/shared/state-reader.js';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { parsePlan } from '../../lib/plan/plan-parser.js';
-import { buildChecks, knownPersonas, parallelGroups, planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
-import { knownSurfaces } from '../../lib/specs/screen-checklist.js';
+import { renderPlanHtml } from '../../lib/plan/plan-html.js';
+import { buildChecks, planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
 import { revocationWarnings } from '../../lib/specs/adr-index.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 import { seedDotnetBuildIgnores } from '../../lib/stack/dotnet-build-ignores.js';
 import { reportDotnetIgnores } from '../state/advance.js';
+import { syncStackRules } from '../../lib/installers/stack-sync.js';
 
 function readJson(path) {
   try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
@@ -21,17 +22,14 @@ export function runPlanCheck(featureName, cwd = process.cwd()) {
   const planPath = getAbsoluteOutputPath(cwd, featureName, 'plan');
   const checksPath = getAbsoluteOutputPath(cwd, featureName, 'checks');
   const base = { feature: featureName, plan: planPath, checksPath };
-  if (!existsSync(planPath)) return { ...base, ok: false, exit: 2, error: 'plan-not-found', errors: [], warnings: [], groups: [] };
+  if (!existsSync(planPath)) return { ...base, ok: false, exit: 2, error: 'plan-not-found', errors: [], warnings: [] };
 
   const text = readFileSync(planPath, 'utf8');
   const plan = parsePlan(text);
-  const { errors, warnings } = validatePlan(plan, {
-    personas: knownPersonas(cwd), surfaces: knownSurfaces(cwd), ...planRuleOptions(cwd, featureName),
-  });
+  const { errors, warnings } = validatePlan(plan, { ...planRuleOptions(cwd, featureName), text });
   warnings.push(...revocationWarnings(cwd, plan));
-  const groups = errors.length === 0 ? parallelGroups(plan.slices) : [];
   const hash = planHash(text);
-  const result = { ...base, planHash: hash, errors, warnings, groups, written: false };
+  const result = { ...base, planHash: hash, errors, warnings, written: false };
   if (errors.length > 0) return { ...result, ok: false, exit: 1 };
 
   const approved = isGateApproved(featureName, 'plan', cwd);
@@ -41,7 +39,9 @@ export function runPlanCheck(featureName, cwd = process.cwd()) {
   }
 
   atomicWriteJson(checksPath, buildChecks(featureName, text, plan));
-  return { ...result, ok: true, exit: 0, written: true };
+  const viewPath = getAbsoluteOutputPath(cwd, featureName, 'planView');
+  writeFileSync(viewPath, renderPlanHtml(featureName, plan, { planHash: hash }));
+  return { ...result, ok: true, exit: 0, written: true, viewPath };
 }
 
 export function planCheckCommand(featureName, options = {}) {
@@ -54,8 +54,13 @@ export function planCheckCommand(featureName, options = {}) {
   }
 
   const result = runPlanCheck(featureName);
+  // After the plan validates: in a greenfield project the plan is where the stack is born.
+  const stackSync = result.written
+    ? syncStackRules(process.cwd(), { log: (line) => console.error(chalk.gray(line)) })
+    : null;
   const gitignoreAdded = result.written ? seedDotnetBuildIgnores(process.cwd(), { featureName }) : [];
   if (options.json) {
+    if (stackSync?.added.length) result.rulesAdded = stackSync.added;
     if (gitignoreAdded.length) result.gitignoreAdded = gitignoreAdded;
     if (gitignoreAdded.skipped) result.gitignoreSkipped = gitignoreAdded.skipped;
     console.log(JSON.stringify(result, null, 2));
@@ -77,7 +82,7 @@ export function planCheckCommand(featureName, options = {}) {
     console.log(chalk.red(`✗ plan-check: ${result.errors.length} erro(s) em ${result.plan} — checks.json não foi gravado`));
   } else {
     console.log(chalk.green(`✓ plan-check: ${join('2-plan', 'checks.json')} gravado (${result.planHash.slice(0, 12)})`));
-    result.groups.forEach((g, i) => console.log(chalk.gray(`  onda ${i + 1}: ${g.join(', ')}${g.length > 1 ? ' (paralelo)' : ''}`)));
+    console.log(chalk.gray(`  visão do plano: ${result.viewPath}`));
     reportDotnetIgnores(gitignoreAdded);
   }
   process.exit(result.exit);

package/src/commands/validation/validate-feature.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import chalk from 'chalk';
 import { parsePlan } from '../../lib/plan/plan-parser.js';
-import { knownPersonas, planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
+import { planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
 
 // Matched against section markers (headings and line-start bold labels), never whole-file
 // substrings. required → ERROR, recommended → WARNING, optional → never penalized; an array is any-of.
@@ -117,7 +117,7 @@ function validatePlanOutput(content, planDir, result) {
   const plan = parsePlan(content);
   const root = path.resolve(planDir, '..', '..', '..', '..');
   const feature = path.basename(path.resolve(planDir, '..'));
-  const { errors, warnings } = validatePlan(plan, { personas: knownPersonas(root), ...planRuleOptions(root, feature) });
+  const { errors, warnings } = validatePlan(plan, { ...planRuleOptions(root, feature), text: content });
   result.errors.push(...errors);
   result.warnings.push(...warnings);
   result.sections.found.push(...plan.sections.filter((x) => x.key).map((x) => x.name));
@@ -137,7 +137,7 @@ function validateChecksOutput(content, planDir, result) {
     result.errors.push('checks.json is stale — plan.md changed after it was generated; run `morph-spec plan-check`');
     return;
   }
-  result.sections.found.push(`${doc.checks?.length ?? 0} check(s), ${doc.slices?.length ?? 0} slice(s)`);
+  result.sections.found.push(`${doc.checks?.length ?? 0} check(s)`);
 }
 
 function validateMarkdownSections(content, sections, result) {