proffesor-for-testing__agentic-qe/docs/implementation/ddd/learning-optimization.md

Learning & Optimization Domain

Bounded Context Overview

Domain: Learning & Optimization Responsibility: Pattern learning, cross-agent knowledge transfer, strategy optimization Location: src/domains/learning-optimization/

The Learning & Optimization domain enables continuous improvement across the QE platform through pattern extraction, experience mining, strategy optimization, and cross-domain knowledge synthesis.

Ubiquitous Language

Term	Definition
Learned Pattern	Extracted approach from successful operations
Experience	Recorded agent action with outcome
Knowledge	Transferable insight between domains
Strategy	Parameterized approach to a task
Reward	Feedback signal for reinforcement learning
Experience Replay	Re-using past experiences for learning
Knowledge Transfer	Sharing insights between agents/domains
Dream Cycle	Offline pattern consolidation process

Domain Model

Aggregates

LearnedPattern (Aggregate Root)

Extracted pattern from QE operations.

interface LearnedPattern {
  id: string;
  type: PatternType;
  domain: DomainName;
  name: string;
  description: string;
  confidence: number;
  usageCount: number;
  successRate: number;
  context: PatternContext;
  template: PatternTemplate;
  createdAt: Date;
  lastUsedAt: Date;
}

OptimizedStrategy (Aggregate Root)

Optimized strategy for domain operations.

interface OptimizedStrategy {
  id: string;
  domain: DomainName;
  objective: OptimizationObjective;
  currentStrategy: Strategy;
  optimizedStrategy: Strategy;
  improvement: number;
  confidence: number;
  validationResults: ValidationResult[];
}

Entities

Experience

Recorded agent experience for learning.

interface Experience {
  id: string;
  agentId: AgentId;
  domain: DomainName;
  action: string;
  state: StateSnapshot;
  result: ExperienceResult;
  reward: number;
  timestamp: Date;
}

Knowledge

Transferable insight.

interface Knowledge {
  id: string;
  type: KnowledgeType;
  domain: DomainName;
  content: KnowledgeContent;
  sourceAgentId: AgentId;
  targetDomains: DomainName[];
  relevanceScore: number;
  version: number;
  createdAt: Date;
  expiresAt?: Date;
}

Value Objects

PatternType

type PatternType =
  | 'test-pattern'
  | 'fix-pattern'
  | 'optimization-pattern'
  | 'detection-pattern'
  | 'workflow-pattern'
  | 'failure-pattern';

KnowledgeType

type KnowledgeType =
  | 'fact'
  | 'rule'
  | 'heuristic'
  | 'model'
  | 'embedding'
  | 'workflow';

PatternContext

Context for pattern applicability.

interface PatternContext {
  readonly language?: string;
  readonly framework?: string;
  readonly testType?: string;
  readonly codeContext?: string;
  readonly tags: string[];
}

PatternTemplate

Template for pattern application.

interface PatternTemplate {
  readonly type: 'code' | 'prompt' | 'workflow' | 'config';
  readonly content: string;
  readonly variables: TemplateVariable[];
}

StateSnapshot

Captured state at experience time.

interface StateSnapshot {
  readonly context: Record<string, unknown>;
  readonly metrics: Record<string, number>;
  readonly embeddings?: number[];
}

ExperienceResult

Outcome of an experience.

interface ExperienceResult {
  readonly success: boolean;
  readonly outcome: Record<string, unknown>;
  readonly duration: number;
  readonly resourceUsage?: ResourceUsage;
}

OptimizationObjective

Goal for strategy optimization.

interface OptimizationObjective {
  readonly metric: string;
  readonly direction: 'maximize' | 'minimize';
  readonly constraints: Constraint[];
}

Domain Services

ILearningOptimizationCoordinator

Primary coordinator for the domain.

interface ILearningOptimizationCoordinator {
  runLearningCycle(domain: DomainName): Promise<Result<LearningCycleReport>>;
  optimizeAllStrategies(): Promise<Result<OptimizationReport>>;
  shareCrossDomainLearnings(): Promise<Result<CrossDomainSharingReport>>;
  getLearningDashboard(): Promise<Result<LearningDashboard>>;
  exportModels(domains?: DomainName[]): Promise<Result<ModelExport>>;
  importModels(modelExport: ModelExport): Promise<Result<ImportReport>>;
  publishDreamCycleCompleted(
    cycleId: string,
    durationMs: number,
    conceptsProcessed: number,
    insights: DreamInsight[],
    patternsCreated: number
  ): Promise<void>;

