@gotza02/seq-thinking 1.1.0

package/src/agents/meta-reasoning-agent.ts

@@ -0,0 +1,672 @@
+/**
+ * Meta-Reasoning Agent Implementation
+ * @module agents/meta-reasoning-agent
+ * @version 1.0.0
+ */
+
+import { BaseAgent } from './base-agent.js';
+import {
+  AgentType,
+  ThoughtType,
+  type Task,
+  type TaskResult,
+  type AgentCapability,
+  type Thought,
+  type ThinkingSession
+} from '../types/index.js';
+
+/**
+ * Meta-observation
+ */
+interface MetaObservation {
+  type: 'pattern' | 'concern' | 'insight' | 'suggestion';
+  description: string;
+  severity?: 'low' | 'medium' | 'high';
+  recommendation?: string;
+  triggeredActions?: string[];
+}
+
+/**
+ * Thinking pattern
+ */
+interface ThinkingPattern {
+  pattern: string;
+  frequency: number;
+  impact: 'positive' | 'negative' | 'neutral';
+  suggestion?: string;
+}
+
+/**
+ * Meta-reasoning agent that reflects on thinking processes
+ */
+export class MetaReasoningAgent extends BaseAgent {
+  /** Observation history */
+  private observationHistory: MetaObservation[] = [];
+
+  /**
+   * Create a new meta-reasoning agent
+   * @param config - Agent configuration
+   */
+  constructor(config: {
+    name: string;
+    capabilities?: AgentCapability[];
+  }) {
+    const defaultCapabilities: AgentCapability[] = [
+      {
+        name: 'process_reflection',
+        description: 'Reflect on thinking processes',
+        confidence: 0.9,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'strategy_assessment',
+        description: 'Assess reasoning strategies',
+        confidence: 0.85,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'bias_detection',
+        description: 'Detect cognitive biases',
+        confidence: 0.8,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'pattern_analysis',
+        description: 'Analyze thinking patterns',
+        confidence: 0.85,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      }
+    ];
+
+    super({
+      name: config.name,
+      type: AgentType.META_REASONING,
+      capabilities: config.capabilities || defaultCapabilities,
+      maxConcurrentTasks: 5,
+      confidenceThreshold: 0.7
+    });
+  }
+
+  /**
+   * Get agent type
+   * @returns Agent type
+   */
+  getType(): string {
+    return AgentType.META_REASONING;
+  }
+
+  /**
+   * Get agent capabilities
+   * @returns Array of capabilities
+   */
+  getCapabilities(): AgentCapability[] {
+    return this.config.capabilities;
+  }
+
+  /**
+   * Process a task - perform meta-reasoning
+   * @param task - Task to process
+   * @returns Task result
+   */
+  async process(task: Task): Promise<TaskResult> {
+    const startTime = Date.now();
+    const input = task.input as {
+      session?: ThinkingSession;
+      thoughts?: Thought[];
+      operation: 'reflect' | 'analyze_patterns' | 'assess_strategy' | 'detect_bias';
+    };
+
+    let result: unknown;
+    let confidence = 0.8;
+
+    switch (input.operation) {
+      case 'reflect':
+        result = this.reflect(input.session);
+        break;
+      case 'analyze_patterns':
+        result = this.analyzeThinkingPatterns(input.thoughts || []);
+        break;
+      case 'assess_strategy':
+        result = this.assessStrategy(input.session);
+        break;
+      case 'detect_bias':
+        result = this.detectBias(input.thoughts || []);
+        break;
+      default:
+        result = this.reflect(input.session);
+    }
+
+    return this.createTaskResult(
+      task.id,
+      result,
+      confidence,
+      Date.now() - startTime,
+      {
+        reasoningSteps: 1,
+        intermediateResults: []
+      }
+    );
+  }
+
+  /**
+   * Reflect on a thinking session
+   * @param session - Session to reflect on
+   * @returns Reflection result
+   */
+  reflect(session?: ThinkingSession): {
+    reflection: string;
+    insights: string[];
+    recommendations: string[];
+    observations: MetaObservation[];
+  } {
+    if (!session) {
+      return {
+        reflection: 'No session provided for reflection',
+        insights: [],
+        recommendations: [],
+        observations: []
+      };
+    }
+
+    const thoughts = Array.from(session.thoughts.values());
+    const insights: string[] = [];
+    const recommendations: string[] = [];
+    const observations: MetaObservation[] = [];
+
+    // Analyze thinking patterns
+    const patterns = this.analyzeThinkingPatterns(thoughts);
+
+    for (const pattern of patterns) {
+      if (pattern.impact === 'negative') {
+        observations.push({
+          type: 'concern',
+          description: pattern.pattern,
+          severity: pattern.frequency > 3 ? 'high' : 'medium',
+          recommendation: pattern.suggestion
+        });
+        recommendations.push(pattern.suggestion || 'Review and adjust thinking pattern');
+      } else if (pattern.impact === 'positive') {
+        observations.push({
+          type: 'insight',
+          description: pattern.pattern
+        });
+        insights.push(pattern.pattern);
+      }
+    }
+
+    // Check confidence trends
+    const confidenceTrend = this.analyzeConfidenceTrend(thoughts);
+    if (confidenceTrend.trend === 'declining') {
+      observations.push({
+        type: 'concern',
+        description: 'Confidence is declining over time',
+        severity: 'medium',
+        recommendation: 'Review assumptions and gather more evidence'
+      });
+      recommendations.push('Strengthen reasoning with additional evidence');
+    } else if (confidenceTrend.trend === 'improving') {
+      insights.push('Confidence is improving, indicating solid reasoning progress');
+    }
+
+    // Check thought type distribution
+    const typeDistribution = this.analyzeThoughtTypeDistribution(thoughts);
+    const analysisCount = typeDistribution.get(ThoughtType.ANALYSIS) || 0;
+    const hypothesisCount = typeDistribution.get(ThoughtType.HYPOTHESIS) || 0;
+    
+    if (analysisCount > hypothesisCount * 3) {
+      observations.push({
+        type: 'suggestion',
+        description: 'Heavy focus on analysis with limited hypothesis generation',
+        recommendation: 'Consider exploring more alternative hypotheses'
+      });
+      recommendations.push('Generate more diverse hypotheses');
+    }
+
+    // Check for meta-reasoning gaps
+    const metaThoughtCount = thoughts.filter(t => t.thoughtType === ThoughtType.META_REASONING).length;
+    if (metaThoughtCount < thoughts.length * 0.1) {
+      observations.push({
+        type: 'suggestion',
+        description: 'Limited meta-reasoning detected',
+        recommendation: 'Increase reflection on the thinking process itself'
+      });
+      recommendations.push('Add more meta-reasoning steps');
+    }
+
+    const reflection = `Analyzed ${thoughts.length} thoughts across ${session.branches.size} branches. ` +
+      `Found ${insights.length} positive insights and ${recommendations.length} areas for improvement.`;
+
+    return {
+      reflection,
+      insights,
+      recommendations,
+      observations
+    };
+  }
+
+  /**
+   * Analyze thinking patterns
+   * @param thoughts - Thoughts to analyze
+   * @returns Array of patterns
+   */
+  analyzeThinkingPatterns(thoughts: Thought[]): ThinkingPattern[] {
+    const patterns: ThinkingPattern[] = [];
+
+    if (thoughts.length === 0) return patterns;
+
+    // Pattern: Repetitive thinking
+    const contentSimilarities = this.findSimilarThoughts(thoughts);
+    if (contentSimilarities.length > thoughts.length * 0.3) {
+      patterns.push({
+        pattern: 'Repetitive thinking detected - similar thoughts being generated',
+        frequency: contentSimilarities.length,
+        impact: 'negative',
+        suggestion: 'Focus on generating novel insights rather than restating'
+      });
+    }
+
+    // Pattern: Confidence progression
+    const confidenceValues = thoughts.map(t => t.confidence.overall);
+    const avgConfidence = confidenceValues.reduce((a, b) => a + b, 0) / confidenceValues.length;
+
+    if (avgConfidence < 0.5) {
+      patterns.push({
+        pattern: 'Low average confidence across thoughts',
+        frequency: thoughts.length,
+        impact: 'negative',
+        suggestion: 'Strengthen evidence and reasoning for key claims'
+      });
+    } else if (avgConfidence > 0.8) {
+      patterns.push({
+        pattern: 'High confidence maintained throughout',
+        frequency: thoughts.length,
+        impact: 'positive'
+      });
+    }
+
+    // Pattern: Branch exploration
+    const branchIds = new Set(thoughts.map(t => t.branchId));
+    if (branchIds.size === 1 && thoughts.length > 5) {
+      patterns.push({
+        pattern: 'Single branch exploration - no parallel hypotheses',
+        frequency: 1,
+        impact: 'negative',
+        suggestion: 'Consider branching to explore alternative approaches'
+      });
+    } else if (branchIds.size > 2) {
+      patterns.push({
+        pattern: 'Active branch exploration with parallel hypotheses',
+        frequency: branchIds.size,
+        impact: 'positive'
+      });
+    }
+
+    // Pattern: Assumption documentation
+    const thoughtsWithAssumptions = thoughts.filter(t => t.assumptions.length > 0).length;
+    if (thoughtsWithAssumptions < thoughts.length * 0.3) {
+      patterns.push({
+        pattern: 'Limited explicit assumption documentation',
+        frequency: thoughts.length - thoughtsWithAssumptions,
+        impact: 'negative',
+        suggestion: 'Document assumptions explicitly for each major claim'
+      });
+    }
+
+    // Pattern: Revision activity
+    const revisedThoughts = thoughts.filter(t => t.revisionHistory.length > 0).length;
+    if (revisedThoughts > thoughts.length * 0.5) {
+      patterns.push({
+        pattern: 'High revision rate - thoughts being frequently corrected',
+        frequency: revisedThoughts,
+        impact: 'neutral',
+        suggestion: 'Consider more careful initial analysis to reduce revisions'
+      });
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Assess reasoning strategy
+   * @param session - Session to assess
+   * @returns Strategy assessment
+   */
+  assessStrategy(session?: ThinkingSession): {
+    assessment: string;
+    strengths: string[];
+    weaknesses: string[];
+    suggestions: string[];
+  } {
+    if (!session) {
+      return {
+        assessment: 'No session provided',
+        strengths: [],
+        weaknesses: [],
+        suggestions: []
+      };
+    }
+
+    const thoughts = Array.from(session.thoughts.values());
+    const strengths: string[] = [];
+    const weaknesses: string[] = [];
+    const suggestions: string[] = [];
+
+    // Assess hypothesis generation
+    const hypothesisCount = thoughts.filter(t => t.thoughtType === ThoughtType.HYPOTHESIS).length;
+    if (hypothesisCount >= 3) {
+      strengths.push('Good hypothesis generation with multiple alternatives');
+    } else if (hypothesisCount < 2 && thoughts.length > 5) {
+      weaknesses.push('Limited hypothesis generation');
+      suggestions.push('Generate at least 3 alternative hypotheses early in the process');
+    }
+
+    // Assess evidence gathering
+    const evidenceCount = thoughts.filter(t => t.thoughtType === ThoughtType.EVIDENCE).length;
+    if (evidenceCount >= thoughts.length * 0.2) {
+      strengths.push('Strong evidence-based reasoning');
+    } else {
+      weaknesses.push('Insufficient evidence gathering');
+      suggestions.push('Support claims with more evidence and citations');
+    }
+
+    // Assess counterargument consideration
+    const counterCount = thoughts.filter(t => t.thoughtType === ThoughtType.COUNTERARGUMENT).length;
+    if (counterCount >= 2) {
+      strengths.push('Good consideration of counterarguments');
+    } else if (thoughts.length > 8) {
+      weaknesses.push('Limited counterargument analysis');
+      suggestions.push('Actively seek and address counterarguments');
+    }
+
+    // Assess synthesis
+    const synthesisCount = thoughts.filter(t => t.thoughtType === ThoughtType.SYNTHESIS).length;
+    if (synthesisCount >= 2) {
+      strengths.push('Regular synthesis of findings');
+    } else if (thoughts.length > 10) {
+      suggestions.push('Periodically synthesize findings to maintain coherence');
+    }
+
+    // Assess self-correction
+    const correctionCount = thoughts.filter(t => t.thoughtType === ThoughtType.SELF_CORRECTION).length;
+    if (correctionCount >= 1) {
+      strengths.push('Active self-correction detected');
+    }
+
+    const assessment = strengths.length > weaknesses.length
+      ? 'Overall effective reasoning strategy'
+      : weaknesses.length > strengths.length
+        ? 'Strategy needs improvement'
+        : 'Balanced strategy with room for improvement';
+
+    return {
+      assessment,
+      strengths,
+      weaknesses,
+      suggestions
+    };
+  }
+
+  /**
+   * Detect cognitive biases
+   * @param thoughts - Thoughts to analyze
+   * @returns Bias detection results
+   */
+  detectBias(thoughts: Thought[]): {
+    detectedBiases: Array<{
+      bias: string;
+      evidence: string;
+      severity: 'low' | 'medium' | 'high';
+      mitigation: string;
+    }>;
+    overallRisk: 'low' | 'medium' | 'high';
+  } {
+    const detectedBiases: Array<{
+      bias: string;
+      evidence: string;
+      severity: 'low' | 'medium' | 'high';
+      mitigation: string;
+    }> = [];
+
+    if (thoughts.length === 0) {
+      return { detectedBiases, overallRisk: 'low' };
+    }
+
+    // Check for confirmation bias
+    const confirmingThoughts = thoughts.filter(t =>
+      t.content.toLowerCase().includes('confirms') ||
+      t.content.toLowerCase().includes('proves') ||
+      t.content.toLowerCase().includes('supports')
+    ).length;
+
+    const disconfirmingThoughts = thoughts.filter(t =>
+      t.content.toLowerCase().includes('contradicts') ||
+      t.content.toLowerCase().includes('challenges') ||
+      t.content.toLowerCase().includes('refutes')
+    ).length;
+
+    if (confirmingThoughts > disconfirmingThoughts * 3 && confirmingThoughts > 2) {
+      detectedBiases.push({
+        bias: 'Confirmation Bias',
+        evidence: `${confirmingThoughts} confirming vs ${disconfirmingThoughts} disconfirming thoughts`,
+        severity: 'medium',
+        mitigation: 'Actively seek disconfirming evidence for each claim'
+      });
+    }
+
+    // Check for anchoring bias
+    const firstThoughtConfidence = thoughts[0]?.confidence.overall || 0.5;
+    const confidenceVariance = this.calculateConfidenceVariance(thoughts);
+
+    if (confidenceVariance < 0.1 && thoughts.length > 5) {
+      detectedBiases.push({
+        bias: 'Anchoring Bias',
+        evidence: 'Low confidence variance suggests anchoring to initial estimates',
+        severity: 'low',
+        mitigation: 'Re-evaluate confidence independently for each thought'
+      });
+    }
+
+    // Check for availability bias
+    const recentThoughts = thoughts.slice(-3);
+    const recentReferences = recentThoughts.filter(t =>
+      t.dependencies.some(d => thoughts.slice(0, -3).some(pt => pt.id === d))
+    ).length;
+
+    if (recentReferences === 0 && thoughts.length > 5) {
+      detectedBiases.push({
+        bias: 'Availability Bias',
+        evidence: 'Recent thoughts do not reference earlier work',
+        severity: 'low',
+        mitigation: 'Actively reference and build upon earlier insights'
+      });
+    }
+
+    // Check for overconfidence
+    const highConfidenceCount = thoughts.filter(t => t.confidence.overall > 0.9).length;
+    if (highConfidenceCount > thoughts.length * 0.5) {
+      detectedBiases.push({
+        bias: 'Overconfidence Bias',
+        evidence: `${highConfidenceCount}/${thoughts.length} thoughts have >90% confidence`,
+        severity: 'medium',
+        mitigation: 'Calibrate confidence more conservatively'
+      });
+    }
+
+    // Check for sunk cost fallacy
+    const revisionCount = thoughts.filter(t => t.revisionHistory.length > 0).length;
+    if (revisionCount > thoughts.length * 0.7 && thoughts.length > 5) {
+      detectedBiases.push({
+        bias: 'Sunk Cost Fallacy',
+        evidence: 'High revision rate may indicate reluctance to abandon initial approach',
+        severity: 'low',
+        mitigation: 'Be willing to start fresh if current approach is not working'
+      });
+    }
+
+    // Determine overall risk
+    const highSeverityCount = detectedBiases.filter(b => b.severity === 'high').length;
+    const mediumSeverityCount = detectedBiases.filter(b => b.severity === 'medium').length;
+
+    let overallRisk: 'low' | 'medium' | 'high' = 'low';
+    if (highSeverityCount > 0 || mediumSeverityCount > 2) {
+      overallRisk = 'high';
+    } else if (mediumSeverityCount > 0) {
+      overallRisk = 'medium';
+    }
+
+    return { detectedBiases, overallRisk };
+  }
+
+  // ============================================================================
+  // Helper Methods
+  // ============================================================================
+
+  /**
+   * Find similar thoughts
+   * @param thoughts - Thoughts to compare
+   * @returns Array of similar thought pairs
+   */
+  private findSimilarThoughts(thoughts: Thought[]): Array<[Thought, Thought]> {
+    const similar: Array<[Thought, Thought]> = [];
+
+    for (let i = 0; i < thoughts.length; i++) {
+      for (let j = i + 1; j < thoughts.length; j++) {
+        if (this.thoughtsAreSimilar(thoughts[i], thoughts[j])) {
+          similar.push([thoughts[i], thoughts[j]]);
+        }
+      }
+    }
+
+    return similar;
+  }
+
+  /**
+   * Check if two thoughts are similar
+   * @param a - First thought
+   * @param b - Second thought
+   * @returns True if similar
+   */
+  private thoughtsAreSimilar(a: Thought, b: Thought): boolean {
+    const wordsA = new Set(a.content.toLowerCase().split(/\s+/));
+    const wordsB = new Set(b.content.toLowerCase().split(/\s+/));
+    const intersection = [...wordsA].filter(w => wordsB.has(w));
+    const union = new Set([...wordsA, ...wordsB]);
+
+    return union.size > 0 && intersection.length / union.size > 0.7;
+  }
+
+  /**
+   * Analyze confidence trend
+   * @param thoughts - Thoughts to analyze
+   * @returns Trend analysis
+   */
+  private analyzeConfidenceTrend(thoughts: Thought[]): {
+    trend: 'improving' | 'declining' | 'stable';
+    initial: number;
+    final: number;
+  } {
+    if (thoughts.length < 3) {
+      return { trend: 'stable', initial: 0, final: 0 };
+    }
+
+    const sorted = [...thoughts].sort((a, b) =>
+      a.metadata.createdAt.getTime() - b.metadata.createdAt.getTime()
+    );
+
+    const firstThird = sorted.slice(0, Math.ceil(sorted.length / 3));
+    const lastThird = sorted.slice(-Math.ceil(sorted.length / 3));
+
+    const initial = firstThird.reduce((sum, t) => sum + t.confidence.overall, 0) / firstThird.length;
+    const final = lastThird.reduce((sum, t) => sum + t.confidence.overall, 0) / lastThird.length;
+
+    const diff = final - initial;
+    const threshold = 0.1;
+
+    let trend: 'improving' | 'declining' | 'stable';
+    if (diff > threshold) {
+      trend = 'improving';
+    } else if (diff < -threshold) {
+      trend = 'declining';
+    } else {
+      trend = 'stable';
+    }
+
+    return { trend, initial, final };
+  }
+
+  /**
+   * Analyze thought type distribution
+   * @param thoughts - Thoughts to analyze
+   * @returns Type distribution map
+   */
+  private analyzeThoughtTypeDistribution(thoughts: Thought[]): Map<ThoughtType, number> {
+    const distribution = new Map<ThoughtType, number>();
+
+    for (const thought of thoughts) {
+      const count = distribution.get(thought.thoughtType) || 0;
+      distribution.set(thought.thoughtType, count + 1);
+    }
+
+    return distribution;
+  }
+
+  /**
+   * Calculate confidence variance
+   * @param thoughts - Thoughts to analyze
+   * @returns Variance
+   */
+  private calculateConfidenceVariance(thoughts: Thought[]): number {
+    if (thoughts.length < 2) return 0;
+
+    const values = thoughts.map(t => t.confidence.overall);
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const squaredDiffs = values.map(v => Math.pow(v - mean, 2));
+
+    return squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
+  }
+
+  /**
+   * Generate meta-observation for a thought
+   * @param thought - Thought to analyze
+   * @returns Meta-observation or null
+   */
+  generateMetaObservation(thought: Thought): MetaObservation | null {
+    const observations: string[] = [];
+    const triggeredActions: string[] = [];
+
+    // Check for high uncertainty
+    const uncertaintyRange = thought.confidence.uncertaintyBounds[1] - thought.confidence.uncertaintyBounds[0];
+    if (uncertaintyRange > 0.4) {
+      observations.push('High uncertainty detected');
+      triggeredActions.push('gather_more_evidence');
+    }
+
+    // Check for low confidence
+    if (thought.confidence.overall < 0.4) {
+      observations.push('Low confidence in this thought');
+      triggeredActions.push('review_reasoning');
+    }
+
+    // Check for missing assumptions
+    if (thought.assumptions.length === 0) {
+      observations.push('No explicit assumptions documented');
+      triggeredActions.push('document_assumptions');
+    }
+
+    if (observations.length === 0) return null;
+
+    return {
+      type: 'pattern',
+      description: observations.join('; '),
+      triggeredActions
+    };
+  }
+
+  /**
+   * Get observation history
+   * @returns Observation history
+   */
+  getObservationHistory(): MetaObservation[] {
+    return [...this.observationHistory];
+  }
+}