@polymorphism-tech/morph-spec 4.21.0 → 5.0.1

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

@@ -9,14 +9,12 @@ import { useDetailPanel } from '../hooks/useDetailPanel.js';
 const PHASE_COLORS = {
   proposal:  { bg: '#166534', border: '#22c55e', text: '#bbf7d0' },
   uiux:      { bg: '#854d0e', border: '#f59e0b', text: '#fef3c7' },
-  design:    { bg: '#1e40af', border: '#60a5fa', text: '#dbeafe' },
   plan:      { bg: '#7c2d12', border: '#fb923c', text: '#fed7aa' },
-  tasks:     { bg: '#6d28d9', border: '#a78bfa', text: '#ede9fe' },
   implement: { bg: '#0e7490', border: '#22d3ee', text: '#cffafe' },
-  sync:      { bg: '#374151', border: '#9ca3af', text: '#f3f4f6' },
+  review:    { bg: '#6d28d9', border: '#a78bfa', text: '#ede9fe' },
 };
 
-const GATED_PHASES = new Set(['uiux', 'design', 'plan', 'tasks']);
+const GATED_PHASES = new Set(['uiux', 'plan', 'review']);
 
 // Gate node: small gold square with "G" label
 function GateNode({ data }) {

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

@@ -7,10 +7,9 @@ import DetailPanel from '../components/DetailPanel.jsx';
 import SearchFilter from '../components/SearchFilter.jsx';
 import { useDetailPanel } from '../hooks/useDetailPanel.js';
 
-// Colors for skill levels
+// Colors for skill categories (v5 — all skills in skills/core/)
 const LEVEL_COLORS = {
-  'level-0-meta':       { bg: '#134e4a', border: '#14b8a6', label: 'L0 Meta' },
-  'level-1-workflows':  { bg: '#1e3a5f', border: '#38bdf8', label: 'L1 Workflows' },
+  'core': { bg: '#134e4a', border: '#14b8a6', label: 'Core' },
 };
 const FALLBACK_LEVEL = { bg: '#1a2e1a', border: '#4ade80', label: 'Skill' };
 

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

@@ -11,8 +11,8 @@ const HoverContext = createContext({ hoveredPhase: null, setHoveredPhase: () =>
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
-// Canonical phase order (we render exactly these 7 columns)
-const PHASE_ORDER = ['proposal', 'uiux', 'design', 'plan', 'tasks', 'implement', 'sync'];
+// Canonical phase order (we render exactly these 5 columns)
+const PHASE_ORDER = ['proposal', 'uiux', 'plan', 'implement', 'review'];
 
 const PHASE_X_GAP = 200;
 const PHASE_W = 160;

package/src/dashboard/scanner/agents-scanner.js

@@ -1,35 +1,30 @@
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import { join, basename } from 'path';
-
-function findMdFiles(dir) {
-  const results = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) results.push(...findMdFiles(fullPath));
-    else if (entry.name.endsWith('.md') && entry.name !== 'README.md') results.push(fullPath);
-  }
-  return results;
-}
-
-export function scanAgents(frameworkDir) {
-  const agentsJsonPath = join(frameworkDir, 'agents.json');
-  const agentsDir = join(frameworkDir, 'agents');
-  if (!existsSync(agentsJsonPath) || !existsSync(agentsDir)) {
-    return { version: 'unknown', total: 0, tiers: {}, list: [] };
-  }
-  const agentsJson = JSON.parse(readFileSync(agentsJsonPath, 'utf8'));
-  const mdFiles = findMdFiles(agentsDir);
-  const promptMap = {};
-  for (const filePath of mdFiles) {
-    promptMap[basename(filePath, '.md')] = readFileSync(filePath, 'utf8');
-  }
-  const list = Object.entries(agentsJson.agents).map(([id, agent]) => ({
-    id, color: agent.color, tier: agent.tier, title: agent.title, group: agent.group,
-    activePhases: agent.active_phases, reportsTo: agent.reports_to,
-    domains: agent.domains || [], keywords: agent.keywords || [],
-    validators: agent.validators || [], standards: agent.standards || [],
-    stacks: agent.stacks || [], prompt: promptMap[id] || '',
-    teammate: agent.teammate || null,
-  }));
-  return { version: agentsJson.version, total: agentsJson.total_agents, tiers: agentsJson.tiers, list };
-}
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Scan agents.json (v5) — flat domain personas, no tiers.
+ * Returns the list shaped for the dashboard inspector.
+ */
+export function scanAgents(frameworkDir) {
+  const agentsJsonPath = join(frameworkDir, 'agents.json');
+  if (!existsSync(agentsJsonPath)) {
+    return { version: 'unknown', total: 0, list: [] };
+  }
+  const agentsJson = JSON.parse(readFileSync(agentsJsonPath, 'utf8'));
+  const list = Object.entries(agentsJson.agents).map(([id, agent]) => ({
+    id,
+    title: agent.title,
+    icon: agent.icon || null,
+    color: agent.color || null,
+    domains: agent.domains || [],
+    keywords: agent.keywords || [],
+    standards: agent.standards || [],
+    stack: agent.stack || ['*'],
+    persona: agent.persona || '',
+  }));
+  return {
+    version: agentsJson.version,
+    total: agentsJson.total_agents || list.length,
+    list,
+  };
+}

package/src/lib/agents/metrics-aggregator.js

@@ -32,7 +32,7 @@ export function aggregateProjectMetrics(state) {
   });
 
   const totalFeatures = featureMetrics.length;
