pixelcrew 0.2.2 → 0.2.6

package/src/orchestrator/ontology.js

@@ -0,0 +1,394 @@
+/**
+ * PIXEL CREW — Universal Software Ontology
+ * 
+ * Defines the domain-agnostic primitives, grammatical contracts, and schemas of software architecture.
+ * The orchestrator owns the software synthesis process, NOT a catalog of application domains.
+ * The domain is runtime data.
+ */
+
+export const UNIVERSAL_CAPABILITIES = [
+  'search',
+  'filter',
+  'sort',
+  'create',
+  'edit',
+  'delete',
+  'view',
+  'schedule',
+  'calculate',
+  'simulate',
+  'compare',
+  'upload',
+  'download',
+  'export',
+  'authenticate',
+  'authorize',
+  'approve',
+  'reject',
+  'assign',
+  'track',
+  'visualize',
+  'collaborate',
+  'notify',
+  'archive',
+  'restore'
+];
+
+export const LAYOUT_PRIMITIVES = {
+  STACK: 'stack',
+  SPLIT: 'split',
+  GRID: 'grid',
+  OVERLAY: 'overlay',
+  WORKSPACE: 'workspace',
+  SIDEBAR: 'sidebar',
+  INSPECTOR: 'inspector',
+  CANVAS: 'canvas',
+  TIMELINE: 'timeline',
+  SEQUENCE: 'sequence',
+  NESTED: 'nested',
+  FREEFORM: 'freeform'
+};
+
+export const UI_PRIMITIVES = {
+  COLLECTION: 'collection',
+  TABLE: 'table',
+  FORM: 'form',
+  TIMELINE: 'timeline',
+  CALENDAR: 'calendar',
+  BOARD: 'board',
+  CANVAS: 'canvas',
+  INSPECTOR: 'inspector',
+  WORKSPACE: 'workspace',
+  MODAL: 'modal',
+  DRAWER: 'drawer',
+  SEARCH: 'search',
+  FILTER: 'filter',
+  PAGINATION: 'pagination',
+  VISUALIZATION: 'visualization'
+};
+
+export const OPERATION_METHODS = {
+  GET: 'GET',
+  POST: 'POST',
+  PUT: 'PUT',
+  PATCH: 'PATCH',
+  DELETE: 'DELETE'
+};
+
+export const REQUIREMENT_CATEGORIES = {
+  WORKFLOW: 'workflow',
+  UI_COMPONENT: 'ui_component',
+  API_ENDPOINT: 'api_endpoint',
+  DATA_MODEL: 'data_model',
+  SECURITY: 'security',
+  PERFORMANCE: 'performance',
+  DESIGN_QUALITY: 'design_quality'
+};
+
+export class UniversalSoftwareOntology {
+  /**
+   * Validate & Normalize Project Definition
+   */
+  static validateProject(project) {
+    if (!project || typeof project !== 'object') {
+      throw new Error('Project definition must be a valid object.');
+    }
+    return {
+      name: String(project.name || 'Universal Application').trim(),
+      description: String(project.description || 'Open-world synthesized software application').trim(),
+      domain: String(project.domain || 'general-software').toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+      goals: Array.isArray(project.goals) ? project.goals.map(String) : []
+    };
+  }
+
+  /**
+   * Validate & Normalize Actor Definition
+   */
+  static validateActor(actor, index = 0) {
+    if (!actor || typeof actor !== 'object') {
+      return {
+        id: `actor-${index + 1}`,
+        name: 'User',
+        role: 'Primary Operator',
+        capabilities: ['view', 'create', 'search'],
+        permissions: ['read', 'write']
+      };
+    }
+    const name = String(actor.name || `Actor ${index + 1}`).trim();
+    const id = actor.id || `actor-${name.toLowerCase().replace(/[^a-z0-9]+/g, '-') || (index + 1)}`;
+    return {
+      id,
+      name,
+      role: String(actor.role || name).trim(),
+      capabilities: Array.isArray(actor.capabilities) ? actor.capabilities.map(String) : ['view', 'search'],
+      permissions: Array.isArray(actor.permissions) ? actor.permissions.map(String) : ['read']
+    };
+  }
+
+  /**
+   * Validate & Normalize Entity Definition
+   */
+  static validateEntity(entity, index = 0) {
+    if (!entity || typeof entity !== 'object' || !entity.name) {
+      throw new Error(`Entity at index ${index} must have a valid string name.`);
+    }
+    const cleanName = String(entity.name).replace(/[^a-zA-Z0-9]/g, '');
+    if (!cleanName) {
+      throw new Error(`Entity name '${entity.name}' contains no alphanumeric characters.`);
+    }
+    const id = entity.id || `entity-${cleanName.toLowerCase()}`;
+    const title = entity.title || cleanName;
+    const plural = String(entity.plural || `${cleanName}s`).trim();
+    const description = String(entity.description || `Domain entity representing ${cleanName}`).trim();
+
+    const fields = Array.isArray(entity.fields) && entity.fields.length > 0
+      ? entity.fields.map((f, fi) => this.normalizeField(f, fi))
+      : [
+        { name: 'id', type: 'string', required: true, label: 'ID', sampleValue: `${id}-001` },
+        { name: 'name', type: 'string', required: true, label: 'Name', sampleValue: `Sample ${cleanName}` },
+        { name: 'status', type: 'string', required: false, label: 'Status', sampleValue: 'Active' },
+        { name: 'createdAt', type: 'datetime', required: true, label: 'Created At', sampleValue: '2026-08-31T00:00:00.000Z' }
+      ];
+
+    const relationships = Array.isArray(entity.relationships)
+      ? entity.relationships.map(r => this.normalizeRelationship(r, cleanName))
+      : [];
+
+    const constraints = Array.isArray(entity.constraints) ? entity.constraints.map(String) : [];
+    const seedData = Array.isArray(entity.seedData) ? entity.seedData : [];
+
+    return {
+      id,
+      name: cleanName,
+      title,
+      plural,
+      description,
+      fields,
+      relationships,
+      constraints,
+      seedData
+    };
+  }
+
+  /**
+   * Normalize an individual Field definition
+   */
+  static normalizeField(field, index = 0) {
+    if (typeof field === 'string') {
+      const isNum = /(count|price|depth|size|age|rating|score|amount|total|latitude|longitude|index|duration|tokens|ms|speed)/i.test(field);
+      const isDate = /(date|time|at|created|updated|scheduled|timestamp)/i.test(field);
+      const isBool = /(is|has|enabled|active|completed|verified)/i.test(field);
+      const type = field === 'id' ? 'string' : (isNum ? 'number' : (isDate ? 'datetime' : (isBool ? 'boolean' : 'string')));
+      return {
+        name: field,
+        type,
+        required: field === 'id' || field === 'name',
+        label: field.charAt(0).toUpperCase() + field.slice(1).replace(/([A-Z])/g, ' $1'),
+        sampleValue: isNum ? 100 : (isDate ? '2026-08-31T12:00:00.000Z' : (isBool ? true : `Sample ${field}`))
+      };
+    }
+    const name = String(field.name || `field_${index + 1}`).trim();
+    const type = String(field.type || 'string').toLowerCase();
+    const required = Boolean(field.required ?? (name === 'id' || name === 'name'));
+    const label = String(field.label || name.charAt(0).toUpperCase() + name.slice(1)).trim();
+    let sampleValue = field.sampleValue;
+    if (sampleValue === undefined) {
+      if (type === 'number') sampleValue = 42;
+      else if (type === 'boolean') sampleValue = true;
+      else if (type === 'datetime') sampleValue = '2026-08-31T12:00:00.000Z';
+      else sampleValue = `Sample ${label}`;
+    }
+    return {
+      name,
+      type,
+      required,
+      label,
+      sampleValue
+    };
+  }
+
+  /**
+   * Normalize an Entity Relationship
+   */
+  static normalizeRelationship(rel, sourceEntity) {
+    if (typeof rel === 'string') {
+      return {
+        type: 'belongsTo',
+        targetEntity: rel.replace(/[^a-zA-Z0-9]/g, ''),
+        foreignKey: `${rel.toLowerCase()}Id`
+      };
+    }
+    return {
+      type: rel.type || 'hasMany',
+      targetEntity: String(rel.targetEntity || rel.target || 'Entity').replace(/[^a-zA-Z0-9]/g, ''),
+      foreignKey: rel.foreignKey || (rel.type === 'belongsTo' ? `${(rel.targetEntity || 'entity').toLowerCase()}Id` : undefined),
+      cardinality: rel.cardinality || (rel.type === 'hasMany' ? '1:N' : 'N:1')
+    };
+  }
+
+  /**
+   * Validate & Normalize Workflow Definition
+   */
+  static validateWorkflow(wf, index = 0) {
+    if (!wf || typeof wf !== 'object') {
+      return {
+        id: `workflow-${index + 1}`,
+        name: `Workflow ${index + 1}`,
+        actor: 'User',
+        trigger: 'Manual Action',
+        steps: ['Initiate', 'Process', 'Complete'],
+        outcome: 'Completed'
+      };
+    }
+    const name = String(wf.name || `Workflow ${index + 1}`).trim();
+    const id = wf.id || `workflow-${name.toLowerCase().replace(/[^a-z0-9]+/g, '-') || (index + 1)}`;
+    return {
+      id,
+      name,
+      actor: String(wf.actor || 'User').trim(),
+      trigger: String(wf.trigger || 'Action Triggered').trim(),
+      steps: Array.isArray(wf.steps) ? wf.steps.map(String) : ['Execute action', 'Record state'],
+      outcome: String(wf.outcome || 'Workflow completed').trim()
+    };
+  }
+
+  /**
+   * Validate & Normalize View Definition
+   */
+  static validateView(view, entities = [], index = 0) {
+    if (!view || typeof view !== 'object') {
+      const fallbackEntity = entities[0] ? entities[0].name : 'Item';
+      return {
+        id: `view-${index + 1}`,
+        componentName: `${fallbackEntity}Overview`,
+        title: `${fallbackEntity} Overview`,
+        purpose: `Browse and manage ${fallbackEntity} records`,
+        targetEntities: [fallbackEntity],
+        layout: { type: LAYOUT_PRIMITIVES.GRID, density: 'comfortable' },
+        regions: [
+          { role: 'navigation', components: ['search', 'filter'] },
+          { role: 'content', components: ['collection'] }
+        ],
+        capabilities: ['search', 'filter', 'view']
+      };
+    }
+    const rawTitle = String(view.title || view.name || `View ${index + 1}`).trim();
+    const cleanComp = (view.componentName || rawTitle).replace(/[^a-zA-Z0-9]/g, '');
+    const componentName = cleanComp.charAt(0).toUpperCase() + cleanComp.slice(1) || `DynamicView${index + 1}`;
+    const id = view.id || `view-${componentName.toLowerCase()}`;
+    const targetEntities = Array.isArray(view.targetEntities) && view.targetEntities.length > 0
+      ? view.targetEntities.map(e => String(e).replace(/[^a-zA-Z0-9]/g, ''))
+      : (view.targetEntity ? [String(view.targetEntity).replace(/[^a-zA-Z0-9]/g, '')] : (entities[0] ? [entities[0].name] : ['System']));
+
+    const layout = typeof view.layout === 'object' && view.layout !== null
+      ? view.layout
+      : { type: LAYOUT_PRIMITIVES.GRID, density: 'comfortable' };
+
+    const regions = Array.isArray(view.regions) ? view.regions : [
+      { role: 'navigation', components: ['search', 'filter'] },
+      { role: 'content', components: ['collection'] }
+    ];
+
+    const capabilities = Array.isArray(view.capabilities) ? view.capabilities.map(String) : ['view', 'search', 'filter'];
+
+    return {
+      id,
+      componentName,
+      title: rawTitle,
+      purpose: String(view.purpose || `Interactive interface for ${rawTitle}`).trim(),
+      targetEntities,
+      layout,
+      regions,
+      capabilities
+    };
+  }
+
+  /**
+   * Validate & Normalize Operation Definition
+   */
+  static validateOperation(op, entities = [], index = 0) {
+    if (!op || typeof op !== 'object') {
+      const ent = entities[0] ? entities[0].name : 'Resource';
+      return {
+        id: `operation-${index + 1}`,
+        path: `/api/${ent.toLowerCase()}s`,
+        method: OPERATION_METHODS.GET,
+        description: `List ${ent} records`,
+        targetEntity: ent,
+        requestFields: [],
+        responseFields: [],
+        authorization: 'none'
+      };
+    }
+    const path = String(op.path || '/api/resource').startsWith('/') ? String(op.path || '/api/resource') : `/${op.path}`;
+    const method = Object.values(OPERATION_METHODS).includes(String(op.method).toUpperCase())
+      ? String(op.method).toUpperCase()
+      : OPERATION_METHODS.GET;
+    const targetEntity = String(op.targetEntity || (entities[0] ? entities[0].name : 'Entity')).replace(/[^a-zA-Z0-9]/g, '');
+    const id = op.id || `op-${method.toLowerCase()}-${path.replace(/[^a-zA-Z0-9]/g, '-')}`;
+
+    return {
+      id,
+      path,
+      method,
+      description: String(op.description || `Execute ${method} on ${path}`).trim(),
+      targetEntity,
+      requestFields: Array.isArray(op.requestFields) ? op.requestFields.map(String) : [],
+      responseFields: Array.isArray(op.responseFields) ? op.responseFields.map(String) : [],
+      authorization: String(op.authorization || 'none')
+    };
+  }
+
+  /**
+   * Validate & Normalize Event Definition
+   */
+  static validateEvent(evt, index = 0) {
+    if (!evt || typeof evt !== 'object') {
+      return {
+        id: `event-${index + 1}`,
+        name: `Event${index + 1}`,
+        source: 'System',
+        payload: { timestamp: 'datetime' },
+        consumers: ['AuditLogger']
+      };
+    }
+    const name = String(evt.name || `Event${index + 1}`).replace(/[^a-zA-Z0-9]/g, '');
+    return {
+      id: evt.id || `event-${name.toLowerCase()}`,
+      name,
+      source: String(evt.source || 'System').trim(),
+      payload: typeof evt.payload === 'object' && evt.payload !== null ? evt.payload : {},
+      consumers: Array.isArray(evt.consumers) ? evt.consumers.map(String) : []
+    };
+  }
+
+  /**
+   * Validate & Normalize Requirement Definition
+   */
+  static validateRequirement(req, index = 0) {
+    if (!req || typeof req !== 'object') {
+      return {
+        id: `REQ-${String(index + 1).padStart(3, '0')}`,
+        category: REQUIREMENT_CATEGORIES.WORKFLOW,
+        target: 'system',
+        description: 'System requirement',
+        acceptanceCriteria: ['Requirement fulfilled'],
+        priority: 'high'
+      };
+    }
+    const id = req.id || `REQ-${String(index + 1).padStart(3, '0')}`;
+    const category = Object.values(REQUIREMENT_CATEGORIES).includes(req.category)
+      ? req.category
+      : REQUIREMENT_CATEGORIES.WORKFLOW;
+    return {
+      id,
+      category,
+      target: String(req.target || 'system').trim(),
+      description: String(req.description || `Requirement ${id}`).trim(),
+      acceptanceCriteria: Array.isArray(req.acceptanceCriteria) && req.acceptanceCriteria.length > 0
+        ? req.acceptanceCriteria.map(String)
+        : ['Functionality implemented and verified'],
+      priority: ['critical', 'high', 'medium', 'low'].includes(req.priority) ? req.priority : 'high'
+    };
+  }
+}

