@baselineos/persona 0.1.0

package/dist/index.js

@@ -0,0 +1,2445 @@
+// src/engine.ts
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+var BaselinePersonaEngine = class extends EventEmitter {
+  personas;
+  activePersonas;
+  behaviorData;
+  adaptations;
+  config;
+  initialized;
+  constructor(config = {}) {
+    super();
+    this.personas = /* @__PURE__ */ new Map();
+    this.activePersonas = /* @__PURE__ */ new Map();
+    this.behaviorData = /* @__PURE__ */ new Map();
+    this.adaptations = [];
+    this.config = {
+      enableAutonomousLearning: config.enableAutonomousLearning ?? true,
+      enableBehavioralAnalysis: config.enableBehavioralAnalysis ?? true,
+      enablePredictiveCustomization: config.enablePredictiveCustomization ?? true,
+      enableCrossPersonaSharing: config.enableCrossPersonaSharing ?? false
+    };
+    this.initialized = false;
+    this.initializeCorePersonas();
+    this.initializeEventListeners();
+    this.initialized = true;
+    console.log("[BaselinePersonaEngine] Persona engine initialized with", this.personas.size, "core personas");
+  }
+  // ─── Persona Initialization ──────────────────────────────────────────────
+  initializeCorePersonas() {
+    const corePersonas = {
+      designer: {
+        name: "Designer",
+        description: "Visual and UX designer focused on creating beautiful, intuitive interfaces and experiences",
+        focus: ["visual-design", "ux-research", "prototyping", "design-systems", "accessibility"],
+        studio: {
+          interface: {
+            layout: "canvas-centric",
+            colorScheme: "creative-vibrant",
+            typography: "modern-sans",
+            visualElements: ["color-picker", "layer-panel", "asset-library", "component-inspector", "design-tokens"]
+          },
+          lexicon: {
+            terminology: ["wireframe", "mockup", "prototype", "design-system", "component-library", "style-guide", "user-flow", "information-architecture"],
+            language: "design-focused",
+            abbreviations: ["UX", "UI", "IA", "A11Y", "DS", "DT"]
+          },
+          frames: {
+            primary: ["canvas-frame", "component-library-frame", "prototype-frame"],
+            secondary: ["color-palette-frame", "typography-frame", "spacing-frame"],
+            utility: ["export-frame", "handoff-frame", "feedback-frame"]
+          },
+          templates: {
+            layouts: ["responsive-grid", "mobile-first", "desktop-canvas", "tablet-adaptive"],
+            components: ["button-system", "form-elements", "navigation-patterns", "card-layouts"],
+            pages: ["landing-page", "dashboard", "settings-page", "onboarding-flow"]
+          },
+          workflows: {
+            design: ["research-ideate-design-test", "sketch-wireframe-mockup-prototype"],
+            review: ["design-critique", "stakeholder-review", "usability-testing"],
+            handoff: ["spec-generation", "asset-export", "developer-handoff"]
+          },
+          aiModels: {
+            generation: ["layout-generator", "color-palette-ai", "icon-generator"],
+            analysis: ["design-consistency-checker", "accessibility-auditor", "visual-hierarchy-analyzer"],
+            suggestion: ["component-recommender", "layout-optimizer", "design-pattern-matcher"]
+          }
+        },
+        agilePM: {
+          sprints: {
+            methodology: "design-sprint",
+            cycles: ["understand", "diverge", "converge", "prototype", "test"],
+            duration: "1-week"
+          },
+          userStories: {
+            format: ["As a user, I want...", "Design requirement:", "Visual specification:"],
+            priorities: ["must-have", "should-have", "nice-to-have"],
+            categories: ["ux-improvement", "visual-design", "accessibility", "responsive"]
+          },
+          backlog: {
+            categories: ["design-tasks", "research-tasks", "prototype-tasks", "review-tasks"],
+            priorities: ["critical", "high", "medium", "low"],
+            estimations: ["story-points", "design-complexity", "research-hours"]
+          },
+          analytics: {
+            metrics: ["design-velocity", "iteration-count", "user-satisfaction", "accessibility-score"],
+            reports: ["sprint-design-report", "ux-metrics-dashboard", "design-debt-tracker"],
+            tracking: ["task-completion", "review-cycles", "design-quality"]
+          }
+        }
+      },
+      developer: {
+        name: "Developer",
+        description: "Software developer focused on building robust, scalable applications with clean code",
+        focus: ["coding", "architecture", "testing", "deployment", "performance"],
+        studio: {
+          interface: {
+            layout: "code-centric",
+            colorScheme: "dark-professional",
+            typography: "monospace-primary",
+            visualElements: ["code-editor", "terminal-panel", "file-explorer", "git-panel", "debugger"]
+          },
+          lexicon: {
+            terminology: ["refactor", "deploy", "CI/CD", "microservice", "API", "SDK", "middleware", "ORM"],
+            language: "technical",
+            abbreviations: ["API", "SDK", "CI", "CD", "PR", "MR", "TDD", "BDD"]
+          },
+          frames: {
+            primary: ["code-editor-frame", "terminal-frame", "debug-frame"],
+            secondary: ["git-history-frame", "dependency-frame", "test-runner-frame"],
+            utility: ["documentation-frame", "api-explorer-frame", "performance-frame"]
+          },
+          templates: {
+            code: ["microservice-template", "api-gateway", "worker-service", "cli-tool"],
+            testing: ["unit-test-suite", "integration-test", "e2e-test", "load-test"],
+            deployment: ["docker-compose", "kubernetes-manifest", "serverless-config", "ci-pipeline"]
+          },
+          workflows: {
+            development: ["branch-develop-test-merge", "trunk-based-development"],
+            review: ["code-review", "pair-programming", "mob-programming"],
+            deployment: ["blue-green", "canary", "rolling-update", "feature-flags"]
+          },
+          aiModels: {
+            generation: ["code-generator", "test-generator", "documentation-generator"],
+            analysis: ["code-quality-analyzer", "security-scanner", "performance-profiler"],
+            suggestion: ["refactoring-advisor", "architecture-recommender", "dependency-checker"]
+          }
+        },
+        agilePM: {
+          sprints: {
+            methodology: "scrum",
+            cycles: ["planning", "daily-standup", "development", "review", "retrospective"],
+            duration: "2-weeks"
+          },
+          userStories: {
+            format: ["As a developer, I want...", "Technical requirement:", "Bug fix:"],
+            priorities: ["blocker", "critical", "major", "minor"],
+            categories: ["feature", "bug-fix", "tech-debt", "infrastructure"]
+          },
+          backlog: {
+            categories: ["features", "bugs", "tech-debt", "infrastructure", "documentation"],
+            priorities: ["critical", "high", "medium", "low"],
+            estimations: ["story-points", "fibonacci", "t-shirt-sizing"]
+          },
+          analytics: {
+            metrics: ["velocity", "bug-rate", "code-coverage", "deployment-frequency"],
+            reports: ["sprint-burndown", "velocity-chart", "cumulative-flow", "defect-density"],
+            tracking: ["task-hours", "story-completion", "sprint-goal-achievement"]
+          }
+        }
+      },
+      business_analyst: {
+        name: "Business Analyst",
+        description: "Business analyst focused on requirements gathering, process optimization, and stakeholder management",
+        focus: ["requirements", "process-analysis", "stakeholder-management", "data-analysis", "documentation"],
+        studio: {
+          interface: {
+            layout: "document-centric",
+            colorScheme: "professional-neutral",
+            typography: "serif-readable",
+            visualElements: ["document-editor", "diagram-tool", "spreadsheet", "stakeholder-map", "process-modeler"]
+          },
+          lexicon: {
+            terminology: ["requirement", "stakeholder", "process-flow", "use-case", "acceptance-criteria", "business-rule", "gap-analysis", "feasibility"],
+            language: "business-professional",
+            abbreviations: ["BA", "BRD", "SRS", "UAT", "KPI", "ROI", "SWOT"]
+          },
+          frames: {
+            primary: ["requirements-frame", "process-modeler-frame", "stakeholder-frame"],
+            secondary: ["data-analysis-frame", "reporting-frame", "documentation-frame"],
+            utility: ["meeting-notes-frame", "decision-log-frame", "risk-register-frame"]
+          },
+          templates: {
+            documents: ["business-requirements-doc", "functional-spec", "use-case-doc", "process-map"],
+            analysis: ["gap-analysis-template", "swot-analysis", "cost-benefit-analysis", "feasibility-study"],
+            presentations: ["stakeholder-presentation", "project-proposal", "status-report", "executive-summary"]
+          },
+          workflows: {
+            requirements: ["elicit-analyze-validate-manage", "interview-workshop-prototype-review"],
+            analysis: ["as-is-to-be-gap-recommendation", "data-collection-analysis-insight"],
+            management: ["stakeholder-identification-analysis-engagement", "change-impact-assessment"]
+          },
+          aiModels: {
+            generation: ["requirements-generator", "process-flow-generator", "report-generator"],
+            analysis: ["requirements-conflict-detector", "process-bottleneck-analyzer", "stakeholder-sentiment-analyzer"],
+            suggestion: ["requirement-prioritizer", "process-optimizer", "risk-identifier"]
+          }
+        },
+        agilePM: {
+          sprints: {
+            methodology: "kanban",
+            cycles: ["intake", "analysis", "validation", "documentation", "handoff"],
+            duration: "continuous"
+          },
+          userStories: {
+            format: ["As a business user, I want...", "Business requirement:", "Process improvement:"],
+            priorities: ["business-critical", "high-value", "medium-value", "low-value"],
+            categories: ["new-requirement", "change-request", "process-improvement", "compliance"]
+          },
+          backlog: {
+            categories: ["requirements", "analysis-tasks", "documentation", "reviews", "meetings"],
+            priorities: ["urgent", "high", "medium", "low"],
+            estimations: ["effort-hours", "complexity-rating", "business-value-score"]
+          },
+          analytics: {
+            metrics: ["requirements-throughput", "stakeholder-satisfaction", "defect-leakage", "requirement-stability"],
+            reports: ["requirements-status", "stakeholder-engagement", "process-efficiency", "change-impact"],
+            tracking: ["requirement-lifecycle", "approval-cycle-time", "rework-rate"]
+          }
+        }
+      },
+      data_scientist: {
+        name: "Data Scientist",
+        description: "Data scientist focused on extracting insights from data through analysis, modeling, and visualization",
+        focus: ["data-analysis", "machine-learning", "statistical-modeling", "data-visualization", "feature-engineering"],
+        studio: {
+          interface: {
+            layout: "notebook-centric",
+            colorScheme: "data-analytical",
+            typography: "technical-readable",
+            visualElements: ["notebook-editor", "data-explorer", "chart-builder", "model-inspector", "pipeline-viewer"]
+          },
+          lexicon: {
+            terminology: ["feature-engineering", "model-training", "hyperparameter", "cross-validation", "dimensionality-reduction", "ensemble", "gradient-descent", "overfitting"],
+            language: "scientific-technical",
+            abbreviations: ["ML", "DL", "NLP", "CNN", "RNN", "GAN", "PCA", "AUC"]
+          },
+          frames: {
+            primary: ["notebook-frame", "data-explorer-frame", "visualization-frame"],
+            secondary: ["model-training-frame", "experiment-tracker-frame", "pipeline-frame"],
+            utility: ["dataset-catalog-frame", "feature-store-frame", "model-registry-frame"]
+          },
+          templates: {
+            notebooks: ["eda-notebook", "model-training-notebook", "feature-engineering-notebook", "evaluation-notebook"],
+            pipelines: ["data-ingestion-pipeline", "feature-pipeline", "training-pipeline", "inference-pipeline"],
+            reports: ["analysis-report", "model-performance-report", "data-quality-report", "experiment-summary"]
+          },
+          workflows: {
+            analysis: ["collect-clean-explore-model-evaluate", "hypothesis-experiment-analyze-report"],
+            modeling: ["feature-select-train-validate-deploy", "experiment-track-compare-select"],
+            deployment: ["model-package-test-deploy-monitor", "ab-test-evaluate-rollout"]
+          },
+          aiModels: {
+            generation: ["feature-generator", "model-architecture-generator", "data-augmentation"],
+            analysis: ["data-quality-analyzer", "model-explainer", "drift-detector"],
+            suggestion: ["algorithm-recommender", "hyperparameter-tuner", "feature-importance-ranker"]
+          }
+        },
+        agilePM: {
+          sprints: {
+            methodology: "crisp-dm",
+            cycles: ["business-understanding", "data-understanding", "data-preparation", "modeling", "evaluation", "deployment"],
+            duration: "3-weeks"
+          },
+          userStories: {
+            format: ["As a data scientist, I want...", "Analysis requirement:", "Model specification:"],
+            priorities: ["high-impact", "medium-impact", "low-impact", "experimental"],
+            categories: ["data-exploration", "feature-engineering", "model-development", "deployment"]
+          },
+          backlog: {
+            categories: ["data-tasks", "modeling-tasks", "evaluation-tasks", "deployment-tasks", "research"],
+            priorities: ["critical", "high", "medium", "low"],
+            estimations: ["complexity-points", "computation-hours", "research-days"]
+          },
+          analytics: {
+            metrics: ["model-accuracy", "experiment-throughput", "data-pipeline-reliability", "model-latency"],
+            reports: ["experiment-dashboard", "model-comparison", "data-quality-dashboard", "pipeline-health"],
+            tracking: ["experiment-progress", "model-performance-over-time", "data-freshness"]
+          }
+        }
+      },
+      product_manager: {
+        name: "Product Manager",
+        description: "Product manager focused on strategy, roadmapping, and delivering value to users and the business",
+        focus: ["product-strategy", "roadmapping", "user-research", "prioritization", "go-to-market"],
+        studio: {
+          interface: {
+            layout: "strategic-overview",
+            colorScheme: "executive-clean",
+            typography: "professional-modern",
+            visualElements: ["roadmap-board", "metrics-dashboard", "user-feedback-panel", "competitive-landscape", "okr-tracker"]
+          },
+          lexicon: {
+            terminology: ["product-market-fit", "north-star-metric", "user-persona", "value-proposition", "product-backlog", "release-train", "feature-flag", "a-b-test"],
+            language: "product-strategic",
+            abbreviations: ["PM", "PRD", "OKR", "KPI", "MRR", "ARR", "NPS", "DAU", "MAU"]
+          },
+          frames: {
+            primary: ["roadmap-frame", "metrics-frame", "feedback-frame"],
+            secondary: ["competitive-analysis-frame", "user-research-frame", "release-frame"],
+            utility: ["stakeholder-frame", "experiment-frame", "documentation-frame"]
+          },
+          templates: {
+            documents: ["product-requirements-doc", "product-brief", "go-to-market-plan", "competitive-analysis"],
+            planning: ["quarterly-roadmap", "release-plan", "experiment-plan", "launch-checklist"],
+            communication: ["stakeholder-update", "sprint-review-deck", "product-newsletter", "feature-announcement"]
+          },
+          workflows: {
+            discovery: ["research-ideate-validate-build", "opportunity-solution-tree"],
+            delivery: ["define-design-develop-deliver", "dual-track-agile"],
+            analysis: ["measure-analyze-learn-iterate", "hypothesis-driven-development"]
+          },
+          aiModels: {
+            generation: ["prd-generator", "roadmap-generator", "release-notes-generator"],
+            analysis: ["user-feedback-analyzer", "competitive-intelligence", "churn-predictor"],
+            suggestion: ["feature-prioritizer", "experiment-recommender", "pricing-optimizer"]
+          }
+        },
+        agilePM: {
+          sprints: {
+            methodology: "dual-track-agile",
+            cycles: ["discovery", "definition", "delivery", "measurement", "iteration"],
+            duration: "2-weeks"
+          },
+          userStories: {
+            format: ["As a product user, I want...", "Product requirement:", "Feature specification:"],
+            priorities: ["must-have", "should-have", "could-have", "wont-have"],
+            categories: ["new-feature", "enhancement", "experiment", "tech-enabler"]
+          },
+          backlog: {
+            categories: ["features", "experiments", "tech-enablers", "bugs", "improvements"],
+            priorities: ["p0-critical", "p1-high", "p2-medium", "p3-low"],
+            estimations: ["impact-effort-matrix", "rice-score", "weighted-scoring"]
+          },
+          analytics: {
+            metrics: ["feature-adoption", "time-to-value", "customer-satisfaction", "revenue-impact"],
+            reports: ["product-health-dashboard", "feature-performance", "okr-progress", "release-metrics"],
+            tracking: ["feature-usage", "experiment-results", "customer-feedback-trends"]
+          }
+        }
+      }
+    };
+    for (const [id, config] of Object.entries(corePersonas)) {
+      const persona = {
+        ...config,
+        id,
+        createdAt: /* @__PURE__ */ new Date(),
+        lastModified: /* @__PURE__ */ new Date(),
+        usageCount: 0,
+        adaptationScore: 0,
+        customizations: /* @__PURE__ */ new Map()
+      };
+      this.personas.set(id, persona);
+    }
+  }
+  // ─── Event Listeners ──────────────────────────────────────────────────────
+  initializeEventListeners() {
+    this.on("persona:activated", (data) => {
+      console.log(`[BaselinePersonaEngine] Persona activated: ${data.personaId} for user ${data.userId}`);
+    });
+    this.on("persona:switched", (data) => {
+      console.log(`[BaselinePersonaEngine] Persona switched from ${data.fromPersonaId} to ${data.toPersonaId} for user ${data.userId}`);
+    });
+    this.on("persona:customized", (data) => {
+      console.log(`[BaselinePersonaEngine] Persona customized: ${data.personaId} for user ${data.userId}`);
+    });
+    this.on("behavior:recorded", (data) => {
+      if (this.config.enableBehavioralAnalysis) {
+        const patterns = this.analyzeBehaviorPatterns(data.userId);
+        if (patterns.length > 0 && this.config.enableAutonomousLearning) {
+          this.adaptPersonaAutonomously(data.userId, patterns);
+        }
+      }
+    });
+    this.on("adaptation:applied", (data) => {
+      console.log(`[BaselinePersonaEngine] Adaptation applied: ${data.type} to persona ${data.personaId} for user ${data.userId}`);
+    });
+  }
+  // ─── Persona Management ───────────────────────────────────────────────────
+  addPersona(id, config) {
+    if (this.personas.has(id)) {
+      throw new Error(`Persona with id '${id}' already exists`);
+    }
+    const persona = {
+      ...config,
+      id,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastModified: /* @__PURE__ */ new Date(),
+      usageCount: 0,
+      adaptationScore: 0,
+      customizations: /* @__PURE__ */ new Map()
+    };
+    this.personas.set(id, persona);
+    this.emit("persona:added", { personaId: id });
+    console.log(`[BaselinePersonaEngine] Persona added: ${id}`);
+    return persona;
+  }
+  setActivePersona(personaId, userId) {
+    const persona = this.personas.get(personaId);
+    if (!persona) {
+      throw new Error(`Persona '${personaId}' not found`);
+    }
+    const activePersona = {
+      ...persona,
+      userId,
+      activatedAt: /* @__PURE__ */ new Date(),
+      sessionId: randomUUID()
+    };
+    persona.usageCount++;
+    persona.lastModified = /* @__PURE__ */ new Date();
+    this.activePersonas.set(userId, activePersona);
+    this.emit("persona:activated", { personaId, userId });
+    return activePersona;
+  }
+  getActivePersona(userId) {
+    return this.activePersonas.get(userId);
+  }
+  getStudioConfig(userId) {
+    const activePersona = this.activePersonas.get(userId);
+    if (!activePersona) {
+      return null;
+    }
+    return activePersona.studio;
+  }
+  getAgilePMConfig(userId) {
+    const activePersona = this.activePersonas.get(userId);
+    if (!activePersona) {
+      return null;
+    }
+    return activePersona.agilePM;
+  }
+  customizePersona(personaId, userId, customizations) {
+    const persona = this.personas.get(personaId);
+    if (!persona) {
+      throw new Error(`Persona '${personaId}' not found`);
+    }
+    persona.customizations.set(userId, {
+      ...persona.customizations.get(userId) || {},
+      ...customizations
+    });
+    persona.lastModified = /* @__PURE__ */ new Date();
+    const activePersona = this.activePersonas.get(userId);
+    if (activePersona && activePersona.id === personaId) {
+      Object.assign(activePersona, this.deepMerge(activePersona, customizations));
+    }
+    this.emit("persona:customized", { personaId, userId, customizations });
+    return persona;
+  }
+  getPersonalizedPersona(personaId, userId) {
+    const persona = this.personas.get(personaId);
+    if (!persona) {
+      return null;
+    }
+    const userCustomizations = persona.customizations.get(userId);
+    if (!userCustomizations) {
+      return persona;
+    }
+    return this.deepMerge({ ...persona }, userCustomizations);
+  }
+  switchPersona(userId, newPersonaId) {
+    const currentPersona = this.activePersonas.get(userId);
+    const fromPersonaId = currentPersona ? currentPersona.id : "none";
+    const newActivePersona = this.setActivePersona(newPersonaId, userId);
+    this.emit("persona:switched", { fromPersonaId, toPersonaId: newPersonaId, userId });
+    return newActivePersona;
+  }
+  // ─── Behavioral Learning ──────────────────────────────────────────────────
+  learnFromBehavior(userId, behavior) {
+    if (!this.behaviorData.has(userId)) {
+      this.behaviorData.set(userId, []);
+    }
+    const entry = {
+      ...behavior,
+      timestamp: behavior.timestamp || /* @__PURE__ */ new Date()
+    };
+    this.behaviorData.get(userId).push(entry);
+    this.emit("behavior:recorded", { userId, type: behavior.type });
+  }
+  analyzeBehaviorPatterns(userId) {
+    const data = this.behaviorData.get(userId);
+    if (!data || data.length < 3) {
+      return [];
+    }
+    const patterns = [];
+    const workflowPattern = this.identifyWorkflowPattern(data);
+    if (workflowPattern) {
+      patterns.push(workflowPattern);
+    }
+    const toolPattern = this.identifyToolPreferencePattern(data);
+    if (toolPattern) {
+      patterns.push(toolPattern);
+    }
+    const timePattern = this.identifyTimePattern(data);
+    if (timePattern) {
+      patterns.push(timePattern);
+    }
+    const collaborationPattern = this.identifyCollaborationPattern(data);
+    if (collaborationPattern) {
+      patterns.push(collaborationPattern);
+    }
+    return patterns;
+  }
+  identifyPattern(data, type) {
+    const relevantData = data.filter((d) => d.type === type);
+    if (relevantData.length < 2) {
+      return null;
+    }
+    const confidence = Math.min(relevantData.length / 10, 1);
+    return {
+      type,
+      confidence,
+      data: relevantData
+    };
+  }
+  identifyWorkflowPattern(data) {
+    const workflowData = data.filter(
+      (d) => d.type === "workflow_start" || d.type === "workflow_complete" || d.type === "workflow_step"
+    );
+    if (workflowData.length < 3) {
+      return null;
+    }
+    const workflowTypes = /* @__PURE__ */ new Map();
+    for (const d of workflowData) {
+      const wType = d.workflowType || "unknown";
+      workflowTypes.set(wType, (workflowTypes.get(wType) || 0) + 1);
+    }
+    const confidence = Math.min(workflowData.length / 15, 1);
+    return {
+      type: "workflow_preference",
+      confidence,
+      data: workflowData
+    };
+  }
+  identifyToolPreferencePattern(data) {
+    const toolData = data.filter(
+      (d) => d.type === "tool_used" || d.type === "tool_selected" || d.type === "tool_configured"
+    );
+    if (toolData.length < 2) {
+      return null;
+    }
+    const confidence = Math.min(toolData.length / 10, 1);
+    return {
+      type: "tool_preference",
+      confidence,
+      data: toolData
+    };
+  }
+  identifyTimePattern(data) {
+    const timedData = data.filter((d) => d.timestamp instanceof Date);
+    if (timedData.length < 5) {
+      return null;
+    }
+    const hours = timedData.map((d) => d.timestamp.getHours());
+    const avgHour = hours.reduce((a, b) => a + b, 0) / hours.length;
+    const variance = hours.reduce((sum, h) => sum + Math.pow(h - avgHour, 2), 0) / hours.length;
+    if (variance < 16) {
+      return {
+        type: "time_preference",
+        confidence: Math.min(1 - variance / 16, 1),
+        data: timedData
+      };
+    }
+    return null;
+  }
+  identifyCollaborationPattern(data) {
+    const collabData = data.filter(
+      (d) => d.type === "collaboration" || d.type === "shared" || d.type === "commented" || d.type === "reviewed"
+    );
+    if (collabData.length < 2) {
+      return null;
+    }
+    const confidence = Math.min(collabData.length / 8, 1);
+    return {
+      type: "collaboration_preference",
+      confidence,
+      data: collabData
+    };
+  }
+  // ─── Autonomous Adaptation ────────────────────────────────────────────────
+  adaptPersonaAutonomously(userId, patterns) {
+    const activePersona = this.activePersonas.get(userId);
+    if (!activePersona) {
+      return;
+    }
+    for (const pattern of patterns) {
+      if (pattern.confidence < 0.5) {
+        continue;
+      }
+      const adaptation = this.generateAdaptation(activePersona.id, userId, pattern);
+      if (adaptation) {
+        this.applyPersonaAdaptation(adaptation);
+      }
+    }
+  }
+  generateAdaptation(personaId, userId, pattern) {
+    let changes = {};
+    switch (pattern.type) {
+      case "workflow_preference":
+        changes = this.generateWorkflowAdaptation(pattern);
+        break;
+      case "tool_preference":
+        changes = this.generateToolAdaptation(pattern);
+        break;
+      case "time_preference":
+        changes = this.generateTimeAdaptation(pattern);
+        break;
+      case "collaboration_preference":
+        changes = this.generateCollaborationAdaptation(pattern);
+        break;
+      default:
+        return null;
+    }
+    if (Object.keys(changes).length === 0) {
+      return null;
+    }
+    return {
+      id: randomUUID(),
+      personaId,
+      userId,
+      type: pattern.type,
+      changes,
+      confidence: pattern.confidence,
+      appliedAt: /* @__PURE__ */ new Date(),
+      source: "autonomous-learning"
+    };
+  }
+  generateWorkflowAdaptation(pattern) {
+    const workflowCounts = /* @__PURE__ */ new Map();
+    for (const d of pattern.data) {
+      const wType = d.workflowType || "default";
+      workflowCounts.set(wType, (workflowCounts.get(wType) || 0) + 1);
+    }
+    let preferredWorkflow = "default";
+    let maxCount = 0;
+    for (const [wType, count] of workflowCounts) {
+      if (count > maxCount) {
+        maxCount = count;
+        preferredWorkflow = wType;
+      }
+    }
+    return {
+      studio: {
+        workflows: {
+          preferred: preferredWorkflow,
+          frequencyMap: Object.fromEntries(workflowCounts)
+        }
+      }
+    };
+  }
+  generateToolAdaptation(pattern) {
+    const toolCounts = /* @__PURE__ */ new Map();
+    for (const d of pattern.data) {
+      const tool = d.tool || d.toolName || "unknown";
+      toolCounts.set(tool, (toolCounts.get(tool) || 0) + 1);
+    }
+    const preferredTools = [];
+    for (const [tool, count] of toolCounts) {
+      if (count >= 2) {
+        preferredTools.push(tool);
+      }
+    }
+    return {
+      studio: {
+        interface: {
+          preferredTools,
+          toolUsageMap: Object.fromEntries(toolCounts)
+        }
+      }
+    };
+  }
+  generateTimeAdaptation(pattern) {
+    const hours = pattern.data.filter((d) => d.timestamp instanceof Date).map((d) => d.timestamp.getHours());
+    if (hours.length === 0) {
+      return {};
+    }
+    const avgHour = Math.round(hours.reduce((a, b) => a + b, 0) / hours.length);
+    let timePreference = "flexible";
+    if (avgHour >= 5 && avgHour < 12) {
+      timePreference = "morning";
+    } else if (avgHour >= 12 && avgHour < 17) {
+      timePreference = "afternoon";
+    } else if (avgHour >= 17 && avgHour < 21) {
+      timePreference = "evening";
+    } else {
+      timePreference = "night";
+    }
+    return {
+      preferences: {
+        activeHours: { average: avgHour, preference: timePreference }
+      }
+    };
+  }
+  generateCollaborationAdaptation(pattern) {
+    const collabTypes = /* @__PURE__ */ new Map();
+    for (const d of pattern.data) {
+      collabTypes.set(d.type, (collabTypes.get(d.type) || 0) + 1);
+    }
+    const collaborators = /* @__PURE__ */ new Set();
+    for (const d of pattern.data) {
+      if (d.collaborator) {
+        collaborators.add(d.collaborator);
+      }
+      if (d.reviewer) {
+        collaborators.add(d.reviewer);
+      }
+    }
+    return {
+      preferences: {
+        collaboration: {
+          style: collabTypes.size > 2 ? "highly-collaborative" : "selective",
+          frequentCollaborators: Array.from(collaborators),
+          preferredMethods: Object.fromEntries(collabTypes)
+        }
+      }
+    };
+  }
+  applyPersonaAdaptation(adaptation) {
+    const persona = this.personas.get(adaptation.personaId);
+    if (!persona) {
+      return;
+    }
+    const existingCustomizations = persona.customizations.get(adaptation.userId) || {};
+    persona.customizations.set(
+      adaptation.userId,
+      this.deepMerge(existingCustomizations, adaptation.changes)
+    );
+    persona.adaptationScore = Math.min(persona.adaptationScore + adaptation.confidence * 0.1, 1);
+    persona.lastModified = /* @__PURE__ */ new Date();
+    const activePersona = this.activePersonas.get(adaptation.userId);
+    if (activePersona && activePersona.id === adaptation.personaId) {
+      Object.assign(activePersona, this.deepMerge(activePersona, adaptation.changes));
+      activePersona.adaptationScore = persona.adaptationScore;
+    }
+    this.adaptations.push(adaptation);
+    this.emit("adaptation:applied", {
+      personaId: adaptation.personaId,
+      userId: adaptation.userId,
+      type: adaptation.type,
+      confidence: adaptation.confidence
+    });
+  }
+  // ─── Recommendations ──────────────────────────────────────────────────────
+  getPersonaRecommendations(userId, context = {}) {
+    const behaviors = this.behaviorData.get(userId) || [];
+    const patterns = this.analyzeBehaviorPatterns(userId);
+    const recommendations = [];
+    for (const [personaId, persona] of this.personas) {
+      const patternScore = this.calculatePatternFitScore(persona, patterns);
+      const contextScore = this.calculateContextFitScore(persona, context);
+      const personaScore = this.calculatePersonaFitScore(persona, behaviors);
+      const totalScore = patternScore * 0.4 + contextScore * 0.3 + personaScore * 0.3;
+      recommendations.push({
+        personaId,
+        score: Math.round(totalScore * 100) / 100,
+        reasoning: this.generateRecommendationReasoning(persona, patternScore, contextScore, personaScore),
+        fitScores: {
+          pattern: Math.round(patternScore * 100) / 100,
+          context: Math.round(contextScore * 100) / 100,
+          persona: Math.round(personaScore * 100) / 100
+        }
+      });
+    }
+    recommendations.sort((a, b) => b.score - a.score);
+    return recommendations;
+  }
+  calculatePersonaFitScore(persona, behaviors) {
+    if (behaviors.length === 0) {
+      return 0.5;
+    }
+    let score = 0;
+    const focusAreas = persona.focus;
+    for (const behavior of behaviors) {
+      const behaviorType = behavior.type.toLowerCase();
+      for (const focus of focusAreas) {
+        if (behaviorType.includes(focus) || focus.includes(behaviorType)) {
+          score += this.getPatternWeight(behavior.type);
+        }
+      }
+    }
+    return Math.min(score / behaviors.length, 1);
+  }
+  calculatePatternFitScore(persona, patterns) {
+    if (patterns.length === 0) {
+      return 0.5;
+    }
+    let totalScore = 0;
+    for (const pattern of patterns) {
+      const weight = this.getPatternWeight(pattern.type);
+      totalScore += pattern.confidence * weight;
+    }
+    return Math.min(totalScore / patterns.length, 1);
+  }
+  calculateContextFitScore(persona, context) {
+    if (Object.keys(context).length === 0) {
+      return 0.5;
+    }
+    let matchCount = 0;
+    let totalChecks = 0;
+    const contextData = this.extractContextData(context);
+    const focusAreas = persona.focus;
+    for (const item of contextData) {
+      totalChecks++;
+      for (const focus of focusAreas) {
+        if (item.toLowerCase().includes(focus) || focus.includes(item.toLowerCase())) {
+          matchCount++;
+          break;
+        }
+      }
+    }
+    return totalChecks > 0 ? matchCount / totalChecks : 0.5;
+  }
+  generateRecommendationReasoning(persona, patternScore, contextScore, personaScore) {
+    const reasons = [];
+    if (patternScore > 0.7) {
+      reasons.push(`Strong behavioral pattern match with ${persona.name} workflows`);
+    } else if (patternScore > 0.4) {
+      reasons.push(`Moderate behavioral alignment with ${persona.name} focus areas`);
+    }
+    if (contextScore > 0.7) {
+      reasons.push(`Current context strongly aligns with ${persona.name} capabilities`);
+    } else if (contextScore > 0.4) {
+      reasons.push(`Some contextual relevance to ${persona.name} tools and processes`);
+    }
+    if (personaScore > 0.7) {
+      reasons.push(`Historical usage patterns strongly favor ${persona.name} persona`);
+    } else if (personaScore > 0.4) {
+      reasons.push(`Some historical affinity with ${persona.name} persona`);
+    }
+    if (reasons.length === 0) {
+      reasons.push(`${persona.name} is available as a general-purpose persona option`);
+    }
+    return reasons.join(". ") + ".";
+  }
+  // ─── Utility Methods ──────────────────────────────────────────────────────
+  deepMerge(target, source) {
+    const output = { ...target };
+    for (const key of Object.keys(source)) {
+      if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && !(source[key] instanceof Date) && !(source[key] instanceof Map) && !(source[key] instanceof Set)) {
+        if (target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+          output[key] = this.deepMerge(target[key], source[key]);
+        } else {
+          output[key] = { ...source[key] };
+        }
+      } else {
+        output[key] = source[key];
+      }
+    }
+    return output;
+  }
+  calculateCustomizationLevel(persona) {
+    let level = 0;
+    for (const [, customizations] of persona.customizations) {
+      level += Object.keys(customizations).length;
+    }
+    return Math.min(level / 10, 1);
+  }
+  extractContextData(context) {
+    const data = [];
+    for (const [key, value] of Object.entries(context)) {
+      data.push(key);
+      if (typeof value === "string") {
+        data.push(value);
+      } else if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "string") {
+            data.push(item);
+          }
+        }
+      }
+    }
+    return data;
+  }
+  getPatternWeight(type) {
+    const weights = {
+      workflow_preference: 0.9,
+      tool_preference: 0.8,
+      time_preference: 0.3,
+      collaboration_preference: 0.7,
+      workflow_start: 0.6,
+      workflow_complete: 0.8,
+      workflow_step: 0.4,
+      tool_used: 0.7,
+      tool_selected: 0.5,
+      tool_configured: 0.6,
+      collaboration: 0.5,
+      shared: 0.4,
+      commented: 0.3,
+      reviewed: 0.6
+    };
+    return weights[type] || 0.5;
+  }
+  // ─── Analytics & Status ────────────────────────────────────────────────────
+  getStatus() {
+    return {
+      initialized: this.initialized,
+      totalPersonas: this.personas.size,
+      activePersonas: this.activePersonas.size,
+      behaviorDataPoints: this.countBehaviorTypes(),
+      adaptationsApplied: this.adaptations.length,
+      config: { ...this.config }
+    };
+  }
+  getAnalytics() {
+    const behaviorsByType = {};
+    for (const [, behaviors] of this.behaviorData) {
+      for (const b of behaviors) {
+        behaviorsByType[b.type] = (behaviorsByType[b.type] || 0) + 1;
+      }
+    }
+    let totalAdaptationScore = 0;
+    let personaCount = 0;
+    for (const [, persona] of this.personas) {
+      totalAdaptationScore += persona.adaptationScore;
+      personaCount++;
+    }
+    return {
+      totalPersonas: this.personas.size,
+      activePersonas: this.activePersonas.size,
+      totalBehaviors: this.countBehaviorTypes(),
+      behaviorsByType,
+      totalAdaptations: this.adaptations.length,
+      adaptationsByPersona: this.groupAdaptationsByPersona(),
+      adaptationsByUser: this.groupAdaptationsByUser(),
+      averageAdaptationScore: personaCount > 0 ? totalAdaptationScore / personaCount : 0
+    };
+  }
+  countBehaviorTypes() {
+    let total = 0;
+    for (const [, behaviors] of this.behaviorData) {
+      total += behaviors.length;
+    }
+    return total;
+  }
+  groupAdaptationsByPersona() {
+    const groups = {};
+    for (const adaptation of this.adaptations) {
+      groups[adaptation.personaId] = (groups[adaptation.personaId] || 0) + 1;
+    }
+    return groups;
+  }
+  groupAdaptationsByUser() {
+    const groups = {};
+    for (const adaptation of this.adaptations) {
+      groups[adaptation.userId] = (groups[adaptation.userId] || 0) + 1;
+    }
+    return groups;
+  }
+};
+
+// src/ui.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { randomUUID as randomUUID2 } from "crypto";
+var PersonaUISystem = class extends EventEmitter2 {
+  engine;
+  components;
+  selectorState;
+  studioState;
+  workflows;
+  progressStates;
+  resultDisplays;
+  config;
+  initialized;
+  constructor(engine, config = {}) {
+    super();
+    this.engine = engine;
+    this.components = /* @__PURE__ */ new Map();
+    this.workflows = /* @__PURE__ */ new Map();
+    this.progressStates = /* @__PURE__ */ new Map();
+    this.resultDisplays = /* @__PURE__ */ new Map();
+    this.config = {
+      defaultLayout: config.defaultLayout || "responsive",
+      defaultTheme: config.defaultTheme || "system",
+      enableAnimations: config.enableAnimations ?? true,
+      enableTransitions: config.enableTransitions ?? true,
+      selectorPosition: config.selectorPosition || "top-right",
+      maxWorkflows: config.maxWorkflows || 10,
+      progressUpdateInterval: config.progressUpdateInterval || 1e3
+    };
+    this.selectorState = {
+      isOpen: false,
+      selectedPersonaId: null,
+      hoveredPersonaId: null,
+      searchQuery: "",
+      filteredOptions: []
+    };
+    this.studioState = {
+      activeFrames: [],
+      layout: this.config.defaultLayout,
+      theme: this.config.defaultTheme,
+      panels: [],
+      toolbars: []
+    };
+    this.initialized = false;
+    this.initializeComponents();
+    this.initializeEventListeners();
+    this.initialized = true;
+    console.log("[PersonaUISystem] UI system initialized");
+  }
+  // ─── Component Initialization ─────────────────────────────────────────────
+  initializeComponents() {
+    this.registerComponent({
+      id: "persona-selector",
+      type: "selector",
+      visible: true,
+      position: { x: 0, y: 0 },
+      size: { width: 320, height: 480 },
+      config: {
+        position: this.config.selectorPosition,
+        showSearch: true,
+        showDescriptions: true,
+        showFocusAreas: true,
+        animateTransitions: this.config.enableAnimations
+      },
+      state: {}
+    });
+    this.registerComponent({
+      id: "studio-interface",
+      type: "studio",
+      visible: false,
+      position: { x: 0, y: 0 },
+      size: { width: 1920, height: 1080 },
+      config: {
+        layout: this.config.defaultLayout,
+        theme: this.config.defaultTheme,
+        enableDragDrop: true,
+        enableResize: true,
+        enablePanelCollapse: true
+      },
+      state: {}
+    });
+    this.registerComponent({
+      id: "workflow-engine",
+      type: "workflow",
+      visible: false,
+      position: { x: 0, y: 0 },
+      size: { width: 800, height: 600 },
+      config: {
+        maxConcurrent: this.config.maxWorkflows,
+        showProgress: true,
+        enableCancel: true,
+        enablePause: false
+      },
+      state: {}
+    });
+    this.registerComponent({
+      id: "result-display",
+      type: "display",
+      visible: false,
+      position: { x: 0, y: 0 },
+      size: { width: 800, height: 600 },
+      config: {
+        formats: ["table", "chart", "json", "markdown", "html"],
+        defaultFormat: "table",
+        enableExport: true,
+        enableShare: true
+      },
+      state: {}
+    });
+    this.registerComponent({
+      id: "progress-tracker",
+      type: "tracker",
+      visible: false,
+      position: { x: 0, y: 0 },
+      size: { width: 400, height: 200 },
+      config: {
+        updateInterval: this.config.progressUpdateInterval,
+        showEstimatedTime: true,
+        showStepDetails: true,
+        position: "bottom-right"
+      },
+      state: {}
+    });
+  }
+  initializeEventListeners() {
+    this.on("selector:opened", () => {
+      this.selectorState.isOpen = true;
+      this.updateComponent("persona-selector", { state: { isOpen: true } });
+      console.log("[PersonaUISystem] Persona selector opened");
+    });
+    this.on("selector:closed", () => {
+      this.selectorState.isOpen = false;
+      this.selectorState.hoveredPersonaId = null;
+      this.updateComponent("persona-selector", { state: { isOpen: false } });
+      console.log("[PersonaUISystem] Persona selector closed");
+    });
+    this.on("persona:selected", (data) => {
+      this.handlePersonaSelection(data.personaId, data.userId);
+    });
+    this.on("workflow:started", (data) => {
+      this.showComponent("progress-tracker");
+      console.log(`[PersonaUISystem] Workflow started: ${data.workflowId}`);
+    });
+    this.on("workflow:completed", (data) => {
+      this.showComponent("result-display");
+      console.log(`[PersonaUISystem] Workflow completed: ${data.workflowId}`);
+    });
+    this.on("workflow:failed", (data) => {
+      console.log(`[PersonaUISystem] Workflow failed: ${data.workflowId} - ${data.error}`);
+    });
+  }
+  // ─── Component Management ─────────────────────────────────────────────────
+  registerComponent(component) {
+    this.components.set(component.id, component);
+    this.emit("component:registered", { componentId: component.id, type: component.type });
+  }
+  getComponent(id) {
+    return this.components.get(id);
+  }
+  updateComponent(id, updates) {
+    const component = this.components.get(id);
+    if (!component) {
+      return null;
+    }
+    if (updates.config) {
+      component.config = { ...component.config, ...updates.config };
+    }
+    if (updates.state) {
+      component.state = { ...component.state, ...updates.state };
+    }
+    if (updates.position) {
+      component.position = updates.position;
+    }
+    if (updates.size) {
+      component.size = updates.size;
+    }
+    if (updates.visible !== void 0) {
+      component.visible = updates.visible;
+    }
+    this.emit("component:updated", { componentId: id, updates });
+    return component;
+  }
+  showComponent(id) {
+    this.updateComponent(id, { visible: true });
+    this.emit("component:shown", { componentId: id });
+  }
+  hideComponent(id) {
+    this.updateComponent(id, { visible: false });
+    this.emit("component:hidden", { componentId: id });
+  }
+  removeComponent(id) {
+    const removed = this.components.delete(id);
+    if (removed) {
+      this.emit("component:removed", { componentId: id });
+    }
+    return removed;
+  }
+  getAllComponents() {
+    return Array.from(this.components.values());
+  }
+  getVisibleComponents() {
+    return Array.from(this.components.values()).filter((c) => c.visible);
+  }
+  // ─── Persona Selector ─────────────────────────────────────────────────────
+  openSelector() {
+    this.emit("selector:opened");
+  }
+  closeSelector() {
+    this.emit("selector:closed");
+  }
+  toggleSelector() {
+    if (this.selectorState.isOpen) {
+      this.closeSelector();
+    } else {
+      this.openSelector();
+    }
+  }
+  setSearchQuery(query) {
+    this.selectorState.searchQuery = query;
+    const filtered = this.filterPersonaOptions(query);
+    this.selectorState.filteredOptions = filtered;
+    this.emit("selector:filtered", { query, count: filtered.length });
+    return filtered;
+  }
+  filterPersonaOptions(query) {
+    const allOptions = this.getPersonaOptions();
+    if (!query || query.trim() === "") {
+      return allOptions;
+    }
+    const lowerQuery = query.toLowerCase();
+    return allOptions.filter(
+      (option) => option.name.toLowerCase().includes(lowerQuery) || option.description.toLowerCase().includes(lowerQuery) || option.focus.some((f) => f.toLowerCase().includes(lowerQuery))
+    );
+  }
+  getPersonaOptions() {
+    const options = [];
+    const personaColors = {
+      designer: "#FF6B6B",
+      developer: "#4ECDC4",
+      business_analyst: "#45B7D1",
+      data_scientist: "#96CEB4",
+      product_manager: "#FFEAA7"
+    };
+    const personaIcons = {
+      designer: "palette",
+      developer: "code",
+      business_analyst: "briefcase",
+      data_scientist: "chart",
+      product_manager: "target"
+    };
+    const corePersonaIds = ["designer", "developer", "business_analyst", "data_scientist", "product_manager"];
+    for (const id of corePersonaIds) {
+      const persona = this.engine.getActivePersona(id);
+      if (persona) {
+        options.push({
+          id: persona.id,
+          name: persona.name,
+          description: persona.description,
+          focus: persona.focus,
+          icon: personaIcons[id],
+          color: personaColors[id]
+        });
+      } else {
+        options.push(this.getDefaultPersonaOption(id, personaIcons[id], personaColors[id]));
+      }
+    }
+    if (options.length === 0) {
+      for (const id of corePersonaIds) {
+        options.push(this.getDefaultPersonaOption(id, personaIcons[id], personaColors[id]));
+      }
+    }
+    return options;
+  }
+  getDefaultPersonaOption(id, icon, color) {
+    const defaults = {
+      designer: {
+        id: "designer",
+        name: "Designer",
+        description: "Visual and UX designer focused on creating beautiful, intuitive interfaces",
+        focus: ["visual-design", "ux-research", "prototyping", "design-systems", "accessibility"],
+        icon: icon || "palette",
+        color: color || "#FF6B6B"
+      },
+      developer: {
+        id: "developer",
+        name: "Developer",
+        description: "Software developer focused on building robust, scalable applications",
+        focus: ["coding", "architecture", "testing", "deployment", "performance"],
+        icon: icon || "code",
+        color: color || "#4ECDC4"
+      },
+      business_analyst: {
+        id: "business_analyst",
+        name: "Business Analyst",
+        description: "Business analyst focused on requirements gathering and process optimization",
+        focus: ["requirements", "process-analysis", "stakeholder-management", "data-analysis"],
+        icon: icon || "briefcase",
+        color: color || "#45B7D1"
+      },
+      data_scientist: {
+        id: "data_scientist",
+        name: "Data Scientist",
+        description: "Data scientist focused on extracting insights through analysis and modeling",
+        focus: ["data-analysis", "machine-learning", "statistical-modeling", "data-visualization"],
+        icon: icon || "chart",
+        color: color || "#96CEB4"
+      },
+      product_manager: {
+        id: "product_manager",
+        name: "Product Manager",
+        description: "Product manager focused on strategy, roadmapping, and delivering value",
+        focus: ["product-strategy", "roadmapping", "user-research", "prioritization"],
+        icon: icon || "target",
+        color: color || "#FFEAA7"
+      }
+    };
+    return defaults[id] || {
+      id,
+      name: id.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+      description: `Persona: ${id}`,
+      focus: [],
+      icon: icon || "user",
+      color: color || "#CCCCCC"
+    };
+  }
+  hoverPersona(personaId) {
+    this.selectorState.hoveredPersonaId = personaId;
+    this.emit("selector:hovered", { personaId });
+  }
+  selectPersona(personaId, userId) {
+    this.selectorState.selectedPersonaId = personaId;
+    this.emit("persona:selected", { personaId, userId });
+    this.closeSelector();
+  }
+  getSelectorState() {
+    return { ...this.selectorState };
+  }
+  // ─── Persona Selection Handling ────────────────────────────────────────────
+  handlePersonaSelection(personaId, userId) {
+    try {
+      const activePersona = this.engine.setActivePersona(personaId, userId);
+      this.applyPersonaToStudio(activePersona);
+      this.engine.learnFromBehavior(userId, {
+        type: "persona_selected",
+        personaId,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      console.log(`[PersonaUISystem] Persona applied: ${personaId} for user ${userId}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[PersonaUISystem] Failed to apply persona: ${message}`);
+      this.emit("error", { type: "persona_selection_failed", personaId, userId, error: message });
+    }
+  }
+  applyPersonaToStudio(persona) {
+    const studioConfig = persona.studio;
+    this.studioState.layout = studioConfig.interface.layout;
+    this.studioState.theme = studioConfig.interface.colorScheme;
+    this.studioState.activeFrames = [
+      ...studioConfig.frames.primary || [],
+      ...studioConfig.frames.secondary || []
+    ];
+    this.updateComponent("studio-interface", {
+      visible: true,
+      config: {
+        layout: studioConfig.interface.layout,
+        theme: studioConfig.interface.colorScheme,
+        typography: studioConfig.interface.typography,
+        visualElements: studioConfig.interface.visualElements
+      },
+      state: {
+        activePersonaId: persona.id,
+        activeFrames: this.studioState.activeFrames
+      }
+    });
+    this.studioState.panels = this.generatePanels(studioConfig);
+    this.studioState.toolbars = this.generateToolbars(studioConfig);
+    this.emit("studio:configured", {
+      personaId: persona.id,
+      layout: studioConfig.interface.layout,
+      frameCount: this.studioState.activeFrames.length
+    });
+  }
+  generatePanels(studioConfig) {
+    const panels = [];
+    const visualElements = studioConfig.interface.visualElements || [];
+    for (let i = 0; i < visualElements.length; i++) {
+      panels.push({
+        id: `panel-${visualElements[i]}`,
+        type: "panel",
+        visible: true,
+        position: { x: 0, y: i * 200 },
+        size: { width: 300, height: 200 },
+        config: {
+          title: visualElements[i].replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+          collapsible: true,
+          draggable: true
+        },
+        state: {}
+      });
+    }
+    return panels;
+  }
+  generateToolbars(studioConfig) {
+    const toolbars = [];
+    const workflows = studioConfig.workflows || {};
+    for (const [category, items] of Object.entries(workflows)) {
+      toolbars.push({
+        id: `toolbar-${category}`,
+        type: "toolbar",
+        visible: true,
+        position: { x: 0, y: 0 },
+        size: { width: 600, height: 48 },
+        config: {
+          category,
+          items,
+          orientation: "horizontal"
+        },
+        state: {}
+      });
+    }
+    return toolbars;
+  }
+  getStudioState() {
+    return { ...this.studioState };
+  }
+  // ─── Workflow Engine ──────────────────────────────────────────────────────
+  startWorkflow(type, personaId, userId, parameters = {}) {
+    if (this.workflows.size >= this.config.maxWorkflows) {
+      throw new Error(`Maximum concurrent workflows (${this.config.maxWorkflows}) reached`);
+    }
+    const steps = this.generateWorkflowSteps(type, personaId);
+    const workflow = {
+      id: randomUUID2(),
+      type,
+      personaId,
+      userId,
+      parameters,
+      startTime: /* @__PURE__ */ new Date(),
+      status: "pending",
+      progress: 0,
+      steps,
+      results: {}
+    };
+    this.workflows.set(workflow.id, workflow);
+    const progressState = {
+      workflowId: workflow.id,
+      phase: "initialization",
+      percentage: 0,
+      currentStep: steps.length > 0 ? steps[0].name : "unknown",
+      stepsCompleted: 0,
+      totalSteps: steps.length,
+      startedAt: /* @__PURE__ */ new Date()
+    };
+    this.progressStates.set(workflow.id, progressState);
+    this.emit("workflow:started", { workflowId: workflow.id, type, personaId, userId });
+    this.engine.learnFromBehavior(userId, {
+      type: "workflow_start",
+      workflowType: type,
+      personaId,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    this.runWorkflow(workflow.id);
+    return workflow;
+  }
+  generateWorkflowSteps(type, _personaId) {
+    const defaultSteps = {
+      design: ["Research", "Ideation", "Wireframing", "Mockup", "Prototype", "Testing", "Iteration"],
+      development: ["Planning", "Architecture", "Implementation", "Testing", "Code Review", "Deployment"],
+      analysis: ["Data Collection", "Data Cleaning", "Exploration", "Analysis", "Visualization", "Reporting"],
+      "product-planning": ["Research", "Strategy", "Requirements", "Prioritization", "Roadmap", "Communication"],
+      "sprint-planning": ["Backlog Review", "Capacity Planning", "Story Selection", "Task Breakdown", "Commitment"],
+      default: ["Initialize", "Process", "Validate", "Complete"]
+    };
+    const stepNames = defaultSteps[type] || defaultSteps["default"];
+    return stepNames.map((name, index) => ({
+      id: randomUUID2(),
+      name,
+      description: `${name} phase of ${type} workflow`,
+      status: index === 0 ? "active" : "pending",
+      data: {}
+    }));
+  }
+  async runWorkflow(workflowId) {
+    const workflow = this.workflows.get(workflowId);
+    if (!workflow) {
+      return;
+    }
+    workflow.status = "running";
+    for (let i = 0; i < workflow.steps.length; i++) {
+      const step = workflow.steps[i];
+      if (workflow.status === "cancelled") {
+        step.status = "skipped";
+        continue;
+      }
+      step.status = "active";
+      step.startedAt = /* @__PURE__ */ new Date();
+      this.updateProgress(workflowId, {
+        phase: step.name.toLowerCase(),
+        currentStep: step.name,
+        stepsCompleted: i,
+        percentage: Math.round(i / workflow.steps.length * 100)
+      });
+      this.emit("workflow:step", { workflowId, stepId: step.id, stepName: step.name, stepIndex: i });
+      try {
+        await this.executeWorkflowStep(workflow, step);
+        step.status = "completed";
+        step.completedAt = /* @__PURE__ */ new Date();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        step.status = "failed";
+        workflow.status = "failed";
+        workflow.error = message;
+        workflow.endTime = /* @__PURE__ */ new Date();
+        this.emit("workflow:failed", { workflowId, error: message, failedStep: step.name });
+        return;
+      }
+    }
+    workflow.status = "completed";
+    workflow.progress = 100;
+    workflow.endTime = /* @__PURE__ */ new Date();
+    this.updateProgress(workflowId, {
+      phase: "complete",
+      currentStep: "Done",
+      stepsCompleted: workflow.steps.length,
+      percentage: 100
+    });
+    this.generateResults(workflow);
+    this.emit("workflow:completed", { workflowId, results: workflow.results });
+    this.engine.learnFromBehavior(workflow.userId, {
+      type: "workflow_complete",
+      workflowType: workflow.type,
+      personaId: workflow.personaId,
+      duration: workflow.endTime.getTime() - workflow.startTime.getTime(),
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  async executeWorkflowStep(workflow, step) {
+    const duration = 50 + Math.random() * 150;
+    await new Promise((resolve) => setTimeout(resolve, duration));
+    step.data = {
+      executedAt: /* @__PURE__ */ new Date(),
+      duration,
+      workflowType: workflow.type,
+      personaId: workflow.personaId
+    };
+  }
+  generateResults(workflow) {
+    const completedSteps = workflow.steps.filter((s) => s.status === "completed");
+    const failedSteps = workflow.steps.filter((s) => s.status === "failed");
+    const totalDuration = workflow.endTime ? workflow.endTime.getTime() - workflow.startTime.getTime() : 0;
+    workflow.results = {
+      summary: {
+        workflowType: workflow.type,
+        personaId: workflow.personaId,
+        totalSteps: workflow.steps.length,
+        completedSteps: completedSteps.length,
+        failedSteps: failedSteps.length,
+        totalDuration,
+        averageStepDuration: completedSteps.length > 0 ? totalDuration / completedSteps.length : 0
+      },
+      steps: workflow.steps.map((s) => ({
+        name: s.name,
+        status: s.status,
+        duration: s.completedAt && s.startedAt ? s.completedAt.getTime() - s.startedAt.getTime() : null,
+        data: s.data
+      })),
+      artifacts: this.generateArtifacts(workflow)
+    };
+  }
+  generateArtifacts(workflow) {
+    const artifacts = [];
+    switch (workflow.type) {
+      case "design":
+        artifacts.push(
+          { type: "wireframe", name: "Initial Wireframes", format: "svg" },
+          { type: "mockup", name: "High-Fidelity Mockups", format: "png" },
+          { type: "prototype", name: "Interactive Prototype", format: "html" }
+        );
+        break;
+      case "development":
+        artifacts.push(
+          { type: "code", name: "Source Code", format: "typescript" },
+          { type: "tests", name: "Test Suite", format: "typescript" },
+          { type: "documentation", name: "API Documentation", format: "markdown" }
+        );
+        break;
+      case "analysis":
+        artifacts.push(
+          { type: "dataset", name: "Processed Dataset", format: "csv" },
+          { type: "visualization", name: "Data Visualizations", format: "svg" },
+          { type: "report", name: "Analysis Report", format: "markdown" }
+        );
+        break;
+      case "product-planning":
+        artifacts.push(
+          { type: "roadmap", name: "Product Roadmap", format: "json" },
+          { type: "requirements", name: "Requirements Document", format: "markdown" },
+          { type: "metrics", name: "Success Metrics", format: "json" }
+        );
+        break;
+      default:
+        artifacts.push(
+          { type: "output", name: "Workflow Output", format: "json" }
+        );
+    }
+    return artifacts;
+  }
+  cancelWorkflow(workflowId) {
+    const workflow = this.workflows.get(workflowId);
+    if (!workflow || workflow.status !== "running") {
+      return false;
+    }
+    workflow.status = "cancelled";
+    workflow.endTime = /* @__PURE__ */ new Date();
+    this.emit("workflow:cancelled", { workflowId });
+    return true;
+  }
+  getWorkflow(workflowId) {
+    return this.workflows.get(workflowId);
+  }
+  getActiveWorkflows() {
+    return Array.from(this.workflows.values()).filter(
+      (w) => w.status === "running" || w.status === "pending"
+    );
+  }
+  getCompletedWorkflows() {
+    return Array.from(this.workflows.values()).filter(
+      (w) => w.status === "completed"
+    );
+  }
+  getAllWorkflows() {
+    return Array.from(this.workflows.values());
+  }
+  // ─── Progress Tracking ────────────────────────────────────────────────────
+  updateProgress(workflowId, updates) {
+    const state = this.progressStates.get(workflowId);
+    if (!state) {
+      return;
+    }
+    Object.assign(state, updates);
+    if (state.percentage < 100 && state.stepsCompleted > 0) {
+      const elapsed = Date.now() - state.startedAt.getTime();
+      const avgStepTime = elapsed / state.stepsCompleted;
+      const remainingSteps = state.totalSteps - state.stepsCompleted;
+      state.estimatedTimeRemaining = Math.round(avgStepTime * remainingSteps);
+    }
+    this.emit("progress:updated", { workflowId, progress: { ...state } });
+  }
+  getProgress(workflowId) {
+    return this.progressStates.get(workflowId);
+  }
+  getAllProgress() {
+    return Array.from(this.progressStates.values());
+  }
+  getActiveProgress() {
+    return Array.from(this.progressStates.values()).filter((p) => p.percentage < 100);
+  }
+  // ─── Result Display ───────────────────────────────────────────────────────
+  createResultDisplay(workflowId, type, title, data, format = "table") {
+    const result = {
+      id: randomUUID2(),
+      workflowId,
+      type,
+      title,
+      data,
+      format,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.resultDisplays.set(result.id, result);
+    this.showComponent("result-display");
+    this.emit("result:created", { resultId: result.id, workflowId, type });
+    return result;
+  }
+  getResultDisplay(resultId) {
+    return this.resultDisplays.get(resultId);
+  }
+  getResultsForWorkflow(workflowId) {
+    return Array.from(this.resultDisplays.values()).filter(
+      (r) => r.workflowId === workflowId
+    );
+  }
+  getAllResults() {
+    return Array.from(this.resultDisplays.values());
+  }
+  removeResultDisplay(resultId) {
+    return this.resultDisplays.delete(resultId);
+  }
+  clearResults() {
+    this.resultDisplays.clear();
+    this.emit("results:cleared");
+  }
+  // ─── Layout & Theme ───────────────────────────────────────────────────────
+  setLayout(layout) {
+    this.studioState.layout = layout;
+    this.updateComponent("studio-interface", {
+      config: { layout }
+    });
+    this.emit("layout:changed", { layout });
+  }
+  setTheme(theme) {
+    this.studioState.theme = theme;
+    this.updateComponent("studio-interface", {
+      config: { theme }
+    });
+    this.emit("theme:changed", { theme });
+  }
+  getLayout() {
+    return this.studioState.layout;
+  }
+  getTheme() {
+    return this.studioState.theme;
+  }
+  // ─── Frame Management ─────────────────────────────────────────────────────
+  activateFrame(frameId) {
+    if (!this.studioState.activeFrames.includes(frameId)) {
+      this.studioState.activeFrames.push(frameId);
+      this.emit("frame:activated", { frameId });
+    }
+  }
+  deactivateFrame(frameId) {
+    const index = this.studioState.activeFrames.indexOf(frameId);
+    if (index > -1) {
+      this.studioState.activeFrames.splice(index, 1);
+      this.emit("frame:deactivated", { frameId });
+    }
+  }
+  getActiveFrames() {
+    return [...this.studioState.activeFrames];
+  }
+  setActiveFrames(frameIds) {
+    this.studioState.activeFrames = [...frameIds];
+    this.emit("frames:updated", { frameIds });
+  }
+  // ─── Status & Analytics ───────────────────────────────────────────────────
+  getStatus() {
+    return {
+      initialized: this.initialized,
+      components: this.components.size,
+      visibleComponents: this.getVisibleComponents().length,
+      activeWorkflows: this.getActiveWorkflows().length,
+      completedWorkflows: this.getCompletedWorkflows().length,
+      totalResults: this.resultDisplays.size,
+      selectorState: {
+        isOpen: this.selectorState.isOpen,
+        selectedPersonaId: this.selectorState.selectedPersonaId
+      },
+      studioState: {
+        layout: this.studioState.layout,
+        theme: this.studioState.theme,
+        activeFrames: this.studioState.activeFrames.length,
+        panels: this.studioState.panels.length,
+        toolbars: this.studioState.toolbars.length
+      },
+      config: { ...this.config }
+    };
+  }
+  getUIAnalytics() {
+    const workflows = Array.from(this.workflows.values());
+    const completed = workflows.filter((w) => w.status === "completed");
+    const failed = workflows.filter((w) => w.status === "failed");
+    const totalDuration = completed.reduce((sum, w) => {
+      if (w.endTime) {
+        return sum + (w.endTime.getTime() - w.startTime.getTime());
+      }
+      return sum;
+    }, 0);
+    const workflowsByType = {};
+    for (const w of workflows) {
+      workflowsByType[w.type] = (workflowsByType[w.type] || 0) + 1;
+    }
+    const workflowsByPersona = {};
+    for (const w of workflows) {
+      workflowsByPersona[w.personaId] = (workflowsByPersona[w.personaId] || 0) + 1;
+    }
+    return {
+      totalWorkflows: workflows.length,
+      completedWorkflows: completed.length,
+      failedWorkflows: failed.length,
+      averageDuration: completed.length > 0 ? totalDuration / completed.length : 0,
+      workflowsByType,
+      workflowsByPersona,
+      totalResults: this.resultDisplays.size,
+      componentCount: this.components.size
+    };
+  }
+  // ─── Cleanup ──────────────────────────────────────────────────────────────
+  dispose() {
+    this.removeAllListeners();
+    this.components.clear();
+    this.workflows.clear();
+    this.progressStates.clear();
+    this.resultDisplays.clear();
+    this.initialized = false;
+    console.log("[PersonaUISystem] UI system disposed");
+  }
+};
+
+// src/personas/agile-pm.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import { randomUUID as randomUUID3 } from "crypto";
+import { readFile, writeFile } from "fs/promises";
+var AgileProductManagerPersona = class extends EventEmitter3 {
+  sprints;
+  backlog;
+  velocityHistory;
+  workspacePath;
+  constructor(workspacePath = "./workspace") {
+    super();
+    this.sprints = /* @__PURE__ */ new Map();
+    this.backlog = [];
+    this.velocityHistory = [];
+    this.workspacePath = workspacePath;
+    console.log("[AgileProductManagerPersona] Persona initialized");
+  }
+  // ─── Sprint Management ────────────────────────────────────────────────────
+  createSprint(name, startDate, duration, goals, team) {
+    const endDate = this.calculateEndDate(startDate, duration);
+    const sprint = {
+      id: randomUUID3(),
+      name,
+      startDate,
+      endDate,
+      goals,
+      stories: [],
+      team,
+      status: "planning"
+    };
+    this.sprints.set(sprint.id, sprint);
+    this.emit("sprint:created", { sprintId: sprint.id, name });
+    console.log(`[AgileProductManagerPersona] Sprint created: ${name} (${startDate} - ${endDate})`);
+    return sprint;
+  }
+  addStoryToSprint(sprintId, story) {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+    const fullStory = {
+      ...story,
+      id: randomUUID3(),
+      status: "todo",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    sprint.stories.push(fullStory);
+    this.emit("story:added", { sprintId, storyId: fullStory.id, title: fullStory.title });
+    console.log(`[AgileProductManagerPersona] Story added to sprint ${sprint.name}: ${fullStory.title}`);
+    return fullStory;
+  }
+  updateStoryStatus(sprintId, storyId, newStatus) {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+    const story = sprint.stories.find((s) => s.id === storyId);
+    if (!story) {
+      throw new Error(`Story '${storyId}' not found in sprint '${sprintId}'`);
+    }
+    const oldStatus = story.status;
+    story.status = newStatus;
+    story.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (newStatus === "done") {
+      story.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    this.emit("story:statusChanged", { sprintId, storyId, oldStatus, newStatus });
+    console.log(`[AgileProductManagerPersona] Story ${story.title}: ${oldStatus} -> ${newStatus}`);
+    return story;
+  }
+  // ─── Backlog Management ───────────────────────────────────────────────────
+  addToBacklog(item) {
+    const fullItem = {
+      ...item,
+      id: randomUUID3(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.backlog.push(fullItem);
+    this.emit("backlog:itemAdded", { itemId: fullItem.id, title: fullItem.title });
+    console.log(`[AgileProductManagerPersona] Backlog item added: ${fullItem.title}`);
+    return fullItem;
+  }
+  prioritizeBacklog(criteria = "priority") {
+    const priorityOrder = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    switch (criteria) {
+      case "priority":
+        this.backlog.sort((a, b) => {
+          const aPriority = priorityOrder[a.priority] ?? 4;
+          const bPriority = priorityOrder[b.priority] ?? 4;
+          return aPriority - bPriority;
+        });
+        break;
+      case "points":
+        this.backlog.sort((a, b) => b.points - a.points);
+        break;
+      case "created":
+        this.backlog.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+        break;
+      case "type":
+        this.backlog.sort((a, b) => a.type.localeCompare(b.type));
+        break;
+      default:
+        this.backlog.sort((a, b) => {
+          const aPriority = priorityOrder[a.priority] ?? 4;
+          const bPriority = priorityOrder[b.priority] ?? 4;
+          return aPriority - bPriority;
+        });
+    }
+    this.emit("backlog:prioritized", { criteria, itemCount: this.backlog.length });
+    console.log(`[AgileProductManagerPersona] Backlog prioritized by ${criteria}: ${this.backlog.length} items`);
+    return [...this.backlog];
+  }
+  // ─── Velocity & Metrics ───────────────────────────────────────────────────
+  calculateVelocity(sprintId) {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+    const totalPoints = sprint.stories.reduce((sum, s) => sum + s.points, 0);
+    const completedPoints = sprint.stories.filter((s) => s.status === "done").reduce((sum, s) => sum + s.points, 0);
+    const velocityData = {
+      sprintId: sprint.id,
+      sprintName: sprint.name,
+      plannedPoints: totalPoints,
+      completedPoints,
+      velocity: completedPoints
+    };
+    this.velocityHistory.push(velocityData);
+    this.emit("velocity:calculated", { sprintId, velocity: completedPoints });
+    return velocityData;
+  }
+  // ─── Reporting ────────────────────────────────────────────────────────────
+  generateSprintReport(sprintId) {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+    const totalStories = sprint.stories.length;
+    const completedStories = sprint.stories.filter((s) => s.status === "done").length;
+    const totalPoints = sprint.stories.reduce((sum, s) => sum + s.points, 0);
+    const completedPoints = sprint.stories.filter((s) => s.status === "done").reduce((sum, s) => sum + s.points, 0);
+    const storiesByStatus = {};
+    for (const story of sprint.stories) {
+      storiesByStatus[story.status] = (storiesByStatus[story.status] || 0) + 1;
+    }
+    const storiesByPriority = {};
+    for (const story of sprint.stories) {
+      storiesByPriority[story.priority] = (storiesByPriority[story.priority] || 0) + 1;
+    }
+    const report = {
+      sprint,
+      totalStories,
+      completedStories,
+      totalPoints,
+      completedPoints,
+      completionRate: totalStories > 0 ? completedStories / totalStories * 100 : 0,
+      velocity: completedPoints,
+      storiesByStatus,
+      storiesByPriority
+    };
+    this.emit("report:generated", { sprintId, type: "sprint" });
+    console.log(`[AgileProductManagerPersona] Sprint report generated for: ${sprint.name}`);
+    return report;
+  }
+  generateBurndownData(sprintId) {
+    const sprint = this.sprints.get(sprintId);
+    if (!sprint) {
+      throw new Error(`Sprint '${sprintId}' not found`);
+    }
+    const totalPoints = sprint.stories.reduce((sum, s) => sum + s.points, 0);
+    const startDate = new Date(sprint.startDate);
+    const endDate = new Date(sprint.endDate);
+    const totalDays = Math.ceil((endDate.getTime() - startDate.getTime()) / (1e3 * 60 * 60 * 24));
+    const dailyIdealBurn = totalPoints / totalDays;
+    const burndownData = [];
+    let actualRemaining = totalPoints;
+    for (let day = 0; day <= totalDays; day++) {
+      const currentDate = new Date(startDate);
+      currentDate.setDate(currentDate.getDate() + day);
+      const dateStr = currentDate.toISOString().split("T")[0];
+      const storiesCompletedByDate = sprint.stories.filter((s) => {
+        if (!s.completedAt) return false;
+        return new Date(s.completedAt) <= currentDate;
+      });
+      const completedPoints = storiesCompletedByDate.reduce((sum, s) => sum + s.points, 0);
+      actualRemaining = totalPoints - completedPoints;
+      burndownData.push({
+        day,
+        date: dateStr,
+        idealRemaining: Math.max(0, totalPoints - dailyIdealBurn * day),
+        actualRemaining
+      });
+    }
+    this.emit("burndown:generated", { sprintId, dataPoints: burndownData.length });
+    return burndownData;
+  }
+  // ─── Utility Methods ──────────────────────────────────────────────────────
+  calculateEndDate(startDate, durationDays) {
+    const date = new Date(startDate);
+    date.setDate(date.getDate() + durationDays);
+    return date.toISOString().split("T")[0];
+  }
+  async loadWorkspaceData() {
+    try {
+      const filePath = `${this.workspacePath}/agile-pm-data.json`;
+      const data = await readFile(filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      for (const sprint of parsed.sprints) {
+        this.sprints.set(sprint.id, sprint);
+      }
+      this.backlog = parsed.backlog || [];
+      console.log(`[AgileProductManagerPersona] Workspace data loaded: ${this.sprints.size} sprints, ${this.backlog.length} backlog items`);
+      return parsed;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[AgileProductManagerPersona] No existing workspace data found: ${message}`);
+      return null;
+    }
+  }
+  async saveWorkspaceData() {
+    try {
+      const data = {
+        sprints: Array.from(this.sprints.values()),
+        backlog: this.backlog,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const filePath = `${this.workspacePath}/agile-pm-data.json`;
+      await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+      console.log("[AgileProductManagerPersona] Workspace data saved");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[AgileProductManagerPersona] Failed to save workspace data: ${message}`);
+    }
+  }
+  getPersonaStatus() {
+    const activeSprints = Array.from(this.sprints.values()).filter(
+      (s) => s.status === "active" || s.status === "planning"
+    );
+    const completedSprints = Array.from(this.sprints.values()).filter(
+      (s) => s.status === "completed"
+    );
+    let totalStories = 0;
+    for (const sprint of this.sprints.values()) {
+      totalStories += sprint.stories.length;
+    }
+    const avgVelocity = this.velocityHistory.length > 0 ? this.velocityHistory.reduce((sum, v) => sum + v.velocity, 0) / this.velocityHistory.length : 0;
+    return {
+      persona: "Agile Product Manager",
+      activeSprints: activeSprints.length,
+      totalStories,
+      backlogSize: this.backlog.length,
+      averageVelocity: Math.round(avgVelocity * 100) / 100,
+      completedSprints: completedSprints.length
+    };
+  }
+};
+
+// src/personas/dev-lead.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import { randomUUID as randomUUID4 } from "crypto";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { readFile as readFile2, writeFile as writeFile2, access } from "fs/promises";
+import { constants as fsConstants } from "fs";
+var execAsync = promisify(exec);
+var SoftwareDevelopmentLeadPersona = class extends EventEmitter4 {
+  team;
+  reviews;
+  techDebt;
+  builds;
+  tests;
+  workspacePath;
+  constructor(workspacePath = "./workspace") {
+    super();
+    this.team = /* @__PURE__ */ new Map();
+    this.reviews = /* @__PURE__ */ new Map();
+    this.techDebt = [];
+    this.builds = [];
+    this.tests = [];
+    this.workspacePath = workspacePath;
+    console.log("[SoftwareDevelopmentLeadPersona] Persona initialized");
+  }
+  // ─── Team Management ──────────────────────────────────────────────────────
+  addTeamMember(name, role, skills, capacity = 40) {
+    const member = {
+      id: randomUUID4(),
+      name,
+      role,
+      skills,
+      capacity,
+      currentTasks: [],
+      performance: {
+        velocity: 1,
+        quality: 1,
+        collaboration: 1
+      },
+      joinedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.team.set(member.id, member);
+    this.emit("team:memberAdded", { memberId: member.id, name });
+    console.log(`[SoftwareDevelopmentLeadPersona] Team member added: ${name} (${role})`);
+    return member;
+  }
+  assignTask(memberId, taskData) {
+    const member = this.team.get(memberId);
+    if (!member) {
+      throw new Error(`Team member '${memberId}' not found`);
+    }
+    const currentLoad = member.currentTasks.reduce((sum, t) => sum + t.estimatedHours, 0);
+    if (currentLoad + taskData.estimatedHours > member.capacity) {
+      console.log(`[SoftwareDevelopmentLeadPersona] Warning: ${member.name} may be over capacity (${currentLoad + taskData.estimatedHours}/${member.capacity}h)`);
+    }
+    const task = {
+      ...taskData,
+      id: randomUUID4(),
+      assignedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "assigned"
+    };
+    member.currentTasks.push(task);
+    this.emit("task:assigned", { memberId, taskId: task.id, title: task.title });
+    console.log(`[SoftwareDevelopmentLeadPersona] Task assigned to ${member.name}: ${task.title}`);
+    return task;
+  }
+  // ─── Code Reviews ────────────────────────────────────────────────────────
+  initiateCodeReview(title, description, files, author, reviewer) {
+    const review = {
+      id: randomUUID4(),
+      title,
+      description,
+      files,
+      reviewer,
+      author,
+      status: "pending",
+      comments: [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.reviews.set(review.id, review);
+    this.emit("review:created", { reviewId: review.id, title });
+    console.log(`[SoftwareDevelopmentLeadPersona] Code review initiated: ${title}`);
+    return review;
+  }
+  addReviewComment(reviewId, author, content, options = {}) {
+    const review = this.reviews.get(reviewId);
+    if (!review) {
+      throw new Error(`Code review '${reviewId}' not found`);
+    }
+    const comment = {
+      id: randomUUID4(),
+      author,
+      content,
+      line: options.line,
+      file: options.file,
+      type: options.type || "comment",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    review.comments.push(comment);
+    if (review.status === "pending") {
+      review.status = "in-review";
+    }
+    this.emit("review:commented", { reviewId, commentId: comment.id, author });
+    console.log(`[SoftwareDevelopmentLeadPersona] Review comment added by ${author} on ${review.title}`);
+    return comment;
+  }
+  approveCodeReview(reviewId, approver) {
+    const review = this.reviews.get(reviewId);
+    if (!review) {
+      throw new Error(`Code review '${reviewId}' not found`);
+    }
+    review.status = "approved";
+    review.approvedAt = (/* @__PURE__ */ new Date()).toISOString();
+    review.approver = approver;
+    this.emit("review:approved", { reviewId, approver });
+    console.log(`[SoftwareDevelopmentLeadPersona] Code review approved: ${review.title} by ${approver}`);
+    return review;
+  }
+  // ─── Technical Debt ───────────────────────────────────────────────────────
+  identifyTechnicalDebt(title, description, category, severity, estimatedEffort, impact, options = {}) {
+    const item = {
+      id: randomUUID4(),
+      title,
+      description,
+      category,
+      severity,
+      estimatedEffort,
+      impact,
+      file: options.file,
+      line: options.line,
+      identifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "identified"
+    };
+    this.techDebt.push(item);
+    this.emit("techDebt:identified", { itemId: item.id, title, severity });
+    console.log(`[SoftwareDevelopmentLeadPersona] Tech debt identified: ${title} (${severity})`);
+    return item;
+  }
+  prioritizeTechnicalDebt(criteria = "severity") {
+    const severityOrder = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    switch (criteria) {
+      case "severity":
+        this.techDebt.sort((a, b) => {
+          const aOrder = severityOrder[a.severity] ?? 4;
+          const bOrder = severityOrder[b.severity] ?? 4;
+          return aOrder - bOrder;
+        });
+        break;
+      case "effort":
+        this.techDebt.sort((a, b) => a.estimatedEffort - b.estimatedEffort);
+        break;
+      case "impact": {
+        const impactOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+        this.techDebt.sort((a, b) => {
+          const aOrder = impactOrder[a.impact] ?? 4;
+          const bOrder = impactOrder[b.impact] ?? 4;
+          return aOrder - bOrder;
+        });
+        break;
+      }
+      case "category":
+        this.techDebt.sort((a, b) => a.category.localeCompare(b.category));
+        break;
+      default:
+        this.techDebt.sort((a, b) => {
+          const aOrder = severityOrder[a.severity] ?? 4;
+          const bOrder = severityOrder[b.severity] ?? 4;
+          return aOrder - bOrder;
+        });
+    }
+    this.emit("techDebt:prioritized", { criteria, itemCount: this.techDebt.length });
+    console.log(`[SoftwareDevelopmentLeadPersona] Tech debt prioritized by ${criteria}: ${this.techDebt.length} items`);
+    return [...this.techDebt];
+  }
+  // ─── Codebase Analysis ────────────────────────────────────────────────────
+  async analyzeCodebase(directory) {
+    console.log(`[SoftwareDevelopmentLeadPersona] Analyzing codebase: ${directory}`);
+    const filesByType = await this.countFilesByType(directory);
+    const filesByExtension = await this.countFilesByExtension(directory);
+    const totalFiles = Object.values(filesByExtension).reduce((sum, count) => sum + count, 0);
+    const codeQualityScore = this.calculateCodeQualityScore();
+    const techDebtCount = this.techDebt.filter((item) => item.status !== "resolved").length;
+    const analysis = {
+      totalFiles,
+      filesByType,
+      filesByExtension,
+      codeQualityScore,
+      techDebtItems: techDebtCount,
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.emit("codebase:analyzed", { directory, totalFiles, codeQualityScore });
+    console.log(`[SoftwareDevelopmentLeadPersona] Codebase analysis complete: ${totalFiles} files, quality score: ${codeQualityScore}`);
+    return analysis;
+  }
+  async countFilesByType(directory) {
+    const filesByType = {
+      source: 0,
+      test: 0,
+      config: 0,
+      documentation: 0,
+      asset: 0,
+      other: 0
+    };
+    try {
+      const { stdout } = await execAsync(`find "${directory}" -type f -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -5000`);
+      const files = stdout.trim().split("\n").filter(Boolean);
+      for (const file of files) {
+        const lower = file.toLowerCase();
+        if (lower.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/)) {
+          filesByType["test"]++;
+        } else if (lower.match(/\.(ts|js|tsx|jsx|py|rb|go|rs|java|c|cpp|h)$/)) {
+          filesByType["source"]++;
+        } else if (lower.match(/\.(json|yaml|yml|toml|ini|env|conf|cfg)$/)) {
+          filesByType["config"]++;
+        } else if (lower.match(/\.(md|txt|rst|doc|docx|pdf)$/)) {
+          filesByType["documentation"]++;
+        } else if (lower.match(/\.(png|jpg|jpeg|gif|svg|ico|mp4|mp3|woff|ttf)$/)) {
+          filesByType["asset"]++;
+        } else {
+          filesByType["other"]++;
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[SoftwareDevelopmentLeadPersona] Error counting files by type: ${message}`);
+    }
+    return filesByType;
+  }
+  async countFilesByExtension(directory) {
+    const filesByExtension = {};
+    try {
+      const { stdout } = await execAsync(`find "${directory}" -type f -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -5000`);
+      const files = stdout.trim().split("\n").filter(Boolean);
+      for (const file of files) {
+        const parts = file.split(".");
+        const ext = parts.length > 1 ? `.${parts[parts.length - 1]}` : "no-extension";
+        filesByExtension[ext] = (filesByExtension[ext] || 0) + 1;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[SoftwareDevelopmentLeadPersona] Error counting files by extension: ${message}`);
+    }
+    return filesByExtension;
+  }
+  async scanCodebase(directory, pattern) {
+    try {
+      const { stdout } = await execAsync(`grep -rl "${pattern}" "${directory}" --include="*.ts" --include="*.js" 2>/dev/null | head -100`);
+      return stdout.trim().split("\n").filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  calculateCodeQualityScore() {
+    let score = 100;
+    const unresolvedDebt = this.techDebt.filter((item) => item.status !== "resolved");
+    for (const item of unresolvedDebt) {
+      switch (item.severity) {
+        case "critical":
+          score -= 15;
+          break;
+        case "high":
+          score -= 10;
+          break;
+        case "medium":
+          score -= 5;
+          break;
+        case "low":
+          score -= 2;
+          break;
+      }
+    }
+    const pendingReviews = Array.from(this.reviews.values()).filter(
+      (r) => r.status === "pending" || r.status === "in-review"
+    );
+    score -= pendingReviews.length * 3;
+    return Math.max(0, Math.min(100, Math.round(score)));
+  }
+  // ─── Build & Test ─────────────────────────────────────────────────────────
+  async runBuild(command = "npm run build") {
+    const build = {
+      id: randomUUID4(),
+      status: "running",
+      command,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      output: "",
+      errors: []
+    };
+    console.log(`[SoftwareDevelopmentLeadPersona] Running build: ${command}`);
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: this.workspacePath,
+        timeout: 3e5
+      });
+      build.status = "success";
+      build.output = stdout;
+      if (stderr) {
+        build.errors = stderr.split("\n").filter(Boolean);
+      }
+    } catch (error) {
+      build.status = "failed";
+      if (error instanceof Error) {
+        build.output = error.stdout || "";
+        build.errors = [error.stderr || error.message];
+      } else {
+        build.errors = [String(error)];
+      }
+    }
+    build.endTime = (/* @__PURE__ */ new Date()).toISOString();
+    build.duration = new Date(build.endTime).getTime() - new Date(build.startTime).getTime();
+    this.builds.push(build);
+    this.emit("build:completed", { buildId: build.id, status: build.status });
+    console.log(`[SoftwareDevelopmentLeadPersona] Build ${build.status}: ${command} (${build.duration}ms)`);
+    return build;
+  }
+  async runTests(command = "npm test") {
+    const testResult = {
+      id: randomUUID4(),
+      status: "running",
+      command,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      output: ""
+    };
+    console.log(`[SoftwareDevelopmentLeadPersona] Running tests: ${command}`);
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: this.workspacePath,
+        timeout: 6e5
+      });
+      testResult.output = stdout + (stderr ? "\n" + stderr : "");
+      testResult.status = "passed";
+      const passedMatch = stdout.match(/(\d+)\s*(passing|passed|pass)/i);
+      const failedMatch = stdout.match(/(\d+)\s*(failing|failed|fail)/i);
+      const skippedMatch = stdout.match(/(\d+)\s*(pending|skipped|skip)/i);
+      testResult.passed = passedMatch ? parseInt(passedMatch[1], 10) : 0;
+      testResult.failed = failedMatch ? parseInt(failedMatch[1], 10) : 0;
+      testResult.skipped = skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
+      if (testResult.failed > 0) {
+        testResult.status = "failed";
+      }
+    } catch (error) {
+      testResult.status = "failed";
+      if (error instanceof Error) {
+        testResult.output = error.stdout || error.message;
+      } else {
+        testResult.output = String(error);
+      }
+    }
+    testResult.endTime = (/* @__PURE__ */ new Date()).toISOString();
+    testResult.duration = new Date(testResult.endTime).getTime() - new Date(testResult.startTime).getTime();
+    this.tests.push(testResult);
+    this.emit("tests:completed", {
+      testId: testResult.id,
+      status: testResult.status,
+      passed: testResult.passed,
+      failed: testResult.failed
+    });
+    console.log(`[SoftwareDevelopmentLeadPersona] Tests ${testResult.status}: ${testResult.passed} passed, ${testResult.failed} failed, ${testResult.skipped} skipped (${testResult.duration}ms)`);
+    return testResult;
+  }
+  // ─── File Utilities ───────────────────────────────────────────────────────
+  async fileExists(filePath) {
+    try {
+      await access(filePath, fsConstants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ─── Workspace Persistence ────────────────────────────────────────────────
+  async loadWorkspaceData() {
+    try {
+      const filePath = `${this.workspacePath}/dev-lead-data.json`;
+      const data = await readFile2(filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      for (const member of parsed.team) {
+        this.team.set(member.id, member);
+      }
+      for (const review of parsed.reviews) {
+        this.reviews.set(review.id, review);
+      }
+      this.techDebt = parsed.techDebt || [];
+      console.log(`[SoftwareDevelopmentLeadPersona] Workspace data loaded: ${this.team.size} members, ${this.reviews.size} reviews, ${this.techDebt.length} debt items`);
+      return parsed;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[SoftwareDevelopmentLeadPersona] No existing workspace data found: ${message}`);
+      return null;
+    }
+  }
+  async saveWorkspaceData() {
+    try {
+      const data = {
+        team: Array.from(this.team.values()),
+        reviews: Array.from(this.reviews.values()),
+        techDebt: this.techDebt,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const filePath = `${this.workspacePath}/dev-lead-data.json`;
+      await writeFile2(filePath, JSON.stringify(data, null, 2), "utf-8");
+      console.log("[SoftwareDevelopmentLeadPersona] Workspace data saved");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[SoftwareDevelopmentLeadPersona] Failed to save workspace data: ${message}`);
+    }
+  }
+  // ─── Status ───────────────────────────────────────────────────────────────
+  getPersonaStatus() {
+    const activeReviews = Array.from(this.reviews.values()).filter(
+      (r) => r.status === "pending" || r.status === "in-review"
+    );
+    let openTasks = 0;
+    let totalCapacity = 0;
+    let totalQuality = 0;
+    let memberCount = 0;
+    for (const member of this.team.values()) {
+      openTasks += member.currentTasks.filter((t) => t.status !== "completed" && t.status !== "cancelled").length;
+      totalCapacity += member.capacity - member.currentTasks.reduce((sum, t) => sum + t.estimatedHours, 0);
+      totalQuality += member.performance.quality;
+      memberCount++;
+    }
+    const unresolvedDebt = this.techDebt.filter((item) => item.status !== "resolved");
+    return {
+      persona: "Software Development Lead",
+      teamSize: this.team.size,
+      activeReviews: activeReviews.length,
+      techDebtItems: unresolvedDebt.length,
+      openTasks,
+      teamCapacity: Math.max(0, totalCapacity),
+      averageQuality: memberCount > 0 ? Math.round(totalQuality / memberCount * 100) / 100 : 0
+    };
+  }
+};
+export {
+  AgileProductManagerPersona,
+  BaselinePersonaEngine,
+  PersonaUISystem,
+  SoftwareDevelopmentLeadPersona
+};