-  const completedFeatures = featureMetrics.filter(f => f.phase === 'archived' || f.phase === 'done').length;
+  const completedFeatures = featureMetrics.filter(f => f.phase === 'review').length;
   const totalTasks = featureMetrics.reduce((sum, f) => sum + f.taskCount, 0);
   const completedTasks = featureMetrics.reduce((sum, f) => sum + f.completedTasks, 0);
   const totalDispatches = featureMetrics.reduce((sum, f) => sum + f.dispatchCount, 0);

package/src/lib/agents/output-collector.js

@@ -14,23 +14,22 @@ import { OUTPUT_SCHEMA, getAbsoluteOutputPath } from '../../core/paths/output-sc
  */
 export const SOURCE_WEIGHTS = {
   proposal:       1.0,
-  schemaAnalysis: 1.0,
+  stackScan:      0.8,
+  migrationPlan:  0.8,
   spec:           1.5,
-  contracts:      1.0,
-  contractsTs:    1.0,
-  contractsVsa:   1.0,
-  decisions:      1.0,
-  plan:           1.2,
+  mandate:        1.3,
   tasks:          1.3,
+  decisions:      1.0,
   uiDesignSystem: 1.0,
   uiMockups:      1.0,
   uiComponents:   1.0,
   uiFlows:        1.0,
   recap:          1.0,
+  reviewReport:   1.0,
 };
 
