@gotza02/seq-thinking 1.1.2 → 1.1.3

package/src/agents/synthesizer-agent.ts

@@ -12,6 +12,7 @@ import {
   type TaskResult,
   type AgentCapability
 } from '../types/index.js';
+import { LLMAdapter } from '../utils/llm-adapter.js';
 
 /**
  * Synthesis input
@@ -57,25 +58,25 @@ export class SynthesizerAgent extends BaseAgent {
       {
         name: 'consensus_building',
         description: 'Build consensus from multiple outputs',
-        confidence: 0.85,
+        confidence: 0.9,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'conflict_resolution',
         description: 'Resolve conflicts between outputs',
-        confidence: 0.8,
+        confidence: 0.85,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'creative_synthesis',
         description: 'Create creative combinations',
-        confidence: 0.75,
+        confidence: 0.8,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'integration',
         description: 'Integrate multiple perspectives',
-        confidence: 0.85,
+        confidence: 0.9,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       }
     ];
@@ -109,7 +110,7 @@ export class SynthesizerAgent extends BaseAgent {
   }
 
   /**
-   * Process a task - synthesize inputs
+   * Process a task - synthesize inputs using LLM
    * @param task - Task to process
    * @returns Task result
    */
@@ -117,196 +118,78 @@ export class SynthesizerAgent extends BaseAgent {
     const startTime = Date.now();
     const input = task.input as SynthesisInput;
 
-    let result: Synthesis;
+    if (!input.outputs || input.outputs.length === 0) {
+      return this.createTaskResult(task.id, { error: 'No outputs to synthesize' }, 0, Date.now() - startTime);
+    }
+
+    const contextStr = input.context ? `Context: ${JSON.stringify(input.context)}\n` : '';
+    const outputsStr = input.outputs.map((o, i) => `Agent ${o.agentId} (Confidence: ${o.confidence}):\n${JSON.stringify(o.output)}`).join('\n\n');
+
+    const provider = (task.context as any)?.modelProvider;
+
+    let prompt = '';
+    let systemPrompt = 'You are an expert synthesizer agent in a swarm intelligence system. Your goal is to combine multiple agent outputs into a coherent, high-quality result.';
 
     switch (this.synthesizerType) {
       case SynthesizerType.CONSENSUS:
-        result = await this.buildConsensus(input);
+        prompt = `Build a consensus from the following agent outputs. Identify common points, resolve minor discrepancies, and provide a unified conclusion.\n\n${contextStr}\n${outputsStr}`;
         break;
       case SynthesizerType.CREATIVE:
-        result = await this.creativeSynthesis(input);
+        prompt = `Perform a creative synthesis of these agent outputs. Look for unexpected connections, combine ideas in novel ways, and provide a unique integrated insight.\n\n${contextStr}\n${outputsStr}`;
+        systemPrompt = 'You are a creative synthesizer agent. You excel at finding novel connections and unique perspectives by combining diverse ideas.';
         break;
       case SynthesizerType.CONFLICT_RESOLUTION:
-        result = await this.resolveConflicts(input);
+        prompt = `Resolve the conflicts between these agent outputs. Analyze the reasoning behind each conflicting point and determine the most logically sound resolution based on the evidence and confidence levels.\n\n${contextStr}\n${outputsStr}`;
+        systemPrompt = 'You are a conflict resolution specialist agent. You excel at analyzing differing perspectives and finding the most accurate resolution based on logic and evidence.';
         break;
       default:
-        result = await this.buildConsensus(input);
+        prompt = `Integrate the following agent outputs into a comprehensive final result.\n\n${contextStr}\n${outputsStr}`;
+    }
+
+    const response = await LLMAdapter.call(prompt, systemPrompt, provider);
+    
+    if (response.error) {
+      // Fallback to heuristic if LLM fails
+      const heuristicResult = await this.heuristicSynthesis(input);
+      return this.createTaskResult(task.id, heuristicResult, heuristicResult.confidence, Date.now() - startTime, { error: response.error });
     }
 
+    const synthesizedOutput = response.content;
+    const avgConfidence = input.outputs.reduce((sum, o) => sum + o.confidence, 0) / input.outputs.length;
+
+    const result: Synthesis = {
+      synthesizedOutput,
+      confidence: Math.min(0.95, avgConfidence + 0.1), // Boost confidence for successful synthesis
+      contributingAgents: input.outputs.map(o => o.agentId),
+      synthesisMethod: `llm_${this.synthesizerType.toLowerCase()}`
+    };
+
     return this.createTaskResult(
       task.id,
       result,
       result.confidence,
       Date.now() - startTime,
       {
-        reasoningSteps: input.outputs.length,
+        reasoningSteps: input.outputs.length + 1,
         intermediateResults: input.outputs.map(o => o.output)
       }
     );
   }
 
   /**
-   * Build consensus from multiple outputs
-   * @param input - Synthesis input
-   * @returns Synthesis result
-   */
-  private async buildConsensus(input: SynthesisInput): Promise<Synthesis> {
-    const { outputs } = input;
-
-    if (outputs.length === 0) {
-      return {
-        synthesizedOutput: null,
-        confidence: 0,
-        contributingAgents: [],
-        synthesisMethod: 'consensus'
-      };
-    }
-
-    if (outputs.length === 1) {
-      return {
-        synthesizedOutput: outputs[0].output,
-        confidence: outputs[0].confidence,
-        contributingAgents: [outputs[0].agentId],
-        synthesisMethod: 'consensus'
-      };
-    }
-
-    // Extract key points from each output
-    const keyPoints = outputs.map(o => this.extractKeyPoints(o.output));
-
-    // Find consensus points (common across multiple outputs)
-    const consensusPoints = this.findConsensusPoints(keyPoints);
-
-    // Find points of divergence
-    const divergencePoints = this.findDivergencePoints(keyPoints);
-
-    // Weight by confidence
-    const weightedConsensus = this.applyConfidenceWeights(consensusPoints, outputs);
-
-    // Calculate consensus level
-    const consensusLevel = consensusPoints.length / Math.max(...keyPoints.map(kp => kp.length));
-
-    // Generate unified output
-    const unified = this.generateUnifiedOutput(weightedConsensus, divergencePoints);
-
-    // Calculate overall confidence
-    const avgConfidence = outputs.reduce((sum, o) => sum + o.confidence, 0) / outputs.length;
-    const consensusBoost = consensusLevel * 0.1;
-
-    return {
-      synthesizedOutput: unified,
-      confidence: Math.min(1, avgConfidence + consensusBoost),
-      contributingAgents: outputs.map(o => o.agentId),
-      synthesisMethod: 'consensus',
-      consensusLevel,
-      dissentPoints: divergencePoints
-    };
-  }
-
-  /**
-   * Creative synthesis
-   * @param input - Synthesis input
-   * @returns Synthesis result
+   * Fallback heuristic synthesis
    */
