@nbiish/cognitive-tools-mcp 0.9.15 → 0.9.17

package/README.md

@@ -46,12 +46,12 @@ Both packages are maintained in parallel and receive the same updates. You can u
 
 ## Features
 
-Provides five cognitive tools for AI agents:
-- `think`: Internal workspace for structured analysis and planning
-- `chain_of_thought`: Sequential reasoning steps for problem-solving
-- `reflection`: Self-critique and improvement of reasoning
-- `plan_and_solve`: High-level strategy development
-- `chain_of_draft`: Concise, iterative reasoning steps
+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.
 
 ## Installation
 
@@ -95,49 +95,36 @@ Or:
 
 ## Tool Descriptions
 
-### Think Tool
-- **Purpose**: MANDATORY core cognitive step for structured deliberation. Use this internal workspace for analysis, planning, verification, risk assessment, and self-correction before ANY action and after using other cognitive tools.
-- **Input**: `thought` (string) - Your detailed internal monologue and reasoning. Structure clearly with sections like Analysis, Plan, Verification, Risk Assessment, and Self-Correction.
-- **Response Format**:
-```json
-{
-  "content": [{
-    "type": "text",
-    "text": "Returns the complete thought content you provided for explicit grounding in the next step"
-  }]
-}
-```
-
-### Chain of Thought Tool
-- **Purpose**: Generate explicit, sequential reasoning steps for problem-solving
-- **Input**: 
-  - `generated_cot_text` (string) - The full, step-by-step Chain of Thought text you generated internally
-  - `problem_statement` (string) - The original problem statement this CoT addresses
-- **Response Format**: Returns the complete CoT text for mandatory analysis in the next step
-
-### Reflection Tool
-- **Purpose**: Self-critique and improvement of reasoning or plans
-- **Input**: 
-  - `generated_critique_text` (string) - The full critique text you generated internally
-  - `input_reasoning_or_plan` (string) - The original text that was critiqued
-- **Response Format**: Returns the complete critique text for mandatory analysis in the next step
-
-### Plan and Solve Tool
-- **Purpose**: High-level strategy development for complex objectives
-- **Input**: 
-  - `generated_plan_text` (string) - The full, structured plan text you generated internally
-  - `task_objective` (string) - The original high-level task objective this plan addresses
-- **Response Format**: Returns the complete plan text for mandatory analysis in the next step
-
-### Chain of Draft Tool
-- **Purpose**: Concise, iterative reasoning steps for rapid exploration
-- **Input**: `problem_statement` (string) - Problem suitable for concise, iterative reasoning
-- **Response Format**: Returns a confirmation message; the drafts you generated internally must be analyzed in the next step
-
-### Mandatory Pre-Deliberation Assessment
-- **Purpose**: Must be called BEFORE initiating significant cognitive processes (`think`) or complex action sequences. Evaluates CUC-N, recommends strategy, commits to next thought mode.
-- **Input**: `assessment_and_choice` (string) - Your assessment including Situation Description, CUC-N Ratings, Recommended Strategy, and Selected Mode
-- **Response Format**: Returns confirmation with the selected mode
+*(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`.
 
 ## Development
 
@@ -218,6 +205,8 @@ The script includes robust error handling:
 
 Here are some example test cases that demonstrate the cognitive tools using culturally appropriate Anishinaabe concepts. These examples are provided with respect and acknowledgment of Anishinaabe teachings.
 
+*(Note: These examples show tool invocation structure. The actual content for inputs like `thought`, `generated_cot_text`, etc., must be generated internally by the agent based on the specific task, following the workflows described in `latest.md`.)*
+
 ### Using the MCP Inspector
 
 1. Start the MCP Inspector:
@@ -227,62 +216,53 @@ npm run inspector
 
 2. Connect to the server and try these example tool calls:
 
-#### Think Tool Example
+#### `assess_cuc_n_mode` Example
 ```json
 {
-  "toolName": "think",
+  "toolName": "assess_cuc_n_mode",
   "arguments": {
-    "thought": "Analyzing the Seven Grandfather Teachings (Nibwaakaawin - Wisdom, Zaagi'idiwin - Love, Minaadendamowin - Respect, Aakode'ewin - Bravery, Gwayakwaadiziwin - Honesty, Dabaadendiziwin - Humility, Debwewin - Truth) and their application in modern problem-solving:\n\n1. How does Nibwaakaawin guide decision-making?\n2. How can Zaagi'idiwin inform our approach to community?\n3. How does Minaadendamowin shape our relationship with knowledge?"
+    "assessment_and_choice": "1) Situation Description: User wants to understand the Anishinaabe concept of Mino-Bimaadiziwin (Living the Good Life).\\n2) CUC-N Ratings: Complexity: Medium (Involves cultural concepts), Uncertainty: Medium (Requires accessing and synthesizing knowledge), Consequence: Medium (Accuracy is important), Novelty: Low (Explaining concepts is common).\\n3) Rationale: Requires careful explanation of interconnected teachings.\\n4) Recommended Initial Strategy: Use chain_of_thought to break down the concept.\\n5) Explicit Mode Selection: Selected Mode: think"
   }
 }
 ```
 
-Example Response:
+#### `think` Tool Example
 ```json
 {
-  "content": [{
-    "type": "text",
-    "text": "Analyzing the Seven Grandfather Teachings..."
-  }]
-}
-```
-
-#### Chain of Thought Example
-```json
-{
-  "toolName": "chain_of_thought",
+  "toolName": "think",
   "arguments": {
-    "problem_statement": "Understanding the seasonal cycle of maple sugar harvesting (ziigwaage - spring sugar making):\n1. Observe weather patterns and temperature changes\n2. Identify appropriate maple trees\n3. Prepare tools and equipment respectfully\n4. Follow proper protocols for tree tapping\n5. Collect sap with gratitude\n6. Process sap into sugar while sharing teachings"
+    "thought": "## Observe:\\nReceived task to explain Mino-Bimaadiziwin. Assessment chose 'think' mode.\\n## Orient:\\nMino-Bimaadiziwin is central to Anishinaabe philosophy, encompassing balance, health, and connection.\\n## Decide:\\nPlan to use chain_of_thought to structure the explanation.\\n## Reason:\\nA step-by-step approach will clarify the components (spiritual, mental, emotional, physical well-being).\\n## Act:\\nInternally generate CoT for Mino-Bimaadiziwin.\\n## Verification:\\nReview generated CoT for accuracy and completeness before calling the tool.\\n## Risk & Contingency:\\nRisk: Misrepresenting cultural concepts (Medium). Contingency: Rely on established knowledge, cross-reference if unsure, state limitations.\\n## Learning & Adaptation:\\nReinforce the need for careful handling of cultural knowledge."
   }
 }
 ```
 
-#### Reflection Example
+#### `quick_think` Example
 ```json
 {
-  "toolName": "reflection",
+  "toolName": "quick_think",
   "arguments": {
-    "input_reasoning_or_plan": "Reflecting on our relationship with Nibi (water):\n- Understanding water as first medicine\n- Considering our role as water protectors\n- Learning from the teachings of water\n- Examining how we honor water in daily life\n- Planning actions to protect water sources"
+    "brief_thought": "Observed successful completion of file read. Task is simple confirmation, no deep analysis needed. Proceeding to next step."
   }
 }
 ```
 
-#### Plan and Solve Example
+#### `chain_of_thought` Example
 ```json
 {
-  "toolName": "plan_and_solve",
+  "toolName": "chain_of_thought",
   "arguments": {
-    "task_objective": "Planning a community gathering that honors traditional protocols:\n1. Consult with Elders on proper procedures\n2. Select appropriate time based on seasonal calendar\n3. Arrange for traditional foods and medicines\n4. Prepare the gathering space with respect\n5. Ensure proper opening and closing ceremonies\n6. Include time for teaching and sharing"
+    "generated_cot_text": "Step 1: Define Mino-Bimaadiziwin - Living in balance and harmony.\\nStep 2: Explain the Four Hills of Life (infancy, youth, adulthood, elderhood) and their connection.\\nStep 3: Discuss the importance of the Seven Grandfather Teachings.\\nStep 4: Relate physical, mental, emotional, spiritual health.\\nStep 5: Emphasize connection to community, land, and spirit.",
+    "problem_statement": "Explain the Anishinaabe concept of Mino-Bimaadiziwin."
   }
 }
 ```
 
-#### Chain of Draft Example
+#### `chain_of_draft` Example
 ```json
 {
   "toolName": "chain_of_draft",
   "arguments": {
-    "problem_statement": "Learning basic Anishinaabemowin greetings:\n1. Boozhoo (Hello)\n2. Aaniin (Hello/Welcome)\n3. Miigwech (Thank you)\n4. Baamaapii (Until later/Goodbye)\n5. Practice proper pronunciation\n6. Understand cultural context of each greeting"
+    "draft_description": "Draft 1: Basic Anishinaabemowin greetings - Boozhoo, Aaniin. Draft 2: Added Miigwech, Baamaapii. Draft 3: Noted pronunciation focus needed."
   }
 }
 ```

package/build/index.js

@@ -1,34 +1,33 @@
 #!/usr/bin/env node
 /**
  * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server
+ * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server (Simplified Core, Relaxed Validation)
  *
- * Version: 0.9.12
- *
- * Description: Provides a suite of cognitive tools for an AI Pair Programmer,
+ * Description: Provides a streamlined suite of cognitive tools for an AI agent,
  *              enabling structured reasoning, planning, analysis, and iterative
- *              refinement (Chain of Thought, Chain of Draft, Reflection).
- *              This server focuses on managing the AI's *internal cognitive loop*,
- *              as described in the Anthropic research on the 'think' tool and
- *              related cognitive patterns. External actions are planned within
- *              the 'think' step but executed by the calling environment.
+ *              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.
  *
  * Key Principles:
- * 1.  **Structured Deliberation:** Tools guide specific cognitive acts (planning,
- *     reasoning, critique).
+ * 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 analysis, planning the *next immediate step*, verification, and
- *     self-correction.
+ *     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 (full `think` vs. `quick_think`).
- * 4.  **Internal Generation First:** Tools like `plan_and_solve`, `chain_of_thought`,
- *     `reflection`, and `synthesize_prior_reasoning` are called *after* the AI
- *     has internally generated the relevant text (plan, CoT, critique, summary).
- *     The tool logs this generation and returns it, grounding the AI for the
- *     mandatory `think` analysis step.
- * 5.  **Iterative Refinement (Chain of Draft):** The `chain_of_draft` tool signals
- *     internal draft creation/modification, prompting analysis via `think`.
+ *     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.
  *
  * Protocol:    Model Context Protocol (MCP) over stdio.
  * -----------------------------------------------------------------------------
@@ -36,13 +35,13 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-export const version = "0.9.12";
 // --- Server Definition ---
-const server = new McpServer({
+const serverInfo = {
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: version,
-    description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite v0.9.12: Enables structured, iterative reasoning (Chain of Thought/Draft), planning, and analysis for AI agents, focusing on the cognitive loop. MANDATORY `think` step integrates results."
-});
+    version: "0.9.16",
+    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite (Simplified, Relaxed Validation): Enables structured reasoning (CoT/CoD) and analysis for AI agents. Returns results as Markdown.`
+};
+const server = new McpServer(serverInfo);
 // --- Logging Helpers ---
 /**
  * Logs an incoming tool call to stderr.
@@ -74,11 +73,11 @@ 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
+    // Return a structured error message suitable for the LLM (still as plain text for clarity)
     return {
         content: [{
                 type: "text",
-                text: `Error executing tool '${toolName}': ${errorMessage}.`
+                text: `Error executing tool '${toolName}': ${errorMessage}. Please analyze this error.`
             }]
     };
 }
@@ -87,7 +86,7 @@ function logToolError(toolName, error) {
  * Tool: assess_cuc_n_mode
  * Purpose: Mandatory initial assessment of task characteristics to determine cognitive strategy.
  * Workflow: Call BEFORE starting complex tasks or significantly changing strategy.
- * Output: Confirms assessment and selected mode (`think` or `quick_think`). Result MUST inform the subsequent cognitive flow.
+ * 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').")
@@ -95,24 +94,20 @@ server.tool("assess_cuc_n_mode", "**Mandatory Pre-Deliberation Assessment.** Eva
     const toolName = 'assess_cuc_n_mode';
     logToolCall(toolName);
     try {
-        // Enhanced validation using regex for robustness
+        // Basic Zod validation ensures it's a string. Content validation removed.
         const modeRegex = /Selected Mode: (think|quick_think)/i;
-        const cucnRegex = /CUC-N Ratings:/i;
-        const strategyRegex = /Recommended Initial Strategy:/i;
-        if (!assessment_and_choice || typeof assessment_and_choice !== 'string') {
-            throw new Error('Input must be a non-empty string.');
-        }
-        if (!cucnRegex.test(assessment_and_choice)) {
-            throw new Error('Invalid assessment: String must include "CUC-N Ratings:".');
-        }
         const modeMatch = assessment_and_choice.match(modeRegex);
-        if (!modeMatch || !modeMatch[1]) {
-            throw new Error('Invalid assessment: String must include explicit "Selected Mode: think" or "Selected Mode: quick_think".');
-        }
-        const selectedMode = modeMatch[1].toLowerCase();
-        logToolResult(toolName, true, `Selected mode: ${selectedMode}`);
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Assessment Details:\n${assessment_and_choice}`);
-        return { content: [{ type: "text", text: assessment_and_choice }] };
+        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);
@@ -120,45 +115,33 @@ server.tool("assess_cuc_n_mode", "**Mandatory Pre-Deliberation Assessment.** Eva
 });
 /**
  * Tool: think
- * Purpose: The **CENTRAL HUB** for the cognitive loop, incorporating OODReAct principles (Observe-Orient-Decide-Reason-Act).
- * Workflow: Combines observation, orientation, decision-making, reasoning, and action for enhanced problem-solving.
- * Output: Returns the structured thought text itself, grounding the AI's reasoning process in the context.
+ * 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.
+ * Output: Returns the structured thought text itself, formatted as Markdown.
  */
