@nbiish/cognitive-tools-mcp 8.9.1 → 8.9.8

package/build/index.js

@@ -1,1167 +1,215 @@
 #!/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."
-};
-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"
-        }
-    ];
-    // 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")
-            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"))
-            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)
-            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)
-            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"))
-            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;
-    }
-    // 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;
-    }
-    // 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;
-    }
-    // Terminal execution
-    if (input.includes("run") || input.includes("execute") || input.includes("install")) {
-        recommendations.push("• **run_in_terminal** - Execute commands and scripts");
-        toolCount += 1;
-    }
-    // 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;
-    }
-    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**";
-    }
-    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";
-    }
-    // Synthesis indicators
-    if (/\b(combine|integrate|synthesize|merge|unify|connect|relate|together)\b/.test(inputLower)) {
-        return "synthesize";
-    }
-    // Evaluation indicators  
-    if (/\b(evaluate|assess|judge|rate|compare|review|quality|effectiveness)\b/.test(inputLower)) {
-        return "evaluate";
+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"
     }
-    // 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));
-    }
-    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) {
+};
+class DeliberationEngine {
+    deliberate(input, context) {
+        // Generate the deliberation framework that prompts the LLM to evaluate strategies itself
+        const availableStrategies = Object.entries(PROMPTING_STRATEGIES)
+            .map(([name, strategy]) => `**${name}** (${strategy.type}): ${strategy.description}`)
+            .join('\n');
+        return `DELIBERATION: You are now entering a 6-stage cognitive deliberation process. Please work through each stage systematically:
+
+## Stage 1: Scientific Investigation
+**Your Task:** Analyze the following input using scientific methodology:
+- **Input:** "${input}"
+${context ? `- **Context:** "${context}"` : ''}
+
+**Please identify:**
+1. Core question/problem
+2. Initial hypothesis about the best approach
+3. What type of task this is (computational, reasoning, creative, analysis, planning, general)
+4. Task complexity level (low, medium, high)
+
+## Stage 2: OOReD Process - Strategy Evaluation
+**Orient Stage:** You have access to these cognitive techniques:
+
+${availableStrategies}
+
+**Your Evaluation Task:** 
+For each technique, consider:
+- How well would this technique solve the specific problem? (Solution Level 0.00-0.99)
+- How efficiently can this technique be applied here? (Efficiency Level 0.00-0.99)
+- Total Score = Solution Level + Efficiency Level
+
+**Selection Rule:** Choose techniques with total scores ≥1.53 for combined effectiveness
+
+## Stage 3: Critical Thinking Framework
+Apply these questions:
+1. What is the purpose of my thinking?
+2. What precise question am I trying to answer?
+3. Within what context am I operating?
+4. What information do I need to gather?
+5. How reliable is this information?
+6. What concepts are relevant to my thinking?
+7. What conclusions can I draw?
+8. What assumptions am I making?
+9. What are the implications?
+10. What are the consequences?
+
+## Stage 4 & 5: Review Cycles
+- Review your strategy selections against the ≥1.53 threshold
+- Validate your reasoning approach
+- Refine your methodology
+
+## Stage 6: Final Action Synthesis
+**Present your analysis in this format:**
+
+**Selected Cognitive Technique(s):** [List techniques scoring ≥1.53]
+
+**Strategy Evaluation Results (0.00-0.99 scale):**
+[Show your evaluations like:]
+- TechniqueName: solution=X.XX, efficiency=Y.YY, total=Z.ZZ ✓ (if ≥1.53)
+
+**Estimated Tools Needed:** [1-8 tools for implementation]
+
+**Recommended Pair Programmer Tools:**
+- websearch (for current information and validation)
+- file manipulation tools (for code and document management)
+- code analysis tools (for computational problem solving)
+- context synthesis tools (for information integration)
+- debugging and testing tools (for solution verification)
+
+Return to 'deliberate' after using the following tools: [Your estimated tool count]
+
+# To accomplish Task:
+[Describe the task using your selected cognitive approach]
+
+---
+
+**Now:** Apply your selected cognitive technique(s) to actually solve the original problem "${input}" using your enhanced reasoning framework.`;
+    }
+}
+// MCP Server setup
+const server = new Server({
+    name: "gikendaasowin-aabajichiganan-mcp",
+    version: "8.9.4",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+const deliberationEngine = new DeliberationEngine();
+// 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") {
+        const { input, context } = args;
+        if (!input || typeof input !== "string") {
+            throw new Error("Input is required and must be a string");
+        }
+        try {
+            const result = deliberationEngine.deliberate(input, context);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Deliberation failed: ${error}`);
+        }
     }
-}
-// 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
-});
-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
+    throw new Error(`Unknown tool: ${name}`);
 });
-// --- 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);
+});