@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

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

@@ -8,6 +8,7 @@
 import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync, rmdirSync, statSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { getAllOutputPaths, getOutputPath } from '../paths/output-schema.js';
+import { derivePhaseFrom, diskArtifactProbe } from '../../../framework/hooks/shared/state-reader.js';
 
 const STATE_FILE_NAME = '.morph/state.json';
 const FEATURES_DIR_NAME = '.morph/features';
@@ -156,56 +157,19 @@ function scaffoldState() {
   };
 }
 /**
- * Derive current phase from filesystem.
- *
- * Walks the phase map in descending order and returns the first phase whose
- * CANONICAL ARTIFACT exists. An empty folder is not enough — `mkdir 2-plan/`
- * does not count as "in plan phase" until `spec.md` (the first canonical
- * plan-phase output) lands. If no canonical artifact is found anywhere,
- * returns `'proposal'` (the starting phase).
- *
- * This avoids the chicken-and-egg problem where the agent pre-creates all
- * phase folders, the derived phase jumps to the highest one, and
- * `enforce-phase-writes` then blocks the agent from writing back to the
- * prior phase folder.
+ * Derive current phase from filesystem — delegates to the hook-side rule
+ * (`derivePhaseFrom`) so the CLI and the hooks never disagree on a feature.
  *
  * @param {string} featurePath - Absolute path to .morph/features/{feature}/
- * @returns {string} Phase name: 'review' | 'implement' | 'plan' | 'uiux' | 'proposal'
+ * @returns {string} Phase name: 'review' | 'implement' | 'uiux' | 'plan'
  */
-const PHASE_INDEX = { proposal: 0, uiux: 1, plan: 2, implement: 3, review: 4 };
-
-/** Phase implied purely by approved gates (mirrors hook-side gateImpliedPhase). */
-function gateImpliedPhaseFromGates(gates) {
-  const ok = (g) => gates?.[g]?.approved === true;
-  if (ok('review')) return 'review';
-  if (ok('plan')) return 'implement';
-  if (ok('uiux')) return 'plan';
-  return 'proposal';
-}
-
 export function derivePhase(featurePath) {
-  const phaseMap = [
-    ['4-review',    'review',    'review-report.md'],
-    ['3-implement', 'implement', 'recap.md'],
-    ['2-plan',      'plan',      'spec.md'],
-    ['1-design',    'uiux',      'design-system.md'],
-    ['0-proposal',  'proposal',  'proposal.md'],
-  ];
-  let artifactPhase = 'proposal';
-  for (const [folder, phase, canonical] of phaseMap) {
-    if (existsSync(join(featurePath, folder, canonical))) { artifactPhase = phase; break; }
-  }
-
-  // Gate-aware (same rule as the hook-side derivePhaseForFeature): an approved
-  // gate advances the phase before the next phase's canonical artifact exists,
-  // so the agent can actually write that first artifact.
-  let gates = null;
+  let feature = null;
   try {
     const fjPath = join(featurePath, 'feature.json');
-    if (existsSync(fjPath)) gates = JSON.parse(readFileSync(fjPath, 'utf8'))?.approvalGates;
-  } catch { gates = null; }
-  const implied = gateImpliedPhaseFromGates(gates);
-  return PHASE_INDEX[implied] > PHASE_INDEX[artifactPhase] ? implied : artifactPhase;
+    if (existsSync(fjPath)) feature = JSON.parse(readFileSync(fjPath, 'utf8'));
+  } catch { feature = null; }
+  return derivePhaseFrom(feature, diskArtifactProbe(featurePath));
 }
 
 /**
@@ -498,7 +462,7 @@ export function getFeature(featureName) {
 /**
  * Create or get feature with default structure.
  * v5: every feature follows the fixed phase sequence
- * (proposal → uiux → plan → implement → review). No workflow selection.
+ * (plan → [uiux] → implement → review). No workflow selection.
  * @param {string} featureName - Feature name
  * @returns {Promise<Object>} Feature object
  */