-server.tool("think", "**MANDATORY Central Hub for Analysis and Planning.** Called after assessment (`assess_cuc_n_mode`), other cognitive tools (`plan_and_solve`, `chain_of_thought`, `chain_of_draft`, `reflection`, `synthesize_prior_reasoning`, `gauge_confidence`), internal drafts (`chain_of_draft`), or external action results. Incorporates OODReAct principles (Observe-Orient-Decide-Reason-Act) for enhanced problem-solving. Consider structuring your thought process to: 1) Observe new information and changes, 2) Orient by analyzing context and patterns, 3) Decide on potential actions, 4) Reason through implications and alternatives, and 5) Act by planning specific execution steps. Follow the MANDATORY structure in the `thought` parameter. For simpler follow-up steps, consider using `quick_think` instead.", {
-    thought: z.string().describe("Your **detailed** internal monologue. While any clear, structured format is accepted, consider following OODReAct principles in your thinking:\n- Observe: What new information/signals are available?\n- Orient: How does this fit into the bigger picture?\n- Decide: What are the potential actions to take?\n- Reason: What are the implications and alternatives?\n- Act: How to execute the chosen action?\n\nRequired sections:\n## Analysis/Observation\n## Plan/Decision\n## Verification\n## Risk & Contingency\n## Learning & Adaptation")
+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.")
 }, async ({ thought }) => {
     const toolName = 'think';
     logToolCall(toolName);
     try {
-        if (!thought || typeof thought !== 'string' || thought.trim().length === 0) {
+        // 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.');
         }
-        // Define required sections (more flexible now)
-        const requiredSections = [
-            ["## Analysis:", "## Observe:", "## Observation:"],
-            ["## Orient:", "## Orientation:"],
-            ["## Plan:", "## Decide:", "## Decision:"],
-            ["## Reason:", "## Reasoning:", "## Analysis:"],
-            ["## Act:", "## Action:", "## Execution:"],
-            ["## Verification:"],
-            ["## Risk & Contingency:", "## Risks:", "## Challenges:"],
-            ["## Learning & Adaptation:", "## Self-Correction:", "## Learning:"]
-        ];
-        const missingSections = requiredSections.filter(sectionGroup => !sectionGroup.some(section => thought.includes(section)));
-        let validationReport = [];
-        if (missingSections.length > 0) {
-            validationReport.push("WARNING: Some recommended sections might be missing. Consider including observation, orientation, decision, reasoning, action, verification, risks, and learning components in your thought process.");
-        }
-        if (validationReport.length > 0) {
-            console.warn(`[${new Date().toISOString()}] [CognitiveToolsServer] Think Tool Validation Report:\n${validationReport.join("\n")}`);
-        }
-        const format = thought.includes("## Observe:") ? "OODReAct-style" : "Traditional";
-        logToolResult(toolName, true, `Thought logged (Style: ${format}, Length: ${thought.length})`);
+        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: thought }]
+            content: [{
+                    type: "text",
+                    text: "```markdown\n" + thought + "\n```"
+                }]
         };
     }
     catch (error) {
+        // Use logToolError to format the error for the LLM
         return logToolError(toolName, error);
     }
 });
