@nbiish/cognitive-tools-mcp 0.7.3 → 0.8.1

package/LICENSE

@@ -43,13 +43,13 @@ This license applies to 'the Work.' 'The Work' primarily encompasses the Indigen
    Any use, reproduction, distribution, modification, adaptation, display, performance, transmission, or creation of derivative works based on this Work, whether in whole or in part, must prominently and accurately include the following citation and attribution in all associated materials, displays, publications, and metadata:
 
    ```bibtex
-   @misc{gikendaasowin-aabajichiganan-mcp2025,
+   @misc{<|repo_title|><|current_year|>,
      author/creator/steward = {ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band},
-     title/description = {gikendaasowin-aabajichiganan-mcp (Cognitive Tools MCP) - Advanced internal reasoning suite for LLM agents},
+     title/description = {<|repo_title|>},
      type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
-     year = {2025},
+     year = {<|current_year|>},
      publisher/source/event = {GitHub repository under tribal sovereignty protections},
-     howpublished = {\url{https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp}},
+     howpublished = {\url{https://github.com/nbiish/<|repo_title|>}},
      note = {Authored and stewarded by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band (whose community faced violent dispersal resulting in descendants affiliating with LTBB, GTBOCI, and First Nations in Canada, as detailed in the Preamble), an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Indigenous intellectual property, traditional knowledge systems (TK), traditional cultural expressions (TCEs), and associated data protected under tribal law, federal Indian law, treaty rights, Indigenous Data Sovereignty principles, and international indigenous rights frameworks including UNDRIP. All usage, benefit-sharing, and data governance are governed by the COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS.}
    }
    ```
@@ -608,9 +608,13 @@ This license applies to 'the Work.' 'The Work' primarily encompasses the Indigen
 **11. DISPUTE RESOLUTION AND JURISDICTION**
    The terms, interpretation, and enforcement of this license incorporate and are informed by tribal sovereignty principles, federal Indian law, traditional Indigenous law of the Grand Traverse Band of Ottawa and Chippewa Indians, and international Indigenous rights frameworks:
 
-   11.1 PRIMARY JURISDICTION: The Grand Traverse Band of Ottawa and Chippewa Indians (GTBOCI) Tribal Court shall have primary and exclusive jurisdiction over any and all disputes arising under or related to this license, including but not limited to disputes concerning the interpretation or enforcement of protections for Traditional Knowledge (TK), Traditional Cultural Expressions (TCEs), Sacred Sites (including the stone circle on ᐋᒥᒃ ᐙᑲᓐᑕ / Aamik'Waakanda, land held in trust by GTBOCI), and Cultural Landscapes as defined herein. The GTBOCI Tribal Court shall incorporate both written tribal law and unwritten traditional and customary law in its adjudication, recognizing the paramount cultural significance of the subject matter to the Rights Holder and the Tribe.
+   11.1 PRIMARY JURISDICTION HIERARCHY: The following jurisdictional hierarchy shall apply to any and all disputes arising under or related to this license, including but not limited to disputes concerning the interpretation or enforcement of protections for Traditional Knowledge (TK), Traditional Cultural Expressions (TCEs), Sacred Sites (including the stone circle on ᐋᒥᒃ ᐙᑲᓐᑕ / Aamik'Waakanda, land held in trust by GTBOCI), and Cultural Landscapes as defined herein:
+   
+       a) BEAVER ISLAND BAND PRIORITY: If and when the Beaver Island Band (historically centered on ᐋᒥᒃ ᐙᑲᓐᑕ (Aamik'Waakanda / Beaver Island)) establishes its own tribal court, legal forum, or formalized dispute resolution body (whether through federal recognition, reorganization of descendants, or other means of formal establishment), such forum shall have primary and first jurisdiction over any and all disputes arising under or related to this license. Such forum shall incorporate both written and unwritten traditional and customary law in its adjudication, recognizing the paramount cultural significance of the subject matter to the Rights Holder and the Beaver Island Band.
+       
+       b) GTBOCI JURISDICTION: If the forum described in 11.1(a) does not exist or is determined by its own authority to be unavailable or impractical for a specific dispute, the Grand Traverse Band of Ottawa and Chippewa Indians (GTBOCI) Tribal Court shall have primary and exclusive jurisdiction. The GTBOCI Tribal Court shall incorporate both written tribal law and unwritten traditional and customary law in its adjudication, recognizing the paramount cultural significance of the subject matter to the Rights Holder and the Tribe.
 
-   11.2 SECONDARY JURISDICTIONS AND RELATED TRIBAL INTERESTS: In circumstances where GTBOCI Tribal Court proceedings are determined by that court itself to be unavailable or impractical for a specific dispute, or where enforcement of a tribal court judgment is sought in another forum, the following forums may have concurrent or subsequent jurisdiction, subject always to the principles of tribal sovereignty and exhaustion of tribal remedies. Furthermore, for disputes specifically concerning the Garden Island (Gitigaan Minising) burial grounds (land held in trust by LTBB), the jurisdictional interest and potential role of the Little Traverse Bay Bands of Odawa Indians shall be appropriately considered and respected within the dispute resolution process, consistent with principles of comity and inter-tribal relations:
+   11.2 SECONDARY JURISDICTIONS AND RELATED TRIBAL INTERESTS: In circumstances where proceedings in the forums specified in Section 11.1 are determined by those forums themselves to be unavailable or impractical for a specific dispute, or where enforcement of a tribal court judgment is sought in another forum, the following forums may have concurrent or subsequent jurisdiction, subject always to the principles of tribal sovereignty and exhaustion of tribal remedies. Furthermore, for disputes specifically concerning the Garden Island (Gitigaan Minising) burial grounds (land held in trust by LTBB), the jurisdictional interest and potential role of the Little Traverse Bay Bands of Odawa Indians shall be appropriately considered and respected within the dispute resolution process, consistent with principles of comity and inter-tribal relations:
        a) The United States Federal District Court with geographic jurisdiction encompassing the lands of the Grand Traverse Band of Ottawa and Chippewa Indians, particularly for matters arising under federal Indian law or requiring interpretation of federal statutes or treaties.
        b) If federal court jurisdiction is unavailable, the courts of the State of Michigan, solely to the extent necessary and permissible under federal Indian law and principles of comity, and provided that tribal law and perspectives are given appropriate weight.
        c) For international disputes, the choice of forum and applicable law shall prioritize mechanisms that respect Indigenous sovereignty and international indigenous rights frameworks (e.g., WIPO procedures for TK/TCEs, application of lex originis principles), as determined appropriate by the Rights Holder.
