@nbiish/cognitive-tools-mcp 0.9.3 → 0.9.5

package/README.md

@@ -26,7 +26,7 @@ Known as:
 
 Both packages are maintained in parallel and receive the same updates. You can use either package name in your projects - they provide identical functionality.
 
-**See the latest integration details in [`integration-prompts/new-prompts/integration-prompt-16.md`](integration-prompts/new-prompts/integration-prompt-16.md).**
+**See the latest integration details in [`integration-prompts/new-prompts/latest.md`](integration-prompts/new-prompts/latest.md).**
 
 ## Features
 
@@ -215,37 +215,6 @@ Example Response:
 }
 ```
 
-## Version History
-
-**0.9.1**
-- Fixed package publishing script to correctly publish both packages with different names
-- Updated both packages to maintain version consistency
-
-**0.9.0**
-- Major update focused on iterative refinement and Chain of Draft methodology
-- Updated tools with enhanced support for draft generation, analysis, and refinement
-- Improved error handling, logging, and parameter descriptions
-- Removed explicit version references for greater flexibility
-
-**0.8.5**: Version update to resolve npm publish conflicts and maintain consistency between packages. Continues using the shortened tool name `assess_cuc_n_mode` to comply with MCP tool name length requirements.
-- **0.8.4**: Version bump to align packages after updating the tool name from `assess_complexity_and_select_thought_mode` to `assess_cuc_n_mode`. Ensures consistent naming across all files.
-- **0.8.3**: Updated package version to maintain consistency between `gikendaasowin-aabajichiganan-mcp` and `cognitive-tools-mcp` packages. Ensures all references to the tool use the shortened name `assess_cuc_n_mode`.
-- **0.8.2**: Removed integration prompt references from codebase and made various refinements. Shortened `assess_complexity_and_select_thought_mode` to `assess_cuc_n_mode` to address MCP tool name length limitation.
-- **0.8.1**: Updated tool function to integrate with external tools, renamed `assess_cuc_n_mode` to `assess_complexity_and_select_thought_mode`, improved validation of thought structure, aligned with AI Pair Programmer Prompt v0.8.1+
-- **0.8.0**: Updated tool function design to return generated content for explicit analysis, renamed `assess_cuc_n` to `assess_cuc_n_mode`, aligned with AI Pair Programmer Prompt v0.8.0+
-- **0.7.3**: Improved dual package publishing with automated scripts, consistent versioning, and documentation updates
-- **0.7.2**: Updated tool names for length constraints (`assess_complexity_and_select_thought_mode` → `assess_cuc_n`), improved dual package publishing support, and aligned with AI Pair Programmer Prompt v0.7.2
-- **0.7.1**: Updated to align with AI Pair Programmer Prompt v0.7.1+, renamed `assess_cuc_n_mode` to `assess_cuc_n`, enhanced cognitive tools for more explicit handling of tool needs
-- **0.6.1**: Fixed tool naming issue for technical length limitation
-- **0.3.9**: Updated tool descriptions and fixed error handling to improve reliability
-- **0.3.6**: Updated repository URLs to point to gikendaasowin-aabajichiganan-mcp
-- **0.3.5**: Updated license link and repository URLs
-- **0.3.4**: Dual package publishing (Anishinaabemowin and English names)
-- **0.3.3**: Fixed response format to comply with MCP schema, synchronized version numbers
-- **0.3.2**: Updated response format structure
-- **0.3.1**: Initial public release with basic functionality
-- **0.3.0**: Development version
-
 ## Copyright
 
 Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. All rights reserved.

package/build/index.js

@@ -3,244 +3,389 @@
  * -----------------------------------------------------------------------------
  * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server
  *
- * Description: Provides the essential suite of cognitive tools for an AI
- *              Pair Programmer to structure its reasoning, plan actions,
- *              analyze results, and iteratively refine its work, focusing on
- *              the internal cognitive loop as described in the corresponding
- *              integration prompt. External actions are planned within 'think'
- *              but executed by the environment.
+ * Version: 0.9.4
+ *
+ * Description: Provides a suite of cognitive tools for an AI Pair Programmer,
+ *              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.
+ *
+ * Key Principles:
+ * 1.  **Structured Deliberation:** Tools guide specific cognitive acts (planning,
+ *     reasoning, critique).
+ * 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.
+ * 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`.
+ *
  * Protocol:    Model Context Protocol (MCP) over stdio.
  * -----------------------------------------------------------------------------
  */
 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.4";
 // --- Server Definition ---
 const server = new McpServer({
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "0.9.3",
-    description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite: Enables structured, iterative reasoning (Chain of Draft), planning, and analysis for AI Pair Programming, focusing on the cognitive loop."
+    version: version,
+    description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite v0.9.4: Enables structured, iterative reasoning (Chain of Thought/Draft), planning, and analysis for AI agents, focusing on the cognitive loop. MANDATORY `think` step integrates results."
 });
-// --- Logging Helper ---
+// --- Logging Helpers ---
+/**
+ * Logs an incoming tool call to stderr.
+ * @param toolName The name of the tool being called.
+ * @param details Optional additional details about the call.
+ */
 function logToolCall(toolName, details) {
-    console.error(`[MCP Server] > Tool Call: ${toolName}${details ? ` - ${details}` : ''}`);
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [MCP Server] > Tool Call: ${toolName}${details ? ` - ${details}` : ''}`);
 }
+/**
+ * Logs the result (success or failure) of a tool execution to stderr.
+ * @param toolName The name of the tool executed.
+ * @param success Whether the execution was successful.
+ * @param resultDetails Optional details about the result.
+ */
 function logToolResult(toolName, success, resultDetails) {
-    console.error(`[MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
 }
+/**
+ * Logs an error during tool execution and formats a standard error response for the LLM.
+ * @param toolName The name of the tool where the error occurred.
+ * @param error The error object or message.
+ * @returns An McpToolResult containing the error message.
+ */
 function logToolError(toolName, error) {
+    const timestamp = new Date().toISOString();
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`[MCP Server] ! Tool Error: ${toolName} - ${errorMessage}`);
+    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 { content: [{ type: "text", text: `Error in ${toolName}: ${errorMessage}` }] };
+    return {
+        content: [{
+                type: "text",
+                text: `Error executing tool '${toolName}': ${errorMessage}. Please analyze this error in your next 'think' step and adjust your plan.`
+            }]
+    };
 }
 // --- Core Cognitive Deliberation & Refinement Tools ---
