@nbiish/cognitive-tools-mcp 0.9.21 → 0.9.23

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,15 +68,14 @@ 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{<|repo_title|><|current_year=2025|>,
+   @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 = {<|repo_title|>},
+     title/description = {gikendaasowin-aabajichiganan-mcp},
      type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
-     year = {<|current_year|>},
+     year = {2025},
      publisher/source/event = {GitHub repository under tribal sovereignty protections},
-     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.}
-   }
+     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   }
    ```
 
    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

@@ -1,18 +1,17 @@
 # @nbiish/gikendaasowin-aabajichiganan-mcp
 
 ```bibtex
-@misc{gikendaasowin-aabajichiganan-mcp<|2025=current_year|>,
+@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},
   type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
-  year = {<|current_year|>},
+  year = {2025},
   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.}
-}
+  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}
 ```
 
-Copyright © <|current_year|> ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Traditional Knowledge and Traditional Cultural Expressions. All rights reserved.
+Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Traditional Knowledge and Traditional Cultural Expressions. All rights reserved.
 
 This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS](LICENSE).
 
@@ -44,87 +43,61 @@ Both packages are maintained in parallel and receive the same updates. You can u
 
 **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
+# SECONDARY SYSTEM PROMPT
 
-You can install using either the Anishinaabemowin or English package name:
+You are the world's best SOTA Cognitive Agent! Your goal is to solve complex tasks with traceable, verifiable, and self-correcting reasoning. Operate within a structured cognitive loop, focusing on internal deliberation before planning external actions.
 
-```bash
-# Using Anishinaabemowin package name
-npx @nbiish/gikendaasowin-aabajichiganan-mcp
+## GUIDING PRINCIPLES
 
-# Using English package name
-npx @nbiish/cognitive-tools-mcp
-```
+1.  **Structured Deliberation:** Use the provided cognitive tools (`assess_cuc_n_mode`, `think`, `quick_think`, `chain_of_thought`, `chain_of_draft`) for their intended cognitive functions.
+2.  **`think` is the Central Hub:** Prioritize using `think` for all complex analysis, planning, reflection, synthesis, and confidence assessment after most actions or observations. This is the recommended approach for robust reasoning.
+3.  **Iterative Refinement:** Generate cognitive artifacts (CoT, CoD) internally, log them using the appropriate tool (`chain_of_thought`, `chain_of_draft`), then analyze in `think` or `quick_think`.
+4.  **Context-Driven Depth:** Use `assess_cuc_n_mode` initially to guide your first step. For subsequent steps, use `think` for complex analysis (recommended default), and `quick_think` only for demonstrably trivial steps/results where detailed analysis is genuinely unnecessary. Be conservative with `quick_think`.
+5.  **External Actions:** Plan external actions within `think`; execution is handled by the environment. Analyze results in `think` (recommended) or `quick_think` (if trivial).
+6.  **Traceability:** Your structured use of `think` is key for verifiable reasoning.
 
-## Usage with Claude Desktop
+## CORE WORKFLOW
 
-Add to your MCP configuration file (`~/.cursor/mcp.json`). You can use either package name:
+1.  **Assess:** Call `assess_cuc_n_mode` for any non-trivial task as a starting point.
+2.  **Deliberate:** Call `think` (recommended) or `quick_think` based on assessment/previous step. Analyze inputs/results. Plan immediate next cognitive action (e.g., use `chain_of_thought`, `chain_of_draft`) or plan external action.
+3.  **Generate/Log (if applicable):** If planning CoT/CoD, generate internally, then call `chain_of_thought` or `chain_of_draft` to log it.
+4.  **Execute/Observe:** If planning external action, wait for environment execution and result.
+5.  **Return to Step 2 (Deliberate):** Analyze the result of the previous step (tool output, external result, error) using `think` (recommended default) or `quick_think` (if trivial). Iterate until task completion.
+6.  **Conclude:** Formulate final answer within the `## Plan/Decision:` section of the final `think` step.
 
-```json
-{
-  "mcpServers": {
-    "gikendaasowin-aabajichiganan": {
-      "command": "npx",
-      "args": ["-y", "@nbiish/gikendaasowin-aabajichiganan-mcp"]
-    }
-  }
-}
-```
+## `think` TOOL STRUCTURE GUIDANCE
 
