@nbiish/cognitive-tools-mcp 2.0.1 → 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,29 +1,21 @@
 #!/usr/bin/env node
 /**
  * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Agentic Cognitive Tools MCP Server (v2.0)
+ * Gikendaasowin Aabajichiganan - Agentic Cognitive Tools MCP Server (v3.2)
  *
- * Description: Provides cognitive tools for an AI agent based on the
- * Gikendaasowin Cognitive Framework (v7 Guidelines). Emphasizes
- * a mandatory structured deliberation cycle (Observe-Orient-Decide-Act)
- * performed *after* receiving information and *before* significant actions,
- * ideally using the `think` tool. Supports adaptive reasoning styles
- * (CoT, CoD/CRP, SCoT) and integrates with potentially dynamic toolsets,
- * including a preference for Executable Code Actions (CodeAct) if available.
- * 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 (v7 Alignment):
- * 1.  **Mandatory Deliberation:** A structured internal reasoning cycle is required
- * before non-trivial actions.
- * 2.  **Centralized Analysis (`think`):** The `think` tool is the preferred mechanism
- * for the mandatory deliberation cycle (analysis, planning, OODReAct structure).
- * 3.  **Adaptability:** Assumes the agent adapts to dynamically available tools.
- * 4.  **CodeAct Preference:** Aligns with agent preference for executable code actions.
- * 5.  **Adaptive Reasoning:** Supports CoT, CoD/CRP, SCoT styles within `think`.
- * 6.  **Traceability:** Logs tool usage; `think` tool provides reasoning trace.
- * 7.  **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";
@@ -32,11 +24,12 @@ import { z } from "zod";
 // --- Server Definition ---
 const serverInfo = {
     name: "gikendaasowin-agentic-cognitive-tools-mcp",
-    version: "2.0.0", // Version reflects alignment with v7 guidelines
-    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Agentic Cognitive Tools (v2.0): Implements Gikendaasowin v7 Guidelines. Facilitates mandatory Observe-Orient-Decide-Act deliberation cycle (using 'think' tool) before actions. Supports adaptive reasoning (CoT, CoD/CRP, SCoT) and dynamic tool environments (incl. CodeAct preference). Returns Markdown.`
+    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 ---
+// --- Logging Helpers (Internal - No changes needed) ---
 /**
  * Logs an incoming tool call to stderr.
  * @param toolName The name of the tool being called.
@@ -57,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.
@@ -67,121 +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, guiding towards the mandatory deliberation step
+    // **Refined Error Guidance:** Expanded acronyms on first mention here.
     return {
         content: [{
                 type: "text",
-                text: `Error executing tool '${toolName}': ${errorMessage}. **Action Required:** Initiate the mandatory deliberation cycle (use the 'think' tool if available) to analyze this error (Observe/Orient), review context/goals, and plan the next corrective step (Decide/Reason/Act(Plan)).`
+                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 (Aligned with v7 Guidelines) ---
+// --- Core Cognitive Deliberation & Refinement Steps (v3.2 - Expanded Acronyms) ---
 /**
- * Tool: assess_cuc_n_mode (Optional Initial Assessment)
- * Purpose: Optional initial assessment of task characteristics (Complexity, Uncertainty, Consequence, Novelty)
- * to *inform* the strategy for the mandatory deliberation cycle.
- * Workflow: Can be called *optionally* at the start of complex tasks to help frame the initial approach.
- * The primary, mandatory deliberation happens *later* using `think` or internally.
- * Output: Returns the 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", "**(Optional) Initial Task Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to *inform* the initial strategy. Call optionally before complex tasks. This assessment helps frame the mandatory deliberation cycle (which uses `think` or occurs internally) but does *not* replace it. Output is your assessment.", {
-    assessment_text: z.string().describe("Your structured CUC-N assessment including: 1) Situation/Task Summary, 2) CUC-N Analysis (Low/Medium/High rationale), 3) Potential Strategy Considerations (e.g., 'Requires careful step-by-step planning via CoT', 'Efficiency via CoD/CRP seems appropriate', 'Need to prioritize CodeAct for file manipulation'). This informs, but does not dictate, the mandatory deliberation step.")
-}, async ({ assessment_text }) => {
-    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 {
-        if (assessment_text.trim().length === 0) {
-            throw new Error('Invalid assessment_text: Must be a non-empty string containing the CUC-N analysis.');
+        if (assessment_and_orientation_text.trim().length === 0) {
+            throw new Error('Invalid input: Must provide a non-empty CUC-N assessment and orientation.');
+        }
+        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, `Assessment logged (length: ${assessment_text.length})`);
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${assessment_text}`);
-        // Return the assessment text directly
-        return {
-            content: [{
-                    type: "text",
-                    text: assessment_text
-                }]
-        };
+        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 (Mandatory Deliberation Hub)
- * Purpose: The **PREFERRED & CENTRAL HUB** for the **MANDATORY** structured deliberation cycle
- * (Observe-Orient-Decide-Act).
- * Workflow: **MUST** be called (if available) *after* receiving new information (tool results, CodeAct output/errors,
- * USER input, file reads) and *before* executing any non-trivial action (tool call, CodeAct execution,
- * complex response generation). Use it to analyze inputs, orient context/goals/policies, decide the next
- * action, reason (CoT, CoD/CRP, SCoT), plan the action details (tool params, CodeAct code), define
- * verification, and consider risks. Essential for reliability, error handling, and complex tasks.
- * Output: Returns the structured thought process itself, formatted as Markdown, serving as an internal log.
+ * 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", "**Mandatory Deliberation Hub.** Use this tool (if available) for the required structured deliberation cycle *after* info and *before* action. Input MUST follow the OODReAct structure: ## Observe (analyze inputs/results/errors), ## Orient (context/goals/policy check), ## Decide (next action: tool, CodeAct, query, respond), ## Reason (justify decision; use CoT, CoD/CRP, or SCoT style), ## Act (Plan) (tool params, CodeAct code, response draft), ## Verification (success criteria), ## Risk & Contingency (briefly).", {
-    thought: z.string().describe("Your **structured OODReAct deliberation**. MUST include all sections: Observe, Orient, Decide, Reason (using appropriate CoT/CoD/CRP/SCoT style), Act(Plan) (with specific tool parameters or CodeAct code), Verification, Risk & Contingency. This is critical for documenting the mandatory reasoning process before acting.")
+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 {
-        // Basic validation: Check if it's non-empty and maybe contains expected markers
         if (thought.trim().length === 0) {
-            throw new Error('Invalid thought: Must be a non-empty string.');
+            throw new Error('Invalid thought: Input cannot be empty.');
         }
-        if (!thought.includes("## Observe:") || !thought.includes("## Orient:") || !thought.includes("## Decide:") || !thought.includes("## Reason:") || !thought.includes("## Act (Plan):")) {
-            throw new Error('Invalid thought structure: Must contain required OODReAct sections (Observe, Orient, Decide, Reason, Act(Plan)).');
+        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, `Deliberation logged (length: ${thought.length})`);
         console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${thought}`);
-        // Return the thought process itself as the result
-        return {
-            content: [{
-                    type: "text",
-                    text: thought
-                }]
-        };
+        return { content: [{ type: "text", text: thought }] };
     }
     catch (error) {
         return logToolError(toolName, error);
     }
 });
 /**
- * Tool: quick_think (Minimal Cognitive Step - Use With Extreme Caution)
- * Purpose: A minimal cognitive step ONLY for acknowledging *trivial*, *immediately obvious* successes or state transitions.
- * Workflow: **STRONGLY DISCOURAGED.** Use ONLY if the mandatory deliberation cycle (`think` or internal) is genuinely unnecessary
- * because the situation involves absolutely no analysis, planning, policy check, error handling, or complex reasoning.
- * Example: Confirming receipt of simple data before an already-planned trivial action.
- * **DO NOT USE** after most tool calls, CodeAct executions, or before any complex action - use `think` instead.
- * 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", "**(Use Sparingly/Discouraged) Minimal Cognitive Step.** Use ONLY for acknowledging *trivial successes* or confirming *obvious, pre-planned* simple steps where NO analysis/planning/policy check is needed (e.g., 'Data received, proceeding with planned step X'). **The mandatory deliberation cycle (`think` tool or internal) is required for almost all situations.** Prefer `think` after any tool/CodeAct output or error.", {
-    brief_thought: z.string().describe("Your **extremely concise** confirmation for a truly trivial step (e.g., 'Trivial action X succeeded'). Must be non-empty but very short. DO NOT use for analysis, planning, error reflection, or complex reasoning - use the `think` tool for the mandatory deliberation cycle.")
+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.");
         }
-        // Optional stricter length check to enforce brevity
-        if (brief_thought.length > 150) { // Example limit
-            console.error(`[${new Date().toISOString()}] [MCP Server] WARNING: 'quick_think' input is long. Ensure 'think' wasn't more appropriate.`);
+        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.`);
         }
         logToolResult(toolName, true, `Logged: ${brief_thought.substring(0, 80)}...`);
         console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${brief_thought}`);
-        // Return the 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 ---
+// --- Server Lifecycle and Error Handling (Internal - No changes needed) ---
 /**
  * Gracefully shuts down the server.
  */
@@ -204,14 +196,14 @@ process.on('SIGTERM', shutdown);
 process.on('uncaughtException', (error, origin) => {
     const timestamp = new Date().toISOString();
     console.error(`[${timestamp}] [MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
-    shutdown().catch(() => process.exit(1)); // Attempt graceful shutdown
+    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);
-    shutdown().catch(() => process.exit(1)); // Attempt graceful shutdown
+    shutdown().catch(() => process.exit(1));
 });
-// --- Start the Server ---
+// --- Start the Server (Internal - No changes needed) ---
 /**
  * Initializes and starts the MCP server.
  */
@@ -221,9 +213,9 @@ async function main() {
         await server.connect(transport);
         const border = '=====================================================';
         console.error(border);
-        console.error(` ${serverInfo.description}`);
+        console.error(` ${serverInfo.description}`); // Uses updated description
         console.error(` Version: ${serverInfo.version}`);
-        console.error(` Aligned with Gikendaasowin v7 Agentic Guidelines`);
+        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": "2.0.1",
+  "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",