pixelcrew 0.2.2 → 0.2.3

package/src/orchestrator/planner.js

@@ -0,0 +1,329 @@
+/**
+ * PIXEL CREW — Dynamic Project Planner & Task Graph Engine
+ * 
+ * Analyzes user prompts from first principles and creates:
+ * 1. Deep Project Specification (Domain, Components, Features, Data Models)
+ * 2. Dynamic Task Graph (DAG) with explicit dependency resolution
+ */
+
+import { SkillRegistry } from './skills-registry.js';
+
+export class DynamicPlanner {
+  constructor() {
+    this.skillRegistry = new SkillRegistry();
+  }
+
+  /**
+   * Step 1: Analyze Requirements from User Prompt
+   */
+  analyzeRequirements(prompt, options = {}) {
+    const p = (prompt || '').toLowerCase();
+
+    // 1. Target Framework & 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. Domain Classification
+    let domain = 'custom';
+    if (p.includes('portfolio') || p.includes('resume') || p.includes('showcase my project') || p.includes('developer portfolio') || p.includes('personal site')) {
+      domain = 'portfolio';
+    } else if (p.includes('restaurant') || p.includes('culinary') || p.includes('dining') || p.includes('cafe') || p.includes('bistro') || p.includes('menu')) {
+      domain = 'restaurant';
+    } else if (p.includes('ecommerce') || p.includes('shop') || p.includes('store') || p.includes('product store') || p.includes('clothing')) {
+      domain = 'ecommerce';
+    } else if (p.includes('saas') || p.includes('platform') || p.includes('subscription') || p.includes('analytics') || p.includes('pricing calculator')) {
+      domain = 'saas';
+    } else if (p.includes('agency') || p.includes('studio') || p.includes('creative lab') || p.includes('design agency')) {
+      domain = 'agency';
+    } else if (p.includes('database') || p.includes('infra') || p.includes('developer tool') || p.includes('query') || p.includes('api engine')) {
+      domain = 'devtool';
+    }
+
+    // 3. Motion & Animation Intent
+    const hasAnimations = p.includes('animation') || p.includes('motion') || p.includes('interactive') || p.includes('kinetic') || true;
+    
+    // 4. Extract Entity / Project Name
+    let projectName = "Bespoke System";
+    let companyName = "Studio Artisan";
+    let roleOrSubtitle = "Modern Digital Platform";
+    let summary = "Engineered with intentional restraint and zero generic AI slop.";
+
+    if (domain === 'portfolio') {
+      projectName = "Modern Developer Portfolio";
+      companyName = "Alex Rivera";
+      roleOrSubtitle = "Staff Systems Architect & Creative Technologist";
+      summary = "Designing high-order distributed architectures, sub-millisecond query engines, and kinetic human-grade web interfaces.";
+    } else if (domain === 'restaurant') {
+      projectName = "Artisan Culinary Studio";
+      companyName = "AURELIA";
+      roleOrSubtitle = "Modern Botanical Gastronomy & Tasting Lab";
+      summary = "Hyper-seasonal tasting menus driven by foraging, fermentation, and architectural plating.";
+    } else if (domain === 'ecommerce') {
+      projectName = "Minimalist Object Store";
+      companyName = "MONOLITH GOODS";
+      roleOrSubtitle = "Precision-Crafted Hardware & Studio Tools";
+      summary = "Industrial-grade design artifacts engineered for creators, architects, and minimalists.";
+    } else if (domain === 'saas' || domain === 'devtool') {
+      projectName = "High-Performance Data Infrastructure";
+      companyName = "VectorScale";
+      roleOrSubtitle = "Real-Time Telemetry & Vector Query Engine";
+      summary = "Sub-millisecond latency query routing and deterministic state coordination for autonomous AI swarms.";
+    } else if (domain === 'agency') {
+      projectName = "Kinetic Creative Studio";
+      companyName = "KITE CREATIVE";
+      roleOrSubtitle = "Design Engineering & Spatial Digital Systems";
+      summary = "We partner with visionary founders to build category-defining digital flagships and interactive products.";
+    }
+
+    return {
+      prompt,
+      domain,
+      framework,
+      hasAnimations,
+      projectName,
+      companyName,
+      roleOrSubtitle,
+      summary,
+      requestedFeatures: this.extractRequestedFeatures(p, domain)
+    };
+  }
+
+  /**
+   * Helper: Extracts requested interactive feature modules
+   */
+  extractRequestedFeatures(promptLower, domain) {
+    const features = [];
+
+    if (domain === 'portfolio') {
+      features.push('project-filter-matrix', 'interactive-terminal-shell', 'career-timeline', 'contact-modal');
+    } else if (domain === 'restaurant') {
+      features.push('interactive-tasting-menu', 'table-reservation-modal', 'chef-curation-slider', 'hours-location-card');
+    } else if (domain === 'ecommerce') {
+      features.push('product-bento-grid', 'interactive-cart-drawer', 'currency-toggle', 'live-spec-sheet');
+    } else if (domain === 'saas' || domain === 'devtool') {
+      features.push('interactive-latency-calculator', 'code-sandbox-tabs', 'benchmark-comparison-matrix', 'pricing-tier-switcher');
+    } else {
+      features.push('asymmetric-showcase', 'interactive-feature-tabs', 'dynamic-contact-drawer');
+    }
+
+    if (promptLower.includes('dark') || promptLower.includes('theme') || promptLower.includes('toggle')) {
+      features.push('theme-toggle');
+    }
+
+    return features;
+  }
+
+  /**
+   * Step 2: Create Unique Project Specification
+   */
+  createProjectSpecification(analysis) {
+    const { domain, framework, companyName, roleOrSubtitle, summary, requestedFeatures, hasAnimations } = analysis;
+
+    // 1. Design Tokens & Palette (High-contrast, zero generic AI purple blobs)
+    let palette = {
+      bg: "#090a0f",
+      surface: "#10121a",
+      surfaceRaised: "#181b26",
+      border: "rgba(255, 255, 255, 0.08)",
+      borderHover: "rgba(255, 255, 255, 0.25)",
+      textPrimary: "#f8fafc",
+      textSecondary: "#94a3b8",
+      accent: "#38bdf8",
+      accentGlow: "rgba(56, 189, 248, 0.15)"
+    };
+
+    let fonts = {
+      display: "'Space Grotesk', -apple-system, sans-serif",
+      body: "'Plus Jakarta Sans', -apple-system, sans-serif",
+      mono: "'JetBrains Mono', monospace",
+      googleFontsUrl: "https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;700&family=Plus+Jakarta+Sans:wght@300;400;500;600;700&family=Space+Grotesk:wght@500;600;700&display=swap"
+    };
+
+    if (domain === 'restaurant') {
+      palette = {
+        bg: "#0c0b0a",
+        surface: "#141311",
+        surfaceRaised: "#1c1b18",
+        border: "rgba(217, 196, 163, 0.12)",
+        borderHover: "rgba(217, 196, 163, 0.35)",
+        textPrimary: "#f5f2eb",
+        textSecondary: "#a8a29e",
+        accent: "#d4af37",
+        accentGlow: "rgba(212, 175, 55, 0.15)"
+      };
+      fonts = {
+        display: "'Cormorant Garamond', Georgia, serif",
+        body: "'Plus Jakarta Sans', sans-serif",
+        mono: "'JetBrains Mono', monospace",
+        googleFontsUrl: "https://fonts.googleapis.com/css2?family=Cormorant+Garamond:ital,wght@0,400;0,600;1,400&family=Plus+Jakarta+Sans:wght@300;400;500;600&display=swap"
+      };
+    } else if (domain === 'agency' || domain === 'portfolio') {
+      palette = {
+        bg: "#08090c",
+        surface: "#0f1117",
+        surfaceRaised: "#161922",
+        border: "rgba(255, 255, 255, 0.08)",
+        borderHover: "rgba(255, 255, 255, 0.3)",
+        textPrimary: "#ffffff",
+        textSecondary: "#9ca3af",
+        accent: "#10b981",
+        accentGlow: "rgba(16, 185, 129, 0.15)"
+      };
+      fonts = {
+        display: "'Instrument Serif', Georgia, serif",
+        body: "'Inter', -apple-system, sans-serif",
+        mono: "'JetBrains Mono', monospace",
+        googleFontsUrl: "https://fonts.googleapis.com/css2?family=Instrument+Serif:ital@0;1&family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500;600&display=swap"
+      };
+    }
+
+    // 2. Dynamic Section Topology
+    const sections = this.buildSectionTopology(domain, companyName, roleOrSubtitle, summary, requestedFeatures);
+
+    return {
+      projectName: analysis.projectName,
+      domain,
+      framework,
+      companyName,
+      headline: roleOrSubtitle,
+      summary,
+      hasAnimations,
+      palette,
+      fonts,
+      requestedFeatures,
+      sections,
+      apiRoutes: [
+        { path: 'src/app/api/contact/route.ts', purpose: 'Handles inquiries with RFC 7807 validation' },
+        { path: 'src/app/api/data/route.ts', purpose: 'Serves dynamic domain entities & filtering' }
+      ]
+    };
+  }
+
+  /**
+   * Helper: Builds domain-specific section hierarchy
+   */
+  buildSectionTopology(domain, name, headline, summary, features) {
+    if (domain === 'portfolio') {
+      return [
+        { id: 'navbar', component: 'Navbar', title: name, navLinks: ['Projects', 'Console', 'Timeline', 'Contact'] },
+        { id: 'hero', component: 'Hero', headline: "Architecting high-order distributed systems & kinetic web platforms.", subheadline: summary, primaryCta: "Explore Selected Works", secondaryCta: "Launch Interactive Shell" },
+        { id: 'projects', component: 'ProjectsGrid', title: "Selected Works & Architectures", categories: ["All", "Distributed Systems", "AI & RAG", "Frontend Islands", "Open Source"] },
+        { id: 'terminal', component: 'TerminalBio', title: "Interactive Developer Shell", subtitle: "Type `skills`, `architecture`, `experience`, or `contact`" },
+        { id: 'experience', component: 'ExperienceTimeline', title: "Career & Technical Milestones" },
+        { id: 'contact', component: 'ContactSection', title: "Let's build something exceptional together.", email: "alex@example.com" }
+      ];
+    } else if (domain === 'restaurant') {
+      return [
+        { id: 'navbar', component: 'Navbar', title: name, navLinks: ['Tasting Menu', 'Philosophy', 'Private Dining', 'Reservations'] },
+        { id: 'hero', component: 'Hero', headline: "Hyper-seasonal gastronomy rooted in botanical exploration.", subheadline: summary, primaryCta: "Reserve a Table", secondaryCta: "View Seasonal Menu" },
+        { id: 'tasting-menu', component: 'TastingMenu', title: "Autumn Tasting Course", categories: ["All", "First Course", "Main Course", "Dessert", "Wine Pairings"] },
+        { id: 'philosophy', component: 'ChefPhilosophy', title: "From Soil to Plate", quote: "We cook not to impress, but to connect guests with the untamed landscape." },
+        { id: 'reservation', component: 'ReservationSection', title: "Join Us at the Table", cta: "Book Reservation" }
+      ];
+    } else {
+      return [
+        { id: 'navbar', component: 'Navbar', title: name, navLinks: ['Capabilities', 'Architecture', 'Throughput', 'Contact'] },
+        { id: 'hero', component: 'Hero', headline: headline, subheadline: summary, primaryCta: "Launch Interactive Sandbox", secondaryCta: "Explore Specs" },
+        { id: 'showcase', component: 'BentoShowcase', title: "Engineered from First Principles", cards: 4 },
+        { id: 'interactive', component: 'InteractiveCalculator', title: "Performance ROI Calculator" },
+        { id: 'contact', component: 'ContactSection', title: "Deploy Modern Architecture", email: "team@example.com" }
+      ];
+    }
+  }
+
+  /**
+   * Step 3: Create Dynamic Task Graph (DAG)
+   */
+  createTaskGraph(spec) {
+    const tasks = [
+      {
+        id: 'task-plan',
+        agentId: 'orchestrator',
+        name: 'Project Requirement Analysis & DAG Compilation',
+        task: `Deconstruct brief for ${spec.domain.toUpperCase()} project into modular task DAG`,
+        skills: ['frontend/nextjs'],
+        dependsOn: [],
+        status: 'queued'
+      },
+      {
+        id: 'task-design-director',
+        agentId: 'creativeDirector',
+        name: 'Visual Direction & Anti-AI Guardian Strategy',
+        task: `Formulate authentic visual personality, fluid clamp typography, and ban purple gradients & repetitive cards`,
+        skills: ['design/ui-design', 'design/typography', 'anti-ai/slop-guardian'],
+        dependsOn: ['task-plan'],
+        status: 'queued'
+      },
+      {
+        id: 'task-content-strategist',
+        agentId: 'contentStrategist',
+        name: 'Grounded Technical Copywriting & Domain Data',
+        task: `Author bespoke domain fixtures and technical value props with zero placeholder cliché copy`,
+        skills: ['content/copywriting', 'backend/data-models'],
+        dependsOn: ['task-plan'],
+        status: 'queued'
+      },
+      {
+        id: 'task-frontend-scaffold',
+        agentId: 'frontend',
+        name: 'Next.js 14/15 App Router Scaffolding & Root Layout',
+        task: `Synthesize package.json, tsconfig.json, tailwind.config.ts, src/app/layout.tsx, and globals.css`,
+        skills: ['frontend/nextjs', 'frontend/react', 'frontend/tailwind'],
+        dependsOn: ['task-design-director'],
+        status: 'queued'
+      },
+      {
+        id: 'task-frontend-components',
+        agentId: 'frontend',
+        name: 'Bespoke Asymmetric Section Components & Pages',
+        task: `Build src/app/page.tsx and all section components (${spec.sections.map(s => s.component).join(', ')})`,
+        skills: ['frontend/nextjs', 'frontend/react', 'design/ui-design'],
+        dependsOn: ['task-frontend-scaffold', 'task-content-strategist'],
+        status: 'queued'
+      },
+      {
+        id: 'task-backend-routes',
+        agentId: 'backend',
+        name: 'TypeScript API Route Handlers & Data Contract',
+        task: `Synthesize src/app/api/contact/route.ts and src/app/api/data/route.ts with RFC 7807 validation`,
+        skills: ['backend/route-handlers', 'backend/data-models'],
+        dependsOn: ['task-frontend-scaffold'],
+        status: 'queued'
+      },
+      {
+        id: 'task-animation-motion',
+        agentId: 'animationSpecialist',
+        name: 'Framer Motion Transitions & Interactive Micro-Interactions',
+        task: `Add smooth reveal choreography, interactive category filtering, and terminal emulator logic`,
+        skills: ['motion/framer-motion', 'motion/micro-interactions'],
+        dependsOn: ['task-frontend-components'],
+        status: 'queued'
+      },
+      {
+        id: 'task-responsive-specialist',
+        agentId: 'responsiveSpecialist',
+        name: 'Responsive Viewport Optimization & Layout Integrity',
+        task: `Ensure zero horizontal scroll, fluid clamp() font scaling, and touch target sizing`,
+        skills: ['quality/responsive-design', 'frontend/accessibility'],
+        dependsOn: ['task-frontend-components'],
+        status: 'queued'
+      },
+      {
+        id: 'task-qa-visual-critic',
+        agentId: 'visualCritic',
+        name: 'Anti-AI Rubric Review & Build Verification',
+        task: `Audit generated codebase against 6-dimension Anti-AI rubric and verify final threshold >= 8.5/10`,
+        skills: ['quality/visual-review', 'quality/browser-testing'],
+        dependsOn: ['task-animation-motion', 'task-responsive-specialist', 'task-backend-routes'],
+        status: 'queued'
+      }
+    ];
+
+    return {
+      spec,
+      tasks
+    };
+  }
+}