package/src/orchestrator/planner.js

@@ -0,0 +1,302 @@
+/**
+ * PIXEL CREW — Dynamic Prompt-Driven Project Planner & Task Graph Engine
+ * 
+ * Decomposes arbitrary user prompts from first principles into:
+ * 1. Semantic AST (Domain, Actors, Entities, Views, Operations, Interactive Workflows)
+ * 2. Requirement Contract (REQ-001..N with verifiable acceptance criteria)
+ * 3. Bespoke Design Specification (DesignEngine)
+ * 4. Dynamic Task Graph (DAG) with specialized agent role allocation
+ */
+
+import { SkillRegistry } from './skills-registry.js';
+import { SemanticEngine } from './semantic-engine.js';
+import { RequirementContract } from './requirement-contract.js';
+import { DesignEngine } from './design-engine.js';
+import { TaskPlanner } from './task-planner.js';
+
+export class DynamicPlanner {
+  constructor() {
+    this.skillRegistry = new SkillRegistry();
+  }
+
+  /**
+   * Step 1: Semantic Requirement Analysis from User Prompt
+   */
+  analyzeRequirements(prompt, options = {}) {
+    const rawPrompt = (prompt || '').trim();
+    const p = rawPrompt.toLowerCase();
+
+    // 1. Target Framework & Runtime Stack
+    let framework = options.targetFramework || 'nextjs';
+    if (p.includes('react') && !p.includes('next')) framework = 'react';
+    else if (p.includes('vue')) framework = 'vue';
+    else if (p.includes('vanilla')) framework = 'vanilla';
+
+    // 2. Parse into full Semantic Project AST
+    const ast = SemanticEngine.parsePromptToAST(rawPrompt);
+
+    // 3. Create verifiable Requirement Contract
+    const contract = new RequirementContract(ast);
+
+    // 4. Synthesize bespoke DesignSpec
+    const designSpec = DesignEngine.synthesizeDesignSpec(ast, rawPrompt);
+
+    // 5. Motion & Animation Intent
+    const hasAnimations = true;
+
+    // 6. Requested Interactive Features
+    const requestedFeatures = this.extractRequestedFeatures(p, ast);
+
+    return {
+      prompt: rawPrompt,
+      domain: ast.domain,
+      framework,
+      hasAnimations,
+      projectName: ast.appName,
+      companyName: ast.appName,
+      roleOrSubtitle: ast.headline,
+      summary: ast.summary,
+      ast,
+      contract,
+      designSpec,
+      entities: ast.entities,
+      views: ast.views,
+      operations: ast.operations,
+      requirements: ast.requirements,
+      metrics: this.synthesizeDynamicMetrics(ast.appName, p),
+      actions: this.synthesizeDynamicActions(p),
+      aestheticMood: 'bespoke',
+      palette: designSpec.color || ast.palette,
+      fonts: designSpec.typography || ast.fonts,
+      requestedFeatures
+    };
+  }
+
+  /**
+   * Helper: Extracts requested interactive features
+   */
+  extractRequestedFeatures(p, ast) {
+    const features = [];
+    if (p.includes('saas') || p.includes('dashboard')) {
+      features.push('saas-kpi-dashboard');
+    }
+    if (p.includes('portfolio') || p.includes('developer') || p.includes('showcase')) {
+      features.push('project-filter-matrix', 'interactive-terminal-shell');
+    }
+    if (p.includes('restaurant') || p.includes('tasting') || p.includes('dining') || p.includes('reservation')) {
+      features.push('interactive-tasting-menu', 'table-reservation-modal');
+    }
+    if (p.includes('login') || p.includes('auth') || p.includes('sign in') || p.includes('account')) {
+      features.push('auth-login-modal', 'jwt-session-management');
+    }
+    if (p.includes('pricing') || p.includes('tier') || p.includes('plan')) {
+      features.push('pricing-tier-switcher');
+    }
+    if (p.includes('search') || p.includes('filter') || p.includes('sort')) {
+      features.push('realtime-filter-search');
+    }
+    if (features.length === 0) {
+      features.push('domain-workspace', 'realtime-filter-search');
+    }
+    return features;
+  }
+
+  /**
+   * Helper: Synthesizes dynamic metrics
+   */
+  synthesizeDynamicMetrics(subject, p) {
+    if (p.includes('orbit') || p.includes('rocket') || p.includes('space') || p.includes('mission')) {
+      return [
+        { label: "Delta-V Budget", value: "3,840 m/s", change: "Optimal Margin", status: "optimal" },
+        { label: "Altitude & Apogee", value: "542.8 km", change: "LEO Synchronous", status: "optimal" },
+        { label: "Inclination Vector", value: "51.64°", change: "Nominal", status: "nominal" },
+        { label: "Telemetry Link", value: "99.98%", change: "Ground Lock", status: "nominal" }
+      ];
+    }
+    if (p.includes('legal') || p.includes('contract') || p.includes('clause') || p.includes('compliance')) {
+      return [
+        { label: "Risk Index", value: "94.2 / 100", change: "Sub-10ms Inference", status: "optimal" },
+        { label: "Compliance Score", value: "99.94%", change: "Strict Benchmark", status: "optimal" },
+        { label: "Clauses Extracted", value: "1,480 / sec", change: "Zero Hallucination", status: "optimal" },
+        { label: "Active Agreements", value: "482 Files", change: "Multi-Jurisdiction", status: "nominal" }
+      ];
+    }
+    if (p.includes('audio') || p.includes('synth') || p.includes('midi') || p.includes('sound')) {
+      return [
+        { label: "DSP Latency", value: "0.18 ms", change: "Zero Buffer Drop", status: "optimal" },
+        { label: "Sample Processing", value: "192 kHz", change: "32-bit Float", status: "optimal" },
+        { label: "Polyphony Voices", value: "64 Active", change: "Real-Time Parallel", status: "optimal" },
+        { label: "Filter Headroom", value: "+18.4 dB", change: "Analog Modeled", status: "nominal" }
+      ];
+    }
+    if (p.includes('real estate') || p.includes('property') || p.includes('mortgage') || p.includes('valuation')) {
+      return [
+        { label: "Valuation Comps", value: "12,400 Comps", change: "Real-Time Index", status: "optimal" },
+        { label: "Portfolio AUM", value: "$42.8M", change: "+12.4% Annualized", status: "optimal" },
+        { label: "Average Cap Rate", value: "6.85%", change: "+45 bps vs Index", status: "optimal" },
+        { label: "Confidence Score", value: "99.2%", change: "Hedonic Model", status: "optimal" }
+      ];
+    }
+    return [
+      { label: `${subject} Throughput`, value: "4.2M ops/s", change: "+18.4% p99", status: "optimal" },
+      { label: "Query Latency", value: "0.48 ms", change: "Sub-millisecond", status: "optimal" },
+      { label: "Active Nodes", value: "1,248 Nodes", change: "Multi-Region", status: "nominal" },
+      { label: "Availability SLA", value: "99.999%", change: "Zero Downtime", status: "nominal" }
+    ];
+  }
+
+  /**
+   * Helper: Extracts dynamic user operations / actions
+   */
+  synthesizeDynamicActions(p) {
+    return ['search-and-filter', 'execute-runtime-command', 'inspect-telemetry'];
+  }
+
+  /**
+   * Step 2: Create Dynamic Project Specification
+   */
+  createProjectSpecification(analysis) {
+    const {
+      prompt,
+      domain,
+      framework,
+      projectName,
+      companyName,
+      roleOrSubtitle,
+      summary,
+      ast,
+      contract,
+      designSpec,
+      entities,
+      views,
+      operations,
+      requirements,
+      metrics,
+      actions,
+      aestheticMood,
+      palette,
+      fonts,
+      requestedFeatures
+    } = analysis;
+
+    const sections = this.buildDynamicSectionTopology(ast, requestedFeatures, companyName, projectName, roleOrSubtitle, summary, domain);
+
+    return {
+      appName: companyName || projectName || 'Application',
+      companyName: companyName || projectName || 'Application',
+      projectName: projectName || 'Application',
+      domain: domain || 'software-system',
+      headline: roleOrSubtitle || `Unified Platform for ${projectName}`,
+      summary: summary || 'Engineered with open-world synthesis.',
+      targetFramework: framework,
+      sections,
+      palette,
+      fonts,
+      ast,
+      contract,
+      designSpec,
+      entities,
+      views,
+      operations,
+      requirements,
+      metrics,
+      actions,
+      aestheticMood,
+      requestedFeatures,
+      apiRoutes: [
+        { path: 'src/app/api/auth/login/route.ts' },
+        { path: 'src/app/api/dashboard/stats/route.ts' },
+        { path: 'src/app/api/contact/route.ts' },
+        { path: 'src/app/api/data/route.ts' }
+      ],
+      rawPrompt: prompt
+    };
+  }
+
+  buildDynamicSectionTopology(ast, requestedFeatures, companyName, projectName, roleOrSubtitle, summary, domain) {
+    const sections = [
+      {
+        id: "header",
+        componentName: "PortalHeader",
+        role: "Persistent Navigation & Workspace Header",
+        stateful: false
+      }
+    ];
+
+    if (domain === 'portfolio') {
+      sections.push(
+        { id: "hero", component: "Hero", componentName: "Hero", role: "Masthead", stateful: false },
+        { id: "projects", component: "ProjectsGrid", componentName: "ProjectsGrid", role: "Projects Showcase", stateful: true }
+      );
+    } else if (domain === 'restaurant') {
+      sections.push(
+        { id: "tasting", component: "TastingMenu", componentName: "TastingMenu", role: "Tasting Menu", stateful: true },
+        { id: "reservation", component: "ReservationSection", componentName: "ReservationSection", role: "Reservation", stateful: true }
+      );
+    } else if (domain === 'saas' || requestedFeatures.includes('saas-kpi-dashboard')) {
+      sections.push(
+        { id: "metrics", component: "DashboardMetrics", componentName: "DashboardMetrics", role: "Metrics & KPIs", stateful: true },
+        { id: "auth", component: "AuthLoginModal", componentName: "AuthLoginModal", role: "Authentication Modal", stateful: true },
+        { id: "pricing", component: "PricingMatrix", componentName: "PricingMatrix", role: "Pricing Matrix", stateful: true }
+      );
+    } else if (ast && Array.isArray(ast.views) && ast.views.length > 0) {
+      ast.views.forEach(v => {
+        sections.push({
+          id: v.id || v.componentName.toLowerCase(),
+          component: v.componentName,
+          componentName: v.componentName,
+          role: v.purpose || v.title,
+          stateful: true
+        });
+      });
+    } else {
+      sections.push({
+        id: "workspace",
+        component: "DynamicWorkspace",
+        componentName: "DynamicWorkspace",
+        role: "Primary Domain Workspace",
+        stateful: true
+      });
+    }
+
+    return sections;
+  }
+
+  /**
+   * Step 3: Dynamic Task Graph (DAG) Compilation
+   */
+  createTaskGraph(spec) {
+    const tasks = [
+      { id: 'task-plan', name: 'Synthesize AST & Requirements', agentId: 'orchestrator', dependsOn: [], skills: ['open-world-synthesis'], status: 'queued' },
+      { id: 'task-design-director', name: 'Artistic Direction & Negative Constraints', agentId: 'creativeDirector', dependsOn: ['task-plan'], skills: ['design-director'], status: 'queued' },
+      { id: 'task-content-strategist', name: 'Copywriting & Content Topology', agentId: 'uxPlanner', dependsOn: ['task-plan'], skills: ['ux-architecture'], status: 'queued' },
+      { id: 'task-frontend-scaffold', name: 'Design Tokens & Global CSS Layout', agentId: 'designSystem', dependsOn: ['task-design-director'], skills: ['design-tokens'], status: 'queued' },
+      { id: 'task-backend-routes', name: 'API Routes & RFC 7807 Handlers', agentId: 'backend', dependsOn: ['task-frontend-scaffold'], skills: ['typescript-routes'], status: 'queued' },
+      { id: 'task-frontend-components', name: 'Dynamic View Components Synthesis', agentId: 'frontend', dependsOn: ['task-content-strategist', 'task-frontend-scaffold'], skills: ['react-19'], status: 'queued' },
+      { id: 'task-animation-motion', name: 'Fluid Motion & Micro-Interactions', agentId: 'frontend', dependsOn: ['task-frontend-components'], skills: ['framer-motion'], status: 'queued' },
+      { id: 'task-responsive-specialist', name: 'Responsive Viewport Calibration', agentId: 'frontend', dependsOn: ['task-frontend-components'], skills: ['tailwind'], status: 'queued' },
+      { id: 'task-qa-visual-critic', name: 'Impeccable Visual Quality Gate', agentId: 'qa', dependsOn: ['task-animation-motion', 'task-backend-routes', 'task-responsive-specialist'], skills: ['visual-critic'], status: 'queued' }
+    ];
+
+    const agents = {
+      creativeDirector: { role: 'Creative Director', skills: ['design-director', 'anti-ai-patterns'] },
+      uxPlanner: { role: 'UX Planner', skills: ['ux-architecture', 'bento-layout'] },
+      designSystem: { role: 'Design System Architect', skills: ['design-tokens', 'fluid-typography'] },
+      frontend: { role: 'Frontend Engineer', skills: ['react-19', 'nextjs-app-router', 'tailwind'] },
+      backend: { role: 'Backend & API Engineer', skills: ['typescript-routes', 'rfc7807-errors'] },
+      database: { role: 'Database & Data Modeler', skills: ['data-fixtures', 'typescript-interfaces'] },
+      qa: { role: 'QA & Compliance Auditor', skills: ['requirement-validation', 'visual-critic'] }
+    };
+
+    return {
+      spec,
+      totalTasks: tasks.length,
+      agents,
+      tasks
+    };
+  }
+
+  compileTaskGraph(spec) {
+    return this.createTaskGraph(spec);
+  }
+}