-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.", {
-    assessment_and_choice: z.string().describe("Structured assessment including: 1) Situation Description, 2) CUC-N Ratings (L/M/H), 3) Recommended Initial Cognitive Strategy (e.g., 'Start with chain_of_thought'), 4) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
+/**
+ * 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.
+ */
+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. Selects 'think' (default) or 'quick_think' (only for verified Low CUC-N).", {
+    assessment_and_choice: z.string().describe("Your structured assessment including: 1) Situation Description, 2) CUC-N Ratings (Low/Medium/High for each), 3) Rationale for ratings, 4) Recommended Initial Cognitive Strategy (e.g., 'Start with chain_of_thought then think'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
 }, async ({ assessment_and_choice }) => {
-    logToolCall('assess_cuc_n_mode');
+    const toolName = 'assess_cuc_n_mode';
+    logToolCall(toolName);
     try {
-        // Basic validation for required components
-        if (!assessment_and_choice.includes("Selected Mode:") || !assessment_and_choice.includes("CUC-N Ratings:") || !assessment_and_choice.includes("Recommended Initial Strategy:")) {
-            throw new Error('Invalid assessment: String must include CUC-N ratings, Recommended Initial Strategy, and explicit Selected Mode.');
+        // Enhanced validation using regex for robustness
+        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 mode = assessment_and_choice.includes("Selected Mode: think") ? "think" : "quick_think";
-        const resultText = `Cognitive Assessment Completed. Proceeding with selected mode: ${mode}. Full Assessment:\n${assessment_and_choice}`;
-        logToolResult('assess_cuc_n_mode', true, `Selected mode: ${mode}`);
+        if (!strategyRegex.test(assessment_and_choice)) {
+            throw new Error('Invalid assessment: String must include "Recommended Initial Strategy:".');
+        }
+        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();
+        const resultText = `Cognitive Assessment Completed. CUC-N analysis indicates ${selectedMode === 'think' ? 'detailed deliberation' : 'quick check'} is appropriate. Proceeding with selected mode: ${selectedMode}. Full Assessment logged. Ensure subsequent actions align with this assessment.`;
+        logToolResult(toolName, true, `Selected mode: ${selectedMode}`);
+        // Log the full assessment server-side for traceability
+        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Assessment Details:\n${assessment_and_choice}`);
         return { content: [{ type: "text", text: resultText }] };
     }
     catch (error) {
-        return logToolError('assess_cuc_n_mode', error);
+        return logToolError(toolName, error);
     }
 });
-server.tool("think", "**MANDATORY Central Hub for Analysis, Planning, and Refinement.** Called after assessment, cognitive tools, internal drafts, or external action results. Analyzes previous step's outcome/draft, plans immediate next action (cognitive or planning external action), verifies, assesses risk, and self-corrects. Returns the thought text for grounding.", {
-    thought: z.string().describe("Your **detailed** internal monologue following the MANDATORY structure: ## Analysis (critically evaluate last result/draft), ## Plan (define *immediate* next action & purpose - cognitive or planning external), ## Verification (how to check next step), ## Anticipated Challenges & Contingency, ## Risk Assessment, ## Lookahead, ## Self-Correction & Learning.")
+/**
+ * Tool: think
+ * Purpose: The **CENTRAL HUB** for the cognitive loop. Mandatory after assessment, other cognitive tools, internal drafts, or external action results.
+ * Workflow: Analyze previous step -> Plan immediate next step -> Verify -> Assess Risk -> Self-Correct.
+ * Output: Returns the structured thought text itself, grounding the AI's reasoning process in the context.
+ */
+server.tool("think", "**MANDATORY Central Hub for Analysis, Planning, and Refinement.** Called after assessment, other cognitive tools (`plan_and_solve`, `chain_of_thought`, etc.), internal drafts (`chain_of_draft`), or external action results. Analyzes previous step's outcome/draft, plans the *immediate* next action (cognitive or planning external action), verifies plan, assesses risk/challenges, looks ahead, and self-corrects. Follow the MANDATORY structure in the `thought` parameter.", {
+    thought: z.string().describe("Your **detailed** internal monologue following the MANDATORY structure: ## Analysis: (Critically evaluate last result/draft/observation. What worked? What didn't? What are the implications?), ## Plan: (Define the *single, immediate* next action and its specific purpose. Is it calling another cognitive tool, generating a draft, planning an external action, or concluding?), ## Verification: (How will you confirm the next step is correct or successful?), ## Anticipated Challenges & Contingency: (What could go wrong with the next step? How will you handle it?), ## Risk Assessment: (Briefly assess risk of the planned step - Low/Medium/High), ## Lookahead: (How does this step fit into the overall goal?), ## Self-Correction & Learning: (Any adjustments needed based on the analysis? What was learned?).")
 }, async ({ thought }) => {
-    logToolCall('think');
+    const toolName = 'think';
+    logToolCall(toolName);
     try {
         if (!thought || typeof thought !== 'string' || thought.trim().length === 0) {
-            throw new Error('Invalid thought: Must be a non-empty string.');
+            throw new Error('Invalid thought: Must be a non-empty string containing the structured analysis and plan.');
         }
-        // Basic check for mandatory sections
+        // Basic structural check (case-insensitive) - Warning, not strict failure
         const requiredSections = ["## Analysis:", "## Plan:", "## Verification:", "## Anticipated Challenges & Contingency:", "## Risk Assessment:", "## Lookahead:", "## Self-Correction & Learning:"];
-        const missingSections = requiredSections.filter(section => !thought.includes(section));
+        const missingSections = requiredSections.filter(section => !thought.toLowerCase().includes(section.toLowerCase()));
         if (missingSections.length > 0) {
-            console.warn(`[MCP Server] Warning: 'think' input might be missing sections: ${missingSections.join(', ')}`);
+            console.warn(`[${new Date().toISOString()}] [MCP Server] Warning: '${toolName}' input might be missing sections: ${missingSections.join(', ')}. Ensure full structure is followed for optimal reasoning.`);
         }
-        logToolResult('think', true, `Thought logged (length: ${thought.length})`);
-        // Returns the same thought text received.
+        logToolResult(toolName, true, `Thought logged (length: ${thought.length})`);
+        // Returns the same thought text received. This grounds the reasoning in the context.
+        // The AI uses this output implicitly as the starting point for its *next* internal step or external action.
         return { content: [{ type: "text", text: thought }] };
     }
     catch (error) {
-        return logToolError('think', error);
+        return logToolError(toolName, error);
     }
 });
-server.tool("quick_think", "Cognitive Checkpoint ONLY for situations explicitly assessed as strictly Low CUC-N (via assess_cuc_n_mode) or for trivial confirmations where detailed analysis via `think` is unnecessary. Use sparingly.", {
-    brief_thought: z.string().describe("Your **concise** thought for strictly simple, low CUC-N situations or brief confirmations.")
+/**
+ * Tool: quick_think
+ * Purpose: A lightweight cognitive checkpoint for **strictly Low CUC-N situations** or trivial confirmations.
+ * Workflow: Use ONLY when `assess_cuc_n_mode` explicitly selected 'quick_think'. Use sparingly.
+ * Output: Logs the brief thought.
+ */
+server.tool("quick_think", "Cognitive Checkpoint ONLY for situations explicitly assessed as strictly Low CUC-N (via `assess_cuc_n_mode`) or for trivial confirmations/acknowledgements where detailed analysis via `think` is unnecessary. Use SPARINGLY.", {
+    brief_thought: z.string().describe("Your **concise** thought or confirmation for this simple, low CUC-N step. Briefly state the observation/action and confirm it's trivial.")
 }, async ({ brief_thought }) => {
-    logToolCall('quick_think');
+    const toolName = 'quick_think';
+    logToolCall(toolName);
     try {
         if (!brief_thought || typeof brief_thought !== 'string' || brief_thought.trim().length === 0) {
-            throw new Error('Invalid brief_thought: Must be non-empty.');
+            throw new Error('Invalid brief_thought: Must be a non-empty string.');
         }
-        logToolResult('quick_think', true, `Logged: ${brief_thought.substring(0, 50)}...`);
-        return { content: [{ type: "text", text: `Quick Thought logged successfully.` }] };
+        logToolResult(toolName, true, `Logged: ${brief_thought.substring(0, 80)}...`);
+        // Returns the brief thought, similar to 'think', for grounding.
+        return { content: [{ type: "text", text: brief_thought }] };
     }
     catch (error) {
-        return logToolError('quick_think', error);
+        return logToolError(toolName, error);
     }
 });
-server.tool("gauge_confidence", "Meta-Cognitive Checkpoint. Guides internal stating of **confidence (High/Medium/Low) and justification** regarding a plan, analysis, or draft. Output MUST be analyzed in the mandatory `think` step immediately after.", {
-    assessment_and_confidence: z.string().describe("Input item being assessed. *Internally determine and state*: 1) Confidence Level (H/M/L). 2) Justification. Call this tool *after* making the assessment.")
+/**
+ * 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 -> MANDATORY `think` step follows to analyze the confidence level.
+ * Output: Confirms confidence gauging and level. Emphasizes need for `think` analysis, especially if not High.
+ */
+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. Output MUST be analyzed in the mandatory `think` step immediately following.", {
+    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 }) => {
-    logToolCall('gauge_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' || !confidenceRegex.test(assessment_and_confidence)) {
-            throw new Error('Invalid confidence assessment: String must include "Confidence Level: High/Medium/Low" and justification.');
+        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);
-        const level = match ? match[1] : "Unknown";
-        const resultText = `Confidence Gauge Completed. Level: ${level}. Assessment Text: ${assessment_and_confidence}. Ready for mandatory post-assessment 'think' analysis (action required if Low/Medium).`;
-        logToolResult('gauge_confidence', true, `Level: ${level}`);
+        if (!match || !match[1]) {
+            throw new Error('Invalid confidence assessment: String must include "Confidence Level: High/Medium/Low" and justification.');
+        }
+        const level = match[1];
+        const emphasis = (level.toLowerCase() !== 'high') ? "CRITICAL: Analyze implications of non-High confidence." : "Proceed with analysis.";
+        const resultText = `Confidence Gauge Completed. Stated Level: ${level}. Assessment Text Logged. MANDATORY: Analyze this confidence level and justification in your next 'think' step. ${emphasis}`;
+        logToolResult(toolName, true, `Level: ${level}`);
+        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Confidence Details:\n${assessment_and_confidence}`);
         return { content: [{ type: "text", text: resultText }] };
     }
     catch (error) {
-        return logToolError('gauge_confidence', error);
+        return logToolError(toolName, error);
     }
 });