  // MinCut integration (ADR-047)
  setMinCutBridge(bridge: QueenMinCutBridge): void;
  isTopologyHealthy(): boolean;

  // Consensus integration (MM-001)
  isConsensusAvailable(): boolean;
}

IPatternLearningService

Pattern extraction and application.

interface IPatternLearningService {
  learnPattern(experiences: Experience[]): Promise<Result<LearnedPattern>>;
  findMatchingPatterns(context: PatternContext, limit?: number): Promise<Result<LearnedPattern[]>>;
  applyPattern(pattern: LearnedPattern, variables: Record<string, unknown>): Promise<Result<string>>;
  updatePatternFeedback(patternId: string, success: boolean): Promise<Result<void>>;
  consolidatePatterns(patternIds: string[]): Promise<Result<LearnedPattern>>;
  getPatternStats(domain?: DomainName): Promise<Result<PatternStats>>;
}

IExperienceMiningService

Experience collection and analysis.

interface IExperienceMiningService {
  recordExperience(experience: Omit<Experience, 'id' | 'timestamp'>): Promise<Result<string>>;
  mineExperiences(domain: DomainName, timeRange: TimeRange): Promise<Result<MinedInsights>>;
  calculateReward(result: ExperienceResult, objective: OptimizationObjective): number;
  getReplayBuffer(agentId: AgentId, limit?: number): Promise<Result<Experience[]>>;
  clusterExperiences(experiences: Experience[]): Promise<Result<ExperienceCluster[]>>;
}

IStrategyOptimizerService

Strategy optimization using ML.

interface IStrategyOptimizerService {
  optimizeStrategy(
    currentStrategy: Strategy,
    objective: OptimizationObjective,
    experiences: Experience[]
  ): Promise<Result<OptimizedStrategy>>;
  runABTest(strategyA: Strategy, strategyB: Strategy, testConfig: ABTestConfig): Promise<Result<ABTestResult>>;
  recommendStrategy(context: PatternContext): Promise<Result<Strategy>>;
  evaluateStrategy(strategy: Strategy, experiences: Experience[]): Promise<Result<StrategyEvaluation>>;
}

IKnowledgeSynthesisService

Cross-agent knowledge transfer.

interface IKnowledgeSynthesisService {
  shareKnowledge(knowledge: Knowledge, targetAgents: AgentId[]): Promise<Result<void>>;
  queryKnowledge(query: KnowledgeQuery): Promise<Result<Knowledge[]>>;
  synthesizeKnowledge(knowledgeIds: string[]): Promise<Result<Knowledge>>;
  transferKnowledge(knowledge: Knowledge, targetDomain: DomainName): Promise<Result<Knowledge>>;
  validateRelevance(knowledge: Knowledge, context: PatternContext): Promise<Result<number>>;
}

Domain Events

Event	Trigger	Payload
PatternLearnedEvent	Pattern extracted	{ patternId, patternType, domain, confidence }
KnowledgeSharedEvent	Knowledge transferred	{ knowledgeId, sourceAgent, targetDomains, knowledgeType }
StrategyOptimizedEvent	Strategy improved	{ strategyId, domain, improvement, metric }
ExperienceRecordedEvent	Experience logged	{ experienceId, agentId, domain, reward }
LearningMilestoneReachedEvent	Milestone achieved	{ milestone, domain, metrics }
DreamCycleCompletedEvent	Dream cycle done	{ cycleId, conceptsProcessed, insights, patternsCreated }

Repositories

interface IPatternRepository {
  findById(id: string): Promise<LearnedPattern | null>;
  findByDomain(domain: DomainName): Promise<LearnedPattern[]>;
  findByType(type: PatternType): Promise<LearnedPattern[]>;
  findSimilar(embedding: number[], limit: number): Promise<LearnedPattern[]>;
  save(pattern: LearnedPattern): Promise<void>;
  update(pattern: LearnedPattern): Promise<void>;
  delete(id: string): Promise<void>;
}

interface IExperienceRepository {
  findById(id: string): Promise<Experience | null>;
  findByAgentId(agentId: AgentId, limit?: number): Promise<Experience[]>;
  findByDomain(domain: DomainName, timeRange: TimeRange): Promise<Experience[]>;
  save(experience: Experience): Promise<void>;
  deleteOlderThan(date: Date): Promise<number>;
}

