@polymorphism-tech/morph-spec 8.47.0 → 9.0.0

package/src/dashboard/scanner/docs-scanner.js

@@ -1,6 +1,6 @@
 /**
  * The reading material of the framework — the charter, the runtime
- * instructions, the CLI reference and the Gate 3 evaluator checklist — for the
+ * instructions, the CLI reference and the Gate 3 review checklist — for the
  * dashboard's Guide page.
  */
 import { readFileSync } from 'fs';
@@ -27,7 +27,7 @@ const GUIDE = [
   { id: 'morph', path: 'MORPH.md', title: 'Carta do harness (MORPH.md)', summary: 'Como o Claude trabalha: papéis, fases, gates, sub-agents. É a fonte única do comportamento.' },
   { id: 'runtime', path: 'CLAUDE.md', title: 'Instruções de runtime (CLAUDE.md)', summary: 'O que é injetado no CLAUDE.md do projeto: como começar cada sessão, regras críticas, comandos.' },
   { id: 'cli', path: 'docs/CLI.md', title: 'Referência do CLI', summary: 'Todos os comandos morph-spec: gates, verify, worktrees, grafo, telemetria.' },
-  { id: 'review-checklist', path: 'evals/review-checklist.md', title: 'Checklist do avaliador (Gate 3)', summary: 'O que o avaliador independente procura antes do ship: veredito SHIP/FIX e bloqueador com evidência.' },
+  { id: 'review-checklist', path: 'evals/review-checklist.md', title: 'Checklist do Gate 3', summary: 'O que verificador, revisor e segurança procuram antes do ship: veredito SHIP/FIX e bloqueador com evidência.' },
 ];
 
 export function scanDocs(frameworkDir) {

package/src/dashboard/scanner/features-scanner.js

@@ -6,9 +6,9 @@
  *   - which tree owns a feature  → `resolveFeatureTree` (feature-truth.js)
  *   - the current phase          → `derivePhaseFrom` (state-reader.js)
  *   - gate order                 → `GATE_PREREQ` (gate-order.js)
- *   - the evaluator's verdict    → `evaluatorVerdictFromText` (evaluator-report.js)
+ *   - the review verdict         → `reviewReportsFromDir` (review-reports.js)
  *   - path confinement           → `canonicalPath`/`isInside` (test-runner.js)
- *   - tasks.json validity        → `validateTasksJson` (tasks-json-parser.js)
+ *   - slice progress             → `sliceProgress` (slice-progress.js)
  *
  * Three places a feature can live: the root `.morph/features/{f}`, a worktree
  * `{worktrees}/{wt}/.morph/features/{f}`, and `.morph/archive/{f}` once
@@ -21,10 +21,12 @@
 
 import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { join, basename, isAbsolute } from 'path';
-import { derivePhaseFrom, PHASE_ARTIFACTS } from '../../../framework/hooks/shared/state-reader.js';
+import { derivePhaseFrom, diskArtifactProbe, PHASE_ARTIFACTS } from '../../../framework/hooks/shared/state-reader.js';
 import { GATE_PREREQ } from '../../core/state/gate-order.js';
-import { validateTasksJson } from '../../lib/tasks/tasks-json-parser.js';
-import { evaluatorVerdictFromText } from '../../lib/evaluator-report.js';
+import { sliceProgress, checksPath } from '../../../framework/hooks/shared/slice-progress.js';
+import {
+  reviewReportsFromDir, requiredReviewRoles, combinedVerdict, allBlockers, checksCoverage, reviewFileName, REVIEW_ROLES,
+} from '../../lib/review-reports.js';
 import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
 import { containerDirs } from '../../../framework/hooks/shared/worktree-root.js';
 import { canonicalPath, isInside, readMorphConfig } from '../../lib/tasks/test-runner.js';
@@ -33,7 +35,6 @@ import { isFinished } from './feature-status.js';
 export const GATES = Object.keys(GATE_PREREQ);
 const FINISHED = new Set(['completed', 'abandoned']);
 const FOLDER_PHASE = Object.fromEntries(PHASE_ARTIFACTS.map(([folder, phase]) => [folder, phase]));
-const EVALUATOR_REPORT = '4-review/evaluator-report.md';
 const MAX_FILE_BYTES = 2 * 1024 * 1024;
 const MAX_DEPTH = 4;
 
@@ -141,31 +142,26 @@ function resolveLocation(projectDir, name, loc, resolveTree) {
 }
 
 /**
- * tasks.json as the dashboard needs it: the list even when the file breaks the
- * schema (a read-only viewer shows what is there), with the errors alongside.
+ * The plan's slices with the status their reports give, plus the fields the
+ * extraction carries for the card. `null` when the plan has not been checked yet.
  */
-export function readTasks(dir) {
-  const path = join(dir, '2-plan', 'tasks.json');
-  if (!existsSync(path)) return { list: [], errors: [], present: false };
-  const data = readJson(path);
-  if (!data) return { list: [], errors: ['tasks.json não é JSON válido'], present: true };
-  const { valid, errors } = validateTasksJson(data);
-  const list = Array.isArray(data.tasks) ? data.tasks.filter((t) => t && typeof t === 'object') : [];
-  return { list, errors: valid ? [] : errors, present: true };
+export function readSlices(dir) {
+  const progress = sliceProgress(dir);
+  if (!progress) return null;
+  const extracted = new Map((readJson(checksPath(dir))?.slices || []).filter((x) => x && x.id).map((x) => [x.id, x]));
+  const list = progress.slices.map((sl) => {
+    const x = extracted.get(sl.id) || {};
+    return {
+      ...sl,
+      persona: x.persona ?? null,
+      files: Array.isArray(x.files) ? x.files : [],
+      covers: Array.isArray(x.covers) ? x.covers : [],
+    };
+  });
+  return { counts: { total: progress.total, done: progress.done, partial: progress.partial, pending: progress.pending }, list };
 }
 
-function taskCounts(list) {
-  const counts = { total: list.length, done: 0, inProgress: 0, blocked: 0, pending: 0, skipped: 0 };
-  for (const t of list) {
-    // `completed` is the pre-schema spelling of `done` (MORPH_OS archives carry both).
-    if (t.status === 'done' || t.status === 'completed') counts.done += 1;
-    else if (t.status === 'in_progress') counts.inProgress += 1;
-    else if (t.status === 'blocked') counts.blocked += 1;
-    else if (t.status === 'skipped') counts.skipped += 1;
-    else counts.pending += 1;
-  }
-  return counts;
-}
+const NO_SLICES = { total: 0, done: 0, partial: 0, pending: 0 };
 
 function gatesOf(feature) {
   const skipped = new Set(feature.skippedPhases || []);
@@ -185,20 +181,67 @@ function gatesOf(feature) {
   });
 }
 
-function evaluatorVerdict(dir) {
-  const path = join(dir, ...EVALUATOR_REPORT.split('/'));
-  if (!existsSync(path)) return null;
-  try { return evaluatorVerdictFromText(readFileSync(path, 'utf8')); } catch { return null; }
+// Security counts only when its report exists: deciding it is required takes git.
+function reviewVerdict(dir, workType, reports = reviewReportsFromDir(dir)) {
+  const present = Object.values(reports).some((r) => r.status !== 'missing');
+  if (!present) return null;
+  const required = requiredReviewRoles({ workType, securityRequired: reports.security.status !== 'missing' });
+  return { verdict: combinedVerdict(reports, required), blockers: allBlockers(reports) };
+}
+
+/**
+ * One row per review report the feature asks for or already has: status,
+ * verdict, blockers and the SHA it reviewed.
+ */
+export function reviewRows(reports, workType) {
+  const required = requiredReviewRoles({ workType, securityRequired: reports.security.status !== 'missing' });
+  return Object.keys(REVIEW_ROLES)
+    .filter((role) => required.includes(role) || reports[role].status !== 'missing')
+    .map((role) => {
+      const r = reports[role];
+      return {
+        role,
+        path: `4-review/${reviewFileName(role)}`,
+        status: r.status,
+        verdict: r.verdict ?? null,
+        blockers: r.blockers?.length ?? 0,
+        reviewedSha: r.reviewedSha ?? null,
+      };
+    });
+}
+
+/**
+ * The plan's scenarios, each with the verifier's row for it. `coverage` is
+ * `null` until a verifier report exists; only PROVADO covers.
+ */
+export function readChecks(dir, verifier) {
+  const checks = readJson(checksPath(dir))?.checks;
+  if (!Array.isArray(checks)) return null;
+  const list = checks.filter((c) => c && c.id);
+  const rows = verifier?.checks ?? null;
+  const byId = new Map((rows ?? []).map((r) => [r.id, r]));
+  const coverage = verifier && verifier.status !== 'missing'
+    ? { total: list.length, ...checksCoverage(list.map((c) => c.id), rows) }
+    : null;
+  return {
+    coverage,
+    list: list.map((c) => ({
+      id: c.id,
+      text: c.text ?? '',
+      proof: c.proof ?? null,
+      status: byId.get(c.id)?.status ?? null,
+      evidence: byId.get(c.id)?.evidence ?? null,
+    })),
+  };
 }
 
 function summarize(name, resolved) {
   const { location, dir, ownerTree, rootStale } = resolved;
   const feature = normalizeFeature(resolved.feature);
-  const has = (rel) => existsSync(join(dir, ...rel.split('/')));
   const gates = gatesOf(feature);
   const reviewApproved = gates.find((g) => g.gate === 'review')?.approved === true;
-  const tasks = readTasks(dir);
-  const verdict = evaluatorVerdict(dir);
+  const slices = readSlices(dir);
+  const verdict = reviewVerdict(dir, feature.workType);
   const status = feature.status || (location === 'archive' ? 'completed' : 'draft');
   const finished = isFinished({ status, location });
   return {
@@ -210,19 +253,19 @@ function summarize(name, resolved) {
     dir,
     ownerTree,
     rootStale,
-    phase: derivePhaseFrom(feature, has),
-    inEvaluation: has(EVALUATOR_REPORT) && !reviewApproved,
+    phase: derivePhaseFrom(feature, diskArtifactProbe(dir)),
+    inEvaluation: verdict !== null && !reviewApproved,
     gates,
     awaiting: !finished && gates.some((g) => g.paused),
-    tasks: taskCounts(tasks.list),
-    // Titles of an active feature's tasks, for the global search. Finished
+    slices: slices?.counts ?? NO_SLICES,
+    // Titles of an active feature's slices, for the global search. Finished
     // features leave them out: 170 archived plans would bloat every list reply.
-    taskIndex: finished ? [] : tasks.list.map((t) => ({ id: t.id, title: t.title || '', status: t.status || 'pending' })),
+    sliceIndex: finished || !slices ? [] : slices.list.map((sl) => ({ id: sl.id, title: sl.title, status: sl.status })),
     verification: feature.verification
-      ? { status: feature.verification.status ?? null, scope: feature.verification.scope ?? null, ts: feature.verification.ts ?? null }
+      ? { status: feature.verification.status ?? null, ts: feature.verification.ts ?? null }
       : null,
     verdict: verdict?.verdict ?? null,
-    blockers: verdict?.verdict ? verdict.blockers.length : null,
+    blockers: verdict ? verdict.blockers.length : null,
     createdAt: feature.createdAt || null,
     updatedAt: feature.updatedAt || feature.archivedAt || feature.createdAt || null,
     archivedAt: feature.archivedAt || null,
@@ -309,24 +352,21 @@ export function scanFeatures(projectDir, { resolveTree = resolveFeatureTree } =
   };
 }
 
-/**
- * One feature in full: summary + tasks with their verify, the gate
- * decisions, the verify nodes and the document tree.
- */
 export function readFeatureDetail(projectDir, name, { resolveTree = resolveFeatureTree, known } = {}) {
   const resolved = resolveOne(projectDir, name, resolveTree, known);
   if (!resolved) return null;
   const summary = summarize(name, resolved);
   const feature = normalizeFeature(resolved.feature);
-  const tasks = readTasks(resolved.dir);
-  const verdict = evaluatorVerdict(resolved.dir);
+  const slices = readSlices(resolved.dir);
+  const reports = reviewReportsFromDir(resolved.dir);
+  const verdict = reviewVerdict(resolved.dir, feature.workType, reports);
+  const checks = readChecks(resolved.dir, reports.verifier);
   return {
     ...summary,
-    tasksList: tasks.list.map((t) => ({
-      ...t,
-      verification: feature.taskVerifications?.[t.id] || null,
-    })),
-    tasksErrors: tasks.errors,
+    slicesList: slices?.list ?? [],
+    checksList: checks?.list ?? [],
+    checksCoverage: checks?.coverage ?? null,
+    reviews: reviewRows(reports, feature.workType),
     gateDecisions: feature.gateDecisions || {},
     verificationNodes: feature.verification?.nodes || null,
     featureVerification: feature.verifications?.feature || null,
@@ -336,13 +376,8 @@ export function readFeatureDetail(projectDir, name, { resolveTree = resolveFeatu
   };
 }
 
-/**
- * The content of one file of a feature, confined to the feature's directory.
- * Junctions and win32 case are resolved by `canonicalPath` before the check,
- * so `..`, an absolute path or a link that leaves the folder are all refused.
- *
- * @returns {{ path: string, content: string, mtime: string } | { error: string, status: number }}
- */
+// Junctions and win32 case are resolved by `canonicalPath` before the check,
+// so `..`, an absolute path or a link that leaves the feature folder are refused.
 export function readFeatureFile(projectDir, name, relPath, { resolveTree = resolveFeatureTree, known } = {}) {
   if (typeof relPath !== 'string' || relPath === '') return { error: 'path ausente', status: 400 };
   if (isAbsolute(relPath) || /^[a-zA-Z]:/.test(relPath)) return { error: 'path fora da feature', status: 403 };

package/src/dashboard/scanner/project-api.js

@@ -89,7 +89,7 @@ export function createProjectApi(projectDir, deps = {}) {
 
   // Which tree owns a feature costs a few git calls (~0.3 s each on Windows)
   // and only changes when a file or folder appears or disappears — never when
-  // an agent rewrites feature.json or tasks.json, which is what happens all
+  // an agent rewrites feature.json or a slice report, which is what happens all
   // the time. Remembered per feature; a structural change or TTL_MS forgets it.
   const resolveTree = deps.resolveTree || resolveFeatureTree;
   const now = deps.now || Date.now;

package/src/dashboard/scanner/standards-scanner.js

@@ -1,11 +1,12 @@
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { personaStandardIds } from '../../utils/agents-installer.js';
+import { loadStandardsRegistry } from '../../lib/standards/registry.js';
 
 export function scanStandards(frameworkDir, agents) {
   const standardsJsonPath = join(frameworkDir, 'standards', 'STANDARDS.json');
   if (!existsSync(standardsJsonPath)) return { version: 'unknown', list: [] };
-  const sJson = JSON.parse(readFileSync(standardsJsonPath, 'utf8'));
+  const sJson = loadStandardsRegistry(standardsJsonPath);
   const refMap = {};
   for (const agent of agents) {
     for (const std of personaStandardIds(agent)) {

package/src/lib/ci/ci-verify.js

@@ -18,7 +18,7 @@ export class CiUsageError extends Error {}
 const NODE_KEYS = ['build', 'tests', 'validators', 'e2e'];
 
 function isVerifyResult(result) {
-  return Boolean(result) && ['pass', 'fail'].includes(result.status) && result.scope === 'feature'
+  return Boolean(result) && ['pass', 'fail'].includes(result.status)
     && NODE_KEYS.every((k) => typeof result.nodes?.[k]?.status === 'string');
 }
 
@@ -47,6 +47,22 @@ function dispatchWorkflow(root, workflow, branch) {
   }
 }
 
+/**
+ * When CI falls back to local, the last green feature stamp still proves the tree if nothing moved
+ * since it by the gate's own staleness rule and nothing is uncommitted (treeMovedSince sees only
+ * commits). A null sha or HEAD would read as "not moved", so both are required.
+ *
+ * @returns {object|null} the stamp to reuse, or null = run local
+ */
+export function reusableLocalStamp(root, stamp) {
+  if (stamp?.status !== 'pass' || !stamp.sha) return null;
+  const head = getHeadSha(root);
+  if (!head) return null;
+  const dirty = uncommittedCode(root);
+  if (dirty === null || dirty.length > 0) return null;
+  return treeMovedSince(root, stamp.sha, head) ? null : stamp;
+}
+
 /**
  * `verify {f} --ci`: the feature-scope proof, run by the project's CI over the pushed commit.
  * Every way CI cannot answer is `mode: 'local'` with the reason, and the caller runs the local

package/src/lib/ci/github-ci.js

@@ -140,7 +140,7 @@ export function listRuns(root, branch, workflow) {
 
 /**
  * The newest run over the same code as HEAD. `isCurrent` is a tree comparison, not SHA equality:
- * the evaluator and the archive commit only `.morph/`, and the workflow does not re-run for them.
+ * the review agents and the archive commit only `.morph/`, and the workflow does not re-run for them.
  */
 export function pickRun(runs, isCurrent) {
   return (runs || []).find((run) => !(run.status === 'completed' && NO_VERDICT.has(run.conclusion))

package/src/lib/detectors/index.js

@@ -10,14 +10,9 @@
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 
-/**
- * Common monorepo locations for a frontend `package.json`, root included.
- *
- * Exported so `discoverFrontendPackages()` (src/lib/tasks/test-nodes.js, #87
- * PR B) scans the SAME candidate list this detector already uses — one
- * spelling of "where a frontend package might live", not two that drift.
- */
-export const PACKAGE_LOCATIONS = ['.', 'src/frontend', 'src/web', 'frontend', 'apps/web', 'packages/app'];
+import { PACKAGE_LOCATIONS } from '../../../framework/hooks/shared/frontend-locations.js';
+
+export { PACKAGE_LOCATIONS };
 
 /**
  * Detect project structure from filesystem evidence.

package/src/lib/generators/handoff-generator.js

@@ -7,67 +7,43 @@
  * fresh instance starts focused instead of inheriting a wall of stale context.
  *
  * Deterministic by construction — everything here is derived from feature.json,
- * tasks.json, decisions.md and the worktree env manifest. The document is
+ * the extracted plan checks, the slice reports and the worktree env manifest. The document is
  * therefore REGENERABLE (never hand-edited, never merged): `morph-spec handoff`
  * rebuilds it, and setup/create/advance/approve regenerate it at the moments a
  * new session is most likely to pick the feature up.
  *
- * Every section is fail-open: a missing tasks.json or a corrupt decisions.md
- * degrades that section, never the document.
+ * Every section is fail-open: missing or corrupt plan checks degrade that
+ * section, never the document.
  */
 
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { ensureCommonExclude } from '../../../framework/hooks/shared/git-exclude.js';
 import { derivePhaseForFeature, getPendingGates } from '../../../framework/hooks/shared/state-reader.js';
-
-const PHASE_DIRS = {
-  proposal: '0-proposal',
-  uiux: '1-design',
-  plan: '2-plan',
-  implement: '3-implement',
-  review: '4-review',
-};
+import { sliceProgress, readySlices } from '../../../framework/hooks/shared/slice-progress.js';
 
 /** Ordered pointer candidates — only existing paths make it into the doc. */
 const POINTER_CANDIDATES = [
-  ['0-proposal/proposal.md', 'proposta: problema, escopo e riscos'],
-  // Behaviour before solution — the same order morph-plan writes them in.
-  ['2-plan/usecases', 'use cases: comportamento e pós-condições testáveis (pasta)'],
-  ['2-plan/spec.md', 'especificação técnica'],
-  ['2-plan/tasks.json', 'DAG de tasks (status vivo)'],
-  ['decisions.md', 'decisões registradas'],
-  ['3-implement/recap.md', 'recap da implementação'],
-  ['4-review/review-report.md', 'relatório do Gate 3'],
+  ['2-plan/plan.md', 'plano: problema, cenários com prova, decisões e fatias'],
+  ['2-plan/checks.json', 'cenários e fatias extraídos pelo plan-check'],
+  ['1-design/design-system.md', 'design system da feature'],
+  ['3-implement/reports', 'relatórios das fatias (**Arquivos:**/**Standards:**): o registro da implementação'],
+  ['4-review/verifier.md', 'verificador do Gate 3: cada cenário provado'],
+  ['4-review/reviewer.md', 'revisor do Gate 3: escopo, arquitetura, regressão'],
+  ['4-review/security.md', 'segurança do Gate 3 (só com caminho sensível)'],
 ];
 
 function readJson(path) {
   return JSON.parse(readFileSync(path, 'utf8').replace(/^/, ''));
 }
 
-function taskSummary(featureDir) {
-  try {
-    const tasksPath = join(featureDir, '2-plan', 'tasks.json');
-    if (!existsSync(tasksPath)) return null;
-    const data = readJson(tasksPath);
-    if (!Array.isArray(data.tasks)) return null;
-    const done = data.tasks.filter((t) => t.status === 'done').length;
-    const doneIds = new Set(data.tasks.filter((t) => t.status === 'done').map((t) => t.id));
-    const ready = data.tasks.filter(
-      (t) => t.status === 'pending' && Array.isArray(t.dependencies) && t.dependencies.every((d) => doneIds.has(d)),
-    );
-    return { done, total: data.tasks.length, ready };
-  } catch {
-    return null;
-  }
-}
-
 function decisionTitles(featureDir, limit = 5) {
   try {
-    const path = join(featureDir, 'decisions.md');
+    const path = join(featureDir, '2-plan', 'checks.json');
     if (!existsSync(path)) return [];
-    const titles = [...readFileSync(path, 'utf8').matchAll(/^##\s+(.+)$/gm)].map((m) => m[1].trim());
-    return titles.slice(-limit);
+    const adrs = readJson(path).adrs;
+    if (!Array.isArray(adrs)) return [];
+    return adrs.map((a) => `${a.id} — ${a.title}`).slice(-limit);
   } catch {
     return [];
   }
@@ -86,34 +62,27 @@ function readWorktreeEnv(cwd) {
   }
 }
 
-function nextAction(feature, phase, tasks, featureName) {
+function nextAction(feature, phase, slices, featureName) {
   const gates = feature.approvals || feature.approvalGates || {};
   const approved = (g) => gates[g]?.approved === true;
 
   switch (phase) {
-    case 'proposal':
-      // An approved Gate 1 with no plan artifact yet means "plan work is open":
-      // the derived phase only flips when 2-plan/spec.md lands (derivePhase is
-      // artifact-first). Pointing back at the proposal here would be wrong.
-      return approved('proposal')
-        ? `Gate 1 aprovado — produza \`2-plan/spec.md\` + \`tasks.json\` (a fase avança com o primeiro artefato; Gate 2 em seguida).`
-        : `Complete \`0-proposal/proposal.md\` e aprove o Gate 1 (\`morph-spec advance ${featureName}\`). Skill: /morph-proposal ${featureName}.`;
+    case 'plan':
+      return `Escreva \`2-plan/plan.md\`, rode \`morph-spec plan-check ${featureName}\` até zero erro e aprove o gate do plano (\`morph-spec advance ${featureName}\`). Skill: /morph-proposal ${featureName}.`;
     case 'uiux':
       return approved('uiux')
-        ? `Gate de uiux aprovado — produza \`2-plan/spec.md\` + \`tasks.json\` (Gate 2 em seguida).`
+        ? `Gate de uiux aprovado — implemente as fatias do plano via /morph-apply ${featureName}.`
         : `Complete \`1-design/design-system.md\` e aprove o gate de uiux (\`morph-spec advance ${featureName}\`).`;
-    case 'plan':
-      return `Produza \`2-plan/spec.md\` + \`tasks.json\` e aprove o Gate 2 (\`morph-spec advance ${featureName}\`).`;
     case 'implement': {
-      const ready = tasks?.ready?.map((t) => `${t.id} "${t.title}"`).join(', ');
+      const ready = readySlices(slices).map((s) => `${s.id} "${s.title}"`).join(', ');
       return ready
-        ? `Execute as tasks ready — ${ready} — via /morph-apply ${featureName} (task fecha com verify verde e critérios provados).`
-        : `Todas as tasks concluídas ou bloqueadas — rode \`morph-spec advance ${featureName}\` para escancarar a review, ou destrave dependências. Skill: /morph-apply ${featureName}.`;
+        ? `Implemente as fatias prontas — ${ready} — via /morph-apply ${featureName} (cada fatia grava 3-implement/reports/{id}.md).`
+        : `Todas as fatias têm relatório final — rode \`morph-spec verify ${featureName}\` e siga para a review. Skill: /morph-apply ${featureName}.`;
     }
     case 'review':
       return approved('review')
         ? `Gate 3 aprovado — feche: \`morph-spec finish ${featureName} --pr\` (abre PR) ou \`--merge\` (merge local na default). Arquiva + integra num passo.`
-        : `Produza \`4-review/review-report.md\` (avaliador independente) e aprove o Gate 3; depois \`morph-spec finish ${featureName} --pr|--merge\`.`;
+        : `Rode /morph-review ${featureName} (verificador ∥ revisor, segurança se exigida) e aprove o Gate 3; depois \`morph-spec finish ${featureName} --pr|--merge\`.`;
     default:
       return `Rode \`morph-spec status ${featureName}\` para orientar o próximo passo.`;
   }
@@ -131,7 +100,7 @@ function nextAction(feature, phase, tasks, featureName) {
  *   copy at birth (create.js) — a handoff built FROM the worktree's own copy
  *   would otherwise always say "no worktree registered", even while sitting
  *   inside one. Pass `undefined` (the default) to fall back to `feature.worktree`.
- * @returns {{ markdown: string, meta: { generatedAt: string, phase: string, tasksDone: number, tasksTotal: number } } | null}
+ * @returns {{ markdown: string, meta: { generatedAt: string, phase: string, slicesDone: number, slicesTotal: number } } | null}
  */
 export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
   const featureDir = join(cwd, '.morph', 'features', featureName);
@@ -144,15 +113,15 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     return null;
   }
 
-  let phase = 'proposal';
+  let phase = 'plan';
   let pendingGates = [];
   try {
-    phase = derivePhaseForFeature(featureName, cwd) || 'proposal';
+    phase = derivePhaseForFeature(featureName, cwd) || 'plan';
     pendingGates = getPendingGates(featureName, cwd) || [];
-  } catch { /* fail-open — proposal defaults keep the doc useful */ }
+  } catch { /* fail-open — plan defaults keep the doc useful */ }
 
   const generatedAt = new Date().toISOString();
-  const tasks = taskSummary(featureDir);
+  const slices = sliceProgress(featureDir);
   const env = readWorktreeEnv(cwd);
   const decisions = decisionTitles(featureDir);
   const worktree = opts.worktree !== undefined ? opts.worktree : (feature.worktree || null);
@@ -187,9 +156,9 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     '## Estado',
     '',
     `- Gates: ${gateLine}`,
-    tasks
-      ? `- Tasks: ${tasks.done}/${tasks.total} done · ready agora: ${tasks.ready.length ? tasks.ready.map((t) => `**${t.id}** "${t.title}"`).join(', ') : 'nenhuma'}`
-      : '- Tasks: sem tasks.json ainda (fase de planejamento não concluída)',
+    slices
+      ? `- Fatias: ${slices.done}/${slices.total} feitas${slices.partial ? ` · ${slices.partial} parcial(is)` : ''} · prontas agora: ${readySlices(slices).map((s) => `**${s.id}** "${s.title}"`).join(', ') || 'nenhuma'}`
+      : '- Fatias: sem checks.json ainda (rode plan-check)',
     pendingGates.length ? `- Gates pendentes: ${pendingGates.join(', ')}` : null,
     '',
     '## Leia nesta ordem (ponteiros — nada copiado)',
@@ -200,7 +169,7 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     '',
     '## Próxima ação',
     '',
-    nextAction(feature, phase, tasks, featureName),
+    nextAction(feature, phase, slices, featureName),
     '',
     '## Retomar',
     '',
@@ -214,8 +183,8 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     meta: {
       generatedAt,
       phase,
-      tasksDone: tasks?.done ?? 0,
-      tasksTotal: tasks?.total ?? 0,
+      slicesDone: slices?.done ?? 0,
+      slicesTotal: slices?.total ?? 0,
     },
   };
 }