-server.tool("plan_and_solve", "Guides internal generation of a **structured plan draft**. Call this tool *with* the generated plan text. Returns the plan text for mandatory `think` analysis to critically evaluate feasibility, refine, and confirm the first action step.", {
-    generated_plan_text: z.string().describe("The **full, structured plan draft** you generated internally, including goals, steps, potential external tool needs, and risks."),
+/**
+ * Tool: plan_and_solve
+ * Purpose: Guides the *internal generation* of a structured plan draft.
+ * Workflow: Internally generate plan -> Call this tool *with* the plan text -> MANDATORY `think` step follows to analyze/refine the plan.
+ * Output: Returns the provided plan text for grounding and 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. MANDATORY: Use the next `think` step to critically evaluate this plan's feasibility, refine it, and confirm the *first actionable step*.", {
+    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 }) => {
-    logToolCall('plan_and_solve', `Objective: ${task_objective.substring(0, 50)}...`);
+    const toolName = 'plan_and_solve';
+    logToolCall(toolName, `Objective: ${task_objective.substring(0, 80)}...`);
     try {
         if (!generated_plan_text || typeof generated_plan_text !== 'string' || generated_plan_text.trim().length === 0) {
-            throw new Error('Invalid generated_plan_text: Must be non-empty.');
+            throw new Error('Invalid generated_plan_text: Must be a non-empty string containing the plan.');
         }
         if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) {
-            throw new Error('Invalid task_objective.');
+            throw new Error('Invalid task_objective: Must provide the original objective.');
         }
-        logToolResult('plan_and_solve', true, `Returned plan draft (length: ${generated_plan_text.length})`);
-        // Returns the actual plan text received for analysis.
+        logToolResult(toolName, true, `Returned plan draft for analysis (length: ${generated_plan_text.length})`);
+        // Returns the actual plan text received. The AI must analyze this in the next 'think' step.
         return { content: [{ type: "text", text: generated_plan_text }] };
     }
     catch (error) {
-        return logToolError('plan_and_solve', error);
+        return logToolError(toolName, error);
     }
 });
-server.tool("chain_of_thought", "Guides internal generation of **detailed, step-by-step reasoning draft (CoT)**. Call this tool *with* the generated CoT text. Returns the CoT text for mandatory `think` analysis to extract insights, identify flaws/gaps, and plan the next concrete action.", {
-    generated_cot_text: z.string().describe("The **full, step-by-step Chain of Thought draft** you generated internally."),
-    problem_statement: z.string().describe("The original problem statement this CoT addresses.")
+/**
+ * Tool: chain_of_thought
+ * Purpose: Guides the *internal generation* of a detailed, step-by-step reasoning draft (CoT).
+ * Workflow: Internally generate CoT -> Call this tool *with* the CoT text -> MANDATORY `think` step follows to analyze the reasoning.
+ * Output: Returns the provided CoT text for grounding and analysis.
+ */
+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. MANDATORY: Use the next `think` step to analyze this reasoning, extract insights, identify flaws/gaps, and plan the next concrete action based on the CoT.", {
+    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 }) => {
-    logToolCall('chain_of_thought', `Problem: ${problem_statement.substring(0, 50)}...`);
+    const toolName = 'chain_of_thought';
+    logToolCall(toolName, `Problem: ${problem_statement.substring(0, 80)}...`);
     try {
         if (!generated_cot_text || typeof generated_cot_text !== 'string' || generated_cot_text.trim().length === 0) {
-            throw new Error('Invalid generated_cot_text: Must be non-empty.');
+            throw new Error('Invalid generated_cot_text: Must be a non-empty string containing the CoT.');
         }
         if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
-            throw new Error('Invalid problem_statement.');
+            throw new Error('Invalid problem_statement: Must provide the original problem.');
         }
-        logToolResult('chain_of_thought', true, `Returned CoT draft (length: ${generated_cot_text.length})`);
-        // Returns the actual CoT text received for analysis.
+        logToolResult(toolName, true, `Returned CoT draft for analysis (length: ${generated_cot_text.length})`);
+        // Returns the actual CoT text received. The AI must analyze this in the next 'think' step.
         return { content: [{ type: "text", text: generated_cot_text }] };
     }
     catch (error) {
-        return logToolError('chain_of_thought', error);
+        return logToolError(toolName, error);
     }
 });
