@polymorphism-tech/morph-spec 4.21.0 → 5.0.1

package/src/core/workflows/workflow-detector.js

@@ -9,8 +9,8 @@
  * @module workflow-detector
  */
 
-import { readFileSync, existsSync, readdirSync } from 'fs';
-import { join, dirname } from 'path';
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { getPhaseSequence } from '../state/phase-state-machine.js';
 
@@ -221,6 +221,153 @@ function matchComplexity(complexity, criteria) {
   return { matches: meetsAll, score };
 }
 
+// Directories to skip during codebase scanning
+const SCAN_SKIP_DIRS = new Set([
+  'node_modules', '.git', '.morph', 'dist', 'out', '.next',
+  'obj', 'bin', '.worktrees', '.vs', '.vscode', 'coverage'
+]);
+
+/**
+ * Quick codebase scan to estimate change complexity from actual files.
+ * Reads only filenames (not content). Capped at 2000 files.
+ *
+ * @param {string} projectPath - Project root
+ * @param {string[]} keywords - Keywords extracted from user request
+ * @returns {{ affectedFiles: number, hasSharedInfra: boolean, hasTests: boolean, score: number }}
+ */
+export function quickCodebaseScan(projectPath, keywords) {
+  if (!projectPath || projectPath === '.' || !existsSync(projectPath)) {
+    return { affectedFiles: 0, hasSharedInfra: false, hasTests: false, score: 0.5 };
+  }
+
+  const infraPatterns = ['dockerfile', 'docker-compose', '.bicep', '.tf', 'appsettings.json', 'terraform'];
+  const testPatterns = ['.test.', '.spec.', '__tests__'];
+  const keywordsLower = keywords.map(k => k.toLowerCase());
+
+  let filesExamined = 0;
+  let affectedFiles = 0;
+  let hasSharedInfra = false;
+  let hasTests = false;
+  const MAX_FILES = 2000;
+
+  function walk(dir) {
+    if (filesExamined >= MAX_FILES) return;
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      if (filesExamined >= MAX_FILES) return;
+      if (entry.isDirectory()) {
+        if (!SCAN_SKIP_DIRS.has(entry.name)) walk(join(dir, entry.name));
+        continue;
+      }
+      filesExamined++;
+      const nameLower = entry.name.toLowerCase();
+
+      if (infraPatterns.some(p => nameLower.includes(p))) hasSharedInfra = true;
+      if (testPatterns.some(p => nameLower.includes(p))) hasTests = true;
+      if (keywordsLower.some(k => k.length >= 3 && nameLower.includes(k))) affectedFiles++;
+    }
+  }
+
+  walk(projectPath);
+
+  // Score: more affected files = higher complexity
+  let score = 0.5;
+  if (affectedFiles === 0) score = 0.3;
+  else if (affectedFiles <= 3) score = 0.4;
+  else if (affectedFiles <= 8) score = 0.6;
+  else if (affectedFiles <= 15) score = 0.75;
+  else score = 0.9;
+
+  if (hasSharedInfra) score = Math.min(1, score + 0.1);
+
+  return { affectedFiles, hasSharedInfra, hasTests, score };
+}
+
+/**
+ * Find completed features similar to the current description.
+ * Uses Jaccard similarity on tokenized keywords.
+ *
+ * @param {string} userRequest - Current feature description
+ * @param {string} projectPath - Project root (for loading state)
+ * @returns {{ similarFeatures: Array<{name: string, workflow: string, similarity: number}>, suggestedWorkflow: string|null, score: number }}
+ */
+export function findSimilarFeatures(userRequest, projectPath) {
+  const neutral = { similarFeatures: [], suggestedWorkflow: null, score: 0.5 };
+
+  let state;
+  try {
+    const statePath = join(projectPath, '.morph', 'state.json');
+    if (!existsSync(statePath)) return neutral;
+    state = JSON.parse(readFileSync(statePath, 'utf8'));
+  } catch { return neutral; }
+
+  if (!state?.features) return neutral;
+
+  const requestTokens = new Set(
+    userRequest.toLowerCase().split(/[\s\-_.,;:!?]+/).filter(t => t.length >= 3)
+  );
+  if (requestTokens.size === 0) return neutral;
+
+  const candidates = [];
+
+  for (const [name, feature] of Object.entries(state.features)) {
+    if (feature.status !== 'completed') continue;
+    if (!feature.workflow || feature.workflow === 'auto') continue;
+
+    // Build token set from feature name + matched keywords
+    const featureTokens = new Set(
+      name.toLowerCase().split(/[\s\-_.,;:!?]+/).filter(t => t.length >= 3)
+    );
+    if (feature.workflowDetection?.matchedKeywords) {
+      for (const kw of feature.workflowDetection.matchedKeywords) {
+        kw.toLowerCase().split(/[\s\-_]+/).filter(t => t.length >= 3).forEach(t => featureTokens.add(t));
+      }
+    }
+
+    // Jaccard similarity
+    const intersection = [...requestTokens].filter(t => featureTokens.has(t)).length;
+    const union = new Set([...requestTokens, ...featureTokens]).size;
+    const similarity = union > 0 ? intersection / union : 0;
+
+    if (similarity > 0.3) {
+      candidates.push({ name, workflow: feature.workflow, similarity });
+    }
+  }
+
+  if (candidates.length === 0) return neutral;
+
+  candidates.sort((a, b) => b.similarity - a.similarity);
+  const top = candidates.slice(0, 3);
+
+  // Suggest the workflow used by the most similar feature
+  const suggestedWorkflow = top[0].workflow;
+
+  // Score: higher similarity = more confidence in the suggestion
+  const score = Math.min(1, top[0].similarity + 0.2);
+
+  return { similarFeatures: top, suggestedWorkflow, score };
+}
+
+/**
+ * Score based on description length and structure.
+ * Short descriptions suggest simple tasks, long ones suggest complex.
+ *
+ * @param {string} userRequest
+ * @returns {number} 0-1 score where higher = more complex
+ */
+export function scoreDescriptionLength(userRequest) {
+  const len = userRequest.trim().length;
+  const sentences = userRequest.split(/[.!?]+/).filter(s => s.trim().length > 0).length;
+
+  if (len < 30) return 0.2;
+  if (len < 80) return 0.35;
+  if (len < 150) return 0.5;
+  if (len < 300 && sentences <= 3) return 0.65;
+  return 0.8;
+}
+
 /**
  * Detect workflow for a feature request
  * @param {Object} options - Detection options
@@ -254,6 +401,14 @@ export async function detectWorkflow(options) {
   // Estimate complexity
   const complexity = estimateComplexity(userRequest);
 
+  // New signals: codebase scan + feature history + description length
+  const codebaseScan = quickCodebaseScan(projectPath, complexity.hasInfra
+    ? [...userRequest.toLowerCase().split(/\s+/).filter(w => w.length >= 3)]
+    : userRequest.toLowerCase().split(/\s+/).filter(w => w.length >= 3)
+  );
+  const featureHistory = findSimilarFeatures(userRequest, projectPath);
+  const descriptionScore = scoreDescriptionLength(userRequest);
+
   // Score each workflow
   const scores = [];
 
@@ -261,30 +416,53 @@ export async function detectWorkflow(options) {
     const keywordMatch = matchKeywords(userRequest, workflow.keywords || []);
     const complexityMatch = matchComplexity(complexity, workflow.criteria || {});
 
-    // Weighted scoring
-    const keywordWeight = 0.4;
-    const complexityWeight = 0.3;
-    const priorityWeight = 0.2;
-    const contextWeight = 0.1;
+    // Enhanced weighted scoring (6 signals)
+    const weights = {
+      keywords: 0.25,
+      complexity: 0.20,
+      codebaseAnalysis: 0.20,
+      featureHistory: 0.15,
+      priority: 0.10,
+      descriptionLength: 0.10,
+    };
 
     // Priority score (lower number = higher priority = higher score)
     const priorityScore = workflow.priority ? (4 - workflow.priority) / 3 : 0.5;
 
-    // Context score (checks for special conditions)
-    let contextScore = 0.5;
-    if (workflow.criteria?.hasPrototype && (userRequest.toLowerCase().includes('prototype') || userRequest.toLowerCase().includes('mockup'))) {
-      contextScore = 1.0;
+    // Codebase analysis score: align scan results with workflow expectations
+    let codebaseScore = codebaseScan.score;
+    if (workflow.criteria?.noInfrastructure && codebaseScan.hasSharedInfra) {
+      codebaseScore *= 0.5; // Penalize simple workflows when infra detected
+    }
+    if (workflow.criteria?.minFiles && codebaseScan.affectedFiles >= workflow.criteria.minFiles) {
+      codebaseScore = Math.min(1, codebaseScore + 0.2);
+    }
+
+    // Feature history score: boost if similar features used this workflow
+    let historyScore = featureHistory.score;
+    if (featureHistory.suggestedWorkflow === workflow.id) {
+      historyScore = Math.min(1, historyScore + 0.3);
+    } else if (featureHistory.suggestedWorkflow && featureHistory.suggestedWorkflow !== workflow.id) {
+      historyScore *= 0.6;
+    }
+
+    // Description length score: align with workflow complexity expectations
+    let descScore = descriptionScore;
+    if (workflow.priority === 1 && descriptionScore > 0.6) {
+      descScore *= 0.7; // Long descriptions less likely to be fast-track
     }
-    if (workflow.criteria?.hasExistingPages && userRequest.toLowerCase().includes('existing')) {
-      contextScore = 1.0;
+    if (workflow.priority === 3 && descriptionScore < 0.4) {
+      descScore *= 0.7; // Short descriptions less likely to be full
     }
 
     // Calculate total score
     let totalScore =
-      (keywordMatch.score * keywordWeight) +
-      (complexityMatch.score * complexityWeight) +
-      (priorityScore * priorityWeight) +
-      (contextScore * contextWeight);
+      (keywordMatch.score * weights.keywords) +
+      (complexityMatch.score * weights.complexity) +
+      (codebaseScore * weights.codebaseAnalysis) +
+      (historyScore * weights.featureHistory) +
+      (priorityScore * weights.priority) +
+      (descScore * weights.descriptionLength);
 
     // Penalty for workflows with no keyword matches
     if (keywordMatch.matched.length === 0) {
@@ -335,13 +513,26 @@ export async function detectWorkflow(options) {
       reason: `${w.workflowName} (${Math.round(w.score * 100)}% match)`
     }));
 
+  // Warnings for low confidence or ambiguous results
+  const warnings = [];
+  if (confidence < 0.4) {
+    warnings.push('Low confidence — consider specifying workflow explicitly with --workflow');
+  }
+  if (alternatives.length > 0 && alternatives[0].confidence > confidence * 0.8) {
+    warnings.push(`Close alternative: ${alternatives[0].workflowId} (${Math.round(alternatives[0].confidence * 100)}%) — verify recommendation`);
+  }
+  if (featureHistory.similarFeatures.length > 0 && featureHistory.suggestedWorkflow !== topResult.workflowId) {
+    warnings.push(`Similar features used ${featureHistory.suggestedWorkflow} workflow`);
+  }
+
   return {
     workflowId: topResult.workflowId,
     confidence,
     matchedKeywords: topResult.keywordMatch,
     estimatedComplexity: complexity,
     reasoning: reasoning.join(' + '),
-    alternativeWorkflows: alternatives
+    alternativeWorkflows: alternatives,
+    warnings
   };
 }
 
@@ -387,17 +578,9 @@ export function listWorkflows(projectPath = '.') {
  * @param {string} feature
  * @returns {Promise<boolean>}
  */