package/src/orchestrator/skills-registry.js

@@ -0,0 +1,194 @@
+/**
+ * PIXEL CREW — Modular Skill Registry
+ * 
+ * Reusable capability definitions across Frontend, Design, Motion, Quality, Backend, and Content.
+ */
+
+export const SKILL_DEFINITIONS = {
+  // Frontend Skills
+  'frontend/nextjs': {
+    id: 'frontend/nextjs',
+    name: 'Next.js 14/15 App Router',
+    category: 'frontend',
+    description: 'Server Components, Streaming SSR, Layout hierarchy, and Metadata APIs',
+    targetAgents: ['frontend']
+  },
+  'frontend/react': {
+    id: 'frontend/react',
+    name: 'React 18/19 Primitives',
+    category: 'frontend',
+    description: 'Custom React hooks, client-side state management, and component islands',
+    targetAgents: ['frontend']
+  },
+  'frontend/tailwind': {
+    id: 'frontend/tailwind',
+    name: 'Tailwind CSS & Token System',
+    category: 'frontend',
+    description: 'Utility-first styling, design token mapping, fluid clamp scales, and dark mode',
+    targetAgents: ['frontend', 'designSystem']
+  },
+  'frontend/accessibility': {
+    id: 'frontend/accessibility',
+    name: 'WCAG 2.1 AA/AAA Accessibility',
+    category: 'frontend',
+    description: 'ARIA landmarks, keyboard focus management, and color contrast compliance',
+    targetAgents: ['frontend', 'qa']
+  },
+
+  // Design Skills
+  'design/ui-design': {
+    id: 'design/ui-design',
+    name: 'Bespoke UI & Asymmetric Layouts',
+    category: 'design',
+    description: 'High-contrast visual hierarchy, intentional whitespace, and Bento grid topologies',
+    targetAgents: ['creativeDirector', 'uxPlanner']
+  },
+  'design/typography': {
+    id: 'design/typography',
+    name: 'Expressive Typography Scales',
+    category: 'design',
+    description: 'Mathematical fluid clamp() type scales, display serif and geometric sans pairings',
+    targetAgents: ['creativeDirector', 'designSystem']
+  },
+  'design/design-system': {
+    id: 'design/design-system',
+    name: 'Design System Architecture',
+    category: 'design',
+    description: 'CSS Custom Properties, HSL color tokens, surface elevation tiers, and borders',
+    targetAgents: ['designSystem']
+  },
+
+  // Motion & Animation Skills
+  'motion/framer-motion': {
+    id: 'motion/framer-motion',
+    name: 'Framer Motion & View Transitions',
+    category: 'motion',
+    description: 'Smooth scroll-driven reveals, staggered entrance choreography, and gesture physics',
+    targetAgents: ['animationSpecialist', 'frontend']
+  },
+  'motion/micro-interactions': {
+    id: 'motion/micro-interactions',
+    name: 'Interactive Micro-Interactions',
+    category: 'motion',
+    description: 'Hover states, magnetic buttons, live filter transitions, and interactive terminal state',
+    targetAgents: ['animationSpecialist', 'frontend']
+  },
+
+  // Quality & Review Skills
+  'quality/responsive-design': {
+    id: 'quality/responsive-design',
+    name: 'Adaptive Responsive Design',
+    category: 'quality',
+    description: 'Fluid viewports from 360px mobile to 4K desktop with zero horizontal overflow',
+    targetAgents: ['responsiveSpecialist', 'frontend']
+  },
+  'quality/visual-review': {
+    id: 'quality/visual-review',
+    name: '6-Dimension Anti-AI Rubric Review',
+    category: 'quality',
+    description: 'Originality, Typography, Layout, Hierarchy, Brand Consistency, and AI Slop Penalty audit',
+    targetAgents: ['visualCritic', 'qa']
+  },
+  'quality/browser-testing': {
+    id: 'quality/browser-testing',
+    name: 'Build Verification & Smoke Testing',
+    category: 'quality',
+    description: 'Syntax validation, TypeScript type-checking, and layout integrity checks',
+    targetAgents: ['qa']
+  },
+
+  // Backend & Data Skills
+  'backend/route-handlers': {
+    id: 'backend/route-handlers',
+    name: 'TypeScript Route Handlers',
+    category: 'backend',
+    description: 'Next.js App Router API routes, JSON schema validation, and RFC 7807 error envelopes',
+    targetAgents: ['backend']
+  },
+  'backend/data-models': {
+    id: 'backend/data-models',
+    name: 'Structured Data Modeling',
+    category: 'backend',
+    description: 'Domain entities, TypeScript interfaces, and static fixtures',
+    targetAgents: ['backend', 'database']
+  },
+
+  // Content & Anti-AI Skills
+  'content/copywriting': {
+    id: 'content/copywriting',
+    name: 'Grounded Technical Copywriting',
+    category: 'content',
+    description: 'Zero AI cliché copy, authentic product propositions, and real technical metrics',
+    targetAgents: ['contentStrategist', 'uxPlanner']
+  },
+  'anti-ai/slop-guardian': {
+    id: 'anti-ai/slop-guardian',
+    name: 'Anti-AI Pattern Detection Guardian',
+    category: 'quality',
+    description: 'Bans purple/blue mesh gradient blobs, repeating 3-card grids, and fake AI sparkles',
+    targetAgents: ['creativeDirector', 'visualCritic']
+  }
+};
+
+export class SkillRegistry {
+  constructor() {
+    this.skills = new Map(Object.entries(SKILL_DEFINITIONS));
+  }
+
+  getSkill(skillId) {
+    return this.skills.get(skillId) || null;
+  }
+
+  getAllSkills() {
+    return Array.from(this.skills.values());
+  }
+
+  getSkillsByCategory(category) {
+    return Array.from(this.skills.values()).filter(s => s.category === category);
+  }
+
+  /**
+   * Matches task requirements to skill IDs
+   */
+  matchSkills(taskRequirement) {
+    const text = (taskRequirement || '').toLowerCase();
+    const matched = new Set();
+
+    if (text.includes('next') || text.includes('component') || text.includes('page')) {
+      matched.add('frontend/nextjs');
+      matched.add('frontend/react');
+      matched.add('frontend/tailwind');
+    }
+    if (text.includes('design') || text.includes('visual') || text.includes('artistic')) {
+      matched.add('design/ui-design');
+      matched.add('design/typography');
+      matched.add('design/design-system');
+      matched.add('anti-ai/slop-guardian');
+    }
+    if (text.includes('animation') || text.includes('motion') || text.includes('interaction')) {
+      matched.add('motion/framer-motion');
+      matched.add('motion/micro-interactions');
+    }
+    if (text.includes('responsive') || text.includes('mobile') || text.includes('tablet')) {
+      matched.add('quality/responsive-design');
+    }
+    if (text.includes('api') || text.includes('backend') || text.includes('route')) {
+      matched.add('backend/route-handlers');
+      matched.add('backend/data-models');
+    }
+    if (text.includes('qa') || text.includes('test') || text.includes('review') || text.includes('rubric')) {
+      matched.add('quality/visual-review');
+      matched.add('quality/browser-testing');
+    }
+    if (text.includes('copy') || text.includes('content') || text.includes('text')) {
+      matched.add('content/copywriting');
+    }
+
+    if (matched.size === 0) {
+      matched.add('frontend/nextjs');
+      matched.add('frontend/tailwind');
+    }
+
+    return Array.from(matched);
+  }
+}

