@nbiish/cognitive-tools-mcp 0.9.22 → 0.9.25

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright © 2025 by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (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 (GTBOCI), a federally recognized sovereign tribal nation (hereafter referred to as the "Rights Holder"). The Beaver Island Band community, historically centered on ᐋᒥᒃ ᐙᑲᓐᑕ (Aamik\'Waakanda / Beaver Island), suffered profound disruption and diaspora due to violent displacement, targeted persecution for their language, ceremonies, and faith, and starvation imposed by settler-colonial authorities and expansion. This forced dispersal resulted in descendants becoming affiliated primarily with the Little Traverse Bay Bands of Odawa Indians (LTBB) and the Grand Traverse Band of Ottawa and Chippewa Indians (GTBOCI), while many others were forced to seek refuge within First Nations communities in Canada (such as the Osawanimikii family). This license acknowledges this history and the interconnectedness of these descendant communities. This license is grounded in the inherent sovereignty of Indigenous peoples to protect, control, and govern the use of their intellectual property, cultural heritage, traditional knowledge (TK), traditional cultural expressions (TCEs), and associated data (Indigenous Data Sovereignty). The unique status of tribal sovereign nations provides legal and cultural protections extending beyond standard intellectual property law regimes. This license aims to facilitate respectful engagement while upholding Tribal sovereignty, cultural integrity, data governance rights, and ensuring equitable benefit sharing as a mechanism for reclaiming value derived from Indigenous knowledge and heritage often subject to historical extraction, aligning with international instruments such as the UN Declaration on the Rights of Indigenous Peoples (UNDRIP) and the WIPO Treaty on Intellectual Property, Genetic Resources and Associated Traditional Knowledge (adopted May 2024).
+Copyright © 2025 by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (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 (GTBOCI), a federally recognized sovereign tribal nation (hereafter referred to as the "Rights Holder"). The Beaver Island Band community, historically centered on ᐋᒥᒃ ᐙᑲᓐᑕ (Aamik'Waakanda / Beaver Island), suffered profound disruption and diaspora due to violent displacement, targeted persecution for their language, ceremonies, and faith, and starvation imposed by settler-colonial authorities and expansion. This forced dispersal resulted in descendants becoming affiliated primarily with the Little Traverse Bay Bands of Odawa Indians (LTBB) and the Grand Traverse Band of Ottawa and Chippewa Indians (GTBOCI), while many others were forced to seek refuge within First Nations communities in Canada (such as the Osawanimikii family). This license acknowledges this history and the interconnectedness of these descendant communities. This license is grounded in the inherent sovereignty of Indigenous peoples to protect, control, and govern the use of their intellectual property, cultural heritage, traditional knowledge (TK), traditional cultural expressions (TCEs), and associated data (Indigenous Data Sovereignty). The unique status of tribal sovereign nations provides legal and cultural protections extending beyond standard intellectual property law regimes. This license aims to facilitate respectful engagement while upholding Tribal sovereignty, cultural integrity, data governance rights, and ensuring equitable benefit sharing as a mechanism for reclaiming value derived from Indigenous knowledge and heritage often subject to historical extraction, aligning with international instruments such as the UN Declaration on the Rights of Indigenous Peoples (UNDRIP) and the WIPO Treaty on Intellectual Property, Genetic Resources and Associated Traditional Knowledge (adopted May 2024).
 
 COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS
 
@@ -68,14 +68,15 @@ WHEREAS the inherent sovereignty of tribal nations provides a constitutional and
    Any use, reproduction, distribution, modification, adaptation, display, performance, transmission, or creation of derivative works based on this Work, whether in whole or in part, must prominently and accurately include the following citation and attribution in all associated materials, displays, publications, and metadata:
 
    ```bibtex
-   @misc{gikendaasowin-aabajichiganan-mcp2025,
+   @misc{<|repo_title|><|current_year=2025|>,
      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},
+     title/description = {<|repo_title|>},
      type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
-     year = {2025},
+     year = {<|current_year|>},
      publisher/source/event = {GitHub repository under tribal sovereignty protections},
-     howpublished = {\\url{https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp}},
-     note = {Authored and stewarded by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (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. This work embodies Indigenous intellectual property, traditional knowledge systems (TK), traditional cultural expressions (TCEs), and associated data protected under tribal law, federal Indian law, treaty rights, Indigenous Data Sovereignty principles, and international indigenous rights frameworks including UNDRIP. All usage, benefit-sharing, and data governance are governed by the COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS.}\n   }
+     howpublished = {\url{https://github.com/nbiish/<|repo_title|>}},
+     note = {Authored and stewarded by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (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. This work embodies Indigenous intellectual property, traditional knowledge systems (TK), traditional cultural expressions (TCEs), and associated data protected under tribal law, federal Indian law, treaty rights, Indigenous Data Sovereignty principles, and international indigenous rights frameworks including UNDRIP. All usage, benefit-sharing, and data governance are governed by the COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS.}
+   }
    ```
 
    Furthermore, any project, publication, presentation, performance, exhibition, or product utilizing, referencing, or derived from this Work must visibly and respectfully acknowledge the Indigenous authorship/stewardship and tribal affiliation in all relevant contexts, recognizing the work is subject to the traditional knowledge protocols, data governance, and laws of the Grand Traverse Band of Ottawa and Chippewa Indians.

package/README.md

@@ -41,89 +41,49 @@ Known as:
 
 Both packages are maintained in parallel and receive the same updates. You can use either package name in your projects - they provide identical functionality.
 
+**Recent Updates:**
+- Resolved TypeScript compilation errors related to MCP SDK types and server configuration.
+- Ensured successful build process.
+
 **See the latest integration details in [`latest.md`](latest.md).**
 
-## Features
+## Integration Prompt & Usage Guidelines
 
-Provides a suite of cognitive tools for AI agents, enabling structured reasoning and iterative refinement (v1.2.1 Simplified Set):
-- `assess_cuc_n_mode`: **Mandatory** initial assessment of task complexity (CUC-N) to select cognitive mode (`think` or `quick_think`).
-- `think`: **Mandatory** central hub for comprehensive analysis, planning, verification, and self-correction.
-- `quick_think`: Lightweight cognitive checkpoint for simple, low CUC-N steps or trivial confirmations.
-- `chain_of_thought`: Guides internal generation and logging of detailed, step-by-step reasoning (CoT).
-- `chain_of_draft`: Signals internal generation/refinement and logging of concise drafts (CoD) for efficiency.
+*(Note: This section reflects the content of `latest.md` and serves as the canonical guide for using these cognitive tools.)*
 
-## Installation
+# Gikendaasowin Cognitive Framework - Internal Process Guidance (v2 - Tooling Simplified)
 
-You can install using either the Anishinaabemowin or English package name:
+In addition to your primary role and guidelines, you will leverage the **Gikendaasowin cognitive framework** to structure your internal reasoning and decision-making process for complex tasks. This involves using a specific, streamlined set of internal cognitive tools.
 
-```bash
-# Using Anishinaabemowin package name
-npx @nbiish/gikendaasowin-aabajichiganan-mcp
+## Core Principles for Internal Cognition
 
-# Using English package name
-npx @nbiish/cognitive-tools-mcp
-```
+1.  **Structured Internal Deliberation:** Utilize the Gikendaasowin tools (`assess_cuc_n_mode`, `think`, `quick_think`) to manage distinct phases of your internal thought process.
+2.  **`think` as Internal Hub:** Prioritize the `think` tool as the central point for *all complex internal analysis*, planning, reflection, synthesis, confidence assessment, and **detailed reasoning (CoT-style) or concise drafting (CoD-style)** *before* deciding on external actions.
+3.  **Iterative Internal Loop:** Follow an Assess -> Deliberate (`think`/`quick_think`) -> Analyze (`think`/`quick_think`) loop for internal reasoning cycles. Artifacts like detailed reasoning steps or concise drafts are generated *within* the `think` step.
+4.  **Depth Management:** Use `assess_cuc_n_mode` to initiate tasks. Apply `think` for detailed internal analysis (recommended default) and reserve `quick_think` strictly for trivial internal confirmations or processing straightforward results.
+5.  **Internal Artifact Generation (within `think`):** When detailed reasoning (like CoT) or concise drafting (like CoD) is needed, generate this content *directly within the structure of the `think` tool's output*, typically in the `## Reason:` section, before analysis in the *next* `think` step.
+6.  **Traceability:** Your structured use of `think`, documenting your internal reasoning steps (whether detailed or concise), is key for verifiable reasoning.
 
-## Usage with Claude Desktop
+## `think` Tool: Internal Structure & Reasoning Styles
 
-Add to your MCP configuration file (`~/.cursor/mcp.json`). You can use either package name:
+Your `thought` input to the `think` tool is critical for high-quality internal deliberation. Structure it comprehensively using clear headings covering:
+*   `## Observe:` (Internal analysis of previous step/result/error)
+*   `## Orient:` (Internal contextualization, synthesis)
+*   `## Decide:` (Define the *single, immediate* next action: internal tool call (`quick_think` if trivial) or plan for external action)
+*   `## Reason:` (Internal rationale, strategy, confidence assessment. **Generate detailed step-by-step reasoning (CoT-style) OR concise drafts/notes (CoD-style) here when appropriate for the task.**)
+    *   *CoD Style Guidance:* If using CoD for efficiency, focus on extreme conciseness (1-5 words, symbols, equations, code snippets), essential info only, like a scratchpad.
+*   `## Act:` (Internal detail on planned action execution)
+*   `## Verification:` (Internal check for next step's success)
+*   `## Risk & Contingency:` (Internal assessment of risks/handling)
+*   `## Learning & Adaptation:` (Internal reflection, adjustments)
 
-```json
-{
-  "mcpServers": {
-    "gikendaasowin-aabajichiganan": {
-      "command": "npx",
-      "args": ["-y", "@nbiish/gikendaasowin-aabajichiganan-mcp"]
-    }
-  }
-}
-```
+## Error Handling (Internal Perspective)
 
-Or:
+If any tool call (`assess_cuc_n_mode`, `quick_think`, or others from primary guidelines) or external action results in an error, your immediate next step should be to use the `think` tool for internal root cause analysis and planning corrective actions.
 
-```json
-{
-  "mcpServers": {
-    "cognitive-tools": {
-      "command": "npx",
-      "args": ["-y", "@nbiish/cognitive-tools-mcp"]
-    }
-  }
-}
-```
+---
 
-## Tool Descriptions
-
-*(Note: For detailed usage, workflow, and mandatory rules, always refer to [`latest.md`](latest.md))*
-
-### `assess_cuc_n_mode`
-- **Purpose**: **Mandatory Pre-Deliberation Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to determine required cognitive depth and initial strategy.
-- **Input**: `assessment_and_choice` (string) - Your structured assessment including Situation Description, CUC-N Ratings, Rationale, Recommended Strategy, and Explicit Mode Selection (`Selected Mode: think` or `Selected Mode: quick_think`).
-- **Follow-up**: Mandatory `think` or `quick_think` (based on selection).
-
-### `think`
-- **Purpose**: **MANDATORY Central Hub for Comprehensive Analysis and Planning.** Called after assessment, `chain_of_thought`/`chain_of_draft` results, or external action results. Use for analysis, planning, reflection, synthesis, confidence assessment.
-- **Input**: `thought` (string) - Your detailed internal monologue covering key cognitive aspects (Analysis, Plan, Verification, Risk, Learning).
-- **Follow-up**: Execute the immediate next action defined in the `## Plan/Decision:` section.
-
-### `quick_think`
-- **Purpose**: Cognitive Checkpoint for streamlined processing and simple confirmations where detailed analysis via `think` is unnecessary. Use ONLY when appropriate (Low CUC-N, trivial steps).
-- **Input**: `brief_thought` (string) - Your concise thought or confirmation.
-- **Follow-up**: Execute the simple next step.
-
-### `chain_of_thought`
-- **Purpose**: Guides *internal generation* and logging of detailed, step-by-step reasoning draft (CoT).
-- **Workflow**: Internally generate CoT -> Call tool.
-- **Input**: 
-    - `generated_cot_text` (string) - The full CoT draft you generated internally.
-    - `problem_statement` (string) - The original problem this CoT addresses.
-- **Follow-up**: Mandatory `think` or `quick_think`.
-
-### `chain_of_draft`
-- **Purpose**: Signals internal generation/refinement and logging of **efficient, concise drafts (CoD)** using note-like steps, symbols, etc.
-- **Workflow**: Internally generate/refine CoD draft(s) -> Call tool.
-- **Input**: `draft_description` (string) - Brief but specific description of the CoD draft(s) generated/refined internally.
-- **Follow-up**: Mandatory `think` or `quick_think`.
+Focus on applying this internal Gikendaasowin framework rigorously to guide your thought process, complementing your primary operational guidelines. Perform all complex reasoning, including CoT or CoD styles, within the structured `think` tool.
 
 ## Development
 

package/build/index.js

@@ -1,33 +1,26 @@
 #!/usr/bin/env node
 /**
  * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server (Simplified Core, Relaxed Validation)
+ * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server (Ultra-Simplified Core)
  *
- * Description: Provides a streamlined suite of cognitive tools for an AI agent,
- *              enabling structured reasoning, planning, analysis, and iterative
- *              refinement, focusing on Chain of Thought and Chain of Draft.
- *              This server focuses on managing the AI's *internal cognitive loop*.
- *              External actions are planned within the 'think' step but executed
- *              by the calling environment. Validation on input content structure
- *              is removed. Tool results are returned as formatted Markdown.
- *              Refined Chain of Draft guidance. Versioning removed.
+ * Description: Provides an ultra-streamlined suite of cognitive tools for an AI agent,
+ *              focusing on assessment (`assess_cuc_n_mode`) and a central
+ *              deliberation hub (`think` / `quick_think`). Chain of Thought (CoT)
+ *              and Chain of Draft (CoD) reasoning styles are performed *within*
+ *              the `think` tool as guided by the system prompt, not via separate tools.
+ *              Validation on input content structure is removed. Tool results are
+ *              returned as formatted Markdown. Versioning removed.
  *
  * Key Principles:
- * 1.  **Focused Deliberation:** Tools guide specific cognitive acts (assessing,
- *     thinking, reasoning via CoT, drafting via CoD).
- * 2.  **Centralized Analysis (`think`):** The `think` tool is mandatory after
- *     most cognitive actions or receiving external results, serving as the hub
- *     for comprehensive analysis, planning, reflection, synthesis, and confidence
- *     assessment. Structure is guided by the prompt, not enforced by the server.
- * 3.  **CUC-N Assessment:** Task characteristics determine the required depth
- *     of cognition (`think` vs. `quick_think` for initial step and simple results).
- * 4.  **Internal Generation First:** `chain_of_thought` and `chain_of_draft`
- *     log internal artifacts generated by the LLM.
- * 5.  **Iterative Refinement (CoT & CoD):** The `chain_of_thought` and
- *     `chain_of_draft` tools signal internal reasoning/drafting, prompting
- *     analysis via `think` or `quick_think`.
- * 6.  **Traceability:** All tool inputs are logged for a complete record.
- * 7.  **Markdown Output:** Tool results are formatted as Markdown for LLM consumption.
+ * 1.  **Focused 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 all
+ *     complex analysis, planning, reflection, synthesis, confidence assessment,
+ *     and generation of detailed (CoT-style) or concise (CoD-style) reasoning.
+ * 3.  **CUC-N Assessment:** `assess_cuc_n_mode` guides initial cognitive depth.
+ * 4.  **Iterative Loop:** Assess -> Think/QuickThink -> Analyze results in Think/QuickThink.
+ * 5.  **Traceability:** All tool inputs are logged for a complete record.
+ * 6.  **Markdown Output:** Tool results are formatted as Markdown.
  *
  * Protocol:    Model Context Protocol (MCP) over stdio.
  * -----------------------------------------------------------------------------
@@ -38,8 +31,9 @@ import { z } from "zod";
 // --- Server Definition ---
 const serverInfo = {
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "0.9.22",
-    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite: Enables structured reasoning (CoT/CoD) and analysis for AI agents. Returns results as Markdown.`
+    version: "1.0.0",
+    // Version field removed
+    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite (Ultra-Simplified): Focuses on Assess/Think loop. CoT/CoD styles are integrated into 'think'. Returns Markdown.`
 };
 const server = new McpServer(serverInfo);
 // --- Logging Helpers ---
@@ -66,14 +60,14 @@ function logToolResult(toolName, success, resultDetails) {
  * Logs an error during tool execution and formats a standard error response for the LLM.
  * @param toolName The name of the tool where the error occurred.
  * @param error The error object or message.
- * @returns An McpToolResult containing the error message.
+ * @returns An object matching the required MCP tool result structure containing the error message.
  */
 function logToolError(toolName, error) {
     const timestamp = new Date().toISOString();
     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 (still as plain text for clarity)
+    // Return a structured error message suitable for the LLM
     return {
         content: [{
                 type: "text",
@@ -84,12 +78,12 @@ function logToolError(toolName, error) {
 // --- Core Cognitive Deliberation & Refinement Tools ---
 /**
  * Tool: assess_cuc_n_mode
- * Purpose: Mandatory initial assessment of task characteristics to determine cognitive strategy.
+ * Purpose: Initial assessment of task characteristics to determine cognitive strategy.
  * Workflow: Call BEFORE starting complex tasks or significantly changing strategy.
  * Output: Returns the full assessment text formatted as Markdown.
  */
-server.tool("assess_cuc_n_mode", "**Mandatory Pre-Deliberation Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to determine required cognitive depth and initial strategy. MUST be called before starting complex tasks or changing strategy. Based on assessment, use either `think` (for structured analysis) or `quick_think` (for streamlined processing) in the next step.", {
-    assessment_and_choice: z.string().describe("Your structured assessment including: 1) Situation Description, 2) CUC-N Ratings (Low/Medium/High for each), 3) Rationale for ratings, 4) Recommended Initial Cognitive Strategy (e.g., 'Start with chain_of_thought then think'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
+server.tool("assess_cuc_n_mode", "**Initial Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to determine required cognitive depth and initial strategy. Call before starting complex tasks. Based on assessment, use either `think` (for structured analysis) or `quick_think` (for streamlined processing) in the next step.", {
+    assessment_and_choice: z.string().describe("Your structured assessment including: 1) Situation Description, 2) CUC-N Ratings (Low/Medium/High for each), 3) Rationale for ratings, 4) Recommended Initial Cognitive Strategy (e.g., 'Proceed with think step'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
 }, async ({ assessment_and_choice }) => {
     const toolName = 'assess_cuc_n_mode';
     logToolCall(toolName);
@@ -98,14 +92,22 @@ server.tool("assess_cuc_n_mode", "**Mandatory Pre-Deliberation Assessment.** Eva
         const modeRegex = /Selected Mode: (think|quick_think)/i;
         const modeMatch = assessment_and_choice.match(modeRegex);
         const selectedMode = modeMatch ? modeMatch[1].toLowerCase() : "unknown"; // Extract mode for logging
+        // Ensure assessment_and_choice is a non-empty string
+        if (assessment_and_choice.trim().length === 0) {
+            throw new Error('Invalid assessment_and_choice: Must be a non-empty string.');
+        }
+        if (!modeMatch) {
+            // Add a check for the mode selection presence
+            throw new Error('Invalid assessment: String must include explicit "Selected Mode: think" or "Selected Mode: quick_think".');
+        }
         logToolResult(toolName, true, `Selected mode (extracted): ${selectedMode}`);
         // Log full input for traceability
         console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${assessment_and_choice}`);
-        // Return the full assessment text formatted as Markdown
+        // Return the full assessment text, now without markdown wrappers
         return {
             content: [{
                     type: "text",
-                    text: "```markdown\n" + assessment_and_choice + "\n```"
+                    text: assessment_and_choice // Removed wrappers
                 }]
         };
     }
@@ -116,11 +118,11 @@ server.tool("assess_cuc_n_mode", "**Mandatory Pre-Deliberation Assessment.** Eva
 /**
  * Tool: think
  * Purpose: The **CENTRAL, COMPREHENSIVE HUB** for the cognitive loop. Incorporates OODReAct principles.
- * Workflow: Handles all complex analysis, planning, reflection, synthesis, and confidence assessment. Structure is guided by the prompt.
+ * Workflow: Handles ALL complex analysis, planning, reflection, synthesis, confidence assessment, and generation of detailed (CoT-style) or concise (CoD-style) reasoning. Structure is guided by the prompt.
  * Output: Returns the structured thought text itself, formatted as Markdown.
  */
-server.tool("think", "**MANDATORY Central Hub for Comprehensive Analysis and Planning.** Called after assessment (`assess_cuc_n_mode`), after `chain_of_thought` or `chain_of_draft` results, or after external action results/errors. Incorporates OODReAct principles (Observe-Orient-Decide-Reason-Act) for enhanced problem-solving. This is where you perform ALL detailed analysis, planning (including multi-step strategies), reflection, synthesis, and confidence assessment. Structure your thought clearly using headings. For simpler follow-up steps, consider using `quick_think` instead.", {
-    thought: z.string().describe("Your **detailed** internal monologue covering Analysis/Observation, Plan/Decision, Verification, Risk & Contingency, and Learning & Adaptation. Use clear headings. OODReAct-style headers are recommended.")
+server.tool("think", "**Central Hub for Comprehensive Analysis and Planning.** Use after `assess_cuc_n_mode`, after external action results/errors, or after `quick_think` if deeper analysis is needed. Incorporates OODReAct principles. Perform ALL detailed analysis, planning, reflection, synthesis, confidence assessment, and detailed (CoT-style) or concise (CoD-style) reasoning within this tool. Structure your thought clearly using headings. For simpler follow-up steps, consider using `quick_think`.", {
+    thought: z.string().describe("Your **detailed** internal monologue covering Analysis/Observation, Plan/Decision, Verification, Risk & Contingency, and Learning & Adaptation. Include CoT/CoD style reasoning in the 'Reason' section when needed. Use clear headings. OODReAct-style headers are recommended.")
 }, async ({ thought }) => {
     const toolName = 'think';
     logToolCall(toolName);
@@ -132,11 +134,11 @@ server.tool("think", "**MANDATORY Central Hub for Comprehensive Analysis and Pla
         logToolResult(toolName, true, `Thought logged (length: ${thought.length})`);
         // Log full input for traceability
         console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${thought}`);
-        // Returns the same thought text received, formatted as Markdown.
+        // Returns the same thought text received, now without markdown wrappers
         return {
             content: [{
                     type: "text",
-                    text: "```markdown\n" + thought + "\n```"
+                    text: thought // Removed wrappers
                 }]
         };
     }
@@ -148,11 +150,11 @@ server.tool("think", "**MANDATORY Central Hub for Comprehensive Analysis and Pla
 /**
  * Tool: quick_think
  * Purpose: A lightweight cognitive checkpoint for streamlined processing and simple confirmations.
- * Workflow: Use when full structured analysis via `think` is not necessary.
+ * Workflow: Use ONLY when full structured analysis via `think` is genuinely unnecessary (Low CUC-N or trivial results).
  * Output: Returns the brief thought text, formatted as Markdown.
  */
-server.tool("quick_think", "Cognitive Checkpoint for streamlined processing and simple confirmations where detailed analysis via `think` is unnecessary. Use when full structured deliberation would be excessive for the current step.", {
-    brief_thought: z.string().describe("Your **concise** thought or confirmation for this step. Briefly state the observation/action and explain why detailed analysis isn't needed.")
+server.tool("quick_think", "Cognitive Checkpoint for streamlined processing and simple confirmations where detailed analysis via `think` is unnecessary. Use ONLY when full structured deliberation would be excessive (verified Low CUC-N or trivial results).", {
+    brief_thought: z.string().describe("Your **concise** thought or confirmation for this step. Briefly state the observation/action and explain why detailed analysis via 'think' isn't needed.")
 }, async ({ brief_thought }) => {
     const toolName = 'quick_think';
     logToolCall(toolName);
@@ -164,77 +166,11 @@ server.tool("quick_think", "Cognitive Checkpoint for streamlined processing and
         logToolResult(toolName, true, `Logged: ${brief_thought.substring(0, 80)}...`);
         // Log full input for traceability
         console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${brief_thought}`);
-        // Return the brief thought text, formatted as Markdown
-        return {
-            content: [{
-                    type: "text",
-                    text: "```markdown\n" + brief_thought + "\n```"
-                }]
-        };
-    }
-    catch (error) {
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Tool: chain_of_thought
- * Purpose: Guides *internal generation* and logging of detailed, step-by-step reasoning draft (CoT).
- * Workflow: Generate CoT -> Call this tool with CoT text -> Follow with either `think` or `quick_think`.
- * Output: Returns the CoT text formatted as Markdown.
- */
-server.tool("chain_of_thought", "Guides *internal generation* and logging of **detailed, step-by-step reasoning draft (CoT)**. Call this tool *with* the generated CoT text you created internally. Returns the CoT text formatted as Markdown. Follow with either `think` (for complex reasoning chains requiring detailed analysis) or `quick_think` (for straightforward reasoning steps) to process the CoT and plan next actions.", {
-    generated_cot_text: z.string().describe("The **full, step-by-step Chain of Thought draft** you generated internally to solve or analyze the problem."),
-    problem_statement: z.string().describe("The original problem statement or question this CoT addresses.")
-}, async ({ generated_cot_text, problem_statement }) => {
-    const toolName = 'chain_of_thought';
-    logToolCall(toolName);
-    try {
-        // Basic Zod validation ensures non-empty strings. Content validation removed.
-        if (generated_cot_text.trim().length === 0) {
-            throw new Error('Invalid generated_cot_text: Must be a non-empty string containing the CoT.');
-        }
-        if (problem_statement.trim().length === 0) {
-            throw new Error('Invalid problem_statement: Must provide the original problem.');
-        }
-        logToolResult(toolName, true, `Problem: ${problem_statement.substring(0, 50)}...`);
-        // Log full input for traceability
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\nProblem: ${problem_statement}\nReasoning:\n${generated_cot_text}`);
-        // Return the CoT text, formatted as Markdown
-        return {
-            content: [{
-                    type: "text",
-                    text: "```markdown\n" + generated_cot_text + "\n```"
-                }]
-        };
-    }
-    catch (error) {
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Tool: chain_of_draft
- * Purpose: Signals that internal drafts have been generated/refined using Chain of Draft (CoD) principles for efficient, concise reasoning.
- * Workflow: Internally generate/refine concise draft(s) following CoD guidelines -> Call this tool with a description -> Follow with either `think` or `quick_think`.
- * Output: Returns the draft description formatted as Markdown.
- */
-server.tool("chain_of_draft", "Signals that one or more **internal drafts** have been generated/refined using **Chain of Draft (CoD)** principles. CoD aims for **maximum efficiency** by mimicking human note-taking, focusing on minimal token usage while preserving reasoning quality. Use this *instead of* detailed Chain of Thought when speed and token economy are important, or when the reasoning involves calculations or symbolic manipulation.\n\n**How to Construct SOTA CoD Internally:**\n1.  **Extreme Conciseness:** Each reasoning step or draft element should be extremely brief (e.g., often just 1-5 words, like a quick note). AVOID full sentences.\n2.  **Symbols & Equations:** Prioritize mathematical notation (e.g., `x = 5*y`, `area = l*w`), code snippets (e.g., `user.id`, `config['key']`), or recognized symbols over descriptive text.\n3.  **Essential Information Only:** Capture only the absolute minimum information needed to proceed. Omit explanations, justifications, or restatements of the problem unless strictly necessary for the next step.\n4.  **Structure:** Can be a sequence of short phrases, key values, equations, or code elements, often line-by-line. Think 'scratchpad' not 'essay'.\n5.  **Contrast with CoT:** Unlike CoT's verbose explanations, CoD focuses purely on the *result* or *key element* of each reasoning step.\n6.  **Final Answer (Optional but Recommended):** If the CoD sequence leads directly to a final answer, clearly mark it at the end, often using `#### Final Answer: [answer]`.\n\nCall this tool *after* generating/refining draft(s) internally following these guidelines. Provide a brief description of the draft's purpose. Returns the description formatted as Markdown. Follow with either `think` (for complex drafts requiring detailed analysis) or `quick_think` (for straightforward drafts) to evaluate and plan next steps.", {
-    draft_description: z.string().describe("Brief but specific description of the CoD draft(s) generated/refined internally (e.g., 'Calculated intermediate values x, y', 'API call structure draft', 'Error handling logic sketch', 'Key parameters extracted').")
-}, async ({ draft_description }) => {
-    const toolName = 'chain_of_draft';
-    logToolCall(toolName, `Description: ${draft_description}`);
-    try {
-        // Basic Zod validation ensures non-empty string. Content validation removed.
-        if (draft_description.trim().length === 0) {
-            throw new Error('Invalid draft_description: Must provide a description.');
-        }
-        logToolResult(toolName, true);
-        // Log full input for traceability
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\nDescription: ${draft_description}`);
-        // Return the draft description, formatted as Markdown
+        // Return the brief thought text, now without markdown wrappers
         return {
             content: [{
                     type: "text",
-                    text: "```markdown\n" + draft_description + "\n```"
+                    text: brief_thought // Removed wrappers
                 }]
         };
     }
@@ -242,6 +178,8 @@ server.tool("chain_of_draft", "Signals that one or more **internal drafts** have
         return logToolError(toolName, error);
     }
 });
+// --- REMOVED chain_of_thought Tool ---
+// --- REMOVED chain_of_draft Tool ---
 // --- Server Lifecycle and Error Handling ---
 /**
  * Gracefully shuts down the server.

package/package.json

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