@polymorphism-tech/morph-spec 4.11.1 → 4.13.0

package/framework/hooks/claude-code/session-start/inject-morph-context.js

@@ -11,17 +11,17 @@
  * Fail-open: exits 0 on any error.
  */
 
-import { loadState, getActiveFeature, getPendingGates, getMissingOutputs, derivePhaseForFeature } from '../../shared/state-reader.js';
+import { loadState, getActiveFeature, getPendingGates, getMissingOutputs, derivePhaseForFeature, getTaskStats } from '../../shared/state-reader.js';
 import { stateExists } from '../../shared/state-reader.js';
 import { injectContext, pass } from '../../shared/hook-response.js';
 import { resetActivity, logHookActivity } from '../../shared/activity-logger.js';
-import { readFileSync, existsSync, writeFileSync, renameSync, unlinkSync } from 'fs';
+import { readFileSync, existsSync, writeFileSync, renameSync, unlinkSync, statSync } from 'fs';
 import { join } from 'path';
 import { resetStaleTasks } from '../../shared/stale-task-reset.js';
 import { execSync as _execSync } from 'child_process';
 import { parseWorktreeResult, buildWorktreeContextLine, buildWorktreeResumeContext } from '../../shared/worktree-helpers.js';
 
-const DEFAULT_SPEC_MAX_CHARS = 3000;
+const DEFAULT_SPEC_MAX_CHARS = 6000;
 
 function getSpecMaxChars() {
   try {
@@ -90,6 +90,29 @@ try {
   // ────────────────────────────────────────────────────────────────────────────
 
   const lines = ['MORPH-SPEC Status:'];
+
+  // ── Context freshness check ─────────────────────────────────────────────
+  // If .morph/context/README.md is missing or older than 24h, suggest refresh.
+  try {
+    const contextReadmePath = join(process.cwd(), '.morph/context/README.md');
+    let contextStale = false;
+    if (!existsSync(contextReadmePath)) {
+      contextStale = true;
+    } else {
+      const stat = statSync(contextReadmePath);
+      const ageMs = Date.now() - stat.mtimeMs;
+      const TWENTY_FOUR_HOURS = 24 * 60 * 60 * 1000;
+      contextStale = ageMs > TWENTY_FOUR_HOURS;
+    }
+    if (contextStale) {
+      lines.push('');
+      lines.push('⚠ Architecture context is stale or missing. Run: morph-spec context refresh');
+    }
+  } catch {
+    // Fail-open — context freshness check must never block the session
+  }
+  // ────────────────────────────────────────────────────────────────────────
+
   if (staleResetLog.length > 0) {
     lines.push(`⚠️  ${staleResetLog.length} task(s) auto-reset in_progress → pending (orphaned from previous session): ${staleResetLog.join(', ')}`);
   }
@@ -100,9 +123,10 @@ try {
     lines.push(`- Active feature: ${name} (phase: ${phase}, workflow: ${feature.workflow || 'auto'})`);
     lines.push(`- Status: ${feature.status}`);
 
-    // Task progress
-    if (feature.tasks) {
-      lines.push(`- Tasks: ${feature.tasks.completed || 0}/${feature.tasks.total || 0} completed`);
+    // Task progress (read directly from taskList)
+    const stats = getTaskStats(feature);
+    if (stats.total > 0) {
+      lines.push(`- Tasks: ${stats.completed}/${stats.total} completed`);
     }
 
     // Pending approvals
@@ -124,16 +148,8 @@ try {
       lines.push(`- Last checkpoint: #${lastCp.checkpointNum} (${lastCp.passed ? 'passed' : 'failed'})`);
     }
 
-    // Task tracking guidance for work phases
-    if (['proposal', 'setup', 'uiux', 'design', 'clarify', 'plan', 'tasks', 'implement'].includes(phase)) {
-      lines.push('');
-      lines.push('⚠️  MANDATORY: Create session tasks (TaskCreate) BEFORE starting phase work.');
-      lines.push('   Analyze the phase workflow and create tasks reflecting your planned actions.');
-      lines.push('   Mark each in_progress → completed as you go. See phase skill for guidance.');
-    }
-
     // Trust level visibility — warn when low trust may block approval gates
-    const APPROVAL_GATE_PHASES = new Set(['proposal', 'setup', 'design', 'tasks']);
+    const APPROVAL_GATE_PHASES = new Set(['proposal', 'design', 'tasks']);
     if (APPROVAL_GATE_PHASES.has(phase)) {
       const config = getProjectConfig();
       const trustLevel = config?.trust?.level || config?.trustLevel || 'low';
@@ -150,15 +166,15 @@ try {
     }
 
     // Active feature spec (truncated for context budget)
-    const specPath = join(process.cwd(), `.morph/features/${name}/1-design/spec.md`);
+    const specPath = join(process.cwd(), `.morph/features/${name}/2-design/spec.md`);
     if (existsSync(specPath)) {
       try {
         const specContent = readFileSync(specPath, 'utf-8');
         const truncated = specContent.length > SPEC_MAX_CHARS
-          ? specContent.slice(0, SPEC_MAX_CHARS) + `\n\n[... spec truncated — full file at .morph/features/${name}/1-design/spec.md]`
+          ? specContent.slice(0, SPEC_MAX_CHARS) + `\n\n[... spec truncated — full file at .morph/features/${name}/2-design/spec.md]`
           : specContent;
         lines.push('');
-        lines.push(`--- Active feature spec (${name}/1-design/spec.md) ---`);
+        lines.push(`--- Active feature spec (${name}/2-design/spec.md) ---`);
         lines.push(truncated);
         lines.push('--- End spec ---');
       } catch {
@@ -249,20 +265,37 @@ try {
   }
   // ────────────────────────────────────────────────────────────────────────────
 
-  // Remind about key commands
-  lines.push('');
-  lines.push('Key commands: morph-spec status <feature> | morph-spec phase advance <feature> | morph-spec approve <feature> <gate>');
+  // ── CLI availability detection ─────────────────────────────────────────────
+  // Check which development CLIs are available for the current phase.
+  // Uses execSync with short timeout — fail-open on any error.
+  try {
+    const currentPhaseForCli = active ? derivePhaseForFeature(active.name) : '';
+    if (currentPhaseForCli) {
+      const cliChecks = [
+        { name: 'docker', cmd: 'docker --version', phases: ['design', 'implement'] },
+        { name: 'supabase', cmd: 'npx supabase --version', phases: ['design', 'implement'] },
+        { name: 'psql', cmd: 'psql --version', phases: ['design', 'implement'] },
+        { name: 'az', cmd: 'az version --output none', phases: ['implement'] },
+        { name: 'gh', cmd: 'gh --version', phases: ['design', 'tasks', 'implement'] },
+      ];
 
-  // System Map — compact summary for sessions without a live monitor terminal
-  if (active) {
-    const { name } = active;
-    const sysPhase = derivePhaseForFeature(name);
-    lines.push('');
-    lines.push('── MORPH SYSTEM MAP ─────────────────────────────────────────────');
-    lines.push(`🪝 Hooks: 10 registrados  |  📏 Rules: em .claude/rules/  |  🎯 Skills: em .claude/skills/`);
-    lines.push(`   Use \`morph-spec doctor\` para health check  |  \`morph-spec status ${name}\` para dashboard`);
-    lines.push('─────────────────────────────────────────────────────────────────');
+      const relevant = cliChecks.filter(c => c.phases.includes(currentPhaseForCli));
+      if (relevant.length > 0) {
+        const cliStatus = relevant.map(c => {
+          try {
+            _execSync(c.cmd, { stdio: 'pipe', timeout: 5000 });
+            return `${c.name} ✓`;
+          } catch {
+            return `${c.name} ✗`;
+          }
+        });
+        lines.push(`CLIs: ${cliStatus.join(', ')}`);
+      }
+    }
+  } catch {
+    // Fail-open — CLI detection must never block the session
   }
+  // ────────────────────────────────────────────────────────────────────────────
 
   injectContext(lines.join('\n'));
 } catch {

package/framework/hooks/claude-code/session-start/resume-context.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * SessionStart Hook: Resume Context Orientation
+ *
+ * Event: SessionStart | Matcher: resume
+ *
+ * Fires ONLY when a session resumes via /resume.
+ * Injects a brief orientation message so Claude immediately knows
+ * the active feature, phase, in-progress tasks, and last checkpoint.
+ *
+ * Fail-open: exits 0 on any error.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import {
+  stateExists, getActiveFeature, derivePhaseForFeature,
+} from '../../shared/state-reader.js';
+import { injectContext, pass } from '../../shared/hook-response.js';
+import { logHookActivity } from '../../shared/activity-logger.js';
+import { SPEC_SUMMARY_MAX_CHARS } from '../../shared/compact-restore.js';
+
+try {
+  if (!stateExists()) pass();
+
+  const active = getActiveFeature();
+  if (!active) pass();
+
+  const { name, feature } = active;
+  const phase = derivePhaseForFeature(name);
+  const cwd = process.cwd();
+
+  const lines = [
+    `🔄 RESUME — Você está continuando a feature "${name}" na fase ${phase}.`,
+  ];
+
+  // In-progress tasks
+  const taskList = Array.isArray(feature.taskList) ? feature.taskList : [];
+  const inProg = taskList.filter(t => t.status === 'in_progress');
+  if (inProg.length > 0) {
+    const ids = inProg.map(t => t.id).join(', ');
+    lines.push(`Tasks em progresso: ${ids}`);
+  }
+
+  // Task progress summary
+  const tasks = feature.tasks || {};
+  if (tasks.total > 0) {
+    lines.push(`Progresso: ${tasks.completed || 0}/${tasks.total} tasks concluídas`);
+  }
+
+  // Last checkpoint
+  const checkpoints = Array.isArray(feature.checkpoints) ? feature.checkpoints : [];
+  if (checkpoints.length > 0) {
+    const last = checkpoints[checkpoints.length - 1];
+    lines.push(`Último checkpoint: #${last.checkpointNum} (${last.passed ? 'passed' : 'failed'})`);
+  }
+
+  // Spec summary (truncated)
+  const specPath = join(cwd, `.morph/features/${name}/2-design/spec.md`);
+  if (existsSync(specPath)) {
+    try {
+      const raw = readFileSync(specPath, 'utf-8');
+      const summary = raw.length > SPEC_SUMMARY_MAX_CHARS
+        ? raw.slice(0, SPEC_SUMMARY_MAX_CHARS) + '\n[... truncated]'
+        : raw;
+      lines.push('');
+      lines.push('Spec summary:');
+      lines.push(summary);
+    } catch { /* non-blocking */ }
+  }
+
+  logHookActivity('resume-context', 'SessionStart', 'resume_injected');
+  injectContext(lines.join('\n'));
+} catch {
+  process.exit(0);
+}

package/framework/hooks/claude-code/statusline.py

@@ -37,19 +37,18 @@ _CREATE_NO_WINDOW = 0x08000000 if os.name == 'nt' else 0
 # ── MORPH framework constants (derived from phases.json / trust-manager.js) ──
 
 PHASE_POSITIONS = {
-    'proposal': 1, 'setup': 1,
+    'proposal': 1,
     'uiux': 2, 'design': 2,
-    'clarify': 3,
+    'plan': 3,
     'tasks': 4,
     'implement': 5, 'sync': 5,
 }
 PHASE_LABELS = {
     'proposal': 'proposal',
-    'setup': 'setup',
     'uiux': 'UI/UX',
     'design': 'design',
-    'clarify': 'refinement',
-    'tasks': 'planning',
+    'plan': 'planning',
+    'tasks': 'tasks',
     'implement': 'implement',
     'sync': 'sync',
 }

package/framework/hooks/claude-code/stop/validate-completion.js

@@ -30,7 +30,7 @@ import { logHookActivity } from '../../shared/activity-logger.js';
 const COMPACT_TRIGGER_PHASES = new Set(['implement']);
 
 // Phases where compaction is suggested when arriving from a heavy spec phase
-const HEAVY_SOURCE_PHASES = new Set(['tasks', 'design', 'clarify', 'uiux']);
+const HEAVY_SOURCE_PHASES = new Set(['tasks', 'design', 'uiux']);
 
 try {
   // Prevent infinite loop
@@ -78,7 +78,7 @@ try {
       `   loaded during planning take significant space. A compact now gives`,
       `   Claude a clean slate focused on writing code.`,
       ``,
-      `   After /compact, resume with: morph-spec task next ${name}`,
+      `   After /compact, resume with: morph-spec task start ${name} <next-task-id>`,
     );
   }
 
@@ -96,7 +96,7 @@ try {
   }
 
   // Missing outputs in spec phases
-  if (['proposal', 'design', 'clarify', 'tasks', 'uiux'].includes(currentPhase)) {
+  if (['proposal', 'design', 'tasks', 'uiux'].includes(currentPhase)) {
     const missing = getMissingOutputs(name);
     if (missing.length > 0) {
       warnings.push(`Missing outputs for '${name}' (${currentPhase} phase):`);
@@ -124,7 +124,7 @@ try {
   }
 
   // ── MEMORY.md reminder ────────────────────────────────────────────────────
-  const WORK_PHASES = new Set(['design', 'clarify', 'tasks', 'implement']);
+  const WORK_PHASES = new Set(['design', 'tasks', 'implement']);
   const memoryLines = [];
   if (WORK_PHASES.has(currentPhase)) {
     memoryLines.push('📝 Sessão encerrando. Considere salvar no MEMORY.md:');

package/framework/hooks/claude-code/user-prompt/enrich-prompt.js

@@ -39,8 +39,11 @@ try {
     if (promptLower.includes(featureName.toLowerCase())) {
       const featurePhase = feature.phase || derivePhaseForFeature(featureName);
       context.push(`[morph-spec] Feature '${featureName}': phase=${featurePhase}, status=${feature.status}`);
-      if (feature.tasks?.total > 0) {
-        context.push(`  Tasks: ${feature.tasks.completed || 0}/${feature.tasks.total} completed`);
+      const taskList = feature.taskList || [];
+      const activeTasks = taskList.filter(t => t.status !== 'expanded');
+      if (activeTasks.length > 0) {
+        const completed = activeTasks.filter(t => t.status === 'completed').length;
+        context.push(`  Tasks: ${completed}/${activeTasks.length} completed`);
       }
       break; // Only inject for the first matched feature
     }
@@ -64,15 +67,12 @@ try {
 
     // Coding intent during implement phase but no task in_progress
     if (wantsToCode && activePhase === 'implement') {
-      let hasActiveTask = feature.tasks?.inProgress > 0;
-      if (!hasActiveTask && feature.taskList) {
-        hasActiveTask = feature.taskList.some(t => t.status === 'in_progress');
-      }
+      const hasActiveTask = feature.taskList?.some(t => t.status === 'in_progress') ||
+        feature.tasks?.inProgress > 0; // fallback for legacy state
       if (!hasActiveTask) {
         context.push(
           `[morph-spec] REMINDER: No task is currently in_progress for '${name}'.` +
           ` Start a task before coding:\n` +
-          `  morph-spec task next ${name}        # see what's next\n` +
           `  morph-spec task start ${name} <id>   # mark it in progress`
         );
       }
@@ -95,7 +95,7 @@ try {
     if (promptLower.includes('next task') || promptLower.includes('what\'s next')) {
       if (activePhase === 'implement') {
         context.push(
-          `[morph-spec] Use: morph-spec task next ${name}`
+          `[morph-spec] Check tasks.md for the next task, then: morph-spec task start ${name} <id>`
         );
       }
     }

package/framework/hooks/shared/compact-restore.js

@@ -8,17 +8,19 @@
  * Pure functions — no I/O.
  */
 
-export const DECISIONS_MAX_CHARS = 1500;
-export const MAX_PENDING_TASKS   = 8;
+export const DECISIONS_MAX_CHARS     = 3000;
+export const MAX_PENDING_TASKS       = 8;
+export const SPEC_SUMMARY_MAX_CHARS  = 3000;
 
 /**
  * Build the richContext object to embed in pre-compact memory file.
- * @param {Object} feature          - Feature state object (tasks, taskList)
+ * @param {Object} feature          - Feature state object (tasks, taskList, checkpoints)
  * @param {string} phase            - Current derived phase string
  * @param {string} decisionsContent - Raw text of decisions.md (may be empty string)
+ * @param {string} [specContent=''] - Raw text of spec.md (may be empty string)
  * @returns {Object} richContext
  */
-export function buildRichContext(feature, phase, decisionsContent) {
+export function buildRichContext(feature, phase, decisionsContent, specContent = '') {
   const taskList = Array.isArray(feature.taskList) ? feature.taskList : [];
 
   const inProgress = taskList
@@ -34,12 +36,23 @@ export function buildRichContext(feature, phase, decisionsContent) {
     ? decisionsContent.slice(0, DECISIONS_MAX_CHARS)
     : decisionsContent;
 
+  const specSummary = specContent.length > SPEC_SUMMARY_MAX_CHARS
+    ? specContent.slice(0, SPEC_SUMMARY_MAX_CHARS)
+    : specContent;
+
+  const checkpoints = Array.isArray(feature.checkpoints) ? feature.checkpoints : [];
+  const lastCheckpoint = checkpoints.length > 0
+    ? { passed: checkpoints[checkpoints.length - 1].passed, checkpointNum: checkpoints[checkpoints.length - 1].checkpointNum }
+    : null;
+
   return {
     phase,
     tasks:            feature.tasks || {},
     decisionsSnippet,
     inProgress,
     nextPending,
+    specSummary,
+    lastCheckpoint,
   };
 }
 
@@ -53,7 +66,7 @@ export function buildRestoreBlock(memorySnapshot) {
   if (!rc) return null;
 
   const { timestamp, activeFeature } = memorySnapshot;
-  const { phase, tasks, decisionsSnippet, inProgress, nextPending } = rc;
+  const { phase, tasks, decisionsSnippet, inProgress, nextPending, specSummary, lastCheckpoint } = rc;
 
   const done  = tasks?.completed ?? '?';
   const total = tasks?.total     ?? '?';
@@ -63,6 +76,16 @@ export function buildRestoreBlock(memorySnapshot) {
     `Active feature: ${activeFeature} | Phase: ${phase} | Tasks: ${done}/${total}`,
   ];
 
+  if (lastCheckpoint) {
+    lines.push(`Last checkpoint: #${lastCheckpoint.checkpointNum} (${lastCheckpoint.passed ? 'passed' : 'failed'})`);
+  }
+
+  if (specSummary) {
+    lines.push('');
+    lines.push('Spec summary (at time of compact):');
+    lines.push(specSummary);
+  }
+
   if (decisionsSnippet) {
     lines.push('');
     lines.push('Key decisions (at time of compact):');

package/framework/hooks/shared/dispatch-helpers.js

@@ -112,6 +112,23 @@ export function parseDispatchAgentsCommand(command) {
   return { featureName: match[1], phase: match[2] };
 }
 
+/**
+ * Convert a subagent_type string back to a morph agent ID.
+ * Reverses the mapping used when dispatching agents as subagents.
+ *
+ * Example: 'morph-nextjs-expert' → 'nextjs-expert'
+ *
+ * @param {string} subagentType - The subagent_type value (e.g. 'morph-nextjs-expert')
+ * @returns {string|null} - Agent ID without 'morph-' prefix, or null if invalid
+ */
+export function subagentTypeToAgentId(subagentType) {
+  if (!subagentType || typeof subagentType !== 'string') return null;
+  if (!subagentType.startsWith('morph-')) return null;
+  const agentId = subagentType.slice('morph-'.length);
+  if (!agentId) return null;
+  return agentId;
+}
+
 /**
  * Extract the tool result string from a PostToolUse hook payload.
  * Handles multiple possible formats.

package/framework/hooks/shared/phase-utils.js

@@ -8,15 +8,13 @@
  */
 
 /** Phase order */
-export const PHASE_ORDER = ["proposal","setup","uiux","design","clarify","plan","tasks","implement","sync"];
+export const PHASE_ORDER = ["proposal","uiux","design","plan","tasks","implement","sync"];
 
 /** Map phase → allowed output subdirectory */
 export const PHASE_DIRS = {
   proposal: '0-proposal',
-  setup: '0-proposal',
-  uiux: '2-ui',
-  design: '1-design',
-  clarify: '1-design',
+  uiux: '1-ui',
+  design: '2-design',
   plan: '3-plan',
   tasks: '4-tasks',
   implement: '5-implement',
@@ -28,7 +26,6 @@ export const OUTPUT_PHASE_MAP = {
   proposal: 'proposal',
   schemaAnalysis: 'design',
   spec: 'design',
-  clarifications: 'clarify',
   contracts: 'design',
   contractsTs: 'design',
   contractsVsa: 'design',
@@ -47,7 +44,6 @@ export const FILENAME_TO_OUTPUT = {
   'proposal.md': 'proposal',
   'schema-analysis.md': 'schemaAnalysis',
   'spec.md': 'spec',
-  'clarifications.md': 'clarifications',
   'contracts.cs': 'contracts',
   'contracts.ts': 'contractsTs',
   'contracts-vsa.cs': 'contractsVsa',
@@ -90,7 +86,7 @@ export function extractFeatureName(filePath) {
 /**
  * Extract phase subdirectory from a .morph/features/{feature}/{phaseDir}/... path
  * @param {string} filePath - File path to analyze
- * @returns {string|null} Phase directory (e.g., '0-proposal', '1-design') or null
+ * @returns {string|null} Phase directory (e.g., '0-proposal', '2-design') or null
  */
 export function extractPhaseDir(filePath) {
   const normalized = filePath.replace(/\\/g, '/');

package/framework/hooks/shared/state-reader.js

@@ -110,14 +110,14 @@ export function derivePhaseForFeature(featureName, projectPath) {
     ['5-implement', 'implement'],
     ['4-tasks', 'tasks'],
     ['3-plan', 'plan'],
-    ['2-ui', 'uiux'],
-    ['1-design', 'design'],
+    ['2-design', 'design'],
+    ['1-ui', 'uiux'],
     ['0-proposal', 'proposal'],
   ];
   for (const [folder, phase] of phaseMap) {
     if (existsSync(join(basePath, folder))) return phase;
   }
-  return 'setup';
+  return 'proposal';
 }
 
 /**
@@ -181,6 +181,37 @@ export function getOutputs(featureName, projectPath) {
  * @param {string} [projectPath]
  * @returns {Array<{type: string, path: string}>}
  */
+/**
+ * Get task statistics directly from taskList (preferred over feature.tasks counters).
+ * Excludes expanded tasks from counts, matching calculateProgress() behavior.
+ *
+ * @param {Object} feature - Feature state object
+ * @returns {{ total: number, completed: number, inProgress: number, pending: number }}
+ */
+export function getTaskStats(feature) {
+  const list = feature?.taskList || [];
+  if (list.length > 0) {
+    const active = list.filter(t => t.status !== 'expanded');
+    return {
+      total: active.length,
+      completed: active.filter(t => t.status === 'completed').length,
+      inProgress: active.filter(t => t.status === 'in_progress').length,
+      pending: active.filter(t => t.status === 'pending').length,
+    };
+  }
+  // Fallback: read from legacy counter object
+  const tasks = feature?.tasks;
+  if (tasks && typeof tasks === 'object' && !Array.isArray(tasks)) {
+    return {
+      total: tasks.total || 0,
+      completed: tasks.completed || 0,
+      inProgress: tasks.inProgress || 0,
+      pending: tasks.pending || 0,
+    };
+  }
+  return { total: 0, completed: 0, inProgress: 0, pending: 0 };
+}
+
 export function getMissingOutputs(featureName, projectPath) {
   const feature = getFeature(featureName, projectPath);
   if (!feature?.outputs) return [];

package/framework/phases.json

@@ -22,27 +22,10 @@
         { "trigger": "beforePhaseStart", "skill": "morph-brainstorming" }
       ]
     },
-    "setup": {
-      "id": "setup",
-      "index": 1,
-      "folder": null,
-      "displayName": "Setup",
-      "goals": [
-        "Load project context from .morph/context/",
-        "Activate relevant agents by tier and keyword",
-        "Confirm workflow type (fast-track / standard / full-morph)"
-      ],
-      "requiredOutputs": [],
-      "optionalOutputs": [],
-      "recommendedMCPs": ["github"],
-      "pausePoints": [],
-      "agentTiers": [1, 2],
-      "requiredSkills": []
-    },
     "uiux": {
       "id": "uiux",
-      "index": 1.5,
-      "folder": "2-ui",
+      "index": 2,
+      "folder": "1-ui",
       "displayName": "UI/UX Design",
       "optional": true,
       "goals": [
@@ -59,14 +42,13 @@
       "agentTiers": [1, 2, 3],
       "requiredSkills": [
         { "trigger": "beforeArchitecturalDecision", "skill": "morph-brainstorming" },
-        { "trigger": "onHTMLPrototypeAvailable",    "skill": "morph-replicate" },
         { "trigger": "beforePhaseComplete",         "skill": "morph-frontend-review" }
       ]
     },
     "design": {
       "id": "design",
-      "index": 2,
-      "folder": "1-design",
+      "index": 3,
+      "folder": "2-design",
       "displayName": "Technical Design",
       "goals": [
         "Write technical specification",
@@ -75,8 +57,8 @@
         "Document architectural decisions"
       ],
       "requiredOutputs": ["spec", "contracts"],
-      "optionalOutputs": ["schemaAnalysis", "clarifications", "decisions"],
-      "recommendedMCPs": ["supabase", "context7", "github"],
+      "optionalOutputs": ["schemaAnalysis", "decisions"],
+      "recommendedMCPs": ["context7", "github"],
       "pausePoints": [
         { "id": "design", "label": "Approve Design Spec" }
       ],
@@ -89,26 +71,6 @@
         { "trigger": "beforePhaseComplete",          "skill": "morph-verification-before-completion" }
       ]
     },
-    "clarify": {
-      "id": "clarify",
-      "index": 3,
-      "folder": "1-design",
-      "displayName": "Clarification",
-      "goals": [
-        "Resolve open questions and ambiguities",
-        "Update spec with clarification decisions",
-        "Confirm edge cases are handled"
-      ],
-      "requiredOutputs": ["clarifications"],
-      "optionalOutputs": [],
-      "recommendedMCPs": ["context7", "github"],
-      "pausePoints": [],
-      "agentTiers": [1, 2],
-      "requiredSkills": [
-        { "trigger": "beforePhaseStart",    "skill": "morph-phase-clarify" },
-        { "trigger": "beforePhaseComplete", "skill": "morph-verification-before-completion" }
-      ]
-    },
     "plan": {
       "id": "plan",
       "index": 5,
@@ -166,7 +128,7 @@
       ],
       "requiredOutputs": ["recap"],
       "optionalOutputs": [],
-      "recommendedMCPs": ["supabase", "context7", "playwright", "github", "vercel", "docker", "azure"],
+      "recommendedMCPs": ["context7", "playwright", "github", "vercel"],
       "pausePoints": [],
       "agentTiers": [1, 2, 3, 4],
       "requiredSkills": [

package/framework/rules/ai-agents-standards.md

@@ -0,0 +1,15 @@
+---
+paths:
+  - "**/Agents/**"
+  - "**/agents/**"
+  - "**/*Agent*.cs"
+stacks:
+  - dotnet
+---
+
+# Microsoft Agent Framework Standards
+
+@.morph/framework/standards/ai-agents/setup.md
+@.morph/framework/standards/ai-agents/workflows.md
+@.morph/framework/standards/ai-agents/production.md
+@.morph/framework/standards/integration/mcp/mcp-tools.md

package/framework/rules/asaas-standards.md

@@ -0,0 +1,13 @@
+---
+paths:
+  - "**/Payment*/**"
+  - "**/Billing/**"
+  - "**/Asaas/**"
+  - "**/Financial/**"
+stacks:
+  - dotnet
+---
+
+# Asaas Payment Integration Standards
+
+@.morph/framework/standards/backend/integrations/asaas/asaas-api.md