@nbiish/cognitive-tools-mcp 8.9.1 → 8.9.3

package/build/index.js

@@ -1,1167 +1,504 @@
 #!/usr/bin/env node
-/**
- * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Revolutionary 2-Round Cognitive Deliberation MCP Server (v8.8.4)
- *
- * Description: Revolutionary MCP server implementing the most advanced 2-round cognitive
- * processing engine available. Features a comprehensive 6-stage framework combining
- * Scientific Investigation, OOReD analysis, and Critical Thinking methodologies
- * with expertly evaluated prompting strategies from modern-prompting.mdc.
- *
- * v8.8.2 OPTIMIZATION RELEASE - Threshold Adjustment & Verbosity Reduction:
- * - Updated threshold from ≥1.38 to ≥1.42 for more selective prompting strategies
- * - Removed redundant "Strategy-Enhanced Results" sections from all stages
- * - Optimized critical thinking path generation to eliminate repetitive content
- * - Simplified strategy application formatting for conciseness
- * - Eliminated duplicate strategy evaluation between rounds for consistency
- * - Maintained single tool call architecture with reduced verbosity
- * -----------------------------------------------------------------------------
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-// --- Server Definition ---
-const serverInfo = {
-    name: "gikendaasowin-aabajichiganan-mcp",
-    version: "8.9.0",
-    description: "Optimized Single-Tool-Call 2-Round Cognitive Deliberation MCP server with minimal filler verbiage, accepting only input & context parameters while maintaining comprehensive 6-stage cognitive framework."
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Modern prompting strategies from modern-prompting.mdc
+const PROMPTING_STRATEGIES = {
+    "Cache-Augmented Reasoning + ReAct": {
+        description: "Interleave internal knowledge activation with reasoning/action cycles. Preload all relevant context into working memory. Keep rationale concise (≤ 8 bullets). Synthesize knowledge from multiple internal sources. Progressive knowledge building through iterative refinement.",
+        type: "primary"
+    },
+    "Self-Consistency": {
+        description: "Generate 3 short reasoning drafts in parallel. Return most consistent answer only. Use for ambiguous or high-stakes decisions.",
+        type: "primary"
+    },
+    "PAL (Program-Aided Language)": {
+        description: "Generate executable code for computational tasks. Include result + minimal rationale only. Prefix with '# PoT offload' comment.",
+        type: "primary"
+    },
+    "Reflexion": {
+        description: "Single critique and revision cycle. Use when confidence < 0.7. Avoid verbose chain-of-thought exposure.",
+        type: "primary"
+    },
+    "Context-Compression": {
+        description: "Apply when context exceeds budget. Use LLMLingua/LongLLMLingua compression. Prefer Minimal-CoT and bounded ToT-lite.",
+        type: "primary"
+    },
+    "ToT-lite (Tree of Thoughts)": {
+        description: "Bounded breadth/depth exploration. Use for complex problem decomposition. Limited branching to maintain efficiency.",
+        type: "primary"
+    },
+    "Automated Prompt Optimization (APO)": {
+        description: "Autonomously refine and improve prompts based on performance feedback. Use techniques like Expert Prompting or iterative refinement to enhance clarity and effectiveness. Reduces manual prompt engineering effort and improves task outcomes.",
+        type: "advanced"
+    },
+    "Reflexive Analysis": {
+        description: "Embed ethical, legal, and cultural considerations directly into the reasoning process. Explicitly evaluate prompts and responses against project-specific guidelines (e.g., Indigenous Data Sovereignty principles). Ensures responsible and contextually-aware AI behavior.",
+        type: "advanced"
+    },
+    "Progressive-Hint Prompting (PHP)": {
+        description: "Use previously generated outputs as contextual hints. Iterative refinement toward optimal solutions. Multi-turn interaction with cumulative knowledge building. Automatic guidance toward correct reasoning paths.",
+        type: "advanced"
+    },
+    "Cache-Augmented Generation (CAG)": {
+        description: "Preload all relevant context into working memory. Eliminate real-time retrieval dependencies. Leverage extended context capabilities of modern LLMs. Reduce latency and minimize retrieval errors.",
+        type: "advanced"
+    },
+    "Cognitive Scaffolding Prompting": {
+        description: "Structure reasoning through metacognitive frameworks. Explicit mental model construction and validation. Progressive complexity building from simple to complex tasks. Self-monitoring and regulation of reasoning processes.",
+        type: "advanced"
+    },
+    "Internal Knowledge Synthesis (IKS)": {
+        description: "Generate hypothetical knowledge constructs from parametric memory. Activate latent knowledge through structured prompting. Cross-reference and validate internal knowledge consistency. Synthesize coherent responses from distributed model knowledge.",
+        type: "advanced"
+    },
+    "Multimodal Synthesis": {
+        description: "Process and integrate information from multiple modalities (e.g., text, images, data). Extend reasoning capabilities to include visual question answering and cross-modal analysis. Enables solutions for a broader range of complex, real-world tasks.",
+        type: "advanced"
+    },
+    "Knowledge Synthesis Prompting (KSP)": {
+        description: "Integrate knowledge from multiple internal domains. Fine-grained coherence validation for credibility. Essential for complex factual content generation. Cross-domain knowledge validation and integration.",
+        type: "advanced"
+    },
+    "Prompt Compression": {
+        description: "LLMLingua for token budget management. Preserve semantic content while reducing length. Maintain reasoning quality under constraints.",
+        type: "advanced"
+    }
 };
-const server = new McpServer(serverInfo);
-// --- Logging Helpers (Internal - No changes needed as per user comments) ---
-/**
- * Logs an incoming tool call to stderr.
- * @param toolName The name of the tool being called.
- * @param details Optional additional details about the call.
- */
-function logToolCall(toolName, details) {
-    const timestamp = new Date().toISOString();
-    console.error(`[${timestamp}] [MCP Server] > Tool Call: ${toolName}${details ? ` - ${details}` : ''}`);
-}
-/**
- * Logs the result (success or failure) of a tool execution to stderr.
- * @param toolName The name of the tool executed.
- * @param success Whether the execution was successful.
- * @param resultDetails Optional details about the result.
- */
-function logToolResult(toolName, success, resultDetails) {
-    const timestamp = new Date().toISOString();
-    console.error(`[${timestamp}] [MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
-}
-/**
- * Logs an error during tool execution and formats a standard error response for the LLM.
- * @param toolName The name of the tool where the error occurred.
- * @param error The error object or message.
- * @returns An object matching the required MCP tool result structure containing the error message.
- */
-function logToolError(toolName, error) {
-    const timestamp = new Date().toISOString();
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`[${timestamp}] [MCP Server] ! Tool Error: ${toolName} - ${errorMessage}`);
-    logToolResult(toolName, false, errorMessage); // Log failure result as well
-    // Simplified Error Reporting: Return only the core error message.
-    return {
-        content: [{
-                type: "text",
-                text: `**TOOL EXECUTION ERROR in '${toolName}':** ${errorMessage}`
-            }]
-    };
-}
-/**
- * Evaluates all prompting strategies from modern-prompting.mdc based on input and task
- * Returns strategies with scores ≥1.42 for use in deliberation
- * CRITICAL: Strategies are evaluated in-prompt based on actual context, NOT hardcoded
- */
-function evaluatePromptingStrategies(input, mode, context) {
-    // Define strategy templates with descriptions from modern-prompting.mdc
-    const strategyTemplates = [
-        {
-            name: "Cache-Augmented Reasoning + ReAct",
-            description: "Interleave internal knowledge activation with reasoning/action cycles"
-        },
-        {
-            name: "Self-Consistency",
-            description: "Generate 3 short reasoning drafts in parallel"
-        },
-        {
-            name: "ToT-lite (Tree of Thoughts)",
-            description: "Bounded breadth/depth exploration for complex problem decomposition"
-        },
-        {
-            name: "Progressive-Hint Prompting (PHP)",
-            description: "Use previously generated outputs as contextual hints"
-        },
-        {
-            name: "Cognitive Scaffolding Prompting",
-            description: "Structure reasoning through metacognitive frameworks"
-        },
-        {
-            name: "Knowledge Synthesis Prompting (KSP)",
-            description: "Integrate knowledge from multiple internal domains"
-        },
-        {
-            name: "Reflexive Analysis",
-            description: "Embed ethical, legal, and cultural considerations"
-        },
-        {
-            name: "PAL (Program-Aided Language)",
-            description: "Generate executable code for computational tasks"
-        },
-        {
-            name: "Context-Compression",
-            description: "Apply when context exceeds budget using LLMLingua"
+class CognitiveDeliberationEngine {
+    // Stage 1: Scientific Investigation
+    performScientificInvestigation(input, context) {
+        return `## Scientific Investigation Framework
+
+**1. Identify Question:** ${this.extractCoreQuestion(input)}
+
+**2. Form Hypothesis:** ${this.formHypothesis(input, context)}
+
+**3. Experimental Design:** ${this.designApproach(input, context)}
+
+**4. Data Analysis Framework:** ${this.establishAnalysisFramework(input)}
+
+**5. Conclusion Preparation:** ${this.prepareConclusions(input)}`;
+    }
+    // Stage 2: Initial OOReD
+    performInitialOOReD(input, selectedStrategies, context) {
+        return `## Initial OOReD Process
+
+**Observe:** Input complexity analysis reveals ${this.analyzeComplexity(input)}. Context depth: ${context ? 'comprehensive' : 'minimal'}. Task characteristics: ${this.identifyTaskType(input)}.
+
+**Orient:** Solution pathway identification using ${selectedStrategies.join(', ')} strategies. Primary approach: ${this.identifyPrimaryApproach(input, selectedStrategies)}.
+
+**Reason:** Core reasoning foundation: ${this.establishReasoning(input, selectedStrategies, context)}.
+
+**Decide:** Action framework: ${this.decideActions(input, context)}`;
+    }
+    // Stage 3: Critical Thinking
+    performCriticalThinking(input, context) {
+        return `## Critical Thinking Framework
+
+1. **Purpose:** ${this.identifyPurpose(input)}
+2. **Precise Question:** ${this.refineQuestion(input)}
+3. **Operating Context:** ${this.establishContext(input, context)}
+4. **Information Needs:** ${this.identifyInformationNeeds(input)}
+5. **Credibility Assessment:** ${this.assessCredibility(input, context)}
+6. **Relevant Concepts:** ${this.identifyRelevantConcepts(input)}
+7. **Preliminary Conclusions:** ${this.drawPreliminaryConclusions(input)}
+8. **Assumptions Analysis:** ${this.analyzeAssumptions(input)}
+9. **Implications:** ${this.identifyImplications(input)}
+10. **Consequences:** ${this.assessConsequences(input)}
+
+**Pre-Action Tool Planning:** ${this.planToolUsage(input)}`;
+    }
+    // Stage 4: Scientific Review
+    performScientificReview(input, round1Results, context) {
+        return `## Scientific Review Process
+
+**Question Validation:** ${this.validateQuestion(input, round1Results)}
+
+**Hypothesis Refinement:** ${this.refineHypothesis(input, round1Results)}
+
+**Methodology Assessment:** ${this.assessMethodology(round1Results)}
+
+**Evidence Evaluation:** ${this.evaluateEvidence(input, context, round1Results)}
+
+**Conclusion Verification:** ${this.verifyConclusions(round1Results)}`;
+    }
+    // Stage 5: OOReD Review  
+    performOOReD_Review(input, round1Results, selectedStrategies, context) {
+        return `## OOReD Review Process
+
+**Enhanced Observation:** ${this.enhanceObservation(input, round1Results)}
+
+**Strategic Reorientation:** ${this.reorient(input, round1Results, selectedStrategies)}
+
+**Advanced Reasoning:** ${this.advancedReasoning(input, context, round1Results, selectedStrategies)}
+
+**Final Decision Framework:** ${this.finalDecisionFramework(input, round1Results)}`;
+    }
+    // Stage 6: Final Action
+    performFinalAction(input, allResults, selectedStrategies, context) {
+        const toolCount = this.calculateToolUsage(input, allResults);
+        return `## Final Action Synthesis
+
+**Comprehensive Solution:** ${this.synthesizeSolution(input, context, allResults, selectedStrategies)}
+
+**Implementation Pathway:** ${this.createImplementationPath(input, allResults)}
+
+**Verification Framework:** ${this.establishVerification(input, allResults)}
+
+**Success Metrics:** ${this.defineSuccessMetrics(input, allResults)}
+
+**Fact-Based Recommendations:** ${this.generateRecommendations(input, context, allResults, selectedStrategies)}
+
+**tool use before re-deliberation: ${toolCount}**`;
+    }
+    // Strategy evaluation system
+    evaluatePromptingStrategies(input, context) {
+        const scores = [];
+        for (const [strategyName, strategy] of Object.entries(PROMPTING_STRATEGIES)) {
+            const solutionLevel = this.calculateSolutionLevel(input, context, strategy);
+            const efficiencyLevel = this.calculateEfficiencyLevel(input, strategy);
+            const totalScore = solutionLevel + efficiencyLevel;
+            scores.push({
+                strategy: strategyName,
+                solutionLevel: parseFloat(solutionLevel.toFixed(2)),
+                efficiencyLevel: parseFloat(efficiencyLevel.toFixed(2)),
+                totalScore: parseFloat(totalScore.toFixed(2)),
+                reasoning: this.generateStrategyReasoning(input, strategy, solutionLevel, efficiencyLevel)
+            });
         }
-    ];
-    // DYNAMIC IN-PROMPT EVALUATION: Score each strategy based on actual input and context
-    const strategies = strategyTemplates.map(template => {
-        const solutionLevel = evaluateSolutionLevel(template.name, template.description, input, mode, context);
-        const efficiencyLevel = evaluateEfficiencyLevel(template.name, template.description, input, mode, context);
-        return {
-            name: template.name,
-            description: template.description,
-            solutionLevel: solutionLevel,
-            efficiencyLevel: efficiencyLevel,
-            totalScore: solutionLevel + efficiencyLevel
-        };
-    });
-    // Return strategies with scores ≥1.42
-    return strategies.filter(s => s.totalScore >= 1.42).sort((a, b) => b.totalScore - a.totalScore);
-}
-/**
- * DYNAMIC IN-PROMPT EVALUATION: Evaluates solution capability based on actual task requirements
- * Returns 0.00-0.99 based on how well the strategy solves the specific problem
- */
-function evaluateSolutionLevel(strategyName, description, input, mode, context) {
-    let score = 0.50; // Base score
-    // Analyze input complexity and requirements
-    const inputLength = input.length;
-    const hasCodeTerms = /code|implement|debug|program|function|class|method|variable/.test(input.toLowerCase());
-    const hasAnalysisTerms = /analyze|compare|evaluate|assess|review|examine/.test(input.toLowerCase());
-    const hasCreativeTerms = /create|design|generate|build|develop|invent/.test(input.toLowerCase());
-    const hasDecisionTerms = /decide|choose|select|determine|resolve|conclude/.test(input.toLowerCase());
-    const hasComplexLogic = /algorithm|logic|reasoning|thinking|strategy|approach/.test(input.toLowerCase());
-    const hasMultiStep = /step|phase|stage|process|workflow|procedure/.test(input.toLowerCase());
-    // Strategy-specific solution evaluation based on modern-prompting.mdc capabilities
-    if (strategyName.includes("Cache-Augmented Reasoning + ReAct")) {
-        score = 0.60; // Strong baseline for reasoning + action cycles
-        if (hasComplexLogic && hasMultiStep)
-            score += 0.20;
-        if (mode === "analyze" || mode === "decide")
-            score += 0.15;
-        if (context && context.length > 100)
-            score += 0.10; // Benefits from context
-    }
-    else if (strategyName.includes("Self-Consistency")) {
-        score = 0.55; // Good for validation
-        if (hasDecisionTerms)
-            score += 0.25; // Excels at decision validation
-        if (mode === "decide" || mode === "evaluate")
-            score += 0.18;
-        if (inputLength > 300)
-            score += 0.10; // Better with complex inputs
-    }
-    else if (strategyName.includes("Tree of Thoughts")) {
-        score = 0.65; // Strong for complex decomposition
-        if (hasComplexLogic && hasMultiStep)
-            score += 0.25;
-        if (mode === "analyze" || mode === "synthesize")
-            score += 0.20;
-        if (hasCreativeTerms)
-            score += 0.15; // Good for creative problem solving
-    }
-    else if (strategyName.includes("Progressive-Hint Prompting")) {
-        score = 0.52; // Moderate baseline
-        if (hasMultiStep)
-            score += 0.20;
-        if (context && context.length > 50)
-            score += 0.18; // Uses previous context well
-        if (mode === "synthesize")
-            score += 0.12;
-    }
-    else if (strategyName.includes("Cognitive Scaffolding")) {
-        score = 0.68; // High baseline for structured thinking
-        if (hasComplexLogic)
-            score += 0.22;
-        if (inputLength > 500)
-            score += 0.15; // Better with complex inputs
-        if (mode === "analyze" || mode === "evaluate")
-            score += 0.12;
-    }
-    else if (strategyName.includes("Knowledge Synthesis")) {
-        score = 0.58; // Good for integration
-        if (mode === "synthesize")
+        return scores.sort((a, b) => b.totalScore - a.totalScore);
+    }
+    calculateSolutionLevel(input, context, strategy) {
+        let score = 0.1; // Base score
+        // Complexity analysis
+        const complexity = this.analyzeInputComplexity(input);
+        if (complexity === 'high' && strategy.type === 'advanced')
+            score += 0.3;
+        if (complexity === 'medium' && strategy.type === 'primary')
             score += 0.25;
-        if (hasAnalysisTerms)
-            score += 0.18;
-        if (context && hasComplexLogic)
-            score += 0.15;
-    }
-    else if (strategyName.includes("Reflexive Analysis")) {
-        score = 0.45; // Lower baseline, specialized use
-        if (mode === "evaluate")
-            score += 0.30; // Excellent for evaluation
-        if (hasAnalysisTerms)
-            score += 0.20;
-        if (input.includes("ethic") || input.includes("legal") || input.includes("cultur"))
+        if (complexity === 'low')
+            score += 0.2;
+        // Task type matching
+        const taskType = this.identifyTaskType(input);
+        if (taskType === 'computational' && strategy.description.includes('code'))
             score += 0.25;
-    }
-    else if (strategyName.includes("PAL (Program-Aided Language)")) {
-        score = 0.40; // Specialized for computation
-        if (hasCodeTerms)
-            score += 0.35; // Excellent for coding tasks
-        if (input.includes("calculat") || input.includes("comput") || input.includes("math"))
-            score += 0.25;
-        if (mode === "decide" && hasCodeTerms)
+        if (taskType === 'analytical' && strategy.description.includes('reasoning'))
+            score += 0.2;
+        if (taskType === 'creative' && strategy.description.includes('synthesis'))
             score += 0.15;
-    }
-    else if (strategyName.includes("Context-Compression")) {
-        score = 0.35; // Specialized utility
-        if (inputLength > 1000)
-            score += 0.40; // Excels with large inputs
-        if (context && context.length > 500)
-            score += 0.25;
-        if (inputLength > 2000)
-            score += 0.20; // Even better with very large inputs
-    }
-    return Math.min(0.99, score);
-}
-/**
- * DYNAMIC IN-PROMPT EVALUATION: Evaluates efficiency based on computational and cognitive overhead
- * Returns 0.00-0.99 based on how efficiently the strategy processes the specific task
- */
-function evaluateEfficiencyLevel(strategyName, description, input, mode, context) {
-    let score = 0.60; // Base efficiency score
-    const inputLength = input.length;
-    const isSimpleTask = inputLength < 200 && !(/complex|difficult|challenging|intricate/.test(input.toLowerCase()));
-    const isUrgentMode = mode === "decide";
-    const hasTimeConstraints = /quick|fast|urgent|immediate|rapid/.test(input.toLowerCase());
-    // Strategy-specific efficiency evaluation
-    if (strategyName.includes("Cache-Augmented Reasoning + ReAct")) {
-        score = 0.65; // Good balance of power and efficiency
-        if (context)
-            score += 0.12; // More efficient with cached context
-        if (isSimpleTask)
-            score -= 0.08; // Overhead for simple tasks
-        if (hasTimeConstraints)
-            score += 0.08;
-    }
-    else if (strategyName.includes("Self-Consistency")) {
-        score = 0.45; // Lower efficiency due to parallel processing
-        if (isUrgentMode)
-            score -= 0.10; // Slower for urgent decisions
-        if (isSimpleTask)
-            score -= 0.15; // Overkill for simple tasks
-        if (inputLength > 500)
-            score += 0.20; // More worthwhile for complex inputs
-    }
-    else if (strategyName.includes("Tree of Thoughts")) {
-        score = 0.40; // Lower efficiency due to branching
-        if (isSimpleTask)
-            score -= 0.20; // Significant overhead for simple tasks
-        if (hasTimeConstraints)
-            score -= 0.15; // Slow for urgent needs
-        if (inputLength > 800)
-            score += 0.25; // Worth it for very complex problems
-    }
-    else if (strategyName.includes("Progressive-Hint Prompting")) {
-        score = 0.68; // Good efficiency with iterative approach
-        if (context)
-            score += 0.15; // Very efficient with context
-        if (isSimpleTask)
-            score += 0.10; // Good for simple progressive tasks
-        if (hasTimeConstraints)
-            score += 0.08;
-    }
-    else if (strategyName.includes("Cognitive Scaffolding")) {
-        score = 0.52; // Moderate efficiency with structured approach
-        if (inputLength > 600)
-            score += 0.18; // More efficient for complex structured problems
-        if (isSimpleTask)
-            score -= 0.12; // Overhead for simple tasks
-        if (mode === "analyze")
-            score += 0.10;
-    }
-    else if (strategyName.includes("Knowledge Synthesis")) {
-        score = 0.58; // Good efficiency for integration tasks
-        if (context && context.length > 100)
+        // Context utilization
+        if (context && strategy.description.includes('context'))
             score += 0.15;
-        if (mode === "synthesize")
-            score += 0.12;
-        if (isSimpleTask)
-            score -= 0.08;
-    }
-    else if (strategyName.includes("Reflexive Analysis")) {
-        score = 0.35; // Lower efficiency due to deep reflection
-        if (mode === "evaluate")
-            score += 0.25; // More efficient in evaluation mode
-        if (isSimpleTask)
-            score -= 0.15; // Overkill for simple tasks
-        if (hasTimeConstraints)
-            score -= 0.20; // Slow process
-    }
-    else if (strategyName.includes("PAL (Program-Aided Language)")) {
-        score = 0.75; // High efficiency for computational tasks
-        if (input.includes("code") || input.includes("calculat"))
+        return Math.min(score, 0.99);
+    }
+    calculateEfficiencyLevel(input, strategy) {
+        let score = 0.1; // Base score
+        // Processing efficiency
+        if (strategy.type === 'primary')
+            score += 0.3; // Primary strategies are more efficient
+        if (strategy.description.includes('concise'))
+            score += 0.2;
+        if (strategy.description.includes('minimal'))
             score += 0.15;
-        if (isSimpleTask && input.includes("comput"))
-            score += 0.10;
-        if (!input.match(/code|math|calculat|comput|program/))
-            score -= 0.30; // Inefficient for non-computational tasks
-    }
-    else if (strategyName.includes("Context-Compression")) {
-        score = 0.85; // Very high efficiency for compression
-        if (inputLength < 500)
-            score -= 0.25; // Unnecessary for short inputs
-        if (inputLength > 1500)
-            score += 0.10; // More valuable for very long inputs
-        if (hasTimeConstraints)
-            score += 0.05;
-    }
-    return Math.min(0.99, score);
-}
-/**
- * Generates tool usage recommendations for pair programming scenarios
- */
-function generateToolRecommendations(input, mode, deliberationResults) {
-    const recommendations = [];
-    let toolCount = 0;
-    // File manipulation tools
-    if (input.includes("file") || input.includes("code") || input.includes("implement")) {
-        recommendations.push("• **read_file** - Read relevant source files for context");
-        recommendations.push("• **replace_string_in_file** - Make targeted code changes");
-        recommendations.push("• **create_file** - Create new files as needed");
-        toolCount += 3;
-    }
-    // Web search tools
-    if (input.includes("research") || input.includes("latest") || input.includes("current") || mode === "evaluate") {
-        recommendations.push("• **vscode-websearchforcopilot_webSearch** - Search for current information");
-        recommendations.push("• **mcp_brave-search_brave_web_search** - Comprehensive web search");
-        toolCount += 2;
+        // Input length consideration
+        const inputLength = input.length;
+        if (inputLength < 200 && !strategy.description.includes('complex'))
+            score += 0.2;
+        if (inputLength > 1000 && strategy.description.includes('compression'))
+            score += 0.25;
+        // Scalability factors
+        if (strategy.description.includes('parallel'))
+            score += 0.1;
+        if (strategy.description.includes('iterative'))
+            score -= 0.05; // Slightly less efficient
+        return Math.min(score, 0.99);
+    }
+    generateStrategyReasoning(input, strategy, solutionLevel, efficiencyLevel) {
+        const taskType = this.identifyTaskType(input);
+        const complexity = this.analyzeInputComplexity(input);
+        return `${taskType} task with ${complexity} complexity. Strategy alignment: ${solutionLevel > 0.6 ? 'high' : solutionLevel > 0.4 ? 'medium' : 'low'}. Efficiency rating: ${efficiencyLevel > 0.6 ? 'optimal' : efficiencyLevel > 0.4 ? 'adequate' : 'limited'}.`;
+    }
+    // Core cognitive processing method
+    async performCognitiveDeliberation(input, context) {
+        // Strategy evaluation
+        const strategyScores = this.evaluatePromptingStrategies(input, context);
+        const selectedStrategies = strategyScores
+            .filter(s => s.totalScore >= 1.42)
+            .slice(0, strategyScores.filter(s => s.totalScore >= 1.53).length > 1 ? 3 : 1)
+            .map(s => s.strategy);
+        if (selectedStrategies.length === 0) {
+            selectedStrategies.push(strategyScores[0].strategy); // Fallback to highest scoring
+        }
+        // Round 1: Stages 1-2
+        const stage1 = this.performScientificInvestigation(input, context);
+        const stage2 = this.performInitialOOReD(input, selectedStrategies, context);
+        const round1Results = `${stage1}\n\n${stage2}`;
+        // Round 2: Stages 3-6  
+        const stage3 = this.performCriticalThinking(input, context);
+        const stage4 = this.performScientificReview(input, round1Results, context);
+        const stage5 = this.performOOReD_Review(input, round1Results, selectedStrategies, context);
+        const stage6 = this.performFinalAction(input, `${round1Results}\n\n${stage3}\n\n${stage4}\n\n${stage5}`, selectedStrategies, context);
+        // Final compilation
+        return `# Cognitive Deliberation Results
+
+## Round 1: Foundation
+${round1Results}
+
+## Round 2: Advanced Processing
+${stage3}
+
+${stage4}
+
+${stage5}
+
+${stage6}
+
+## Strategy Evaluation Summary
+**Selected Strategies:** ${selectedStrategies.join(', ')}
+**Evaluation Results:** ${strategyScores.slice(0, 3).map(s => `${s.strategy}: ${s.totalScore}`).join(', ')}`;
+    }
+    // Helper methods for cognitive processing
+    extractCoreQuestion(input) {
+        // Extract the fundamental question or problem from input
+        const questionMarkers = ['?', 'how', 'what', 'why', 'when', 'where', 'which'];
+        const hasQuestion = questionMarkers.some(marker => input.toLowerCase().includes(marker));
+        if (hasQuestion) {
+            return `Direct question identified in input requiring systematic investigation.`;
+        }
+        else {
+            return `Implicit problem requiring question formulation: What is the optimal approach to address the stated requirements?`;
+        }
     }
-    // Code analysis tools
-    if (input.includes("debug") || input.includes("error") || input.includes("analyze")) {
-        recommendations.push("• **get_errors** - Check for compilation/lint errors");
-        recommendations.push("• **semantic_search** - Find relevant code patterns");
-        recommendations.push("• **list_code_usages** - Analyze function/class usage");
-        toolCount += 3;
+    formHypothesis(input, context) {
+        const taskType = this.identifyTaskType(input);
+        return `Based on ${taskType} task characteristics${context ? ' and provided context' : ''}, hypothesis: The solution requires systematic application of appropriate cognitive frameworks to achieve optimal results.`;
+    }
+    designApproach(input, context) {
+        return `Multi-stage cognitive processing with strategy selection, iterative refinement, and verification protocols.`;
+    }
+    establishAnalysisFramework(input) {
+        return `Qualitative analysis of reasoning coherence, quantitative assessment of solution completeness, validation against success criteria.`;
+    }
+    prepareConclusions(input) {
+        return `Synthesis framework ready for evidence-based conclusions with confidence calibration and uncertainty quantification.`;
+    }
+    analyzeComplexity(input) {
+        if (input.length > 1000)
+            return 'high cognitive load with multi-faceted requirements';
+        if (input.length > 500)
+            return 'moderate complexity requiring structured approach';
+        return 'manageable complexity with clear pathway identification';
+    }
+    identifyTaskType(input) {
+        const codePatterns = ['code', 'function', 'class', 'method', 'algorithm', 'programming'];
+        const analyticalPatterns = ['analyze', 'evaluate', 'compare', 'assess', 'examine'];
+        const creativePatterns = ['design', 'create', 'generate', 'build', 'develop'];
+        const decisionPatterns = ['choose', 'decide', 'select', 'recommend', 'determine'];
+        const lowerInput = input.toLowerCase();
+        if (codePatterns.some(p => lowerInput.includes(p)))
+            return 'computational';
+        if (analyticalPatterns.some(p => lowerInput.includes(p)))
+            return 'analytical';
+        if (creativePatterns.some(p => lowerInput.includes(p)))
+            return 'creative';
+        if (decisionPatterns.some(p => lowerInput.includes(p)))
+            return 'decision-making';
+        return 'general-purpose';
+    }
+    identifyPrimaryApproach(input, strategies) {
+        return `${strategies[0]} as primary framework with ${strategies.length > 1 ? 'secondary strategies integrated' : 'focused application'}`;
+    }
+    establishReasoning(input, strategies, context) {
+        return `Multi-strategy reasoning utilizing ${strategies.join(' and ')} approaches for comprehensive solution development${context ? ' with contextual grounding' : ''}.`;
+    }
+    decideActions(input, context) {
+        const toolTypes = ['websearch', 'file manipulation', 'code analysis', 'context synthesis'];
+        return `Action sequence prioritizing ${toolTypes.slice(0, 2).join(' and ')} based on input requirements.`;
+    }
+    identifyPurpose(input) {
+        return `Primary purpose: Address the core requirements while optimizing for solution quality and implementation feasibility.`;
+    }
+    refineQuestion(input) {
+        return `Refined question: How can the stated objectives be achieved most effectively using available cognitive and technical resources?`;
+    }
+    establishContext(input, context) {
+        return `Operating within ${context ? 'provided contextual framework' : 'general problem-solving context'} with emphasis on practical implementation.`;
+    }
+    identifyInformationNeeds(input) {
+        const needsAnalysis = input.length > 500 ? 'comprehensive domain knowledge' : 'targeted information';
+        return `Information requirements: ${needsAnalysis}, validation sources, and implementation guidelines.`;
+    }
+    assessCredibility(input, context) {
+        return `Credibility assessment: Input source${context ? ' and context' : ''} evaluated for reliability and completeness. Verification protocols established.`;
+    }
+    identifyRelevantConcepts(input) {
+        return `Key concepts: Domain-specific knowledge, methodological frameworks, implementation patterns, and optimization strategies.`;
+    }
+    drawPreliminaryConclusions(input) {
+        return `Preliminary assessment indicates systematic approach required with iterative refinement and validation checkpoints.`;
+    }
+    analyzeAssumptions(input) {
+        return `Key assumptions: Solution feasibility, resource availability, and standard implementation patterns apply.`;
+    }
+    identifyImplications(input) {
+        return `Solution implications: Systematic implementation required with quality assurance and performance optimization considerations.`;
+    }
+    assessConsequences(input) {
+        return `Implementation consequences: Positive outcomes expected with proper execution, minimal risks with appropriate safeguards.`;
+    }
+    planToolUsage(input) {
+        const toolCount = this.calculateToolUsage(input, '');
+        return `Tool usage plan: ${toolCount} tools anticipated for comprehensive solution development including websearch, file operations, and analysis tools.`;
+    }
+    calculateToolUsage(input, results) {
+        // Calculate recommended tool usage based on complexity and requirements
+        let toolCount = 1; // Minimum
+        const complexity = this.analyzeInputComplexity(input);
+        if (complexity === 'high')
+            toolCount += 3;
+        else if (complexity === 'medium')
+            toolCount += 2;
+        else
+            toolCount += 1;
+        const taskType = this.identifyTaskType(input);
+        if (taskType === 'computational')
+            toolCount += 2;
+        if (taskType === 'analytical')
+            toolCount += 1;
+        if (input.length > 1000)
+            toolCount += 1;
+        if (results.length > 2000)
+            toolCount += 1;
+        return Math.min(toolCount, 7); // Cap at 7 tools
+    }
+    analyzeInputComplexity(input) {
+        if (input.length > 1000)
+            return 'high';
+        if (input.length > 500)
+            return 'medium';
+        return 'low';
+    }
+    // Stage 4-6 helper methods
+    validateQuestion(input, round1Results) {
+        return `Question validation confirms alignment between initial problem identification and cognitive processing results.`;
+    }
+    refineHypothesis(input, round1Results) {
+        return `Hypothesis refinement based on initial processing confirms systematic approach validity with enhanced precision.`;
+    }
+    assessMethodology(round1Results) {
+        return `Methodology assessment indicates appropriate framework selection and implementation pathway optimization.`;
+    }
+    evaluateEvidence(input, context, round1Results) {
+        return `Evidence evaluation confirms reasoning coherence and solution pathway validity${context ? ' with contextual validation' : ''}.`;
+    }
+    verifyConclusions(round1Results) {
+        return `Conclusion verification establishes logical consistency and implementation feasibility across all processing stages.`;
+    }
+    enhanceObservation(input, round1Results) {
+        return `Enhanced observation integrating initial findings with critical thinking framework results for comprehensive understanding.`;
     }
-    // Documentation tools
-    if (input.includes("documentation") || input.includes("library") || input.includes("api")) {
-        recommendations.push("• **mcp_context7_get-library-docs** - Get up-to-date library documentation");
-        toolCount += 1;
+    reorient(input, round1Results, strategies) {
+        return `Strategic reorientation utilizing ${strategies.join(' and ')} approaches for optimized solution development.`;
     }
-    // Terminal execution
-    if (input.includes("run") || input.includes("execute") || input.includes("install")) {
-        recommendations.push("• **run_in_terminal** - Execute commands and scripts");
-        toolCount += 1;
+    advancedReasoning(input, context, round1Results, strategies) {
+        return `Advanced reasoning synthesis combining ${strategies.length} selected strategies with comprehensive validation protocols.`;
     }
-    // Default minimum recommendations for pair programming
-    if (toolCount === 0) {
-        recommendations.push("• **semantic_search** - Explore codebase for relevant patterns");
-        recommendations.push("• **read_file** - Review key implementation files");
-        recommendations.push("• **vscode-websearchforcopilot_webSearch** - Research best practices");
-        toolCount = 3;
+    finalDecisionFramework(input, round1Results) {
+        return `Final decision framework established with clear implementation priorities and success verification methods.`;
     }
-    return { toolCount: Math.min(8, toolCount), recommendations };
-}
-/**
- * Formats prompting strategy evaluation results for output
- * Shows dynamically evaluated strategies with real-time scoring
- */
-function formatPromptingStrategyResults(strategies) {
-    if (strategies.length === 0) {
-        return "**No strategies met the threshold of ≥1.42 through dynamic evaluation**";
+    synthesizeSolution(input, context, allResults, strategies) {
+        return `Comprehensive solution synthesis utilizing ${strategies.join(', ')} strategies for optimal implementation approach${context ? ' within provided contextual framework' : ''}.`;
     }
-    let result = `**SELECTED PROMPTING STRATEGIES (Score ≥1.42 - Dynamically Evaluated):**\n`;
-    strategies.forEach((strategy, index) => {
-        result += `${index + 1}. **${strategy.name}** (Total: ${strategy.totalScore.toFixed(2)})\n`;
-        result += `   - Solution Level: ${strategy.solutionLevel.toFixed(2)} (evaluated in-prompt for task fit)\n`;
-        result += `   - Efficiency Level: ${strategy.efficiencyLevel.toFixed(2)} (evaluated in-prompt for computational overhead)\n`;
-        result += `   - Description: ${strategy.description}\n\n`;
-    });
-    result += `*All scores dynamically calculated based on actual input context, task mode, and complexity requirements*\n`;
-    return result;
-}
-/**
- * Applies selected prompting strategies to enhance stage processing
- */
-function applySelectedStrategies(strategies, input, mode, stage) {
-    if (strategies.length === 0)
-        return "";
-    return `**Applied Strategies:** ${strategies.map(s => `${s.name} (${s.totalScore.toFixed(2)})`).join(', ')}\n`;
-}
-/**
- * Formats strategy application for display
- */
-function formatStrategyApplication(strategies) {
-    return strategies.map(s => `${s.name} (${s.totalScore.toFixed(2)})`).join(', ');
-}
-/**
- * Applies scientific scaffolding for enhanced investigation
- */
-function applyScientificScaffolding(input, mode) {
-    return `**Metacognitive Framework Applied:**
-- Problem decomposition using hierarchical analysis
-- Evidence evaluation through structured criteria
-- Hypothesis strength assessment using confidence scoring
-- Systematic validation through cross-referencing methodology`;
-}
-/**
- * Validates scientific consistency using self-consistency approach
- */
-function validateScientificConsistency(questionIdentification, hypothesisFormation) {
-    return `**Consistency Analysis:**
-- Question-hypothesis alignment: HIGH (systematic correspondence achieved)
-- Internal logic coherence: VALIDATED (no contradictory elements detected)
-- Methodological consistency: CONFIRMED (approach aligns with scientific principles)
-- Evidence-conclusion linkage: STRONG (clear causal relationships established)`;
-}
-// --- Cognitive Deliberation Engine ---
-/**
- * Automatically determines the optimal processing mode based on input analysis
- */
-function determineOptimalMode(input, context) {
-    const inputLower = input.toLowerCase();
-    // Decision indicators
-    if (/\b(decide|choose|select|determine|should|which|option|alternative)\b/.test(inputLower)) {
-        return "decide";
+    createImplementationPath(input, allResults) {
+        return `Implementation pathway: systematic execution with iterative validation, quality assurance checkpoints, and optimization opportunities.`;
     }
-    // Synthesis indicators
-    if (/\b(combine|integrate|synthesize|merge|unify|connect|relate|together)\b/.test(inputLower)) {
-        return "synthesize";
+    establishVerification(input, allResults) {
+        return `Verification framework: solution completeness validation, performance assessment, and success criteria confirmation.`;
     }
-    // Evaluation indicators  
-    if (/\b(evaluate|assess|judge|rate|compare|review|quality|effectiveness)\b/.test(inputLower)) {
-        return "evaluate";
+    defineSuccessMetrics(input, allResults) {
+        return `Success metrics: solution quality, implementation efficiency, requirement satisfaction, and stakeholder value delivery.`;
     }
-    // Default to analyze for investigation, problem-solving, understanding
-    return "analyze";
-}
-/**
- * Performs complete two-round cognitive deliberation in a single tool call
- * Round 1: Stages 1-2 (Scientific Investigation + Initial OOReD)
- * Round 2: Stages 3-6 (Critical Thinking + Reviews + Final Action)
- * All happens internally without requiring multiple tool calls or session management
- */
-async function performCognitiveDeliberation(input, context) {
-    // Auto-determine best mode based on input analysis
-    const mode = determineOptimalMode(input, context);
-    // ROUND 1: Stages 1-2 (Internal processing)
-    // STAGE 1: SCIENTIFIC INVESTIGATION with prompting strategy evaluation
-    const selectedStrategies = evaluatePromptingStrategies(input, mode, context);
-    const stage1 = await performScientificInvestigation(input, mode, context, selectedStrategies);
-    // STAGE 2: INITIAL OOReD
-    const stage2 = await performInitialOOReD(input, mode, context, stage1, selectedStrategies);
-    // ROUND 2: Stages 3-6 (Internal processing continues)
-    const firstRoundResults = `${stage1}\n${stage2}`;
-    // STAGE 3: CRITICAL THINKING + PRE-ACT
-    const stage3 = await performCriticalThinkingPreAct(input, mode, context, firstRoundResults, selectedStrategies);
-    // STAGE 4: SCIENTIFIC REVIEW
-    const stage4 = await performScientificReview(input, mode, context, firstRoundResults, stage3, selectedStrategies);
-    // STAGE 5: OOReD REVIEW  
-    const stage5 = await performOOReViewReview(input, mode, context, firstRoundResults, stage4, selectedStrategies);
-    // STAGE 6: FINAL ACT
-    const stage6 = await performFinalAct(input, mode, context, stage3, stage5, selectedStrategies);
-    // Generate final tool recommendations
-    const finalToolRecs = generateToolRecommendations(input, mode, `${stage3}\n${stage5}\n${stage6}`);
-    // Return concise result without formatting constraints
-    return `${firstRoundResults}\n${stage3}\n${stage4}\n${stage5}\n${stage6}\n\ntool use before re-deliberation: ${finalToolRecs.toolCount}`;
-}
-// --- 6-Stage Cognitive Processing Functions with Integrated Prompting Strategies ---
-/**
- * STAGE 1: SCIENTIFIC INVESTIGATION
- * Implements selected prompting strategies for systematic hypothesis formation and experimental design
- */
-async function performScientificInvestigation(input, mode, context, strategies) {
-    // Apply selected prompting strategies for scientific investigation
-    const useCoT = strategies?.some(s => s.name.includes("Chain-of-Thought") || s.name.includes("Cache-Augmented"));
-    const useScaffolding = strategies?.some(s => s.name.includes("Scaffolding"));
-    const useSelfConsistency = strategies?.some(s => s.name.includes("Self-Consistency"));
-    // Chain-of-Thought: Step-by-step scientific method application
-    const questionIdentification = identifyScientificQuestion(input, mode, useCoT);
-    const hypothesisFormation = formHypothesis(input, mode, context, useCoT);
-    const experimentDesign = designCognitiveExperiment(input, mode, useScaffolding);
-    // Apply cognitive scaffolding if selected
-    const scaffoldingResults = useScaffolding ? applyScientificScaffolding(input, mode) : "";
-    // Apply self-consistency validation if selected
-    const consistencyCheck = useSelfConsistency ? validateScientificConsistency(questionIdentification, hypothesisFormation) : "";
-    // Return concise scientific investigation results 
-    return `${questionIdentification} ${hypothesisFormation} ${experimentDesign} ${designDataAnalysisFramework(input, mode)} ${setupConclusionFramework(mode)}${scaffoldingResults ? ` ${scaffoldingResults}` : ''}${consistencyCheck ? ` ${consistencyCheck}` : ''}`;
-}
-/**
- * STAGE 2: INITIAL OBSERVE-ORIENT-REASON-DECIDE
- * Implements selected prompting strategies for multiple reasoning path exploration
- */
-async function performInitialOOReD(input, mode, context, stage1Result, strategies) {
-    // Tree-of-Thoughts: Multiple parallel reasoning paths
-    const observationPaths = generateMultipleObservationPaths(input, mode, context);
-    const orientationAlternatives = generateOrientationAlternatives(input, mode, stage1Result);
-    const reasoningBranches = generateReasoningBranches(input, mode, context);
-    // Meta-Prompting: Self-reflection on reasoning quality
-    const qualityAssessment = assessReasoningQuality(reasoningBranches);
-    // Return concise OOReD analysis
-    return `${observationPaths} ${orientationAlternatives} ${reasoningBranches} ${selectOptimalReasoningPath(reasoningBranches, qualityAssessment)}`;
-}
-/**
- * STAGE 3: CRITICAL THINKING + PRE-ACTION PLANNING
- * Implements selected prompting strategies for 10-step critical thinking with validation
- */
-async function performCriticalThinkingPreAct(input, mode, context, firstRoundResult, strategies) {
-    // Self-Consistency: Multiple critical thinking approaches
-    const criticalThinkingPaths = await generateCriticalThinkingPaths(input, mode, firstRoundResult);
-    const consensusAnalysis = findConsensusAcrossPaths(criticalThinkingPaths);
-    // Meta-Prompting: Pre-action planning with tool identification
-    const toolPlanning = await planRequiredTools(input, mode, consensusAnalysis);
-    // Apply selected prompting strategies
-    const strategyResults = strategies ? applySelectedStrategies(strategies, input, mode, "critical-thinking") : "";
-    // Return concise critical thinking analysis
-    return `${formatCriticalThinkingPaths(criticalThinkingPaths)} ${consensusAnalysis} ${toolPlanning}${strategyResults ? ` ${strategyResults}` : ''}`;
-}
-/**
- * STAGE 4: SCIENTIFIC REVIEW & VALIDATION
- * Implements selected prompting strategies for enhanced validation
- */
-async function performScientificReview(input, mode, context, firstRoundResult, stage3Result, strategies) {
-    // Chain-of-Thought: Systematic review of scientific method application
-    const reviewSteps = performSystematicReview(firstRoundResult, stage3Result);
-    // Self-Consistency: Multiple validation approaches
-    const validationPaths = generateValidationPaths(firstRoundResult, mode);
-    const consistencyCheck = assessCrossStageConsistency(firstRoundResult, stage3Result);
-    // Apply selected prompting strategies
-    const strategyResults = strategies ? applySelectedStrategies(strategies, input, mode, "scientific-review") : "";
-    // Return concise scientific review
-    return `${reviewSteps} ${validationPaths} ${consistencyCheck}${strategyResults ? ` ${strategyResults}` : ''}`;
-}
-/**
- * STAGE 5: OOReD REVIEW & REFINEMENT
- * Implements selected prompting strategies for multi-path refinement with expert perspectives
- */
-async function performOOReViewReview(input, mode, context, firstRoundResult, stage4Result, strategies) {
-    // Tree-of-Thoughts: Multiple refinement paths
-    const refinementPaths = generateRefinementPaths(firstRoundResult, stage4Result, mode);
-    // Role-Based Prompting: Expert domain perspectives
-    const expertPerspectives = generateExpertPerspectives(input, mode, firstRoundResult, stage4Result);
-    // Apply selected prompting strategies
-    const strategyResults = strategies ? applySelectedStrategies(strategies, input, mode, "oored-review") : "";
-    // Return concise OOReD review and refinement
-    return `${refinementPaths} ${expertPerspectives} ${integrateStageFindings(firstRoundResult, stage4Result)} ${generateRefinementRecommendations(refinementPaths, expertPerspectives)}${strategyResults ? ` ${strategyResults}` : ''}`;
-}
-/**
- * STAGE 6: FACT-BASED ACTION & FINAL RECOMMENDATIONS
- * Integrates all selected prompting strategies for comprehensive output
- * Synthesizes all stages into actionable recommendations
- */
-async function performFinalAct(input, mode, context, stage3Result, stage5Result, strategies) {
-    // Integrate all prompting strategies for final synthesis
-    const finalSynthesis = synthesizeAllStages(input, mode, stage3Result, stage5Result);
-    const actionPlan = generateFinalActionPlan(finalSynthesis, mode);
-    const qualityMetrics = calculateQualityMetrics(finalSynthesis);
-    // Apply selected prompting strategies
-    const strategyResults = strategies ? applySelectedStrategies(strategies, input, mode, "final-action") : "";
-    // Return concise final action and recommendations
-    return `${finalSynthesis} ${actionPlan} ${qualityMetrics} ${generateImplementationRoadmap(actionPlan, mode)} ${defineSuccessCriteria(finalSynthesis, mode)} ${generateRiskMitigationPlan(finalSynthesis, actionPlan)}${strategyResults ? ` ${strategyResults}` : ''}`;
-}
-// --- Enhanced Cognitive Helper Functions with Integrated Prompting Strategies ---
-// STAGE 1 HELPERS: Scientific Investigation Functions
-function identifyScientificQuestion(input, mode, useCoT) {
-    const questionTypes = {
-        analyze: "What are the fundamental components and relationships in this problem?",
-        decide: "What decision criteria and alternatives should be systematically evaluated?",
-        synthesize: "How can disparate information sources be integrated into unified understanding?",
-        evaluate: "What assessment criteria and benchmarks should be applied for comprehensive evaluation?"
-    };
-    const enhancedAnalysis = useCoT ? " (Enhanced with step-by-step reasoning chain)" : "";
-    return `**Core Question:** ${questionTypes[mode]}${enhancedAnalysis}
-**Context-Specific:** ${input.substring(0, 150)}${input.length > 150 ? '...' : ''}
-**Investigative Focus:** ${determineInvestigativeFocus(input, mode)}
-${useCoT ? '**Chain-of-Thought Enhancement:** Systematic questioning approach with explicit reasoning steps' : ''}`;
-}
-function formHypothesis(input, mode, context, useCoT) {
-    const hypotheses = generateContextualHypotheses(input, mode);
-    const cotEnhancement = useCoT ? "\n**Chain-of-Thought Reasoning:** Each hypothesis derived through systematic logical progression" : "";
-    return `**Primary Hypothesis:** ${hypotheses.primary}
-**Alternative Hypotheses:** 
-${hypotheses.alternatives.map((h, i) => `${i + 1}. ${h}`).join('\n')}
-**Testable Predictions:** ${hypotheses.predictions.join(', ')}
-${context ? `**Context Integration:** ${context.substring(0, 100)}${context.length > 100 ? '...' : ''}` : ''}${cotEnhancement}`;
-}
-function designCognitiveExperiment(input, mode, useScaffolding) {
-    const scaffoldingEnhancement = useScaffolding ?
-        "\n**Cognitive Scaffolding Applied:** Structured methodology with progressive complexity building" : "";
-    return `**Experimental Approach:** ${selectExperimentalMethod(mode)}
-**Data Collection Strategy:** ${defineDataCollection(input, mode)}
-**Variables Identification:** 
-- Independent: ${identifyIndependentVariables(input)}
-- Dependent: ${identifyDependentVariables(input, mode)}
-- Controlled: ${identifyControlledVariables(input)}
-**Validation Method:** ${defineValidationMethod(mode)}${scaffoldingEnhancement}`;
-}
-function designDataAnalysisFramework(input, mode) {
-    return `**Analysis Method:** ${selectAnalysisMethod(mode)}
-**Statistical Approach:** ${defineStatisticalApproach(input, mode)}
-**Pattern Recognition:** ${definePatternRecognition(mode)}
-**Quality Metrics:** ${defineQualityMetrics(mode)}`;
-}
-function setupConclusionFramework(mode) {
-    return `**Evidence Evaluation:** Systematic assessment of findings against hypotheses
-**Confidence Intervals:** Statistical significance and reliability measures
-**Generalizability:** Scope and limitations of conclusions
-**Future Research:** Identified areas for further investigation
-**Mode-Specific Output:** ${defineModeSpecificOutput(mode)}`;
-}
-// STAGE 2 HELPERS: Initial OOReD Functions
-function generateMultipleObservationPaths(input, mode, context) {
-    const paths = [
-        `**Path 1 (Technical):** ${generateTechnicalObservation(input, mode)}`,
-        `**Path 2 (Strategic):** ${generateStrategicObservation(input, mode)}`,
-        `**Path 3 (User-Centered):** ${generateUserCenteredObservation(input, mode)}`,
-        context ? `**Path 4 (Contextual):** ${generateContextualObservation(input, context, mode)}` : ''
-    ].filter(p => p);
-    return paths.join('\n');
-}
-function generateOrientationAlternatives(input, mode, stage1Result) {
-    const alternatives = generateSolutionAlternatives(input, mode, stage1Result);
-    return alternatives.map((alt, i) => `**Alternative ${i + 1}:** ${alt.description} (Feasibility: ${alt.feasibility})`).join('\n');
-}
-function generateReasoningBranches(input, mode, context) {
-    return `**Branch A (Deductive):** ${performDeductiveReasoning(input, mode)}
-**Branch B (Inductive):** ${performInductiveReasoning(input, mode)}
-**Branch C (Abductive):** ${performAbductiveReasoning(input, mode)}
-${context ? `**Branch D (Contextual):** ${performContextualReasoning(input, context, mode)}` : ''}`;
-}
-function assessReasoningQuality(reasoningBranches) {
-    return {
-        score: 8.5,
-        confidence: "High - consistent across multiple reasoning approaches",
-        improvements: "Consider additional edge cases and constraint analysis",
-        alternatives: "Explored deductive, inductive, and abductive reasoning paths"
-    };
-}
-function selectOptimalReasoningPath(reasoningBranches, qualityAssessment) {
-    return `**Selected Path:** Integrated approach combining strongest elements from each branch
-**Rationale:** ${qualityAssessment.confidence}
-**Confidence Score:** ${qualityAssessment.score}/10
-**Implementation Strategy:** Hybrid methodology leveraging multiple reasoning approaches`;
-}
-// STAGE 3 HELPERS: Critical Thinking Functions
-async function generateCriticalThinkingPaths(input, mode, firstRoundResult) {
-    const paths = [];
-    const criticalQuestions = [
-        "What is the purpose of my thinking?",
-        "What precise question am I trying to answer?",
-        "Within what context or framework am I operating?",
-        "What information do I have and need to gather?",
-        "How reliable and credible is this information?",
-        "What concepts, algorithms, and facts are relevant?",
-        "What conclusions can I draw from this information?",
-        "What am I taking for granted; what assumptions am I making?",
-        "If I accept conclusions, what are the implications?",
-        "What would be the consequences if I put this solution into action?"
-    ];
-    for (const question of criticalQuestions) {
-        paths.push(await applyCriticalQuestion(input, mode, question, firstRoundResult));
+    generateRecommendations(input, context, allResults, strategies) {
+        const taskType = this.identifyTaskType(input);
+        return `Fact-based recommendations: Proceed with ${taskType} implementation using ${strategies[0]} as primary approach. Execute systematic validation. Monitor performance indicators. Iterate based on feedback.`;
     }
-    return paths;
-}
-function findConsensusAcrossPaths(paths) {
-    return `**Common Elements Across Paths:**
-- Systematic approach emphasis (9/10 paths)
-- Evidence-based reasoning priority (8/10 paths)  
-- Risk assessment integration (7/10 paths)
-- Stakeholder consideration (6/10 paths)
-**Divergent Elements:** Methodological preferences and validation approaches
-**Consensus Strength:** 78% alignment across critical thinking dimensions`;
-}
-async function planRequiredTools(input, mode, consensus) {
-    return `**Tool Categories Identified:**
-- **Information Gathering:** Web search, documentation access
-- **Analysis Tools:** Statistical analysis, pattern recognition
-- **Validation Tools:** Cross-reference checking, expert consultation
-- **Implementation Tools:** Project management, progress tracking
-**Priority Ranking:** Based on ${mode} mode requirements and consensus analysis
-**Resource Requirements:** Time, expertise, and technological capabilities assessed`;
-}
-function formatCriticalThinkingPaths(paths) {
-    return paths.map((path, i) => `**Step ${i + 1}:** ${path.split(' - Applied to')[0]} - Completed`).join('\n');
-}
-// Additional helper functions for remaining stages...
-function evaluateThinkingProcess(paths) {
-    return "Systematic and comprehensive - all critical thinking steps addressed";
-}
-function validateAssumptions(paths) {
-    return "Key assumptions identified and validated against evidence";
-}
-function detectCognitiveBiases(paths) {
-    return "Confirmation bias and availability heuristic potential detected and mitigated";
-}
-function assessCompletenessOfAnalysis(paths) {
-    return "Comprehensive coverage of 10-step critical thinking framework achieved";
-}
-// STAGE 4 HELPERS: Scientific Review Functions
-function performSystematicReview(stage1, stage3) {
-    return `**Review Methodology:** Systematic comparison of initial investigation against critical thinking analysis
-**Consistency Check:** ${checkConsistency(stage1, stage3)}
-**Gap Analysis:** ${identifyGaps(stage1, stage3)}
-**Strength Assessment:** ${assessStrengths(stage1, stage3)}
-**Validation Status:** ${determineValidationStatus(stage1, stage3)}`;
-}
-function generateValidationPaths(stage1, mode) {
-    return `**Path 1 (Peer Review):** Independent verification of methodology and conclusions
-**Path 2 (Data Validation):** Cross-checking of evidence and sources
-**Path 3 (Logic Testing):** Systematic evaluation of reasoning chains
-**Path 4 (Practical Testing):** Real-world applicability assessment
-**Consensus Score:** 85% validation across all paths`;
-}
-function assessCrossStageConsistency(stage1, stage3) {
-    return `**Consistency Score:** 92% alignment between stages
-**Key Alignments:** Hypothesis, methodology, and conclusions
-**Minor Discrepancies:** Emphasis and prioritization differences
-**Resolution Strategy:** Integration of complementary insights`;
-}
-// STAGE 5 HELPERS: OOReD Review Functions  
-function generateRefinementPaths(stage2, stage4, mode) {
-    return `**Refinement Path 1:** Enhanced observation incorporating validation insights
-**Refinement Path 2:** Strengthened orientation based on scientific review
-**Refinement Path 3:** Improved reasoning using consistency findings
-**Refinement Path 4:** Optimized decision-making with integrated analysis
-**Selected Improvements:** ${selectBestRefinements(stage2, stage4, mode)}`;
-}
-function generateExpertPerspectives(input, mode, stage2, stage4) {
-    const experts = getRelevantExperts(mode);
-    return experts.map(expert => `**${expert.role}:** ${expert.analysis}`).join('\n');
-}
-function integrateStageFindings(stage2, stage4) {
-    return `**Integration Analysis:** Systematic combination of OOReD and scientific validation
-**Synergies Identified:** ${identifySynergies(stage2, stage4)}
-**Conflicts Resolved:** ${resolveConflicts(stage2, stage4)}
-**Enhanced Understanding:** ${generateEnhancedUnderstanding(stage2, stage4)}`;
-}
-function generateRefinementRecommendations(refinements, perspectives) {
-    return `**Priority Refinements:** 
-1. Strengthen evidence base with additional validation
-2. Enhance reasoning with expert domain knowledge
-3. Improve decision criteria with stakeholder input
-4. Optimize implementation with practical considerations
-**Implementation Timeline:** Phased approach over 3-4 iterations`;
-}
-// STAGE 6 HELPERS: Final Action Functions
-function synthesizeAllStages(input, mode, stage3, stage5) {
-    return `**Comprehensive Synthesis:** Integration of all cognitive stages and prompting strategies
-**Key Insights:** ${extractKeyInsights(stage3, stage5)}
-**Validated Conclusions:** ${extractValidatedConclusions(stage3, stage5)}
-**Actionable Recommendations:** ${extractActionableRecommendations(stage3, stage5, mode)}
-**Confidence Assessment:** High confidence based on multi-stage validation`;
 }
-function generateFinalActionPlan(synthesis, mode) {
-    return `**Immediate Actions:** ${defineImmediateActions(synthesis, mode)}
-**Short-term Goals:** ${defineShortTermGoals(synthesis, mode)}
-**Long-term Objectives:** ${defineLongTermObjectives(synthesis, mode)}
-**Resource Allocation:** ${defineResourceAllocation(synthesis)}
-**Timeline:** ${defineTimeline(synthesis)}`;
-}
-function calculateQualityMetrics(synthesis) {
-    return `**Comprehensiveness:** 94% (all major aspects covered)
-**Consistency:** 91% (high alignment across stages)
-**Reliability:** 88% (strong validation and verification)
-**Applicability:** 89% (practical implementation feasibility)
-**Innovation:** 85% (novel insights and approaches identified)`;
-}
-function generateImplementationRoadmap(actionPlan, mode) {
-    return `**Phase 1:** Foundation establishment and resource preparation
-**Phase 2:** Core implementation with monitoring and feedback
-**Phase 3:** Optimization and scaling based on results
-**Phase 4:** Evaluation and continuous improvement
-**Mode-Specific Considerations:** ${getModeSpecificConsiderations(mode)}`;
-}
-function defineSuccessCriteria(synthesis, mode) {
-    return `**Quantitative Metrics:** ${defineQuantitativeMetrics(mode)}
-**Qualitative Indicators:** ${defineQualitativeIndicators(mode)}
-**Validation Methods:** ${defineValidationMethods(mode)}
-**Review Schedule:** ${defineReviewSchedule()}
-**Success Threshold:** 85% achievement across all criteria`;
-}
-function generateRiskMitigationPlan(synthesis, actionPlan) {
-    return `**High-Risk Areas:** ${identifyHighRiskAreas(synthesis, actionPlan)}
-**Mitigation Strategies:** ${defineMitigationStrategies(synthesis)}
-**Contingency Plans:** ${defineContingencyPlans(actionPlan)}
-**Monitoring Systems:** ${defineMonitoringSystems()}
-**Escalation Procedures:** ${defineEscalationProcedures()}`;
-}
-// Supporting utility functions (simplified implementations for core functionality)
-function determineInvestigativeFocus(input, mode) {
-    const focuses = {
-        analyze: "Component breakdown and relationship mapping",
-        decide: "Decision criteria and alternative evaluation",
-        synthesize: "Information integration and pattern recognition",
-        evaluate: "Assessment criteria and benchmark comparison"
-    };
-    return focuses[mode];
-}
-function generateContextualHypotheses(input, mode) {
+// MCP Server setup
+const server = new Server({
+    name: "gikendaasowin-aabajichiganan-mcp",
+    version: "8.9.1",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+const deliberationEngine = new CognitiveDeliberationEngine();
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
-        primary: `The optimal ${mode} approach will emerge through systematic application of cognitive frameworks`,
-        alternatives: [
-            "Multiple valid solutions may exist requiring prioritization",
-            "Context-specific adaptations may be necessary",
-            "Hybrid approaches may provide superior results"
+        tools: [
+            {
+                name: "deliberate",
+                description: "Advanced cognitive deliberation framework implementing 6-stage processing (Scientific Investigation → OOReD → Critical Thinking → Reviews → Action) with dynamic prompting strategy evaluation. Takes input and optional context, returns comprehensive cognitive processing results with tool usage recommendations.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        input: {
+                            type: "string",
+                            description: "The primary input, question, problem, or task requiring cognitive deliberation",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Optional additional context, background information, or constraints",
+                        },
+                    },
+                    required: ["input"],
+                },
+            },
         ],
-        predictions: [
-            "Structured methodology will improve outcomes",
-            "Multi-perspective analysis will enhance quality",
-            "Validation mechanisms will increase reliability"
-        ]
-    };
-}
-// Comprehensive utility functions for all stages
-function selectExperimentalMethod(mode) {
-    const methods = {
-        analyze: "Systematic decomposition with controlled variable analysis",
-        decide: "Multi-criteria decision analysis with weighted factors",
-        synthesize: "Information integration with cross-validation",
-        evaluate: "Comparative assessment with benchmark standards"
-    };
-    return methods[mode];
-}
-function defineDataCollection(input, mode) {
-    return `Structured collection focusing on ${mode}-relevant metrics and evidence patterns`;
-}
-function identifyIndependentVariables(input) {
-    return "Problem context, available resources, time constraints";
-}
-function identifyDependentVariables(input, mode) {
-    return `${mode} outcome quality, implementation feasibility, stakeholder satisfaction`;
-}
-function identifyControlledVariables(input) {
-    return "Methodological consistency, evaluation criteria, validation standards";
-}
-function defineValidationMethod(mode) {
-    return "Multi-stage validation with cross-verification and consensus checking";
-}
-function selectAnalysisMethod(mode) {
-    return `${mode}-optimized analysis combining quantitative metrics with qualitative insights`;
-}
-function defineStatisticalApproach(input, mode) {
-    return "Descriptive statistics with confidence intervals and significance testing";
-}
-function definePatternRecognition(mode) {
-    return "Systematic pattern identification using multiple analytical perspectives";
-}
-function defineQualityMetrics(mode) {
-    return "Comprehensiveness, consistency, reliability, and applicability measures";
-}
-function defineModeSpecificOutput(mode) {
-    const outputs = {
-        analyze: "Structured breakdown with component relationships",
-        decide: "Prioritized recommendations with risk assessment",
-        synthesize: "Integrated understanding with unified framework",
-        evaluate: "Comprehensive assessment with actionable insights"
     };
-    return outputs[mode];
-}
-function generateTechnicalObservation(input, mode) {
-    return `Technical analysis reveals implementation requirements and constraints for ${mode} processing`;
-}
-function generateStrategicObservation(input, mode) {
-    return `Strategic perspective identifies long-term implications and alignment opportunities`;
-}
-function generateUserCenteredObservation(input, mode) {
-    return `User-centered analysis emphasizes practical applicability and stakeholder impact`;
-}
-function generateContextualObservation(input, context, mode) {
-    return `Contextual analysis integrates specific constraints and environmental factors`;
-}
-function generateSolutionAlternatives(input, mode, stage1Result) {
-    return [
-        { description: "Systematic approach with phased implementation", feasibility: "High" },
-        { description: "Rapid prototyping with iterative refinement", feasibility: "Medium" },
-        { description: "Comprehensive analysis with delayed implementation", feasibility: "Medium" }
-    ];
-}
-function performDeductiveReasoning(input, mode) {
-    return `From general principles: ${mode} requires systematic application of proven methodologies`;
-}
-function performInductiveReasoning(input, mode) {
-    return `From specific observations: Pattern analysis suggests ${mode}-optimized approach`;
-}
-function performAbductiveReasoning(input, mode) {
-    return `Best explanation: Integrated framework provides optimal ${mode} outcomes`;
-}
-function performContextualReasoning(input, context, mode) {
-    return `Context-specific reasoning incorporates environmental factors and constraints`;
-}
-async function applyCriticalQuestion(input, mode, question, firstRoundResult) {
-    return `${question} - Applied to ${mode}: Systematic consideration reveals targeted analysis approach`;
-}
-function checkConsistency(stage1, stage3) {
-    return "High consistency - methodological alignment achieved";
-}
-function identifyGaps(stage1, stage3) {
-    return "Minor gaps in evidence integration - addressed through synthesis";
-}
-function assessStrengths(stage1, stage3) {
-    return "Strong methodological foundation with comprehensive analysis";
-}
-function determineValidationStatus(stage1, stage3) {
-    return "Validated - cross-stage verification successful";
-}
-function selectBestRefinements(stage2, stage4, mode) {
-    return "Enhanced observation, strengthened reasoning, optimized decision-making";
-}
-function getRelevantExperts(mode) {
-    const experts = {
-        analyze: [
-            { role: "Systems Analyst", analysis: "Comprehensive decomposition methodology validated" },
-            { role: "Research Methodologist", analysis: "Systematic approach aligns with best practices" }
-        ],
-        decide: [
-            { role: "Decision Scientist", analysis: "Multi-criteria framework appropriately applied" },
-            { role: "Risk Analyst", analysis: "Risk assessment integration enhances reliability" }
-        ],
-        synthesize: [
-            { role: "Knowledge Engineer", analysis: "Information integration methodology sound" },
-            { role: "Systems Integrator", analysis: "Cross-domain synthesis effectively executed" }
-        ],
-        evaluate: [
-            { role: "Quality Assurance Expert", analysis: "Assessment criteria comprehensively defined" },
-            { role: "Performance Analyst", analysis: "Evaluation methodology meets standards" }
-        ]
-    };
-    return experts[mode];
-}
-function identifySynergies(stage2, stage4) {
-    return "Complementary methodologies enhance overall analytical strength";
-}
-function resolveConflicts(stage2, stage4) {
-    return "Minor methodological differences resolved through integration";
-}
-function generateEnhancedUnderstanding(stage2, stage4) {
-    return "Unified understanding emerges from multi-stage validation";
-}
-function extractKeyInsights(stage3, stage5) {
-    return "Systematic methodology with multi-perspective validation enhances outcome quality";
-}
-function extractValidatedConclusions(stage3, stage5) {
-    return "Comprehensive analysis with expert validation supports reliable implementation";
-}
-function extractActionableRecommendations(stage3, stage5, mode) {
-    return `Proceed with ${mode}-optimized implementation using validated methodological framework`;
-}
-function defineImmediateActions(synthesis, mode) {
-    return "Finalize methodology, prepare resources, initiate implementation planning";
-}
-function defineShortTermGoals(synthesis, mode) {
-    return "Complete initial implementation, establish monitoring, gather feedback";
-}
-function defineLongTermObjectives(synthesis, mode) {
-    return "Achieve full implementation, optimize performance, scale approach";
-}
-function defineResourceAllocation(synthesis) {
-    return "Balanced allocation across planning (30%), implementation (50%), monitoring (20%)";
-}
-function defineTimeline(synthesis) {
-    return "3-month phased approach with monthly review milestones";
-}
-function getModeSpecificConsiderations(mode) {
-    const considerations = {
-        analyze: "Focus on component identification and relationship mapping",
-        decide: "Emphasize criteria weighting and alternative evaluation",
-        synthesize: "Prioritize information integration and pattern recognition",
-        evaluate: "Concentrate on assessment criteria and benchmark comparison"
-    };
-    return considerations[mode];
-}
-function defineQuantitativeMetrics(mode) {
-    return "Success rate > 85%, accuracy > 90%, completion time within 120% of estimate";
-}
-function defineQualitativeIndicators(mode) {
-    return "Stakeholder satisfaction, methodological rigor, outcome reliability";
-}
-function defineValidationMethods(mode) {
-    return "Peer review, expert consultation, empirical testing, stakeholder feedback";
-}
-function defineReviewSchedule() {
-    return "Weekly progress reviews, monthly milestone assessments, quarterly comprehensive evaluations";
-}
-function identifyHighRiskAreas(synthesis, actionPlan) {
-    return "Implementation complexity, resource availability, stakeholder alignment";
-}
-function defineMitigationStrategies(synthesis) {
-    return "Phased approach, contingency planning, stakeholder engagement, quality assurance";
-}
-function defineContingencyPlans(actionPlan) {
-    return "Alternative methodologies, resource reallocation, timeline adjustment, scope modification";
-}
-function defineMonitoringSystems() {
-    return "Real-time progress tracking, quality metrics monitoring, stakeholder feedback systems";
-}
-function defineEscalationProcedures() {
-    return "Clear escalation paths with defined triggers and response protocols";
-}
-// Additional helper functions for Stage 4
-function assessHypothesisStrength(stage1Result) {
-    return "Strong - well-formed hypotheses with testable predictions";
-}
-function assessEvidenceQuality(stage1Result, stage3Result) {
-    return "High quality - multiple sources with cross-validation";
-}
-function assessLogicalCoherence(stage1Result, stage3Result) {
-    return "Excellent - logical consistency maintained across analysis stages";
-}
-function assessMethodologicalRigor(stage1Result) {
-    return "High rigor - systematic approach with appropriate controls";
-}
-// --- Enhanced 6-Stage Cognitive Framework Documentation (2025) ---
-/**
- * 🚀 REVOLUTIONARY 2-ROUND COGNITIVE DELIBERATION FRAMEWORK - 2025 EDITION
- *
- * This implementation represents the evolution of cognitive processing, integrating:
- * - Scientific Investigation methodology for systematic hypothesis formation
- * - OOReD (Observe-Orient-Reason-Decide) framework for strategic analysis
- * - Critical Thinking 10-step framework for comprehensive evaluation
- * - Advanced prompting strategy evaluation system with 0.00-1.00 scoring
- *
- * 📚 2-ROUND PROCESSING ARCHITECTURE:
- *
- * **ROUND 1 - Foundation Building (Stages 1-2):**
- *    - Stage 1: Scientific Investigation with prompting strategy evaluation
- *    - Stage 2: Initial OOReD with selected strategy application
- *    - Output: First round results + tool recommendations for continued processing
- *
- * **ROUND 2 - Advanced Analysis (Stages 3-6):**
- *    - Stage 3: Critical Thinking & Pre-Action Planning
- *    - Stage 4: Scientific Review & Validation
- *    - Stage 5: OOReD Review & Refinement
- *    - Stage 6: Fact-Based Action & Final Recommendations
- *
- * **PROMPTING STRATEGY EVALUATION:**
- *    - Automatic evaluation of all strategies from modern-prompting.mdc
- *    - Solution Level (0.00-0.99) + Efficiency Level (0.00-0.99) scoring
- *    - Strategies with total score ≥1.42 are automatically selected and applied
- *    - Combined strategy application for scores ≥1.42
- *
- * **TOOL RECOMMENDATION ENGINE:**
- *    - Intelligent analysis of input to recommend relevant pair programming tools
- *    - File manipulation tools (read_file, replace_string_in_file, create_file)
- *    - Web search tools (websearch, brave-search) for research tasks
- *    - Code analysis tools (semantic_search, get_errors, list_code_usages)
- *    - Documentation tools (context7 library docs) for API/library information
- *
- * 🎯 COGNITIVE ENHANCEMENT BENEFITS:
- *
- * **Enhanced Reliability:**
- *    - 2-round validation process with cross-round consistency checking
- *    - Prompting strategy evaluation ensures optimal approach selection
- *    - Session-based state management for complex multi-phase analysis
- *
- * **Improved Actionability:**
- *    - Tool usage recommendations with specific count guidance
- *    - Focus on pair programming scenarios and development workflows
- *    - Clear guidance for continuing deliberation with session management
- *
- * **Better Integration:**
- *    - Follows tested specifications from new-mcp-flow.md
- *    - Implements 0.00-1.00 scoring system (no percentages)
- *    - Provides markdown formatted output with tool recommendations
- *
- * 📊 PERFORMANCE METRICS:
- *    - Strategy Selection Accuracy: 95% optimal strategy identification
- *    - 2-Round Consistency: 92% cross-round alignment
- *    - Tool Recommendation Relevance: 88% actionable suggestions
- *    - Implementation Compliance: 100% specification adherence
- */
-/**
- * Tool: deliberate (Revolutionary Single-Tool-Call 2-Round Cognitive Processing Engine)
- *
- * **REVOLUTIONARY SINGLE-CALL FRAMEWORK:** This tool implements advanced 2-round
- * cognitive deliberation system in ONE tool call, combining Scientific Investigation,
- * OOReD analysis, and Critical Thinking frameworks with automatic prompting strategy evaluation.
- *
- * **2-ROUND PROCESSING PIPELINE (SINGLE CALL):**
- * **Round 1 (Foundation):** Stages 1-2 - Scientific Investigation + Initial OOReD
- * **Round 2 (Advanced):** Stages 3-6 - Critical Thinking + Reviews + Final Action
- *
- * **KEY FEATURES:**
- * - **SINGLE TOOL CALL:** Complete 6-stage deliberation without session management
- * - **Automatic Strategy Evaluation:** Analyzes all modern-prompting.mdc strategies
- * - **0.00-1.00 Scoring System:** Solution + Efficiency levels with ≥1.42 threshold
- * - **Internal 2-Round Processing:** All deliberation happens within one tool invocation
- * - **Tool Recommendations:** Intelligent suggestions for pair programming workflows
- * - **Concise Output:** Raw cognitive processing results without formatting constraints
- *
- * **📥 INPUT:** Complex problems requiring systematic 2-round cognitive analysis
- * **📤 OUTPUT:** Processed cognitive analysis with tool recommendations in single response
- */
-server.tool("deliberate", {
-    input: z
-        .string()
-        .describe("The problem, question, decision, or situation that needs cognitive deliberation and analysis."),
-    context: z
-        .string()
-        .optional()
-        .describe("Additional context, constraints, or background information relevant to the deliberation.")
-}, async ({ input, context }) => {
-    const toolName = 'deliberate';
-    logToolCall(toolName, `Input length: ${input.length}`);
-    try {
-        // Single tool call that performs complete 2-round cognitive deliberation
-        const deliberationResult = await performCognitiveDeliberation(input, context);
-        logToolResult(toolName, true, `Complete 2-round deliberation finished`);
-        return { content: [{ type: "text", text: deliberationResult }] };
-    }
-    catch (error) {
-        return logToolError(toolName, error);
-    }
 });
-// --- Server Lifecycle and Error Handling (Internal - No changes needed as per user comments) ---
-/**
- * Gracefully shuts down the server.
- */
-async function shutdown() {
-    console.error('\n[MCP Server] Shutting down gracefully...');
-    try {
-        await server.close();
-        console.error('[MCP Server] Server closed.');
-        process.exit(0);
-    }
-    catch (err) {
-        console.error('[MCP Server] Error during shutdown:', err);
-        process.exit(1);
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (name === "deliberate") {
+        try {
+            const { input, context } = args;
+            if (!input || typeof input !== "string") {
+                throw new Error("Input parameter is required and must be a string");
+            }
+            const result = await deliberationEngine.performCognitiveDeliberation(input, context);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error in cognitive deliberation: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
     }
-}
-// Setup signal handlers
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);
-// Setup global error handlers
-process.on('uncaughtException', (error, origin) => {
-    const timestamp = new Date().toISOString();
-    console.error(`[${timestamp}] [MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
-    shutdown().catch(() => process.exit(1)); // Attempt graceful shutdown, then force exit
+    throw new Error(`Unknown tool: ${name}`);
 });
-process.on('unhandledRejection', (reason, promise) => {
-    const timestamp = new Date().toISOString();
-    console.error(`[${timestamp}] [MCP Server] FATAL: Unhandled Promise Rejection:`, reason);
-    shutdown().catch(() => process.exit(1)); // Attempt graceful shutdown, then force exit
-});
-// --- Start the Server (Internal - No changes needed as per user comments) ---
-/**
- * Initializes and starts the MCP server.
- */
+// Start the server
 async function main() {
-    try {
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-        const border = '==================== Gikendaasowin MCP ====================';
-        console.error(border);
-        console.error(`Name: ${serverInfo.name}`);
-        console.error(`Version: ${serverInfo.version}`);
-        console.error(`Description: ${serverInfo.description}`);
-        console.error('Status: Running on stdio, awaiting MCP requests...');
-        console.error('==========================================================');
-    }
-    catch (error) {
-        const timestamp = new Date().toISOString();
-        console.error(`[${timestamp}] [MCP Server] Fatal error during startup:`, error);
-        process.exit(1);
-    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Gikendaasowin Aabajichiganan MCP server running on stdio");
 }
-// Execute the main function to start the server
-main();
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});