@nbiish/cognitive-tools-mcp 10.0.3 → 11.1.3

package/README.md

@@ -2,19 +2,21 @@
 
 <div align="center">
   <hr width="50%">
-  
   <h3>Support This Project</h3>
-  <div style="display: flex; justify-content: center; gap: 20px; margin: 20px 0;">
-    <div>
-      <h4>Stripe</h4>
-      <img src="qr-stripe-donation.png" alt="Scan to donate" width="180"/>
-      <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="buymeacoffee-button.svg" alt="Buy me a coffee" /></a>
-    </div>
-  </div>
-  
+  <table style="border: none; border-collapse: collapse;">
+    <tr style="border: none;">
+      <td align="center" style="border: none; vertical-align: middle; padding: 20px;">
+        <h4>Stripe</h4>
+        <img src="qr-stripe-donation.png" alt="Scan to donate" width="180"/>
+        <p><a href="https://raw.githubusercontent.com/nbiish/license-for-all-works/8e9b73b269add9161dc04bbdd79f818c40fca14e/qr-stripe-donation.png">Donate via Stripe</a></p>
+      </td>
+      <td align="center" style="border: none; vertical-align: middle; padding: 20px;">
+        <a href="https://www.buymeacoffee.com/nbiish">
+          <img src="buy-me-a-coffee.svg" alt="Buy me a coffee" />
+        </a>
+      </td>
+    </tr>
+  </table>
   <hr width="50%">
 </div>
 