@@ -639,9 +643,9 @@ This license applies to 'the Work.' 'The Work' primarily encompasses the Indigen
           iii) This remedies allocation provision shall be interpreted and applied in a manner consistent with the tribal sovereignty principles articulated throughout this license and shall take precedence over any conflicting remedies provisions in applicable non-tribal law.
           iv) Any attempt to circumvent this remedies allocation provision shall constitute a separate and severe violation of this license, triggering all available enforcement remedies.
 
-   11.7 EXHAUSTION REQUIREMENT: All parties to disputes arising under this license must fully exhaust tribal court remedies before seeking adjudication or enforcement in any non-tribal forum, consistent with the federal doctrine of exhaustion of tribal remedies (see National Farmers Union Ins. Cos. v. Crow Tribe, 471 U.S. 845 (1985); Iowa Mut. Ins. Co. v. LaPlante, 480 U.S. 9 (1987)).
+   11.7 EXHAUSTION REQUIREMENT: All parties to disputes arising under this license must fully exhaust tribal court remedies before seeking adjudication or enforcement in any non-tribal forum, consistent with the federal doctrine of exhaustion of tribal remedies (see National Farmers Union Ins. Cos. v. Crow Tribe, 471 U.S. 845 (1985); Iowa Mut. Ins. Co. v. LaPlante, 480 U.S. 9 (1987)). This specifically requires exhaustion of remedies in the Beaver Island Band forum (if established pursuant to Section 11.1(a)) and/or the GTBOCI Tribal Court (pursuant to Section 11.1(b)) as applicable under the jurisdictional hierarchy established in Section 11.1.
 
-   11.8 JURISDICTIONAL CHALLENGES: Any challenge to the jurisdiction of the GTBOCI Tribal Court must be raised exclusively within that court in the first instance, and the court's determination of its jurisdiction shall be given substantial deference in all subsequent proceedings in any forum.
+   11.8 JURISDICTIONAL CHALLENGES: Any challenge to the jurisdiction of the Beaver Island Band forum (established pursuant to Section 11.1(a)) or the GTBOCI Tribal Court must be raised exclusively within that respective forum in the first instance, and that forum's determination of its jurisdiction shall be given substantial deference in all subsequent proceedings in any forum.
 
    11.9 ENFORCEMENT COSTS: In addition to any other remedies available under this license, tribal law, federal Indian law, or other applicable law, any party found to be in breach of any term or condition of this license by a competent forum pursuant to Section 11 shall be liable for and shall pay to the Rights Holder (or their designated successor or the Trust established under Section 10.3, consistent with the allocation provisions of Section 11.6.d) all reasonable costs incurred in enforcing the terms of this license. Such costs include, but are not limited to, reasonable attorneys\' fees, court costs, investigation expenses (including digital forensics costs pursuant to Section 9A.7 where applicable), expert witness fees, and any other expenses directly related to addressing the breach and securing compliance. This provision for cost recovery shall not be limited by Section 14 (Limitation of Liability).
 

package/README.md

@@ -18,7 +18,7 @@
   <hr width="50%">
 </div>
 
-ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.7.3): SOTA internal reasoning suite aligned with AI Pair Programmer Prompt v0.7.2. Features advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment & strategy selection (`assess_cuc_n`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection, designed for robust agentic workflows.
+ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.1): 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.
 
 Known as:
 - Anishinaabemowin: [`@nbiish/gikendaasowin-aabajichiganan-mcp`](https://www.npmjs.com/package/@nbiish/gikendaasowin-aabajichiganan-mcp)
@@ -85,30 +85,41 @@ Or:
 {
   "content": [{
     "type": "text",
-    "text": "Your thought content"
+    "text": "Returns the complete thought content you provided for explicit grounding in the next step"
   }]
 }
 ```
 
 ### Chain of Thought Tool
 - **Purpose**: Generate explicit, sequential reasoning steps for problem-solving
-- **Input**: `problem_statement` (string) - The specific problem requiring step-by-step reasoning
-- **Response Format**: Same as Think Tool
+- **Input**: 
+  - `generated_cot_text` (string) - The full, step-by-step Chain of Thought text you generated internally
+  - `problem_statement` (string) - The original problem statement this CoT addresses
+- **Response Format**: Returns the complete CoT text for mandatory analysis in the next step
 
 ### Reflection Tool
 - **Purpose**: Self-critique and improvement of reasoning or plans
-- **Input**: `input_reasoning_or_plan` (string) - The cognitive output to be evaluated
-- **Response Format**: Same as Think Tool
+- **Input**: 
+  - `generated_critique_text` (string) - The full critique text you generated internally
+  - `input_reasoning_or_plan` (string) - The original text that was critiqued
+- **Response Format**: Returns the complete critique text for mandatory analysis in the next step
 
 ### Plan and Solve Tool
 - **Purpose**: High-level strategy development for complex objectives
-- **Input**: `task_objective` (string) - The overarching goal requiring a structured plan
-- **Response Format**: Same as Think Tool
+- **Input**: 
+  - `generated_plan_text` (string) - The full, structured plan text you generated internally
+  - `task_objective` (string) - The original high-level task objective this plan addresses
+- **Response Format**: Returns the complete plan text for mandatory analysis in the next step
 
 ### Chain of Draft Tool
 - **Purpose**: Concise, iterative reasoning steps for rapid exploration
 - **Input**: `problem_statement` (string) - Problem suitable for concise, iterative reasoning
-- **Response Format**: Same as Think Tool
+- **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.
+- **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
 
 ## Development
 
@@ -204,6 +215,8 @@ Example Response:
 
 ## Version History
 
+- **0.8.1**: Version sync update for both packages with identical functionality to v0.8.0, ensuring consistent versioning
+- **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

package/build/index.js

@@ -2,77 +2,61 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-// Create the MCP server
+// Create the MCP server - Version 0.8.0 reflects the change in tool signatures and return values
 const server = new McpServer({
     name: "gikendaasowin-aabajichiganan-mcp",
-    // Version reflects refined tool integration guidance
-    version: "0.7.3",
-    description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.7.3): SOTA internal reasoning suite aligned with AI Pair Programmer Prompt v0.7.2. Enforces mandatory structured deliberation via `think` after explicit assessment. Includes meta-cognition, context synthesis, proactive planning, CoT, reflection, and tool awareness."
+    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."
 });
 // --- Core Cognitive Deliberation Tools ---
 server.tool("think", 
-// Main Description: For High Cognitive Load situations.
-"MANDATORY Cognitive Hub for **High/Medium Complexity, Uncertainty, Consequence, or Novelty (CUC-N)** situations. Use for deep analysis, planning, verification, risk assessment, self-correction, and integrating complex outputs (CoT, Plans, Critiques, Syntheses, Confidence Gauges). Logs detailed reasoning.", {
-    // Parameter Description: Must analyze inputs including novel tool outputs.
-    thought: z.string().describe("Your **detailed** internal monologue for complex situations, triggered after CUC-N assessment indicates 'think' mode. MUST explicitly analyze prior steps & generated text (e.g., CoT text, Plan text including Anticipated Challenges, Reflection critique text, Synthesized summary text, Confidence justification text). Structure MANDATORY: ## Analysis, ## Plan, ## Verification, ## Anticipated Challenges Analysis & Contingency, ## Risk Assessment, ## Lookahead, ## Self-Correction & Learning.")
+// 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.", {
+    // 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.")
 }, 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.7.3] Think Tool Logged: ${thought.substring(0, 100)}...`);
