@polymorphism-tech/morph-spec 9.7.0 → 10.0.0

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';
@@ -15,9 +10,10 @@ 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 { readPlanChecks } from '../../lib/plan/checks.js';
-import { featureGeneratesMedia, collectReviewRequirement } from './gate-check.js';
-
-export { inspectReport, REPORT_MARKERS };
+import { isTestPath } from '../../lib/graph/sanitize.js';
+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) {
@@ -30,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;
@@ -43,139 +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 });
-    }
+const isTestRef = (p) => isTestPath(p) || /\.(test|spec)\.[a-z]+$|Tests?\.cs$/i.test(p);
+
+/** 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 });
   }
-  return { available: trees.some((t) => t.events.length > 0), writes: dedupeEvents(events) };
+  return spread;
 }
 
-// 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' };
-}
-
-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 { 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: 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));
@@ -187,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) {
@@ -209,17 +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}`));
-    }
+  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;
@@ -245,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) {

package/src/commands/validation/verify.js

@@ -14,6 +14,7 @@ import { afterHeavyRun } from '../../lib/heavy/cleanup.js';
 import { memoryBusyHint } from '../../lib/heavy/live-stacks.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
 import { runCiVerify, CiUsageError, reusableLocalStamp } from '../../lib/ci/ci-verify.js';
+import { syncStackRules } from '../../lib/installers/stack-sync.js';
 
 function statusIcon(status) {
   if (status === 'pass') return chalk.green('✓');
@@ -57,12 +58,6 @@ function formatVerifyResult(result) {
     for (const line of result.feedback) lines.push(`  ${line}`);
   }
 
-  if (result.traceability?.warnings?.length > 0) {
-    lines.push('');
-    lines.push(chalk.yellow('Traceability warnings (advisory — never fails verify):'));
-    for (const w of result.traceability.warnings) lines.push(`  ⚠ ${w}`);
-  }
-
   lines.push('');
   return lines.join('\n');
 }
@@ -180,6 +175,8 @@ export async function verifyCommand(featureName, options = {}) {
     process.exit(2);
   }
 
+  syncStackRules(process.cwd(), { persistTags: false, log: (line) => console.error(chalk.gray(line)) });
+
   if (options.ci) {
     const conflict = CI_EXCLUSIVE_FLAGS.find(([flag]) => options[flag])?.[1];
     if (conflict) {
@@ -309,6 +306,9 @@ export async function verifyCommand(featureName, options = {}) {
       for (const u of result.baseline.updates) {
         console.log(chalk.green(`  baseline ${u.id}: ${u.from ?? '—'} → ${u.to}`));
       }
+      for (const id of result.baseline.removed ?? []) {
+        console.log(chalk.gray(`  baseline ${id}: removida (runner sem baseline, só o piso zero)`));
+      }
       console.log(chalk.gray(`Gravada em ${result.baseline.path}
 `));
     }

package/src/core/paths/output-schema.js

@@ -3,12 +3,12 @@ import { join } from 'path';
 export const OUTPUT_SCHEMA = {
   plan:           { filename: 'plan.md',               phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
   checks:         { filename: 'checks.json',           phaseDir: '2-plan',      phase: 'plan',      protected: true,  approvalGate: 'plan' },
+  planCritique:   { filename: 'critica.md',            phaseDir: '2-plan',      phase: 'plan',      protected: false },
+  planView:       { filename: 'plan.html',             phaseDir: '2-plan',      phase: 'plan',      protected: false },
 
-  uiDesignSystem: { filename: 'design-system.md',      phaseDir: '1-design',    phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
   uiMockups:      { filename: 'mockups.md',            phaseDir: '1-design',    phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
-  uiComponents:   { filename: 'components.md',         phaseDir: '1-design',    phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
-  uiFlows:        { filename: 'flows.md',              phaseDir: '1-design',    phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
 
+  implementReport: { filename: 'report.md',           phaseDir: '3-implement', phase: 'implement', protected: false },
   evidencias:     { dirname: 'evidencias', filenamePattern: '^C\\d+\\.md$', displayFilename: '{Cn}.md',
                     phaseDir: '3-implement', phase: 'implement', protected: false, multi: true },
 

package/src/core/state/state-manager.js

@@ -450,10 +450,8 @@ export async function markOutput(featureName, outputType) {
     if (suggestion) {
       errorMsg += `\n\nDid you mean '${suggestion}'?`;
       const kebabAlternative = {
-        'uiDesignSystem': 'ui-design-system',
         'uiMockups': 'ui-mockups',
-        'uiComponents': 'ui-components',
-        'uiFlows': 'ui-flows'
+        'implementReport': 'implement-report'
       }[suggestion];
       if (kebabAlternative) {
         errorMsg += ` (also accepts '${kebabAlternative}')`;
@@ -462,7 +460,7 @@ export async function markOutput(featureName, outputType) {
 
     errorMsg += `\n\nValid types:\n`;
     errorMsg += `  ${validCamelCaseTypes.join(', ')}\n`;
-    errorMsg += `\nNote: kebab-case is also accepted (e.g., 'ui-design-system', 'stack-scan')`;
+    errorMsg += `\nNote: kebab-case is also accepted (e.g., 'ui-mockups', 'implement-report')`;
 
     throw new Error(errorMsg);
   }

package/src/dashboard/app/components/CommandPalette.jsx

@@ -8,7 +8,7 @@ import { useMorphQuery } from '../hooks/useMorphQuery.js';
 import { apiBase, projectHref, featureHref } from '../lib/project.js';
 
 const KIND_LABEL = {
-  page: 'Página', project: 'Projeto', feature: 'Feature', slice: 'Fatia', skill: 'Skill', persona: 'Persona',
+  page: 'Página', project: 'Projeto', feature: 'Feature', skill: 'Skill', persona: 'Persona',
   standard: 'Standard', rule: 'Rule', hook: 'Hook', guide: 'Guia',
 };
 
@@ -46,9 +46,6 @@ function featureIndex(project, features, projectName = null) {
   const where = (text) => (projectName ? (text ? `${projectName}: ${text}` : projectName) : text);
   for (const f of features || []) {
     out.push({ kind: 'feature', title: f.name, hint: where(f.description), to: featureHref(project, f.name), hay: `${f.name} ${f.description || ''} ${projectName || ''}` });
-    for (const sl of f.sliceIndex || []) {
-      out.push({ kind: 'slice', title: `${sl.id} ${sl.title}`, hint: where(f.name), to: featureHref(project, f.name, '?tab=slices'), hay: `${sl.id} ${sl.title} ${f.name} ${projectName || ''}` });
-    }
   }
   return out;
 }
@@ -112,7 +109,7 @@ export default function CommandPalette({ open, onClose, portfolio, project }) {
               value={query}
               onChange={(e) => setQuery(e.target.value)}
               onKeyDown={onKey}
-              placeholder="Buscar features, fatias, skills, personas, standards, seções do guia…"
+              placeholder="Buscar features, skills, personas, standards, seções do guia…"
               className="w-full bg-transparent text-base text-[var(--color-fg)] outline-none focus-visible:outline-none placeholder:text-[var(--color-faint)]"
               aria-controls="palette-results"
               aria-activedescendant={results[active] ? `palette-${active}` : undefined}