@nbiish/cognitive-tools-mcp 8.9.3 → 10.0.1

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

@@ -2,445 +2,143 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-// Modern prompting strategies from modern-prompting.mdc
+// Compressed cognitive strategies from modern-prompting research
 const PROMPTING_STRATEGIES = {
+    "Chain of Draft (CoD)": {
+        description: "Concise reasoning drafts ≤5 words/step. Essential calculations only. Abstract verbose details."
+    },
     "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"
+        description: "Interleave knowledge activation with reasoning cycles. Keep rationale concise (≤8 bullets). Progressive knowledge building."
     },
     "Self-Consistency": {
-        description: "Generate 3 short reasoning drafts in parallel. Return most consistent answer only. Use for ambiguous or high-stakes decisions.",
-        type: "primary"
+        description: "Generate 3 reasoning drafts in parallel. Return most consistent answer for high-stakes decisions."
     },
     "PAL (Program-Aided Language)": {
-        description: "Generate executable code for computational tasks. Include result + minimal rationale only. Prefix with '# PoT offload' comment.",
-        type: "primary"
+        description: "Generate executable code for computational tasks. Include result + minimal rationale. Prefix '# PoT offload'."
     },
     "Reflexion": {
-        description: "Single critique and revision cycle. Use when confidence < 0.7. Avoid verbose chain-of-thought exposure.",
-        type: "primary"
+        description: "Single critique and revision cycle. Use when confidence < 0.7. Avoid verbose chain-of-thought exposure."
     },
     "Context-Compression": {
-        description: "Apply when context exceeds budget. Use LLMLingua/LongLLMLingua compression. Prefer Minimal-CoT and bounded ToT-lite.",
-        type: "primary"
+        description: "LLMLingua compression when context exceeds budget. Prefer Minimal-CoT and bounded ToT-lite."
     },
     "ToT-lite (Tree of Thoughts)": {
-        description: "Bounded breadth/depth exploration. Use for complex problem decomposition. Limited branching to maintain efficiency.",
-        type: "primary"
+        description: "Bounded breadth/depth exploration. Limited branching for complex problem decomposition efficiency."
+    },
+    "Metacognitive Prompting (MP)": {
+        description: "5-stage introspective reasoning: understand → judge → evaluate → decide → assess confidence. Human-like cognition."
     },
     "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"
+        description: "Autonomously refine prompts via performance feedback. Expert prompting + iterative refinement. Reduces manual effort."
     },
     "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"
+        description: "Embed ethical/legal/cultural considerations. Evaluate against project guidelines. Indigenous Data Sovereignty aware."
     },
     "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"
+        description: "Use previous outputs as contextual hints. Multi-turn interaction with cumulative knowledge building."
     },
     "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"
+        description: "Preload relevant context into working memory. Eliminate real-time retrieval dependencies."
     },
     "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"
+        description: "Structure reasoning through metacognitive frameworks. Mental model construction + validation. Self-monitoring processes."
     },
     "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"
+        description: "Generate hypothetical knowledge constructs from parametric memory. Cross-reference internal knowledge consistency."
     },
     "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"
+        description: "Process text/images/data integration. Visual question answering + cross-modal analysis. Broader task solutions."
     },
     "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"
+        description: "Integrate multiple internal domains. Fine-grained coherence validation. Cross-domain knowledge integration."
     },
     "Prompt Compression": {
-        description: "LLMLingua for token budget management. Preserve semantic content while reducing length. Maintain reasoning quality under constraints.",
-        type: "advanced"
+        description: "LLMLingua for token budget management. Preserve semantic content while reducing length constraints."
     }
 };
