@baselineos/persona 0.1.0

package/src/engine.ts

@@ -0,0 +1,1196 @@
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+
+// ─── Type Definitions ────────────────────────────────────────────────────────
+
+export interface StudioConfig {
+  interface: {
+    layout: string;
+    colorScheme: string;
+    typography: string;
+    visualElements: string[];
+  };
+  lexicon: {
+    terminology: string[];
+    language: string;
+    abbreviations: string[];
+  };
+  frames: Record<string, string[]>;
+  templates: Record<string, string[]>;
+  workflows: Record<string, string[]>;
+  aiModels: Record<string, string[]>;
+}
+
+export interface AgilePMConfig {
+  sprints: {
+    methodology: string;
+    cycles: string[];
+    duration: string;
+  };
+  userStories: Record<string, string[]>;
+  backlog: Record<string, string[]>;
+  analytics: Record<string, string[]>;
+}
+
+export interface PersonaConfig {
+  name: string;
+  description: string;
+  focus: string[];
+  studio: StudioConfig;
+  agilePM: AgilePMConfig;
+}
+
+export interface Persona extends PersonaConfig {
+  id: string;
+  createdAt: Date;
+  lastModified: Date;
+  usageCount: number;
+  adaptationScore: number;
+  customizations: Map<string, Record<string, unknown>>;
+}
+
+export interface ActivePersona extends Persona {
+  userId: string;
+  activatedAt: Date;
+  sessionId: string;
+}
+
+export interface BehaviorData {
+  type: string;
+  timestamp?: Date;
+  [key: string]: unknown;
+}
+
+export interface BehaviorPattern {
+  type: string;
+  confidence: number;
+  data: BehaviorData[];
+}
+
+export interface PersonaEngineConfig {
+  enableAutonomousLearning?: boolean;
+  enableBehavioralAnalysis?: boolean;
+  enablePredictiveCustomization?: boolean;
+  enableCrossPersonaSharing?: boolean;
+}
+
+export interface PersonaAdaptation {
+  id: string;
+  personaId: string;
+  userId: string;
+  type: string;
+  changes: Record<string, unknown>;
+  confidence: number;
+  appliedAt: Date;
+  source: string;
+}
+
+export interface PersonaRecommendation {
+  personaId: string;
+  score: number;
+  reasoning: string;
+  fitScores: {
+    pattern: number;
+    context: number;
+    persona: number;
+  };
+}
+
+export interface PersonaAnalytics {
+  totalPersonas: number;
+  activePersonas: number;
+  totalBehaviors: number;
+  behaviorsByType: Record<string, number>;
+  totalAdaptations: number;
+  adaptationsByPersona: Record<string, number>;
+  adaptationsByUser: Record<string, number>;
+  averageAdaptationScore: number;
+}
+
+export interface PersonaStatus {
+  initialized: boolean;
+  totalPersonas: number;
+  activePersonas: number;
+  behaviorDataPoints: number;
+  adaptationsApplied: number;
+  config: PersonaEngineConfig;
+}
+
+// ─── Core Persona Engine ─────────────────────────────────────────────────────
+
+export class BaselinePersonaEngine extends EventEmitter {
+  private personas: Map<string, Persona>;
+  private activePersonas: Map<string, ActivePersona>;
+  private behaviorData: Map<string, BehaviorData[]>;
+  private adaptations: PersonaAdaptation[];
+  private config: PersonaEngineConfig;
+  private initialized: boolean;
+
+  constructor(config: PersonaEngineConfig = {}) {
+    super();
+    this.personas = new Map();
+    this.activePersonas = new Map();
+    this.behaviorData = 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 ──────────────────────────────────────────────
+
+  private initializeCorePersonas(): void {
+    const corePersonas: Record<string, PersonaConfig> = {
+      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: Persona = {
+        ...config,
+        id,
+        createdAt: new Date(),
+        lastModified: new Date(),
+        usageCount: 0,
+        adaptationScore: 0,
+        customizations: new Map(),
+      };
+      this.personas.set(id, persona);
+    }
+  }
+
+  // ─── Event Listeners ──────────────────────────────────────────────────────
+
+  private initializeEventListeners(): void {
+    this.on('persona:activated', (data: { personaId: string; userId: string }) => {
+      console.log(`[BaselinePersonaEngine] Persona activated: ${data.personaId} for user ${data.userId}`);
+    });
+
+    this.on('persona:switched', (data: { fromPersonaId: string; toPersonaId: string; userId: string }) => {
+      console.log(`[BaselinePersonaEngine] Persona switched from ${data.fromPersonaId} to ${data.toPersonaId} for user ${data.userId}`);
+    });
+
+    this.on('persona:customized', (data: { personaId: string; userId: string }) => {
+      console.log(`[BaselinePersonaEngine] Persona customized: ${data.personaId} for user ${data.userId}`);
+    });
+
+    this.on('behavior:recorded', (data: { userId: string; type: string }) => {
+      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: { personaId: string; userId: string; type: string }) => {
+      console.log(`[BaselinePersonaEngine] Adaptation applied: ${data.type} to persona ${data.personaId} for user ${data.userId}`);
+    });
+  }
+
+  // ─── Persona Management ───────────────────────────────────────────────────
+
+  addPersona(id: string, config: PersonaConfig): Persona {
+    if (this.personas.has(id)) {
+      throw new Error(`Persona with id '${id}' already exists`);
+    }
+
+    const persona: Persona = {
+      ...config,
+      id,
+      createdAt: new Date(),
+      lastModified: new Date(),
+      usageCount: 0,
+      adaptationScore: 0,
+      customizations: new Map(),
+    };
+
+    this.personas.set(id, persona);
+    this.emit('persona:added', { personaId: id });
+    console.log(`[BaselinePersonaEngine] Persona added: ${id}`);
+    return persona;
+  }
+
+  setActivePersona(personaId: string, userId: string): ActivePersona {
+    const persona = this.personas.get(personaId);
+    if (!persona) {
+      throw new Error(`Persona '${personaId}' not found`);
+    }
+
+    const activePersona: ActivePersona = {
+      ...persona,
+      userId,
+      activatedAt: new Date(),
+      sessionId: randomUUID(),
+    };
+
+    persona.usageCount++;
+    persona.lastModified = new Date();
+
+    this.activePersonas.set(userId, activePersona);
+    this.emit('persona:activated', { personaId, userId });
+    return activePersona;
+  }
+
+  getActivePersona(userId: string): ActivePersona | undefined {
+    return this.activePersonas.get(userId);
+  }
+
+  getStudioConfig(userId: string): StudioConfig | null {
+    const activePersona = this.activePersonas.get(userId);
+    if (!activePersona) {
+      return null;
+    }
+    return activePersona.studio;
+  }
+
+  getAgilePMConfig(userId: string): AgilePMConfig | null {
+    const activePersona = this.activePersonas.get(userId);
+    if (!activePersona) {
+      return null;
+    }
+    return activePersona.agilePM;
+  }
+
+  customizePersona(personaId: string, userId: string, customizations: Record<string, unknown>): Persona {
+    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 = new Date();
+
+    const activePersona = this.activePersonas.get(userId);
+    if (activePersona && activePersona.id === personaId) {
+      Object.assign(activePersona, this.deepMerge(activePersona as unknown as Record<string, unknown>, customizations));
+    }
+
+    this.emit('persona:customized', { personaId, userId, customizations });
+    return persona;
+  }
+
+  getPersonalizedPersona(personaId: string, userId: string): Persona | null {
+    const persona = this.personas.get(personaId);
+    if (!persona) {
+      return null;
+    }
+
+    const userCustomizations = persona.customizations.get(userId);
+    if (!userCustomizations) {
+      return persona;
+    }
+
+    return this.deepMerge({ ...persona } as Record<string, unknown>, userCustomizations) as unknown as Persona;
+  }
+
+  switchPersona(userId: string, newPersonaId: string): ActivePersona {
+    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: string, behavior: BehaviorData): void {
+    if (!this.behaviorData.has(userId)) {
+      this.behaviorData.set(userId, []);
+    }
+
+    const entry: BehaviorData = {
+      ...behavior,
+      timestamp: behavior.timestamp || new Date(),
+    };
+
+    this.behaviorData.get(userId)!.push(entry);
+    this.emit('behavior:recorded', { userId, type: behavior.type });
+  }
+
+  analyzeBehaviorPatterns(userId: string): BehaviorPattern[] {
+    const data = this.behaviorData.get(userId);
+    if (!data || data.length < 3) {
+      return [];
+    }
+
+    const patterns: BehaviorPattern[] = [];
+
+    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;
+  }
+
+  private identifyPattern(data: BehaviorData[], type: string): BehaviorPattern | null {
+    const relevantData = data.filter((d) => d.type === type);
+    if (relevantData.length < 2) {
+      return null;
+    }
+
+    const confidence = Math.min(relevantData.length / 10, 1.0);
+    return {
+      type,
+      confidence,
+      data: relevantData,
+    };
+  }
+
+  private identifyWorkflowPattern(data: BehaviorData[]): BehaviorPattern | null {
+    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 = new Map<string, number>();
+    for (const d of workflowData) {
+      const wType = (d.workflowType as string) || 'unknown';
+      workflowTypes.set(wType, (workflowTypes.get(wType) || 0) + 1);
+    }
+
+    const confidence = Math.min(workflowData.length / 15, 1.0);
+    return {
+      type: 'workflow_preference',
+      confidence,
+      data: workflowData,
+    };
+  }
+
+  private identifyToolPreferencePattern(data: BehaviorData[]): BehaviorPattern | null {
+    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.0);
+    return {
+      type: 'tool_preference',
+      confidence,
+      data: toolData,
+    };
+  }
+
+  private identifyTimePattern(data: BehaviorData[]): BehaviorPattern | null {
+    const timedData = data.filter((d) => d.timestamp instanceof Date);
+    if (timedData.length < 5) {
+      return null;
+    }
+
+    const hours = timedData.map((d) => (d.timestamp as Date).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.0 - variance / 16, 1.0),
+        data: timedData,
+      };
+    }
+
+    return null;
+  }
+
+  private identifyCollaborationPattern(data: BehaviorData[]): BehaviorPattern | null {
+    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.0);
+    return {
+      type: 'collaboration_preference',
+      confidence,
+      data: collabData,
+    };
+  }
+
+  // ─── Autonomous Adaptation ────────────────────────────────────────────────
+
+  private adaptPersonaAutonomously(userId: string, patterns: BehaviorPattern[]): void {
+    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);
+      }
+    }
+  }
+
+  private generateAdaptation(personaId: string, userId: string, pattern: BehaviorPattern): PersonaAdaptation | null {
+    let changes: Record<string, unknown> = {};
+
+    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: new Date(),
+      source: 'autonomous-learning',
+    };
+  }
+
+  private generateWorkflowAdaptation(pattern: BehaviorPattern): Record<string, unknown> {
+    const workflowCounts = new Map<string, number>();
+    for (const d of pattern.data) {
+      const wType = (d.workflowType as string) || '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),
+        },
+      },
+    };
+  }
+
+  private generateToolAdaptation(pattern: BehaviorPattern): Record<string, unknown> {
+    const toolCounts = new Map<string, number>();
+    for (const d of pattern.data) {
+      const tool = (d.tool as string) || (d.toolName as string) || 'unknown';
+      toolCounts.set(tool, (toolCounts.get(tool) || 0) + 1);
+    }
+
+    const preferredTools: string[] = [];
+    for (const [tool, count] of toolCounts) {
+      if (count >= 2) {
+        preferredTools.push(tool);
+      }
+    }
+
+    return {
+      studio: {
+        interface: {
+          preferredTools,
+          toolUsageMap: Object.fromEntries(toolCounts),
+        },
+      },
+    };
+  }
+
+  private generateTimeAdaptation(pattern: BehaviorPattern): Record<string, unknown> {
+    const hours = pattern.data
+      .filter((d) => d.timestamp instanceof Date)
+      .map((d) => (d.timestamp as Date).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 },
+      },
+    };
+  }
+
+  private generateCollaborationAdaptation(pattern: BehaviorPattern): Record<string, unknown> {
+    const collabTypes = new Map<string, number>();
+    for (const d of pattern.data) {
+      collabTypes.set(d.type, (collabTypes.get(d.type) || 0) + 1);
+    }
+
+    const collaborators = new Set<string>();
+    for (const d of pattern.data) {
+      if (d.collaborator) {
+        collaborators.add(d.collaborator as string);
+      }
+      if (d.reviewer) {
+        collaborators.add(d.reviewer as string);
+      }
+    }
+
+    return {
+      preferences: {
+        collaboration: {
+          style: collabTypes.size > 2 ? 'highly-collaborative' : 'selective',
+          frequentCollaborators: Array.from(collaborators),
+          preferredMethods: Object.fromEntries(collabTypes),
+        },
+      },
+    };
+  }
+
+  private applyPersonaAdaptation(adaptation: PersonaAdaptation): void {
+    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) as Record<string, unknown>
+    );
+
+    persona.adaptationScore = Math.min(persona.adaptationScore + adaptation.confidence * 0.1, 1.0);
+    persona.lastModified = new Date();
+
+    const activePersona = this.activePersonas.get(adaptation.userId);
+    if (activePersona && activePersona.id === adaptation.personaId) {
+      Object.assign(activePersona, this.deepMerge(activePersona as unknown as Record<string, unknown>, 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: string, context: Record<string, unknown> = {}): PersonaRecommendation[] {
+    const behaviors = this.behaviorData.get(userId) || [];
+    const patterns = this.analyzeBehaviorPatterns(userId);
+
+    const recommendations: PersonaRecommendation[] = [];
+
+    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: Persona, behaviors: BehaviorData[]): number {
+    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.0);
+  }
+
+  private calculatePatternFitScore(persona: Persona, patterns: BehaviorPattern[]): number {
+    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.0);
+  }
+
+  private calculateContextFitScore(persona: Persona, context: Record<string, unknown>): number {
+    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;
+  }
+
+  private generateRecommendationReasoning(
+    persona: Persona,
+    patternScore: number,
+    contextScore: number,
+    personaScore: number
+  ): string {
+    const reasons: string[] = [];
+
+    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 ──────────────────────────────────────────────────────
+
+  private deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown> {
+    const output: Record<string, unknown> = { ...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] as Record<string, unknown>, source[key] as Record<string, unknown>);
+        } else {
+          output[key] = { ...(source[key] as Record<string, unknown>) };
+        }
+      } else {
+        output[key] = source[key];
+      }
+    }
+
+    return output;
+  }
+
+  private calculateCustomizationLevel(persona: Persona): number {
+    let level = 0;
+    for (const [, customizations] of persona.customizations) {
+      level += Object.keys(customizations).length;
+    }
+    return Math.min(level / 10, 1.0);
+  }
+
+  private extractContextData(context: Record<string, unknown>): string[] {
+    const data: string[] = [];
+
+    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;
+  }
+
+  private getPatternWeight(type: string): number {
+    const weights: Record<string, number> = {
+      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(): PersonaStatus {
+    return {
+      initialized: this.initialized,
+      totalPersonas: this.personas.size,
+      activePersonas: this.activePersonas.size,
+      behaviorDataPoints: this.countBehaviorTypes(),
+      adaptationsApplied: this.adaptations.length,
+      config: { ...this.config },
+    };
+  }
+
+  getAnalytics(): PersonaAnalytics {
+    const behaviorsByType: Record<string, number> = {};
+    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,
+    };
+  }
+
+  private countBehaviorTypes(): number {
+    let total = 0;
+    for (const [, behaviors] of this.behaviorData) {
+      total += behaviors.length;
+    }
+    return total;
+  }
+
+  private groupAdaptationsByPersona(): Record<string, number> {
+    const groups: Record<string, number> = {};
+    for (const adaptation of this.adaptations) {
+      groups[adaptation.personaId] = (groups[adaptation.personaId] || 0) + 1;
+    }
+    return groups;
+  }
+
+  private groupAdaptationsByUser(): Record<string, number> {
+    const groups: Record<string, number> = {};
+    for (const adaptation of this.adaptations) {
+      groups[adaptation.userId] = (groups[adaptation.userId] || 0) + 1;
+    }
+    return groups;
+  }
+}