-/** Phase order for sorting collected outputs */
-const PHASE_ORDER = ['proposal', 'uiux', 'design', 'plan', 'tasks', 'implement'];
+/** Phase order for sorting collected outputs (v5 NLH model) */
+const PHASE_ORDER = ['proposal', 'uiux', 'plan', 'implement', 'review'];
 
 /**
  * Collect all existing phase output files for a feature.

package/src/lib/context/context-builder.js

@@ -0,0 +1,289 @@
+/**
+ * @fileoverview Context-Aware Dispatch — Agent Context Builder
+ *
+ * Assembles curated context payloads per agent, based on domain persona,
+ * phase, and active task. Agents get only what they need — not everything.
+ *
+ * @module context-builder
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENTS_JSON_PATH = join(__dirname, '../../../framework/agents.json');
+const STANDARDS_JSON_PATH = join(__dirname, '../../../framework/standards/STANDARDS.json');
+
+let _agentsCache = null;
+let _standardsCache = null;
+
+function loadAgents() {
+  if (_agentsCache) return _agentsCache;
+  if (!existsSync(AGENTS_JSON_PATH)) return { agents: {} };
+  try {
+    _agentsCache = JSON.parse(readFileSync(AGENTS_JSON_PATH, 'utf8'));
+    return _agentsCache;
+  } catch { return { agents: {} }; }
+}
+
+function loadStandards() {
+  if (_standardsCache) return _standardsCache;
+  if (!existsSync(STANDARDS_JSON_PATH)) return { standards: [] };
+  try {
+    _standardsCache = JSON.parse(readFileSync(STANDARDS_JSON_PATH, 'utf8'));
+    return _standardsCache;
+  } catch { return { standards: [] }; }
+}
+
+/** Max chars for spec content (flat — v5 has no tier hierarchy) */
+const SPEC_BUDGET = 8000;
+
+/** Max number of standard digests */
+const STANDARDS_BUDGET = 10;
+
+/**
+ * Context assembly rules by phase.
+ * Controls which context sections are included.
+ */
+const PHASE_CONTEXT_PROFILES = {
+  proposal: {
+    includeSpec: false,
+    includeStandards: false,
+    includeTask: false,
+    includeCodePaths: false,
+    includePhaseArtifacts: false,
+  },
+  uiux: {
+    includeSpec: false,
+    includeStandards: true,
+    includeTask: false,
+    includeCodePaths: false,
+    includePhaseArtifacts: false,
+  },
+  plan: {
+    includeSpec: true,
+    includeStandards: true,
+    includeTask: false,
+    includeCodePaths: false,
+    includePhaseArtifacts: true,
+  },
+  implement: {
+    includeSpec: true,
+    includeStandards: true,
+    includeTask: true,
+    includeCodePaths: true,
+    includePhaseArtifacts: false,
+  },
+  review: {
+    includeSpec: true,
+    includeStandards: true,
+    includeTask: false,
+    includeCodePaths: true,
+    includePhaseArtifacts: true,
+  },
+};
+
+/**
+ * Extract only the FR sections referenced by a task.
+ *
+ * @param {string} specContent - Full spec.md content
+ * @param {string[]} frIds - FR IDs (e.g., ['FR001', 'FR003'])
+ * @returns {string} Scoped spec with only referenced FRs
+ */
+export function scopeSpecToFRs(specContent, frIds) {
+  if (!frIds || frIds.length === 0 || !specContent) return specContent;
+
+  const sections = [];
+
+  // Always include overview/context sections
+  const overviewMatch = specContent.match(/^(#[^#][\s\S]*?)(?=\n##\s+FR\d)/m);
+  if (overviewMatch) {
+    sections.push(overviewMatch[1].trim());
+  }
+
+  // Extract each referenced FR section
+  for (const frId of frIds) {
+    const pattern = new RegExp(
+      `(##\\s+${frId}[:\\s—–\\-][\\s\\S]*?)(?=\\n##\\s+FR\\d|\\n##\\s+[^F]|$)`,
+      'm'
+    );
+    const match = pattern.exec(specContent);
+    if (match) {
+      sections.push(match[1].trim());
+    }
+  }
+
+  return sections.length > 0 ? sections.join('\n\n---\n\n') : specContent;
+}
+
+/**
+ * Build standard digests for an agent based on their standards[] array.
+ *
+ * @param {string} agentId - Agent ID from agents.json
+ * @returns {string[]} Array of digest paragraphs
+ */
+export function buildAgentDigests(agentId) {
+  const agents = loadAgents();
+  const agentData = agents.agents?.[agentId];
+  if (!agentData?.standards || agentData.standards.length === 0) return [];
+
+  const standards = loadStandards();
+  const standardsList = standards.standards || [];
+
+  const digests = [];
+  for (const stdId of agentData.standards) {
+    const std = standardsList.find(s => s.id === stdId);
+    if (std?.digest) {
+      digests.push(`[${std.id}] ${std.name}: ${std.digest}`);
+    }
+  }
+
+  return digests;
+}
+
+/**
+ * Extract FR IDs from a task's title/body in tasks.md format.
+ * Format: ### T001 — Title [FR001, FR003]
+ *
+ * @param {string} taskTitle - Task title that may contain [FR...] references
+ * @param {string} [taskBlock] - Full task block for body references
+ * @returns {string[]}
+ */
+export function extractFRIds(taskTitle, taskBlock) {
+  const frIds = new Set();
+
+  // From title: [FR001, FR003]
+  const titleMatch = (taskTitle || '').match(/\[([^\]]*FR\d+[^\]]*)\]/);
+  if (titleMatch) {
+    const matches = titleMatch[1].match(/FR\d+/g);
+    if (matches) matches.forEach(id => frIds.add(id));
+  }
+
+  // From body: **FRs:** FR001, FR002
+  if (taskBlock) {
+    const bodyMatch = taskBlock.match(/\*\*FRs?:\*\*\s*(.+)/i);
+    if (bodyMatch) {
+      const matches = bodyMatch[1].match(/FR\d+/g);
+      if (matches) matches.forEach(id => frIds.add(id));
+    }
+  }
+
+  return [...frIds];
+}
+
+/**
+ * Build a curated context payload for a specific agent.
+ *
+ * @param {string} agentId - Agent ID from agents.json
+ * @param {Object} options
+ * @param {string} options.feature - Feature name
+ * @param {string} options.phase - Current phase
+ * @param {string} [options.taskId] - Active task ID (implement phase)
+ * @param {string} [options.projectPath='.'] - Project root
+ * @returns {AgentContext}
+ *
+ * @typedef {Object} AgentContext
+ * @property {string|null} spec - Full spec or task-scoped section
+ * @property {string[]} standards - Digest paragraphs for this agent's standards
+ * @property {string|null} task - Mandate task section or null
+ * @property {string[]} codeContext - Relevant file paths
+ * @property {string|null} phaseArtifacts - Previous phase outputs
+ * @property {Object} budget - Context budget hints
+ */
+export async function buildAgentContext(agentId, { feature, phase, taskId, projectPath = '.' }) {
+  const agents = loadAgents();
+  const profile = PHASE_CONTEXT_PROFILES[phase] || PHASE_CONTEXT_PROFILES.implement;
+  const maxSpecChars = SPEC_BUDGET;
+  const maxStandards = STANDARDS_BUDGET;
+
+  const result = {
+    spec: null,
+    standards: [],
+    task: null,
+    codeContext: [],
+    phaseArtifacts: null,
+    budget: { maxSpecChars, maxStandards },
+  };
+
+  // Standards digests
+  if (profile.includeStandards) {
+    result.standards = buildAgentDigests(agentId).slice(0, maxStandards);
+  }
+
+  // Spec content (scoped by task FRs when possible)
+  if (profile.includeSpec) {
+    try {
+      const specPath = getAbsoluteOutputPath(projectPath, feature, 'spec');
+      if (existsSync(specPath)) {
+        let specContent = readFileSync(specPath, 'utf8');
+
+        // If task-scoped, extract mandate section for this task
+        if (taskId) {
+          const mandatePath = getAbsoluteOutputPath(projectPath, feature, 'mandate');
+          if (existsSync(mandatePath)) {
+            try {
+              const { extractTaskSection } = await import('../../lib/generators/mandate-generator.js');
+              const section = extractTaskSection(readFileSync(mandatePath, 'utf8'), taskId);
+              if (section) {
+                result.spec = section.slice(0, maxSpecChars);
+                result.task = section;
+              }
+            } catch { /* fall through to raw spec */ }
+          }
+        }
+
+        if (!result.spec) {
+          result.spec = specContent.slice(0, maxSpecChars);
+        }
+      }
+    } catch { /* spec not available */ }
+  }
+
+  // Task mandate section
+  if (profile.includeTask && taskId && !result.task) {
+    try {
+      const mandatePath = getAbsoluteOutputPath(projectPath, feature, 'mandate');
+      if (existsSync(mandatePath)) {
+        const { extractTaskSection } = await import('../../lib/generators/mandate-generator.js');
+        const section = extractTaskSection(readFileSync(mandatePath, 'utf8'), taskId);
+        if (section) result.task = section;
+      }
+    } catch { /* mandate not available */ }
+  }
+
+  // Code paths from task
+  if (profile.includeCodePaths && taskId) {
+    try {
+      const planPath = getAbsoluteOutputPath(projectPath, feature, 'plan');
+      if (existsSync(planPath)) {
+        const planContent = readFileSync(planPath, 'utf8');
+        const backtickPaths = planContent.match(/`([^`]+\.[a-z]{1,4})`/g);
+        if (backtickPaths) {
+          result.codeContext = [...new Set(backtickPaths.map(p => p.replace(/`/g, '')))].slice(0, 20);
+        }
+      }
+    } catch { /* plan not available */ }
+  }
+
+  // Phase artifacts (decisions, previous outputs)
+  if (profile.includePhaseArtifacts) {
+    try {
+      const decisionsPath = getAbsoluteOutputPath(projectPath, feature, 'decisions');
+      if (existsSync(decisionsPath)) {
+        result.phaseArtifacts = readFileSync(decisionsPath, 'utf8').slice(0, 3000);
+      }
+    } catch { /* decisions not available */ }
+  }
+
+  return result;
+}
+
+/**
+ * Invalidate module-level caches. Used in tests.
+ */
+export function clearCache() {
+  _agentsCache = null;
+  _standardsCache = null;
+}