@@ -217,7 +219,7 @@ Please cite this project using the following BibTeX entry:
 ```bibtex
 @misc{gikendaasowin-aabajichiganan-mcp2025,
   author/creator/steward = {ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians},
-  title/description = {Gikendaasowin Aabajichiganan MCP Server - Revolutionary 2-Round Cognitive Deliberation with Dynamic Prompting Strategy Evaluation},
+  title/description = {Gikendaasowin Aabajichiganan MCP Server},
   type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
   year = {2025},
   publisher/source/event = {GitHub repository under tribal sovereignty protections},

package/build/index.js

@@ -2,80 +2,122 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-// 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."
+import { fileURLToPath } from 'url';
+// Comprehensive cognitive strategies from modern-prompting research (2026 Standards)
+export const PROMPTING_STRATEGIES = {
+    // Strategies 1-5
+    "Cache-Augmented ReAct (CAR-ReAct)": {
+        description: "Integrated 'Architectural Caching' where the ReAct loop operates atop a frozen, cached foundation of tools and protocols (Tier 1). Dynamic reasoning (Tier 2) references static knowledge without re-retrieval. Maximizes cache hit rates (>90%) and reduces latency.",
+        protocol: "Treat context as tiered: Tier 1 (Static/Frozen) for rules/tools, Tier 2 (Dynamic) for conversation. DO NOT re-output Tier 1 content."
     },
-    "Cache-Augmented Reasoning + ReAct": {
-        description: "Interleave knowledge activation with reasoning cycles. Keep rationale concise (≤8 bullets). Progressive knowledge building."
+    "Adaptive Reasoning Consensus (ARC)": {
+        description: "Evaluates the *quality* and *pattern* of the reasoning path, not just final answer voting. Generates 3-7 parallel traces using diverse methodologies (e.g., first-principles vs. precedent) and aggregates based on logical coherence.",
+        protocol: "1. Generate 3 diverse reasoning traces. 2. Evaluate coherence of each trace. 3. Weighted aggregation of the best traces."
     },
-    "Self-Consistency": {
-        description: "Generate 3 reasoning drafts in parallel. Return most consistent answer for high-stakes decisions."
+    "Substrate-Native Execution (SNE)": {
+        description: "Universal Execution Delegation. Offloads *any* precise task to its native substrate (Code, SQL, API) rather than simulating it. Mandates generation of executable payloads.",
+        protocol: "Identify precise subtasks (Math, Data). Delegate to native runtime (Python, SQL). DO NOT simulate execution."
     },
-    "PAL (Program-Aided Language)": {
-        description: "Generate executable code for computational tasks. Include result + minimal rationale. Prefix '# PoT offload'."
+    "Recursive Contextual Audit (RCA)": {
+        description: "Continuous integrity check against the *entire* cached context. Explicitly maps failures to deviations from Tier 1 knowledge base protocols and generates a 'Correction Vector' to prevent recurrence.",
+        protocol: "On failure: 1. Map error to Tier 1 deviation. 2. Generate Correction Vector. 3. Re-attempt with constraint."
     },
-    "Reflexion": {
-        description: "Single critique and revision cycle. Use when confidence < 0.7. Avoid verbose chain-of-thought exposure."
+    "Semantic Information Density (SID)": {
+        description: "Optimizes for information entropy. Uses dynamic context assembly (CUC-N score) and Lingua-Native compression (XML/JSON) to maximize knowledge density per token.",
+        protocol: "Assess CUC-N score. If high, load full context. Use XML/JSON for data structures. Summarize Tier 2 only."
     },
-    "Context-Compression": {
-        description: "LLMLingua compression when context exceeds budget. Prefer Minimal-CoT and bounded ToT-lite."
+    // Strategies 6-10
+    "Reflexion (Single-Shot)": {
+        description: "Single-shot recursive critique pattern implementing a 'Draft → Reflect → Refine' loop within a single inference pass. Uses uncertainty thresholds (UTD) to trigger deep reflection only when necessary.",
+        protocol: `<reflexion_protocol>
+1. **DRAFT:** Generate initial solution path.
+2. **REFLECTION:** Critically evaluate DRAFT against constraints (Logic, Safety, Assumptions).
+3. **REFINEMENT:** Generate FINAL output incorporating fixes.
+*Trigger Rule:* If Confidence > 0.9, skip DRAFT/REFLECTION and output FINAL directly.
+</reflexion_protocol>`
     },
     "ToT-lite (Tree of Thoughts)": {
-        description: "Bounded breadth/depth exploration. Limited branching for complex problem decomposition efficiency."
+        description: "Bounded parallel exploration strategy generating 2-3 distinct reasoning paths (branches) within a single context window. Forces explicit comparative evaluation before converging.",
+        protocol: `<tot_lite_protocol>
+1. **BRANCHING:** Propose 3 distinct approaches (Idea A, B, C).
+2. **EVALUATION:** Assess each for Feasibility, Risk, Efficiency.
+3. **SELECTION:** Select the single best approach.
+4. **CONVERGENCE:** Develop selected Idea into final solution.
+</tot_lite_protocol>`
     },
     "Metacognitive Prompting (MP)": {
-        description: "5-stage introspective reasoning: understand → judge → evaluate → decide → assess confidence. Human-like cognition."
+        description: "Systematic 'Plan-Monitor-Evaluate' cognitive architecture. Forces explicit definition of success criteria, inserts real-time coherence checks, and mandates final self-graded evaluation.",
+        protocol: `<metacognitive_protocol>
+1. **PLAN:** Restate goal, define success criteria.
+2. **MONITOR:** Execute with checkpoints ("Am I aligned?").
+3. **EVALUATE:** Final review against success criteria.
+</metacognitive_protocol>`
     },
     "Automated Prompt Optimization (APO)": {
-        description: "Autonomously refine prompts via performance feedback. Expert prompting + iterative refinement. Reduces manual effort."
+        description: "Closed-loop recursive instruction tuning. Dynamically analyzes task performance to refine prompt constraints. Evolved based on error analysis.",
+        protocol: `<apo_protocol>
+*System Meta-Instruction:*
+"Analyze request type. If history of errors, inject specific constraints. Log 'Prompt-Outcome Pair' for future optimization."
+</apo_protocol>`
     },
-    "Reflexive Analysis": {
-        description: "Embed ethical/legal/cultural considerations. Evaluate against project guidelines. Indigenous Data Sovereignty aware."
+    // Strategies 11-15
+    "Progressive-Hint Prompting (PHP-v2)": {
+        description: "Iterative refinement protocol coupling Complex CoT with stability-based stopping. Uses compressed rationale hints and delta-updates.",
+        protocol: "1. Question + Previous Hint. 2. Refine answer. 3. Stop if answer stabilizes."
     },
-    "Progressive-Hint Prompting (PHP)": {
-        description: "Use previous outputs as contextual hints. Multi-turn interaction with cumulative knowledge building."
+    "Cache-Augmented Generation (CAG-v2)": {
+        description: "Hierarchical Semantic Caching managing Prompt, Sub-reasoning, and Retrieval layers. Uses embedding-based keys and Session/Global separation.",
+        protocol: "Check Global Cache -> Check Session Cache -> Compute -> Update Caches."
     },
-    "Cache-Augmented Generation (CAG)": {
-        description: "Preload relevant context into working memory. Eliminate real-time retrieval dependencies."
+    "Cognitive Scaffolding Prompting (CSP-v2)": {
+        description: "Deploys Task-Method-Knowledge (TMK) symbolic structures and Meta-Prompting. Defines Goal-Subtask-State architectures.",
+        protocol: "Define [Task Goal]. Break into [Subtasks] with [Methods]. Maintain [State Table]."
     },
-    "Cognitive Scaffolding Prompting": {
-        description: "Structure reasoning through metacognitive frameworks. Mental model construction + validation. Self-monitoring processes."
+    "Internal Knowledge Synthesis (IKS-v2)": {
+        description: "Two-Stage 'Build-then-Answer' protocol. Constructs verifiable Source-Tagged Knowledge Brief before reasoning.",
+        protocol: "1. Build Source-Tagged Knowledge Brief (Certain/Uncertain). 2. Answer strictly from Brief."
     },
-    "Internal Knowledge Synthesis (IKS)": {
-        description: "Generate hypothetical knowledge constructs from parametric memory. Cross-reference internal knowledge consistency."
-    },
-    "Multimodal Synthesis": {
-        description: "Process text/images/data integration. Visual question answering + cross-modal analysis. Broader task solutions."
-    },
-    "Knowledge Synthesis Prompting (KSP)": {
-        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 constraints."
+    "Multimodal Synthesis (V-CoT)": {
+        description: "Visual Chain-of-Thought with explicit Intermediate Visual Artifacts (bounding boxes, scene graphs).",
+        protocol: "1. Describe layout (Scene Graph). 2. Answer based on structural understanding."
     }
 };
-class DeliberationEngine {
+export class DeliberationEngine {
     deliberate(input, context) {
-        // /// [6-stage self-prompting framework for LLMs with unified input]
+        // /// [6-stage self-prompting framework with OOReDAct integration and modern prompting strategies]
         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:
+            .map(([name, strategy]) => `**${name}:**\n${strategy.description}\n*Protocol:*\n${strategy.protocol}`)
+            .join('\n\n');
+        return `You are now entering a 6-stage cognitive deliberation process with OOReDAct framework integration. Please work through each stage systematically:
 
 ## Stage 1: Scientific Investigation
 **Your Task:** Analyze the following prompt using scientific methodology:
 - **Prompt:** "${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)