@@ -511,17 +475,10 @@ async function ensureFeature(featureName) {
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
       approvalGates: {
-        proposal: { approved: false, timestamp: null, approvedBy: null },
-        uiux: { approved: false, timestamp: null, approvedBy: null },
         plan: { approved: false, timestamp: null, approvedBy: null },
+        uiux: { approved: false, timestamp: null, approvedBy: null },
         review: { approved: false, timestamp: null, approvedBy: null }
       },
-      tasks: {
-        total: 0,
-        completed: 0,
-        inProgress: 0,
-        pending: 0
-      },
       checkpoints: [],
       trustConfig: {},
       contextBundles: [],
@@ -575,18 +532,11 @@ export async function createFeature(featureName, options = {}) {
     createdAt: now,
     updatedAt: now,
     approvalGates: {
-      proposal: { approved: false, timestamp: null, approvedBy: null },
-      uiux: { approved: false, timestamp: null, approvedBy: null },
       plan: { approved: false, timestamp: null, approvedBy: null },
+      uiux: { approved: false, timestamp: null, approvedBy: null },
       review: { approved: false, timestamp: null, approvedBy: null }
     },
     gateDecisions: {},
-    tasks: {
-      total: 0,
-      completed: 0,
-      inProgress: 0,
-      pending: 0
-    },
     checkpoints: [],
     trustConfig: {},
     contextBundles: [],
@@ -603,7 +553,7 @@ export async function createFeature(featureName, options = {}) {
 }
 
 /**
- * Update feature property (supports nested keys like "tasks.completed")
+ * Update feature property (supports nested keys like "approvalGates.plan.approved")
  * @param {string} featureName - Feature name
  * @param {string} key - Property key (supports dot notation)
  * @param {any} value - Value to set
@@ -657,36 +607,6 @@ export async function updateFeatureMultiple(featureName, updates) {
   saveState(state);
 }
 
-/**
- * Add checkpoint to feature
- * @param {string} featureName - Feature name
- * @param {string} note - Checkpoint note
- * @returns {Object} Checkpoint object
- */
-export async function addCheckpoint(featureName, note) {
-  await ensureFeature(featureName);
-  const state = loadState();
-  const feature = state.features[featureName];
-
-  const checkpoint = {
-    passed: true,
-    checkpointNum: feature.checkpoints.length + 1,
-    timestamp: new Date().toISOString(),
-    phase: feature.phase || 'proposal',
-    results: [],
-    summary: {
-      note: note,
-      completedTasks: feature.tasks.completed
-    }
-  };
-
-  feature.checkpoints.push(checkpoint);
-  feature.updatedAt = new Date().toISOString();
-
-  saveState(state);
-  return checkpoint;
-}
-
 /**
  * Normalize output type from kebab-case to camelCase (BUG-002 fix - Enhanced)
  * Supports both kebab-case and camelCase input formats for all output types
@@ -781,7 +701,7 @@ function findClosestMatch(inputType, validTypes) {
 /**
  * Mark output as created
  * @param {string} featureName - Feature name
- * @param {string} outputType - Output type (proposal, spec, tasks, etc.)
+ * @param {string} outputType - Output type (plan, checks, verifierReport, etc.)
  */
 export async function markOutput(featureName, outputType) {
   await ensureFeature(featureName);
@@ -860,7 +780,7 @@ export async function trackFileChange(featureName, filePath, action, phase) {
   state.features[featureName].fileChanges.push({
     path: filePath,
     action,
-    phase: phase || state.features[featureName].phase || 'proposal',
+    phase: phase || state.features[featureName].phase || 'plan',
     timestamp: new Date().toISOString()
   });
 
@@ -968,7 +888,7 @@ export function getSummary() {
 /**
  * Set approval gate status
  * @param {string} featureName - Feature name
- * @param {string} gate - Gate name (proposal, uiux, plan, review)
+ * @param {string} gate - Gate name (plan, uiux, review)
  * @param {boolean} approved - Approval status
  * @param {Object} metadata - Additional metadata (approvedBy, reason, etc.)
  */
@@ -978,9 +898,8 @@ export async function setApprovalGate(featureName, gate, approved, metadata = {}
 
   if (!feature.approvalGates) {
     feature.approvalGates = {
-      proposal: { approved: false, timestamp: null, approvedBy: null },
-      uiux: { approved: false, timestamp: null, approvedBy: null },
       plan: { approved: false, timestamp: null, approvedBy: null },
+      uiux: { approved: false, timestamp: null, approvedBy: null },
       review: { approved: false, timestamp: null, approvedBy: null }
     };
   }
@@ -1026,7 +945,7 @@ export function isPendingApproval(featureName) {
     return false;
   }
 
-  const currentPhase = feature.phase || 'proposal';
+  const currentPhase = feature.phase || 'plan';
 
   // Check if current phase has an approval gate
   const phaseGateMap = {

package/src/core/templates/template-registry.js

@@ -76,7 +76,7 @@ export function getAllTemplates(projectPath = null) {
 /**
  * Get template by ID.
  *
- * @param {string} templateId - Template identifier (e.g., 'proposal', 'spec')
+ * @param {string} templateId - Template identifier (e.g., 'plan')
  * @param {string} [projectPath] - Optional project path
  * @returns {Object|null} Template object or null if not found
  */
@@ -100,7 +100,7 @@ export function getTemplatesByCategory(category, projectPath = null) {
 /**
  * Get templates by phase.
  *
- * @param {string} phase - Phase name (e.g., 'proposal', 'design', 'implement')
+ * @param {string} phase - Phase name (e.g., 'plan', 'uiux', 'implement')
  * @param {string} [projectPath] - Optional project path
  * @returns {Array} Filtered template array
  */

package/src/core/templates/template-seed.js

@@ -0,0 +1,22 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { getTemplateById, resolveFrameworkTemplatePath } from './template-registry.js';
+
+/** The project-local override (same relative path as in the package) wins over the package copy. */
+export function templateSourcePath(templateId, cwd = process.cwd()) {
+  const template = getTemplateById(templateId);
+  const local = template ? join(cwd, '.morph', 'framework', 'templates', template.path) : null;
+  return local && existsSync(local) ? local : resolveFrameworkTemplatePath(templateId);
+}
+
+/** @returns {{ path: string, written: boolean }} `written: false` when the file already existed. */
+export function writeIfAbsent(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  try {
+    writeFileSync(path, content, { encoding: 'utf8', flag: 'wx' });
+    return { path, written: true };
+  } catch (err) {
+    if (err.code === 'EEXIST') return { path, written: false };
+    throw err;
+  }
+}

package/src/core/work-types.js

@@ -13,7 +13,7 @@
  * Fields per type:
  *   label            - Human-readable name
  *   scaffold         - Phase folders created at feature birth (subset of
- *                       0-proposal/1-design/2-plan/3-implement/4-review)
+ *                       2-plan/1-design/3-implement/4-review)
  *   skippedGates     - Gates stamped `policy:{type}`-approved at birth
  *                       instead of waiting for human approval
  *   forcedPauseGates - Gates that ALWAYS pause for a human, regardless of
@@ -27,29 +27,29 @@ export const POLICY_APPROVER_PREFIX = 'policy:';
 export const WORK_TYPES = {
   feature: {
     label: 'Feature',
-    scaffold: ['0-proposal'],
+    scaffold: ['2-plan'],
     skippedGates: [],
     forcedPauseGates: [],
-    entrySkill: 'morph-proposal',
+    entrySkill: 'morph-plan',
   },
   bug: {
     label: 'Bug fix',
-    scaffold: ['0-proposal'],
+    scaffold: ['2-plan'],
     skippedGates: [],
     forcedPauseGates: [],
-    entrySkill: 'morph-proposal',
+    entrySkill: 'morph-plan',
   },
   chore: {
     label: 'Chore',
-    scaffold: ['0-proposal', '2-plan', '3-implement'],
-    skippedGates: ['proposal', 'plan'],
+    scaffold: ['2-plan', '3-implement'],
+    skippedGates: ['plan'],
     forcedPauseGates: [],
-    entrySkill: 'morph-proposal',
+    entrySkill: 'morph-plan',
   },
   hotfix: {
     label: 'Hotfix',
-    scaffold: ['0-proposal', '2-plan', '3-implement'],
-    skippedGates: ['proposal', 'plan'],
+    scaffold: ['2-plan', '3-implement'],
+    skippedGates: ['plan'],
     forcedPauseGates: ['review'],
     entrySkill: 'morph-hotfix',
   },

package/src/dashboard/app/App.jsx

@@ -14,7 +14,6 @@ import SkillsLibrary from './pages/SkillsLibrary.jsx';
 import RulesMap from './pages/RulesMap.jsx';
 import Standards from './pages/Standards.jsx';
 import Guide from './pages/Guide.jsx';
-import Rubrics from './pages/Rubrics.jsx';
 import { useNow } from './hooks/usePref.js';
 import { useProjects, useCurrentProject, projectHref } from './lib/project.js';
 
@@ -77,7 +76,6 @@ export default function App() {
             <Route path="/p/:project/activity" element={<Activity />} />
             <Route path="/guide" element={<Guide />} />
             <Route path="/guide/:doc" element={<Guide />} />
-            <Route path="/rubrics" element={<Rubrics />} />
             <Route path="/agents" element={<AgentMap />} />
             <Route path="/phases" element={<PhasePipeline />} />
             <Route path="/hooks" element={<HookInspector />} />

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

@@ -1,7 +1,7 @@
 import { useEffect, useState } from 'react';
 import { Link } from 'react-router-dom';
 import {
-  ChatCircleText, Question, BookOpenText, PaperPlaneTilt, ArrowBendDownLeft, CheckSquare, ShieldCheck, Flag, WarningOctagon,
+  ChatCircleText, Question, BookOpenText, PaperPlaneTilt, ArrowBendDownLeft, ShieldCheck, Flag, WarningOctagon,
   PencilSimpleLine, Eye, TerminalWindow, Wrench,
 } from '@phosphor-icons/react';
 import { useMorphQuery } from '../hooks/useMorphQuery.js';
@@ -16,7 +16,6 @@ export const KIND_META = {
   skill: { label: 'Skills', icon: BookOpenText },
   dispatch: { label: 'Despachos', icon: PaperPlaneTilt },
   handback: { label: 'Retornos', icon: ArrowBendDownLeft },
-  task: { label: 'Tasks', icon: CheckSquare },
   verify: { label: 'Verify', icon: ShieldCheck },
   gate: { label: 'Gates', icon: Flag },
   failure: { label: 'Falhas', icon: WarningOctagon },
@@ -25,7 +24,7 @@ export const KIND_META = {
   command: { label: 'Comandos', icon: TerminalWindow },
   tool: { label: 'Outras tools', icon: Wrench },
 };
-const DEFAULT = ['prompt', 'question', 'skill', 'dispatch', 'handback', 'task', 'verify', 'gate', 'failure'];
+const DEFAULT = ['prompt', 'question', 'skill', 'dispatch', 'handback', 'verify', 'gate', 'failure'];
 
 const NODE_TONE = { pass: 'text-[var(--color-ok)]', fail: 'text-[var(--color-bad)]', skip: 'text-[var(--color-faint)]' };
 

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

@@ -8,13 +8,13 @@ import { useMorphQuery } from '../hooks/useMorphQuery.js';
 import { apiBase, projectHref, featureHref } from '../lib/project.js';
 
 const KIND_LABEL = {
-  page: 'Página', project: 'Projeto', feature: 'Feature', task: 'Task', skill: 'Skill', persona: 'Persona',
-  standard: 'Standard', rule: 'Rule', hook: 'Hook', guide: 'Guia', rubric: 'Rubrica',
+  page: 'Página', project: 'Projeto', feature: 'Feature', slice: 'Fatia', skill: 'Skill', persona: 'Persona',
+  standard: 'Standard', rule: 'Rule', hook: 'Hook', guide: 'Guia',
 };
 
 const PAGES = [
   ['Portfólio', '/'], ['Guia', '/guide'], ['Fases', '/phases'], ['Skills', '/skills'],
-  ['Personas', '/agents'], ['Standards', '/standards'], ['Rules', '/rules'], ['Hooks', '/hooks'], ['Rubricas', '/rubrics'],
+  ['Personas', '/agents'], ['Standards', '/standards'], ['Rules', '/rules'], ['Hooks', '/hooks'],
 ];
 
 /** Everything the framework knows that has a page — built once. */
@@ -35,7 +35,6 @@ function knowledgeIndex() {
       out.push({ kind: 'guide', title: h.text, hint: d.title, to: `/guide/${d.id}#${h.slug}`, hay: `${h.text} ${d.title}` });
     }
   }
-  for (const r of morphData.docs?.rubrics || []) out.push({ kind: 'rubric', title: r.title, to: `/rubrics?sel=${encodeURIComponent(`dim:${r.id}`)}`, hay: r.title });
   return out;
 }
 
@@ -44,7 +43,7 @@ function projectIndex(portfolio) {
 }
 
 /**
- * Features and their tasks. `projectName` is set for another project's
+ * Features and their slices. `projectName` is set for another project's
  * features, so a hit says where it lives.
  */
 function featureIndex(project, features, projectName = null) {
@@ -52,8 +51,8 @@ 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 t of f.taskIndex || []) {
-      out.push({ kind: 'task', title: `${t.id} ${t.title}`, hint: where(f.name), to: featureHref(project, f.name, '?tab=tasks'), hay: `${t.id} ${t.title} ${f.name} ${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;
@@ -120,7 +119,7 @@ export default function CommandPalette({ open, onClose, portfolio, project }) {
               value={query}
               onChange={(e) => setQuery(e.target.value)}
               onKeyDown={onKey}
-              placeholder="Buscar features, tasks, skills, personas, standards, seções do guia…"
+              placeholder="Buscar features, fatias, 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/EntityLink.jsx

@@ -16,12 +16,11 @@ export function entityHref(kind, id) {
     case 'hook': return q('hooks');
     case 'phase': return q('phases');
     case 'guide': return `/guide/${encodeURIComponent(id)}`;
-    case 'rubric': return q('rubrics');
     default: return '#';
   }
 }
 
-/** `standards/backend/dotnet/testing.md` (as tasks.json cites it) → the registry `path`. */
+// `standards/backend/dotnet/testing.md` (as a plan may cite it) → the registry `path`.
 export function standardKey(ref) {
   return String(ref).replace(/^\.?\/?(\.morph\/framework\/)?standards\//, '');
 }

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

@@ -7,7 +7,7 @@ const REMARK = [remarkGfm];
 const REHYPE = [rehypeSlug];
 
 /** Frontmatter keys worth showing, in the order a reader wants them. */
-const META_ORDER = ['name', 'description', 'when-to-invoke', 'user-invokable', 'stacks', 'version', 'cliVersion'];
+const META_ORDER = ['name', 'description', 'when_to_use', 'user-invocable', 'stacks', 'version', 'cliVersion'];
 
 function MetaBlock({ meta }) {
   const keys = Object.keys(meta).sort((a, b) => {

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

@@ -1,6 +1,6 @@
 import { NavLink, useLocation, useNavigate } from 'react-router-dom';
 import {
-  MagnifyingGlass, SquaresFour, Kanban, Pulse, BookOpen, FlowArrow, PuzzlePiece, UsersThree, Books, Ruler, Plug, Scales,
+  MagnifyingGlass, SquaresFour, Kanban, Pulse, BookOpen, FlowArrow, PuzzlePiece, UsersThree, Books, Ruler, Plug,
 } from '@phosphor-icons/react';
 import { projectHref } from '../lib/project.js';
 
@@ -12,7 +12,6 @@ const KNOWLEDGE = [
   { to: '/standards', label: 'Standards', icon: Books },
   { to: '/rules', label: 'Rules', icon: Ruler },
   { to: '/hooks', label: 'Hooks', icon: Plug },
-  { to: '/rubrics', label: 'Rubricas', icon: Scales },
 ];
 
 function Badge({ pulse }) {

package/src/dashboard/app/hooks/useMorphQuery.js

@@ -5,7 +5,7 @@ import { useEffect, useRef, useState } from 'react';
  * reports that the project's `.morph/` changed in the given scope.
  *
  * `scope` matches the server's invalidation: 'features' (feature.json,
- * tasks.json, artifacts) or 'activity' (events.jsonl). A refetch keeps the old
+ * slice reports, artifacts) or 'activity' (events.jsonl). A refetch keeps the old
  * data on screen until the new one arrives — no flash of "loading" while an
  * agent is working.
  *

package/src/dashboard/app/lib/phases.js

@@ -6,9 +6,8 @@
 import morphData from 'virtual:morph-data';
 
 const LABELS = {
-  proposal: 'Proposta',
-  uiux: 'UI/UX',
   plan: 'Plano',
+  uiux: 'UI/UX',
   implement: 'Implementação',
   review: 'Revisão',
 };
@@ -29,9 +28,8 @@ export function phaseMeta(id) {
 }
 
 export const GATE_LABEL = {
-  proposal: 'Gate 1 (proposta)',
+  plan: 'Gate do plano',
   uiux: 'Gate UI/UX',
-  plan: 'Gate 2 (plano)',
   review: 'Gate 3 (revisão)',
 };
 

package/src/dashboard/app/pages/Activity.jsx

@@ -13,7 +13,7 @@ export default function Activity() {
         <h1 className="mt-1 text-4xl font-semibold tracking-tight">Atividade</h1>
         <p className="mt-3 max-w-2xl text-sm leading-relaxed text-[var(--color-dim)]">
           O que o Claude fez no projeto, contado a partir da telemetria dos hooks: suas mensagens, as skills carregadas,
-          os sub-agents despachados, as tasks, os verifies e os gates. Atualiza sozinho enquanto ele trabalha.
+          os sub-agents despachados, os verifies e os gates. Atualiza sozinho enquanto ele trabalha.
         </p>
       </header>
       <div className="rise-2 bezel">