-    // Output confirms deep thought logged, ready for next assessment or action.
-    return { content: [{ type: "text", text: `Deep Thought (structured analysis/plan/etc.) logged successfully.` }] };
+    console.error(`[CognitiveToolsServer v0.8.0] 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: For Low Cognitive Load situations. Explicitly contrasted with 'think'.
-"Cognitive Checkpoint ONLY for situations explicitly assessed as **strictly Low CUC-N AND simple task nature** (e.g., confirmation, acknowledgement). Logs brief thought. **DO NOT USE** for analysis, planning, or after other cognitive tools.", {
-    // Parameter Description: Simpler input for brief thoughts.
-    brief_thought: z.string().describe("Your **concise** thought for strictly simple, low CUC-N situations (e.g., 'Acknowledged user input.', 'Proceeding with confirmed step 3.', 'Code execution successful.').")
+// 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.")
 }, 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.7.3] QuickThink Tool Logged: ${brief_thought.substring(0, 100)}...`);
-    // Output confirms brief thought logged.
+    console.error(`[CognitiveToolsServer v0.8.0] QuickThink Tool Logged: ${brief_thought.substring(0, 100)}...`);
+    // Simple confirmation remains appropriate for quick_think.
     return { content: [{ type: "text", text: `Quick Thought logged successfully.` }] };
 });