package/src/lib/detectors/claude-config-detector.js

@@ -27,8 +27,23 @@ export function detectClaudeConfig(targetPath) {
     hooks: [],
   };
 
+  const mcpJsonNames = new Set();
+
   try {
-    // ── MCP Servers from settings ────────────────────────────────────────────
+    // ── MCP Servers from .mcp.json (primary — Claude Code reads this) ───────
+    const mcpJsonPath = join(targetPath, '.mcp.json');
+    if (existsSync(mcpJsonPath)) {
+      try {
+        const mcpJson = JSON.parse(readFileSync(mcpJsonPath, 'utf8'));
+        const mcps = mcpJson.mcpServers || {};
+        for (const [name, config] of Object.entries(mcps)) {
+          result.mcpServers.push({ name, config });
+          mcpJsonNames.add(name);
+        }
+      } catch { /* invalid JSON */ }
+    }
+
+    // ── MCP Servers + hooks from settings (legacy + hooks/permissions) ───────
     const settingsPaths = [
       join(targetPath, '.claude', 'settings.json'),
       join(targetPath, '.claude', 'settings.local.json'),
@@ -38,12 +53,13 @@ export function detectClaudeConfig(targetPath) {
       if (existsSync(sp)) {
         try {
           const settings = JSON.parse(readFileSync(sp, 'utf8'));
+          // Legacy MCP entries — skip if already in .mcp.json, but allow later settings files to override earlier ones
           const mcps = settings.mcpServers || {};
           for (const [name, config] of Object.entries(mcps)) {
-            // Avoid duplicates — later file wins
+            if (mcpJsonNames.has(name)) continue; // .mcp.json takes priority
             const idx = result.mcpServers.findIndex(m => m.name === name);
             if (idx >= 0) {
-              result.mcpServers[idx] = { name, config };
+              result.mcpServers[idx] = { name, config }; // later file wins
             } else {
               result.mcpServers.push({ name, config });
             }

package/src/lib/generators/context-generator.js

@@ -15,7 +15,6 @@ import fs from 'fs/promises';
 import path from 'path';
 import { existsSync } from 'fs';
 import { getOutputPath } from '../../core/paths/output-schema.js';
-import { tierToRole } from '../../utils/tier-helpers.js';
 
 /**
  * Resolve a template path: check .morph/framework/templates/ first, then framework/templates/.
@@ -253,29 +252,20 @@ export async function generateProjectContext(projectPath) {
     // Project standards
     PROJECT_STANDARDS: standards,
 
-    // Agents by tier
-    AGENT_COUNT: agents?.total_agents || 0,
-    TIER_1_AGENTS: Object.entries(agents?.agents || {})
-      .filter(([id, agent]) => !id.startsWith('_') && agent.tier === 1)
+    // Agents (v5: flat personas, no tiers)
+    AGENT_COUNT: agents?.total_agents || Object.keys(agents?.agents || {}).length,
+    PERSONAS: Object.entries(agents?.agents || {})
+      .filter(([id]) => !id.startsWith('_'))
       .map(([id, agent]) => ({
         id,
         title: agent.title,
-        always_active: Array.isArray(agent.active_phases) ? agent.active_phases.includes('*') : !!agent.always_active
-      })),
-    TIER_2_AGENTS: Object.entries(agents?.agents || {})
-      .filter(([id, agent]) => !id.startsWith('_') && agent.tier === 2)
-      .map(([id, agent]) => ({
-        id,
-        title: agent.title,
-        domains: (agent.domains || []).join(', ')
-      })),
-    TIER_3_AGENTS: Object.entries(agents?.agents || {})
-      .filter(([id, agent]) => !id.startsWith('_') && agent.tier === 3)
-      .map(([id, agent]) => ({
-        id,
-        title: agent.title,
-        reports_to: agent.reports_to || agent.relationships?.reports_to || 'N/A'
+        domains: (agent.domains || []).join(', '),
+        stack: (agent.stack || ['*']).join(', ')
       })),
+    // v4 compat (kept empty so legacy templates still render)
+    TIER_1_AGENTS: [],
+    TIER_2_AGENTS: [],
+    TIER_3_AGENTS: [],
 
     // Agent Teams config
     AGENT_TEAMS_ENABLED: config?.agentTeams?.enabled || false,
@@ -342,7 +332,7 @@ export async function generateFeatureContext(projectPath, featureName) {
   let tasks = [];
 
   try {
-    const decisionsPath = path.join(outputsDir, '2-design', 'decisions.md');
+    const decisionsPath = path.join(outputsDir, '2-plan', 'decisions.md');
     const decisionsContent = await fs.readFile(decisionsPath, 'utf8');
     // Parse decisions.md (simplified - just extract ADR headers)
     const adrMatches = decisionsContent.matchAll(/##\s+ADR-(\d+):\s+(.+)/g);
@@ -359,7 +349,7 @@ export async function generateFeatureContext(projectPath, featureName) {
   }
 
   try {
-    const tasksPath = path.join(outputsDir, '4-tasks', 'tasks.json');
+    const tasksPath = path.join(outputsDir, '2-plan', 'tasks.md');
     const tasksContent = await fs.readFile(tasksPath, 'utf8');
     tasks = JSON.parse(tasksContent).tasks || [];
   } catch (err) {
@@ -381,24 +371,12 @@ export async function generateFeatureContext(projectPath, featureName) {
     .filter(id => agents?.agents[id])
     .map(id => ({ id, ...agents.agents[id] }));
 
-  // Group by tier and build squads
-  const teamLead = activeAgents.find(a => tierToRole(a.tier) === 'orchestrator');
-  const domainLeaders = activeAgents.filter(a => tierToRole(a.tier) === 'leader');
-  const specialists = activeAgents.filter(a => tierToRole(a.tier) === 'specialist');
-  const validators = activeAgents.filter(a => tierToRole(a.tier) === 'validator');
-
-  const squads = domainLeaders.map(leader => ({
-    leader: {
-      id: leader.id,
-      title: leader.title
-    },
-    members: specialists
-      .filter(s => (s.reports_to || s.relationships?.reports_to) === leader.id)
-      .map(s => ({
-        id: s.id,
-        title: s.title
-      }))
-  }));
+  // v5: flat persona model — no tiers, no squads. Just list active personas.
+  const teamLead = null;
+  const domainLeaders = [];
+  const specialists = activeAgents;
+  const validators = activeAgents.filter(a => a.id === 'evaluator');
+  const squads = [];
 
   // Build data object
   const data = {
@@ -484,12 +462,12 @@ export async function generateFeatureContext(projectPath, featureName) {
     PROPOSAL_PATH: getOutputPath(featureName, 'proposal'),
     SPEC_PATH: getOutputPath(featureName, 'spec'),
     CONTRACTS_PATH: getOutputPath(featureName, 'contracts'),
-    TASKS_PATH: `.morph/features/${featureName}/4-tasks/tasks.json`,
+    TASKS_PATH: `.morph/features/${featureName}/2-plan/tasks.md`,
     DECISIONS_PATH: getOutputPath(featureName, 'decisions'),
     RECAP_PATH: getOutputPath(featureName, 'recap'),
 
     // Version
-    MORPH_VERSION: '3.0.0-hierarchical',
+    MORPH_VERSION: '5.0.0',
     FEATURE_ID: feature.id || featureName
   };
 

package/src/lib/generators/index.js

@@ -10,3 +10,4 @@ export * from './recap-generator.js';
 export * from './metadata-extractor.js';
 export * from './architecture-scanner.js';
 export * from './scaffold-generator.js';
+export * from './mandate-generator.js';