@nbiish/cognitive-tools-mcp 0.9.16 → 0.9.17

package/README.md

@@ -46,16 +46,12 @@ Both packages are maintained in parallel and receive the same updates. You can u
 
 ## Features
 
-Provides a suite of cognitive tools for AI agents, enabling structured reasoning and iterative refinement:
+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 analysis, planning, verification, and self-correction, incorporating OODReAct principles.
+- `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.
-- `gauge_confidence`: Meta-cognitive check to state confidence (High/Medium/Low) in a plan, analysis, or draft.
-- `chain_of_thought`: Guides internal generation of detailed, step-by-step reasoning (CoT).
-- `plan_and_solve`: Guides internal generation of a structured, multi-step plan.
-- `chain_of_draft`: Signals internal generation/refinement of concise drafts (CoD).
-- `reflection`: Guides internal generation of a critical self-evaluation (critique).
-- `synthesize_prior_reasoning`: Guides internal generation of a summary to consolidate context.
+- `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
 
@@ -102,65 +98,34 @@ Or:
 *(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. MUST be called before starting complex tasks or changing strategy.
+- **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 Analysis and Planning.** Called after assessment, other cognitive tools, internal drafts, or external action results. Incorporates OODReAct principles (Observe-Orient-Decide-Reason-Act).
-- **Input**: `thought` (string) - Your detailed internal monologue, ideally structured with sections like Observe, Orient, Decide, Reason, Act, Verification, Risk & Contingency, Learning & Adaptation.
-- **Follow-up**: Execute the immediate next action defined in the `## Plan:` (or `## Decide:`) section.
+- **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.
 
-### `gauge_confidence`
-- **Purpose**: Meta-Cognitive Checkpoint. Guides *internal stating* of confidence (High/Medium/Low) and justification regarding a specific plan, analysis, or draft.
-- **Workflow**: Internally generate assessment -> Call tool.
-- **Input**: `assessment_and_confidence` (string) - Text containing the item being assessed AND your explicit internal assessment (Confidence Level + Justification).
-- **Follow-up**: Mandatory `think` or `quick_think`.
-
 ### `chain_of_thought`
-- **Purpose**: Guides *internal generation* of a detailed, step-by-step reasoning draft (CoT).
+- **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`.
 
-### `plan_and_solve`
-- **Purpose**: Guides *internal generation* of a structured plan draft.
-- **Workflow**: Internally generate plan -> Call tool.
-- **Input**:
-    - `generated_plan_text` (string) - The full, structured plan draft you generated internally.
-    - `task_objective` (string) - The original high-level task objective.
-- **Follow-up**: Mandatory `think` or `quick_think`.
-
 ### `chain_of_draft`
-- **Purpose**: Signals that one or more **internal drafts** have been generated/refined using Chain of Draft (CoD) principles (concise, note-like steps).
-- **Workflow**: Internally generate/refine draft(s) -> Call tool.
-- **Input**: `draft_description` (string) - Brief but specific description of the draft(s) generated/refined internally.
-- **Follow-up**: Mandatory `think` or `quick_think`.
-
-### `reflection`
-- **Purpose**: Guides *internal generation* of a critical self-evaluation (critique) on a prior step, draft, plan, or outcome.
-- **Workflow**: Internally generate critique -> Call tool.
-- **Input**:
-    - `generated_critique_text` (string) - The full critique text you generated internally.
-    - `input_subject_description` (string) - A brief description of what was critiqued.
-- **Follow-up**: Mandatory `think` or `quick_think`.
-
-### `synthesize_prior_reasoning`
-- **Purpose**: Context Management Tool. Guides *internal generation* of a structured summary of preceding context.
-- **Workflow**: Internally generate summary -> Call tool.
-- **Input**:
-    - `generated_summary_text` (string) - The full, structured summary text you generated internally.
-    - `context_to_summarize_description` (string) - Description of the context that was summarized.
+- **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
 
 ```bash
@@ -281,16 +246,6 @@ npm run inspector
 }
 ```
 
-#### `gauge_confidence` Example
-```json
-{
-  "toolName": "gauge_confidence",
-  "arguments": {
-    "assessment_and_confidence": "Assessment of the plan to explain Mino-Bimaadiziwin using CoT.\\nConfidence Level: Medium.\\nJustification: The CoT approach is suitable, but explaining deep cultural concepts always carries a risk of nuance loss. Confidence is medium as external validation isn't possible here."
-  }
-}
-```
-
 #### `chain_of_thought` Example
 ```json
 {
@@ -302,17 +257,6 @@ npm run inspector
 }
 ```
 
-#### `plan_and_solve` Example
-```json
-{
-  "toolName": "plan_and_solve",
-  "arguments": {
-    "generated_plan_text": "Goal: Plan a community gathering honoring traditional protocols.\\nStep 1: Consult Elders on protocols (Timing: Next action).\\nStep 2: Identify suitable date/location based on consultation.\\nStep 3: Arrange traditional foods/medicines.\\nStep 4: Prepare space respectfully.\\nStep 5: Finalize opening/closing ceremony details.\\nAssumptions: Elders are available for consultation.\\nRisks: Scheduling conflicts (Medium).",
-    "task_objective": "Planning a community gathering that honors traditional protocols."
-  }
-}
-```
-
 #### `chain_of_draft` Example
 ```json
 {
@@ -323,28 +267,6 @@ npm run inspector
 }
 ```
 
-#### `reflection` Example
-```json
-{
-  "toolName": "reflection",
-  "arguments": {
-    "generated_critique_text": "Critique of CoT for Mino-Bimaadiziwin: Strengths - Covers key components. Weaknesses - Could elaborate more on the interconnectedness of the teachings. Suggestion - Add a concluding step summarizing the holistic nature.",
-    "input_subject_description": "Critique of the internally generated CoT for explaining Mino-Bimaadiziwin."
-  }
-}
-```
-
-#### `synthesize_prior_reasoning` Example
-```json
-{
-  "toolName": "synthesize_prior_reasoning",
-  "arguments": {
-    "generated_summary_text": "Summary of last 3 steps: 1) Assessed task (explain Mino-Bimaadiziwin). 2) Planned to use CoT via 'think'. 3) Internally generated CoT draft covering definition, Four Hills, Seven Teachings, health aspects, and connection.",
-    "context_to_summarize_description": "Summary of assessment, planning, and CoT generation for Mino-Bimaadiziwin explanation."
-  }
-}
-```
-
 ## Citation
 
 Please cite this project using the following BibTeX entry:

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.16",
+  "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",