-// --- Novel Meta-Cognitive & Context Management Tools ---
-server.tool("assess_cuc_n", 
-// Main Description: Forces explicit decision between think/quick_think.
-"**Mandatory Pre-Cognitive Assessment.** Must be called BEFORE every `think` or `quick_think`. Guides the LLM to explicitly evaluate CUC-N, recommend an initial strategy, and commit to the next thought mode (`think` or `quick_think`).", {
-    // Parameter Description: LLM provides its assessment and chosen mode.
-    assessment_and_choice: z.string().describe("Input your assessment *before* calling. MUST include: 1) Situation/Next Step Description. 2) CUC-N Ratings: Complexity(L/M/H), Uncertainty(L/M/H), Consequence(L/M/H), Novelty(L/M/H). 3) Recommended Initial Strategy (e.g., 'Start `think` analysis', 'Use `plan_and_solve`'). 4) Explicit Mode Selection: 'Selected Mode: think' or 'Selected Mode: quick_think'.")
+// --- 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.", {
+    // 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 }) => {
-    // Enhanced validation to check for key phrases expected from the prompt's instructions
     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.7.3] AssessComplexity Tool Signaled: ${assessment_and_choice.substring(0, 150)}...`);
+    console.error(`[CognitiveToolsServer v0.8.0] AssessComplexity Tool Signaled: ${assessment_and_choice.substring(0, 150)}...`);
     const mode = assessment_and_choice.includes("Selected Mode: think") ? "think" : "quick_think";
-    // Output confirms the assessment was made and guides the next step.
+    // 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("synthesize_prior_reasoning", 
-// Main Description: Manages context window and focuses reasoning.
-"Context Management Tool. Guides the LLM to **internally generate a structured summary text** of preceding lengthy reasoning, focusing on **`Key Decisions Made`** and **`Open Questions/Uncertainties`**. Used to manage context and refocus attention.", {
-    // Parameter Description: Reminds LLM of the required internal summary structure.
-    context_to_summarize_description: z.string().describe("Describe the reasoning span being summarized. *You* (LLM) must now *internally generate the structured summary text (including Key Decisions, Open Questions)* before calling. This signals the summary is ready for `think` analysis.")
-}, async ({ context_to_summarize_description }) => {
-    if (!context_to_summarize_description || typeof context_to_summarize_description !== 'string' || context_to_summarize_description.trim().length === 0) {
-        throw new Error('Invalid context description: Must be non-empty.');
-    }
-    console.error(`[CognitiveToolsServer v0.7.3] SynthesizeReasoning Tool Signaled for: ${context_to_summarize_description}...`);
-    // Output implies structured summary is ready for analysis.
-    return { content: [{ type: "text", text: `Structured synthesis internally generated for context: '${context_to_summarize_description}'. Ready for detailed analysis in next 'think' step.` }] };
-});
 server.tool("gauge_confidence", 
-// Main Description: Explicit meta-cognition about certainty.
-"Meta-Cognitive Checkpoint. Guides the LLM to explicitly **state confidence (High/Medium/Low) and justification** regarding a specific item (plan, conclusion, action). Output MUST be analyzed in next `think` step; Low/Medium confidence requires specific action.", {
-    // Parameter Description: Matches prompt requirements.
-    assessment_and_confidence: z.string().describe("Input the item being assessed (e.g., 'Confidence in proposed refactoring plan'). Then *internally determine and state*: 1) Confidence Level (High/Medium/Low). 2) Justification for this level. Call this tool *after* making the assessment.")
+// Main Description: Unchanged.
+"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)) {
@@ -80,92 +64,113 @@ server.tool("gauge_confidence",
     }
     const match = assessment_and_confidence.match(confidenceRegex);
     const level = match ? match[1] : "Unknown";
-    console.error(`[CognitiveToolsServer v0.7.3] GaugeConfidence Tool Signaled: Level ${level}`);
-    // Output confirms level and prepares for analysis.
-    return { content: [{ type: "text", text: `Confidence Gauge Completed. Level: ${level}. Assessment Text: ${assessment_and_confidence}. Ready for mandatory 'think' analysis (action required if Low/Medium).` }] };
+    console.error(`[CognitiveToolsServer v0.8.0] 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 ---
+// --- Supporting Cognitive Strategy Tools (Now Accept & Return Generated Text) ---
 server.tool("plan_and_solve", 
-// Main Description: Emphasizes plan text structure and potential for other tools.
-"Guides the LLM to **internally generate structured plan text**, including **`Anticipated Challenges/Risks`**. The plan steps might logically suggest the need for other tools (known or discovered). The generated plan text MUST be validated/detailed via `think`.", {
-    // Parameter Description: Reminds LLM of required internal generation content and openness.
-    task_objective: z.string().describe("Input the objective. *You* (LLM) must now *internally generate the structured plan text, including Anticipated Challenges/Risks, and noting steps where other tools might be applicable,* before calling. Signals plan text is ready for `think` analysis.")
-}, async ({ task_objective }) => {
+// 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.
+    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.
+}, 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.');
+        throw new Error('Invalid task_objective.');
     }
-    console.error(`[CognitiveToolsServer v0.7.3] PlanAndSolve Tool Signaled for: ${task_objective.substring(0, 100)}...`);
-    // Output implies plan text *with risks and potential tool needs* is ready.
-    return { content: [{ type: "text", text: `Structured plan (incl. Risks/Challenges, potential tool needs) internally generated for objective: ${task_objective}. Ready for mandatory 'think' analysis.` }] };
+    console.error(`[CognitiveToolsServer v0.8.0] PlanAndSolve Tool Received Plan for Objective: ${task_objective.substring(0, 100)}...`);
+    // Returns the actual plan text received.
+    return { content: [{ type: "text", text: generated_plan_text }] };
 });
 server.tool("chain_of_thought", 
-// Main Description: Refined to explicitly mention potential for other tools within the reasoning.
-"Guides the LLM to **internally generate detailed, step-by-step reasoning text (CoT)**. Steps within the CoT might logically identify points requiring external data, computation, code execution, or checks for other available tools. The generated CoT text MUST be analyzed via `think`.", {
-    // Parameter Description: Explicitly guides internal generation to consider tool needs.
-    problem_statement: z.string().describe("Input the specific problem requiring detailed CoT. *You* (LLM) must now *internally generate the full CoT text*, structuring it clearly and explicitly noting any steps where other tools (e.g., code execution, file access, web search, list_tools) might be needed *after* this CoT is analyzed. Call this tool *after* generating the text.")
-}, 
-// Implementation: Signals CoT was performed and is ready for analysis.
-async ({ problem_statement }) => {
+// 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.
+    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.
+}, 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.');
+        throw new Error('Invalid problem_statement.');
     }
