@nbiish/cognitive-tools-mcp 8.7.0 → 8.8.4

package/README.md

@@ -11,7 +11,7 @@
       <p><a href="https://raw.githubusercontent.com/nbiish/license-for-all-works/8e9b73b269add9161dc04bbdd79f818c40fca14e/qr-stripe-donation.png">Donate via Stripe</a></p>
     </div>
     <div style="display: flex; align-items: center;">
-      <a href="https://www.buymeacoffee.com/nbiish"><img src="https://img.buymeacoffee.com/button-api/?text=Buy me a coffee&emoji=&slug=nbiish&button_colour=FFDD00&font_colour=000000&font_family=Cookie&outline_colour=000000&coffee_colour=ffffff" /></a>
+      <a href="https://www.buymeacoffee.com/nbiish"><img src="buymeacoffee-button.svg" alt="Buy me a coffee" /></a>
     </div>
   </div>
   
@@ -36,6 +36,43 @@ Both packages are maintained in parallel and receive the same updates. You can u
 ◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
 </div>
 
+## ᐴ REPOSITORY STRUCTURE ᔔ [MAZINAAZIWIN] ◈──◆──◇──◆──◈
+
+Current repository structure (v8.8.3):
+
+```text
+.
+├── .cursor/                    # Development rules and style guides
+│   ├── anishinaabe-cyberpunk-style.mdc
+│   └── rules/
+├── .github/                    # GitHub configuration
+│   ├── copilot-instructions.md
+│   └── FUNDING.yml
+├── build/                      # Compiled JavaScript output
+│   └── index.js
+├── new-flow/                   # Flow documentation and images
+│   ├── new-flow-images/
+│   └── new-mcp-flow.md
+├── src/                        # TypeScript source code
+│   └── index.ts
+├── buymeacoffee-button.svg     # Support button
+├── CONTRIBUTING.md             # Contribution guidelines
+├── latest.md                   # Integration prompt (licensed)
+├── LICENSE                     # Comprehensive restricted use license
+├── modern-prompting.mdc        # Prompting strategy definitions
+├── package-cognitive-tools.json # English package configuration
+├── package-gikendaasowin.json  # Anishinaabemowin package configuration
+├── package.json               # Main package configuration
+├── publish-both-packages.sh   # Dual publishing script
+├── qr-stripe-donation.png     # Donation QR code
+├── README.md                  # This file
+└── tsconfig.json              # TypeScript configuration
+```
+
+<div align="center">
+◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
+</div>
+
 ## ᐴ GASHKITOONAN ᔔ [ENHANCED CAPABILITIES] ◈──◆──◇──◆──◈
 
 ### 🚀 Revolutionary 6-Stage Cognitive Framework

package/build/index.js