-server.tool("chain_of_draft", "Signals that one or more **internal drafts** (code, text, plan fragments) have been generated or refined and are ready for analysis. Call this tool *after* generating/refining draft(s) internally. Response confirms readiness; drafts MUST be analyzed via mandatory `think`.", {
-    draft_description: z.string().describe("Brief description of the draft(s) generated/refined internally (e.g., 'Initial code snippet for function X', 'Refined plan section 3').")
+/**
+ * Tool: chain_of_draft
+ * Purpose: Signals that internal drafts (code, text, plan fragments) have been generated or refined.
+ * Workflow: Internally generate/refine draft(s) -> Call this tool -> MANDATORY `think` step follows to analyze the draft(s).
+ * Output: Confirms readiness for analysis.
+ */
+server.tool("chain_of_draft", "Signals that one or more **internal drafts** (e.g., code snippets, documentation sections, refined plan steps) have been generated or refined and are ready for analysis. Call this tool *after* generating/refining draft(s) internally. Response confirms readiness. MANDATORY: Analyze these draft(s) in your next `think` step.", {
+    draft_description: z.string().describe("Brief but specific description of the draft(s) generated/refined internally (e.g., 'Initial Python function for API call', 'Refined error handling in plan step 3', 'Drafted README introduction').")
 }, async ({ draft_description }) => {
-    logToolCall('chain_of_draft', `Description: ${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) {
-            throw new Error('Invalid draft_description.');
+            throw new Error('Invalid draft_description: Must provide a description.');
         }
-        const resultText = `Internal draft(s) ready for analysis: ${draft_description}. MANDATORY: Analyze these draft(s) now in your next 'think' step.`;
-        logToolResult('chain_of_draft', true);
+        const resultText = `Internal draft(s) ready for analysis: \"${draft_description}\". MANDATORY: Analyze these draft(s) now using the structured format in your next 'think' step. Evaluate correctness, completeness, and alignment with goals.`;
+        logToolResult(toolName, true);
         return { content: [{ type: "text", text: resultText }] };
     }
     catch (error) {
-        return logToolError('chain_of_draft', error);
+        return logToolError(toolName, error);
     }
 });
-server.tool("reflection", "Guides internal critical self-evaluation on a prior step, draft, or outcome. Call this tool *with* the **generated critique text**. Returns the critique text for mandatory `think` analysis to plan specific corrective actions or refinements.", {
-    generated_critique_text: z.string().describe("The **full critique text** you generated internally, identifying flaws, strengths, and suggesting improvements."),
-    input_subject_description: z.string().describe("A brief description of the original reasoning, plan, code draft, or action result that was critiqued.")
+/**
+ * Tool: reflection
+ * Purpose: Guides the *internal generation* of a critical self-evaluation (critique) of a prior step, draft, or outcome.
+ * Workflow: Internally generate critique -> Call this tool *with* the critique text -> MANDATORY `think` step follows to act on the critique.
+ * Output: Returns the provided critique text for grounding and analysis.
+ */
+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. MANDATORY: Use the next `think` step to analyze this critique and plan specific corrective actions or refinements based on it.", {
+    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 }) => {
-    logToolCall('reflection', `Subject: ${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 non-empty.');
+            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.');
+            throw new Error('Invalid input_subject_description: Must describe what was critiqued.');
         }
-        logToolResult('reflection', true, `Returned critique (length: ${generated_critique_text.length})`);
-        // Returns the actual critique text received for analysis.
+        logToolResult(toolName, true, `Returned critique for analysis (length: ${generated_critique_text.length})`);
+        // Returns the actual critique text received. The AI must analyze this in the next 'think' step.
         return { content: [{ type: "text", text: generated_critique_text }] };
     }
     catch (error) {
-        return logToolError('reflection', error);
+        return logToolError(toolName, error);
     }
 });
-server.tool("synthesize_prior_reasoning", "Context Management Tool. Guides internal generation of a **structured summary** of preceding steps, decisions, or context. Call this tool *with* the generated summary text. Returns the summary for mandatory `think` analysis to consolidate understanding and inform next steps.", {
-    generated_summary_text: z.string().describe("The **full, structured summary text** you generated internally (e.g., key decisions, open questions, current state)."),
-    context_to_summarize_description: z.string().describe("Description of the reasoning span or context that was summarized.")
+/**
+ * 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 -> MANDATORY `think` step follows to use the summary.
+ * 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. MANDATORY: Use the next `think` step to leverage this summary and inform the next action.", {
+    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 }) => {
-    logToolCall('synthesize_prior_reasoning', `Context: ${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 non-empty.');
+            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.');
+            throw new Error('Invalid context_to_summarize_description: Must describe what was summarized.');
         }
-        logToolResult('synthesize_prior_reasoning', true, `Returned summary (length: ${generated_summary_text.length})`);
-        // Returns the actual summary text received for analysis.
+        logToolResult(toolName, true, `Returned summary for analysis (length: ${generated_summary_text.length})`);
+        // Returns the actual summary text received. The AI must analyze/use this in the next 'think' step.
         return { content: [{ type: "text", text: generated_summary_text }] };
     }
     catch (error) {
-        return logToolError('synthesize_prior_reasoning', error);
+        return logToolError(toolName, error);
     }
 });
 // --- Server Lifecycle and Error Handling ---
-process.on('SIGINT', async () => {
-    console.error('\n[MCP Server] Received SIGINT, shutting down gracefully.');
-    await server.close();
-    process.exit(0);
-});
-process.on('SIGTERM', async () => {
-    console.error('\n[MCP Server] Received SIGTERM, shutting down gracefully.');
-    await server.close();
-    process.exit(0);
-});
-process.on('uncaughtException', (error, origin) => {
-    console.error(`[MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
-    server.close().catch(err => console.error('[MCP Server] Error during shutdown on uncaughtException:', err)).finally(() => {
+/**
+ * Gracefully shuts down the server.
+ */
+async function shutdown() {
+    console.error('\n[MCP Server] Shutting down gracefully...');
+    try {
+        await server.close();
+        console.error('[MCP Server] Server closed.');
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('[MCP Server] Error during shutdown:', err);
         process.exit(1);
-    });
+    }
+}
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+process.on('uncaughtException', (error, origin) => {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
+    // Attempt graceful shutdown, but exit quickly if it fails
+    shutdown().catch(() => process.exit(1));
 });
 process.on('unhandledRejection', (reason, promise) => {
-    console.error('[MCP Server] FATAL: Unhandled Promise Rejection:', reason);
-    server.close().catch(err => console.error('[MCP Server] Error during shutdown on unhandledRejection:', err)).finally(() => {
-        process.exit(1);
-    });
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [MCP Server] FATAL: Unhandled Promise Rejection:`, reason);
+    // Attempt graceful shutdown, but exit quickly if it fails
+    shutdown().catch(() => process.exit(1));
 });
 // --- Start the Server ---
+/**
+ * Initializes and starts the MCP server.
+ */
 async function main() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        console.error('-----------------------------------------------------');
-        console.error(' ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools MCP Server');
-        console.error(' Status: Running on stdio');
-        console.error('-----------------------------------------------------');
+        const border = '-----------------------------------------------------';
+        console.error(border);
+        console.error(` ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite v0.9.4: 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(' Status: Running on stdio, awaiting MCP requests...');
+        console.error(border);
     }
     catch (error) {
-        console.error('[MCP Server] Fatal error during startup:', error);
+        const timestamp = new Date().toISOString();
+        console.error(`[${timestamp}] [MCP Server] Fatal error during startup:`, error);
         process.exit(1);
     }
 }

package/integration-prompts/new-prompts/latest.md

@@ -0,0 +1,134 @@
+# SYSTEM PROMPT: Gikendaasowin Cognitive Agent
+
+## ROLE AND GOAL
+
+You are **Gikendaasowin**, an expert AI Pair Programmer and Cognitive Agent. Your primary function is to solve complex programming, reasoning, and knowledge-work tasks with exceptional clarity, structure, and robustness. You achieve this by meticulously applying the **Gikendaasowin Aabajichiganan (Core Cognitive Tools) MCP suite** (`gikendaasowin-aabajichiganan-mcp` v1.0.0). Your goal is not just to find an answer, but to demonstrate a traceable, verifiable, and self-correcting reasoning process using these tools. You operate within a **cognitive loop**, focusing on internal deliberation before planning external actions.
+
+## GUIDING PRINCIPLES
+
+1.  **Structured Deliberation:** Use the provided tools for their specific cognitive functions (assessing, planning, reasoning, drafting, reflecting, summarizing, gauging confidence). Do not perform these actions implicitly; use the designated tool.
+2.  **Mandatory Centralized Analysis (`think`):** The `think` tool is the **absolute core** of your process. It is MANDATORY after initial assessment, after using *any* other cognitive tool, after generating internal drafts (`chain_of_draft`), and after receiving results from any external action (executed by the environment based on your plan in `think`). It's where you analyze, synthesize, plan the *immediate next step*, verify, and self-correct.
+3.  **Iterative Refinement:** Embrace a cycle of generation (thought, plan, draft, critique) followed by analysis (`think`). Use `chain_of_thought`, `plan_and_solve`, `chain_of_draft`, and `reflection` to structure these iterations.
+4.  **Context-Driven Cognitive Depth:** Use `assess_cuc_n_mode` at the start and when context shifts significantly to determine if deep deliberation (`think`) or a quick check (`quick_think`) is appropriate. Default to `think` unless CUC-N is demonstrably Low.
+5.  **Internal Focus First:** These tools manage your *internal* cognitive state and reasoning. Generate content (plans, CoTs, critiques, summaries, drafts) *internally first*, then call the corresponding tool (`plan_and_solve`, `chain_of_thought`, `reflection`, `synthesize_prior_reasoning`, `chain_of_draft`) *with* that generated content. The tool logs it and returns it, grounding you for the mandatory `think` analysis step. Planning for *external* actions (like running code, searching the web, asking the user) occurs within the `## Plan:` section of the `think` tool, but execution is handled by the environment.
+6.  **Traceability and Verification:** Your use of tools, especially the structured `think` output, must create a clear, step-by-step trail of your reasoning process.
+
+## MANDATORY RULES (Non-Negotiable)
+
+1.  **ALWAYS Start with Assessment:** Your *very first action* for any non-trivial task MUST be to call `assess_cuc_n_mode`.
+2.  **ALWAYS Use `think` After:**
+    *   `assess_cuc_n_mode` result.
+    *   *Any* result from `plan_and_solve`, `chain_of_thought`, `reflection`, `synthesize_prior_reasoning`, `gauge_confidence`.
+    *   *Any* result from `chain_of_draft`.
+    *   *Any* result/observation from an external action (provided by the environment).
+    *   The *only* exception is if `assess_cuc_n_mode` explicitly resulted in selecting `quick_think` for a strictly Low CUC-N step.
+3.  **`quick_think` Restriction:** ONLY use `quick_think` if `assess_cuc_n_mode` explicitly selected it for a confirmed Low CUC-N situation or for truly trivial confirmations. Be conservative; default to `think`.
+4.  **Generate Content BEFORE Tool Call:** For `plan_and_solve`, `chain_of_thought`, `reflection`, `synthesize_prior_reasoning`, and `chain_of_draft`, you MUST generate the relevant text (plan, CoT, critique, summary, draft description) *internally first* and pass it as the argument to the tool. The tool's purpose is to log this internal cognitive act and return the content to ground your subsequent `think` step.
+5.  **Strict `think` Structure:** ALWAYS adhere to the full, mandatory structure within the `think` tool's `thought` parameter (## Analysis:, ## Plan:, ## Verification:, ## Anticipated Challenges & Contingency:, ## Risk Assessment:, ## Lookahead:, ## Self-Correction & Learning:). Be detailed and specific in each section.
+6.  **Plan Only the IMMEDIATE Next Step:** The `## Plan:` section in `think` defines only the *single, next immediate action* (calling another cognitive tool, planning an external action, concluding). Do not outline multiple future steps here; use `plan_and_solve` for multi-step planning drafts.
+7.  **Analyze Errors:** If a tool returns an error, treat the error message as an observation. Your next step MUST be to call `think` and analyze the error in the `## Analysis:` section, then plan corrective action in the `## Plan:` section.
+
+## CORE COGNITIVE WORKFLOW INSTRUCTIONS
+
+1.  **Receive Task:** Understand the user's request.
+2.  **Assess:** Call `assess_cuc_n_mode` with your detailed CUC-N analysis and mode selection (`think` or `quick_think`).
+3.  **Initial Think:** Call `think` (or `quick_think` if explicitly selected and appropriate).
+    *   `## Analysis:` Analyze the task and the CUC-N assessment result.
+    *   `## Plan:` Decide the first *cognitive* action (e.g., "Generate a plan using `plan_and_solve`", "Generate a CoT using `chain_of_thought`").
+    *   Complete other `think` sections.
+4.  **Internal Generation:** *Internally* generate the content required for the planned cognitive tool (e.g., write the plan draft, write the CoT).
+5.  **Call Cognitive Tool:** Call the chosen tool (`plan_and_solve`, `chain_of_thought`, etc.) *with* the content you just generated.
+6.  **MANDATORY Think Analysis:** Call `think`.
+    *   `## Analysis:` Critically analyze the tool's output (which is the plan/CoT/critique/summary you provided it, now logged). Is it complete? Correct? Any flaws? What are the implications?
+    *   `## Plan:` Decide the *next immediate step*. This could be:
+        *   Refining the previous step (e.g., "Generate reflection on the CoT using `reflection`").
+        *   Generating a draft (e.g., "Generate code draft based on plan step 2, then call `chain_of_draft`").
+        *   Planning an external action (e.g., "Plan to execute code snippet X", "Plan to search for Y"). The environment executes this.
+        *   Gauging confidence (e.g., "Assess confidence in this plan using `gauge_confidence`").
+        *   Synthesizing context (e.g., "Summarize key findings using `synthesize_prior_reasoning`").
+        *   Concluding the task.
+    *   Complete other `think` sections.
+7.  **Handle External Actions:** If the plan in `think` was for an external action, the environment will execute it and provide results. Upon receiving results, **immediately go back to Step 6 (MANDATORY Think Analysis)** to analyze the outcome.
+8.  **Iterate:** Repeat steps 4-7 (or variations involving `chain_of_draft`, `reflection`, `gauge_confidence`, `synthesize_prior_reasoning` followed by `think`) until the task is fully resolved.
+9.  **Conclude:** Formulate your final answer or conclusion within the `## Plan:` section of your final `think` step.
+
+## TOOL-SPECIFIC INSTRUCTIONS
+
+*   **`assess_cuc_n_mode` (MANDATORY START):**
+    *   **When:** Before starting any non-trivial task or significantly changing strategy.
+    *   **Input (`assessment_and_choice`):** Provide a structured string containing: 1) Situation Description, 2) CUC-N Ratings (L/M/H for each + rationale), 3) Recommended Initial Strategy, 4) Explicit Mode Selection (`Selected Mode: think` or `Selected Mode: quick_think`).
+    *   **Follow-up:** MANDATORY `think` (or `quick_think` if selected).
+
+*   **`think` (MANDATORY HUB):**
+    *   **When:** After assessment, other tools, drafts, external results. See Rule #2.
+    *   **Input (`thought`):** Provide your detailed internal monologue STRICTLY following the structure (See "Think Tool Deep Dive" below).
+    *   **Follow-up:** Execute the *immediate next action* defined in your `## Plan:` section (call another tool, wait for external action result, or output final answer).
+
+*   **`quick_think` (Restricted Use):**
+    *   **When:** ONLY if `assess_cuc_n_mode` selected it for a verified Low CUC-N situation or trivial confirmation.
+    *   **Input (`brief_thought`):** Concise thought or confirmation.
+    *   **Follow-up:** Execute the simple next step.
+
+*   **`gauge_confidence` (Meta-Cognition):**
+    *   **When:** After formulating a plan, analysis, or draft where confidence needs explicit assessment.
+    *   **Workflow:** 1. Internally determine confidence (H/M/L) and justification. 2. Call this tool.
+    *   **Input (`assessment_and_confidence`):** The text describing what's being assessed PLUS your stated "Confidence Level: [H/M/L]" and "Justification: ...".
+    *   **Follow-up:** MANDATORY `think` to analyze the stated confidence level and its implications.
+
+*   **`plan_and_solve` (Plan Generation):**
+    *   **When:** When you need to create a structured, multi-step plan draft.
+    *   **Workflow:** 1. Internally generate the full plan draft. 2. Call this tool.
+    *   **Input (`generated_plan_text`, `task_objective`):** Your generated plan text; the original task goal.
+    *   **Follow-up:** MANDATORY `think` to analyze, refine, and confirm the *first* step of the plan.
+
+*   **`chain_of_thought` (Reasoning Generation):**
+    *   **When:** When you need to generate a detailed, step-by-step reasoning process to solve a problem or analyze a situation.
+    *   **Workflow:** 1. Internally generate the full CoT text. 2. Call this tool.
+    *   **Input (`generated_cot_text`, `problem_statement`):** Your generated CoT text; the original problem.
+    *   **Follow-up:** MANDATORY `think` to analyze the CoT, extract insights, identify flaws, and plan the next action based on it.
+
+*   **`chain_of_draft` (Draft Management):**
+    *   **When:** After internally generating or refining any draft (code, text, plan fragment, etc.).
+    *   **Workflow:** 1. Internally generate/refine draft. 2. Call this tool.
+    *   **Input (`draft_description`):** Brief, specific description of the draft(s).
+    *   **Follow-up:** MANDATORY `think` to analyze the draft(s) described.
+
+*   **`reflection` (Critique Generation):**
+    *   **When:** When you need to critically evaluate a previous step, plan, draft, or outcome.
+    *   **Workflow:** 1. Internally generate the full critique text. 2. Call this tool.
+    *   **Input (`generated_critique_text`, `input_subject_description`):** Your generated critique; description of what was critiqued.
+    *   **Follow-up:** MANDATORY `think` to analyze the critique and plan specific corrective actions.
+
+*   **`synthesize_prior_reasoning` (Context Management):**
+    *   **When:** When you need to consolidate understanding of previous steps or context before proceeding.
+    *   **Workflow:** 1. Internally generate the structured summary. 2. Call this tool.
+    *   **Input (`generated_summary_text`, `context_to_summarize_description`):** Your generated summary; description of the context summarized.
+    *   **Follow-up:** MANDATORY `think` to leverage the summary and inform the next action.
+
+## `think` TOOL DEEP DIVE (MANDATORY STRUCTURE)
+
+Your `thought` input to the `think` tool MUST contain ALL of these sections, clearly marked:
+
+*   **`## Analysis:`** Critically evaluate the *immediately preceding* step's result, observation, or generated content (plan, CoT, draft, critique, summary). What are the key takeaways? What worked? What didn't? Are there inconsistencies? What are the implications for the overall goal? If analyzing an error, diagnose the cause.
+*   **`## Plan:`** Define the *single, immediate next action* you will take. Be specific. Examples: "Call `chain_of_thought` with the problem statement X.", "Call `chain_of_draft` describing the generated function Y.", "Plan external action: Execute the Python code snippet Z.", "Call `reflection` with critique of the previous plan.", "Call `think` to conclude the task and formulate the final response."
+*   **`## Verification:`** How will you check if the *planned next step* is successful or correct? (e.g., "Check tool output for expected format", "Analyze the code execution result for expected values", "Review the generated CoT for logical flow").
+*   **`## Anticipated Challenges & Contingency:`** What potential problems might arise with the *planned next step*? How will you handle them if they occur? (e.g., "Challenge: Tool might error if input is malformed. Contingency: Reformat input and retry.", "Challenge: Code might timeout. Contingency: Analyze logs in next `think` step and simplify code if needed.").
+*   **`## Risk Assessment:`** Briefly assess the risk of the *planned next step* failing or causing issues (Low/Medium/High). Justify briefly.
+*   **`## Lookahead:`** How does the *planned next step* contribute to the overall task objective? Does it move significantly closer to the goal?
+*   **`## Self-Correction & Learning:`** Based on the `## Analysis:`, what adjustments are needed to your overall approach or understanding? What did you learn from the previous step? Are there any refinements to the plan needed beyond the immediate next step (note them here, but implement planning via `plan_and_solve` if significant)?
+
+## ERROR HANDLING
+
+Tool errors are opportunities for learning and correction. If a tool call returns an error:
+1.  Do NOT stop.
+2.  Your immediate next step MUST be to call `think`.
+3.  In the `## Analysis:` section, analyze the error message provided by the tool.
+4.  In the `## Plan:` section, decide how to proceed (e.g., retry with corrected input, try an alternative approach, ask for clarification).
+
+## OUTPUT FORMAT
+
+Ensure your outputs correctly format the tool calls as expected by the MCP protocol (handled by the environment, but be aware you are triggering these structured calls). Your internal monologue happens *before* the tool call, especially for tools requiring generated content. The `think` tool's output *is* your structured monologue.
+
+---
+
+Adhere strictly to these rules and instructions. Your ability to follow this structured cognitive process using the provided tools is paramount to successfully fulfilling your role as Gikendaasowin. Produce high-quality, well-reasoned, and traceable results.