interface IKnowledgeRepository {
  findById(id: string): Promise<Knowledge | null>;
  findByDomain(domain: DomainName): Promise<Knowledge[]>;
  findByType(type: KnowledgeType): Promise<Knowledge[]>;
  search(query: KnowledgeQuery): Promise<Knowledge[]>;
  save(knowledge: Knowledge): Promise<void>;
  update(knowledge: Knowledge): Promise<void>;
  delete(id: string): Promise<void>;
}

interface IStrategyRepository {
  findById(id: string): Promise<OptimizedStrategy | null>;
  findByDomain(domain: DomainName): Promise<OptimizedStrategy[]>;
  findBest(domain: DomainName, objective: string): Promise<OptimizedStrategy | null>;
  save(strategy: OptimizedStrategy): Promise<void>;
}

Context Integration

Upstream Dependencies

• All domains: Provide experiences and patterns
• Memory backend: HNSW indexing for pattern search

Downstream Consumers

• All domains: Receive optimized strategies and patterns
• Test Generation: Pattern-based test creation
• Defect Intelligence: Learned defect patterns

Anti-Corruption Layer

The domain uses the Experience interface to normalize feedback from different domains, enabling cross-domain learning.

Task Handlers

Task Type	Handler	Description
learn-patterns	learnPattern()	Extract patterns
optimize-strategy	optimizeStrategy()	Improve strategies
share-knowledge	shareKnowledge()	Cross-agent transfer
run-learning-cycle	runLearningCycle()	Full learning cycle
run-ab-test	runABTest()	Strategy comparison

Learning Cycle

async function runLearningCycle(domain: DomainName): Promise<LearningCycleReport> {
  // 1. Collect recent experiences
  const experiences = await experienceRepo.findByDomain(domain, last24Hours);

  // 2. Mine for insights
  const insights = await miningService.mineExperiences(domain, experiences);

  // 3. Extract new patterns
  const patterns = await patternService.learnPattern(experiences);

  // 4. Optimize strategies
  const strategies = await optimizerService.optimizeStrategies(domain, experiences);

  // 5. Generate new knowledge
  const knowledge = await synthesisService.synthesize(patterns, insights);

  // 6. Share across domains
  await synthesisService.shareCrossDomain(knowledge);

  return {
    domain,
    experiencesProcessed: experiences.length,
    patternsLearned: patterns.length,
    strategiesOptimized: strategies.length,
    knowledgeGenerated: knowledge.length,
    improvements: calculateImprovements(strategies),
  };
}

Dream Cycle (Offline Consolidation)

The Dream Cycle runs during low-activity periods to consolidate patterns:

interface DreamCycleConfig {
  minIdleTime: number;          // Minimum idle before starting
  maxDuration: number;          // Maximum cycle duration
  targetPatternCount: number;   // Patterns to consolidate
  domains: DomainName[];        // Domains to process
}

interface DreamInsight {
  id: string;
  type: string;
  description: string;
  noveltyScore: number;
  confidenceScore: number;
  actionable: boolean;
  suggestedAction?: string;
  sourceConcepts: string[];
}

Reward Calculation

function calculateReward(
  result: ExperienceResult,
  objective: OptimizationObjective
): number {
  let reward = 0;

  // Base reward for success
  if (result.success) {
    reward += 1.0;
  }

  // Objective-specific reward
  const objectiveValue = result.outcome[objective.metric] as number;
  if (objectiveValue !== undefined) {
    const normalizedValue = normalizeMetric(objectiveValue, objective);
    reward += objective.direction === 'maximize'
      ? normalizedValue
      : 1 - normalizedValue;
  }

  // Efficiency bonus (faster is better)
  const durationPenalty = Math.min(0.2, result.duration / 60000 * 0.1);
  reward -= durationPenalty;

  // Resource efficiency
  if (result.resourceUsage) {
    const resourcePenalty = (result.resourceUsage.memoryMb / 1024) * 0.05;
    reward -= Math.min(0.1, resourcePenalty);
  }

  // Apply constraints as penalties
  for (const constraint of objective.constraints) {
    const value = result.outcome[constraint.metric] as number;
    if (!meetsConstraint(value, constraint)) {
      reward -= 0.5;
    }
  }

  return Math.max(-1, Math.min(1, reward));
}

ADR References

• ADR-006: Unified Memory Service (pattern storage)
• ADR-009: Hybrid Memory Backend (HNSW indexing)
• ADR-047: MinCut topology for distributed learning
• MM-001: Consensus for strategy validation