@nbiish/cognitive-tools-mcp 8.9.3 → 8.9.8

package/README.md

@@ -22,7 +22,9 @@
 ◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
 </div>
 
-Revolutionary MCP server with Enhanced 2-Round, 6-Stage Cognitive Deliberation Framework (v8.9.2). The `deliberate` tool implements an **advanced guided notepad** approach with **dynamic prompting strategy evaluation from modern-prompting.mdc** - featuring **MINIMAL filler verbiage** and **maximum LLM freedom** accepting only `input` and `context` parameters. *(Integration guidelines in [`latest.md`](latest.md) are licensed under [LICENSE](LICENSE).)*
+Revolutionary MCP server with Enhanced 2-Round, 6-Stage Cognitive Deliberation Framework (v8.9.6). The `deliberate` tool implements an **LLM-guided cognitive enhancement framework** that prompts LLMs to evaluate and select from **15 modern cognitive techniques** using a **0.00-0.99 scoring system** with **≥1.53 threshold rule** - accepting only `input` and `context` parameters. *(Integration guidelines in [`latest.md`](latest.md) are licensed under [LICENSE](LICENSE).)*
+
+**🚀 MAJOR BREAKTHROUGH (v8.9.6):** Complete architectural transformation from hardcoded `CognitiveDeliberationEngine` to LLM-guided `DeliberationEngine`. The tool now functions as a **cognitive framework enhancer** that prompts LLMs to evaluate techniques themselves rather than providing pre-calculated scores, enabling true adaptive reasoning.
 
 Known as:
 - Anishinaabemowin: [`@nbiish/gikendaasowin-aabajichiganan-mcp`](https://www.npmjs.com/package/@nbiish/gikendaasowin-aabajichiganan-mcp)
@@ -38,7 +40,7 @@ Both packages are maintained in parallel and receive the same updates. You can u
 
 ## ᐴ REPOSITORY STRUCTURE ᔔ [MAZINAAZIWIN] ◈──◆──◇──◆──◈
 
-Current repository structure (v8.9.2):
+Current repository structure (v8.9.6):
 
 ```text
 .
@@ -76,33 +78,33 @@ Current repository structure (v8.9.2):
 
 ## ᐴ GASHKITOONAN ᔔ [ENHANCED CAPABILITIES] ◈──◆──◇──◆──◈
 
-### 🚀 Revolutionary 2-Round, 6-Stage Cognitive Framework (v8.9.2)
+### 🚀 Revolutionary LLM-Guided Cognitive Framework (v8.9.6)
+
+**NEW IN v8.9.6: COMPLETE ARCHITECTURAL TRANSFORMATION**
+
+- **LLM-Guided Evaluation:** Tool prompts LLMs to evaluate cognitive techniques rather than providing hardcoded scores
+- **True Adaptive Reasoning:** No pre-calculated evaluations - LLMs determine optimal strategies dynamically
+- **15 Modern Cognitive Techniques:** Complete prompting strategy arsenal from Cache-Augmented Reasoning to Multimodal Synthesis
+- **0.00-0.99 Scoring Framework:** LLMs evaluate solution level + efficiency level with ≥1.53 threshold rule
+- **Iterative Enhancement:** Built-in guidance to return to deliberate after tool usage for continuous improvement
 
-**NEW IN v8.9.2: ADVANCED GUIDED NOTEPAD APPROACH**
+**Revolutionary LLM-Guidance Architecture:**
 
-- **LLM Freedom:** Tool accepts only `input` and `context` - no mode parameter needed
-- **Zero Filler Verbiage:** No formatting constraints, headers, or verbose output
-- **Dynamic Strategy Selection:** Evaluates modern-prompting.mdc strategies with 0.00-1.00 rating system
-- **Auto-Mode Detection:** Automatically determines analyze/decide/synthesize/evaluate approach
-- **Pure Cognitive Output:** Raw cognitive processing results for maximum LLM flexibility
+**Framework Delivery Phase:**
 
-**2-Round Processing Architecture:**
+- **6-Stage Structure Presentation** - Complete deliberation framework with critical thinking questions
+- **Cognitive Technique Catalog** - All 15 modern prompting strategies for LLM evaluation
+- **Scoring Instructions** - Clear 0.00-0.99 evaluation criteria with threshold-based selection rules
 
-**Round 1: Foundation Building**
-- **Stage 1: Scientific Investigation** - Systematic hypothesis formation with scientific method
-- **Stage 2: Initial OOReD** - Multiple reasoning path exploration with Tree-of-Thoughts
+**LLM Processing Phase:**
 
-**Round 2: Refinement & Action**
-- **Stage 3: Critical Thinking + Pre-Act** - 10-step framework with tool identification
-- **Stage 4: Scientific Review** - Cross-validation of investigation findings
-- **Stage 5: OOReD Review** - Multi-path reasoning refinement
-- **Stage 6: Final Action** - Comprehensive synthesis with actionable recommendations
+- **Dynamic Technique Selection** - LLM evaluates and scores techniques based on specific problem context
+- **Strategy Combination** - Multiple techniques used when scoring ≥1.53 for enhanced effectiveness  
+- **Tool Planning Integration** - Recommendations for tool usage count and re-deliberation timing
+- **Adaptive Implementation** - LLM applies selected cognitive approaches to actual problem solving
 
-**Dynamic Strategy Integration:**
-- Evaluates all modern-prompting.mdc strategies during Orient stage
-- Assigns solution level (0.00-0.99) + efficiency level (0.00-0.99) ratings
-- Uses strategies with combined rating ≥1.42 (combines multiple if ≥1.53)
-- Includes natural "tool use before re-deliberation: X" count in output
+**Core Innovation:**
+This breakthrough enables LLMs to **meta-cognitively select** their own reasoning approaches rather than following pre-determined paths, resulting in truly adaptive and context-appropriate problem solving.
 
 <div align="center">
 ◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
@@ -110,33 +112,33 @@ Current repository structure (v8.9.2):
 
 ## ᐴ APITENDAAGOZIJIG ᔔ [PERFORMANCE METRICS] ◈──◆──◇──◆──◈
 
-- **Dynamic Strategy Selection:** Evaluates 15+ modern prompting strategies with quantitative rating
-- **2-Round Processing:** Foundation building + refinement for comprehensive analysis
-- **Enhanced Reliability:** Multi-stage validation reduces cognitive errors significantly
-- **Maximum LLM Freedom:** Zero formatting constraints allow natural AI expression
-- **Tool Integration:** Natural count suggestions for optimal re-deliberation timing
+- **LLM-Guided Evaluation:** Prompts LLMs to evaluate and score 15+ cognitive techniques dynamically
+- **True Adaptive Reasoning:** No hardcoded evaluations - strategies selected based on problem context
+- **Meta-Cognitive Enhancement:** LLMs learn to select their own optimal reasoning approaches
+- **Iterative Improvement:** Built-in guidance for tool usage and re-deliberation cycles
+- **Threshold-Based Selection:** ≥1.53 scoring rule ensures quality technique combination
 
 <div align="center">
 ◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
 </div>
 
-## 🚀 Advanced Guided Notepad Approach (v8.9.2)
+## 🚀 LLM-Guided Cognitive Enhancement Framework (v8.9.6)
 
-This revolutionary update transforms the deliberation tool into an "advanced guided notepad" that provides cognitive enhancement without constraining AI creativity.
+This revolutionary update transforms the deliberation tool from a hardcoded evaluation system into an **LLM-guided cognitive enhancement framework** that enables true adaptive reasoning.
 
 ### Core Innovation
 
-**Pure Cognitive Processing:** The tool now provides generations of cognitive techniques as "hints" to process thoughts better, backed by research and rigor, while allowing LLMs complete freedom in output construction.
+**Meta-Cognitive Selection:** The tool now prompts LLMs to evaluate and select cognitive techniques themselves using a structured 0.00-0.99 scoring system, enabling context-appropriate strategy selection rather than pre-determined approaches.
 
 ### Processing Architecture
 
-1. **Input Analysis:** Auto-determines optimal cognitive processing approach (analyze/decide/synthesize/evaluate)
-2. **Round 1:** Scientific Investigation + Initial OOReD (internal cognitive processing)
-3. **Round 2:** Critical Thinking + Reviews + Final Action (internal cognitive processing)
-4. **Strategy Selection:** Evaluates modern-prompting.mdc techniques with quantitative ratings
-5. **Output:** Concise cognitive results + tool usage recommendations
+1. **Framework Presentation:** Delivers complete 6-stage deliberation structure with critical thinking questions
+2. **Technique Catalog:** Presents all 15 modern cognitive techniques for LLM evaluation
+3. **Scoring Framework:** Guides LLM through solution level + efficiency level evaluation (≥1.53 threshold)
+4. **Dynamic Selection:** LLM chooses optimal techniques based on specific problem requirements  
+5. **Implementation Guidance:** Provides tool usage recommendations and re-deliberation encouragement
 
-This approach enables LLMs to leverage advanced cognitive frameworks while maintaining their natural problem-solving flow!
+This breakthrough enables LLMs to **learn and adapt their own reasoning approaches** while leveraging advanced cognitive frameworks for enhanced problem-solving capabilities!
 
 <div align="center">
 ◈──◆──◇─────────────────────────────────────────────────◇──◆──◈

package/build/index.js

@@ -65,375 +65,94 @@ const PROMPTING_STRATEGIES = {
         type: "advanced"
     }
 };
-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)
-            });
-        }
-        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 (complexity === 'low')
-            score += 0.2;
-        // Task type matching
-        const taskType = this.identifyTaskType(input);
-        if (taskType === 'computational' && strategy.description.includes('code'))
-            score += 0.25;
-        if (taskType === 'analytical' && strategy.description.includes('reasoning'))
-            score += 0.2;
-        if (taskType === 'creative' && strategy.description.includes('synthesis'))
-            score += 0.15;
-        // Context utilization
-        if (context && strategy.description.includes('context'))
-            score += 0.15;
-        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;
-        // 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?`;
-        }
-    }
-    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.`;
-    }
-    reorient(input, round1Results, strategies) {
-        return `Strategic reorientation utilizing ${strategies.join(' and ')} approaches for optimized solution development.`;
-    }
-    advancedReasoning(input, context, round1Results, strategies) {
-        return `Advanced reasoning synthesis combining ${strategies.length} selected strategies with comprehensive validation protocols.`;
-    }
-    finalDecisionFramework(input, round1Results) {
-        return `Final decision framework established with clear implementation priorities and success verification methods.`;
-    }
-    synthesizeSolution(input, context, allResults, strategies) {
-        return `Comprehensive solution synthesis utilizing ${strategies.join(', ')} strategies for optimal implementation approach${context ? ' within provided contextual framework' : ''}.`;
-    }
-    createImplementationPath(input, allResults) {
-        return `Implementation pathway: systematic execution with iterative validation, quality assurance checkpoints, and optimization opportunities.`;
-    }
-    establishVerification(input, allResults) {
-        return `Verification framework: solution completeness validation, performance assessment, and success criteria confirmation.`;
-    }
-    defineSuccessMetrics(input, allResults) {
-        return `Success metrics: solution quality, implementation efficiency, requirement satisfaction, and stakeholder value delivery.`;
-    }
-    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.`;
+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.1",
+    version: "8.9.4",
 }, {
     capabilities: {
         tools: {},
     },
 });
-const deliberationEngine = new CognitiveDeliberationEngine();
+const deliberationEngine = new DeliberationEngine();
 // List available tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
@@ -463,12 +182,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 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 { 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);
+            const result = deliberationEngine.deliberate(input, context);
             return {
                 content: [
                     {
@@ -479,15 +198,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error in cognitive deliberation: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
+            throw new Error(`Deliberation failed: ${error}`);
         }
     }
     throw new Error(`Unknown tool: ${name}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "8.9.3",
+  "version": "8.9.8",
   "description": "Revolutionary Single-Tool-Call MCP server with Enhanced 6-Stage Cognitive Deliberation Framework combining Scientific Investigation, OOReD, and Critical Thinking methodologies with DYNAMIC prompting strategy evaluation system (CoT, ToT, Self-Consistency, Meta-Prompting, Role-Based).",
   "private": false,
   "type": "module",