@nbiish/cognitive-tools-mcp 0.9.30 → 2.0.2

package/README.md

@@ -34,7 +34,7 @@ Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimi
 
 This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS](LICENSE).
 
-ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - Cognitive Tools MCP: SOTA reasoning suite focused on iterative refinement and tool integration for AI Pair Programming. Enables structured, iterative problem-solving through Chain of Draft methodology, with tools for draft generation, analysis, and refinement. Features include advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment (`assess_cuc_n_mode`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection.
+ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Agentic Cognitive Tools (v3.2): Implements Gikendaasowin v7 Guidelines. Enforces MANDATORY internal **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle: Starts with 'assess_and_orient', continues with 'think' deliberation before actions. Guides adaptive reasoning (**Chain-of-Thought (CoT)**, **Chain-of-Draft/Condensed Reasoning (CoD/CR)**, **Structured Chain-of-Thought (SCoT)**) & CodeAct preference. Returns Markdown.
 
 Known as:
 - Anishinaabemowin: [`@nbiish/gikendaasowin-aabajichiganan-mcp`](https://www.npmjs.com/package/@nbiish/gikendaasowin-aabajichiganan-mcp)

package/build/index.js

@@ -1,27 +1,21 @@
 #!/usr/bin/env node
 /**
  * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server (v1.2 - Generalized)
+ * Gikendaasowin Aabajichiganan - Agentic Cognitive Tools MCP Server (v3.2)
  *
- * Description: Provides a streamlined suite of cognitive tools for an AI agent,
- *              inspired by research on improving LLM reasoning (like Anthropic's 'think' tool)
- *              applicable across domains (coding, research, planning, etc.).
- *              Focuses on assessment (`assess_cuc_n_mode`) and a central deliberation
- *              hub (`think`) used especially after receiving information/results.
- *              `quick_think` is for trivial steps. CoT/CoD reasoning styles occur within `think`.
- *              Returns Markdown.
+ * Description: Provides cognitive tools implementing the Gikendaasowin v7
+ * Agentic Operational Guidelines. Enforces a mandatory structured
+ * deliberation cycle, **Observe-Orient-Reason-Decide-Act (OOReDAct)**, via
+ * internal cognitive steps, initiated by mandatory assessment/orientation.
+ * Guides adaptive reasoning using techniques like **Chain-of-Thought (CoT)**,
+ * **Chain-of-Draft/Condensed Reasoning (CoD/CR)**, and **Structured
+ * Chain-of-Thought (SCoT)**. Aligns with dynamic tool environments,
+ * including CodeAct preference. Returns Markdown.
  *
- * Key Principles:
- * 1.  **Structured Deliberation:** Tools guide assessment (`assess_cuc_n_mode`) and
- *     thinking/analysis (`think`, `quick_think`).
- * 2.  **Centralized Analysis (`think`):** The `think` tool is the hub for analysis (results, errors),
- *     planning, reflection, policy checks, and reasoning (CoT/CoD). **Crucially used after info/results.**
- * 3.  **CUC-N Assessment:** `assess_cuc_n_mode` guides initial cognitive depth choice.
- * 4.  **Iterative Loop:** Assess -> [Action/Tool] -> Analyze Result/State (`think`) -> Plan (`think`) -> [Execute].
- * 5.  **Traceability & Reliability:** Tool inputs logged; structured thinking enhances reliability across tasks.
- * 6.  **Markdown Output:** Tool results formatted as Markdown.
- *
- * Protocol:    Model Context Protocol (MCP) over stdio.
+ * v3.2 Enhancements:
+ * - Expanded cognitive technique acronyms (OOReDAct, CoT, CoD/CR, SCoT)
+ *   with brief explanations on first use in descriptions.
+ * - Maintained internal system prompt framing.
  * -----------------------------------------------------------------------------
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -29,13 +23,13 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 // --- Server Definition ---
 const serverInfo = {
-    name: "gikendaasowin-aabajichiganan-mcp",
-    version: "1.2.0", // Incremented version
-    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools (Generalized v1.2): Focuses on Assess/Think loop, using 'think' for post-result/state analysis across domains (code, research, etc.) to improve reliability. CoT/CoD integrated into 'think'. Returns Markdown.`
+    name: "gikendaasowin-agentic-cognitive-tools-mcp",
+    version: "3.2.0", // Version reflects acronym expansion
+    // Updated description with expanded acronyms
+    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Agentic Cognitive Tools (v3.2): Implements Gikendaasowin v7 Guidelines. Enforces MANDATORY internal **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle: Starts with 'assess_and_orient', continues with 'think' deliberation before actions. Guides adaptive reasoning (**Chain-of-Thought (CoT)**, **Chain-of-Draft/Condensed Reasoning (CoD/CR)**, **Structured Chain-of-Thought (SCoT)**) & CodeAct preference. Returns Markdown.`
 };
 const server = new McpServer(serverInfo);
-// --- Logging Helpers ---
-// [Keep existing logToolCall, logToolResult, logToolError functions]
+// --- Logging Helpers (Internal - No changes needed) ---
 /**
  * Logs an incoming tool call to stderr.
  * @param toolName The name of the tool being called.
@@ -56,7 +50,8 @@ function logToolResult(toolName, success, resultDetails) {
     console.error(`[${timestamp}] [MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
 }
 /**
- * Logs an error during tool execution and formats a standard error response for the LLM.
+ * Logs an error during tool execution and formats a standard error response for the LLM,
+ * guiding towards the mandatory internal deliberation cycle with expanded acronyms on first use.
  * @param toolName The name of the tool where the error occurred.
  * @param error The error object or message.
  * @returns An object matching the required MCP tool result structure containing the error message.
@@ -66,111 +61,119 @@ function logToolError(toolName, error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     console.error(`[${timestamp}] [MCP Server] ! Tool Error: ${toolName} - ${errorMessage}`);
     logToolResult(toolName, false, errorMessage); // Log failure result as well
-    // Return a structured error message suitable for the LLM
+    // **Refined Error Guidance:** Expanded acronyms on first mention here.
     return {
         content: [{
                 type: "text",
-                text: `Error executing tool '${toolName}': ${errorMessage}. Use the 'think' tool to analyze this error, check context, and plan the next step.` // Enhanced suggestion
+                text: `**INTERNAL ERROR during '${toolName}':** ${errorMessage}\n\n**CORRECTIVE ACTION REQUIRED:** You MUST now perform the full **Observe-Orient-Reason-Decide-Act (OOReDAct)** deliberation cycle to address this error. Structure your thinking with: 1. **Observe** this error message. 2. **Orient** by analyzing the error in context of the goal and previous steps. 3. **Reason** about potential causes and solutions (use adaptive reasoning: **Chain-of-Thought (CoT)** for detailed steps, **Chain-of-Draft/Condensed Reasoning (CoD/CR)** for efficient summaries, or **Structured Chain-of-Thought (SCoT)** for plans/code, as appropriate). 4. **Decide** on the *single best* corrective action (e.g., retry, modify parameters, use different tool/CodeAct, ask USER). 5. **Act(Plan)** the exact parameters or code for the correction. 6. Define **Verification** and **Risk/Contingency**.`
             }]
     };
 }
-// --- Core Cognitive Deliberation & Refinement Tools ---
+// --- Core Cognitive Deliberation & Refinement Steps (v3.2 - Expanded Acronyms) ---
 /**
- * Tool: assess_cuc_n_mode
- * Purpose: Initial assessment of task characteristics to guide cognitive strategy selection.
- * Workflow: Call BEFORE starting complex tasks or significantly changing strategy.
- * Output: Returns the full assessment text formatted as Markdown.
+ * Step: assess_and_orient (Mandatory Initial Assessment & Orientation)
+ * Purpose: **Mandatory first step** for every new user request AND before any significant strategic pivot.
+ * Establishes initial context by assessing task characteristics (Complexity, Uncertainty, Consequence, Novelty - CUC-N)
+ * and performing the initial Observe/Orient steps of the **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle.
+ * Workflow: **Perform this step** at the beginning of processing a user request or when changing overall approach.
+ * Its output informs the *first* full OOReDAct cycle (`think` step).
+ * Output: The assessment and initial orientation text formatted as Markdown.
  */
-server.tool("assess_cuc_n_mode", "**Initial Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to guide cognitive strategy. Call before complex tasks (coding, research, multi-step plans). Based on assessment, explicitly select and state whether the next step requires the detailed `think` tool (for analysis, planning, complex results) or the minimal `quick_think` tool (for trivial steps only).", {
-    assessment_and_choice: z.string().describe("Your structured assessment including: 1) Situation/Task Description, 2) CUC-N Ratings (Low/Medium/High for each), 3) Rationale, 4) Recommended Cognitive Strategy (e.g., 'Requires careful step-by-step planning'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
-}, async ({ assessment_and_choice }) => {
-    const toolName = 'assess_cuc_n_mode';
+server.tool("assess_and_orient", 
+// **Internal Framing:** Expanded OOReDAct on first mention.
+"**Mandatory Initial Assessment & Orientation:** At the start of EVERY user request AND before any major change in strategy, you MUST perform this initial assessment and orientation. Analyze the request/situation using CUC-N (Complexity, Uncertainty, Consequence, Novelty) to perform the initial 'Observe' and 'Orient' steps of the **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle. This assessment is CRITICAL for grounding your subsequent reasoning and planning within the main OOReDAct cycle.", {
+    assessment_and_orientation_text: z.string().describe("Provide your structured CUC-N assessment and initial Orientation. MUST include: 1) Task/Situation Summary (Observe). 2) CUC-N Analysis (Rationale for Low/Medium/High ratings). 3) Initial Orientation (Contextualize task based on CUC-N, goals, constraints, available tools/knowledge; identify key challenges/unknowns). 4) Strategic Implications (How CUC-N influences the approach, e.g., 'High consequence requires rigorous verification in subsequent OOReDAct cycles', 'High uncertainty suggests iterative refinement').")
+}, async ({ assessment_and_orientation_text }) => {
+    const toolName = 'assess_and_orient';
     logToolCall(toolName);
     try {
-        const modeRegex = /Selected Mode: (think|quick_think)/i;
-        const modeMatch = assessment_and_choice.match(modeRegex);
-        const selectedMode = modeMatch ? modeMatch[1].toLowerCase() : "unknown";
-        if (assessment_and_choice.trim().length === 0) {
-            throw new Error('Invalid assessment_and_choice: Must be a non-empty string.');
+        if (assessment_and_orientation_text.trim().length === 0) {
+            throw new Error('Invalid input: Must provide a non-empty CUC-N assessment and orientation.');
         }
-        if (!modeMatch) {
-            throw new Error('Invalid assessment: String must include explicit "Selected Mode: think" or "Selected Mode: quick_think".');
+        if (!assessment_and_orientation_text.includes("CUC-N Analysis") || !assessment_and_orientation_text.includes("Initial Orientation")) {
+            console.warn(`[${new Date().toISOString()}] [MCP Server] WARNING: '${toolName}' input may be missing key sections (CUC-N Analysis, Initial Orientation). Ensure full assessment.`);
         }
-        logToolResult(toolName, true, `Selected mode (extracted): ${selectedMode}`);
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${assessment_and_choice}`);
-        return {
-            content: [{
-                    type: "text",
-                    text: assessment_and_choice
-                }]
-        };
+        logToolResult(toolName, true, `Assessment & Orientation logged (length: ${assessment_and_orientation_text.length})`);
+        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${assessment_and_orientation_text}`);
+        return { content: [{ type: "text", text: assessment_and_orientation_text }] };
     }
     catch (error) {
         return logToolError(toolName, error);
     }
 });
 /**
- * Tool: think
- * Purpose: The **CENTRAL HUB** for structured reasoning, analysis, and planning across all complex tasks.
- * Workflow: Use this tool to **stop and think** *after* receiving information (tool results, calculations, user input, file content) or *before* taking a complex action (generating code, calling critical tools, formulating multi-part answers). Analyze inputs/results, check goals/policies/constraints, verify state, plan next steps, brainstorm, and perform detailed reasoning (CoT/CoD). Essential for reliability, error handling, and managing sequential tasks.
- * Output: Returns the structured thought text itself, formatted as Markdown.
+ * Step: think (Mandatory OOReDAct Deliberation Cycle)
+ * Purpose: The **REQUIRED & CENTRAL cognitive process** for the **MANDATORY** structured deliberation cycle
+ * (**Observe-Orient-Reason-Decide-Act (OOReDAct)**).
+ * Workflow: **You MUST perform this full, structured OOReDAct cycle** *after* the initial `assess_and_orient` step,
+ * *after* receiving subsequent new information (tool results, CodeAct output/errors, USER input, file reads),
+ * and *before* executing any non-trivial action or providing a final response. Use it to rigorously follow the OOReDAct
+ * structure, document reasoning (adapting reasoning styles like **Chain-of-Thought (CoT)**, **Chain-of-Draft/Condensed Reasoning (CoD/CR)**,
+ * or **Structured Chain-of-Thought (SCoT)** as needed), decide the next step, and plan actions precisely.
+ * Output: The structured thought process itself (Markdown), serving as your verifiable internal reasoning log.
  */
-server.tool("think", "**Central Hub for Analysis, Planning & Reasoning.** Use this tool to **stop and think**, especially *after* receiving information (tool results, errors, data) or before complex actions (coding, critical decisions). Analyze inputs/results, check goals/policies, verify information, plan next steps, and perform detailed reasoning (CoT/CoD) as needed. Crucial for reliability in coding, research, planning, and error recovery. Structure thought using clear headings (see prompt examples).", {
-    thought: z.string().describe("Your **structured** internal deliberation. MUST follow prompt guidance (Observe, Orient, Decide, Reason, Act, etc.). Include analysis of information/results, context/goal/policy checks, planning, and rationale (CoT/CoD). Crucial for complex tasks.")
+server.tool("think", 
+// **Internal Framing:** Expanded OOReDAct, CoT, CoD/CR, SCoT on first mention in this tool's description.
+"**Mandatory OOReDAct Deliberation Cycle:** You MUST perform the full, structured **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle *after* the initial `assess_and_orient` step, *after* receiving new information (tool/CodeAct results, errors, USER input), and *before* any non-trivial action or final response. Follow the complete OOReDAct structure, adapting your reasoning style within the 'Reason' step (e.g., using detailed **Chain-of-Thought (CoT)** for complexity, concise **Chain-of-Draft/Condensed Reasoning (CoD/CR)** for efficiency, or **Structured Chain-of-Thought (SCoT)** for planning/code) for reliable, verifiable, and adaptive behavior.", {
+    // **Internal Framing:** Expanded acronyms with explanations in the input description.
+    thought: z.string().describe("Provide your **complete, structured OOReDAct deliberation**. MUST include ALL sections: ## Observe (Analyze latest inputs/results/errors objectively), ## Orient (Contextualize vs goal/policy/prior state/assessment), ## Reason (Justify decision; adapt reasoning style: use **Chain-of-Thought (CoT)** for detailed, step-by-step derivation when complexity is high; use **Chain-of-Draft/Condensed Reasoning (CoD/CR)** for a more concise, high-signal summary when appropriate; use **Structured Chain-of-Thought (SCoT)** for outlining plans or generating structured code), ## Decide (Single, immediate next action: specific tool call, CodeAct execution, query USER, final response), ## Act (Plan) (Detail execution: EXACT tool params per current schema, OR complete runnable CodeAct Python snippet, OR precise response draft), ## Verification (Expected outcome/success criteria for *this* step), ## Risk & Contingency (Brief fallback if verification fails).")
 }, async ({ thought }) => {
     const toolName = 'think';
     logToolCall(toolName);
     try {
         if (thought.trim().length === 0) {
-            throw new Error('Invalid thought: Must be a non-empty string containing substantive reasoning, following the prompted structure.');
+            throw new Error('Invalid thought: Input cannot be empty.');
+        }
+        const requiredSections = ["## Observe", "## Orient", "## Reason", "## Decide", "## Act (Plan)", "## Verification", "## Risk & Contingency"];
+        const missingSections = requiredSections.filter(section => !thought.includes(section));
+        if (missingSections.length > 0) {
+            throw new Error(`Invalid thought structure: Missing required OOReDAct section(s): ${missingSections.join(', ')}. You must provide the complete deliberation.`);
         }
-        logToolResult(toolName, true, `Thought logged (length: ${thought.length})`);
+        logToolResult(toolName, true, `Deliberation logged (length: ${thought.length})`);
         console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${thought}`);
-        return {
-            content: [{
-                    type: "text",
-                    text: thought
-                }]
-        };
+        return { content: [{ type: "text", text: thought }] };
     }
     catch (error) {
         return logToolError(toolName, error);
     }
 });
 /**
- * Tool: quick_think
- * Purpose: A minimal cognitive step for trivial actions or confirmations.
- * Workflow: Use ONLY for acknowledging *trivial* successes, simple variable passing, or confirming *immediately obvious* next steps where NO analysis, planning, policy check, or complex reasoning (handled by `think`) is needed. Use sparingly; prefer `think` for analyzing any tool output, error, or planning non-trivial actions.
- * Output: Returns the brief thought text, formatted as Markdown.
+ * Step: quick_think (Minimal Cognitive Acknowledgement)
+ * Purpose: For acknowledging *simple, expected, non-problematic* outcomes ONLY, where the next step is
+ * *already clearly defined* by a prior **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle (`think` step)
+ * and requires NO re-evaluation or adaptation.
+ * Workflow: Use sparingly to maintain cognitive flow in straightforward sequences. **Does NOT replace the mandatory OOReDAct cycle**.
+ * The full OOReDAct cycle (`think` step) is MANDATORY for handling new information, errors, planning changes,
+ * or any step requiring analysis or decision-making.
+ * Output: The brief acknowledgement text (Markdown).
  */
-server.tool("quick_think", "**Minimal Cognitive Step (Use Sparingly!).** Use ONLY for acknowledging *trivial* successes or confirming *obvious* next steps where NO analysis, planning, or policy check is needed (e.g., 'Action X succeeded, proceeding to Y'). All substantive analysis, error handling, planning, and reasoning (CoT/CoD) belongs in the `think` tool. Prefer `think` after most tool calls or before complex actions.", {
-    brief_thought: z.string().describe("Your **extremely concise** confirmation or trivial thought (e.g., 'Tool success, continue', 'Passing ID to next step'). Must be non-empty but very short. Do NOT use for analysis or planning.")
+server.tool("quick_think", 
+// **Internal Framing:** Expanded OOReDAct on first mention here.
+"**Minimal Cognitive Acknowledgement:** Use ONLY for acknowledging *simple, expected, non-problematic* outcomes (e.g., 'Data fetch OK, proceeding with planned analysis') where the next step is *already determined* by a prior **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle (`think` step) and needs NO re-evaluation. Helps maintain flow in simple sequences. **This step DOES NOT satisfy the mandatory OOReDAct deliberation requirement.** Perform the full OOReDAct cycle (`think` step) for any analysis, planning, reasoning, error handling, or decision making.", {
+    // **Internal Framing:** Expanded OOReDAct on first mention here.
+    brief_thought: z.string().describe("Provide your **extremely concise** acknowledgement for a genuinely trivial step (max ~15 words recommended, e.g., 'Step X succeeded as expected.'). Must be non-empty. **Do NOT use this for ANY analysis, planning, reasoning, decision-making, or error handling** - perform the full **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle (`think` step) instead.")
 }, async ({ brief_thought }) => {
     const toolName = 'quick_think';
     logToolCall(toolName);
     try {
         if (brief_thought.trim().length === 0) {
-            throw new Error('Invalid brief_thought: Must be a non-empty string.');
+            throw new Error('Invalid brief_thought: Must be non-empty.');
+        }
+        if (brief_thought.includes("##")) {
+            throw new Error("Invalid brief_thought: Cannot contain '##' sections. Use the full OOReDAct cycle (`think` step) for structured deliberation.");
+        }
+        if (brief_thought.length > 100) {
+            console.warn(`[${new Date().toISOString()}] [MCP Server] WARNING: 'quick_think' input is long (${brief_thought.length} chars). Confirm this step was truly trivial and required no OOReDAct deliberation.`);
         }
-        // Optional: Add a length check if you want to enforce brevity strictly
-        // if (brief_thought.length > 100) { // Example limit
-        // 	throw new Error('Invalid brief_thought: Input is too long for quick_think. Use think tool for detailed reasoning.');
-        // }
         logToolResult(toolName, true, `Logged: ${brief_thought.substring(0, 80)}...`);
         console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${brief_thought}`);
-        return {
-            content: [{
-                    type: "text",
-                    text: brief_thought
-                }]
-        };
+        return { content: [{ type: "text", text: brief_thought }] };
     }
     catch (error) {
         return logToolError(toolName, error);
     }
 });
-// --- Server Lifecycle and Error Handling ---
-// [Keep existing shutdown, process event handlers, main function]
+// --- Server Lifecycle and Error Handling (Internal - No changes needed) ---
 /**
  * Gracefully shuts down the server.
  */
@@ -186,21 +189,21 @@ async function shutdown() {
         process.exit(1);
     }
 }
+// Setup signal handlers
 process.on('SIGINT', shutdown);
 process.on('SIGTERM', shutdown);
+// Setup global error handlers
 process.on('uncaughtException', (error, origin) => {
     const timestamp = new Date().toISOString();
     console.error(`[${timestamp}] [MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
-    // Attempt graceful shutdown, but exit quickly if it fails
     shutdown().catch(() => process.exit(1));
 });
 process.on('unhandledRejection', (reason, promise) => {
     const timestamp = new Date().toISOString();
     console.error(`[${timestamp}] [MCP Server] FATAL: Unhandled Promise Rejection:`, reason);
-    // Attempt graceful shutdown, but exit quickly if it fails
     shutdown().catch(() => process.exit(1));
 });
-// --- Start the Server ---
+// --- Start the Server (Internal - No changes needed) ---
 /**
  * Initializes and starts the MCP server.
  */
@@ -208,10 +211,11 @@ async function main() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        const border = '-----------------------------------------------------';
+        const border = '=====================================================';
         console.error(border);
-        console.error(` ${serverInfo.description}`);
+        console.error(` ${serverInfo.description}`); // Uses updated description
         console.error(` Version: ${serverInfo.version}`);
+        console.error(` Enforcing Gikendaasowin v7 Guidelines with Internal OOReDAct Cycle`);
         console.error(' Status: Running on stdio, awaiting MCP requests...');
         console.error(border);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "0.9.30",
+  "version": "2.0.2",
   "description": "Cognitive Tools MCP: SOTA reasoning suite focused on iterative refinement and tool integration for AI Pair Programming. Enables structured, iterative problem-solving through Chain of Draft methodology, with tools for draft generation, analysis, and refinement. Features advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment & thought mode selection (`assess_cuc_n_mode`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection with content return. Alternative package name for gikendaasowin-aabajichiganan-mcp.",
   "private": false,
   "type": "module",