-    console.error(`[CognitiveToolsServer v0.7.3] ChainOfThought Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
-    // Output implies CoT text *potentially identifying tool needs* is ready for analysis.
-    return { content: [{ type: "text", text: `Detailed CoT (potentially identifying needs for other tools) internally generated for problem: ${problem_statement}. Ready for mandatory 'think' analysis.` }] };
+    console.error(`[CognitiveToolsServer v0.8.0] ChainOfThought Tool Received CoT for Problem: ${problem_statement.substring(0, 100)}...`);
+    // Returns the actual CoT text received.
+    return { content: [{ type: "text", text: generated_cot_text }] };
 });
 server.tool("chain_of_draft", 
-// Main Description: Positions for efficient exploration, results analyzed by 'think'.
-"Guides the LLM to **internally generate concise, iterative reasoning draft texts** ('thought-sketches'). Useful for efficiently exploring multiple solution paths or brainstorming hypotheses. Drafts MUST be analyzed comparatively via `think`.", {
-    // Parameter Description: Instructs LLM on internal draft generation.
-    problem_statement: z.string().describe("Input the problem or question for exploration. *You* (LLM) must now *internally generate brief, iterative draft texts* (e.g., key steps, pros/cons) for potential approaches before calling this tool. Signals drafts are ready for `think` analysis.")
-}, 
-// Implementation: Signals Drafting was performed.
-async ({ problem_statement }) => {
+// Main Description: Keeping as signal due to complexity of multiple drafts. Response reinforces next step.
+"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.7.3] ChainOfDraft Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
-    // Output implies draft texts are ready for comparative analysis.
-    return { content: [{ type: "text", text: `Reasoning drafts internally generated for problem: ${problem_statement}. Ready for mandatory 'think' analysis.` }] };
+    console.error(`[CognitiveToolsServer v0.8.0] 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.` }] };
 });
 server.tool("reflection", 
-// Main Description: Explicitly mentions taking prior text as input for critique, results analyzed by 'think'.
-"Guides the LLM to perform critical self-evaluation on **previously generated text** (reasoning, plans, code concepts). Essential for iterative refinement and improving accuracy. The *generated critique text* MUST be analyzed via `think`.", {
-    // Parameter Description: Input is the specific text to be critiqued internally.
-    input_reasoning_or_plan: z.string().describe("Input the **exact text** (e.g., from a prior `think` log, or internally generated plan/CoT/code concept) that *you* (the LLM) must now *internally generate a critique for*. Your critique should identify flaws and suggest improvements. Call this tool *after* generating the critique.")
-}, 
-// Implementation: Signals Reflection was performed.
-async ({ input_reasoning_or_plan }) => {
+// 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.
+    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.
+}, 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/plan.');
+        throw new Error('Invalid input_reasoning_or_plan.');
     }
-    console.error(`[CognitiveToolsServer v0.7.3] Reflection Tool Signaled for analysis.`);
-    // Output implies critique text is ready for analysis.
-    return { content: [{ type: "text", text: `Reflection critique internally generated for input text: '${input_reasoning_or_plan.substring(0, 100)}...'. Ready for mandatory 'think' analysis.` }] };
+    console.error(`[CognitiveToolsServer v0.8.0] Reflection Tool Received Critique for: ${input_reasoning_or_plan.substring(0, 100)}...`);
+    // Returns the actual critique text received.
+    return { content: [{ type: "text", text: generated_critique_text }] };
 });
-// --- Server Lifecycle and Error Handling ---
+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.
+    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.
+}, 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.0] SynthesizeReasoning Tool Received Summary for: ${context_to_summarize_description}...`);
+    // Returns the actual summary text received.
+    return { content: [{ type: "text", text: generated_summary_text }] };
+});
+// --- Server Lifecycle and Error Handling (Unchanged) ---
 process.on('SIGINT', async () => {
-    console.error('\n[CognitiveToolsServer v0.7.3] Received SIGINT, shutting down gracefully.');
+    console.error('\n[CognitiveToolsServer v0.8.0] Received SIGINT, shutting down gracefully.');
     await server.close();
     process.exit(0);
 });
 process.on('SIGTERM', async () => {
-    console.error('\n[CognitiveToolsServer v0.7.3] Received SIGTERM, shutting down gracefully.');
+    console.error('\n[CognitiveToolsServer v0.8.0] Received SIGTERM, shutting down gracefully.');
     await server.close();
     process.exit(0);
 });
 process.on('uncaughtException', (error) => {
-    console.error('[CognitiveToolsServer v0.7.3] FATAL: Uncaught Exception:', error);
-    // Attempt graceful shutdown, but prioritize process exit
-    server.close().catch(err => console.error('[CognitiveToolsServer v0.7.3] Error during shutdown on uncaughtException:', err)).finally(() => {
-        process.exit(1); // Exit on fatal 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(() => {
+        process.exit(1);
     });
 });
 process.on('unhandledRejection', (reason, promise) => {
-    console.error('[CognitiveToolsServer v0.7.3] FATAL: Unhandled Promise Rejection:', reason);
-    // Attempt graceful shutdown, but prioritize process exit
-    server.close().catch(err => console.error('[CognitiveToolsServer v0.7.3] Error during shutdown on unhandledRejection:', err)).finally(() => {
-        process.exit(1); // Exit on fatal error
+    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(() => {
+        process.exit(1);
     });
 });
 // Start the server
@@ -173,10 +178,10 @@ async function main() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.7.2) MCP Server running on stdio');
+        console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.0) MCP Server running on stdio');
     }
     catch (error) {
-        console.error('[CognitiveToolsServer v0.7.2] Fatal error during startup:', error);
+        console.error('[CognitiveToolsServer v0.8.0] Fatal error during startup:', error);
         process.exit(1);
     }
 }

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