package/src/orchestrator/task-queue.js

@@ -0,0 +1,128 @@
+/**
+ * PIXEL CREW — Autonomous Agent Runtime & DAG Task Queue
+ * 
+ * Manages dynamic DAG task scheduling, parallel execution, and granular event streaming.
+ */
+
+import { EventEmitter } from 'node:events';
+
+export class TaskQueue extends EventEmitter {
+  constructor(tasks = []) {
+    super();
+    this.tasks = new Map(tasks.map(t => [t.id, { ...t }]));
+    this.completedTasks = new Set();
+    this.runningTasks = new Set();
+    this.failedTasks = new Set();
+    this.history = [];
+  }
+
+  /**
+   * Retrieves all tasks currently ready for execution
+   * (all dependencies completed and task is currently queued)
+   */
+  getReadyTasks() {
+    const ready = [];
+    for (const [id, task] of this.tasks.entries()) {
+      if (task.status === 'queued') {
+        const depsMet = task.dependsOn.every(depId => this.completedTasks.has(depId));
+        if (depsMet) {
+          ready.push(task);
+        }
+      }
+    }
+    return ready;
+  }
+
+  isCompleted() {
+    return this.tasks.size === this.completedTasks.size;
+  }
+
+  hasFailed() {
+    return this.failedTasks.size > 0;
+  }
+
+  /**
+   * Executes the entire DAG with autonomous agent dispatching
+   */
+  async execute(runtimeContext = {}, onEvent = () => {}) {
+    const emit = (event) => {
+      this.history.push(event);
+      this.emit('event', event);
+      onEvent(event);
+    };
+
+    while (!this.isCompleted() && !this.hasFailed()) {
+      const readyTasks = this.getReadyTasks();
+
+      if (readyTasks.length === 0 && this.runningTasks.size === 0) {
+        throw new Error('Deadlock detected in Task Graph: cyclic dependency or unmet prerequisite');
+      }
+
+      // Execute all ready tasks in parallel batch
+      const promises = readyTasks.map(async (task) => {
+        task.status = 'running';
+        this.runningTasks.add(task.id);
+
+        emit({
+          type: 'agent.started',
+          agent: task.agentId,
+          taskId: task.id,
+          taskName: task.name,
+          message: `Workstation activated for: ${task.name}`
+        });
+
+        // Activate required skills
+        for (const skill of task.skills) {
+          emit({
+            type: 'skill.activated',
+            agent: task.agentId,
+            taskId: task.id,
+            skill,
+            message: `Applying skill: ${skill}`
+          });
+        }
+
+        // Execute actual agent task payload if handler exists
+        if (runtimeContext.executeTaskHandler) {
+          try {
+            await runtimeContext.executeTaskHandler(task, emit);
+          } catch (err) {
+            task.status = 'failed';
+            this.failedTasks.add(task.id);
+            this.runningTasks.delete(task.id);
+            emit({
+              type: 'task.failed',
+              agent: task.agentId,
+              taskId: task.id,
+              error: err.message
+            });
+            throw err;
+          }
+        } else {
+          await new Promise(r => setTimeout(r, 400));
+        }
+
+        task.status = 'completed';
+        this.runningTasks.delete(task.id);
+        this.completedTasks.add(task.id);
+
+        emit({
+          type: 'task.completed',
+          agent: task.agentId,
+          taskId: task.id,
+          taskName: task.name,
+          message: `Completed: ${task.name}`
+        });
+      });
+
+      await Promise.all(promises);
+    }
+
+    return {
+      success: !this.hasFailed(),
+      completedCount: this.completedTasks.size,
+      totalTasks: this.tasks.size,
+      history: this.history
+    };
+  }
+}

package/src/server/server.js

@@ -4,8 +4,15 @@ import fsSync from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-export function createServer(engine, options = {}) {
-  const rootDir = engine.rootDir;
+export function createServer(engineOrRootDir, maybeEngine, options = {}) {
+  let engine = engineOrRootDir;
+  let rootDir = engine?.rootDir || process.cwd();
+
+  if (typeof engineOrRootDir === 'string') {
+    rootDir = engineOrRootDir;
+    engine = maybeEngine;
+  }
+
   const dashboardDir = path.join(rootDir, '.pixel-agents', 'dashboard');
   const legacyDashboardDir = path.join(rootDir, '.pixel-dashboard');
   const fallbackDashboardDir = fileURLToPath(new URL('../dashboard', import.meta.url));