-export async function checkZeroTouchEligibility(feature) {
-  try {
-    const { getTrust } = await import('../../lib/trust/trust-manager.js').catch(() => ({
-      getTrust: null
-    }));
-
-    if (!getTrust) return false;
-
-    const trust = getTrust(feature);
-    return trust.level === 'auto';
-  } catch {
-    return false;
-  }
+export async function checkZeroTouchEligibility(/* feature */) {
+  // v5: trust manager removed. The autonomy contract (MORPH.md) replaces it —
+  // Claude advances autonomously between gates. Returning false keeps any
+  // legacy callers happy without granting unintended privileges.
+  return false;
 }

package/src/core/workflows/workflow-router.js

@@ -0,0 +1,204 @@
+/**
+ * @fileoverview Natural Language Workflow Router
+ *
+ * Classifies free-text input into morph-spec intents and routes to the
+ * appropriate command. Uses pattern matching for intent detection and
+ * delegates to detectWorkflow() for proposal classification.
+ *
+ * @module workflow-router
+ */
+
+import { detectWorkflow } from './workflow-detector.js';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * @typedef {Object} RoutedIntent
+ * @property {string} intent - 'proposal' | 'status' | 'approve' | 'fast-track'
+ * @property {string} command - The morph-spec command to execute
+ * @property {string[]} args - Arguments for the command
+ * @property {number} confidence - 0-1
+ * @property {string} explanation - Human-readable reason for routing decision
+ * @property {Object} [workflowDetection] - If intent is proposal/fast-track, includes detection result
+ */
+
+const INTENT_PATTERNS = [
+  // Status queries (highest priority)
+  { pattern: /^(status|progress|where\s+am\s+i)\b/i, intent: 'status', confidence: 0.9 },
+  { pattern: /what('s|\s+is)\s+(next|done|left|remaining)/i, intent: 'status', confidence: 0.85 },
+  { pattern: /what\s+tasks/i, intent: 'status', confidence: 0.85 },
+  { pattern: /tasks?\s+(left|remaining|pending|todo)/i, intent: 'status', confidence: 0.85 },
+  { pattern: /^show\s+(me\s+)?status/i, intent: 'status', confidence: 0.9 },
+
+  // Approval actions
+  { pattern: /^(approve|lgtm|looks?\s+good|ship\s+it)\b/i, intent: 'approve', confidence: 0.85 },
+
+  // Explicit simple/fix intents → fast-track proposal
+  { pattern: /^(fix|typo|rename|toggle|bump|config)\b/i, intent: 'fast-track', confidence: 0.75 },
+  { pattern: /\b(typo|spelling|label|icon|badge|tooltip|css\s+fix)\b/i, intent: 'fast-track', confidence: 0.7 },
+
+  // Everything else → proposal (further classified by detectWorkflow)
+  { pattern: /.+/, intent: 'proposal', confidence: 0.5 },
+];
+
+/**
+ * Route natural language to the best morph-spec command.
+ *
+ * @param {string} input - User's natural language description
+ * @param {Object} [options]
+ * @param {string} [options.projectPath='.'] - Project path for codebase analysis
+ * @param {string} [options.activeFeature] - Currently active feature name (for status/approve)
+ * @returns {Promise<RoutedIntent>}
+ */
+export async function routeIntent(input, options = {}) {
+  const { projectPath = '.' } = options;
+  const trimmed = (input || '').trim();
+
+  if (!trimmed) {
+    return {
+      intent: 'proposal',
+      command: 'morph-spec',
+      args: ['--help'],
+      confidence: 0,
+      explanation: 'Empty input — showing help'
+    };
+  }
+
+  // Match against patterns in order
+  let matchedIntent = null;
+  for (const { pattern, intent, confidence } of INTENT_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      matchedIntent = { intent, confidence };
+      break;
+    }
+  }
+
+  const activeFeature = options.activeFeature || findActiveFeature(projectPath);
+
+  // Route based on intent
+  switch (matchedIntent.intent) {
+    case 'status': {
+      const feature = activeFeature || '<feature>';
+      return {
+        intent: 'status',
+        command: 'morph-spec',
+        args: ['status', feature],
+        confidence: activeFeature ? matchedIntent.confidence : matchedIntent.confidence * 0.6,
+        explanation: activeFeature
+          ? `Status query for active feature "${feature}"`
+          : 'Status query — no active feature found'
+      };
+    }
+
+    case 'approve': {
+      const feature = activeFeature || '<feature>';
+      return {
+        intent: 'approve',
+        command: 'morph-spec',
+        args: ['approve', feature],
+        confidence: activeFeature ? matchedIntent.confidence : matchedIntent.confidence * 0.5,
+        explanation: activeFeature
+          ? `Approve active feature "${feature}"`
+          : 'Approve — no active feature found'
+      };
+    }
+
+    case 'fast-track': {
+      // Validate with detectWorkflow — regex might be too eager
+      const detection = await detectWorkflow({
+        userRequest: trimmed,
+        projectPath,
+      });
+
+      // If detectWorkflow disagrees, defer to it
+      if (detection.workflowId !== 'fast-track' && detection.confidence > matchedIntent.confidence) {
+        const slug = slugify(trimmed);
+        return {
+          intent: 'proposal',
+          command: 'morph-spec',
+          args: ['state', 'init', slug, '--user-request', trimmed],
+          confidence: detection.confidence,
+          explanation: `Detected as ${detection.workflowId} (${detection.reasoning})`,
+          workflowDetection: detection
+        };
+      }
+
+      const slug = slugify(trimmed);
+      return {
+        intent: 'fast-track',
+        command: 'morph-spec',
+        args: ['state', 'init', slug, '--workflow', 'fast-track', '--user-request', trimmed],
+        confidence: Math.max(matchedIntent.confidence, detection.confidence),
+        explanation: `Simple task → fast-track workflow (${detection.reasoning})`,
+        workflowDetection: detection
+      };
+    }
+
+    case 'proposal':
+    default: {
+      const detection = await detectWorkflow({
+        userRequest: trimmed,
+        projectPath,
+      });
+
+      const slug = slugify(trimmed);
+      const args = ['state', 'init', slug, '--user-request', trimmed];
+      if (detection.workflowId !== 'auto') {
+        args.push('--workflow', detection.workflowId);
+      }
+
+      return {
+        intent: 'proposal',
+        command: 'morph-spec',
+        args,
+        confidence: detection.confidence,
+        explanation: `New feature → ${detection.workflowId} workflow (${detection.reasoning})`,
+        workflowDetection: detection
+      };
+    }
+  }
+}
+
+/**
+ * Find the currently active feature from state.json.
+ * Returns the most recently updated feature.
+ *
+ * @param {string} [projectPath='.']
+ * @returns {string|null} Feature name or null
+ */
+export function findActiveFeature(projectPath = '.') {
+  try {
+    const statePath = join(projectPath, '.morph', 'state.json');
+    if (!existsSync(statePath)) return null;
+
+    const state = JSON.parse(readFileSync(statePath, 'utf8'));
+    if (!state?.features) return null;
+
+    const entries = Object.entries(state.features)
+      .sort((a, b) => {
+        const dateA = a[1].updatedAt || a[1].createdAt || '';
+        const dateB = b[1].updatedAt || b[1].createdAt || '';
+        return dateB.localeCompare(dateA);
+      });
+
+    return entries.length > 0 ? entries[0][0] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Convert a description into a feature slug.
+ * @param {string} text
+ * @returns {string}
+ */
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .trim()
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .slice(0, 50)
+    .replace(/-$/, '');
+}

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

@@ -7,18 +7,22 @@ import DetailPanel from '../components/DetailPanel.jsx';
 import SearchFilter from '../components/SearchFilter.jsx';
 import { useDetailPanel } from '../hooks/useDetailPanel.js';
 
-// Tier color palette: bg color, border color
-const TIER_COLORS = {
-  user: { bg: '#78350f', border: '#f59e0b', label: 'User' },
-  1:    { bg: '#991b1b', border: '#ef4444', label: 'T1' },
-  2:    { bg: '#9a3412', border: '#f97316', label: 'T2' },
-  3:    { bg: '#1e40af', border: '#3b82f6', label: 'T3' },
-  4:    { bg: '#6d28d9', border: '#8b5cf6', label: 'T4' },
+// Domain persona color palette (v5 — flat, no tiers)
+const PERSONA_COLORS = {
+  user:           { bg: '#78350f', border: '#f59e0b', label: 'User' },
+  'dotnet-senior':{ bg: '#991b1b', border: '#ef4444', label: 'Backend' },
+  'ef-modeler':   { bg: '#7c2d12', border: '#fb923c', label: 'Data' },
+  'maf-expert':   { bg: '#1e3a5f', border: '#38bdf8', label: 'Agents' },
+  'nextjs-expert':{ bg: '#064e3b', border: '#34d399', label: 'Frontend' },
+  'ui-designer':  { bg: '#4a1d96', border: '#a78bfa', label: 'Design' },
+  'infra-engineer':{ bg: '#1e3a5f', border: '#60a5fa', label: 'Infra' },
+  'evaluator':    { bg: '#374151', border: '#9ca3af', label: 'Eval' },
 };
+const FALLBACK_PERSONA = { bg: '#1e40af', border: '#3b82f6', label: 'Persona' };
 
 // Custom AgentNode component
 function AgentNode({ data }) {
-  const colors = data.isUser ? TIER_COLORS.user : (TIER_COLORS[data.tier] || TIER_COLORS[4]);
+  const colors = data.isUser ? PERSONA_COLORS.user : (PERSONA_COLORS[data.personaId] || FALLBACK_PERSONA);
   return (
     <div
       className="rounded-lg px-3 py-2 min-w-[130px] max-w-[160px] cursor-pointer select-none"
@@ -29,7 +33,7 @@ function AgentNode({ data }) {
         {data.label}
       </div>
       <div className="text-gray-300 text-[10px] mt-0.5 truncate">
-        {data.isUser ? 'Principal' : `${colors.label} · ${data.group || ''}`}
+        {data.isUser ? 'Principal' : `${colors.label} · ${data.domains?.[0] || ''}`}
       </div>
       <Handle type="source" position={Position.Bottom} style={{ background: colors.border, width: 8, height: 8 }} />
     </div>
@@ -58,22 +62,19 @@ function buildLayout(nodes, edges) {
 // AgentDetail shown inside the panel
 function AgentDetail({ agent }) {
   const [showPrompt, setShowPrompt] = useState(false);
-  const tierColors = TIER_COLORS[agent.tier] || TIER_COLORS[4];
+  const personaColors = PERSONA_COLORS[agent.id] || FALLBACK_PERSONA;
 
   return (
     <div className="text-sm text-gray-200 space-y-4">
       {/* Header */}
       <div>
         <div className="flex items-center gap-2 mb-1">
-          <span className="px-2 py-0.5 rounded text-xs font-bold" style={{ background: tierColors.bg, color: tierColors.border, border: `1px solid ${tierColors.border}` }}>
-            Tier {agent.tier}
+          <span className="px-2 py-0.5 rounded text-xs font-bold" style={{ background: personaColors.bg, color: personaColors.border, border: `1px solid ${personaColors.border}` }}>
+            {personaColors.label}
           </span>
-          <span className="text-gray-400 text-xs">{agent.group}</span>
+          <span className="text-gray-400 text-xs">{agent.domains?.[0] || ''}</span>
         </div>
         <p className="text-gray-400 text-xs">ID: <span className="text-gray-300 font-mono">{agent.id}</span></p>
-        {agent.reportsTo && (
-          <p className="text-gray-400 text-xs mt-0.5">Reports to: <span className="text-blue-300 font-mono">{agent.reportsTo}</span></p>
-        )}
       </div>
 
       {/* Active Phases */}
@@ -173,15 +174,15 @@ function AgentDetail({ agent }) {
 export default function AgentMap() {
   const { agents } = morphData;
   const [search, setSearch] = useState('');
-  const [tierFilter, setTierFilter] = useState('');
+  const [domainFilter, setDomainFilter] = useState('');
   const [groupFilter, setGroupFilter] = useState('');
   const [phaseFilter, setPhaseFilter] = useState('');
   const [stackFilter, setStackFilter] = useState('');
   const { panel, openPanel, closePanel } = useDetailPanel();
 
   // Derive unique groups, tiers, phases, and stacks for filters
-  const allGroups = useMemo(() => [...new Set(agents.list.map((a) => a.group).filter(Boolean))].sort(), [agents.list]);
-  const allTiers = useMemo(() => [...new Set(agents.list.map((a) => String(a.tier)))].sort(), [agents.list]);
+  const allGroups = useMemo(() => [...new Set(agents.list.map((a) => a.domains?.[0]).filter(Boolean))].sort(), [agents.list]);
+  const allDomains = useMemo(() => [...new Set(agents.list.flatMap((a) => a.domains || []))].sort(), [agents.list]);
   const allPhases = useMemo(() => {
     const phases = new Set();
     for (const a of agents.list) {
@@ -208,17 +209,17 @@ export default function AgentMap() {
       agents.list
         .filter((a) => {
           const matchesSearch = !q || a.title.toLowerCase().includes(q) || a.id.toLowerCase().includes(q) || a.keywords?.some((k) => k.toLowerCase().includes(q));
-          const matchesTier = !tierFilter || String(a.tier) === tierFilter;
-          const matchesGroup = !groupFilter || a.group === groupFilter;
+          const matchesDomain = !domainFilter || (a.domains || []).includes(domainFilter);
+          const matchesGroup = !groupFilter || (a.domains || []).includes(groupFilter);
           const matchesPhase = !phaseFilter || (a.activePhases || []).includes('*') || (a.activePhases || []).includes(phaseFilter);
           const matchesStack = !stackFilter || (a.stacks || []).includes(stackFilter);
-          return matchesSearch && matchesTier && matchesGroup && matchesPhase && matchesStack;
+          return matchesSearch && matchesDomain && matchesGroup && matchesPhase && matchesStack;
         })
         .map((a) => a.id)
     );
   }, [agents.list, search, tierFilter, groupFilter, phaseFilter, stackFilter]);
 
-  const hasFilter = search || tierFilter || groupFilter || phaseFilter || stackFilter;
+  const hasFilter = search || domainFilter || groupFilter || phaseFilter || stackFilter;
 
   // Build React Flow nodes and edges
   const { nodes: layoutNodes, edges } = useMemo(() => {
@@ -236,15 +237,15 @@ export default function AgentMap() {
     // Agent nodes
     for (const agent of agents.list) {
       const dimmed = hasFilter && !matchedIds.has(agent.id);
-      const tierColors = TIER_COLORS[agent.tier] || TIER_COLORS[4];
+      const personaColors = PERSONA_COLORS[agent.id] || FALLBACK_PERSONA;
       rawNodes.push({
         id: agent.id,
         type: 'agentNode',
         data: {
           label: agent.title,
-          tier: agent.tier,
-          group: agent.group,
-          color: tierColors.border,
+          personaId: agent.id,
+          domains: agent.domains,
+          color: personaColors.border,
           agentRef: agent,
         },
         style: dimmed ? { opacity: 0.2 } : {},
@@ -252,17 +253,15 @@ export default function AgentMap() {
       });
     }
 
-    // reports_to edges (solid, tier-colored)
+    // user → agent edges (flat — no hierarchy in v5)
     for (const agent of agents.list) {
-      const source = agent.reportsTo === 'user' ? '__user__' : agent.reportsTo;
-      if (!source) continue;
-      const tierColors = TIER_COLORS[agent.tier] || TIER_COLORS[4];
+      const personaColors = PERSONA_COLORS[agent.id] || FALLBACK_PERSONA;
       rawEdges.push({
         id: `rt-${agent.id}`,
-        source,
+        source: '__user__',
         target: agent.id,
         type: 'smoothstep',
-        style: { stroke: tierColors.border, strokeWidth: 1.5 },
+        style: { stroke: personaColors.border, strokeWidth: 1.5 },
         animated: false,
       });
     }

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

@@ -2,7 +2,7 @@ import morphData from 'virtual:morph-data';
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
-const PHASE_ORDER = ['proposal', 'uiux', 'design', 'plan', 'tasks', 'implement', 'sync'];
+const PHASE_ORDER = ['proposal', 'uiux', 'plan', 'implement', 'review'];
 
 const STATUS_BADGE = {
   in_progress: { label: 'In Progress', bg: 'bg-blue-900/60', border: 'border-blue-600', text: 'text-blue-300' },