-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)}.
+class DeliberationEngine {
+    deliberate(input, context) {
+        // /// [6-stage self-prompting framework for LLMs with unified input]
+        const strategiesList = Object.entries(PROMPTING_STRATEGIES)
+            .map(([name, strategy]) => `**${name}:** ${strategy.description}`)
+            .join('\n');
+        return `You are now entering a 6-stage cognitive deliberation process. Please work through each stage systematically:
 
-**Reason:** Core reasoning foundation: ${this.establishReasoning(input, selectedStrategies, context)}.
+## Stage 1: Scientific Investigation
+**Your Task:** Analyze the following prompt using scientific methodology:
+- **Prompt:** "${prompt}"
 
-**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)}
+**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)
 
-**Hypothesis Refinement:** ${this.refineHypothesis(input, round1Results)}
+## Stage 2: OOReD Process - Strategy Evaluation
+**Orient Stage:** You have access to these cognitive techniques:
 
-**Methodology Assessment:** ${this.assessMethodology(round1Results)}
+${strategiesList}
 
-**Evidence Evaluation:** ${this.evaluateEvidence(input, context, round1Results)}
+**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
 
-**Conclusion Verification:** ${this.verifyConclusions(round1Results)}`;
-    }
-    // Stage 5: OOReD Review  
-    performOOReD_Review(input, round1Results, selectedStrategies, context) {
-        return `## OOReD Review Process
+**Selection Rule:** Choose techniques with total scores ≥1.53 for combined effectiveness
 
-**Enhanced Observation:** ${this.enhanceObservation(input, round1Results)}
+## Stage 3: Critical Thinking Framework
+Apply rapid validation checks:
+1. **Purpose:** What outcome am I optimizing for?
+2. **Question:** What specific problem needs solving?
+3. **Context:** What constraints or requirements apply?
+4. **Evidence:** What facts do I need vs. what do I have?
+5. **Reliability:** How confident am I in my information sources?
+6. **Assumptions:** What am I taking for granted that could be wrong?
+7. **Implications:** What happens if I'm right? What if I'm wrong?
 
-**Strategic Reorientation:** ${this.reorient(input, round1Results, selectedStrategies)}
+## Stage 4 & 5: Review Cycles
+- Review your strategy selections against the ≥1.53 threshold
+- Validate your reasoning approach
+- Refine your methodology
 
-**Advanced Reasoning:** ${this.advancedReasoning(input, context, round1Results, selectedStrategies)}
+## Stage 6: Final Action Synthesis
+**Present your analysis in this format:**
 
-**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
+**DELIBERATION:** [Your thought process through stages 1-5]
 
-**Comprehensive Solution:** ${this.synthesizeSolution(input, context, allResults, selectedStrategies)}
+**SELECTED TOOLS:** [List of tools you estimate are needed to accomplish the task]
 
-**Implementation Pathway:** ${this.createImplementationPath(input, allResults)}
+**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)
 
-**Verification Framework:** ${this.establishVerification(input, allResults)}
+**Selected Cognitive Technique(s):** [List techniques scoring ≥1.53]
 
-**Success Metrics:** ${this.defineSuccessMetrics(input, allResults)}
+**Estimated Tools Needed:** [1-8 tools for implementation]
 
-**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.`;
+**Now:** Apply your selected cognitive technique(s) to actually solve the original problem "${prompt}" using your enhanced reasoning framework.`;
     }
 }
-// MCP Server setup
+// MCP Server setup with 6-stage cognitive deliberation framework
 const server = new Server({
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "8.9.1",
+    version: "10.0.0", // /// [6-stage deliberation with 0.00-0.99 scoring system]
 }, {
     capabilities: {
         tools: {},
     },
 });
-const deliberationEngine = new CognitiveDeliberationEngine();
+const deliberationEngine = new DeliberationEngine();
 // List available tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         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.",
+                description: "Advanced cognitive deliberation framework implementing 6-stage processing (Scientific Investigation → OOReD → Critical Thinking → Review → OOReD → Act) with dynamic prompting strategy evaluation. Takes a prompt combining the question/problem and any context, returns comprehensive cognitive processing results with tool usage recommendations.",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -463,12 +161,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,24 +177,16 @@ 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}`);
 });
-// Start the server
+// Start the server with 6-stage cognitive deliberation framework
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Gikendaasowin Aabajichiganan MCP server running on stdio");
+    console.error("Gikendaasowin Aabajichiganan MCP server running with 6-stage cognitive deliberation framework");
 }
 main().catch((error) => {
     console.error("Fatal error in main():", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "8.9.3",
+  "version": "10.0.1",
   "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",