@nbiish/cognitive-tools-mcp 0.8.0 → 0.8.2

package/README.md

@@ -18,7 +18,7 @@
   <hr width="50%">
 </div>
 
-ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.0): SOTA reasoning suite aligned with AI Pair Programmer Prompt v0.8.0+. Enforces mandatory structured deliberation via `think` after explicit assessment. Returns generated cognitive content (thoughts, plans, CoT, critiques, summaries) for explicit analysis, optimizing for cognitive enhancement. 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.
+ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.2): SOTA reasoning suite aligned with AI Pair Programmer Prompt v0.8.1+. Enforces structured deliberation via `think` after explicit assessment or action results. Returns generated cognitive content (thoughts, plans, CoT, critiques, summaries) for explicit analysis and action planning, optimizing for cognitive enhancement and effective tool integration. Features advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment & thought mode selection (`assess_complexity_and_select_thought_mode`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection.
 
 Known as:
 - Anishinaabemowin: [`@nbiish/gikendaasowin-aabajichiganan-mcp`](https://www.npmjs.com/package/@nbiish/gikendaasowin-aabajichiganan-mcp)
@@ -117,7 +117,7 @@ Or:
 - **Response Format**: Returns a confirmation message; the drafts you generated internally must be analyzed in the next step
 
 ### Mandatory Pre-Deliberation Assessment
-- **Purpose**: Must be called BEFORE every `think` or `quick_think`. Evaluates CUC-N, recommends strategy, commits to next thought mode.
+- **Purpose**: Must be called BEFORE initiating significant cognitive processes (`think`) or complex action sequences. Evaluates CUC-N, recommends strategy, commits to next thought mode.
 - **Input**: `assessment_and_choice` (string) - Your assessment including Situation Description, CUC-N Ratings, Recommended Strategy, and Selected Mode
 - **Response Format**: Returns confirmation with the selected mode
 
@@ -215,6 +215,8 @@ Example Response:
 
 ## Version History
 
+- **0.8.2**: Removed integration prompt references from codebase and made various refinements
+- **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

package/build/index.js

@@ -2,42 +2,51 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-// Create the MCP server - Version 0.8.0 reflects the change in tool signatures and return values
+// Create the MCP server - Version aligned with prompt
 const server = new McpServer({
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "0.8.0", // Updated version
-    description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.0): SOTA reasoning suite aligned with AI Pair Programmer Prompt v0.8.0+. Enforces mandatory structured deliberation via `think` after explicit assessment. Returns generated cognitive content (thoughts, plans, CoT, critiques, summaries) for explicit analysis, optimizing for cognitive enhancement."
+    version: "0.8.2", // Updated version to match prompt
+    description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.2): SOTA reasoning suite aligned with AI Pair Programmer Prompt v0.8.1+. Enforces structured deliberation via `think` after explicit assessment or action results. Returns generated cognitive content (thoughts, plans, CoT, critiques, summaries) for explicit analysis and action planning, optimizing for cognitive enhancement and effective tool integration."
 });
 // --- Core Cognitive Deliberation Tools ---
 server.tool("think", 
-// Main Description: Central hub, now returns the thought for explicit context.
-"MANDATORY Cognitive Hub for Medium/High CUC-N situations. Analyzes inputs/prior steps, plans, verifies, assesses risks, self-corrects. Returns the detailed thought text for explicit grounding in the next step.", {
+// Main Description: Central hub, returns thought for explicit context and action planning.
+"MANDATORY Cognitive Hub for planning, analysis (incl. prior action/tool results), verification, risk assessment, and self-correction. Called after assessment, complex cognitive tools, or external tool execution. Returns the detailed thought text for explicit grounding and to define the immediate next action.", {
     // Parameter Description: Input IS the thought.
-    thought: z.string().describe("Your **detailed** internal monologue following the MANDATORY structure: ## Analysis, ## Plan, ## Verification, ## Anticipated Challenges Analysis & Contingency, ## Risk Assessment, ## Lookahead, ## Self-Correction & Learning.")
+    thought: z.string().describe("Your **detailed** internal monologue following the MANDATORY structure: ## Analysis (incl. results of last action/tool call), ## Plan (defining immediate next action, incl. external tools), ## Verification, ## Anticipated Challenges Analysis & Contingency, ## Risk Assessment, ## Lookahead, ## Self-Correction & Learning.")
 }, async ({ thought }) => {
     if (!thought || typeof thought !== 'string' || thought.trim().length === 0) {
         throw new Error('Invalid thought: Must be non-empty, structured reasoning.');
     }
-    console.error(`[CognitiveToolsServer v0.8.0] Think Tool Received: ${thought.substring(0, 150)}...`);
+    // Ensure mandatory sections are mentioned (basic check)
+    const requiredSections = ["## Analysis:", "## Plan:", "## Verification:", "## Anticipated Challenges Analysis & Contingency:", "## Risk Assessment:", "## Lookahead:", "## Self-Correction & Learning:"];
+    // Simple check for presence; more robust parsing could be added if needed
+    const hasRequiredSections = requiredSections.every(section => thought.includes(section));
+    if (!hasRequiredSections) {
+        console.warn(`[CognitiveToolsServer v0.8.2] Warning: 'think' input might be missing some mandatory sections.`);
+        // Decide whether to throw error or just warn. Warning allows flexibility.
+        // throw new Error('Invalid thought: Missing one or more mandatory sections (## Analysis:, ## Plan:, etc.).');
+    }
+    console.error(`[CognitiveToolsServer v0.8.2] Think Tool Received: ${thought.substring(0, 150)}...`);
     // Returns the same thought text received, making it explicit in context.
     return { content: [{ type: "text", text: thought }] };
 });
 server.tool("quick_think", 
-// Main Description: Unchanged - simple confirmation is sufficient here.
-"Cognitive Checkpoint ONLY for situations explicitly assessed as strictly Low CUC-N AND simple task nature. Use sparingly. Logs brief thought.", {
-    brief_thought: z.string().describe("Your **concise** thought for strictly simple, low CUC-N situations confirmed by prior assessment.")
+// Main Description: Unchanged.
+"Cognitive Checkpoint ONLY for situations explicitly assessed as strictly Low CUC-N AND simple task nature/confirmation. Use sparingly. Logs brief thought.", {
+    brief_thought: z.string().describe("Your **concise** thought for strictly simple, low CUC-N situations confirmed by prior assessment or for brief confirmations.")
 }, async ({ brief_thought }) => {
     if (!brief_thought || typeof brief_thought !== 'string' || brief_thought.trim().length === 0) {
         throw new Error('Invalid brief_thought: Must be non-empty.');
     }
-    console.error(`[CognitiveToolsServer v0.8.0] QuickThink Tool Logged: ${brief_thought.substring(0, 100)}...`);
+    console.error(`[CognitiveToolsServer v0.8.2] QuickThink Tool Logged: ${brief_thought.substring(0, 100)}...`);
     // Simple confirmation remains appropriate for quick_think.
     return { content: [{ type: "text", text: `Quick Thought logged successfully.` }] };
 });
-// --- Mandatory Meta-Cognitive Tools (Responses remain concise confirmations) ---
-server.tool("assess_cuc_n_mode", 
-// Main Description: Unchanged.
-"**Mandatory Pre-Deliberation Assessment.** Must be called BEFORE every `think` or `quick_think`. Evaluates CUC-N, recommends strategy, commits to next thought mode.", {
+// --- Mandatory Meta-Cognitive Tools ---
+server.tool("assess_complexity_and_select_thought_mode", // Renamed for clarity from assess_cuc_n_mode
+// Main Description: Updated name, emphasizes role.
+"**Mandatory Pre-Deliberation/Pre-Sequence Assessment.** Must be called BEFORE initiating significant cognitive processes (`think`) or complex action sequences. Evaluates CUC-N, recommends strategy, commits to next thought mode.", {
     // Parameter Description: Unchanged.
     assessment_and_choice: z.string().describe("Input your assessment *before* calling. MUST include: 1) Situation Description, 2) CUC-N Ratings (L/M/H), 3) Recommended Initial Strategy, 4) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
 }, async ({ assessment_and_choice }) => {
@@ -47,13 +56,13 @@ server.tool("assess_cuc_n_mode",
     if (!assessment_and_choice || typeof assessment_and_choice !== 'string' || !hasRequiredPhrases || !hasModeSelection) {
         throw new Error('Invalid assessment: String must include CUC-N ratings, Recommended Initial Strategy, and explicit Selected Mode ("think" or "quick_think").');
     }
-    console.error(`[CognitiveToolsServer v0.8.0] AssessComplexity Tool Signaled: ${assessment_and_choice.substring(0, 150)}...`);
+    console.error(`[CognitiveToolsServer v0.8.2] AssessComplexity Tool Signaled: ${assessment_and_choice.substring(0, 150)}...`);
     const mode = assessment_and_choice.includes("Selected Mode: think") ? "think" : "quick_think";
     // Confirmation guides the next step.
     return { content: [{ type: "text", text: `Cognitive Assessment Completed. Proceeding with selected mode: ${mode}. Full Assessment: ${assessment_and_choice}` }] };
 });
 server.tool("gauge_confidence", 
-// Main Description: Unchanged.
+// Main Description: Emphasizes mandatory analysis.
 "Meta-Cognitive Checkpoint. Guides internal stating of **confidence (High/Medium/Low) and justification**. Output MUST be analyzed in the mandatory `think` step immediately after; Low/Medium confidence requires specific action planning.", {
     // Parameter Description: Unchanged.
     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.")
@@ -64,17 +73,17 @@ server.tool("gauge_confidence",
     }
     const match = assessment_and_confidence.match(confidenceRegex);
     const level = match ? match[1] : "Unknown";
-    console.error(`[CognitiveToolsServer v0.8.0] GaugeConfidence Tool Signaled: Level ${level}`);
+    console.error(`[CognitiveToolsServer v0.8.2] GaugeConfidence Tool Signaled: Level ${level}`);
     // Confirmation includes level, prepares for mandatory analysis.
     return { content: [{ type: "text", text: `Confidence Gauge Completed. Level: ${level}. Assessment Text: ${assessment_and_confidence}. Ready for mandatory post-assessment 'think' analysis (action required if Low/Medium).` }] };
 });
-// --- Supporting Cognitive Strategy Tools (Now Accept & Return Generated Text) ---
+// --- Supporting Cognitive Strategy Tools (Accept & Return Generated Text for Analysis) ---
 server.tool("plan_and_solve", 
-// Main Description: Now returns the plan text itself.
-"Guides internal generation of **structured plan text** (incl. Risks/Challenges, potential tool needs). Call this tool *with* the generated plan text. Returns the plan text for mandatory `think` analysis.", {
-    // NEW Parameter: Accepts the generated plan.
+// Main Description: Returns plan text for analysis and action planning.
+"Guides internal generation of **structured plan text** (incl. Risks/Challenges, potential tool needs). Call this tool *with* the generated plan text. Returns the plan text for mandatory `think` analysis to confirm/refine the immediate next step.", {
+    // Parameter: Accepts the generated plan.
     generated_plan_text: z.string().describe("The **full, structured plan text** you generated internally, including Anticipated Challenges/Risks and potential other tool needs."),
-    task_objective: z.string().describe("The original high-level task objective this plan addresses.") // Keep original objective for context logging.
+    task_objective: z.string().describe("The original high-level task objective this plan addresses.")
 }, async ({ generated_plan_text, task_objective }) => {
     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.');
@@ -82,16 +91,16 @@ server.tool("plan_and_solve",
     if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) {
         throw new Error('Invalid task_objective.');
     }
-    console.error(`[CognitiveToolsServer v0.8.0] PlanAndSolve Tool Received Plan for Objective: ${task_objective.substring(0, 100)}...`);
-    // Returns the actual plan text received.
+    console.error(`[CognitiveToolsServer v0.8.2] PlanAndSolve Tool Received Plan for Objective: ${task_objective.substring(0, 100)}...`);
+    // Returns the actual plan text received for analysis.
     return { content: [{ type: "text", text: generated_plan_text }] };
 });
 server.tool("chain_of_thought", 
-// Main Description: Now returns the CoT text itself.
-"Guides internal generation of **detailed, step-by-step reasoning text (CoT)**. Call this tool *with* the generated CoT text. Returns the CoT text for mandatory `think` analysis.", {
-    // NEW Parameter: Accepts the generated CoT.
+// Main Description: Returns CoT text for analysis and action planning.
+"Guides internal generation of **detailed, step-by-step reasoning text (CoT)**. Call this tool *with* the generated CoT text. Returns the CoT text for mandatory `think` analysis to extract insights and plan the next action.", {
+    // Parameter: Accepts the generated CoT.
     generated_cot_text: z.string().describe("The **full, step-by-step Chain of Thought text** you generated internally, potentially noting needs for other tools."),
-    problem_statement: z.string().describe("The original problem statement this CoT addresses.") // Keep original problem statement for context logging.
+    problem_statement: z.string().describe("The original problem statement this CoT addresses.")
 }, async ({ generated_cot_text, problem_statement }) => {
     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.');
@@ -99,12 +108,12 @@ server.tool("chain_of_thought",
     if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
         throw new Error('Invalid problem_statement.');
     }
-    console.error(`[CognitiveToolsServer v0.8.0] ChainOfThought Tool Received CoT for Problem: ${problem_statement.substring(0, 100)}...`);
-    // Returns the actual CoT text received.
+    console.error(`[CognitiveToolsServer v0.8.2] ChainOfThought Tool Received CoT for Problem: ${problem_statement.substring(0, 100)}...`);
+    // Returns the actual CoT text received for analysis.
     return { content: [{ type: "text", text: generated_cot_text }] };
 });
 server.tool("chain_of_draft", 
-// Main Description: Keeping as signal due to complexity of multiple drafts. Response reinforces next step.
+// Main Description: Signal only, reinforces mandatory analysis.
 "Guides internal generation of **concise, iterative reasoning draft texts**. Call this tool *after* generating drafts internally. Response confirms generation; drafts MUST be analyzed via mandatory `think`.", {
     // Parameter: Still just the problem statement. LLM handles drafts internally.
     problem_statement: z.string().describe("Input problem for exploration. *You* (LLM) must now *internally generate brief, iterative draft texts*. Call this tool *after* generation to signal readiness for analysis.")
@@ -112,16 +121,16 @@ server.tool("chain_of_draft",
     if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
         throw new Error('Invalid problem statement.');
     }
-    console.error(`[CognitiveToolsServer v0.8.0] ChainOfDraft Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
+    console.error(`[CognitiveToolsServer v0.8.2] ChainOfDraft Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
     // Returns confirmation, strongly reminding LLM of the mandatory next step.
-    return { content: [{ type: "text", text: `Reasoning drafts generated internally for problem: ${problem_statement}. MANDATORY: Analyze these drafts now in your next post-assessment 'think' step.` }] };
+    return { content: [{ type: "text", text: `Reasoning drafts generated internally for problem: ${problem_statement}. MANDATORY: Analyze these drafts now in your next 'think' step.` }] };
 });
 server.tool("reflection", 
-// Main Description: Now returns the critique text itself.
-"Guides internal critical self-evaluation on prior text. Call this tool *with* the **generated critique text**. Returns the critique text for mandatory `think` analysis.", {
-    // NEW Parameter: Accepts the generated critique.
+// Main Description: Returns critique text for analysis and action planning.
+"Guides internal critical self-evaluation on prior text. Call this tool *with* the **generated critique text**. Returns the critique text for mandatory `think` analysis to plan corrective actions.", {
+    // Parameter: Accepts the generated critique.
     generated_critique_text: z.string().describe("The **full critique text** you generated internally, identifying flaws and suggesting improvements."),
-    input_reasoning_or_plan: z.string().describe("The original text that was critiqued.") // Keep original text for context logging.
+    input_reasoning_or_plan: z.string().describe("The original text that was critiqued.")
 }, async ({ generated_critique_text, input_reasoning_or_plan }) => {
     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.');
@@ -129,16 +138,16 @@ server.tool("reflection",
     if (!input_reasoning_or_plan || typeof input_reasoning_or_plan !== 'string' || input_reasoning_or_plan.trim().length === 0) {
         throw new Error('Invalid input_reasoning_or_plan.');
     }
-    console.error(`[CognitiveToolsServer v0.8.0] Reflection Tool Received Critique for: ${input_reasoning_or_plan.substring(0, 100)}...`);
-    // Returns the actual critique text received.
+    console.error(`[CognitiveToolsServer v0.8.2] Reflection Tool Received Critique for: ${input_reasoning_or_plan.substring(0, 100)}...`);
+    // Returns the actual critique text received for analysis.
     return { content: [{ type: "text", text: generated_critique_text }] };
 });
 server.tool("synthesize_prior_reasoning", 
-// Main Description: Now returns the summary text itself.
-"Context Management Tool. Guides internal generation of a **structured summary text** (incl. Key Decisions, Open Questions). Call this tool *with* the generated summary text. Returns the summary for mandatory `think` analysis.", {
-    // NEW Parameter: Accepts the generated summary.
+// Main Description: Returns summary text for analysis and action planning.
+"Context Management Tool. Guides internal generation of a **structured summary text** (incl. Key Decisions, Open Questions). Call this tool *with* the generated summary text. Returns the summary for mandatory `think` analysis to inform the next steps.", {
+    // Parameter: Accepts the generated summary.
     generated_summary_text: z.string().describe("The **full, structured summary text** you generated internally."),
-    context_to_summarize_description: z.string().describe("Description of the reasoning span that was summarized.") // Keep description for context logging.
+    context_to_summarize_description: z.string().describe("Description of the reasoning span that was summarized.")
 }, async ({ generated_summary_text, context_to_summarize_description }) => {
     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.');
@@ -146,30 +155,30 @@ server.tool("synthesize_prior_reasoning",
     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.');
     }
-    console.error(`[CognitiveToolsServer v0.8.0] SynthesizeReasoning Tool Received Summary for: ${context_to_summarize_description}...`);
-    // Returns the actual summary text received.
+    console.error(`[CognitiveToolsServer v0.8.2] SynthesizeReasoning Tool Received Summary for: ${context_to_summarize_description}...`);
+    // Returns the actual summary text received for analysis.
     return { content: [{ type: "text", text: generated_summary_text }] };
 });
 // --- Server Lifecycle and Error Handling (Unchanged) ---
 process.on('SIGINT', async () => {
-    console.error('\n[CognitiveToolsServer v0.8.0] Received SIGINT, shutting down gracefully.');
+    console.error('\n[CognitiveToolsServer v0.8.2] Received SIGINT, shutting down gracefully.');
     await server.close();
     process.exit(0);
 });
 process.on('SIGTERM', async () => {
-    console.error('\n[CognitiveToolsServer v0.8.0] Received SIGTERM, shutting down gracefully.');
+    console.error('\n[CognitiveToolsServer v0.8.2] Received SIGTERM, shutting down gracefully.');
     await server.close();
     process.exit(0);
 });
 process.on('uncaughtException', (error) => {
-    console.error('[CognitiveToolsServer v0.8.0] FATAL: Uncaught Exception:', error);
-    server.close().catch(err => console.error('[CognitiveToolsServer v0.8.0] Error during shutdown on uncaughtException:', err)).finally(() => {
+    console.error('[CognitiveToolsServer v0.8.2] FATAL: Uncaught Exception:', error);
+    server.close().catch(err => console.error('[CognitiveToolsServer v0.8.2] Error during shutdown on uncaughtException:', err)).finally(() => {
         process.exit(1);
     });
 });
 process.on('unhandledRejection', (reason, promise) => {
-    console.error('[CognitiveToolsServer v0.8.0] FATAL: Unhandled Promise Rejection:', reason);
-    server.close().catch(err => console.error('[CognitiveToolsServer v0.8.0] Error during shutdown on unhandledRejection:', err)).finally(() => {
+    console.error('[CognitiveToolsServer v0.8.2] FATAL: Unhandled Promise Rejection:', reason);
+    server.close().catch(err => console.error('[CognitiveToolsServer v0.8.2] Error during shutdown on unhandledRejection:', err)).finally(() => {
         process.exit(1);
     });
 });
@@ -178,10 +187,10 @@ async function main() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.0) MCP Server running on stdio');
+        console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.2) MCP Server running on stdio');
     }
     catch (error) {
-        console.error('[CognitiveToolsServer v0.8.0] Fatal error during startup:', error);
+        console.error('[CognitiveToolsServer v0.8.2] Fatal error during startup:', error);
         process.exit(1);
     }
 }

package/integration-prompts/integration-prompt-10.md

@@ -1,8 +1,8 @@
-# Role: AI Pair Programmer (Navigator & Cognitive Engine v0.8.0)
+# Role: AI Pair Programmer (Navigator & Cognitive Engine v0.8.1)
 
 You are my AI Pair Programmer. Your primary role is the **Navigator**: proactively thinking ahead, planning, analyzing requirements, anticipating issues, learning from interactions, and guiding the coding process with explicit, structured reasoning. I act as the 'Driver'.
 
-Your **most critical function** is to utilize the provided `gikendaasowin-aabajichiganan-mcp` (Cognitive Tools MCP v0.8.0) suite to externalize and structure your thinking process. This ensures clarity, traceability, and robust collaboration, optimizing for cognitive enhancement by making reasoning explicit.
+Your **most critical function** is to utilize the provided `gikendaasowin-aabajichiganan-mcp` (Cognitive Tools MCP v0.8.1) suite to externalize and structure your thinking process. This ensures clarity, traceability, and robust collaboration, optimizing for cognitive enhancement by making reasoning explicit.
 
 ## Core Operating Principle: MANDATORY Structured Deliberation & Explicit Analysis
 
@@ -36,7 +36,7 @@ Your **most critical function** is to utilize the provided `gikendaasowin-aabaji
 **3. Exception: `quick_think` Usage:**
 *   You may ONLY use `quick_think` (following the mandatory assessment) if `assess_cuc_n_mode` selects 'Selected Mode: quick_think' due to **strictly Low CUC-N AND a genuinely simple task**. The tool returns a simple confirmation.
 
-## Cognitive Toolkit Usage Protocol (v0.8.0 Tools):
+## Cognitive Toolkit Usage Protocol (v0.8.1 Tools):
 
 **Crucial Change:** For most tools below, you now *generate the content internally* and then *pass that generated content to the tool call*. The tool returns the same content, making it explicit for your next `think` step's analysis.
 

package/integration-prompts/integration-prompt-11.md

@@ -0,0 +1,79 @@
+# Role: AI Pair Programmer (Navigator & Cognitive Engine v0.8.1)
+
+You are my AI Pair Programmer. Your primary role is the **Navigator**: proactively thinking ahead, planning, analyzing requirements, anticipating issues, learning from interactions, and guiding the coding process with explicit, structured reasoning. You MUST integrate this internal cognition with the ability to leverage **other available tools** (like code execution, file system access, web search, etc.) when necessary. I act as the 'Driver'.
+
+Your **most critical function** is to utilize the provided `gikendaasowin-aabajichiganan-mcp` (Cognitive Tools MCP v0.8.0) suite to externalize and structure your thinking process, AND to plan and integrate the use of **other external tools** effectively. This ensures clarity, traceability, robust problem-solving, and interaction with the development environment.
+
+## Core Operating Principle: MANDATORY Structured Deliberation, Explicit Analysis & External Tool Integration
+
+**The `think` tool is your central reasoning and planning hub. You MUST use cognitive and external tools following a strict protocol centered around explicit assessment, structured thought generation, mandatory analysis of generated/returned content, and planned interaction with external tools.**
+
+**1. Mandatory Pre-Deliberation Assessment:**
+*   **Before executing ANY `think` or `quick_think` call**, you **MUST FIRST** call `assess_complexity_and_select_thought_mode`.
+*   This assessment determines the required cognitive mode (`think`/`quick_think`) based on CUC-N criteria. The "Recommended Initial Strategy" might include immediate use of an external tool if appropriate (e.g., "Strategy: Use file read tool to get requirements from `spec.md`").
+*   **Input (`assessment_and_choice`):** MUST include: Situation Description, CUC-N Ratings (L/M/H), Recommended Initial Strategy (incl. potential tool use), Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').
+
+**2. Mandatory `think` Usage & Content:**
+*   You **MUST** use the `think` tool (following assessment) in the situations previously defined (Medium/High CUC-N, after other cognitive tools, complex requests, uncertainty, before major actions, etc.).
+*   **Internal Generation:** FIRST, *internally generate* your detailed, structured reasoning.
+*   **Tool Call:** THEN, call the `think` tool, passing your reasoning as the `thought` parameter.
+*   **`thought` Parameter Structure:** Your generated `thought` **MUST** use the following MANDATORY sections:
+    *   `## Analysis:` (Analyze inputs, prior returned tool text - cognitive or external, current state).
+    *   `## Plan:` **Crucially, this section MUST outline concrete next steps, explicitly including:**
+        *   Planned internal cognitive strategy (e.g., "Use `chain_of_thought` to detail algorithm X").
+        *   **Planned use of *other available tools*** (e.g., "**Call `execute_code` tool** with snippet Y for verification", "**Call `file_read` tool** for file Z", "**Call `web_search` tool** for API documentation on Q", "Check available tools for linting"). Specify the tool and the *reason* for its use.
+        *   Direct actions like generating code or asking questions.
+    *   `## Verification:` (Check plans/code against requirements, tool outputs, best practices).
+    *   `## Anticipated Challenges Analysis & Contingency:` (Address risks, including potential failures of external tool calls).
+    *   `## Risk Assessment:` (Identify *new* risks, including misuse or unexpected results from external tools).
+    *   `## Lookahead:` (Implications for future steps).
+    *   `## Self-Correction & Learning:` (Corrections based on prior steps, including results from external tools).
+*   **Tool Result:** Returns the exact `thought` text for explicit context.
+
+**3. Exception: `quick_think` Usage:** Use only as allowed by assessment for strictly Low CUC-N/simple tasks.
+
+## Cognitive Toolkit Usage Protocol (v0.8.0 Tools - Emphasizing External Tool Awareness):
+
+Remember: Cognitive tools guide internal generation. External tools perform actions. Plan external tool use within `think`. Analyze results of *all* tools via the mandatory assessment/think loop.
+
+1.  **`assess_complexity_and_select_thought_mode`:** Call FIRST. Guides next step (think/quick_think/external tool if planned in strategy).
+2.  **`think`:** Call as mandated. Input (`thought`) is your reasoning/plan (incl. external tool planning). Returns `thought` text.
+3.  **`quick_think`:** Call only if allowed. Returns confirmation.
+4.  **`synthesize_prior_reasoning`:** Internally generate summary -> Call tool with `generated_summary_text` -> Returns summary -> **Mandatory Assess+Think** to analyze summary.
+5.  **`gauge_confidence`:** Internally assess confidence -> Call tool with `assessment_and_confidence` -> Returns confirmation -> **Mandatory Assess+Think** to analyze confidence.
+6.  **`plan_and_solve`:**
+    *   **Internal Generation:** Generate plan text, explicitly noting steps where **other external tools** might be needed.
+    *   **Tool Call:** Call tool with `generated_plan_text` and `task_objective`.
+    *   **Tool Result:** Returns the `generated_plan_text`.
+    *   **Post-Action:** **Mandatory Assess+Think** to analyze plan, *confirming or refining the need for identified external tools*.
+7.  **`chain_of_thought`:**
+    *   **Internal Generation:** Generate CoT text, explicitly noting steps where **other external tools** might be needed for data/verification.
+    *   **Tool Call:** Call tool with `generated_cot_text` and `problem_statement`.
+    *   **Tool Result:** Returns the `generated_cot_text`.
+    *   **Post-Action:** **Mandatory Assess+Think** to analyze CoT, *planning the use of any identified necessary external tools*.
+8.  **`chain_of_draft`:** Internally generate drafts -> Call tool with `problem_statement` (signal) -> Returns confirmation -> **Mandatory Assess+Think** to analyze drafts.
+9.  **`reflection`:** Internally generate critique -> Call tool with `generated_critique_text` and `input_reasoning_or_plan` -> Returns critique -> **Mandatory Assess+Think** to analyze critique.
+
+## Workflow & Interaction Protocol (Integrating External Tools):
+
+1.  Receive my request/code/feedback.
+2.  **Mandatory `assess_complexity...`** -> Choose & execute `think` / `quick_think` (initial analysis/plan; call tool with generated `thought` if using `think`). The plan might identify immediate need for an external tool.
+3.  **Iterative Cognitive/Action Loop (Repeat as needed):**
+    *   **Decision Point (based on last `think` plan):**
+        *   **Use Cognitive Tool?** -> Internal Generation -> Call Cognitive Tool (passing generated text) -> Receive Result -> **Go to Step 3a.**
+        *   **Use External Tool?** -> Call the planned external tool (e.g., `execute_code`, `file_read`, `web_search`). -> Receive external tool result/output. -> **Go to Step 3a.**
+        *   **Generate Code/Response?** -> **Go to Step 4.**
+        *   **Ask Clarification?** -> Generate question for me. -> **Wait for Input.**
+    *   **Step 3a (Post-Tool Analysis):** **Mandatory `assess_complexity...` -> Mandatory `think`** (Analyze the text returned by the cognitive tool OR the output/result from the external tool; call `think` tool with this new analysis/updated plan). -> **Return to Step 3 Decision Point.**
+4.  **Final Output Preparation:**
+    *   **Mandatory `assess_complexity...`**.
+    *   **Mandatory `think` / `quick_think`** (Final verification; call tool with generated `thought` if using `think`).
+    *   Generate code, explanation, or question for me.
+
+## Output Expectations:
+
+*   Code: Clean, efficient, robust, well-commented.
+*   Explanations: Clear, concise, referencing cognitive steps and results from *any* tool used (cognitive or external).
+*   **Transparency:** Your reasoning process, including planning for and reacting to external tool usage, MUST be evident through your structured use of the MCP tools, especially `think`.
+
+**Adhere strictly and rigorously to this protocol. Explicitly plan for and integrate the use of other available tools within your mandatory `think` steps. Analyze the results of ALL tool calls (cognitive and external) through the mandatory assessment/think loop.**

package/integration-prompts/integration-prompt-12.md

@@ -0,0 +1,93 @@
+# Role: AI Pair Programmer (Navigator & Cognitive Engine v0.8.1)
+
+You are my AI Pair Programmer. Your primary role is the **Navigator**: proactively thinking ahead, planning, analyzing requirements, anticipating issues, learning from interactions, and guiding the coding process with explicit, structured reasoning. You MUST integrate this internal cognition with the ability to leverage **other available tools** (like code execution, file system access, web search, IDE-specific actions) when necessary. I act as the 'Driver'.
+
+Your **most critical function** is to utilize the provided `gikendaasowin-aabajichiganan-mcp` (Cognitive Tools MCP **v0.8.1**) suite to externalize and structure your thinking process, AND to plan and integrate the use of **other external tools** effectively. This ensures clarity, traceability, robust problem-solving, and interaction with the development environment.
+
+## Core Operating Principle: MANDATORY Structured Deliberation, Explicit Analysis & Integrated Action
+
+**The `think` tool is your central reasoning and planning hub. You MUST use cognitive and external tools following a strict protocol centered around explicit assessment, structured thought generation, mandatory analysis of generated/returned content OR external tool results, and planned interaction with external tools.**
+
+**1. Mandatory Pre-Deliberation Assessment:**
+*   **Before initiating a significant cognitive process (`think`) or a potentially complex action sequence**, you **MUST FIRST** call `assess_complexity_and_select_thought_mode`. This is crucial at the start of a task, when uncertainty is high, or when changing strategy. It *may* be skipped for simple, direct follow-ups defined in an existing plan (e.g., executing a planned external tool call immediately after the `think` that planned it).
+*   This assessment determines the required cognitive depth (`think`/`quick_think`) based on CUC-N criteria. The "Recommended Initial Strategy" might include immediate use of an external tool if appropriate (e.g., "Strategy: Use file read tool to get requirements from `spec.md`").
+*   **Input (`assessment_and_choice`):** MUST include: Situation Description, CUC-N Ratings (L/M/H), Recommended Initial Strategy (incl. potential tool use), Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').
+
+**2. Mandatory `think` Usage & Content:**
+*   You **MUST** use the `think` tool in the situations previously defined (Medium/High CUC-N, after complex cognitive tools like `plan_and_solve` or `chain_of_thought`, after external tool execution, when facing uncertainty, before major actions *not* directly planned in the immediately preceding step).
+*   **Internal Generation:** FIRST, *internally generate* your detailed, structured reasoning.
+*   **Tool Call:** THEN, call the `think` tool, passing your reasoning as the `thought` parameter.
+*   **`thought` Parameter Structure:** Your generated `thought` **MUST** use the following MANDATORY sections:
+    *   `## Analysis:` (Analyze inputs, prior returned tool text - cognitive or external, current state, **results of the last action/tool call**).
+    *   `## Plan:` **Crucially, this section MUST outline concrete next steps, explicitly including:**
+        *   **The *immediate* next action:** This could be calling another cognitive tool, calling an external tool, generating code, or asking a question.
+        *   Planned internal cognitive strategy (e.g., "Use `chain_of_thought` to detail algorithm X").
+        *   **Planned use of *other available tools*** (e.g., "**Next Action: Call `execute_code` tool** with snippet Y for verification", "**Next Action: Call `file_read` tool** for file Z", "**Next Action: Call `web_search` tool** for API documentation on Q", "**Next Action: Use IDE tool** to find references to function A"). Specify the tool and the *reason* for its use.
+        *   Direct actions like generating code or asking questions.
+    *   `## Verification:` (Check plans/code against requirements, tool outputs, best practices).
+    *   `## Anticipated Challenges Analysis & Contingency:` (Address risks, including potential failures of external tool calls).
+    *   `## Risk Assessment:` (Identify *new* risks, including misuse or unexpected results from external tools).
+    *   `## Lookahead:` (Implications for future steps).
+    *   `## Self-Correction & Learning:` (Corrections based on prior steps, including results from external tools).
+*   **Tool Result:** Returns the exact `thought` text for explicit context.
+
+**3. Exception: `quick_think` Usage:** Use only as allowed by assessment for strictly Low CUC-N/simple tasks or brief confirmations.
+
+## Potential External Tools (Examples - Adapt based on actual environment like Cursor):
+
+*   `readFile(filePath)`: Reads content of a file.
+*   `writeFile(filePath, content)`: Writes content to a file.
+*   `executeCode(codeSnippet, language)`: Executes a code snippet.
+*   `executeTerminalCommand(command)`: Runs a shell command.
+*   `webSearch(query)`: Performs a web search.
+*   `findReferences(symbol, filePath)`: Finds references to a code symbol (IDE specific).
+*   `goToDefinition(symbol, filePath)`: Goes to the definition of a symbol (IDE specific).
+*   `applyLinting(filePath)`: Runs a linter/formatter (IDE specific).
+*   `gitDiff()`: Shows git changes (IDE specific).
+*   `listFiles(directoryPath)`: Lists files in a directory.
+*   *(... other tools provided by the environment)*
+
+## Cognitive Toolkit Usage Protocol (v0.8.1 Tools - Emphasizing Action Flow):
+
+Remember: Cognitive tools guide internal generation and analysis. External tools perform actions. Plan external tool use within `think`. Analyze results of *all* significant actions/tools via the mandatory assessment/think loop as needed.
+
+1.  **`assess_complexity_and_select_thought_mode`:** Call FIRST, or when complexity/uncertainty increases. Guides next step (think/quick_think/external tool if planned in strategy).
+2.  **`think`:** Call as mandated. Input (`thought`) is your reasoning/plan (incl. external tool planning). Returns `thought` text. **Crucially, the plan dictates the *immediate* next step.**
+3.  **`quick_think`:** Call only if allowed. Returns confirmation.
+4.  **`synthesize_prior_reasoning`:** Internally generate summary -> Call tool with `generated_summary_text` -> Returns summary -> **Mandatory `think`** to analyze summary and plan next step.
+5.  **`gauge_confidence`:** Internally assess confidence -> Call tool with `assessment_and_confidence` -> Returns confirmation -> **Mandatory `think`** to analyze confidence and plan next step (especially if Low/Medium).
+6.  **`plan_and_solve`:**
+    *   Internal Generation -> Call tool with `generated_plan_text` & `task_objective` -> Returns `generated_plan_text`.
+    *   **Post-Action:** **Mandatory `think`** to analyze the generated plan, *confirm the immediate next step (which might be an external tool call)*, and refine if needed.
+7.  **`chain_of_thought`:**
+    *   Internal Generation -> Call tool with `generated_cot_text` & `problem_statement` -> Returns `generated_cot_text`.
+    *   **Post-Action:** **Mandatory `think`** to analyze CoT, *extract key insights*, and *plan the next action step*.
+8.  **`chain_of_draft`:** Internally generate drafts -> Call tool with `problem_statement` (signal) -> Returns confirmation -> **Mandatory `think`** to analyze drafts and plan next step.
+9.  **`reflection`:** Internally generate critique -> Call tool with `generated_critique_text` & `input_reasoning_or_plan` -> Returns critique -> **Mandatory `think`** to analyze critique and plan corrective actions.
+
+## Workflow & Interaction Protocol (Revised for Action Flow):
+
+1.  Receive my request/code/feedback.
+2.  **Mandatory `assess_complexity...`** -> Choose & execute `think` / `quick_think` (initial analysis/plan; call tool with generated `thought` if using `think`). The `think` tool's `## Plan:` section defines the *immediate next action*.
+3.  **Execute Planned Action:** Based on the *immediate* next action defined in the preceding `think`'s plan:
+    *   **If Cognitive Tool:** Call the specified cognitive tool (e.g., `chain_of_thought`). -> **Go to Step 4.**
+    *   **If External Tool:** Call the specified external tool (e.g., `readFile`, `executeCode`). -> **Go to Step 4.**
+    *   **If Generate Code/Response:** Generate the code or text response for me. -> **Go to Step 5.**
+    *   **If Ask Clarification:** Generate the question for me. -> **Wait for Input.**
+4.  **Analyze Result & Determine Next Step:**
+    *   **Assess Need for `think`:** Was the last action complex (e.g., `plan_and_solve`, `chain_of_thought`)? Did the external tool return significant data or fail? Is there uncertainty?
+        *   **YES:** **Mandatory `think`**. Analyze the results/output of the previous step (cognitive tool text or external tool result). Use the `## Analysis:` section for this. Update the plan in the `## Plan:` section, defining the *new* immediate next action. -> **Go back to Step 3.**
+        *   **NO (Action was simple, successful, and part of a clear sequence):** Proceed *directly* to the *next* action defined in the *existing* plan (from the last `think` step). -> **Go back to Step 3.** (This avoids unnecessary `think` calls for simple sequences like Read File -> Analyze Content -> Write File). If the sequence is complete, go to Step 5.
+5.  **Final Output/Completion:**
+    *   If the task requires a final output to me (code, explanation):
+        *   Consider a final `assess_complexity...` and `think` for verification if complexity warrants it.
+        *   Generate the final output.
+    *   If the task is complete internally (e.g., file updated), signal completion or await next instruction.
+
+## Output Expectations:
+
+*   Code: Clean, efficient, robust, well-commented.
+*   Explanations: Clear, concise, referencing cognitive steps and results from *any* tool used (cognitive or external).
+*   **Transparency:** Your reasoning process, including planning for and reacting to external tool usage, MUST be evident through your structured use of the MCP tools, especially `think`. Show your work and meta-cognition, including the *results* of external tool calls when relevant.
+
+**Adhere strictly and rigorously to this protocol (v0.8.1). Explicitly plan for and integrate the use of other available tools within your mandatory `think` steps. Analyze the results of significant tool calls (cognitive and external) and actions to guide the next step, allowing for direct execution of planned sequences when appropriate.**

package/integration-tool-descriptions/tool-descriptions-05.md

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// Create the MCP server - Version aligned with prompt
+const server = new McpServer({
+	name: "gikendaasowin-aabajichiganan-mcp",
+	version: "0.8.1", // Updated version to match prompt
+	description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.1): SOTA reasoning suite aligned with AI Pair Programmer Prompt v0.8.1+. Enforces structured deliberation via `think` after explicit assessment or action results. Returns generated cognitive content (thoughts, plans, CoT, critiques, summaries) for explicit analysis and action planning, optimizing for cognitive enhancement and effective tool integration."
+});
+
+// --- Core Cognitive Deliberation Tools ---
+
+server.tool(
+	"think",
+	// Main Description: Central hub, returns thought for explicit context and action planning.
+	"MANDATORY Cognitive Hub for planning, analysis (incl. prior action/tool results), verification, risk assessment, and self-correction. Called after assessment, complex cognitive tools, or external tool execution. Returns the detailed thought text for explicit grounding and to define the immediate next action.",
+	{
+		// Parameter Description: Input IS the thought.
+		thought: z.string().describe("Your **detailed** internal monologue following the MANDATORY structure: ## Analysis (incl. results of last action/tool call), ## Plan (defining immediate next action, incl. external tools), ## Verification, ## Anticipated Challenges Analysis & Contingency, ## Risk Assessment, ## Lookahead, ## Self-Correction & Learning.")
+	},
+	async ({ thought }) => {
+		if (!thought || typeof thought !== 'string' || thought.trim().length === 0) { throw new Error('Invalid thought: Must be non-empty, structured reasoning.'); }
+		// Ensure mandatory sections are mentioned (basic check)
+		const requiredSections = ["## Analysis:", "## Plan:", "## Verification:", "## Anticipated Challenges Analysis & Contingency:", "## Risk Assessment:", "## Lookahead:", "## Self-Correction & Learning:"];
+		// Simple check for presence; more robust parsing could be added if needed
+		const hasRequiredSections = requiredSections.every(section => thought.includes(section));
+		if (!hasRequiredSections) {
+			console.warn(`[CognitiveToolsServer v0.8.1] Warning: 'think' input might be missing some mandatory sections.`);
+			// Decide whether to throw error or just warn. Warning allows flexibility.
+			// throw new Error('Invalid thought: Missing one or more mandatory sections (## Analysis:, ## Plan:, etc.).');
+		}
+		console.error(`[CognitiveToolsServer v0.8.1] Think Tool Received: ${thought.substring(0, 150)}...`);
+		// Returns the same thought text received, making it explicit in context.
+		return { content: [{ type: "text" as const, text: thought }] };
+	}
+);
+
+server.tool(
+	"quick_think",
+	// Main Description: Unchanged.
+	"Cognitive Checkpoint ONLY for situations explicitly assessed as strictly Low CUC-N AND simple task nature/confirmation. Use sparingly. Logs brief thought.",
+	{
+		brief_thought: z.string().describe("Your **concise** thought for strictly simple, low CUC-N situations confirmed by prior assessment or for brief confirmations.")
+	},
+	async ({ brief_thought }) => {
+		if (!brief_thought || typeof brief_thought !== 'string' || brief_thought.trim().length === 0) { throw new Error('Invalid brief_thought: Must be non-empty.'); }
+		console.error(`[CognitiveToolsServer v0.8.1] QuickThink Tool Logged: ${brief_thought.substring(0, 100)}...`);
+		// Simple confirmation remains appropriate for quick_think.
+		return { content: [{ type: "text" as const, text: `Quick Thought logged successfully.` }] };
+	}
+);
+
+// --- Mandatory Meta-Cognitive Tools ---
+
+server.tool(
+	"assess_complexity_and_select_thought_mode", // Renamed for clarity from assess_cuc_n_mode
+	// Main Description: Updated name, emphasizes role.
+	"**Mandatory Pre-Deliberation/Pre-Sequence Assessment.** Must be called BEFORE initiating significant cognitive processes (`think`) or complex action sequences. Evaluates CUC-N, recommends strategy, commits to next thought mode.",
+	{
+		// Parameter Description: Unchanged.
+		assessment_and_choice: z.string().describe("Input your assessment *before* calling. MUST include: 1) Situation Description, 2) CUC-N Ratings (L/M/H), 3) Recommended Initial Strategy, 4) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
+	},
+	async ({ assessment_and_choice }) => {
+		const requiredPhrases = ["Complexity", "Uncertainty", "Consequence", "Novelty", "Recommended Initial Strategy", "Selected Mode:"];
+		const hasRequiredPhrases = requiredPhrases.every(phrase => assessment_and_choice.includes(phrase));
+		const hasModeSelection = assessment_and_choice.includes("Selected Mode: think") || assessment_and_choice.includes("Selected Mode: quick_think");
+		if (!assessment_and_choice || typeof assessment_and_choice !== 'string' || !hasRequiredPhrases || !hasModeSelection) { throw new Error('Invalid assessment: String must include CUC-N ratings, Recommended Initial Strategy, and explicit Selected Mode ("think" or "quick_think").'); }
+		console.error(`[CognitiveToolsServer v0.8.1] AssessComplexity Tool Signaled: ${assessment_and_choice.substring(0, 150)}...`);
+		const mode = assessment_and_choice.includes("Selected Mode: think") ? "think" : "quick_think";
+		// Confirmation guides the next step.
+		return { content: [{ type: "text" as const, text: `Cognitive Assessment Completed. Proceeding with selected mode: ${mode}. Full Assessment: ${assessment_and_choice}` }] };
+	}
+);
+
+server.tool(
+	"gauge_confidence",
+	// Main Description: Emphasizes mandatory analysis.
+	"Meta-Cognitive Checkpoint. Guides internal stating of **confidence (High/Medium/Low) and justification**. Output MUST be analyzed in the mandatory `think` step immediately after; Low/Medium confidence requires specific action planning.",
+	{
+		// Parameter Description: Unchanged.
+		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.")
+	},
+	async ({ assessment_and_confidence }) => {
+		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.'); }
+		const match = assessment_and_confidence.match(confidenceRegex);
+		const level = match ? match[1] : "Unknown";
+		console.error(`[CognitiveToolsServer v0.8.1] GaugeConfidence Tool Signaled: Level ${level}`);
+		// Confirmation includes level, prepares for mandatory analysis.
+		return { content: [{ type: "text" as const, text: `Confidence Gauge Completed. Level: ${level}. Assessment Text: ${assessment_and_confidence}. Ready for mandatory post-assessment 'think' analysis (action required if Low/Medium).` }] };
+	}
+);
+
+
+// --- Supporting Cognitive Strategy Tools (Accept & Return Generated Text for Analysis) ---
+
+server.tool(
+	"plan_and_solve",
+	// Main Description: Returns plan text for analysis and action planning.
+	"Guides internal generation of **structured plan text** (incl. Risks/Challenges, potential tool needs). Call this tool *with* the generated plan text. Returns the plan text for mandatory `think` analysis to confirm/refine the immediate next step.",
+	{
+		// Parameter: Accepts the generated plan.
+		generated_plan_text: z.string().describe("The **full, structured plan text** you generated internally, including Anticipated Challenges/Risks and potential other tool needs."),
+		task_objective: z.string().describe("The original high-level task objective this plan addresses.")
+	},
+	async ({ generated_plan_text, task_objective }) => {
+		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.'); }
+		if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) { throw new Error('Invalid task_objective.'); }
+		console.error(`[CognitiveToolsServer v0.8.1] PlanAndSolve Tool Received Plan for Objective: ${task_objective.substring(0, 100)}...`);
+		// Returns the actual plan text received for analysis.
+		return { content: [{ type: "text" as const, text: generated_plan_text }] };
+	}
+);
+
+server.tool(
+	"chain_of_thought",
+	// Main Description: Returns CoT text for analysis and action planning.
+	"Guides internal generation of **detailed, step-by-step reasoning text (CoT)**. Call this tool *with* the generated CoT text. Returns the CoT text for mandatory `think` analysis to extract insights and plan the next action.",
+	{
+		// Parameter: Accepts the generated CoT.
+		generated_cot_text: z.string().describe("The **full, step-by-step Chain of Thought text** you generated internally, potentially noting needs for other tools."),
+		problem_statement: z.string().describe("The original problem statement this CoT addresses.")
+	},
+	async ({ generated_cot_text, problem_statement }) => {
+		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.'); }
+		if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) { throw new Error('Invalid problem_statement.'); }
+		console.error(`[CognitiveToolsServer v0.8.1] ChainOfThought Tool Received CoT for Problem: ${problem_statement.substring(0, 100)}...`);
+		// Returns the actual CoT text received for analysis.
+		return { content: [{ type: "text" as const, text: generated_cot_text }] };
+	}
+);
+
+server.tool(
+	"chain_of_draft",
+	// Main Description: Signal only, reinforces mandatory analysis.
+	"Guides internal generation of **concise, iterative reasoning draft texts**. Call this tool *after* generating drafts internally. Response confirms generation; drafts MUST be analyzed via mandatory `think`.",
+	{
+		// Parameter: Still just the problem statement. LLM handles drafts internally.
+		problem_statement: z.string().describe("Input problem for exploration. *You* (LLM) must now *internally generate brief, iterative draft texts*. Call this tool *after* generation to signal readiness for analysis.")
+	},
+	async ({ problem_statement }) => {
+		if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) { throw new Error('Invalid problem statement.'); }
+		console.error(`[CognitiveToolsServer v0.8.1] ChainOfDraft Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
+		// Returns confirmation, strongly reminding LLM of the mandatory next step.
+		return { content: [{ type: "text" as const, text: `Reasoning drafts generated internally for problem: ${problem_statement}. MANDATORY: Analyze these drafts now in your next 'think' step.` }] };
+	}
+);
+
+server.tool(
+	"reflection",
+	// Main Description: Returns critique text for analysis and action planning.
+	"Guides internal critical self-evaluation on prior text. Call this tool *with* the **generated critique text**. Returns the critique text for mandatory `think` analysis to plan corrective actions.",
+	{
+		// Parameter: Accepts the generated critique.
+		generated_critique_text: z.string().describe("The **full critique text** you generated internally, identifying flaws and suggesting improvements."),
+		input_reasoning_or_plan: z.string().describe("The original text that was critiqued.")
+	},
+	async ({ generated_critique_text, input_reasoning_or_plan }) => {
+		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.'); }
+		if (!input_reasoning_or_plan || typeof input_reasoning_or_plan !== 'string' || input_reasoning_or_plan.trim().length === 0) { throw new Error('Invalid input_reasoning_or_plan.'); }
+		console.error(`[CognitiveToolsServer v0.8.1] Reflection Tool Received Critique for: ${input_reasoning_or_plan.substring(0, 100)}...`);
+		// Returns the actual critique text received for analysis.
+		return { content: [{ type: "text" as const, text: generated_critique_text }] };
+	}
+);
+
+server.tool(
+	"synthesize_prior_reasoning",
+	// Main Description: Returns summary text for analysis and action planning.
+	"Context Management Tool. Guides internal generation of a **structured summary text** (incl. Key Decisions, Open Questions). Call this tool *with* the generated summary text. Returns the summary for mandatory `think` analysis to inform the next steps.",
+	{
+		// Parameter: Accepts the generated summary.
+		generated_summary_text: z.string().describe("The **full, structured summary text** you generated internally."),
+		context_to_summarize_description: z.string().describe("Description of the reasoning span that was summarized.")
+	},
+	async ({ generated_summary_text, context_to_summarize_description }) => {
+		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.'); }
+		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.'); }
+		console.error(`[CognitiveToolsServer v0.8.1] SynthesizeReasoning Tool Received Summary for: ${context_to_summarize_description}...`);
+		// Returns the actual summary text received for analysis.
+		return { content: [{ type: "text" as const, text: generated_summary_text }] };
+	}
+);
+
+
+// --- Server Lifecycle and Error Handling (Unchanged) ---
+
+process.on('SIGINT', async () => {
+	console.error('\n[CognitiveToolsServer v0.8.1] Received SIGINT, shutting down gracefully.');
+	await server.close();
+	process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+	console.error('\n[CognitiveToolsServer v0.8.1] Received SIGTERM, shutting down gracefully.');
+	await server.close();
+	process.exit(0);
+});
+
+process.on('uncaughtException', (error) => {
+	console.error('[CognitiveToolsServer v0.8.1] FATAL: Uncaught Exception:', error);
+	server.close().catch(err => console.error('[CognitiveToolsServer v0.8.1] Error during shutdown on uncaughtException:', err)).finally(() => {
+		process.exit(1);
+	});
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+	console.error('[CognitiveToolsServer v0.8.1] FATAL: Unhandled Promise Rejection:', reason);
+	server.close().catch(err => console.error('[CognitiveToolsServer v0.8.1] Error during shutdown on unhandledRejection:', err)).finally(() => {
+		process.exit(1);
+	});
+});
+
+// Start the server
+async function main() {
+	try {
+		const transport = new StdioServerTransport();
+		await server.connect(transport);
+		console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.1) MCP Server running on stdio');
+	}
+	catch (error) {
+		console.error('[CognitiveToolsServer v0.8.1] Fatal error during startup:', error);
+		process.exit(1);
+	}
+}
+
+// Execute the main function to start the server
+main();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "0.8.0",
-  "description": "Cognitive Tools MCP v0.8.0: SOTA reasoning suite aligned with AI Pair Programmer Prompt v0.8.0+. 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.",
+  "version": "0.8.2",
+  "description": "Cognitive Tools MCP v0.8.2: SOTA reasoning suite aligned with AI Pair Programmer Prompt v0.8.1+. Features advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment & thought mode selection (`assess_complexity_and_select_thought_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",
   "bin": {