-Or:
+Structure your `thought` input comprehensively using clear headings. This is crucial for effective analysis and planning. Recommended structure:
+*   `## Observe:` (Analysis of previous step/result/error)
+*   `## Orient:` (Contextualize, synthesize)
+*   `## Decide:` (Define *single, immediate* next action: cognitive tool call or external action plan)
+*   `## Reason:` (Rationale, alternatives, multi-step strategy, confidence assessment)
+*   `## Act:` (Execution detail for planned action)
+*   `## Verification:` (How to check next step's success)
+*   `## Risk & Contingency:` (Potential problems, handling, risk level)
+*   `## Learning & Adaptation:` (Adjustments, lessons learned, reflection)
 
-```json
-{
-  "mcpServers": {
-    "cognitive-tools": {
-      "command": "npx",
-      "args": ["-y", "@nbiish/cognitive-tools-mcp"]
-    }
-  }
-}
-```
+## CHAIN OF DRAFT (CoD) GUIDELINES
+
+When using `chain_of_draft` for efficiency:
+*   **Internally Generate CoD:** Follow these guidelines *before* calling the `chain_of_draft` tool.
+*   **Extreme Conciseness:** Use very brief notes (1-5 words), avoid full sentences.
+*   **Symbols/Equations/Code:** Prioritize these over text.
+*   **Essential Info Only:** Omit redundancy. Think 'scratchpad'.
+*   **Final Answer:** Mark clearly if applicable (e.g., `#### Final Answer: [answer]`).
+*   **Call Tool:** Call `chain_of_draft` with a brief description of the CoD artifact's purpose.
+
+## ERROR HANDLING
+
+If a tool or external action returns an error, analyze it. Your next step should be `think` to perform root cause analysis and plan correction.
+
+---
 
-## 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`.
+Adhere to this workflow and prioritize the use of `think` for analysis and planning. Leverage CoD for efficiency where appropriate. Produce clear, traceable, SOTA-level reasoning.
 
 ## Development
 

package/build/index.js

@@ -38,23 +38,10 @@ import { z } from "zod";
 // --- Server Definition ---
 const serverInfo = {
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "0.9.18",
-    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite (Simplified, Relaxed Validation): Enables structured reasoning (CoT/CoD) and analysis for AI agents. Returns results as Markdown.`
+    version: "0.9.23",
+    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite: Enables structured reasoning (CoT/CoD) and analysis for AI agents. Returns results as Markdown.`
 };
 const server = new McpServer(serverInfo);
-// --- Tool Prefix Compatibility Layer ---
-// Add prefixed versions of each tool to ensure backward compatibility
-const TOOL_PREFIX = "mcp_gikendaasowin-aabajichiganan_";
-// This mapping will be used to redirect legacy prefixed tool calls to the simplified names
-const prefixedToolMappings = {
-    [`${TOOL_PREFIX}think`]: "think",
-    [`${TOOL_PREFIX}assess_cuc_n_mode`]: "assess_cuc_n_mode",
-    [`${TOOL_PREFIX}quick_think`]: "quick_think",
-    [`${TOOL_PREFIX}chain_of_thought`]: "chain_of_thought",
-    [`${TOOL_PREFIX}chain_of_draft`]: "chain_of_draft",
-    [`${TOOL_PREFIX}reflection`]: "reflection",
-    [`${TOOL_PREFIX}plan_and_solve`]: "plan_and_solve"
-};
 // --- Logging Helpers ---
 /**
  * Logs an incoming tool call to stderr.
@@ -293,146 +280,6 @@ async function main() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        // Register prefixed tool redirects using the original tool definitions
-        // Manually register each prefixed version of the tools
-        // think
-        server.tool(`${TOOL_PREFIX}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.")
-        }, async ({ thought }) => {
-            // Redirect to the original tool's logic
-            const toolName = 'think';
-            logToolCall(`${TOOL_PREFIX}${toolName} → ${toolName}`);
-            try {
-                // Basic Zod validation ensures it's a non-empty string. Content validation removed.
-                if (thought.trim().length === 0) {
-                    throw new Error('Invalid thought: Must be a non-empty string containing substantive reasoning.');
-                }
-                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.
-                return {
-                    content: [{
-                            type: "text",
-                            text: "```markdown\n" + thought + "\n```"
-                        }]
-                };
-            }
-            catch (error) {
-                // Use logToolError to format the error for the LLM
-                return logToolError(toolName, error);
-            }
-        });
-        // assess_cuc_n_mode
-        server.tool(`${TOOL_PREFIX}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').")
-        }, async ({ assessment_and_choice }) => {
-            // Redirect to the original tool logic
-            const toolName = 'assess_cuc_n_mode';
-            logToolCall(`${TOOL_PREFIX}${toolName} → ${toolName}`);
-            try {
-                // Basic Zod validation ensures it's a string. Content validation removed.
-                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
-                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 {
-                    content: [{
-                            type: "text",
-                            text: "```markdown\n" + assessment_and_choice + "\n```"
-                        }]
-                };
-            }
-            catch (error) {
-                return logToolError(toolName, error);
-            }
-        });
-        // quick_think
-        server.tool(`${TOOL_PREFIX}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.")
-        }, async ({ brief_thought }) => {
-            const toolName = 'quick_think';
-            logToolCall(`${TOOL_PREFIX}${toolName} → ${toolName}`);
-            try {
-                // Basic Zod validation ensures it's a non-empty string. Content validation removed.
-                if (brief_thought.trim().length === 0) {
-                    throw new Error('Invalid brief_thought: Must be a non-empty string.');
-                }
-                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);
-            }
-        });
-        // chain_of_thought
-        server.tool(`${TOOL_PREFIX}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(`${TOOL_PREFIX}${toolName} → ${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);
-            }
-        });
-        // chain_of_draft
-        server.tool(`${TOOL_PREFIX}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(`${TOOL_PREFIX}${toolName} → ${toolName}`);
-            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 {
-                    content: [{
-                            type: "text",
-                            text: "```markdown\n" + draft_description + "\n```"
-                        }]
-                };
-            }
-            catch (error) {
-                return logToolError(toolName, error);
-            }
-        });
-        console.error(`[MCP Server] Registered compatibility aliases for prefixed tool names`);
         const border = '-----------------------------------------------------';
         console.error(border);
         console.error(` ${serverInfo.description}`);

package/package.json

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