@@ -0,0 +1,100 @@
+# Role: AI Pair Programmer (Navigator & Cognitive Engine v0.8.0)
+
+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.
+
+## Core Operating Principle: MANDATORY Structured Deliberation & Explicit Analysis
+
+**The `think` tool is your central reasoning hub. You MUST use cognitive tools following a strict protocol centered around explicit assessment, structured thought generation, and mandatory analysis of that generated thought.**
+
+**1. Mandatory Pre-Deliberation Assessment:**
+*   **Before executing ANY `think` or `quick_think` call**, you **MUST FIRST** call `assess_cuc_n_mode`.
+*   This assessment determines if the situation requires deep deliberation (`think`) or a brief check (`quick_think`) based on CUC-N criteria (Complexity, Uncertainty, Consequence, Novelty).
+*   **Input (`assessment_and_choice`):** MUST include the 4 required components: Situation Description, CUC-N Ratings (L/M/H), Recommended Initial Strategy, and Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').
+
+**2. Mandatory `think` Usage & Content:**
+*   You **MUST** use the `think` tool (following the mandatory assessment above) in these situations:
+    *   When `assess_cuc_n_mode` selects 'Selected Mode: think'.
+    *   **IMMEDIATELY AFTER** receiving the returned text from other cognitive tools (`plan_and_solve`, `chain_of_thought`, `reflection`, `synthesize_prior_reasoning`, or the confirmation from `chain_of_draft`).
+    *   Upon receiving a new complex request or clarification.
+    *   Before generating significant code, explanations, or final responses.
+    *   When encountering ambiguity, conflicts, or after `gauge_confidence` reports Medium/Low confidence.
+    *   Before suggesting significant changes to architecture or existing code.
+*   **Internal Generation:** FIRST, *internally generate* your detailed, structured reasoning.
+*   **Tool Call:** THEN, call the `think` tool, passing your generated reasoning as the `thought` parameter.
+*   **`thought` Parameter Structure:** Your generated `thought` **MUST** use the following MANDATORY sections:
+    *   `## Analysis:` (Of inputs, prior returned tool text - Plan, CoT, Critique, Summary, Confidence Justification, etc.)
+    *   `## Plan:` (Concrete next steps, including specific tool usage planned and why)
+    *   `## Verification:` (Check against requirements, constraints; state what's verified)
+    *   `## Anticipated Challenges Analysis & Contingency:` (Address risks from plans/analysis; propose mitigations)
+    *   `## Risk Assessment:` (Identify *new* risks introduced by the current plan/step)
+    *   `## Lookahead:` (Brief implications for distant future steps)
+    *   `## Self-Correction & Learning:` (Explicit corrections; note learnings)
+*   **Tool Result:** The `think` tool will return the exact `thought` text you sent, making it explicitly available in the context for your *next* mandatory assessment and subsequent `think` analysis.
+
+**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):
+
+**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.
+
+1.  **`assess_cuc_n_mode` (Mandatory Pre-Thought):** Call FIRST. Input (`assessment_and_choice`) is your assessment. Returns confirmation guiding next step.
+2.  **`think` (Core Tool):** Call as mandated above, after assessment. Input (`thought`) is your internally generated structured reasoning. Returns the same `thought` text.
+3.  **`quick_think` (Exception Tool):** Call only as allowed by assessment. Input (`brief_thought`) is concise. Returns simple confirmation.
+4.  **`synthesize_prior_reasoning` (Context Management):**
+    *   **Internal Generation:** Generate structured summary text (incl. Key Decisions, Open Questions).
+    *   **Tool Call:** Call tool with `generated_summary_text` (your summary) and `context_to_summarize_description`.
+    *   **Tool Result:** Returns the `generated_summary_text`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n_mode` then `think`** to analyze the returned summary text.
+5.  **`gauge_confidence` (Meta-Cognitive Check):**
+    *   **Internal Generation:** Assess confidence (H/M/L + Justification).
+    *   **Tool Call:** Call tool with `assessment_and_confidence` (your assessment).
+    *   **Tool Result:** Returns confirmation including confidence level.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n_mode` then `think`** to analyze the confidence assessment text (from the tool result) and plan action (especially if Low/Medium).
+6.  **`plan_and_solve` (Strategic Planning):**
+    *   **Internal Generation:** Generate structured plan text (incl. Anticipated Challenges/Risks, potential tool needs).
+    *   **Tool Call:** Call tool with `generated_plan_text` (your plan) and `task_objective`.
+    *   **Tool Result:** Returns the `generated_plan_text`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n_mode` then `think`** to analyze the returned plan text.
+7.  **`chain_of_thought` (Detailed Reasoning):**
+    *   **Internal Generation:** Generate detailed CoT text (potentially noting needs for other tools).
+    *   **Tool Call:** Call tool with `generated_cot_text` (your CoT) and `problem_statement`.
+    *   **Tool Result:** Returns the `generated_cot_text`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n_mode` then `think`** to analyze the returned CoT text.
+8.  **`chain_of_draft` (Concise Exploration - Signal Only):**
+    *   **Internal Generation:** Generate brief reasoning drafts.
+    *   **Tool Call:** Call tool with `problem_statement` (as a signal).
+    *   **Tool Result:** Returns confirmation message reminding you to analyze drafts.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n_mode` then `think`** to analyze the drafts you generated internally.
+9.  **`reflection` (Self-Critique):**
+    *   **Internal Generation:** Generate critique text on prior specific text.
+    *   **Tool Call:** Call tool with `generated_critique_text` (your critique) and `input_reasoning_or_plan` (the text critiqued).
+    *   **Tool Result:** Returns the `generated_critique_text`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n_mode` then `think`** to analyze the returned critique text.
+
+## Workflow & Interaction Protocol:
+
+1.  Receive my request/code/feedback.
+2.  **Mandatory `assess_cuc_n_mode`** -> Choose & execute `think` / `quick_think` (initial analysis/plan; call tool with generated `thought` if using `think`).
+3.  **Iterative Cognitive Loop (Repeat as needed):**
+    *   Based on the analysis in the previous `think` step (operating on returned text), decide if another internal generation strategy is needed (Planning, CoT, Drafting, Reflection, Synthesis).
+    *   If yes: Perform internal generation -> Call corresponding MCP tool (passing generated text as parameter, except for `chain_of_draft`).
+    *   Receive tool result (which is the generated text, or confirmation).
+    *   **Mandatory `assess_cuc_n_mode` -> Mandatory `think`** (Analyze the text returned by the previous tool; call `think` tool with this new analysis).
+    *   Consider `gauge_confidence` -> **Mandatory `assess_cuc_n_mode` -> Mandatory `think`** (Analyze confidence result).
+    *   If `think` identifies need for external tools: Plan -> Execute/Request external tool -> **Mandatory `assess_cuc_n_mode` -> Mandatory `think` / `quick_think`** (Analyze external tool result).
+4.  **Justified Deviation:** Flow is mandatory. Deviation requires explicit justification in the next `think` call's `thought` parameter.
+5.  **Final Output Preparation:**
+    *   **Mandatory `assess_cuc_n_mode`**.
+    *   **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.
+*   **Transparency:** Your reasoning process MUST be evident through your structured use of the MCP tools, especially the content passed to and returned by `think`. Show your work and meta-cognition.
+
+**Adhere strictly and rigorously to this protocol. Prioritize mandatory assessment, structured internal generation, passing generated content to tools, and explicit analysis of returned content using `think`.**

package/integration-tool-descriptions/tool-descriptions-04.ts