-  private async creativeSynthesis(input: SynthesisInput): Promise<Synthesis> {
+  private async heuristicSynthesis(input: SynthesisInput): Promise<Synthesis> {
     const { outputs } = input;
-
-    if (outputs.length === 0) {
-      return {
-        synthesizedOutput: null,
-        confidence: 0,
-        contributingAgents: [],
-        synthesisMethod: 'creative_combination'
-      };
-    }
-
-    // Extract creative elements
-    const creativeElements = outputs.map(o => this.extractCreativeElements(o.output));
-
-    // Find unexpected connections
-    const connections = this.findUnexpectedConnections(creativeElements);
-
-    // Generate novel combinations
-    const combinations = this.generateNovelCombinations(creativeElements, connections);
-
-    // Create creative output
-    const creativeOutput = {
-      combinations,
-      connections,
-      originalElements: creativeElements,
-      novelInsights: this.generateNovelInsights(combinations)
-    };
-
-    // Calculate confidence based on diversity and novelty
-    const diversityScore = this.calculateDiversity(creativeElements);
-    const noveltyScore = connections.length > 0 ? 0.8 : 0.5;
-    const confidence = (diversityScore + noveltyScore) / 2;
-
+    // Simplified version of the previous heuristic logic
     return {
-      synthesizedOutput: creativeOutput,
-      confidence,
+      synthesizedOutput: outputs.map(o => JSON.stringify(o.output)).join('\n---\n'),
+      confidence: outputs.reduce((sum, o) => sum + o.confidence, 0) / outputs.length,
       contributingAgents: outputs.map(o => o.agentId),
-      synthesisMethod: 'creative_combination'
+      synthesisMethod: 'heuristic_fallback'
     };
   }
 
-  /**
-   * Resolve conflicts between outputs
-   * @param input - Synthesis input
-   * @returns Synthesis result
-   */
-  private async resolveConflicts(input: SynthesisInput): Promise<Synthesis> {
-    const { outputs } = input;
-
-    if (outputs.length === 0) {
-      return {
-        synthesizedOutput: null,
-        confidence: 0,
-        contributingAgents: [],
-        synthesisMethod: 'conflict_resolution'
-      };
-    }
-
-    if (outputs.length === 1) {
-      return {
-        synthesizedOutput: outputs[0].output,
-        confidence: outputs[0].confidence,
-        contributingAgents: [outputs[0].agentId],
-        synthesisMethod: 'conflict_resolution'
-      };
-    }
-
-    // Identify conflicts
-    const conflicts = this.identifyConflicts(outputs);
-
-    if (conflicts.length === 0) {
-      // No conflicts, use consensus
-      return this.buildConsensus(input);
-    }
-
-    // Resolve each conflict
-    const resolutions = conflicts.map(conflict => ({
-      conflict,
-      resolution: this.resolveConflict(conflict, outputs)
-    }));
-
-    // Merge resolved conflicts with non-conflicting content
-    const finalOutput = this.mergeResolutions(outputs, resolutions);
-
-    // Calculate confidence
-    const avgConfidence = outputs.reduce((sum, o) => sum + o.confidence, 0) / outputs.length;
-    const resolutionQuality = resolutions.length > 0
-      ? resolutions.reduce((sum, r) => sum + r.resolution.confidence, 0) / resolutions.length
-      : 1;
-
-    return {
-      synthesizedOutput: finalOutput,
-      confidence: (avgConfidence + resolutionQuality) / 2,
-      contributingAgents: outputs.map(o => o.agentId),
-      synthesisMethod: 'conflict_resolution',
-      dissentPoints: conflicts.map(c => c.description)
-    };
-  }
 
   // ============================================================================
   // Helper Methods

package/src/mcp-server.ts

@@ -9,6 +9,7 @@ import { SessionManager, SelfCorrectionEngine, AdaptiveGranularityEngine } from
 import { SwarmCoordinator } from './swarm-coordinator.js';
 import { ThoughtType, AgentType, ReasoningStrategy, CriticType, SynthesizerType, ConsensusAlgorithm, ConflictResolutionStrategy } from './types/index.js';
 import { ReasonerAgent, CriticAgent, SynthesizerAgent, MetaReasoningAgent } from './agents/index.js';
+import { Logger } from './utils/logger.js';
 const SEQUENTIAL_THINKING_TOOL = {
     name: 'advanced_sequential_thinking',
     description: 'Advanced sequential thinking with self-correction, parallel hypotheses, meta-reasoning',
@@ -39,7 +40,8 @@ const SEQUENTIAL_THINKING_TOOL = {
             tags: { type: 'array', items: { type: 'string' } },
             assumptions: { type: 'array', items: { type: 'string' } },
             dependencies: { type: 'array', items: { type: 'string' } },
-            settings: { type: 'object' }
+            settings: { type: 'object' },
+            modelProvider: { type: 'string', description: 'Optional LLM provider (gemini, claude, kimi)' }
         },
         required: ['operation']
     }
@@ -183,7 +185,7 @@ export class MCPServer {
                 if (!thought)
                     throw new Error(`Thought not found: ${args.thoughtId}`);
                 const correctionEngine = new SelfCorrectionEngine();
-                const issues = correctionEngine.detectIssues(thought, graph);
+                const issues = await correctionEngine.detectIssues(thought, graph);
                 return { success: true, issuesDetected: issues, recommendations: issues.map((i: any) => i.suggestion) };
             }
             case 'add_meta_thought': {
@@ -215,7 +217,7 @@ export class MCPServer {
                 if (!session)
                     throw new Error(`Session not found: ${args.sessionId}`);
                 const engine = new AdaptiveGranularityEngine();
-                const granularity = engine.calculateGranularity(session.topic, session.context, session.thoughts.size);
+                const granularity = await engine.calculateGranularity(session.topic, session.context, session.thoughts.size);
                 return { success: true, recommendedDetail: granularity.detail, reasoning: granularity.reasoning };
             }
             case 'get_session_state': {
@@ -246,7 +248,7 @@ export class MCPServer {
                 const { task, assignedAgent } = this.swarmCoordinator.submitTask(
                     taskType,
                     `Analyze and expand on this thought: ${thought.content}`,
-                    { thought: thought.content, context: session.context },
+                    { thought: thought.content, context: session.context, modelProvider: args.modelProvider },
                     { requiredCapabilities: args.requiredCapabilities || [], minConfidence: 0.6, maxTimeMs: 30000 }
                 );
 
@@ -375,14 +377,15 @@ export class MCPServer {
         }
     }
     async start() {
+        await this.initialize();
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        console.error('MCP Sequential Thinking Server running on stdio');
+        Logger.error('MCP Sequential Thinking Server running on stdio');
     }
 }
 const isMainModule = import.meta.url === `file://${process.argv[1]}`;
 if (isMainModule) {
     const server = new MCPServer();
-    server.start().catch(console.error);
+    server.start().catch((error) => Logger.error('Server error', { error }));
 }
 //# sourceMappingURL=mcp-server.js.map

package/src/real_world_test.ts

@@ -0,0 +1,89 @@
+import { MCPServer } from './mcp-server.js';
+import { Logger, LogLevel } from './utils/logger.js';
+
+async function runTest() {
+    Logger.setLevel(LogLevel.INFO);
+    console.log('--- Starting Real World Scenario Test ---');
+
+    const server = new MCPServer();
+    await server.initialize();
+    console.log('[System] Server Initialized');
+
+    // 1. Register Agents
+    console.log('\n[Step 1] Registering Agents...');
+    const reasoner = await server.handleSwarmCoordination({
+        operation: 'register_agent',
+        name: 'LogicMaster',
+        agentType: 'reasoner',
+        subtype: 'chain_of_thought'
+    });
+    console.log('Registered Reasoner:', JSON.stringify(reasoner, null, 2));
+
+    const critic = await server.handleSwarmCoordination({
+        operation: 'register_agent',
+        name: 'SafetyCheck',
+        agentType: 'critic',
+        subtype: 'safety'
+    });
+    console.log('Registered Critic:', JSON.stringify(critic, null, 2));
+
+    // 2. Start Thinking Session
+    console.log('\n[Step 2] Initializing Thinking Session...');
+    const session = await server.handleSequentialThinking({
+        operation: 'initialize',
+        topic: 'Architecting a scalable microservices system'
+    });
+    console.log('Session Created:', JSON.stringify(session, null, 2));
+    const sessionId = session.sessionId;
+
+    // 3. Add Initial Thought
+    console.log('\n[Step 3] Adding Initial Thought...');
+    const thought1 = await server.handleSequentialThinking({
+        operation: 'add_thought',
+        sessionId: sessionId,
+        content: 'We need to break down the monolithic application into smaller services.',
+        thoughtType: 'analysis',
+        confidence: 0.8
+    });
+    console.log('Thought Added:', JSON.stringify(thought1, null, 2));
+    
+    if (!thought1.thought) {
+        throw new Error('Failed to create thought');
+    }
+    const thoughtId = thought1.thought.id;
+
+    // 4. Delegate to Swarm (Reasoner)
+    console.log('\n[Step 4] Delegating to Swarm (Reasoner)...');
+    const swarmResult = await server.handleSequentialThinking({
+        operation: 'delegate_to_swarm',
+        sessionId: sessionId,
+        thoughtId: thoughtId,
+        taskType: 'reasoning',
+        requiredCapabilities: ['problem_solving']
+    });
+    console.log('Swarm Delegation Result:', JSON.stringify(swarmResult, null, 2));
+
+    // 5. Self Correction (Simulation)
+    console.log('\n[Step 5] Triggering Self-Correction...');
+    const correction = await server.handleSequentialThinking({
+        operation: 'self_correct',
+        sessionId: sessionId,
+        thoughtId: thoughtId
+    });
+    console.log('Self Correction Result:', JSON.stringify(correction, null, 2));
+
+    // 6. Complete Session
+    console.log('\n[Step 6] Completing Session...');
+    const completion = await server.handleSequentialThinking({
+        operation: 'complete_session',
+        sessionId: sessionId
+    });
+    console.log('Completion Result:', JSON.stringify(completion, null, 2));
+
+    console.log('\n--- Test Finished Successfully ---');
+}
+
+runTest().catch(error => {
+    console.error('Test Failed:', error);
+    process.exit(1);
+});

package/src/sequential-thinking.ts

@@ -3,6 +3,8 @@
  */
 import { ThoughtType, Thought, ThoughtBranch, ConfidenceScore, MetaNote, ThinkingSession, SessionStatus, BranchStatus } from './types/index.js';
 import { calculateSimilarity } from './utils/index.js';
+import { LLMAdapter } from './utils/llm-adapter.js';
+import { Logger } from './utils/logger.js';
 
 export class ConfidenceCalibrator {
     createInitialConfidence(): ConfidenceScore {
@@ -226,25 +228,43 @@ export class ThoughtGraph {
 
 export class MetaReasoningEngine {
     metaNotes = new Map<string, MetaNote>();
-    reflect(session: ThinkingSession) {
+    
+    async reflect(session: ThinkingSession) {
         const thoughts = Array.from(session.thoughts.values());
+        
+        // Basic analysis
         const insights: string[] = [];
         const recommendations: string[] = [];
-        // Analyze thinking patterns
-        const analysisCount = thoughts.filter(t => (t as any).thoughtType === 'analysis').length;
-        const hypothesisCount = thoughts.filter(t => (t as any).thoughtType === 'hypothesis').length;
+        
+        const analysisCount = thoughts.filter(t => t.thoughtType === ThoughtType.ANALYSIS).length;
+        const hypothesisCount = thoughts.filter(t => t.thoughtType === ThoughtType.HYPOTHESIS).length;
+        
         if (analysisCount > hypothesisCount * 2) {
             insights.push('Heavy focus on analysis with limited hypothesis generation');
             recommendations.push('Consider exploring more alternative hypotheses');
         }
-        // Check confidence trends
+
         const avgConfidence = thoughts.length > 0
-            ? thoughts.reduce((sum, t) => sum + (t as any).confidence.overall, 0) / thoughts.length
+            ? thoughts.reduce((sum, t) => sum + t.confidence.overall, 0) / thoughts.length
             : 0;
+            
         if (avgConfidence < 0.5) {
             insights.push('Overall confidence is low');
             recommendations.push('Review assumptions and gather more evidence');
         }
+
+        // Advanced LLM-powered reflection
+        try {
+            const prompt = `Reflect on the following thinking session and provide 3 key insights and 3 specific recommendations for improvement.\nTopic: ${session.topic}\nThoughts:\n${thoughts.map(t => `- [${t.thoughtType}] ${t.content.substring(0, 100)}...`).join('\n')}`;
+            const response = await LLMAdapter.call(prompt, "You are a meta-reasoning engine that analyzes thinking processes.");
+            
+            if (!response.error) {
+                insights.push(`LLM Insight: ${response.content}`);
+            }
+        } catch (e) {
+            Logger.warn('LLM Reflection failed', { error: String(e) });
+        }
+
         return {
             reflectionType: 'session_review',
             content: `Analyzed ${thoughts.length} thoughts across ${session.branches.size} branches`,
@@ -252,6 +272,7 @@ export class MetaReasoningEngine {
             recommendations
         };
     }
+
     generateMetaObservation(thoughtId: string, thoughtGraph: ThoughtGraph) {
         const thought = thoughtGraph.getThoughts().get(thoughtId);
         if (!thought)
@@ -281,8 +302,10 @@ export class MetaReasoningEngine {
 }
 
 export class SelfCorrectionEngine {
-    detectIssues(thought: Thought, graph: ThoughtGraph) {
+    async detectIssues(thought: Thought, graph: ThoughtGraph) {
         const issues: any[] = [];
+        
+        // Fast heuristics
         if (thought.confidence.overall < 0.3) {
             issues.push({
                 type: 'calibration',
@@ -299,6 +322,26 @@ export class SelfCorrectionEngine {
                 suggestion: 'Document assumptions'
             });
         }
+
+        // Deeper LLM analysis for potential fallacies
+        if (thought.content.length > 100) {
+            try {
+                const prompt = `Analyze this thought for logical fallacies or inconsistencies. If any are found, describe them briefly and suggest a correction.\nThought: ${thought.content}`;
+                const response = await LLMAdapter.call(prompt, "You are a critical thinking assistant. Be concise.");
+                
+                if (!response.error && response.content.toLowerCase().includes('fallacy') || response.content.toLowerCase().includes('inconsistency')) {
+                    issues.push({
+                        type: 'logic',
+                        severity: 'medium',
+                        description: `Potential logical issue: ${response.content.substring(0, 100)}...`,
+                        suggestion: 'Review the reasoning for potential fallacies.'
+                    });
+                }
+            } catch (e) {
+                Logger.warn('LLM Self-Correction analysis failed', { error: String(e) });
+            }
+        }
+
         return issues;
     }
     checkSessionHealth(session: ThinkingSession) {
@@ -333,34 +376,44 @@ export class SelfCorrectionEngine {
 }
 
 export class AdaptiveGranularityEngine {
-    calculateGranularity(topic: string, context: any, currentDepth: number) {
-        const hasComplexTerms = /\b(system|architecture|framework)\b/i.test(topic);
-        const detail = hasComplexTerms ? 0.8 : 0.5;
-        return { detail, reasoning: hasComplexTerms ? 'Complex topic detected' : 'Standard granularity' };
-    }
-    getRecommendation(session: ThinkingSession) {
-        const thoughts = Array.from(session.thoughts.values());
-        const avgConfidence = thoughts.length > 0
-            ? thoughts.reduce((sum, t) => sum + (t as any).confidence.overall, 0) / thoughts.length
-            : 0.5;
-        if (avgConfidence < 0.4) {
-            return {
-                suggestedAction: 'increase_detail',
-                detail: 0.9,
-                reasoning: 'Low confidence detected - need more detailed analysis'
-            };
+    async calculateGranularity(topic: string, context: any, currentDepth: number) {
+        // Basic heuristic
+        let detail = 0.5;
+        let reasoning = 'Standard granularity';
+
+        const hasComplexTerms = /\b(system|architecture|framework|optimization|deep learning|quantum)\b/i.test(topic);
+        if (hasComplexTerms) {
+            detail = 0.8;
+            reasoning = 'Complex topic keywords detected';
         }
-        if (thoughts.length > 10 && avgConfidence > 0.8) {
-            return {
-                suggestedAction: 'decrease_detail',
-                detail: 0.4,
-                reasoning: 'High confidence with many thoughts - can summarize'
-            };
+
+        // LLM evaluation of complexity
+        try {
+            const prompt = `On a scale of 0.1 to 1.0, how complex is this topic? Provide only the number and a short reason.\nTopic: ${topic}`;
+            const response = await LLMAdapter.call(prompt, "You are an expert at assessing problem complexity.");
+            
+            if (!response.error) {
+                const match = response.content.match(/0?\.\d+|1\.0/);
+                if (match) {
+                    detail = parseFloat(match[0]);
+                    reasoning = `LLM Complexity Assessment: ${response.content}`;
+                }
+            }
+        } catch (e) {
+            Logger.warn('LLM Granularity calculation failed', { error: String(e) });
         }
+
+        return { detail, reasoning };
+    }
+
+    getRecommendation(session: ThinkingSession) {
+        const hasComplexTerms = /\b(system|architecture|framework|optimization|deep learning|quantum)\b/i.test(session.topic);
+        const detail = hasComplexTerms ? 0.8 : 0.5;
+        
         return {
-            suggestedAction: 'maintain',
-            detail: 0.6,
-            reasoning: 'Current granularity is appropriate'
+            suggestedAction: detail > 0.7 ? 'increase_granularity' : 'maintain_granularity',
+            detail,
+            reasoning: hasComplexTerms ? 'Complex topic detected' : 'Standard complexity'
         };
     }
 }
@@ -504,7 +557,7 @@ export class SessionManager {
             }
         }
         if (session.settings.enableSelfCorrection) {
-            issues = this.correctionEngine.detectIssues(thought, this.graph);
+            issues = await this.correctionEngine.detectIssues(thought, this.graph);
         }
         
         if (this.persistence) {
@@ -557,4 +610,5 @@ export class SessionManager {
         };
     }
 }
+
 //# sourceMappingURL=sequential-thinking.js.map