@@ -1,33 +1,30 @@
 #!/usr/bin/env node
 /**
  * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Revolutionary 2-Round Cognitive Deliberation MCP Server (v8.7.0)
+ * Gikendaasowin Aabajichiganan - Revolutionary 2-Round Cognitive Deliberation MCP Server (v8.8.3)
  *
  * 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.7.0 REVOLUTIONARY RELEASE - 2-Round Deliberation Framework:
- * - Complete refactor implementing 2-round deliberation process
- * - DYNAMIC prompting strategy evaluation with in-prompt 0.00-1.00 scoring system
- * - Session-based multi-phase deliberation with state management
- * - Tool usage recommendations focusing on pair programming scenarios
- * - Enhanced reliability with cross-round validation and consistency checking
- * - Comprehensive markdown output with tool count recommendations
- * - Revolutionary 2-round cognitive processing following tested specifications
- * - CRITICAL: All strategy ratings calculated dynamically based on actual task context
+ * 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 { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-const sessions = new Map();
 // --- Server Definition ---
 const serverInfo = {
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "8.7.0",
-    description: "Revolutionary 2-Round Cognitive Deliberation MCP server implementing the new 6-stage framework with prompting strategy evaluation and tool recommendations."
+    version: "8.8.3",
+    description: "Optimized Single-Tool-Call 2-Round Cognitive Deliberation MCP server with threshold adjustment (≥1.42) and reduced verbosity while maintaining comprehensive 6-stage cognitive framework."
 };
 const server = new McpServer(serverInfo);
 // --- Logging Helpers (Internal - No changes needed as per user comments) ---
@@ -71,7 +68,7 @@ function logToolError(toolName, error) {
 }
 /**
  * Evaluates all prompting strategies from modern-prompting.mdc based on input and task
- * Returns strategies with scores ≥1.38 for use in deliberation
+ * 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) {
@@ -126,8 +123,8 @@ function evaluatePromptingStrategies(input, mode, context) {
             totalScore: solutionLevel + efficiencyLevel
         };
     });
-    // Return strategies with scores ≥1.38
-    return strategies.filter(s => s.totalScore >= 1.38).sort((a, b) => b.totalScore - a.totalScore);
+    // 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
@@ -366,21 +363,15 @@ function generateToolRecommendations(input, mode, deliberationResults) {
     }
     return { toolCount: Math.min(8, toolCount), recommendations };
 }
-/**
- * Generates a unique session ID for multi-phase deliberation
- */
-function generateSessionId() {
-    return `del_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-}
 /**
  * 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.38 through dynamic evaluation**";
+        return "**No strategies met the threshold of ≥1.42 through dynamic evaluation**";
     }
-    let result = `**SELECTED PROMPTING STRATEGIES (Score ≥1.38 - Dynamically Evaluated):**\n`;
+    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`;
@@ -394,11 +385,9 @@ function formatPromptingStrategyResults(strategies) {
  * Applies selected prompting strategies to enhance stage processing
  */
 function applySelectedStrategies(strategies, input, mode, stage) {
-    let results = `**Applied Strategies for ${stage}:**\n`;
-    strategies.forEach(strategy => {
-        results += `- **${strategy.name}** (${strategy.totalScore.toFixed(2)}): Enhanced ${stage} processing\n`;
-    });
-    return results;
+    if (strategies.length === 0)
+        return "";
+    return `**Applied Strategies:** ${strategies.map(s => `${s.name} (${s.totalScore.toFixed(2)})`).join(', ')}\n`;
 }
 /**
  * Formats strategy application for display
@@ -428,23 +417,19 @@ function validateScientificConsistency(questionIdentification, hypothesisFormati
 }
 // --- Cognitive Deliberation Engine ---
 /**
- * Performs two-round cognitive deliberation using the new 6-Stage Framework
+ * 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, mode, context, sessionId) {
-    // Check if this is a continuing session
-    let session = sessionId ? sessions.get(sessionId) : null;
-    if (!session) {
-        // First round: Stages 1-2
-        const firstRoundId = generateSessionId();
-        // 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);
-        // Store first round results
-        const firstRoundResults = `# 1ST ROUND OF DELIBERATION
+async function performCognitiveDeliberation(input, mode, 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);
+    const firstRoundResults = `# 1ST ROUND OF DELIBERATION
 
 ## PROMPTING STRATEGY EVALUATION
 ${formatPromptingStrategyResults(selectedStrategies)}
@@ -457,47 +442,20 @@ ${stage2}
 
 ---
 *First Round Complete: Scientific Investigation + Initial OOReD*`;
-        // Create session for second round
-        session = {
-            id: firstRoundId,
-            input,
-            mode,
-            context,
-            phase: 'first-round',
-            firstRoundResults,
-            createdAt: new Date()
-        };
-        sessions.set(firstRoundId, session);
-        // Generate tool recommendations
-        const toolRecs = generateToolRecommendations(input, mode, firstRoundResults);
-        return `${firstRoundResults}
-
-## NEXT STEPS
-To continue with the second round of deliberation (Stages 3-6), call the deliberate tool again with:
-- session_id: "${firstRoundId}"
-- Same input and parameters
-
-**tool use before re-deliberation: ${toolRecs.toolCount}**
-
-### RECOMMENDED TOOLS BEFORE SECOND ROUND:
-${toolRecs.recommendations.join('\n')}`;
-    }
-    else {
-        // Second round: Stages 3-6
-        const selectedStrategies = evaluatePromptingStrategies(input, mode, context);
-        // STAGE 3: CRITICAL THINKING + PRE-ACT
-        const stage3 = await performCriticalThinkingPreAct(input, mode, context, session.firstRoundResults, selectedStrategies);
-        // STAGE 4: SCIENTIFIC REVIEW
-        const stage4 = await performScientificReview(input, mode, context, session.firstRoundResults, stage3, selectedStrategies);
-        // STAGE 5: OOReD REVIEW  
-        const stage5 = await performOOReViewReview(input, mode, context, session.firstRoundResults, stage4, selectedStrategies);
-        // STAGE 6: FINAL ACT
-        const stage6 = await performFinalAct(input, mode, context, stage3, stage5, selectedStrategies);
-        // Clean up session
-        sessions.delete(sessionId);
-        // Generate final tool recommendations
-        const finalToolRecs = generateToolRecommendations(input, mode, `${stage3}\n${stage5}\n${stage6}`);
-        const secondRoundResults = `# 2ND ROUND OF DELIBERATION
+    // ROUND 2: Stages 3-6 (Internal processing continues)
+    // Use same strategies for consistency (input/mode/context unchanged)
+    const secondRoundStrategies = selectedStrategies;
+    // STAGE 3: CRITICAL THINKING + PRE-ACT
+    const stage3 = await performCriticalThinkingPreAct(input, mode, context, firstRoundResults, secondRoundStrategies);
+    // STAGE 4: SCIENTIFIC REVIEW
+    const stage4 = await performScientificReview(input, mode, context, firstRoundResults, stage3, secondRoundStrategies);
+    // STAGE 5: OOReD REVIEW  
+    const stage5 = await performOOReViewReview(input, mode, context, firstRoundResults, stage4, secondRoundStrategies);
+    // STAGE 6: FINAL ACT
+    const stage6 = await performFinalAct(input, mode, context, stage3, stage5, secondRoundStrategies);
+    // Generate final tool recommendations
+    const finalToolRecs = generateToolRecommendations(input, mode, `${stage3}\n${stage5}\n${stage6}`);
+    const secondRoundResults = `# 2ND ROUND OF DELIBERATION
 
 ## STAGE 3: CRITICAL THINKING & PRE-ACTION PLANNING
 ${stage3}
@@ -513,7 +471,8 @@ ${stage6}
 
 ---
 *Second Round Complete: Critical Thinking + Reviews + Final Action*`;
-        return `${session.firstRoundResults}
+    // Return complete single-tool-call result
+    return `${firstRoundResults}
 
 ${secondRoundResults}
 
@@ -530,8 +489,7 @@ ${finalToolRecs.recommendations.join('\n')}
 ---
 *Enhanced 2-Round Cognitive Framework: Scientific Investigation + OOReD + Critical Thinking*
 *Processing Mode: ${mode} | Total Strategies Applied: ${selectedStrategies.length}*
-*Session: ${sessionId} | Framework Version: 8.0.0*`;
-    }
+*Framework Version: 8.8.3 | Complete Single-Tool-Call Processing*`;
 }
 // --- 6-Stage Cognitive Processing Functions with Integrated Prompting Strategies ---
 /**
@@ -639,9 +597,6 @@ ${consensusAnalysis}
 **Pre-Action Planning:**
 ${toolPlanning}
 
-**Strategy-Enhanced Results:**
-${strategyResults}
-
 **Meta-Cognitive Assessment:**
 - Thinking process evaluation: ${evaluateThinkingProcess(criticalThinkingPaths)}
 - Assumption validation: ${validateAssumptions(criticalThinkingPaths)}
@@ -674,9 +629,6 @@ ${validationPaths}
 **Cross-Stage Consistency Analysis:**
 ${consistencyCheck}
 
-**Strategy-Enhanced Results:**
-${strategyResults}
-
 **Enhanced Validation Results:**
 - Hypothesis strength: ${assessHypothesisStrength(firstRoundResult)}
 - Evidence quality: ${assessEvidenceQuality(firstRoundResult, stage3Result)}
@@ -708,9 +660,6 @@ ${expertPerspectives}
 **Integration Analysis:**
 ${integrateStageFindings(firstRoundResult, stage4Result)}
 
-**Strategy-Enhanced Results:**
-${strategyResults}
-
 **Refinement Recommendations:**
 ${generateRefinementRecommendations(refinementPaths, expertPerspectives)}`;
 }
@@ -740,9 +689,6 @@ ${actionPlan}
 **Quality Assurance Metrics:**
 ${qualityMetrics}
 
-**Strategy-Enhanced Results:**
-${strategyResults}
-
 **Implementation Roadmap:**
 ${generateImplementationRoadmap(actionPlan, mode)}
 
@@ -873,7 +819,7 @@ async function planRequiredTools(input, mode, consensus) {
 **Resource Requirements:** Time, expertise, and technological capabilities assessed`;
 }
 function formatCriticalThinkingPaths(paths) {
-    return paths.map((path, i) => `**Step ${i + 1}:** ${path.substring(0, 200)}${path.length > 200 ? '...' : ''}`).join('\n');
+    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) {
@@ -1081,7 +1027,7 @@ 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 enhanced understanding based on ${firstRoundResult.substring(0, 100)}...`;
+    return `${question} - Applied to ${mode}: Systematic consideration reveals targeted analysis approach`;
 }
 function checkConsistency(stage1, stage3) {
     return "High consistency - methodological alignment achieved";
@@ -1227,8 +1173,8 @@ function assessMethodologicalRigor(stage1Result) {
  * **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.38 are automatically selected and applied
- *    - Combined strategy application for scores ≥1.38
+ *    - 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
@@ -1261,25 +1207,26 @@ function assessMethodologicalRigor(stage1Result) {
  *    - Implementation Compliance: 100% specification adherence
  */
 /**
- * Tool: deliberate (Revolutionary 2-Round Cognitive Processing Engine)
+ * Tool: deliberate (Revolutionary Single-Tool-Call 2-Round Cognitive Processing Engine)
  *
- * **REVOLUTIONARY 2-ROUND FRAMEWORK:** This tool implements the most advanced 2-round
- * cognitive deliberation system available, combining Scientific Investigation, OOReD
- * analysis, and Critical Thinking frameworks with automatic prompting strategy evaluation.
+ * **REVOLUTIONARY SINGLE-CALL FRAMEWORK:** This tool implements the most advanced 2-round
+ * cognitive deliberation system available in ONE tool call, combining Scientific Investigation,
+ * OOReD analysis, and Critical Thinking frameworks with automatic prompting strategy evaluation.
  *
- * **2-ROUND PROCESSING PIPELINE:**
+ * **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.38 threshold
- * - **Session Management:** Continue complex deliberations across multiple calls
+ * - **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
- * - **Markdown Output:** Structured results with tool usage guidance
+ * - **Markdown Output:** Structured results with "tool use before re-deliberation" count
  *
  * **📥 INPUT:** Complex problems requiring systematic 2-round cognitive analysis
- * **📤 OUTPUT:** Structured analysis with tool recommendations and session continuity
+ * **📤 OUTPUT:** Complete structured analysis with tool recommendations in single response
  *
  * **🎯 OPTIMAL USE CASES:**
  * - Complex development tasks requiring systematic analysis
@@ -1289,8 +1236,8 @@ function assessMethodologicalRigor(stage1Result) {
  * - Research and development requiring systematic investigation
  *
  * **⚡ REVOLUTIONARY CAPABILITIES:**
- * - 2-round deliberation with automatic strategy selection
- * - Session-based state management for complex workflows
+ * - Single-call 2-round deliberation with automatic strategy selection
+ * - Complete 6-stage processing without external session management
  * - Tool usage recommendations with specific count guidance
  * - Cross-round validation with consistency checking
  * - Comprehensive action planning with implementation roadmaps
@@ -1306,18 +1253,14 @@ server.tool("deliberate", {
     context: z
         .string()
         .optional()
-        .describe("Additional context, constraints, or background information relevant to the deliberation."),
-    session_id: z
-        .string()
-        .optional()
-        .describe("Session ID for continuing multi-phase deliberation. Use the ID returned from first round to continue with second round.")
-}, async ({ input, mode, context, session_id }) => {
+        .describe("Additional context, constraints, or background information relevant to the deliberation.")
+}, async ({ input, mode, context }) => {
     const toolName = 'deliberate';
-    logToolCall(toolName, `Mode: ${mode}, Input length: ${input.length}, Session: ${session_id || 'new'}`);
+    logToolCall(toolName, `Mode: ${mode}, Input length: ${input.length}`);
     try {
-        // Two-round cognitive deliberation processing
-        const deliberationResult = await performCognitiveDeliberation(input, mode, context, session_id);
-        logToolResult(toolName, true, `Mode: ${mode}, Deliberation completed`);
+        // Single tool call that performs complete 2-round cognitive deliberation
+        const deliberationResult = await performCognitiveDeliberation(input, mode, context);
+        logToolResult(toolName, true, `Mode: ${mode}, Complete 2-round deliberation finished`);
         return { content: [{ type: "text", text: deliberationResult }] };
     }
     catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "8.7.0",
-  "description": "Revolutionary 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).",
+  "version": "8.8.4",
+  "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",
   "bin": {