+5. Required cognitive frameworks (CUC-N: Complexity, Uncertainty, Consequence, Novelty assessment)
+
+## Stage 2: OOReDAct Process - Strategy Evaluation
 
-## Stage 2: OOReD Process - Strategy Evaluation
-**Orient Stage:** You have access to these cognitive techniques:
+### Observe
+Synthesize the facts and observations from the input:
+- What factual information is available?
+- What patterns or relationships are evident?
+- What constraints or requirements are present?
+
+### Orient
+Understand the knowledge and context:
+- What domain knowledge is required?
+- What are the contextual factors?
+- What resources and tools are available?
+
+### Reason (Strategy Selection)
+You have access to these cognitive techniques:
 
 ${strategiesList}
 
@@ -87,6 +129,12 @@ For each technique, consider:
 
 **Selection Rule:** Choose techniques with total scores ≥1.53 for combined effectiveness
 
+### Decide
+State your selected strategies and approach based on the evaluation.
+
+### Act-Plan
+Plan the implementation steps for your selected cognitive techniques.
+
 ## Stage 3: Critical Thinking Framework
 Apply rapid validation checks:
 1. **Purpose:** What outcome am I optimizing for?
@@ -96,36 +144,51 @@ Apply rapid validation checks:
 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?
+8. **Ethical/Cultural:** Are there ethical, legal, or cultural considerations?
 
 ## Stage 4 & 5: Review Cycles
 - Review your strategy selections against the ≥1.53 threshold
