@polymorphism-tech/morph-spec 9.8.0 → 10.0.0

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) {

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) {

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}

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

@@ -0,0 +1,116 @@
+import { useMorphQuery } from '../hooks/useMorphQuery.js';
+import { apiBase } from '../lib/project.js';
+
+// Validated with the dataviz palette checker against --color-core (#12151b), dark mode.
+const SESSION = '#26a69a';
+const HUMAN = '#d07f27';
+// Not a series: pauses logged before the resolver existed, so nobody knows who cleared them.
+const UNKNOWN = 'var(--color-gray-500)';
+const GATE_ORDER = ['plan', 'uiux', 'review'];
+const GATE_LABEL = { plan: 'Plano', uiux: 'Design', review: 'Gate 3' };
+
+function split(s = {}) {
+  const unknown = s.pausedUnattributed ?? 0;
+  const human = Math.max(0, (s.pausedForHuman ?? 0) - unknown);
+  return { human, unknown, session: Math.max(0, (s.paused ?? 0) - human - unknown) };
+}
+
+export function gateRows(gates = {}) {
+  const known = GATE_ORDER.filter((g) => gates[g]);
+  const extra = Object.keys(gates).filter((g) => !GATE_ORDER.includes(g)).sort();
+  return [...known, ...extra].map((g) => ({ gate: g, label: GATE_LABEL[g] ?? g, decisions: gates[g].decisions ?? 0, ...split(gates[g]) }));
+}
+
+export function humanSignals(gates = {}, top = 5) {
+  return Object.entries(gates)
+    .flatMap(([gate, slot]) => Object.entries(slot.bySignal ?? {}).map(([signal, s]) => ({ gate, signal, ...split(s) })))
+    .filter((r) => r.human > 0 || r.unknown > 0)
+    .sort((a, b) => b.human - a.human || b.unknown - a.unknown || a.signal.localeCompare(b.signal))
+    .slice(0, top);
+}
+
+function Swatch({ color, children }) {
+  return <span className="flex items-center gap-1.5"><span className="h-2.5 w-2.5 rounded-sm" style={{ background: color }} />{children}</span>;
+}
+
+function Bar({ row, max }) {
+  const parts = [
+    ['session', row.session, SESSION, 'a sessão resolveu'],
+    ['human', row.human, HUMAN, 'foi para você'],
+    ['unknown', row.unknown, UNKNOWN, 'antes do registro'],
+  ].filter(([, n]) => n > 0);
+  const total = row.session + row.human + row.unknown;
+  const describe = parts.map(([, n, , what]) => `${what} ${n}`).join(', ');
+  return (
+    <div className="grid grid-cols-[4.5rem_1fr_auto] items-center gap-3">
+      <span className="text-sm text-[var(--color-fg)]">{row.label}</span>
+      <div className="flex h-3 gap-[2px]" role="img" aria-label={`${row.label}: ${describe || 'nenhuma pausa'}`}>
+        {parts.map(([key, n, color, what], i) => (
+          <span key={key} className={`h-full ${i === 0 ? 'rounded-l-[4px]' : ''} ${i === parts.length - 1 ? 'rounded-r-[4px]' : ''}`}
+            style={{ width: `${(n / max) * 100}%`, background: color }} title={`${row.label} · ${what}: ${n}`} />
+        ))}
+      </div>
+      <span className="text-right text-xs tabular-nums text-[var(--color-dim)]">
+        {total === 0 ? `nenhuma pausa em ${row.decisions}` : `${row.human} de ${total} para você`}
+      </span>
+    </div>
+  );
+}
+
+export function GatePausesView({ gates }) {
+  const rows = gateRows(gates);
+  if (rows.length === 0) {
+    return <p className="text-sm text-[var(--color-faint)]">Nenhuma decisão de gate na telemetria ainda.</p>;
+  }
+  const max = Math.max(1, ...rows.map((r) => r.session + r.human + r.unknown));
+  const signals = humanSignals(gates);
+  const anyUnknown = rows.some((r) => r.unknown > 0);
+  return (
+    <div className="space-y-5">
+      <div className="flex flex-wrap items-baseline justify-between gap-2">
+        <h2 className="text-base font-semibold">Pausas por gate</h2>
+        <div className="flex flex-wrap gap-x-4 gap-y-1 text-xs text-[var(--color-dim)]" aria-hidden="true">
+          <Swatch color={SESSION}>a sessão resolveu</Swatch>
+          <Swatch color={HUMAN}>foi para você</Swatch>
+          {anyUnknown && <Swatch color={UNKNOWN}>antes do registro</Swatch>}
+        </div>
+      </div>
+      <div className="space-y-2.5">{rows.map((r) => <Bar key={r.gate} row={r} max={max} />)}</div>
+      {anyUnknown && (
+        <p className="text-xs text-[var(--color-faint)]">Pausas gravadas antes de o morph-spec registrar quem resolve cada uma: não entram na conta de "para você".</p>
+      )}
+      {signals.length > 0 && (
+        <table className="w-full text-sm">
+          <caption className="mb-2 text-left text-xs text-[var(--color-dim)]">O que mais te chamou</caption>
+          <thead className="text-xs text-[var(--color-faint)]">
+            <tr>
+              <th className="pb-1 text-left font-normal">sinal</th>
+              <th className="pb-1 text-left font-normal">gate</th>
+              <th className="pb-1 text-right font-normal">para você</th>
+              <th className="pb-1 text-right font-normal">sessão</th>
+              {anyUnknown && <th className="pb-1 text-right font-normal">antes</th>}
+            </tr>
+          </thead>
+          <tbody>
+            {signals.map((s) => (
+              <tr key={`${s.gate}:${s.signal}`} className="border-t border-[var(--color-hair)]">
+                <td className="py-1.5 font-mono text-xs text-[var(--color-fg)]">{s.signal}</td>
+                <td className="py-1.5 text-[var(--color-dim)]">{GATE_LABEL[s.gate] ?? s.gate}</td>
+                <td className="py-1.5 text-right tabular-nums text-[var(--color-fg)]">{s.human}</td>
+                <td className="py-1.5 text-right tabular-nums text-[var(--color-dim)]">{s.session}</td>
+                {anyUnknown && <td className="py-1.5 text-right tabular-nums text-[var(--color-faint)]">{s.unknown}</td>}
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+    </div>
+  );
+}
+
+export default function GatePauses({ project }) {
+  const { data, error } = useMorphQuery(`${apiBase(project)}/gates`, { scope: 'activity', project });
+  if (error) return <p className="text-sm text-[var(--color-bad)]">Não consegui ler os gates: {error}</p>;
+  if (!data) return <p className="text-sm text-[var(--color-faint)]">Lendo a telemetria…</p>;
+  return <GatePausesView gates={data.gates} />;
+}