@polymorphism-tech/morph-spec 8.47.0 → 9.0.0

package/src/commands/project/status.js

@@ -2,7 +2,7 @@
  * MORPH-SPEC Feature Status Command
  *
  * Displays a comprehensive dashboard showing feature progress, phase status,
- * outputs, tasks, approvals, and next steps.
+ * outputs, slices, approvals, and next steps.
  *
  * Usage:
  *   morph-spec status <feature-name>
@@ -14,6 +14,7 @@
 
 import chalk from 'chalk';
 import { loadState, getFeature, derivePhase, deriveOutputs } from '../../core/state/state-manager.js';
+import { sliceProgress } from '../../../framework/hooks/shared/slice-progress.js';
 
 /**
  * Phase symbols for visual representation
@@ -29,13 +30,19 @@ const PHASE_SYMBOLS = {
  * Phase definitions with order
  */
 const PHASE_ORDER = [
-  { key: 'proposal', name: 'FASE 0: PROPOSAL', order: 0 },
-  { key: 'uiux', name: 'FASE 1: UI/UX', order: 1, optional: true },
-  { key: 'plan', name: 'FASE 2: PLAN', order: 2 },
-  { key: 'implement', name: 'FASE 3: IMPLEMENT', order: 3 },
-  { key: 'review', name: 'FASE 4: REVIEW', order: 4 }
+  { key: 'plan', name: 'FASE 1: PLAN', order: 0 },
+  { key: 'uiux', name: 'FASE 2: UI/UX', order: 1, optional: true },
+  { key: 'implement', name: 'FASE 3: IMPLEMENT', order: 2 },
+  { key: 'review', name: 'FASE 4: REVIEW', order: 3 }
 ];
 
+const PHASE_OUTPUTS = {
+  plan: ['plan', 'checks'],
+  uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
+  implement: [],
+  review: ['verifierReport', 'reviewerReport']
+};
+
 /**
  * Calculate phase status (completed, current, pending, skipped)
  */