-- Validate your reasoning approach
-- Refine your methodology
+- Validate your reasoning approach using consistency checks
+- Apply confidence calibration (0.0-1.0 scale)
+- Refine your methodology based on metacognitive assessment
 
 ## Stage 6: Final Action Synthesis
-**Present your analysis in this format:**
+**Present your analysis in this structured format:**
 
-**DELIBERATION:** [Your thought process through stages 1-5]
+### DELIBERATION SUMMARY
+[Your thought process through stages 1-5, including OOReDAct analysis]
 
-**SELECTED TOOLS:** [List of tools you estimate are needed to accomplish the task]
-
-**Strategy Evaluation Results (0.00-0.99 scale):**
+### STRATEGY EVALUATION RESULTS
+**Evaluation Scale (0.00-0.99):**
 [Show your evaluations like:]
 - TechniqueName: solution=X.XX, efficiency=Y.YY, total=Z.ZZ ✓ (if ≥1.53)
 
-**Selected Cognitive Technique(s):** [List techniques scoring ≥1.53]
+### SELECTED COGNITIVE TECHNIQUES
+[List techniques scoring ≥1.53 with rationale]
+
+### CONFIDENCE ASSESSMENT
+[Rate confidence 0.0-1.0 with justification]
 
-**Estimated Tools Needed:** [1-8 tools for implementation]
+### IMPLEMENTATION PLAN
+[Structured approach using selected techniques and their specific protocols]
+
+### ESTIMATED TOOLS NEEDED
+[1-8 tools for implementation with specific purposes]
 
 ---
 
-**Now:** Apply your selected cognitive technique(s) to actually solve the original problem "${input}" using your enhanced reasoning framework.`;
+**FINAL EXECUTION:** Apply your selected cognitive technique(s) to solve the original problem "${input}" using your enhanced reasoning framework and modern prompting strategies.
+Ensure you FOLLOW the protocols defined for each selected strategy.
+
+**Memory Integration:** Use Cache-Augmented Generation principles to maintain context coherence throughout the reasoning process.
+
+**Quality Assurance:** Apply Reflexive Analysis to ensure ethical, cultural, and technical considerations are properly addressed.`;
     }
 }