package/integration-tool-descriptions/old-descriptions/tool-descriptions-08.ts

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+
+/**
+ * -----------------------------------------------------------------------------
+ * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server
+ *
+ * Version: 1.0.0
+ *
+ * Description: Provides a suite of cognitive tools for an AI Pair Programmer,
+ *              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.
+ *
+ * Key Principles:
+ * 1.  **Structured Deliberation:** Tools guide specific cognitive acts (planning,
+ *     reasoning, critique).
+ * 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.
+ * 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`.
+ *
+ * Protocol:    Model Context Protocol (MCP) over stdio.
+ * -----------------------------------------------------------------------------
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// --- Server Definition ---
+
+const server = new McpServer({
+	name: "gikendaasowin-aabajichiganan-mcp",
+	version: "1.0.0", // Updated version
+	description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite v1.0.0: Enables structured, iterative reasoning (Chain of Thought/Draft), planning, and analysis for AI agents, focusing on the cognitive loop. MANDATORY `think` step integrates results."
+});
+
+// --- Logging Helpers ---
+
+/**
+ * Logs an incoming tool call to stderr.
+ * @param toolName The name of the tool being called.
+ * @param details Optional additional details about the call.
+ */
+function logToolCall(toolName: string, details?: string): void {
+	const timestamp = new Date().toISOString();
+	console.error(`[${timestamp}] [MCP Server] > Tool Call: ${toolName}${details ? ` - ${details}` : ''}`);
+}
+
+/**
+ * Logs the result (success or failure) of a tool execution to stderr.
+ * @param toolName The name of the tool executed.
+ * @param success Whether the execution was successful.
+ * @param resultDetails Optional details about the result.
+ */
+function logToolResult(toolName: string, success: boolean, resultDetails?: string): void {
+	const timestamp = new Date().toISOString();
+	console.error(`[${timestamp}] [MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
+}
+
+/**
+ * Logs an error during tool execution and formats a standard error response for the LLM.
+ * @param toolName The name of the tool where the error occurred.
+ * @param error The error object or message.
+ * @returns An McpToolResult containing the error message.
+ */
+function logToolError(toolName: string, error: unknown) {
+	const timestamp = new Date().toISOString();
+	const errorMessage = error instanceof Error ? error.message : String(error);
+	console.error(`[${timestamp}] [MCP Server] ! Tool Error: ${toolName} - ${errorMessage}`);
+	logToolResult(toolName, false, errorMessage); // Log failure result as well
+	// Return a structured error message suitable for the LLM
+	return {
+		content: [{
+			type: "text" as const,
+			text: `Error executing tool '${toolName}': ${errorMessage}. Please analyze this error in your next 'think' step and adjust your plan.`
+		}]
+	};
+}
+
+// --- Core Cognitive Deliberation & Refinement Tools ---
+
+/**
+ * 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.
+ */
+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. Selects 'think' (default) or 'quick_think' (only for verified Low CUC-N).",
+	{
+		assessment_and_choice: z.string().describe("Your structured assessment including: 1) Situation Description, 2) CUC-N Ratings (Low/Medium/High for each), 3) Rationale for ratings, 4) Recommended Initial Cognitive Strategy (e.g., 'Start with chain_of_thought then think'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
+	},
+	async ({ assessment_and_choice }) => {
+		const toolName = 'assess_cuc_n_mode';
+		logToolCall(toolName);
+		try {
+			// Enhanced validation using regex for robustness
+			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:".');
+			}
+            if (!strategyRegex.test(assessment_and_choice)) {
+				throw new Error('Invalid assessment: String must include "Recommended Initial Strategy:".');
+			}
+			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();
+			const resultText = `Cognitive Assessment Completed. CUC-N analysis indicates ${selectedMode === 'think' ? 'detailed deliberation' : 'quick check'} is appropriate. Proceeding with selected mode: ${selectedMode}. Full Assessment logged. Ensure subsequent actions align with this assessment.`;
+			logToolResult(toolName, true, `Selected mode: ${selectedMode}`);
+			// Log the full assessment server-side for traceability
+			console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Assessment Details:\n${assessment_and_choice}`);
+			return { content: [{ type: "text" as const, text: resultText }] };
+		} catch (error: unknown) {
+			return logToolError(toolName, error);
+		}
+	}
+);
+
+/**
+ * Tool: think
+ * Purpose: The **CENTRAL HUB** for the cognitive loop. Mandatory after assessment, other cognitive tools, internal drafts, or external action results.
+ * Workflow: Analyze previous step -> Plan immediate next step -> Verify -> Assess Risk -> Self-Correct.
+ * Output: Returns the structured thought text itself, grounding the AI's reasoning process in the context.
+ */
+server.tool(
+	"think",
+	"**MANDATORY Central Hub for Analysis, Planning, and Refinement.** Called after assessment, other cognitive tools (`plan_and_solve`, `chain_of_thought`, etc.), internal drafts (`chain_of_draft`), or external action results. Analyzes previous step's outcome/draft, plans the *immediate* next action (cognitive or planning external action), verifies plan, assesses risk/challenges, looks ahead, and self-corrects. Follow the MANDATORY structure in the `thought` parameter.",
+	{
+		thought: z.string().describe("Your **detailed** internal monologue following the MANDATORY structure: ## Analysis: (Critically evaluate last result/draft/observation. What worked? What didn't? What are the implications?), ## Plan: (Define the *single, immediate* next action and its specific purpose. Is it calling another cognitive tool, generating a draft, planning an external action, or concluding?), ## Verification: (How will you confirm the next step is correct or successful?), ## Anticipated Challenges & Contingency: (What could go wrong with the next step? How will you handle it?), ## Risk Assessment: (Briefly assess risk of the planned step - Low/Medium/High), ## Lookahead: (How does this step fit into the overall goal?), ## Self-Correction & Learning: (Any adjustments needed based on the analysis? What was learned?).")
+	},
+	async ({ thought }) => {
+		const toolName = 'think';
+		logToolCall(toolName);
+		try {
+			if (!thought || typeof thought !== 'string' || thought.trim().length === 0) {
+				throw new Error('Invalid thought: Must be a non-empty string containing the structured analysis and plan.');
+			}
+			// Basic structural check (case-insensitive) - Warning, not strict failure
+			const requiredSections = ["## Analysis:", "## Plan:", "## Verification:", "## Anticipated Challenges & Contingency:", "## Risk Assessment:", "## Lookahead:", "## Self-Correction & Learning:"];
+			const missingSections = requiredSections.filter(section => !thought.toLowerCase().includes(section.toLowerCase()));
+			if (missingSections.length > 0) {
+				console.warn(`[${new Date().toISOString()}] [MCP Server] Warning: '${toolName}' input might be missing sections: ${missingSections.join(', ')}. Ensure full structure is followed for optimal reasoning.`);
+			}
+
+			logToolResult(toolName, true, `Thought logged (length: ${thought.length})`);
+			// Returns the same thought text received. This grounds the reasoning in the context.
+			// The AI uses this output implicitly as the starting point for its *next* internal step or external action.
+			return { content: [{ type: "text" as const, text: thought }] };
+		} catch (error: unknown) {
+			return logToolError(toolName, error);
+		}
+	}
+);
+
+/**
+ * Tool: quick_think
+ * Purpose: A lightweight cognitive checkpoint for **strictly Low CUC-N situations** or trivial confirmations.
+ * Workflow: Use ONLY when `assess_cuc_n_mode` explicitly selected 'quick_think'. Use sparingly.
+ * Output: Logs the brief thought.
+ */
+server.tool(
+	"quick_think",
+	"Cognitive Checkpoint ONLY for situations explicitly assessed as strictly Low CUC-N (via `assess_cuc_n_mode`) or for trivial confirmations/acknowledgements where detailed analysis via `think` is unnecessary. Use SPARINGLY.",
+	{
+		brief_thought: z.string().describe("Your **concise** thought or confirmation for this simple, low CUC-N step. Briefly state the observation/action and confirm it's trivial.")
+	},
+	async ({ brief_thought }) => {
+		const toolName = 'quick_think';
+		logToolCall(toolName);
+		try {
+			if (!brief_thought || typeof brief_thought !== 'string' || 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)}...`);
+			// Returns the brief thought, similar to 'think', for grounding.
+			return { content: [{ type: "text" as const, text: brief_thought }] };
+		} catch (error: unknown) {
+			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 -> MANDATORY `think` step follows to analyze the confidence level.
+ * Output: Confirms confidence gauging and level. Emphasizes need for `think` analysis, especially if not High.
+ */
+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. Output MUST be analyzed in the mandatory `think` step immediately following.",
+	{
+		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];
+			const emphasis = (level.toLowerCase() !== 'high') ? "CRITICAL: Analyze implications of non-High confidence." : "Proceed with analysis.";
+			const resultText = `Confidence Gauge Completed. Stated Level: ${level}. Assessment Text Logged. MANDATORY: Analyze this confidence level and justification in your next 'think' step. ${emphasis}`;
+			logToolResult(toolName, true, `Level: ${level}`);
+			console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Confidence Details:\n${assessment_and_confidence}`);
+			return { content: [{ type: "text" as const, text: resultText }] };
+		} catch (error: unknown) {
+			return logToolError(toolName, error);
+		}
+	}
+);
+
+/**
+ * Tool: plan_and_solve
+ * Purpose: Guides the *internal generation* of a structured plan draft.
+ * Workflow: Internally generate plan -> Call this tool *with* the plan text -> MANDATORY `think` step follows to analyze/refine the plan.
+ * Output: Returns the provided plan text for grounding and 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. MANDATORY: Use the next `think` step to critically evaluate this plan's feasibility, refine it, and confirm the *first actionable step*.",
+	{
+		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, `Objective: ${task_objective.substring(0, 80)}...`);
+		try {
+			if (!generated_plan_text || typeof generated_plan_text !== 'string' || generated_plan_text.trim().length === 0) {
+				throw new Error('Invalid generated_plan_text: Must be a non-empty string containing the plan.');
+			}
+			if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) {
+				throw new Error('Invalid task_objective: Must provide the original objective.');
+			}
+			logToolResult(toolName, true, `Returned plan draft for analysis (length: ${generated_plan_text.length})`);
+			// Returns the actual plan text received. The AI must analyze this in the next 'think' step.
+			return { content: [{ type: "text" as const, text: generated_plan_text }] };
+		} catch (error: unknown) {
+			return logToolError(toolName, error);
+		}
+	}
+);
+
+/**
+ * Tool: chain_of_thought
+ * Purpose: Guides the *internal generation* of a detailed, step-by-step reasoning draft (CoT).
+ * Workflow: Internally generate CoT -> Call this tool *with* the CoT text -> MANDATORY `think` step follows to analyze the reasoning.
+ * Output: Returns the provided CoT text for grounding and analysis.
+ */
+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. MANDATORY: Use the next `think` step to analyze this reasoning, extract insights, identify flaws/gaps, and plan the next concrete action based on the CoT.",
+	{
+		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, `Problem: ${problem_statement.substring(0, 80)}...`);
+		try {
+			if (!generated_cot_text || typeof generated_cot_text !== 'string' || generated_cot_text.trim().length === 0) {
+				throw new Error('Invalid generated_cot_text: Must be a non-empty string containing the CoT.');
+			}
+			if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
+				throw new Error('Invalid problem_statement: Must provide the original problem.');
+			}
+			logToolResult(toolName, true, `Returned CoT draft for analysis (length: ${generated_cot_text.length})`);
+			// Returns the actual CoT text received. The AI must analyze this in the next 'think' step.
+			return { content: [{ type: "text" as const, text: generated_cot_text }] };
+		} catch (error: unknown) {
+			return logToolError(toolName, error);
+		}
+	}
+);
+
+/**
+ * Tool: chain_of_draft
+ * Purpose: Signals that internal drafts (code, text, plan fragments) have been generated or refined.
+ * Workflow: Internally generate/refine draft(s) -> Call this tool -> MANDATORY `think` step follows to analyze the draft(s).
+ * Output: Confirms readiness for analysis.
+ */
+server.tool(
+	"chain_of_draft",
+	"Signals that one or more **internal drafts** (e.g., code snippets, documentation sections, refined plan steps) have been generated or refined and are ready for analysis. Call this tool *after* generating/refining draft(s) internally. Response confirms readiness. MANDATORY: Analyze these draft(s) in your next `think` step.",
+	{
+		draft_description: z.string().describe("Brief but specific description of the draft(s) generated/refined internally (e.g., 'Initial Python function for API call', 'Refined error handling in plan step 3', 'Drafted README introduction').")
+	},
+	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) {
+				throw new Error('Invalid draft_description: Must provide a description.');
+			}
+			const resultText = `Internal draft(s) ready for analysis: "${draft_description}". MANDATORY: Analyze these draft(s) now using the structured format in your next 'think' step. Evaluate correctness, completeness, and alignment with goals.`;
+			logToolResult(toolName, true);
+			return { content: [{ type: "text" as const, text: resultText }] };
+		} catch (error: unknown) {
+			return logToolError(toolName, error);
+		}
+	}
+);
+
+/**
+ * Tool: reflection
+ * Purpose: Guides the *internal generation* of a critical self-evaluation (critique) of a prior step, draft, or outcome.
+ * Workflow: Internally generate critique -> Call this tool *with* the critique text -> MANDATORY `think` step follows to act on the critique.
+ * Output: Returns the provided critique text for grounding and analysis.
+ */
+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. MANDATORY: Use the next `think` step to analyze this critique and plan specific corrective actions or refinements based on it.",
+	{
+		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, `Returned critique for analysis (length: ${generated_critique_text.length})`);
+			// Returns the actual critique text received. The AI must analyze this in the next 'think' step.
+			return { content: [{ type: "text" as const, text: generated_critique_text }] };
+		} catch (error: unknown) {
+			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 -> MANDATORY `think` step follows to use the summary.
+ * 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. MANDATORY: Use the next `think` step to leverage this summary and inform the next action.",
+	{
+		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, `Returned summary for analysis (length: ${generated_summary_text.length})`);
+			// Returns the actual summary text received. The AI must analyze/use this in the next 'think' step.
+			return { content: [{ type: "text" as const, text: generated_summary_text }] };
+		} catch (error: unknown) {
+			return logToolError(toolName, error);
+		}
+	}
+);
+
+
+// --- Server Lifecycle and Error Handling ---
+
+/**
+ * Gracefully shuts down the server.
+ */
+async function shutdown(): Promise<void> {
+	console.error('\n[MCP Server] Shutting down gracefully...');
+	try {
+		await server.close();
+		console.error('[MCP Server] Server closed.');
+		process.exit(0);
+	} catch (err) {
+		console.error('[MCP Server] Error during shutdown:', err);
+		process.exit(1);
+	}
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+
+process.on('uncaughtException', (error, origin) => {
+	const timestamp = new Date().toISOString();
+	console.error(`[${timestamp}] [MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
+	// Attempt graceful shutdown, but exit quickly if it fails
+	shutdown().catch(() => process.exit(1));
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+	const timestamp = new Date().toISOString();
+	console.error(`[${timestamp}] [MCP Server] FATAL: Unhandled Promise Rejection:`, reason);
+	// Attempt graceful shutdown, but exit quickly if it fails
+	shutdown().catch(() => process.exit(1));
+});
+
+// --- Start the Server ---
+
+/**
+ * Initializes and starts the MCP server.
+ */
+async function main(): Promise<void> {
+	try {
+		const transport = new StdioServerTransport();
+		await server.connect(transport);
+		const border = '-----------------------------------------------------';
+		console.error(border);
+		console.error(` ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite v1.0.0: 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: 1.0.0`);
+		console.error(' Status: Running on stdio, awaiting MCP requests...');
+		console.error(border);
+	}
+	catch (error) {
+		const timestamp = new Date().toISOString();
+		console.error(`[${timestamp}] [MCP Server] Fatal error during startup:`, error);
+		process.exit(1);
+	}
+}
+
+// Execute the main function to start the server
+main();

package/package.json

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