@gotza02/seq-thinking 1.1.1 → 1.1.3

package/src/__tests__/sequential-thinking.test.ts

@@ -292,9 +292,9 @@ describe('MetaReasoningEngine', () => {
     graph = new ThoughtGraph();
   });
 
-  test('should reflect on session', () => {
+  test('should reflect on session', async () => {
     const session = createMockSession();
-    const reflection = engine.reflect(session);
+    const reflection = await engine.reflect(session);
     
     assert.ok(reflection.reflectionType);
     assert.ok(reflection.content);
@@ -318,18 +318,18 @@ describe('MetaReasoningEngine', () => {
     }
   });
 
-  test('should handle empty session reflection', () => {
+  test('should handle empty session reflection', async () => {
     const emptySession = createMockSession({ totalThoughts: 0, totalBranches: 0 });
-    const reflection = engine.reflect(emptySession);
+    const reflection = await engine.reflect(emptySession);
     
     assert.ok(reflection);
     assert.ok(Array.isArray(reflection.insights));
     assert.ok(Array.isArray(reflection.recommendations));
   });
 
-  test('should handle session with multiple branches', () => {
+  test('should handle session with multiple branches', async () => {
     const session = createMockSession({ totalThoughts: 10, totalBranches: 3 });
-    const reflection = engine.reflect(session);
+    const reflection = await engine.reflect(session);
     
     assert.ok(reflection.insights.length > 0 || reflection.recommendations.length > 0);
   });
@@ -344,11 +344,11 @@ describe('SelfCorrectionEngine', () => {
     graph = new ThoughtGraph();
   });
 
-  test('should detect issues in thought', () => {
+  test('should detect issues in thought', async () => {
     const sessionId = 'test-session';
     const thought = graph.createThought(sessionId, 'Test thought with potential issues');
     
-    const issues = engine.detectIssues(thought, graph);
+    const issues = await engine.detectIssues(thought, graph);
     
     assert.ok(Array.isArray(issues));
     issues.forEach(issue => {
@@ -359,14 +359,14 @@ describe('SelfCorrectionEngine', () => {
     });
   });
 
-  test('should detect no issues in well-formed thought', () => {
+  test('should detect no issues in well-formed thought', async () => {
     const sessionId = 'test-session';
     const thought = graph.createThought(sessionId, 'Well-formed thought with clear reasoning', {
       confidence: 0.95,
       assumptions: ['valid-assumption'],
     });
     
-    const issues = engine.detectIssues(thought, graph);
+    const issues = await engine.detectIssues(thought, graph);
     
     // Should either return empty array or only low severity issues
     issues.forEach(issue => {
@@ -418,30 +418,30 @@ describe('AdaptiveGranularityEngine', () => {
     engine = new AdaptiveGranularityEngine();
   });
 
-  test('should calculate granularity for simple topic', () => {
+  test('should calculate granularity for simple topic', async () => {
     const context = createMockContext();
-    const result = engine.calculateGranularity('Simple topic', context, 1);
+    const result = await engine.calculateGranularity('Simple topic', context, 1);
     
     assert.ok(typeof result.detail === 'number');
     assert.ok(result.detail > 0 && result.detail <= 1);
     assert.ok(result.reasoning);
   });
 
-  test('should calculate granularity for complex topic', () => {
+  test('should calculate granularity for complex topic', async () => {
     const context = createMockContext();
     const complexTopic = 'Analyze the implications of quantum computing on cryptographic systems';
-    const result = engine.calculateGranularity(complexTopic, context, 1);
+    const result = await engine.calculateGranularity(complexTopic, context, 1);
     
     assert.ok(result.detail > 0);
     assert.ok(result.reasoning.length > 0);
   });
 
-  test('should adjust granularity based on depth', () => {
+  test('should adjust granularity based on depth', async () => {
     const context = createMockContext();
     const topic = 'Test topic';
     
-    const shallow = engine.calculateGranularity(topic, context, 1);
-    const deep = engine.calculateGranularity(topic, context, 10);
+    const shallow = await engine.calculateGranularity(topic, context, 1);
+    const deep = await engine.calculateGranularity(topic, context, 10);
     
     // Deeper depth might suggest different granularity
     assert.ok(typeof shallow.detail === 'number');
@@ -458,7 +458,7 @@ describe('AdaptiveGranularityEngine', () => {
     assert.ok(recommendation.reasoning);
   });
 
-  test('should handle empty context', () => {
+  test('should handle empty context', async () => {
     const emptyContext: SessionContext = {
       originalProblem: '',
       constraints: [],
@@ -467,13 +467,13 @@ describe('AdaptiveGranularityEngine', () => {
       longTermReferences: [],
     };
     
-    const result = engine.calculateGranularity('Topic', emptyContext, 1);
+    const result = await engine.calculateGranularity('Topic', emptyContext, 1);
     
     assert.ok(typeof result.detail === 'number');
     assert.ok(result.reasoning);
   });
 
-  test('should handle very complex context', () => {
+  test('should handle very complex context', async () => {
     const complexContext: SessionContext = {
       originalProblem: 'Complex multi-faceted problem',
       constraints: Array(20).fill('constraint'),
@@ -482,7 +482,7 @@ describe('AdaptiveGranularityEngine', () => {
       longTermReferences: Array(10).fill('ref'),
     };
     
-    const result = engine.calculateGranularity('Complex topic', complexContext, 5);
+    const result = await engine.calculateGranularity('Complex topic', complexContext, 5);
     
     assert.ok(typeof result.detail === 'number');
     assert.ok(result.detail > 0 && result.detail <= 1);

package/src/agents/base-agent.ts

@@ -13,6 +13,7 @@ import {
   type TaskResult,
   type SwarmMessage
 } from '../types/index.js';
+import { Logger } from '../utils/logger.js';
 
 /**
  * Abstract base class for all agents
@@ -142,11 +143,11 @@ export abstract class BaseAgent {
         const result = handler(message);
         if (result instanceof Promise) {
           result.catch(error => {
-            console.error(`Error in message handler for agent ${this.id}:`, error);
+            Logger.error(`Error in message handler for agent ${this.id}`, { error });
           });
         }
       } catch (error) {
-        console.error(`Error in message handler for agent ${this.id}:`, error);
+        Logger.error(`Error in message handler for agent ${this.id}`, { error });
       }
     }
   }
@@ -254,6 +255,7 @@ export abstract class BaseAgent {
       tokensUsed?: number;
       reasoningSteps?: number;
       intermediateResults?: unknown[];
+      error?: string;
     } = {}
   ): TaskResult {
     return {
@@ -266,7 +268,8 @@ export abstract class BaseAgent {
       metadata: {
         tokensUsed: metadata.tokensUsed || 0,
         reasoningSteps: metadata.reasoningSteps || 1,
-        intermediateResults: metadata.intermediateResults || []
+        intermediateResults: metadata.intermediateResults || [],
+        error: metadata.error
       }
     };
   }

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

@@ -14,6 +14,7 @@ import {
   type Thought,
   type ThinkingSession
 } from '../types/index.js';
+import { LLMAdapter } from '../utils/llm-adapter.js';
 
 /**
  * Meta-observation
@@ -27,17 +28,7 @@ interface MetaObservation {
 }
 
 /**
- * Thinking pattern
- */
-interface ThinkingPattern {
-  pattern: string;
-  frequency: number;
-  impact: 'positive' | 'negative' | 'neutral';
-  suggestion?: string;
-}
-
-/**
- * Meta-reasoning agent that reflects on thinking processes
+ * Meta-reasoning agent that reflects on thinking processes using LLM
  */
 export class MetaReasoningAgent extends BaseAgent {
   /** Observation history */
@@ -54,26 +45,26 @@ export class MetaReasoningAgent extends BaseAgent {
     const defaultCapabilities: AgentCapability[] = [
       {
         name: 'process_reflection',
-        description: 'Reflect on thinking processes',
-        confidence: 0.9,
+        description: 'Reflect on thinking processes using LLM',
+        confidence: 0.95,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'strategy_assessment',
-        description: 'Assess reasoning strategies',
-        confidence: 0.85,
+        description: 'Assess reasoning strategies using LLM',
+        confidence: 0.9,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'bias_detection',
-        description: 'Detect cognitive biases',
-        confidence: 0.8,
+        description: 'Detect cognitive biases using LLM',
+        confidence: 0.85,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'pattern_analysis',
-        description: 'Analyze thinking patterns',
-        confidence: 0.85,
+        description: 'Analyze thinking patterns using LLM',
+        confidence: 0.9,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       }
     ];
@@ -104,7 +95,7 @@ export class MetaReasoningAgent extends BaseAgent {
   }
 
   /**
-   * Process a task - perform meta-reasoning
+   * Process a task - perform meta-reasoning using LLM
    * @param task - Task to process
    * @returns Task result
    */
@@ -116,30 +107,48 @@ export class MetaReasoningAgent extends BaseAgent {
       operation: 'reflect' | 'analyze_patterns' | 'assess_strategy' | 'detect_bias';
     };
 
-    let result: unknown;
-    let confidence = 0.8;
+    const provider = (task.context as any)?.modelProvider;
+
+    let prompt = '';
+    let systemPrompt = 'You are a meta-reasoning agent. Your role is to analyze and reflect on the thinking processes of other agents or sessions, identifying patterns, biases, and areas for improvement.';
+
+    const sessionData = input.session ? `Session Topic: ${input.session.topic}\nSession Status: ${input.session.status}\n` : '';
+    const thoughtsData = (input.thoughts || (input.session ? Array.from(input.session.thoughts.values()) : []))
+      .map(t => `Step ${t.stepNumber} (${t.thoughtType}, Confidence: ${t.confidence.overall}):\n${t.content}`).join('\n\n');
 
     switch (input.operation) {
       case 'reflect':
-        result = this.reflect(input.session);
+        prompt = `Perform a comprehensive reflection on this thinking session. What are the key insights? What has been achieved? What is still missing?\n\n${sessionData}${thoughtsData}`;
         break;
       case 'analyze_patterns':
-        result = this.analyzeThinkingPatterns(input.thoughts || []);
+        prompt = `Analyze the thinking patterns in these thoughts. Are there repetitive cycles? Is there a logical progression? Are there any gaps in the reasoning chain?\n\n${thoughtsData}`;
         break;
       case 'assess_strategy':
-        result = this.assessStrategy(input.session);
+        prompt = `Assess the reasoning strategy used in this session. Is it effective for the topic? Should the strategy be adjusted (e.g., move from analysis to synthesis)?\n\n${sessionData}${thoughtsData}`;
         break;
       case 'detect_bias':
-        result = this.detectBias(input.thoughts || []);
+        prompt = `Identify any cognitive biases present in these thoughts (e.g., confirmation bias, anchoring, overconfidence). Provide evidence from the text for each detected bias.\n\n${thoughtsData}`;
+        systemPrompt = 'You are an expert in cognitive psychology and bias detection. Your role is to identify subtle biases in reasoning processes.';
         break;
       default:
-        result = this.reflect(input.session);
+        prompt = `Reflect on the following thoughts and provide meta-observations.\n\n${thoughtsData}`;
+    }
+
+    const response = await LLMAdapter.call(prompt, systemPrompt, provider);
+
+    if (response.error) {
+      // Fallback to simple reflection if LLM fails
+      return this.createTaskResult(task.id, { error: response.error, fallback: 'LLM failed' }, 0, Date.now() - startTime);
     }
 
     return this.createTaskResult(
       task.id,
-      result,
-      confidence,
+      {
+        analysis: response.content,
+        operation: input.operation,
+        timestamp: new Date()
+      },
+      0.9,
       Date.now() - startTime,
       {
         reasoningSteps: 1,
@@ -148,374 +157,6 @@ export class MetaReasoningAgent extends BaseAgent {
     );
   }
 
-  /**
-   * 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