@@ -166,7 +149,7 @@ server.tool("think", "**MANDATORY Central Hub for Analysis and Planning.** Calle
  * 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.
- * Output: Logs the brief thought.
+ * 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.")
@@ -174,40 +157,20 @@ server.tool("quick_think", "Cognitive Checkpoint for streamlined processing and
     const toolName = 'quick_think';
     logToolCall(toolName);
     try {
-        if (!brief_thought || typeof brief_thought !== 'string' || brief_thought.trim().length === 0) {
+        // 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)}...`);
-        return { content: [{ type: "text", text: brief_thought }] };
-    }
-    catch (error) {
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Tool: gauge_confidence
- * Purpose: Meta-Cognitive Checkpoint to explicitly state confidence in a preceding analysis, plan, or draft.
- * Workflow: Generate assessment -> Call this tool with assessment text -> Follow with either `think` or `quick_think`.
- * Output: Confirms confidence gauging and level.
- */
-server.tool("gauge_confidence", "Meta-Cognitive Checkpoint. Guides *internal stating* of **confidence (High/Medium/Low) and justification** regarding a specific plan, analysis, or draft you just formulated. Call this tool *with* the text containing your confidence assessment. Follow with either `think` (for detailed analysis) or `quick_think` (for straightforward confirmation) based on the confidence level and complexity.", {
-    assessment_and_confidence: z.string().describe("The text containing the item being assessed AND your explicit internal assessment: 1) Confidence Level: (High/Medium/Low). 2) Justification for this level.")
-}, async ({ assessment_and_confidence }) => {
-    const toolName = 'gauge_confidence';
-    logToolCall(toolName);
-    try {
-        const confidenceRegex = /Confidence Level: (High|Medium|Low)/i;
-        if (!assessment_and_confidence || typeof assessment_and_confidence !== 'string') {
-            throw new Error('Input must be a non-empty string.');
-        }
-        const match = assessment_and_confidence.match(confidenceRegex);
-        if (!match || !match[1]) {
-            throw new Error('Invalid confidence assessment: String must include "Confidence Level: High/Medium/Low" and justification.');
-        }
-        const level = match[1];
-        logToolResult(toolName, true, `Level: ${level}`);
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Confidence Details:\n${assessment_and_confidence}`);
-        return { content: [{ type: "text", text: assessment_and_confidence }] };
+        // 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);
@@ -215,59 +178,34 @@ server.tool("gauge_confidence", "Meta-Cognitive Checkpoint. Guides *internal sta
 });
 /**
  * Tool: chain_of_thought
- * Purpose: Guides *internal generation* of detailed, step-by-step reasoning draft (CoT).
+ * 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 for analysis.
+ * Output: Returns the CoT text formatted as Markdown.
  */
-server.tool("chain_of_thought", "Guides *internal generation* of **detailed, step-by-step reasoning draft (CoT)**. Call this tool *with* the generated CoT text you created internally. Returns the CoT text. 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.", {
+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 {
-        if (!generated_cot_text || typeof generated_cot_text !== 'string' || !problem_statement || typeof problem_statement !== 'string') {
-            throw new Error('Both generated_cot_text and problem_statement must be non-empty strings.');
+        // 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 (!generated_cot_text.match(/step|phase|:\s|^\d+[\.\)]/im)) {
-            throw new Error('Invalid CoT format: Must contain clear reasoning steps (numbered, labeled as steps/phases, or with clear delineation).');
+        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)}...`);
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Details:\nProblem: ${problem_statement}\nReasoning:\n${generated_cot_text}`);
-        return { content: [{ type: "text", text: generated_cot_text }] };
-    }
-    catch (error) {
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Tool: plan_and_solve
- * Purpose: Guides *internal generation* of a structured plan draft.
- * Workflow: Generate plan -> Call this tool with plan text -> Follow with either `think` or `quick_think`.
- * Output: Returns the plan text for analysis.
- */
-server.tool("plan_and_solve", "Guides *internal generation* of a **structured plan draft**. Call this tool *with* the generated plan text you created internally. Returns the plan text. Follow with either `think` (for complex plans requiring detailed analysis) or `quick_think` (for straightforward plans) to evaluate feasibility and confirm next steps.", {
-    generated_plan_text: z.string().describe("The **full, structured plan draft** you generated internally, including goals, steps, potential external tool needs, assumptions, and risks."),
-    task_objective: z.string().describe("The original high-level task objective this plan addresses.")
-}, async ({ generated_plan_text, task_objective }) => {
-    const toolName = 'plan_and_solve';
-    logToolCall(toolName);
-    try {
-        if (!generated_plan_text || typeof generated_plan_text !== 'string' || !task_objective || typeof task_objective !== 'string') {
-            throw new Error("Missing or invalid required parameters: 'generated_plan_text' and 'task_objective' must be non-empty strings.");
-        }
-        // Basic structure check (optional, less strict)
-        // if (!generated_plan_text.match(/phase|step|goal|objective|:\\s|^\\d+[\\.\\)]/im)) {
-        // 	console.warn(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Warning: Plan structure might be basic. Consider using clear steps/phases.`);
-        // }
-        // Removed strict validation for risk/challenge
-        // if (!generated_plan_text.toLowerCase().includes('risk') && !generated_plan_text.toLowerCase().includes('challenge')) {
-        // 	throw new Error("Invalid plan format: Must include risk/challenge assessment.");
-        // }
-        logToolResult(toolName, true, `Task: ${task_objective.substring(0, 50)}...`);
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Details:\nTask: ${task_objective}\nPlan:\n${generated_plan_text}`);
-        // Return the plan text directly (potentially formatted as markdown if needed, but currently just text)
-        return { content: [{ type: "text", text: generated_plan_text }] };
+        // 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);
@@ -275,79 +213,30 @@ server.tool("plan_and_solve", "Guides *internal generation* of a **structured pl
 });
 /**
  * Tool: chain_of_draft
- * Purpose: Signals that internal drafts have been generated/refined using Chain of Draft (CoD) principles.
- * Workflow: Internally generate/refine concise draft(s) -> Call this tool -> Follow with either `think` or `quick_think`.
- * Best Practices from Research:
- * - Keep each draft step short (< 5 words) like human notes
- * - Use equations, symbols, or brief phrases instead of sentences
- * - Focus on essential information only
- * - End with #### followed by final answer/conclusion
- * Output: Returns markdown-formatted response with CoD guidance and next tool recommendation.
+ * 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 is an efficient prompting technique that uses concise, note-like drafts instead of full sentences. Best practices:\n- Keep each step short (< 5 words)\n- Use equations/symbols when possible\n- Focus on essential information\n- End with #### followed by conclusion\n\nCall this tool *after* generating/refining draft(s) internally. Returns markdown-formatted response with next tool recommendation. 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 draft(s) generated/refined internally (e.g., 'Initial API function - params defined', 'Error handling v2', 'README structure').")
+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 {
-        if (!draft_description || typeof draft_description !== 'string' || draft_description.trim().length === 0) {
+        // 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);
-        return { content: [{ type: "text", text: draft_description }] };
-    }
-    catch (error) {
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Tool: reflection
- * Purpose: Guides *internal generation* of a critical self-evaluation (critique) on a prior step, draft, plan, or outcome.
- * Call this tool *with* the **generated critique text** you created internally.
- * Returns the critique text.
- * Follow with either `think` or `quick_think` to process the critique.
- */
-server.tool("reflection", "Guides *internal generation* of a critical self-evaluation (critique) on a prior step, draft, plan, or outcome. Call this tool *with* the **generated critique text** you created internally. Returns the critique text. Follow with either `think` (for complex critiques requiring detailed analysis) or `quick_think` (for straightforward critiques) to process the feedback and plan improvements.", {
-    generated_critique_text: z.string().describe("The **full critique text** you generated internally, identifying specific flaws, strengths, assumptions, alternative approaches, and concrete suggestions for improvement."),
-    input_subject_description: z.string().describe("A brief description of the original reasoning, plan, code draft, or action result that was critiqued (e.g., 'Critique of the plan generated via plan_and_solve', 'Reflection on the CoT for problem X').")
-}, async ({ generated_critique_text, input_subject_description }) => {
-    const toolName = 'reflection';
-    logToolCall(toolName, `Subject: ${input_subject_description}`);
-    try {
-        if (!generated_critique_text || typeof generated_critique_text !== 'string' || generated_critique_text.trim().length === 0) {
-            throw new Error('Invalid generated_critique_text: Must be a non-empty string containing the critique.');
-        }
-        if (!input_subject_description || typeof input_subject_description !== 'string' || input_subject_description.trim().length === 0) {
-            throw new Error('Invalid input_subject_description: Must describe what was critiqued.');
-        }
-        logToolResult(toolName, true, `Critique length: ${generated_critique_text.length}`);
-        return { content: [{ type: "text", text: generated_critique_text }] };
-    }
-    catch (error) {
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Tool: synthesize_prior_reasoning
- * Purpose: Context Management Tool. Guides the *internal generation* of a structured summary of preceding context.
- * Workflow: Internally generate summary -> Call this tool *with* the summary text -> Follow with either `think` or `quick_think`.
- * Output: Returns the provided summary text for grounding and analysis.
- */
-server.tool("synthesize_prior_reasoning", "Context Management Tool. Guides *internal generation* of a **structured summary** of preceding steps, decisions, key findings, or relevant context to consolidate understanding before proceeding. Call this tool *with* the generated summary text you created internally. Returns the summary. Follow with either `think` (for complex context requiring detailed analysis) or `quick_think` (for straightforward context) to leverage this summary and inform next actions.", {
-    generated_summary_text: z.string().describe("The **full, structured summary text** you generated internally (e.g., key decisions made, open questions, current state of implementation, relevant facts gathered)."),
-    context_to_summarize_description: z.string().describe("Description of the reasoning span or context that was summarized (e.g., 'Summary of the last 5 steps', 'Consolidated findings from tool results A and B').")
-}, async ({ generated_summary_text, context_to_summarize_description }) => {
-    const toolName = 'synthesize_prior_reasoning';
-    logToolCall(toolName, `Context: ${context_to_summarize_description}`);
-    try {
-        if (!generated_summary_text || typeof generated_summary_text !== 'string' || generated_summary_text.trim().length === 0) {
-            throw new Error('Invalid generated_summary_text: Must be a non-empty string containing the summary.');
-        }
-        if (!context_to_summarize_description || typeof context_to_summarize_description !== 'string' || context_to_summarize_description.trim().length === 0) {
-            throw new Error('Invalid context_to_summarize_description: Must describe what was summarized.');
-        }
-        logToolResult(toolName, true, `Summary length: ${generated_summary_text.length}`);
-        return { content: [{ type: "text", text: generated_summary_text }] };
+        // 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);
@@ -393,8 +282,8 @@ async function main() {
         await server.connect(transport);
         const border = '-----------------------------------------------------';
         console.error(border);
-        console.error(` ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite v0.9.12: Enables structured, iterative reasoning (Chain of Thought/Draft), planning, and analysis for AI agents, focusing on the cognitive loop. MANDATORY \`think\` step integrates results.`);
-        console.error(` Version: ${version}`);
+        console.error(` ${serverInfo.description}`);
+        // Version logging removed from startup message
         console.error(' Status: Running on stdio, awaiting MCP requests...');
         console.error(border);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "0.9.15",
+  "version": "0.9.17",
   "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",
@@ -16,7 +16,6 @@
   ],
   "scripts": {
     "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
-    "prepare": "npm run build",
     "watch": "tsc --watch",
     "inspector": "npx @modelcontextprotocol/inspector build/index.js",
     "start": "node build/index.js",