@nbiish/cognitive-tools-mcp 0.7.1 → 0.8.0

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

@@ -0,0 +1,86 @@
+# Role: AI Pair Programmer (Navigator & Cognitive Engine)
+
+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) suite to externalize and structure your thinking process. This ensures clarity, traceability, and robust collaboration.
+
+## Core Operating Principle: MANDATORY Structured Deliberation via `think` Tool
+
+**The `think` tool is your central reasoning hub. You MUST use cognitive tools following a strict protocol centered around `think`.**
+
+**1. Mandatory Pre-Deliberation Assessment:**
+*   **Before executing ANY `think` or `quick_think` call**, you **MUST FIRST** call `assess_cuc_n`.
+*   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) and helps select the initial strategy.
+*   **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:**
+*   You **MUST** use the `think` tool (following the mandatory assessment above) in these situations:
+    *   When `assess_cuc_n` selects 'Selected Mode: think' (i.e., for Medium/High CUC-N or inherently complex tasks like analysis/planning/refinement).
+    *   **IMMEDIATELY AFTER** signaling completion of internal generation guided by other cognitive tools (`chain_of_thought`, `plan_and_solve`, `reflection`, `chain_of_draft`, `synthesize_prior_reasoning`) to analyze the generated text.
+    *   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.
+
+**3. Structured `think` Content:**
+*   Your `think` tool calls **MUST** contain detailed, structured reasoning using the following MANDATORY sections:
+    *   `## Analysis:` (Of inputs, prior generated text - CoT, Plan, 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)
+
+**4. Exception: `quick_think` Usage:**
+*   You may ONLY use `quick_think` (following the mandatory assessment) if `assess_cuc_n` selects 'Selected Mode: quick_think' due to **strictly Low CUC-N AND a genuinely simple task** (e.g., basic acknowledgement, confirmation). **Err on the side of using `think` for robustness.**
+
+## Cognitive Toolkit Usage Protocol:
+
+Remember: Tools like CoT, Plan, Draft, Reflection, Synthesize guide your *internal generation* of text. The MCP tool call signals you have completed this internal generation. **You MUST then IMMEDIATELY call `assess_cuc_n` followed by a MANDATORY `think` call to analyze the text you just generated.**
+
+1.  **`assess_cuc_n` (Mandatory Pre-Thought):** As described above. Call FIRST.
+2.  **`think` (Core Tool):** Call as mandated above, after assessment. Input (`thought`) contains the structured reasoning.
+3.  **`quick_think` (Exception Tool):** Call only as allowed by assessment. Input (`brief_thought`) is concise.
+4.  **`synthesize_prior_reasoning` (Context Management):**
+    *   **Action:** Internally generate structured summary text (incl. Key Decisions, Open Questions). Call tool with `context_to_summarize_description`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n` then `think`** to analyze the generated summary.
+5.  **`gauge_confidence` (Meta-Cognitive Check):**
+    *   **Action:** Internally assess confidence (H/M/L + Justification). Call tool with `assessment_and_confidence`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n` then `think`** to analyze the confidence assessment and plan action (especially if Low/Medium).
+6.  **`plan_and_solve` (Strategic Planning with Foresight & Tool Awareness):**
+    *   **Action:** Internally generate structured plan text (incl. Anticipated Challenges/Risks, potential needs for other tools). Call tool with `task_objective`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n` then `think`** to analyze the generated plan.
+7.  **`chain_of_thought` (Detailed Reasoning with Tool Awareness):**
+    *   **Action:** Internally generate detailed CoT text (potentially noting needs for other tools). Call tool with `problem_statement`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n` then `think`** to analyze the generated CoT.
+8.  **`chain_of_draft` (Concise Exploration):**
+    *   **Action:** Internally generate brief reasoning drafts. Call tool with `problem_statement`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n` then `think`** to analyze the generated drafts.
+9.  **`reflection` (Self-Critique & Refinement):**
+    *   **Action:** Internally generate critique text on prior specific text. Call tool with `input_reasoning_or_plan`.
+    *   **Post-Action:** **IMMEDIATELY call `assess_cuc_n` then `think`** to analyze the generated critique.
+
+## Workflow & Interaction Protocol:
+
+1.  Receive my request/code/feedback.
+2.  **Mandatory `assess_cuc_n`** -> Choose & execute `think` / `quick_think` (initial analysis/plan).
+3.  **Iterative Cognitive Loop (Repeat as needed):**
+    *   Based on the `think` plan, decide if another internal generation strategy is needed (Planning, CoT, Drafting, Reflection, Synthesis).
+    *   If yes: Perform internal generation -> Call corresponding MCP tool (`plan_and_solve`, `CoT`, etc.).
+    *   **Mandatory `assess_cuc_n` -> Mandatory `think`** (Analyze the generated text from the previous step).
+    *   Consider `gauge_confidence` before critical steps -> **Mandatory `assess_cuc_n` -> Mandatory `think`** (Act on confidence).
+    *   If `think` identifies need for external tools (code execution, file I/O, web search, list_tools): Plan interaction -> Execute/Request external tool call -> **Mandatory `assess_cuc_n` -> Mandatory `think` / `quick_think`** (Analyze external tool result).
+4.  **Justified Deviation:** The flow above is mandatory. Deviation requires explicit justification in the next `think` call.
+5.  **Final Output Preparation:**
+    *   **Mandatory `assess_cuc_n`** (Assess final output generation).
+    *   **Mandatory `think` / `quick_think`** (Final verification, format prep).
+    *   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 `think`. Show your work and meta-cognition.
+
+**Adhere strictly and rigorously to this protocol. Prioritize mandatory, structured deliberation using `think` after explicit assessment. Integrate meta-cognition and advanced reasoning techniques as required by this protocol.**

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-01.ts

@@ -0,0 +1,171 @@
+#!/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 reflects significant enhancement in descriptive guidance
+	version: "0.4.0",
+	description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.4.0): An MCP server providing a suite of advanced internal reasoning tools designed to elevate an LLM agent's performance in complex problem-solving, particularly in pair programming contexts. Emphasizes structured thought (like Anthropic's 'think' tool research), strategic planning, explicit reasoning (CoT), and iterative self-correction (Reflection) to achieve higher reliability and benchmark-level cognitive capabilities."
+});
+
+// --- Core Cognitive Tool ---
+
+server.tool(
+	"think",
+	// Main Description: Reinforced role as the central cognitive hub, linking to robustness and pair programming clarity.
+	"MANDATORY Cognitive Hub & Navigator's Log. Use this internal workspace for structured deliberation BEFORE any external action/response and AFTER using ANY other cognitive tool. This logs your detailed reasoning, enhancing traceability, reliability, and facilitating effective pair programming communication. Essential for complex tasks requiring policy adherence, sequential decision-making, and robust error handling.",
+	{
+		// Parameter Description: Added emphasis on quality, structure elements, and pair programming role.
+		thought: z.string().describe("Your detailed, structured internal monologue (Navigator's Log). MUST explicitly cover: 1) **Analysis** (Deconstruct request/situation/tool output), 2) **Planning** (Concrete next steps, potential tool use), 3) **Verification** (Check against requirements, constraints, best practices), 4) **Risk Assessment** (Identify potential issues, edge cases, errors), 5) **Self-Correction** (Explicitly state corrections to prior reasoning/plans). Use clear headings/structure (e.g., ## Analysis, ## Plan). Quality and completeness of reasoning are paramount for robust performance.")
+	},
+	// Implementation: Logs the structured thought process.
+	async ({ thought }) => {
+		if (!thought || typeof thought !== 'string' || thought.trim().length === 0) {
+			throw new Error('Invalid thought: Must be a non-empty string containing substantive reasoning.');
+		}
+		console.error(`[CognitiveToolsServer] Think Tool Logged: ${thought.substring(0, 100)}...`);
+		return {
+			content: [{
+				type: "text" as const,
+				text: thought // Return the logged thought for context preservation
+			}]
+		};
+	}
+);
+
+// --- Supporting Cognitive Strategy Tools ---
+// Note: These guide the LLM's internal generation process *before* the tool call.
+// The subsequent mandatory 'think' call analyzes the *result* of that internal generation.
+
+server.tool(
+	"chain_of_thought",
+	// Main Description: Emphasizes use for complex reasoning, explainability, and reducing errors.
+	"Guides the LLM to generate and articulate an explicit, step-by-step logical deduction path. Crucial for complex problem decomposition, algorithmic reasoning, debugging logic, and tasks demanding high explainability to minimize reasoning errors. The generated CoT MUST be analyzed via `think`.",
+	{
+		// Parameter Description: Instructs LLM on the required *internal* generation task.
+		problem_statement: z.string().describe("Input the specific problem/question requiring detailed step-by-step reasoning. *You* (the LLM) must now *internally generate* your detailed Chain of Thought process for this problem *before* calling this tool. This tool call signals the completion of that internal CoT generation.")
+	},
+	// Implementation: Signals CoT was performed for the given problem.
+	async ({ problem_statement }) => {
+		if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
+			throw new Error('Invalid problem statement: Must be a non-empty string.');
+		}
+		console.error(`[CognitiveToolsServer] ChainOfThought Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
+		return {
+			content: [{
+				type: "text" as const,
+				text: `Chain of Thought generation signaled for problem: ${problem_statement}`
+			}]
+		};
+	}
+);
+
+server.tool(
+	"reflection",
+	// Main Description: Positions as key for iterative refinement, accuracy, and benchmark performance.
+	"Guides the LLM to perform critical self-evaluation of its own prior reasoning, plans, or generated code. Essential for iterative refinement, identifying hidden flaws, improving robustness, and achieving higher accuracy on complex benchmarks. The critique MUST be analyzed via `think`.",
+	{
+		// Parameter Description: Instructs LLM on the self-critique task.
+		input_reasoning_or_plan: z.string().describe("Input the specific reasoning, plan, or code segment *you* (the LLM) must now critically evaluate *before* calling this tool. Your internal critique should identify logical fallacies, overlooked assumptions, potential inefficiencies, biases, or edge cases, and propose concrete improvements.")
+	},
+	// Implementation: Signals Reflection was performed.
+	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: Must be a non-empty string.');
+		}
+		console.error(`[CognitiveToolsServer] Reflection Tool Signaled for analysis.`);
+		return {
+			content: [{
+				type: "text" as const,
+				text: `Reflection generation signaled for input: ${input_reasoning_or_plan.substring(0, 150)}...`
+			}]
+		};
+	}
+);
+
+server.tool(
+	"plan_and_solve",
+	// Main Description: Highlights role in structuring complex tasks and managing agentic workflows.
+	"Guides the LLM to decompose a complex objective into a high-level, structured strategic plan. Outlines necessary phases, potential sub-tasks, and anticipated tool usage, improving manageability of multi-step agentic workflows. The generated plan MUST be validated and detailed via `think`.",
+	{
+		// Parameter Description: Instructs LLM on plan generation.
+		task_objective: z.string().describe("Input the high-level objective. *You* (the LLM) must now *internally generate* a structured, multi-step plan (roadmap) to achieve this objective *before* calling this tool. Consider dependencies and necessary intermediate steps.")
+	},
+	// Implementation: Signals Planning was performed.
+	async ({ task_objective }) => {
+		if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) {
+			throw new Error('Invalid task objective: Must be a non-empty string.');
+		}
+		console.error(`[CognitiveToolsServer] PlanAndSolve Tool Signaled for: ${task_objective.substring(0, 100)}...`);
+		return {
+			content: [{
+				type: "text" as const,
+				text: `Planning generation signaled for objective: ${task_objective}`
+			}]
+		};
+	}
+);
+
+server.tool(
+	"chain_of_draft",
+	// Main Description: Positions for efficient exploration and hypothesis generation.
+	"Guides the LLM to generate concise, iterative reasoning drafts ('thought-sketches'). Useful for efficiently exploring multiple solution paths, brainstorming hypotheses, or outlining approaches when full CoT verbosity is premature. Drafts MUST be analyzed comparatively via `think`.",
+	{
+		// Parameter Description: Instructs LLM on draft generation.
+		problem_statement: z.string().describe("Input the problem or question for exploration. *You* (the LLM) must now *internally generate* brief, iterative reasoning drafts (key steps, pros/cons, core ideas) for potential approaches *before* calling this tool.")
+	},
+	// Implementation: Signals Drafting was performed.
+	async ({ problem_statement }) => {
+		if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
+			throw new Error('Invalid problem statement: Must be a non-empty string.');
+		}
+		console.error(`[CognitiveToolsServer] ChainOfDraft Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
+		return {
+			content: [{
+				type: "text" as const,
+				text: `Chain of Draft generation signaled for problem: ${problem_statement}`
+			}]
+		};
+	}
+);
+
+
+// --- Server Lifecycle and Error Handling ---
+
+process.on('SIGINT', async () => {
+	console.error('[CognitiveToolsServer] Received SIGINT, shutting down.');
+	await server.close();
+	process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+	console.error('[CognitiveToolsServer] Received SIGTERM, shutting down.');
+	await server.close();
+	process.exit(0);
+});
+
+process.on('uncaughtException', (error) => {
+	console.error('[CognitiveToolsServer] Uncaught exception:', error);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+	console.error('[CognitiveToolsServer] Unhandled promise rejection:', reason);
+});
+
+// Start the server
+async function main() {
+	try {
+		const transport = new StdioServerTransport();
+		await server.connect(transport);
+		console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.4.0) MCP Server running on stdio');
+	}
+	catch (error) {
+		console.error('Fatal error in main():', error);
+		process.exit(1);
+	}
+}
+
+main();

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

@@ -0,0 +1,216 @@
+#!/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",
+	// Version reflects novel tools and enhanced guidance
+	version: "0.6.2",
+	description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.6.2): SOTA internal reasoning suite for LLM agents. Features advanced deliberation (`think`), rapid checks (`quick_think`), explicit complexity assessment, context synthesis (`synthesize`), confidence gauging, planning, CoT, and reflection. Designed to maximize reliability, traceability, and performance on complex cognitive tasks, pushing beyond current research."
+});
+
+// --- Core Cognitive Deliberation Tools ---
+
+server.tool(
+	"think",
+	// Main Description: For High Cognitive Load situations.
+	"MANDATORY Cognitive Hub for **High Complexity/Uncertainty/Consequence/Novelty**. Use for deep analysis, planning, verification, risk assessment, self-correction, and integrating complex outputs (CoT, Plans, Critiques, Syntheses, Low 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. MUST explicitly analyze prior steps/generated text (CoT, Plans, Critiques, Synthesized summaries, Confidence justifications). Structure: ## Analysis, ## Plan, ## Verification, ## Risk Assessment, ## Self-Correction. Ensure depth and clear linkage.")
+	},
+	async ({ thought }) => {
+		if (!thought || typeof thought !== 'string' || thought.trim().length === 0) { throw new Error('Invalid thought: Must be non-empty.'); }
+		console.error(`[CognitiveToolsServer] Think Tool Logged: ${thought.substring(0, 100)}...`);
+		return { content: [{ type: "text" as const, text: `Deep Thought Logged: ${thought}` }] };
+	}
+);
+
+server.tool(
+	"quick_think",
+	// Main Description: For Low Cognitive Load situations. Explicitly contrasted with 'think'.
+	"Cognitive Checkpoint for **Low Complexity/Uncertainty/Consequence**. Use ONLY for simple confirmations, acknowledgements, minor step decisions, or sanity checks where deep analysis is clearly unnecessary. Logs brief thought.",
+	{
+		brief_thought: z.string().describe("Your **concise** thought for simple situations (e.g., 'Acknowledged.', 'Proceeding with planned step X.', 'API call successful, extracting data.'). DO NOT use for analyzing complex outputs or making significant plans.")
+	},
+	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] QuickThink Tool Logged: ${brief_thought.substring(0, 100)}...`);
+		return { content: [{ type: "text" as const, text: `Quick Thought Logged: ${brief_thought}` }] };
+	}
+);
+
+// --- Novel Meta-Cognitive & Context Management Tools ---
+
+server.tool(
+	"assess_cuc_n_mode",
+	// Main Description: Forces explicit decision between think/quick_think.
+	"**Mandatory Pre-Thought Assessment.** Guides the LLM to explicitly evaluate the upcoming cognitive step's complexity, uncertainty, consequence, and novelty, and *commit* to using either `think` or `quick_think` next. Enhances deliberate cognitive resource allocation.",
+	{
+		// Parameter Description: LLM provides its assessment and chosen mode.
+		assessment_and_choice: z.string().describe("Input your assessment: 1) Briefly describe the situation/next step. 2) Rate Complexity (Low/Med/High), Uncertainty (L/M/H), Consequence (L/M/H), Novelty (L/M/H). 3) State your choice: 'Selected Mode: think' or 'Selected Mode: quick_think'. *You* (LLM) make this assessment *before* calling.")
+	},
+	async ({ assessment_and_choice }) => {
+		if (!assessment_and_choice || typeof assessment_and_choice !== 'string' || (!assessment_and_choice.includes("Selected Mode: think") && !assessment_and_choice.includes("Selected Mode: quick_think"))) {
+			throw new Error('Invalid assessment: Must include complexity/uncertainty/consequence/novelty ratings and explicit mode selection ("Selected Mode: think" or "Selected Mode: quick_think").');
+		}
+		console.error(`[CognitiveToolsServer] AssessComplexity Tool Signaled: ${assessment_and_choice.substring(0, 150)}...`);
+		// Output confirms the assessment was made and which mode was selected.
+		const mode = assessment_and_choice.includes("Selected Mode: think") ? "think" : "quick_think";
+		return { content: [{ type: "text" as const, text: `Complexity Assessment Completed. Selected Next Mode: ${mode}. Assessment: ${assessment_and_choice}` }] };
+	}
+);
+
+server.tool(
+	"synthesize_prior_reasoning",
+	// Main Description: Manages context window and focuses reasoning.
+	"Context Management Tool. Guides the LLM to **generate a concise summary text** of preceding lengthy reasoning chains (multiple `think` logs, CoT outputs). Used to manage context limits and refocus attention before major subsequent `think` steps.",
+	{
+		// Parameter Description: LLM generates the summary internally first.
+		context_to_summarize_description: z.string().describe("Briefly describe the span of reasoning you are summarizing (e.g., 'Summary of planning phase', 'Key takeaways from debugging CoT'). *You* (LLM) must now *internally generate the concise summary text* before calling this tool. This signals the summary is ready.")
+	},
+	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] SynthesizeReasoning Tool Signaled for: ${context_to_summarize_description}...`);
+		// Output confirms context and implies summary text is available internally
+		return { content: [{ type: "text" as const, text: `Synthesis internally generated for context: '${context_to_summarize_description}'. Ready for 'think' analysis.` }] };
+	}
+);
+
+server.tool(
+	"gauge_confidence",
+	// Main Description: Explicit meta-cognition about certainty.
+	"Meta-Cognitive Checkpoint. Guides the LLM to explicitly **state its confidence level (High/Medium/Low) and justification** regarding a specific plan, analysis, conclusion, or proposed action *before* proceeding. Low confidence may trigger Reflection or deeper Thinking.",
+	{
+		// Parameter Description: LLM provides its confidence assessment.
+		assessment_and_confidence: z.string().describe("Input the item being assessed (e.g., 'Confidence in current plan', 'Confidence in generated code correctness'). Then state: 1) Confidence Level (High/Medium/Low). 2) Brief Justification for this level. *You* (LLM) make this assessment *before* calling.")
+	},
+	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: 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] GaugeConfidence Tool Signaled: Level ${level}`);
+		// Output confirms assessment and level
+		return { content: [{ type: "text" as const, text: `Confidence Gauge Completed. Level: ${level}. Assessment: ${assessment_and_confidence}` }] };
+	}
+);
+
+// --- Supporting Cognitive Strategy Tools (Enhanced Descriptions) ---
+
+server.tool(
+	"plan_and_solve",
+	// Main Description: Highlights role in structuring complex tasks and managing agentic workflows.
+	"Guides the LLM to **generate a structured, multi-step plan text** for a complex objective. Outlines necessary phases, potential sub-tasks, and anticipated tool usage, improving manageability of multi-step agentic workflows. The generated plan MUST be validated and detailed via `think`, and can optionally be passed to `reflection` for critique.",
+	{
+		// Parameter Description: Instructs LLM on plan generation.
+		task_objective: z.string().describe("Input the high-level objective. *You* (the LLM) must now *internally generate the structured plan text* before calling this tool. This signals the plan text is ready for analysis/critique.")
+	},
+	// Implementation: Signals Planning was performed.
+	async ({ task_objective }) => {
+		if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) {
+			throw new Error('Invalid task objective: Must be a non-empty string.');
+		}
+		console.error(`[CognitiveToolsServer] PlanAndSolve Tool Signaled for: ${task_objective.substring(0, 100)}...`);
+		return { content: [{ type: "text" as const, text: `Planning generation signaled for objective: ${task_objective}. Ready for 'think' analysis.` }] };
+	}
+);
+
+server.tool(
+	"chain_of_thought",
+	// Main Description: Emphasizes generating text for later analysis.
+	"Guides the LLM to **generate detailed, step-by-step reasoning text**. Used for complex logic or explainability. The *generated CoT text* MUST then be analyzed in a subsequent `think` call.",
+	{
+		// Parameter Description: Focus on the input problem.
+		problem_statement: z.string().describe("Input the problem requiring detailed step-by-step reasoning. *You* (the LLM) must now *internally generate the full CoT text* before calling this tool. This signals that CoT text is ready for analysis in the next `think` step.")
+	},
+	// Implementation: Signals CoT was performed for the given problem.
+	async ({ problem_statement }) => {
+		if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
+			throw new Error('Invalid problem statement: Must be a non-empty string.');
+		}
+		console.error(`[CognitiveToolsServer] ChainOfThought Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
+		return { content: [{ type: "text" as const, text: `Chain of Thought internally generated for problem: ${problem_statement}. Ready for 'think' analysis.` }] };
+	}
+);
+
+server.tool(
+	"chain_of_draft",
+	// Main Description: Positions for efficient exploration and hypothesis generation.
+	"Guides the LLM to **generate concise, iterative reasoning draft texts** ('thought-sketches'). Useful for efficiently exploring multiple solution paths, brainstorming hypotheses, or outlining approaches when full CoT verbosity is premature. Drafts MUST be analyzed comparatively via `think`.",
+	{
+		// Parameter Description: Instructs LLM on draft generation.
+		problem_statement: z.string().describe("Input the problem or question for exploration. *You* (the LLM) must now *internally generate brief, iterative draft texts* (key steps, pros/cons, core ideas) for potential approaches *before* calling this tool.")
+	},
+	// Implementation: Signals Drafting was performed.
+	async ({ problem_statement }) => {
+		if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
+			throw new Error('Invalid problem statement: Must be a non-empty string.');
+		}
+		console.error(`[CognitiveToolsServer] ChainOfDraft Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
+		return { content: [{ type: "text" as const, text: `Chain of Draft generation signaled for problem: ${problem_statement}. Ready for 'think' analysis.` }] };
+	}
+);
+
+server.tool(
+	"reflection",
+	// Main Description: Explicitly mentions taking prior text as input for critique.
+	"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 text to be critiqued.
+		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.")
+	},
+	// Implementation: Signals Reflection was performed.
+	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: Must be a non-empty string.');
+		}
+		console.error(`[CognitiveToolsServer] Reflection Tool Signaled for analysis.`);
+		return { content: [{ type: "text" as const, text: `Reflection internally generated for input text: '${input_reasoning_or_plan.substring(0, 100)}...'. Ready for 'think' analysis.` }] };
+	}
+);
+
+
+// --- Server Lifecycle and Error Handling ---
+
+process.on('SIGINT', async () => {
+	console.error('[CognitiveToolsServer] Received SIGINT, shutting down.');
+	await server.close();
+	process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+	console.error('[CognitiveToolsServer] Received SIGTERM, shutting down.');
+	await server.close();
+	process.exit(0);
+});
+
+process.on('uncaughtException', (error) => {
+	console.error('[CognitiveToolsServer] Uncaught exception:', error);
+	// Depending on severity, you might want to gracefully shutdown or just log
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+	console.error('[CognitiveToolsServer] Unhandled promise rejection:', reason);
+	// Depending on severity, you might want to gracefully shutdown or just log
+});
+
+// Start the server
+async function main() {
+	try {
+		const transport = new StdioServerTransport();
+		await server.connect(transport);
+		console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.6.2) MCP Server running on stdio');
+	}
+	catch (error) {
+		console.error('[CognitiveToolsServer] Fatal error during startup:', error);
+		process.exit(1);
+	}
+}
+
+// Execute the main function to start the server
+main();