@polymorphism-tech/morph-spec 2.4.0 → 3.0.1

package/src/lib/standards-context-injector.js

@@ -0,0 +1,287 @@
+/**
+ * @fileoverview Standards Context Injector
+ *
+ * Automatically loads and surfaces relevant standards content for agents.
+ * Resolution order: project overrides → framework standards → content standards
+ *
+ * @module standards-context-injector
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Agent → Standards mapping
+ * Maps each agent ID to relevant standard files (without .md extension)
+ */
+const AGENT_STANDARDS_MAP = {
+  // Tier 1: Orchestrators
+  'standards-architect': [
+    'architecture',
+    'coding',
+    'azure',
+    'dotnet10-compatibility',
+    'program-cs-checklist'
+  ],
+  'ai-system-architect': [
+    'agent-framework-setup',
+    'agent-framework-workflows',
+    'agent-framework-production',
+    'agent-framework-blazor-ui',
+    'architecture',
+    'coding'
+  ],
+  'popm-advisor': [], // No technical standards
+
+  // Tier 2: Domain Leaders
+  'dotnet-senior': [
+    'coding',
+    'architecture',
+    'dotnet10-compatibility',
+    'program-cs-checklist'
+  ],
+  'azure-architect': [
+    'azure',
+    'architecture',
+    'dotnet10-compatibility'
+  ],
+  'ui-designer': [
+    'css-naming',
+    'css-animations',
+    'fluent-ui-setup',
+    'fluent-ui-blazor'
+  ],
+
+  // Tier 3: Specialists - Backend Squad
+  'ef-modeler': [
+    'blazor-efcore',
+    'architecture',
+    'coding',
+    'dotnet10-compatibility'
+  ],
+  'event-architect': [
+    'architecture',
+    'coding',
+    'dotnet10-compatibility'
+  ],
+  'api-designer': [
+    'architecture',
+    'coding',
+    'dotnet10-compatibility'
+  ],
+  'nosql-cache-expert': [
+    'architecture',
+    'coding'
+  ],
+  'ddd-expert': [
+    'architecture',
+    'coding'
+  ],
+  'hangfire-orchestrator': [
+    'architecture',
+    'coding',
+    'blazor-lifecycle', // Background jobs + Blazor lifecycle
+    'dotnet10-compatibility'
+  ],
+  'ms-agent-expert': [
+    'agent-framework-setup',
+    'agent-framework-workflows',
+    'agent-framework-production',
+    'agent-framework-blazor-ui',
+    'coding',
+    'architecture'
+  ],
+  'asaas-financial': [
+    'coding',
+    'architecture'
+  ],
+  'clerk-auth': [
+    'coding',
+    'architecture',
+    'passkeys-auth'
+  ],
+  'resend-email': [
+    'coding',
+    'architecture'
+  ],
+
+  // Tier 3: Specialists - Frontend Squad
+  'blazor-builder': [
+    'blazor-lifecycle',
+    'blazor-state',
+    'blazor-efcore',
+    'blazor-pitfalls',
+    'html-to-blazor',
+    'fluent-ui-blazor',
+    'css-naming',
+    'css-animations',
+    'coding',
+    'architecture'
+  ],
+  'nextjs-expert': [
+    'coding'
+  ],
+  'css-specialist': [
+    'css-naming',
+    'css-animations',
+    'fluent-ui-blazor'
+  ],
+
+  // Tier 3: Specialists - Infrastructure Squad
+  'bicep-architect': [
+    'azure',
+    'architecture'
+  ],
+  'devops-engineer': [
+    'azure',
+    'dotnet10-compatibility'
+  ],
+  'container-specialist': [
+    'azure',
+    'dotnet10-compatibility'
+  ],
+  'observability-expert': [
+    'azure',
+    'architecture'
+  ],
+  'azure-identity': [
+    'azure',
+    'architecture',
+    'passkeys-auth'
+  ],
+
+  // Tier 3: Specialists - Quality Squad
+  'testing-specialist': [
+    'coding',
+    'architecture',
+    'dotnet10-compatibility'
+  ],
+  'code-analyzer': [
+    'coding',
+    'architecture',
+    'dotnet10-compatibility',
+    'program-cs-checklist'
+  ],
+  'troubleshooting-expert': [
+    'architecture',
+    'blazor-pitfalls',
+    'dotnet10-compatibility'
+  ],
+  'load-testing-expert': [
+    'architecture',
+    'azure'
+  ],
+  'documentation-specialist': [], // No technical standards
+
+  // Tier 4: Validators
+  'security-expert': [
+    'coding',
+    'architecture',
+    'passkeys-auth'
+  ]
+};
+
+/**
+ * Load a single standard file with project override support
+ * @param {string} standardName - Standard filename without .md extension
+ * @param {string} projectPath - Root path of the project
+ * @returns {string|null} Standard content or null if not found
+ */
+function loadStandard(standardName, projectPath) {
+  const locations = [
+    // 1. Project override
+    join(projectPath, '.morph/project/standards', `${standardName}.md`),
+    // 2. Content standards (AI/Agent Framework, Azure, etc.)
+    join(projectPath, 'content/.morph/standards', `${standardName}.md`),
+    // 3. Framework standards (Blazor, CSS, .NET)
+    join(projectPath, 'framework/standards', `${standardName}.md`)
+  ];
+
+  for (const path of locations) {
+    if (existsSync(path)) {
+      try {
+        return readFileSync(path, 'utf8');
+      } catch (err) {
+        // Continue to next location
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Load all relevant standards for a given agent
+ * @param {string} agentId - Agent ID (e.g., 'blazor-builder')
+ * @param {string} projectPath - Root path of the project
+ * @returns {Object} { sections: [{standard, content}], fullContent: string }
+ */
+export function loadStandardsForAgent(agentId, projectPath = '.') {
+  const standardNames = AGENT_STANDARDS_MAP[agentId] || [];
+  const sections = [];
+  const contentParts = [];
+
+  // Load inferred standards if exists (project-specific learnings)
+  const inferredPath = join(projectPath, '.morph/project/standards/inferred.md');
+  if (existsSync(inferredPath)) {
+    try {
+      const inferredContent = readFileSync(inferredPath, 'utf8');
+      sections.push({
+        standard: 'inferred',
+        content: inferredContent
+      });
+      contentParts.push(`# Project-Specific Standards (Inferred)\n\n${inferredContent}`);
+    } catch (err) {
+      // Ignore if can't read
+    }
+  }
+
+  // Load each standard
+  for (const standardName of standardNames) {
+    const content = loadStandard(standardName, projectPath);
+    if (content) {
+      sections.push({
+        standard: standardName,
+        content
+      });
+      contentParts.push(`# ${standardName}\n\n${content}`);
+    }
+  }
+
+  return {
+    sections,
+    fullContent: contentParts.join('\n\n---\n\n'),
+    standardNames // For debugging/introspection
+  };
+}
+
+/**
+ * Get list of standards for an agent (without loading content)
+ * @param {string} agentId - Agent ID
+ * @returns {string[]} Array of standard names
+ */
+export function getStandardsListForAgent(agentId) {
+  return AGENT_STANDARDS_MAP[agentId] || [];
+}
+
+/**
+ * Check if a standard exists in any location
+ * @param {string} standardName - Standard filename without .md extension
+ * @param {string} projectPath - Root path of the project
+ * @returns {Object} { exists: boolean, location: string|null }
+ */
+export function checkStandardExists(standardName, projectPath = '.') {
+  const locations = [
+    { type: 'project', path: join(projectPath, '.morph/project/standards', `${standardName}.md`) },
+    { type: 'content', path: join(projectPath, 'content/.morph/standards', `${standardName}.md`) },
+    { type: 'framework', path: join(projectPath, 'framework/standards', `${standardName}.md`) }
+  ];
+
+  for (const loc of locations) {
+    if (existsSync(loc.path)) {
+      return { exists: true, location: loc.type, path: loc.path };
+    }
+  }
+
+  return { exists: false, location: null, path: null };
+}

package/src/lib/state-manager.js

@@ -291,6 +291,21 @@ export function removeAgent(featureName, agentId) {
   return false;
 }
 
+/**
+ * Normalize output type from kebab-case to camelCase for UI types (BUG #12 fix)
+ * @param {string} type - Output type (e.g., 'ui-design-system' or 'uiDesignSystem')
+ * @returns {string} Normalized type in camelCase
+ */
+function normalizeOutputType(type) {
+  const kebabMap = {
+    'ui-design-system': 'uiDesignSystem',
+    'ui-mockups': 'uiMockups',
+    'ui-components': 'uiComponents',
+    'ui-flows': 'uiFlows'
+  };
+  return kebabMap[type] || type;
+}
+
 /**
  * Mark output as created
  * @param {string} featureName - Feature name
@@ -300,15 +315,17 @@ export function markOutput(featureName, outputType) {
   ensureFeature(featureName);
   const state = loadState();
 
-  if (!state.features[featureName].outputs[outputType]) {
-    throw new Error(`Output type '${outputType}' not valid. Valid types: proposal, spec, contracts, tasks, uiDesignSystem, uiMockups, uiComponents, uiFlows, decisions, recap`);
+  const normalized = normalizeOutputType(outputType);
+
+  if (!state.features[featureName].outputs[normalized]) {
+    throw new Error(`Output type '${outputType}' not valid. Valid types: proposal, spec, contracts, tasks, uiDesignSystem (or ui-design-system), uiMockups (or ui-mockups), uiComponents (or ui-components), uiFlows (or ui-flows), decisions, recap`);
   }
 
-  state.features[featureName].outputs[outputType].created = true;
+  state.features[featureName].outputs[normalized].created = true;
   state.features[featureName].updatedAt = new Date().toISOString();
 
   // If marking tasks output, try to sync task count from state tasks array
-  if (outputType === 'tasks') {
+  if (normalized === 'tasks') {
     syncTasksCount(state.features[featureName]);
   }
 

package/src/lib/team-orchestrator.js

@@ -0,0 +1,322 @@
+/**
+ * @fileoverview Hierarchical Agent Teams Orchestrator
+ *
+ * Builds Agent Teams using 4-tier hierarchy:
+ * - Tier 1: Orchestrators (Team Lead in delegate mode)
+ * - Tier 2: Domain Leaders (Squad Leaders)
+ * - Tier 3: Specialists (Domain experts)
+ * - Tier 4: Validators (Run in hooks, not teammates)
+ *
+ * @module team-orchestrator
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Load agents.json with hierarchical structure
+ * @param {string} projectPath - Root path of the project
+ * @returns {Promise<Object>} Parsed agents configuration
+ */
+async function loadAgentsConfig(projectPath) {
+  const agentsPath = path.join(projectPath, 'content/.morph/config/agents.json');
+  const content = await fs.readFile(agentsPath, 'utf8');
+  return JSON.parse(content);
+}
+
+/**
+ * Detect if Agent Teams should be spawned based on complexity
+ * @param {Object} options
+ * @param {string[]} options.activeAgents - Agent IDs detected for feature
+ * @param {string} options.complexity - Complexity level (trivial|low|medium|high|critical)
+ * @param {number} options.estimatedFiles - Estimated files to modify
+ * @param {boolean} options.multiDomain - Does feature span multiple domains?
+ * @returns {Object} { shouldSpawn: boolean, reason: string, recommendedMode: string }
+ */
+export function shouldSpawnAgentTeam(options) {
+  const { activeAgents = [], complexity, estimatedFiles = 0, multiDomain = false } = options;
+
+  // Never spawn for trivial/low complexity
+  if (complexity === 'trivial' || complexity === 'low') {
+    return {
+      shouldSpawn: false,
+      reason: 'Complexity too low - single session sufficient',
+      recommendedMode: 'single'
+    };
+  }
+
+  // Always spawn for critical complexity
+  if (complexity === 'critical') {
+    return {
+      shouldSpawn: true,
+      reason: 'Critical complexity - parallel coordination essential',
+      recommendedMode: 'tmux'
+    };
+  }
+
+  // Spawn if multi-domain (backend + frontend + infra)
+  if (multiDomain) {
+    return {
+      shouldSpawn: true,
+      reason: 'Multi-domain feature - benefits from parallel squads',
+      recommendedMode: 'auto'
+    };
+  }
+
+  // Spawn if 3+ independent modules (high file count)
+  if (estimatedFiles >= 15) {
+    return {
+      shouldSpawn: true,
+      reason: 'High file count - parallel implementation recommended',
+      recommendedMode: 'auto'
+    };
+  }
+
+  // Spawn if 5+ specialists active (indicates complex coordination)
+  if (activeAgents.length >= 5) {
+    return {
+      shouldSpawn: true,
+      reason: '5+ specialists active - team coordination beneficial',
+      recommendedMode: 'auto'
+    };
+  }
+
+  // Default: single session for medium complexity
+  return {
+    shouldSpawn: false,
+    reason: 'Medium complexity - single session with subagents OK',
+    recommendedMode: 'single'
+  };
+}
+
+/**
+ * Build hierarchical team structure from active agents
+ * @param {string[]} activeAgentIds - Agent IDs to include in team
+ * @param {Object} agentsConfig - Loaded agents.json
+ * @returns {Object} Team structure with lead, domain leaders, specialists
+ */
+export function buildTeamHierarchy(activeAgentIds, agentsConfig) {
+  const agents = agentsConfig.agents;
+  const activeAgents = activeAgentIds
+    .filter(id => !id.startsWith('_comment') && agents[id])
+    .map(id => ({ id, ...agents[id] }));
+
+  // Tier 1: Orchestrator (Team Lead)
+  const orchestrators = activeAgents.filter(a => a.tier === 1 && a.role === 'orchestrator');
+  const teamLead = orchestrators.find(a => a.id === 'standards-architect') || orchestrators[0];
+
+  // Tier 2: Domain Leaders
+  const domainLeaders = activeAgents.filter(a => a.tier === 2 && a.role === 'domain-leader');
+
+  // Tier 3: Specialists (group by domain)
+  const specialists = activeAgents.filter(a => a.tier === 3 && a.role === 'specialist');
+
+  // Tier 4: Validators (run in hooks, NOT teammates)
+  const validators = activeAgents.filter(a => a.tier === 4 && a.role === 'validator');
+
+  // Group specialists under their Domain Leaders
+  const squads = {};
+  domainLeaders.forEach(leader => {
+    const squadMembers = specialists.filter(specialist => {
+      // Check if specialist reports to this leader
+      return specialist.relationships?.reports_to === leader.id;
+    });
+
+    if (squadMembers.length > 0) {
+      squads[leader.id] = {
+        leader,
+        members: squadMembers
+      };
+    }
+  });
+
+  return {
+    teamLead,
+    squads,
+    validators, // Not in teammates, run as hooks
+    totalTeammates: 1 + domainLeaders.length + specialists.length // Lead + Leaders + Specialists
+  };
+}
+
+/**
+ * Generate teammate spawn instructions for Agent Teams
+ * @param {Object} teamHierarchy - Output from buildTeamHierarchy
+ * @param {string} featureName - Feature name
+ * @param {string} phase - Current MORPH phase
+ * @returns {Object[]} Array of teammate configs for Agent Teams
+ */
+export function generateTeammateConfigs(teamHierarchy, featureName, phase) {
+  const teammates = [];
+  const { teamLead, squads } = teamHierarchy;
+
+  // Add Team Lead (standards-architect in delegate mode)
+  if (teamLead && teamLead.teammate) {
+    teammates.push({
+      id: teamLead.id,
+      tier: teamLead.tier,
+      role: teamLead.teammate.role,
+      icon: teamLead.teammate.icon,
+      spawnPrompt: `${teamLead.teammate.spawn_prompt}
+
+Feature: ${featureName}
+Phase: ${phase}
+
+Your Domain Leaders:
+${Object.values(squads).map(s => `- ${s.leader.title} (${s.leader.id})`).join('\n')}
+
+DO NOT implement code yourself. Coordinate Domain Leaders, resolve conflicts, synthesize results.`
+    });
+  }
+
+  // Add Domain Leaders + their squad members
+  Object.entries(squads).forEach(([leaderId, squad]) => {
+    const leader = squad.leader;
+
+    // Add Domain Leader
+    if (leader.teammate) {
+      teammates.push({
+        id: leader.id,
+        tier: leader.tier,
+        role: leader.teammate.role,
+        icon: leader.teammate.icon,
+        spawnPrompt: `${leader.teammate.spawn_prompt}
+
+Feature: ${featureName}
+Phase: ${phase}
+
+Your Squad (${squad.members.length} specialists):
+${squad.members.map(m => `- ${m.title} (${m.id})`).join('\n')}
+
+Coordinate your specialists. Escalate conflicts to ${leader.relationships.escalates_to}.`
+      });
+    }
+
+    // Add Specialists in this squad
+    squad.members.forEach(specialist => {
+      if (specialist.teammate) {
+        teammates.push({
+          id: specialist.id,
+          tier: specialist.tier,
+          role: specialist.teammate.role,
+          icon: specialist.teammate.icon,
+          spawnPrompt: `${specialist.teammate.spawn_prompt}
+
+Feature: ${featureName}
+Phase: ${phase}
+
+Reports to: ${specialist.relationships.reports_to}
+Escalate to: ${specialist.relationships.escalates_to}
+
+${specialist.relationships.collaborates_with ?
+  `Collaborate with: ${specialist.relationships.collaborates_with.join(', ')}` : ''}`
+        });
+      }
+    });
+  });
+
+  return teammates;
+}
+
+/**
+ * Generate Agent Teams command for spawning
+ * @param {Object[]} teammates - Output from generateTeammateConfigs
+ * @param {string} displayMode - 'auto' | 'in-process' | 'tmux'
+ * @returns {string} Command to spawn Agent Teams
+ */
+export function generateSpawnCommand(teammates, displayMode = 'auto') {
+  // Agent Teams are spawned via Claude Code's Task tool with subagent_type="general-purpose"
+  // and special teammate configs. This is a conceptual representation.
+
+  const command = {
+    tool: 'Task',
+    subagent_type: 'general-purpose',
+    agent_teams_enabled: true,
+    display_mode: displayMode,
+    teammates: teammates.map(t => ({
+      id: t.id,
+      role: t.role,
+      icon: t.icon,
+      prompt: t.spawnPrompt
+    }))
+  };
+
+  return JSON.stringify(command, null, 2);
+}
+
+/**
+ * Main orchestration function - decides if/when to spawn Agent Teams
+ * @param {Object} options
+ * @param {string} options.projectPath - Project root path
+ * @param {string} options.featureName - Feature name
+ * @param {string} options.phase - MORPH phase
+ * @param {string[]} options.activeAgents - Active agent IDs
+ * @param {string} options.complexity - Complexity level
+ * @param {number} options.estimatedFiles - Estimated file count
+ * @param {boolean} options.multiDomain - Multi-domain feature?
+ * @returns {Promise<Object>} Team orchestration result
+ */
+export async function orchestrateTeam(options) {
+  const {
+    projectPath,
+    featureName,
+    phase,
+    activeAgents = [],
+    complexity,
+    estimatedFiles = 0,
+    multiDomain = false
+  } = options;
+
+  // Step 1: Decide if Agent Teams should spawn
+  const spawnDecision = shouldSpawnAgentTeam({
+    activeAgents,
+    complexity,
+    estimatedFiles,
+    multiDomain
+  });
+
+  if (!spawnDecision.shouldSpawn) {
+    return {
+      useAgentTeams: false,
+      reason: spawnDecision.reason,
+      recommendation: 'Use single session with Task tool for subagents'
+    };
+  }
+
+  // Step 2: Load agents config and build hierarchy
+  const agentsConfig = await loadAgentsConfig(projectPath);
+  const teamHierarchy = buildTeamHierarchy(activeAgents, agentsConfig);
+
+  // Step 3: Generate teammate configs
+  const teammates = generateTeammateConfigs(teamHierarchy, featureName, phase);
+
+  // Step 4: Generate spawn command
+  const spawnCommand = generateSpawnCommand(teammates, spawnDecision.recommendedMode);
+
+  return {
+    useAgentTeams: true,
+    reason: spawnDecision.reason,
+    displayMode: spawnDecision.recommendedMode,
+    teamHierarchy: {
+      teamLead: teamHierarchy.teamLead?.id,
+      squads: Object.keys(teamHierarchy.squads),
+      totalTeammates: teamHierarchy.totalTeammates,
+      validators: teamHierarchy.validators.map(v => v.id)
+    },
+    teammates,
+    spawnCommand,
+    recommendation: `Spawn ${teamHierarchy.totalTeammates} teammates in ${spawnDecision.recommendedMode} mode`
+  };
+}
+
+/**
+ * Get agent squad assignments (for informational purposes)
+ * @param {Object} agentsConfig - Loaded agents.json
+ * @returns {Object} Squad information
+ */
+export function getSquadInfo(agentsConfig) {
+  return agentsConfig.squads || {};
+}