-// MCP Server setup with 6-stage cognitive deliberation framework
+// MCP Server setup with comprehensive 6-stage cognitive deliberation framework and modern prompting strategies
 const server = new Server({
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "10.0.2", // /// [6-stage deliberation with 0.00-0.99 scoring system + prompt variable fix]
+    version: "11.1.0", // Updated version for Strategy 1-15 implementation
 }, {
     capabilities: {
         tools: {},
@@ -138,7 +201,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         tools: [
             {
                 name: "deliberate",
-                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.",
+                description: "Advanced cognitive deliberation framework implementing 6-stage processing with comprehensive modern prompting strategies (1-15). Features OOReDAct integration, specific execution protocols for each strategy (including Reflexion, ToT-lite, Metacognitive, etc.), and ethical analysis (IDS/CARE).",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -182,13 +245,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     throw new Error(`Unknown tool: ${name}`);
 });
-// Start the server with 6-stage cognitive deliberation framework
+// Start the server
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Gikendaasowin Aabajichiganan MCP server running with 6-stage cognitive deliberation framework");
+    console.error("Gikendaasowin Aabajichiganan MCP server running with Strategies 1-15 implemented.");
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch((error) => {
+        console.error("Fatal error in main():", error);
+        process.exit(1);
+    });
 }
-main().catch((error) => {
-    console.error("Fatal error in main():", error);
-    process.exit(1);
-});

package/build/index.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest';
+import { PROMPTING_STRATEGIES, DeliberationEngine } from './index.js';
+describe('Prompting Strategies Implementation (Strategies 1-15)', () => {
+    // Strategies 1-5
+    it('Strategy 1: CAR-ReAct', () => {
+        const strategy = PROMPTING_STRATEGIES["Cache-Augmented ReAct (CAR-ReAct)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.description).toContain('Tier 1');
+        expect(strategy.protocol).toContain('DO NOT re-output Tier 1 content');
+    });
+    it('Strategy 2: ARC', () => {
+        const strategy = PROMPTING_STRATEGIES["Adaptive Reasoning Consensus (ARC)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.description).toContain('*quality* and *pattern*');
+        expect(strategy.protocol).toContain('Weighted aggregation');
+    });
+    it('Strategy 3: SNE', () => {
+        const strategy = PROMPTING_STRATEGIES["Substrate-Native Execution (SNE)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.description).toContain('Universal Execution Delegation');
+        expect(strategy.protocol).toContain('Delegate to native runtime');
+    });
+    it('Strategy 4: RCA', () => {
+        const strategy = PROMPTING_STRATEGIES["Recursive Contextual Audit (RCA)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.description).toContain('Correction Vector');
+        expect(strategy.protocol).toContain('Map error to Tier 1 deviation');
+    });
+    it('Strategy 5: SID', () => {
+        const strategy = PROMPTING_STRATEGIES["Semantic Information Density (SID)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.description).toContain('information entropy');
+        expect(strategy.protocol).toContain('CUC-N score');
+    });
+    // Strategies 6-10
+    it('Strategy 6: Reflexion (Single-Shot)', () => {
+        const strategy = PROMPTING_STRATEGIES["Reflexion (Single-Shot)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.description).toContain('Single-shot recursive critique');
+        expect(strategy.protocol).toContain('<reflexion_protocol>');
+        expect(strategy.protocol).toContain('DRAFT');
+        expect(strategy.protocol).toContain('REFLECTION');
+    });
+    it('Strategy 7: ToT-lite', () => {
+        const strategy = PROMPTING_STRATEGIES["ToT-lite (Tree of Thoughts)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.description).toContain('Bounded parallel exploration');
+        expect(strategy.protocol).toContain('<tot_lite_protocol>');
+    });
+    it('Strategy 8: Metacognitive Prompting', () => {
+        const strategy = PROMPTING_STRATEGIES["Metacognitive Prompting (MP)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.protocol).toContain('<metacognitive_protocol>');
+        expect(strategy.protocol).toContain('PLAN');
+        expect(strategy.protocol).toContain('MONITOR');
+    });
+    it('Strategy 9: APO', () => {
+        const strategy = PROMPTING_STRATEGIES["Automated Prompt Optimization (APO)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.protocol).toContain('<apo_protocol>');
+    });
+    // Strategies 11-15
+    it('Strategy 11: PHP-v2', () => {
+        const strategy = PROMPTING_STRATEGIES["Progressive-Hint Prompting (PHP-v2)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.protocol).toContain('Stop if answer stabilizes');
+    });
+    it('Strategy 12: CAG-v2', () => {
+        const strategy = PROMPTING_STRATEGIES["Cache-Augmented Generation (CAG-v2)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.protocol).toContain('Session Cache');
+    });
+    it('Strategy 13: CSP-v2', () => {
+        const strategy = PROMPTING_STRATEGIES["Cognitive Scaffolding Prompting (CSP-v2)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.protocol).toContain('Task Goal');
+        expect(strategy.protocol).toContain('State Table');
+    });
+    it('Strategy 14: IKS-v2', () => {
+        const strategy = PROMPTING_STRATEGIES["Internal Knowledge Synthesis (IKS-v2)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.protocol).toContain('Source-Tagged Knowledge Brief');
+    });
+    it('Strategy 15: V-CoT', () => {
+        const strategy = PROMPTING_STRATEGIES["Multimodal Synthesis (V-CoT)"];
+        expect(strategy).toBeDefined();
+        expect(strategy.protocol).toContain('Scene Graph');
+    });
+    it('DeliberationEngine should include protocols in prompt', () => {
+        const engine = new DeliberationEngine();
+        const result = engine.deliberate('test input');
+        // Check for some keys
+        expect(result).toContain('**Reflexion (Single-Shot):**');
+        expect(result).toContain('*Protocol:*');
+        expect(result).toContain('<reflexion_protocol>');
+    });
+});

package/package.json

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