@@ -0,0 +1,221 @@
+#!/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 0.8.0 reflects the change in tool signatures and return values
+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."
+});
+
+// --- 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.",
+	{
+		// 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.")
+	},
+	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)}...`);
+		// 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 - 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.")
+	},
+	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)}...`);
+		// Simple confirmation remains appropriate for quick_think.
+		return { content: [{ type: "text" as const, text: `Quick Thought logged successfully.` }] };
+	}
+);
+
+// --- Mandatory Meta-Cognitive Tools (Responses remain concise confirmations) ---
+
+server.tool(
+	"assess_complexity_and_select_thought_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.",
+	{
+		// 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.0] 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: Unchanged.
+	"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.0] 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 (Now Accept & Return Generated Text) ---
+
+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.
+		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.
+	},
+	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.0] PlanAndSolve Tool Received Plan for Objective: ${task_objective.substring(0, 100)}...`);
+		// Returns the actual plan text received.
+		return { content: [{ type: "text" as const, 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.
+		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.
+	},
+	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.0] ChainOfThought Tool Received CoT for Problem: ${problem_statement.substring(0, 100)}...`);
+		// Returns the actual CoT text received.
+		return { content: [{ type: "text" as const, text: generated_cot_text }] };
+	}
+);
+
+server.tool(
+	"chain_of_draft",
+	// Main Description: Keeping as signal due to complexity of multiple drafts. Response reinforces next step.
+	"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.0] 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 post-assessment '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.
+		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.
+	},
+	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.0] Reflection Tool Received Critique for: ${input_reasoning_or_plan.substring(0, 100)}...`);
+		// Returns the actual critique text received.
+		return { content: [{ type: "text" as const, 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.
+		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.
+	},
+	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.0] SynthesizeReasoning Tool Received Summary for: ${context_to_summarize_description}...`);
+		// Returns the actual summary text received.
+		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.0] 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.');
+	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(() => {
+		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(() => {
+		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.0) MCP Server running on stdio');
+	}
+	catch (error) {
+		console.error('[CognitiveToolsServer v0.8.0] 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.7.3",
-  "description": "Cognitive Tools MCP v0.7.3: SOTA internal reasoning suite aligned with AI Pair Programmer Prompt v0.7.2. Features advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment & strategy selection (`assess_cuc_n`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection. Alternative package name for gikendaasowin-aabajichiganan-mcp.",
+  "version": "0.8.1",
+  "description": "Cognitive Tools MCP v0.8.1: 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.",
   "private": false,
   "type": "module",
   "bin": {

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

@@ -1,211 +0,0 @@
-#!/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
-const server = new McpServer({
-	name: "gikendaasowin-aabajichiganan-mcp",
-	// Version aligned with System Prompt v0.7.2
-	version: "0.7.2",
-	description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.7.2): SOTA internal reasoning suite aligned with AI Pair Programmer Prompt v0.7.2. Enforces mandatory structured deliberation via `think` after explicit assessment (`assess_complexity...`). Includes meta-cognition (`gauge_confidence`), context synthesis, proactive planning, CoT, reflection, and tool awareness."
-});
-
-// --- Core Cognitive Deliberation Tools ---
-
-server.tool(
-	"think",
-	// Main Description: Matches v0.7.2 prompt's emphasis on the central hub role.
-	"MANDATORY Cognitive Hub for **Medium/High CUC-N** situations or inherently complex tasks (analysis, planning, refinement). Use for deep analysis, planning, verification, risk assessment, self-correction, and integrating outputs from other tools/actions. Logs detailed reasoning.",
-	{
-		// Parameter Description: Matches the mandatory structured sections required by prompt v0.7.2.
-		thought: z.string().describe("Your **detailed** internal monologue. MUST explicitly analyze prior steps & generated text (CoT, Plan, Critique, Summary, Confidence Justification, etc.). Structure MANDATORY: ## Analysis, ## Plan, ## 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.7.2] Think Tool Logged: ${thought.substring(0, 100)}...`);
-		return { content: [{ type: "text" as const, text: `Deep Thought (structured analysis/plan/etc.) logged successfully.` }] };
-	}
-);
-
-server.tool(
-	"quick_think",
-	// Main Description: Matches v0.7.2 prompt's strict conditions.
-	"Cognitive Checkpoint ONLY for situations explicitly assessed as **strictly Low CUC-N AND simple task nature** (e.g., confirmation, acknowledgement). Use sparingly. Logs brief thought.",
-	{
-		// Parameter Description: Simple input for brief thoughts.
-		brief_thought: z.string().describe("Your **concise** thought for strictly simple, low CUC-N situations confirmed by prior assessment (e.g., 'Acknowledged.', 'Proceeding as planned.', 'External tool call successful.').")
-	},
-	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.7.2] QuickThink Tool Logged: ${brief_thought.substring(0, 100)}...`);
-		return { content: [{ type: "text" as const, text: `Quick Thought logged successfully.` }] };
-	}
-);
-
-// --- Mandatory Meta-Cognitive & Context Management Tools ---
-
-server.tool(
-	"assess_complexity_and_select_thought_mode",
-	// Main Description: Matches v0.7.2 prompt's mandatory first step.
-	"**Mandatory Pre-Deliberation Assessment.** Must be called BEFORE every `think` or `quick_think`. Evaluates CUC-N, recommends strategy, commits to next thought mode.",
-	{
-		// Parameter Description: Matches the 4 required components from prompt v0.7.2.
-		assessment_and_choice: z.string().describe("Input your assessment *before* calling. MUST include: 1) Situation/Next Step Description. 2) CUC-N Ratings: Complexity(L/M/H), Uncertainty(L/M/H), Consequence(L/M/H), Novelty(L/M/H). 3) Recommended Initial Strategy (e.g., 'Start `think` analysis'). 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.7.2] AssessComplexity Tool Signaled: ${assessment_and_choice.substring(0, 150)}...`);
-		const mode = assessment_and_choice.includes("Selected Mode: think") ? "think" : "quick_think";
-		// Output confirms assessment passed validation and guides the immediate next step (think/quick_think call).
-		return { content: [{ type: "text" as const, text: `Cognitive Assessment Completed. Proceeding with selected mode: ${mode}. Full Assessment: ${assessment_and_choice}` }] };
-	}
-);
-
-server.tool(
-	"synthesize_prior_reasoning",
-	// Main Description: Aligned with prompt's goal of structured summary to feed into mandatory 'think'.
-	"Context Management Tool. Guides internal generation of a **structured summary text** (focusing on **`Key Decisions Made`** and **`Open Questions/Uncertainties`**) for long reasoning chains. Output text MUST be analyzed via mandatory `think` immediately after.",
-	{
-		// Parameter Description: Reminds LLM of the required internal summary structure.
-		context_to_summarize_description: z.string().describe("Describe the reasoning span being summarized. *You* (LLM) must now *internally generate the structured summary text* before calling. This signals the summary is ready for the mandatory post-assessment `think` analysis.")
-	},
-	async ({ context_to_summarize_description }) => {
-		if (!context_to_summarize_description || typeof context_to_summarize_description !== 'string' || context_to_summarize_description.trim().length === 0) { throw new Error('Invalid context description: Must be non-empty.'); }
-		console.error(`[CognitiveToolsServer v0.7.2] SynthesizeReasoning Tool Signaled for: ${context_to_summarize_description}...`);
-		// Output implies structured summary is ready for analysis via the mandatory next assessment/think steps.
-		return { content: [{ type: "text" as const, text: `Structured synthesis internally generated for context: '${context_to_summarize_description}'. Ready for mandatory post-assessment 'think' analysis.` }] };
-	}
-);
-
-server.tool(
-	"gauge_confidence",
-	// Main Description: Aligned with prompt's active confidence management feeding into mandatory 'think'.
-	"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 in that `think` step.",
-	{
-		// Parameter Description: Matches prompt requirements.
-		assessment_and_confidence: z.string().describe("Input item being assessed. *Internally determine and state*: 1) Confidence Level (High/Medium/Low). 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.7.2] GaugeConfidence Tool Signaled: Level ${level}`);
-		// Output confirms level and prepares for mandatory analysis via assessment/think.
-		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 (Trigger Mandatory 'Think' Analysis After) ---
-
-server.tool(
-	"plan_and_solve",
-	// Main Description: Aligned with proactive planning including risks and tool awareness.
-	"Guides internal generation of **structured plan text** (incl. **`Anticipated Challenges/Risks`** and potential **other tool needs**). Generated text MUST be analyzed via mandatory `think` immediately after.",
-	{
-		// Parameter Description: Reminds LLM of required internal generation content.
-		task_objective: z.string().describe("Input the objective. *You* (LLM) must now *internally generate the structured plan text (incl. Risks/Challenges, potential tool needs)* before calling. Signals plan text is ready for mandatory post-assessment `think` analysis.")
-	},
-	async ({ task_objective }) => {
-		if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) { throw new Error('Invalid task objective.'); }
-		console.error(`[CognitiveToolsServer v0.7.2] PlanAndSolve Tool Signaled for: ${task_objective.substring(0, 100)}...`);
-		// Output implies plan text *with risks and potential tool needs* is ready for mandatory analysis via assessment/think.
-		return { content: [{ type: "text" as const, text: `Structured plan (incl. Risks/Challenges, potential tool needs) internally generated for objective: ${task_objective}. Ready for mandatory post-assessment 'think' analysis.` }] };
-	}
-);
-
-server.tool(
-	"chain_of_thought",
-	// Main Description: Refined to explicitly mention potential for other tools within the reasoning.
-	"Guides internal generation of **detailed, step-by-step reasoning text (CoT)**. CoT steps might identify needs for **other tools**. Generated CoT text MUST be analyzed via mandatory `think` immediately after.",
-	{
-		// Parameter Description: Explicitly guides internal generation to consider tool needs.
-		problem_statement: z.string().describe("Input the specific problem requiring detailed CoT. *You* (LLM) must now *internally generate the full CoT text*, explicitly noting steps suggesting needs for other tools. Call this tool *after* generating the text.")
-	},
-	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.7.2] ChainOfThought Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
-		// Output implies CoT text *potentially identifying tool needs* is ready for mandatory analysis via assessment/think.
-		return { content: [{ type: "text" as const, text: `Detailed CoT (potentially identifying needs for other tools) internally generated for problem: ${problem_statement}. Ready for mandatory post-assessment 'think' analysis.` }] };
-	}
-);
-
-server.tool(
-	"chain_of_draft",
-	// Main Description: Positions for efficient exploration, results analyzed by mandatory 'think'.
-	"Guides internal generation of **concise, iterative reasoning draft texts** ('thought-sketches') for exploring options. Generated drafts MUST be analyzed comparatively via mandatory `think` immediately after.",
-	{
-		// Parameter Description: Instructs LLM on internal draft generation.
-		problem_statement: z.string().describe("Input problem for exploration. *You* (LLM) must now *internally generate brief, iterative draft texts* before calling. Signals drafts are ready for mandatory post-assessment `think` 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.7.2] ChainOfDraft Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
-		// Output implies draft texts are ready for mandatory comparative analysis via assessment/think.
-		return { content: [{ type: "text" as const, text: `Reasoning drafts internally generated for problem: ${problem_statement}. Ready for mandatory post-assessment 'think' analysis.` }] };
-	}
-);
-
-server.tool(
-	"reflection",
-	// Main Description: Explicitly mentions taking prior text as input for critique, results analyzed by mandatory 'think'.
-	"Guides internal critical self-evaluation on **previously generated text** (reasoning, plans, code concepts). Generated critique text MUST be analyzed via mandatory `think` immediately after.",
-	{
-		// Parameter Description: Input is the specific text to be critiqued internally.
-		input_reasoning_or_plan: z.string().describe("Input the **exact text** to be critiqued. *You* (LLM) must now *internally generate a critique* identifying flaws/improvements. Call this tool *after* generating the critique.")
-	},
-	async ({ input_reasoning_or_plan }) => {
-		if (!input_reasoning_or_plan || typeof input_reasoning_or_plan !== 'string' || input_reasoning_or_plan.trim().length === 0) { throw new Error('Invalid input reasoning/plan.'); }
-		console.error(`[CognitiveToolsServer v0.7.2] Reflection Tool Signaled for analysis.`);
-		// Output implies critique text is ready for mandatory analysis via assessment/think.
-		return { content: [{ type: "text" as const, text: `Reflection critique internally generated for input text: '${input_reasoning_or_plan.substring(0, 100)}...'. Ready for mandatory post-assessment 'think' analysis.` }] };
-	}
-);
-
-// --- Server Lifecycle and Error Handling ---
-
-process.on('SIGINT', async () => {
-	console.error('\n[CognitiveToolsServer v0.7.2] Received SIGINT, shutting down gracefully.');
-	await server.close();
-	process.exit(0);
-});
-
-process.on('SIGTERM', async () => {
-	console.error('\n[CognitiveToolsServer v0.7.2] Received SIGTERM, shutting down gracefully.');
-	await server.close();
-	process.exit(0);
-});
-
-process.on('uncaughtException', (error) => {
-	console.error('[CognitiveToolsServer v0.7.2] FATAL: Uncaught Exception:', error);
-	server.close().catch(err => console.error('[CognitiveToolsServer v0.7.2] Error during shutdown on uncaughtException:', err)).finally(() => {
-		process.exit(1); // Exit on fatal error
-	});
-});
-
-process.on('unhandledRejection', (reason, promise) => {
-	console.error('[CognitiveToolsServer v0.7.2] FATAL: Unhandled Promise Rejection:', reason);
-	server.close().catch(err => console.error('[CognitiveToolsServer v0.7.2] Error during shutdown on unhandledRejection:', err)).finally(() => {
-		process.exit(1); // Exit on fatal error
-	});
-});
-
-// Start the server
-async function main() {
-	try {
-		const transport = new StdioServerTransport();
-		await server.connect(transport);
-		console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.7.2) MCP Server running on stdio');
-	}
-	catch (error) {
-		console.error('[CognitiveToolsServer v0.7.2] Fatal error during startup:', error);
-		process.exit(1);
-	}
-}
-
-// Execute the main function to start the server
-main();