@@ -61,15 +68,7 @@ function getPhaseStatus(phaseKey, currentPhase, feature) {
  * Check if phase has any outputs created
  */
 function checkPhaseOutputs(phaseKey, feature) {
-  const phaseOutputMap = {
-    proposal: ['proposal', 'stackScan'],
-    uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-    plan: ['spec', 'tasks', 'decisions'],
-    implement: ['recap'],
-    review: ['reviewReport']
-  };
-
-  const outputs = phaseOutputMap[phaseKey] || [];
+  const outputs = PHASE_OUTPUTS[phaseKey] || [];
   return outputs.some(output => feature.outputs[output]?.created);
 }
 
@@ -99,15 +98,7 @@ function formatPhase(phaseKey, currentPhase, feature, options = {}) {
 
   // Add output files if verbose
   if (options.verbose && status !== 'pending' && status !== 'skipped') {
-    const phaseOutputMap = {
-      proposal: ['proposal', 'stackScan'],
-      uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-      plan: ['spec', 'tasks', 'decisions'],
-      implement: ['recap'],
-      review: ['reviewReport']
-    };
-
-    const outputs = phaseOutputMap[phaseKey] || [];
+    const outputs = PHASE_OUTPUTS[phaseKey] || [];
     const created = outputs.filter(o => feature.outputs[o]?.created);
     if (created.length > 0) {
       display += chalk.gray(`\n     Files: ${created.length}/${outputs.length}`);
@@ -121,7 +112,7 @@ function formatPhase(phaseKey, currentPhase, feature, options = {}) {
  * Calculate completion percentage
  */
 function calculateCompletionPercentage(feature) {
-  const totalPhases = PHASE_ORDER.filter(p => !p.optional).length; // 6 required phases
+  const totalPhases = PHASE_ORDER.filter(p => !p.optional).length;
   const completedPhases = PHASE_ORDER.filter(p => {
     if (p.optional) return false;
     const status = getPhaseStatus(p.key, feature.phase, feature);
@@ -139,9 +130,8 @@ function getNextSteps(feature) {
 
   // Check for pending approvals relevant to current phase
   const phaseApprovalMap = {
-    proposal: 'proposal',
-    uiux: 'uiux',
     plan: 'plan',
+    uiux: 'uiux',
     implement: 'plan',
     review: 'review'
   };
@@ -158,14 +148,7 @@ function getNextSteps(feature) {
   }
 
   // Check for missing outputs in current phase
-  const phaseOutputMap = {
-    proposal: ['proposal'],
-    plan: ['spec', 'tasks'],
-    implement: ['recap'],
-    review: ['reviewReport']
-  };
-
-  const requiredOutputs = phaseOutputMap[feature.phase] || [];
+  const requiredOutputs = feature.phase === 'uiux' ? [] : PHASE_OUTPUTS[feature.phase] || [];
   const missingOutputs = requiredOutputs.filter(o => !feature.outputs[o]?.created);
 
   if (missingOutputs.length > 0) {
@@ -199,25 +182,6 @@ function getNextSteps(feature) {
   return steps;
 }
 
-/**
- * Estimate remaining time based on tasks
- */
-function estimateRemainingTime(feature) {
-  if (!feature.tasks || feature.tasks.total === 0) {
-    return 'Not estimated';
-  }
-
-  const remaining = feature.tasks.total - feature.tasks.completed;
-  const avgHoursPerTask = 2; // Configurable estimate
-  const hours = remaining * avgHoursPerTask;
-
-  if (hours < 1) return '< 1 hour';
-  if (hours === 1) return '1 hour';
-  if (hours < 8) return `${hours} hours`;
-  const days = Math.ceil(hours / 8);
-  return `~${days} day${days > 1 ? 's' : ''} (${hours}h)`;
-}
-
 /**
  * Main status command
  */
@@ -251,6 +215,7 @@ export async function statusCommand(featureName, options = {}) {
   if (!feature.outputs) {
     feature.outputs = deriveOutputs(featureName, process.cwd());
   }
+  const slices = sliceProgress(featurePath);
 
   // JSON output mode
   if (options.json) {
@@ -270,10 +235,9 @@ export async function statusCommand(featureName, options = {}) {
         created: output.created,
         path: output.path
       })),
-      tasks: feature.tasks || { total: 0, completed: 0, inProgress: 0, pending: 0 },
+      slices,
       approvals: feature.approvalGates || {},
-      nextSteps: getNextSteps(feature),
-      estimatedTimeRemaining: estimateRemainingTime(feature)
+      nextSteps: getNextSteps(feature)
     };
 
     console.log(JSON.stringify(status, null, 2));
@@ -315,17 +279,13 @@ export async function statusCommand(featureName, options = {}) {
   }
   console.log('');
 
-  // Tasks progress
-  if (feature.tasks && feature.tasks.total > 0) {
-    console.log(chalk.white.bold('Tasks Progress:'));
-    const { total, completed, inProgress, pending } = feature.tasks;
-    const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
-
-    console.log(`  Total: ${total}`);
-    console.log(chalk.green(`  ✓ Completed: ${completed} (${percentage}%)`));
-    if (inProgress > 0) console.log(chalk.cyan(`  ▶ In Progress: ${inProgress}`));
-    if (pending > 0) console.log(chalk.gray(`  ⬜ Pending: ${pending}`));
-    console.log(`  Estimated time remaining: ${estimateRemainingTime(feature)}`);
+  if (slices && slices.total > 0) {
+    console.log(chalk.white.bold('Fatias:'));
+    const percentage = Math.round((slices.done / slices.total) * 100);
+    console.log(`  Total: ${slices.total}`);
+    console.log(chalk.green(`  ✓ Feitas: ${slices.done} (${percentage}%)`));
+    if (slices.partial > 0) console.log(chalk.cyan(`  ▶ Parciais: ${slices.partial}`));
+    if (slices.pending > 0) console.log(chalk.gray(`  ⬜ Pendentes: ${slices.pending}`));
     console.log('');
   }
 
@@ -361,7 +321,7 @@ export async function statusCommand(featureName, options = {}) {
     });
     console.log('');
   } else {
-    console.log(chalk.green('✓ All tasks complete!\n'));
+    console.log(chalk.green('✓ Nada pendente.\n'));
   }
 
   // Footer

package/src/commands/project/update.js

@@ -35,6 +35,7 @@ import { reconcileLegacyTemplatesCopy } from '../../lib/installers/templates-rec
 import { createEffects } from '../../lib/installers/effects.js';
 import { applyEditorSettings } from '../../lib/worktree/vscode-settings.js';
 import { registerProject } from '../../lib/projects/registry.js';
+import { findOldFormatFeatures, oldFormatGuardLines } from '../../lib/specs/old-format.js';
 import {
   writeGraphifyignore, describeOutdatedIgnore, graphifyignoreTracked,
 } from '../../lib/graph/graphifyignore.js';
@@ -531,6 +532,21 @@ export async function updateCommand(options = {}) {
       + `Quem decide é o primeiro.`);
   }
 
+  // `--force` não dispensa: esta CLI não sabe conduzir essas features.
+  const oldFormat = needsInitialization ? [] : findOldFormatFeatures(targetPath);
+  if (oldFormat.length) {
+    const lines = oldFormatGuardLines(oldFormat, targetPath);
+    if (dryRun) {
+      notices.push(...lines);
+    } else {
+      logger.error(lines[0]);
+      for (const l of lines.slice(1)) logger.dim(l);
+      logger.blank();
+      process.exitCode = 1;
+      return { refused: true, reason: 'old-format-features', features: oldFormat, effects: fx.list() };
+    }
+  }
+
   // ── A partir daqui, tudo passa pelo coletor ──────────────────────────────
   if (needsInitialization) {
     logger.warn('MORPH not fully initialized. Creating basic structure...');
@@ -647,7 +663,7 @@ export async function updateCommand(options = {}) {
     // MUST come from the pre-clean backup: cleanFrameworkDirs() deleted .morph/config/
     // above and restoreUserConfig() only runs at the end — re-reading the file here
     // yields [] and silently downgrades the whole install to universal-only assets
-    // (the ".claude/agents/ only has morph-evaluator.md after update" bug).
+    // (the ".claude/agents/ only has morph-verifier.md after update" bug).
     let projectTags = [];
     try {
       if (configBackup) projectTags = getProjectTags(configBackup);

package/src/commands/project/worktree.js

@@ -1867,7 +1867,7 @@ export async function worktreeListCommand(options = {}) {
       if (!m) continue; // skip the primary root entry and any non-morph worktree
       const feature = m[1];
 
-      let phase = 'proposal';
+      let phase = 'plan';
       let status = 'unknown';
       let pendingGates = [];
       try {

package/src/commands/state/advance.js

@@ -1,12 +1,16 @@
 import chalk from 'chalk';
 import { existsSync, mkdirSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { join, relative } from 'path';
 import { fileURLToPath } from 'url';
 import { getFeature, setApprovalGate, derivePhase } from '../../core/state/state-manager.js';
 import { unmetPrereqs } from '../../core/state/gate-order.js';
 import { OUTPUT_SCHEMA } from '../../core/paths/output-schema.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 import { uiuxAutoApprovalBlock } from '../../lib/specs/screen-checklist.js';
+import { seedDesignArtifacts } from '../../lib/specs/design-seed.js';
+import { sliceProgress } from '../../../framework/hooks/shared/slice-progress.js';
+import { autoApprovalRefusal, printRefusal } from './auto-approval.js';
+import { seedDotnetBuildIgnores } from '../../lib/stack/dotnet-build-ignores.js';
 
 const FRAMEWORK_DIR = fileURLToPath(new URL('../../../framework/', import.meta.url));
 
@@ -20,17 +24,16 @@ const FRAMEWORK_DIR = fileURLToPath(new URL('../../../framework/', import.meta.u
  */
 
 // The gate approved when *completing* a given phase. `implement` has no gate
-// (it ends when all tasks are done), so advancing from implement just scaffolds
-// the review folder.
-const PHASE_GATE = { proposal: 'proposal', uiux: 'uiux', plan: 'plan', review: 'review' };
+// (it ends when all slices are done), so advancing from implement just
+// scaffolds the review folder.
+const PHASE_GATE = { plan: 'plan', uiux: 'uiux', review: 'review' };
 
 // The next phase folder to scaffold when advancing FROM a given phase. The
-// default forward path skips the optional design phase (proposal → plan); pass
-// --design to take the uiux branch (proposal → 1-design).
+// default forward path skips the optional design phase (plan → implement); pass
+// --design to take the uiux branch (plan → 1-design).
 const NEXT_PHASE_DIR = {
-  proposal: '2-plan',
-  uiux: '2-plan',
   plan: '3-implement',
+  uiux: '3-implement',
   implement: '4-review',
 };
 
@@ -63,12 +66,19 @@ function missingPhaseArtifacts(phase, featurePath) {
       const rel = `${entry.phaseDir}/${entry.filename}`;
       if (!existsSync(join(featurePath, entry.phaseDir, entry.filename))) missing.push(rel);
     }
+    if (phase === 'implement') missing.push(...unfinishedSliceReports(featurePath));
     return missing;
   } catch {
     return [];
   }
 }
 
+function unfinishedSliceReports(featurePath) {
+  const progress = sliceProgress(featurePath);
+  if (!progress) return ['2-plan/checks.json'];
+  return progress.slices.filter((s) => s.status !== 'feito').map((s) => `3-implement/reports/${s.id}.md`);
+}
+
 /**
  * When a required artifact is absent HERE, check whether it exists in the
  * worktree that owns this feature. `feature.json` travels committed on
@@ -105,6 +115,16 @@ function resolveApprovedBy(options) {
   return 'auto';
 }
 
+export function reportDotnetIgnores(added) {
+  if (added.length) console.log(chalk.gray(`   .gitignore: ${added.join(' ')} adicionados (projeto .NET) — commite antes do primeiro build.`));
+}
+
+function reportDesignSeed({ mockups, designSystem }) {
+  const rel = (p) => relative(process.cwd(), p).replace(/\\/g, '/');
+  if (mockups.written) console.log(chalk.gray(`   Escrito ${rel(mockups.path)} a partir do template (checklist de tela por \`## Tela:\`).`));
+  if (designSystem.written) console.log(chalk.gray(`   Escrito ${rel(designSystem.path)} a partir do template (o projeto não tinha design system).`));
+}
+
 export async function advanceCommand(featureName, options = {}) {
   try {
     const feature = getFeature(featureName);
@@ -127,6 +147,21 @@ export async function advanceCommand(featureName, options = {}) {
     const featurePath = join(process.cwd(), '.morph', 'features', featureName);
     const phase = derivePhase(featurePath);
 
+    // The plan gate is often closed by the human's answer to the gate question
+    // (state-sync), which already moves the derived phase to implement: taking
+    // the design branch then is opening 1-design/, not closing a phase.
+    if (options.design && phase === 'implement' && feature.approvalGates?.plan?.approved === true) {
+      mkdirSync(join(featurePath, '1-design'), { recursive: true });
+      reportDesignSeed(seedDesignArtifacts(featureName, process.cwd()));
+      reportDotnetIgnores(seedDotnetBuildIgnores(process.cwd(), { featureName }));
+      try {
+        const { writeHandoff } = await import('../../lib/generators/handoff-generator.js');
+        writeHandoff(featureName, process.cwd());
+      } catch { /* fail-open */ }
+      console.log(chalk.green(`\n✅ "${featureName}": gate plan já aprovado — ramo de design aberto (1-design/).\n`));
+      return;
+    }
+
     if (phase === 'review') {
       console.log(chalk.yellow(`\n⚠️  Feature "${featureName}" is already at the final phase (review).`));
       console.log(chalk.gray(`Approve Gate 3 with: morph-spec approve ${featureName} review`));
@@ -134,11 +169,9 @@ export async function advanceCommand(featureName, options = {}) {
       return;
     }
 
-    // Phase-exit artifact check (D3): a phase transition must not step over the
-    // artifact the phase it is CLOSING owes. Observed: a feature reached review
-    // with NO 3-implement/recap.md — the file was written later, by hand, so
-    // the Gate 3 review had nothing to review. `implement` has no gate, which
-    // is precisely why nothing stopped it.
+    // Phase-exit artifact check: a phase transition must not step over what the
+    // phase it is CLOSING owes. `implement` has no gate, so this is the only
+    // thing that keeps a feature with unfinished slice reports out of review.
     //
     // `--force` bypasses (same deliberate-recovery role it already plays for
     // gate order) but still names what was skipped — a silent bypass would be
@@ -160,7 +193,7 @@ export async function advanceCommand(featureName, options = {}) {
         process.exit(1);
       }
 
-      console.error(chalk.red(`\n❌ A fase "${phase}" não pode ser encerrada — artefato(s) obrigatório(s) ausente(s):`));
+      console.error(chalk.red(`\n❌ A fase "${phase}" não pode ser encerrada — artefato(s) obrigatório(s) ausente(s) ou PARCIAL:`));
       for (const rel of missingArtifacts) console.error(chalk.gray(`   • ${rel}`));
       console.error(chalk.gray('\n   Produza o artefato e rode de novo, ou passe --force para avançar assim mesmo.\n'));
       process.exit(1);
@@ -170,25 +203,11 @@ export async function advanceCommand(featureName, options = {}) {
     const gate = PHASE_GATE[phase];
     const approvedBy = resolveApprovedBy(options);
 
-    // The screen checklist is part of what the uiux phase owes. The predicate
-    // is approve.js's too: an "auto" signature never closes a gate the
-    // gate-check would pause, and a recorded decision or a human signature
-    // (--approver) is the answer to that pause; --force is not, as in approve.
-    const checklistBlock = phase === 'uiux' ? uiuxAutoApprovalBlock(process.cwd(), featureName, feature) : null;
-    if (checklistBlock && approvedBy === 'auto') {
-      console.error(chalk.red(`\n❌ A fase "uiux" não pode ser encerrada com assinatura automática — ${checklistBlock}.`));
-      console.error(chalk.gray('\n   Complete o checklist (ver a skill morph-uiux) e rode de novo. Quem decidiu aprovar assim'));
-      console.error(chalk.gray(`   mesmo grava a decisão (morph-spec gate-decision ${featureName} uiux --pause false --reason "...")`));
-      console.error(chalk.gray('   ou assina com --approver <nome>. O --force não dispensa o checklist.\n'));
-      process.exit(1);
-    }
-
     // Gate monotonicity (mirrors approve.js): advance is a gate write-path too,
     // so it must not stamp gate N while a predecessor is pending. In the
-    // sanctioned flow advance is always in-order (it approves G1 before the plan
-    // artifact that flips the phase to plan exists), but an anomalous filesystem
-    // state — e.g. 2-plan/spec.md present without Gate 1, the lead-termometro
-    // shape — would otherwise let advance deepen the violation by stamping G2.
+    // sanctioned flow advance is always in-order, but an anomalous filesystem
+    // state — e.g. 1-design/design-system.md present without the plan gate —
+    // would otherwise let advance deepen the violation by stamping uiux.
     // Escape via --force for deliberate recovery.
     if (gate) {
       const unmet = unmetPrereqs(gate, feature.approvalGates);
@@ -199,24 +218,11 @@ export async function advanceCommand(featureName, options = {}) {
       }
     }
 
-    // Hotfix backstop (defensive, mirrors approve.js): the phase==='review'
-    // early-return above already stops advance from ever reaching a
-    // gate==='review' approval, but guard the approval itself too so this
-    // stays true even if the early-return's shape changes later. Gate on the
-    // RESOLVED approvedBy — headless contexts have no TTY and resolve to
-    // "auto" regardless of --mode, so checking the raw --mode string alone
-    // would let them slip through (same bug the approve.js backstop had).
-    if (gate === 'review' && feature.workType === 'hotfix' && approvedBy === 'auto') {
-      console.error(chalk.red('\n❌ Hotfix exige aprovação humana no Gate 3 — trust:auto não se aplica.'));
-      console.error(chalk.gray('   Aprove com --approver <nome>, num terminal interativo, ou pela resposta humana "aprovado" (state-sync) ao review-report via AskUserQuestion.\n'));
-      process.exit(1);
-    }
-
     // Gate idempotency (F15): `setApprovalGate` REPLACES the gate object whole
     // (state-manager.js), so re-writing an already-approved gate does not
     // refresh it — it destroys `approvedBy`, `timestamp`, `notes` and
     // `selfAssessed` in one assignment. And `resolveApprovedBy` above answers
-    // "auto" in every headless context, so `approve f proposal --approver
+    // "auto" in every headless context, so `approve f plan --approver
     // lucas` followed by `advance f` used to rewrite a human's signature as
     // "auto" — the one stamp the charter forbids on a human-approved gate.
     // The state-sync hook already carries exactly this guard; `advance`, the
@@ -228,6 +234,14 @@ export async function advanceCommand(featureName, options = {}) {
     const priorGate = gate ? feature.approvalGates?.[gate] : null;
     const alreadyApproved = priorGate?.approved === true;
 
+    const refusal = alreadyApproved ? null
+      : autoApprovalRefusal({ cwd: process.cwd(), featureName, feature, gate, approvedBy });
+    if (refusal) {
+      printRefusal(chalk, refusal);
+      process.exit(1);
+    }
+    const checklistBlock = phase === 'uiux' && !alreadyApproved ? uiuxAutoApprovalBlock(process.cwd(), featureName, feature) : null;
+
     if (gate && !alreadyApproved) {
       await setApprovalGate(featureName, gate, true, {
         approvedBy,
@@ -238,11 +252,13 @@ export async function advanceCommand(featureName, options = {}) {
 
     // 2) Scaffold the next phase folder so the agent can write its first artifact.
     let nextDir = NEXT_PHASE_DIR[phase];
-    if (phase === 'proposal' && options.design) nextDir = '1-design';
+    if (phase === 'plan' && options.design) nextDir = '1-design';
     if (nextDir) {
       const nextPath = join(featurePath, nextDir);
       if (!existsSync(nextPath)) mkdirSync(nextPath, { recursive: true });
     }
+    if (nextDir === '1-design') reportDesignSeed(seedDesignArtifacts(featureName, process.cwd()));
+    if (phase === 'plan') reportDotnetIgnores(seedDotnetBuildIgnores(process.cwd(), { featureName }));
 
     // Fleet handoff: a phase transition is exactly when a session hands the
     // feature over (to a new instance, or to itself after /compact) — refresh